Beat the PID

Ahmed
/
Beat the PID
on 9 Nov 2026
3
43
20
0
9980
game.m
function g = game()
%GAME Beat the PID.
%   One button switches an actuator ON or OFF. ON pushes the trace up, OFF
%   lets it fall. Keep the trace in the band, then beat the PID ghost,
%   which obeys the same one-button rule but cannot see the future band.
%
%   Structure: init builds the state and pooled graphics, update advances the
%   game and never draws, and render copies the state onto the graphics.
%
%   Best played in desktop MATLAB: graphics in MATLAB Online can run far slower,
%   and the game then plays in slow motion. See the Tips & Tricks post to run it.
g.init = @initState;
g.update = @updateState;
g.render = @renderFrame;
end

function s = initState(ax)
%initState - Set up the world, the plants, the graphics and the first level
ax.Color = [.03 .03 .02];
ax.Toolbar.Visible = 'off';
s.ax = ax;
% MATLAB starts with the same seed each session, so shuffle for fresh bands.
rng('shuffle');
% Physics uses a fixed step, so every machine simulates the same plant.
s.h = 1/120;
s.T = 20;
s.L = plants(s.h);
s.res = zeros(numel(s.L),1);
s.mode = 0;
s.cool = 0;
s.g = makeGraphics(ax);
s = setupLevel(s,1);
renderFrame([],s);
end

function L = plants(h)
%plants - Define every level as a linear plant and discretize it for step h
% Each plant is x' = A*x + B*[u;1] with u switching 0 or 1, and y is x(1).
% kind picks the graphics: 1 thermal, 2 shower, 3 spring, 4 rocket, 5 pendulum.
% sp holds the band center for each stage; stages start at 0, 7 and 14 s.
% pid holds [Ki Kd minDwell] for the ghost's relay controller; Kp is 1.
% Rocket and pendulum crash on leaving the 0-1 range.
c = {
    'THERMOSTAT','HEATER','Heat builds slowly.',1,-.45,[.45 0],0,0,.08,[.45 .65 .4],40,[.3 .12 .7]
    'LAGGY OVEN','ELEMENT','The element stays hot.',1,[-.67 .67;0 -1.67],[0 0;1.67 0],1,0,.07,[.45 .62 .38],45,[.05 .75 .3]
    'SPRING','MOTOR','It rings.',3,[0 1;-5.76 -1.06],[0 0;2.3 1.73],0,0,.08,[.5 .6 .42],45,[.2 .4 .5]
    'BAD SHOWER','HOT TAP','The pipe delays you.',2,-.5,[.5 0],0,.5,.11,[.5 .68 .36],35,[.2 .2 .9]
    'ROCKET','THRUST','Avoid the ground.',4,[0 1;0 -.4],[0 0;.5 -.25],1,0,.1,[.5 .68 .36],45,[.2 1.1 .8]
    'PENDULUM','PUSH','It wants to fall.',5,[0 1;.8 0],[0 0;.8 -.8],0,0,.12,[.5 .54 .46],40,[.2 1.2 .6]
    };
f = {'name','act','hint','kind','A','B','u0','delay','band','sp','pass','pid'};
L = cell2struct(c,f,2);
for k = 1:numel(L)
    L(k).sp = [0 7 14;L(k).sp].';
    % Exact discretization: expm of the augmented matrix gives Ad and Bd.
    n = size(L(k).A,1);
    M = expm([L(k).A L(k).B;zeros(2,n+2)]*h);
    L(k).Ad = M(1:n,1:n);
    L(k).Bd = M(1:n,n+1:n+2);
end
end

function s = setupLevel(s,k)
%setupLevel - Start a fresh attempt at level k
s.lv = k;
p = s.L(k);
% Each attempt moves later band steps by up to 1 s and 0.05. The first row
% stays put so the trace starts inside the band. The ghost shares this copy.
p.sp(2:3,:) = p.sp(2:3,:)+[2 .1].*(rand(2)-.5);
s.p = p;
s.x = zeros(size(p.A,1),1);
s.x(1) = p.sp(1,2);
s.xg = s.x;
[s.u,s.ug,s.ud] = deal(p.u0);
% Ring buffer of past commands implements the transport delay.
s.nb = round(p.delay/s.h)+1;
s.ub = repmat(p.u0,2,s.nb);
s.ip = 1;
[s.t,s.acc,s.in,s.ing,s.ei,s.dwg,s.n] = deal(0);
[s.crash,s.gdead,s.won] = deal(false);
[s.y,s.yg,s.ygp] = deal(s.x(1));
% History rows are the player, the ghost and the actuator.
s.H = nan(3,90);
end

function v = spAt(p,t)
%spAt - Look up the band center at time or times t
v = p.sp(max(sum(t(:) >= p.sp(:,1).',2),1),2).';
end

function s = stepPlant(s)
%stepPlant - Advance the player, the ghost and the scoring by one fixed step
p = s.p;
s.ub(:,s.ip) = [s.u;s.ug];
s.ip = mod(s.ip,s.nb)+1;
d = s.ub(:,s.ip);
s.ud = d(1);
s.x = p.Ad*s.x+p.Bd*[d(1);1];
s.xg = p.Ad*s.xg+p.Bd*[d(2);1];
s.y = s.x(1);
s.yg = s.xg(1);
s.t = s.t+s.h;
r = spAt(p,s.t);
s.in = s.in+s.h*(abs(s.y-r) <= p.band);
if ~s.gdead
    s.ing = s.ing+s.h*(abs(s.yg-r) <= p.band);
    s.gdead = p.kind > 3 && abs(s.yg-.5) >= .5;
    % Relay PID: same on/off actuator, limited to a human-like switch rate.
    % The output's sign picks ON or OFF. Clamping the integral stops windup.
    e = r-s.yg;
    s.ei = max(-.3,min(.3,s.ei+e*s.h));
    v = e+p.pid(1)*s.ei-p.pid(2)*(s.yg-s.ygp)/s.h;
    s.ygp = s.yg;
    s.dwg = s.dwg+s.h;
    if s.dwg >= p.pid(3) && (v > 0) ~= s.ug
        s.ug = v > 0;
        s.dwg = 0;
    end
end
s.crash = p.kind > 3 && abs(s.y-.5) >= .5;
s.n = s.n+1;
if mod(s.n,8) == 0
    s.H = [s.H(:,2:end) [s.y;s.yg;s.ud]];
end
end

function s = updateState(s,dt,pressed)
%updateState - Run one frame; mode is 0 title, 1 intro, 2 play, 3 result, 4 end
s.cool = max(0,s.cool-dt);
if s.mode == 2
    s.u = xor(s.u,pressed)+0;
    % Spend real elapsed time in fixed steps, so frame rate never alters physics.
    s.acc = s.acc+dt;
    while s.acc >= s.h && s.t < s.T && ~s.crash
        s.acc = s.acc-s.h;
        s = stepPlant(s);
    end
    if s.t >= s.T || s.crash
        s = finishLevel(s);
    end
elseif pressed && s.cool == 0
    if s.mode == 1
        s.mode = 2;
        return
    end
    % Title and final cards restart; results advance or retry.
    k = max(1,(s.mode == 3)*(s.lv+s.won));
    s.res = s.res*(s.mode ~= 4);
    s.mode = 4;
    if k <= numel(s.L)
        s = setupLevel(s,k);
        s.mode = 1;
    end
    s.cool = .25;
end
end

function s = finishLevel(s)
%finishLevel - Score the attempt and show the result card
s.me = round(100*s.in/s.T);
s.pm = round(100*s.ing/s.T);
s.won = ~s.crash && s.me >= s.p.pass;
s.beat = s.won && s.me > s.pm;
s.res(s.lv) = s.beat;
s.mode = 3;
s.cool = .6;
end

function G = makeGraphics(ax)
%makeGraphics - Create every graphics object once; render only updates them
nf = {'PickableParts','none'};
pt = @(x,y,c,varargin) patch(ax,x,y,c,'EdgeColor','none',nf{:},varargin{:});
ln = @(x,y,c,w,varargin) line(ax,x,y,'Color',c,'LineWidth',w,nf{:},varargin{:});
tx = @(x,y,z,c,a) text(ax,x,y,'','FontSize',z,'Color',c,'HorizontalAlignment',a,'FontWeight','bold','FontName','FixedWidth',nf{:});
cy = [1 .82 0];
gr = [.62 .58 .46];
fg = [1 .97 .84];
or = [1 .5 0];
ln([40 780 780 40 40],[110 110 520 520 110],[.3 .26 .1],1);
G.band = pt(nan,nan,[.26 .21 .02]);
ln([580 580],[110 520],gr,1,'LineStyle',':');
% History lines share fixed X data, so only their Y data ever gets sent.
hx = 580-(89:-1:0)*6;
G.ghost = ln(hx,hx*nan,gr,1,'LineStyle','--');
G.trace = ln(hx,hx*nan,cy,2.5);
G.head = ln(580,nan,cy,1,'Marker','o','MarkerSize',10,'MarkerFaceColor','w');
G.dig = ln(hx,hx*nan,or,2);
G.hud = tx(40,560,12,cy,'left');
pt([40 560 560 40],[533 533 541 541],[.17 .15 .06]);
G.bar = pt(nan(1,4),[533 533 541 541],cy);
G.lamp = pt([620 780 780 620],[22 22 92 92],[.1 .09 .05],'EdgeColor',gr);
G.lampT = tx(700,57,13,fg,'center');

% One pooled view per plant type, shown or hidden as levels change.
g = pt([685 715 715 685],[110 110 520 520],[.1 .09 .05],'EdgeColor',gr);
G.fill = pt([688 712 712 688],[112 112 112 112],or);
G.drops = ln(650*ones(1,14),nan(1,14),[1 .25 0],1,'LineStyle','none','Marker','.','MarkerSize',24);
G.spring = ln(700+[0 14*(-1).^(1:14) 0],nan(1,16),gr,2);
G.block = pt([670 730 730 670],nan(1,4),cy,'EdgeColor','k');
G.flame = pt(700+[-11 11 0],nan(1,3),or);
G.ship = pt(700+[0 14 14 24 -24 -14 -14],nan(1,7),fg,'EdgeColor',cy);
G.rod = ln([700 700],[150 280],fg,4,'Marker','o','MarkerIndices',2,'MarkerSize',18,'MarkerFaceColor',cy);
G.v = {[g G.fill],[g G.fill G.drops],[G.spring G.block],[G.ship G.flame],G.rod};
set([G.v{:}],'Visible','off');

% The card comes last so that it covers everything underneath.
G.card = pt([120 680 680 120],[150 150 450 450],[.07 .06 .03],'EdgeColor',cy);
G.t1 = tx(400,400,26,fg,'center');
G.t2 = tx(400,275,12,cy,'center');
end

function renderFrame(~,s)
%renderFrame - Copy the state onto the graphics without changing the state
% Every property set travels to the browser in MATLAB Online, so this sends
% only what changed. Identical frames, such as idle menus, send nothing.
st = [s.mode s.lv s.t s.u];
if isequal(s.ax.UserData,st)
    return
end
s.ax.UserData = st;
G = s.g;
k = [s.lv floor(s.n/8)];
if ~isequal(G.trace.UserData,k)
    G.trace.UserData = k;
    drawScope(G,s);
end
G.head.YData = scopeY(s.y);
o = {'OFF','ON'};
t = [s.p.act ' ' o{s.u+1}];
if ~strcmp(G.lampT.String,t)
    G.lampT.String = t;
    G.lamp.FaceColor = [.1 .09 .05]+s.u*[.8 .36 0];
end
v = G.v{s.p.kind};
if v(end).Visible == "off"
    set([G.v{:}],'Visible','off');
    set(v,'Visible','on');
end
drawPlant(G,s);
drawCard(G,s);
end

function y = scopeY(v)
%scopeY - Map a plant output from 0-1 onto scope pixels
y = 110+410*v;
end

function drawScope(G,s)
%drawScope - Scroll the scope at the 15 Hz sample rate, not on every frame
p = s.p;
% The band scrolls in from the right, so the player can see steps coming.
% Its polygon needs vertices only at the ends of the window and at steps.
b = max(s.t-6,0);
e = s.t+2.2;
q = p.sp(:,1).';
q = q(q > b & q < e);
t = sort([b q-.01 q e]);
r = spAt(p,t);
x = 580+90*(t-s.t);
set(G.band,'XData',[x fliplr(x)],'YData',[scopeY(r+p.band) fliplr(scopeY(r-p.band))]);
G.band.FaceColor = [.36 .08 .04]+(abs(s.y-spAt(p,s.t)) <= p.band)*[-.1 .13 -.02];
G.trace.YData = scopeY(s.H(1,:));
G.ghost.YData = scopeY(s.H(2,:));
G.dig.YData = 28+s.H(3,:)*60;
x = 40+520*s.t/s.T;
G.bar.XData = [40 x x 40];
% Text is slow to send, so the status line refreshes about twice a second.
if mod(floor(s.n/8),8) == 0
    G.hud.String = sprintf('%d/%d %s  YOU %d%%  PID %d%%  NEED %d%%',s.lv,numel(s.L),p.name,round(100*s.in/s.T),round(100*s.ing/s.T),p.pass);
end
if p.kind < 3
    G.fill.FaceColor = [1 s.y 0];
end
if s.nb > 1
    i = round(linspace(1,s.nb,14));
    y = linspace(125,515,14);
    y(s.ub(1,mod(s.ip+i-2,s.nb)+1) == 0) = nan;
    G.drops.YData = y;
end
end

function drawPlant(G,s)
%drawPlant - Animate the physical object for the current plant
Y = scopeY(s.y);
switch s.p.kind
    case {1,2}
        G.fill.YData = [112 112 Y Y];
    case 3
        G.spring.YData = linspace(520,Y+20,16);
        G.block.YData = Y+[-20 -20 20 20];
    case 4
        G.ship.YData = Y+[32 12 -16 -28 -28 -16 12];
        G.flame.YData = Y-28-[0 0 35*s.ud];
    case 5
        a = 1.6*(s.y-.5);
        set(G.rod,'XData',700+[0 130*sin(a)],'YData',150+[0 130*cos(a)]);
end
end

function drawCard(G,s)
%drawCard - Fill in the menu card, or skip the work during play
if s.mode == 2 && G.card.Visible == "off"
    return
end
p = s.p;
a = {'',''};
switch s.mode
    case 0
        a = {'BEAT THE PID',{'YOU ARE THE CONTROLLER','','One button switches the actuator ON or OFF.', ...
            'ON pushes the trace up. OFF lets it fall.','Stay in the band. Beat the PID ghost.','','TAP TO BEGIN'}};
    case 1
        a = {p.name,{p.hint,'','Dashed line: the PID ghost.','','TAP TO START'}};
    case 3
        m = {'TOO LOOSE','PASSED','YOU BEAT THE PID','CRASHED'};
        a = {m{1+s.won+s.beat+3*s.crash},{sprintf('YOU %d%%  PID %d%%',s.me,s.pm),'','TAP TO CONTINUE'}};
    case 4
        a = {sprintf('%d OF %d PIDS BEATEN',sum(s.res),numel(s.L)),'TAP TO PLAY AGAIN'};
end
set([G.card G.t1 G.t2],'Visible',s.mode ~= 2);
G.t1.String = a{1};
G.t2.String = a{2};
end
Play Game
Preview

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