Insane in the Membrane

David Marshall
/
Insane in the Membrane
on 6 Nov 2026
4
54
31
4
9518
game.m
function g = game()
    % Insane in the Membrane: dodge balls bouncing inside the membrane.
    g.init   = @initState;
    g.update = @updateState;
    g.render = @renderFrame;
end

function s = initState(ax)
    ax.YDir = 'normal';
    ax.Color = [0.03 0.04 0.08];
    ax.ZLim = [-1000 10];

    % World and tuning knobs
    s.W = 800;          % room width
    s.floorY = 40;      % floor height
    s.N = 20;           % ball pool size
    s.r = 12;           % ball radius
    s.pw = 56;          % player width
    s.ph = 22;          % player height
    s.pSpeed = 340;     % player slide speed
    s.ord = [1 4 3 9 5 10 12];   % membrane modes, one per 10s level

    % The MathWorks logo: membrane rotated to the logo's view, flattened
    % into the 2D world (depth goes to Z so lighting still works)
    hp = {'HitTest', 'off', 'PickableParts', 'none'};
    [X, Y] = meshgrid(linspace(-1, 1, 81));
    s.XY = [X(:)'; Y(:)'];
    for k = 1:numel(s.ord)
        L = membrane(s.ord(k), 40);
        s.L(:,:,k) = L/max(abs(L(:)));
    end
    s.T = viewmtx(-37, 32);
    sx = rescale(s.T(1,1:2)*s.XY, 0, s.W);
    s.ci = round(sx'/5) + 1;
    s.cx = 0:5:s.W;
    s.mk = [];
    s.t = 0;
    s = shape(s);
    s.g.surf = surface(ax, reshape(sx, 81, 81), 0*X, 0*X, 'FaceColor', [0.9 0.2 0.2], ...
        'EdgeColor', 'none', 'FaceLighting', 'gouraud', 'BackFaceLighting', 'lit', ...
        'AmbientStrength', 0.3, 'DiffuseStrength', 0.6, 'SpecularStrength', 1, ...
        'SpecularColorReflectance', 1, 'SpecularExponent', 7, hp{:});
    light(ax, 'Position', s.T(1:3,1:3)*[0.5; -1; 0.4], 'Color', [0.8 0.8 0]);
    light(ax, 'Position', s.T(1:3,1:3)*[0.6; 3; 0.8], 'Color', [0 0.46 0.66]);

    % Ceiling = the logo's top silhouette
    lc = {'Color', [1 0.9 0.8], 'LineWidth', 1.5, hp{:}};
    s.g.ceil = line(ax, s.cx, s.cy, 0*s.cx - 1, lc{:});   % z = -1 keeps lines behind the card
    s.g.room = line(ax, [0 0 s.W s.W], [0 0 0 0], -[1 1 1 1], lc{:});

    s.g.balls = gobjects(1, s.N);
    for k = 1:s.N
        s.g.balls(k) = rectangle(ax, 'Position', [0 0 2 2]*s.r, 'Curvature', [1 1], ...
            'FaceColor', [0.2 0.6 1], 'EdgeColor', 'none', 'Visible', 'off', hp{:});
    end
    s.g.player = rectangle(ax, 'Position', [0 s.floorY s.pw s.ph], ...
        'FaceColor', [1 1 1], 'EdgeColor', 'none', hp{:});
    s.g.pick = rectangle(ax, 'Position', [0 0 18 18], 'Curvature', [1 1], ...
        'FaceColor', [1 0.85 0.2], 'EdgeColor', 'none', 'Visible', 'off', hp{:});

    % Effects: a ring closing in where a ball spawns, a ring bursting out
    % where one is cleared
    rc = {'Curvature', [1 1], 'LineWidth', 2, 'Visible', 'off', hp{:}};
    s.g.spawn = rectangle(ax, rc{:});
    s.g.burst = rectangle(ax, rc{:}, 'LineWidth', 4);
    tx = @(x, y, str, varargin) text(ax, x, y, str, 'HorizontalAlignment', 'center', ...
        'FontName', 'Impact', hp{:}, varargin{:});
    s.g.clear = tx(0, 0, 'CLEAR!', 'FontSize', 22);

    % HUD: big stopwatch and current membrane mode
    s.g.clock = tx(s.W/2, 572, '', 'Color', 'w', 'FontSize', 30);
    s.g.mode = text(ax, 16, 580, '', 'Color', [0.6 0.7 0.8], 'FontSize', 11, ...
        'FontName', 'FixedWidth', hp{:});

    % Title / game-over card
    s.g.panel = patch(ax, [150 650 650 150], [120 120 470 470], [0.02 0.03 0.07], ...
        'EdgeColor', [1 0.55 0.1], 'LineWidth', 2, hp{:});
    big = {'FontSize', 48};
    s.g.sh1 = tx(403, 417, '', 'Color', 'k', big{:});
    s.g.t1 = tx(400, 420, '', 'Color', [1 0.55 0.1], big{:});
    s.g.t2 = tx(400, 378, '', 'Color', 'w', 'FontSize', 16, 'FontAngle', 'italic', ...
        'FontName', 'Georgia');
    s.g.sh3 = tx(403, 333, '', 'Color', 'k', big{:});
    s.g.t3 = tx(400, 336, '', 'Color', [0.3 0.65 1], big{:});
    s.g.t4 = tx(400, 245, '', 'Color', [0.85 0.9 1], 'FontSize', 16, 'FontName', 'Helvetica');
    s.g.t5 = tx(400, 160, '', 'Color', 'w', 'FontSize', 20);

    s.best = 0;
    s.clk = 0;
    s = resetRound(s);
    s.started = false;
end

function s = shape(s)
    % Blend into the next membrane mode during the first 2s of each level
    i = floor(s.t/10);
    K = numel(s.ord);
    a = min(1, (s.t - 10*i)/2 + (i == 0));
    mk = [mod(i - 1, K) + 1, mod(i, K) + 1, a];
    if isequal(mk, s.mk), return, end
    s.mk = mk;
    L = (1 - a)*s.L(:,:,mk(1)) + a*s.L(:,:,mk(2));
    P = s.T*[s.XY; 1.78*L(:)'; ones(1, 81^2)];
    s.sy = rescale(P(2,:), s.floorY, s.floorY + 500);
    s.sz = P(3,:)*100 - 400;
    s.cy = smoothdata(movmax(accumarray(s.ci, s.sy', [], @max)', 3), 'gaussian', 5);
end

function y = ceilY(s, x)
    % Ceiling height from the logo silhouette table
    y = interp1(s.cx, s.cy, x);
end

function s = resetRound(s)
    s.px = s.W/2;
    s.dir = 1;
    [s.bx, s.by, s.vx, s.vy] = deal(zeros(1, s.N));
    s.on = false(1, s.N);   % ball active
    s.t = 0;
    s.spawnT = 1;
    s.picks = 0;
    s.pkOn = false;
    s.pkX = 0;
    s.pkT = 2;
    [s.spT, s.fxT, s.spX, s.spY, s.fxX, s.fxY] = deal(0);
    s.newBest = false;
    s.started = true;
    s.gameOver = false;
    s = shape(s);
end

function s = updateState(s, dt, pressed)
    s.clk = s.clk + dt;
    if s.gameOver
        if pressed, s = resetRound(s); end
        return
    end
    if ~s.started
        if pressed, s.started = true; end
        return
    end
    s.t = s.t + dt;
    s = shape(s);
    s.spT = max(0, s.spT - dt);
    s.fxT = max(0, s.fxT - dt);

    % Player: constant slide, tap reverses, walls bounce
    if pressed, s.dir = -s.dir; end
    s.px = s.px + s.dir*s.pSpeed*dt;
    half = s.pw/2;
    if s.px < half, s.px = half; s.dir = 1; end
    if s.px > s.W - half, s.px = s.W - half; s.dir = -1; end

    % Spawn a ball at the ceiling's peak
    s.spawnT = s.spawnT - dt;
    k = find(~s.on, 1);
    if s.spawnT <= 0 && ~isempty(k)
        spd = 260*(1 + s.t/90);
        [c, i] = max(s.cy);
        s.on(k) = true;
        s.bx(k) = s.cx(i);
        s.by(k) = c - s.r - 2;
        s.vx(k) = spd*(0.3 + 0.5*rand)*sign(rand - 0.5);
        s.vy(k) = -sqrt(spd^2 - s.vx(k)^2);
        s.spawnT = max(1.5, 4.5 - s.t/15);
        [s.spT, s.spX, s.spY] = deal(0.4, s.bx(k), s.by(k));
    end

    % Move balls
    r = s.r;
    for k = find(s.on)
        x = s.bx(k) + s.vx(k)*dt;
        y = s.by(k) + s.vy(k)*dt;
        vx = s.vx(k);
        vy = s.vy(k);
        if x < r, x = r; vx = abs(vx); end
        if x > s.W - r, x = s.W - r; vx = -abs(vx); end
        if y < s.floorY + r, y = s.floorY + r; vy = abs(vy); end
        c = ceilY(s, x);
        if y + r > c
            sl = (ceilY(s, x + 1) - ceilY(s, x - 1))/2;
            n = [-sl 1]/hypot(sl, 1);
            vn = vx*n(1) + vy*n(2);
            if vn > 0
                vx = vx - 2*vn*n(1);
                vy = vy - 2*vn*n(2);
            end
            y = c - r;
        end
        if abs(vy) < 110
            vy = 110*(2*(vy >= 0) - 1);
        end
        % Hit test against the player box
        qx = min(max(x, s.px - half), s.px + half);
        qy = min(max(y, s.floorY), s.floorY + s.ph);
        if (x - qx)^2 + (y - qy)^2 < r^2
            s.gameOver = true;
            s.newBest = s.t > s.best;
            s.best = max(s.best, s.t);
        end
        s.bx(k) = x;
        s.by(k) = y;
        s.vx(k) = vx;
        s.vy(k) = vy;
    end

    % Pickups: rare, short-lived, behind you, only once the room is busy.
    % Grab one to clear the lowest ball.
    s.pkT = s.pkT - dt;
    live = find(s.on);
    if s.pkOn
        if abs(s.px - s.pkX) < half + 9
            s.picks = s.picks + 1;
            s.pkOn = false;
            s.pkT = 8;
            [~, j] = min(s.by(live));
            j = live(j);
            s.on(j) = false;
            [s.fxT, s.fxX, s.fxY] = deal(0.6, s.bx(j), s.by(j));
        elseif s.pkT <= 0
            s.pkOn = false;
            s.pkT = 8;
        end
    elseif s.pkT <= 0 && numel(live) >= 3
        s.pkOn = true;
        d = s.dir*(150 + 200*rand);
        s.pkX = s.px - d;
        if s.pkX < 40 || s.pkX > s.W - 40, s.pkX = s.px + d; end
        s.pkT = 3;
    end
end

function renderFrame(~, s)
    g = s.g;
    if ~isequal(g.surf.UserData, s.mk)
        g.surf.YData = reshape(s.sy, 81, 81);
        g.surf.ZData = reshape(s.sz, 81, 81);
        g.surf.UserData = s.mk;
        g.ceil.YData = s.cy;
        g.room.YData = [s.cy(1) s.floorY s.floorY s.cy(end)];
    end
    r = s.r;
    for k = 1:s.N
        g.balls(k).Visible = s.on(k);
        if s.on(k)
            g.balls(k).Position = [s.bx(k) - r, s.by(k) - r, 2*r, 2*r];
        end
    end
    g.player.Position = [s.px - s.pw/2, s.floorY, s.pw, s.ph];
    g.pick.Visible = s.pkOn;
    g.pick.Position = [s.pkX - 9, s.floorY + 2, 18, 18];

    % Effects fade from their color to the background
    bg = [0.03 0.04 0.08];
    k = s.spT/0.4;
    q = r + 50*k;
    g.spawn.Visible = k > 0;
    g.spawn.Position = [s.spX - q, s.spY - q, 2*q, 2*q];
    g.spawn.EdgeColor = bg + ([0.3 0.65 1] - bg)*(1 - k);
    k = s.fxT/0.6;
    q = r + 90*(1 - k);
    c = bg + ([1 0.85 0.2] - bg)*k;
    g.burst.Visible = k > 0;
    g.burst.Position = [s.fxX - q, s.fxY - q, 2*q, 2*q];
    g.burst.EdgeColor = c;
    g.clear.Visible = k > 0;
    g.clear.Position = [s.fxX, s.fxY + 30 + 50*(1 - k)];
    g.clear.Color = c;

    % HUD
    g.clock.String = sprintf('%.1f', s.t);
    g.mode.String = sprintf('membrane(%d)', s.ord(s.mk(2)));

    % Title / game-over card
    blink = mod(s.clk, 1) < 0.65;
    card = ~s.started || s.gameOver;
    if ~s.started
        str = {'INSANE', 'in the', 'MEMBRANE', ...
            {'TAP  to reverse direction', 'Dodge the bouncing balls', ...
            'Grab the gold orb to clear a ball', 'Survive as long as you can'}, 'TAP TO START'};
    else
        b = sprintf('Best  %.1f s', s.best);
        if s.newBest, b = 'NEW BEST!'; end
        str = {'GAME OVER', 'you survived', sprintf('%.1f s', s.t), b, 'TAP TO RETRY'};
    end
    g.panel.Visible = card;
    g.clock.Visible = ~card;
    h = [g.t1 g.t2 g.t3 g.t4 g.t5 g.sh1 g.sh3];
    set(h, 'Visible', card);
    set(h, {'String'}, [str str([1 3])]');
    g.t5.Visible = card && blink;
end
Play Game
Preview

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