Los juegos son divertidos

Este codegolf aquí fue tan divertido que tuve que hacer una versión para otros juegos clásicos de complejidad similar. La forma más corta de crear un juego básico de Space Invaders en Python

Esta vez, sin embargo, trata de recrear el clásico juego 'Snake', en el que comienzas como una pequeña figura, moviéndote constantemente para recolectar piezas para aumentar tu puntaje. Cuando recoges una pieza, tu 'cola' crece, que sigue el camino que has hecho. El objetivo es durar más tiempo sin chocar contra su propia cola o contra las paredes.

Calificaciones:

• Usted, los personajes que forman la cola, las paredes y las piezas que recolecta deben ser personajes diferentes.
• muestra un HUD con el puntaje. La puntuación aumenta en 1 punto por cada pieza que recojas
• El jugador pierde cuando choca con su propia cola o la pared.
• una pieza se genera en un área aleatoria inmediatamente después de que se recolecta una pieza, por no mencionar al comienzo del juego
• La velocidad del juego no importa, siempre que sea consistente
• Las 'celdas' deben tener 2x1 caracteres, ya que la altura de los caracteres de bloque es ~ dos veces el ancho Puede ser 1x1, porque 2x1 es simplemente feo y realmente no pensé en eso
• Las teclas para cambiar la dirección deben ser awsd, izquierda, arriba, abajo, derecha respectivamente
• la dirección de inicio siempre debe estar arriba
• Debes mostrar los bordes de la pared. La puntuación puede superponerse a la pared.

El código más corto que cumpla con los criterios anteriores gana. Puntos de bonificación imaginarios para la creatividad

JavaScript ( 553 512 bytes)

Enlace a la versión jugable

c=0;a=b=d=-1;e=[f=[20,7],[20,8]];i=Math.random;~function n(){if(c&&(87==a||83==a
))c=0,d=87==a?-1:1;if(d&&(65==a||68==a))d=0,c=65==a?-1:1;p([j=e[0][0]+c,k=e[0][1
]+d])||!j||39==j||!k||10==k?b+=" | GAME OVER":(e.unshift([j,k]),p(f)?(f=[1+38*i(
)|0,1+9*i()|0],b++):e.pop());for(m=h="";11>h;h++){for(g=0;40>g;g++)l=g+","+h,m+=
!g||39==g||!h||10==h?"X":e[0]==l?"O":p(l)?"*":f==l?"%":" ";m+="\n"}x.innerHTML=m
+b;!b.sup&&setTimeout(n,99)}();onkeydown=function(o){a=o.keyCode};function p(o){
return e.join(p).indexOf(p+o)+1}

Al principio intenté que saliera a la consola real (con console.logy console.clear), pero parpadeaba demasiado, así que lo puse en HTML similar a una consola. Funcionará con esto:

<pre id=x>

También lo implementé primero con celdas 2x1, pero se veía peor que 1x1. Sin embargo, eso sería un cambio menor.

Utiliza awsdteclas en el teclado.

Actualizar:

Pude reducirlo a 512 bytes (exactamente 0x200) mejorando la búsqueda de cola y haciendo algo más de magia.

Ahora obtienes 2 puntos cuando aparece una pieza en tu cola (es una característica). También arreglé la superposición cuando la serpiente se muerde.

Código de máquina x86 (128 bytes)

Al igual que mi presentación para Generar un Fractal de Mandlebrot , escribí un producto para el juego de la serpiente en 128 bytes. No cumple completamente con los requisitos del desafío (comienza a moverse hacia la derecha, no todos los muros están dibujados), pero lo estoy publicando porque creo que es una solución interesante y creativa. El puntaje se muestra en binario a la derecha, las teclas de flecha controlan la dirección del movimiento, la 'comida' se suelta al azar y termina si te golpeas a ti mismo, a la pared o al borde de la pantalla.

Enlace para ejecutable y código fuente

Además, en lo que respecta al comentario anterior sobre si dosbox está haciendo trampa, creo que es perfectamente aceptable siempre que esté en un modo de visualización basado en texto, ya que es solo un terminal de dos.

16 bits 8086

526 bytes / 390 bytes

Decodifique esto utilizando un decodificador Base64 y llámelo "snake.com" y luego ejecútelo desde el símbolo del sistema de Windows. Probado en WinXP, es posible que deba usar DosBox para obtener el modo de video correcto. Las teclas de control son 'wasd' y espacio para salir. Presione 'w' para comenzar.

uBMAzRC5AD+2AOipAb1AAbgAoI7Auf//v4sMsAHzqrgAtLksAfOqg8cU/sx19OgsAYs+8gKwAuj4
ALQAzRpCiRYOA4kWEAPouAC0C80hCsB0IbQIzSG+ygKDxgOAPAB0EjgEdfSLRAGzAP/Qo1cBiB7w
AulqAIEGdAGu/7P+uNECgMMEw7MCuNsCgMMGw4s+8gKLHvACisPolwADv+YCJoo16I0AiT7yAoD+
A775AnREiz70AiaKHbAA6HUAA7/mAok+9AKA/gB0FscGVwHNAoEudAGu/zPJtj/o2QDofQC0AM0a
OxYOA3X2/wYOA+lZ/8YEAE7+BIA8CnT16F4AaOAB6EQAM9K5LQD38YvCweACBQoA9+WL+OguALlL
ADPS9/HB4gKDwgsD+iaAPQB10rADiMRXq4HHPQGrq4HHPAGrq4HHPQGrX8OhEAO62wD34rntf/fx
iRYQA4vCw772Ar8K9bUEshCstACL2AHDi4f6ArMDtwXR+LEAwNEC/smA4Q8miA0p7/7PdevoIQA6
xHQE/st13ugKAP7NdcroAwB1+8O3BSbGBQEp7/7PdfaBx0EG/srDuBAQM9uAwwLNEID7CnX2w7gD
AM0QzSB3dgEgxgIAYYcBZIUBIMYCAHd8AXN+ASDGAgAA+wAF/P8EAAIAH4ofigAAAADRxeD/TJlO
gQPvQrVA4++BVdVjgQ==

Aquí hay una versión en modo de caracteres que tiene 390 bytes de longitud:

uAMAzRC4ALiOwLlQADP/uCCf86uzF6u4AA+xTvOruCCfq7LdfCxUPOr6BgBiz5+AqF8Aqu0AM0aQ
okWhgKJFogC6MUAtAvNIQrAdCG0CM0hvlYCg8YDgDwAdBI4BHX0i0QBswD/0KNSAYgefALpdgCBB
m8Bov+z/rhdAoDDBMOzArhnAoDDBsOLPn4Cix58AiaJHQOclgmijUmiR2JPn4CgP4DvoUCdFOLPo
ACJoodJscFAAADv3JYiT6AAoD+AHQkxwZSAVkCgS5vAaL/vwEAudAHJoA9qnUEJsYFzIPHAuLx6F
4AtADNGjsWhgJ19oMGhgIC6Uz/xgQATv4EgDwKdPXoPgBo5wHoIgC5FwD38Wn6oADoFgC5TgD38U
ID0gP6JoA9AHXhJscFA93DoYgCutsA9+K57X/38YkWiAKLwjPSw76CAr8CALkEALSfrAQwq+L6w8
0gd3EBIFcCAGGCAWSAASBXAgB3dwFzeQEgVwIAYP+gAP7/AgACqtAH0AcAAAAA

Este modo de personaje tiene tres bytes más (pero la serpiente es mejor):

uAMAzRC4ALiOwLlQADP/uCCf86uzF6u4AA+xTvOruCCfq/7LdfCxUPOr6BsBiz6BAibHBQEKtADN
GkKJFokCiRaLAujHALQLzSEKwHQhtAjNIb5ZAoPGA4A8AHQSOAR19ItEAbMA/9CjUwGIHn8C6XgA
gQZwAaD/s/64YAKAwwTDswK4agKAwwbDiz6BAosefwImiR0Dv3VYJoo1JscFAQqJPoECgP4DvogC
dFOLPoMCJoodJscFAAADv3VYiT6DAoD+AHQkxwZTAVwCgS5wAaD/vwEAudAHJoA9qnUEJsYFzIPH
AuLx6F4AtADNGjsWiQJ19oMGiQIE6Ur/xgQATv4EgDwKdPXoPgBo6gHoIgC5FwD38Wn6oADoFgC5
TgD38UID0gP6JoA9AHXhJscFA93DoYsCutsA9+K57X/38YkWiwKLwjPSw76FAr8CALkEALSfrAQw
q+L6w80gd3IBIFoCAGGDAWSBASBaAgB3eAFzegEgWgIAYP+gAP7/AgACqtAH0AcAAAAA

cáscara / sh, 578 caracteres

Intenté cumplir con POSIX (ser lo más portátil posible y evitar los bashismos, incluso el generador de números aleatorios no necesita / proc). Puede, por ejemplo, jugarlo en su terminal nativa o mediante una sesión SSH: ejecutar con 'dash -c ./snake' También hay una variante no legible / legible en ~ 2800 bytes, que se puede ver aquí .

Algunas notas: el script de shell no es adecuado para codificar juegos 8-)

• para ser justos, solo usamos los llamados 'builtins', que significa:
  • no hay llamadas externas de programas como 'clear', 'stty' o 'tput'
  • por eso, redibujamos la pantalla completa en cada movimiento
  • Los únicos componentes internos utilizados (también conocidos como comandos nativos) son:
    • echo, eval, while-loop, let, break, read, case, test, set, shift, alias, source
• no hay un generador de números aleatorios (PRNG), por lo que tenemos que construir nuestro propio
• obtener bloques de pulsación de teclas, por lo que tenemos que generar otro hilo
  • para obtener el evento en la tarea principal, usamos un archivo temporal (¡feo!)
• la serpiente en sí es una lista, que es barata:
  • cada elemento es una tupla (x, y)
  • perder la cola significa: cambiar la lista por 1
  • agregar una (nueva) cabeza significa: agregar una cadena
• la cuadrícula es internamente una matriz, pero shell / sh no lo sabe:
  • "emulamos" la matriz (x, y) a través de una fea llamada eval con vars globales
• y finalmente: nos divertimos mucho!

#!/bin/sh
alias J=do T=let E=echo D=done W=while\ let
p(){ eval A$1x$2=${3:-#};}
g(){ eval F="\${A$1x$2:- }";}
r(){
E $((1+(99*I)%$1))
}
X=9
Y=8
L="8 8 $X $Y"
I=41
W I-=1
J
p $I 1
p $I 21
p 1 $I
p 41 $I
D
p 3 3 :
>L
W I+=1
J
E -ne \\033[H
y=22
W y-=1
J
Z=
x=42
W x-=1
J
g $x $y
Z=$Z$F
D
E "$Z"
D
E $B
. ./L
case $D in
a)T X+=1;;d)T X-=1;;s)T Y-=1;;*)T Y+=1;;esac
g $X $Y
case $F in
\ |:)p $X $Y O
L="$L $X $Y"
case $F in
:)W I+=1
J
x=`r 39`
y=`r 19`
g $x $y
[ "$F" = \  ]&&{
p $x $y :
break
}
D
T B+=1;;*)set $L
p $1 $2 \ 
shift 2
L=$@;;esac;;*).;;
esac
D&
while read -sn1 K
J
E D=$K>L
D

Ruby 1.9 / Solo Windows / ( 354 337 355 346 bytes)

require'Win32API';G=(W=Win32API).new g="crtdll","_getch",t=[],?I
B=(c=?#*39+h="#
#")+((S=' ')*38+h)*20+c;n=proc{c while B[c=rand(800)]!=S;B[c]=?*;S}
n[h=760];k={97=>-1,100=>1,119=>d=-41,115=>41}
(B[h]=?O;system'cls';$><<B<<$.;sleep 0.1
d=k[G.call]if W.new(g,"_kbhit",[],?I).call>0
t<<h;B[h]=?o;B[h+=d]==?*?B[h]=n[$.+=1]:B[t.shift]=S)while B[h]==S

Juega en un tablero de 20x40 en la consola de Windows. La puntuación se muestra debajo del tablero. Use WASDpara controlar la serpiente, cualquier otra tecla para salir (¡con fuerza!). Edite el tiempo de suspensión al final de la línea 5 para controlar la velocidad. (¡O guarde 10 caracteres y haga que sea casi imposible de jugar eliminando el sueño por completo!)

Función de bonificación: no se inicia aleatoriamente (cuando se genera la pieza inicial en la ubicación de la serpiente).

Necesitaba ~ 100 caracteres para solucionar la falta de un getchar sin bloqueo. Aparentemente, Ruby 1.9.3 incluye una biblioteca "io / console" que habría salvado aproximadamente la mitad de ellas. Y esta solución es específica de Windows. Hay soluciones publicadas para hacer el mismo tipo de cosas en los sistemas * nix, pero no las he probado para comparar el recuento de caracteres.

Editar:

Tuve que agregar 18 bytes después de darme cuenta de que la cola solo crece después de comer, no después de cada paso.

Edición 2: (Posiblemente) se solucionó el problema del bloqueo, se guardaron los 9 bytes al restringirlos a un artículo de comida.

Applesoft Basic - 478 (462)

Este fue mi primer código de golf, pero fue escrito en 1989, y principalmente implementa el juego de la serpiente según lo solicitado (pero sin comida, las serpientes crecen continuamente, y en realidad son dos jugadores, no uno) usando solo dos líneas de Applesoft Basic.

Hubo una serie de concursos de programas de dos líneas en ese momento, como en el diario Dr. Dobbs. Pasé 6 meses descubriendo cómo encajar esto en dos líneas que tienen un límite de 255 caracteres (y solo una rama)

Más información en: http://davesource.com/Projects/SpeedWaller/

El programa escrito es exactamente dos líneas:

1ONSCRN(X,Y)<>7ANDB<>0ANDSCRN(U,V)<>7GOTO2:HOME:GR:X=10:Y=20:U=30:V=Y:I=201:J=202:K=203:M=205:W=215:A=193:S=211:Z=218:O=1:Q=-1:P=49152:COLOR=7:HLIN0,39AT0:HLIN0,39AT39:VLIN0,39AT0:VLIN0,39AT39:VTAB22: ?"WASZ IJKM  "C:ONB=0GOTO2:CALL-678:RUN
2PLOTX,Y:PLOTU,V:B=PEEK(P):G=B<>ZANDB<>W:H=B<>AANDB<>S:O=G*(O*H+(B=S)-(B=A)):L=H*(L*G+(B=Z)-(B=W)):G=B<>IANDB<>M:H=B<>JANDB<>K:Q=G*(Q*H+(B=K)-(B=J)):R=H*(R*G+(B=M)-(B=I)):X=X+O:Y=Y+L:U=U+Q:V=V+R:FORN=1TO99:NEXT:C=C+1:VTAB22:HTAB12:?C:GOTO1

El listado cuando está formateado se ve así:

1 ONSCRN(X,Y)<>7 AND B<>0 AND SCRN(U,V) <> 7 GOTO 2: HOME : GR :
  X=10 : Y=20 : U=30 : V=Y : I=201 : J=202 : K=203 : M=205 : W=215 :
  A=193 : S=211 : Z=218 : O=1 : Q=-1 : P=49152 : COLOR=7 : HLIN 0,39
  AT 0 : HLIN 0,39 AT 39 : VLIN 0,39 AT 0 : VLIN 0,39 AT 39 : VTAB 22 :
  ? "WASZ IJKM  "C : ON B=0 GOTO 2 : CALL -678 : RUN
2 PLOT X,Y : PLOT U,V : B=PEEK(P) : G= B<>Z AND B<>W: H=B<>A AND B<>S :
  O=G*(O*H+(B=S)-(B=A)) : L=H*(L*G+(B=Z)-(B=W)) : G=B<>I AND B<>M :
  H=B<>J AND B<>K : Q=G*(Q*H+(B=K)-(B=J)) : R=H*(R*G+(B=M)-(B=I)) :
  X=X+O : Y=Y+L : U=U+Q : V=V+R : FOR N=1 TO 99 : NEXT : C=C+1 :
  VTAB 22 : HTAB 12 : ? C : GOTO 1

El juego es en realidad dos jugadores e incluye "instrucciones" en la parte inferior de la página que muestran las teclas y un contador para que puedas ver cuántos pasos sobreviviste. Son 478 caracteres, 16 de ellos son las instrucciones y la salida del contador, por lo que 462 si quieres afeitarlos.

Consola C # .NET Framework 4.7.2 ( 2,456 2,440 2,424 2,408 2,052 1,973 1,747 1,686 bytes)

Esto fue divertido, pero realmente tuve que pensar qué variables eran qué, porque son solo una letra.

using m=System.Console;using System;using System.Collections.Generic;using System.Threading;class s{static void Main(){m.CursorVisible=0>1;new s()._();}int l;Action<string> w=(x)=>m.Write(x);Action<int,int>n=(x,y)=>m.SetCursorPosition(x,y);(int x,int y)d,c,a;int h,u;List<(int x,int y)>p;void _(){while(1>0){f();h=25;u=25;p=new List<(int x,int y)>();l=0;d=(0,-1);c=(u/2,h/2);e();m.SetWindowSize(u+4,h+4);m.SetBufferSize(u+4,h+4);while(1>0){k();if(t())break;g();r();}f();m.SetWindowSize(u+4,h+6);m.SetBufferSize(u+4,h+6);n(1,h+3);w("        Game over,\n   press any key to retry.");f();m.ReadKey(1>0);m.Clear();}}private bool t(){if(c.x<0||c.y<0||c.x>=u||c.y>=h){r();n(c.x+2,c.y+2);w("X");return 1>0;}for(i=0;i<p.Count;i++){for(int j=0;j<i;j++){if(p[i].x==p[j].x&&p[i].y==p[j].y){r();n(c.x+2,c.y+2);w("X");return 1>0;}}}return 0>1;}private void e(){a=(z.Next(u),z.Next(h));l++;}void f(){while(m.KeyAvailable)m.ReadKey(1>0);}int i;void k(){var b=DateTime.Now;while((DateTime.Now-b).TotalMilliseconds<230)Thread.Sleep(10);if(!m.KeyAvailable)return;var a=m.ReadKey(1>0).Key;switch(a){case ConsoleKey.A:if(d.x==0)d=(-1,0);break;case ConsoleKey.W:if(d.y==0)d=(0,-1);break;case ConsoleKey.S:if(d.y==0)d=(0,1);break;case ConsoleKey.D:if(d.x==0)d=(1,0);break;}f();}void g(){c.x+=d.x;c.y+=d.y;p.Add((c.x,c.y));while(p.Count>l)p.RemoveAt(0);if(c.x==a.x&&c.y==a.y)e();}void r(){n(1,1);w("/");w(new string('-',u));w("\\");n(1,h+2);w("\\");w(new string('-',u));w("/");for(i=0;i<h;i++){n(1,i+2);w("|");n(u+2,i+2);w("|");}for(i=0;i<h;i++){for(int j=0;j<u;j++){n(i+2,j+2);w(" ");}}n(a.x+2,a.y+2);w("@");for(i=0;i<p.Count;i++){n(p[i].x+2,p[i].y+2);w("#");}n(2,0);w("Score:"+l);}Random z=new Random();}

Algunas capturas de pantalla:

Binario: https://github.com/wooden-utensil/snakeCodeGolf/releases/tag/v1.0.0.0

Repositorio de GitHub: https://github.com/wooden-utensil/snakeCodeGolf

Registro de cambios: https://github.com/wooden-utensil/snakeCodeGolf/releases

Python 3 - 644

from curses import *
import time
from collections import deque
from random import randrange as R
N,W,S,E=z=119,97,115,100
t=tuple
u=0,0
def m(s):
 a=lambda o,y,x:y.addch(o[0],o[1],x);q=lambda:(R(L-2),R(C-2));L,C=s.getmaxyx();curs_set(0);s.nodelay(1);s.border();s.refresh();r=newwin(L-2,C-2,1,1);n=deque();y,x=[L-2,0];d=N;n.append(u);c=N;p=q();a(p,r,N);a(u,s,48)
 while 1:
  if c in z:d=c
  if d==N:y-=1
  if d==S:y+=1
  if d==W:x-=1
  if d==E:x+=1
  l=n.pop()
  if (y,x) in n:return
  if (y,x)==p:p=q();a(p,r,N);n.append(l);s.addstr(0,0,str(len(n)))
  n.appendleft((y,x));a((y,x),r,S);a(l,r,32);r.refresh();time.sleep(.2);c=s.getch()
wrapper(m)

No deja de fumar limpiamente. La pieza podría desaparecer si se genera encima de la serpiente.

Bash (demasiados caracteres: ca. 1522)

t=tput
tc="$t cup"
tr="$t rev"
ts="$t sgr0"
ox=5
oy=5
((w=$($t cols)-2-2*ox))
((h=$($t lines)-2-2*oy))
trap "$t rmcup
stty echo
echo 'Thanks for playing snake!'
" EXIT
$t smcup
$t civis
stty -echo
clear
printf -v hs %$((w+2))s
printf -v v "|%${w}s|"
$tc $oy $ox
printf %s ${hs// /_}
for((i=1;i<=h+1;++i)); do
$tc $((oy+i)) $ox
printf %s "$v"
done
$tc $((oy+h+2)) $ox
printf %s ${hs// /¯}
dx=0
dy=-1
hx=$((w/2))
hy=$((h-2))
l=2
xa=($hx $hx)
ya=($hy $((hy+1)))
$tr
for((i=0;i<${#xa[@]};++i)); do
$tc $((ya[i]+1+oy)) $((xa[i]+1+ox))
printf \ 
done
$ts
print_food() {
$tc $((fy+1+oy)) $((fx+1+ox))
printf "*"
}
nf() {
rf=1
while((rf))
do
rf=0
((fx=RANDOM%w))
((fy=RANDOM%h))
for ((i=0;i<${#ya[@]};++i))
do
if((ya[i]==fy&&xa[i]==fx))
then
rf=1
break
fi
done
done
print_food
}
nf
ps() {
s="SCORE: $l"
$tc $((oy-1)) $((ox+(w-${#s})/2))
printf "$s"
}
ps
while :
do
read -t 0.2 -s -n1 k
if (($?==0))
then
case $k in
w|W)((dy==0))&&{ dx=0;dy=-1;};;
a|A)((dx==0))&&{ dx=-1;dy=0;};;
s|S)((dy==0))&&{ dx=0;dy=1;};;
d|D)((dx==0))&&{ dx=1; dy=0;};;
q|Q)break;;
esac
fi
((hx=${xa[0]}+dx))
((hy=${ya[0]}+dy))
if((hx<0||hy<0||hx>w||hy>h))
then
go=1
break
fi
for((i=1;i<${#ya[@]}-1;++i))
do
if((hx==xa[i]&&hy==ya[i]))
then
go=1
break 2
fi
done
$tc $((ya[-1]+1+oy)) $((xa[-1]+1+ox))
printf \ 
$tr
$tc $((hy+1+oy)) $((hx+1+ox))
printf \ 
$ts
if((hx==fx&&hy==fy))
then
((++l))
ps
nf
else
ya=(${ya[@]::${#ya[@]}-1})
xa=(${xa[@]::${#xa[@]}-1})
fi
ya=($hy ${ya[@]})
xa=($hx ${xa[@]})
done
if((go))
then
$tc 3 3
echo GAME OVER
read -t 3 -s -n1
fi