Dino run

Vinay Ramesh
/
Dino run
on 2 Nov 2026
2
10
8
0
9205
game.m
function g = game()
%game One-button dino runner. Tap SPACE or click to jump the cacti.
%
%   The desert scrolls left at a speed that ramps up with distance. The
%   dinosaur auto-runs in place; the only input is a single edge-triggered
%   button. Tap on the ground to jump, tap again in mid-air to double
%   jump. Cacti sometimes come in clusters that need the double jump.
%
%   You start with three lives. Hitting a cactus costs one and makes the
%   dino briefly invulnerable (it blinks). While a life is missing, a
%   floating heart sometimes appears -- jump into it to win the life back.
%   Your score is the distance run, in metres.
%
%   Workflow:
%       >> minihackContest.validate
%       >> minihackContest.play
%       >> minihackContest.submit

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

end

function state = initState(ax)
% Build the world and every graphics object once. render() only mutates
% the handles stored in state.g -- it never creates anything. All per-run
% values (position, lives, cacti, ...) are set by resetRound.

% --- World (harness supplies an 800x600 world) ----------------------
state.groundY = 120;          % y of the ground surface (dino stands here)

% --- Dino & physics (all motion is scaled by dt in update) ----------
state.playerX = 150;          % fixed horizontal position
state.playerW = 52;
state.playerH = 56;
state.gravity = -2300;        % px/s^2
state.jumpV = 830;            % px/s launch velocity
state.jump2V = 720;           % px/s double-jump velocity

% Dino silhouette in unit coords (x right, y up), facing right.
state.dinoShape = [0 .72; .12 .62; .35 .66; .52 .72; .52 1; 1 1; 1 .8; ...
    .78 .8; .78 .75; .9 .75; .9 .68; .7 .68; .7 .56; .84 .5; .84 .44; ...
    .7 .48; .66 .3; .55 .22; .3 .22; .15 .38];

% Saguaro silhouette in unit coords: rounded trunk, two curved arms.
a = @(cx,cy,r,t0,t1) [cx+r*cosd(linspace(t0,t1,7))', cy+r*sind(linspace(t0,t1,7))'];
state.cactusShape = [.32 0; .32 .3; a(.14,.42,.12,270,180); ...
    a(.11,.66,.09,180,0); a(.26,.48,.06,180,270); .32 .42; ...
    a(.5,.82,.18,180,0); .68 .58; a(.74,.64,.06,270,360); ...
    a(.89,.8,.09,180,0); a(.86,.58,.12,0,-90); .68 .46; .68 0];

% Vertical ribs (NaN-separated); their vertices double as spine tufts.
r = [.41 .04 .88; .5 .04 .96; .59 .04 .88; .11 .36 .7; .89 .52 .84];
state.ribShape = NaN(35, 2);
for k = 1:5
    state.ribShape(7*k-6:7*k-1, :) = [r(k,1)*ones(6,1), linspace(r(k,2),r(k,3),6)'];
end

% --- Parallax clouds and ground pebbles (motion cues) ---------------
state.cloud.x = [220 480 700];
state.cloud.y = [470 520 440];
state.cloud.s = [1 .8 1.2];
state.stripe.x = linspace(0, 800, 7);

state = resetRound(state);
state.started = false;        % wait on the title screen for the first tap

ax.Color = [.99 .87 .68];     % warm desert sky

% --- Graphics objects (create ONCE) ---------------------------------
% Each graphics property update is costly, so like objects are batched:
% one patch for all clouds, one for all cacti (a column per face, NaN =
% hidden), one line for all ribs / pebbles, and an hgtransform for the
% whole dino. render() then touches only about ten objects per frame.
o = {'HitTest','off','PickableParts','none'};   % keep clicks on the button
e = [o {'EdgeColor','none'}];                    % filled shapes, no outline
c = [e {'Curvature',[1 1]}];                     % ...and rounded

rectangle(ax, c{:}, 'Position',[650 470 95 95], 'FaceColor',[1 .72 .3]);
state.g.cloud = patch(ax, e{:}, 'XData',NaN, 'YData',NaN, 'FaceColor',[1 .97 .92]);
rectangle(ax, e{:}, 'Position',[0 0 800 state.groundY], 'FaceColor',[.93 .76 .48]);
state.g.stripe = line(ax, o{:}, 'XData',NaN(21,1), 'YData',repmat([78;78;NaN],7,1), ...
    'LineWidth',6, 'Color',[.8 .63 .4]);

state.g.obs = patch(ax, o{:}, 'XData',NaN, 'YData',NaN, 'FaceColor',[.33 .55 .31], ...
    'EdgeColor',[.17 .33 .18], 'LineWidth',1.5);
state.g.rib = line(ax, o{:}, 'XData',NaN, 'YData',NaN, 'Color',[.22 .42 .23], 'Marker','.', ...
    'MarkerSize',6, 'MarkerEdgeColor',[.96 .93 .78]);

state.g.puff = rectangle(ax, c{:}, 'EdgeColor','w', 'LineWidth',2.5);

% Dino parts live in unit coords; the transform scales and places them.
dinoC = [.33 .34 .38];
T = hgtransform(ax, o{:});
state.g.dino = T;
patch(T, e{:}, 'XData',state.dinoShape(:,1), 'YData',state.dinoShape(:,2), 'FaceColor',dinoC);
state.g.legs = patch(T, e{:}, 'XData',[.3 .41 .41 .3; .5 .61 .61 .5]', ...
    'YData',zeros(4,2), 'FaceColor',dinoC);
rectangle(T, c{:}, 'Position',[.6 .84 .154 .143], 'FaceColor','w');
rectangle(T, c{:}, 'Position',[.667 .876 .077 .071], 'FaceColor',[.05 .05 .08]);

state.g.heart = text(ax, 0, 0, char(9829), o{:}, 'Color',[.88 .16 .24], 'FontSize',30, ...
    'HorizontalAlignment','center');

t = [o {'Color',[.35 .22 .12], 'FontWeight','bold'}];
state.g.score = text(ax, 22, 585, '', t{:}, 'FontSize',22, 'VerticalAlignment','top');
state.g.msg = text(ax, 400, 340, '', t{:}, 'FontSize',30, 'HorizontalAlignment','center');
end

function state = updateState(state, dt, pressed)
% Advance the world by dt seconds. `pressed` is one true per press.

% Title / game-over screens: a tap starts a fresh run and, falling
% through, also launches the first hop.
if state.gameOver || ~state.started
    if ~pressed, return; end
    state = resetRound(state);
end

% Difficulty ramp: speed climbs with distance, then plateaus.
state.scrollSpeed = 320 + min(state.dist * .03, 340);
state.dist = state.dist + state.scrollSpeed * dt;

% Jump from the ground, or double jump once while airborne.
if pressed
    if state.grounded
        state.vy = state.jumpV;
        state.grounded = false;
        state.jumpsLeft = 1;
    elseif state.jumpsLeft > 0
        state.vy = state.jump2V;
        state.jumpsLeft = 0;
        state.puff.t = 1;
        state.puff.x = state.playerX + 20;
        state.puff.y = state.playerY;
    end
end

% Vertical physics.
state.vy = state.vy + state.gravity * dt;
state.playerY = state.playerY + state.vy * dt;
if state.playerY <= state.groundY
    state.playerY = state.groundY;
    if ~state.grounded
        state.squash = 1;     % just landed -> squash pop
    end
    state.vy = 0;
    state.grounded = true;
    state.jumpsLeft = 0;
end
state.squash = max(0, state.squash - dt * 6);
state.puff.t = max(0, state.puff.t - dt * 3);
state.hurt = max(0, state.hurt - dt);
state.runPhase = state.runPhase + state.scrollSpeed * dt / 45;

% Parallax clouds (slower than the ground), then ground pebbles.
state.cloud.x = state.cloud.x - state.scrollSpeed * .15 .* state.cloud.s * dt;
state.cloud.x(state.cloud.x < -90) = 860;
state.stripe.x = state.stripe.x - state.scrollSpeed * dt;
wrap = state.stripe.x < -28;
state.stripe.x(wrap) = state.stripe.x(wrap) + 828;

% Spawn cacti on a distance-based cadence so gaps stay fair as speed
% rises. Sometimes spawn a cluster of 2-3 that calls for a double jump.
state.spawnTimer = state.spawnTimer - dt;
if state.spawnTimer <= 0
    count = 1;
    if rand < .3, count = 2 + (rand < .4); end
    x = 820;
    for k = 1:count
        idx = find(~state.obs.active, 1);
        if isempty(idx), break; end
        state.obs.active(idx) = true;
        state.obs.w(idx) = 34 + rand * 20;
        state.obs.h(idx) = 44 + rand * 56;
        state.obs.x(idx) = x;
        x = x + state.obs.w(idx) * .85;
    end
    state.spawnTimer = (300 + rand * 220 + x - 820) / state.scrollSpeed;
end

% Hitboxes are inset a little so near-misses feel fair.
px1 = state.playerX + 8;
px2 = state.playerX + 42;

% Move active cacti, test collision, recycle off-screen ones. A hit
% costs a life and grants a short invulnerability window.
for i = find(state.obs.active)
    state.obs.x(i) = state.obs.x(i) - state.scrollSpeed * dt;
    ox = state.obs.x(i);
    ow = state.obs.w(i);
    if px1 < ox + ow * .9 && px2 > ox + ow * .1 && ...
            state.playerY < state.groundY + state.obs.h(i) * .95 && state.hurt <= 0
        state.lives = state.lives - 1;
        state.hurt = 1.5;
        state.gameOver = state.lives <= 0;
    end
    state.obs.active(i) = ox + ow > -12;
end

% Heart pickup: floats in at jump height, only while a life is missing.
state.heartTimer = state.heartTimer - dt;
if state.heartTimer <= 0
    state.heartTimer = 9 + rand * 6;
    state.heart.on = state.lives < 3;
    state.heart.x = 820;
    state.heart.y = 200 + rand * 110;
end
state.heart.x = state.heart.x - state.scrollSpeed * dt;
if state.heart.on && abs(state.heart.x - state.playerX - 26) < 36 && ...
        abs(state.heart.y - state.playerY - 28) < 42
    state.lives = state.lives + 1;
    state.heart.on = false;
end
state.heart.on = state.heart.on && state.heart.x > -40;
end

function renderFrame(~, state)
% Push state onto the existing handles. No creation, no drawnow. Every
% batched object is updated with a single set() call.
G = state.g;
gy = state.groundY;

% Dino: squash (landing: wide+short) / stretch (airborne: tall+thin),
% placed by the transform; blink while invulnerable after a hit.
k = .25 * state.squash - .25 * min(.2, abs(state.vy) / 4000);
w = state.playerW * (1 + k);
h = state.playerH * (1 - k);
set(G.dino, 'Visible', state.gameOver || mod(floor(state.hurt * 12), 2) == 0, ...
    'Matrix', [w 0 0 state.playerX + (state.playerW - w) / 2; 0 h 0 state.playerY; 0 0 1 0; 0 0 0 1]);

% Legs: alternate while running, both stretched down while airborne.
lift = [0 0];
if state.grounded && state.started && ~state.gameOver
    step = mod(floor(state.runPhase), 2);
    lift = .108 * [step, 1 - step];
end
G.legs.YData = [lift; lift; .28 .28; .28 .28];

r = 10 + (1 - state.puff.t) * 40;
set(G.puff, 'Visible', state.puff.t > 0, 'Position', ...
    [state.puff.x - r, state.puff.y - r * .4, 2 * r, r * .8]);

th = linspace(0, 2*pi, 32)';
s = state.cloud.s;
set(G.cloud, 'XData', state.cloud.x + 40 * s .* (1 + cos(th)), ...
    'YData', state.cloud.y + 17 * s .* (1 + sin(th)));
x = state.stripe.x;
G.stripe.XData = reshape([x; x + 18; NaN(1, 7)], [], 1);

% Cacti: one column per cactus; inactive ones are NaN and not drawn.
off = ~state.obs.active;
X = state.obs.x + state.cactusShape(:,1) .* state.obs.w;
X(:, off) = NaN;
set(G.obs, 'XData', X, 'YData', gy + state.cactusShape(:,2) .* state.obs.h);
X = state.obs.x + state.ribShape(:,1) .* state.obs.w;
X(:, off) = NaN;
Y = gy + state.ribShape(:,2) .* state.obs.h;
set(G.rib, 'XData', X(:), 'YData', Y(:));

set(G.heart, 'Visible', state.heart.on, 'Position', ...
    [state.heart.x, state.heart.y + 6 * sin(state.dist / 40)]);

m = floor(state.dist / 10);
G.score.String = {sprintf('%d m', m), ['\color[rgb]{.88 .16 .24}' ...
    repmat(char(9829), 1, state.lives), repmat(char(9825), 1, 3 - state.lives)]};
msg = sprintf('TAP TO START\ntap in air to double jump');
if state.gameOver
    msg = sprintf('GAME OVER\n%d m  -  TAP', m);
end
set(G.msg, 'Visible', state.gameOver || ~state.started, 'String', msg);
end


function state = resetRound(state)
% Start a fresh run, preserving all graphics handles in state.g.

state.started = true;
state.gameOver = false;
state.dist = 0;
state.scrollSpeed = 320;
state.playerY = state.groundY;
state.vy = 0;
state.grounded = true;
state.jumpsLeft = 0;          % mid-air jumps remaining (1 = double jump ready)
state.runPhase = 0;           % drives the leg animation
state.squash = 0;             % 1 right after a landing, decays to 0
state.puff = struct('t', 0, 'x', 0, 'y', 0);    % double-jump puff ring
state.lives = 3;
state.hurt = 0;               % invulnerability seconds left after a hit
state.heart = struct('on', false, 'x', -100, 'y', 0);
state.heartTimer = 8;         % seconds until the next heart may appear

% Cactus pool (fixed size, recycled).
state.obs.x = -100 * ones(1, 9);
state.obs.w = zeros(1, 9);
state.obs.h = zeros(1, 9);
state.obs.active = false(1, 9);
state.spawnTimer = .8;        % seconds until the next spawn
end
Play Game
Preview

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