Crear programa de serpiente (2 / 4 paso)

Paso 2: Luego copiar y pegar este código en el Bloc de notas

::---------------------------------------------------------------------
:: configurar algunas variables globales utilizados por el juego y el controlador

setlocal disableDelayedExpansion
: getSession
Si temp ("set tempFileBase=%temp%\") else Si tmp set "tempFileBase=%tmp%\"
conjunto "tempFileBase = % tempFileBase % serpiente % tiempo:: = _ %"
conjunto "keyFile=%tempFileBase%_key.txt"
conjunto "cmdFile=%tempFileBase%_cmd.txt"
conjunto "gameLock=%tempFileBase%_gameLock.txt"
conjunto "gameLog=%tempFileBase%_gameLog.txt"
conjunto "signal=%tempFileBase%_signal.txt"
conjunto "saveLoc=%userprofile%\Snake"
conjunto "userPref=%saveLoc%\SnakeUserPref.txt"
conjunto "hiFile=%saveLoc%\Snake!growth! Hola"

::------------------------------------------
:: Esta sesión de juego y lanzamiento de la cerradura.
:: Lazo atrás y una nueva sesión si fracaso.
:: Limpieza y salir cuando haya terminado

llamar: lanzar 7 > '% gameLock %' || GOTO: getSession
del "% tempFileBase % *"
salida/b

::------------------------------------------
: iniciar el juego y el controlador

llamar al: fixLogs
copiar nul "% keyFile" > nul
copiar nul "% cmdFile %" > nul
Inicio "" /b cmd /c ^ "" % ~ f0 "startController 9 ^ > ^ >"% keyFile"8 ^ < '% cmdFile %' 2 ^ > nul ^ > nul ^"
CMD /c ^ "" % ~ f0 "startGame 9 ^ <"% keyFile"8 ^ > ^ > '% cmdFile %' ^ Eco ()

::--------------------------------------------------------------
:: Al salir, espere a que el controlador de cerrar antes de regresar

: cerrar
2 > nul (>> llamada "% keyFile") || GOTO: cerrar
Si no existen "% ~ dp0CursorPos.exe" ()
juego de echo puede mejorarse mediante la instalación de
Eco CursorPos.exe de Aacini, disponible en
Eco http://goo.gl/hr6Kkn
echo)
echo % cmdcmdline % |find /i "% ~ f0" > nul & & hacer una pausa
)
salida/b 0

::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
: juego
% title ~ nx0
CLS

::---------------------------------------
:: Tamaño campo de juego
:: máxima igualdad: (width-2)*(height-2) < = 1365

conjunto "anchura = 40" máximo = 99
conjunto "altura = 25" max = 99

::----------------------------
:: cambiar el tamaño de la ventana de la consola

Set /a cols = ancho + 1, líneas = altura + 10, area=(width-2)*(height-2)
Si () % área % gtr 1365
echo ERROR: área del campo de juego demasiado grande
sendCmd % dejar de fumar
salida
)
Si % líneas % lss 14 set = 14
Si % cols % lss 46 set cols = 46
con modo: cols = líneas de % de % cols = % de líneas

::----------------------------
:: definir variables

conjunto "configOptions = diffCode dificultad crecimiento moveKeys arriba abajo izquierda derecha"
conjunto "configOptionCnt = 9"

conjunto "moveKeys = 4"

conjunto "up = W"
conjunto "abajo = S"
conjunto «izquierda = A»
conjunto «derecha = D»
conjunto "Pausa = P"

conjunto "espacio ="
conjunto "destino = #"
conjunto "comida = +"
conjunto "cabeza =
conjunto "cuerpo = O"
conjunto "muerte = X"

conjunto "crecimiento = 1"

Si existen "% userPref %" / f "usebackq delims =" condition ("% userPref %") set "%% V"

conjunto "spinner1 =-"
conjunto "spinner2 = \"
conjunto "spinner3 = |"
conjunto "spinner4 = /"
sistema "spinner = spinner1 spinner2 spinner3 spinner4"

conjunto "delay1 = 20"
conjunto "delay2 = 15"
conjunto "delay3 = 10"
conjunto "delay4 = 7"
conjunto "delay5 = 5"
conjunto "delay6 = 3"

conjunto "desc1 = perezoso"
conjunto "desc2 = arrastre"
conjunto "desc3 = lenta"
conjunto "desc4 = Normal"
conjunto "desc5 = rápido"
conjunto "desc6 = loco"

conjunto "spinnerDelay = 3"

Set /a "altura de la anchura-= 1,-= 1"

:: definir LF como un carácter de avance de línea (nueva línea)
Set ^ «LF = ^

^ "Sobre vaciar es necesaria: No extraiga

:: definir CR como un carácter de retorno de carro
for /f % % en (' copiar /Z "% ~ dpf0" nul ") set" CR = %% A "

:: definir BS como carácter de retroceso
for /f % % en (' "sugerirán el $H para % en (1) rem" ') set "BS = %% A"

conjunto "superior = A B C D E F G H I J K L M N O P Q R S T U V W X Y Z"
Set "no válido = * ~ ="

::---------------------------
:: definir macros

Si existen "% ~ dp0CursorPos.exe" ()
conjunto "cls = CursorPos 0 0"
conjunto "ClearLine = Eco (& CursorPos 0 -1"
conjunto "ClearPrev = CursorPos 0 - 0 y echo ("
) () otro
conjunto "cls = cls"
conjunto "ClearLine ="
conjunto "ClearPrev ="
)

:: definir una nueva línea a continuación de la línea
Set ^ "\n=^^^%LF%%LF%^%LF%%LF%^^"

:: setErr
::: Sistemas ERRORLEVEL 1
conjunto "setErr=(call)"

:: clrErr
::: Sistemas ERRORLEVEL 0
conjunto "clrErr = (llamada)"

:: comando sendCmd
::: envía un comando al controlador
conjunto "sendCmd = > & 8 echo"

:: getKey [ValidKey] [ValidKey...]
::: Control de pulsación de tecla del controlador. Aceptar una ValidKey.
::: Token delimitadores y veneno caracteres deben ser citados.
::: Aceptar cualquier tecla si no ValidKey especificado.
::: Volver resultado en variable clave. Clave es indefinido si ninguna tecla válida.
Set getKey=%\n%
para %% # (1 2) hacer si %% #== 2 (%\n%
Set key=%\n%
Set inKey=%\n%
Set keyTest=%\n%
^ < ^ & 9 set /p "inKey="%\n%
Si define inKey (%\n%
Set inKey=!inKey:~0,-1!%\ n %
para % en (! args!) set /a keyTest = 1 ^ & si /i! inKey! EQU %% ~ C fije key=!inKey!%\ n %
)%\n%
Si no define keyTest key=!inKey!%\ n %
) else set args =

:: dibujar
::: dibuja el tablero
Set draw=%\n%
Set screen=%\n%
para /l % % de (0,1, % de altura) configurar pantalla =! pantalla!!!! línea %% Y!! LF!%\ n %
pantalla Set =! pantalla! Velocidad =! Dificultad ¡ repetición! LF! Tasa de crecimiento =! crecimiento! Puntuación =! Hola! LF! Puntuación =! puntuación! Tiempo =! m!:!s!%\ n %
Si define reproducción si no se define replayFinished (%\n%
pantalla Set =! pantalla!!!! LF!!!! LF! Presione una tecla para cancelar la replay%\n%
)%\n%
cls de % ^ & echo(!screen!

:: prueba X Y ValueListVar
::: prueba si valor en las coordenadas X, Y es dentro de contenidos de ValueListVar
Set test=%\n%
para %% # (1 2) hacer si %% #== 2 (for /f "tokens = 1-3" condition en ("! args!") hacer (%\n%
para % en ("! línea %% 2: ~ %% 1.1!") si "! %% 3: %% ~ A =!"neq"! %% 3!" clrErr % %setErr%%\n% más
)) else set args =

:: parcela X Y ValueVar
::: sitios de contenido de ValueVar en las coordenadas X, Y
Set plot=%\n%
para %% # (1 2) hacer si %% #== 2 (for /f "tokens = 1-3" condition en ("! args!") hacer (%\n%
conjunto "part2=!line%%2:~%%1!"%\ n %
conjunto "línea %% 2 =! línea %% 2: ~ 0, %% 1!!!! %%3!! part2:~1!"%\ n %
)) else set args =

::--------------------------------------
:: el juego
setlocal enableDelayedExpansion
Si no existen "% saveLoc%\" md "% saveLoc"
conjunto "reproducir = Aborting... "
conjunto "replayAvailable ="
llamar al: loadHighScores
llamada: menú principal

::--------------------------------------
:: principales loop (bucle infinito)
para /l %%. en () no)

% === Busque y proceso cancelar señal si en modo de reproducción replay === %
Si define replay si existen ("% de señal"
del "% de señal"
conjunto "replayFinished = 1"
% drenaje %
echo)
ClearLine %
llamar: purga
para % en (! configOptions!) establece "%% A =! %% ASALVO!"
llamada: menú principal
)

% === Calcular tiempo desde última jugada === %
for /f "tokens = 1-4 delims =:.," condition en ("! tiempo: = 0!") set /a "t2 = (((1 %% un * 60) + 1 %% b) * 60 + 1 %% c) * 100 + 1 %% d-36610100, tDiff = t2-t1"
Si! tDiff! LSS 0 set /a tDiff += 24 * 60 * 60 * 100

Si! tDiff! GEQ! retraso! (
% === retraso ha caducado, así que tiempo para el movimiento === %
Set /a t1 = t2

% === Calcular tiempo de juego === %
Si no define el conjunto de casillas "casillas =! t2!"
Set /a "gameTime=(t2-gameStart)"
Si! gameTime! LSS 0 set /a "gameTime += 24 * 60 * 60 * 100"
Set /a "gameTime =(gameTime-pauseTime)/100, m = gameTime/60, s = gameTime %% 60"
Si! m! LSS 10 set "m = 0! m!"
Si! s! LSS 10 set "s = 0 ¡ ¡ s!"

% === Haz keypress === %
getKey %! las llaves!
Si /i! clave! EQU! pausa! (

% === pausar juego === %
echo)
llamar: pide "Pausa - Oprima una tecla para continuar..."
% ClearPrev %
sendCmd % ir
for /f "tokens = 1-4 delims =:.," condition en ("! tiempo: = 0!") set /a "t2 = (((1 %% un * 60) + 1 %% b) * 60 + 1 %% c) * 100 + 1 %% d-36610100, tDiff = t2-t1"
Si! tDiff! LSS 0 set /a tDiff += 24 * 60 * 60 * 100
Set /a pauseTime += tDiff

) () otro

% === establecer dirección === %
Si no define replay (echo(!key!.) >> «! gameLog! "
para % en (! clave!) si! moveKeys! () ecuación 2
Set /a "xDiff = xTurn %% K *! yDiff!, yDiff = yTurn %% K *! xDiff!"
) else if "! %% KAxis!"neq"! eje!" (
Set /a "xDiff = xDiff %% K, yDiff = yDiff %% K"
conjunto "eje =! %% KAxis!"
)

% === borrar la cola === %
conjunto "TX =! snakeX: ~ -2!"
conjunto "TY =! snakeY: ~ -2!"
conjunto "snakeX =! snakeX: ~ 0, -2!"
conjunto "snakeY =! snakeY: ~ 0, -2!"
% de la parcela. TX!! TY! espacio

% === calcular nueva ubicación cabeza e intente mover === %
Set /a "X = PX + xDiff, Y = PY + yDiff"
Set "X =! X!"
Set "Y =! Y!"
Set "X =! X: ~ -2! "
Set "Y =! Y: ~ -2! "
(prueba de % %! X!! Y! playerSpace) & & ()

% === movimiento acertado === %

% === Retire la nueva ubicación de la cabeza de la lista vacía === %
para % en ("! X.") para % en ("! Y!") conjunto "vacío =! vacía: #%% ~ X %% ~ Y =!"

% === comer cualquier alimento que pueda estar presente === %
(prueba de % %! X!! Y! alimentos) & & ()
% === iniciar crecimiento === %
Set /a crecer crecimiento +=

% === localizar y dibujar nuevos alimentos === %
Si define () repetición
< & 9 set /p "F ="
) () otro
Set /a "F = (! al azar! %%(emptyCnt-1)) * 6 + 1"
(echo! F!) >> «! gameLog! "
)
para % en (! F!) hacer (% parcela %! vacía: ~ %% F, 5! alimento)
)

Si! crecer! (GTR 0
% === restaurar la cola === %
% de la parcela. TX!! TY! cuerpo
conjunto "snakeX =! snakeX!!!! TX."
conjunto "snakeY =! snakeY!!!! TY!"
Set /a emptyCnt = 1

% === administrar puntuación === %
Set /a "puntuación += 1, crecer-= 1"
Si no define replay si! puntuación! GTR! Hola! Set /a "Hola += 1, newHi = 1"

) () otro
% === Añadir la posición de la cola anterior a la lista vacía === %
conjunto "vacío =! vacía! #! TX!! TY!"
)

% === la cabeza nuevo === %
Si define snakeX (% parcela %! PX!! PY! cuerpo)
% de la parcela. X!! Y! cabeza

% === Añadir la nueva posición de la cabeza a las cadenas de serpiente === %
conjunto "snakeX =! X!!!! snakeX!"
conjunto "snakeY =! Y!! snakeY!"
conjunto "PX =! X!"
conjunto "PY =! Y!"

% drenaje %

) || (

% === movimiento fallido - juego sobre === %
conjunto "replayFinished = 1"
% de la parcela. TX!! TY! cuerpo
llamar: spinner! PX!! PY! muerte
% drenaje %
Si define () newHi
echo)
Eco nueva puntuación más alta - ¡ Felicidades ^ ^!
conjunto "Hola! diffCode! =! cuenta!"
copia "! gameLog!" "% hiFile %! diffCode!. txt"> nul
>> «% hiFile! diffCode!. txt"Eco::! puntuación!
)
echo)
ClearLine %
llamar: pedir "Presione una tecla para continuar..."
para % en (! configOptions!) establece "%% A =! %% ASALVO!"
llamada: menú principal
)
)
)
)

::-------------------------------------
: getString pronto Var MaxLen
:: Solicitar una cadena con longitud máxima de MaxLen.
:: Claves válidas son alfanuméricos, espacio, guión bajo y guión
:: Cadena termina por entrar
:: Retroceso trabaja para borrar el carácter anterior
:: El resultado es devuelto en Var
Set /a "maxLen = %3"
conjunto "%2 ="
indicador de % de % sendCmd
llamar: purga
: getStringLoop
(getKey %! superior! 0 1 2 3 4 5 6 7 8 9 "" _ - {Enter}! BS!)
Si define () clave
Si! clave! () equ {Enter}
echo)
salida/b
)
Si! clave! NEQ! BS! Si! maxLen! (GTR 0
Set /a maxLen = 1
conjunto "2% =! %2! clave!
)
Si! clave! EQU! BS! Si define () %2
Set /a maxLen += 1
conjunto "2% =! 2%: ~ 0, -1!"
)
)
Si define inKey sendCmd por ciento uno
GOTO: getStringLoop

::-------------------------------------
: pedir pronto ValidKey [Validkey]...
:: Aviso para pulsar una tecla.
:: Espere hasta que se presiona un ValidKey y devuelve el resultado en la variable clave.
:: Token delimitadores,), y veneno caracteres deben ser citados.
indicador de % de % sendCmd
(set validKeys = % *)
(set validKeys =! validKeys:% 1 =!)
llamar: purga
: getResponse
(getKey %! validKeys!)
Si no define () clave
Si define inKey sendCmd por ciento uno
GOTO: getResponse
)
salida/b

: purga
conjunto "inKey ="
para /l % % en (1 1 1000) no ()
Set /p "inKey ="
Si "! inKey!" equ "{purgada}." salida/b
) < & 9
GOTO: purga

::-------------------------------------
: spinner X Y ValueVar
Set /a d1 =-1000000
para/l % (1 1 5) hacer para % en (spinner %) no ()
llamar al: spinnerDelay
Parcela % Condition %2% %
% drenaje %
)
llamar al: spinnerDelay
(parcela % Condition % %2 3)
salida/b

::-------------------------------------
: retraso centiSeconds
setlocal
for /f "tokens = 1-4 delims =:.," condition en ("! tiempo: = 0!") set /a "spinnerDelay = %1, d1 = (((1 %% un * 60) + 1 %% b) * 60 + 1 %% c) * 100 + 1 %% d-36610100"
:: caen a través: spinnerDelay

::-------------------------------------
: spinnerDelay
for /f "tokens = 1-4 delims =:.," condition en ("! tiempo: = 0!") set /a "d2 = (((1 %% un * 60) + 1 %% b) * 60 + 1 %% c) * 100 + 1 %% dDiff d-36610100, = d2-d1"
Si % dDiff % lss 0 set /a dDiff += 24 * 60 * 60 * 100
Si % dDiff % lss % spinnerDelay % goto: spinnerDelay
Set /a d1 = d2
salida/b

::-------------------------------------
: menú principal
CLS
conjunto "loadAvailable ="
tasa de crecimiento de eco =! crecimiento!
echo)
Eco menú principal:
echo)
Eco N - nuevo juego
Si define replayAvailable eco R - juego anterior de repetición
Si define saveAvailable eco S - guardar un juego
Si existen *. snake.txt echo L - carga y ver un guardado juego & set "loadAvailable = L"

Eco C - opciones de Control
Eco G - opciones de gráfico
echo Q - dejar de fumar
echo)
conjunto "hiAvailable ="
para /l % % en (1 1 6) hacer si define Hola %% () N
Si no define () hiAvailable
Eco repetición alta puntuación:
echo)
)
conjunto "desc =! desc %% N!..."
conjunto "hiAvailable =! hiAvailable! %% N "
echo % %! desc: ~ 0, 8 ¡ Hola %% N!
)
Si se ha definido (eco) hiAvailable
establecer "teclas = N C G Q! hiAvailable! replayAvailable! saveAvailable! loadAvailable!"
llamar: pedir ">"! las llaves!
Si /i! clave! () ecuación Q
sendCmd % dejar de fumar
CLS
salida
)
Si /i! clave! () ecuación N
conjunto "reproducir ="
conjunto "replayAvailable = R"
conjunto "saveAvailable = S"
GOTO: inicializar
)
Si /i! clave! () equ S
Si define () replayAvailable
llamar: pedir "puntuación # o P de la anterior: «! hiAvailable! P
) () otro
llamar: pedir "puntuación #: «! hiAvailable!
)
Eco! clave!
Si /i! clave! EQU P (sistema "src =! gameLog!") otro conjunto "src = % hiFile %! clave!. txt"
llamar: getString "Guardar nombre de archivo:" archivo 20
copia "! fuente!" «! archivo!. Snake.txt"
llamar: pedir "Presione una tecla para continuar..."
)
Si /i! clave! () equ L
llamar: getString "nombre de archivo de carga:" archivo 20
Si existen "! archivo!. () Snake.txt"
conjunto "reproducir =! archivo!. Snake.txt"
GOTO: inicializar
)
echo Error: archivo "! archivo!. Snake.txt"no encontrado
llamar: pedir "Presione una tecla para continuar..."
)
Si /i! clave! () ecuación R
conjunto "reproducir =! gameLog!"
GOTO: inicializar
)
Si! clave! GEQ 1 si! clave! (Leq 6
conjunto "reproducir = % hiFile %! clave!. txt"
GOTO: inicializar
)
Si /i! clave! EQU C llamada: controlOptions
Si /i! clave! EQU G llamada: graphicOptions
GOTO: menú principal

::-------------------------------------
: controlOptions
CLS
conjunto "teclas = {Enter} T L R P"
Si! moveKeys! conjunto equ 4 "llaves =! las llaves! U D"
Eco opciones de Control:
echo)
Eco T - tipo... =! moveKeys! teclas
echo)
Eco L - izquierda... =! izquierda!
Eco R - derecho... =! derecho!
Si! moveKeys! EQU 4 echo U - arriba... =! arriba!
Si! moveKeys! EQU 4 echo D - abajo... =! abajo!
echo)
Eco P - pausa... =! pausa!
echo)
Eco {Enter} - volver al menú principal
echo)
llamar: pedir ">"! las llaves!
Si! clave! goto equ {Enter}: saveUserPrefs
Si /i! clave! () ecuación T
Si! moveKeys! EQU 2 (set "moveKeys = 4") otro conjunto "moveKeys = 2"
GOTO: controlOptions
)
conjunto "opción = LLeft RRight UUp DDown PPause"
for /f % % en ("! opción: * % clave % =!") hacer ()
llamar: pedir "Presione una tecla para %% O:"
para % en (0 1 2) hacer si "! llave!"equ"! no válido: ~ %% K, 1!" goto: controlOptions
para % en (! superior!) establece "clave =! clave: %% C = %% C!"
conjunto "%% O =! llave!"
)
GOTO: controlOptions

::-------------------------------------
: graphicOptions
CLS
Eco opciones gráficas:
echo)
Eco B - frontera... =! vinculado!
Eco E - espacio vacío. =! espacio!
Eco de H - serpiente cabeza... =! cabeza!
Eco S - cuerpo de la serpiente... =! cuerpo!
Eco F - comida... =! comida!
echo D - muerte... =! muerte!
echo)
Eco G - tasa de crecimiento. =! crecimiento!
echo)
Eco {Enter} - Rturn menú principal
echo)
llamar: pedir ">" B E H S F D G {Enter}
Si! clave! goto equ {Enter}: saveUserPrefs
Si /i! clave! () ecuación G
llamar: pedir "Pulse un dígito la tasa de crecimiento (0 = 10)" 0 1 2 3 4 5 6 7 8 9
Si! clave! EQU 0 conjunto "clave = 10"
conjunto "crecimiento =! llave!"
llamar al: loadHighScores
) () otro
conjunto "opción =-BBorder:bound:-EEmpty: espacio:-HSnake: cabezal:-SSnake cuerpo: cuerpo:-FFood:food:-DDeath:death:"
for /f "tokens = 1, 2 delims =:" condition en ("! opción: *-% clave % =!") hacer)
llamar: pedir "Presione una tecla para %% A"
para % en (0 1 2) hacer si "! llave!"equ"! no válido: ~ %% K, 1!" goto: graphicOptions
conjunto "%% B =! llave!"
)
)
GOTO: graphicOptions

::------------------------------------
: saveUserPrefs
(para % en (moveKeys arriba izquierda derecha espacio limitado alimento cuerpo cabeza muerte pausa crecimiento) echo %% V =! %% V!) > "% userPref"
salida/b

::-------------------------------------
: inicializar
CLS
Si define () repetición
Eco opciones de velocidad de reproducción:
) () otro
Eco opciones de velocidad:
)
demora de eco
echo # Descripción (segundos)
echo --- ----------- ---------
para /l % % en (1 1 6) no ()
conjunto "retardo = 0! retraso %% N!"
conjunto "desc =! desc %% N!"
echo % % desc: ~ 0, 11. 0.! retardo: ~ -2!
)
echo)
llamar: pedir "escoger una velocidad (1-6): «1 2 3 4 5 6
conjunto "dificultad =! desc % clave %!"
conjunto "retardo =! retraso % clave %!"
conjunto "diffCode = % clave %"
echo % clave % - % de dificultad
echo)
conjunto "eje = X"
conjunto "xDiff = + 1"
conjunto "yDiff = + 0"
conjunto "vacío ="
Set /a "PX = 1, PY = altura/2, FX = width / 2 + 1, FY = PY, score = 0, emptyCnt = 0, t1 =-1000000"
conjunto "casillas ="
establecer "m = 00"
establece "s = 00"
conjunto "snakeX = % PX"
conjunto "snakeY = % PY"
conjunto "snakeX = % snakeX: ~ -2%"
conjunto "snakeY = % snakeY: ~ -2%"
para /l % % en (0% de altura de 1%) no ()
conjunto "línea %% Y ="
para /l % % en (0,1, % de anchura) hacer ()
conjunto "celda ="
Si Condition 0 conjunto "célula = % dependiente"
Si Condition % altura % conjunto "célula = % dependiente"
Si Condition 0 conjunto "célula = % dependiente"
Si Condition % width % conjunto "célula = % dependiente"
Si Condition % PX si Condition % PY % conjunto "célula = cabeza %"
Si no define () celular
conjunto "célula = % de espacio"
establecer "eX = %% X"
conjunto "eY = %% Y"
conjunto "vacío =! vacía! #! eX: ~ -2 ¡ eY: ~ -2!"
Set /a emptyCnt += 1
)
Si Condition FX % si % % % FY % conjunto "célula = % de alimentos"
conjunto "línea %% Y =! línea %% Y!! celular!"
)
)
para % en (! configOptions!) establece "%% ASALVO =! %% A!"
conjunto "replayFinished ="
Si define () repetición
% sendCmd % replay
sendCmd %! reproducir!
llamar al: waitForSignal
conjunto "reproducir = (reproducir en! dificultad!)"
conjunto "leer = 1"
< & 9 ()
para /l % % en (1 1! configOptionCnt!) hacer si define () leer
Set /p "ln ="
Si "! ln!" equ "Final" (fijar lectura =) otro conjunto "! ln!"
)
)
conjunto "teclas ="
conjunto "Hola = 0"
for /f "delims =:" condition en (' findstr "^::" "% hiFile %! diffCode!. txt"2 ^ > nul') establece" Hola = %% A "
(% de drenaje)
llamar: retardo 100
) () otro
Si Hola % diffCode % (set "= Hola! hola % diffCode %!") otro conjunto "Hola = 0"
(% de drenaje)
> "! gameLog!" (
para % en (! configOptions!) hacer (echo %% A =! %% A!)
(echo final)
)
echo)
Si! moveKeys! () ecuación 4
Controles de eco:! hasta! = hasta! abajo! = abajo! izquierda! = left! derecho! = derecho! pausa! = pausa
) () otro
Controles de eco:! izquierda! = left! derecho! = derecho! pausa! = pausa
)
Eco Evite correr en ti mismo (! cuerpo! cuerpo!!!! cabeza! ^) o pared (! vinculado! ^)
Eco de comer alimentos (! comida! ^) para crecer.
echo)
llamar: pedir "Presione una tecla para iniciar..."
sendCmd % ir
)
conjunto "pauseTime = 0"
conjunto "xDiff! por! = + 0"
conjunto "xDiff! por! = + 0"
conjunto "xDiff! izquierda! =-1"
conjunto "xDiff! derecho! = + 1"
conjunto "yDiff! por! =-1"
conjunto "yDiff! por! = + 1"
conjunto "yDiff! izquierda. = + 0"
conjunto "yDiff! derecho! = + 0"
conjunto "! arriba! Eje = Y "
conjunto "! por! Eje = Y "
conjunto "! izquierda! Eje = X "
conjunto "! derecho! Eje = X "
conjunto "xTurn! izquierda! = 1"
conjunto "xTurn! derecho! =-1"
conjunto "yTurn! izquierda! =-1"
conjunto "yTurn! derecho! = 1"
conjunto "playerSpace =! espacio!!!! ¡ la comida!"
Set ^ "teclas ="! izquierda! " «! derecho!» «! pausa!» ^"
conjunto "newHi ="
conjunto "crecer = 0"
Si! moveKeys! conjunto equ 4 ^ "teclas =! las llaves! "! arriba!" «! abajo!» ^"
CLS
salida/b

::-------------------------------------
: waitForSignal
Si no existen "% señal" goto: waitForSignal
del "% de señal"
salida/b

::-------------------------------------
: loadHighScores
conjunto "saveAvailable ="
para /l % % en (1 1 6) no ()
conjunto "Hola %% N ="
for /f "delims =:" condition en (' findstr "^::" "% hiFile%%%N.txt" 2 ^ > nul') hacer ()
conjunto "Hola %% N = %% A"
conjunto "saveAvailable = S"
)
)
salida/b

::-------------------------------------
: fixLogs
setlocal enableDelayedExpansion
para % en (* .snake) hacer ()
ren "%% F" "%% F.txt"
llamar: fixLog "%% F.txt"
)
pushd "% SaveLoc"
for /f "delims =" condition en (' dir /b SnakeHi*.txt 2 ^ > nul') hacer ()
conjunto "archivo = %% ~ nF"
conjunto "archivo = Snake1Hi! file:~-1!. txt"
ren "%% F" "! archivo!"
llamar a: fixLog «! archivo! "
)
popd
salida/b

: ruta de fixLog
> "% ~ 1.new" ()
< "% ~ 1" ()
para % en (diffCode dificultad moveKeys arriba abajo izquierda derecha) no ()
Set /p "val ="
(echo %% A =! val!)
)
)
(eco de crecimiento = 1)
(echo final)
+ 7 más "% ~ 1"
)
mover /y "% ~ 1.new" "% ~ 1" > nul
salida/b

::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::::
: controlador
:: Detecta la pulsación de las teclas y envía la información al juego mediante un archivo llave.
:: El controlador tiene varios modos de entrada que son activados por comandos enviados
:: el juego mediante un archivo cmd.
::
:: Los modos:
::
:: no mantener - entrada, espere a que comando
::
:: ir - continuamente conseguir y enviar pulsaciones de teclas
::
:: mensaje - Send {purgada} marcador para permitir juego purgar el búfer de entrada, luego
:: obtener/enviar sólo presionar una tecla y mantenga
::
:: uno - Get/enviar una tecla oprimida
::
:: replay - copiar un registro de juego en el archivo de clave. La siguiente línea en el archivo cmd
:: especifica el nombre del archivo de registro para copiar. Durante la reproducción, el controlador
:: enviará una señal de interrupción al juego si se presiona una tecla.
::
:: dejar de fumar - salir inmediatamente del proceso de control
::
:: Como escrito incorrectamente informa de esta rutina! ««««como), pero eso no importa
:: ya no necesitamos esa clave. Tanto y tecla Enter se divulgan como {Enter}.
:: Un carácter adicional se agrega a la salida para preservar cualquier caracteres de control
:: cuando es leído por SET /P.

setlocal enableDelayedExpansion
for /f % % en (' copiar /Z "% ~ dpf0" nul ') set "CR = %% un"
conjunto "cmd = hold"
conjunto "inCmd ="
conjunto "clave ="
para /l %%. en () no)
Si "! cmd!" neq 'hold' ()
for /f "delims =" condition en (' xcopy/w "% ~ f0" "% ~ f0" 2 ^ > nul') hacer ()
Si no define sistema de la llave "key = %% A"
)
conjunto "clave =! clave: ~ -1!"
Si! clave! equ! CR! conjunto "clave = {Enter}"
)
< & 8 set /p "inCmd ="
Si define () inCmd
Si! inCmd! EQU dejar salir
conjunto "cmd =! inCmd!"
Si! inCmd! (replay) equ
< & 8 set /p "archivo ="
tipo "! archivo!" > & 9
copiar nul "% de señal"
)
conjunto "inCmd ="
)
Si define () clave
Si "! cmd!" equ "prompt" (echo {purgada}.)
Si "! cmd!" equ "reproducir" ()
copiar nul "% señal" > nul
(echo {purgada}.)
conjunto "cmd = go"
) else (echo(!key!.)
Si "! cmd!" neq "ir" set "cmd = hold"
conjunto "clave ="
) > & 9
)