Boid Shepherd

Vinay Ramesh
/
Boid Shepherd
on 3 Nov 2026
2
31
12
2
9996
game.m
function g = game()
%game Boid Shepherd -- a one-button flocking herding game.
%
%   A fully vectorized Reynolds flocking swarm (separation, alignment,
%   cohesion) of ~140 boids runs every frame. You pilot a shepherd orb
%   the flock is drawn toward. A heading indicator sweeps continuously
%   around the orb; TAP (space/click) to dash in the current heading.
%   Lead the flock into the pastel pen to fill the meter and score,
%   before the time bar runs out.
%
%   Workflow:
%       >> minihackContest.validate
%       >> minihackContest.play
%       >> minihackContest.submit

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

% ---------------------------------------------------------------------
function S = initState(ax)
W = 800; H = 600; N = 140;
S.W = W; S.H = H; S.N = N;

% --- flock S (column vectors) ---
ang = rand(N,1)*2*pi;
S.bx = 100 + rand(N,1)*(W-200);
S.by = 100 + rand(N,1)*(H-200);
S.bvx = cos(ang)*60;
S.bvy = sin(ang)*60;

% --- shepherd orb ---
S.orbX = W/2; S.orbY = H/2;
S.orbVX = 0;  S.orbVY = 0;
S.orbAngle = 0;
% orb radius 14

% --- flocking tuning (steer weights ~ order 1; Reynolds style) ---
% vision radius 72, separation 26, orb pull radius 240
% steer weights (sep 1.6, aln 1.0, coh 0.85, orb 1.5, wall 2.2) are inlined in flock()
% wall margin 70
% speed clamp [55, 190]

% --- orb control ---
S.sweepRate = 2.4;   % dash impulse 300, drag 2.0, orb max speed 270 inlined below

% --- goal pen + delivery meter ---
S.gw = 150; S.gh = 120;
S.gx = W-210; S.gy = H-190;
S.fill = 0; S.frac = 0;
S.flash = 0; S.popX = 0; S.popY = 0;

% --- game loop ---
S.score = 0; S.best = 0;
S.time = 30;   % round length 30 s
S.started = false; S.gameOver = false;

% --- axes look: a meadow (harness already set 800x600, hold on, ticks off) ---
ax.Color = [0.72 0.83 0.58];
ax.XLim = [0 W]; ax.YLim = [0 H];

% --- create every graphics object ONCE; render only mutates them ---
% hp: clicks must pass through every object to the one-button handler.
hp = {'HitTest','off','PickableParts','none'};
% grass: faint random tufts, drawn once behind everything
image(ax,'XData',[0 W],'YData',[0 H],'CData', ...
    reshape([0.70 0.82 0.56],1,1,3) + 0.06*rand(60,80) - 0.03,hp{:});
% pen: wooden fence on lusher grass; meter fills with trampled earth
gr.goal = rectangle(ax,'Position',[S.gx S.gy S.gw S.gh], ...
    'Curvature',0.10,'FaceColor',[0.66 0.80 0.50],'EdgeColor',[0.50 0.34 0.20], ...
    'LineWidth',2,'LineStyle','--',hp{:});
gr.fill = rectangle(ax,'Position',[S.gx S.gy S.gw 0.1], ...
    'Curvature',0.10,'FaceColor',[0.76 0.66 0.48],'EdgeColor','none', ...
    hp{:});
% sheep: dark faces (one quiver) poking out ahead of woolly bodies
gr.dir = quiver(ax,S.bx,S.by,S.bvx*0,S.bvy*0,0,'ShowArrowHead','off', ...
    'Color',[0.22 0.20 0.18],'LineWidth',3.5,hp{:});
gr.boids = scatter(ax,S.bx,S.by,70,ones(N,3),'filled', ...
    'MarkerEdgeColor',[0.55 0.52 0.48],hp{:});
% shepherd: brown cloak with a sunlit halo, crook-coloured aim
gr.glow = rectangle(ax,'Position',orbBox(S.orbX,S.orbY,32), ...
    'Curvature',[1 1],'FaceColor',[0.90 0.86 0.62],'EdgeColor','none', ...
    hp{:});
gr.orb = rectangle(ax,'Position',orbBox(S.orbX,S.orbY,14), ...
    'Curvature',[1 1],'FaceColor',[0.45 0.30 0.18],'EdgeColor','none', ...
    hp{:});
gr.head = line(ax,[S.orbX S.orbX],[S.orbY S.orbY], ...
    'Color',[0.36 0.24 0.14],'LineWidth',3,hp{:});
gr.tbar = rectangle(ax,'Position',[20 H-26 300 12],'Curvature',[1 1], ...
    'FaceColor',[0.96 0.80 0.36],'EdgeColor','none',hp{:});
gr.score = text(ax,20,H-52,'Delivered: 0','Color',[0.20 0.24 0.14], ...
    'FontSize',18,'FontWeight','bold',hp{:});
gr.best = text(ax,20,H-78,'Best: 0','Color',[0.30 0.36 0.22], ...
    'FontSize',13,hp{:});
gr.pop = text(ax,0,0,'+1','Color',[1 0.97 0.86],'FontSize',26, ...
    'FontWeight','bold','HorizontalAlignment','center','Visible','off',hp{:});
gr.msg = text(ax,W/2,H/2,'','Color',[0.16 0.20 0.10],'FontSize',22, ...
    'FontWeight','bold','HorizontalAlignment','center', ...
    hp{:});
S.g = gr;

S.showMsg = true;
S.msgStr = sprintf(['BOID SHEPHERD\n\nThe aim sweeps around the orb\n' ...
    'Tap space / click to dash that way\n' ...
    'Each tap reverses the sweep\n' ...
    'Lead the flock into the pen\n\n(press to begin)']);
end

% ---------------------------------------------------------------------
function S = updateState(S, dt, pressed)
if ~S.started
    S = flock(S, dt);
    if pressed
        S.started = true;
        S.showMsg = false;
    end
    return
end
if S.gameOver
    S = flock(S, dt);
    if pressed
        S = resetRound(S);
    end
    return
end

% --- orb control: sweeping aim, tap to dash ---
S.orbAngle = S.orbAngle + S.sweepRate*dt;
if pressed
    S.orbVX = S.orbVX + 300*cos(S.orbAngle);
    S.orbVY = S.orbVY + 300*sin(S.orbAngle);
    S.sweepRate = -S.sweepRate;   % rock the aim back and forth
end
S.flash = max(S.flash - dt, 0);
k = max(0, 1 - 2*dt);
S.orbVX = S.orbVX*k;
S.orbVY = S.orbVY*k;
osp = hypot(S.orbVX, S.orbVY);
if osp > 270
    S.orbVX = S.orbVX/osp*270;
    S.orbVY = S.orbVY/osp*270;
end
S.orbX = S.orbX + S.orbVX*dt;
S.orbY = S.orbY + S.orbVY*dt;
r = 14;
if S.orbX < r,          S.orbX = r;          S.orbVX = -S.orbVX*0.6; end
if S.orbX > S.W-r,  S.orbX = S.W-r;  S.orbVX = -S.orbVX*0.6; end
if S.orbY < r,          S.orbY = r;          S.orbVY = -S.orbVY*0.6; end
if S.orbY > S.H-r,  S.orbY = S.H-r;  S.orbVY = -S.orbVY*0.6; end

% --- flocking simulation ---
S = flock(S, dt);

% --- delivery meter: fill while the flock sits in the pen ---
inG = S.bx > S.gx & S.bx < S.gx+S.gw & ...
      S.by > S.gy & S.by < S.gy+S.gh;
frac = sum(inG)/S.N;
S.frac = frac;
S.fill = S.fill + (frac*1.1 - 0.18)*dt;
S.fill = min(max(S.fill,0),1);
if S.fill >= 1
    S.score = S.score + 1;
    S.fill = 0;
    S.time = min(S.time + 6, 30);
    % celebrate: flash, floating +1, burst the flock out of the pen
    S.flash = 0.6;
    S.popX = S.gx + S.gw/2; S.popY = S.gy + S.gh/2;
    [ux,uy] = unitv(S.bx - S.popX, S.by - S.popY);
    S.bvx = S.bvx + 160*ux.*inG;
    S.bvy = S.bvy + 160*uy.*inG;
    S = relocateGoal(S);
    S.sweepRate = sign(S.sweepRate)*min(abs(S.sweepRate) + 0.15, 4.2);
    S.gw = max(S.gw - 6, 100);
    S.gh = max(S.gh - 5, 85);
end

% --- timer ---
S.time = S.time - dt;
if S.time <= 0
    S.time = 0;
    S.gameOver = true;
    S.showMsg = true;
    tag = '';
    if S.score > S.best
        S.best = S.score;
        if S.score > 0, tag = 'NEW BEST!'; end
    end
    S.msgStr = sprintf('TIME!\n\nYou delivered %d\n%s\n\n(press to try again)', ...
        S.score, tag);
end
end

% ---------------------------------------------------------------------
function S = flock(S, dt)
% Vectorized Reynolds flocking. O(N^2) pairwise interactions per frame.
N = S.N;
bx = S.bx; by = S.by; bvx = S.bvx; bvy = S.bvy;
spd = 190;

dx = bx - bx.';           % dx(i,j) = bx(i) - bx(j)
dy = by - by.';
d2 = dx.^2 + dy.^2;
d2(1:N+1:end) = inf;      % ignore self

vis = double(d2 < 5184);
sep = double(d2 < 676);
visN = sum(vis,2); sepN = sum(sep,2);
cnt = visN; cnt(cnt==0) = 1;
hasV = visN > 0; hasS = sepN > 0;

% separation: steer away from close neighbors (1/d^2 weighted)
w  = sep ./ max(d2,1);
sx = sum(w.*dx,2); sy = sum(w.*dy,2);
[sux,suy] = unitv(sx,sy);
stSx = (sux*spd - bvx).*hasS; stSy = (suy*spd - bvy).*hasS;

% alignment: match average neighbor velocity
avx = (vis*bvx)./cnt; avy = (vis*bvy)./cnt;
[aux,auy] = unitv(avx,avy);
stAx = (aux*spd - bvx).*hasV; stAy = (auy*spd - bvy).*hasV;

% cohesion: steer toward neighbor centroid
cmx = (vis*bx)./cnt - bx; cmy = (vis*by)./cnt - by;
[cux,cuy] = unitv(cmx,cmy);
stCx = (cux*spd - bvx).*hasV; stCy = (cuy*spd - bvy).*hasV;

fx = 1.6*stSx + stAx + 0.85*stCx;
fy = 1.6*stSy + stAy + 0.85*stCy;

% attraction to the shepherd orb (only while actively herding)
if S.started && ~S.gameOver
    ox = S.orbX - bx; oy = S.orbY - by;
    inR = (ox.^2 + oy.^2) < 57600;
    [oux,ouy] = unitv(ox,oy);
    fx = fx + 1.5*(oux*spd - bvx).*inR;
    fy = fy + 1.5*(ouy*spd - bvy).*inR;
end

% wall avoidance near the margin
m = 70; W = S.W; H = S.H;
inx = (bx<m) - (bx>W-m);
iny = (by<m) - (by>H-m);
nearW = (inx~=0) | (iny~=0);
[wux,wuy] = unitv(inx,iny);
fx = fx + 2.2*(wux*spd - bvx).*nearW;
fy = fy + 2.2*(wuy*spd - bvy).*nearW;

% integrate + clamp speed to [minSpeed, maxSpeed]
bvx = bvx + fx*dt; bvy = bvy + fy*dt;
sp = sqrt(bvx.^2 + bvy.^2); sp(sp==0) = 1;
hi = sp > spd;
bvx(hi) = bvx(hi)./sp(hi)*spd; bvy(hi) = bvy(hi)./sp(hi)*spd;
lo = sp < 55;
bvx(lo) = bvx(lo)./sp(lo)*55; bvy(lo) = bvy(lo)./sp(lo)*55;

bx = bx + bvx*dt; by = by + bvy*dt;
bx = min(max(bx,0),W); by = min(max(by,0),H);

S.bx = bx; S.by = by; S.bvx = bvx; S.bvy = bvy;
end

% ---------------------------------------------------------------------
function renderFrame(~, S)
g = S.g;
sp = sqrt(S.bvx.^2 + S.bvy.^2);
t = min(sp/190,1);
C = (1-t).*[0.97 0.96 0.92] + t.*[1 0.84 0.78];   % wool blushes when running
set(g.boids,'XData',S.bx,'YData',S.by,'CData',C);
set(g.dir,'XData',S.bx,'YData',S.by,'UData',13*S.bvx./sp,'VData',13*S.bvy./sp);

r = 14;
g.orb.Position  = orbBox(S.orbX,S.orbY,r);
g.glow.Position = orbBox(S.orbX,S.orbY,32);
L = 36;
set(g.head,'XData',[S.orbX S.orbX+L*cos(S.orbAngle)], ...
           'YData',[S.orbY S.orbY+L*sin(S.orbAngle)]);

% pen edge glows with the share of flock inside; face flashes on delivery
f = min(S.frac*3,1); q = S.flash/0.6;
set(g.goal,'Position',[S.gx S.gy S.gw S.gh], ...
    'EdgeColor',(1-f)*[0.50 0.34 0.20] + f*[0.98 0.80 0.25], ...
    'LineWidth',2 + 3*f, ...
    'FaceColor',(1-q)*[0.66 0.80 0.50] + q*[1 1 1]);
if S.flash > 0
    set(g.pop,'Position',[S.popX S.popY + (1-q)*70 0],'Visible','on');
else
    set(g.pop,'Visible','off');
end
g.best.String = sprintf('Best: %d', S.best);
g.fill.Position = [S.gx S.gy S.gw max(S.gh*S.fill,0.1)];
set(g.tbar,'Position',[20 S.H-26 max(300*S.time/30,0.1) 12]);
g.score.String = sprintf('Delivered: %d', S.score);

if S.showMsg
    set(g.msg,'String',S.msgStr,'Visible','on');
else
    set(g.msg,'Visible','off');
end
end

% ---------------------------------------------------------------------
function S = resetRound(S)
W = S.W; H = S.H; N = S.N;
S.score = 0;
S.time = 30;
S.fill = 0;
S.gw = 150; S.gh = 120;
S.sweepRate = 2.4;
S.gameOver = false;
S.started = true;
S.showMsg = false;
S.flash = 0; S.frac = 0;

ang = rand(N,1)*2*pi;
S.bx = 100 + rand(N,1)*(W-200);
S.by = 100 + rand(N,1)*(H-200);
S.bvx = cos(ang)*60; S.bvy = sin(ang)*60;
S = relocateGoal(S);
S.orbX = W/2; S.orbY = H/2;
S.orbVX = 0; S.orbVY = 0;
end

% ---------------------------------------------------------------------
function S = relocateGoal(S)
% keep the new pen away from the flock so every delivery is earned
mg = 40; cx = mean(S.bx); cy = mean(S.by);
for k = 1:20
    S.gx = mg + rand*(S.W - S.gw - 2*mg);
    S.gy = mg + rand*(S.H - S.gh - 2*mg);
    if hypot(S.gx + S.gw/2 - cx, S.gy + S.gh/2 - cy) > 250, break; end
end
end

% ---------------------------------------------------------------------
function p = orbBox(x,y,r)
p = [x-r y-r 2*r 2*r];
end

% ---------------------------------------------------------------------
function [ux,uy] = unitv(x,y)
L = sqrt(x.^2 + y.^2); L(L==0) = 1;
ux = x./L; uy = y./L;
end
Play Game
Preview

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