Pacemaker

Jan Studnicka
/
Pacemaker
on 12 Nov 2026
1
22
11
1
9893
game.m
function g = game()
%game PACEMAKER -- a one-button lesson in cardiac pacing.
%
%   You are a demand pacemaker. Each tap delivers one pacing pulse.
%   Pace when the heart misses a beat (green window), never during the
%   T wave (red window), and do not waste battery on a heart that beats
%   on its own.

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

function s = initState(ax)
ax.YDir = 'normal';
ax.Color = [0 .05 .03];

% Lesson texts
s.nm = {'SINUS PAUSES', 'WENCKEBACH AV BLOCK', 'COMPLETE AV BLOCK', 'EXERCISE'};
s.ls = compose({'The sinus node sometimes pauses.\nPace only when a beat is late.', ...
    'P-to-QRS delay grows, then a beat drops.\nFill only that gap.', ...
    'P waves never reach the ventricles.\nYou are the only rhythm.', ...
    'The body needs more blood.\nThe window comes sooner every beat.'});
s.why = compose({['VENTRICULAR FIBRILLATION\n\nYour pulse hit the T wave (R-on-T).\n' ...
    'The recovering heart is electrically vulnerable.'], ...
    ['ASYSTOLE\n\nPauses too long: no beat, no blood flow.\n' ...
    'A pacemaker must fire when the heart does not.'], ...
    ['BATTERY DEPLETED\n\nWasted pulses drain the device.\n' ...
    'Sense first, pace only on demand.']});

% Simulation state (times in seconds)
s.t = 0;      s.t0 = -9;   s.acc = 0;
s.mode = 0;   % 0 title (self-playing demo), 1 playing, 2 game over
s.dead = 0;   % 0 beating, 1 fibrillation, 2 flatline
s.c = 1;      s.best = 0;
s.buf = zeros(1, 400);
s = newGame(s);

% Graphics -- created once, only mutated in renderFrame
G = [.3 1 .45];   D = [.6 .8 .65];   E = 'none';
o = {'HitTest', 'off', 'PickableParts', E};
s.g.zone = rc(ax, [0 180 1 300], [0 .4 .18], E);
s.g.risk = rc(ax, [0 180 1 300], [.55 .06 .06], E);
v = 0:40:800;  h = 180:50:480;  n = nan(size(v));  m = nan(size(h));
line(ax, [v; v; n], [180+0*v; 480+0*v; n], 'Color', [0 .2 .1], o{:});
line(ax, [0*h; 800+0*h; m], [h; h; m], 'Color', [0 .2 .1], o{:});
s.g.zl = tt(ax, 0, 468, 'PACE', 'w', 9, 'center');
s.g.rl = tt(ax, 0, 468, 'STOP', 'w', 9, 'center');
s.g.now = line(ax, [560 560], [170 490], 'LineWidth', 2, o{:});
s.x = (399:-1:0)*1.4;   % trace sample offsets left of the "now" line
s.g.tr = line(ax, 560 - s.x, s.buf, 'Color', G, 'LineWidth', 2, o{:});
a = linspace(0, 2*pi, 60);
s.hx = 16*sin(a).^3;
s.hy = 13*cos(a) - 5*cos(2*a) - 2*cos(3*a) - cos(4*a);
s.g.heart = patch(ax, 'XData', s.hx, 'YData', s.hy, 'FaceColor', [.9 .15 .2], ...
    'EdgeColor', E, o{:});
s.g.lvl = tt(ax, 20, 570, '', G, 12, 'left');
s.g.sc  = tt(ax, 20, 535, '', 'w', 12, 'left');
s.g.hr  = tt(ax, 700, 552, '', G, 22, 'right');
tt(ax, 20, 120, 'BLOOD FLOW', 'w', 10, 'left');
tt(ax, 20, 85, 'BATTERY', 'w', 10, 'left');
tt(ax, 460, 120, 'falls when a beat is missed', D, 10, 'left');
tt(ax, 460, 85, 'every pulse costs energy', D, 10, 'left');
rc(ax, [150 111 300 18], E, [.4 .5 .4]);
rc(ax, [150 76 300 18], E, [.4 .5 .4]);
s.g.pf = rc(ax, [150 111 300 18], [.9 .25 .3], E);
s.g.bt = rc(ax, [150 76 300 18], [.95 .8 .2], E);
s.g.msg = tt(ax, 560, 152, '', 'w', 14, 'center');
s.g.tip = tt(ax, 400, 30, '', D, 10, 'center');
s.g.big = tt(ax, 405, 545, '', 'w', 12, 'center');
set(s.g.big, 'BackgroundColor', [0 .1 .06], 'EdgeColor', G, 'Margin', 12);
end

function h = tt(ax, x, y, str, c, n, al)
% Bold monospace label that never intercepts clicks.
h = text(ax, x, y, str, 'Color', c, 'FontSize', n, 'HorizontalAlignment', al, ...
    'FontName', 'FixedWidth', 'FontWeight', 'bold', 'HitTest', 'off', ...
    'PickableParts', 'none');
end

function h = rc(ax, pos, fc, ec)
% Rectangle that never intercepts clicks.
h = rectangle(ax, 'Position', pos, 'FaceColor', fc, 'EdgeColor', ec, ...
    'HitTest', 'off', 'PickableParts', 'none');
end

function s = newGame(s)
% Reset everything except graphics handles, trace buffer and best score.
s.dead = 0;  s.lv = 0;  s.L = 1;  s.nb = 0;  s.k = 0;
s.T = 1;     % escape interval: pace if no beat for this long
s.w = .3;    % width of the pacing window
s.tv = .46;  % time since last ventricular beat
s.tp = 9;    % time since last P wave
s.ta = 0;    % atrial clock
s.pp = .3;   % current P-P interval (short: first beat comes quickly)
s.pend = 0;  % countdown of a conducted beat (0 = none)
s.kind = 0;  % last beat: 1 intrinsic, 2 paced
s.rr = .85;  s.sp = 0;
s.perf = 1;  s.batt = 1;  s.score = 0;
s.msg = '';  s.msgT = 0;  s.mc = [.3 1 .45];
s.banT = 3.5;   % how long the lesson banner stays up
end

function s = updateState(s, dt, pressed)
s.t = s.t + dt;
s.msgT = s.msgT - dt;
s.banT = s.banT - dt;
if s.mode == 1
    if pressed
        s = pulse(s);
    end
elseif pressed && s.t - s.t0 > 2.5   % lockout: let the player read why
    s = newGame(s);
    s.mode = 1;
elseif s.mode == 0                   % title demo paces itself, for free
    if s.tv > s.T + .1
        s = pulse(s);
    end
    s.score = 0;  s.batt = 1;
end
% Advance the heart model at a fixed 100 Hz so the trace is dt-independent
s.acc = s.acc + dt*100;
n = floor(s.acc);
s.acc = s.acc - n;
for i = 1:n
    s = step(s);
end
end

function s = pulse(s)
% One pacing pulse; the outcome depends on where in the cycle it lands.
s.sp = 2;
s.batt = s.batt - .012;
s.msgT = 1.2;
s.mc = [1 .8 .2];
if s.tv < .2
    s.msg = 'NO CAPTURE: refractory';
    s.batt = s.batt - .05;
elseif s.tv < .45
    s = over(s, 1);
    return
else
    if s.tv < s.T - .04
        s.msg = 'TOO EARLY: wasted';
        s.batt = s.batt - .06;
    elseif s.tv <= s.T + s.w + .04
        p = 10*(s.lv + 1);
        s.score = s.score + p;
        s.msg = sprintf('PACED +%d', p);
        s.mc = [.3 1 .45];
    else
        s.score = s.score + 2;
        s.msg = 'LATE +2';
    end
    if s.L < 3   % paced beat resets the sinus node to its normal rate
        s.ta = 0;  s.k = 0;  s.pend = 0;  s.pp = .7;
    end
    s = beat(s, 2);
end
if s.batt <= 0
    s = over(s, 3);
end
end

function s = beat(s, kind)
% Ventricular contraction (kind 1 intrinsic, 2 paced).
s.rr = s.tv;
s.kind = kind;
if kind == 1 && s.tv <= s.T + s.w   % reward for correctly staying quiet
    s.score = s.score + 1;
    s.msg = 'SENSED +1';
    s.msgT = .8;
    s.mc = [.3 1 .45];
end
if s.mode == 1
    if s.tv <= s.T + s.w + .04
        s.perf = min(1, s.perf + .04);
    end
    s.nb = s.nb + 1;
    if s.nb >= 20
        s.lv = s.lv + 1;  s.nb = 0;  s.k = 0;
        s.L = mod(s.lv, 4) + 1;
        s.w = .3*.8^floor(s.lv/4);
        s.batt = min(1, s.batt + .3);
        s.msg = 'LEVEL UP: recharged';
        s.msgT = 2;
        s.banT = 3.5;
    end
    s.T = 1;
    if s.L == 4
        s.T = max(.6, 1 - .02*s.nb);
    end
end
s.tv = 0;
end

function s = step(s)
% Advance the heart by 10 ms and append one sample to the trace.
h = .01;
s.tv = s.tv + h;  s.tp = s.tp + h;  s.ta = s.ta + h;
if s.dead == 1
    y = .3*sin(33*s.tv) + .2*sin(51*s.tv + 1) + .05*randn;
elseif s.dead == 2
    y = .01*randn;
else
    if s.ta >= s.pp          % sinus node fires: P wave
        s.ta = 0;  s.tp = 0;  s.k = mod(s.k + 1, 4);
        % Per lesson: next P-P interval and AV delay (0 = not conducted).
        % 1 occasional sinus pause, 2 PR grows and every 4th P is dropped,
        % 3 and 4 nothing is conducted.
        pp = [.8 + (rand < .4)*(.9 + .5*rand), .8, .7, s.T];
        pd = [.16, (.06 + .09*s.k)*(s.k > 0), 0, 0];
        s.pp = pp(s.L);  s.pend = pd(s.L);
    end
    if s.pend > 0            % AV node delay, then intrinsic beat
        s.pend = s.pend - h;
        if s.pend <= 0 && s.tv > .45
            s = beat(s, 1);
        end
    end
    if s.mode == 1 && s.tv > s.T + s.w
        s.perf = s.perf - h*.22*(1 + .3*floor(s.lv/4));
        if s.perf <= 0
            s = over(s, 2);
        end
    end
    % ECG as a sum of Gaussian bumps: P, QRS, T
    y = .12*gb(s.tp, .05, .025);
    if s.kind == 1
        y = y - .1*gb(s.tv, .03, .008) + gb(s.tv, .05, .011) ...
            - .22*gb(s.tv, .07, .009) + .28*gb(s.tv, .3, .05);
    elseif s.kind == 2       % paced: wide, inverted QRS
        y = y - .85*gb(s.tv, .09, .035) + .38*gb(s.tv, .34, .06);
    end
end
if s.sp > 0                  % pacing spike artifact
    y = y + .8;
    s.sp = s.sp - 1;
end
s.buf = [s.buf(2:end) y];
end

function y = gb(t, c, w)
y = exp(-((t - c)/w)^2);
end

function s = over(s, c)
s.mode = 2;
s.dead = 1 + (c > 1);
s.c = c;
s.t0 = s.t;
s.msgT = 0;
s.best = max(s.best, s.score);
end

function renderFrame(~, s)
g = s.g;
play = s.mode == 1;
live = s.mode < 2;
late = play && s.tv > s.T + s.w;   % the pacing window was missed
% The model runs in 10 ms steps; shifting by the leftover fraction of a
% step makes the scroll speed constant instead of 3-or-4 samples a frame.
x = 560 - 1.4*s.acc;
set(g.tr, 'XData', x - s.x, 'YData', 330 + 140*s.buf);
zx = x + (s.T - s.tv)*140;
rx = x + (.2 - s.tv)*140;
g.zone.Position = [zx 180 s.w*140 300];
g.risk.Position = [rx 180 35 300];
g.zl.Position = [zx + s.w*70, 468];
g.rl.Position = [rx + 17.5, 468];
put([g.zone g.zl], 'Visible', live);
put([g.risk g.rl], 'Visible', live && s.kind > 0);
k = 2.2*(1 + .3*exp(-8*s.tv)*(s.dead == 0));
g.heart.XData = 750 + k*s.hx;
g.heart.YData = 550 + k*s.hy;
hr = '-- bpm';
if s.dead == 0
    hr = sprintf('%d bpm', round(60/s.rr));
end
put(g.hr, 'String', hr);
put(g.pf, 'Position', [150 111 max(s.perf, .001)*300 18]);
put(g.bt, 'Position', [150 76 max(s.batt, .001)*300 18]);
put(g.sc, 'String', sprintf('SCORE %d   BEST %d', s.score, max(s.best, s.score)));
msg = s.msg;  mc = s.mc;  nc = [.8 .9 .8];
if late
    msg = 'PACE NOW';  mc = [1 .35 .35];  nc = mc;
end
put(g.now, 'Color', nc);
put(g.msg, 'String', msg);
put(g.msg, 'Color', mc);
put(g.msg, 'Visible', late || s.msgT > 0);
p = [405 545 0];
if s.mode == 0
    lvl = 'PACEMAKER';
    tip = 'Demo: the pacemaker fills in missed beats.';
    big = sprintf(['TAP (space / click) = one pacing pulse\n' ...
        'Tap when GREEN reaches the white line\n' ...
        'Never tap in RED (the T wave)\n' ...
        'Heart beats on its own? Stay quiet\nTAP TO START']);
else
    lvl = sprintf('LEVEL %d  %s', s.lv + 1, s.nm{s.L});
    tip = s.ls{s.L};
    big = tip;
    if s.mode == 2
        p = [400 330 0];
        r = '';
        if s.t - s.t0 > 2.5
            r = 'Tap to restart';
        end
        big = sprintf('%s\n\nSCORE %d\n%s', s.why{s.c}, s.score, r);
    end
end
put(g.lvl, 'String', lvl);
put(g.tip, 'String', tip);
put(g.big, 'String', big);
put(g.big, 'Position', p);
put(g.big, 'Visible', ~play || s.banT > 0);
end

function put(h, p, v)
% Touch a graphics property only when it changes, so unchanged text and
% bars are not re-sent to the renderer every frame.
if ischar(v)
    v = splitlines(v);   % text objects store multi-line strings as cells
end
if ~isequal(get(h(1), p), v)
    set(h, p, v);
end
end
Play Game
Preview

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