Over the Wall

Mike Croucher
/
Over the Wall
on 4 Nov 2026
3
32
11
2
9995
game.m
function g = game()
% OVER THE WALL - one-button artillery defence.
% Tap once to lock the swinging aim angle, tap again to lock the pulsing
% power and fire. Lob shells over your wall onto the advancing creeps.
% Lose a point when a creep reaches the wall, when you hit your own wall,
% or when a shell falls back onto your turret. Bonus point every 25 kills.
% Positions in flight / aiming use complex numbers: x + 1i*y.
% Colours are [red green blue] in 0..1; leading zeros are dropped (.15 = 0.15).
% State field key: sc score, lv lives, kl kills, wv wave, lf creeps left to spawn,
% md mode (0 title, 1 play, 2 game over), tm clock, T time in mode, bk breather,
% bs best, hp creep hit points, wk creep walk phase, sp spawn timer, an aim angle,
% c creep type (0 = empty slot), x creep x, p aim phase (0 angle, 1 power, 2 flight),
% a aim clock, e time since explosion, tq shell trail, wd wind, fe feather burst, sk sky, su sun, ms message,
% po/uS/uP/uT popup text handle/string/position/timer, sT/lT/vT score/lives/wave text.
% Graphics property names are abbreviated (MATLAB accepts unambiguous prefixes):
% Hi HitTest, Pi PickableParts, X/Y XData/YData, Vi Visible, Ho HorizontalAlignment, St String, Po Position.
g.init = @initState;
g.update = @updateState;
g.render = @renderFrame;
end

function s = initState(ax)
% (the harness already sets the 800x600 world)
P ={'Hi', 'off', 'Pi', 'none'};
L = @(varargin) line(ax, nan, nan, varargin{:}, P{:});
Q = @(x, y, c, varargin) patch(ax, x, y, c, 'EdgeC', 'none', varargin{:}, P{:});
% shared property names and values (cheaper than repeating them)
M = {'LineStyle', 'none', 'Marker', 'o'};
D = [.15 .15 .15];          % dark outline grey
F = 'MarkerF';
G = 'MarkerE';
S = 'MarkerS';
E = 'EdgeC';
W = 'LineW';

% sky gradient, sun, clouds, hills, ground
% (sky, sun and cloud colours are set each frame by the dusk fade)
s.sk = Q([0 800 800 0], [80 80 600 600], 'w', 'FaceVertexCData', ones(4, 3), 'FaceC', 'interp');
s.su = L(M{:}, S, 55, G, [1 .82 .3], W, 4);
s.cl = L(M{:}, S, 32, G, 'none');
% birds: slot 1 enters from the right, slot 2 from the left; velocity 0 = idle
s.bd = L('Color', [.2 .2 .25], W, 2.5);
[s.bp, s.bv] = deal([0 0]);
[s.tm, s.dk, s.bs] = deal(0);
s.F = F;
x = 0:20:800;
Q([x 800 0], [125 + 22 * sin(x / 90) + 12 * sin(x / 37 + 1) 80 80], [.55 .8 .45]);
Q([0 800 800 0], [0 0 80 80], [.36 .7 .26]);
L('X', [0 800], 'Y', [80 80], 'Color', [.25 .55 .2], W, 3);

% the wall, with mortar lines
s.wl = Q([200 225 225 200], [80 80 200 200], [.65 .63 .6], E, [.35 .33 .3], W, 2);
L('X', repmat([200 225 nan], 1, 7), 'Y', kron(97:17:199, [1 1 1]), 'Color', [.42 .4 .37], W, 1.5);
% wind flag on a pole above the wall
L('X', [212 212], 'Y', [200 248], 'Color', D, W, 2);
s.fg = Q(nan, nan, [.9 .2 .2], E, D);

% turret: barrel on an hgtransform, dome base on top
s.tr = hgtransform(ax, P{:});
patch(s.tr, [0 50 50 0], [-6 -6 6 6], [.22 .28 .22], E, 'none', P{:});
k = linspace(0, pi, 20);
s.tb = Q(60 + 32 * cos(k), 80 + 32 * sin(k), [.3 .4 .3], E, [.15 .2 .15], W, 2);
s.ar = L(W, 4);

% creeps: legs, one patch for all 30 bodies, eyes
s.lg = L('Color', D, W, 3);
s.cr = patch(ax, 'Verti', nan(480, 2), 'Faces', reshape(1:480, 16, 30)', 'FaceVertexCData', zeros(30, 3), 'FaceC', 'flat', E, D, W, 1.5, P{:});
s.ey = L(M{:}, S, 7, F, 'w', G, 'k');
k = (0:15)' * pi / 8;
s.kx = sign(cos(k)) .* abs(cos(k)) .^ .5 / 2;
s.ky = (1 + sign(sin(k)) .* abs(sin(k)) .^ .5) / 2;

% shell, trail, explosion, debris
s.tl = L('Color', [1 1 1 .8], W, 2, 'LineStyle', ':');
s.sh = L('Marker', 'o', S, 9, F, D, 'Color', 'k');
s.ex = Q(nan, nan, [1 .6 .1], E, [1 .9 .3], W, 3);
s.pt = L(M{1:3}, 's', S, 5, F, [.45 .3 .15], G, 'none');

% text
tp = [{'FontN', 'Arial', 'FontW', 'bold', 'FontS', 18, 'Color', [.1 .15 .35]}, P];
tc = [tp, {'Ho', 'center'}];
s.sT = text(ax, 16, 575, '', tp{:});
s.vT = text(ax, 400, 575, '', tc{:});
s.lT = text(ax, 784, 572, '', tp{:}, 'Ho', 'right', 'Color', [.85 .1 .15], 'FontS', 24);
s.po = text(ax, 0, 0, '', tc{:});
s.ms = text(ax, 470, 360, '', tc{:}, 'FontS', 30);

% creep types: walker, runner, brute (colour row 4 = damaged brute)
s.W = [32 22 46];
s.H = [34 24 48];
s.C = [.35 .78 .25; 1 .6 .1; .55 .3 .75; .85 .55 .95];
s = resetRun(s);
end

function s = resetRun(s)
% (time, dusk level, birds and best score carry over between runs)
[s.md, s.T, s.p, s.a, s.an, s.pw, s.sc, s.kl, s.wv, s.lf, s.sp, s.b, s.v, s.uT, s.ep, s.uP, s.wd, s.fe] = deal(0);
[s.lv, s.bk, s.e] = deal(5, 2, 9);
s.fl = [0 0];
s.uS = '';
s.tq = nan(1, 14);
[s.pp, s.pv] = deal(zeros(1, 16));
[s.x, s.c, s.hp, s.cv, s.wk] = deal(zeros(1, 30));
end

function s = updateState(s, dt, pressed)
s.tm = s.tm + dt;
s.T = s.T + dt;
s.fl = max(s.fl - dt, 0);
s.uT = max(s.uT - dt, 0);
s.e = s.e + dt;
% debris: complex position and velocity, settles on the grass
s.pv = s.pv - 700i * dt;
s.pp = s.pp + s.pv * dt;
g = imag(s.pp) < 82;
s.pp(g) = real(s.pp(g)) + 82i;
s.pv(g) = 0;
% day fades to dusk over waves 1..10
s.dk = s.dk + (min(max(s.wv - 1, 0) / 9, 1) - s.dk) * dt / 2;
% birds: idle slot k occasionally launches; slot 1 starts at x=820 flying
% left at 70, slot 2 starts at x=-20 flying right at 80
k = find(s.bv == 0 & rand(1, 2) < .15 * dt);
s.bp(k) = 1660 - 840 * k + 1i * (380 + 140 * rand(size(k)));
s.bv(k) = 150 * k - 220;
s.bp = s.bp + s.bv * dt;
s.bv(abs(real(s.bp) - 400) > 440) = 0;
% title (mode 0) and game over (mode 2): a tap starts a fresh run
if s.md ~= 1
    if pressed && s.T > .8
        s = resetRun(s);
        s.md = 1;
    end
    return
end

% aiming: swinging angle (a tap moves to phase 1 and restarts the clock),
% then pulsing power, then flight
s.a = s.a + dt;
if s.p == 0
    s.an = pi / 2 * (1 - abs(mod(s.a / 1.3, 2) - 1));
    s.p = +pressed;
    s.a = s.a * ~pressed;
elseif s.p == 1
    s.pw = 1 - abs(mod(s.a / .9, 2) - 1);
    if pressed
        u = exp(1i * s.an);
        s.b = 60 + 95i + 48 * u;
        s.v = (170 + 470 * s.pw) * u;
        s.p = 2;
        s.tq(:) = s.b;
    end
else
    s = flight(s, dt);
end

% creeps walk; any that reach the wall cost a point
a = s.c > 0;
s.x(a) = s.x(a) - s.cv(a) * dt;
s.wk = s.wk + s.cv * dt / 6;
lk = a & s.x - s.W(max(s.c, 1)) / 2 < 227;
if any(lk)
    s.c(lk) = 0;
    s = hurt(s, nnz(lk), 1);
end

% waves with breathers between them
if s.bk > 0
    s.bk = s.bk - dt;
    if s.bk <= 0
        s.wv = s.wv + 1;
        s.lf = 3 + 2 * s.wv;
        s.wd = (2 * rand - 1) * min(30 * s.wv - 30, 150);
        s.sp = .5;
    end
    return
end
s.sp = s.sp - dt;
i = find(s.c == 0, 1);
if s.lf > 0 && s.sp <= 0 && any(i)
    r = rand;
    t = 1 + (s.wv > 1 && r < .35) + 2 * (s.wv > 2 && r > .78);
    v = [1 1.9 .6];
    s.c(i) = t;
    s.x(i) = 830;
    s.hp(i) = 1 + (t == 3);
    s.cv(i) = min(34 + 2.4 * s.wv, 70) * v(t);
    s.wk(i) = 6 * rand;
    s.lf = s.lf - 1;
    s.sp = max(.9, 3.2 - .22 * s.wv) * (.7 + .6 * rand);
end
if s.lf == 0 && ~any(s.c)
    s.bk = 3;
end
end

function s = flight(s, dt)
% four sub-steps so fast shells cannot skip through the wall.
% j = 1 hit the wall, 2 fell on the turret; either costs a point.
for k = 1:4
    s.v = s.v + (s.wd - 520i) * dt / 4;
    s.b = s.b + s.v * dt / 4;
    x = real(s.b);
    y = imag(s.b);
    t = max(s.c, 1);
    % bird strike: mid-air burst of feathers, +50
    j = abs(s.b - s.bp) < 15 & s.bv ~= 0;
    if any(j)
        s.bv(j) = 0;
        s = pop(explode(s), '+50', s.b + 40i);
        s.fe = 1;
        s.sc = s.sc + 50;
        return
    end
    j = find([x > 200 && x < 225 && y < 200, imag(s.v) < 0 && abs(s.b - 60 - 85i) < 36], 1);
    if j
        s = hurt(explode(s), 1, j + 1);
        return
    end
    if y <= 80 || any(s.c > 0 & abs(x - s.x) < s.W(t) / 2 & y < 88 + s.H(t))
        s.b = x + 1i * max(y, 80);
        s = explode(s);
        return
    end
end
s.tq = [s.tq(2:end) s.b];
if abs(x - 400) > 430
    [s.p, s.a] = deal(0);
end
end

function s = explode(s)
[s.p, s.a, s.e, s.fe] = deal(0);
s.ep = s.b;
s.pp(:) = s.b;
s.pv = 500 * rand(1, 16) - 250 + 150i + 300i * rand(1, 16);
% splash damage; multi-kills multiply the points
t = max(s.c, 1);
hit = s.c > 0 & abs(s.x + 1i * (88 + s.H(t) / 2) - s.b) < 55 + s.W(t) / 2;
s.hp(hit) = s.hp(hit) - 1;
dead = hit & s.hp <= 0;
n = nnz(dead);
if n
    v = [10 15 25];
    p = n * sum(v(s.c(dead)));
    s.sc = s.sc + p;
    % g = 1 when the kill count passes a multiple of 25: extra life
    s.kl = s.kl + n;
    g = mod(s.kl, 25) < n;
    s.lv = s.lv + g;
    s.c(dead) = 0;
    q = sprintf('+%d  x%d', p, n);
    s = pop(s, [q(1:end - 4 * (n < 2)) repmat('  EXTRA LIFE!', 1, g)], s.b + 70i);
end
end

function s = pop(s, t, p)
% floating score popup: text t rising from point p for one second
s.uS = t;
s.uP = p;
s.uT = 1;
end

function s = hurt(s, n, k)
% k: 1 creep reached the wall, 2 shell hit the wall, 3 shell hit the turret
% (1 and 2 flash the wall, 3 flashes the turret base)
s.lv = s.lv - n;
s.fl(k - (k > 1)) = .5;
p = [245 + 150i, 212 + 220i, 60 + 140i];
s = pop(s, '-1', p(k));
if s.lv <= 0
    [s.lv, s.T, s.p] = deal(0);
    s.md = 2;
    s.bs = max(s.bs, s.sc);
end
end

function renderFrame(~, s)
% XY sets a line/patch from complex points z = x + 1i*y
XY = @(h, z, varargin) set(h, 'X', real(z), 'Y', imag(z), varargin{:});

% sky, sun and clouds blend from midday (d = 0) to sunset (d = 1)
% (rows: horizon colour, sky-top colour; the sun sinks behind the hills)
d = s.dk;
c = [.78 .92 1; .35 .6 .95] + d * [.22 -.3 -.6; .15 -.22 -.23];
s.sk.FaceVertexCData = c([1 1 2 2], :);
XY(s.su, 650 + 1i * (480 - 330 * d), s.F, [1, .93 - .43 * d, .4 - .25 * d]);
z = mod([110 390 660] + 12 * s.tm + 60, 920) - 60 + [-24; 0; 24; 6] + 1i * ([470 525 430] + [0; 10; 0; 16]);
XY(s.cl, z(:), s.F, 1 - d * [0 .25 .3]);

% birds: flapping V shapes
f = 1i * 6 * sin(12 * s.tm + [0 2]);
z = s.bp + [f - 12; 0 * f; f + 12; f * nan];
z(:, s.bv == 0) = nan;
XY(s.bd, z(:));

% wind flag: length and direction follow the wind, flutters, droops in calm
w = s.wd / 150;
XY(s.fg, 212 + [247i, 233i, 34 * w + 1i * (228 + 12 * abs(w) + 3 * sin(9 * s.tm))]);

% creeps: bodies, eyes, walking legs (NaN hides unused slots)
t = max(s.c, 1);
w = s.W(t);
h = s.H(t);
b = 88 + 2 * abs(sin(s.wk));
s.x(s.c == 0) = nan;
X = s.x + w .* s.kx;
Y = b + h .* s.ky;
set(s.cr, 'Verti', [X(:) Y(:)], 'FaceVertexCData', s.C(t + (t == 3 & s.hp < 2), :));
Y = [b; b];
z = s.x + w .* [-.3; -.04] + 1i * (Y + .7 * [h; h]);
XY(s.ey, z(:));
X = s.x + w .* [-.22; .22];
d = 5 * sin(s.wk) .* [1; -1];
z = [X(:)' + 1i * Y(:)'; X(:)' + d(:)' + 80i; d(:)' * nan * (1 + 1i)];
XY(s.lg, z(:));

% turret, aim arrow (head built from complex points), flashes
s.tr.Matrix = makehgtform('translate', [60 95 0], 'zrotate', s.an);
L = 147 - (s.p == 1) * (70 - 95 * s.pw);
z = 60 + 95i + exp(1i * s.an) * [52, L, nan, L - 16 + 10i, L, L - 16 - 10i];
XY(s.ar, z, 'Color', [.15 .2 .5] + (s.p == 1) * [.05 + .8 * s.pw, .6 - .6 * s.pw, -.4], 'Vi', s.md == 1 && s.p < 2);
f = s.fl / .5;
s.wl.FaceColor = [.65 .63 .6] + f(1) * [.35 -.45 -.45];
s.tb.FaceColor = [.3 .4 .3] + f(2) * [.7 -.2 -.2];

% shell, trail, explosion, debris
XY(s.tl, s.tq, 'Vi', s.p == 2);
XY(s.sh, s.b, 'Vi', s.p == 2);
XY(s.ex, s.ep + (12 + 55 * min(s.e / .2, 1)) * exp(1i * (0:24) / 4), 'FaceA', max(0, .85 - 1.7 * s.e), 'Vi', s.e < .5);
XY(s.pt, s.pp, s.F,[.45 .3 .15] + s.fe * [.55 .7 .85], 'Vi', s.e < 1.2);

% text
s.sT.String = sprintf('SCORE %d', s.sc);
s.vT.String = sprintf('WAVE %d', max(s.wv, 1));
s.lT.String = repmat(char(9829), 1, s.lv);
set(s.po, 'St', s.uS(1:end * (s.uT > 0)), 'Po', [real(s.uP), imag(s.uP) + 40 - 40 * s.uT]);
m = {{'OVER THE WALL', '', 'tap to start'}, sprintf('WAVE %d', s.wv + 1), {'GAME OVER', sprintf('score %d   best %d', s.sc, s.bs), 'tap to play again'}, ''};
s.ms.String = m{s.md + 1 + 2 * (s.md == 1 && s.bk <= 0)};
end
Play Game
Preview

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