DIRECTORY 
Convert USING [ValueToRope],
FootballInternal,
FootballMaster,
FootballMasterRpcControl USING [ImportInterface],
Graphics USING [
black, Box, Context, DrawBox, DrawChar, DrawRope, DrawTo, GetBounds,
SetColor, SetCP, SetPaintMode, SetStipple, Translate, white],
GraphicsColor USING [green],
InputFocus USING [SetInputFocus],
IO USING [Close, GetOutputStreamRope, GetToken, int, PutF, ROS, STREAM],
Menus USING [ClickProc, CreateEntry, CreateMenu, InsertMenuEntry, Menu],
MessageWindow USING[Append, Blink, Clear],
Process USING [Detach, SetTimeout],
Real USING [RoundI],
Rope USING [Cat, Find, FromChar, Length, ROPE, Substr],
RPC USING [ImportFailed],
TIPUser USING [InstantiateNewTIPTable, TIPScreenCoords, TIPTable],
UserExec USING [CommandProc, GetNameAndPassword, RegisterCommand],
ViewerClasses USING [
DestroyProc, ModifyProc, NotifyProc, PaintProc, 
Viewer, ViewerClass, ViewerClassRec],
ViewerOps USING [CreateViewer, PaintViewer, RegisterViewerClass, SetMenu],
ViewerTools USING [GetSelectionContents, MakeNewTextViewer];


FootballViewer: MONITOR
IMPORTS 
Convert, FootballInternal, FootballMaster, FootballMasterRpcControl, 
Graphics, InputFocus, IO, Menus, MessageWindow, Process, Real, Rope, RPC, 
TIPUser, UserExec, ViewerOps, ViewerTools
EXPORTS FootballInternal  =
BEGIN OPEN FootballInternal, FootballMaster;

game: PUBLIC Game;
myTeam: PUBLIC Team;
displayLine: INTEGER _ 20;
viewer: PUBLIC ViewerClasses.Viewer;
shadow: ARRAY Position OF RECORD[oldX, oldY: REAL, char: CHARACTER];

Initialize: PROCEDURE =
BEGIN
Process.SetTimeout[@timer, 1];
game _ NEW[GameRec _ []];
FOR i: Position IN Players DO
game.player[i].position _ i;
ENDLOOP;
CreateMenu[];
MakeFootballClass[];
UserExec.RegisterCommand["Football", Create, "Football arcade game."];
END;

CreateMenu: PROCEDURE =
BEGIN
OPEN FootballInternal;
menu _ Menus.CreateMenu[4];
Menus.InsertMenuEntry[menu, Menus.CreateEntry["DisableDelayOfGame", MyCommand, $DisableDelayOfGame]];
Menus.InsertMenuEntry[menu, Menus.CreateEntry["Decline", MyCommand, $Decline]];
Menus.InsertMenuEntry[menu, Menus.CreateEntry["Accept", MyCommand, $Accept]];
Menus.InsertMenuEntry[menu, Menus.CreateEntry["TimeOut", MyCommand, $TimeOut]];
Menus.InsertMenuEntry[menu, Menus.CreateEntry["Kick", MyCommand, $Kick]];
Menus.InsertMenuEntry[menu, Menus.CreateEntry["Pass", MyCommand, $Pass]];
Menus.InsertMenuEntry[menu, Menus.CreateEntry["Hike", MyCommand, $Hike]];
Menus.InsertMenuEntry[menu, 
Menus.CreateEntry[name: "WritePlays", proc: PlayBook, clientData: $Write, guarded: TRUE]];
Menus.InsertMenuEntry[menu, Menus.CreateEntry["ReadPlays", PlayBook, $Read]];
Menus.InsertMenuEntry[menu, Menus.CreateEntry["SavePlay", MySave]];
Menus.InsertMenuEntry[menu, Menus.CreateEntry["SaveSetUp", MySave, $SetUp]];
Menus.InsertMenuEntry[menu, Menus.CreateEntry["Help", MyCommand, $Help]];
END;

MySave: Menus.ClickProc = TRUSTED {FootballInternal.SavePlay[
side: IF game.offense = myTeam THEN offense ELSE defense,
name: ViewerTools.GetSelectionContents[],
setUp: clientData = $SetUp]};
MyCommand: Menus.ClickProc = TRUSTED {TipMe[NIL, LIST[clientData]]};
PlayBook: Menus.ClickProc = TRUSTED {
name: Rope.ROPE _ ViewerTools.GetSelectionContents[];
IF name.Length[] < 2 THEN {
name _ UserExec.GetNameAndPassword[].name;
name _ Rope.Substr[name, 0, Rope.Find[name, "."]];
name _ Rope.Cat[name, ".plays"]};
IF clientData = $Read
THEN FootballInternal.ReadPlayBook[name]
ELSE FootballInternal.WritePlayBook[name]};

menu: Menus.Menu;
imported: BOOLEAN _ FALSE;

Create: UserExec.CommandProc =
TRUSTED BEGIN -- exec: ExecHandle, exec.commandLine: ROPE
self: Rope.ROPE;
remote, local: Rope.ROPE;
failed: BOOLEAN _ FALSE;
self _ UserExec.GetNameAndPassword[].name;
remote _ IO.GetToken[event.commandLineStream];
IF remote.Length[] # 0 THEN local _ IO.GetToken[event.commandLineStream];
IF remote.Length[] = 0 THEN remote _ self;
IF local.Length[] = 0 THEN local _ self; 
IF ~imported THEN {
myTeam _ visitors;
FOR i: CARDINAL IN [0..2) DO
failed _ FALSE;
FootballMasterRpcControl.ImportInterface [
interfaceName: [instance: remote]
! RPC.ImportFailed => {failed _ TRUE; CONTINUE}];
IF failed AND Rope.Find[remote, "."] < 0 
THEN remote _ Rope.Cat[remote, ".pa"] ELSE EXIT;
ENDLOOP;
IF failed THEN {
failed _ FALSE;
myTeam _ home;
FootballInternal.StartServer[local];
FootballMasterRpcControl.ImportInterface [
interfaceName: [instance: local]
! RPC.ImportFailed => {failed _ TRUE; CONTINUE}];
IF failed THEN RETURN[FALSE, "couldn't import self!!!"]};
imported _ TRUE};
IF viewer = NIL OR viewer.destroyed THEN {
newProcess: BOOLEAN _ viewer = NIL;
viewer _ ViewerOps.CreateViewer[
flavor: $Football, 
info: [
name: "Football", 
iconic: FALSE,
data: NIL,
scrollable: FALSE],
paint: FALSE];
ViewerOps.SetMenu[viewer, menu];
ViewerOps.PaintViewer[viewer, all];
IF newProcess THEN Process.Detach[FORK FootballInternal.Control[]]};
RETURN[TRUE, NIL];
END;

selected: PUBLIC Position _ none;
setUp: BOOLEAN _ FALSE;

MakeFootballClass: PROCEDURE = 
BEGIN
tipTable: TIPUser.TIPTable _ TIPUser.InstantiateNewTIPTable["Football.tip"];
viewerClass: ViewerClasses.ViewerClass _ NEW[
ViewerClasses.ViewerClassRec _
[paint:  PaintMe,	-- called whenever the Viewer should repaint
notify:  TipMe,   	-- TIP input events
modify:  Noop, 	-- InputFocus changes reported through here
destroy:  DestroyMe,	-- called before Viewer structures freed on destroy op
scroll:  NIL,	-- document scrolling
icon:  document,	-- picture to display when small
tipTable: tipTable,	-- could be moved into Viewer instance if needed
cursor:  crossHairsCircle -- standard cursor when mouse is in viewer
]];
ViewerOps.RegisterViewerClass[$Football, viewerClass];
END;


Noop: ViewerClasses.ModifyProc = TRUSTED {};
DestroyMe: ViewerClasses.DestroyProc = 
TRUSTED BEGIN
END;

TipMe: ViewerClasses.NotifyProc = 
TRUSTED BEGIN
x, y: REAL _ 1000;
InputFocus.SetInputFocus[self];
FOR input _ input, input.rest DO
IF input = NIL THEN EXIT;
WITH input.first SELECT FROM
z: TIPUser.TIPScreenCoords => {[x, y] _ Translate[z.mouseX, z.mouseY]; LOOP};
ENDCASE;
SELECT input.first FROM
$Help => [] _ ViewerTools.MakeNewTextViewer[[name: "Football.doc", file: "Football.doc", iconic: FALSE]];
$Accept => {
FootballMaster.PenaltyResponse[myTeam, TRUE];
MessageWindow.Clear[]};
$Decline => {
FootballMaster.PenaltyResponse[myTeam, FALSE];
MessageWindow.Clear[]};
$Hike => FootballMaster.Hike[myTeam];
$TimeOut => FootballMaster.TimeOut[myTeam];
$Pass => IF x = 1000 
THEN SetCommand[ball, [pass, [null[]]]] -- defaults location
ELSE SetCommand[ball, [pass, [absolute[x, y]]]];
$Kick => IF x = 1000 
THEN SetCommand[ball, [kick, [goal[]]]] 
ELSE SetCommand[ball, [kick, [absolute[x, y]]]];
$DoIt => SELECT game.state FROM
setUp => FootballMaster.Hike[myTeam]
ENDCASE => SetCommand[ball, [pass, [null[]]]];
$Select => selected _ Select[x, y, myTeam, 10];
$Deselect => selected _ none;
$SetUp => IF selected # none THEN SetCommand[selected, [run, [absolute[x, y]]], TRUE];
$Run => IF selected # none THEN SetCommand[selected, [run, [absolute[x, y]]]]; 
$Block => {
target: Position _ Select[x, y, Opponent[myTeam], 1];
IF selected = none THEN RETURN;
IF target = selected THEN target _ none;
IF target = none
THEN SetCommand[selected, [block, [absolute[x, y]]]]
ELSE SetCommand[selected, [block, [player[target]]]]}; 
$BlockDefault => IF selected # none THEN SetCommand[selected, [block, [player[none]]]];
$Stop => IF selected # none THEN SetCommand[selected, [stop, [null[]]]];
$Freeze => IF selected # none THEN SetCommand[selected, [stop, [null[]]], TRUE];
$DisableDelayOfGame => FootballMaster.DisableDelayOfGame[];
ENDCASE;
ENDLOOP;
END;


Translate: PROC[x, y: REAL] RETURNS[REAL, REAL] =
BEGIN
x _ x - deltaX;
y _ y - deltaY;
RETURN[x/yard, y/yard];
END;

Select: PROC[x, y: REAL, team: Team, delta: REAL _ 1000] RETURNS[player: Position] =
BEGIN
min, temp: REAL _ 1000;
FOR i: Position IN Players DO
IF TeamOf[i] # team THEN LOOP;
temp _ ABS[game.player[i].x - x] + ABS[game.player[i].y - y];
IF temp < min THEN {min _ temp; player _ i};
ENDLOOP;
IF min > delta THEN player _ none;
END;



deltaX: REAL;
deltaY: REAL = 50;
lastState: State;
lastTime: INTEGER _ 0;
penaltyState: PenaltyState _ none; 
timeouts: ARRAY Team OF INTEGER _ [4,4];
penalties: ARRAY Team OF Penalty _ [none, none];
oldScore: ARRAY Team OF INTEGER _ [0, 0];
timer: CONDITION;

PaintMe: ViewerClasses.PaintProc =
TRUSTED BEGIN -- self: Viewer, context: Graphics.Context, whatChanged: REF ANY,
new: INTEGER;
clock: INTEGER _ MAX[0, game.clock];
fieldErased: BOOLEAN _ FALSE;
scoreboardErased: BOOLEAN _ FALSE;
IF self.iconic THEN RETURN;
new _ GetDisplayLine[Real.RoundI[game.player[game.ballCarrier].x], 
displayLine, self.cw/yard];
deltaX _ self.cw/2 - new*yard;
Graphics.Translate[context, deltaX, deltaY];
fieldErased _ (new # displayLine) OR whatChanged = NIL;
IF fieldErased THEN DisplayField[context, whatChanged # NIL];
scoreboardErased _ (game.state = huddle AND lastState # huddle) 
OR (game.state = offField AND lastState # offField) 
OR game.timeouts # timeouts OR game.penalties # penalties
OR game.score # oldScore OR game.penaltyState # penaltyState 
OR fieldErased;
IF scoreboardErased THEN DisplayStats[context, ~fieldErased];
IF scoreboardErased OR (clock # lastTime) 
THEN DisplayClock[context, clock, ~scoreboardErased];
[] _ Graphics.SetPaintMode[context, invert];
IF fieldErased OR (game.state = option AND lastState # option) 
THEN ErasePlay[context, ~fieldErased]; 
IF game.state < option THEN DisplayPlay[context];
FOR i: Position IN Players DO
DisplayPlayer[context, @game.player[i], ~fieldErased];
ENDLOOP;
DisplayBall[context, ~fieldErased];
IF game.penalties # penalties AND game.penalties # [none, none] 
THEN Flash[context, Graphics.GetBounds[context], grey];
-- IF game.score # oldScore THEN Flash[context, scoreboard, black];
IF game.penaltyState # penaltyState AND game.penaltyState = asking 
AND game.penalties[Opponent[myTeam]] # none THEN {
MessageWindow.Append["Please accept or decline penalty.", TRUE];
MessageWindow.Blink[]};
lastTime _ clock;
displayLine _ new;  
lastState _ game.state;
oldScore _ game.score;
timeouts _ game.timeouts;
penalties _ game.penalties; 
penaltyState _ game.penaltyState; 
END;


Flash: ENTRY PROC[context: Graphics.Context, box: Graphics.Box, color: CARDINAL] =
BEGIN
Graphics.SetStipple[context, color];
Graphics.DrawBox[context, box]; WAIT timer;
Graphics.DrawBox[context, box];
Graphics.SetStipple[context, black];
END;

Erase: PROC[context: Graphics.Context, box: Graphics.Box] =
BEGIN
[] _ Graphics.SetPaintMode[context, opaque];
IF viewer.column = color
THEN Graphics.SetColor[context, GraphicsColor.green]
ELSE Graphics.SetColor[context, Graphics.white];
Graphics.DrawBox[context, box];
Graphics.SetColor[context, Graphics.black];
[] _ Graphics.SetPaintMode[context, transparent];
END;

GetDisplayLine: PROC[ballX, displayLine, screenWidth: INTEGER] RETURNS[INTEGER] =
BEGIN
SELECT TRUE FROM
displayLine - ballX > screenWidth/2 => 
displayLine _ MIN[MAX[ballX, 0], 100];
displayLine - ballX > screenWidth/2 - 5 => 
displayLine _ screenWidth/2 - 5 + ballX;
ballX - displayLine > screenWidth/2 =>  
displayLine _ MIN[MAX[ballX, 0], 100];
ballX - displayLine > screenWidth/2 - 5 =>  
displayLine _ ballX - screenWidth/2 + 5;
ENDCASE;
IF displayLine + 10 < screenWidth/2 THEN 
displayLine _ - 10 + screenWidth/2; 
IF 100 - displayLine + 10 < screenWidth/2 THEN 
displayLine _ 100 + 10 - screenWidth/2; 
RETURN[displayLine];
END;


yard: INTEGER _ 8;
grey: CARDINAL _ 055132B;
black: CARDINAL _ 177777B;
statsX: REAL _ 37*yard;
statsY: REAL _ 100 + fieldWidth*yard;
scoreboard: Graphics.Box = [statsX - 30, statsY - 65, statsX + 300, statsY + 30];


DisplayField: PROC[context: Graphics.Context, erase: BOOLEAN] =
BEGIN
x, y: REAL;
rope: Rope.ROPE;
IF erase THEN Erase[context, Graphics.GetBounds[context]];
IF viewer.column = color THEN {
[] _ Graphics.SetPaintMode[context, opaque];
Graphics.SetColor[context, GraphicsColor.green];
Graphics.DrawBox[context, Graphics.GetBounds[context]];
Graphics.SetColor[context, Graphics.white]};
y _ fieldWidth*yard;
DrawLine[context, -10*yard, 0, 110*yard, 0];
DrawLine[context, -10*yard, fieldWidth*yard, 110*yard, fieldWidth*yard];
DrawLine[context, -10*yard, 0, -10*yard, y];
DrawLine[context, 110*yard, 0, 110*yard, y];
FOR i: INTEGER IN [0..10] DO
x _ i*10*yard;
y _ fieldWidth*yard;
DrawLine[context, x, 0, x, y];
DrawLine[context, x-3, y/3, x+3, y/3];
DrawLine[context, x-3, 2*y/3, x+3, 2*y/3];
IF i = 0 OR i = 10 THEN rope _ Rope.FromChar['G] 
ELSE rope _ Convert.ValueToRope[[signed[MIN[100-i*10, i*10]]]]; 
DrawRope[context, rope, x-5, y+5];
DrawRope[context, rope, x-5, -15];
ENDLOOP;
IF viewer.column # color THEN {
Graphics.SetStipple[context, grey];
Graphics.DrawBox[context, [-10*yard, 0, 0, fieldWidth*yard]];
Graphics.DrawBox[context, [100*yard, 0, 110*yard, fieldWidth*yard]];
Graphics.SetStipple[context, black]};
END;

DisplayStats: PROC[context: Graphics.Context, erase: BOOLEAN] = 
BEGIN
number: Rope.ROPE;
IF erase THEN Erase[context, scoreboard];
MessageWindow.Clear[]; -- remove any messages.
IF myTeam = home
THEN DrawRope[context, "(home)", statsX+82, statsY+15]
ELSE DrawRope[context, "(visitors)", statsX+75, statsY+15];
context.SetCP[statsX, statsY];
IF game.offense = home
THEN context.DrawRope["HOME* "]
ELSE context.DrawRope["HOME  "];
SELECT game.quarter FROM
1 => context.DrawRope["   First Quarter   "];
2 => context.DrawRope["  Second Quarter  "];
3 => context.DrawRope["  Third Quarter   "];
4 => context.DrawRope["  Fourth Quarter  "];
5 => context.DrawRope["    Game Over    "];
ENDCASE => ERROR;
IF game.offense = visitors
THEN context.DrawRope["VISITORS* "]
ELSE context.DrawRope["VISITORS  "];
number _ Convert.ValueToRope[[signed[game.score[home]]]];
DrawRope[context, number, statsX+20, statsY-15];
number _ Convert.ValueToRope[[signed[game.score[visitors]]]]; 
DrawRope[context, number, statsX+185, statsY-15];
number _ Convert.ValueToRope[[signed[game.timeouts[home]]]];
DrawRope[context, number, statsX+20, statsY-30];
DrawRope[context, " - timeouts - ", statsX+60, statsY-30];
number _ Convert.ValueToRope[[signed[game.timeouts[visitors]]]];
DrawRope[context, number, statsX+185, statsY-30];
SELECT game.down FROM
1 => number _ "first down and ";
2 => number _ "second down and ";
3 => number _ "third down and ";
4 => number _ "fourth down and ";
ENDCASE => number _ ">>>> down and ";
DrawRope[context, number, statsX-20, statsY-45];
IF game.firstDownMarker <= 0 OR game.firstDownMarker >= 100 THEN number _ "goal"
ELSE {toGo: INTEGER;
toGo _ Real.RoundI[ABS[game.scrimmage-game.firstDownMarker]];
number _ IF toGo < 1 THEN "inches" ELSE Convert.ValueToRope[[signed[toGo]]]};
context.DrawRope[number];
context.DrawRope[" to go on the "];
number _ Convert.ValueToRope[[signed[
MIN[Real.RoundI[game.scrimmage], Real.RoundI[100-game.scrimmage]]]]];
context.DrawRope[number];
context.DrawRope[" yard line."];
context.SetCP[statsX - 20, statsY - 60];
IF game.penalties # [none, none] THEN {DisplayPenalties[context]; RETURN};
context.SetCP[statsX + 60, statsY - 60];
SELECT game.score[home] - oldScore[home] FROM
7 => FlashMessage["TOUCHDOWN!  "];
3 => FlashMessage["FIELD GOAL!  "];
2 => FlashMessage["SAFETY!  "];
ENDCASE;
SELECT game.score[visitors] - oldScore[visitors] FROM
7 => FlashMessage["TOUCHDOWN!  "];
3 => FlashMessage["FIELD GOAL!  "];
2 => FlashMessage["SAFETY!  "];
ENDCASE;
END;

DisplayPenalties: PROC[context: Graphics.Context] =
BEGIN
DisplayPenalty[context, game.penalties[home], home];
IF game.penalties[visitors] # none THEN {
IF game.penalties[home] # none THEN context.DrawRope[" and "];
DisplayPenalty[context, game.penalties[visitors], visitors]};
context.DrawRope[": "];
SELECT game.penaltyState FROM
accepted => context.DrawRope["ACCEPTED."];
declined => context.DrawRope["DECLINED."];
canceled => context.DrawRope["CANCELED."];
ENDCASE;
END;

DisplayPenalty: PROC[context: Graphics.Context, penalty: Penalty, team: Team] =
BEGIN
SELECT penalty FROM
none => RETURN;
offSides => context.DrawRope["offsides "];
forwardPass => context.DrawRope["illegal forward pass "];
grounding => context.DrawRope["intentional grounding "];
delayOfGame => context.DrawRope["delay of game "];
ENDCASE => context.DrawRope["illegal procedure "];
SELECT team FROM
home => context.DrawRope["against home"];
visitors => context.DrawRope["against visitors"];
ENDCASE;
END;

DisplayClock: PROCEDURE[context: Graphics.Context, clock: INTEGER, erase: BOOLEAN] =
BEGIN
stream: IO.STREAM _ IO.ROS[];
IF erase THEN Erase[context, [statsX+89, statsY-16, statsX + 150, statsY-3]]; 
stream.PutF["%2d:%02d", IO.int[clock/60], IO.int[clock MOD 60]];
DrawRope[context, IO.GetOutputStreamRope[stream], statsX+90, statsY-15];
stream.Close[];
END;

DisplayPlayer: PROC[context: Graphics.Context, player: Player, erase: BOOLEAN] =
BEGIN
i: Position;
x, y: REAL;
same: BOOLEAN;
char: CHARACTER;
i _ player.position;
x _ Real.RoundI[player.x*yard];
y _ Real.RoundI[player.y*yard];
char _ IF TeamOf[i] = home THEN 'O ELSE 'X;
same _ (x = shadow[i].oldX AND y = shadow[i].oldY AND char = shadow[i].char);
IF erase AND same THEN RETURN;
IF erase AND ~same THEN DrawChar[context, 
shadow[i].char, shadow[i].oldX, shadow[i].oldY];
DrawChar[context, char, x, y];
shadow[i].oldX _ x;
shadow[i].oldY _ y;
shadow[i].char _ char;
END;

DisplayBall: PROC[context: Graphics.Context, erase: BOOLEAN] =
BEGIN
x, y: REAL;
same: BOOLEAN;
x _ Real.RoundI[game.player[game.ballCarrier].x*yard];
y _ Real.RoundI[game.player[game.ballCarrier].y*yard];
same _ (x = shadow[ball].oldX AND y = shadow[ball].oldY);
IF erase AND same THEN RETURN;
IF erase AND ~same THEN DrawChar[context, 
'*, shadow[ball].oldX, shadow[ball].oldY];
DrawChar[context, '*, x, y];
shadow[ball].oldX _ x;
shadow[ball].oldY _ y;
END;

FlashMessage: PROC[message: Rope.ROPE] = INLINE {
MessageWindow.Append[message, TRUE];
MessageWindow.Blink[]};

DrawLine: PROC[context: Graphics.Context, x1, y1, x2, y2: REAL] =
INLINE {context.SetCP[x1, y1]; context.DrawTo[x2, y2]};

DrawChar: PROC[context: Graphics.Context, char: CHARACTER, x, y: REAL] =
INLINE {context.SetCP[x, y]; context.DrawChar[char]};

DrawRope: PROC[context: Graphics.Context, rope: Rope.ROPE, x, y: REAL] =
INLINE {context.SetCP[x, y]; context.DrawRope[rope]};


old: ARRAY [0..6] OF Pattern;
Pattern: TYPE = RECORD[x1, y1, x2, y2: REAL, command: Command];

ErasePlay: PROC[context: Graphics.Context, erase: BOOLEAN] =
BEGIN
Graphics.SetStipple[context, grey];
FOR i: CARDINAL IN [0..6] DO
IF erase THEN DrawPattern[context, old[i]]; 
old[i] _ [0, 0, 0, 0, [stop, [null[ ]]]]; 
ENDLOOP;
Graphics.SetStipple[context, black];
END;

DisplayPlay: PROC[context: Graphics.Context] =
BEGIN
new: Pattern;
Graphics.SetStipple[context, grey];
FOR i: CARDINAL IN [0..6) DO
new.command _ planned.commands[i];
new.x1 _ game.player[Add[IF myTeam = home THEN HQB ELSE VQB, i]].x;
new.y1 _ game.player[Add[IF myTeam = home THEN HQB ELSE VQB, i]].y;
[new.x2, new.y2] _ GetTarget[new.command.target, new.y1];
IF Equal[old[i], new] THEN LOOP;
DrawPattern[context, old[i]];
DrawPattern[context, new];
old[i] _ new;
ENDLOOP;
Graphics.SetStipple[context, black];
new.command _ planned.ball;
new.x1 _ new.y1 _ 0;
[new.x2, new.y2] _ GetTarget[planned.ball.target, game.player[ball].y];
IF Equal[old[6], new] THEN RETURN;
DrawPattern[context, old[6]];
DrawPattern[context, new];
old[6] _ new;
END;

d: REAL _ 4;
block: REAL _ 2.5;
zone: REAL _ 10;

DrawPattern: PROC[context: Graphics.Context, p: Pattern] =
BEGIN -- assumes that the paintMode is 'invert'
r: REAL _ 1;
IF p.command.target = [player[ball]] THEN RETURN;
SELECT p.command.action FROM
stop => RETURN;
pass, kick => {DrawChar[context, '+, p.x2*yard, p.y2*yard]; RETURN};
ENDCASE => DrawLine[context, p.x1*yard+d, p.y1*yard+d, p.x2*yard+d, p.y2*yard+d];
SELECT p.command.target.type FROM
player => {
DrawLine[context, (p.x2-r)*yard+d, p.y2*yard+d, p.x2*yard+d, (p.y2+r)*yard+d];
DrawLine[context, (p.x2+r)*yard+d, p.y2*yard+d, p.x2*yard+d, (p.y2+r)*yard+d];
DrawLine[context, (p.x2-r)*yard+d, p.y2*yard+d, p.x2*yard+d, (p.y2-r)*yard+d];
DrawLine[context, (p.x2+r)*yard+d, p.y2*yard+d, p.x2*yard+d, (p.y2-r)*yard+d]};
relative, absolute => {
IF p.command.action = run THEN {
DrawChar[context, 'o, p.x2*yard+2, p.y2*yard+2]; RETURN};
IF game.offense # myTeam THEN r _ zone ELSE r _ block;
DrawLine[context, (p.x2-r)*yard+d, (p.y2-r)*yard+d, (p.x2-r)*yard+d, (p.y2+r)*yard+d];
DrawLine[context, (p.x2-r)*yard+d, (p.y2+r)*yard+d, (p.x2+r)*yard+d, (p.y2+r)*yard+d];
DrawLine[context, (p.x2+r)*yard+d, (p.y2+r)*yard+d, (p.x2+r)*yard+d, (p.y2-r)*yard+d];
DrawLine[context, (p.x2+r)*yard+d, (p.y2-r)*yard+d, (p.x2-r)*yard+d, (p.y2-r)*yard+d]};
ENDCASE;
END;

GetTarget: PROC[target: Target, oldY: REAL] RETURNS[x, y: REAL] =
BEGIN
goal: INTEGER _ Goal[Opponent[myTeam], game.quarter];
WITH t: target SELECT FROM
player => RETURN[game.player[t.position].x, game.player[t.position].y];
relative => RETURN[
game.scrimmage + (IF goal > 50 THEN t.x ELSE - t.x), 
fieldWidth/2 + t.y];
absolute => RETURN[t.x, t.y];
goal => RETURN[goal, oldY];
ENDCASE => RETURN[0, 0];
END;

Equal: PROC[a, b: Pattern] RETURNS[BOOLEAN] =
INLINE BEGIN
IF a.x1 # b.x1 THEN RETURN[FALSE];
IF a.x2 # b.x2 THEN RETURN[FALSE];
IF a.y1 # b.y1 THEN RETURN[FALSE];
IF a.y2 # b.y2 THEN RETURN[FALSE];
IF a.command.action # b.command.action THEN RETURN[FALSE];
WITH t: a.command.target SELECT FROM
null => IF b.command.target # t THEN RETURN[FALSE];
goal => IF b.command.target # t THEN RETURN[FALSE];
player => IF b.command.target # t THEN RETURN[FALSE];
relative => IF b.command.target # t THEN RETURN[FALSE];
absolute => IF b.command.target # t THEN RETURN[FALSE];
ENDCASE => ERROR;
RETURN[TRUE];
END;

Add: PROCEDURE[p: Position, i: INTEGER] RETURNS[Position] =
INLINE {RETURN[LOOPHOLE[LOOPHOLE[p, INTEGER]+i]]};


Initialize[];

END . . .





„FootballViewer.mesa
Last Edited by: John Maxwell on: January 28, 1983 11:20 am

******************************************************************
Viewers Class Interface
******************************************************************
coordSys: top,
remove the player from the game
[self: Viewer, input: LIST OF REF ANY]
N.B.  Called at Process.priorityForeground!
select out the coordinates
select an atom
offField => FootballMaster.KickOff[myTeam];
IF (input.rest = NIL OR input.rest.first # $Deselect)
AND ABS[game.player[selected].x - x] < 3
AND ABS[game.player[selected].y - y] < 3 THEN RETURN;
******************************************************************
Viewers Paint Proc
******************************************************************

******************************************************************
Display Procedures
******************************************************************
			(home)
HOME*  First Quarter  VISITORS
7         7:14            14
4    - timeouts -        4
first down and goal on the 4
first line
second line
(clock drawn separately)
third line
fourth line
display status
IF game.possessor # game.offense AND game.pass 
THEN {context.DrawRope["INTERCEPTION!  "]; Flash[context, scoreboard]};

******************************************************************
Displaying the planned play
******************************************************************
�Ên˜Jš
œ™Jš
œ:™:J˜šÏk	œ
˜
Jšœ�œ˜J˜J˜Jšœ�œ˜1šœ	�œ˜J˜DJ˜=—Jšœ�œ	˜Jšœ�œ˜!Jš�œ
�œ3�œ�œ˜HJšœ�œ=˜HJšœ�œ˜*Jšœ�œ˜#Jšœ�œ
˜Jšœ�œ�œ
˜7Jš�œ
�œ˜Jšœ�œ5˜BJšœ	�œ4˜Bšœ�œ˜J˜0J˜%—Jšœ
�œ;˜JJšœ�œ+˜<J˜—J˜šœ�˜š�œ
˜J˜EJšœ�œ-�œ˜JJ˜)—Jš�œ˜—Jš�œ
�œ"˜,J˜Jšœ�œ˜Jšœ�œ˜Jšœ
�œ˜Jšœ�œ˜$Jšœ�œ
�œ
�œ
�œ�	œ˜DJ˜šÏn
œ�	œ˜Jš
�˜J˜Jšœ�œ˜š�œ
�œ	�˜J˜Jš�œ
˜—J˜
J˜J˜FJš�œ
˜J˜—šž
œ�	œ˜Jš
�˜Jš�œ˜J˜J˜eJ˜OJ˜MJ˜OJ˜IJ˜IJ˜I˜JšœS�œ˜Z—J˜MJ˜CJ˜LJ˜IJš�œ
˜J˜—šÏbœ�œ˜=Jšœ�œ�œ	�œ	˜9J˜)J˜—JšŸ	œ�œ�œ�œ˜DšŸœ�œ˜%Jšœ�œ&˜5š�œ�œ˜J˜*J˜2J˜!—š�œ˜Jš�œ$˜(Jš�œ'˜+J˜——J˜Jšœ
�œ�œ
˜J˜šŸœ˜Jš�œ
�œ
Ïc+˜9Jšœ�œ
˜Jšœ�œ
˜Jšœ�œ�œ
˜J˜*Jšœ	�œ#˜.Jš�œ�œ	�œ#˜IJš�œ�œ˜*Jš�œ�œ˜)š�œ�œ˜J˜š�œ�œ
�œ�˜Jšœ	�œ
˜˜*J˜!Jšœ�œ�œ�œ˜1—š�œ�œ˜)Jš�œ"�œ
�œ
˜0—Jš�œ
˜—š�œ�œ˜Jšœ	�œ
˜J˜J˜$˜*J˜ Jšœ�œ�œ�œ˜1—Jš�œ�œ
�œ
�œ˜9—Jšœ�œ˜—š�œ
�œ
�œ�œ˜*Jšœ�œ�œ
˜#˜ J˜˜J˜Jšœ�œ
˜Jšœ�œ
˜
Jšœ�œ˜—Jšœ�œ˜—J˜ J˜#Jš�œ�œ�œ˜D—Jš�œ
�œ�œ˜Jš�œ
˜J˜—J™Jš
œB™BJš
œ™Jš
œB™BJšœ
�œ˜!Jšœ�œ�œ
˜J˜šžœ�	œ˜Jš
�˜J˜Lšœ)�œ
˜-˜šœ ,˜>Jšœ ˜&Jšœ +˜;Jšœ 6˜KJšœ	�œ ˜#Jšœ  ˜1Jšœ 0˜DJš
œ™Jšœ *˜DJ˜———J˜6Jš�œ
˜J˜—J˜JšŸœ�œ˜,šŸ	œ˜'Jš�œ
�˜
Jš
œ™Jš�œ
˜J˜—šŸœ˜"Jš�œ
�˜
Jš
œ&™&Jš
œ+™+Jšœ�œ˜J˜š�œ�˜ Jš�œ	�œ
�œ
�œ
˜Jš
œ™š�œ
�œ
�˜JšœG�œ˜MJš�œ
˜—Jš
œ™š�œ
�˜Jšœa�œ˜i˜Jšœ'�œ˜-J˜—˜
Jšœ'�œ˜.J˜—J˜%J˜+šœ	�œ
˜Jš�œ$ ˜<Jš�œ,˜0—šœ	�œ
˜Jš�œ$˜(Jš�œ,˜0—šœ	�œ�˜Jš
œ+™+J˜$Jš�œ'˜.—J˜/J˜Jšœ
�œ�œ/�œ˜VJšœ�œ�œ0˜O˜J˜5Jš�œ�œ
�œ
˜Jš�œ�œ˜(š
œ5™5Jš
œ(™(Jš
œ5™5—š�œ˜Jš�œ0˜4Jš�œ3˜7——Jšœ�œ�œ/˜WJšœ	�œ�œ(˜HJšœ�œ�œ(�œ˜PJ˜;Jš�œ
˜—Jš�œ
˜—Jš�œ
˜J˜—J˜šž	œ�œ�œ�œ
�œ�œ˜1Jš
�˜J˜J˜Jš�œ˜Jš�œ
˜J˜—š
žœ�œ�œ�œ	�œ˜TJš
�˜Jšœ�œ˜š�œ
�œ	�˜Jš�œ�œ
�œ
˜Jšœ�œ�œ˜=Jš�œ�œ˜,Jš�œ
˜—Jš�œ
�œ˜"Jš�œ
˜J˜—J˜Jš
œB™BJš
œ™Jš
œB™BJ˜Jšœ�œ
˜
Jšœ�œ˜J˜Jšœ
�œ˜J˜#Jšœ
�œ�œ
�œ	˜(Jšœ�œ�œ˜0Jšœ
�œ�œ
�œ
˜)Jšœ�	œ
˜J˜˜"Jš�
œ
 A˜OJšœ�œ
˜
Jšœ�œ�œ˜$Jšœ
�œ�œ
˜Jšœ�œ�œ
˜"Jš�œ
�œ
�œ
˜˜CJ˜—J˜J˜,Jšœ"�œ�œ
˜7Jš�œ
�œ%�œ˜=šœ(�œ˜@Jš�œ�œ˜4Jš�œ�œ˜9Jš�œ�œ"˜=Jš�œ
˜—Jš�œ�œ%˜=š�œ�œ˜*Jš�œ1˜5—J˜,š�œ
�œ�œ˜?Jš�œ#˜'—Jš�œ�œ˜1š�œ
�œ	�˜J˜6Jš�œ
˜—J˜#š�œ�œ˜@Jš�œ3˜7—Jš�œ�œ#˜Cš�œ"�œ˜Cš�œ)�œ˜2Jšœ:�œ˜@J˜——J˜J˜J˜J˜J˜J˜J˜"Jš�œ
˜J˜—J˜šžœ�œ
�œ6�œ˜RJš
�˜J˜$Jšœ �œ˜+J˜J˜$Jš�œ
˜J˜—šžœ�œ0˜;Jš
�˜J˜,š�œ˜Jš�œ0˜4Jš�œ,˜0—J˜J˜+J˜1Jš�œ
˜J˜—š
žœ�œ"�œ�œ
�œ˜QJš
�˜š�œ
�œ
�˜˜'Jšœ�œ
�œ˜&—˜+J˜(—˜(Jšœ�œ
�œ˜&—˜,J˜(—Jš�œ
˜—š�œ"�œ
˜)J˜$—š�œ(�œ
˜/J˜(—Jš�œ˜Jš�œ
˜J˜—J™Jš
œB™BJš
œ™Jš
œB™BJ˜Jšœ�œ˜Jšœ�œ˜Jšœ�œ˜Jšœ�œ˜Jšœ�œ˜%J˜QJ˜J˜šžœ�œ#�œ˜?Jš
�˜Jšœ�œ
˜Jšœ�œ
˜Jš�œ�œ-˜:š�œ�œ˜J˜,J˜0J˜7J˜,—J˜J˜,J˜HJ˜,J˜,š�œ�œ
�œ	�˜J˜J˜J˜J˜&J˜*š�œ�œ�œ˜1Jš�œ$�œ˜@—J˜"J˜"Jš�œ
˜—š�œ�œ˜J˜#J˜=J˜DJ˜%—Jš�œ
˜J˜—šžœ�œ#�œ˜@Jš
�˜Jš
œ	™	Jš
œ™Jš
œ™Jš
œ™Jš
œ™Jšœ
�œ
˜Jš�œ�œ˜)Jšœ ˜.Jš
œ
™
š�œ˜Jš�œ2˜6Jš�œ7˜;—J˜š�œ˜Jš�œ˜Jš�œ˜ —š�œ�˜J˜-J˜,J˜,J˜,J˜+Jš�œ�œ
˜—š�œ˜Jš�œ˜#Jš�œ ˜$—Jš
œ™J˜9J˜0Jš
œ™J˜>J˜1Jš
œ
™
J˜<J˜0J˜:J˜@J˜1Jš
œ™š�œ�˜J˜ J˜!J˜ J˜!Jš�œ˜%—J˜0š�œ�œ�œ˜Pš�œ�œ
˜Jšœ�œ'˜=Jšœ	�œ
�œ
�œ&˜M——J˜J˜#˜%Jš�œB˜E—J˜J˜ Jš
œ™J˜(Jš�œ�œ�œ˜JJ˜(Jš
œ/™/Jš
œG™Gš�œ#�˜-J˜"J˜#J˜Jš�œ
˜—š�œ+�˜5J˜"J˜#J˜Jš�œ
˜—Jš�œ
˜J˜—šžœ�œ˜3Jš
�˜J˜4š�œ!�œ˜)Jš�œ�œ˜>J˜=—J˜š�œ�˜J˜*J˜*J˜*Jš�œ
˜—Jš�œ
˜J˜—šžœ�œ;˜OJš
�˜š�œ	�˜Jšœ�œ
˜J˜*J˜9J˜8J˜2Jš�œ+˜2—š�œ�˜J˜)J˜1Jš�œ
˜—Jš�œ
˜J˜—šžœ�	œ#�œ	�œ˜TJš
�˜Jš	œ�œ
�œ�œ
�œ˜Jš�œ�œA˜NJšœ�œ�œ�œ˜@Jšœ�œ4˜HJ˜Jš�œ
˜J˜—šž
œ�œ3�œ˜PJš
�˜J˜Jšœ�œ
˜Jšœ�œ
˜Jšœ�	œ
˜J˜J˜J˜Jšœ�œ�œ�œ˜+Jšœ�œ�œ˜MJš�œ�œ�œ
�œ
˜š�œ�œ�œ˜*J˜0—J˜J˜J˜J˜Jš�œ
˜J˜—šžœ�œ#�œ˜>Jš
�˜Jšœ�œ
˜Jšœ�œ
˜J˜6J˜6Jšœ�œ˜9Jš�œ�œ�œ
�œ
˜š�œ�œ�œ˜*J˜*—J˜J˜J˜Jš�œ
˜J˜—šžœ�œ�œ�œ˜1Jšœ�œ˜$J˜J˜—šžœ�œ,�œ˜AJš�œ1˜7J˜—šžœ�œ"�	œ�œ˜HJš�œ/˜5J˜—šžœ�œ'�œ�œ˜HJš�œ/˜5J˜—J™Jš
œB™BJš
œ™Jš
œB™BJ˜Jšœ�œ�œ	˜Jšœ	�œ�œ�œ˜?J˜šž	œ�œ#�œ˜<Jš
�˜J˜#š�œ�œ
�œ�˜Jš�œ�œ˜,J˜*Jš�œ
˜—J˜$Jš�œ
˜J˜—šžœ�œ˜.Jš
�˜J˜
J˜#š�œ�œ
�œ�˜J˜"Jšœ�œ�œ
�œ
�œ
�œ˜CJšœ�œ�œ
�œ
�œ
�œ˜CJ˜9Jš�œ�œ
�œ
˜ J˜J˜J˜
Jš�œ
˜—J˜$J˜J˜J˜GJš�œ�œ
�œ
˜"J˜J˜J˜
Jš�œ
˜J˜Jšœ�œ˜Jšœ�œ˜Jšœ�œ˜J˜šžœ�œ)˜:Jš�œ
 )˜/Jšœ�œ˜Jš�œ#�œ
�œ
˜1š�œ�˜Jšœ�œ
˜Jšœ<�œ˜DJš�œJ˜Q—š�œ�˜!˜J˜NJ˜NJ˜NJ˜O—˜š�œ�œ˜ Jšœ1�œ˜9—Jš�œ�œ
�œ˜6J˜VJ˜VJ˜VJ˜WJš�œ
˜——Jš�œ
˜J˜——š
ž	œ�œ�œ�œ�œ˜AJš
�˜Jšœ�œ(˜5š�œ�œ
�˜Jšœ
�œ7˜Gšœ�œ
˜Jšœ�œ�œ�œ	˜5J˜—Jšœ�œ˜Jšœ�œ
˜Jš�œ�œ˜—Jš�œ
˜J˜—šžœ�œ�œ
�œ˜-Jš�œ
�˜Jš�œ
�œ
�œ
�œ˜"Jš�œ
�œ
�œ
�œ˜"Jš�œ
�œ
�œ
�œ˜"Jš�œ
�œ
�œ
�œ˜"Jš�œ%�œ
�œ
�œ˜:š�œ�œ
�˜$Jš	œ�œ�œ
�œ
�œ˜3Jš	œ�œ�œ
�œ
�œ˜3Jš	œ
�œ�œ
�œ
�œ˜5Jš	œ�œ�œ
�œ
�œ˜7Jš	œ�œ�œ
�œ
�œ˜7Jš�œ�œ
˜—Jš�œ
�œ˜
Jš�œ
˜J˜—šžœ�	œ�œ�œ˜;Jš
�œ�œ
�œ
�œ�œ˜2J˜—J˜J˜
J˜Jš�œ˜	J˜J˜J˜J˜J˜—…—Upqb