Sticky 8

JKMSMKJ
/
Sticky 8
on 11 Nov 2026
1
20
5
0
4999
game.m
function g = game()
%STICKY8 Keep at least one bar unstuck for 9s.
% A game inspired from a puzzle described here: 
% https://www.quantamagazine.org/the-physics-of-time-puzzle-20160913/
g = struct(init = @initState, update = @updateState, render = @renderFrame);
end

function S = initState(ax)
%initState Build the axes, graphics elements, etc.
set(ax, XLim=[-0.409 5.409], YLim=[-0.182 4.182], Color='k');
axis(ax, 'equal');
%State elements
S = struct(md=1, t=0, tc=0, tf=.09, tt=0, gd=.5, anT=0, fresh=0, g8=[121 231 232 123 222 221 122]);
% md : Scene mode: 1 title, 2 play, 3 round-over
% t : global clock (drives blinking only, never paused)
% tc : round countdown
% tf : controls total steps per 9s
% tt : accumulator counting down to the next movement tick
% gd : input guard (ignores taps for a moment after a scene change)
% anT : time the title-in-HUD fly animation
% fresh : newest bar index owing a tap
% g8 : 7 grey segments
hE = 100 + 10*(0:4)' + (0:4); % 25 horizontal edges, i,j in 0..4
vE = 200 + 10*(0:5)' + (0:3); % 24 vertical edges, i in 0..5, j in 0..3
ed = [hE(:); vE(:)]; % 49 total edges
S.ed = ed(~ismember(ed, S.g8)); % 42 allowed edges for bars placement
S.vd = {'LEGEND!','SUPER!','Awesome!','Great!','Good!','Not Bad!','Got Lucky!','You Lose!'}; % verdict
S = placeBars(S); % Scatter the 7 bars anywhere legal on the board to start.
%Graphics elements: Visual
line(ax, [0 5], [0:4;0:4]', Color='b'); % X-Gridlines.
line(ax, [0:5;0:5]', [0 4], Color='b'); % Y-Gridlines.
[so, si, sj] = deal(floor(S.g8/100), mod(floor(S.g8/10), 10), mod(S.g8, 10));
[G.slot, G.bar] = deal(gobjects(1,7)); % 7 slots & colourful bars
G.bc = lines(7); % Bar colours
for s = 1:7
    G.slot(s) = line(ax, si(s)+[0 so(s)==1], sj(s)+[0 so(s)==2], Color=[.3 .3 .3], LineWidth=2);
    G.bar(s) = line(ax, [0 0], [0 0], Color=G.bc(s,:), LineWidth=2);
end
uistack(G.bar,'top');
%Graphics elements: Texts
[N, P, C] = deal({'time', 'titleH', 'stat', 'titleM', 'subT', 'prompt'},...
    [5 4.091 16; 2.5 3.5 16; 0 4.091 16; 2.5 3.5 38; 2.5 1.841 15; 2.5 .436 20],...
    ['w'; 'm'; 'w'; 'm'; 'c'; 'g']);
for q = 1:6
    G.(N{q}) = text(ax, P(q,1), P(q,2), '', FontSize=P(q,3), Color=C(q,:),...
        FontWeight='bold', HorizontalAlignment='center');
end
set(G.time, HorizontalAlignment='right');
set(G.titleH, String='STICKY 8', Visible=0);
set(G.stat, HorizontalAlignment='left');
set(G.titleM, String='STICKY 8', Visible=1);
set(G.subT, String='Timely taps / spaces keep the figure 8 unlit...', Visible=1);
set(G.prompt, String='TAP TO PLAY');
set(findall(ax, '-property', 'HitTest'), HitTest=0, PickableParts='none');
S.G = G;
end

function S = placeBars(S)
%placeBars Deal 7 random starting edges.
S.B(:,1) = S.ed(randi(42, 7, 1)); % 7 bars' edges as 3-digit codes
S.B(:,2) = 0; % 7 bars' stuck flags (1 - stuck bar)
end

function S = newGame(S)
%newGame Begin a fresh round from title screen or round-over screen.
[S.md, S.tc, S.tt, S.gd, S.anT, S.fresh] = deal(2, 0, 0, .5, S.t, 0);
S = placeBars(S);
end

function S = updateState(S, dt, pressed)
%updateState Advance the simulation one frame and consume one tap.
S.t = S.t + dt;
S.gd = S.gd - dt; % recharge the input guard.
switch S.md
    case {1, 3} % Title / round-over.
        if pressed && S.gd <= 0
            S = newGame(S);
        end
    case 2 % Round countdown.
        S.tc = S.tc + dt;
        if S.fresh
            if pressed
                S.B(S.fresh,2) = 0;
                S.fresh = 0;
            end
            if S.gd < 0
                S.fresh = 0;
            end
        end
        % The round ends one of two ways: the clock runs out or the 8 lights up!
        if S.tc >= 9
            S.md = 3;
            S.gd = .6;
        else
            S.tt = S.tt + dt;
            if S.tt >= S.tf
                S.tt = S.tt - S.tf;
                S = doStep(S);
                if all(S.B(:,2))
                    S.md = 3;
                    S.gd = .6;
                end
            end
        end
end
end

function S = doStep(S)
%doStep Each free bar takes a random walk.
for k = 1:7
    if S.B(k,2)
        continue
    end
    e = S.B(k,1);
    E = [mod(floor(e/10), 10) mod(e, 10)] + [0 0; e<200 e>=200];
    % Random walk
    M = stp(E(randi(2), :));
    F = stp(M);
    % Re-encode the unordered unit edge {M, F}.
    if M(2) == F(2)
        c = 100 + 10*min(M(1), F(1)) + M(2);
    else
        c = 200 + 10*M(1) + min(M(2), F(2));
    end
    % Stick check on a display segment (code in S.g8).
    S.B(k,1) = c;
    v = S.B(:,1);
    v(~S.B(:,2)) = 0; % only stuck bars can block
    if any(c == S.g8) && ~any(v == c)
        S.B(k,2) = 1;
        S.fresh = k;
        S.gd = .25;
    end
end
end

function n = stp(n)
%stp One random step from node n = [x y].
d = [1 0; -1 0; 0 1; 0 -1];
p = n + d; % the 4 candidate nodes
p = p(all(p >= 0 & p <= [5 4], 2),:);
n = p(randi(size(p,1)),:); % uniform on-board neighbour
end

function renderFrame(~, S)
%renderFrame Push the current state into the graphics scene.
G = S.G;
for k = 1:7
    e = S.B(k,1);
    set(G.bar(k), XData=mod(floor(e/10),10)+[0 e<200], YData=mod(e,10)+[0 e>=200]);
end
ns = sum(S.B(:,2));
G.time.String = sprintf('TIME: %.1f', max(9-S.tc, 0));
G.stat.String = sprintf('STUCK: %d/7', ns);
cg = [1 0 1]; % magenta (title / verdict).
blink = mod(S.t, 1.1) < .72; % blink is a shared 1-cycle 1.1 s square wave for prompt.
switch S.md
    case 1 % Title
        G.prompt.Visible = blink;
    case 2 % Play
        if G.titleH.Position(2) < 4.091
            % Title-in-HUD fly animation.
            p = min(max((S.t - S.anT)/.9, 0), 1);
            pe = p^2 * (3 - 2*p); % smooth-step easing!?
            set(G.titleH, Position=[2.5,3.5+.591*pe], FontSize=38-22*pe, Color=cg+([1 1 1]-cg)*pe, Visible=1);
            G.subT.Visible = 0;
            G.titleM.Position(2) = 2; % Round verdict is displayed at the center!
        end
        G.titleM.Visible = 0;
        G.prompt.Visible = 0;
    otherwise % Round-over
        set(G.titleM, String=S.vd{ns+1}, Color=cg*(ns<6)+[1 0 0]*(ns>=6), Visible=1);
        G.prompt.Visible = blink;
end
end
Play Game
Preview

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