KOI - MATLAB One-Button Game Mini Hack

Leonard
/
KOI
on 5 Nov 2026
10
58
24
5
9934
game.m
function g = game()
% KOI - one tap flips the turning direction. Collect lotus blossoms, avoid the
% rim and the stone.  (Ein Tap kehrt den Drehsinn um.)
%
% Aufbau des Codes:
%   i -> legt ALLES an: Wasser-Raster, Deko, Objekte, State-Felder
%   u -> reine Physik/Spiellogik pro Frame (h-skaliert), keine Grafik
%   r -> schreibt nur State-Werte in vorhandene Grafik-Handles
%   W -> erzeugt das Wasser-Raster (Caustics/Ripples/Gold) neu
%   z/blo/rp -> Rundenreset, Blueten-Spawn, Ripple-Pool
%   Q/G -> Hilfsfunktionen (Smoothstep, deterministlicher Zufall)
%
% Grafik: 160x120-Wasserraster mit Caustics, Koi aus Wirbelsaeulen-Kette
% (Zeichnung, Augen, Brust-+Schwanzflossen, Schatten), pulsierende Lotus-
% Zielbluete mit Glow, Ufersteine, statischer Fels unten rechts, Goldring am
% Rand (voll bei Score 5) mit Funkregen (ab 10, quadratisch bis Score 40),
% Combo-HUD bis x3, Attract-Modus mit Autopilot, Rang-Meldung bei Game-Over.
% Kommentare zaehlen in den Contest-Chars NICHT. Alle frueheren Fassungen
% liegen als game_snap_*.m nebenan.
g.init = @i; g.update = @u; g.render = @r;
end

function s = i(ax)
% Weltkoordinaten: 800x600, y zeigt nach UNTEN (YDir reverse).
ax.XLim=[0 800]; ax.YLim=[0 600]; ax.YDir='reverse'; ax.Color=[.055 .086 .102];
% Standard-Option fuer ALLE Grafiken: nicht anklickbar (one-button-Vertrag).
N=14;               % N = Wirbelsaeulen-Punkte
e={'EdgeColor','none'}; l={'LineStyle','none'}; c={'HorizontalAlignment','center'}; fb={'FontWeight','bold'}; gc=[1 .8 .3];

% --- Wasser-Hintergrund: stehendes 200x150 RGB-Raster, 4x hochskaliert --------
[X,Y]=meshgrid(((1:160)-.5)*5,((1:120)-.5)*5);  % 160x120 Raster, 5x hochskaliert
U=hypot(X-400,Y-300)/270;                % normierter Abstand (1 = Rand)
q=min(U,1);                              % Radialverlauf
f=(1-Q(.88,1,U)*.55);                    % Vignette
nz=mod(sin(X.*.7+Y.*1.3)*43758.5,1);              % Stein-Sprenkel-Hash
rm=Q(.985,1.02,U);                       % Stein-Uferring
% r3() biegt 1x3-Farbvektoren auf 1x1x3 -> Broadcasting statt cat(3,...)
s.B=(1-q).*f.*(1-rm).*r3([.051 .278 .341])+q.*f.*(1-rm).*r3([.02 .122 .169])+rm.*(nz.*r3([.063 .055 .055])+r3([.055 .086 .106]));
s.X=X; s.Y=Y; s.U=U;                      % Raster-Koordinaten fuer W()
s.M=1-Q(.96,1,U);                        % Maske: Caustics enden am Rand
s.K=(1-U).*s.M;                          % Caustics-Staerke
s.im=image(ax,[2 798],[2 598],s.B); % Bildhandle; CData wird pro Frame ersetzt

% --- Seerosenblaetter (statische Deko, 3 Stueck, Dreiecks-Faecher mit Kerbe) --
P=[205 135 38 .4;585 150 30 3.6;215 455 34 5]; V=[];
for k=1:3
  th=P(k,4)+linspace(0,2*pi-.45,32)'; V=[V; P(k,1:2); P(k,1:2)+P(k,3)*[cos(th) sin(th)]];
end
patch(ax,'Vertices',V,'Faces',reshape(1:99,33,3)','FaceColor',[.12 .45 .3],'EdgeColor',[.06 .3 .2]);

% --- Lotus-Geometrie: 3 Ebenen x 8 Blaetter (nutzt nur noch die Ziel-Bluete) --
rr=[18 13 8]; ro=[0 .4 .2]; cc=[1 .47 .63;1 .59 .73;1 .76 .84]; p=linspace(0,2*pi,12)'; fl=[];
for v=1:3
  for j=1:8
    a=(j-1)*pi/4+ro(v); fl=[fl; [rr(v)*.28*cos(p) rr(v)*.55*(sin(p)-1)]*[cos(a) sin(a);-sin(a) cos(a)]];
  end
end
LF=reshape(1:288,12,24)'; FC=repelem(cc,8,1);
s.fl=fl;

% --- Uferstein unten rechts: statischer Fels, fester Kreis-Kollider R=33.
% bluete() haelt 80px Sicherheitsabstand, der Fisch muss nie durch ihn durch. ---
th=(0:15)'/8*pi; patch(ax,'Vertices',26*(1+.15*sin(3*th+1)+.08*sin(5*th)).*[cos(th) sin(th)]+[545 435],'Faces',1:16,'FaceColor',[.2 .24 .28],'EdgeColor',[.32 .38 .42]);

% --- Koi: Wirbelsaeulen-Breite, Schatten, Koerper, Schwanz+Brustflossen -------
t=(0:N-1)'/(N-1); s.tt=t; s.w=max(1.2,10.5*sin(pi*min(1,.22+.78*t)).^.7.*(1-.5*t));
vc=[1 .55 .3]+(t>.15&t<.55)*[0 .40 .58];        % Koi-Zeichnung: orange mit weissem Mittelband
s.fn=patch(ax,'Vertices',zeros(15,2),'Faces',[9:15 NaN(1,2);1 3 5 7 NaN(1,5);2 4 6 8 NaN(1,5)],'FaceColor',[1 .69 .42],'FaceAlpha',.7,e{:});
s.sh=patch(ax,'Vertices',zeros(2*N,2),'Faces',1:2*N,'FaceColor','k','FaceAlpha',.28,'EdgeColor','none');  % Fisch-Schatten
s.bd=patch(ax,'Vertices',zeros(2*N,2),'Faces',[(1:N-1)' (2:N)' N+(2:N)' N+(1:N-1)'],'FaceVertexCData',[vc;vc],'FaceColor','interp',e{:});
s.hh=line(ax,0,0,l{:},'Marker','o','MarkerSize',12,'MarkerFaceColor',[.98 .95 .9],'MarkerEdgeColor',[.98 .95 .9]);
s.ey=line(ax,[0 0],[0 0],l{:},'Marker','.','MarkerSize',8,'Color',[.08 .08 .11]);
% Ziel-Bluete (atmet im Render):
s.bp=patch(ax,'Vertices',fl,'Faces',LF,'FaceVertexCData',FC,'FaceColor','flat',e{:});

% --- Gold-Glimmer: 44 feste Nadelstiche auf dem Uferring, Vektor-Scatter ueber
% dem Raster (8x-Pixel waeren zu grob). fester Winkel/Phase; blinkt ab Score 10.
a=rand(1,44)*2*pi; s.gx=400+270*cos(a); s.gy=300+270*sin(a);
s.gp=rand(1,44)*2*pi; s.gw=.5+rand(1,44);
s.gm=scatter(ax,s.gx,s.gy,1,[1 .85 .5],'filled','MarkerEdgeColor','none');

% --- Titel (filigran, mit Glow-Kopie) + Untertitel + HUD + Game-Over-Kasten ----
t78={'FontSize',78,'FontName','Segoe UI Light','HorizontalAlignment','center'};
s.ti=text(ax,403,111,'K O I','Color',[.2 .45 .43],t78{:});
s.ti=[s.ti text(ax,400,108,'K O I','Color',[.95 .99 .98],t78{:})];
s.tb=text(ax,400,178,'t a p   t o   t u r n','Color',gc,'FontSize',14,c{:});
s.hd=text(ax,400,26,'','Color',gc,'FontSize',16,fb{:},c{:});
s.ms=text(ax,400,300,'','Color',gc,'FontSize',16,fb{:},c{:},'Visible','off');

set(get(ax,'Children'),'HitTest','off','PickableParts','none'); s.t=0; s.st=0; s.best=0; s.sd=12345; s=z(s);
end

function s = u(s,h,b)
% EIN Tap: Attract->Start | Spiel->Drehsinn umkehren (+Carve-Boost) | Over->Neustart
s.t=s.t+h;
if b
  if s.st==0, s.st=1;
  elseif s.st==1, s.dir=-s.dir; s.bo=.22;
  elseif s.ot>.6, s=z(s); s.st=1; return
  end
end
if s.st==2, s.ot=s.ot+h; s.v=s.v*exp(-2.5*h); end   % nach Tod: Fisch gleitet aus
s.bo=max(0,s.bo-h);                                 % Boost klingt linear ab

% --- Attract: Autopilot "tippt" alle 0.5s Richtung Bluete (bzw. Zentrum) -------
if s.st==0
  s.pt=s.pt-h;
  if s.pt<=0
    s.pt=.5; p=s.S(1,:); d=[s.bx s.by]-p;
    if hypot(p(1)-400,p(2)-300)>185, d=[400 300]-p; end
    s.dir=1-2*(cos(s.a)*d(2)-sin(s.a)*d(1)<0);
  end
end

% --- Bewegung: Kursrate-Easing (Ziel dir*v/72), Vorwaertsintegration -----------
s.av=s.av+(s.dir*s.v/72*(1+4*s.bo)-s.av)*min(1,16*h);
s.a=s.a+s.av*h;
s.S(1,:)=s.S(1,:)+s.v*h*[cos(s.a) sin(s.a)];
% Wirbelsaeulen-Kette: jeder Punkt folgt dem vorigen auf 6.4 px:
for i=2:14
  d=s.S(i,:)-s.S(i-1,:); s.S(i,:)=s.S(i-1,:)+d/max(hypot(d(1),d(2)),1e-6)*6.4;
end
s.ph=s.ph+h*(2+s.v/20);                             % Schwimmphase (Undulation)
s.rp(:,3)=s.rp(:,3)+h; p=s.S(1,:);                  % Ripple-Alterung

% --- Ziel-Bluete einsammeln (28 px) --------------------------------------------
if s.st<2 && hypot(p(1)-s.bx,p(2)-s.by)<28
  s=rp(s,s.bx,s.by,0,1.1);                            % Pfluecks-Ripple
  if s.st==1                                        % Score nur im echten Spiel
    s.mu=(s.t-s.tl<4)*min(s.mu+1,3)+(s.t-s.tl>=4); s.tl=s.t;   % Combo bis x3
    s.sc=s.sc+s.mu; s.n=s.n+1; s.v=min(120+4*s.n,190);
  end
  s=blo(s);
end

% --- Tod: Uferring oder Felskontakt (Fels bei (545,435), R=33) ------------------
dd=hypot(p(1)-400,p(2)-300);
if s.st==1 && (dd>256 || hypot(p(1)-545,p(2)-435)<29)
  s.st=2; s.ot=0; s.best=max(s.best,s.sc); s=rp(s,p(1),p(2),0,.9);
end
end

function r(~,s)
% Nur Property-Writes auf vorhandene Handles. Keine neuen Objekte.
t=s.t; N=14; S=s.S; s.im.CData=W(s);
% Tangente/Normale je Wirbel, wellende Mittellinie Ct, linker/rechter Rand:
Tg=S([1 1:N-1],:)-S([2:N N],:); Tg=Tg./max(hypot(Tg(:,1),Tg(:,2)),1e-6); Nm=[-Tg(:,2) Tg(:,1)];
Ct=S+Nm.*(sin(s.ph-(0:N-1)'*.55).*(.6+5.5*s.tt)); Wd=Nm.*s.w;
s.bd.Vertices=[Ct+Wd;Ct-Wd]; s.sh.Vertices=[Ct+Wd;flipud(Ct-Wd)]+[9 12];  % Schatten = selbe Silhouette, versetzt
% Schwanzfaecher: 7 Punkte entlang Heckrichtung, seitlich mit sw pendelnd:
d=Ct(N,:)-Ct(N-1,:); d=d/hypot(d(1),d(2)); n=[-d(2) d(1)]; sw=sin(s.ph-8)*8;
F=Ct(N,:)+[0 14 28 21 28 14 0]'*d+[2 14+sw 11+sw sw -11+sw -14+sw -2]'*n;
% Brustflossen: 2 Vierecke an Wirbel 4, senkrecht zum Koerper, schlagen mit ph.
% g=[+1;-1] rechnet beide Flossen parallel; D = Normalenabstand je Ecke (2x4):
b=Ct(6,:)-Ct(4,:); b=b/hypot(b(1),b(2)); g=[1;-1]; wd=(11+3*sin(s.ph+g)).*g;
D=[zeros(2,1) wd+2*g wd zeros(2,1)];
X=Ct(4,1)+Nm(4,1)*D+b(1)*[0 0 14 5]; Y=Ct(4,2)+Nm(4,2)*D+b(2)*[0 0 14 5];
s.fn.Vertices=[[X(:) Y(:)]; F];
s.hh.XData=Ct(1,1); s.hh.YData=Ct(1,2);
E=Ct(2,:)+[1;-1]*Nm(2,:)*s.w(2)*.7; s.ey.XData=E(:,1); s.ey.YData=E(:,2);   % Augen am 2. Wirbel
% Ziel-Bluete: atmet und schaukelt:
by=s.by+2*sin(2*t); s.bp.Vertices=s.fl*(1+.05*sin(3*t))+[s.bx by];
% Gold-Glimmer: ab Score 10, Intensitaet waechst mit dem Score (gl 0..1 bei 10..40).
if s.sc>=10
  gl=min(1,(s.sc-10)/30);
  b=max(0,sin(t*(4+2.6*gl).*s.gw+s.gp)).^(5-3*gl);
  s.gm.SizeData=b*(8+700*gl.^2)+2; s.gm.Visible='on';
else, s.gm.Visible='off'; end
% HUD: Score + aktive Combo; Titel nur im Attract, Kasten nur bei Game-Over:
s.ti(1).Visible=s.st==0; s.ti(2).Visible=s.st==0; s.tb.Visible=s.st==0; h=''; if s.st, h=num2str(s.sc); if s.mu>1 && t-s.tl<4, h=[h ' x' num2str(s.mu)]; end, end
s.hd.String=h;
if s.st==2
  nm={'Quiet pond','Graceful','Pond master'};
  s.ms.String=sprintf('%s\nSCORE %d BEST %d\ntap again',nm{1+(s.sc>=10)+(s.sc>=30)},s.sc,s.best); s.ms.Visible='on';
else
  s.ms.Visible='off';
end
end

function C = W(s)
% Wasser-Raster: Caustics + Ripples + Goldring, additiv auf Hintergrund s.B.
t=s.t; X=s.X; Y=s.Y;
% Caustics: zwei gekreuzte Sinusfelder -> duenne Lichtfilamente (q^7).
q=1-abs(sin(.05*X+.03*Y+1.3*sin(.021*Y+.6*t))+sin(.04*X-.055*Y+1.3*sin(.019*X-.5*t)))/2;
c=q.^7.*s.K; l=0*c;
% Ripples: expandierende Wellenfront (Radius 125*Alter), Ring via Gauß*sin:
for k=find(s.rp(:,3)<1.7)'   % tote Slots haben Alter 9 und fallen raus
  d=hypot(X-s.rp(k,1),Y-s.rp(k,2))-125*s.rp(k,3);
  l=l+s.rp(k,4)*(1-s.rp(k,3)/1.7)*.6*exp(-d.^2/110).*(.5+.5*sin(.55*d));
end
l=l.*s.M;
% Gold auf dem Steinring (R 266..275), waechst mit Score (voll bei 5),
% ab Score 10 goldenes Nachziehen bis +30 (Funken liegen als Scatter drueber).
bd=Q(.981,1.002,s.U).*(1-Q(1.004,1.024,s.U));   % Uferbandzone (R 265..276 / 270)
ga=min(s.sc,5)/5;                                    % Attract hat sc=0 -> automatisch kein Gold
go=bd.*ga.*(.28+.22*min(1,max(0,s.sc-10)/30))*(1+.15*sin(2*t));
% Blueten-Glow: pulsierendes warmes Leuchten um das Ziel.
gl=exp(-hypot(X-s.bx,Y-s.by).^2/1300)*.5*(.75+.25*sin(3*t)).*s.M;
C=min(s.B+c.*r3([.451 .851 .8])+l.*r3([.588 .922 .922])+gl.*r3([1 .431 .647])+go.*r3([.9 .68 .22]),1);
end

function v = r3(v)
v=reshape(v,1,1,3);
end

function s = z(s)
% Neue Runde: alles bis auf best/seed zurueck. Grafik-Handles bleiben.
s.S=[250 330]-(0:13)'*6.4.*[cos(-.3) sin(-.3)];
s.a=-.3; s.av=0; s.dir=1; s.v=120; s.n=0; s.mu=1; s.tl=-9; s.pt=0; s.ph=0; s.ot=0; s.bo=0; s.sc=0;
s.rp=repmat([0 0 9 0],8,1); s=blo(s);
end

function s = blo(s)
% Neue Ziel-Bluete: 70-165 px ums Zentrum, 140 px vom Kopf entfernt.
for k=1:30
  [u,s.sd]=G(s.sd); [r,s.sd]=G(s.sd); a=6.28*u; d=70+95*r; x=400+d*cos(a); y=300+d*sin(a);
  if hypot(x-s.S(1,1),y-s.S(1,2))>140 && hypot(x-545,y-435)>80, break, end
end
s.bx=x; s.by=y;
end

function s = rp(s,x,y,a,m)
% Ripple-Pool: ueberschreibe den aeltesten Eintrag.
[~,i]=max(s.rp(:,3)); s.rp(i,:)=[x y a m];
end

function y = Q(a,b,x)
% Smoothstep 0..1 ueber [a,b] (Hermite). Fuer Vignette, Uferring, Land-Maske.
x=min(max((x-a)/(b-a),0),1); y=x.*x.*(3-2*x);
end

function [v,d] = G(d)
% Park-Miller LCG: deterministischer Zufall, Saat im State -> reproduzierbar.
d=mod(d*16807,2^31-1); v=d/(2^31-1);
end
Play Game
Preview

Play Game opens this in MATLAB Drive. Click Run this app there to play.