Orbit Hopper: Neon Slingshot

Surekha
/
Orbit Hopper: Neon Slingshot
on 6 Nov 2026
1
5
1
0
6454
game.m
function g = game()
%game Orbit Hopper -- a one-button neon space game.
%
%   Your ship orbits a planet. Tap to fling off along your current
%   heading; drift into another planet's capture ring to latch on.
%   Each new planet scores a point. Drift off-screen and you're lost.

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

function s = initState(ax)
ax.Color = [0.02 0.02 0.07];
s.N = 6;                                   % planet pool size
s.best = 0;
s.cols = [0 1 1; 1 0.2 0.9; 0.4 1 0.2; 1 0.6 0.1; 0.5 0.5 1; 1 1 0.3];
t = linspace(0, 2*pi, 48);
s.ux = cos(t);
s.uy = sin(t);

% Parallax starfield: each star has its own depth factor
s.starX = rand(1,140)*800;
s.starY = rand(1,140)*600;
s.starD = 0.1 + 0.5*rand(1,140);

p = {'HitTest','off','PickableParts','none'};
s.h.stars = line(ax, s.starX, s.starY, 'LineStyle','none', 'Marker','.', ...
    'MarkerSize',5, 'Color',[0.6 0.6 0.9], p{:});
for i = 1:s.N
    col = s.cols(i,:);
    s.h.glow(i) = patch(ax, 'XData',s.ux, 'YData',s.uy, 'FaceColor',col, ...
        'EdgeColor','none', 'FaceAlpha',0.12, p{:});
    s.h.body(i) = patch(ax, 'XData',s.ux, 'YData',s.uy, 'FaceColor',col*0.3, ...
        'EdgeColor',col, 'LineWidth',2.5, p{:});
    s.h.ring(i) = line(ax, s.ux, s.uy, 'LineStyle',':', 'Color',col*0.6, ...
        'LineWidth',1, p{:});
end
s.h.trail = line(ax, 0, 0, 'Color',[1 0.25 0.9], 'LineWidth',2, p{:});
s.h.aim = line(ax, [0 0], [0 0], 'LineStyle','--', 'Color',[1 1 0.5]*0.7, p{:});
s.h.shipGlow = line(ax, 0, 0, 'LineStyle','none', 'Marker','o', 'MarkerSize',18, ...
    'MarkerFaceColor',[0.4 0.4 0.15], 'MarkerEdgeColor','none', p{:});
s.h.ship = line(ax, 0, 0, 'LineStyle','none', 'Marker','o', 'MarkerSize',8, ...
    'MarkerFaceColor',[1 1 0.8], 'MarkerEdgeColor',[1 1 0.3], p{:});
f = [{'FontName','FixedWidth', 'FontWeight','bold', 'Interpreter','none'}, p];
s.h.score = text(ax, 20, 570, '0', 'Color',[0 1 1], 'FontSize',26, f{:});
s.h.best = text(ax, 780, 570, '', 'Color',[1 0.25 0.9], 'FontSize',14, ...
    'HorizontalAlignment','right', f{:});
s.h.msg = text(ax, 400, 160, '', 'Color',[1 1 1], 'FontSize',22, ...
    'HorizontalAlignment','center', f{:});

s = newRound(s);
end

function s = newRound(s)
s.camX = 0;
s.score = 0;
s.time = 0;
s.mode = 0;            % 0 = orbiting, 1 = flying, 2 = lost
s.started = false;
s.deadT = 0;
s.lastX = 200;
s.P = zeros(s.N, 6);   % columns: x, y0, radius, drift amp, phase, visited
s.P(1,:) = [200 300 40 0 0 1];
for i = 2:s.N
    s = spawnPlanet(s, i);
end
s.c = planetCenters(s);
s.cur = 1;
s.leave = 0;
s.ang = pi/2;
s.rad = 68;
s.dir = -1;            % clockwise, so the first launch heads right
s.x = 200;
s.y = 300 + s.rad;
s.vx = 0;
s.vy = 0;
s.trail = repmat([s.x s.y], 40, 1);
end

function s = spawnPlanet(s, i)
% Place a new planet beyond the farthest one. Gaps and vertical drift
% grow with distance travelled.
d = min(1, s.lastX/6000);
s.lastX = s.lastX + 230 + 130*d + 60*rand;
r = 22 + 22*rand;
amp = 110*d*rand;
y0 = 80 + amp + (440 - 2*amp)*rand;
s.P(i,:) = [s.lastX, y0, r, amp, 2*pi*rand, 0];
end

function c = planetCenters(s)
c = [s.P(:,1), s.P(:,2) + s.P(:,4).*sin(0.8*s.time + s.P(:,5))];
end

function s = updateState(s, dt, pressed)
if s.mode == 2
    s.deadT = s.deadT + dt;
    if pressed && s.deadT > 0.6
        s = newRound(s);
    end
    return
end

s.time = s.time + dt;
s.c = planetCenters(s);
c = s.c;
spd = 160 + 3*min(s.score, 30);

if s.mode == 0
    % Orbit the current planet, spiralling gently to a comfortable radius
    s.rad = s.rad + (s.P(s.cur,3) + 28 - s.rad)*min(1, 2*dt);
    s.ang = s.ang + s.dir*spd/s.rad*dt;
    s.x = c(s.cur,1) + s.rad*cos(s.ang);
    s.y = c(s.cur,2) + s.rad*sin(s.ang);
    if pressed
        s.started = true;
        s.mode = 1;
        s.vx = -s.dir*spd*sin(s.ang);
        s.vy = s.dir*spd*cos(s.ang);
        s.leave = s.cur;
    end
    tgtX = c(s.cur,1) - 220;
else
    % Free flight with a weak pull from every planet except the one left
    dx = c(:,1) - s.x;
    dy = c(:,2) - s.y;
    d = hypot(dx, dy);
    G = 2.2e6*(s.P(:,3)/35).^2;
    G(s.leave) = 0;
    a = G./max(d, 30).^3;
    s.vx = s.vx + sum(a.*dx)*dt;
    s.vy = s.vy + sum(a.*dy)*dt;
    v = hypot(s.vx, s.vy);
    s.vx = s.vx*spd/v;    % keep speed constant: gravity only bends the path
    s.vy = s.vy*spd/v;
    s.x = s.x + s.vx*dt;
    s.y = s.y + s.vy*dt;

    hit = d < s.P(:,3) + 45;
    hit(s.leave) = false;
    k = find(hit, 1);
    if ~isempty(k)
        s.mode = 0;
        s.cur = k;
        s.leave = 0;
        s.rad = d(k);
        s.ang = atan2(s.y - c(k,2), s.x - c(k,1));
        cr = (s.x - c(k,1))*s.vy - (s.y - c(k,2))*s.vx;
        s.dir = sign(cr) + (cr == 0);
        if ~s.P(k,6)
            s.P(k,6) = 1;
            s.score = s.score + 1;
            s.best = max(s.best, s.score);
        end
    elseif s.y < -30 || s.y > 630 || s.x < s.camX - 30 || s.x > s.camX + 830
        s.mode = 2;
        s.deadT = 0;
    end
    tgtX = max(s.camX, s.x - 500);
end

s.camX = s.camX + (tgtX - s.camX)*min(1, 3*dt);
s.trail = [s.trail(2:end,:); s.x s.y];

% Recycle planets that scrolled off the left edge
for i = 1:s.N
    if i ~= s.cur && i ~= s.leave && s.P(i,1) < s.camX - 120
        s = spawnPlanet(s, i);
    end
end
end

function renderFrame(~, s)
h = s.h;
cx = s.camX;
h.stars.XData = mod(s.starX - cx*s.starD, 800);
for i = 1:s.N
    r = s.P(i,3);
    px = s.c(i,1) - cx;
    py = s.c(i,2);
    h.glow(i).XData = px + 1.7*r*s.ux;
    h.glow(i).YData = py + 1.7*r*s.uy;
    h.body(i).XData = px + r*s.ux;
    h.body(i).YData = py + r*s.uy;
    h.ring(i).XData = px + (r + 45)*s.ux;
    h.ring(i).YData = py + (r + 45)*s.uy;
    h.ring(i).Visible = ~s.P(i,6);
end
h.trail.XData = s.trail(:,1) - cx;
h.trail.YData = s.trail(:,2);
sx = s.x - cx;
h.ship.XData = sx;
h.ship.YData = s.y;
h.shipGlow.XData = sx;
h.shipGlow.YData = s.y;
h.aim.Visible = s.mode == 0;
tx = -s.dir*sin(s.ang);
ty = s.dir*cos(s.ang);
h.aim.XData = sx + [0 70*tx];
h.aim.YData = s.y + [0 70*ty];
h.score.String = sprintf('%d', s.score);
h.best.String = sprintf('BEST %d', s.best);
if s.mode == 2
    h.msg.String = {'LOST IN SPACE', sprintf('score %d', s.score), 'tap to retry'};
elseif ~s.started
    h.msg.String = {'ORBIT HOPPER', 'tap to launch'};
else
    h.msg.String = '';
end
end
Play Game
Preview

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