Twilight Run

Mike Croucher
/
Twilight Run
on 3 Nov 2026
2
15
5
1
9781
game.m
function g = game()
%game Twilight Run -- a one-button city-bomber game.
%   Your biplane flies across the city at dusk, dropping a little lower
%   on every pass. Tap to drop a bomb (one in the air at a time); each
%   bomb knocks several floors off the tower below it. Flatten the whole
%   skyline to land and fly on to a taller, faster city. Fly into a
%   building and it's over.

g.init   = @initState;
g.update = @updateState;
g.render = @renderFrame;
end

function s = initState(ax)
ax.YDir = 'normal';
ax.XLim = [0 800];
ax.YLim = [0 600];
np = {'HitTest', 'off', 'PickableParts', 'none'};

s.C   = 16;      % building columns
s.x0  = 80;      % left edge of the city
s.cw  = 40;      % column pitch
s.bw  = 34;      % building width
s.fh  = 16;      % floor height
s.gnd = 40;      % ground level
s.best = 0;

% Dusk sky: vertical gradient, faint stars, low sun
patch(ax, [0 800 800 0], [0 0 600 600], 'k', 'FaceVertexCData', ...
    [0.98 0.55 0.35; 0.98 0.55 0.35; 0.14 0.1 0.32; 0.14 0.1 0.32], ...
    'FaceColor', 'interp', 'EdgeColor', 'none', np{:});
line(ax, rand(1, 40) * 800, 430 + rand(1, 40) * 170, 'LineStyle', 'none', ...
    'Marker', '.', 'MarkerSize', 6, 'Color', [1 0.95 0.85], np{:});
a = linspace(0, 2 * pi, 40);
patch(ax, 560 + 95 * cos(a), 90 + 95 * sin(a), [1 0.78 0.42], ...
    'EdgeColor', 'none', np{:});

% Building pool: body, lit windows, rooftop antenna
for c = 1:s.C
    s.h.bld(c) = rectangle(ax, 'Position', [0 0 1 1], ...
        'FaceColor', [0.2 0.12 0.28], 'EdgeColor', 'none', np{:});
    s.h.win(c) = line(ax, 0, 0, 'LineStyle', 'none', 'Marker', 's', ...
        'MarkerSize', 3, 'MarkerFaceColor', [1 0.82 0.45], ...
        'MarkerEdgeColor', 'none', np{:});
    s.h.ant(c) = line(ax, [0 0], [0 0], 'Color', [0.2 0.12 0.28], ...
        'LineWidth', 2, np{:});
end
for c = 1:s.C
    s.h.cap(c) = rectangle(ax, 'Position', [0 0 1 1], 'EdgeColor', 'none', np{:});
end
rectangle(ax, 'Position', [0 0 800 s.gnd], 'FaceColor', [0.12 0.07 0.14], ...
    'EdgeColor', 'none', np{:});
line(ax, 20:40:780, 20 * ones(1, 20), 'LineStyle', 'none', 'Marker', '_', ...
    'MarkerSize', 10, 'Color', [0.9 0.75 0.5], np{:});

% Biplane (faces +x) under one transform
s.h.pl = hgtransform(ax, np{:});
P = @(x, y, c) patch('XData', x, 'YData', y, 'FaceColor', c, ...
    'EdgeColor', 'none', 'Parent', s.h.pl, np{:});
body = [0.2 0.55 0.6];
wing = [0.95 0.9 0.75];
P([-22 14 20 14 -22 -26], [-3 -5 0 5 3 9], body);           % fuselage + tail
P([-26 -18 -20 -26], [3 3 13 13], body);                    % tail fin
P([-6 8 8 -6], [8 8 11 11], wing);                          % top wing
P([-8 6 6 -8], [-7 -7 -4 -4], wing);                        % lower wing
line([-2 -2 NaN 5 5], [-4 8 NaN -4 8], 'Color', [0.3 0.2 0.15], ...
    'Parent', s.h.pl, np{:});                               % struts
line(2, 7, 'Marker', 'o', 'MarkerSize', 5, 'MarkerFaceColor', [0.85 0.3 0.25], ...
    'MarkerEdgeColor', 'none', 'Parent', s.h.pl, np{:});    % pilot scarf
s.h.prop = line([21 21], [-8 8], 'Color', [0.25 0.2 0.2], 'LineWidth', 2, ...
    'Parent', s.h.pl, np{:});

s.h.bomb = line(ax, 0, 0, 'Marker', 'o', 'MarkerSize', 7, ...
    'MarkerFaceColor', [0.15 0.1 0.15], 'MarkerEdgeColor', [0.15 0.1 0.15], np{:});
% Debris pool: rubble chunks and sparks
s.ND = 40;
s.h.rub = line(ax, NaN, NaN, 'LineStyle', 'none', 'Marker', 's', ...
    'MarkerSize', 7, 'MarkerFaceColor', [0.22 0.14 0.3], ...
    'MarkerEdgeColor', 'none', np{:});
s.h.spk = line(ax, NaN, NaN, 'LineStyle', 'none', 'Marker', '.', ...
    'MarkerSize', 13, 'Color', [1 0.85 0.4], np{:});
s.h.boom = rectangle(ax, 'Position', [0 0 1 1], 'Curvature', [1 1], ...
    'FaceColor', [1 0.7 0.25], 'EdgeColor', [1 0.95 0.6], 'LineWidth', 2, ...
    'Visible', 'off', np{:});

tp = [{'Color', [1 0.95 0.85], 'FontSize', 14, 'FontWeight', 'bold', ...
    'FontName', 'Consolas'}, np];
s.h.score = text(ax, 16, 580, '', tp{:});
s.h.best  = text(ax, 784, 580, '', 'HorizontalAlignment', 'right', tp{:});
s.h.msg = text(ax, 400, 360, '', 'Color', 'w', 'FontSize', 20, ...
    'FontWeight', 'bold', 'HorizontalAlignment', 'center', np{:});

s.score = 0;
s.city  = 1;
s = newCity(s);
s.mode = 0;              % 0 title, 1 flying, 2 landing, 3 cleared, 4 crashed
end

function s = newCity(s)
% Fresh skyline; taller and faster with each city.
L = s.city;
hmax = min(6 + 2 * L, 22);
s.fl  = randi([2 hmax], 1, s.C) .* (rand(1, s.C) > 0.08);
s.ant = rand(1, s.C) < 0.35;
s.lit = rand(22, 3, s.C) > 0.3;        % which windows are lit
s.arm = rand(1, s.C) < min(0.1 + 0.07 * L, 0.45);   % steel-capped towers
s.crk = false(1, s.C);                 % cap cracked (next hit lands)
s.dp = zeros(s.ND, 4);                 % debris x, y, vx, vy
s.da = false(s.ND, 1);                 % debris active
s.dk = false(s.ND, 1);                 % debris is a spark
s.di = 0;
s.spd = min(190 + 25 * L, 380);        % plane speed (px/s)
s.drop = 22;                           % altitude lost per pass
s.pow = 4;                             % floors destroyed per bomb
s.px = -40;
s.py = 545;
s.bomb = false;
s.bx = 0; s.by = 0; s.bv = 0;
s.boomT = -1; s.boomP = [0 0];
s.t = 0;
s.T = 0;
s.mode = 1;
end

function s = updateState(s, dt, pressed)
s.t = s.t + dt;
if s.boomT >= 0
    s.boomT = s.boomT + dt;
    if s.boomT > 0.35, s.boomT = -1; end
end
% Debris: ballistic, settles when it reaches the ground
if any(s.da)
    s.dp(:, 4) = s.dp(:, 4) - 650 * dt;
    s.dp(:, 1:2) = s.dp(:, 1:2) + dt * s.dp(:, 3:4);
    s.da = s.da & s.dp(:, 2) > s.gnd;
end

switch s.mode
    case 0                      % title
        if pressed, s.mode = 1; end
        return
    case 3                      % city cleared
        s.T = s.T + dt;
        if pressed && s.T > 0.6
            s.city = s.city + 1;
            s = newCity(s);
        end
        return
    case 4                      % crashed: plane tumbles to the ground
        s.T = s.T + dt;
        s.py = max(s.py - 220 * dt, s.gnd + 6);
        if pressed && s.T > 0.8
            s.score = 0;
            s.city = 1;
            s = newCity(s);
        end
        return
end

% Fly; wrap round and drop lower each pass
s.px = s.px + s.spd * dt;
if s.px > 840
    s.px = -40;
    if s.mode == 1
        s.py = max(s.py - s.drop, s.gnd + 22);
    end
end

if s.mode == 2
    % Skyline flat: glide down to land
    s.py = s.py - 90 * dt;
    if s.py <= s.gnd + 10
        s.py = s.gnd + 10;
        s.mode = 3;
        s.T = 0;
        s.score = s.score + 500 * s.city;
    end
end

% Drop a bomb (one at a time)
if pressed && s.mode == 1 && ~s.bomb && s.px > 0 && s.px < 800
    s.bomb = true;
    s.bx = s.px;
    s.by = s.py - 14;
    s.bv = 120;
end

% Bomb falls straight down and eats floors off the tower it lands on
if s.bomb
    s.bv = s.bv + 700 * dt;
    s.by = s.by - s.bv * dt;
    c = floor((s.bx - s.x0) / s.cw) + 1;
    inCol = c >= 1 && c <= s.C && mod(s.bx - s.x0, s.cw) <= s.bw + 3;
    if inCol && s.fl(c) > 0 && s.by <= s.gnd + s.fl(c) * s.fh
        top = s.gnd + s.fl(c) * s.fh;
        if s.arm(c) && ~s.crk(c)
            s.crk(c) = true;            % first hit only cracks the cap
            s = debris(s, s.bx, top, 5);
        else
            k = min(s.pow, s.fl(c));
            s.fl(c) = s.fl(c) - k;
            s.crk(c) = false;
            s.score = s.score + 10 * k * s.city * (1 + s.arm(c));
            s = debris(s, s.bx, top, 10);
        end
        s = boom(s, s.bx, s.gnd + s.fl(c) * s.fh);
    elseif s.by <= s.gnd
        s = boom(s, s.bx, s.gnd);
    end
end

% Collision: any tower under the plane taller than its belly
c1 = max(floor((s.px - 24 - s.x0) / s.cw) + 1, 1);
c2 = min(floor((s.px + 30 - s.x0) / s.cw) + 1, s.C);
if c1 <= c2 && any(s.gnd + s.fl(c1:c2) * s.fh > s.py - 8)
    s.mode = 4;
    s.T = 0;
    s.bomb = false;
    s = boom(s, s.px, s.py);
    s.best = max(s.best, s.score);
    return
end

if s.mode == 1 && ~any(s.fl)
    s.mode = 2;
end
s.best = max(s.best, s.score);
end

function s = debris(s, x, y, n)
% Throw n pieces from (x, y) into the ring-buffer pool.
for j = 1:n
    s.di = mod(s.di, s.ND) + 1;
    s.dp(s.di, :) = [x + 8 * (rand - 0.5), y, 260 * (rand - 0.5), 80 + 220 * rand];
    s.da(s.di) = true;
    s.dk(s.di) = rand < 0.35;
end
end

function s = boom(s, x, y)
s.bomb  = false;
s.boomT = 0;
s.boomP = [x y];
end

function renderFrame(~, s)
for c = 1:s.C
    x = s.x0 + (c - 1) * s.cw;
    n = s.fl(c);
    h = n * s.fh;
    on = n > 0;
    s.h.bld(c).Visible = on;
    s.h.win(c).Visible = on;
    s.h.ant(c).Visible = on && s.ant(c);
    s.h.cap(c).Visible = on && s.arm(c);
    if on
        s.h.bld(c).Position = [x, s.gnd, s.bw, h];
        if s.arm(c)
            s.h.bld(c).FaceColor = [0.26 0.27 0.38];
        else
            s.h.bld(c).FaceColor = [0.2 0.12 0.28];
        end
        s.h.cap(c).Position = [x - 2, s.gnd + h - 6, s.bw + 4, 6];
        if s.crk(c)
            s.h.cap(c).FaceColor = [1 0.45 0.15];
        else
            s.h.cap(c).FaceColor = [0.72 0.77 0.88];
        end
        [fy, wx] = find(s.lit(1:n, :, c));
        s.h.win(c).XData = x - 1 + 9 * wx';
        s.h.win(c).YData = s.gnd + (fy' - 0.45) * s.fh;
        s.h.ant(c).XData = x + s.bw / 2 * [1 1];
        s.h.ant(c).YData = s.gnd + h + [0 12];
    end
end

rot = 0;
if s.mode == 4
    rot = -0.6;
end
s.h.pl.Matrix = makehgtform('translate', [s.px s.py 0], 'zrotate', rot, ...
    'scale', 1.9);
s.h.prop.YData = 8 * abs(sin(30 * s.t)) * [-1 1];

X = s.dp(:, 1);
X(~s.da) = NaN;
s.h.rub.XData = X(~s.dk);
s.h.rub.YData = s.dp(~s.dk, 2);
s.h.spk.XData = X(s.dk);
s.h.spk.YData = s.dp(s.dk, 2);

s.h.bomb.Visible = s.bomb;
s.h.bomb.XData = s.bx;
s.h.bomb.YData = s.by;

if s.boomT >= 0
    r = 6 + 70 * s.boomT;
    s.h.boom.Position = [s.boomP - r, 2 * r, 2 * r];
    s.h.boom.Visible = 'on';
else
    s.h.boom.Visible = 'off';
end

s.h.score.String = sprintf('SCORE %d   CITY %d', s.score, s.city);
s.h.best.String = sprintf('BEST %d', s.best);
switch s.mode
    case 0
        m = {'TWILIGHT RUN', 'tap to drop a bomb', ...
            'flatten the city before you fly into it', ...
            'steel-capped towers take 2 hits', '', 'tap to start'};
    case 3
        m = {sprintf('CITY %d CLEARED!', s.city), ...
            sprintf('+%d landing bonus', 500 * s.city), 'tap to fly on'};
    case 4
        m = {'CRASHED!', sprintf('Score %d', s.score), 'tap to try again'};
    otherwise
        m = '';
end
s.h.msg.String = m;
end
Play Game
Preview

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