Split

Ned Gulley
/
Split
on 4 Nov 2026
5
34
12
0
9579
game.m
function g = game()
%game Split: tap when the scanning line splits the dots 50/50.
%
%   A line sweeps across a shape full of dots. Tap when you think it
%   divides the dots into two equal halves. Your score for the level is
%   the difference between the two percentages, and it is added to the
%   bar on the right. When the bar reaches 100 the game is over.
%   The line makes three round trips: green, then yellow, then red, each
%   faster than the last. If red finishes, the level scores 100.

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

function s = initState(ax)
s.c = [350 290];               % shape center
s.phase = 0;                   % 0 title, 1 intro, 2 sweep, 3 reveal, 4 game over
s.t = 0;
s.bar = 0;
s.level = 1;
s = newLevel(s);

bg = [0.07 0.08 0.12];
ax.Color = bg;
np = {'HitTest','off','PickableParts','none'};
ln = @(varargin) line(ax, nan, nan, varargin{:}, np{:});
s.g.shape = patch(ax, nan, nan, [0.15 0.18 0.27], 'EdgeColor', [0.45 0.5 0.65], np{:});
dots = @(c, z) ln('LineStyle', 'none', 'Marker', 'o', 'MarkerSize', z, ...
    'MarkerFaceColor', c, 'MarkerEdgeColor', 'none');
s.g.dN = dots([0.92 0.94 1], 6);
s.g.dA = dots([0.3 0.85 1], 6);
s.g.dB = dots([1 0.6 0.25], 6);
s.g.line = ln('LineWidth', 3);
s.g.piv = dots('w', 10);
s.g.barF = patch(ax, nan, nan, 'g', 'EdgeColor', 'none', np{:});
ln('XData', [720 760 760 720 720], 'YData', [60 60 540 540 60], 'Color', [0.6 0.65 0.8]);
txt = @(x, y, z, c, a) text(ax, x, y, '', 'Color', c, 'FontSize', z, ...
    'FontWeight', 'bold', 'HorizontalAlignment', a, np{:});
s.g.barT = txt(740, 42, 14, 'w', 'center');
s.g.hud = txt(20, 575, 14, 'w', 'left');
s.g.eq = txt(383, 575, 22, 'w', 'right');
s.g.fly = txt(412, 575, 22, [1 0.9 0.3], 'center');
s.g.pA = txt(0, 0, 20, [0.3 0.85 1], 'center');
s.g.pB = txt(0, 0, 20, [1 0.6 0.25], 'center');
s.g.msg = txt(350, 300, 20, 'w', 'center');
set([s.g.pA s.g.pB s.g.msg], 'BackgroundColor', bg, 'Margin', 6);
end

function s = updateState(s, dt, pressed)
s.t = s.t + dt;
if s.phase == 0 && pressed || s.phase == 1 && s.t > 1
    s.phase = s.phase + 1;
    s.t = 0;
elseif s.phase == 2
    if ~pressed
        % Each round trip is two legs of s.p; each trip is 1.5x faster.
        s.p = min(6, s.p + dt*1.5^floor(s.p/2)/s.T);
        s.ang = s.ang + s.w*dt;
        s = placeLine(s);
    end
    if pressed || s.p == 6     % red pass done: line stops at the start edge
        s = reveal(s);
    end
elseif s.phase == 3
    s = animate(s);
    if s.t > 4.2
        s.level = s.level + 1;
        s = nextUp(s, 1 + 3*(s.bar >= 100));
    end
elseif s.phase == 4 && pressed && s.t > 1
    s.bar = 0;
    s.level = 1;
    s = nextUp(s, 1);
end
end

function s = nextUp(s, ph)
s.phase = ph;
s.t = 0;
if ph < 4
    s = newLevel(s);
else
    s.level = s.level - 1;
end
end

function s = newLevel(s)
k = s.level;
% Difficulty ramp: shape, dot pattern, sweep mode, line angle, rotation.
sh = [1 1 2 randi([2 3]) 4 + 4*(rand < 0.25) - (rand < 0.5) randi(8)];
sh = sh(min(k, 6));
pat = [1 1 1 1 1 2 2 3 3 4 2 3 2 randi([2 4])];
pat = pat(min(k, 14));
s.mode = 1 + (k == 11 || k == 12 || k > 13 && rand < 0.5);
s.phi = (k == 7 || k == 9)*1.2*(rand - 0.5) + (k > 9)*2*pi*rand;
s.w = 0.35*(k == 13) + (k > 13 && rand < 0.5)*sign(rand - 0.5)*(0.2 + 0.3*rand);
sc = 1 - (k > 4)*0.15*rand;
if s.mode == 2 || s.w
    sc = 0.55 + 0.15*(s.mode == 1);
end
s.T = max(1.8, 5.5 - 0.3*(k - 1));    % seconds per one-way pass, first trip
P = [];
while size(P, 1) < 10
    V = mkShape(sh, sc, k);
    P = mkDots(V, pat, 2*round(min(50 + 8*k, 170)/2), k);
end
s.lv = V;
s.ld = P;
s.p = 0;
s.ang = 0;
s.A = false(size(P, 1), 1);

% Sweep range: just past the dots, or their bounding circle if rotating.
Rb = max(vecnorm(P, 2, 2));
n = [cos(s.phi) sin(s.phi)];
pr = (P + s.c)*n';
if s.w
    pr = s.c*n' + [-Rb Rb];
end
s.lo = min(pr) - 22;
s.hi = max(pr) + 22;
psi = randi(8)*pi/4;
D0 = Rb + 70;
s.piv = s.c + D0*[cos(psi) sin(psi)];
s.th = psi + pi + (asin(Rb/D0) + 0.1)*[-1 1];
s = placeLine(s);
end

function V = mkShape(sh, A, k)
B = 190*A;
A = 250*A;
r = rand(1, 2);
a = (0:59)'/60*2*pi;
switch sh
    case 1                     % rectangle
        V = [-1 -1; 1 -1; 1 1; -1 1].*[A B].*(0.5 + 0.5*r);
    case 2                     % triangle
        V = [-A -B; A -B; A*(2*r(1) - 1) B];
    case 3                     % trapezoid
        t = A*(0.2 + 0.5*r(1));
        o = A*0.4*(2*r(2) - 1);
        V = [-A -B; A -B; o + t B; o - t B];
    case 4                     % ellipse
        V = [0.8*A*cos(a) B*sin(a)];
    case 5                     % L shape
        V = [-A -B; A -B; A 0; 0 0; 0 B; -A B];
    case 6                     % blob
        q = 1 + 0.25*sin(3*a + 6*r(1)) + 0.15*sin(5*a + 6*r(2));
        V = [0.8*A*q.*cos(a) B*q.*sin(a)]/1.3;
    case 7                     % half disc
        a = a(1:31);
        V = [A*cos(a) B*(2*sin(a) - 1)];
    otherwise                  % house
        V = [-A -B; A -B; A B/3; 0 B; -A B/3];
end
if k > 2
    V = V.*sign(rand(1, 2) - 0.5);    % random mirroring
end
V = V - (max(V) + min(V))/2;
end

function P = mkDots(V, pat, N, k)
% Dots live inside a slightly shrunken copy of the shape so none touch the edge.
V = 0.94*V;
in = @(P) P(inpolygon(P(:, 1), P(:, 2), V(:, 1), V(:, 2)), :);
h0 = max(26, sqrt(polyarea(V(:, 1), V(:, 2))/N));    % floor keeps dots distinct
R = max(abs(V(:)));
if pat < 3
    % Lattice (square, or hex from level 3), jittered for pattern 2.
    % Nudge the spacing until the dot count is even.
    hex = k > 2 && rand < 0.5;
    for h = h0*(1:0.015:1.5)
        dy = h*(1 - 0.134*hex);
        j = -ceil(R/dy):ceil(R/dy);
        [X, Y] = meshgrid(h*(j + 0.5), dy*j);
        P = [X(:) + hex*mod(round(Y(:)/dy), 2)*h/2, Y(:)];
        P = in(P + (pat == 2)*0.5*h*(rand(size(P)) - 0.5));
        if mod(size(P, 1), 2) == 0
            return
        end
    end
end
% Dart throwing with a minimum spacing, thinned by a density map:
% a gradient in a random direction (pattern 3) or a few clusters (pattern 4).
Q = in((2*rand(30000, 2) - 1)*R);
a = 2*pi*rand;
t = Q*[cos(a); sin(a)];
d = 0.08 + 0.92*rescale(t).^2;
if pat == 4
    C = Q(randi(end, randi([2 4]), 1), :);
    d = 0.06 + sum(exp(-((Q(:, 1) - C(:, 1)').^2 + (Q(:, 2) - C(:, 2)').^2)/(0.18*N*h0^2)), 2);
end
Q = Q(rand(size(d)) < d, :);
P = Q(1, :);
for i = 2:size(Q, 1)
    if size(P, 1) < N && all(vecnorm(P - Q(i, :), 2, 2) > max(13, 0.5*h0))
        P(end + 1, :) = Q(i, :); %#ok<AGROW>
    end
end
P = P(1:end - mod(end, 2), :);
end

function s = placeLine(s)
a = s.ang;
Rm = [cos(a) -sin(a); sin(a) cos(a)];
s.wd = s.ld*Rm' + s.c;
s.wv = s.lv*Rm' + s.c;
u = 1 - abs(mod(s.p, 2) - 1);
n = [cos(s.phi) sin(s.phi)];
P = n*(s.lo + u*(s.hi - s.lo));
D = [-n(2) n(1)];
t0 = -2000;
if s.mode == 2
    th = s.th(1) + u*diff(s.th);
    P = s.piv;
    n = [-sin(th) cos(th)];
    D = [cos(th) sin(th)];
    t0 = 0;
end
s.sv = (s.wd - P)*n';          % > 0 means ahead of the line
% Clip the line (or ray) to the play box.
t1 = 2000;
b = [30 680; 30 540];
for k = 1:2
    if abs(D(k)) > 1e-9
        ta = (b(k, :) - P(k))/D(k);
        t0 = max(t0, min(ta));
        t1 = min(t1, max(ta));
    end
end
s.lxy = [P + t0*D; P + t1*D];
s.nrm = n;
c = [0.25 1 0.4; 1 0.9 0.15; 1 0.3 0.25];
s.lcol = c(min(floor(s.p/2), 2) + 1, :);
end

function s = reveal(s)
s.A = s.sv < 0;
pA = round(100*mean(s.A));
pB = 100 - pA;
s.diff = abs(pA - pB);
s.old = s.bar;
s.bar = min(100, s.bar + s.diff);
s.eqStr = sprintf('%d %s %d =', max(pA, pB), char(8722), min(pA, pB));
s.pStr = {sprintf('%d%%', pA), sprintf('%d%%', pB)};
mid = mean(s.lxy);
s.pos = [labelPos(s.wd(s.A, :), mid - 90*s.nrm); labelPos(s.wd(~s.A, :), mid + 90*s.nrm)];
s.phase = 3;
s.t = 0;
s = animate(s);
end

function p = labelPos(D, p)
if ~isempty(D)
    p = mean(D, 1);
end
p = max(min(p, [650 520]), 50);
end

function s = animate(s)
% Reveal timeline: colors, then percentages, then the equation, then the
% difference flies into the bar and the bar grows.
t = s.t;
e = (1 - cos(pi*min(max((t - 1.9)/0.8, 0), 1)))/2;
s.fp = [412 575] + e*([740 60 + 4.8*s.old] - [412 575]);
s.fs = 22 - 8*e;
s.flyOn = t > 1.1 && t < 2.7;
s.barV = s.old + min(max((t - 2.7)/0.5, 0), 1)*(s.bar - s.old);
end

function renderFrame(~, s)
g = s.g;
xy = @(h, P) set(h, 'XData', P(:, 1), 'YData', P(:, 2));
xy(g.shape, s.wv);
on = {'off', 'on'};
rev = s.phase > 2;
z = nan(1, 2);
xy(g.dN, z);
xy(g.dA, z);
xy(g.dB, z);
v = s.bar;
if rev
    xy(g.dA, s.wd(s.A, :));
    xy(g.dB, s.wd(~s.A, :));
    v = s.barV;
    set(g.pA, 'String', s.pStr{1}, 'Position', s.pos(1, :));
    set(g.pB, 'String', s.pStr{2}, 'Position', s.pos(2, :));
    g.eq.String = s.eqStr;
    set(g.fly, 'String', "" + s.diff, 'Position', s.fp, 'FontSize', s.fs);
else
    xy(g.dN, s.wd);
end
xy(g.line, s.lxy);
g.line.Color = s.lcol;
xy(g.piv, z);
if s.mode == 2
    xy(g.piv, s.piv);
end
y1 = 60 + 4.8*v;
set(g.barF, 'XData', [720 760 760 720], 'YData', [60 60 y1 y1], ...
    'FaceColor', [min(1, v/50) min(1, 2 - v/50) 0.25]);
g.barT.String = "" + round(v);
g.hud.String = "Level " + s.level;
set([g.pA g.pB], 'Visible', on{1 + (rev && s.t > 0.4)});
g.eq.Visible = on{1 + (rev && s.t > 1.1)};
g.fly.Visible = on{1 + (s.phase == 3 && s.flyOn)};
m = {{'SPLIT', '', 'Tap when the line splits the dots 50 / 50.', ...
    'Green, yellow, red: three passes, then you lose the level.', '', 'Tap to start'}, ...
    "Level " + s.level, '', '', ...
    {'GAME OVER', "You reached level " + s.level, '', 'Tap to play again'}};
m = m{s.phase + 1};
g.msg.String = m;
g.msg.Visible = on{1 + ~isempty(m)};
end
Play Game
Preview

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