TRANSCRIPTION - one-button climber - MATLAB One-Button Game Mini Hack

Soobok
/
TRANSCRIPTION - one-button climber
on 12 Nov 2026
6
27
6
1
9973
game.m
function g = game()
%game TRANSCRIPTION - one-button climber: RNA polymerase climbs a DNA
%   helix, reading the template strand and building mRNA, one gene per
%   stage. The arrow swings; tap to step onto the next base pair on the
%   side it points.
%   Geometry: rung step 62 px sideways, 58 px up; helix radius 78;
%   12 on-screen rungs drawn as one patch.
g.init   = @ini;
g.update = @upd;
g.render = @ren;
end

function s = ini(ax)
ax.Color = [.03 .02 .08];
ax.XLim = [0 800]; ax.YLim = [0 600];
% Online-friendly graphics: few objects, batched geometry, and render only
% sets a property when its value changes (see sv).
P = {'HitTest','off','PickableParts','none'};
L = @(p,varargin) line(p, nan, nan, P{:}, varargin{:});
T = @(p,x,y,f,c,varargin) text(p, x, y, '', P{:}, 'FontSize',f, 'Color',c, ...
    'FontWeight','bold', 'HorizontalAlignment','center', varargin{:});
s.bs = 0;
% Base colours A, T/U, G, C; R maps a base to its complement index
s.bc = [1 .25 .45; 1 .85 .15; .2 1 .45; .25 .6 1];
s.R = [2 1 4 3]; s.bl = 'ATGC'; s.rl = 'AUGC';
% Static star field (never updated)
p = rand(70,2).*[800 600];
line(ax, p(:,1), p(:,2), P{:}, 'LineStyle','none', 'Marker','.', 'Color',[.28 .22 .55]);
% Backbones: both strands in one patch per layer (glow, core), drawn as
% out-and-back edge loops with per-vertex colours -> 1 set per layer
c = [1 .2 .85; .1 .9 1];
for k = 1:2
    s.g.bb(k) = patch(ax, 'Faces', [1:97 97:-1:1; 98:194 194:-1:98], ...
        'Vertices', zeros(194,2), 'FaceVertexCData', kron(c, ones(97,1))*(.3 + .7*(k>1)), ...
        'FaceColor','none', 'EdgeColor','flat', 'LineWidth', 12 - 8.5*(k>1), ...
        'LineJoin','round', P{:});
end
% Rungs: ONE patch of 24 quads (12 on-screen rungs x 2 halves)
s.g.r = patch(ax, 'Faces', reshape(1:96,4,[])', 'Vertices', zeros(96,2), ...
    'FaceVertexCData', zeros(24,3), 'FaceColor','flat', 'EdgeColor','none', P{:});
% Base-pair labels on the 3 rungs ahead of the polymerase only
for k = 1:3
    s.g.t(k) = T(ax, 0, 0, 10, [.9 .9 1]);
end
% Polymerase rig: everything moving with it lives in hgtransform tr (one
% Matrix set per frame); the pendulum arrow sits in a rotating child tq.
s.g.tr = hgtransform(ax, P{:});
s.g.tq = hgtransform(s.g.tr, P{:});
% mRNA trail in tr's local coordinates: a static wavy shape, so it only
% changes when a base is added. Tiles = one scatter, 3 newest lettered.
k = 1:12;
s.mx = 20 + 21*k + 5*sin(.8*k);
s.my = -8 - 15*k + 4*cos(.8*k);
s.g.ms = scatter(ax, nan, nan, 170, [1 1 1], 's', 'filled', 'Parent', s.g.tr, P{:});
for k = 1:3
    s.g.mt(k) = T(s.g.tr, s.mx(k), s.my(k), 10, [0 0 0]);
end
s.g.tg = L(s.g.tr, 'Marker','o', 'MarkerSize',20, 'LineWidth',2);
s.g.pop = L(s.g.tr, 'Marker','o', 'Color',[1 1 1], 'XData',0, 'YData',0);
% Pendulum arrow: rod + bob (base marker hides under the body)
s.g.ar = L(s.g.tq, 'LineWidth',4, 'Marker','o', 'MarkerSize',11, 'XData',[0 0], 'YData',[16 52]);
s.g.b = L(s.g.tr, 'Marker','o', 'MarkerSize',30, 'LineWidth',2.5, ...
    'MarkerEdgeColor',[1 1 1], 'XData',0, 'YData',0);
% HUD
rectangle(ax, 'Position',[20 560 224 20], 'FaceColor',[.12 .1 .2], P{:});
s.g.bar = rectangle(ax, 'Position',[22 562 220 16], 'EdgeColor','none', P{:});
T(ax, 268, 570, 11, [.8 .8 1], 'String','NTP');
s.g.sc = T(ax, 450, 568, 20, [1 1 1]);
s.g.bt = T(ax, 720, 568, 12, [1 .85 .3]);
s.g.cb = T(ax, 400, 520, 18, [1 .9 .2]);
s.g.pn = patch(ax, [110 690 690 110], [170 170 430 430], [0 0 0], 'FaceAlpha',.6, ...
    'EdgeColor',[.4 .9 1], P{:});
% Start screen text is set once here (restart skips the start screen)
s.g.m1 = T(ax, 400, 380, 32, [.3 1 .9], 'String','TRANSCRIPTION');
s.g.m2 = T(ax, 400, 270, 14, [1 1 1], 'FontWeight','normal', 'String', ...
    sprintf(['RNA polymerase reads DNA, writes mRNA (A>U T>A G>C C>G).\n\n' ...
    'TAP to step where the arrow points.\nWrong side = stall. ' ...
    'Finish genes to refill NTPs.\n\nTAP TO START']));
s = rst(s, 0);
end

function s = rst(s, mode)
s.mode = mode;
s.n = 1; s.rx = 0; s.rd = 1; s.rp = 1; s.m = [];
s.Gk = 1; s.Gp = 0; s.gene = 1; s.rel = 0;
s = gen(s);
s.E = 1; s.ph = pi/2; s.t = 0; s.fa = 1;
s.cx = 0; s.cy = 58; s.X = 0; s.Y = 58;
s.hop = 0; s.pop = 1; s.cm = 0; s.last = -9; s.ct = 0;
s.sk = 0; s.sh = [0 0];
s.sp = 0;   % fvx/fvy/why/nb/to are set by fail() before use
end

function s = gen(s)
% Append rungs: each zigzags left/right of the previous, runs allowed.
while numel(s.rx) < s.n + 30
    i = numel(s.rx) + 1;
    d = s.rd(i-1);
    if rand > .45 || i < 3
        d = -d;
    end
    s.rd(i) = d;
    s.rx(i) = s.rx(i-1) + d*62;
    % Gene bookkeeping: force AUG start and a stop codon at the end
    s.Gp = s.Gp + 1;
    if s.Gp > gl(s.Gk)
        s.Gk = s.Gk + 1; s.Gp = 1;
    end
    c = gl(s.Gk) - s.Gp;
    e = randi(4);
    if s.Gp < 4
        e = s.Gp;               % A U G
    elseif c < 3
        if c == 2
            st = [2 1 1; 2 1 3; 2 3 1];   % UAA UAG UGA
            s.Gs = st(randi(3),:);
        end
        e = s.Gs(3 - c);
    end
    s.rp(i) = s.R(e);   % template base complementary to mRNA base e
end
end

function n = gl(k)
% Gene length (nt): 30, 45, 60, 90, then +30 each
v = [1 1.5 2 3];
n = 30*max(k - 1, v(min(k, 4)));
end

function s = upd(s, dt, p)
s.t = s.t + dt;
s.ct = max(0, s.ct - dt);
s.rel = max(0, s.rel - dt);
s.pop = s.pop + dt;
s.hop = max(0, s.hop - dt);
s.sk = s.sk*exp(-7*dt);
s.sh = s.sk*(2*rand(1,2) - 1);   % screen-shake offset [x y]
lv = s.n - 1;
per = max(.5, 1.45 - .004*lv);            % swing period (s)
switch s.mode
    case 0
        per = 1.6;
        s.mode = double(p);
    case 1
        s.E = s.E - dt*min(.6, .06 + .0024*lv);   % NTP drain
        if p
            if s.fa == s.rd(s.n+1)
                s.n = s.n + 1;
                % Template base (left strand) -> complementary RNA base
                s.m(end+1) = s.R(s.rp(s.n));
                s.cm = 1 + s.cm*(s.t - s.last < .45);
                s.last = s.t;
                if s.cm >= 3
                    s.ct = .6;
                end
                s.E = min(1, s.E + .1 + .006*min(s.cm,6));
                s.pop = 0; s.hop = .12;
                s = gen(s);
                if numel(s.m) == gl(s.gene)   % gene finished
                    s.gene = s.gene + 1; s.m = []; s.E = 1; s.rel = 1.6;
                end
            else
                s = fail(s, s.fa, 'POLYMERASE STALLED');
            end
        end
        if s.mode == 1 && s.E <= 0
            s.E = 0;
            s = fail(s, s.rd(s.n+1), 'OUT OF NTPs');
        end
    case 2
        s.to = s.to + dt;
        s.fvy = s.fvy - 1900*dt;
        s.cx = s.cx + s.fvx*dt;
        s.cy = s.cy + s.fvy*dt;
        s.fvx = s.fvx*exp(-2*dt);
        s.sp = s.sp + dt*14;
        if p && s.to > .45
            s = rst(s, 1);
        end
        return
end
% Advance swing after input so taps judge the facing the player saw
s.ph = s.ph + dt*2*pi/per;
s.fa = 1 - 2*(sin(s.ph) < 0);
k = min(1, dt*22);
s.cx = s.cx + (s.rx(s.n) - s.cx)*k;
s.cy = s.cy + (s.n*58 - s.cy)*k;
k = min(1, dt*7);
s.X = s.X + (s.cx - s.X)*k;
s.Y = s.Y + (s.cy - s.Y)*k;
end

function s = fail(s, f, why)
s.mode = 2; s.to = 0; s.why = why;
s.sk = 16; s.fvx = f*186; s.fvy = 380; s.sp = 0;
s.nb = s.n - 1 > s.bs;
s.bs = max(s.bs, s.n - 1);
end

function ren(~, s)
G = s.g;
% Camera offset rounded to whole pixels: once the camera settles, the
% values stop changing and sv() skips the updates entirely.
ox = round(400 - s.X + s.sh(1));
oy = round(190 - s.Y + s.sh(2));
% Transcription bubble centred on the polymerase: w = opening weight,
% op = backbone half-width (opens to 113 px inside the bubble)
q = s.n;
if s.mode < 2
    q = s.cy/58;
end
w = @(i) exp(-((i - q)/2.3).^2);
op = @(i,h) h + w(i).*(113 - h);
% Backbones: 97 samples per strand (clamped at the bottom), both strands
% in one Vertices array shared by the glow and core patches
S = max(1, s.n - 4:.125:s.n + 8);
fl = floor(S);
c = s.rx(fl) + (s.rx(fl+1) - s.rx(fl)).*(1 - cos(pi*(S - fl)))/2 + ox;
h = op(S, 78*cos(.45*S + .8*s.t));
set(G.bb, 'Vertices', [c + h, c - h; S*58 + oy, S*58 + oy]');
% Rungs n-4..n+7 (the on-screen ones), vectorised. Halves pull apart
% inside the bubble; quad half-height 1+2.5*dep = old line width/2.
% Index clamped at the bottom: a clamped rung draws on top of rung 1.
i = max(1, s.n - 4:s.n + 7);
th = .45*i + .8*s.t;
he = op(i, 78*cos(th));
d = .35 + .65*(sin(th) + 1)/2;
x = s.rx(i) + ox; y = i*58 + oy;
b = [s.rp(i) s.R(s.rp(i))];
A = [x - he, x + he]; B = [x, x] + .6*w([i i]).*[-he he];
Y = [y y]; d = [d d]; h = 1 + 2.5*d;
set(G.r, 'Vertices', [reshape([A; B; B; A], [], 1) reshape([Y - h; Y - h; Y + h; Y + h], [], 1)], ...
    'FaceVertexCData', s.bc(b,:).*d');
% Template-base labels on the next 3 rungs, at the rung centre
for j = 6:8
    sv(G.t(j - 5), 'Position', [x(j) y(j) + 12 0], 'String', s.bl(b(j)));
end
% Polymerase rig: one translation + one rotation
hp = 14*sin(pi*(1 - s.hop/.12))*(s.hop > 0);
bx = round(s.cx + ox); by = round(s.cy + oy + 18 + hp);
sv(G.tr, 'Matrix', makehgtform('translate', [bx by 0]));
sv(G.tq, 'Matrix', makehgtform('zrotate', -1.15*sin(s.ph) - s.sp));
cl = [.6 .725 .575] + s.fa*[-.4 .275 .425];   % right: cyan, left: orange
sv(G.ar, 'Color', cl, 'MarkerFaceColor', cl);
% Body blinks red when NTPs are low
sv(G.b, 'MarkerFaceColor', [.75 .45 1] + (s.E < .25 && mod(s.t, .3) < .15)*[.25 -.25 -.8]);
% Target ring at the next rung on the facing side (local coordinates)
sv(G.tg, 'XData', s.rx(s.n) + s.fa*62 + ox - bx, 'YData', (s.n + 1)*58 + oy - by, ...
    'Color', cl, 'Visible', s.mode == 1);
% mRNA (newest base next to the polymerase): changes only on a new base
nm = numel(s.m);
k = 1:min(nm, 12);
e = s.m(nm + 1 - k);
sv(G.ms, 'XData', s.mx(k), 'YData', s.my(k), 'CData', s.bc(e,:));
for k = 1:3
    sv(G.mt(k), 'String', s.rl(e(k:min(k, end))));
end
% Pop ring: only touched while it is showing
sv(G.pop, 'Visible', s.pop < .3);
if s.pop < .3
    set(G.pop, 'MarkerSize', 18 + 255*s.pop, 'LineWidth', 4 - 12*s.pop);
end
% HUD (bar quantised to 2 px so it is not re-sent every frame)
e = round(110*max(0, s.E))/110;
sv(G.bar, 'Position', [22 562 max(.01, 220*e) 16], ...
    'FaceColor', [min(1, 2*(1-e)) min(1, 2*e)*.9 .25]);
sv(G.sc, 'String', sprintf('GENE %d  %d/%d nt', s.gene, nm, gl(s.gene)));
sv(G.bt, 'String', sprintf('BEST %d nt', s.bs));
m = sprintf('COMBO x%d', s.cm); f = round(18 + 16*s.ct);
if s.rel > 0
    m = sprintf('mRNA RELEASED - gene %d', s.gene - 1); f = 24;
end
sv(G.cb, 'Visible', s.ct + s.rel > 0, 'String', m, 'FontSize', f);
% Screens
for h = [G.pn G.m1 G.m2]
    sv(h, 'Visible', s.mode ~= 1);
end
if s.mode == 2
    sv(G.m1, 'String', s.why, 'Color', [1 .3 .4]);
    m = sprintf('5''-%s%s-3''\n\n%d genes, %d nt%s\nBEST %d nt', repmat('...', 1, nm > 12), ...
        s.rl(s.m(max(1, nm - 11):end)), s.gene - 1, s.n - 1, repmat('  NEW BEST', 1, s.nb), s.bs);
    if s.to > .45
        m = [m newline newline 'TAP TO TRANSCRIBE'];
    end
    sv(G.m2, 'String', m);
end
end


function sv(h, varargin)
% sv(h, prop, value, ...) sets each property only when its value changes,
% so unchanged text/visibility does not trigger a redraw.
for k = 1:2:numel(varargin)
    if ~isequal(h.(varargin{k}), varargin{k+1})
        h.(varargin{k}) = varargin{k+1};
    end
end
end
Play Game
Preview

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