MATLAB Hoop & Swish

Jitin Beri
/
MATLAB Hoop & Swish
on 3 Nov 2026
2
53
28
2
9997
game.m
function g = game()
%game MATLAB Hoop & Swish — one-button basketball in the MATLAB Arena.
%
%   Two taps per shot: an aim line sweeps 40-70 degrees — tap to lock the
%   angle; then the parula colorbar power meter swings — tap to shoot.
%   Swish = 3, rim/board = 2. Three in a row puts you ON FIRE (points x2
%   until you miss). The shooter moves after every shot, so every shot
%   needs a new angle/power. The dotted arc shows your last shot.
%   Five misses ends the game (GAME OVER screen). Both
%   sweeps speed up as you score. Everything readable lives in the bottom
%   HUD: Workspace, Command Window, Power colorbar.
%
%   World x 0..800, view y -50..550 (HUD below y=35), floor at y=60. Rim x=640..715 at height 360,
%   backboard face at x=720. Ball radius 14.
%   State: mode 0 title / 1 aiming / 2 ball in flight / 3 game over.
%     px shooter x; x,y,vx,vy,sp ball; ph power phase; tx,ty last-shot arc;
%     ah angle phase; an angle (deg); al angle locked;
%     in scored this shot; touch hit rim/board; ft,st flight/score time;
%     cX,cY,cU,cV confetti (falls away under gravity); tm logo clock; nw crowd-jump timer;
%     c1,c2,cc Command Window lines and colour.
%
%   >> minihackContest.validate
%   >> minihackContest.play
%   >> minihackContest.submit

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

function s = initState(ax)
NV = {'HitTest','off','PickableParts','none'};
E = [{'EdgeColor','none'} NV];
MO = [.85 .325 .098];   % MATLAB orange

% view extends below the court for the bottom HUD bar
ax.YLim=[-50 550];

% arena: dark navy wall
ax.Color=[.04 .1 .22];

% parula-tinted crowd (bodies + heads) that jumps with arms up when you
% score; arms are one NaN-separated line behind the bodies
x=8:16:792; q=mod(0:49,2); c=parula(50);
s.CY=[70+3*q 92+3*q];
k=[x-7;x-12;x*NaN;x+7;x+12;x*NaN];
s.g.fa=line(ax,k(:),k(:),'Color',[.6 .7 .9],'LineWidth',3,NV{:});
s.g.crowd=scatter(ax,[x x],s.CY,190,[c*.35;c*.55],'filled',NV{:});

% MATLAB membrane logo on the wall, lit; it slowly turns (re-projected
% and depth-sorted every frame in renderFrame)
L=membrane(1,12); m=size(L,1);
[X,Y]=meshgrid(linspace(-1,1,m));
[gx,gy]=gradient(L,2/(m-1));
b=max(0,(.5*gx-.3*gy+.8)./sqrt(gx.^2+gy.^2+1));
k=min(1,.2+.9*b(:));   % lit side orange, shadow side cool blue like the logo
C=max(0,([.7 .15 .05]+L(:)*[.3 .55 .1]).*k+[0 .1 .3].*(1-k));
s.M=[X(:) Y(:) L(:) 1+0*L(:)]';
a=reshape(1:m*m-m,m,m-1); a=a(1:m-1,:);
F=[a(:) a(:)+1 a(:)+m+1 a(:)+m];
s.F=F(any(L(F),2),:);
s.g.mem=patch(ax,'Faces',s.F,'Vertices',s.M(1:2,:)','FaceVertexCData',C,'FaceColor','interp',E{:});

% wooden court with a MATLAB-blue key under the hoop
rectangle(ax,'Position',[0 0 800 60],'FaceColor',[.8 .55 .3],E{:});
rectangle(ax,'Position',[560 0 240 60],'FaceColor',[.4 .5 .55],E{:});

% hoop: pole + arm, glass backboard
line(ax,[743 743 NaN 728 743],[60 415 NaN 415 415],'Color',[.45 .47 .52],'LineWidth',8,NV{:});
rectangle(ax,'Position',[720 335 10 135],'FaceColor',[.85 .92 1],E{:});

% shooter in a MATLAB-orange jersey
SK=[.96 .78 .6];
s.g.legs=line(ax,[0 0 0],[60 100 60],'Color',SK*.8,'LineWidth',5,NV{:});
s.g.body=rectangle(ax,'Curvature',.3,'FaceColor',MO,E{:});
s.g.arms=line(ax,0,0,'Color',SK,'LineWidth',4,NV{:});
s.g.head=rectangle(ax,'Curvature',1,'FaceColor',SK,E{:});

% last shot's arc (dotted) and aim line
s.g.tr=line(ax,0,0,'LineStyle',':','Color',[.5 .9 1],NV{:});
s.g.aim=line(ax,0,0,'LineStyle','--','LineWidth',3,'Color','w',NV{:});

% ball: fire glow, ball, spinning seams
s.g.glow=line(ax,0,0,'Marker','o','MarkerSize',34,'MarkerFaceColor',[1 .55 0],NV{:});
s.g.ball=rectangle(ax,'Curvature',1,'FaceColor',MO,NV{:});
s.g.seam=line(ax,0,0,'Color','k',NV{:});

% net and rim, in front of the ball
line(ax,[642 666 678 690 714 NaN 654 660 678 696 702],360-50*[0 1 0 1 0 NaN 1 0 1 0 1],'Color','w',NV{:});   % criss-cross net
line(ax,[640 720],[360 360],'Color',MO,'LineWidth',5,NV{:});

% parula confetti
s.g.conf=scatter(ax,NaN(1,40),NaN(1,40),28,parula(40),'filled',NV{:});

% start / game-over overlay: dimmed court + big banner
s.g.ov=[patch(ax,[0 800 800 0],[35 35 550 550],'k','FaceAlpha',.65,E{:}) ...
    text(ax,400,300,'','FontSize',36,'Color','w','FontWeight','bold','HorizontalAlignment','center',NV{:})];

% bottom HUD: a MATLAB desktop strip with Workspace, Command Window and
% a horizontal parula colorbar power meter with a pointer
rectangle(ax,'Position',[0 -50 800 85],'FaceColor',[.16 .17 .21],E{:});
for p=[8 180; 196 380; 584 208]'
    rectangle(ax,'Position',[p(1) -44 p(2) 56],'FaceColor','w',E{:});
    rectangle(ax,'Position',[p(1) 12 p(2) 18],'FaceColor',[.88 .91 .95],E{:});
end
text(ax,[16 204 592],[21 21 21],{'Workspace','Command Window','Power'},'FontSize',10,'FontWeight','bold','Color','k',NV{:});
FW={'FontName','FixedWidth','FontSize',12,'Color','k',NV{:}};
s.g.ws=text(ax,16,10,'','VerticalAlignment','top',FW{:},'FontSize',10);
s.g.c1=text(ax,204,0,'',FW{:});
s.g.c2=text(ax,204,-20,'',FW{:});
image(ax,'XData',[600 776],'YData',[-16 -4],'CData',repmat(permute(parula(30),[3 1 2]),2,1),NV{:});
s.g.ind=patch(ax,[0 -7 7],[3 11 11],'k',E{:});
% the physics, in feet (25 px = 1 ft): launch speed and gravity
text(ax,592,-34,'v = 20+22p ft/s  g = 36 ft/s²',FW{:},'FontSize',9);

s.cX=NaN(1,40); s.cY=s.cX; s.cU=s.cX; s.cV=s.cX;
s=resetRound(s);
end

function s = updateState(s, dt, pressed)
R=14;
% background, confetti and crowd animate in every mode
s.tm=s.tm+dt;
s.nw=max(0,s.nw-2*dt);   % cheer lasts ~0.5 s
s.cV=s.cV-600*dt; s.cX=s.cX+s.cU*dt; s.cY=s.cY+s.cV*dt;
if s.mode==0          % title screen
    if pressed, s.mode=1; end
    return
end
if s.mode==3          % game over: short lockout so a late tap can't skip it
    s.ot=s.ot+dt;
    if pressed && s.ot>.6, s=resetRound(s); s.mode=1; end
    return
end

if s.mode==1          % aiming: tap 1 locks the angle, tap 2 the power
    s.x=s.px+16; s.y=206;
    w=dt*min(.8,.4+.006*s.score);   % same sweep speed for angle and power
    % a tap locks exactly the value shown on the previous frame
    if ~s.al
        if pressed, s.al=1; s.ph=0; return, end
        s.ah=s.ah+w;
        s.an=round(40+30*(1-abs(1-mod(s.ah,2))));
        s.c2=sprintf('>> shoot(angle=%d',s.an);   % live readout on line 2; line 1 keeps the last shot
        return
    end
    if ~pressed
        s.ph=s.ph+w;
        s.c2=sprintf('>> shoot(angle=%d, power=%.2f',s.an,1-abs(1-mod(s.ph,2)));   % live power
        return
    end
    p=1-abs(1-mod(s.ph,2));
    v=500+550*p;
    s.vx=v*cosd(s.an); s.vy=v*sind(s.an);
    s.mode=2; [s.ft,s.in,s.st,s.touch]=deal(0); s.tx=[]; s.ty=[];
    s.c1=sprintf('>> shoot(angle=%d, power=%.2f)',s.an,p); s.c2='';
    return
end

% ball in flight, sub-stepped so it can't tunnel through the rim
s.ft=s.ft+dt;
s.tx(end+1)=s.x; s.ty(end+1)=s.y;   % record the arc
n=ceil(dt*hypot(s.vx,s.vy)/4)+1; h=dt/n;
for k=1:n
    py=s.y;
    s.vy=s.vy-900*h;
    s.x=s.x+s.vx*h; s.y=s.y+s.vy*h;
    s.sp=s.sp-s.vx/R*h;
    % front and back of the rim are small round posts
    for q=[640 715]
        dx=s.x-q; dy=s.y-360; d=hypot(dx,dy)+eps;
        if d<R+3
            nx=dx/d; ny=dy/d; vn=s.vx*nx+s.vy*ny;
            if vn<0, s.vx=s.vx-1.55*vn*nx; s.vy=s.vy-1.55*vn*ny; end
            s.x=q+nx*(R+3); s.y=360+ny*(R+3); s.touch=1;
        end
    end
    % backboard face
    if s.x+R>720 && s.x<730 && abs(s.y-403)<68 && s.vx>0
        s.x=720-R; s.vx=-.65*s.vx; s.touch=1;
    end
    % floor
    if s.y<60+R, s.y=60+R; s.vy=-.55*s.vy; s.vx=.8*s.vx; end
    % dropped down through the hoop: crowd jumps, confetti bursts
    if ~s.in && py>360 && s.y<=360 && s.x>640 && s.x<715
        s.in=1; s.nw=1;
        s.cX(:)=677; s.cY(:)=360;
        s.cU=500*rand(1,40)-250; s.cV=150+300*rand(1,40);
    end
end

s.st=s.st+dt*s.in;
if s.in && s.st>.6 || ~s.in && (s.x>830 || s.ft>3.5 || s.ft>.5 && s.y<75)
    s=endShot(s);
end
end

function s = endShot(s)
if s.in
    p=(3-s.touch)*(1+(s.streak>=3));
    s.score=s.score+p; s.streak=s.streak+1;
    s.c1=[s.c1 sprintf('  ans = %d',p)];
else
    s.miss=s.miss+1; s.streak=0;
    s.c1=[s.c1 sprintf('  %% miss %d/5',s.miss)];
end
s.ot=0; s.al=0;
s.mode=1+2*(s.miss>4);
s.px=140+240*rand;
end

function renderFrame(~, s)
g=s.g; R=14; px=s.px;


% colorbar pointer; crowd jumps after a make
x=597+182*(1-abs(1-mod(s.ph,2)));
g.ind.XData=x+[0 -7 7];
j=14*abs(sin(s.nw*(9+5*mod(0:49,2))));   % fans bounce, alternate fans out of step
g.crowd.YData=s.CY+[j j];
y=s.CY(1:50)+10+j; h=y+36*(s.nw>0);  % shoulders -> raised hands
k=[y;h;y*NaN;y;h;y*NaN];
g.fa.YData=k(:); g.fa.Visible=s.nw>0;

% turning membrane logo
P=viewmtx(25*sin(s.tm/3)-37.5,30)*s.M; z=P(3,:); [~,o]=sort(sum(z(s.F),2));
g.mem.Faces=s.F(o,:); g.mem.Vertices=[430+115*P(1,:);290+115*P(2,:)]';

% shooter: ball held overhead while aiming, follow-through after release
f=s.mode>1;
g.legs.XData=px+[-9 0 9];
g.body.Position=[px-12 96 24 60];
g.head.Position=[px-11 157 22 22];
hx=px+16+12*f; hy=192+8*f;
g.arms.XData=[px-8 hx NaN px+8 hx]; g.arms.YData=[150 hy NaN 150 hy];

% aim line (angle readout lives in the Command Window)
g.aim.XData=s.x+[18 100]*cosd(s.an); g.aim.YData=s.y+[18 100]*sind(s.an);
g.aim.Visible=s.mode==1;

g.tr.XData=s.tx; g.tr.YData=s.ty;

% ball, seams, glow when ON FIRE
x=s.x; y=s.y; c=cos(s.sp)*R; d=sin(s.sp)*R;
g.ball.Position=[x-R y-R 2*R 2*R];
g.seam.XData=[x-c x+c NaN x+d x-d]; g.seam.YData=[y-d y+d NaN y-c y+c];
g.glow.XData=x; g.glow.YData=y;
g.glow.Visible=s.streak>2;

g.conf.XData=s.cX; g.conf.YData=s.cY;

% Workspace + Command Window
g.ws.String=sprintf('score  %5d\nmisses %3d/5\ndx  %6.2fft\ndy  %6.2fft',s.score,s.miss,(661.5-px)/25,6.16);   % release -> rim centre, 25 px = 1 ft
g.c1.String=s.c1;
g.c2.String=s.c2;
m=s.mode; o=g.ov(2);
% the same scoring rules appear on the title and the game-over screen
r='\n\\fontsize{15}swish (no rim) = 3 pts, hits rim/board, goes in = 2 pts\n3 in a row = ON FIRE: points x2 until a miss\n5 misses = game over\n\\fontsize{20}';
o.String=sprintf(['MATLAB Hoop & Swish\n\\fontsize{15}tap 1: angle, tap 2: power' r 'tap to start']);
if m>2, o.String=sprintf(['\\color{red}GAME OVER\n\\fontsize{20}score %d\\color{white}' r 'tap to replay'],s.score); end
set(g.ov,'Visible',m==0 || m>2);
end

function s = resetRound(s)
[s.mode,s.score,s.miss,s.streak,s.vx,s.vy,s.sp,s.ph,s.ah,s.al,s.nw, ...
    s.ft,s.in,s.st,s.touch,s.ot,s.tm,s.tx,s.ty]=deal(0);
s.px=200; s.x=216; s.y=206; s.an=40;
s.c1='>>'; s.c2='';
end
Play Game
Preview

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