Pivot Golf

Ned Gulley
/
Pivot Golf
on 3 Nov 2026
7
54
28
2
8962
game.m
function g = game()
%game Pivot Golf: a spinning segment that walks by swapping pivots.
%
%   The segment rotates around its pivot (the big dot). Tap SPACE or
%   click to swap the pivot to the other end and reverse the spin.
%   Sweep the segment over the red flag to collect it. Bumpers (teal)
%   reverse your spin, bombs (dark red) end the game, and pink speed pills spin
%   you 50% faster for 5 s. Every 3 flags starts a new level: open
%   minefields alternate with walls of mines broken by doors.

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

function s = initState(ax)
s.W = 800;
s.H = 600;
s.L0 = 112.5;                  % base segment length (px)
s.w0 = 2*pi/2.5;               % rad/s, ~1 rev per 2.5 s
s.per = 3;                     % period of the length wobble (s)
s.rB = 12;                     % bomb, bumper, pill radii
s.rU = 16;
s.rP = 10;
s.nB = 90;                     % pool sizes
s.nU = 16;
s.nP = 3;
s.fpl = 3;                     % flags per level
a = (0:47)*pi/24;
s.circ = [cos(a); sin(a)]';
s = resetRound(s);

ax.YDir = 'reverse';
ax.Color = [0.10 0.12 0.18];

% Circles are edgeless filled discs: a rim-colored disc behind a slightly
% smaller fill disc. Patch edges leave a spur where the outline closes.
np = {'HitTest','off','PickableParts','none'};
disc = @(n, c) patch(ax, nan(48, n), nan(48, n), c, ...
    'EdgeColor', 'none', np{:});
s.g.uR = disc(s.nU, [0.85 1 1]);
s.g.u = disc(s.nU, [0.2 0.75 0.75]);
s.g.bR = disc(s.nB, [1 0.45 0.2]);
s.g.b = disc(s.nB, [0.45 0.05 0.08]);
s.g.pR = disc(s.nP, [1 0.9 0.97]);
s.g.p = disc(s.nP, [1 0.35 0.75]);
s.g.seg = line(ax, 0, 0, 'LineWidth', 4, np{:});
s.g.tip = line(ax, 0, 0, 'LineStyle', 'none', 'Marker', 'o', ...
    'MarkerSize', 9, 'MarkerFaceColor', [0.6 0.8 1], ...
    'MarkerEdgeColor', 'none', np{:});
s.g.piv = line(ax, 0, 0, 'LineStyle', 'none', 'Marker', 'o', ...
    'MarkerSize', 18, 'MarkerFaceColor', [1 0.8 0.2], ...
    'MarkerEdgeColor', 'none', np{:});
s.g.pole = line(ax, 0, 0, 'Color', [0.85 0.85 0.85], 'LineWidth', 2, np{:});
s.g.flag = patch(ax, [0 0 0], [0 0 0], [0.95 0.2 0.2], 'EdgeColor', 'none', np{:});
s.g.boomR = disc(1, [1 0.9 0.4]);
s.g.boom = disc(1, [1 0.6 0.1]);
s.g.hud = text(ax, 20, 24, '', 'Color', 'w', 'FontSize', 14, np{:});
s.g.msg = text(ax, s.W/2, s.H/2, '', 'Color', 'w', 'FontSize', 22, ...
    'FontWeight', 'bold', 'HorizontalAlignment', 'center', np{:});
end

function s = resetRound(s)
s.omega = s.w0;
s.L = s.L0;
s.Lhit = s.L0;
s.t = 0;
s.amp = 0;                     % wobble amplitude, fraction of L0
s.ampGoal = 0;
s.pivot = [s.W/2 s.H/2];
s.theta = 0;
s.flags = 0;
s.level = 1;
s.tee = true;                  % frozen until the tee-off tap
s.flag = [600 150];
s.bombs = zeros(0, 2);
s.bumps = zeros(0, 2);
s.armed = false(0, 1);
s.pills = zeros(0, 2);
s.boostT = 0;
s.over = false;
s.boomT = 0;
s.boomAt = [0 0];
end

function s = updateState(s, dt, pressed)
if s.over
    s.boomT = s.boomT + dt;
    if pressed && s.boomT > 0.6
        s = resetRound(s);
    end
    return
end
if s.tee
    s.tee = ~pressed;
    return
end

if pressed
    s = swapPivot(s);
end

% Length wobble; the amplitude eases toward its goal so L never jumps.
s.t = s.t + dt;
s.boostT = max(s.boostT - dt, 0);
s.amp = s.amp + max(min(s.ampGoal - s.amp, 0.1*dt), -0.1*dt);
Lprev = s.L;
s.L = s.L0*(1 + s.amp*sin(2*pi*s.t/s.per));
s.Lhit = max(Lprev, s.L);

th0 = s.theta;
dth = s.omega*dt*(1 + 0.5*(s.boostT > 0));
s.theta = mod(th0 + dth, 2*pi);

hit = sweptHit(s, th0, dth, s.bombs, s.rB);
if any(hit)
    s.over = true;
    s.boomT = 0;
    s.boomAt = s.bombs(find(hit, 1), :);
    return
end

hit = sweptHit(s, th0, dth, s.pills, s.rP);
if any(hit)
    s.pills(hit, :) = [];
    s.boostT = 5;
end

if sweptHit(s, th0, dth, s.flag, 10)
    s.flags = s.flags + 1;
    if mod(s.flags, s.fpl) == 0
        s = newLevel(s);
    else
        s = spawnFlag(s);
    end
end

% Bumpers: one bounce per contact; re-arm once the segment has cleared it.
if ~isempty(s.bumps)
    hit = sweptHit(s, th0, dth, s.bumps, s.rU) & s.armed;
    gone = segDist(s.pivot, tipOf(s), nearImage(s, s.bumps)) > s.rU + 4;
    s.armed = (s.armed | gone) & ~hit;
    if any(hit)
        % Reverse the spin about the same pivot, like a pinball bumper.
        % Undo this frame's motion so it doesn't sink into the bumper.
        s.theta = th0;
        s.L = Lprev;
        s.omega = -s.omega;
    end
end
end

function renderFrame(~, s)
p = s.pivot;
t = tipOf(s);
% The world wraps: draw all 9 tiled copies and let axes clipping show
% whatever pokes across an edge.
[ox, oy] = meshgrid([-1 0 1]*s.W, [-1 0 1]*s.H);
ox = ox(:)';
oy = oy(:)';
z = nan(1, 9);
s.g.seg.XData = reshape([p(1) + ox; t(1) + ox; z], 1, []);
s.g.seg.YData = reshape([p(2) + oy; t(2) + oy; z], 1, []);
pink = s.boostT > 0;
s.g.seg.Color = [0.9 0.9 0.95]*~pink + [1 0.45 0.8]*pink;
s.g.piv.XData = p(1) + ox;
s.g.piv.YData = p(2) + oy;
s.g.tip.XData = t(1) + ox;
s.g.tip.YData = t(2) + oy;
f = s.flag;
s.g.pole.XData = [f(1) f(1)];
s.g.pole.YData = [f(2) f(2)-30];
s.g.flag.XData = [f(1) f(1)+20 f(1)];
s.g.flag.YData = [f(2)-30 f(2)-24 f(2)-18];

setDiscs(s, s.g.bR, s.bombs, s.rB, s.nB);
setDiscs(s, s.g.b, s.bombs, s.rB - 2, s.nB);
setDiscs(s, s.g.uR, s.bumps, s.rU, s.nU);
setDiscs(s, s.g.u, s.bumps, s.rU - 2.5, s.nU);
setDiscs(s, s.g.pR, s.pills, s.rP, s.nP);
setDiscs(s, s.g.p, s.pills, s.rP - 2.5, s.nP);

k = min(s.boomT/0.5, 1);
c = s.boomAt(s.over, :);       % empty unless exploding
setDiscs(s, s.g.boomR, c, 110*k, 1);
setDiscs(s, s.g.boom, c, 100*k, 1);
s.g.boomR.FaceAlpha = 1 - 0.7*k;
s.g.boom.FaceAlpha = 1 - 0.7*k;

if s.over
    m = {'BOOM!', sprintf('level %d, %d flags', s.level, s.flags), ...
        'tap to restart'};
elseif s.tee && s.flags == 0
    m = {'PIVOT GOLF', 'tap to tee off, then tap to swap pivot'};
elseif s.tee
    m = {sprintf('Level %d', s.level), 'tap to tee off'};
else
    m = '';
end
s.g.msg.String = m;
s.g.hud.String = sprintf('Level %d    Flags %d', s.level, s.flags);
end

function setDiscs(s, h, c, r, n)
% One disc per row of c in a fixed-size patch; unused columns are NaN so
% they don't draw.
x = nan(48, n);
y = x;
k = size(c, 1);
x(:, 1:k) = c(:, 1)' + r*s.circ(:, 1);
y(:, 1:k) = c(:, 2)' + r*s.circ(:, 2);
h.XData = x;
h.YData = y;
end

function s = swapPivot(s)
s.pivot = mod(tipOf(s), [s.W s.H]);
s.theta = s.theta + pi;
s.omega = -s.omega;
end

function t = tipOf(s)
t = s.pivot + s.L*[cos(s.theta) sin(s.theta)];
end

function hit = sweptHit(s, th0, dth, c, rad)
% True for each circle (rows of c, radius rad) that the segment passed
% over while rotating from th0 by dth, so fast spins can't skip one.
d = nearImage(s, c) - s.pivot;
r = hypot(d(:, 1), d(:, 2));
phi = atan2(d(:, 2), d(:, 1));
slack = asin(min(rad./max(r, eps), 1));
a = mod(sign(dth)*(phi - th0) + slack, 2*pi);
hit = (r <= s.Lhit + rad & a <= abs(dth) + 2*slack) | r <= rad;
end

function d = segDist(p, q, c)
% Distance from each row of c to the segment p-q.
v = q - p;
u = min(max(((c - p)*v')/(v*v'), 0), 1);
e = c - (p + u*v);
d = hypot(e(:, 1), e(:, 2));
end

function c = nearImage(s, c)
% Wrapped copy of each point closest to the pivot. The segment is shorter
% than half the screen, so that's the only copy it can touch.
WH = [s.W s.H];
c = c - WH.*round((c - s.pivot)./WH);
end

function in = inLane(s, f, c, w)
% Rows of c (any wrapped copy) within w of the straight line pivot->f.
in = false(size(c, 1), 1);
for ox = [-1 0 1]*s.W
    for oy = [-1 0 1]*s.H
        in = in | segDist(s.pivot, f, c + [ox oy]) < w;
    end
end
end


function s = newLevel(s)
% Lay out a fresh field and wait for a tee-off tap. Levels 2-6 and even
% levels are open minefields that thicken slowly; odd levels from 7 on
% are a pair of mine walls with matching doors.
% Nothing deadly starts within reach of a full spin, and the walls sit
% just outside it. Quick taps let the segment crawl sideways, sweeping a
% band only one length wide, so doors and flag paths only need to be
% about L wide.
k = s.level + 1;
s.level = k;
s.tee = true;
s.ampGoal = min(0.04*max(k - 4, 0), 0.35);
Lm = s.L0*(1 + s.ampGoal);
r0 = Lm + s.rB + 12;
if mod(k, 2) && k >= 7
    i = 1 + (mod(k, 4) == 3);  % 2: horizontal walls, 1: vertical
    D = [s.W s.H];
    E = D(3 - i);              % wall length
    u = (0:34:E - 17)';
    dc = rand*E + (0:i - 1)*E/i;
    gap = abs(mod(u - dc + E/2, E) - E/2);
    u = u(all(gap > Lm/2 + 20, 2));
    b = zeros(0, 2);
    for side = [-1 1]
        q = zeros(numel(u), 2);
        q(:, i) = mod(s.pivot(i) + side*r0, D(i));
        q(:, 3 - i) = u;
        b = [b; q]; %#ok<AGROW>
    end
    b = [b; place(s, k - 7, b, r0)];
else
    b = place(s, min(2*k - 2, 50), [], r0);
end
s.bombs = b(1:min(end, s.nB), :);
s.bumps = place(s, min(ceil(k/2), s.nU), b, 60);
s.pills = place(s, min(max(floor((k - 3)/2), 0), s.nP), [b; s.bumps], 60);
s.armed = true(size(s.bumps, 1), 1);
s = spawnFlag(s);
end

function c = place(s, n, avoid, r0)
% n random points at least 40 px from avoid and each other, and at least
% r0 from the pivot.
c = zeros(0, 2);
for j = 1:n
    for tries = 1:100
        p = [20 + rand*(s.W - 40), 20 + rand*(s.H - 40)];
        if all(hypot2([avoid; c] - p) > 40) && ...
                hypot2(nearImage(s, p) - s.pivot) > r0
            c(end+1, :) = p; %#ok<AGROW>
            break
        end
    end
end
end

function s = spawnFlag(s)
% Pick a flag at least 200 px away with a bomb-free lane to it (the band
% a sideways crawl sweeps). Failing that, take the candidate with the
% fewest bombs in its lane and clear just those.
w = 0.5*s.L0*(1 + s.ampGoal) + s.rB + 4;
obs = [s.bombs; s.bumps; s.pills];
best = inf;
cut = false(size(s.bombs, 1), 1);
s.flag = s.pivot + [s.W s.H]/2;    % far-side fallback, in case
for tries = 1:200
    f = [40 + rand*(s.W - 80), 60 + rand*(s.H - 90)];
    if hypot2(f - s.pivot) < 200 || any(hypot2(obs - f) < 35) || ...
            any(hypot2(s.bombs - f) < 70)
        continue
    end
    blk = inLane(s, f, s.bombs, w);
    if sum(blk) < best
        best = sum(blk);
        s.flag = f;
        cut = blk;
    end
    if ~best
        break
    end
end
s.bombs(cut, :) = [];
end

function d = hypot2(v)
d = hypot(v(:, 1), v(:, 2));
end
Play Game
Preview

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