Gone With The Wind

Matt Tearle
/
Gone With The Wind
on 3 Nov 2026
7
47
20
5
9657
game.m
function g = game()
% Gone With The Wind
% Bug floats down in wind vector field created by spinning blades
% Hit spacebar to fly up
% Float all the way to the bottom, avoiding the blades and the walls

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

function state = initState(ax)
state = initializeRound(struct());
ax.XLim = [0 800];
ax.YLim = [0 600];
ax.YDir = 'normal'; % Positive angular rates rotate counterclockwise.
ax.Color = [0.08 0.11 0.17];
state.graphics.field = quiver(ax, state.gridX, state.gridY, ...
    state.arrowScale*state.fieldU, state.arrowScale*state.fieldV, 0, ...
    Color=state.palette.field, LineWidth=0.8, MaxHeadSize=0.7, ...
    HitTest='off', PickableParts='none');
state.graphics.circles = gobjects(state.n, 1);
state.graphics.propellers = gobjects(state.n, 1);
for k = 1:state.n
    center = state.centers(k, :);
    if state.baseRate(k) < 0
        edgeColor = state.palette.clockwise;
    else
        edgeColor = state.palette.counterclockwise;
    end
    state.graphics.circles(k) = rectangle(ax, ...
        Position=[center-state.r 2*state.r 2*state.r], ...
        Curvature=[1 1], FaceColor=rateColor(state, k), ...
        EdgeColor=edgeColor, LineWidth=1.5, ...
        HitTest='off', PickableParts='none');
    c = cos(state.angle(k));
    s = sin(state.angle(k));
    state.graphics.propellers(k) = patch(ax, ...
        center(1)+c*state.bladeX-s*state.bladeY, ...
        center(2)+s*state.bladeX+c*state.bladeY, state.palette.propeller, ...
        EdgeColor='none', HitTest='off', PickableParts='none');
end
state.graphics.bug = rectangle(ax, Position=[0 0 28 28], ...
    Curvature=[1 1], FaceColor=state.palette.bug, ...
    EdgeColor=state.palette.propeller, LineWidth=1.5, ...
    HitTest='off', PickableParts='none');
state.graphics.seam = line(ax, [0 0], [0 0], ...
    Color=state.palette.propeller, LineWidth=1.5, ...
    HitTest='off', PickableParts='none');
state.graphics.head = rectangle(ax, Position=[0 0 12 10], ...
    Curvature=[1 1], FaceColor=state.palette.propeller, ...
    EdgeColor='none', HitTest='off', PickableParts='none');
state.graphics.spots = patch(ax, state.spotX, state.spotY, ...
    state.palette.propeller, EdgeColor='none', ...
    HitTest='off', PickableParts='none');
state.graphics.eyes = patch(ax, state.eyeX, state.eyeY, 'w', ...
    EdgeColor='none', HitTest='off', PickableParts='none');
state.graphics.message = text(ax, 400, 300, '', ...
    FontSize=18, FontWeight='bold', ...
    HorizontalAlignment='center', ...
    HitTest='off', PickableParts='none');
renderFrame([], state);
end

function state = updateState(state, dt, pressed)
% Called every frame. Advance state by dt seconds. `pressed` is
% true on the frame SPACE or a click was fired since the last
% frame (edge-triggered -- one `true` per discrete press). Scale
% all motion by dt so the game plays the same on any machine.
if state.outcome ~= 0
    if pressed, state = initializeRound(state); state.started = true; end
    return
end
if ~state.started
    if pressed, state.started = true; end
    return
end
state.time = state.time + dt;
state.rotationRate = state.baseRate + state.amplitude.* ...
    sin(state.frequency*state.time + state.phase);
% Exact integral of the sinusoidal rate avoids frame-rate-dependent drift.
state.angle = mod(state.initialAngle + state.baseRate*state.time + ...
    state.amplitude./state.frequency.*(cos(state.phase)- ...
    cos(state.frequency*state.time+state.phase)), 2*pi);
state = updateField(state);
state = moveAvatar(state, dt, pressed);
end

function renderFrame(~, s)
% Called every frame after updateState. Push your s onto the
% graphics objects you created in initState. Do NOT call drawnow.
%   s.player.Position = [s.x 300 30 30];
s.graphics.field.UData = s.arrowScale*s.fieldU;
s.graphics.field.VData = s.arrowScale*s.fieldV;
for k = 1:s.n
    s.graphics.circles(k).Position = [s.centers(k,:)-s.r 2*s.r 2*s.r];
    if s.baseRate(k) < 0, edge = s.palette.clockwise; else, edge = s.palette.counterclockwise; end
    s.graphics.circles(k).EdgeColor = edge;
    s.graphics.circles(k).FaceColor = rateColor(s, k);
    c = cos(s.angle(k));
    sn = sin(s.angle(k));
    s.graphics.propellers(k).XData = s.centers(k, 1) + ...
        c*s.bladeX-sn*s.bladeY;
    s.graphics.propellers(k).YData = s.centers(k, 2) + ...
        sn*s.bladeX+c*s.bladeY;
end
p = s.avatarPosition;
s.graphics.bug.Position = [p-s.avatarRadius 28 28];
s.graphics.head.Position = [p+[-6 3] 12 10];
s.graphics.seam.XData = p(1)+[0 0];
s.graphics.seam.YData = p(2)+[-13 5];
s.graphics.spots.XData = p(1)+s.spotX;
s.graphics.spots.YData = p(2)+s.spotY;
s.graphics.eyes.XData = p(1)+s.eyeX;
s.graphics.eyes.YData = p(2)+s.eyeY;
ngm = '(Hit space for a new game)';
if ~s.started
    s.graphics.message.String = s.instructions;
    s.graphics.message.Color = s.palette.neutral;
elseif s.outcome < 0
    s.graphics.message.String = {'Game Over'; ngm};
    s.graphics.message.Color = s.palette.failure;
elseif s.outcome > 0
    s.graphics.message.String = {'Success'; ngm};
    s.graphics.message.Color = s.palette.success;
else
    s.graphics.message.String = '';
end
end

function s = initializeRound(s)
rng("shuffle")
% Number of radius of blades
s.n = 8;
s.r = 30;
s.centerMargin = 120; % Minimum center distance from any window edge.
s.centerSpacing = 4*s.r; % One full diameter between circle rims.
s.time = 0;
s.centers = zeros(s.n, 2);
inset = s.centerMargin;
xPositions = linspace(inset, 800-inset, s.n);
for k = 1:s.n
    % Reject candidates that leave less than a diameter between rims.
    candidate = [xPositions(k) inset+rand*(600-2*inset)];
    while any(sum((s.centers(1:k-1, :)-candidate).^2, 2) < s.centerSpacing^2)
        candidate(2) = inset+rand*(600-2*inset);
    end
    s.centers(k, :) = candidate;
end
% Angular rates are radians/second. Both rotation directions are present.
direction = [ones(4, 1); -ones(4, 1)];
direction = direction(randperm(s.n));
s.minimumRate = 0.35; % Minimum absolute angular speed, radians/second.
s.amplitude = 0.5+1.9*rand(s.n, 1); % Wider swings, radians/second.
% Raise the base magnitude enough to keep the larger swings above the floor.
s.baseRate = direction.*(s.amplitude+s.minimumRate+ ...
    0.2+0.8*rand(s.n, 1));
s.frequency = 2*pi./(0.9+1.5*rand(s.n, 1)); % Period: 0.9-2.4 seconds.
s.phase = 2*pi*rand(s.n, 1);
s.initialAngle = 2*pi*rand(s.n, 1);
s.angle = s.initialAngle;
s.rotationRate = s.baseRate + s.amplitude.*sin(s.phase);
s.maxRate = max(abs(s.baseRate)+s.amplitude);
s.palette.clockwise = [0.62 0.28 0.88]; % Purple.
s.palette.counterclockwise = [0.18 0.88 0.80]; % Teal blue.
s.palette.neutral = [0.88 0.88 0.88]; % Zero saturation, same HSV value.
s.palette.propeller = [0.08 0.11 0.17];
s.gridSpacing = 20;
s.arrowScale = 8; % Display pixels per unit of field magnitude.
s.palette.field = [0.48 0.57 0.66];
[s.gridX, s.gridY] = meshgrid(10:s.gridSpacing:790, ...
    10:s.gridSpacing:590);
% Rows are grid points; columns are spinners. Cache the unit-rate fields.
dx = s.gridX(:)-s.centers(:, 1)';
dy = s.gridY(:)-s.centers(:, 2)';
distanceSquared = dx.^2+dy.^2;
s.insideSpinner = any(distanceSquared < s.r^2, 2);
distanceSquared(s.insideSpinner, :) = Inf;
% Tangent (-dy,dx)/distance times r/distance: magnitude r/distance.
s.fieldBasisU = -s.r*dy./distanceSquared;
s.fieldBasisV = s.r*dx./distanceSquared;
s = updateField(s);
% Three tapered blades, each inside the circle, in local coordinates.
bladeAngle = (0:2)*2*pi/3;
bx = s.r*[0.12; 0.82; 0.68; 0.12];
by = s.r*[-0.10; -0.18; 0.22; 0.10];
s.bladeX = bx*cos(bladeAngle)-by*sin(bladeAngle);
s.bladeY = bx*sin(bladeAngle)+by*cos(bladeAngle);
s.avatarRadius = 14;
s.avatarPosition = [20+760*rand 584];
s.fallSpeed = 60; % Faster downward drift, pixels/second.
s.avatarMass = 0.5; % Lower mass gives a faster response to the flow.
s.flowScale = 35;
s.flySpeed = 120;
s.started = false;
s.instructions = ["Reach the bottom while avoiding the walls and spinners"; ...
    "Press space to fly up";"Hit space to start"];
s.avatarVelocity = [0 -s.fallSpeed];
s.outcome = 0; % 0: falling, -1: game over, +1: success.
s.palette.bug = [1 0.22 0.28];
s.palette.failure = [1 0.20 0.25];
s.palette.success = [0.35 1 0.45];
theta = linspace(0, 2*pi, 16)';
s.spotX = 2.4*cos(theta)+[-6 6 -7 7 -5 5];
s.spotY = 2.4*sin(theta)+[4 4 -2 -2 -8 -8];
s.eyeX = 1.5*cos(theta)+[-3 3];
s.eyeY = 1.5*sin(theta)+[9 9];
end

function s = moveAvatar(s, dt, pressed)
p = s.avatarPosition;
offset = p-s.centers;
d2 = sum(offset.^2, 2);
radius = s.r+s.avatarRadius;
if any(d2 <= radius^2)
    s.outcome = -1;
    return
end
% Evaluate the same analytic field at the moving avatar, avoiding NaN grid
% interpolation near spinner rims. Relax toward downward drift plus flow.
weight = s.r*s.rotationRate./d2;
flow = [sum(-offset(:,2).*weight) sum(offset(:,1).*weight)];
target = [0 -s.fallSpeed]+s.flowScale*flow;
s.avatarVelocity = target+(s.avatarVelocity-target)*exp(-2*dt/s.avatarMass);
if pressed, s.avatarVelocity(2) = s.flySpeed; end
step = s.avatarVelocity*dt;
% Swept circle collision: closest point along the movement segment.
fraction = sum((s.centers-p).*step, 2)/max(sum(step.^2), eps);
fraction = min(1, max(0, fraction));
closest = p+fraction.*step;
hitSpinner = any(sum((closest-s.centers).^2, 2) <= radius^2);
s.avatarPosition = p+step;
if s.avatarPosition(2) > 600-s.avatarRadius
    s.avatarPosition(2) = 600-s.avatarRadius;
    s.avatarVelocity(2) = min(0, s.avatarVelocity(2));
end
s.avatarPosition(2) = max(s.avatarRadius, s.avatarPosition(2));
p = s.avatarPosition;
if hitSpinner || p(1)-s.avatarRadius <= 0 || p(1)+s.avatarRadius >= 800
    s.outcome = -1;
elseif p(2)-s.avatarRadius <= 0
    s.outcome = 1;
end
end

function state = updateField(state)
u = state.fieldBasisU*state.rotationRate;
v = state.fieldBasisV*state.rotationRate;
u(state.insideSpinner) = NaN;
v(state.insideSpinner) = NaN;
state.fieldU = reshape(u, size(state.gridX));
state.fieldV = reshape(v, size(state.gridY));
end

function color = rateColor(state, k)
% Fixed hues encode direction; saturation encodes absolute angular speed.
rate = state.rotationRate(k);
if rate < 0
    hueColor = state.palette.clockwise;
else
    hueColor = state.palette.counterclockwise;
end
fraction = min(1, abs(rate)/state.maxRate);
color = (1-fraction)*state.palette.neutral + fraction*hueColor;
end
Play Game
Preview

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