![[BACK]](/cvsweb/icons/back.gif){kind=icon}
Return to execute.c CVS log ![[TXT]](/cvsweb/icons/text.gif){kind=icon}
![[DIR]](/cvsweb/icons/dir.gif){kind=icon}
Up to [CSRG BSD Unix] / 43BSDReno / games / hunt / NEW|
Return to execute.c CVS log | Up to [CSRG BSD Unix] / 43BSDReno / games / hunt / NEW |
1.1 ! root 1: /* ! 2: * Hunt ! 3: * Copyright (c) 1985 Conrad C. Huang, Gregory S. Couch, Kenneth C.R.C. Arnold ! 4: * San Francisco, California ! 5: * ! 6: * Copyright (c) 1985 Regents of the University of California. ! 7: * All rights reserved. The Berkeley software License Agreement ! 8: * specifies the terms and conditions for redistribution. ! 9: */ ! 10: ! 11: # include "hunt.h" ! 12: ! 13: # undef CTRL ! 14: # define CTRL(x) ('x' & 037) ! 15: ! 16: # ifdef MONITOR ! 17: /* ! 18: * mon_execute: ! 19: * Execute a single monitor command ! 20: */ ! 21: mon_execute(pp) ! 22: register PLAYER *pp; ! 23: { ! 24: register char ch; ! 25: ! 26: ch = pp->p_cbuf[pp->p_ncount++]; ! 27: switch (ch) { ! 28: case CTRL(L): ! 29: sendcom(pp, REDRAW); ! 30: break; ! 31: case 'q': ! 32: (void) strcpy(pp->p_death, "| Quit |"); ! 33: break; ! 34: } ! 35: } ! 36: # endif MONITOR ! 37: ! 38: /* ! 39: * execute: ! 40: * Execute a single command ! 41: */ ! 42: execute(pp) ! 43: register PLAYER *pp; ! 44: { ! 45: register char ch; ! 46: ! 47: ch = pp->p_cbuf[pp->p_ncount++]; ! 48: ! 49: # ifdef FLY ! 50: if (pp->p_flying >= 0) { ! 51: switch (ch) { ! 52: case CTRL(L): ! 53: sendcom(pp, REDRAW); ! 54: break; ! 55: case 'q': ! 56: (void) strcpy(pp->p_death, "| Quit |"); ! 57: break; ! 58: } ! 59: return; ! 60: } ! 61: # endif FLY ! 62: ! 63: switch (ch) { ! 64: case CTRL(L): ! 65: sendcom(pp, REDRAW); ! 66: break; ! 67: case 'h': ! 68: move(pp, LEFTS); ! 69: break; ! 70: case 'H': ! 71: face(pp, LEFTS); ! 72: break; ! 73: case 'j': ! 74: move(pp, BELOW); ! 75: break; ! 76: case 'J': ! 77: face(pp, BELOW); ! 78: break; ! 79: case 'k': ! 80: move(pp, ABOVE); ! 81: break; ! 82: case 'K': ! 83: face(pp, ABOVE); ! 84: break; ! 85: case 'l': ! 86: move(pp, RIGHT); ! 87: break; ! 88: case 'L': ! 89: face(pp, RIGHT); ! 90: break; ! 91: case 'f': ! 92: case '1': ! 93: fire(pp, 0); /* SHOT */ ! 94: break; ! 95: case 'g': ! 96: case '2': ! 97: fire(pp, 1); /* GRENADE */ ! 98: break; ! 99: case 'F': ! 100: case '3': ! 101: fire(pp, 2); /* SATCHEL */ ! 102: break; ! 103: case 'G': ! 104: case '4': ! 105: fire(pp, 3); /* 7x7 BOMB */ ! 106: break; ! 107: case '5': ! 108: fire(pp, 4); /* 9x9 BOMB */ ! 109: break; ! 110: case '6': ! 111: fire(pp, 5); /* 11x11 BOMB */ ! 112: break; ! 113: case '7': ! 114: fire(pp, 6); /* 13x13 BOMB */ ! 115: break; ! 116: case '8': ! 117: fire(pp, 7); /* 15x15 BOMB */ ! 118: break; ! 119: case '9': ! 120: fire(pp, 8); /* 17x17 BOMB */ ! 121: break; ! 122: case '0': ! 123: fire(pp, 9); /* 19x19 BOMB */ ! 124: break; ! 125: case '@': ! 126: fire(pp, 10); /* 21x21 BOMB */ ! 127: break; ! 128: # ifdef OOZE ! 129: case 'o': ! 130: fire_slime(pp, 0); /* SLIME */ ! 131: break; ! 132: case 'O': ! 133: fire_slime(pp, 1); /* SSLIME */ ! 134: break; ! 135: case 'p': ! 136: fire_slime(pp, 2); ! 137: break; ! 138: case 'P': ! 139: fire_slime(pp, 3); ! 140: break; ! 141: # endif OOZE ! 142: case 's': ! 143: scan(pp); ! 144: break; ! 145: case 'c': ! 146: cloak(pp); ! 147: break; ! 148: case 'q': ! 149: (void) strcpy(pp->p_death, "| Quit |"); ! 150: break; ! 151: } ! 152: } ! 153: ! 154: /* ! 155: * move: ! 156: * Execute a move in the given direction ! 157: */ ! 158: move(pp, dir) ! 159: register PLAYER *pp; ! 160: int dir; ! 161: { ! 162: register PLAYER *newp; ! 163: register int x, y; ! 164: register FLAG moved; ! 165: register BULLET *bp; ! 166: ! 167: y = pp->p_y; ! 168: x = pp->p_x; ! 169: ! 170: switch (dir) { ! 171: case LEFTS: ! 172: x--; ! 173: break; ! 174: case RIGHT: ! 175: x++; ! 176: break; ! 177: case ABOVE: ! 178: y--; ! 179: break; ! 180: case BELOW: ! 181: y++; ! 182: break; ! 183: } ! 184: ! 185: moved = FALSE; ! 186: switch (Maze[y][x]) { ! 187: case SPACE: ! 188: # ifdef RANDOM ! 189: case DOOR: ! 190: # endif RANDOM ! 191: moved = TRUE; ! 192: break; ! 193: case WALL1: ! 194: case WALL2: ! 195: case WALL3: ! 196: # ifdef REFLECT ! 197: case WALL4: ! 198: case WALL5: ! 199: # endif REFLECT ! 200: break; ! 201: case MINE: ! 202: case GMINE: ! 203: if (dir == pp->p_face) ! 204: pickup(pp, y, x, 2, Maze[y][x]); ! 205: else if (opposite(dir, pp->p_face)) ! 206: pickup(pp, y, x, 95, Maze[y][x]); ! 207: else ! 208: pickup(pp, y, x, 50, Maze[y][x]); ! 209: Maze[y][x] = SPACE; ! 210: moved = TRUE; ! 211: break; ! 212: case SHOT: ! 213: case GRENADE: ! 214: case SATCHEL: ! 215: case BOMB: ! 216: # ifdef OOZE ! 217: case SLIME: ! 218: # endif OOZE ! 219: # ifdef DRONE ! 220: case DSHOT: ! 221: # endif DRONE ! 222: bp = is_bullet(y, x); ! 223: if (bp != NULL) ! 224: bp->b_expl = TRUE; ! 225: Maze[y][x] = SPACE; ! 226: moved = TRUE; ! 227: break; ! 228: case LEFTS: ! 229: case RIGHT: ! 230: case ABOVE: ! 231: case BELOW: ! 232: if (dir != pp->p_face) ! 233: sendcom(pp, BELL); ! 234: else { ! 235: newp = play_at(y, x); ! 236: checkdam(newp, pp, pp->p_ident, STABDAM, KNIFE); ! 237: } ! 238: break; ! 239: # ifdef FLY ! 240: case FLYER: ! 241: newp = play_at(y, x); ! 242: message(newp, "Oooh, there's a short guy waving at you!"); ! 243: message(pp, "You couldn't quite reach him!"); ! 244: break; ! 245: # endif FLY ! 246: # ifdef BOOTS ! 247: case BOOT: ! 248: case BOOT_PAIR: ! 249: if (Maze[y][x] == BOOT) ! 250: pp->p_nboots++; ! 251: else ! 252: pp->p_nboots += 2; ! 253: for (newp = Boot; newp < &Boot[NBOOTS]; newp++) { ! 254: if (newp->p_flying < 0) ! 255: continue; ! 256: if (newp->p_y == y && newp->p_x == x) { ! 257: newp->p_flying = -1; ! 258: if (newp->p_undershot) ! 259: fixshots(y, x, newp->p_over); ! 260: } ! 261: } ! 262: if (pp->p_nboots == 2) ! 263: message(pp, "Wow! A pair of boots!"); ! 264: else ! 265: message(pp, "You can hobble around on one boot."); ! 266: Maze[y][x] = SPACE; ! 267: moved = TRUE; ! 268: break; ! 269: # endif BOOTS ! 270: } ! 271: if (moved) { ! 272: if (pp->p_ncshot > 0) ! 273: if (--pp->p_ncshot == MAXNCSHOT) { ! 274: cgoto(pp, STAT_GUN_ROW, STAT_VALUE_COL); ! 275: outstr(pp, " ok", 3); ! 276: } ! 277: if (pp->p_undershot) { ! 278: fixshots(pp->p_y, pp->p_x, pp->p_over); ! 279: pp->p_undershot = FALSE; ! 280: } ! 281: drawplayer(pp, FALSE); ! 282: pp->p_over = Maze[y][x]; ! 283: pp->p_y = y; ! 284: pp->p_x = x; ! 285: drawplayer(pp, TRUE); ! 286: } ! 287: } ! 288: ! 289: /* ! 290: * face: ! 291: * Change the direction the player is facing ! 292: */ ! 293: face(pp, dir) ! 294: register PLAYER *pp; ! 295: register int dir; ! 296: { ! 297: if (pp->p_face != dir) { ! 298: pp->p_face = dir; ! 299: drawplayer(pp, TRUE); ! 300: } ! 301: } ! 302: ! 303: /* ! 304: * fire: ! 305: * Fire a shot of the given type in the given direction ! 306: */ ! 307: fire(pp, req_index) ! 308: register PLAYER *pp; ! 309: register int req_index; ! 310: { ! 311: if (pp == NULL) ! 312: return; ! 313: # ifdef DEBUG ! 314: if (req_index < 0 || req_index >= MAXBOMB) ! 315: message(pp, "What you do?"); ! 316: # endif DEBUG ! 317: while (req_index >= 0 && pp->p_ammo < shot_req[req_index]) ! 318: req_index--; ! 319: if (req_index < 0) { ! 320: message(pp, "Not enough charges."); ! 321: return; ! 322: } ! 323: if (pp->p_ncshot > MAXNCSHOT) ! 324: return; ! 325: if (pp->p_ncshot++ == MAXNCSHOT) { ! 326: cgoto(pp, STAT_GUN_ROW, STAT_VALUE_COL); ! 327: outstr(pp, " ", 3); ! 328: } ! 329: pp->p_ammo -= shot_req[req_index]; ! 330: (void) sprintf(Buf, "%3d", pp->p_ammo); ! 331: cgoto(pp, STAT_AMMO_ROW, STAT_VALUE_COL); ! 332: outstr(pp, Buf, 3); ! 333: ! 334: add_shot(shot_type[req_index], pp->p_y, pp->p_x, pp->p_face, ! 335: shot_req[req_index], pp, FALSE, pp->p_face); ! 336: pp->p_undershot = TRUE; ! 337: ! 338: /* ! 339: * Show the object to everyone ! 340: */ ! 341: showexpl(pp->p_y, pp->p_x, shot_type[req_index]); ! 342: for (pp = Player; pp < End_player; pp++) ! 343: sendcom(pp, REFRESH); ! 344: # ifdef MONITOR ! 345: for (pp = Monitor; pp < End_monitor; pp++) ! 346: sendcom(pp, REFRESH); ! 347: # endif MONITOR ! 348: } ! 349: ! 350: # ifdef OOZE ! 351: /* ! 352: * fire_slime: ! 353: * Fire a slime shot in the given direction ! 354: */ ! 355: fire_slime(pp, req_index) ! 356: register PLAYER *pp; ! 357: register int req_index; ! 358: { ! 359: if (pp == NULL) ! 360: return; ! 361: # ifdef DEBUG ! 362: if (req_index < 0 || req_index >= MAXSLIME) ! 363: message(pp, "What you do?"); ! 364: # endif DEBUG ! 365: while (req_index >= 0 && pp->p_ammo < slime_req[req_index]) ! 366: req_index--; ! 367: if (req_index < 0) { ! 368: message(pp, "Not enough charges."); ! 369: return; ! 370: } ! 371: if (pp->p_ncshot > MAXNCSHOT) ! 372: return; ! 373: if (pp->p_ncshot++ == MAXNCSHOT) { ! 374: cgoto(pp, STAT_GUN_ROW, STAT_VALUE_COL); ! 375: outstr(pp, " ", 3); ! 376: } ! 377: pp->p_ammo -= slime_req[req_index]; ! 378: (void) sprintf(Buf, "%3d", pp->p_ammo); ! 379: cgoto(pp, STAT_AMMO_ROW, STAT_VALUE_COL); ! 380: outstr(pp, Buf, 3); ! 381: ! 382: add_shot(SLIME, pp->p_y, pp->p_x, pp->p_face, ! 383: slime_req[req_index] * SLIME_FACTOR, pp, FALSE, pp->p_face); ! 384: pp->p_undershot = TRUE; ! 385: ! 386: /* ! 387: * Show the object to everyone ! 388: */ ! 389: showexpl(pp->p_y, pp->p_x, SLIME); ! 390: for (pp = Player; pp < End_player; pp++) ! 391: sendcom(pp, REFRESH); ! 392: # ifdef MONITOR ! 393: for (pp = Monitor; pp < End_monitor; pp++) ! 394: sendcom(pp, REFRESH); ! 395: # endif MONITOR ! 396: } ! 397: # endif OOZE ! 398: ! 399: /* ! 400: * add_shot: ! 401: * Create a shot with the given properties ! 402: */ ! 403: add_shot(type, y, x, face, charge, owner, expl, over) ! 404: int type; ! 405: int y, x; ! 406: char face; ! 407: int charge; ! 408: PLAYER *owner; ! 409: int expl; ! 410: char over; ! 411: { ! 412: register BULLET *bp; ! 413: register int size; ! 414: ! 415: switch (type) { ! 416: case SHOT: ! 417: case MINE: ! 418: size = 1; ! 419: break; ! 420: case GRENADE: ! 421: case GMINE: ! 422: size = 2; ! 423: break; ! 424: case SATCHEL: ! 425: size = 3; ! 426: break; ! 427: case BOMB: ! 428: for (size = 3; size < MAXBOMB; size++) ! 429: if (shot_req[size] >= charge) ! 430: break; ! 431: size++; ! 432: break; ! 433: default: ! 434: size = 0; ! 435: break; ! 436: } ! 437: ! 438: bp = create_shot(type, y, x, face, charge, size, owner, ! 439: (owner == NULL) ? NULL : owner->p_ident, expl, over); ! 440: bp->b_next = Bullets; ! 441: Bullets = bp; ! 442: } ! 443: ! 444: BULLET * ! 445: create_shot(type, y, x, face, charge, size, owner, score, expl, over) ! 446: int type; ! 447: int y, x; ! 448: char face; ! 449: int charge; ! 450: int size; ! 451: PLAYER *owner; ! 452: IDENT *score; ! 453: int expl; ! 454: char over; ! 455: { ! 456: register BULLET *bp; ! 457: ! 458: bp = (BULLET *) malloc(sizeof (BULLET)); /* NOSTRICT */ ! 459: if (bp == NULL) { ! 460: if (owner != NULL) ! 461: message(owner, "Out of memory"); ! 462: return NULL; ! 463: } ! 464: ! 465: bp->b_face = face; ! 466: bp->b_x = x; ! 467: bp->b_y = y; ! 468: bp->b_charge = charge; ! 469: bp->b_owner = owner; ! 470: bp->b_score = score; ! 471: bp->b_type = type; ! 472: bp->b_size = size; ! 473: bp->b_expl = expl; ! 474: bp->b_over = over; ! 475: bp->b_next = NULL; ! 476: ! 477: return bp; ! 478: } ! 479: ! 480: /* ! 481: * cloak: ! 482: * Turn on or increase length of a cloak ! 483: */ ! 484: cloak(pp) ! 485: register PLAYER *pp; ! 486: { ! 487: if (pp->p_ammo <= 0) { ! 488: message(pp, "No more charges"); ! 489: return; ! 490: } ! 491: # ifdef BOOTS ! 492: if (pp->p_nboots > 0) { ! 493: message(pp, "Boots are too noisy to cloak!"); ! 494: return; ! 495: } ! 496: # endif BOOTS ! 497: (void) sprintf(Buf, "%3d", --pp->p_ammo); ! 498: cgoto(pp, STAT_AMMO_ROW, STAT_VALUE_COL); ! 499: outstr(pp, Buf, 3); ! 500: ! 501: pp->p_cloak += CLOAKLEN; ! 502: ! 503: if (pp->p_scan >= 0) ! 504: pp->p_scan = -1; ! 505: ! 506: showstat(pp); ! 507: } ! 508: ! 509: /* ! 510: * scan: ! 511: * Turn on or increase length of a scan ! 512: */ ! 513: scan(pp) ! 514: register PLAYER *pp; ! 515: { ! 516: if (pp->p_ammo <= 0) { ! 517: message(pp, "No more charges"); ! 518: return; ! 519: } ! 520: (void) sprintf(Buf, "%3d", --pp->p_ammo); ! 521: cgoto(pp, STAT_AMMO_ROW, STAT_VALUE_COL); ! 522: outstr(pp, Buf, 3); ! 523: ! 524: pp->p_scan += SCANLEN; ! 525: ! 526: if (pp->p_cloak >= 0) ! 527: pp->p_cloak = -1; ! 528: ! 529: showstat(pp); ! 530: } ! 531: ! 532: /* ! 533: * pickup: ! 534: * check whether the object blew up or whether he picked it up ! 535: */ ! 536: pickup(pp, y, x, prob, obj) ! 537: register PLAYER *pp; ! 538: register int y, x; ! 539: int prob; ! 540: int obj; ! 541: { ! 542: register int req; ! 543: ! 544: switch (obj) { ! 545: case MINE: ! 546: req = BULREQ; ! 547: break; ! 548: case GMINE: ! 549: req = GRENREQ; ! 550: break; ! 551: default: ! 552: abort(); ! 553: } ! 554: if (rand_num(100) < prob) ! 555: add_shot(obj, y, x, LEFTS, req, (PLAYER *) NULL, ! 556: TRUE, pp->p_face); ! 557: else { ! 558: pp->p_ammo += req; ! 559: (void) sprintf(Buf, "%3d", pp->p_ammo); ! 560: cgoto(pp, STAT_AMMO_ROW, STAT_VALUE_COL); ! 561: outstr(pp, Buf, 3); ! 562: } ! 563: }
This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.