[Cyan]<CedarChest6.1>MazeWar>MazeWarPlayerInsides.Mesa!3

[Cedar]<CedarChestŽ>Top>MazeWar.df=>MazeWarPlayerInsides.Mesa

Mike Spreitzer July 10, 1986 9:36:07 pm PDT

Hal Murray, March 16, 1986 7:27:33 pm PST

DIRECTORY BasicTime, Commander, Icons, Imager, ImagerPixelMap, Labels, MazeWarFinder, MazeWarPlayer, MazeWarPlayerRpcControl, Rope, RPC, ViewerClasses;

MazeWarPlayerInsides: CEDAR DEFINITIONS =

BEGIN

ROPE: TYPE = Rope.ROPE;

Viewer: TYPE = ViewerClasses.Viewer;

Context: TYPE = Imager.Context;

Bitmap: TYPE = ImagerPixelMap.PixelMap;

nilBitmap: Bitmap = [0, 0, 0, 0, 0, 0, NIL];

Label: TYPE = Labels.Label;

PlayerId: TYPE = MazeWarFinder.PlayerId;

BasicPlayer: TYPE = MazeWarFinder.BasicPlayer;

BasicPlayerList: TYPE = MazeWarFinder.BasicPlayerList;

Angle: TYPE = MazeWarPlayer.Angle;

PlayerInterface: TYPE = MazeWarPlayerRpcControl.InterfaceRecord;

MazeView: TYPE = REF MazeViewRep;

MazeViewRep: TYPE = RECORD [

asRope: ROPE,

players, differentMazePlayers: LIST OF Player ← NIL,

container, maze: Viewer ← NIL,

rows, cols: INTEGER,

topX, topY, inX, inY: Number,

squares: SEQUENCE size: CARDINAL OF Square];

Square: TYPE = RECORD [

occupants: PlayerList ← NIL,

open: BOOLEAN ← TRUE,

changed: BOOLEAN ← FALSE];

PlayerList: TYPE = LIST OF Player;

Player: TYPE = REF PlayerRep;

PlayerRep: TYPE = RECORD [

id: PlayerId ← -1,

ir: PlayerInterface,

callFailures: INTEGER ← 0,

instanceName: ROPE,

destroyed, pausing, --blinking,-- shot, quivering: BOOLEAN ← FALSE,

quiverTill: BasicTime.Pulses,

row, col, angle, peek: INTEGER ← 0,

srow, scol, sangle, speek: INTEGER ← -1,

distance, sdistance: INTEGER ← -1,

mv: MazeView,

name: ROPE,

score: INTEGER ← 0,

nameLabel, scoreLabel: Label,

pics: PlayerPics,

announce: BOOL ← FALSE,

announceLock: REF MONITORLOCK,

announceChange: CONDITION,

announceShot: BOOL ← FALSE];

LocatedBitmap: TYPE = RECORD [

bitmap: Bitmap ← nilBitmap,

fOrigin, sOrigin: INTEGER ← 0];

pieces: ARRAY [0 .. MaxDistance] OF ARRAY Piece OF LocatedBitmap;

Piece: TYPE = {LeftFilled, LeftGap, LeftEdge, RightFilled, RightGap, RightEdge, HorEdges};

Index: PROC [mv: MazeView, row, col: INTEGER] RETURNS [index: INTEGER] = INLINE {index ← row * mv.cols + col};

Direction: PROC [mv: MazeView, drow, dcol: INTEGER] RETURNS [dIndex: INTEGER] = INLINE {dIndex ← Index[mv, drow, dcol]};

dToA: ARRAY [-1 .. 1] OF ARRAY [-1 .. 1] OF [0 .. 4] =

[[4, 3, 4], [2, 4, 0], [4, 1, 4]];

aToD: ARRAY [0 .. 4) OF RECORD [drow, dcol: INTEGER] =

[[0, 1], [1, 0], [0, -1], [-1, 0]];

tvd: INTEGER = 8;

Number: TYPE = INT;

Pt3: TYPE = RECORD [x, y, z: Number];

r: Number = 1200;

s: Number = 300;

dz: Number = r*2/s;

z1: Number = dz;

hither: Number = 3*dz/4;

w: Number = r/hither;

peekLeft: INTEGER = 3;

peekRight: INTEGER = 1;

myself: Player;

playerNumber: CARDINAL;

myInstance: ROPE;

topviews: ARRAY Angle OF Bitmap;

PlayerPics: TYPE = REF PlayerPicsRep;

PlayerPicsRep: TYPE = RECORD [

name: ROPE,

pics: ARRAY [1..MaxDistance] OF ARRAY Angle OF Bitmap];

MaxDistance: INTEGER = 29;

defaultPlayerPics: PlayerPics;

mazeViewerFlavor: ATOM;

mazeViewerClass: ViewerClasses.ViewerClass;

mazeWarriorIcon: Icons.IconFlavor;

exportedPlayer: BOOLEAN;

paints: INTEGER;

clippable: BOOLEAN;

blt: BOOLEAN;

forkNotify: BOOLEAN;

quiverTime: BasicTime.Pulses;

shownPlayers: PlayerList;

StartPlayer, StopPlayer: Commander.CommandProc;

MakeNewPlayer: PROC [name, instance, picsSource, mazeSource: ROPE] RETURNS [errmsg: ROPE ← NIL];

EnsurePlayer: PROC [bp: BasicPlayer] RETURNS [q: Player];

FindPlayer: PROC [pl: PlayerList, id: PlayerId] RETURNS [p: Player];

Filter: PROC [org: PlayerList, rem: Player] RETURNS [ohne: PlayerList];

PickAPlace: PROC [mv: MazeView] RETURNS [row, col: INTEGER];

DrawHall: PROC [context: Context, mv: MazeView, row, col, drow, dcol: INTEGER, angle: Angle];

AddScoring: PROC [vp, p: Player];

AddPlayerAt: PROC [mv: MazeView, ir: PlayerInterface, instanceName: ROPE, id: PlayerId, name: ROPE, row, col: INTEGER, angle: Angle, score: INTEGER, pp: PlayerPics] RETURNS [p: Player];

Peek: PROC [peek, row, col, angle: INTEGER] RETURNS [prow, pcol, pdrow, pdcol, pangle: INTEGER];

Visible: PROC [mv: MazeView, frow, fcol, fdrow, fdcol, trow, tcol: INTEGER] RETURNS [distance: INTEGER];

Visibility: PROC [from, to: Player] RETURNS [distance: INTEGER];

NormalizePlayerPicsRoot: PROC [ROPE] RETURNS [ROPE];

GetPlayerPics: PROC [root: ROPE] RETURNS [pp: PlayerPics];

LosePlayerPics: PROC [root: ROPE];

IncrPaint: PROC [p: Player];

PaintMaze: ViewerClasses.PaintProc--PROC [self: Viewer, context: Graphics.Context, whatChanged: REF ANY, clear: BOOL]--;

AnnounceStatus: PROC [shot: BOOLEAN];

NoticeCall: PROC [p: Player, ok: BOOLEAN];

HandleCallFailure: PROC [callee: Player, why: RPC.CallFailure] RETURNS [handled: BOOLEAN ← FALSE];

CallUnderMonitor1: PROC [PROC];

END.