Singletris

Ned Gulley
/
Singletris
about 10 hours ago
2
8
4
0
8712
game.m
function g = game()
%game Singletris: drop single blocks and keep the tower standing.
%
%   A block slides back and forth above the tower. Tap to drop it. It
%   falls straight down and lands on the first thing it touches. If the
%   stack can still carry every block's weight, it stays and a new block
%   appears. If not, the stack tips over and the game is over.
%
%   Physics works in block units (one block = 1 x 1). Blocks sit in
%   integer rows on a pedestal 3 blocks wide centered at x = 10.

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

function s = initState(ax)
ax.YDir = 'normal';
ax.XLim = [0 800];
ax.YLim = [0 600];
ax.Color = [0.06 0.07 0.12];
s.y0 = 1.5;                    % top of the pedestal
s.best = 0;
np = {'HitTest','off','PickableParts','none'};
s.g.tf = hgtransform(ax, np{:});     % world (blocks) -> screen (px)
s.g.tl = hgtransform(ax, np{:});     % same, but x stays in px (labels)

% Height markers every 5 rows.
k = 5:5:300;
x = repmat([-30 50 nan], 1, numel(k));
y = kron(s.y0 + k, [1 1 1]);
line(s.g.tf, x, y, 'Color', [1 1 1 0.08], 'LineWidth', 1, np{:});
for v = k
    text(s.g.tl, 8, s.y0 + v + 0.35, num2str(v), 'Color', [1 1 1 0.3], ...
        'FontSize', 10, np{:});
end
patch(s.g.tf, 10 + 1.5*[-1 1 1 -1], [-80 -80 s.y0 s.y0], [0.3 0.33 0.43], ...
    'EdgeColor', [0.6 0.65 0.8], 'LineWidth', 1.5, np{:});
s.g.gd = patch(s.g.tf, nan, nan, 'w', 'FaceAlpha', 0.07, 'EdgeColor', 'none', np{:});
s.g.bk = patch(s.g.tf, 'Vertices', zeros(0, 2), 'Faces', zeros(0, 4), ...
    'FaceColor', 'flat', 'FaceVertexCData', zeros(0, 3), ...
    'EdgeColor', 'none', np{:});
txt = @(x, y, z, c) text(ax, x, y, '', 'Color', c, 'FontSize', z, ...
    'FontWeight', 'bold', 'HorizontalAlignment', 'center', np{:});
s.g.hud = txt(400, 580, 14, 'w');
s.g.ttl = txt(400, 400, 44, [0.3 0.9 1]);
s.g.msg = txt(400, 330, 18, 'w');
set([s.g.ttl s.g.msg], 'BackgroundColor', ax.Color, 'Margin', 8);
s = reset(s);
s.ph = 0;                      % 0 title, 1 aim, 2 drop, 3 tip, 4 game over
end

function s = reset(s)
s.P = zeros(0, 2);             % block centers
s.A = zeros(0, 1);             % block angles
s.R = zeros(0, 1);             % block rows
s.C = zeros(0, 3);             % block colors
s.V = zeros(0, 2);             % velocities (game over only)
s.W = zeros(0, 1);             % spin rates (game over only)
s.n = 0;
s.top = s.y0;
s.cam = 0;
s.z = 1;
s.t = 0;
s.ph = 1;
s.msg = '';
s = newBlock(s);
end

function s = newBlock(s)
pal = [0 0.9 0.95; 1 0.85 0.1; 0.7 0.35 1; 0.25 0.9 0.3; 1 0.3 0.3; 0.25 0.5 1; 1 0.6 0.1];
s.hc = pal(randi(7), :);
s.hx = 0.5 + 19*rand;
s.dir = 2*(rand < 0.5) - 1;
s.hy = s.top + 5;
s.v = min(13, 4 + 0.3*s.n);    % slide speed, blocks per second
s = aim(s);
end

function s = aim(s)
% Find where the sliding block would land: the highest block it overlaps,
% else the pedestal, else nowhere (lr = -inf).
X = s.P(:, 1);
j = abs(X - s.hx) < 1 - 1e-9;
if any(j)
    s.lr = max(s.R(j)) + 1;
elseif abs(s.hx - 10) < 2 - 1e-9
    s.lr = 0;
else
    s.lr = -inf;
end
s.ty = max(s.y0 + s.lr, -80);
end

function s = updateState(s, dt, pressed)
s.t = s.t + dt;
% Camera: zoom out to half size as the tower grows, then scroll.
need = s.top + 7.5;
zt = min(1, max(0.5, 15/need));
a = min(1, 3*dt);
s.z = s.z + (zt - s.z)*a;
s.cam = s.cam + (max(0, need - 15/zt) - s.cam)*a;

switch s.ph
    case {0, 1}
        s.hx = s.hx + s.dir*s.v*dt;
        if s.hx > 19.5 || s.hx < 0.5
            s.hx = min(max(s.hx, 0.5), 19.5);
            s.dir = -s.dir;
        end
        s = aim(s);
        if pressed
            s.ph = s.ph + 1;
        end
    case 2
        s.hy = s.hy - 15*dt;
        if s.hy - 0.5 <= s.ty
            s.hy = s.ty + 0.5;
            s = addBlock(s, s.lr);
            if stable(s)
                s.n = s.n + 1;
                s.best = max(s.best, s.n);
                s.top = max(s.top, s.hy + 0.5);
                s = newBlock(s);
                s.ph = 1;
            else
                [s.S, s.pv] = tipBody(s);
                s.P0 = s.P;
                s.th = 0;
                s.om = -0.4*sign(mean(s.P(s.S, 1)) - s.pv(1));
                s.ph = 3;
                s.t = 0;
                if isempty(s.S)
                    s = explode(s);
                end
            end
        elseif ~isfinite(s.lr) && s.hy < s.y0
            s = addBlock(s, -1);
            s.V(end, 2) = -15;
            s.F = false(size(s.R));
            s.F(end) = true;
            s.msg = 'Missed the tower!';
            s.ph = 4;
            s.t = 0;
        end
    case 3
        % The failing part turns as one rigid body about its support edge.
        S = s.S;
        Q = s.P0(S, :) - s.pv;
        I = sum(1/6 + sum(Q.^2, 2));
        c = cos(s.th);
        sn = sin(s.th);
        rx = c*Q(:, 1) - sn*Q(:, 2);
        s.om = s.om - 25*sum(rx)/I*dt;
        s.th = s.th + s.om*dt;
        c = cos(s.th);
        sn = sin(s.th);
        s.P(S, :) = s.pv + [c*Q(:, 1) - sn*Q(:, 2), sn*Q(:, 1) + c*Q(:, 2)];
        s.A(S) = s.th;
        if abs(s.th) > 1.1 || s.t > 2.5
            s = explode(s);
        end
    case 4
        F = s.F;
        s.V(F, 2) = s.V(F, 2) - 25*dt;
        s.P(F, :) = s.P(F, :) + s.V(F, :)*dt;
        s.A(F) = s.A(F) + s.W(F)*dt;
        if s.t > 1.2
            s.msg = sprintf('%s\nTap to play again', strtok(s.msg, newline));
            if pressed
                s = reset(s);
            end
        end
end
end

function s = addBlock(s, r)
s.P(end + 1, :) = [s.hx s.hy];
s.A(end + 1, 1) = 0;
s.R(end + 1, 1) = r;
s.C(end + 1, :) = s.hc;
s.V(end + 1, :) = 0;
s.W(end + 1, 1) = 0;
end

function s = explode(s)
n = numel(s.R);
s.F = true(n, 1);
X = s.P(:, 1);
s.V = [4*randn(n, 1) + 2*(X - mean(X)), 6 + 10*rand(n, 1)];
s.W = 6*randn(n, 1);
S = s.S;
Q = s.P(S, :) - s.pv;
s.V(S, :) = s.V(S, :) + s.om*[-Q(:, 2) Q(:, 1)];
s.W(S) = s.W(S) + s.om;
s.msg = sprintf('TOPPLED!  You stacked %d', s.n);
s.ph = 4;
s.t = 0;
end

function [I, J] = sup(X, R, i)
% Support intervals [lo hi] under block i, and the blocks giving them
% (0 = pedestal).
if R(i) == 0
    J = 0;
    I = [max(X(i) - 0.5, 8.5) min(X(i) + 0.5, 11.5)];
else
    J = find(R == R(i) - 1 & abs(X - X(i)) < 1 - 1e-9);
    I = [max(X(J), X(i)) - 0.5, min(X(J), X(i)) + 0.5];
end
end

function ok = stable(s)
% Static equilibrium: each contact carries two non-negative vertical
% forces at the ends of its overlap. The stack stands if some set of
% such forces balances the weight and torque of every block.
X = s.P(:, 1);
n = numel(X);
M = zeros(2*n, 0);
for i = 1:n
    [I, J] = sup(X, s.R, i);
    for k = 1:numel(J)
        for q = I(k, :)
            col = zeros(2*n, 1);
            col(2*i - [1 0]) = [1; q - X(i)];
            if J(k)
                col(2*J(k) - [1 0]) = -[1; q - X(J(k))];
            end
            M(:, end + 1) = col; %#ok<AGROW>
        end
    end
end
b = repmat([1; 0], n, 1);
f = lsqnonneg(M, b);
ok = norm(M*f - b) < 1e-6;
end

function [S, p] = tipBody(s)
% Lowest group of connected blocks whose center of mass lies outside its
% support, and the support edge it tips over.
X = s.P(:, 1);
R = s.R;
S = [];
p = [0 0];
for r = 0:max(R)
    k = find(R >= r);
    c = conncomp(graph(abs(R(k) - R(k)') == 1 & abs(X(k) - X(k)') < 1 - 1e-9));
    for m = 1:max(c)
        G = k(c == m);
        I = zeros(0, 2);
        for i = G(R(G) == r)'
            I = [I; sup(X, R, i)]; %#ok<AGROW>
        end
        cx = mean(X(G));
        if ~isempty(I) && (cx < min(I(:, 1)) - 1e-6 || cx > max(I(:, 2)) + 1e-6)
            S = G;
            p = [min(I(:, 1)) + (cx > max(I(:, 2)))*(max(I(:, 2)) - min(I(:, 1))), s.y0 + r];
            return
        end
    end
end
end

function V = sq(P, A, h)
ux = h*[-1 1 1 -1];
uy = h*[-1 -1 1 1];
c = cos(A);
sn = sin(A);
X = (P(:, 1) + c*ux - sn*uy)';
Y = (P(:, 2) + sn*ux + c*uy)';
V = [X(:) Y(:)];
end

function renderFrame(~, s)
z = s.z;
sh = 0;
if s.ph == 4 && s.n
    sh = 0.4*exp(-5*s.t)*sin(70*s.t);    % shake when it blows up
end
ty = -40*z*(s.cam + sh);
s.g.tf.Matrix = [40*z 0 0 400 - 400*z; 0 40*z 0 ty; 0 0 1 0; 0 0 0 1];
s.g.tl.Matrix = [1 0 0 0; 0 40*z 0 ty; 0 0 1 0; 0 0 0 1];
P = s.P;
A = s.A;
C = s.C;
if s.ph < 3
    P = [P; s.hx s.hy];
    A = [A; 0];
    C = [C; s.hc];
    s.g.gd.XData = s.hx + 0.5*[-1 1 1 -1];
    s.g.gd.YData = [s.ty s.ty s.hy - 0.5 s.hy - 0.5];
else
    s.g.gd.XData = nan;
end
n = size(P, 1);
set(s.g.bk, 'Faces', zeros(0, 4), 'Vertices', [sq(P, A, 0.5); sq(P, A, 0.44); sq(P, A, 0.28)], ...
    'Faces', reshape(1:12*n, 4, [])', 'FaceVertexCData', [0.3*C; 0.9*C; 0.5*C + 0.5]);
s.g.hud.String = sprintf('Blocks %d     Best %d', s.n, s.best);
s.g.ttl.String = repmat('SINGLETRIS', 1, s.ph == 0);
m = s.msg;
if s.ph == 0
    m = sprintf('Tap to drop a block.\nDon''t let the tower tip over.');
end
s.g.msg.String = m;
end
Play Game
Preview

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