![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to monsters.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [Research Unix] / researchv9 / jtools / src / demo / pacman|
Return to monsters.c CVS log | Up to [Research Unix] / researchv9 / jtools / src / demo / pacman |
1.1 root 1: /*----------------------------------------------------------------------*/
2: /* */
3: /* PACMAN for BBN BitGraphs */
4: /* */
5: /* File: monsters.c68 */
6: /* Contents: monster definitions and manipulation routines */
7: /* Author: Bob Brown (rlb) */
8: /* Purdue CS */
9: /* Date: May, 1982 */
10: /* Description: Initialization, movement, drawing routines. */
11: /* Interacts with several pacman routines. */
12: /* */
13: /*----------------------------------------------------------------------*/
14:
15: #include "style.h"
16: #include "pacman.h"
17:
18: /*
19: ** Monster structure initialization
20: **
21: ** The following lists the static part of the monster structures, in the order
22: ** that they leave the stable.
23: */
24:
25: monster Monster[MAXMONSTER] = {
26: { 45, 36, MOVEUP, 0, 5, -10 },
27: { 45, 41, MOVEUP, 24, 0, -20 }, /* fast, but stupid */
28: { 39, 33, MOVEDOWN, 52, 9, 0 },
29: { 39, 48, MOVEDOWN, 80, 13, 5 }, /* slow, but methodical */
30: };
31:
32: /*
33: ** monnew - create a new set of monsters.
34: **
35: ** Called once at the beginning of a game.
36: */
37:
38: monnew()
39: {
40: register monster *mptr;
41: for ( mptr=Monster ; mptr < &Monster[MAXMONSTER] ; mptr++ )
42: mptr->time = Monbase + mptr->inittime;
43: }
44:
45: /*
46: ** moninit - reinitialize the monsters.
47: **
48: ** Called at the beginning of each wave or when Pacman dies.
49: */
50:
51: moninit()
52: {
53: register monster *mptr;
54: for ( mptr=Monster ; mptr < &Monster[MAXMONSTER] ; mptr++ ) {
55: if ( mptr == Monster ) {
56: mptr->row = STARTROW;
57: mptr->col = STARTCOL;
58: mptr->dir = MOVERIGHT;
59: mptr->movestate = ROAMING;
60: } else {
61: mptr->row = mptr->initrow;
62: mptr->col = mptr->initcol;
63: mptr->dir = mptr->initdir;
64: mptr->movestate = STABLED;
65: }
66: mptr->mrow = SCtoMZ(mptr->row);
67: mptr->mcol = SCtoMZ(mptr->col);
68: mptr->state = DANGEROUS;
69: mptr->delay = mptr->initdelay;
70: mptr->font = MONSTERCHAR[0];
71: Monseeking = FALSE;
72: mondraw(mptr);
73: eladd(mptr->time+STARTDELAY,monmove,(char *)mptr);
74: }
75: }
76: /*
77: ** monfont - change the font of the monsters.
78: **
79: ** Called when Pacman swallows a pill or starts getting weaker.
80: */
81:
82: monfont(chr)
83: char chr;
84: {
85: register monster *mptr;
86: for ( mptr=Monster ; mptr < &Monster[MAXMONSTER] ; mptr++ ) {
87: monfont1(mptr,chr);
88: }
89: }
90:
91: monfont1(mptr,chr)
92: register monster *mptr;
93: char chr;
94: {
95: mondraw(mptr);
96: mptr->font = chr;
97: mondraw(mptr);
98: }
99: /*
100: ** moncomp - turn on/off (i.e. complement) all the monsters
101: */
102:
103: moncomp()
104: {
105: register monster *mptr;
106: for ( mptr=Monster ; mptr < &Monster[MAXMONSTER] ; mptr++ )
107: mondraw(mptr);
108: }
109:
110: /*
111: ** mondraw - complement a single monster
112: */
113:
114: mondraw(mptr)
115: register monster *mptr;
116: {
117: blt40(mptr->font,mptr->row,mptr->col,INVERT);
118: }
119:
120: /*
121: ** Move a particular monster
122: **
123: ** This routine moves a given monster based its current movestate
124: */
125:
126: int
127: monmove(mptr)
128: register monster *mptr;
129: {
130: register move *newmove;
131: int newdelay;
132: /*
133: ** Motion depends on the monster movestate
134: */
135: mondraw(mptr);
136: switch ( mptr->movestate ) {
137: /*
138: ** In the center box - won't come out until time delay elapses and
139: ** the pacman isn't dangerous (fixes ambush bug).
140: */
141: case STABLED:
142: newmove = bounce(mptr);
143: if ( mptr->delay > 0 )
144: mptr->delay = max(mptr->delay-1,0);
145: else
146: mptr->movestate = LEAVING;
147: break;
148: case LEAVING:
149: newmove = tostart(mptr);
150: if ( newmove->row == STARTROW && newmove->col == STARTCOL )
151: mptr->movestate = ROAMING;
152: break;
153: /*
154: ** If roaming about, switch to seeking if someone sees him and fall
155: ** into seeking code.
156: */
157: case ROAMING:
158: if ( Monseeking )
159: mptr->movestate = SEEKING;
160: else if ( seeshim(mptr) ) {
161: Monseeking = TRUE;
162: mptr->movestate = SEEKING;
163: } else {
164: newmove = dumbmove(mptr);
165: break;
166: }
167: /*
168: ** When seeking the pacman, they may always make a random move. if the
169: ** Pacman is powerful, then they move away if edible, else random.
170: */
171: case SEEKING:
172: if ( grand(0,100) < Seekprob+mptr->bonus && !Pacman.safe && !(Pacman.power>0 && mptr->state==DANGEROUS))
173: newmove = seekmove(mptr);
174: else
175: newmove = dumbmove(mptr);
176: break;
177: case HOMING:
178: newmove = todoor(mptr);
179: if ( newmove->row == STARTROW && newmove->col == STARTCOL )
180: mptr->movestate = HOMING2;
181: break;
182: case HOMING2:
183: newmove = tostable(mptr);
184: if ( newmove->row==mptr->initrow && newmove->col==mptr->initcol ) {
185: mptr->movestate = STABLED;
186: mptr->state = DANGEROUS;
187: mptr->font = MONSTERCHAR[mptr->initdir];
188: newmove->dir = mptr->initdir;
189: mptr->delay = Pacman.power+(mptr-Monster)*24;
190: }
191: break;
192: }
193: /*
194: ** Move the monster on the screen
195: */
196: mptr->row = newmove->row;
197: mptr->col = newmove->col;
198: mptr->dir = newmove->dir;
199: mptr->mrow = SCtoMZ(mptr->row);
200: mptr->mcol = SCtoMZ(mptr->col);
201: if ( mptr->state == DANGEROUS )
202: mptr->font = MONSTERCHAR[mptr->dir];
203: mondraw(mptr);
204: /*
205: ** Check for collision with the pacman
206: */
207: if ( mptr->state == DANGEROUS && collide(mptr) && Pacman.alive ) {
208: pacdie();
209: return;
210: }
211: /*
212: ** The time till next move depends on whether the monster is alive,
213: ** or is in the slow corridor, or is weakened by the pacman's power.
214: */
215: newdelay = mptr->state==DEAD ? EYESDELAY :
216: inslow(mptr->row,mptr->col) ? Pacman.time+SLOWDELTA :
217: mptr->time+Pacman.power*POWERDELAY;
218:
219: eladd(newdelay,monmove,mptr);
220: }
221: /*
222: ** Simplest of all possible move commands - chooses random direction
223: */
224: move *
225: dumbmove(mptr)
226: register monster *mptr;
227: {
228: register int moves;
229: static move movelist[4];
230: if ( !aligns(mptr->row, mptr->col) ) {
231: onestep(mptr->row,mptr->col,mptr->dir,&movelist[0]);
232: return movelist;
233: }
234: moves=compmoves(mptr->row,mptr->col,movelist,mptr->dir,FALSE);
235: if (moves == 1 )
236: return movelist;
237: return &movelist[grand(0,moves-1)];
238: }
239: /*
240: ** Direction seeking Monster move
241: */
242: move *
243: seekmove(mptr)
244: register monster *mptr;
245: {
246: register int moves;
247: static move movelist[4];
248: if ( !aligns(mptr->row, mptr->col) ) {
249: onestep(mptr->row,mptr->col,mptr->dir,&movelist[0]);
250: return movelist;
251: }
252: /*
253: ** Monsters can reverse once when the pacman swallows a pill -
254: ** Should save it until the pacman is close (unimplemented).
255: */
256: if ( mptr->canreverse ) {
257: moves=compmoves(mptr->row,mptr->col,movelist,0,FALSE);
258: mptr->canreverse = FALSE;
259: } else
260: moves=compmoves(mptr->row,mptr->col,movelist,mptr->dir,FALSE);
261: if (moves == 1 )
262: return movelist;
263: if ( mptr->state == EDIBLE )
264: return furthest(movelist,moves,Pacman.row,Pacman.col);
265: return closest(movelist,moves,Pacman.row,Pacman.col);
266: }
267: /*
268: ** Compute all the possible moves a monster can make.
269: **
270: */
271:
272: compmoves(mrow, mcol, list, curdir, doorok)
273: int mrow, mcol, curdir;
274: register move *list;
275: bool doorok;
276: {
277: register int moves, i;
278: /*
279: ** The list of moves will not include the direction opposite
280: ** of curdir, if it is nonzero. This statement computes the
281: ** opposite direction effeciently.
282: */
283: if ( curdir > 0 )
284: curdir = ((curdir+1)&3)+1;
285: moves = 0;
286: for ( i=1 ; i<=4 ; i++ ) {
287: if ( i == curdir )
288: continue;
289: onestep(mrow,mcol,i,list);
290: if ( (doorok && hitdoor(list->row,list->col)) ||
291: !(hitwall(list->row,list->col,i)||(i==MOVEUP&&hitblk(list->row,list->col))) ) {
292: list++;
293: moves++;
294: }
295: }
296: return moves;
297: }
298: onestep(mrow, mcol, dir, list)
299: register int mrow, mcol, dir;
300: register move *list;
301: {
302: list->col = mcol;
303: list->row = mrow;
304: list->dir = dir;
305: switch ( dir ) {
306: case MOVERIGHT:
307: list->col++;
308: break;
309: case MOVEUP:
310: list->row--;
311: break;
312: case MOVELEFT:
313: list->col--;
314: break;
315: case MOVEDOWN:
316: list->row++;
317: break;
318: }
319: if ( list->col < 0 )
320: list->col += MZtoSC(MAZECOLS);
321: if ( list->col >= MZtoSC(MAZECOLS) )
322: list->col = 0;
323: }
324: /*
325: ** Choose the move from a list the goes in the direction closest to a
326: ** given point.
327: **
328: ** SCREEN COORDINATES
329: */
330: move *
331: closest(list,moves,row,col)
332: register move *list;
333: register int moves;
334: register int row, col;
335: {
336: register move *lptr;
337: int dist, diff, diffr, diffc;
338: dist = 0x7fff;
339: for ( ; moves>0 ; moves-- ) {
340: diffr = iabs(row-list->row);
341: diffc = iabs(col-list->col);
342: diff = max(diffr,diffc);
343: if ( diff < dist ) {
344: lptr = list;
345: dist = diff;
346: }
347: list++;
348: }
349: return lptr;
350: }
351: move *
352: furthest(list,moves,row,col)
353: register move *list;
354: register int moves;
355: register int row, col;
356: {
357: register move *lptr;
358: int dist, diff, diffr, diffc;
359: dist = -1;
360: for ( ; moves>0 ; moves-- ) {
361: diffr = iabs(row-list->row);
362: diffc = iabs(col-list->col);
363: diff = min(diffr,diffc);
364: if ( diff > dist ) {
365: lptr = list;
366: dist = diff;
367: }
368: list++;
369: }
370: return lptr;
371: }
372:
373: /*
374: ** Check if a monster "sees" the pacman
375: */
376: seeshim(mptr)
377: register monster *mptr;
378: {
379: register int rdiff, cdiff;
380: register int i;
381: rdiff = abs(mptr->row - Pacman.row);
382: cdiff = abs(mptr->col - Pacman.col);
383: switch ( mptr->dir ) {
384: case MOVERIGHT:
385: if ( rdiff > 3 || mptr->col > Pacman.col )
386: return FALSE;
387: for ( i=mptr->mcol ; i<Pacman.mcol ; i++ )
388: if ( (Board[mptr->mrow][i]&TYPEMASK) <= WALLMAX )
389: return FALSE;
390: return TRUE;
391: case MOVEUP:
392: if ( cdiff > 3 || mptr->row < Pacman.row )
393: return FALSE;
394: for ( i=mptr->mrow ; i>Pacman.mrow ; i-- )
395: if ( (Board[i][mptr->mcol]&TYPEMASK) <= WALLMAX )
396: return FALSE;
397: return TRUE;
398: case MOVELEFT:
399: if ( rdiff > 3 || mptr->col < Pacman.col )
400: return FALSE;
401: for ( i=mptr->mcol ; i>Pacman.mcol ; i-- )
402: if ( (Board[mptr->mrow][i]&TYPEMASK) <= WALLMAX )
403: return FALSE;
404: return TRUE;
405: case MOVEDOWN:
406: if ( cdiff > 3 || mptr->row > Pacman.row )
407: return FALSE;
408: for ( i=mptr->mrow ; i<Pacman.mrow ; i++ )
409: if ( (Board[i][mptr->mcol]&TYPEMASK) <= WALLMAX )
410: return FALSE;
411: return TRUE;
412: }
413: }
414:
415: /*
416: ** Bounce the monster around in the stable
417: */
418: move *
419: bounce(mptr)
420: register monster *mptr;
421: {
422: static move newmove;
423: onestep(mptr->row, mptr->col, mptr->dir, &newmove);
424: if ( hitwall(newmove.row, newmove.col,mptr->dir) ) {
425: mptr->dir = ((mptr->dir+1)&3)+1;
426: onestep(mptr->row, mptr->col, mptr->dir, &newmove);
427: }
428: return &newmove;
429: }
430: /*
431: ** move a monster closer to the starting position
432: */
433: move *
434: tostart(mptr)
435: register monster *mptr;
436: {
437: static move movelist[4];
438: int moves;
439: moves = compmoves(mptr->row, mptr->col, movelist, mptr->dir, TRUE);
440: if ( mptr->col != STARTCOL )
441: return closest(movelist,moves, mptr->row, STARTCOL);
442: return closest(movelist,moves, STARTROW, STARTCOL);
443: }
444: /*
445: ** Move the monster towards the door
446: */
447: move *
448: todoor(mptr)
449: register monster *mptr;
450: {
451: static move movelist[4];
452: int moves;
453: if ( !aligns(mptr->row, mptr->col) ) {
454: onestep(mptr->row,mptr->col,mptr->dir,&movelist[0]);
455: return movelist;
456: }
457: moves = compmoves(mptr->row, mptr->col, movelist, mptr->dir, FALSE);
458: return closest(movelist,moves, STARTROW, STARTCOL);
459:
460: }
461: /*
462: ** move a monster back to the stable
463: */
464: move *
465: tostable(mptr)
466: register monster *mptr;
467: {
468: static move movelist[4];
469: int moves;
470: moves = compmoves(mptr->row, mptr->col, movelist, mptr->dir, TRUE);
471: if ( mptr->row!=mptr->initrow )
472: return closest(movelist,moves, mptr->initrow, mptr->col);
473: return closest(movelist,moves, mptr->initrow, mptr->initcol);
474: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.