Cricket chase

Vinay Ramesh
/
Cricket chase
on 4 Nov 2026
2
62
16
4
9936
game.m
function g = game()
%game Cricket -- chase 80 off 5 overs with 3 wickets, one button.
%
%   TAP (space/click) as the ring closes.
%   The closer your timing, the bigger the shot:
%     perfect        -> SIX (the crowd holds up 6 cards)
%     very good      -> FOUR
%     good           -> 1-3 runs (the batsmen run automatically)
%     off            -> DEFENDED (dot ball)
%     way off / none -> the ball carries on:
%                         at the stumps   -> BOWLED (the only dismissal)
%                         outside off     -> DOT BALL
%                         a real WIDE     -> +1 run, ball bowled again
%   It's all about timing the ball to its speed -- and never missing a
%   straight one.
%
%   The bowler changes every over: MEDIUM, FAST, SPIN (turns late) or
%   MYSTERY (quick, then slows). Three perfects in a row put you IN THE
%   ZONE (gold ring): double timing window for 3 balls. Balls get faster
%   and the window tighter as your score climbs.
%
%   Workflow:
%       >> minihackContest.validate
%       >> minihackContest.play
%       >> minihackContest.submit

g.init   = @initGame;
g.update = @step;
g.render = @draw;
end

% ---------------------------------------------------------------------
% The game is simulated on a top-down GROUND plane and drawn through a
% simple perspective camera behind the striker (see pj). Ground layout:
% boundary ellipse centred (400,330), radii 700x330; striker's stumps
% y=160, hitting zone (400,205), release point y=440.
%
% Phases S.ph (one function each, see step): 0 title, 1 run-up,
% 2 delivery, 3 boundary flight, 4 ground shot + running, 5 result
% pause, 6 game over.
%
% Other state: sc/wk runs & wickets, n LEGAL balls bowled before this
% one, wd this ball was a wide, ty bowler type, T ball travel time,
% off ball line at the crease (0 = at the stumps, |off|>50 = wide),
% win perfect window (s), z zone balls, str perfect streak, sw swung,
% b ball ground pos, h ball height, fp fielder positions, r runs for
% this shot, s run progress (in runs; 0.8 s per run).
function S = initGame(ax)
ax.Color = [0.13 0.2 0.4];   % twilight sky: a day-night match
hp = {'HitTest','off','PickableParts','none'};
e = [{'EdgeColor','none'} hp];   % no outline, clicks pass through

% floodlights: four towers (two near, two far), each a pole topped by a
% bright lamp bank; poles start behind the stands. P = [x, top y, scale]
P = [45 560 1.5; 755 560 1.5; 230 470 0.9; 570 470 0.9];
line(ax,[P(:,1) P(:,1)]',[0*P(:,1)+300 P(:,2)]','Color',[0.45 0.48 0.55], ...
    'LineWidth',3,hp{:});
scatter(ax,P(:,1),P(:,2),900*P(:,3).^2,[1 1 0.85],'s','filled',hp{:});
% stands packed with crowd
rectangle(ax,'Position',[0 288 800 150],'FaceColor',[0.3 0.3 0.38], ...
    e{:});
scatter(ax,800*rand(800,1),296 + 140*rand(800,1),30, ...
    rand(800,3),'filled',hp{:});
% outfield with mowing stripes across the ground (bands of ground y)
rectangle(ax,'Position',[0 0 800 300],'FaceColor',[0.36 0.66 0.23], ...
    e{:});
for b = 100:80:620
    [~,y] = pj(0, [b b+40], 0);
    rectangle(ax,'Position',[0 y(1) 800 diff(y)],'FaceColor',[0.42 0.73 0.28], ...
        e{:});
end
% advertising boards just outside the rope (coloured squares along it),
% boundary rope, dashed 30-yard circle -- far halves only (the near
% halves are behind the camera)
a = linspace(0,pi,100);
[x,y,k] = pj(400 + 715*cos(a), 330 + 345*sin(a), 0.05);
scatter(ax,x,y,400*k.^2,repmat([1 1 1; 0.1 0.3 0.8],50,1), ...
    's','filled',hp{:});
[x,y] = pj(400 + 700*cos(a), 330 + 330*sin(a), 0);
line(ax,x,y,'Color','w','LineWidth',2,hp{:});
[x,y] = pj(400 + 230*cos(a), 300 + 230*sin(a), 0);
line(ax,x,y,'Color','w','LineStyle','--',hp{:});
% pitch and creases
[x,y] = pj([380 420 420 380], [140 140 470 470], 0);
patch(ax,x,y,[0.87 0.74 0.52],e{:});
[x,y] = pj([372 428 NaN 372 428], [185 185 NaN 415 415], 0);
line(ax,x,y,'Color','w','LineWidth',2,hp{:});
% striker's stumps, in screen space (= pj of x 393/400/407, y 160, h 0..0.4)
G.st = line(ax,[387 387 NaN 400 400 NaN 413 413],[60 135 NaN 60 135 NaN 60 135], ...
    'LineWidth',5,hp{:});
% hitting zone + shrinking timing ring (screen space, around the zone)
rectangle(ax,'Position',[380 129 40 40],'Curvature',[1 1], ...
    'EdgeColor',[1 0.85 0.2],'LineWidth',2,hp{:});
G.ring = rectangle(ax,'Curvature',[1 1],'LineWidth',3,hp{:});
% fielders: slip, point, cover, mid-off, mid-on, midwicket inside the
% circle; deep cover, long-off, long-on, deep midwicket on the rope
S.F = [470 215; 610 260; 570 400; 470 480; 330 480; 220 380; ...
    950 480; 560 640; 240 640; -150 470];
% people as stick figures (one line per team, see man) + heads: the
% fielding side in red kit, batsmen in blue with dark helmets; bat; ball
G.fld = line(ax,0,0,'Color',[0.8 0.15 0.2],'LineWidth',3,hp{:});
G.fhd = scatter(ax,0,0,1,[0.95 0.8 0.65],'filled',hp{:});
G.men = line(ax,0,0,'Color',[0.15 0.3 0.85],'LineWidth',4,hp{:});
G.head = scatter(ax,0,0,1,[0.1 0.15 0.4],'filled',hp{:});
G.bat = line(ax,0,0,'Color',[0.98 0.95 0.85],'LineWidth',6,hp{:});
G.shad = scatter(ax,0,0,1,[0.3 0.5 0.2],'filled',hp{:});
G.ball = scatter(ax,0,0,1,[0.9 0.05 0.05],'filled',hp{:});
% crowd cards (one text object per fan), held up after a boundary
tx = {'Color','w','FontWeight','bold',hp{:}};
G.card = text(ax,70:83:740,320 + 80*rand(1,9),'','FontSize',14,tx{:}, ...
    'Color',[0.7 0 0],'BackgroundColor',[1 0.9 0.2]);
% TV score bar along the bottom, centre message just above it, and the
% timing hint beside the batter
rectangle(ax,'Position',[0 0 800 30],'FaceColor',[0.05 0.08 0.22], ...
    e{:});
G.hud = text(ax,14,15,'','FontSize',13,tx{:});
G.msg = text(ax,0,0,'','FontSize',15,tx{:},'HorizontalAlignment','center');
S.g = G;

% bowler names / base ball travel times (s); time per run (s)
S.bn = {'MEDIUM','FAST','SPIN','MYSTERY'};
S.tb = [1.1 0.78 1.25 1.15];
% the chase: 80 runs off 30 legal balls (5 overs), 3 wickets
S = newGame(S);
S.ph = 0; S.res = '';
S.msg = sprintf('Chase 80 in 5 overs with 3 wickets in hand\nTap as the ring hits the gold');
end

% ---------------------------------------------------------------------
function [x,y,k] = pj(x,y,h)
% Perspective: ground point (x,y) at height h -> screen. k = scale.
% The camera sits at ground y=0; nothing is drawn closer than y=40.
k = 300./max(y, 40);
x = 400 + (x - 400).*k;
y = 380 - 170.7*k + 100*h.*k;
end

% ---------------------------------------------------------------------
function S = step(S, dt, p)
% One small function per phase (cheaper than a big switch).
S.t = S.t + dt; S.swT = S.swT + dt;
f = {@ph0, @ph1, @ph2, @ph3, @ph4, @ph5, @ph0};
S = f{S.ph + 1}(S, p);
end

function S = ph0(S, p)
% title / game over: tap to start a new chase
if p && S.t > 0.6, S = newGame(S); end
end

function S = ph1(S, ~)
% run-up (longer at the start of an over, to show the bowler)
S.bw = 520 - 70*max(0, (S.t - S.ru + 0.8)/0.8);
if S.t > S.ru, S.ph = 2; S.t = 0; S.msg = ''; end
end

function S = ph2(S, p)
% ball in flight down the pitch
u = S.t/S.T;
q = u;   % distance along pitch; the mystery ball is quick, then slows
if S.ty == 4, q = min(1.5*u, 0.6 + (u - 0.4)/1.5); end
f = u;   % sideways: seamers drift steadily, spin turns sharply late
if S.ty == 3, f = max(0, (u - 0.65)/0.35)^2; end
S.b = [400 + S.off*f, 440 - 235*q];
S.h = abs(0.75 - q)*0.5;   % dips to the bounce at q=0.75
if p && ~S.sw
    S.sw = 1; S.swT = 0;
    e = S.t - S.T; a = abs(e)/S.win;   % timing error, in windows
    S.str = (S.str + 1)*(a <= 1);
    if S.str >= 3, S.z = 4; S.str = 0; end   % zone for the next 3 balls
    % runs by timing: 6 / 4 / 3..1 / 0 (defended); beyond 4.5 windows
    % the bat misses and the ball carries on. Hitting a wide makes it a
    % legal ball, as in real cricket.
    if a <= 4.5
        S = shot(S, 6*(a <= 1) + 4*(a > 1 && a <= 2) + ...
            (a > 2 && a <= 3.5)*round(3 - 1.3*(a - 2)));
    end
elseif q > 1.19   % reached the stumps
    if abs(S.off) > 50   % a wide: one extra, and the ball doesn't count
        S.wd = 1;
        S = result(S, 1, 'WIDE  +1');
    elseif S.off
        S = result(S, 0, 'DOT BALL');
    else   % at the stumps: the only way to get out
        S.wk = S.wk + 1; S.dead = 1;
        S = result(S, 0, 'BOWLED!');
    end
end
end

function S = ph3(S, ~)
% boundary: ball flies over (six) or races along the ground (four)
u = min(S.t/S.d, 1);
S.b = S.b0 + (S.tg - S.b0)*u;
% a six arcs high and comes down IN the stands (still 1.5 up)
S.h = (S.r == 6)*(2.5*sin(pi*u) + 1.5*u);
if u >= 1, S = result(S, S.r, S.pm); end
end

function S = ph4(S, ~)
% ground shot: ball rolls, a fielder chases, batsmen run
u = min(S.t/S.d, 1);
S.b = S.b0 + (S.tg - S.b0)*(1 - (1 - u)^2);
S.h = 0;
f0 = S.F(S.fi,:); D = S.tg - f0;
S.fp(S.fi,:) = f0 + D*min(1, S.t*220/max(norm(D), 1));
S.s = min(S.t/0.8, S.r);
if S.t > max(0.8*S.r, S.d) + 0.2, S = result(S, S.r, S.pm); end
end

function S = ph5(S, ~)
% result pause, then the next ball or the end of the chase
if S.t < 1.1, return; end
S.ph = 6; S.t = 0;
L = S.n + ~S.wd;   % legal balls bowled so far
% the result, worded like cricket (shown in the sky and on the TV bar)
if S.sc >= 80
    S.res = sprintf('WON by %d wicket%s, %d balls left', 3 - S.wk, ...
        repmat('s', 1, S.wk ~= 2), 30 - L);
elseif S.wk >= 3 || L >= 30   % all out, or the 5 overs are done
    S.res = sprintf('LOST by %d runs', 79 - S.sc);
    if S.sc == 79, S.res = 'MATCH TIED'; end
else
    S = nextBall(S); return
end
S.msg = [S.res newline '(tap to replay)'];
end

% ---------------------------------------------------------------------
function S = shot(S, r)
% Hit the ball forward of square (so it stays in front of the camera)
% for r runs: 6 = lofted over the rope, 4 = along the ground to the
% rope, 0..3 = into the field, distance growing with r.
th = pi*(0.1 + 0.8*rand);
v = [cos(th) sin(th)];
B = [400 205];
% distance L from the bat to the rope along v: ray/ellipse intersection
% with the rope (centre (400,330), radii 700x330) and the bat at
% c0 = B - centre = [0 -125], so b = 2*sum(c0.*v./E.^2) = -v(2)/435.6
% and -4ac = 4*a*(1 - (125/330)^2) = 3.426*a
a = sum((v./[700 330]).^2); b = -v(2)/435.6;
L = (-b + sqrt(b^2 + 3.426*a))/(2*a);
S.r = r; S.b0 = B; S.t = 0;
if r >= 4
    D = L*(1 + 0.3*(r == 6));
    S.ph = 3; S.d = 0.5 + D/550;
    S.pm = 'FOUR!';
    if r == 6, S.pm = 'SIX!'; end
else
    D = min(40 + 110*r, 0.85*L);
    S.ph = 4; S.d = 0.3 + D/350;
    S.pm = sprintf('%d RUN%s', r, repmat('S', 1, r > 1));
    if ~r, S.pm = 'DEFENDED'; end
end
S.tg = B + v*D;
[~, S.fi] = min(sum((S.F - S.tg).^2, 2));   % nearest fielder chases
end

% ---------------------------------------------------------------------
function S = result(S, r, m)
S.sc = S.sc + r; S.msg = m;
S.ph = 5; S.t = 0;
end

% ---------------------------------------------------------------------
function S = newGame(S)
S.sc = 0; S.wk = 0; S.n = -1; S.z = 0; S.str = 0; S.wd = 0;
S = nextBall(S);
end

function S = nextBall(S)
% after a wide the same ball is bowled again (n doesn't advance)
d = ~S.wd;
S.n = S.n + d; S.wd = 0; S.z = max(S.z - d, 0);   % wides don't use up the zone
S.ru = 0.8;
S.msg = '';
if d && ~mod(S.n, 6)   % new over, new bowler
    S.ty = randi(4); S.ru = 1.8;
    S.msg = sprintf('OVER %d: %s BOWLER', S.n/6 + 1, S.bn{S.ty});
end
% faster balls and a tighter window as the score climbs
S.T = S.tb(S.ty)*max(0.65, 1 - S.sc/300);
S.win = max(0.022, 0.032 - S.sc/6000)*(1 + (S.z > 0));
% line: about half the balls at the stumps, the rest outside off (spin:
% more); one in ten sprayed down the leg or off side as a wide
S.off = sign(rand - 0.5)*max(26*(rand < 0.45 + 0.25*(S.ty == 3)), 75*(rand < 0.1));
S.ph = 1; S.t = 0; S.sw = 0; S.swT = 9;
S.b = [392 450]; S.h = 0.3; S.fp = S.F; S.s = 0; S.r = 0;
S.dead = 0; S.bw = 520; S.fi = 1;
end

% ---------------------------------------------------------------------
function draw(~, S)
G = S.g;
% ball and its ground shadow; marker area shrinks with distance
[x,y,k] = pj(S.b(1), S.b(2), S.h);
set(G.ball,'XData',x,'YData',y,'SizeData',max(50*k^2, 20));
[x,y] = pj(S.b(1), S.b(2), 0);
set(G.shad,'XData',x,'YData',y,'SizeData',40*k^2);
% fielding side: the 10 fielders plus the bowler. Runners stride (leg
% spread q oscillates): the chasing fielder, and the bowler on his run-up
q = sin(18*S.t);
w = ones(11,1);
w([S.fi 11]) = q.^[S.ph == 4, S.ph == 1];   % q^0 = 1: standing
[x,y,k] = pj([S.fp(:,1); 392], [S.fp(:,2); S.bw], 0);
[X,Y] = man(x,y,k,w);
set(G.fld,'XData',X,'YData',Y);
set(G.fhd,'XData',x,'YData',y + 39*k,'SizeData',60*k.^2);
% batsmen run between the creases: triangle wave of run progress
r = 1 - abs(1 - mod(S.s, 2));
[x,y,k] = pj([385; 414], [200 + 210*r; 410 - 210*r], 0);
% striker holds the bat with BOTH hands: both arms run from the
% shoulders to one point on the handle; hands + bat swing together
% about the shoulders (a: rest low at -1.3, ~200 degrees in 0.2 s)
a = -1.3 + 3.5*S.sw*min(S.swT/0.2, 1);
c = k(1)*[cos(a) sin(a)];
h = [x(1), y(1) + 29*k(1)] + 14*c;   % the striker's hands on the handle
[X,Y] = man(x,y,k,q^(S.s < S.r && S.ph == 4),h);
set(G.men,'XData',X,'YData',Y);
set(G.head,'XData',x,'YData',y + 39*k,'SizeData',75*k.^2);
set(G.bat,'XData',h(1) + [0 26*c(1)],'YData',h(2) + [0 26*c(2)]);
% ring closes on the zone exactly when the ball arrives; gold in the zone
rr = 20 + 150*max(S.T - S.t, 0)/S.T;
set(G.ring,'Position',[400-rr 149-rr 2*rr 2*rr],'Visible',S.ph == 2 && ~S.sw, ...
    'EdgeColor',1 - [0 0.15 0.8]*(S.z > 0));
G.st.Color = [0.95 0.9 0.75] - [0 0.8 0.65]*S.dead;
% crowd cards show the boundary while the result is on screen
set(G.card,'String',S.r,'Visible',S.ph == 5 && S.r > 3);
% TV bar; L = legal balls bowled (the current one, once it's played)
L = S.n + (S.ph > 2 && ~S.wd);
s = sprintf('Need %d off %d   Wickets in hand: %d   %s', ...
    max(80 - S.sc, 0), 30 - L, 3 - S.wk, S.bn{S.ty});
if ~mod(S.ph,6), s = S.res; end   % title: blank; game over: the result
G.hud.String = sprintf('%d/%d   %d.%d ov   %s', S.sc, S.wk, floor(L/6), mod(L,6), s);
% messages sit just above the bar; title and game over go up in the sky
set(G.msg,'String',S.msg,'Position',[400 45 + 515*~mod(S.ph,6)]);
end

% ---------------------------------------------------------------------
function [X,Y] = man(x,y,k,s,h)
% Stick figures for N people (feet at screen x,y; scale k; columns):
% legs (foot-hip-foot), body (hip-neck), arms (hand-shoulder-shoulder-
% hand, so two hands on one bat handle still show as two arms).
% s = leg spread: 1 standing, sin() while running. Optional h = [x y]
% puts BOTH hands of person 1 (the striker) on the bat handle; everyone
% else holds their arms out. NaN-separated so a single line object
% draws a whole team.
z = NaN*x;
H = [x - 9*k, y + 20*k, x + 9*k, y + 20*k];   % hands: arms out
if nargin > 4, H(1,:) = [h h]; end   % ...or both on the striker's bat
X = [x - 7*k.*s, x, x + 7*k.*s, z, x, x, z, H(:,1), x - 5*k, x + 5*k, H(:,3), z]';
Y = [y, y + 16*k, y, z, y + 16*k, y + 33*k, z, H(:,2), y + 31*k, y + 31*k, H(:,4), z]';
X = X(:); Y = Y(:);
end
Play Game
Preview

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