Pong im kürzesten Code

28

Die Herausforderung ist einfach. Geben Sie den kürzestmöglichen Code ein, um das klassische Pong-Spiel für 2 Spieler zu reproduzieren . Http://en.wikipedia.org/wiki/Pong . Die Höhe der Grafik und Funktionalität so nah wie möglich an dieser Javascript Demonstration sein sollte http://codeincomplete.com/posts/2011/5/14/javascript_pong/demo.html (aber ohne die zusätzliche Optionen können Sie auf der linken Seite klicken Sie auf oder die Informationen zu Frame, FPS usw. unten rechts).

Wie immer muss der Code in einer freien Sprache (in beiden Richtungen) geschrieben sein und sollte unter Linux lauffähig sein. Alle verwendeten Bibliotheken müssen ebenfalls kostenlos, leicht verfügbar und nicht für die Zwecke dieses Wettbewerbs geschrieben sein (und dürfen auch noch keine funktionierende Version von Pong enthalten!).

code-golf graphical-output game felipa
quelle
Ehrlich gesagt ist diese Frage für Code-Golf etwas zu schwierig. Die Ballphysik für Pong ist ziemlich kompliziert.
beary605
@ beary605, ich finde die Ballphysik nicht zu kompliziert. Meine Lösung ist "so nah wie möglich" an der Javascript-Demonstration und die Physik ist recht einfach.
Standby
Nur als Referenz gibt es einige andere [Code-Golf], die zu lange dauern. Bauen Sie sich ein Motor für ein Labyrinth - Spiel , Tic Tac Toe (aka Tic-Tac-Toe) (beide zusätzliche Einträge verwenden könnte, die standardmäßig auf „gewinnen“ mag?), Schreiben einen kleinen HTTP - Server , Selbstdolmetscher Interpreter , Self- Compiler kompilieren , Regexes kompilieren ...
dmckee
@felipa, Können Sie "so nah wie möglich" formalisieren? Ich weiß nicht, warum meine sed-Lösung nicht in Führung liegt.
Stand
1
@ beary605 zu schwierig?
FantaC

Antworten:

24

Javascript, 883 (+ 70 HTML)

c=document.getElementById('c').getContext('2d')
c.fillStyle="#FFF"
c.font="60px monospace"
w=s=1
p=q=a=b=0
m=n=190
x=300;y=235
u=-5;v=3
setInterval(function(){if(w&&!s)return;s=0
c.clearRect(0,0,640,480)
for(i=5;i<480;i+=20)c.fillRect(318,i,4,10)
m+=p;n+=q
m=m<0?0:m;m=m>380?380:m
n=n<0?0:n;n=n>380?380:n
x+=u;y+=v
if(y<=0){y=0;v=-v}
if(y>=470){y=470;v=-v}
if(x<=40&&x>=20&&y<m+110&&y>m-10){u=-u+0.2;v+=(y-m-45)/20}
if(x<=610&&x>=590&&y<n+110&&y>n-10){u=-u-0.2;v+=(y-n-45)/20}
if(x<-10){b++;x=360;y=235;u=5;w=1}
if(x>640){a++;x=280;y=235;u=-5;w=1}
c.fillText(a+" "+b,266,60)
c.fillRect(20,m,20,100)
c.fillRect(600,n,20,100)
c.fillRect(x,y,10,10)},30)
document.onkeydown=function(e){k=(e||window.event).keyCode;w=w?0:k=='27'?1:0;p=k=='65'?5:k=='81'?-5:p;q=k=='40'?5:k=='38'?-5:q;}
document.onkeyup=function(e){k=(e||window.event).keyCode;p=k=='65'||k=='81'?0:p;q=k=='38'||k=='40'?0:q}


/* Variable index:
a -> left player score
b -> right player score
c -> context
e -> event
i -> counter for dashed line
k -> keycode
m -> left paddle y
n -> right paddle y
p -> left paddle y velocity
q -> right paddle y velocity
s -> is start of game
u -> ball x velocity
v -> ball y velocity
w -> game is waiting (paused)
x -> ball x
y -> ball y
*/

Das Skript kann am Ende von platziert <body>oder aufgerufen werden onLoad. Es benötigt das folgende Canvas-Element:

<canvas id="c"width="640"height="480"style="background:#000"></canvas>

Spieler 1 nutzt die qund aTasten, und Spieler 2 verwendet die pund lTasten. Drücken Sie die escTaste zum Anhalten und eine beliebige Taste zum Starten / Fortfahren.

Sie können es in Ihrem Browser spielen hier .

Ich war mir nicht sicher, welche Physik ich verwenden sollte, also begann ich mit einer einfachen Reflexionsmethode, fügte dann etwas Abwechslung hinzu und experimentierte ein wenig damit. Die Geschwindigkeit des Balls in y-Richtung hängt davon ab, an welcher Stelle des Paddels Sie den Ball schlagen, sodass Sie die Kontrolle darüber haben, wohin der Ball geht. Die Geschwindigkeit des Balls in x-Richtung nimmt mit jedem Treffer in der Rallye langsam zu.

Ich vermute, dass es von Lösungen, die Bibliotheken verwenden, ziemlich leicht zu übertreffen ist, aber ich hatte Spaß daran, es in einfachem Javascript zu machen.

grc
quelle
2
Das ist eine wirklich schöne Implementierung.
Felipa
1
Könnte ein bisschen mehr golfen werden, ich weiß, ich bin ungefähr zwei Jahre zu spät hier. Sie könnten 20aber einer Variablen mit dem Namen zuweisen gund ein dürftiges Byte speichern.
Zacharý
Verdammt, es ist schwer, auf einer Azerty-Tastatur zu spielen ...
dim
38

sed, 35

Erhöhen Sie die Messlatte ein wenig mit einer Briefmarke sed Meditation.

s/> / >/
s/ </< /
s/0</0>/
s/>1/<1/

Die Meditation wird auf stdin / stdout auf zwei Computern genossen, die nicht unbedingt über ein Netzwerk verbunden sind. Die Meditation beginnt im Zustand

0         <       1

mit guru null links und eins rechts. Die spitze Klammer bewegt sich nach links und rechts, und wenn ein Guru seine Nummer so bewegt, dass er den Cursor berührt, erhöht sich seine Punktzahl um eins, und er ist hocherfreut.

Die Meditation wird durch Eingeben des obigen Zustands eingeleitet sed -f medi.sed, und der Computer antwortet mit dem nächsten Zustand. Die pflichtbewussten Gurutypen, die in die Meditation eintreten und die nächste Taste vorlesen, die sie drücken, wobei beide Gurus gleichzeitig die heilige Taste für enterdie Zukunft drücken . Der pflichtbewusste Computer antwortet mit dem nächsten Status. Dies wird wiederum vorgelesen, während Sie wie beim letzten Mal gleichzeitig tippen. Weiter in die Zukunft voranschreiten, bis unendliche Glückseligkeit erreicht ist.

Gurus, die eine Herausforderung anstreben, spielen möglicherweise den Turbo-Modus, in dem die Gurus versuchen, gemeinsam den nächsten Status des Computers vorherzusagen und ihn anstelle des aktuellen Status in die Eingabeaufforderung einzugeben. Die Gurus werden die Weisheit haben, die Übereinstimmung ihrer Vorhersagen zu überprüfen, bevor sie in die Zukunft eintreten.

boothby
quelle
23
Alter ... was habe ich gerade gelesen?
MrZander
9
@MrZander Nur durch ausgiebige Betrachtung kann die Weisheit der Meditation offenbart werden. Diese Betrachtung wird am besten durch die Ausführung des Programms unterstützt.
Stand
15

Python (mit Pygame ) 650 Bytes

Eigenschaften

  • 1- und 2-Spieler-Modi - Wenn das Spiel beginnt, drücken Sie 1für 1 Spieler oder 2für 2 Spieler. Das Spiel beginnt erst, wenn eine dieser Tasten gedrückt wird.
  • Erhöhung der Ballgeschwindigkeit - Mit jeder Salve wird die Ballgeschwindigkeit erhöht, so dass sie nach 10 Salven um ca. 50% gestiegen ist, nach 20 um 50% schneller ist usw.
  • Variable Ballauslenkung - Die Ballauslenkung basiert auf zwei Faktoren: Welchen Teil des Paddels trifft er, und ob sich das Paddel beim Aufprall bewegt oder nicht. Wenn der Ball in der Nähe eines der Enden auf das Paddel trifft, wird er stärker abgelenkt als in der Nähe der Mitte (fast so, als wäre es eine gekrümmte Oberfläche). Wenn sich das Paddel in Bewegung befindet, wird die Bewegung des Paddels zusätzlich zur Auslenkung addiert. Um die stärkste Auslenkung zu erzielen, muss der Ball in der Nähe des Paddelendes aufschlagen und das Paddel muss sich in Richtung desselben Endes bewegen. Dies ist dem originalen Pong für den Atari 2600 sehr ähnlich.
  • Pause - Das Spiel kann jederzeit durch Drücken der SpaceLeiste unterbrochen werden. Die Wiedergabe wird fortgesetzt, wenn Sie ein zweites Mal die Leertaste drücken.
  • Kontrollen - wie bei dem Beispiel Spieler 1 bewegt sich mit der Qund ATasten, und Spieler 2 bewegt sich mit Pund L.

Abschließend möchte ich darum bitten, dass diese Lösung aus verschiedenen Gründen nicht als akzeptierte Antwort ausgewählt wird.

from pygame import*
init();d=display;s=d.set_mode((640,480))
g=p=16;j=q=80;x=y=200;o=t=h=v=1;z=m=n=0;w=[255]*3
while s.fill(time.wait(3)):
 event.get();k=key.get_pressed();t^=o*k[32];o=1-k[32];z=z or-k[49]-k[50]*2;e=k[113]-k[97];f=[k[112]-k[108],(h>0)*cmp(y,q-32)][z];a=p<g;b=q-[y,x][a]
 if p%608<g:m,n,p,h,v=[m+1-a,m,n+a,n,g+a*592,p,1-a*2,h/-.96,1,b/32.+~[f,e][a]][-g<b<j::2]
 for r in[(0,x,g,j),(624,y,g,j),(p,q,g,g)]+[(316,i*31,8,15)for i in range(g)]:draw.rect(s,w,r)
 if z*t:v*=(0<q<464)*2-1;x-=(0<x-e<400)*e/.6;y-=(0<y-f<400)*f/.6;p+=h;q+=v
 c=font.SysFont('monospace',j,1).render('%3d %%-3d'%m%n,1,w);s.blit(c,(320-c.get_width()/2,0));d.flip()

Beispiel-Screenshot:

Hinweis: Die für die Partitur verwendete Schriftart kann von System zu System unterschiedlich sein.

primo
quelle
Die Partitur zeigt in der linken Hälfte für mich, und ich denke, die Ablenkung ist zu stark, aber es ist trotzdem ziemlich cool :)
aditsu
@Aditsu arbeiten Sie unter Linux? Ich werde sehen, ob ich eine Alternative finden kann, die unabhängig von der ausgewählten Schriftart funktioniert. Die Idee hinter der Ablenkung ist, dass es möglich wäre, den Ball mit einer schnelleren Geschwindigkeit (maximal 2,5 auf meiner Skala) abzulenken, als sich das Paddel bewegen kann ( 1,67 ). Dies ist nur möglich, wenn Sie es etwas "Spin" geben. Wenn sich das Paddel beim Schlagen des Balls nicht bewegt, beträgt die maximale Geschwindigkeit 1,5 .
Primo
Ja, ich benutze Linux. Ich finde es seltsam, dass der Ball nach dem Schlagen des Paddels tatsächlich "zurück" (nach oben oder unten) gehen kann, anstatt in die gleiche Richtung (möglicherweise in einem anderen Winkel) weiterzumachen. Aber vielleicht hat die Atari-Version das getan, ich weiß es nicht.
Aditsu
@aditsu Es kostet ein paar Bytes, aber ich glaube, die Partitur sollte unabhängig von der gewählten Schriftart zentriert sein (solange es sich um eine Monospace-Partitur handelt). Lassen Sie mich wissen, ob es bei Ihnen funktioniert. Und ja, die Ablenkung ist der mir bekannten Atari-Version sehr ähnlich (obwohl sie eine gleichmäßigere Verteilung aufweist). Wenn Sie sich das Paddel als (konvex) gekrümmte Oberfläche vorstellen (wie ein Airhockey-Paddel), sollte es meiner Meinung nach intuitiver sein.
Primo
Ja, es ist jetzt zentriert
aditsu
8

HTML & JavaScript (nehmen Sie 2) - 525

Da dem OP der Teil "so nah wie möglich" nicht besonders wichtig zu sein schien, ist hier eine alternative Lösung, die ich gnadenlos vereinfacht, gestrippt und golfen habe. Q / A und P / L zu spielen, aber jede andere Taste hat auch einen Effekt. Auch hier ist der Code vollständig in sich geschlossen und ich habe ihn in Chromium 25 unter Linux getestet. Ich kann es sogar noch weiter verbessern, wenn Sie kleine Bugs oder eine stärkere Verschlechterung der Grafikqualität / des Gameplays akzeptieren.

<canvas id=c><script>C=c.getContext('2d');f=C.fillRect.bind(C)
S=[-1,I=J=0];A=B=210;X=Y=1
function g(n){++S[n];N=Math.random(M=n*613+9)*471}D=document
D.onkeydown=D.onkeyup=function(e){d=!!e.type[5];k=e.keyCode
k&1?I=k&16?d:-d:J=k&4?-d:d}
g(0);setInterval(function(){A-=A<I|A>420+I?0:I
B-=B<J|B>420+J?0:J
M+=X;N+=Y
N<0|N>471?Y=-Y:0
M==622&N>B&N<B+51|M==9&N>A&N<A+51?X=-X:M>630?g(0):M||g(1)
f(0,0,c.width=640,c.height=480)
C.fillStyle='tan';C.font='4em x';C.fillText(S,280,60)
f(0,A,9,60);f(631,B,9,60);f(M,N,9,9)},6)</script>

Danke Shmiddty

aditsu
quelle
Ich verstehe den Einwand nicht. Soweit ich mich erinnern kann, die 715 - Byte - Version (edited 3 Stunden vor diesem Beitrag) ist nahezu identisch mit der ursprünglichen Version von Pong Ich hatte für meinen Atari 2600.
primo
@primo Ich gehe davon aus, dass Sie über meine implizite Behauptung sprechen, dass Ihre Lösung das Kriterium "so nah wie möglich" nicht erfüllt. Nun, das OP erwähnte nicht die Atari 2600-Version, sondern eine spezielle JavaScript-Implementierung, mit der er verbunden war. Und auf den ersten Blick gibt es zwei eklatante Unterschiede in Ihrem Code: keinen Computerspieler und keine "7-Segment" -Score-Anzeige. Es gibt wahrscheinlich viel mehr Unterschiede in der "Mechanik". Wenn diese Dinge nicht wichtig sind, sollte diese Lösung auch gültig sein.
Aditsu
Das ist mein Fehler. Ich habe wirklich "so nah wie möglich" gemeint, damit Ihre erste Lösung die beste ist, die es bisher gab.
Felipa
Sie können die entfernen c=window.c. Sie weisen sich selbst eine globale Variable zu.
Shmiddty
Sie können 1 weiteren Charakter retten, indem Sie sich ++S[n]innerhalb von.random(++S[n])
Shmiddty
5

HTML & JavaScript - 1663

Gegen mein besseres Urteil nahm ich den verrückten Ansatz, den eigentlichen Code aus der Demo zu golfen. Ich habe einige Features und Oberflächenelemente entfernt, aber im Allgemeinen funktioniert es genauso - 0, 1 oder 2, um die Anzahl der menschlichen Spieler zu bestimmen, Q / A und P / L, um sich zu bewegen.

Sofern ich keine Fehler gemacht habe, sollte das Gameplay Pixel für Pixel und Millisekunde für Millisekunde mit dem Original bei 640 * 480 identisch sein (Hinweis: Durch Ändern der Größe des Browserfensters wird die Spielgröße in der Demo geändert). Es gibt einfach keine Anweisungen, gibt den Gewinner nicht bekannt und kümmert sich nicht um esc.

Der Code ist vollständig in sich geschlossen und wurde in Chromium 25 unter Linux getestet. Firefox mag es nicht sehr.

<body bgcolor=0><canvas id=c height=480><script>R=Math.random
C=c.getContext('2d');f=C.fillRect.bind(C)
S=[l=G=I=J=K=L=0,0];r=17;u=463;o=24;q=12;z=10;s=640;v=36
function T(z,t,u,v){P=0;if(e=v*E-u*F){a=(u*t-v*z)/e;b=(E*t-F*z)/e
a<0|a>1|b<0|b>1?0:P={x:M+a*E,y:N+a*F,d:u,s:0,X:X,Y:Y}}}function
i(p,q,h){T(p-22*(E<0),q,0,h)
P?0:T(p,q-h*(F<0),22,0)}function
U(p){if(p.a)if(M<p.x&X<0|M>p.x+q&X>0)p.u=0
else{P=p.P;if(P&&P.X*X>0&P.Y*Y>0&P.s<p.l/z)P.s+=t
else{E=X*z;F=Y*z;i(M-p.x+5,s*q,s*o)
if(p.P=P){y=P.y;while(y<r|y>u)y=y<r?34-y:y>u?u+u-y:y
P.y=y+R(e=(p.l+2)*(X<0?M-p.x-q:p.x-M)/64)*2*e-e}}P?p.u=P.y<p.y+25?1:P.y>p.y+35?-1:0:0}y=p.y-p.u*t*198
p.y=y<q?q:y>408?408:y}function
W(n,x){a=9.6;b=[~8,3,62,31,75,93,~2,7,-1,u][n]
b&4&&f(x,o,v,a);b&64&&f(x,o,a,o)
b&2&&f(x+v,o,-a,o);b&8&&f(x,43.2,v,a)
b&32&&f(x,48,a,o);b&1&&f(x+v,48,-a,o)
b&16&&f(x,72,v,-a)}A={u:0,x:0,y:210};B={u:0,x:628,y:210}
function g(n){if(++S[n]>8)G=A.a=B.a=0
else{N=R(M=n?635:5)*446+r;Y=157.5;X=n?-Y:Y
A.l=z+S[0]-S[1];B.l=20-A.l}}D=document
D.onkeydown=D.onkeyup=function(e){d=!!e.type[5]
k=e.keyCode-45;if(k>2&k<6&d&!G){G=S=[-1,0];A.a=k<4;B.a=k<5
g(0)}k^31?k^35?k^20?k^v?0:I=d:J=d:K=d:L=d
A.a?0:A.u=I-J;B.a?0:B.u=K-L}
setInterval(function(){t=new Date()/1000-l;l+=t;U(A);U(B)
if(G){E=t*X+4*t*t;F=t*Y+4*t*t
x=M+E;y=N+F;m=X+t*(X>0?8:-8);n=Y+t*(Y>0?8:-8)
if(n>0&y>u){y=u;n=-n}if(n<0&y<r){y=r;n=-n}p=m<0?A:B
i(M-p.x+5,N-p.y+5,70)
if(P){if(P.d){y=P.y;n=-n}else{x=P.x;m=-m}n*=n*p.u<0?.5:p.u?1.5:1}M=x;N=y
X=m;Y=n;M>645?g(0):M<-5&&g(1)}c.width=s;C.fillStyle='#fff'
f(0,0,s,q);f(0,468,s,q);for(j=o;j--;)f(314,6+o*j,q,q)
W(S[0],266.5);W(S[1],338.5)
f(0,A.y,q,60);f(s,B.y,-q,60);G&&f(M-5,N-5,z,z)},50/3)</script>

Einige Credits an Shmiddty für Verbesserungen

aditsu
quelle
4

Verarbeitung, 487 Zeichen

int a=320,b=240,c=2,d=2,e=0,f=0,g=0,h=0,i=15,j=80,k=640,
l=160,m;void setup(){size(k,b*2);}void draw(){background
(0);if(keyPressed){if(key=='q'&&g>0)g-=i;if(key=='a'&&g<
j*5)g+=i;if(key=='o'&&h>0)h-=i;if(key=='l'&&h<j*5)h+=i;}
rect(0,g,i,j);for(m=0;m<k;m+=30)rect(312,m,i,i);rect(a,b
,i,i);rect(625,h,i,j);a+=c;b+=d;c*=a<i&&(b>g&&b+i<g+j)||
a>610&&(b>h&&b+i<h+j)?-1:1;d*=b<0||b>=465?-1:1;if(a<0){f
++;a=0;b=240;c=2;}if(a>k){e++;a=625;b=240;c=-2;}textSize
(j);text(e,l,j);text(f,3*l,j);}

Beispielbild:

Bildbeschreibung hier eingeben

Dieser Code wurde mit Rücksicht auf die Kürze erstellt, daher ist er ziemlich fehlerhaft (der Ball geht manchmal durch das Paddel oder wickelt sich darum herum). Die Kontrollen sind Q / A für Spieler 1 und O / L für Spieler 2.

segfaultd
quelle
1
Als ein Spiel scheint Ihre Pong-Version auch ziemlich unfair zu sein, da nur die Schlüssel eines Spielers pro Frame registriert sind: P
Jonathan Frech
2

C # - 1283 Zeichen

Hier kann man noch ein bisschen mehr Golf spielen, aber hier ist es.

using System;using System.Drawing;using System.Runtime.InteropServices;using System.Windows.Forms;using r=System.Drawing.RectangleF;namespace f{public partial class f:Form{public f(){InitializeComponent();}private void f_Load(object sender,EventArgs e){var t=this;var s=new r(0,0,300,300);var q=new r(0,0,15,50);var o=new r(0,0,15,50);var x=new PointF(150,150);var v=.06F;var h=v;var b=new r(x.X,x.Y,15,15);var p1=0;var p2=0;var p=new PictureBox{Size=t.Size,Location=new Point(0,0)};t.Controls.Add(p);p.Paint+=(wh,n)=>{var g=n.Graphics;Action<Brush,r>f=g.FillRectangle;var k=new SolidBrush(Color.Black);var w=new SolidBrush(Color.White);var d=new byte[256];GetKeyboardState(d);var l=q.Location;var _1=.1F;q.Location=new PointF(0,d[90]>1?l.Y+_1:d[81]>1?l.Y-_1:l.Y);l=o.Location;o.Location=new PointF(269,d[77]>1?l.Y+_1:d[79]>1?l.Y-_1:l.Y);f(k,s);f(w,q);f(w,o);Func<r,bool>i=b.IntersectsWith;h=i(q)||i(o)?-h:h;v=b.Top<1||b.Bottom>t.Height-30?-v:v;b.Offset(h,v);if(b.Left<0){p2++;b.Location=x;}if(b.Right>290){p1++;b.Location=x;}f(w,b);for(int j=0;j<19;)f(w,new r(140,(j+(j++%2))*15,10,10));var a=new Font("Arial",20);g.DrawString(p1.ToString(),a,w,100,12);g.DrawString(p2.ToString(),a,w,170,12);p.Invalidate();};}[DllImport("user32.dll")]static extern bool GetKeyboardState(byte[]s);}}

Edit: Die Anforderung für eine kostenlose, unter Linux lauffähige Sprache wurde nicht erkannt ...

Brandon
quelle
2

Tcl / Tk , 932 Bytes

Muss in der interaktiven Shell ausgeführt werden

gri [can .c -w 1024 -he 768 -bg #000]
proc A {} {set ::v [expr (int(rand()*36)+1)*20]}
proc R {C t\ X} {.c cr r $C -f #aaa -t $t}
proc I {} {incr ::v 20}
time {R "504 [I] 520 [I]"} 18
R "0 0 1024 20"
R "0 748 1024 768"
R "0 340 20 440" b
R "1004 340 1024 440" B
R "40 [A] 60 [I]" P
lmap n 4\ 5 T F\ S {.c cr t ${n}62 60 -ta $T -te 0 -fi #aaa -font {"" 56}}
proc C t\ n {lindex [.c coo $t] $n}
lmap {a b c d e} {q b 1 >20 -20 a b 3 <740 20 p B 1 >20 -20 l B 3 <740 20} {bind . $a "if \[C $b $c]$d {.c move $b 0 $e}"}
lassign {0 0 20 20} F S y x
proc M {} {lmap {_ a b c d e f} {0 <40 b 20 S 960 980 2 >984 B -20 F 80 100} {if [C P $_]$a {if [C P 1]>=[C $b 1]&&[C P 3]<=[C $b 3] {bell
set ::x $c} {.c itemco $d -te [incr ::$d]
if \$::$d>8 {tk_messageBox -message WINNER!
lmap T F\ S {.c itemco $T -te [set ::$T 0]}}
.c coo P $e [A] $f [I]}}}
.c move P $::x [set ::y [expr [C P 1]<40?20:[C P 3]>727?-20:$::y]]
after 99 M}
M
focus -f .

Hinweis:

 #There is an Enter at the end

Nur eine sehr minimale Version von Pong, bei der der Ball nur in diagonalen Winkeln läuft und immer die gleiche Geschwindigkeit hat.

Bildbeschreibung hier eingeben

Sergiol
quelle
Outgolf fehlgeschlagen: bit.ly/2VSIGz8
Sergiol