Snake bite

Jitin Beri
/
Snake bite
on 4 Nov 2026
1
22
10
0
9987
game.m
function g = game()
% Throughout, s is the game state struct (it flows init -> update -> render).
%game One-button snake with two modes.
%
%   Start screen auto-cycles between CLASSIC and OBSTACLES every 1.6 s.
%   Press to lock in the highlighted mode. In-game, the snake moves
%   forward on its own and each press rotates heading 90° clockwise
%   (the head lights up while a turn is queued).
%   CLASSIC or OBSTACLES (10 rocks, double points). 3 stages of 10, 15, 20 bites:
%   a bite scores the stage number (x2 in OBSTACLES); clear stage 3 to win.
%   Each new stage puts the snake back to its 4-cell start and pauses 2 s;
%   in OBSTACLES stage 2 adds 2 rocks and stage 3 adds 3 (10, 12, 15).
%   Food is a ladybug. A red bonus apple is on the board at the start and
%   returns 12 s of play after the last one is gone; once out it lasts 6 s:
%   5 x stage points (x2 in OBSTACLES: 5/10/15 or 10/20/30), and the snake moves 40% slower
%   for 4 s. It blinks in its last 1.5 s.
%   One best score is kept across both modes for the session.

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

function s = initState(ax)
c = 20;   % 40 x 30 grid of 20 px cells (800x600 world)
ax.XLim = [0 800]; ax.YLim = [0 600]; ax.YDir = 'reverse';

ho = {'HitTest','off','PickableParts','none'};

% Checkerboard grass: one patch, one face per cell
[X,Y] = meshgrid(0:40-1, 0:30-1); x = X(:)'*c; y = Y(:)'*c;
patch(ax, [x; x+c; x+c; x], [y; y; y+c; y+c], 'g', 'FaceColor', 'flat', ...
    'FaceVertexCData', [.13 .5 .2] + .09*mod(X(:)+Y(:),2), 'EdgeColor', 'none', ho{:});

% Rocks, ladybug (shell, head, spots + line for split/antennae), bonus apple, eat sparks
g.obstacles = scatter(ax, NaN, NaN, 200, [.3 .18 .08], 's', 'filled', 'MarkerEdgeColor', [.12 .06 .02], ho{:});
s.obstacles = zeros(15, 2);   % 10 rocks, +2 at stage 2, +3 at stage 3
g.apple = scatter(ax, NaN(1,6), NaN(1,6), 1, [1 .85 .1; zeros(5,3)], 'filled', ho{:});
g.bug = line(ax, 0, 0, 'Color', 'k', 'LineWidth', 1.5, ho{:});
g.gold = scatter(ax, NaN(1,4), NaN(1,4), 1, 'y', 'filled', ho{:});
g.burst = scatter(ax, NaN(1,8), NaN(1,8), 70, [1 .95 .4], 'filled', ho{:});

% Snake: whole body is one scatter (tapering, head-to-tail colour gradient),
% head is a triangle patch with eyes and a flicking tongue
g.body = scatter(ax, NaN, NaN, 1, 'r', 'filled', ho{:});
g.head = patch(ax, [0 0 0], [0 0 0], 'r', 'EdgeColor', 'none', ho{:});
g.eyes = scatter(ax, [0 0], [0 0], 26, 'w', 'filled', 'MarkerEdgeColor', 'k', ho{:});
g.tongue = line(ax, [0 0], [0 0], 'Color', [1 .2 .5], 'LineWidth', 4, ho{:});

% HUD, dark panel, title, mode picker, hint line
tp = {'HorizontalAlignment', 'center', 'FontWeight', 'bold', ho{:}};
g.score = text(ax, 14, 22, '', 'Color', [.9 .9 .95], 'FontSize', 14, 'FontWeight', 'bold', ho{:});
g.panel = rectangle(ax, 'Position', [180 110 440 380], 'Curvature', .1, ...
    'FaceColor', [.05 .12 .05], 'EdgeColor', [1 .85 .35], 'LineWidth', 4, ho{:});
g.msg = text(ax, 400, 150, '', 'Color', 'w', 'FontSize', 30, tp{:});
g.mC   = text(ax, 400, 220, '', 'FontSize', 20, tp{:});
g.mO = text(ax, 400, 265, '', 'FontSize', 20, tp{:});
g.sub = text(ax, 400, 400, '', 'Color', [.7 .8 .7], 'FontSize', 14, tp{:});

s.g = g;               % graphics handles
s.mode = 1;            % 1 = classic, 2 = obstacles
s.best = 0;            % best score across both modes
s = resetRound(s);
end

function s = resetRound(s)
% Reset numeric/game s; return to title screen. Preserves graphics.
[s.started, s.gameOver, s.won, s.turnQ] = deal(false);
[s.score, s.pauseT, s.stepAcc, s.selT, s.tongueT, s.bites, s.nRock, s.slowT] = deal(0);
[s.gold, s.apple, s.burstAt] = deal([-9 -9]);
s.stepTime = .13; s.burstT = 9; s.burstC = [1 .95 .4];
s.body = zeros(300, 2);   % snake can grow to 300 cells
s = toStart(s);
% Ladybug and bonus apple are out from the start (the apple's 6 s only run
% during play), both kept clear of the title panel (cells ~8-31 x 4-25) so
% they're visible on the title screen
s.apple = clearCell(s); s.gold = clearCell(s); s.goldT = 6; s.nextT = 12;
end

function s = toStart(s)
% Snake back to its 4-cell start in the middle row, heading right.
s.len = 4; s.dir = [1 0]; s.body(1:4,:) = [(20:-1:17)' 15*ones(4,1)];
end

function s = startRound(s)
% Called when the user commits to a mode. Lay out rocks around the food.
s.started = true;
if s.mode == 2, s = placeObstacles(s); end
end

function s = placeObstacles(s)
% Spread rocks with a 5-cell min spacing so none clump together, and keep
% the whole start row ahead of (and just behind) the snake clear, and
% never cover the ladybug or the bonus apple.
s.nRock = 10;
p = 0;
while p < 10
    c = randi(40)-1; r = randi(30)-1;
    if r == 15 && c >= 14 || any(all([s.apple; s.gold] == [c r], 2)), continue, end
    if any(max(abs(s.obstacles(1:p,1)-c), abs(s.obstacles(1:p,2)-r)) < 5), continue, end
    p = p + 1; s.obstacles(p,:) = [c r];
end
end

function a = clearCell(s)
% A free cell that is not under the title panel (cells ~8-31 x 4-25).
a = freeCell(s);
while all(abs(a-[19.5 14.5]) < [13 11]), a = freeCell(s); end
end

function a = freeCell(s)
% A random empty cell: not on the snake, rocks, ladybug or bonus apple, and
% not in the top 2 rows (under the HUD text).
a = s.gold;   % start on a taken cell so the loop always draws at least once
while a(2) < 2 || any(all([s.body(1:s.len,:); s.obstacles(1:s.nRock,:); s.apple; s.gold] == a, 2))
    a = [randi(40) randi(30)] - 1;
end
end

function s = updateState(s, dt, pressed)
s.burstT = s.burstT + dt;
s.best = max(s.best, s.score);   % best across both modes
if s.gameOver || ~s.started
    % Title + game-over both show the mode selector; cycle it and let
    % a press commit the highlighted mode.
    s.selT = s.selT + dt;
    if s.selT >= 1.6   % 1.6 s per toggle
        s.selT = s.selT - 1.6;
        s.mode = 3 - s.mode;
    end
    if pressed
        if s.gameOver
            m = s.mode; s = resetRound(s); s.mode = m;
        end
        s = startRound(s);
    end
    return
end

% Queue one turn per step — forgives multi-press bursts and prevents
% instant 180° reversal from two presses in a row.
s.turnQ = s.turnQ || pressed;

% Short pause after clearing a stage (taps and the bonus timer wait too)
if s.pauseT > 0, s.pauseT = s.pauseT - dt; s.turnQ = false; return, end

s.tongueT = s.tongueT + dt;
s.goldT = max(0, s.goldT - dt); s.slowT = max(0, s.slowT - dt);
% next bonus apple: 12 s of play after the last one is eaten or expires
s.nextT = s.nextT - dt*(s.goldT == 0);
if s.nextT <= 0, s.gold = freeCell(s); s.goldT = 6; s.nextT = 12; end
% step time, 1/0.6 longer (40% slower) while the bonus slow-down runs
e = s.stepTime/(1 - .4*(s.slowT > 0));
s.stepAcc = s.stepAcc + dt;
while s.stepAcc >= e && ~s.gameOver
    s.stepAcc = s.stepAcc - e;
    if s.turnQ
        % 90° clockwise in screen coords (YDir reversed): [dx,dy] -> [-dy, dx]
        s.dir = [-s.dir(2), s.dir(1)];
        s.turnQ = false;
    end
    newHead = s.body(1,:) + s.dir;
    ate = all(newHead == s.apple);
    ateGold = s.goldT > 0 && all(newHead == s.gold);
    newLen = s.len + (ate || ateGold)*(s.len < 300);
    % Walls, rocks, or body cells that remain after the shift end the round
    s.gameOver = any(newHead < 0 | newHead >= [40 30]) || ...
        any(all([s.obstacles(1:s.nRock,:); s.body(1:newLen-1,:)] == newHead, 2));
    if s.gameOver, return, end
    s.body(2:newLen,:) = s.body(1:newLen-1,:);
    s.body(1,:) = newHead;
    s.len = newLen;
    % sparks: yellow for the ladybug, red for the bonus apple
    if ate || ateGold, s.burstAt = newHead; s.burstT = 0; s.burstC = [1 .95 .4] - [0 .65 .1]*ateGold; end
    if ateGold
        s.score = s.score + 5*(1 + (s.bites>=10) + (s.bites>=25))*(1 + (s.mode==2));   % 5 x stage, x2 in OBSTACLES
        s.goldT = 0; s.gold = [-9 -9]; s.slowT = 4;
    end
    if ate
        s.score = s.score + (1 + (s.bites>=10) + (s.bites>=25))*(1 + (s.mode==2));   % stage number, x2 in OBSTACLES
        s.stepTime = max(.055, s.stepTime * .97);
        s.apple = freeCell(s);
        s.bites = s.bites + 1;
        % stages need 10, 15, 20 bites (new stage at bite 10 and 25): each new
        % stage restarts the snake after a pause; the 45th bite wins
        if any(s.bites == [10 25])
            s = toStart(s); s.pauseT = 2;
            % OBSTACLES: stage 2 adds 2 rocks, stage 3 adds 3 (off the start row, snake and food)
            for k = 1:(2 + (s.bites == 25))*(s.mode == 2)
                a = [0 15]; while a(2) == 15, a = freeCell(s); end
                s.nRock = s.nRock + 1; s.obstacles(s.nRock,:) = a;
            end
        end
        if s.bites >= 45
            s.gameOver = true; s.won = true;
        end
    end
end
end

function renderFrame(~, s)
g = s.g;   % graphics handles
c = 20; n = s.len;
play = s.started && ~s.gameOver;
B = s.body(1:n,:)*c + c/2;   % cell centres in pixels

% Body: segments 2..len taper toward the tail, red at the neck to orange at the tail
k = (2:n)'; t = k/n;
set(g.body, 'XData', B(k,1), 'YData', B(k,2), ...
    'SizeData', (16*(1-.4*t)).^2*2.2, 'CData', [1+0*t, .15+.8*t, .5-.4*t]);

% Head: triangle pointing along dir (brighter while a turn is queued),
% two eyes set back from the tip, tongue flicks out once a second
dx = s.dir(1); dy = s.dir(2); hf = (c+8)/2;
T = B(1,:) + hf*[dx dy; -dx-dy dx-dy; dy-dx -dx-dy];   % tip, then the two back corners
set(g.head, 'XData', T(:,1), 'YData', T(:,2), 'FaceColor', [1 .1 .5] + [0 .8 .5]*s.turnQ);
set(g.eyes, 'XData', B(1,1) - dx*2 + [-dy dy]*4, 'YData', B(1,2) - dy*2 + [dx -dx]*4);
set(g.tongue, 'XData', T(1,1) + [0 dx*8], 'YData', T(1,2) + [0 dy*8], 'Visible', play && mod(s.tongueT, 1) < .15);

% Rocks
o = s.obstacles(1:s.nRock,:);
set(g.obstacles, 'XData', [o(:,1)*c+c/2; NaN], 'YData', [o(:,2)*c+c/2; NaN]);

% Ladybug (gently pulsing): yellow shell, black head and 4 spots; one black
% line draws the split down the shell and the two antennae
A = s.apple*c + c/2;
set(g.apple, 'XData', A(1) + [0 0 -5 5 -5 5], 'YData', A(2) + [2 -10 -1 -1 7 7], 'SizeData', [300 80 22 22 22 22]*(1+.25*sin(8*s.tongueT)));
set(g.bug, 'XData', A(1) + [0 0 NaN -2 -7 NaN 2 7], 'YData', A(2) + [-5 12 NaN -12 -19 NaN -12 -19]);

% Bonus apple: two red lobes + brown stem + green leaf; pulses, blinks in its last 1.5 s
P = s.gold*c + c/2;
v = s.goldT > 0 && (s.goldT > 1.5 || mod(floor(s.goldT*8), 2));
set(g.gold, 'XData', P(1) + [-5 5 1 9] + 0./v, 'YData', P(2) + [2 2 -13 -16], ...
    'SizeData', [440 440 50 120]*(1+.25*sin(10*s.tongueT)), 'CData', [.9 .1 .15; .9 .1 .15; .45 .25 .1; .2 .7 .2]);

% Eat sparks: 8 dots fly out from the bite for 0.4 s (red after a bonus apple)
r = 10 + 170*s.burstT; an = (0:7)*pi/4; b = s.burstT < .4;
P = s.burstAt*c + c/2;
set(g.burst, 'XData', P(1) + r*cos(an) + 0./b, 'YData', P(2) + r*sin(an), 'CData', s.burstC);

% HUD
ml = {'CLASSIC','OBSTACLES'}; q = [0 10 25 45]; st = 1 + (s.bites>=10) + (s.bites>=25);   % stage starts at bite 0, 10, 25
g.score.String = sprintf('%d [%s] Stage %d: %d/%d   Best: %d%s%s', s.score, ml{s.mode}, st, s.bites-q(st), q(st+1)-q(st), s.best, ...
    repmat(sprintf('   BONUS APPLE: %ds', ceil(s.goldT)), 1, play && s.goldT > 0), repmat(sprintf('   SLOW: %ds', ceil(s.slowT)), 1, play && s.slowT > 0));

if play
    set([g.panel g.mC g.mO g.sub], 'Visible', 'off');
    % stage banner during the 2 s pause: stage number, points per bite, rock count
    set(g.msg, 'String', sprintf('STAGE %d — GET READY!\n%d pts per bite%s', st, st*(1+(s.mode==2)), ...
        repmat(sprintf(' · %d rocks', s.nRock), 1, s.mode==2)), 'Color', [1 .85 .35], 'Visible', s.pauseT > 0);
else
    g.msg.Color = 'w';
    % title and end screens share the same details: the title adds Best at the
    % bottom, end screens put Score and Best together on top
    d = sprintf('Tap: pick mode, then turn right\n3 stages: 10, 15, 20 bites\nBonus apple: points + slow-mo');
    g.msg.String = 'ONE-BUTTON SNAKE'; sb = sprintf('%s\nBest: %d', d, s.best);
    if s.gameOver
        g.msg.String = 'GAME OVER'; if s.won, g.msg.String = 'YOU WIN!'; end
        sb = sprintf('Score: %d   Best: %d\n%s', s.score, s.best, d);
    end
    set([g.panel g.msg], 'Visible', 'on'); showModePicker(s, sb);
end
end

function showModePicker(s, subText)
g = s.g;
% Highlight the selected mode in gold with a '>' marker; the other is grey.
h = [g.mC g.mO]; on = (1:2) == s.mode;
set([h g.sub], 'Visible', 'on'); g.sub.String = subText;
set(h(on), 'Color', [1 .85 .35]); set(h(~on), 'Color', [.45 .5 .6]);
nm = {'CLASSIC', 'OBSTACLES (x2)'};
for i = 1:2, h(i).String = [repmat('> ', 1, on(i)) nm{i}]; end
end
Play Game
Preview

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