Iced In

Ned Gulley
/
Iced In
on 11 Nov 2026
3
30
11
6
9994
game.m
function g = game()
%game Iced In: rock your car out of an icy driveway before the plow comes.
%
%   Side view of a sunken driveway. Tap to put your foot on the gas, tap
%   again to lift it. The driven (front) tire pushes on the surface with a
%   slip-dependent friction force, so on ice the wheel just spins. Rock the
%   car: gas on the forward swing, off on the back swing. A spinning tire
%   heats up and cools once you lift. Too hot and it blows. When the timer
%   runs out the snowplow buries the driveway.
%
%   Surface color shows the friction coefficient: black asphalt, brown
%   mud, white snow, blue ice. World units are meters.

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

function s = initState(ax)
ax.XLim = [0 25];
ax.YLim = [-5 13.75];
s.x = 0:.01:25;                % terrain grid (m)
s.L = 1;
s.fl = [25*rand(70, 1), 18.75*rand(70, 1) - 5];   % snowflakes
% Surface colors and friction: ice, snow, mud, asphalt
s.mk = [0 .2 .45 .85];
s.cm = [.3 .6 .95; .93 .95 1; .45 .3 .15; .08 .08 .09];
s = newLevel(s);
s.st = 0;                      % 0 title, 1 driving, 2 out, 3 over, 4 plowing
s.T = 0;
s.lock = 0;

% One helper for every patch; p is the parent (axes or hgtransform).
P = @(p, x, y, c, varargin) patch(p, x, y, 'w', 'FaceColor', c, 'EdgeColor', 'none', ...
    'LineJoin', 'round', varargin{:});
R = @(p, x, y, w, h, c, varargin) P(p, x + [0 w w 0], y + [0 0 h h], c, varargin{:});
T = @(x, y, str, z, c, varargin) text(ax, x, y, str, 'FontSize', z, 'Color', c, ...
    'FontWeight', 'bold', 'HorizontalAlignment', 'center', varargin{:});
% Superellipse (e < 1 is boxier) and circle
a = (0:31)*pi/16;
f = @(v, e) sign(v).*abs(v).^e;
E = @(p, x, y, rx, ry, e, c, varargin) P(p, x + rx*f(cos(a), e), y + ry*f(sin(a), e), c, varargin{:});
O = @(p, x, y, r, c, varargin) E(p, x, y, r, r, 1, c, varargin{:});
K = {'EdgeColor', '#3A0D0D', 'LineWidth', 2};

% Night sky, house, commuter with briefcase
R(ax, 0, -5, 25, 18.75, 'interp', 'FaceVertexCData', kron([.05 .07 .15; .2 .25 .4], [1; 1]));
R(ax, 2, 0, 4, 3, '#6B4A3A');
P(ax, [1.6 4 6.4], [3 5 3], '#3A2E2E');
R(ax, 4.8, 3.6, .6, 1.8, '#4A3A3A');
R(ax, 2.6, 0, .9, 1.9, '#2A1E18');
R(ax, 4.3, 1, 1.1, 1.2, '#F2C14E');
line(ax, [.75 1 1.25 1 1 .75 1 1.3], [0 .9 0 .9 1.6 1 1.5 .65], 'Color', '#DDD', 'LineWidth', 3);
O(ax, 1, 1.85, .3, '#DDD');
R(ax, .75, 2.1, .5, .4, '#222');
R(ax, 1.1, .2, .45, .35, '#7A4A1A');

% Driveway: ground fill, colored surface strip, snow the plow dumps
n = 251;
s.g.gd = P(ax, 1:n + 2, 1:n + 2, '#3A404C');
s.g.sf = patch(ax, 'Vertices', zeros(2*n, 2), 'Faces', [1:n-1; 2:n; n+2:2*n; n+1:2*n-1]', ...
    'FaceVertexCData', zeros(2*n, 3), 'FaceColor', 'interp', 'EdgeColor', 'none', 'UserData', 0);

% Cartoon car, rear-wheel drive: bubble cabin, boxy body, exhaust at
% the back. Each wheel is a child transform that spins; wheel 1 is the
% driven rear wheel.
s.g.car = hgtransform(ax);
c = s.g.car;
red = '#E74C3C';
R(c, -2.05, .45, .4, .12, '#555');
E(c, -.15, 1.4, 1.05, .9, 1, red, K{:});
E(c, -.15, 1.45, .8, .66, 1, '#BFE3F5');
E(c, 0, .9, 1.75, .55, .45, red, K{:});
O(c, 1.6, 1.05, .15, '#FFF3B0');
O(c, -1.68, 1.05, .11, '#FF7070');
for k = 1:2
    O(c, 2*k - 3, .45, .56, '#7A1E16');
    w = hgtransform(c);
    s.g.w(k) = w;
    s.g.ti(k) = O(w, 0, 0, .45, '#111', K{:});
    O(w, 0, 0, .24, '#DDD');
    line(w, [-.24 .24 0 0], [0 0 .24 -.24], 'Color', '#666', 'LineWidth', 3);
end
s.g.sm = scatter(ax, nan(24, 1), nan(24, 1), 9, zeros(24, 3), 'filled');

% Snowplow, off screen until the last seconds, pushing a mound of snow
s.g.pl = hgtransform(ax);
c = s.g.pl;
P(c, [1 4.2 4.2 2.6 2.6 1], [.5 .5 3.2 3.2 1.9 1.9], '#E67E22');
R(c, 2.85, 2.2, 1.1, .75, '#9FC6E0');
P(c, [0 .35 .55 .5 .2 0], [0 0 .3 2 2.1 .1], '#BDC3C7');
R(c, .5, .7, .5, .25, '#555');
O(c, 3.3, 3.35, .2, '#F1C40F');
O(c, 1.8, .55, .55, '#111');
O(c, 3.6, .55, .55, '#111');
% Gaussian snow mound draped on the terrain: a rim behind the fill
s.u = -3:.1:3;
s.g.ba = [P(ax, 1:122, 1:122, '#A9C8E8'), P(ax, 1:122, 1:122, '#F4F8FF')];

s.g.fx = line(ax, 0, 0, 'LineStyle', 'none', 'Marker', '.', 'MarkerSize', 7, 'Color', 'w');

% HUD: tire heat and time-left gauges, gas pedal, readouts
T(7.6, 11.3, {'TIRE', 'HEAT'}, 13, 'w');
T(15.9, 11.3, {'TIME', 'LEFT'}, 13, 'w');
B = {'EdgeColor', 'w', 'LineWidth', 2};
R(ax, 8.9, 9.4, .8, 3.8, '#111', B{:});
R(ax, 17.2, 9.4, .8, 3.8, '#111', B{:});
s.g.hb = R(ax, 9, 9.5, .6, 0, 'r');
s.g.tb = R(ax, 17.3, 9.5, .6, 0, '#3498DB');
L = {'HorizontalAlignment', 'left'};
s.g.lv = T(.4, 13.1, '', 14, 'w', L{:});
s.g.su = T(.4, 12.2, '', 12, '#CCC', L{:});
s.g.gp = R(ax, 22.3, 11.2, 2.1, 2, '#333', B{:});
s.g.gt = T(23.35, 12.2, '', 16, 'w');

s.g.ov = [R(ax, 0, -5, 25, 18.75, 'k', 'FaceAlpha', .75), T(12.5, 10, '', 40, '#9FD8FF'), ...
    T(12.5, 4.5, '', 14, 'w'), T(12.5, -3.2, '', 18, '#9FD8FF')];
end

function s = newLevel(s)
% Difficulty: deeper, rounder bowl; heavier car; more ice, lower down;
% touchier tires; sooner plow. Difficulty stops rising after level 12;
% later levels get new maps at that difficulty.
L = min(s.L, 12);
rng(s.L)
x = s.x;
s.c = 13.5;
s.D = min(.5 + .22*L, 2.6);
q = max(2, 4.6 - .3*L);        % 4.6 flat-bottomed, 2 bowl
% Bumps: a random sine wave scales the depth, so it fades out at the lips.
s.Y = -s.D*max(0, 1 - abs((x - s.c)/6).^q).^2.*(1 + rand*min(.02*L, .12)*sin((1 + rand)*x + 7*rand));
s.Yp = gradient(s.Y, .01);
s.Ypp = gradient(s.Yp, .01);
s.m = min(1100 + 100*L, 2300); % vehicle mass (kg)
s.k = .05*1.1^L;               % tire heat sensitivity
s.Tp = max(45, 60 - L);     % seconds until the plow
% Surface: 1 ice, 2 snow, 3 mud, 4 asphalt. Meltwater pools and
% freezes at the bottom, so deeper spots are more slippery.
xc = 0:.8:25;
r = rand(size(xc)) - min(.09*L, .75)*interp1(x, s.Y, xc)/s.D;
k = 4 - (r > .55) - (r > .85) - (r > 1.3);
k(xc < 7) = 2;
k(xc > 19.5) = 4;
b = interp1(x, s.Y, xc + 1) < -.6*s.D;   % no ice under the rear tire low in the bowl, where the car comes to rest
k(b) = max(k(b), 2);
s.mu = min(.85, movmean(interp1(xc, s.mk(k), x, 'nearest'), 30));
[~, i] = min(s.Y);
s.X = x(i);                    % car center (m), at rest in the lowest dip
s.v = 0;                       % car speed along the surface (m/s)
s.W = 0;                       % tire surface speed (m/s)
s.H = 0;                       % tire heat, 1 = blowout
s.gas = 0;
s.t = 0;
s.ph = 0;                      % rear and front wheel angles
s.pf = 0;
s.sm = zeros(24, 5);           % smoke/spray: x y vx vy life
s.sc = zeros(24, 3);
s.pt = 0;                      % time since the plow arrived
s.b = 27.5;                    % snow mound center x and width
s.r = .6;
end

function s = updateState(s, dt, pressed)
s.T = s.T + dt;
s.fl(:, 2) = s.fl(:, 2) - 1.5*dt;
s.fl = mod(s.fl + [0 5], [25 18.75]) - [0 5];
s.sm = s.sm + dt*[s.sm(:, 3:4), 0*s.sm(:, 1:2), -1 + 0*s.sm(:, 1)];
st = s.st;
if pressed
    if st == 1
        s.gas = ~s.gas;
    elseif st == 0 || st > 1 && st < 4 && s.T > s.lock
        s.L = s.L + (st == 2);
        s = newLevel(s);
        s.st = 1;
    end
end
if st == 4
    s.pt = s.pt + dt;
    if s.pt > 1.2
        s = over(s, 'SNOWED IN');
    end
end
if s.st ~= 1
    return
end

% Physics in substeps, since the tire force is stiff in slip.
n = ceil(dt/.004);
h = dt/n;
g = 9.81;
for j = 1:n
    i = round(s.X*100) + 1;
    p = s.Yp(i);
    cs = 1/sqrt(1 + p^2);
    N = max(0, s.m*(g*cs + s.Ypp(i)*cs^3*s.v^2));   % normal force incl. curvature
    mu = s.mu(round((s.X - cs)*100) + 1);           % under the rear tire
    sl = s.W - s.v;                                 % slip speed
    % Traction peaks, then falls. Off the gas the car is in neutral and
    % coasts freely; the rear wheel spins down to rolling speed.
    F = s.gas*mu*.5*N*sin(1.5*atan(2*sl));
    Fe = s.gas*6500*max(0, 1 - s.W/16);             % engine force at the tire
    s.W = s.W + h*((Fe - F)/150 - ~s.gas*4*sl);     % drivetrain inertia (kg)
    s.v = s.v + h*(F - s.m*g*p*cs - .012*N*tanh(s.v/.05) - .4*s.v*abs(s.v))/s.m;
    s.X = s.X + h*s.v*cs;
    s.ph = s.ph - h*s.W/.45;
    s.pf = s.pf - h*s.v/.45;   % front wheel just rolls
    if s.X < 8.1               % rear bumper meets the house
        s.X = 8.1;
        s.v = -.3*min(s.v, 0);
    end
    % Tire heats while the gas is on, more when it spins; cools after.
    s.H = s.H + h*(s.gas*s.k*(.3 + abs(sl)/3) - ~s.gas*.3*s.H);
end
s.t = s.t + dt;
% The plow rolls in over the last 3 s, pushing a growing mound of snow that
% stops at the top of the driveway. The car can't drive through it.
e = min(1, max(0, s.t - s.Tp + 3)/3);
s.r = .6 + .8*e;
s.b = 27.5 - 6.7*e;
if s.X + 1.8 > s.b - 1.2*s.r
    s.X = s.b - 1.2*s.r - 1.8;
    s.v = -.3*max(s.v, 0);
end

if abs(sl) > 1.5              % smoke on asphalt, spray on the rest
    [~, j] = min(s.sm(:, 5));
    xr = s.X - cs;
    s.sm(j, :) = [xr - .4, interp1(s.x, s.Y, xr) + .1, -.6*sign(sl)*(1 + rand), .5 + rand, 1.2];
    s.sc(j, :) = min(1, interp1(s.mk, s.cm, mu) + .1 + .5*(mu > .7));
end
if s.H >= 1
    s = over(s, 'TIRE BLOWOUT');
elseif s.X > 18.9
    s.st = 2;
    s.lock = s.T + .8;
elseif s.t >= s.Tp
    s.st = 4;
end
end

function s = over(s, why)
s.st = 3;
s.why = why;
s.lock = s.T + .8;
end

function renderFrame(~, s)
g = s.g;
x = s.x(1:10:end);
y = s.Y(1:10:end);
if g.sf.UserData ~= s.L
    % New level: redraw the terrain and its friction colors.
    c = interp1(s.mk, s.cm, s.mu(1:10:end));
    set(g.gd, 'XData', [x 25 0], 'YData', [y, -5 -5]);
    set(g.sf, 'Vertices', [x' y'; x' y' - .35], 'FaceVertexCData', [c; c*.8], 'UserData', s.L);
end
% Car pose from the terrain under both wheels
X = s.X;
y = interp1(s.x, s.Y, X + [-1 1]);
g.car.Matrix = makehgtform('translate', [X mean(y) 0], 'zrotate', atan2(diff(y), 2));
g.w(1).Matrix = makehgtform('translate', [-1 .45 0], 'zrotate', s.ph);
g.w(2).Matrix = makehgtform('translate', [1 .45 0], 'zrotate', s.pf);
H = min(s.H, 1);
g.ti(1).FaceColor = interp1([0 .5 1], [.07 .07 .07; .55 .1 .05; 1 .5 .1], H);
set(g.sm, 'XData', s.sm(:, 1) + 0./(s.sm(:, 5) > 0), 'YData', s.sm(:, 2), 'CData', s.sc, ...
    'SizeData', 40 + 250*(1.2 - max(s.sm(:, 5), 0)));
r = s.r;
x = s.b + r*s.u;
y = interp1(s.x, s.Y, min(x, 25));
for k = 1:2
    set(g.ba(k), 'XData', [x flip(x)], 'YData', [y + (1.6 - k/10)*r*exp(-s.u.^2), flip(y)]);
end
g.pl.Matrix = makehgtform('translate', [s.b + r 0 0], 'scale', .9);
set(g.fx, 'XData', s.fl(:, 1), 'YData', s.fl(:, 2));

% HUD
g.hb.YData = 9.5 + 3.6*H*[0 0 1 1];
g.hb.FaceColor = [1, .8 - .8*H, .2 - .2*H];
r = max(0, 1 - s.t/s.Tp);
g.tb.YData = 9.5 + 3.6*r*[0 0 1 1];
g.lv.String = sprintf('LEVEL %d  •  %d kg, rear-wheel drive', s.L, s.m);
m = s.mu(round((X - 1)*100) + 1);
c = {'ICE', 'SNOW', 'MUD', 'ASPHALT'};
g.su.String = sprintf('Rear tire on %s  μ = %.2f', c{1 + (m > .1) + (m > .32) + (m > .65)}, m);
k = s.gas*(s.st == 1);
g.gp.FaceColor = [.2 .2 .2] + k*[0 .5 0];
c = {'gas off', 'GAS ON'};
g.gt.String = c{1 + k};

st = s.st;
h = {'ICED IN', {'Escape before the plow blocks the driveway.', '', ...
    'Tap: gas on. Tap again: gas off.', ...
    'Rock it: gas going forward, coast going back.', ...
    'Wheelspin heats the tire. Too hot and it blows.', '', ...
    'Grip: black asphalt > brown mud > white snow > blue ice'}, 'Tap to start'};
if st == 2
    h = {'YOU''RE OUT!', sprintf('%.0f s to spare', s.Tp - s.t), 'Tap for next level'};
elseif st == 3
    h = {s.why, "Level " + s.L, 'Tap to try again'};
end
set(g.ov, 'Visible', any(st == [0 2 3]));
g.ov(2).String = h{1};
g.ov(3).String = h{2};
set(g.ov(4), 'String', h{3}, 'FontSize', 18 + 1.5*sin(7*s.T));
end
Play Game
Preview

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