Event Horizon

Ahmed
/
Event Horizon
on 10 Nov 2026
7
79
25
5
9993
game.m
function g = game()
%GAME Event Horizon.
%   You orbit a black hole. Each tap fires a burn that raises your orbit, and
%   drag from the accretion disk keeps pulling you down. Deep orbits slow your
%   clock, so Earth races ahead: your score is how many years into Earth's
%   future you travel. Magnetic flares light up rings of the disk: when a ring
%   flickers, get above or below it before it fires; fly into green bands for
%   a bonus. The gauge on the left shows your height. Below r = 3 there are no
%   stable orbits, and below r = 1 nothing comes back.
%
%   The picture is real general relativity, not art. At startup every pixel's
%   light ray is traced backwards through the Schwarzschild metric, and the
%   points where it crosses the disk plane are stored. Each frame then only
%   shades those stored disk points. The ship and flares live in the disk, so
%   gravity bends them too: behind the hole the ship appears as arcs above and
%   below the shadow, and a flare ring becomes a lensed halo.
%
%   Units: Schwarzschild radius Rs = 1, so the photon sphere is r = 1.5 and
%   the innermost stable circular orbit (ISCO) is r = 3.
%
%   Structure: init traces the map and builds graphics, update runs the orbit
%   at a fixed step and never draws, and render shades the image from state.
g.init = @initState;
g.update = @updateState;
g.render = @renderFrame;
end

function s = initState(ax)
%initState - Trace the light map, then set up graphics and a parked orbit
ax.Color = 'k';
ax.Toolbar.Visible = 'off';
rng('shuffle');
s.M = traceMap(160,120);
[s.mode,s.cool,s.best,s.clk] = deal(0);
s = newRun(s);
s.G = makeGraphics(ax);
renderFrame([],s);
end

function M = traceMap(W,H)
%traceMap - Trace one light ray per pixel back from the camera
% Photons obey x'' = -1.5*h^2*x/r^5 with h = |x cross v|, which reproduces
% Schwarzschild light bending exactly in these units. Each ray records its
% first two crossings of the disk plane z = 0: the direct image and the
% lensed image that wrapped around the hole. Rays that escape pick a star.
% The camera sits 13 out and 0.2 rad above the disk, looking at the hole:
% forward is -F, right is +y and up is U.
F = [cos(.2);0;sin(.2)];
U = [-F(3);0;F(1)];
[u,v] = meshgrid(linspace(-.62,.62,W),linspace(.465,-.465,H));
N = W*H;
P = repmat(13*F,1,N);
V = -F+[0;1;0]*u(:).'+U*v(:).';
V = V./vecnorm(V);
h2 = sum(cross(P,V).^2);
[Rr,Aa] = deal(nan(2,N));
[n,st] = deal(zeros(1,N));
id = 1:N;
for k = 1:150
    % Steps shrink near the hole, where the bending is strong.
    d = min(.07*vecnorm(P),1);
    Q = P+V.*d;
    V = V-1.5*h2.*Q./vecnorm(Q).^5.*d;
    j = find(P(3,:).*Q(3,:) < 0);
    X = P(:,j)+(Q(:,j)-P(:,j)).*P(3,j)./(P(3,j)-Q(3,j));
    rx = vecnorm(X);
    m = rx < 10 & n(id(j)) < 2;
    i = id(j(m));
    n(i) = n(i)+1;
    % A ray crosses the plane at most once per step, so i has no repeats.
    q = sub2ind([2 N],n(i),i);
    Rr(q) = rx(m);
    Aa(q) = atan2(X(2,m),X(1,m));
    P = Q;
    r = vecnorm(P);
    o = r > 40;
    % A hash of the escape direction places the stars.
    D = V(:,o)./vecnorm(V(:,o));
    st(id(o)) = mod(sin(D.'*[91;37;53])*43758.5,1) > .997;
    % Traced backwards, a ray inside the photon sphere came from the hole.
    k2 = r > 1.5 & ~o;
    P = P(:,k2);
    V = V(:,k2);
    h2 = h2(k2);
    id = id(k2);
end
% Store each layer as a list of pixels with disk coordinates and shading terms.
for k = 1:2
    i = find(~isnan(Rr(k,:)));
    r = Rr(k,i).';
    a = Aa(k,i).';
    % Disk glow starts at the ISCO and fades outward. The side moving toward
    % the camera is Doppler brightened. The far layer is dimmed a little.
    e = min(1,(r-3)*2).*exp((3-r)/2.6).*min(1,9.5-r).*(1-.6*sin(a))*(1.5-.4*k);
    % Disk points are stored as complex numbers x + iy.
    L(k) = struct('i',i,'r',r,'c',r.*exp(1i*a),'e',max(e,0),'p',8*log(r)+3*a,'w',48*sqrt(.5./r.^3));
end
% The near layer of the disk hides the stars behind it.
st(L(1).i(L(1).e > .03)) = 0;
M = struct('L',L,'st',st(:));
end

function s = newRun(s)
%newRun - Park the ship on a circular orbit at r = 6, bands idle
[s.r,s.vr,s.ph,s.L] = deal(6,0,pi/2,2);
[s.t,s.acc,s.yrs,s.flash,s.burn,s.got,s.td,s.cb,s.ban] = deal(0);
[s.hull,s.lv,s.m,s.wt] = deal(3,1,1,3.5);
% Band slots 1 and 2 are flares, slot 3 is a bonus. Each has a center, a half
% width and a clock; a negative clock waits. The first bonus comes before any
% flare and sits a little lower, so the first lesson is to let yourself sink.
[s.fc,s.fw,s.ft,s.fd,s.msg,s.why] = deal([5 5 5.3],[.5 .5 .35],[-8 -11 -3],[0 0 0],'','');
end

function s = updateState(s,dt,tap)
%updateState - Menus wait for a tap; play runs the orbit at 120 Hz
s.clk = s.clk+dt;
s.cool = max(0,s.cool-dt);
s.flash = max(0,s.flash-2*dt);
s.burn = max(0,s.burn-4*dt);
if s.mode ~= 1
    if tap && s.cool == 0
        s = newRun(s);
        s.mode = 1;
    end
    return
end
if tap
    % Burn: more angular momentum, capped at the circular orbit for r = 7.5.
    s.L = min(s.L+.04,2.165);
    s.burn = 1;
end
s.acc = s.acc+dt;
while s.acc >= 1/120 && s.mode == 1
    s.acc = s.acc-1/120;
    s = step(s,1/120);
end
end

function s = step(s,h)
%step - One fixed physics step; one game second is 16 units of time
T = 16*h;
% Schwarzschild radial equation for a massive body, plus a little damping
% from the disk so orbits settle instead of ringing forever.
s.vr = s.vr+(-.5/s.r^2+s.L^2/s.r^3-1.5*s.L^2/s.r^4-.04*s.vr)*T;
s.r = min(7.5,s.r+s.vr*T);
s.ph = s.ph+s.L/s.r^2*T;
% Disk drag bleeds angular momentum, more deeply and as the run goes on.
s.L = s.L*(1-(.0006+.004/s.r)*(1+s.t/90)*T);
s.t = s.t+h;
% A circular orbit's clock runs at sqrt(1-1.5/r) of a distant clock, so
% Earth gains (1 - that) per second. One second here is ten Earth years.
% Depth combo: each 4 s spent below r = 4 adds 1 to the multiplier, up to 5.
s.cb = (s.cb+h)*(s.r < 4);
m = min(5,1+floor(s.cb/4));
if m > s.m
    s = say(s,sprintf('DEPTH COMBO  x%d',m));
end
s.m = m;
s.yrs = s.yrs+10*h*s.m*(1-sqrt(max(0,1-1.5/s.r)));
% Every 100 years starts a stage: shorter warnings, wider flares, new colors.
if s.yrs >= 100*s.lv
    s.lv = s.lv+1;
    % The stage banner shows until run time passes s.ban.
    s.ban = s.t+2.5;
    s.wt = 3.5-.3*min(5,s.lv-1);
end
% Flares warn for s.wt seconds, burn for 1.2 s, then rest; rests shrink.
% From stage 2 on, flares drift up or down while they are lit.
s.ft = s.ft+h;
s.fc = s.fc+s.fd*h.*(s.ft > 0);
in = abs(s.r-s.fc) < s.fw;
for j = 1:2
    if s.ft(j) > s.wt+1.2
        s.fc(j) = min(7,max(3.3,s.r+randn));
        s.fw(j) = .35+.4*rand+.05*s.lv;
        s.fd(j) = (s.lv > 1)*(rand-.5)*.5;
        s.ft(j) = -max(.3,3-s.t/40)*(.5+rand);
    elseif s.ft(j) > s.wt && in(j)
        s.hull = s.hull-1;
        s.flash = 1;
        s.cb = 0;
        s.ft(j) = 9;
    elseif s.ft(j) > s.wt && s.ft(j)-h <= s.wt && abs(s.r-s.fc(j)) < s.fw(j)+.3
        % Clearing a flare by under 0.3 as it fires is a close call.
        s = say(s,'CLOSE CALL  +5 YEARS');
        s.yrs = s.yrs+5;
    end
end
% A bonus band lasts 5 s, 1 to 2 units above or below you. Reaching it
% repairs the hull and adds 15 years.
if s.ft(3) > 5
    s.fc(3) = min(7,max(3.2,s.r+(1+rand)*sign(randn)));
    s.ft(3) = -4-4*rand;
elseif s.ft(3) >= 0 && in(3)
    s.yrs = s.yrs+15;
    s.hull = min(3,s.hull+1);
    s = say(s,'+15 YEARS  HULL REPAIRED');
    s.ft(3) = 5;
end
if s.hull < 1
    s = over(s,'BURNED BY A FLARE');
elseif s.r < 1.02
    s = over(s,'LOST BEYOND THE EVENT HORIZON');
end
end

function s = say(s,msg)
%say - Flash a message until run time passes s.got, 1.5 s from now
s.msg = msg;
s.got = s.t+1.5;
end

function s = over(s,why)
%over - End the run and keep the best score
s.mode = 2;
s.why = why;
s.best = max(s.best,s.yrs);
s.cool = 1;
s.td = s.clk;
end

function G = makeGraphics(ax)
%makeGraphics - Create every graphics object once
gold = [1 .8 .25];
cy = [.3 .95 1];
G.im = image(ax,[0 800],[600 0],zeros(120,160,3,'uint8'));
f = {'Color',gold,'FontWeight','bold','FontName','Consolas','HorizontalAlignment','center'};
% Height gauge: r = 1 at y = 100, and 60 pixels per unit of r up to 7.5.
patch(ax,[20 80 80 20],[100 100 490 490],'k','FaceAlpha',.6,'EdgeColor',gold*.5);
G.band = patch(ax,repmat([20;80;80;20],1,3),zeros(4,3),'w','FaceVertexCData',zeros(3,3),'FaceColor','flat','EdgeColor','none');
% Dotted lines: the ISCO at r = 3 and the combo line at r = 4.
plot(ax,[20 80 nan 20 80],[220 220 nan 280 280],':','Color',gold);
text(ax,[103 108 50 50],[220 280 88 502],{'ISCO','COMBO','HORIZON','HEIGHT'},f{:},'FontSize',10);
G.gs = plot(ax,[10 90],[0 0],'Color',cy,'LineWidth',4);
% Marker on the ship's brightest image in the main view.
G.you = plot(ax,nan,nan,'o','MarkerSize',24,'Color',cy);
G.yt = text(ax,0,0,'YOU',f{:},'FontSize',10,'Color',cy);
f{8} = 'left';
G.score = text(ax,20,565,'',f{:},'FontSize',20);
G.info = text(ax,20,530,'',f{:},'FontSize',12,'Color',gold*.8);
f{8} = 'right';
G.hull = text(ax,780,565,'',f{:},'FontSize',16);
f{8} = 'center';
G.big = text(ax,420,540,'',f{:},'FontSize',32);
G.sub = text(ax,420,95,'',f{:},'FontSize',13,'Color','w');
G.warn = text(ax,420,40,'',f{:},'FontSize',16,'Color',[1 .55 .2]);
end

function renderFrame(~,s)
%renderFrame - Shade the stored disk points and update the overlay
G = s.G;
[G.im.CData,k,v] = paint(s);
% A flare hit shakes the view; the shake is a function of state, not random.
G.im.XData = [0 800]+14*s.flash*sin(90*s.clk);
% 0/0 is NaN, which hides an object; this idiom is used for several below.
p = [floor((k-1)/120)*800/159 600-mod(k-1,120)*600/119]+0/(v > .3 && s.mode == 1);
[G.you.XData,G.you.YData] = deal(p(1),p(2));
G.yt.Position = p+[0 24];
% Gauge: red bands warn, white bands burn, the green band is the bonus.
on = s.ft >= 0 & s.mode == 1;
y = 100+60*(s.fc-1+[-1;1]*s.fw)+0./on;
G.band.YData = y([1 1 2 2],:);
C = [1 .25 .1;1 .25 .1;.3 1 .3];
C(s.ft > s.wt & [1 1 0],:) = 1;
G.band.FaceVertexCData = C;
% The ship's gauge bar swells on each tap.
G.gs.YData = [1 1]*(100+60*(s.r-1))+0/(s.mode == 1);
G.gs.LineWidth = 4+8*s.burn;
G.hull.String = ['HULL ' repmat('|',1,s.hull)];
% The score heats from gold toward white as the combo grows.
G.score.String = [sprintf('+%.1f YEARS',s.yrs) repmat(sprintf('   x%d COMBO',s.m),1,s.m > 1)];
G.score.Color = [1 .8 .25]+(s.m-1)*[0 .05 .18];
G.info.String = sprintf('your clock: %.0f%% of Earth''s',100*sqrt(max(0,1-1.5/s.r)));
% Hints, most urgent first.
w = abs(s.r-s.fc(1:2)) < s.fw(1:2) & on(1:2) & s.ft(1:2) <= s.wt;
m = {s.msg,sprintf('LEAVE THE RED BAND: %.1f s',s.wt-max(s.ft(w))),'BELOW ISCO: NO STABLE ORBIT','FLY INTO THE GREEN BAND','TAP TO CLIMB, WAIT TO SINK','GO BELOW THE COMBO LINE',''};
G.warn.String = m{find([s.t < s.got,any(w),s.r < 3,on(3) && s.t < 40,s.t < 8,s.t < 30 && s.r > 4,1],1)};
[G.big.String,G.sub.String] = deal('');
% During play the banner sits lower, clear of the score.
G.big.Position = [420 540-80*(s.mode == 1)];
if s.t < s.ban
    G.big.String = sprintf('STAGE %d',s.lv);
    G.sub.String = 'Flares come faster';
end
if s.mode == 0
    G.big.String = 'EVENT HORIZON';
    G.sub.String = {'TAP to climb. WAIT and the disk drags you down.','Deep orbits slow your clock: fly into Earth''s future.','Below the COMBO line years multiply. Leave RED bands','before they burn. Fly into GREEN bands.','','Tap to begin'};
elseif s.mode == 2
    G.big.String = s.why;
    G.sub.String = {sprintf('You traveled %.1f years into Earth''s future',s.yrs),[sprintf('Best %.1f years',s.best) repmat('  NEW BEST',1,s.yrs >= s.best)],'','Tap to try again'};
end
if s.mode ~= 1
    [G.score.String,G.info.String,G.hull.String,G.warn.String] = deal('');
end
end

function [im,k,v] = paint(s)
%paint - Composite one frame; also return where the ship's image is brightest
M = s.M;
I = zeros(19200,1);
S = I;
F = [I I I];
zs = s.r*exp(1i*s.ph);
% Flares flicker red while warning and burn white; the bonus band glows green.
on = s.ft >= 0 & s.mode == 1;
% B(j,c) is how much band j adds to color c: warning, burning or bonus.
B = (on.*[.25+.15*sin(25*s.clk)+.75*(s.ft(1:2) > s.wt) .5]).'.*[(s.ft <= s.wt).*[1 1 0];(s.ft > s.wt).*[1 1 0];0 0 1].';
% Each tap puffs engine exhaust just behind the ship; it is lensed too.
zf = zs*exp(-.35i);
% The ship dims and reddens as it nears the horizon: gravitational redshift.
z = sqrt(max(0,1-1/s.r));
for k = 1:2
    L = M.L(k);
    % Each ring of the disk turns at its own Kepler rate.
    I(L.i) = I(L.i)+L.e.*(.6+.4*sin(L.p-L.w*s.clk))+3*s.burn*exp(-abs(L.c-zf).^2/.08);
    S(L.i) = S(L.i)+exp(-abs(L.c-zs).^2/.2);
    b = max(0,1-((L.r-s.fc)./s.fw).^2);
    F(L.i,:) = F(L.i,:)+b*B;
end
% The ship hides the disk behind it.
S = min(S*z*(1.3+s.burn),1);
[v,k] = max(S);
I = I.*(1-S);
% Each stage recolors the disk, cycling through five palettes.
P = [1 .75 .25;1 .5 .2;1 .4 .55;.75 .5 1;.45 .8 1];
im = I.^[1 1.2 2].*P(mod(s.lv-1,5)+1,:)+F*[1 .25 .05;1 1 .9;.3 1 .3]+M.st*[.9 .9 1]+S*[1-.8*z .3+.65*z .2+.8*z]+s.flash*[.6 0 0];
% Falling in, the picture fades to black.
im = im*max(.1,1-(s.clk-s.td)*(s.mode == 2 && s.r < 1.1));
im = uint8(255*min(reshape(im,120,160,3),1));
end
Play Game
Preview

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