Slalom Run

Mike Croucher
/
Slalom Run
on 2 Nov 2026
3
54
16
2
9101
game.m
function g = game()
%game Slalom -- a one-button downhill skiing game.
%   Tap to switch the direction you carve. The skier swings smoothly
%   between a left and a right diagonal: wide carves move you sideways
%   but bleed speed, straighter lines run fast. Pass between the red and
%   blue flags of each gate to score -- consecutive gates build a combo.
%   Missing a gate costs a life (3 lives); hitting a tree ends the run.

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

function s = initState(ax)
ax.YDir  = 'reverse';
ax.XLim  = [0 800];
ax.YLim  = [0 600];
ax.Color = [0.97 0.98 1];
np = {'HitTest', 'off', 'PickableParts', 'none'};

s.M    = 4;      % gate pool
s.S    = 300;    % vertical spacing between gates
s.Ys   = 150;    % skier's fixed screen height
s.best = 0;
s.h.ax = ax;

% Snow texture: faint bumps that scroll and wrap
s.bx = rand(1, 60) * 800;
s.by = rand(1, 60) * 600;
s.h.bumps = line(ax, s.bx, s.by, 'LineStyle', 'none', 'Marker', '.', ...
    'MarkerSize', 10, 'Color', [0.86 0.9 0.96], np{:});

% Mogul: shaded snow mound (shadow ellipse + offset highlight)
a = linspace(0, 2 * pi, 16)';
s.mV = [22 * cos(a), 11 * sin(a); 15 * cos(a) - 3, 6 * sin(a) - 4];
s.mF = [1:16; 17:32];
for j = 1:3 * s.M
    s.h.mog(j) = patch(ax, 'Faces', s.mF, 'Vertices', s.mV, ...
        'FaceColor', 'flat', 'EdgeColor', 'none', ...
        'FaceVertexCData', [0.8 0.86 0.95; 1 1 1], np{:});
end

s.h.track = line(ax, 0, 0, 'Color', [0.78 0.84 0.93], 'LineWidth', 2, np{:});

% Tree shape: trunk + two stacked triangles, coloured per face
s.treeV = [-3 0; 3 0; 3 8; -3 8; ...
    -16 2; 16 2; 0 -18; -12 -10; 12 -10; 0 -30];
s.treeF = [1 2 3 4; 5 6 7 7; 8 9 10 10];
tc = [0.45 0.3 0.15; 0.1 0.55 0.2; 0.15 0.68 0.28];
% Flag shape: pole + pennant (pennant points outward via sign flip)
s.flagV = [-1 -26; 1 -26; 1 0; -1 0; 1 -26; 14 -20; 1 -14];
s.flagF = [1 2 3 4; 5 6 7 7];
for j = 1:2 * s.M
    s.h.tree(j) = patch(ax, 'Faces', s.treeF, 'Vertices', s.treeV, ...
        'FaceColor', 'flat', 'FaceVertexCData', tc, 'EdgeColor', 'none', np{:});
end
fc = {[0.9 0.15 0.15], [0.15 0.35 0.95]};
for j = 1:2 * s.M
    s.h.flag(j) = patch(ax, 'Faces', s.flagF, 'Vertices', s.flagV, ...
        'FaceColor', 'flat', 'EdgeColor', 'none', ...
        'FaceVertexCData', [0.3 0.3 0.3; fc{2 - mod(j, 2)}], np{:});
end

% Skier (top-down, facing +y = downhill), built under one transform
s.h.sk = hgtransform(ax, np{:});
P = @(x, y, c) patch('XData', x, 'YData', y, 'FaceColor', c, ...
    'EdgeColor', 'none', 'Parent', s.h.sk, np{:});
L = @(x, y, varargin) line('XData', x, 'YData', y, 'Parent', s.h.sk, ...
    varargin{:}, np{:});
dk = [0.15 0.15 0.2];
a = linspace(0, 2 * pi, 20);
P([-8 -4 -4 -6 -8], [-14 -14 16 19 16], dk);                 % left ski
P([4 8 8 6 4], [-14 -14 16 19 16], dk);                      % right ski
L([-11 -14 NaN 11 14], [-3 12 NaN -3 12], 'Color', [0.4 0.4 0.45], ...
    'LineWidth', 1.5);                                       % poles
P(11 * cos(a), -1 + 7 * sin(a), [0.98 0.45 0.1]);            % jacket
P([-10 10 10 -10], [1 1 3.5 3.5], [1 0.85 0.15]);            % scarf
P(5 * cos(a), 1 + 5 * sin(a), [0.2 0.3 0.75]);               % hat
L(0, -3, 'Marker', 'o', 'MarkerSize', 5, 'MarkerFaceColor', 'w', ...
    'MarkerEdgeColor', [0.7 0.7 0.8]);                       % bobble

s.h.puff = rectangle(ax, 'Position', [0 0 1 1], 'Curvature', [1 1], ...
    'EdgeColor', [0.6 0.75 0.95], 'LineWidth', 2, 'Visible', 'off', np{:});

s.h.score = text(ax, 16, 24, '', 'Color', [0.15 0.2 0.35], 'FontSize', 14, ...
    'FontWeight', 'bold', 'FontName', 'Consolas', np{:});
s.h.lives = text(ax, 784, 24, '', 'Color', [0.85 0.15 0.15], 'FontSize', 14, ...
    'FontWeight', 'bold', 'FontName', 'Consolas', ...
    'HorizontalAlignment', 'right', np{:});
s.h.pop = text(ax, 0, 0, '', 'FontSize', 14, 'FontWeight', 'bold', ...
    'HorizontalAlignment', 'center', np{:});
s.h.msg = text(ax, 400, 330, '', 'Color', [0.15 0.2 0.35], 'FontSize', 20, ...
    'FontWeight', 'bold', 'HorizontalAlignment', 'center', np{:});

s = resetRound(s);
end

function s = resetRound(s)
s.t       = 0;
s.mode    = 0;      % 0 = title, 1 = skiing, 2 = crashed
s.deadT   = 0;
s.x       = 400;
s.a       = 0;      % heading (rad); 0 = straight downhill
s.dir     = 1;      % carve target side (+1 right, -1 left)
s.v       = 200;
s.score   = 0;
s.combo   = 0;
s.gates   = 0;
s.lives   = 3;
s.track   = repmat([400 s.Ys], 50, 1);
s.popT    = -1;
s.popS    = '';
s.popC    = [0 0 0];
s.puffT   = -1;

s.gy = zeros(1, s.M); s.gx = s.gy; s.gw = s.gy; s.gd = false(1, s.M);
s.tx = zeros(1, 2 * s.M); s.ty = s.tx;
s.mx = zeros(1, 3 * s.M); s.my = s.mx; s.mo = false(1, 3 * s.M);
s.bump = 0;
s.lastX = 400;
s.lastY = s.Ys + 100;
for i = 1:s.M
    s = spawnGate(s, i);
end
end

function s = spawnGate(s, i)
% New gate below the lowest one, plus two trees in the gap above it,
% kept clear of the straight line between consecutive gate centres.
d = min(s.gates / 40, 1);
y = s.lastY + s.S;
x = min(max(s.lastX + (2 * rand - 1) * (120 + 100 * d), 110), 690);
s.gy(i) = y; s.gx(i) = x; s.gd(i) = false;
s.gw(i) = 170 - 80 * d;
for j = 2 * i - 1:2 * i
    mid = (s.lastX + x) / 2;
    side = 2 * (rand < 0.5) - 1;
    tx = mid + side * (120 + rand * 220);
    if tx < 30 || tx > 770
        tx = mid - side * (120 + rand * 220);
    end
    s.tx(j) = min(max(tx, 30), 770);
    s.ty(j) = y - s.S / 2 + (rand - 0.5) * 80;
end
% Mogul cluster on the direct line between gates (more likely later)
on = rand < 0.3 + 0.4 * d;
for j = 3 * i - 2:3 * i
    f = rand;
    s.mx(j) = s.lastX + (x - s.lastX) * (0.3 + 0.4 * f) + (rand - 0.5) * 50;
    s.my(j) = y - s.S * (0.7 - 0.4 * f);
    s.mo(j) = on;
end
s.lastX = x;
s.lastY = y;
end

function s = updateState(s, dt, pressed)
s.t = s.t + dt;
if s.popT >= 0, s.popT = s.popT + dt; end
if s.puffT >= 0, s.puffT = s.puffT + dt; end
if s.puffT > 0.6, s.puffT = -1; end

if s.mode == 2
    s.deadT = s.deadT + dt;
    if pressed && s.deadT > 0.7
        s = resetRound(s);
        s.mode = 1;
    end
    return
end
if s.mode == 0
    if pressed, s.mode = 1; end
    return
end

% Steering: tap flips the carve; heading eases toward the new side
if pressed, s.dir = -s.dir; end
tgt = 0.85 * s.dir;
s.a = s.a + sign(tgt - s.a) * min(abs(tgt - s.a), 3.5 * dt);

% Speed builds over the run, without limit
s.v = 200 + 5 * s.gates;
% Moguls: hitting one jolts you to ~55% speed for a moment
s.bump = max(s.bump - dt, 0);
if any(s.mo & hypot(s.mx - s.x, s.my - s.Ys) < 24)
    s.bump = 0.4;
end
k = 1 - 0.45 * (s.bump > 0);
dx = k * s.v * sin(s.a) * dt;
dy = k * s.v * max(cos(s.a), 0.35) * dt;
s.x = s.x + dx;
if s.x < 20 || s.x > 780
    s.x = min(max(s.x, 20), 780);
    s.dir = -sign(s.x - 400);
end

% Scroll the world up
s.gy = s.gy - dy; s.ty = s.ty - dy; s.my = s.my - dy;
s.lastY = s.lastY - dy;
s.by = mod(s.by - dy, 600);
s.track(:, 2) = s.track(:, 2) - dy;
s.track = [s.track(2:end, :); s.x s.Ys];
s.score = s.score + dy / 20;

% Gates: judge when the gate line crosses the skier
for i = 1:s.M
    if ~s.gd(i) && s.gy(i) <= s.Ys
        s.gd(i) = true;
        if abs(s.x - s.gx(i)) <= s.gw(i) / 2
            s.gates = s.gates + 1;
            s.combo = s.combo + 1;
            pts = 25 * s.combo;
            s.score = s.score + pts;
            s = popup(s, sprintf('+%d', pts), [0.1 0.55 0.2]);
        else
            s.combo = 0;
            s.lives = s.lives - 1;
            s = popup(s, 'MISSED GATE', [0.85 0.15 0.15]);
            if s.lives <= 0
                s = crash(s);
                return
            end
        end
    end
    if s.gy(i) < -60
        s = spawnGate(s, i);
    end
end

% Trees: crash on contact with the canopy
if any(hypot(s.tx - s.x, s.ty - 11 - s.Ys) < 20)
    s = crash(s);
end
end

function s = popup(s, str, col)
s.popT = 0;
s.popS = str;
s.popC = col;
end

function s = crash(s)
s.mode  = 2;
s.deadT = 0;
s.puffT = 0;
s.best  = max(s.best, floor(s.score));
end

function renderFrame(~, s)
s.h.bumps.YData = s.by;
s.h.track.XData = s.track(:, 1);
s.h.track.YData = s.track(:, 2);

for j = 1:2 * s.M
    s.h.tree(j).Vertices = s.treeV + [s.tx(j) s.ty(j)];
end
for j = 1:3 * s.M
    s.h.mog(j).Vertices = s.mV + [s.mx(j) s.my(j)];
    s.h.mog(j).Visible = s.mo(j);
end
for i = 1:s.M
    for k = 0:1
        sd = 2 * k - 1;       % -1 left flag (red), +1 right flag (blue)
        V = s.flagV .* [sd 1] + [s.gx(i) + sd * s.gw(i) / 2, s.gy(i)];
        s.h.flag(2 * i - 1 + k).Vertices = V;
    end
end

rot = -s.a;
if s.mode == 2
    rot = rot + 1.6;          % tumbled
elseif s.bump > 0
    rot = rot + 0.3 * sin(45 * s.t);   % mogul wobble
end
s.h.sk.Matrix = makehgtform('translate', [s.x s.Ys 0], 'zrotate', rot, 'scale', 1.4);

if s.puffT >= 0
    r = 8 + 90 * s.puffT;
    s.h.puff.Position = [s.x - r, s.Ys - r, 2 * r, 2 * r];
    s.h.puff.Visible = 'on';
else
    s.h.puff.Visible = 'off';
end

if s.popT >= 0 && s.popT < 0.8
    s.h.pop.Position = [s.x, s.Ys - 35 - 40 * s.popT, 0];
    s.h.pop.String = s.popS;
    s.h.pop.Color = s.popC;
    s.h.pop.Visible = 'on';
else
    s.h.pop.Visible = 'off';
end

s.h.score.String = sprintf('SCORE %d   BEST %d   COMBO x%d', ...
    floor(s.score), max(s.best, floor(s.score)), s.combo);
s.h.lives.String = sprintf('LIVES %d', s.lives);
if s.mode == 0
    s.h.msg.String = {'SLALOM', 'tap to switch your carve', ...
        'ski between the flags, miss the trees', '', 'tap to start'};
    s.h.msg.Visible = 'on';
elseif s.mode == 2
    s.h.msg.String = {'WIPEOUT!', sprintf('Score %d', floor(s.score)), ...
        'tap to ski again'};
    s.h.msg.Visible = 'on';
else
    s.h.msg.Visible = 'off';
end
end
Play Game
Preview

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