games/hunt/huntd/execute.c

   1 /*-
   2  * Copyright (c) 1983-2003, Regents of the University of California.
   3  * All rights reserved.
   4  *
   5  * Redistribution and use in source and binary forms, with or without
   6  * modification, are permitted provided that the following conditions are
   7  * met:
   8  *
   9  * 1. Redistributions of source code must retain the above copyright
  10  *    notice, this list of conditions and the following disclaimer.
  11  * 2. Redistributions in binary form must reproduce the above copyright
  12  *    notice, this list of conditions and the following disclaimer in the
  13  *    documentation and/or other materials provided with the distribution.
  14  * 3. Neither the name of the University of California, San Francisco nor
  15  *    the names of its contributors may be used to endorse or promote
  16  *    products derived from this software without specific prior written
  17  *    permission.
  18  *
  19  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS
  20  * IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  21  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
  22  * PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
  23  * OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
  24  * SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
  25  * LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
  26  * DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
  27  * THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
  28  * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
  29  * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  30  *
  31  * $OpenBSD: execute.c,v 1.8 2004/01/16 00:13:19 espie Exp $
  32  * $NetBSD: execute.c,v 1.2 1997/10/10 16:33:13 lukem Exp $
  33  * $DragonFly: src/games/hunt/huntd/execute.c,v 1.2 2008/09/04 16:12:51 swildner Exp $
  34  */
  35
  36 #include <stdlib.h>
  37 #include <string.h>
  38 #include <syslog.h>
  39 #include "hunt.h"
  40 #include "conf.h"
  41 #include "server.h"
  42
  43 static void     cloak(PLAYER *);
  44 static void     face(PLAYER *, int);
  45 static void     fire(PLAYER *, int);
  46 static void     fire_slime(PLAYER *, int);
  47 static void     move_player(PLAYER *, int);
  48 static void     pickup(PLAYER *, int, int, int, int);
  49 static void     scan(PLAYER *);
  50
  51
  52 /*
  53  * mon_execute:
  54  *      Execute a single monitor command
  55  */
  56 void
  57 mon_execute(PLAYER *pp)
  58 {
  59         char    ch;
  60
  61         ch = pp->p_cbuf[pp->p_ncount++];
  62
  63         switch (ch) {
  64           case CTRL('L'):
  65                 /* Redraw messed-up screen */
  66                 sendcom(pp, REDRAW);
  67                 break;
  68           case 'q':
  69                 /* Quit client */
  70                 (void) strlcpy(pp->p_death, "| Quit |", sizeof pp->p_death);
  71                 break;
  72           default:
  73                 /* Ignore everything else */
  74                 ;
  75         }
  76 }
  77
  78 /*
  79  * execute:
  80  *      Execute a single command from a player
  81  */
  82 void
  83 execute(PLAYER *pp)
  84 {
  85         char    ch;
  86
  87         ch = pp->p_cbuf[pp->p_ncount++];
  88
  89         /* When flying, only allow refresh and quit. */
  90         if (pp->p_flying >= 0) {
  91                 switch (ch) {
  92                   case CTRL('L'):
  93                         sendcom(pp, REDRAW);
  94                         break;
  95                   case 'q':
  96                         (void) strlcpy(pp->p_death, "| Quit |",
  97                             sizeof pp->p_death);
  98                         break;
  99                 }
 100                 return;
 101         }
 102
 103         /* Decode the command character: */
 104         switch (ch) {
 105           case CTRL('L'):
 106                 sendcom(pp, REDRAW);    /* Refresh */
 107                 break;
 108           case 'h':
 109                 move_player(pp, LEFTS); /* Move left */
 110                 break;
 111           case 'H':
 112                 face(pp, LEFTS);        /* Face left */
 113                 break;
 114           case 'j':
 115                 move_player(pp, BELOW); /* Move down */
 116                 break;
 117           case 'J':
 118                 face(pp, BELOW);        /* Face down */
 119                 break;
 120           case 'k':
 121                 move_player(pp, ABOVE); /* Move up */
 122                 break;
 123           case 'K':
 124                 face(pp, ABOVE);        /* Face up */
 125                 break;
 126           case 'l':
 127                 move_player(pp, RIGHT); /* Move right */
 128                 break;
 129           case 'L':
 130                 face(pp, RIGHT);        /* Face right */
 131                 break;
 132           case 'f':
 133           case '1':
 134                 fire(pp, 0);            /* SHOT */
 135                 break;
 136           case 'g':
 137           case '2':
 138                 fire(pp, 1);            /* GRENADE */
 139                 break;
 140           case 'F':
 141           case '3':
 142                 fire(pp, 2);            /* SATCHEL */
 143                 break;
 144           case 'G':
 145           case '4':
 146                 fire(pp, 3);            /* 7x7 BOMB */
 147                 break;
 148           case '5':
 149                 fire(pp, 4);            /* 9x9 BOMB */
 150                 break;
 151           case '6':
 152                 fire(pp, 5);            /* 11x11 BOMB */
 153                 break;
 154           case '7':
 155                 fire(pp, 6);            /* 13x13 BOMB */
 156                 break;
 157           case '8':
 158                 fire(pp, 7);            /* 15x15 BOMB */
 159                 break;
 160           case '9':
 161                 fire(pp, 8);            /* 17x17 BOMB */
 162                 break;
 163           case '0':
 164                 fire(pp, 9);            /* 19x19 BOMB */
 165                 break;
 166           case '@':
 167                 fire(pp, 10);           /* 21x21 BOMB */
 168                 break;
 169           case 'o':
 170                 fire_slime(pp, 0);      /* SLIME */
 171                 break;
 172           case 'O':
 173                 fire_slime(pp, 1);      /* SSLIME */
 174                 break;
 175           case 'p':
 176                 fire_slime(pp, 2);      /* large slime */
 177                 break;
 178           case 'P':
 179                 fire_slime(pp, 3);      /* very large slime */
 180                 break;
 181           case 's':                     /* start scanning */
 182                 scan(pp);
 183                 break;
 184           case 'c':                     /* start cloaking */
 185                 cloak(pp);
 186                 break;
 187           case 'q':                     /* quit */
 188                 (void) strlcpy(pp->p_death, "| Quit |", sizeof pp->p_death);
 189                 break;
 190         }
 191 }
 192
 193 /*
 194  * move_player:
 195  *      Try to move player 'pp' in direction 'dir'.
 196  */
 197 static void
 198 move_player(PLAYER *pp, int dir)
 199 {
 200         PLAYER  *newp;
 201         int     x, y;
 202         FLAG    moved;
 203         BULLET  *bp;
 204
 205         y = pp->p_y;
 206         x = pp->p_x;
 207
 208         switch (dir) {
 209           case LEFTS:
 210                 x--;
 211                 break;
 212           case RIGHT:
 213                 x++;
 214                 break;
 215           case ABOVE:
 216                 y--;
 217                 break;
 218           case BELOW:
 219                 y++;
 220                 break;
 221         }
 222
 223         moved = FALSE;
 224
 225         /* What would the player move over: */
 226         switch (Maze[y][x]) {
 227           /* Players can move through spaces and doors, no problem: */
 228           case SPACE:
 229           case DOOR:
 230                 moved = TRUE;
 231                 break;
 232           /* Can't move through walls: */
 233           case WALL1:
 234           case WALL2:
 235           case WALL3:
 236           case WALL4:
 237           case WALL5:
 238                 break;
 239           /* Moving over a mine - try to pick it up: */
 240           case MINE:
 241           case GMINE:
 242                 if (dir == pp->p_face)
 243                         /* facing it: 2% chance of trip */
 244                         pickup(pp, y, x, conf_ptrip_face, Maze[y][x]);
 245                 else if (opposite(dir, pp->p_face))
 246                         /* facing away: 95% chance of trip */
 247                         pickup(pp, y, x, conf_ptrip_back, Maze[y][x]);
 248                 else
 249                         /* facing sideways: 50% chance of trip */
 250                         pickup(pp, y, x, conf_ptrip_side, Maze[y][x]);
 251                 /* Remove the mine: */
 252                 Maze[y][x] = SPACE;
 253                 moved = TRUE;
 254                 break;
 255           /* Moving into a bullet: */
 256           case SHOT:
 257           case GRENADE:
 258           case SATCHEL:
 259           case BOMB:
 260           case SLIME:
 261           case DSHOT:
 262                 /* Find which bullet: */
 263                 bp = is_bullet(y, x);
 264                 if (bp != NULL)
 265                         /* Detonate it: */
 266                         bp->b_expl = TRUE;
 267                 /* Remove it: */
 268                 Maze[y][x] = SPACE;
 269                 moved = TRUE;
 270                 break;
 271           /* Moving into another player: */
 272           case LEFTS:
 273           case RIGHT:
 274           case ABOVE:
 275           case BELOW:
 276                 if (dir != pp->p_face)
 277                         /* Can't walk backwards/sideways into another player: */
 278                         sendcom(pp, BELL);
 279                 else {
 280                         /* Stab the other player */
 281                         newp = play_at(y, x);
 282                         checkdam(newp, pp, pp->p_ident, conf_stabdam, KNIFE);
 283                 }
 284                 break;
 285           /* Moving into a player flying overhead: */
 286           case FLYER:
 287                 newp = play_at(y, x);
 288                 message(newp, "Oooh, there's a short guy waving at you!");
 289                 message(pp, "You couldn't quite reach him!");
 290                 break;
 291           /* Picking up a boot, or two: */
 292           case BOOT_PAIR:
 293                 pp->p_nboots++;
 294           case BOOT:
 295                 pp->p_nboots++;
 296                 for (newp = Boot; newp < &Boot[NBOOTS]; newp++) {
 297                         if (newp->p_flying < 0)
 298                                 continue;
 299                         if (newp->p_y == y && newp->p_x == x) {
 300                                 newp->p_flying = -1;
 301                                 if (newp->p_undershot)
 302                                         fixshots(y, x, newp->p_over);
 303                         }
 304                 }
 305                 if (pp->p_nboots == 2)
 306                         message(pp, "Wow!  A pair of boots!");
 307                 else
 308                         message(pp, "You can hobble around on one boot.");
 309                 Maze[y][x] = SPACE;
 310                 moved = TRUE;
 311                 break;
 312         }
 313
 314         /* Can the player be moved? */
 315         if (moved) {
 316                 /* Check the gun status: */
 317                 if (pp->p_ncshot > 0)
 318                         if (--pp->p_ncshot == conf_maxncshot)
 319                                 outyx(pp, STAT_GUN_ROW, STAT_VALUE_COL, " ok");
 320                 /* Check for bullets flying past: */
 321                 if (pp->p_undershot) {
 322                         fixshots(pp->p_y, pp->p_x, pp->p_over);
 323                         pp->p_undershot = FALSE;
 324                 }
 325                 /* Erase the player: */
 326                 drawplayer(pp, FALSE);
 327                 /* Save under: */
 328                 pp->p_over = Maze[y][x];
 329                 /* Move the player: */
 330                 pp->p_y = y;
 331                 pp->p_x = x;
 332                 /* Draw the player in their new position */
 333                 drawplayer(pp, TRUE);
 334         }
 335 }
 336
 337 /*
 338  * face:
 339  *      Change the direction the player is facing
 340  */
 341 static void
 342 face(PLAYER *pp, int dir)
 343 {
 344         if (pp->p_face != dir) {
 345                 pp->p_face = dir;
 346                 drawplayer(pp, TRUE);
 347         }
 348 }
 349
 350 /*
 351  * fire:
 352  *      Fire a shot of the given type in the given direction
 353  */
 354 static void
 355 fire(PLAYER *pp, int req_index)
 356 {
 357         if (pp == NULL)
 358                 return;
 359
 360         /* Drop the shot type down until we can afford it: */
 361         while (req_index >= 0 && pp->p_ammo < shot_req[req_index])
 362                 req_index--;
 363
 364         /* Can we shoot at all? */
 365         if (req_index < 0) {
 366                 message(pp, "Not enough charges.");
 367                 return;
 368         }
 369
 370         /* Check if the gun is too hot: */
 371         if (pp->p_ncshot > conf_maxncshot)
 372                 return;
 373
 374         /* Heat up the gun: */
 375         if (pp->p_ncshot++ == conf_maxncshot) {
 376                 /* The gun has overheated: */
 377                 outyx(pp, STAT_GUN_ROW, STAT_VALUE_COL, "   ");
 378         }
 379
 380         /* Use up some ammo: */
 381         pp->p_ammo -= shot_req[req_index];
 382         ammo_update(pp);
 383
 384         /* Start the bullet moving: */
 385         add_shot(shot_type[req_index], pp->p_y, pp->p_x, pp->p_face,
 386                 shot_req[req_index], pp, FALSE, pp->p_face);
 387         pp->p_undershot = TRUE;
 388
 389         /* Show the bullet to everyone: */
 390         showexpl(pp->p_y, pp->p_x, shot_type[req_index]);
 391         sendcom(ALL_PLAYERS, REFRESH);
 392 }
 393
 394 /*
 395  * fire_slime:
 396  *      Fire a slime shot in the given direction
 397  */
 398 static void
 399 fire_slime(PLAYER *pp, int req_index)
 400 {
 401         if (pp == NULL)
 402                 return;
 403
 404         /* Check configuration: */
 405         if (!conf_ooze)
 406                 return;
 407
 408         /* Drop the slime type back util we can afford it: */
 409         while (req_index >= 0 && pp->p_ammo < slime_req[req_index])
 410                 req_index--;
 411
 412         /* Can we afford to slime at all? */
 413         if (req_index < 0) {
 414                 message(pp, "Not enough charges.");
 415                 return;
 416         }
 417
 418         /* Is the gun too hot? */
 419         if (pp->p_ncshot > conf_maxncshot)
 420                 return;
 421
 422         /* Heat up the gun: */
 423         if (pp->p_ncshot++ == conf_maxncshot) {
 424                 /* The gun has overheated: */
 425                 outyx(pp, STAT_GUN_ROW, STAT_VALUE_COL, "   ");
 426         }
 427
 428         /* Use up some ammo: */
 429         pp->p_ammo -= slime_req[req_index];
 430         ammo_update(pp);
 431
 432         /* Start the slime moving: */
 433         add_shot(SLIME, pp->p_y, pp->p_x, pp->p_face,
 434                 slime_req[req_index] * conf_slimefactor, pp, FALSE, pp->p_face);
 435         pp->p_undershot = TRUE;
 436
 437         /* Show the object to everyone: */
 438         showexpl(pp->p_y, pp->p_x, SLIME);
 439         sendcom(ALL_PLAYERS, REFRESH);
 440 }
 441
 442 /*
 443  * add_shot:
 444  *      Create a shot with the given properties
 445  */
 446 void
 447 add_shot(int type, int y, int x, char wface, int charge, PLAYER *owner,
 448     int expl, char over)
 449 {
 450         BULLET  *bp;
 451         int     size;
 452
 453         /* Determine the bullet's size based on its type and charge: */
 454         switch (type) {
 455           case SHOT:
 456           case MINE:
 457                 size = 1;
 458                 break;
 459           case GRENADE:
 460           case GMINE:
 461                 size = 2;
 462                 break;
 463           case SATCHEL:
 464                 size = 3;
 465                 break;
 466           case BOMB:
 467                 for (size = 3; size < MAXBOMB; size++)
 468                         if (shot_req[size] >= charge)
 469                                 break;
 470                 size++;
 471                 break;
 472           default:
 473                 size = 0;
 474                 break;
 475         }
 476
 477         /* Create the bullet: */
 478         bp = create_shot(type, y, x, wface, charge, size, owner,
 479                 (owner == NULL) ? NULL : owner->p_ident, expl, over);
 480
 481         /* Insert the bullet into the front of the bullet list: */
 482         bp->b_next = Bullets;
 483         Bullets = bp;
 484 }
 485
 486 /*
 487  * create_shot:
 488  *      allocate storage for an (unlinked) bullet structure;
 489  *      initialize and return it
 490  */
 491 BULLET *
 492 create_shot(int type, int y, int x, char wface, int charge, int size,
 493     PLAYER *owner, IDENT *score, int expl, char over)
 494 {
 495         BULLET  *bp;
 496
 497         bp = (BULLET *) malloc(sizeof (BULLET));        /* NOSTRICT */
 498         if (bp == NULL) {
 499                 logit(LOG_ERR, "malloc");
 500                 if (owner != NULL)
 501                         message(owner, "Out of memory");
 502                 return NULL;
 503         }
 504
 505         bp->b_face = wface;
 506         bp->b_x = x;
 507         bp->b_y = y;
 508         bp->b_charge = charge;
 509         bp->b_owner = owner;
 510         bp->b_score = score;
 511         bp->b_type = type;
 512         bp->b_size = size;
 513         bp->b_expl = expl;
 514         bp->b_over = over;
 515         bp->b_next = NULL;
 516
 517         return bp;
 518 }
 519
 520 /*
 521  * cloak:
 522  *      Turn on or increase length of a cloak
 523  */
 524 static void
 525 cloak(PLAYER *pp)
 526 {
 527         /* Check configuration: */
 528         if (!conf_cloak)
 529                 return;
 530
 531         /* Can we afford it?: */
 532         if (pp->p_ammo <= 0) {
 533                 message(pp, "No more charges");
 534                 return;
 535         }
 536
 537         /* Can't cloak with boots: */
 538         if (pp->p_nboots > 0) {
 539                 message(pp, "Boots are too noisy to cloak!");
 540                 return;
 541         }
 542
 543         /* Consume a unit of ammo: */
 544         pp->p_ammo--;
 545         ammo_update(pp);
 546
 547         /* Add to the duration of a cloak: */
 548         pp->p_cloak += conf_cloaklen;
 549
 550         /* Disable scan, if enabled: */
 551         if (pp->p_scan >= 0)
 552                 pp->p_scan = -1;
 553
 554         /* Re-draw the player's scan/cloak status: */
 555         showstat(pp);
 556 }
 557
 558 /*
 559  * scan:
 560  *      Turn on or increase length of a scan
 561  */
 562 static void
 563 scan(PLAYER *pp)
 564 {
 565         /* Check configuration: */
 566         if (!conf_scan)
 567                 return;
 568
 569         /* Can we afford it?: */
 570         if (pp->p_ammo <= 0) {
 571                 message(pp, "No more charges");
 572                 return;
 573         }
 574
 575         /* Consume one unit of ammo: */
 576         pp->p_ammo--;
 577         ammo_update(pp);
 578
 579         /* Increase the scan time: */
 580         pp->p_scan += Nplayer * conf_scanlen;
 581
 582         /* Disable cloak, if enabled: */
 583         if (pp->p_cloak >= 0)
 584                 pp->p_cloak = -1;
 585
 586         /* Re-draw the player's scan/cloak status: */
 587         showstat(pp);
 588 }
 589
 590 /*
 591  * pickup:
 592  *      pick up a mine or grenade, with some probability of it exploding
 593  */
 594 static void
 595 pickup(PLAYER *pp, int y, int x, int prob, int obj)
 596 {
 597         int     req;
 598
 599         /* Figure out how much ammo the player is trying to pick up: */
 600         switch (obj) {
 601           case MINE:
 602                 req = BULREQ;
 603                 break;
 604           case GMINE:
 605                 req = GRENREQ;
 606                 break;
 607           default:
 608 #ifdef DIAGNOSTIC
 609                 abort();
 610 #endif
 611                 return;
 612         }
 613
 614         /* Does it explode? */
 615         if (rand_num(100) < prob)
 616                 /* Ooooh, unlucky: (Boom) */
 617                 add_shot(obj, y, x, LEFTS, req, NULL, TRUE, pp->p_face);
 618         else {
 619                 /* Safely picked it up. Add to player's ammo: */
 620                 pp->p_ammo += req;
 621                 ammo_update(pp);
 622         }
 623 }
 624
 625 void
 626 ammo_update(PLAYER *pp)
 627 {
 628         outyx(pp, STAT_AMMO_ROW, STAT_VALUE_COL - 1, "%4d", pp->p_ammo);
 629 }