Vortex

Mike Croucher
/
Vortex
on 3 Nov 2026
4
55
21
8
9964
game.m
function g = game()
%game Vortex -- a one-button pseudo-3D game.
%   Your craft rides the inside wall of a neon tunnel, always circling.
%   Tap to reverse the direction you circle. The camera rolls with you,
%   so the tunnel spins around your ship. Barriers rush out of the dark:
%   single blocks to slip past and full rings with one gap to line up
%   with. Speed, spin and narrowness all rise as you go.
%
%   Rendering is a hand-rolled perspective projection onto the 2-D axes:
%   a point at tunnel angle a, radius r, depth z lands at
%   centre + F*r*[cos, sin](a - theta - pi/2) / z.
%
%   Fixed numbers used inline (comments are free, code is counted):
%     280   focal scale F (px)          1.15  player depth
%     26    draw distance (zfar)        13    tunnel rings, 2 apart
%     9     barrier pool                25    points per barrier arc
%     50    vertices per barrier (2*25) 24    warp streaks
%   Timers live in one vector s.tm = [flash shake popup zoneBanner].

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

function s = initState(ax)
ax.XLim  = [0 800];
ax.YLim  = [0 600];
ax.Color = [0.02 0 0.06];
ax.SortMethod = 'childorder';
np = {'HitTest', 'off', 'PickableParts', 'none'};

s.bg   = ax.Color;
s.best = 0;
% Zone styles (cycle every 25 barriers):
%   [ring rgb, static barrier rgb, background rgb, polygon sides]
% A 1e9-gon is exactly round in double precision, so round zones need
% no special case in proj.
% Zone 2 is an octagonal monochrome wireframe with speckle dust.
s.pal = [0.2 0.85 1    1 0.2 0.6     0.02 0 0.06     1e9
         0.85 0.92 1   0.4 0.55 1    0.03 0.03 0.04  8
         1 0.35 0.9    0.2 0.7 1     0.02 0 0.06     1e9
         1 0.85 0.2    0.4 1 0.6     0.02 0 0.06     1e9];
s.ax = ax;

% For speed, each family of shapes is ONE patch with one face per item:
% the whole tunnel is a few property updates per frame.
% Tunnel rings (13 x 49 points): edges coloured per vertex (depth fog)
s.ra = linspace(0, 2 * pi, 49)';
s.ring = patch(ax, 'Faces', reshape(1:637, 49, [])', 'Vertices', zeros(637, 2), ...
    'FaceColor', 'none', 'EdgeColor', 'interp', ...
    'FaceVertexCData', zeros(637, 3), 'LineWidth', 1.5, np{:});
s.lon  = line(ax, 0, 0, 'Color', [0.15 0.35 0.6], 'LineWidth', 1, np{:});
s.warp = line(ax, 0, 0, 'Color', [0.85 0.92 1], np{:});

% Barriers (9 x 50 vertices): front plates of wall segments, drawn
% far-to-near. Colours are per vertex: 'flat' faces take the first
% vertex (fill colour), 'flat' edges each edge's start vertex (glow).
s.ob = patch(ax, 'Faces', reshape(1:450, 50, [])', ...
    'Vertices', NaN(450, 2), 'FaceColor', 'flat', ...
    'FaceVertexCData', zeros(450, 3), 'EdgeColor', 'flat', ...
    'LineWidth', 2, np{:});

% Shield orb
s.orb = line(ax, 0, 0, 'Marker', 'o', 'MarkerFaceColor', [0.5 1 1], ...
    'MarkerEdgeColor', 'w', 'LineWidth', 2, np{:});

% Player craft: fixed on screen (the world rolls around it)
s.pl = hgtransform(ax, np{:});
patch('XData', [-26 0 26 0], 'YData', [-6 14 -6 0], ...
    'FaceColor', [1 0.9 0.3], 'EdgeColor', [1 1 0.8], 'LineWidth', 1.5, ...
    'Parent', s.pl, np{:});
line([-12 12], [-9 -9], 'Color', [1 0.45 0.1], 'LineWidth', 3, ...
    'Parent', s.pl, np{:});
a = linspace(0, 2 * pi, 30);
s.shd = line(36 * cos(a), 3 + 30 * sin(a), 'Color', [0.5 1 1], ...
    'LineWidth', 2, 'Parent', s.pl, np{:});         % shield bubble
% Crash shards (one line object, 10 triangle markers)
s.sh = line(ax, 0, 0, 'LineStyle', 'none', 'Marker', '^', ...
    'MarkerFaceColor', [1 0.9 0.3], 'MarkerEdgeColor', [1 0.5 0.1], np{:});

% Text: HUD (tp) and centred messages (tc)
tp = [{'Color', [0.7 0.9 1], 'FontSize', 14, 'FontWeight', 'bold', ...
    'FontName', 'Consolas'}, np];
tc = [{'FontWeight', 'bold', 'HorizontalAlignment', 'center'}, np];
s.scoreT = text(ax, 16, 580, '', tp{:});
s.bestT  = text(ax, 784, 580, '', 'HorizontalAlignment', 'right', tp{:});
s.pop = text(ax, 400, 150, '', 'Color', [1 1 0.6], 'FontSize', 15, tc{:});
s.msg = text(ax, 400, 330, '', 'Color', 'w', 'FontSize', 20, tc{:});

s = resetRun(s);
end

function s = resetRun(s)
% mode: 0 title, 1 running, 2 crashed.  th: player angle on the wall.
% dist: distance down the tunnel.  cx/cy: tunnel bend.  sz/sa: shield
% orb depth/angle (son: orb waiting).  ns: barriers spawned so far.
[s.mode, s.T, s.t, s.dist, s.passed, s.score, s.cx, s.cy, s.sz, s.sa, s.ns] = deal(0);
[s.dir, s.zone] = deal(1);
[s.shield, s.son, s.sym] = deal(false);
s.th   = -pi / 2;
s.tm   = [0 0 0 0];
s.popS = '';
% Warp streaks: angle, radius, depth (keep this rand order)
s.wa = rand(1, 24) * 2 * pi;
s.wr = 0.8 + 0.18 * rand(1, 24);
s.wz = rand(1, 24) * 26;
s.safe  = s.th;      % a guaranteed-clear angle at the last barrier
s.lastZ = 8;
% ot: 0 plate/ring, 1 spinning bar, 2 double wall
[s.oz, s.oc, s.ow, s.om, s.ot] = deal(zeros(1, 9));
for i = 1:9
    s = spawnBarrier(s, i);
end
end

function [v, w, d] = pace(s)
% Forward speed, spin rate and difficulty (0..1) from barriers passed.
d = min(s.passed / 60, 1);
v = min(5 + 0.06 * s.passed, 20);       % speed ceiling at barrier 250
w = min(2.3 + 0.03 * s.passed, 4.2);
end

function s = spawnBarrier(s, i)
% Place barrier i beyond the last one so a clear path always exists:
% the next safe angle is within reach of the previous one. Before the
% first barrier of each new zone add a ~2 s breather.
[v, w, d] = pace(s);
s.ns = s.ns + 1;
gap = 5 - 1.6 * d + rand + 2 * v * (mod(s.ns, 25) == 1 && s.ns > 1);
% After a two-sided barrier (bar / double wall) the player may have used
% either opening, so leave room to cross half the tunnel (reach = pi)
gap = max(gap, s.sym * pi * v / (0.7 * w));
ps = s.safe;
s.safe = s.safe + (2 * rand - 1) * min(0.7 * w * gap / v, pi);
% Occasional shield orb, halfway along the clear path
if ~s.son && s.passed > 5 && rand < 0.12
    [s.son, s.sz, s.sa] = deal(true, s.lastZ + gap / 2, (ps + s.safe) / 2);
end
% Occasionally (from barrier 15) a spinning bar right across the
% tunnel: a 1.9 x 0.6 rectangle through the centre. At the ship's radius
% (0.86) it blocks +-asin(0.3/0.86) around oc and oc+pi; it lands
% roughly perpendicular to the clear angle so that side stays open.
% Half of these specials are instead a double wall (ot = 2): two big
% blocks on opposite sides, leaving two narrow gaps (+-0.45 rad), one
% centred on the clear angle. Same two-sided collision as the bar.
s.ot(i) = (s.passed >= 15 && rand < 0.12) * (1 + (rand < 0.5));
if s.ot(i) == 1
    s.ow(i) = asin(0.3 / 0.86);
    s.oc(i) = s.safe + pi / 2 + (2 * rand - 1) * (pi / 2 - s.ow(i) - 0.4);
    s.om(i) = (2 * (rand < 0.5) - 1) * (0.15 + 0.1 * rand);
elseif s.ot(i)
    s.ow(i) = pi / 2 - 0.45;
    s.oc(i) = s.safe + pi / 2 + 0.2 * (rand - 0.5);
    s.om(i) = 0;
else
    if rand < 0.45                       % ring with one gap
        s.oc(i) = s.safe + pi;
        s.ow(i) = pi - (0.75 - 0.3 * d);
    else                                 % single block
        s.ow(i) = 0.5 + rand * (0.6 + 0.6 * d);
        s.oc(i) = s.safe + pi + (2 * rand - 1) * max(pi - s.ow(i) - 0.45, 0);
    end
    % From barrier 20 on, some barriers twist as they approach. The
    % twist is per unit depth and zero at the player's depth, so oc is
    % still exactly where it lands -- the clear path is unchanged.
    s.om(i) = 0;
    if s.passed >= 20 && rand < min(0.2 + 0.01 * (s.passed - 20), 0.5)
        s.om(i) = (2 * (rand < 0.5) - 1) * (0.08 + 0.1 * rand + 0.07 * d);
    end
end
s.sym = s.ot(i) > 0;
s.lastZ = s.lastZ + gap;
s.oz(i) = s.lastZ;
end

function s = updateState(s, dt, pressed)
s.t  = s.t + dt;
s.tm = max(s.tm - dt, 0);
if s.mode == 0                           % title: a tap starts the run
    s.mode = +pressed;
    return
end
if s.mode == 2                           % crashed: tap to run again
    s.T = s.T + dt;
    if pressed && s.T > 0.7
        s = resetRun(s);
        s.mode = 1;
    end
    return
end

[v, w] = pace(s);
% Practice start: 60% forward speed, easing to full by barrier 5. Only
% the motion slows -- barriers are still planned at full speed, so the
% clear path stays reachable (slower just means more time).
v = v * min(1, 0.6 + 0.08 * s.passed);
s.dir = s.dir * (1 - 2 * pressed);       % tap reverses direction
s.th = s.th + s.dir * w * dt;
s.wz = s.wz - 1.6 * v * dt;              % streaks outrun the tunnel
r = s.wz < 0.4;
s.wz(r) = s.wz(r) + 0.8 * 26;

% Shield orb pickup as it passes the ship
if s.son
    zs = s.sz - s.dist;
    if zs > 1.15 && zs - v * dt <= 1.15 && abs(angle(exp(1i * (s.th - s.sa)))) < 0.3
        [s.shield, s.son, s.tm(3), s.popS] = deal(true, false, 0.7, 'SHIELD');
    end
    s.son = s.son && zs > 0.3;
end
z0 = s.oz - s.dist;
s.dist = s.dist + v * dt;
z1 = s.oz - s.dist;
s.score = s.score + v * dt;
% Gentle tunnel bend ahead (slowly varying curvature)
s.cx = 0.045 * sin(0.045 * s.dist);
s.cy = 0.035 * sin(0.031 * s.dist + 1);

for i = 1:9
    if z0(i) > 1.15 && z1(i) <= 1.15
        s = passBarrier(s, i);
        if s.mode == 2
            return
        end
    end
    if z1(i) < 0.3
        s = spawnBarrier(s, i);
    end
end
end

function s = passBarrier(s, i)
% Barrier i reaches the ship: crash, shield save, near miss or clean pass.
e = abs(angle(exp(1i * (s.th - s.oc(i)))));
if s.ot(i)
    e = min(e, pi - e);                  % a bar blocks both ends
end
m = e - s.ow(i) - 0.07;
if m < 0 && ~s.shield
    [s.mode, s.T] = deal(2, 0);
    s.tm(1:2) = [0.4 0.45];              % red flash + big shake
    s.best = max(s.best, floor(s.score));
    return
end
s.passed = s.passed + 1;
s.score = s.score + 10;
if m < 0                                 % shield absorbs the hit
    [s.shield, s.tm(2:3), s.popS] = deal(false, [0.3 0.8], 'SHIELD SAVED YOU');
elseif m < 0.12                          % scraped past an edge
    s.score = s.score + 50;
    [s.tm(2:3), s.popS] = deal([0.2 0.7], 'NEAR MISS +50');
end
if floor(s.passed / 25) + 1 > s.zone
    s.zone = s.zone + 1;
    s.tm(4) = 1.8;
end
end

function [x, y] = proj(s, a, r, z)
% Perspective projection, rolled so the player sits at screen bottom.
% The bend term F*c*z/2 is a curved centreline x = c*z^2/2 projected.
% Polygon zones scale r by the n-gon radius at world angle a (so the
% polygon rolls with the tunnel); ring samples (48 steps) hit corners.
n = s.sides;
r = r .* cos(pi / n) ./ cos(mod(a, 2 * pi / n) - pi / n);
q = a - s.th - pi / 2;
x = 400 + 280 * (r .* cos(q) ./ z + s.cx * z / 2);
y = 300 + 280 * (r .* sin(q) ./ z + s.cy * z / 2);
end

function c = fog(s, base, z)
% Fade a colour into the background with depth (z: column -> rows).
f = min(max(z / 26, 0), 1).^0.8;
c = (1 - f) .* base + f .* s.bg;
end

function renderFrame(~, s)
% Red crash flash and screen shake (shake is deterministic in s.t so
% render stays idempotent). With no flash the colour is exactly s.bg.
% Zone style (render's local copy of s only -- nothing persists)
p = s.pal(mod(s.zone - 1, 4) + 1, :);
s.bg = p(7:9);
s.sides = p(10);
k = 25 * s.tm(2);
set(s.ax, 'Color', [0.5 0.05 0.1] * s.tm(1) / 0.4 + s.bg, ...
    'XLim', [0 800] + k * sin(91 * s.t), 'YLim', [0 600] + k * cos(73 * s.t));

% Rings scroll toward the camera (49 x 13 points in one go)
z = (1:13) * 2 - mod(s.dist, 2);
[x, y] = proj(s, s.ra, 1, z);
set(s.ring, 'Vertices', [x(:) y(:)], ...
    'FaceVertexCData', repelem(fog(s, p(1:3), z'), 49, 1));

% Longitudinal lines at 12 fixed tunnel angles (polylines, so they
% bend); in polygon zones they run along the corners (n = sides, else
% 12 evenly spaced). A NaN depth ends each polyline.
n = min(s.sides, 12);
[x, y] = proj(s, mod(0:11, n)' * 2 * pi / n, 1, [0.5 1 2 4 7 11 16 21 26 NaN]);
set(s.lon, 'XData', reshape(x', 1, []), 'YData', reshape(y', 1, []), ...
    'Color', 0.45 * p(1:3));

% Warp streaks: dashes that stretch with speed (rows: start, end, NaN
% separator); speckle dots instead of dashes in polygon zones
v = pace(s);
[x, y] = proj(s, s.wa, s.wr, [s.wz; s.wz + 0.07 * v; NaN(1, 24)]);
d = 1 + (s.sides < 99);               % 2 = speckle-dot style
ls = {'-', 'none'};
mk = {'none', '.'};
set(s.warp, 'XData', x(:)', 'YData', y(:)', 'LineStyle', ls{d}, ...
    'Marker', mk{d}, 'MarkerSize', 7);

% Barriers: arc band from the wall (r=1) inward (r=0.62). Faces are
% filled far-to-near so nearer plates paint over farther ones; hidden
% barriers get NaN vertices. Rotating ones are orange in every zone.
z = s.oz - s.dist;
[~, o] = sort(z, 'descend');
V = NaN(50, 2, 9);
for n = 1:9
    i = o(n);
    f = s.oc(i) + s.om(i) * (z(i) - 1.15);
    b = f + s.ow(i) * linspace(-1, 1, 24 + (s.ot(i) == 0));
    if z(i) <= 0.3 || z(i) >= 26
        continue
    elseif s.ot(i) > 1
        % Double wall: a bow-tie of two opposite sectors meeting at the
        % centre (24 + 1 + 24 + 1 = 50 vertices, one simple face)
        [xo, yo] = proj(s, [b f b + pi f], [ones(1, 24) 0 ones(1, 24) 0], z(i));
    elseif s.ot(i)
        % Spinning bar: the 1.9 x 0.6 rectangle's corners in polar form
        % (radius hypot(0.95,0.3), angles +-atan2(0.3,0.95), pi minus
        % that), padded to 50 vertices with the last corner
        [xo, yo] = proj(s, f + [-2.836 -0.3054 0.3054 2.836 * ones(1, 47)], 0.9962, z(i));
    else
        % Wall plate: outer arc at r=1, back along the inner arc at 0.62
        [xo, yo] = proj(s, [b fliplr(b)], [ones(1, 25) 0.62 * ones(1, 25)], z(i));
    end
    V(:, :, n) = [xo' yo'];
end
% Colour index: 1 zone colour, 2 orange (rotating), 3 red (bar),
% 4 yellow (double wall). Bars always rotate, walls never do.
T = [p(4:6); 1 0.55 0.1; 1 0.25 0.2; 1 0.9 0.2];
B = T(1 + (s.om(o) ~= 0) + s.ot(o) + (s.ot(o) > 1), :);
C = repelem(fog(s, 0.4 * B + 0.6, z(o)'), 50, 1);   % glow edges
C(1:50:end, :) = fog(s, B, z(o)');                  % fills
set(s.ob, 'Vertices', reshape(permute(V, [1 3 2]), [], 2), 'FaceVertexCData', C);

% Shield orb (depth clamped at 0.3, where it is hidden anyway)
zs = max(s.sz - s.dist, 0.3);
[x, y] = proj(s, s.sa, 0.86, zs);
set(s.orb, 'Visible', s.son && zs > 0.3 && zs < 26, 'XData', x, 'YData', y, ...
    'MarkerSize', min(4 + 30 / zs, 40));
s.shd.Visible = s.shield && s.mode == 1;

% Ship: banks into its turn; hidden after a crash, when it bursts into
% 10 shards fanning up into the tunnel at varied speeds (deterministic
% in s.T), shrinking as they go
[px, py] = proj(s, s.th, 0.86, 1.15);
set(s.pl, 'Matrix', makehgtform('translate', [px py 0], 'zrotate', ...
    0.25 * s.dir * (s.mode == 1)), 'Visible', s.mode ~= 2);
k = 1:10;
q = (150 + 40 * mod(3 * k, 4)) * s.T;
set(s.sh, 'XData', px + q .* cos(0.3 * k), 'YData', py + q .* sin(0.3 * k), ...
    'MarkerSize', max(11 - 7 * s.T, 1), 'Visible', s.mode == 2 && s.T < 1.4);

s.scoreT.String = sprintf('SCORE %d   GATES %d', floor(s.score), s.passed);
s.bestT.String = sprintf('BEST %d', max(s.best, floor(s.score)));
% Message by mode (title / running / crashed); zone banner while running
m = {{'VORTEX', '', 'tap to start'}, '', ...
    {'CRASHED', sprintf('Score %d', floor(s.score)), 'tap to run again'}};
m = m{s.mode + 1};
if s.mode == 1 && s.tm(4) > 0
    m = sprintf('ZONE %d', s.zone);
end
s.msg.String = m;
s.pop.String = s.popS(1:end * (s.tm(3) > 0));     % popup while its timer runs
end
Play Game
Preview

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