Traffic conductor

Vinay Ramesh
/
Traffic conductor
on 3 Nov 2026
1
27
15
0
9996
game.m
function g = game()
%game Traffic Conductor -- a one-button crossing-management game.
%
%   One button cycles the master signal through three phases:
%       0 → CARS GO     horizontal road (EW) green, vertical red, gate up
%       1 ↓ CARS GO     vertical road (NS) green, horizontal red, gate up
%       2 STOP: TRAIN   both roads red, rail gate DOWN (train may pass safely)
%
%   Keep traffic flowing. You lose if two roads enter the intersection at
%   once, if a car is on the rail crossing when a train comes, or if any
%   driver runs out of patience (cars turn red the longer they wait).
%
%   Scoring: each car is worth 10 x streak multiplier (cars that get
%   through before turning angry build the streak). Trains earn a bonus
%   for closing the gate late -- or a big one for slipping through
%   without closing it at all.
%
%   Lanes are stored as 2-row arrays: row 1 = EW (moves +x along y=300),
%   row 2 = NS (moves +y along x=400). Car half-length 17, half-width 12.

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

% ------------------------------------------------------------------------
function s = setup(ax)
ax.YDir  = 'reverse';
ax.XLim  = [0 800];
ax.YLim  = [0 600];
ax.Color = [.45 .72 .42];                 % grass

h = {'HitTest','off','PickableParts','none'};  % clicks pass to the button
R = @(p,c,v,varargin) rectangle(ax,'Position',p,'FaceColor',c, ...
    'EdgeColor','none','Curvature',v,h{:},varargin{:});
T = @(x,y,z,a,varargin) text(ax,x,y,'','Color','w','FontSize',z, ...
    'FontWeight','bold','HorizontalAlignment',a,h{:},varargin{:});
L = @(x,y,c,w,varargin) line(ax,x,y,'Color',c,'LineWidth',w,h{:},varargin{:});
Q = @(c,v,varargin) R([0 0 1 1],c,v,'Visible','off',varargin{:});  % pooled
s.pal = [.25 .55 .95; .3 .75 .45; .95 .95 .95; .6 .4 .85; .2 .8 .85; .95 .8 .2];

% ---- static scenery (drawn once, back to front) ----
rd = [.27 .27 .31];
wh = [.95 .95 .95];
R([603 0 34 600],[.55 .5 .45],0);         % rail ballast (roads cover it)
R([0 263 800 74],[.74 .74 .7],0);         % sidewalks
R([363 0 74 600],[.74 .74 .7],0);
R([0 270 800 60],rd,0);
R([370 0 60 600],rd,0);
L([0 400;800 400],[300 0;300 600],[.95 .85 .3],2,'LineStyle','--');
R([370 270 60 60],rd,0);                  % keep the box clear of dashes
for i = 0:5                               % zebra crossings
    R([438 273+i*10 14 5],wh,0);
    R([373+i*10 338 5 14],wh,0);
end
L([366 372;366 428],[272 266;328 266],wh,3);  % stop lines
% rail ties and rails
for y = [0:18:252, 342:18:600]
    R([598 y 44 6],[.42 .3 .2],0);
end
L([609 631;609 631],[0 0;600 600],[.8 .8 .85],3);

% houses (top-down roofs with a ridge line) and trees
hs = [40 70 130 85; 200 150 100 75; 465 70 105 85; 680 390 95 120; 60 400 130 95; 470 440 100 90];
for i = 1:6
    q = hs(i,:);
    e = .5*s.pal(i,:);                    % roofs: muted car palette
    R(q,e+.3,0,'EdgeColor',e);
    L(q(1)+[8 q(3)-8],q(2)+q(4)/2*[1 1],e,2);
end
for t = [260 70; 320 225; 100 215; 560 40; 700 80; 760 190; 250 385; 300 525; 100 560; 505 380; 660 560]'
    R([t'-[20 18] 44 44],[.18 .4 .2],1);  % shadow, crown, highlight
    R([t'-[18 22] 36 36],[.28 .6 .3],1);
    R([t'-[10 17] 14 14],[.42 .74 .4],1);
end

% ---- dynamic pools: 8 cars per lane (body + windshield), 3 trains ----
for i = 1:8
    for l = 1:2
        s.g.c(l,i)  = Q([1 1 1],.35,'EdgeColor','k');
        s.g.ws(l,i) = Q([.15 .2 .3],.3);
    end
end
for i = 1:3                               % locomotive, nose stripe, wagon
    s.g.tr(i) = Q([.2 .27 .4],.15);
    s.g.tn(i) = Q([.95 .75 .1],.2);
    s.g.tw(i) = Q([.62 .25 .2],.1);
end
for i = 1:16                              % "!" badges over angry drivers
    s.g.bd(i) = T(0,0,13,'center','String','!','BackgroundColor',[.9 .1 .1],'Margin',1);
end

% signals with thick housings, rail lamps on a crossbar, striped gate
R([556 240 42 20],[.12 .12 .12],.3);
s.g.sg = [R([345 338 18 18],[0 0 0],1), R([437 244 18 18],[0 0 0],1)];
set(s.g.sg, 'EdgeColor', [.12 .12 .12], 'LineWidth', 4);
s.g.wl = [R([561 244 12 12],[0 0 0],1), R([581 244 12 12],[0 0 0],1)];
s.g.gate = [L(0,0,[.85 .12 .12],6), L(0,0,wh,6,'LineStyle','--')];
s.g.bang = Q([1 .55 .1],1,'EdgeColor',[1 1 .2],'LineWidth',4);  % crash flash

% HUD: score, patience bar of the most impatient driver, phase, rush hour
s.g.sc = T(16,22,15,'left');
R([16 38 160 10],[.15 .15 .15],0);
s.g.pb = R([16 38 160 10],[0 1 0],0);
T(182,43,9,'left','String','PATIENCE');
s.g.ph = T(400,22,15,'center');
s.g.ru = T(784,22,13,'right');
s.g.pop = T(640,240,14,'left');
s.g.msg = T(400,300,18,'center','BackgroundColor',[0 0 0 .6],'Margin',10);
s.pm = 10;                               % seconds a driver will wait
s = newRound(s);
s.on = false;
end

% ------------------------------------------------------------------------
function s = step(s, dt, p)
if ~s.on
    s.on = p;
    return
end
if s.go
    s.gw = s.gw - dt;                     % short lockout so a panic tap
    if p && s.gw < 0                      % doesn't skip the score screen
        s = newRound(s);
    end
    return
end
if p
    s.ph = mod(s.ph + 1, 3);
    s.rh = 0;
end
s.t  = s.t + dt;
s.rh = s.rh + dt;                         % time held in current phase
s.pt = max(s.pt - dt, 0);
s.gp = min(max(s.gp + (2*(s.ph == 2) - 1)*5*dt, 0), 1);

% ---- rush hour: one road periodically gets double traffic ----
s.rt = s.rt - dt;
if s.rt < 0                               % 6 s of rush, then 8-12 s calm
    s.ru = ~s.ru*randi(2);
    s.rt = 6 + ~s.ru*(2 + 4*rand);
end

% ---- cars: spawn, move, track waiting ----
sx = [347 247];                           % stop line before intersection
ex = [840 640];                           % off-screen exit
d  = 170*dt;
iv = max(.9, 2.3 - s.t*.02);
for l = 1:2
    s.sp(l) = s.sp(l) - dt;
    if s.sp(l) <= 0
        j = find(~s.A(l,:), 1);
        if any(j) && ~any(s.A(l,:) & s.P(l,:) < 40)
            s.A(l,j) = true;
            s.P(l,j) = -25;
            s.W(l,j) = 0;
            s.C(l,j) = randi(6);
        end
        s.sp(l) = iv*(1 - .5*(s.ru == l)) + .5*rand;
    end

    hl = inf(1,8);
    if s.ph ~= l - 1
        hl(s.P(l,:) < sx(l) + 1) = sx(l);
    end
    if l == 1 && s.ph == 2
        hl(s.P(1,:) > 430 & s.P(1,:) < 583) = 582;  % wait at rail gate
    end
    o = s.P(l,:);
    a = s.A(l,:);
    [s.P(l,:), s.A(l,:)] = advance(a, o, d, hl, ex(l));

    s.W(l,:) = s.W(l,:) + dt*(s.A(l,:) & s.P(l,:) - o < d/2);
    for w = s.W(l, a & ~s.A(l,:))         % cars that exited this frame
        if w < s.pm/2
            s.st = s.st + 1;
        else
            s.st = 0;
        end
        s.sc = s.sc + 10*min(1 + floor(s.st/5), 5);
        s.n  = s.n + 1;
    end
end

% ---- trains (warning lead shrinks over time) ----
s.tt = s.tt - dt;
s.wn = s.tt > 0 && s.tt <= max(1.8, 2.6 - s.t*.008);
if s.tt <= 0
    j = find(~s.TA, 1);
    if any(j)
        s.TA(j) = true;
        s.T(j) = -60;
    end
    s.tt = max(5, 9 - s.t*.05) + 2*rand;
end
o = s.T;
s.T = s.T + 330*dt*s.TA;
s.TA = s.TA & s.T < 800;                  % wagon trails 92 px behind
if any(s.TA & o < 225 & s.T >= 225)       % train reaches the crossing
    b = 100*any(s.A(1,:) & abs(s.P(1,:) - 620) < 130);  % open gate, car close by
    w = 'DARING!';
    if s.ph == 2
        b = round(25*max(0, 4 - s.rh));   % gate closed late
        w = 'TIGHT!';
    end
    if b
        s.sc = s.sc + b;
        s.pt = 1.2;
        s.ps = sprintf('+%d %s', b, w);
    end
end

% ---- losing conditions ----
box = s.A & s.P + 17 > [370; 270] & s.P - 17 < [430; 330];
onRail = any(s.A(1,:) & s.P(1,:) > 588 & s.P(1,:) < 652);
trX = any(s.TA & s.T > 225 & s.T < 467);  % loco front .. wagon tail
[l, j] = find(s.A & s.W > s.pm, 1);
if all(any(box, 2))
    s = crash(s, 'CRASH!', [400 300]);
elseif onRail && trX
    s = crash(s, 'TRAIN HIT!', [620 300]);
elseif any(l)
    xy = [400 300];                       % lane l varies coordinate l
    xy(l) = s.P(l,j);
    s = crash(s, 'GRIDLOCK! A driver gave up', xy);
end
end

% ------------------------------------------------------------------------
function [x, a] = advance(a, x, d, hl, ex)
% Move one lane forward, front-most car first so followers see room.
% Each car stops at its hard limit or 42 px behind the car ahead.
i = find(a);
[~, o] = sort(x(i), 'descend');
for k = i(o)
    q = x(i);
    q = q(q > x(k));
    x(k) = max(x(k), min([x(k) + d, hl(k), q - 42]));
    a(k) = x(k) <= ex;
end
end

% ------------------------------------------------------------------------
function s = crash(s, why, xy)
s.go  = true;
s.why = why;
s.bxy = xy;
s.gw  = .8;
end

% ------------------------------------------------------------------------
function draw(~, s)
for l = 1:2
    for i = 1:8
        x = s.P(l,i);
        v = s.A(l,i);
        f = min(s.W(l,i)/s.pm, 1);        % blend toward angry red
        c = s.g.c(l,i);
        w = s.g.ws(l,i);
        b = s.g.bd(l*8 - 8 + i);
        set([c w], 'Visible', v);
        b.Visible = v && f > .7;
        c.FaceColor = s.pal(s.C(l,i),:)*(1 - f) + [.9 .1 .1]*f;
        % lane l moves along coordinate l; circshift swaps width/height
        q = [388 288];  q(l) = x - 17;  c.Position = [q circshift([24 34], l)];
        q = [391 291];  q(l) = x + 3;   w.Position = [q circshift([18 8], l)];
        q = [421 277];  q(l) = x;       b.Position = [q 0];
    end
end
for i = 1:3
    y = s.T(i);
    set([s.g.tr(i) s.g.tn(i) s.g.tw(i)], 'Visible', s.TA(i));
    s.g.tr(i).Position = [605 y-45 30 90];
    s.g.tn(i).Position = [607 y+28 26 10];
    s.g.tw(i).Position = [606 y-137 28 86];
end

for l = 1:2                               % red, or green on its phase
    s.g.sg(l).FaceColor = [.9 .2 .2] + (s.ph == l - 1)*[-.7 .65 0];
end
set(s.g.wl, 'FaceColor', [.4 .1 .1] + (s.wn && mod(floor(s.t*6), 2) == 0)*[.6 .75 0]);

a = (1 - s.gp)*1.4;                       % gate boom angle
set(s.g.gate, 'XData', [600, 600 + 73*sin(a)], 'YData', [338, 338 - 73*cos(a)]);

% HUD
fm = max([0, s.W(s.A)'/s.pm]);
fm = min(fm, 1);
s.g.pb.Position  = [16 38 max(160*(1 - fm), .01) 10];
s.g.pb.FaceColor = [.2 + .8*fm, .9*(1 - fm), .1];
s.g.sc.String = sprintf('Score %d   x%d', s.sc, min(1 + floor(s.st/5), 5));
nm = {'→ CARS GO','↓ CARS GO','STOP: TRAIN'};
s.g.ph.String = nm{s.ph + 1};
rs = {'', 'RUSH HOUR →', 'RUSH HOUR ↓'};
s.g.ru.String = rs{s.ru + 1};
s.g.pop.Visible  = s.pt > 0;
s.g.pop.String   = s.ps;
s.g.pop.Position = [645, 250 - 40*(1.2 - s.pt), 0];
s.g.bang.Visible  = s.go;
s.g.bang.Position = [s.bxy - 35, 70, 70];

s.g.msg.Visible = ~s.on || s.go;
if ~s.on
    s.g.msg.String = sprintf(['TRAFFIC CONDUCTOR\n\nSpace/click = next signal\n→ CARS GO > ↓ CARS GO > STOP: TRAIN\n\n' ...
        'Never let roads meet,\na car meet a train,\nor drivers wait too long!\n\nPress to start']);
elseif s.go
    s.g.msg.String = sprintf('%s\n\nScore %d   (%d cars)\n\nPress to restart', s.why, s.sc, s.n);
end
end

% ------------------------------------------------------------------------
function s = newRound(s)
% Reset gameplay state; keep graphics handles (s.g) and constants.
s.A  = false(2,8);  s.P = -60*ones(2,8);  s.W = zeros(2,8);  s.C = ones(2,8);
s.TA = false(1,3);  s.T = -120*ones(1,3);
s.ph = 0;   s.rh = 0;   s.t = 0;   s.gp = 0;   s.wn = false;
s.sc = 0;   s.st = 0;   s.n = 0;
s.sp = [1 2];  s.tt = 6;  s.ru = 0;  s.rt = 10;
s.pt = 0;   s.ps = '';
s.go = false;  s.gw = 0;  s.why = '';  s.bxy = [400 300];
s.on = true;
end
Play Game
Preview

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