Tetr-ish

Claudia
/
Tetr-ish
on 3 Nov 2026
1
27
12
1
7718
game.m
function g = game()
%game Tetr-ish: one-button falling blocks.
%   The falling piece sweeps left and right on its own, turning 90
%   degrees every second bounce. Tap SPACE (or click) to
%   hard-drop it. Clear lines to score; the sweep and gravity speed up
%   every 10 lines.

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

function state = initState(ax)
state.W  = 10;
state.H  = 20;
state.cs = 26;                         % cell size in world units
state.x0 = 270;                        % board top-left corner
state.y0 = 40;
state.px = 6;                          % pixels per cell in the image

% Long line, square, rectangle, short line
state.shapes = {ones(1, 4), ones(2), ones(2, 3), ones(1, 2)};
state.nShapes = numel(state.shapes);
cols = [0.20 0.85 0.95; 0.98 0.85 0.20; 0.70 0.35 0.95; 0.35 0.90 0.40];
empty = [0.07 0.08 0.13];
state.pal = [empty; cols; 0.35*cols + 0.65*empty];

% Bevel mask so each cell looks like a tile
p = state.px;
m = ones(p);
m(:, end) = 0.6; m(end, :) = 0.6;
m(1, 1:end-1) = 1.3; m(1:end-1, 1) = 1.3;
state.mask = m;

ax.YDir  = 'reverse';
ax.Color = [0.04 0.05 0.09];
hit = {'HitTest', 'off', 'PickableParts', 'none'};

x0 = state.x0; y0 = state.y0; cs = state.cs;
bw = state.W*cs; bh = state.H*cs;
% In-game HUD (hidden on the start screen)
border = rectangle(ax, 'Position', [x0-4 y0-4 bw+8 bh+8], 'EdgeColor', [0.5 0.6 0.9], ...
    'LineWidth', 2, 'FaceColor', 'none', hit{:});
state.g.board = image(ax, 'XData', [x0+cs/2, x0+bw-cs/2], ...
    'YData', [y0+cs/2, y0+bh-cs/2], 'CData', zeros(state.H*p, state.W*p, 3), hit{:});

nx = x0 + bw + 40;
nextLbl = text(ax, nx, y0+10, 'NEXT', 'Color', [0.7 0.75 0.9], 'FontSize', 14, ...
    'FontWeight', 'bold', hit{:});
nextBox = rectangle(ax, 'Position', [nx-4 y0+28 4*cs+8 4*cs+8], 'EdgeColor', [0.3 0.35 0.5], ...
    'FaceColor', empty, hit{:});
state.g.next = image(ax, 'XData', [nx+cs/2, nx+4*cs-cs/2], ...
    'YData', [y0+32+cs/2, y0+32+4*cs-cs/2], 'CData', zeros(4*p, 4*p, 3), hit{:});

state.g.score = text(ax, 135, y0+50, '', 'Color', [0.95 0.85 0.3], 'FontSize', 40, ...
    'FontWeight', 'bold', 'HorizontalAlignment', 'center', hit{:});
state.g.stats = text(ax, 135, y0+95, '', 'Color', [0.6 0.65 0.8], 'FontSize', 13, ...
    'HorizontalAlignment', 'center', hit{:});
state.g.msg = text(ax, x0+bw/2, y0+bh/2, '', 'Color', 'w', 'FontSize', 22, ...
    'FontWeight', 'bold', 'HorizontalAlignment', 'center', ...
    'BackgroundColor', [0 0 0 0.6], 'Margin', 10, hit{:});
state.g.hud = [border, state.g.board, nextLbl, nextBox, state.g.next, ...
    state.g.score, state.g.stats];

% Start screen
state.g.splash = [ ...
    text(ax, 400, 250, 'TETR-ISH', 'Color', [0.95 0.85 0.3], 'FontSize', 64, ...
        'FontWeight', 'bold', 'HorizontalAlignment', 'center', hit{:}), ...
    text(ax, 400, 325, 'Blocks swing. You drop.', 'Color', [0.6 0.65 0.8], ...
        'FontSize', 18, 'HorizontalAlignment', 'center', hit{:}), ...
    text(ax, 400, 420, 'Tap to start', 'Color', 'w', 'FontSize', 20, ...
        'HorizontalAlignment', 'center', hit{:})];
state.t = 0;

state.started = false;
state = resetRound(state);
end

function state = resetRound(state)
state.board    = zeros(state.H, state.W);
state.score    = 0;
state.lines    = 0;
state.level    = 1;
state.gameOver = false;
state.flash    = 0;
state.nextId   = randi(state.nShapes);
state = spawn(state);
end

function state = spawn(state)
state.id   = state.nextId;
state.nextId = randi(state.nShapes);
state.mat  = state.shapes{state.id};
state.r    = 1;
state.c    = floor((state.W - size(state.mat, 2))/2) + 1;
state.dir  = 2*randi(2) - 3;
state.sweepAcc = 0;
state.fallAcc  = 0;
state.bounces  = 0;
if ~fits(state, state.mat, state.r, state.c)
    state.gameOver = true;
end
end

function ok = fits(state, m, r, c)
[i, j] = find(m);
rr = r + i - 1; cc = c + j - 1;
ok = all(rr >= 1 & rr <= state.H & cc >= 1 & cc <= state.W);
if ok
    ok = ~any(state.board(sub2ind(size(state.board), rr, cc)));
end
end

function state = lockPiece(state)
[i, j] = find(state.mat);
idx = sub2ind(size(state.board), state.r + i - 1, state.c + j - 1);
state.board(idx) = state.id;
full = all(state.board > 0, 2);
n = sum(full);
if n > 0
    state.board = [zeros(n, state.W); state.board(~full, :)];
    state.lines = state.lines + n;
    state.score = state.score + [100 300 500 800]*(1:4 == n)' * state.level;
    state.level = floor(state.lines/10) + 1;
    state.flash = 0.25;
end
state = spawn(state);
end

function r = dropRow(state)
r = state.r;
while fits(state, state.mat, r + 1, state.c)
    r = r + 1;
end
end

function state = updateState(state, dt, pressed)
state.flash = max(0, state.flash - dt);
state.t = state.t + dt;
if ~state.started
    state.started = pressed;
    return
end
if state.gameOver
    if pressed, state = resetRound(state); end
    return
end
if pressed
    state.score = state.score + 2*(dropRow(state) - state.r);
    state.r = dropRow(state);
    state = lockPiece(state);
    return
end

lv = state.level - 1;
sweepT = max(0.08, 0.28 - 0.015*lv);
fallT  = max(0.20, 1.40 - 0.10*lv);

state.sweepAcc = state.sweepAcc + dt;
while state.sweepAcc >= sweepT
    state.sweepAcc = state.sweepAcc - sweepT;
    if fits(state, state.mat, state.r, state.c + state.dir)
        state.c = state.c + state.dir;
    else
        % Turn 90 degrees once per full back-and-forth trip, nudging
        % sideways off the wall if needed
        state.bounces = state.bounces + 1;
        if mod(state.bounces, 2) == 0
            rot = rot90(state.mat, -1);
            for k = [0 -1 1 -2 2 -3 3]
                if fits(state, rot, state.r, state.c + k)
                    state.mat = rot;
                    state.c = state.c + k;
                    break
                end
            end
        end
        state.dir = -state.dir;
    end
end

state.fallAcc = state.fallAcc + dt;
if state.fallAcc >= fallT
    state.fallAcc = state.fallAcc - fallT;
    if fits(state, state.mat, state.r + 1, state.c)
        state.r = state.r + 1;
    else
        state = lockPiece(state);
    end
end
end

function renderFrame(~, state)
idx = state.board;
if state.started && ~state.gameOver
    [i, j] = find(state.mat);
    gr = dropRow(state);
    idx(sub2ind(size(idx), gr + i - 1, state.c + j - 1)) = state.id + state.nShapes;
    idx(sub2ind(size(idx), state.r + i - 1, state.c + j - 1)) = state.id;
end
state.g.board.CData = toImage(state, idx);

nm = state.shapes{state.nextId};
n = zeros(4);
o = floor((4 - size(nm)) / 2);
n(o(1) + (1:size(nm, 1)), o(2) + (1:size(nm, 2))) = nm * state.nextId;
state.g.next.CData = toImage(state, n);

state.g.score.String = sprintf('%d', state.score);
state.g.stats.String = sprintf('LINES %d  ·  LEVEL %d', state.lines, state.level);
state.g.score.Color = min(1, [0.95 0.85 0.3] + state.flash*[0.2 0.6 2.8]);

onOff = {'off', 'on'};
set(state.g.hud, 'Visible', onOff{state.started + 1});
set(state.g.splash, 'Visible', onOff{~state.started + 1});
state.g.splash(3).Color = [1 1 1] * (0.55 + 0.45*abs(cos(2.5*state.t)));

if ~state.started
    state.g.msg.Visible = 'off';
elseif state.gameOver
    state.g.msg.String = {'GAME OVER', sprintf('Score %d', state.score), '', 'Tap to restart'};
    state.g.msg.Visible = 'on';
else
    state.g.msg.Visible = 'off';
end
end

function img = toImage(state, idx)
[h, w] = size(idx);
c = reshape(state.pal(idx(:) + 1, :), h, w, 3);
img = min(1, repelem(c, state.px, state.px) .* repmat(state.mask, h, w));
end
Play Game
Preview

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