Pump-Send: A Mountain Bike Adventure

Alisha Schor
/
Pump-Send: A Mountain Bike Adventure
on 4 Nov 2026
10
80
28
1
9930
game.m
function g = game()
%GAME pumpsend: a one-button game for the MATLAB One-Button Game Mini Hack.
%   Tap Space or click. Generated by packGame from games/pumpsend/dev.
g.init = @pumpsendInit;
g.update = @pumpsendUpdate;
g.render = @pumpsendRender;
end

function s = pumpsendInit(ax)
%PUMPSENDINIT Style the contest axes, create every graphics object once, and start the first ride.
% Start the ride first so the constants are known; the graphics are added to it below
s = pumpsendNewRun(struct(g=struct()));
g = s.g;

% Paint the landscape
g.sky = patch(ax, XData=[0, 800, 800, 0], YData=[0, 0, 600, 600], FaceVertexCData=s.skyColors([1, 1, 2, 2], :), ...
    FaceColor="interp", EdgeColor="none");
g.sun = plot(ax, 620, 400, "o", MarkerSize=54, MarkerFaceColor=[1, 0.93, 0.7], MarkerEdgeColor="none");

for k = 1:height(s.layers) % Mesa layers, far to near
    g.layers(k) = patch(ax, 0, 0, s.layers(k, 7:9), FaceAlpha=s.layers(k, 6), EdgeColor="none");
end
g.ground = patch(ax, 0, 0, [0.3, 0.3, 0.32], EdgeColor=[0.18, 0.18, 0.2], LineWidth=2);
rider = [0.12, 0.1, 0.14];
g.wheels = plot(ax, [0, 0], [0, 0], "o", MarkerSize=18, Color=rider, LineWidth=2);
g.frame = plot(ax, 0, 0, Color=[0.85, 0.15, 0.1], LineWidth=3);
g.torso = patch(ax, 0, 0, rider, EdgeColor="none");
g.limbs = plot(ax, 0, 0, Color=rider, LineWidth=4, Marker="o", MarkerIndices=9, MarkerSize=10, ...
    MarkerFaceColor=rider);
g.crestLine = plot(ax, 0, 0, Color=[1, 0.9, 0.1], LineWidth=5);
% Render sets the texts' Visible before the first frame is drawn
g.scoreText = text(ax, 20, 570, "Score 0", FontSize=18);
g.hintText = text(ax, 400, 480, "Tap downhill: pump · on a glowing lip: launch · in the air: backflip", ...
    FontSize=16, HorizontalAlignment="center");
g.flashText = text(ax, 0, 0, "", FontSize=20, HorizontalAlignment="center");
g.overText = text(ax, 400, 340, "", FontSize=22, HorizontalAlignment="center");
% Every object ignores clicks so they always reach the contest's button; all texts are bold
s.g = g;
set(ax.Children, HitTest="off", PickableParts="none");
set([g.scoreText, g.hintText, g.flashText, g.overText], FontWeight="bold");
end

function s = pumpsendNewRun(s)
%PUMPSENDNEWRUN Start a fresh ride: tuning constants, a new random track and the rider on the ground.
%   Keeps s.g (s is the game state everywhere). Units are meters, seconds and radians.
%   The fields are listed as name-value pairs and copied onto s in one loop.
fields = struct( ...
    gravity=8.83, ...
    rollDrag=0.08, ...
    pumpDuration=0.3, ...
    pumpGain=2.4, ...
    pumpPenalty=0.9, ...
    pumpSlopeFull=0.4, ...
    spinDamping=0.8, ...
    flipBonus=50, ...
    maxSpeed=22, ...
    stallSpeed=1.5, ...
    stallTime=1.5, ...
    graceTime=0.5, ...
    hintTime=6, ...
    subStep=0.01, ...
    amps=[0.88, 0.275, 0.066], ...
    waveNumbers=[0.35, 0.83, 1.9], ...
    phases=2 * pi * rand(1, 3), ...
    ampGrowth=0.002, ...
    easyHard=[1.3, 2.8; 0.8, 2.5], ... % Difficulty ramp stages
    rampDistance=500, ...
    timeScale=0.8, ...
    hipHeight=0.75, ...
    flightTime=3, ...
    flightSamples=61, ...
    pixelsPerMeter=40, ...
    riderScreenX=250, ...
    screenLeft=-10, ...
    screenRight=810, ...
    screenMidY=210, ...
    groundSamples=81, ...
    ...                          Desert backdrop: one row per layer, far to near. Columns:
    ...                          1 parallax rate (fraction of the track's scroll speed),
    ...                          2 px per radian of the ridge profile, 3 ridge foot (px),
    ...                          4 ridge height above the foot (px),
    ...                          5 cliff steepness (high = flat-topped mesas, low = dunes),
    ...                          6 opacity, 7-9 color
    layers=[0.08, 70, 250, 120, 4, 0.5, 0.6, 0.45, 0.6; ...         dusty purple mesas
    0.2, 55, 215, 90, 3, 0.7, 0.78, 0.42, 0.28; ...                 rust mesas
    0.4, 90, 175, 60, 0.4, 0.9, 0.92, 0.72, 0.46], ...              sand dunes
    skyColors=[1, 0.86, 0.66; 0.3, 0.55, 0.9], ...                          horizon haze, zenith
    torsoPoints=13, ...
    torsoWidth=0.45, ...
    cameraEase=3, ...            1/s, vertical camera smoothing rate
    popImpulse=3, ...            m/s pop boost added to the tangent launch at popSpeedRef
    popSpeedRef=6, ...
    popSpeedCap=1.2, ...
    flashTime=0.5, ...
    ...                          Gameplay
    alive=true, ...
    score=0, ...
    flips=0, ...
    x=0, ...
    speed=7, ...
    vx=0, ...
    vy=0, ...
    omega=0, ...
    airSpin=0, ...
    airborne=false, ...
    pumpTimer=0, ...
    stallTimer=0, ...
    deadTimer=0, ...
    deadMessage="", ...
    elapsed=0, ...
    pops=0, ...
    flashTimer=0, ...
    flashLabel="", ...
    flashGood=false);
for name = string(fieldnames(fields))'
    s.(name) = fields.(name);
end
[s.y, slope] = pumpsendTerrain(s, 0);
s.angle = atan(slope);
s.cameraY = s.y;
s = pumpsendDifficulty(s);
end

function s = pumpsendUpdate(s, dt, pressed)
%PUMPSENDUPDATE Advance one frame: judge the tap (launch, pump, scrub or spin), integrate in substeps, check stall.
%   The ride runs in slow motion (timeScale). After game over the world freezes; a tap after
%   graceTime (real seconds) starts a new ride.
if ~s.alive
    s.deadTimer = s.deadTimer + dt;
    if pressed && s.deadTimer >= s.graceTime
        s = pumpsendNewRun(s);
    end
    return
end
dt = dt * s.timeScale; % The game was too hard, so I slowed down time a bit
s = pumpsendDifficulty(s);

% The tap: a backflip impulse in the air; on the ground a launch in the lip window (the rising convex
% face before a crest), else a pump on any downhill, else a scrub
if pressed && s.airborne
    s.omega = s.omega + s.spinImpulse;
elseif pressed
    [~, slope, kappa] = pumpsendTerrain(s, s.x);
    s.flashTimer = s.flashTime;
    if kappa < 0 && slope >= 0
        % Lip launch along the tangent plus a pop boost; speed is kept.
        % The bike leaves pointing along its flight; omega is already zero (touchdowns and new rides clear it)
        [s.vx, s.vy] = pumpsendLaunch(s, slope);
        s.angle = atan2(s.vy, s.vx);
        s.airborne = true;
        s.airSpin = 0;
        s.pumpTimer = 0;
        s.pops = s.pops + 1;
        s.flashLabel = "POP!";
        s.flashGood = true;
    else
        % A pump on any downhill earns the most where it is steepest (a level spot earns about nothing, but
        % costs nothing); the climb into a lip, or a second tap within pumpDuration, scrubs speed
        s.flashGood = s.pumpTimer <= 0 && slope < 0;
        labels = ["Scrub", "Pump!"];
        s.flashLabel = labels(1 + s.flashGood);
        % pumpsendStep clamps the speed
        s.speed = s.speed + s.flashGood * s.pumpGain * min(1, -slope / s.pumpSlopeFull) ...
            - ~s.flashGood * s.pumpPenalty;
        s.pumpTimer = s.pumpDuration;
    end
end

% Physics in substeps of at most subStep seconds
nSteps = ceil(dt / s.subStep);
for k = 1:nSteps
    s = pumpsendStep(s, dt / nSteps);
    if ~s.alive
        break
    end
end
s.pumpTimer = max(0, s.pumpTimer - dt);
s.flashTimer = max(0, s.flashTimer - dt);

% Stall: too slow on the ground for too long
% (the timer resets to zero whenever the rider is fast enough or in the air)
s.stallTimer = (s.stallTimer + dt) * (s.speed < s.stallSpeed && ~s.airborne);
if s.alive && s.stallTimer >= s.stallTime
    s.alive = false;
    s.deadMessage = "Stalled!";
end

s.score = floor(s.x) + s.flips * s.flipBonus;
s.elapsed = s.elapsed + dt;
s.cameraY = s.cameraY + (s.y - s.cameraY) * (1 - exp(-s.cameraEase * dt));
end

function pumpsendRender(~, s)
%PUMPSENDRENDER Push the state onto the graphics created in pumpsendInit (sets properties only).
%   World to screen: sx = riderScreenX + (xw - x)*ppm, sy = screenMidY + (yw - cameraY)*ppm.
ppm = s.pixelsPerMeter;
g = s.g;
midY = s.screenMidY;

screenX = linspace(s.screenLeft, s.screenRight, s.groundSamples);
edgeX = [screenX, screenX([end, 1])];
% Desert layers scroll slower than the track the farther they are (parallax). Each ridge is a
% clipped sum of sines: clipping a steep profile at 0 and 1 gives mesas with flat tops and cliffs.
for k = 1:numel(g.layers)
    layer = s.layers(k, :);  % rate, px per radian, foot, height, steepness (see pumpsendNewRun)
    u = (screenX + s.x * ppm * layer(1)) / layer(2) + 2 * k;
    ridge = min(1, max(0, layer(5) * (sin(u) + 0.6 * sin(2.7 * u)) + 0.5));
    % A slow swell varies the mesa heights so the tops don't line up
    ridge = layer(3) + layer(4) * ridge .* (0.75 + 0.25 * sin(0.3 * u));
    set(g.layers(k), XData=edgeX, YData=[ridge, 0, 0]);
end

% Track
worldX = s.x + (screenX - s.riderScreenX) / ppm;
[trackY, trackSlope, trackKappa] = pumpsendTerrain(s, worldX);
trackY = midY + (trackY - s.cameraY) * ppm;
% Two corners well below the view close the patch; XData/YData (not Vertices) also rebuild Faces
set(g.ground, XData=edgeX, YData=[trackY, -midY, -midY]);
% Safe lips glow: the rising convex faces where a pop at the current speed lands on a downslope.
% NaN breaks the line elsewhere (0/0 is NaN outside, 0/1 adds nothing inside)
safeLip = trackKappa < 0 & trackSlope >= 0 & pumpsendSafeLip(s, worldX);
set(g.crestLine, XData=screenX, YData=trackY + 0 ./ safeLip);

% Bike and rider as complex points (real = x forward, imag = y up) in local pixels, turned by the
% pitch angle with one complex multiply
crouch = 6i * min(1, s.pumpTimer / (s.pumpDuration / 2));
turn = exp(1i * s.angle);
origin = s.riderScreenX + 1i * (midY + (s.y - s.cameraY) * ppm);
% The wheels are round markers at the hubs, so they need no rotation
hubs = origin + turn * [-18 + 12i, 18 + 12i];
frame = origin + turn * [-18 + 12i, -4 + 30i, 16 + 30i, 18 + 12i, -18 + 12i];
% Rider standing on the pedals (after body.svg): shoulder, elbow, hand on the bars, NaN, hip, knee,
% foot on the pedal, NaN, head (drawn as a marker only). A pump crouch lowers the upper body.
pose = [2 + 56i, 12 + 44i, 16 + 30i, NaN, -2 + 37i, 7 + 29i, -1 + 16i, NaN, 5 + 65i] ...
    - crouch * [1, 0.5, 0, 0, 1, 0.5, 0, 0, 1];
% Torso: an ellipse whose long axis runs from the hip to the shoulder (complex multiply = rotate
% and scale the unit circle onto that axis)
ring = exp(1i * linspace(0, 2 * pi, s.torsoPoints));
torso = origin + turn * ((pose(1) + pose(5)) / 2 + ...
    (pose(1) - pose(5)) / 2 * (real(ring) + s.torsoWidth * 1i * imag(ring)));
limbs = origin + turn * pose;
set(g.wheels, XData=real(hubs), YData=imag(hubs));
set(g.frame, XData=real(frame), YData=imag(frame));
set(g.limbs, XData=real(limbs), YData=imag(limbs));
set(g.torso, XData=real(torso), YData=imag(torso));

% Flash label: green for a pop or a good pump, red for a scrub
flashColor = [0.9, 0.1, 0.1] + s.flashGood * [-0.8, 0.7, 0.1];  % red, or green when good
set(g.flashText, Position=[real(origin), imag(origin) + 90, 0], String=s.flashLabel, Color=flashColor, ...
    Visible=s.flashTimer > 0 && s.alive);

% Texts
g.scoreText.String = sprintf("Score %d   Flips %d", s.score, s.flips);
g.hintText.Visible = s.alive && s.elapsed < s.hintTime;
g.overText.String = [s.deadMessage + "  Score " + s.score; "Tap to restart"];
g.overText.Visible = ~s.alive;
end

function s = pumpsendDifficulty(s)
%PUMPSENDDIFFICULTY Set the landing window and spin for the rider's distance: easy at the start, hard from rampDistance.
%   Blends the rows of s.easyHard linearly in s.x and writes the live landTolerance and spinImpulse
%   that pumpsendUpdate and pumpsendStep read.
live = s.easyHard(1, :) + min(1, s.x / s.rampDistance) * diff(s.easyHard);
s.landTolerance = live(1);
s.spinImpulse = live(2);
end

function [vx, vy] = pumpsendLaunch(s, slope)
%PUMPSENDLAUNCH Launch velocity of a lip pop at track slope (vectorized): the tangent plus the pop boost.
%   Steeper lips and higher speeds send higher. Shared by the pop in pumpsendUpdate and the flight
%   prediction in pumpsendSafeLip, so the glow and the real jump always agree.
theta = atan(slope);
vx = s.speed * cos(theta);
vy = s.speed * sin(theta) + s.popImpulse * min(s.popSpeedCap, s.speed / s.popSpeedRef);
end

function safe = pumpsendSafeLip(s, x)
%PUMPSENDSAFELIP True where a pop from track point x (row vector) at the current speed lands on a downslope.
%   Follows each untouched flight for flightTime seconds, one column per launch point: the hips fly
%   a parabola and, with the pitch following the flight, the wheels swing around them as it turns.
%   The lip glow (pumpsendRender) and the scripted bot both use it, so the bot pops where the glow
%   shows. A flight that has not landed within flightTime counts as unsafe.
[y, slope] = pumpsendTerrain(s, x);
[vx, vy] = pumpsendLaunch(s, slope);
t = linspace(0, s.flightTime, s.flightSamples)';
% Velocity as a complex number; sign() of it is the unit flight direction, and the bike follows it
heading = sign(vx + 1i * (vy - s.gravity * t));
% Wheels: launch point + parabola + the swing of the wheels about the hips since takeoff
wheels = x + vx .* t + 1i * (y + vy .* t - s.gravity / 2 * t .^ 2) ...
    + 1i * s.hipHeight * (heading(1, :) - heading);
[ground, groundSlope] = pumpsendTerrain(s, real(wheels));
% First sample at or below the track (row 1, the takeoff, when it never lands)
[~, touchdown] = max(imag(wheels) <= ground & t > 0);
safe = groundSlope(touchdown + (0:numel(x) - 1) * numel(t)) < 0;
end

function s = pumpsendStep(s, h)
%PUMPSENDSTEP Advance the rider by one substep h: rolling on the track, or ballistic flight.
%   Ground: semi-implicit Euler along the track. The rider never leaves the ground on its own
%   Air: exact ballistic step, pitch following the trajectory, and a damped backflip spin
%   about the hips; touching down lands cleanly or crashes.
if ~s.airborne
    [~, slope] = pumpsendTerrain(s, s.x);
    theta = atan(slope);
    s.speed = s.speed + (-s.gravity * sin(theta) - s.rollDrag * s.speed) * h;
    s.speed = min(max(s.speed, 0), s.maxSpeed);
    s.x = s.x + s.speed * cos(theta) * h;
    [s.y, slope] = pumpsendTerrain(s, s.x);
    s.angle = atan(slope);
    return
end
% The rider pitches with the trajectory plus the backflip spin (omega > 0 lifts the nose)
pitch = atan2(s.vy, s.vx);
% The hips sit hipHeight above the wheels, across the bike (complex number: real = x, imag = y)
hips = 1i * s.hipHeight * exp(1i * s.angle);
s.x = s.x + s.vx * h;
s.y = s.y + s.vy * h - 0.5 * s.gravity * h ^ 2;
s.vy = s.vy - s.gravity * h;
s.omega = s.omega * exp(-s.spinDamping * h);
s.angle = s.angle + s.omega * h + atan2(s.vy, s.vx) - pitch;
s.airSpin = s.airSpin + s.omega * h;
% The rider turns about the hips, not the wheels
swing = hips - 1i * s.hipHeight * exp(1i * s.angle);
s.x = s.x + real(swing);
s.y = s.y + imag(swing);
[ground, slope] = pumpsendTerrain(s, s.x);
if s.y > ground
    return
end
% Touchdown: land if the bike matches the slope, otherwise crash
theta = atan(slope);
angleError = mod(s.angle - theta + pi, 2 * pi) - pi;
s.airborne = false;
if abs(angleError) < s.landTolerance
    s.y = ground;
    s.angle = theta;
    s.omega = 0;
    s.speed = s.vx * cos(theta) + s.vy * sin(theta);  % clamped by the next ground substep
    s.flips = s.flips + round(s.airSpin / (2 * pi));
else
    s.alive = false;
    s.deadMessage = "Crashed!";
end
end

function [h, slope, bend] = pumpsendTerrain(s, x)
%PUMPSENDTERRAIN Track height, slope and second derivative at world x (vectorized, same size as x).
%   Three sines with random phases; amplitudes grow slowly with distance, capped at twice.
%   bend has the sign of the track's curvature (negative on convex crests); only its sign is used
%   since Revision 4 removed the natural takeoff, so the curvature itself is not computed.
scale = min(2, 1 + s.ampGrowth * x(:).');
arg = s.waveNumbers(:) * x(:).' + s.phases(:);
amps = s.amps(:).';
h = reshape(scale .* (amps * sin(arg)), size(x));
slope = reshape(scale .* ((amps .* s.waveNumbers) * cos(arg)), size(x));
bend = reshape(-scale .* ((amps .* s.waveNumbers .^ 2) * sin(arg)), size(x));
end
Play Game
Preview

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