LIGHTKEEPER: tap to reverse the lighthouse beam and guide ships home

Praneel
/
LIGHTKEEPER: tap to reverse the lighthouse beam and guide ships home
on 5 Nov 2026
6
21
8
0
9601
game.m
function g = game()
% LIGHTKEEPER: tap to reverse the lighthouse beam and light every ship
% before it hits the reef. Positions are complex numbers x + iy.
g.init = @initState;
g.update = @updateState;
g.render = @renderFrame;
end

function s = initState(ax)
C = struct('sea',[.04 .07 .14], 'glint',[.6 .85 .95], 'beam',[1 .85 .52], ...
    'hull',[.3 .35 .48], 'lamp',[1 .66 .3], 'red',[.95 .3 .24], 'dim',[.5 .57 .7]);
set(ax, 'XLim',[-400 400], 'YLim',[-300 300], 'Color',C.sea);
s = struct('C',C, 'N',16, 'P',90, 'range',300, 'reef',92, 'bw',0.17, 'wMax',1.7, 'acc',10);

s.gz = complex(800*rand(220,1) - 400, 600*rand(220,1) - 300);
s.gph = 2*pi*rand(220,1);
s.h.glint = scatter(ax, real(s.gz), imag(s.gz), 6, C.sea, 'filled');

Z = (s.reef + 6*randn(60,1)).*exp(2i*pi*rand(60,1));
scatter(ax, real(Z), imag(Z), 30 + 130*rand(60,1), [.14 .17 .23].*(0.8 + 0.5*rand(60,1)), 'filled');
Z = (s.reef + 14 + 5*randn(80,1)).*exp(2i*pi*rand(80,1));
scatter(ax, real(Z), imag(Z), 10, C.sea + 0.35*(C.glint - C.sea), 'filled');
c = exp(2i*pi*(0:60)/60);
disc = @(r, col, varargin) patch(ax, r*real(c), r*imag(c), col, 'EdgeColor','none', varargin{:});
disc(52, [.34 .29 .23]);
disc(40, [.16 .2 .17]);

% One patch draws the fleet, a 5-vertex face per ship; NaN vertices hide
% ships that are not sailing.
N = s.N;
s.h.hull = patch(ax, 'Faces',reshape(1:5*N,5,N)', 'Vertices',nan(5*N,2), ...
    'FaceVertexCData',repmat(C.hull,N,1), 'FaceColor','flat', 'EdgeColor','none');
s.h.lamp = scatter(ax, nan(N,1), nan(N,1), 20, C.lamp, 'filled');
s.h.arc = line(ax, nan, nan, 'Color',C.beam, 'LineWidth',2);

% The beam (soft halo, bright core) is built once along +x and fades out
% past the lamp's reach; render only rotates its hgtransform.
s.h.beam = hgtransform(ax);
for wa = [2.4 1; 0.14 0.45]
    e = exp(1i*wa(1)*s.bw*linspace(-1, 1, 14)');
    V = [0; 300*e; 345*e];
    patch('Parent',s.h.beam, 'Faces',[1:15 nan(1,13); 2:15 29:-1:16], ...
        'Vertices',[real(V) imag(V)], 'FaceColor',C.beam, 'EdgeColor','none', ...
        'FaceVertexAlphaData',wa(2)*[1; 0.4 + zeros(14,1); zeros(14,1)], ...
        'FaceAlpha','interp', 'AlphaDataMapping','none');
end

disc(17, [.62 .16 .16], 'EdgeColor',[.9 .85 .8], 'LineWidth',1.5);
s.h.core = scatter(ax, 0, 0, 70, C.beam, 'filled');
s.h.spin = line(ax, nan, nan, 'LineWidth',2);
s.h.fx = scatter(ax, nan(s.P,1), nan(s.P,1), 10, ones(s.P,3), 'filled');
s.h.lives = scatter(ax, [-376 -356 -336], [252 252 252], 60, C.beam, 'filled');
label = @(x, y, sz, al) text(ax, x, y, '', 'FontSize',sz, 'FontWeight','bold', ...
    'Color',[.93 .89 .8], 'HorizontalAlignment',al);
s.h.score = label(-384, 280, 18, 'left');
s.h.best = label(384, 280, 14, 'right');
s.h.title = label(0, 195, 46, 'center');
s.h.sub = label(0, 150, 13, 'center');
s.h.cue = label(0, -170, 16, 'center');
s.h.hint = label(0, -282, 12, 'center');
% Nothing drawn may swallow a click meant for the button.
set(findobj(ax.Children), 'HitTest','off', 'PickableParts','none');
s.h.ax = ax;

[s.w, s.t, s.best, s.aiT] = deal(0);
s.th = pi/2;
s.spin = 1;
s.taught = false;
s = newRound(s);
s.mode = 0;
end

function s = newRound(s)
[s.z, s.hd, s.v, s.lit] = deal(zeros(s.N,1));
[s.on, s.big, s.safe] = deal(false(s.N,1));
[s.fz, s.fv, s.fl] = deal(nan(s.P,1), zeros(s.P,1), zeros(s.P,1));
s.fc = ones(s.P,3);
[s.fk, s.score, s.played, s.jolt, s.pulse, s.overT] = deal(0);
s.lives = 3;
s.spawnT = 1;
s.mode = 1;
end

function s = updateState(s, dt, pressed)
s.t = s.t + dt;
if pressed && s.mode == 1
    s.spin = -s.spin;
    s.pulse = 1;
elseif pressed && (s.mode == 0 || s.overT > 0.9)
    s = newRound(s);
end
if s.mode == 1
    s.played = s.played + dt;
else
    s.overT = s.overT + dt;
    s = autopilot(s, dt);
end

% A tap only flips the target spin. Thanks to inertia, quick taps cancel
% out and the beam hovers in place.
s.w = s.w + max(-s.acc*dt, min(s.acc*dt, s.spin*s.wMax - s.w));
s.th = mod(s.th + s.w*dt, 2*pi);
s = spawnShips(s, dt);
s = moveShips(s, dt);

s.fl = s.fl - dt;
s.fv = s.fv*(1 - 3*dt);
s.fz = s.fz + s.fv*dt;
s.fz(s.fl <= 0) = nan;
s.jolt = max(0, s.jolt - 2.2*dt);
s.pulse = max(0, s.pulse - 4*dt);
end

function s = autopilot(s, dt)
% Attract mode: chase the ship nearest to wrecking, reversing when that
% way round is shorter.
s.aiT = s.aiT - dt;
k = find(s.on & ~s.safe);
if s.aiT > 0 || isempty(k)
    return
end
[~, j] = min((abs(s.z(k)) - s.reef)./s.v(k));
if mod(s.spin*(angle(s.z(k(j))) - s.th), 2*pi) > pi + 0.5
    s.spin = -s.spin;
    s.aiT = 0.7;
end
end

function s = spawnShips(s, dt)
s.spawnT = s.spawnT - dt;
j = find(~s.on, 1);
if s.spawnT > 0 || isempty(j)
    return
end
L = s.played;
s.spawnT = (0.9 + 1.6*exp(-L/60))*(0.75 + 0.5*rand);
phi = 2*pi*rand;
s.on(j) = true;
s.big(j) = rand < min(0.25, (L - 15)/100);
s.safe(j) = false;
s.lit(j) = 0;
s.z(j) = complex(430*cos(phi), 330*sin(phi));
s.hd(j) = angle(-s.z(j)) + 0.3*(rand - 0.5);
s.v(j) = (90 - 32*exp(-L/50))*(0.85 + 0.3*rand)*(1 - 0.3*s.big(j));
end

function s = moveShips(s, dt)
on = s.on;
k = on & s.safe;
s.hd(k) = s.hd(k) + max(-3*dt, min(3*dt, wrapPi(angle(s.z(k)) - s.hd(k))));
s.v(k) = min(170, s.v(k) + 80*dt);
s.z = s.z + on.*s.v.*exp(1i*s.hd)*dt;

r = abs(s.z);
rad = 13 + 9*s.big;
inBeam = on & ~s.safe & r < s.range & abs(wrapPi(angle(s.z) - s.th)) < s.bw + rad./max(r, 1);
% A slow, steady beam lights a ship three times faster than a sweep.
s.lit(inBeam) = s.lit(inBeam) + dt*(1 + 2*(abs(s.w) < 1));
won = inBeam & s.lit >= 0.6*s.big;
s.safe(won) = true;
hit = on & ~s.safe & r < s.reef + rad;
s.on(hit | r > 520) = false;
for j = find(won | hit)'
    s = burst(s, s.z(j), 12 + 10*s.big(j) + 18*hit(j), s.C.beam + hit(j)*(s.C.red - s.C.beam));
end
if s.mode == 1
    s.score = s.score + sum(1 + 2*s.big(won));
    s.taught = s.taught || any(s.big(won));
    s.lives = s.lives - nnz(hit);
    s.jolt = max(s.jolt, any(hit));
    if s.lives <= 0
        s.mode = 2;
        s.overT = 0;
        s.best = max(s.best, s.score);
    end
end
end

function s = burst(s, z, n, col)
% Particles live in a ring buffer; new bursts overwrite the oldest.
k = mod(s.fk + (0:n-1)', s.P) + 1;
s.fk = k(end);
s.fz(k) = z;
s.fv(k) = (30 + 150*rand(n,1)).*exp(2i*pi*rand(n,1));
s.fl(k) = 0.4 + 0.5*rand(n,1);
s.fc(k,:) = repmat(col, n, 1);
end

function renderFrame(~, s)
h = s.h; C = s.C; t = s.t;

% Touching axes limits forces a full relayout, so do it only while the
% wreck jolt lasts. Shake comes from state alone: render stays idempotent.
if s.jolt > 0 || ~isequal(h.ax.Color, C.sea)
    q = 9*s.jolt^2;
    set(h.ax, 'XLim',[-400 400] + q*sin(71*t), 'YLim',[-300 300] + q*cos(53*t), ...
        'Color',C.sea + 0.25*s.jolt*(C.red - C.sea));
end
glow = max(0, 1 - abs(wrapPi(angle(s.gz) - s.th))/(2.4*s.bw)).*max(0, 1 - abs(s.gz)/340);
h.glint.CData = C.sea + min(1, 0.2 + 0.12*sin(3*t + s.gph) + glow).*(C.glint - C.sea);

big = s.big';
boat = [15; 4+7i; -12+5.5i; -12-5.5i; 4-7i];
ship = [26; 7+10.5i; -20+8i; -20-8i; 7-10.5i];
W = toWorld(boat + big.*(ship - boat), s);
set(h.hull, 'Vertices',[real(W(:)) imag(W(:))], ...
    'FaceVertexCData',C.hull + min(1, s.lit/0.6 + s.safe).*(C.beam - C.hull));
r = abs(s.z);
blink = ~s.safe & r < 190 & sin(t*(10 + (190 - r)/6)) > 0;
setXY(h.lamp, toWorld(6 + 4*big, s), 'SizeData',22 + 15*s.big + 26*blink, ...
    'CData',C.lamp + blink.*(C.red - C.lamp) + s.safe.*(C.glint - C.lamp));
k = find(s.on & s.big & ~s.safe & s.lit > 0);
a = exp(1i*(pi/2 - 2*pi*linspace(0, 1, 25)'.*min(1, s.lit(k)'/0.6)));
setXY(h.arc, [s.z(k).' + 28*a; nan(1, numel(k))]);

h.beam.Matrix = makehgtform('zrotate', s.th);
e = s.th + s.spin*linspace(0.35, 1.1, 10);
b = e(end) - s.spin*0.28;
flare = C.beam + s.pulse*(1 - C.beam);
setXY(h.spin, [34*exp(1i*e), nan, [41 34 27].*exp(1i*[b e(end) b])], 'Color',flare);
set(h.core, 'CData',flare, 'SizeData',70 + 260*s.pulse);
life = max(s.fl, 0);
setXY(h.fx, s.fz, 'SizeData',3 + 40*life, 'CData',C.sea + min(1, 2*life).*(s.fc - C.sea));

h.score.String = sprintf('RESCUED  %d', s.score);
h.best.String = sprintf('BEST  %d', max(s.best, s.score));
h.lives.CData = C.beam + ((1:3)' > s.lives).*(C.dim*0.6 - C.beam);
% Rows are title, subtitle and cue; columns are the three modes.
msg = {'LIGHTKEEPER', '', 'LIGHTS OUT'
    'One lamp. One button. A long night at sea.', '', ...
    sprintf('The reef took three ships.   Rescued %d   Best %d', s.score, s.best)
    'TAP TO LIGHT THE LAMP', '', 'TAP TO RELIGHT'};
m = s.mode + 1;
set(h.title, 'String',msg{1,m}, 'Color',C.beam + (m == 3)*(C.red - C.beam));
h.sub.String = msg{2,m};
set(h.cue, 'String',msg{3,m}, 'Visible',mod(t, 1) < 0.65 && (m == 1 || s.overT > 0.9));
teach = s.mode == 1 && ~s.taught && any(s.on & s.big & ~s.safe);
hints = {'TAP to reverse the beam. Light every ship before it hits the reef.', ...
    'BIG SHIPS NEED A STEADY LIGHT: TAP FAST TO HOLD THE BEAM ON THEM'};
set(h.hint, 'String',hints{1 + teach}, 'Color',C.dim + teach*(C.beam - C.dim));
end

function W = toWorld(P, s)
% Columns are ships: one complex multiply turns the fleet, one add
% moves it into place.
W = s.z.' + P.*exp(1i*s.hd.');
W(:, ~s.on) = nan;
end

function setXY(obj, z, varargin)
set(obj, 'XData',real(z(:)), 'YData',imag(z(:)), varargin{:});
end

function a = wrapPi(a)
a = mod(a + pi, 2*pi) - pi;
end
Play Game
Preview

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