Coin Pusher

Mike Croucher
/
Coin Pusher
on 10 Nov 2026
4
43
19
2
9087
game.m
function g = game()
%game Coin Pusher -- a one-button arcade coin pusher, seen from the front.
%   A coin chute slides back and forth above the shelf. TAP to drop a
%   coin. A chrome pusher slides in and out at the back of the shelf,
%   shoving the pile toward the front edge; coins that fall off the front
%   drop into the tray and come back to you. Every 12 coins won, a prize
%   lands on the shelf: a cyan gem (100 points) or a big gold coin (worth
%   5 coins). Start with 20 coins; the run ends when you are out of coins
%   and nothing has fallen for 6 seconds.
%
%   Shelf coordinates: u across (-130..130), v depth from the front edge
%   (0..150), stored as complex c = u + iv. Screen: x = 400 + u*k,
%   y = 170 + v, where k = 2 - .4v/150 shrinks with depth (perspective).
%   Coins may overlap by 30% (they sit on each other); beyond that they
%   push apart, so a crowded pile passes the pusher's shove to the edge.
%
%   Field key: md mode (0 title, 1 play, 2 game over), T time in mode,
%   t clock, c position, k type (0 empty, 1 coin, 2 gem, 3 gold coin),
%   bk coins in hand, sc score, bs best, cu chute position, dz drop
%   progress (-1 = nothing falling), du drop position, w/wv won coins
%   falling into the tray (screen position, speed), q time since a coin
%   fell, nd coins won since the last prize, uS/uP/uT popup.
%   Tables: R radius, N points, B coins returned, C colour, S outlines.
g.init = @initState;
g.update = @updateState;
g.render = @renderFrame;
end

function s = initState(ax)
ax.Color = [.07 .02 .1];
Q = @(x, y, c, varargin) patch(ax, x, y, c, 'EdgeC', 'none', varargin{:});
L = @(varargin) line(ax, nan, nan, varargin{:});
T = @(x, y, varargin) text(ax, x, y, '', 'FontW', 'bold', 'FontN', 'Arial', 'Ho', 'center', varargin{:});
G = @(x, y, c) Q(x, y, permute(c, [1 3 2]));
% cabinet: tray, back wall and shelf (shaded), neon edges
Q([130 670 670 130], [25 25 155 155], [.03 0 .05], 'EdgeC', [1 .2 .7], 'LineW', 2);
G([190; 610; 610; 190], [320; 320; 520; 520], [.3 .1 .38; .3 .1 .38; .1 .02 .16; .1 .02 .16]);
G([140; 660; 610; 190], [170; 170; 320; 320], [.55 .3 .6; .55 .3 .6; .3 .12 .38; .3 .12 .38]);
L('X', [140 250 nan 550 660], 'Y', [170 170 nan 170 170], 'Color', [.9 .1 .2], 'LineW', 6);
L('X', [140 190 190 nan 660 610 610], 'Y', [170 320 520 nan 170 320 520], 'Color', [.3 .9 1], 'LineW', 3);
% pusher: top and front face
s.pt = Q(nan, nan, [.55 .55 .68]);
s.pf = Q(nan, nan, [.4 .4 .52], 'EdgeC', [.9 .9 1]);
% coins and prizes: one patch, a rim face then a top face per object
s.cn = patch(ax, 'Verti', nan(2160, 2), 'Faces', reshape(1:2160, 12, 180)', 'FaceVertexCData', zeros(180, 3), 'FaceC', 'flat', 'EdgeC', [.45 .3 0]);
% MATLAB logo mascot: the L-shaped membrane, projected and shaded,
% drawn back to front with the flat cut-out corner left out
[x, y] = meshgrid(-1:.1:1);
z = membrane(1, 10);
a = reshape(1:441, 21, 21);
a = a(1:20, 1:20);
f = a(:) + [0 1 22 21];
f = f(any(z(f), 2), :);
[~, o] = sort(sum(x(f) + y(f), 2), 'descend');
f = f(o, :);
q = min(max(.35 + 2 * sum(z(f(:, [2 3])) - z(f(:, [1 4])), 2) + .5 * mean(z(f), 2), 0), 1);
s.lg = patch(ax, 'Faces', f, 'Verti', nan(441, 2), 'FaceVertexCData', [.7 + .3 * q, .12 + .55 * q, .05 + .12 * q], 'FaceC', 'flat', 'EdgeC', 'none');
s.L = 12 * (x(:) - y(:)) + 1i * (5 * (x(:) + y(:)) + 20 * z(:));
s.sp = L('LineStyle', 'none', 'Marker', 'p', 'MarkerFaceC', 'w', 'MarkerEdgeC', [1 1 .6]);
s.lp = L('X', [250 550], 'Y', [170 170], 'LineW', 4);
% chute, the coin in or falling from it, coins falling into the tray
s.ch = Q(nan, nan, [.75 .75 .85], 'EdgeC', [.3 .9 1], 'LineW', 2);
M = {'LineStyle', 'none', 'Marker', 'o', 'MarkerS', 15, 'MarkerFaceC', [1 .8 .15], 'MarkerEdgeC', [.45 .3 0], 'LineW', 2};
s.fc = L(M{:});
s.wc = L(M{:});
% marquee with chasing lights round it and up the cabinet sides
s.mq = Q([150 650 650 150], [530 530 592 592], [.2 0 .25], 'EdgeC', [1 .2 .7], 'LineW', 3);
s.ti = T(400, 561, 'FontS', 30, 'Color', [1 .9 .2], 'St', 'COIN PUSHER');
x = linspace(160, 640, 16);
y = linspace(40, 500, 12);
s.lt = scatter(ax, [x x 122 + 0 * y 678 + 0 * y], [524 + 0 * x 598 + 0 * x y y], 45, zeros(56, 3), 'filled');
% text
s.bT = T(150, 100, 'FontS', 18, 'Color', [1 .85 .2], 'Ho', 'left');
s.sT = T(650, 100, 'FontS', 18, 'Color', [.3 .9 1], 'Ho', 'right');
s.po = T(0, 0, 'FontS', 18, 'Color', 'w');
s.ms = T(400, 300, 'FontS', 17, 'Color', [1 .9 .3], 'Ba', [.15 0 .2], 'EdgeC', [1 .2 .7], 'Margin', 14, 'LineW', 3);
set(ax.Children, 'Hi', 'off', 'Pi', 'none');
% tables: coin, gem, gold coin, MATLAB logo (drawn by its own patch)
e = exp(2i * pi * (0:11) / 12);
c = real(e) + .45i * imag(e);
s.S = [c; (real(e) + .8i * imag(e)) ./ (abs(real(e)) + abs(imag(e))); c; nan(1, 12)];
s.R = [11 14 16 24];
s.N = [10 100 50 250];
s.B = [1 0 5 0];
s.C = [1 .8 .15; .3 .9 1; 1 .95 .55; 1 .5 .1];
[s.t, s.bs, s.ph] = deal(0);
s.o = .95;
s.H = 75;
s = resetRun(s);
end

function s = resetRun(s)
[s.md, s.T, s.sc, s.nd, s.uT, s.uP, s.q, s.ds, s.cb] = deal(0);
s.wt = 9;
[s.bk, s.dz, s.du, s.cu, s.uS, s.lb, s.la] = deal(20, -1, 0, 0, '', 0, 9);
[s.w, s.wv] = deal(nan(1, 12));
% a fresh pile of coins with a MATLAB logo in it, settled
s.k = [ones(1, 45), 4, zeros(1, 44)];
s.c = [230 * rand(1, 45) - 115 + 1i * (5 + 85 * rand(1, 45)), 60i, zeros(1, 44)];
for n = 1:150
    s.t = s.t + 1 / 30;
    s = phys(s);
    s.k(imag(s.c) < 0) = 0;
end
end

function s = updateState(s, dt, pressed)
s.t = s.t + dt;
s.T = s.T + dt;
s.q = s.q + dt;
s.uT = max(s.uT - dt, 0);
s.la = s.la + dt;
s.wt = s.wt + dt;
% the score display rolls up toward the real score like an odometer
s.ds = min(s.sc, s.ds + dt * max(40, 3 * (s.sc - s.ds)));
% chasing lights: faster while a combo of wins is running
s.ph = s.ph + dt * (10 + 5 * min(s.cb, 6) * (s.wt < 1));
% won coins tumble into the tray
s.wv = s.wv - 900 * dt;
s.w = s.w + 1i * s.wv * dt;
s.w(imag(s.w) < 45) = nan;
if s.md ~= 1
    if pressed && s.T > .8
        s = resetRun(s);
        s.md = 1;
    end
    return
end

% the chute sweeps steadily across; a tap drops a coin from it
s.cu = 116 * (1 - 2 * abs(mod(.45 * s.t, 2) - 1));
if pressed && s.dz < 0 && s.bk > 0
    [s.dz, s.du, s.bk] = deal(0, s.cu, s.bk - 1);
end
f = 95 + 12 * sin(2.2 * s.t);
if s.dz >= 0
    s.dz = s.dz + dt;
    if s.dz > .35
        s = put(s, s.du + 1i * (f - 12), 1);
        s.dz = -1;
    end
end
% every 12 coins won, a prize drops in front of the pusher
if s.nd >= 12
    s.nd = 0;
    t = 2 + (rand < .5);
    t(rand < .3 && ~any(s.k == 4)) = 4;
    s = put(s, 200 * rand - 100 + 1i * (f - 18), t);
end
s = phys(s);

% anything pushed past the front edge falls and is won
j = find(s.k & imag(s.c) < 0);
for i = j(abs(real(s.c(j))) < s.H)
    t = s.k(i);
    s.sc = s.sc + s.N(t);
    s.bk = s.bk + s.B(t);
    s.nd = s.nd + 1;
    m = find(isnan(s.w), 1);
    [s.w(m), s.wv(m)] = deal(400 + 2 * real(s.c(i)) + 165i, 0);
    if t > 1
        [s.uS, s.uP, s.uT] = deal(sprintf('+%d', s.N(t) + 10 * s.B(t)), s.w(m) + 40i, 1);
    end
end
% coins won within a second of each other build a combo
n = nnz(abs(real(s.c(j))) < s.H);
if n
    [s.cb, s.wt] = deal(s.cb * (s.wt < 1) + n, 0);
end
s.k(j) = 0;
s.q = s.q * isempty(j);
if s.bk == 0 && s.dz < 0 && s.q > 6
    [s.md, s.T, s.bs] = deal(2, 0, max(s.bs, s.sc));
end
end

function s = put(s, z, t)
i = find(~s.k, 1);
if any(i)
    % the new arrival bounces as it lands
    [s.c(i), s.k(i), s.lb, s.la] = deal(z, t, i, 0);
end
end

function s = phys(s)
% overlapping objects push apart (beyond a 30% allowance), then the side
% walls and the pusher face keep them on the shelf
f = 95 + 12 * sin(2.2 * s.t);
a = find(s.k);
z = s.c(a);
r = s.R(s.k(a));
for n = 1:3
    d = z - z.';
    g = abs(d);
    z = z + sum(d ./ max(g, 1e-9) .* max(s.o * (r + r.') - g, 0) / 2, 1);
    z = min(max(real(z), r - 130), 130 - r) + 1i * min(imag(z), f - r);
end
s.c(a) = z;
end

function renderFrame(~, s)
XY = @(h, z, varargin) set(h, 'XData', real(z), 'YData', imag(z), varargin{:});
% pusher: front face at depth f, top surface back to the wall
f = 95 + 12 * sin(2.2 * s.t);
x = 260 - .52 * f;
XY(s.pf, 400 + [-x x x -x] + 1i * (170 + f + [0 0 24 24]));
XY(s.pt, 400 + [-x x 208 -208] + 1i * (194 + [f f 150 150]));
% coins, back to front; each object is a rim face then a top face
a = find(s.k);
[~, o] = sort(imag(s.c(a)), 'descend');
a = a(o);
z = s.c(a);
t = s.k(a);
k = 2 - .4 * imag(z) / 150;
% the newest arrival bounces twice and wobbles (its outline squashes)
h = 16 * exp(-6 * s.la) * abs(sin(10 * s.la));
b = a == s.lb;
S = s.S(t, :).';
F = 400 + 170i + real(z) .* k + 1i * (imag(z) + b * h) + s.R(t) .* k .* (real(S) + 1i * imag(S) .* (1 + b * .6 * exp(-5 * s.la) * sin(30 * s.la)));
Z = nan(24, 90);
Z(:, 1:numel(a)) = [F - 4i * k; F];
Z = reshape(Z, 12, []);
C = zeros(6, 90);
C(:, 1:numel(a)) = [.6 * s.C(t, :)'; s.C(t, :)'];
set(s.cn, 'Verti', [real(Z(:)), imag(Z(:))], 'FaceVertexCData', reshape(C, 3, [])');
% the MATLAB logo mascot rocks gently where it sits
i = find(s.k == 4);
z = sum(s.c(i));
k = 2 - .4 * imag(z) / 150;
z = 400 + 170i + real(z) * k + 1i * (imag(z) + h * any(i == s.lb)) + 1.1 * k * s.L * exp(.12i * sin(7 * s.t));
set(s.lg, 'Verti', [real(z), imag(z)], 'Vi', any(i));
% prizes twinkle
p = s.k > 1;
XY(s.sp, 400 + 170i + real(s.c(p)) .* (2 - .4 * imag(s.c(p)) / 150) + 1i * imag(s.c(p)) + 12i, 'MarkerS', 6 + 5 * abs(sin(6 * s.t)));
set(s.lp, 'Color', [1 .85 .2] + (s.q < .25) * [0 .15 .8]);
% chute, the coin waiting in it or falling to the shelf, won coins
x = 400 + 1.6 * s.cu;
XY(s.ch, x + [-24 24 9 -9] + 1i * [485 485 462 462]);
y = s.dz >= 0;
XY(s.fc, 400 + (1.6 + .4 * y) * (y * s.du + ~y * s.cu) + 1i * (455 - (297 - f) * min(s.dz / .35, 1) * y), 'Vi', s.md == 1 && (y || s.bk > 0));
XY(s.wc, s.w);
% chasing lights
C = [1 .9 .2; 1 .2 .6; .2 .8 1];
set(s.lt, 'CData', C(1 + mod((1:56)' + floor(s.ph), 3), :));
% the marquee throbs brighter after each win
w = exp(-4 * s.wt) * (.85 + .15 * sin(25 * s.wt));
set(s.ti, 'Color', [1, .9 + .1 * w, .2 + .8 * w], 'FontS', 30 + 5 * w);
set(s.mq, 'EdgeC', [1, .2 + .7 * w, .7 + .3 * w], 'LineW', 3 + 4 * w);
% text
set(s.bT, 'St', sprintf('COINS %d', s.bk));
set(s.sT, 'St', sprintf('SCORE %d', floor(s.ds)));
set(s.po, 'St', s.uS, 'Po', [real(s.uP), imag(s.uP) + 40 * (1 - s.uT)], 'Vi', s.uT > 0);
m = {['COIN PUSHER\n\nTap to drop a coin from the sliding chute.\n' ...
    'Push coins off the shelf to win them back.\nGems, gold coins and the MATLAB logo are worth extra!\n\nTap to start'], '', ...
    'OUT OF COINS\n\nScore %d    Best %d\n\nTap to play again'};
set(s.ms, 'St', sprintf(m{s.md + 1}, s.sc, s.bs), 'Vi', s.md ~= 1);
end
Play Game
Preview

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