The Controls You Can't Control

Matt Tearle
/
The Controls You Can't Control
on 2 Nov 2026
1
22
12
0
9517
game.m
function g = game()
%game Your one-button game.
%
%   Build your game by filling in the three functions below:
%   initState, updateState, and renderFrame. See README.md for the
%   full contract, idioms, and a worked example.
%
%   Workflow:
%       >> minihackContest.validate   % check the contract and contest rules
%       >> minihackContest.play       % play locally at 30 fps
%       >> minihackContest.submit     % publish to the contest

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

function state = initState(ax)
% Called once. Set up your world and build your initial state.
% Create every graphics object you'll need here -- renderFrame should
% only update their properties, never create new ones. The harness
% already configured `ax` with an 800x600 world; override XLim/YLim
% here if your game wants different world coordinates.

state = struct();
state.score = 0;
state.health = 100;
state.gameOver = false;
state.playerRadius = 15;
state.playerPosition = spawnPosition(zeros(0,2), state.playerRadius);
heading = 2*pi*rand;
speed = 120+80*rand; % Pixels per second.
state.playerVelocity = speed*[cos(heading) sin(heading)];
state.rotationRate = 0; % Radians/second; positive is clockwise with YDir reverse.
state.turnIncrement = pi/3; % Each turn tap adds 60 degrees/second.
state.n = 5; % Number of obstacles and number of targets.
positions = zeros(2*state.n, 2);
for k = 1:2*state.n
    occupied = [state.playerPosition; positions(1:k-1,:)];
    positions(k,:) = spawnPosition(occupied, state.playerRadius);
end
state.obstaclePositions = positions(1:state.n,:);
state.targetPositions = positions(state.n+1:end,:);
state.selectedControl = randi(3); % 1: counterclockwise, 2: forward, 3: clockwise
ax.YDir = 'reverse';
ax.Color = [0.10 0.12 0.18];
centers = [296 400 504];
state.graphics.tiles = gobjects(1, 3);
state.graphics.icons = gobjects(1, 3);
for k = 1:3
    x = centers(k);
    state.graphics.tiles(k) = rectangle(ax, ...
        'Position', [x-40 22 80 80], 'Curvature', 0.2, ...
        'HitTest', 'off', 'PickableParts', 'none');
    if k == 2
        % Upward arrow: forward.
        state.graphics.icons(k) = patch(ax, ...
            x+[-8 -8 -22 0 22 8 8], [84 61 61 39 61 61 84], ...
            'w', 'EdgeColor', 'none', ...
            'HitTest', 'off', 'PickableParts', 'none');
    else
        % A curved arrow; reflecting it reverses the turn direction.
        theta = linspace(pi/4, -5*pi/4, 40);
        px = 22*cos(theta);
        py = 22*sin(theta);
        tangent = [sin(theta(end)) -cos(theta(end))];
        tip = [px(end) py(end)];
        base = tip-11*tangent;
        normal = [-tangent(2) tangent(1)];
        head1 = base+6*normal;
        head2 = base-6*normal;
        arrowX = [px NaN head1(1) tip(1) head2(1)];
        arrowY = [py NaN head1(2) tip(2) head2(2)];
        if k == 3, arrowX = -arrowX; end
        state.graphics.icons(k) = line(ax, x+arrowX, 62+arrowY, ...
            'LineWidth', 4, 'HitTest', 'off', 'PickableParts', 'none');
    end
end
state.graphics.score = text(ax, 40, 62, '', ...
    'Color', 'w', 'FontSize', 18, 'FontWeight', 'bold', ...
    'VerticalAlignment', 'middle', ...
    'HitTest', 'off', 'PickableParts', 'none');
state.graphics.healthLabel = text(ax, 590, 43, '', ...
    'Color', 'w', 'FontSize', 14, ...
    'HitTest', 'off', 'PickableParts', 'none');
state.graphics.healthBackground = rectangle(ax, ...
    'Position', [590 62 170 20], 'FaceColor', [0.20 0.23 0.29], ...
    'EdgeColor', 'none', 'HitTest', 'off', 'PickableParts', 'none');
state.graphics.healthFill = rectangle(ax, ...
    'Position', [590 62 170 20], 'FaceColor', [0.30 0.85 0.55], ...
    'EdgeColor', 'none', 'HitTest', 'off', 'PickableParts', 'none');
state.graphics.player = rectangle(ax, ...
    'Position', [0 0 2*state.playerRadius 2*state.playerRadius], ...
    'Curvature', [1 1], 'FaceColor', [0.35 0.75 1], ...
    'EdgeColor', [0.75 0.90 1], 'LineWidth', 1, ...
    'HitTest', 'off', 'PickableParts', 'none');
state.graphics.direction = patch(ax, [0 0 0], [0 0 0], ...
    [0.08 0.15 0.24], 'EdgeColor', 'none', ...
    'HitTest', 'off', 'PickableParts', 'none');
state.graphics.objects = gobjects(1, 2*state.n);
state.graphics.symbols = gobjects(1, 2*state.n);
for k = 1:2*state.n
    p = positions(k,:);
    r = state.playerRadius;
    if k <= state.n
        color = [0.95 0.25 0.30];
        symbolX = [-4 4 NaN -4 4];
        symbolY = [-4 4 NaN 4 -4];
    else
        color = [0.30 0.85 0.55];
        symbolX = [-5 5 NaN 0 0];
        symbolY = [0 0 NaN -5 5];
    end
    state.graphics.objects(k) = rectangle(ax, ...
        'Position', [p-r 2*r 2*r], 'Curvature', [1 1], ...
        'FaceColor', color, 'EdgeColor', 'none', ...
        'HitTest', 'off', 'PickableParts', 'none');
    state.graphics.symbols(k) = line(ax, p(1)+symbolX*r/10, p(2)+symbolY*r/10, ...
        'Color', 'w', 'LineWidth', 2, ...
        'HitTest', 'off', 'PickableParts', 'none');
end
state.graphics.message = text(ax, 400, 300, '', ...
    'Color', 'w', 'FontSize', 28, '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.gameOver, return; end
if pressed
    if state.selectedControl == 2
        state.rotationRate = 0;
    else
        state.rotationRate = state.rotationRate + ...
            (state.selectedControl-2)*state.turnIncrement;
    end
    state.selectedControl = randi(3);
end
lower = [state.playerRadius state.playerRadius];
upper = [800 600]-state.playerRadius;
remaining = dt;
while remaining > 0 && ~state.gameOver
    % Stop each movement segment at a wall, then reflect its velocity.
    velocity = state.playerVelocity;
    wallTime = inf(1,2);
    for k = 1:2
        if velocity(k) > 0
            wallTime(k) = (upper(k)-state.playerPosition(k))/velocity(k);
        elseif velocity(k) < 0
            wallTime(k) = (lower(k)-state.playerPosition(k))/velocity(k);
        end
    end
    % Small segments approximate curved motion consistently across frame rates.
    step = min([remaining wallTime 0.01 0.05/max(abs(state.rotationRate),eps)]);
    start = state.playerPosition;
    movement = velocity*step;
    state.playerPosition = max(lower, min(upper, start+movement));
    remaining = remaining-step;
    bounced = wallTime <= step;
    state.playerVelocity(bounced) = -state.playerVelocity(bounced);
    positions = [state.obstaclePositions; state.targetPositions];
    % Swept circle test catches objects even at high speeds.
    fraction = sum((positions-start).*movement, 2)/max(sum(movement.^2), eps);
    fraction = max(0, min(1, fraction));
    closest = start+fraction.*movement;
    hits = find(sum((positions-closest).^2,2) <= (2*state.playerRadius)^2);
    % Apply effects in the order objects are encountered along the path.
    [~, order] = sort(fraction(hits));
    for j = 1:numel(hits)
        k = hits(order(j));
        occupied = [state.playerPosition; positions([1:k-1 k+1:end],:)];
        positions(k,:) = spawnPosition(occupied, state.playerRadius);
        if k <= state.n
            state.health = max(0, state.health-5);
            state.gameOver = state.health == 0;
        else
            state.score = state.score+1;
            state.playerVelocity = state.playerVelocity*1.06;
        end
        if state.gameOver, break; end
    end
    state.obstaclePositions = positions(1:state.n,:);
    state.targetPositions = positions(state.n+1:end,:);
    angle = state.rotationRate*step;
    state.playerVelocity = state.playerVelocity * ...
        [cos(angle) sin(angle); -sin(angle) cos(angle)];
end
end

function renderFrame(~, state)
% Called every frame after updateState. Push your state onto the
% graphics objects you created in initState. Do NOT call drawnow.
r = state.playerRadius;
p = state.playerPosition;
state.graphics.player.Position = [p-r 2*r 2*r];
forward = state.playerVelocity/norm(state.playerVelocity);
side = [-forward(2) forward(1)];
triangle = [p+0.75*r*forward; p-0.45*r*forward+0.50*r*side; ...
    p-0.45*r*forward-0.50*r*side];
set(state.graphics.direction, 'XData', triangle(:,1), 'YData', triangle(:,2));
state.graphics.score.String = sprintf('Score: %d', floor(state.score));
health = max(0, min(100, state.health));
state.graphics.healthLabel.String = sprintf('Health: %.0f%%', health);
state.graphics.healthFill.Position = [590 62 170*health/100 20];
state.graphics.message.String = '';
if state.gameOver
    state.graphics.message.String = sprintf('Game Over\nScore: %d', state.score);
end
positions = [state.obstaclePositions; state.targetPositions];
for k = 1:2*state.n
    p = positions(k,:);
    state.graphics.objects(k).Position = [p-r 2*r 2*r];
    if k <= state.n
        symbolX = [-4 4 NaN -4 4];
        symbolY = [-4 4 NaN 4 -4];
    else
        symbolX = [-5 5 NaN 0 0];
        symbolY = [0 0 NaN -5 5];
    end
    set(state.graphics.symbols(k), 'XData', p(1)+symbolX*r/10, ...
        'YData', p(2)+symbolY*r/10);
end
for k = 1:3
    if k == state.selectedControl
        iconColor = [1 0.82 0.25];
        tileColor = [0.24 0.22 0.16];
        borderColor = iconColor;
    else
        iconColor = [0.30 0.33 0.39];
        tileColor = [0.13 0.15 0.21];
        borderColor = [0.20 0.23 0.29];
    end
    set(state.graphics.tiles(k), 'FaceColor', tileColor, ...
        'EdgeColor', borderColor, 'LineWidth', 2);
    if k == 2
        state.graphics.icons(k).FaceColor = iconColor;
    else
        state.graphics.icons(k).Color = iconColor;
    end
end
end

function position = spawnPosition(occupied, radius)
position = [radius+(800-2*radius)*rand, 120+radius+(480-2*radius)*rand];
while any(sum((occupied-position).^2,2) < (2*radius+4)^2)
    position = [radius+(800-2*radius)*rand, 120+radius+(480-2*radius)*rand];
end
end
Play Game
Preview

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