Pendulam swing

Vinay Ramesh
/
Pendulam swing
on 2 Nov 2026
7
73
36
1
6911
game.m
function g = game()
%game Pendulum Swing -- a one-button rope-swinging game.
%
%   Tap to let go of the rope and fly. Tap again in mid-air to grab the
%   highlighted anchor. Swing further right to score. Touch the lava and
%   it's over.

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

function s = initState(ax)
s.ax = ax;
s.N = 12;              % anchor pool size
s.grav = 1100;         % gravity (px/s^2)
s.maxR = 330;         % max rope length / grab range
s.r = 12;              % player radius
s.lava = 40;           % lava height

ax.Color = [0.04 0.03 0.10];
ax.YDir = 'normal';
ax.XLim = [0 800];
ax.YLim = [0 600];
ax.Clipping = 'on';

nf = {'HitTest', 'off', 'PickableParts', 'none'};

% Parallax stars (screen-space X stored in state, shifted in render)
s.starX = rand(1, 70) * 800;
s.starY = 60 + rand(1, 70) * 540;
s.g.stars = line(ax, s.starX, s.starY, 'LineStyle', 'none', ...
    'Marker', '.', 'MarkerSize', 6, 'Color', [0.6 0.6 0.9], nf{:});

% Grab-range ring, trail, rope
s.circ = linspace(0, 2*pi, 64);
s.g.range = line(ax, nan, nan, 'Color', [0.3 0.9 1 0.18], ...
    'LineWidth', 1, 'LineStyle', '--', nf{:});
s.g.trail = line(ax, nan, nan, 'Color', [1 0.3 0.8 0.5], ...
    'LineWidth', 3, nf{:});
s.g.rope = line(ax, nan, nan, 'Color', [0.9 0.95 1], 'LineWidth', 2, nf{:});

% Anchor pool
s.g.anc = gobjects(1, s.N);
for i = 1:s.N
    s.g.anc(i) = rectangle(ax, 'Position', [0 0 1 1], ...
        'Curvature', [1 1], 'FaceColor', [0.3 0.9 1], ...
        'EdgeColor', [0.8 1 1], 'LineWidth', 1.5, nf{:});
end

% Player
s.g.player = rectangle(ax, 'Position', [0 0 1 1], 'Curvature', [1 1], ...
    'FaceColor', [1 0.35 0.75], 'EdgeColor', [1 0.85 0.95], ...
    'LineWidth', 2, nf{:});

% Lava
s.g.lava = rectangle(ax, 'Position', [0 0 820 s.lava], ...
    'FaceColor', [1 0.3 0.05], 'EdgeColor', 'none', nf{:});
s.g.lavaTop = line(ax, nan, nan, 'Color', [1 0.85 0.2], 'LineWidth', 3, nf{:});

% HUD
s.g.score = text(ax, 20, 570, '', 'Color', 'w', 'FontSize', 16, ...
    'FontWeight', 'bold', nf{:});
s.g.msg = text(ax, 400, 330, '', 'Color', 'w', 'FontSize', 22, ...
    'FontWeight', 'bold', 'HorizontalAlignment', 'center', nf{:});
s.g.sub = text(ax, 400, 300, '', 'Color', [0.7 0.9 1], 'FontSize', 14, 'VerticalAlignment', 'top', ...
    'HorizontalAlignment', 'center', nf{:});

s.best = 0;
s = resetRound(s);
end

function s = resetRound(s)
s.ancX = zeros(1, s.N);
s.ancY = zeros(1, s.N);
s.ancX(1) = 220;
s.ancY(1) = 470;
s.nextX = s.ancX(1);
for i = 2:s.N
    [s, s.ancX(i), s.ancY(i)] = nextAnchor(s);
end

s.att = true;          % attached to rope?
s.ai = 1;              % anchor index we hang from
s.L = 190;
s.th = -1.0;           % rope angle from straight down (rad)
s.w = 0;               % angular velocity
s.vx = 0;
s.vy = 0;
s = attachedPos(s);
s.cam = 0;
s.score = 0;
s.started = false;
s.over = false;
s.overT = 0;
s.time = 0;
s.trail = repmat([s.px; s.py], 1, 18);
s.tgt = 0;
s.lastX = -inf;
end

function [s, x, y] = nextAnchor(s)
% Gaps and height spread grow with distance travelled.
d = min(s.nextX / 6000, 1);
x = s.nextX + 170 + 110*d + rand*(60 + 60*d);
y = 470 + (rand - 0.5) * (80 + 140*d);
s.nextX = x;
end

function s = attachedPos(s)
s.px = s.ancX(s.ai) + s.L * sin(s.th);
s.py = s.ancY(s.ai) - s.L * cos(s.th);
end

function s = updateState(s, dt, pressed)
s.time = s.time + dt;

if s.over
    s.overT = s.overT + dt;
    if pressed && s.overT > 0.5
        s = resetRound(s);
    end
    return
end

if pressed && ~s.started
    s.started = true;       % first tap only dismisses the title
elseif pressed
    if s.att
        % Let go: convert angular motion into linear velocity
        v = s.L * s.w * 1.15;
        s.vx = v * cos(s.th);
        s.vy = v * sin(s.th);
        s.att = false;
        s.lastX = s.ancX(s.ai);
    elseif s.tgt > 0
        % Grab the highlighted anchor, keeping tangential speed
        s.ai = s.tgt;
        dx = s.px - s.ancX(s.ai);
        dy = s.py - s.ancY(s.ai);
        s.L = max(hypot(dx, dy), 50);
        s.th = atan2(dx, -dy);
        s.w = (s.vx*cos(s.th) + s.vy*sin(s.th)) / s.L;
        s.att = true;
    end
end

% Physics in substeps for stability
n = 4;
h = dt / n;
for k = 1:n
    if s.att
        s.w = s.w - (s.grav / s.L) * sin(s.th) * h;
        % Gentle pump so a swing builds up while hanging, until its
        % amplitude reaches ~1.2 rad (from the energy of the swing)
        if cos(s.th) - s.w^2 * s.L / (2*s.grav) > cos(1.2)
            s.w = s.w + sign(s.w) * 0.5 * h;
        end
        s.th = s.th + s.w * h;
    else
        s.vy = s.vy - s.grav * h;
        s.px = s.px + s.vx * h;
        s.py = s.py + s.vy * h;
    end
end
if s.att
    s = attachedPos(s);
end

% Lava = game over
if s.py - s.r < s.lava
    s.over = true;
    s.overT = 0;
    s.best = max(s.best, s.score);
end

% Nearest anchor ahead of the one we let go of, within range
% (shown highlighted, grabbed on tap)
s.tgt = 0;
if ~s.att
    dd = hypot(s.ancX - s.px, s.ancY - s.py);
    dd(s.ancX <= s.lastX) = inf;
    [m, i] = min(dd);
    if m <= s.maxR
        s.tgt = i;
    end
end

% Camera follows, never scrolls back
s.cam = max(s.cam, s.px - 280);

% Recycle anchors that left the screen
for i = 1:s.N
    if s.ancX(i) < s.cam - 60 && ~(s.att && i == s.ai)
        [s, s.ancX(i), s.ancY(i)] = nextAnchor(s);
    end
end

if s.started
    s.score = max(s.score, floor((s.px - 220) / 10));
end
s.trail = [s.trail(:, 2:end), [s.px; s.py]];
end

function renderFrame(~, s)
c = s.cam;
s.ax.XLim = [c c + 800];

% Parallax stars
s.g.stars.XData = c + mod(s.starX - c*0.25, 800);

% Anchors
for i = 1:s.N
    if i == s.tgt
        fc = [1 0.95 0.3];
        rr = 11;
    elseif s.att && i == s.ai
        fc = [0.95 0.95 1];
        rr = 9;
    else
        fc = [0.3 0.9 1];
        rr = 8;
    end
    s.g.anc(i).Position = [s.ancX(i) - rr, s.ancY(i) - rr, 2*rr, 2*rr];
    s.g.anc(i).FaceColor = fc;
end

% Rope or range ring
if s.att
    s.g.rope.XData = [s.ancX(s.ai) s.px];
    s.g.rope.YData = [s.ancY(s.ai) s.py];
    % Green rope = good moment to let go (forward upswing)
    if s.w > 0 && s.th > 0.3 && s.th < 1.1
        s.g.rope.Color = [0.4 1 0.5];
        s.g.rope.LineWidth = 3;
    else
        s.g.rope.Color = [0.9 0.95 1];
        s.g.rope.LineWidth = 2;
    end
    s.g.range.XData = nan;
    s.g.range.YData = nan;
else
    s.g.rope.XData = nan;
    s.g.rope.YData = nan;
    s.g.range.XData = s.px + s.maxR * cos(s.circ);
    s.g.range.YData = s.py + s.maxR * sin(s.circ);
end

s.g.trail.XData = s.trail(1, :);
s.g.trail.YData = s.trail(2, :);
s.g.player.Position = [s.px - s.r, s.py - s.r, 2*s.r, 2*s.r];

% Lava with a wobbly glowing top
s.g.lava.Position = [c - 10, 0, 820, s.lava];
lx = c + (0:20:800);
s.g.lavaTop.XData = lx;
s.g.lavaTop.YData = s.lava + 3*sin(lx/40 + s.time*4);

% HUD
s.g.score.Position = [c + 20, 570, 0];
s.g.score.String = sprintf('%d m   best %d m', s.score, max(s.best, s.score));
s.g.msg.Position = [c + 400, 330, 0];
s.g.sub.Position = [c + 400, 300, 0];
if s.over
    s.g.msg.String = sprintf('Burned! %d m', s.score);
    s.g.sub.String = 'Tap to try again';
elseif ~s.started
    s.g.msg.String = 'PENDULUM SWING';
    s.g.sub.String = {'Tap when the rope turns GREEN to let go', ...
        'Tap again when a dot turns YELLOW to grab it'};
else
    s.g.msg.String = '';
    s.g.sub.String = '';
end
end
Play Game
Preview

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