Orbit Hopper

Mike Croucher
/
Orbit Hopper
on 2 Nov 2026
4
27
12
1
7886
game.m
function g = game()
%game Orbit Hopper -- a one-button gravity slingshot game.
%   Tap while orbiting to slingshot off along your tangent. In flight,
%   every planet's gravity bends your path. Tap again inside a planet's
%   capture ring to lock into its orbit. Cyan planets spin
%   counter-clockwise, magenta planets spin clockwise. Climb as high as
%   you can; crashing into a planet or drifting off-screen ends the run.

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

function s = initState(ax)
ax.Color = [0.02 0.02 0.07];
ax.YDir  = 'normal';
ax.XLim  = [0 800];
ax.YLim  = [0 600];
np = {'HitTest', 'off', 'PickableParts', 'none'};

s.N    = 8;      % planet pool size
s.G    = 2300;   % gravity strength
s.best = 0;
s.h.ax = ax;

% Two-layer parallax starfield (positions wrap in render)
s.sx = rand(1, 150) * 800;
s.sy = rand(1, 150) * 600;
s.sn = rand(1, 150) < 0.3;
s.h.far  = line(ax, 0, 0, 'LineStyle', 'none', 'Marker', '.', ...
    'MarkerSize', 5, 'Color', [0.35 0.4 0.6], np{:});
s.h.near = line(ax, 0, 0, 'LineStyle', 'none', 'Marker', '.', ...
    'MarkerSize', 9, 'Color', [0.8 0.85 1], np{:});

% Planet pool: capture ring, body, rotating spin arc
for i = 1:s.N
    s.h.ring(i) = rectangle(ax, 'Position', [0 0 1 1], 'Curvature', [1 1], ...
        'LineWidth', 1, np{:});
    s.h.pl(i) = rectangle(ax, 'Position', [0 0 1 1], 'Curvature', [1 1], ...
        'LineWidth', 2.5, np{:});
    s.h.spin(i) = line(ax, [0 0], [0 0], 'LineWidth', 3, np{:});
end

s.h.trail = line(ax, 0, 0, 'Color', [1 0.85 0.3], 'LineWidth', 1.5, np{:});
s.h.ship  = patch(ax, [0 0 0], [0 0 0], [1 0.9 0.4], 'EdgeColor', 'w', ...
    'LineWidth', 1, np{:});
s.h.pulse = rectangle(ax, 'Position', [0 0 1 1], 'Curvature', [1 1], ...
    'LineWidth', 2, 'Visible', 'off', np{:});

s.h.score = text(ax, 0, 0, '', 'Color', [0.8 0.9 1], 'FontSize', 14, ...
    'FontWeight', 'bold', np{:});
s.h.score.Units = 'normalized';
s.h.score.Position = [0.02 0.96 0];
s.h.msg = text(ax, 0, 0, '', 'Color', 'w', 'FontSize', 18, ...
    'HorizontalAlignment', 'center', 'FontWeight', 'bold', np{:});
s.h.msg.Units = 'normalized';
s.h.msg.Position = [0.5 0.62 0];

s = resetRound(s);
end

function s = resetRound(s)
% Reset all gameplay state; graphics handles and best score persist.
s.t       = 0;
s.score   = 0;
s.serial  = 0;
s.cam     = 0;
s.mode    = 1;       % 1 = orbiting, 2 = flying, 3 = dead
s.started = false;
s.deadT   = 0;
s.near    = 0;

s.px = zeros(1, s.N); s.py = s.px; s.pr = s.px;
s.pc = s.px; s.pd = s.px; s.id = s.px;
s.px(1) = 400; s.py(1) = 150; s.pr(1) = 42;
s.pc(1) = 115; s.pd(1) = 1;   s.id(1) = 0;
s.top = 1;
for i = 2:s.N
    s = spawn(s, i);
end

s.k   = 1;
s.th  = -pi/2;
s.orr = 80;
s.spd = 240;
s.pos = [s.px(1) s.py(1)] + s.orr * [cos(s.th) sin(s.th)];
s.vel = [0 0];
s.hd  = 0;
s.trail = repmat(s.pos, 40, 1);
s.pulse = [0 0 -1 0];   % x, y, age (<0 = inactive), colour flag
end

function s = spawn(s, i)
% Place planet i above the current topmost planet. Difficulty rises
% with each planet: bigger gaps, smaller bodies, tighter capture rings.
j = s.top;
s.serial = s.serial + 1;
d = min(s.serial / 50, 1);
s.py(i) = s.py(j) + 200 + 90 * d + rand * 50;
s.px(i) = min(max(s.px(j) + (2 * rand - 1) * (140 + 140 * d), 90), 710);
s.pr(i) = 40 - 16 * d + rand * 10;
s.pc(i) = s.pr(i) + 75 - 35 * d;
s.pd(i) = 2 * (rand < 0.5) - 1;
s.id(i) = s.serial;
s.top = i;
end

function s = updateState(s, dt, pressed)
s.t = s.t + dt;
if s.pulse(3) >= 0
    s.pulse(3) = s.pulse(3) + dt;
    if s.pulse(3) > 0.5, s.pulse(3) = -1; end
end

if s.mode == 3
    s.deadT = s.deadT + dt;
    if pressed && s.deadT > 0.6
        s = resetRound(s);
        s.started = true;
    end
    return
end

% Slow-motion start: 55% speed at height 0, easing to full speed by
% height 30. Same trajectories, just more time to react early on.
dt = dt * (0.55 + 0.45 * min(s.score / 30, 1));

if s.mode == 1
    % Orbiting: circle the current planet; tap = slingshot on tangent.
    % Launch speed = escape speed + fixed excess, so every planet is
    % escapable and the flight speed far away is about s.spd.
    k = s.k;
    v = hypot(s.spd, sqrt(2 * s.G * s.pr(k)^2 / s.orr));
    s.th = s.th + ~pressed * s.pd(k) * v / s.orr * dt;
    s.pos = [s.px(k) s.py(k)] + s.orr * [cos(s.th) sin(s.th)];
    tang = s.pd(k) * [-sin(s.th) cos(s.th)];
    s.hd = atan2(tang(2), tang(1));
    if pressed
        s.started = true;
        s.mode = 2;
        s.vel = v * tang;
    end
    target = s.py(k) - 220;
else
    % Flying: gravity bends the path; tap inside a capture ring to
    % lock into that planet's orbit (a tap outside every ring misses).
    [em, i] = min(hypot(s.px - s.pos(1), s.py - s.pos(2)) - s.pc);
    s.near = (em <= 0) * i;
    if pressed && s.near
        s = capture(s, s.near);
    elseif pressed
        s.pulse = [s.pos 0 0];   % miss: grey blip
    end
    if s.mode == 2
        for n = 1:3
            [s.pos, s.vel, hit] = stepShip(s, s.pos, s.vel, dt / 3);
            if hit
                s = die(s);
                return
            end
        end
        s.hd = atan2(s.vel(2), s.vel(1));
    end
    target = s.pos(2) - 300;
end

% Camera only ever moves up
s.cam = s.cam + max(0, target - s.cam) * min(1, 2.5 * dt);

if s.pos(1) < -30 || s.pos(1) > 830 || s.pos(2) < s.cam - 30 || ...
        s.pos(2) > s.cam + 900
    s = die(s);
    return
end

% Recycle planets that scrolled off the bottom
for i = 1:s.N
    if s.py(i) + s.pc(i) < s.cam - 20 && i ~= s.k
        s = spawn(s, i);
    end
end

s.trail = [s.trail(2:end, :); s.pos];
end

function [p, v, hit] = stepShip(s, p, v, h)
% One gravity step (semi-implicit Euler) from every planet.
dx = s.px - p(1);
dy = s.py - p(2);
d2 = max(dx.^2 + dy.^2, s.pr.^2);
f  = s.G * s.pr.^2 ./ d2.^1.5;
v  = v + h * [sum(f .* dx) sum(f .* dy)];
p  = p + h * v;
hit = any(hypot(dx, dy) < s.pr + 4);
end

function s = capture(s, i)
r = s.pos - [s.px(i) s.py(i)];
s.k    = i;
s.orr  = min(max(norm(r), s.pr(i) + 18), s.pc(i));
s.th   = atan2(r(2), r(1));
s.mode = 1;
s.near = 0;
if s.id(i) > s.score
    s.score = s.id(i);
    s.spd = 240 + 100 * min(s.score / 40, 1);
end
s.pulse = [s.pos 0 1];
end

function s = die(s)
s.mode  = 3;
s.deadT = 0;
s.near  = 0;
s.best  = max(s.best, s.score);
s.pulse = [s.pos 0 2];
end

function renderFrame(~, s)
c = s.cam;
s.h.ax.YLim = [c c + 600];

f = ~s.sn;
s.h.far.XData  = s.sx(f);
s.h.far.YData  = c + mod(s.sy(f) - 0.2 * c, 600);
s.h.near.XData = s.sx(s.sn);
s.h.near.YData = c + mod(s.sy(s.sn) - 0.5 * c, 600);

for i = 1:s.N
    x = s.px(i); y = s.py(i); r = s.pr(i); rc = s.pc(i);
    if s.pd(i) > 0
        col = [0.2 0.9 1];
    else
        col = [1 0.3 0.8];
    end
    s.h.pl(i).Position  = [x - r, y - r, 2 * r, 2 * r];
    s.h.pl(i).FaceColor = col * 0.18;
    s.h.pl(i).EdgeColor = col;
    s.h.ring(i).Position = [x - rc, y - rc, 2 * rc, 2 * rc];
    if i == s.near
        s.h.ring(i).EdgeColor = col;
        s.h.ring(i).LineStyle = '-';
    else
        s.h.ring(i).EdgeColor = [0.3 0.32 0.45];
        s.h.ring(i).LineStyle = ':';
    end
    a = s.pd(i) * 2 * s.t + linspace(0, 1.6, 10);
    s.h.spin(i).XData = x + 0.62 * r * cos(a);
    s.h.spin(i).YData = y + 0.62 * r * sin(a);
    s.h.spin(i).Color = col;
end

alive = s.mode ~= 3;
s.h.ship.Visible  = alive;
s.h.trail.Visible = alive;
a = s.hd + [0 2.5 -2.5];
rr = [13 8 8];
s.h.ship.XData = s.pos(1) + rr .* cos(a);
s.h.ship.YData = s.pos(2) + rr .* sin(a);
s.h.trail.XData = s.trail(:, 1);
s.h.trail.YData = s.trail(:, 2);

p = s.pulse;
if p(3) >= 0
    r = 10 + 140 * p(3);
    cols = [0.6 0.6 0.7; 0.4 1 1; 1 0.35 0.2];
    s.h.pulse.Position  = [p(1) - r, p(2) - r, 2 * r, 2 * r];
    s.h.pulse.EdgeColor = cols(p(4) + 1, :);
    s.h.pulse.Visible   = 'on';
else
    s.h.pulse.Visible = 'off';
end

s.h.score.String = sprintf('HEIGHT %d    BEST %d', s.score, max(s.best, s.score));
if s.mode == 3
    s.h.msg.String = {'LOST IN SPACE', sprintf('Height %d', s.score), ...
        'tap to retry'};
    s.h.msg.Visible = 'on';
elseif ~s.started
    s.h.msg.String = {'ORBIT HOPPER', 'tap to slingshot', ...
        'tap inside a ring to catch an orbit'};
    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.