Les jeux sont amusants

ce codegolf ici était si amusant que j'ai dû faire une version pour d'autres jeux classiques de complexité similaire. Le moyen le plus court de créer un jeu Space Invaders de base en Python

Cette fois, cependant, essayez de recréer le jeu classique "Snake", dans lequel vous commencez comme une petite forme, en vous déplaçant constamment pour collecter des pièces pour augmenter votre score. Lorsque vous collectez un morceau, votre «queue» grandit, qui suit le chemin que vous avez tracé. L'objectif est de durer le plus longtemps sans s'écraser dans votre propre queue ou dans les murs

Qualifications:

• Vous, les personnages qui composent la queue, les murs et les pièces que vous collectez doivent tous être des personnages différents
• montrer un HUD avec le score. Le score augmente de 1 point pour chaque pièce collectée
• Le joueur perd lorsqu'il entre en collision avec sa propre queue ou le mur
• une pièce apparaît dans une zone aléatoire immédiatement après la collecte d'une pièce, sans parler du début de la partie
• La vitesse du jeu n'a pas d'importance, tant qu'elle est cohérente
• Les 'cellules' devraient être 2x1 caractères, car la hauteur des caractères de bloc est ~ le double de la largeur Peut être 1x1, parce que 2x1 est juste moche et je n'y ai pas vraiment pensé
• Les touches pour changer la direction doivent être respectivement awsdgauche, haut, bas, droite
• la direction de départ doit toujours être vers le haut
• Vous devez montrer les bords du mur. Le score peut chevaucher le mur

Le code le plus court répondant aux critères ci-dessus l'emporte. Points bonus imaginaires pour la créativité

JavaScript ( 553 512 octets)

Lien vers la version jouable

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}

J'ai d'abord essayé de le faire sortir sur la vraie console (avec console.logetconsole.clear ), mais il scintillait trop, alors je l'ai mis en HTML de type console. Cela fonctionnera avec ceci:

<pre id=x>

Je l'ai également implémenté avec des cellules 2x1 en premier, mais cela semblait pire que 1x1. Ce serait cependant un changement mineur.

Les usages awsd touches du clavier.

Mise à jour:

J'ai pu le réduire à 512 (exactement 0x200) octets en améliorant la recherche de queue et en faisant plus de magie.

Vous obtenez maintenant 2 points lorsqu'un morceau apparaît dans votre queue (c'est une caractéristique). J'ai également corrigé le chevauchement lorsque le serpent se mord.

Code machine x86 (128 octets)

Tout comme ma soumission pour Générer une fractale de Mandlebrot , j'ai écrit une prod pour le jeu de serpent en 128 octets. Il ne répond pas pleinement aux exigences du défi (il commence à bouger à droite, tous les murs ne sont pas dessinés), mais je le poste car je pense que c'est une solution intéressante et créative. Le score est affiché en binaire à droite, les touches fléchées contrôlent la direction du mouvement, la `` nourriture '' est lâchée au hasard, et elle se termine si vous vous frappez, le mur ou le bord de l'écran.

Lien pour l'exécutable et le code source

En outre, en ce qui concerne le commentaire précédent sur la triche de Dosbox, je pense parfaitement acceptable tant qu'il est en mode d'affichage textuel, car il ne s'agit alors que d'un terminal DOS.

16 bits 8086

526 octets / 390 octets

Décodez-le à l'aide d' un décodeur Base64 et appelez-le "snake.com", puis exécutez-le à partir de l'invite de commande Windows. Testé sur WinXP, vous devrez peut-être utiliser DosBox pour obtenir le bon mode vidéo. Les touches de contrôle sont «wasd» et de l'espace pour quitter. Appuyez sur 'w' pour commencer.

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

Voici une version en mode caractère longue de 390 octets:

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

Ce personnage modifie ses trois octets de plus (mais le serpent est meilleur):

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

shell / sh, 578 caractères

J'ai essayé d'être compatible POSIX (étant le plus portable possible et évitant les bashismes, même le générateur de nombres aléatoires n'a pas besoin de / proc). Vous pouvez par exemple le jouer dans votre terminal natif ou via une session SSH: exécutez avec 'dash -c ./snake' Il existe également une variante non lisible / lisible en ~ 2800 octets, qui peut être vue ici .

Quelques remarques: le shell-scripting n'est pas adapté au codage des jeux 8-)

• pour être honnête, nous n'avons utilisé que ce que l'on appelle des «builtins», ce qui signifie:
  • pas d'appels externes de programmes comme 'clear', 'stty' ou 'tput'
  • à cause de cela, nous redessinons tout l'écran à chaque mouvement
  • les seuls prédéfinis utilisés (aussi appelés commandes natives) sont:
    • echo, eval, while-loop, let, break, read, case, test, set, shift, alias, source
• il n'y a pas de générateur de nombres aléatoires (PRNG), nous devons donc construire notre propre
• obtenir un bloc de touches, nous devons donc générer un autre thread
  • pour obtenir l'événement dans la tâche parent, nous utilisons un fichier temporaire (moche!)
• le serpent lui-même est une liste, qui est bon marché:
  • chaque élément est un (x, y) -uple
  • perdre la queue signifie: décaler la liste de 1
  • ajouter une (nouvelle) tête signifie: ajouter une chaîne
• la grille est en interne un tableau, mais shell / sh ne le sait pas:
  • nous avons "émulé" un tableau (x, y) via un laid eval-call avec des variables globales
• et enfin: on s'est bien amusé!

#!/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 / Windows uniquement / ( 354 337 355 346 octets)

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

Joue dans un tableau 20x40 dans la console Windows. Le score est affiché sous le tableau. Utilisez WASDpour contrôler le serpent, n'importe quelle autre touche pour sortir (avec force!). Modifiez le temps de veille à la fin de la ligne 5 pour contrôler la vitesse. (Ou enregistrez 10 caractères et rendez-les presque illisibles en supprimant complètement le sommeil!)

Fonction bonus: ne démarre pas au hasard (lorsque la pièce initiale est générée à l'emplacement du serpent).

J'avais besoin de ~ 100 caractères pour contourner l'absence d'un getchar non bloquant. Apparemment, Ruby 1.9.3 comprend une bibliothèque "io / console" qui aurait sauvé environ la moitié de celles-ci. Et cette solution est spécifique à Windows. Il existe des solutions publiées pour faire le même type de chose dans les systèmes * nix, mais je ne les ai pas testés pour comparer le nombre de caractères.

Modifier:

J'ai dû ajouter 18 octets après avoir réalisé que la queue ne pousse qu'après avoir mangé, pas après chaque étape.

Edit 2: (éventuellement) correction d'un problème de plantage, sauvé les 9 octets en se limitant à un seul aliment.

Applesoft Basic - 478 (462)

C'était mon tout premier golf de code, mais il a été écrit en 1989, et il implémente principalement le jeu de serpent comme demandé (mais sans nourriture, les serpents grandissent continuellement, et c'est en fait deux joueurs, pas un) en utilisant seulement deux lignes de Applesoft Basic.

Il y avait un certain nombre de concours de programme en deux temps à l'époque, comme dans le journal du Dr Dobbs. J'ai passé 6 mois à trouver comment adapter cela en deux lignes qui ont une limite de 255 caractères (et une seule branche)

Plus d'informations sur: http://davesource.com/Projects/SpeedWaller/

Le programme tapé est exactement deux lignes:

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

La liste une fois formatée ressemble à ceci:

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

Le jeu est en fait à deux joueurs et comprend des "instructions" en bas de la page montrant les clés ainsi qu'un compteur afin que vous puissiez voir combien d'étapes vous avez survécu. C'est 478 caractères, 16 d'entre eux sont les instructions et la sortie du compteur, donc 462 si vous voulez les raser.

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

C'était amusant, mais je devais vraiment penser à quelles variables étaient quoi, car elles ne sont qu'une seule lettre.

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

Quelques captures d'écran:

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

Référentiel GitHub: https://github.com/wooden-utensil/snakeCodeGolf

Journal des modifications: 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)

Ne quitte pas proprement. La pièce peut disparaître si elle apparaît sur le serpent.

Bash (trop de caractères: environ 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