I giochi sono divertenti

questo codegolf qui è stato così divertente che ho dovuto realizzare una versione per altri giochi classici simili per complessità. Il modo più breve per creare un gioco Space Invaders di base in Python

Questa volta, tuttavia, prova a ricreare il classico gioco "Snake", in cui inizi come una piccola forma, muovendoti costantemente verso la raccolta di pezzi per aumentare il tuo punteggio. Quando raccogli un pezzo, la tua 'coda' cresce, che segue il percorso che hai fatto. L'obiettivo è quello di durare più a lungo senza schiantarsi contro la propria coda o contro i muri

Titoli di studio:

• Tu, i personaggi che compongono la coda, le pareti e i pezzi che collezionate dovreste essere tutti personaggi diversi
• mostra un HUD con il punteggio. Il punteggio aumenta di 1 punto per ogni pezzo che raccogli
• Il giocatore perde quando si scontrano con la propria coda o il muro
• un pezzo si genera in un'area casuale immediatamente dopo la raccolta di un pezzo, per non parlare all'inizio del gioco
• La velocità del gioco non ha importanza, purché sia ​​coerente
• Le "celle" dovrebbero essere 2x1 caratteri, poiché l'altezza dei caratteri di blocco è ~ il doppio della larghezza Può essere 1x1, perché 2x1 è semplicemente brutto e non ci ho pensato davvero
• I tasti per cambiare la direzione dovrebbero essere rispettivamente a awsdsinistra, su, giù, a destra
• la direzione di partenza dovrebbe essere sempre in alto
• Devi mostrare i bordi del muro. Il punteggio può sovrapporsi al muro

Vince il codice più breve che soddisfa i criteri sopra indicati. Punti bonus immaginari per la creatività

JavaScript ( 553 512 byte)

Link alla versione giocabile

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}

Ho provato a renderlo inizialmente sulla console reale (con console.loge console.clear), ma tremolava troppo, quindi l'ho inserito in un HTML simile a una console. Funzionerà con questo:

<pre id=x>

Inoltre l'ho implementato prima con celle 2x1, ma sembrava solo peggio di 1x1. Sarebbe comunque un piccolo cambiamento.

Utilizza i awsdtasti sulla tastiera.

Aggiornare:

Sono stato in grado di ridurlo a 512 (esattamente 0x200) byte migliorando la ricerca della coda e facendo un po 'più di magia.

Ora ricevi 2 punti quando un pezzo si genera nella tua coda (è una caratteristica). Ho anche corretto la sovrapposizione quando il serpente si morde.

Codice macchina x86 (128 byte)

Proprio come la mia presentazione per la generazione di un frattale di Mandlebrot , ho scritto un pungolo per il gioco del serpente in 128 byte. Non soddisfa pienamente i requisiti della sfida (inizia a muoversi a destra, non tutti i muri sono disegnati), ma lo sto pubblicando perché penso che sia una soluzione interessante e creativa. Il punteggio viene mostrato in binario a destra, i tasti freccia controllano la direzione del movimento, il "cibo" viene lasciato cadere casualmente e termina se si colpisce te stesso, il muro o il bordo dello schermo.

Link per eseguibile e codice sorgente

Inoltre, per quanto riguarda il precedente commento sul fatto che dosbox stia barando, penso perfettamente accettabile purché sia ​​in una modalità di visualizzazione basata su testo, da allora è solo un terminale dos.

16 bit 8086

526 byte / 390 byte

Decodifica utilizzando un decodificatore Base64 e chiamalo "snake.com", quindi esegui dal prompt dei comandi di Windows. Testato su WinXP, potrebbe essere necessario utilizzare DosBox per ottenere la giusta modalità video. I tasti di controllo sono 'wasd' e lo spazio per uscire. Premi 'w' per iniziare.

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==

Ecco una versione in modalità carattere lunga 390 byte:

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

Questa modalità personaggio ha tre byte in più (ma il serpente è migliore):

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

shell / sh, 578 caratteri

Ho cercato di essere conforme a POSIX (essendo il più portatile possibile ed evitando i bashismi, anche il generatore di numeri casuali non ha bisogno di / proc). Puoi ad esempio giocarlo nel tuo terminale nativo o tramite una sessione SSH: corri con 'dash -c ./snake' C'è anche una variante non semplificata / leggibile in ~ 2800 byte, che può essere vista qui .

Alcune note: shell-scripting non è adatto per i giochi di codifica Cool)

• per essere onesti, abbiamo usato solo i cosiddetti "builtin", che significa:
  • nessuna chiamata esterna di programmi come "clear", "stty" o "tput"
  • per questo motivo, ridisegniamo l'intero schermo ad ogni mossa
  • gli unici builtin usati (noti anche come comandi nativi) sono:
    • echo, eval, while-loop, let, break, read, case, test, set, shift, alias, source
• non esiste un generatore di numeri casuali (PRNG), quindi dobbiamo costruirne uno nostro
• ottenere blocchi di tasti, quindi dobbiamo generare un altro thread
  • per ottenere l'evento in attività genitore usiamo un tempfile (brutto!)
• il serpente stesso è un elenco, che è economico:
  • ogni elemento è una (x, y) -tupla
  • perdere la coda significa: spostare l'elenco di 1
  • aggiungere una (nuova) testa significa: aggiungere una stringa
• la griglia è internamente un array, ma shell / sh non lo sa:
  • abbiamo "emulato" array (x, y) tramite una brutta chiamata di valutazione con varchi globali
• e infine: ci siamo divertiti molto!

#!/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 byte)

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

Gioca in una scheda 20x40 nella console di Windows. Il punteggio è mostrato sotto il tabellone. Usa WASDper controllare il serpente, qualsiasi altra chiave per uscire (con forza!). Modifica il tempo di spegnimento alla fine della riga 5 per controllare la velocità. (O salva 10 personaggi e rendilo quasi ingiocabile rimuovendo completamente il sonno!)

Funzione bonus: non si avvia casualmente (quando il pezzo iniziale viene generato nella posizione del serpente).

Avevo bisogno di ~ 100 caratteri per ovviare alla mancanza di un getchar non bloccante. Apparentemente Ruby 1.9.3 include una libreria "io / console" che avrebbe salvato circa la metà di quelli. E questa soluzione è specifica per Windows. Esistono soluzioni pubblicate per fare lo stesso tipo di cose nei sistemi * nix, ma non le ho testate per confrontare il conteggio dei caratteri.

Modificare:

Ho dovuto aggiungere 18 byte dopo aver realizzato che la coda cresce solo dopo aver mangiato, non dopo ogni passaggio.

Modifica 2: (possibilmente) risolto problema di arresto, salvato i 9 byte limitando a un alimento.

Applesoft Basic - 478 (462)

Questo è stato il mio primo golf di sempre, ma è stato riscritto nel 1989 e implementa principalmente il gioco del serpente come richiesto (ma senza cibo, i serpenti crescono continuamente, ed è in realtà due giocatori, non uno) usando solo due righe di Applesoft Basic.

All'epoca c'erano diversi concorsi di programmi su due righe, come nel diario del Dr. Dobbs. Ho trascorso 6 mesi a capire come adattarlo a due righe che hanno un limite di 255 caratteri (e un solo ramo)

Maggiori informazioni su: http://davesource.com/Projects/SpeedWaller/

Il programma digitato è esattamente di due righe:

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

L'elenco quando formattato è simile al seguente:

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

Il gioco in realtà è composto da due giocatori e include "istruzioni" nella parte inferiore della pagina che mostra le chiavi e un contatore in modo da poter vedere quanti passaggi sei sopravvissuto. Sono 478 caratteri, 16 di questi sono le istruzioni e l'output del contatore, quindi 462 se vuoi raderli.

Console C # .NET Framework 4.7.2 ( 2.456 2.440 2.424 2.408 2.052 1.973 1.747 1.686 byte)

È stato divertente, ma dovevo davvero pensare a cosa fossero le variabili, perché sono solo una lettera.

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();}

Alcuni screenshot:

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

Repository GitHub: https://github.com/wooden-utensil/snakeCodeGolf

Log delle modifiche: 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)

Non si chiude in modo pulito. Il pezzo potrebbe scomparire se si genera sopra il serpente.

Bash (troppi personaggi: circa 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