404: HOME NOT FOUND

Michalis
/
404: HOME NOT FOUND
on 10 Nov 2026
1
9
2
0
9994
game.m
function g = game()
% 404: HOME NOT FOUND - one-button runner with a flipping world
%
% World is 800x600, y grows downward. Fixed numbers used throughout:
%   floor y = 450          platform top y = 378 (72 above the floor)
%   player  x = 150..184   player is 34 tall, s.y is its top edge
% State fields (short names keep the file inside the character cap):
%   y vy     player top / vertical speed      buf  jump-tap buffer
%   air      time since last standing         v d  scroll speed / distance
%   t inv    inversion clock / world currently flipped
%   ox ow oh oy ok  obstacles: x, width, height, bottom y, kind
%   chunk kinds: 1 spikes  2 low block  3 bridge  4 floater (stay low)
%                5 tall barrier  6 stepping stones  7 tower
%   qx qw    platforms     gx gw  voids in the floor     bx by  pickups
%   nx n     next chunk position / chunk counter
g.init = @initState;
g.update = @updateState;
g.render = @renderFrame;
end

function s = initState(ax)
s.ax = ax;
s.W = [36 66 0 40 24 0]; s.H = [34 22 0 30 64 0];
% player quads, one per column: body, leg, leg, antenna
s.py = [0 24 24 -9; 24 34 34 0; 24 34 34 0; 0 24 24 -9];
% scrolling ground marks
s.dp = [40 150 230 380 470 610 700 840];
% colours: navy background, red hazards, amber pickups
s.cb = [.05 .08 .2];
s.best = 0; s.bt = Inf;      % best distance, fastest winning time
% The data centre stands 45000 px away, shown as 5000 m (9 px = 1 m).
% hx/hy: stepped silhouette; lx/ly: lit doorway plus 12 server lights
s.hx = [0;0;40;40;220;220;260;260];
c = repmat([30 85 140 195],1,3); r = repelem([110 150 190],4);
s.lx = [20+[0;0;44;44] c+[0;0;30;30]];
s = resetRound(s);
s.on = false;
s.big = 'PULSE: LAST SIGNAL';
s.sub = 'TAP TO JUMP  /  RIDE PLATFORMS  /  RUN UNDER FLOATERS';

ax.XLim = [0 800]; ax.YLim = [0 600];
ax.YDir = 'reverse'; ax.Color = s.cb;

% ---- graphics: 19 objects, created once, only mutated afterwards ----
P = {'HitTest','off','PickableParts','none'};
w = [1 1 1]; k = s.cb;
N = {'Color',w,P{:}};
F = {'Parent',ax,'EdgeColor','none',P{:},'FaceColor'};
z = zeros(4,6);
% CRT look, part 1: scanlines behind everything, slightly darker than
% the background (opaque, so no transparency cost)
y = 3:6:597; y = [y;y;y];
s.scan = line(ax,repmat([-99;899;NaN],100,1),y(:),'Color',s.cb*.7,P{:});
s.gnd = line(ax,[-99 899],[450 450],'LineWidth',2,N{:});
dy = [458 464 456 462 459 465 457 461];
s.dash = line(ax,zeros(1,24),reshape([dy;dy;dy],1,[]),N{:});
% voids are background-coloured covers over the ground line
s.dc = patch('XData',s.hx-999,'YData',450-[0;200;200;240;240;200;200;0],F{:},[.45 .45 .52]);
s.dl = patch('XData',s.lx-999,'YData',450-[[0;70;70;0] r+[0;12;12;0]], ...
    F{:},[1 .6 0]);
s.gap = patch('XData',z,'YData',z+[447;490;490;447],F{:},k);
s.plat = patch('XData',z,'YData',z+[378;386;386;378],F{:},w);
s.obs = patch('XData',zeros(5,6),'YData',zeros(5,6),F{:},[.9 .15 .15]);
% pickups: blocky pixel-art coins, 12 vertices each
s.bit = patch('XData',zeros(12,12),'YData',zeros(12,12),F{:},[1 .6 0]);
s.pl = patch('XData',150+[0 5 21 15; 0 5 21 15; 34 13 29 19; 34 13 29 19], ...
    'YData',416+s.py,F{:},w);
s.eye = patch('XData',[170;170;179;179],'YData',[423;429;429;423],F{:},k);
s.bar = line(ax,[NaN NaN],[0 0],'LineWidth',3,N{:});
% CRT look, part 2: a thick rounded bezel drawn along the screen edge,
% on top of the game; it is symmetric, so the flip leaves it alone
a = ((0:32)+.5)*pi/16;
line(ax,400+360*sign(cos(a))+40*cos(a),300+260*sign(sin(a))+40*sin(a), ...
    'Color',[.3 .3 .33],'LineWidth',30,P{:});
% text lives in normalized units so the flip never moves it
% (Units is set before Position, as the documentation requires)
T = {'Units','normalized','FontName','FixedWidth','FontWeight','bold', ...
    'HorizontalAlignment','center',N{:}};
s.tb = text(ax,0,0,s.big,T{:},'FontSize',30,'Position',[.5 .53]);
s.ts = text(ax,0,0,s.sub,T{:},'FontSize',12,'Position',[.5 .46]);
s.tst = text(ax,0,0,'',T{:},'FontSize',12,'Position',[.5 .87]);
% score and best top left, live coin counter (amber) top right
% the sign on the building lives in world units so it travels with it
s.sg = text(ax,-999,230,'DATA CENTER','FontSize',12,T{3:end},'Color',[1 .6 0]);
s.th = text(ax,0,0,s.hud,T{:},'FontSize',13,'Position',[.06 .94], ...
    'HorizontalAlignment','left');
s.tc = text(ax,0,0,s.cs,T{:},'FontSize',13,'Position',[.94 .94], ...
    'HorizontalAlignment','right','Color',[1 .6 0]);
end

function s = updateState(s,dt,pressed)
% Game over: shake and a short lockout before the restart tap.
if s.dead
    s.dd = s.dd+dt;
    s.sx = 16*(rand-.5)*(s.dd < .3)*~s.win;
    if pressed && s.dd > .4
        s = resetRound(s);
    end
    return
end
if ~s.on
    if ~pressed
        return
    end
    s.on = true; s.big = ''; s.sub = ''; s.cs = 'COINS 0';
end

% ---- inversion clock, 11 s cycle: the world flips instantly ----
s.t = s.t+dt;
ph = mod(s.t,11);
s.inv = ph >= 6.5;
s.stat = ''; s.bl = NaN;
if s.inv
    s.stat = 'WORLD INVERTED  /  x2'; s.bl = (11-ph)*27;
elseif ph >= 5
    s.stat = 'INVERSION INCOMING'; s.bl = (6.5-ph)*80;
end

% ---- jump: buffered tap, only when standing (0.08 s edge grace) ----
if pressed
    s.buf = .05;                % was .12: late air taps caused surprise jumps
end
if s.buf > 0 && s.air < .08
    s.vy = -780; s.buf = 0; s.air = 1;
end
s.buf = s.buf-dt;
f = s.y+34;                     % feet before this step
s.vy = s.vy+2400*dt;
s.y = s.y+s.vy*dt;

% ---- scroll: 2.4% faster every 250 m, about 480 px/s at the door ----
k = floor(s.m/250);
s.v = 300*1.024^k;
s.sub = '';
if k && mod(s.m,250) < 30       % announce each step for its first 30 m
    s.sub = 'SPEEDING UP';
end
dx = s.v*dt;
s.d = s.d+dx;
s.ox = s.ox-dx; s.qx = s.qx-dx; s.gx = s.gx-dx; s.bx = s.bx-dx;

% ---- support: floor unless over a void, or a one-way platform ----
gl = Inf;
if ~any(167 > s.gx & 167 < s.gx+s.gw)
    gl = 450;
end
if f <= 379 && any(178 > s.qx & 156 < s.qx+s.qw)
    gl = 378;
end
s.air = s.air+dt;
if s.vy >= 0 && f <= gl+1 && s.y+34 >= gl
    s.y = gl-34; s.vy = 0; s.air = 0;
end

% ---- spawn the next chunk; spacing is in seconds, so always fair ----
if s.nx-s.d < 860 && s.nx < 43500      % clear run-up to the data centre
    x = s.nx-s.d; v = s.v;
    s.n = s.n+1;
    j = randi(min(7,1+floor(s.n/2)));
    q = [-999 -999 0 0]; g = [-999 0]; o = j; xo = x;
    if j == 6
        % stepping stones: hop between two platforms over a void
        L = 2.2*v; xo = -999;
        q = [x x+1.4*v 1.1*v .8*v]; g = [x+.6*v 1.4*v];
        b = x+v*[1.25 1.7 1.95]; h = [261 361 361];
    elseif j == 3 || j == 7
        % bridge: one platform across a void
        G = v*(.45+.35*rand); L = .8*v+G+20;
        q = [x -999 L 0]; g = [x+.8*v G]; xo = -999;
        b = x+.8*v+G*[.2 .5 .8]; h = 361;
        if j == 7
            % tower: same platform, no void, held up by a tall barrier
            g = [-999 0]; o = 5; xo = x+L/2;
        end
    else
        % single obstacle with a bit: at jump height, or under a floater
        L = s.W(j);
        b = x+L/2-[2e3*(rand < .5) 2e3 2e3]; h = 315+118*(j == 4);
    end
    k = mod(s.n,6)+1;
    s.ok(k) = o; s.ow(k) = s.W(o); s.oh(k) = s.H(o);
    s.ox(k) = xo; s.oy(k) = 450-52*(o == 4);
    k = mod(2*s.n,6)+[1 2];
    s.qx(k) = q(1:2); s.qw(k) = q(3:4);
    k = mod(s.n,3)+1;
    s.gx(k) = g(1); s.gw(k) = g(2);
    k = mod(3*s.n,12)+(1:3);
    s.bx(k) = b; s.by(k) = h;
    s.nx = s.nx+L+v*(max(1,1.3-s.d/4e4)+.6*rand);
end

% ---- collect bits (worth double while the world is inverted) ----
h = abs(s.bx-167) < 22 & abs(s.by-s.y-17) < 24;
if any(h)
    s.bits = s.bits+sum(h)*(1+s.inv); s.bx(h) = -999;
    s.cs = sprintf('COINS %d',s.bits);
end

% ---- score: text only changes when the number does ----
m = 5*floor(s.d/45);            % metres, shown in steps of 5
if m ~= s.m
    s.m = m;
    s.hud = sprintf('%04d / 5000 m   BEST %04d m',m,max(m,s.best));
end

% ---- death: fell into a void, or touched an obstacle ----
% Floaters hang at head height: run under them, do not jump.
q = 4+4*(s.ok == 1);
if s.y > 436 || any(180 > s.ox+q & 154 < s.ox+s.ow-q & ...
        s.y+34 > s.oy-s.oh+q & s.y < s.oy-q)
    s.dead = true; s.dd = 0;
    s.big = 'SIGNAL LOST';
    s.sub = sprintf('%d m  +  %d COINS  /  TAP TO RETRY',m,s.bits);
    s.best = max(m,s.best);
end

% ---- the end point: walk in through the data centre door ----
if ~s.dead && s.d > 45059
    s.dead = true; s.win = true; s.dd = 0;
    s.y = NaN;                  % inside: the player is no longer drawn
    s.best = 5000; s.bt = min(s.bt,s.t);
    s.big = 'AI IS BACK HOME';
    s.sub = sprintf('%.0f s  /  FASTEST %.0f s  /  %d COINS  /  TAP',s.t,s.bt,s.bits);
end
end

function renderFrame(~,s)
ax = s.ax;
% Colours and direction are only touched on the frame the world turns.
% Hazards stay red and pickups amber in both states.
fg = [1 1 1]-s.inv;
bg = abs(s.inv-s.cb);
if ~isequal(ax.Color,bg)
    ax.Color = bg;
    if s.inv
        ax.YDir = 'normal';
    else
        ax.YDir = 'reverse';
    end
    set([s.gnd s.dash s.bar s.tb s.ts s.tst s.th],'Color',fg);
    set([s.plat s.pl],'FaceColor',fg);
    set([s.gap s.eye],'FaceColor',bg);
    s.scan.Color = bg*.7+.2*s.inv;
end
L = [0 800]+s.sx;
if ~isequal(ax.XLim,L)
    ax.XLim = L;
end

% Player: legs tuck in the air and alternate while running.
Y = s.y+s.py;
if s.air > 0
    Y(2:3,2:3) = Y(2:3,2:3)-5;
elseif s.on && s.dead == s.win
    k = 2+mod(floor(s.d/22),2);
    Y(2:3,k) = Y(2:3,k)-6;
end
s.pl.YData = Y;
s.eye.YData = s.y+[7;13;13;7]+[2;-2;-2;2]*(s.dead-s.win);

% Pooled shapes: unused ones sit far off-screen. Heights only change
% when a chunk spawns, so they are sent to the renderer only then.
e = [0;0;1;1];
t = s.ok == 1;
s.obs.XData = s.ox+s.ow.*([0;0;1;1;1].*~t+[0;.5;.5;.5;1].*t);
s.plat.XData = s.qx+s.qw.*e;
s.gap.XData = s.gx+s.gw.*e;
% Data centre: parked off-screen until near, moved only when it changes.
% Grey walls and amber lights read on both background colours.
x = min(45184-s.d,900);
if s.dc.XData(1) ~= x
    s.dc.XData = s.hx+x;
    s.dl.XData = s.lx+x;
    s.sg.Position = [x+130 230];
end
s.bit.XData = s.bx+4*[-2;2;2;3;3;2;2;-2;-2;-3;-3;-2]*cos(s.d/40);   % spin
if ~isequal(s.obs.UserData,s.n)
    s.obs.UserData = s.n;
    s.obs.YData = s.oy-s.oh.*([0;1;1;0;0].*~t+[0;1;1;1;0].*t);
    s.bit.YData = s.by+4*[-3;-3;-2;-2;2;2;3;3;2;2;-2;-2];
end

% Ground marks wrap off-screen so they never pop.
x = mod(s.dp-s.d,900)-50;
s.dash.XData = reshape([x;x+6+mod(s.dp,17);x+NaN],1,[]);

% Countdown bar: only touched while it is showing or being cleared.
x = 400+[-1 1]*s.bl;
if ~isequaln(s.bar.XData,x)
    set(s.bar,'XData',x,'YData',[1 1]*(100+400*s.inv));
end

setStr(s.tb,s.big); setStr(s.ts,s.sub);
setStr(s.tst,s.stat); setStr(s.th,s.hud); setStr(s.tc,s.cs);
end

function setStr(h,str)
% Text is the most expensive thing to redraw; skip unchanged strings.
if ~strcmp(h.String,str)
    h.String = str;
end
end

function s = resetRound(s)
% Numeric state only; graphics handles and best score are preserved.
z = zeros(1,6);
s.y = 416; s.vy = 0; s.buf = 0; s.air = 0;
s.v = 300; s.d = 0; s.t = 0;
s.inv = false; s.bl = NaN; s.stat = '';
s.on = true; s.dead = false; s.win = false; s.dd = 0; s.sx = 0;
s.nx = 900; s.n = 0; s.bits = 0;
s.ox = z-999; s.ow = z; s.oh = z; s.ok = z; s.oy = z;
s.qx = z-999; s.qw = z;
s.gx = z-999; s.gw = z;
s.bx = zeros(1,12)-999; s.by = s.bx;
s.m = 0; s.hud = sprintf('%04d / 5000 m   BEST %04d m',0,s.best);
s.big = ''; s.sub = ''; s.cs = 'COINS 0';
end
Play Game
Preview

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