Lumi Hop

Rich Conlan
/
Lumi Hop
on 14 Nov 2026
2
9
2
2
9951
game.m
function g = game()
% LUMI HOP by Rich Conlan
% A small glowing robot hops forward across lanes of hazards that get
% stranger every zone. Tap to hop. Tap a steady beat and the 4th tap
% BURSTS Lumi over the next band of hazards to safety.
g.init = @init;
g.update = @update;
g.render = @render;
end

function s = init(ax)
% zones: name | lanes ('.' rest, s slide, b blink laser, w wave jelly, p pinch)
Z = split("NEON DRIFT|.ss.sss....sss|LASER GRID|.bs.bsb....bbb|JELLY SEA|.ww.wsw....www|" + ...
    "CRYSTAL PINCH|.pp.pwp....ppp|PRISM|.sbw.pws...wbp|DREAM CLOCK|.bpb.wsb.bp...bpw|" + ...
    "FRACTAL|.wps.bwp.sb...spb|THE GLOW|.spw.bpw.wbs.ps...bwp", "|");
s.names = Z(1:2:end);
s.typ = [Z{2:2:end} '.']';                         % one char per lane; last = HOME
s.zid = [repelem(1:8, strlength(Z(2:2:end))) 8]';  % zone of each lane
s.zs = find(diff([0; s.zid]));                     % first lane of each zone
ax.Color = [.03 .02 .08];
set(ax, 'DefaultPatchEdgeColor', 'none', 'DefaultLineLineWidth', 2, 'DefaultTextColor', 'w', ...
    'DefaultTextHorizontalAlignment', 'center', ...
    'DefaultTextFontWeight', 'bold');
s.c = exp(2i*pi*(0:24)'/24);
c = s.c;
s.W = hgtransform(ax);                             % the world: camera + shake
s.lp = patch(s.W, 'FaceColor', 'flat');            % lanes
s.hp = patch(s.W, 'FaceColor', 'flat', 'EdgeColor', [.8 .8 .9]); % hazards
s.rl = line(s.W, nan, nan, 'LineWidth', 3);        % tap rings
s.pt = line(s.W, nan, nan, 'LineStyle', 'none', 'Marker', '.', 'MarkerSize', 16);
s.P = hgtransform(s.W);                            % Lumi
s.glow = patch(s.P, 36*real(c), 36*imag(c), 'c', 'FaceAlpha', .3);
s.body = patch(s.P, 20*real(c), 20*imag(c), [.9 .97 1], 'EdgeColor', 'c', 'LineWidth', 3);
patch(s.P, [-7 7] + 2.6*real(c), 3 + 4.5*imag(c) + [0 0], [.1 .1 .3]);
a = -2.6:.25:-.5;
line(s.P, 7*cos(a), 6*sin(a) - 1, 'Color', [.1 .1 .3]);
line(s.P, [0 0], [19 29], 'Color', [.7 .8 .9]);
s.tip = line(s.P, 0, 31, 'Marker', '.', 'MarkerSize', 24);
s.fp = patch(ax, [0 800 800 0], [0 0 600 600], 'r');
s.pn = patch(ax, [70 730 730 70], [350 350 575 575], [.05 .03 .15], 'FaceAlpha', .9);
s.tx = text(ax, 400 + [0 0 0 0], [510 415 578 24], repmat({''}, 1, 4));
set(s.tx, {'FontSize'}, {64; 18; 16; 14});
s.tx(1).Color = [1 .45 .8];
set(findall(ax), 'HitTest', 'off', 'PickableParts', 'none');
% fx: squash, flash, shake, BURST text, zone banner, landing grace (all decay)
[s.best, s.fx, s.pc, s.rg] = deal(0, zeros(1, 6), 'w', [9; 9; 9]);
s.pd = rand(40, 1).*exp(2i*pi*rand(40, 1));      % particle directions
[s.po, s.pa, s.ps] = deal(0, 9, 0);                 % particles: origin, age, speed
s = reset(s, 0);
end

function s = reset(s, m)
% start a run (m = 1) or the attract demo (m = 0: Lumi plays PRISM by itself)
[s.mode, s.T, s.hop, s.hl, s.q, s.g, s.lt, s.li, s.lives, s.score, s.hitT, s.overT, s.won, s.fx, s.lap] = ...
    deal(m, 2.2*~m, 0, 1, 0, 0, -9, 1, 3, 0, 0, 0, 0, [0 0 0 0 2*m 0], 1);   % demo clock phase gives a clean run
s.zone = 1 + 4*(m == 0);
[s.lane, s.mx] = deal(s.zs(s.zone));
s.cam = 60*s.lane - 170;
end

function s = update(s, dt, pr)
s.T = s.T + dt;
s.fx = max(0, s.fx - [6 2.5 40 1 2 1]*dt);
[s.rg, s.pa] = deal(s.rg + dt, s.pa + dt);
s.cam = s.cam + (60*(s.lane + s.hop*s.hl) - 170 - s.cam)*min(1, 8*dt);
if s.mode == 2
    s.overT = s.overT + dt;
    if pr && s.overT > .8 || s.overT > 20, s = reset(s, s.overT < 20); end
    return
end
if s.mode == 0
    if pr, s = reset(s, 1); return, end
    pr = demo(s);
    if s.lane >= s.zs(6), s = reset(s, 0); end
end
if s.hitT > 0
    s.hitT = s.hitT - dt;
    if s.hitT <= 0
        [s.lane, s.hop, s.q, s.g] = deal(s.zs(s.zone), 0, 0, 0);   % back to the zone start
        if s.lives < 1, [s.mode, s.overT] = deal(2, 0); end
    end
    return
end
if pr, s = tap(s); end
if s.hop > 0
    s.hop = s.hop + dt/(.13 + .17*(s.hl > 1));
    if s.hop >= 1, s = land(s); end
end
if ~s.fx(6) && (s.hop == 0 || s.hl == 1) && hit(s, s.lane + (s.hop > .5), s.T)
    [s.hitT, s.fx(2:3), s.lives, s.g] = deal(.7, [1 14], s.lives - (s.mode == 1), 0);
    s = puff(s, 420, [1 .6 .7]);
end
end

function s = tap(s)
% the rhythm: an interval within 30% of the last one grows the groove;
% the 4th steady tap (groove 3) is a BURST
I = s.T - s.lt;
s.g = (I > .2 && I < .9)*(1 + s.g*(abs(I - s.li) < .3*s.li));
b = s.g > 2;
[s.lt, s.li, s.fx(1), s.g] = deal(s.T, I, 1, s.g*~b);
s.rg = [0; s.rg(1:2)];
if s.hop > 0
    s.q = max(s.q, 1 + b);   % one tap is buffered during a hop
else
    s = go(s, b);
end
end

function s = go(s, b)
% start a hop; a burst flies over the next band of hazards to the rest lane
% beyond it (up to 8 lanes ahead)
v = s.typ(min(end, s.lane + (1:8))) == '.';
r = find(v & cumsum(~v) > 0, 1);
n = 1;
if b
    n = [r; 3];
    n = n(1);
    s.fx(4) = .7;
    s = puff(s, 300, [1 .9 .4]);
end
[s.hl, s.hop] = deal(n, 1e-6);
end

function s = land(s)
s.lane = min(s.lane + s.hl, numel(s.typ));
s.fx(6) = .25*(s.hl > 1);
s.score = s.score + 10*max(0, s.lane - s.mx)*(1 + s.g + 2*(s.hl > 1));
s.mx = max(s.mx, s.lane);
if s.zid(s.lane) > s.zone
    [s.zone, s.fx(5), s.lives, s.score] = deal(s.zid(s.lane), 2, min(3, s.lives + 1), s.score + 100);
end
s.hop = 0;
if s.lane == numel(s.typ) && s.mode == 1     % HOME: next lap (faster), or the end
    s.score = s.score + 200*s.lives;
    if s.lap < 3
        [s.lap, s.lane, s.mx, s.zone, s.fx(5), s.cam] = deal(s.lap + 1, 1, 1, 1, 2, -110);
    else
        [s.mode, s.won, s.overT, s.q] = deal(2, 1, 0, 0);
    end
end
s.best = max(s.best, s.score*(s.mode > 0));
if s.q, s = go(s, s.q > 1); s.q = 0; end
end

function b = demo(s)
% attract-mode autopilot: a steady beat whenever the landing lane stays clear
b = s.T - s.lt > .4 && s.hop == 0;
for u = .05:.05:.5
    b = b && ~hit(s, s.lane + 1, s.T + u);
end
end

function s = puff(s, v, c)
[s.po, s.pa, s.ps, s.pc] = deal(400 + 60i*(s.lane + s.hop*s.hl), 0, v, c);
end

function I = haz(s, L, t)
% hazards of lane L at time t as rows [x1 x2 lethal kind]; every period divides 16 s
I = zeros(0, 4);
if L < 1 || L > numel(s.typ), return, end
t = mod(t*8/(9 - s.lap), 16);                      % laps 2 and 3 run 14% and 33% faster
z = s.zid(L);
k = 2 + floor((z + mod(L, 3))/5);                  % speed 60k: 120, 180, 240 px/s
switch s.typ(L)
    case {'s', 'w'}                                % sliding pills / surging jelly
        n = 2 + mod(L, 2);
        x = mod(137*L + (0:n-1)'*960/n + (1 - 2*mod(L, 2))*60*k*t + ...
            (s.typ(L) == 'w')*80*sin(pi*t/2 + L), 960) - 80;
        I = [x - 30 - 10*mod(L, 3), x + 30 + 10*mod(L, 3), x*0 + 1];
    case 'b'                                       % laser: shimmer, then on
        f = mod(t*(1 + floor(z/3))/8 + L*.37, 1);
        I = [-80 880 (f < .4) + (f > .85)/2];          % 1 on, .5 shimmer, 0 off (faint)
    case 'p'                                       % walls closing to the middle
        q = 440*abs(sin(pi*t/4 + L)) - 60;
        I = [-80 400 - q 1; 400 + q 880 1];
end
I(:, 4) = find(s.typ(L) == '.swbp') - 1;           % kind: 1 s, 2 w, 3 b, 4 p
end

function h = hit(s, L, t)
I = haz(s, L, t);
h = any(I(:, 3) == 1 & I(:, 1) < 418 & I(:, 2) > 382);
end

function y = rip(s, x, y)
% the dream warp: one ripple shared by lanes, hazards and Lumi
y = y + 4*s.zone*sin(x/110 + 2*s.T + y/90);
end

function render(~, s)
% lanes: 13 visible rows x 16 quads, hue drifting by zone, time and x
L = floor(s.cam/60) + (0:12)';
Lc = min(max(L, 1), numel(s.typ));
X = repmat(-14:53:781, 13, 1);
r = s.typ(Lc) == '.';
pu = (s.g > 0)*max(0, 1 - 4*mod(s.T - s.lt, s.li)/s.li);   % lanes pulse on your beat
C = reshape(hsv2rgb(cat(3, mod(.6 + s.zid(Lc).*(.13 + .008*s.T + X/1e4), 1), .65 - .3*r + 0*X, ...
    .14 + .07*mod(L, 2) + .16*r + .1*pu + 0*X)), [], 3);
Y = reshape(60*L - 30 + 0*X, [], 1) + [0 0 60 60];
X = X(:) + [0 53 53 0];
set(s.lp, 'Vertices', [X(:) reshape(rip(s, X, Y), [], 1)], 'Faces', reshape(1:832, [], 4), ...
    'FaceVertexCData', C);
% hazards: one rounded 8-gon per interval
H = zeros(0, 5);
for j = 1:13
    I = haz(s, L(j), s.T);
    H = [H; I, I(:, 1)*0 + 60*L(j)]; %#ok<AGROW>
end
k = H(:, 4);
a = max(H(:, 1), -40);
b = min(H(:, 2), 840);
th = (1:8)*pi/4 - pi/8;
X = (a + b)/2 + (b - a)/2.*sign(cos(th)).*abs(cos(th)).^.3;
v = [16 20 2 22];
hh = v(k)' + 12*(k == 3).*H(:, 3);
Y = rip(s, X, H(:, 5) + hh.*sign(sin(th)).*abs(sin(th)).^.3);
P = [1 .3 .6; .3 1 .85; .7 1 .2; .8 .5 1];
set(s.hp, 'Vertices', [reshape(X', [], 1) reshape(Y', [], 1)], 'Faces', reshape(1:8*numel(k), 8, [])', ...
    'FaceVertexCData', P(k, :).*(.3 + .7*H(:, 3)));
% Lumi, rings, ghost beat ring, particles
y = rip(s, 400, 60*(s.lane + s.hop*s.hl));
s.W.Matrix = makehgtform('translate', [s.fx(3)*sin(91*s.T), s.fx(3)*cos(73*s.T) - s.cam, 0]);
s.P.Matrix = makehgtform('translate', [400 y 0], 'scale', [1 + .3*s.fx(1), 1 - .25*s.fx(1), 1]);
s.P.Visible = s.hitT <= 0;
dash = s.hop > 0 && s.hl > 1;
gc = hsv2rgb([mod(.55 - .17*s.g + 3*s.T*dash, 1), .75, 1]);   % groove colour, rainbow in a burst
set(s.glow, 'FaceColor', gc, 'FaceAlpha', .25 + .2*pu + .3*dash);
[s.body.EdgeColor, s.tip.Color] = deal(gc);
R = 400 + 1i*y + (20 + 160*s.rg').*s.c + 0./(s.rg' < .45);
tn = s.lt + s.li - s.T;
R = [R; nan(1, 3)];
R = [R(:); 400 + 1i*y + (20 + 90*tn/s.li)*s.c + 0/(s.g > 0 && tn > 0 && tn < s.li)];
set(s.rl, 'XData', real(R), 'YData', imag(R), 'Color', gc);
q = s.po + s.pd*s.ps*s.pa + 0/(s.pa < .6);
set(s.pt, 'XData', real(q), 'YData', imag(q), 'Color', s.pc);
set(s.fp, 'FaceAlpha', .4*s.fx(2), 'Visible', s.fx(2) > 0);
% text
m = s.mode;
s.pn.Visible = m ~= 1 | s.fx(5) > 0;
nm = s.names(s.zone);
T = ["LUMI HOP" "" "GAME OVER" "HOME!"];
K = 'TAP = HOP      TAP STEADY x4 = BURST';
B = {K, '3 LAPS HOME, EACH ONE FASTER', '', 'TAP TO START'};
U = "";
if m == 2
    B = {"SCORE " + s.score + "      BEST " + s.best, "LAP " + s.lap + " - ZONE " + s.zone + " - " + nm, '', 'TAP TO PLAY AGAIN'};
end
if mod(s.T, 1) > .7 || s.overT < .4*m, B{4} = ''; end
if m == 1
    B = {''};
    if s.fx(4), B = {'BURST!'}; end
    if s.fx(5), B = {"LAP " + s.lap + " - ZONE " + s.zone, nm}; end
    U = "SCORE " + s.score + "   BEAT " + (s.g + 1) + "/4" + "          ZONE " + s.zone + " - " + nm + "          LIVES " + s.lives;
end
set(s.tx, {'String'}, {T(m + 1 + s.won); B; U; ...
    repmat(K, 1, m == 1 && s.zone == 1)});
set(s.tx(2), 'FontSize', 18 + 16*(m == 1), 'Position', [400 415 + 105*(m == 1)]);
end
Play Game
Preview

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