rogue/move.c

   1 /*
   2  * Copyright (c) 1988 The Regents of the University of California.
   3  * All rights reserved.
   4  *
   5  * This code is derived from software contributed to Berkeley by
   6  * Timothy C. Stoehr.
   7  *
   8  * Redistribution and use in source and binary forms, with or without
   9  * modification, are permitted provided that the following conditions
  10  * are met:
  11  * 1. Redistributions of source code must retain the above copyright
  12  *    notice, this list of conditions and the following disclaimer.
  13  * 2. Redistributions in binary form must reproduce the above copyright
  14  *    notice, this list of conditions and the following disclaimer in the
  15  *    documentation and/or other materials provided with the distribution.
  16  * 3. All advertising materials mentioning features or use of this software
  17  *    must display the following acknowledgement:
  18  *      This product includes software developed by the University of
  19  *      California, Berkeley and its contributors.
  20  * 4. Neither the name of the University nor the names of its contributors
  21  *    may be used to endorse or promote products derived from this software
  22  *    without specific prior written permission.
  23  *
  24  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
  25  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
  26  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
  27  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
  28  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
  29  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
  30  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
  31  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
  32  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
  33  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
  34  * SUCH DAMAGE.
  35  */
  36
  37 #ifndef lint
  38 static char sccsid[] = "@(#)move.c      5.3 (Berkeley) 6/1/90";
  39 #endif /* not lint */
  40
  41 /*
  42  * move.c
  43  *
  44  * This source herein may be modified and/or distributed by anybody who
  45  * so desires, with the following restrictions:
  46  *    1.)  No portion of this notice shall be removed.
  47  *    2.)  Credit shall not be taken for the creation of this source.
  48  *    3.)  This code is not to be traded, sold, or used for personal
  49  *         gain or profit.
  50  *
  51  */
  52
  53 #include "rogue.h"
  54
  55 short m_moves = 0;
  56 boolean jump = 0;
  57 char *you_can_move_again = "you can move again";
  58
  59 extern short cur_room, halluc, blind, levitate;
  60 extern short cur_level, max_level;
  61 extern short bear_trap, haste_self, confused;
  62 extern short e_rings, regeneration, auto_search;
  63 extern char hunger_str[];
  64 extern boolean being_held, interrupted, r_teleport, passgo;
  65
  66 one_move_rogue(dirch, pickup)
  67 short dirch, pickup;
  68 {
  69         short row, col;
  70         object *obj;
  71         char desc[DCOLS];
  72         short n, status, d;
  73
  74         row = rogue.row;
  75         col = rogue.col;
  76
  77         if (confused) {
  78                 dirch = gr_dir();
  79         }
  80         (void) is_direction(dirch, &d);
  81         get_dir_rc(d, &row, &col, 1);
  82
  83         if (!can_move(rogue.row, rogue.col, row, col)) {
  84                 return(MOVE_FAILED);
  85         }
  86         if (being_held || bear_trap) {
  87                 if (!(dungeon[row][col] & MONSTER)) {
  88                         if (being_held) {
  89                                 message("you are being held", 1);
  90                         } else {
  91                                 message("you are still stuck in the bear trap", 0);
  92                                 (void) reg_move();
  93                         }
  94                         return(MOVE_FAILED);
  95                 }
  96         }
  97         if (r_teleport) {
  98                 if (rand_percent(R_TELE_PERCENT)) {
  99                         tele();
 100                         return(STOPPED_ON_SOMETHING);
 101                 }
 102         }
 103         if (dungeon[row][col] & MONSTER) {
 104                 rogue_hit(object_at(&level_monsters, row, col), 0);
 105                 (void) reg_move();
 106                 return(MOVE_FAILED);
 107         }
 108         if (dungeon[row][col] & DOOR) {
 109                 if (cur_room == PASSAGE) {
 110                         cur_room = get_room_number(row, col);
 111                         light_up_room(cur_room);
 112                         wake_room(cur_room, 1, row, col);
 113                 } else {
 114                         light_passage(row, col);
 115                 }
 116         } else if ((dungeon[rogue.row][rogue.col] & DOOR) &&
 117                    (dungeon[row][col] & TUNNEL)) {
 118                 light_passage(row, col);
 119                 wake_room(cur_room, 0, rogue.row, rogue.col);
 120                 darken_room(cur_room);
 121                 cur_room = PASSAGE;
 122         } else if (dungeon[row][col] & TUNNEL) {
 123                         light_passage(row, col);
 124         }
 125         mvaddch(rogue.row, rogue.col, get_dungeon_char(rogue.row, rogue.col));
 126         mvaddch(row, col, rogue.fchar);
 127
 128         if (!jump) {
 129                 refresh();
 130         }
 131         rogue.row = row;
 132         rogue.col = col;
 133         if (dungeon[row][col] & OBJECT) {
 134                 if (levitate && pickup) {
 135                         return(STOPPED_ON_SOMETHING);
 136                 }
 137                 if (pickup && !levitate) {
 138                         if (obj = pick_up(row, col, &status)) {
 139                                 get_desc(obj, desc);
 140                                 if (obj->what_is == GOLD) {
 141                                         free_object(obj);
 142                                         goto NOT_IN_PACK;
 143                                 }
 144                         } else if (!status) {
 145                                 goto MVED;
 146                         } else {
 147                                 goto MOVE_ON;
 148                         }
 149                 } else {
 150 MOVE_ON:
 151                         obj = object_at(&level_objects, row, col);
 152                         (void) strcpy(desc, "moved onto ");
 153                         get_desc(obj, desc+11);
 154                         goto NOT_IN_PACK;
 155                 }
 156                 n = strlen(desc);
 157                 desc[n] = '(';
 158                 desc[n+1] = obj->ichar;
 159                 desc[n+2] = ')';
 160                 desc[n+3] = 0;
 161 NOT_IN_PACK:
 162                 message(desc, 1);
 163                 (void) reg_move();
 164                 return(STOPPED_ON_SOMETHING);
 165         }
 166         if (dungeon[row][col] & (DOOR | STAIRS | TRAP)) {
 167                 if ((!levitate) && (dungeon[row][col] & TRAP)) {
 168                         trap_player(row, col);
 169                 }
 170                 (void) reg_move();
 171                 return(STOPPED_ON_SOMETHING);
 172         }
 173 MVED:   if (reg_move()) {                       /* fainted from hunger */
 174                         return(STOPPED_ON_SOMETHING);
 175         }
 176         return((confused ? STOPPED_ON_SOMETHING : MOVED));
 177 }
 178
 179 multiple_move_rogue(dirch)
 180 short dirch;
 181 {
 182         short row, col;
 183         short m;
 184
 185         switch(dirch) {
 186         case '\010':
 187         case '\012':
 188         case '\013':
 189         case '\014':
 190         case '\031':
 191         case '\025':
 192         case '\016':
 193         case '\002':
 194                 do {
 195                         row = rogue.row;
 196                         col = rogue.col;
 197                         if (((m = one_move_rogue((dirch + 96), 1)) == MOVE_FAILED) ||
 198                                 (m == STOPPED_ON_SOMETHING) ||
 199                                 interrupted) {
 200                                 break;
 201                         }
 202                 } while (!next_to_something(row, col));
 203                 if (    (!interrupted) && passgo && (m == MOVE_FAILED) &&
 204                                 (dungeon[rogue.row][rogue.col] & TUNNEL)) {
 205                         turn_passage(dirch + 96, 0);
 206                 }
 207                 break;
 208         case 'H':
 209         case 'J':
 210         case 'K':
 211         case 'L':
 212         case 'B':
 213         case 'Y':
 214         case 'U':
 215         case 'N':
 216                 while ((!interrupted) && (one_move_rogue((dirch + 32), 1) == MOVED)) ;
 217
 218                 if (    (!interrupted) && passgo &&
 219                                 (dungeon[rogue.row][rogue.col] & TUNNEL)) {
 220                         turn_passage(dirch + 32, 1);
 221                 }
 222                 break;
 223         }
 224 }
 225
 226 is_passable(row, col)
 227 register row, col;
 228 {
 229         if ((row < MIN_ROW) || (row > (DROWS - 2)) || (col < 0) ||
 230                 (col > (DCOLS-1))) {
 231                 return(0);
 232         }
 233         if (dungeon[row][col] & HIDDEN) {
 234                 return((dungeon[row][col] & TRAP) ? 1 : 0);
 235         }
 236         return(dungeon[row][col] & (FLOOR | TUNNEL | DOOR | STAIRS | TRAP));
 237 }
 238
 239 next_to_something(drow, dcol)
 240 register drow, dcol;
 241 {
 242         short i, j, i_end, j_end, row, col;
 243         short pass_count = 0;
 244         unsigned short s;
 245
 246         if (confused) {
 247                 return(1);
 248         }
 249         if (blind) {
 250                 return(0);
 251         }
 252         i_end = (rogue.row < (DROWS-2)) ? 1 : 0;
 253         j_end = (rogue.col < (DCOLS-1)) ? 1 : 0;
 254
 255         for (i = ((rogue.row > MIN_ROW) ? -1 : 0); i <= i_end; i++) {
 256                 for (j = ((rogue.col > 0) ? -1 : 0); j <= j_end; j++) {
 257                         if ((i == 0) && (j == 0)) {
 258                                 continue;
 259                         }
 260                         if (((rogue.row+i) == drow) && ((rogue.col+j) == dcol)) {
 261                                 continue;
 262                         }
 263                         row = rogue.row + i;
 264                         col = rogue.col + j;
 265                         s = dungeon[row][col];
 266                         if (s & HIDDEN) {
 267                                 continue;
 268                         }
 269                         /* If the rogue used to be right, up, left, down, or right of
 270                          * row,col, and now isn't, then don't stop */
 271                         if (s & (MONSTER | OBJECT | STAIRS)) {
 272                                 if (((row == drow) || (col == dcol)) &&
 273                                         (!((row == rogue.row) || (col == rogue.col)))) {
 274                                         continue;
 275                                 }
 276                                 return(1);
 277                         }
 278                         if (s & TRAP) {
 279                                 if (!(s & HIDDEN)) {
 280                                         if (((row == drow) || (col == dcol)) &&
 281                                                 (!((row == rogue.row) || (col == rogue.col)))) {
 282                                                 continue;
 283                                         }
 284                                         return(1);
 285                                 }
 286                         }
 287                         if ((((i - j) == 1) || ((i - j) == -1)) && (s & TUNNEL)) {
 288                                 if (++pass_count > 1) {
 289                                         return(1);
 290                                 }
 291                         }
 292                         if ((s & DOOR) && ((i == 0) || (j == 0))) {
 293                                         return(1);
 294                         }
 295                 }
 296         }
 297         return(0);
 298 }
 299
 300 can_move(row1, col1, row2, col2)
 301 {
 302         if (!is_passable(row2, col2)) {
 303                 return(0);
 304         }
 305         if ((row1 != row2) && (col1 != col2)) {
 306                 if ((dungeon[row1][col1] & DOOR) || (dungeon[row2][col2] & DOOR)) {
 307                         return(0);
 308                 }
 309                 if ((!dungeon[row1][col2]) || (!dungeon[row2][col1])) {
 310                         return(0);
 311                 }
 312         }
 313         return(1);
 314 }
 315
 316 move_onto()
 317 {
 318         short ch, d;
 319         boolean first_miss = 1;
 320
 321         while (!is_direction(ch = rgetchar(), &d)) {
 322                 sound_bell();
 323                 if (first_miss) {
 324                         message("direction? ", 0);
 325                         first_miss = 0;
 326                 }
 327         }
 328         check_message();
 329         if (ch != CANCEL) {
 330                 (void) one_move_rogue(ch, 0);
 331         }
 332 }
 333
 334 boolean
 335 is_direction(c, d)
 336 short c;
 337 short *d;
 338 {
 339         switch(c) {
 340         case 'h':
 341                 *d = LEFT;
 342                 break;
 343         case 'j':
 344                 *d = DOWN;
 345                 break;
 346         case 'k':
 347                 *d = UPWARD;
 348                 break;
 349         case 'l':
 350                 *d = RIGHT;
 351                 break;
 352         case 'b':
 353                 *d = DOWNLEFT;
 354                 break;
 355         case 'y':
 356                 *d = UPLEFT;
 357                 break;
 358         case 'u':
 359                 *d = UPRIGHT;
 360                 break;
 361         case 'n':
 362                 *d = DOWNRIGHT;
 363                 break;
 364         case CANCEL:
 365                 break;
 366         default:
 367                 return(0);
 368         }
 369         return(1);
 370 }
 371
 372 boolean
 373 check_hunger(msg_only)
 374 boolean msg_only;
 375 {
 376         register short i, n;
 377         boolean fainted = 0;
 378
 379         if (rogue.moves_left == HUNGRY) {
 380                 (void) strcpy(hunger_str, "hungry");
 381                 message(hunger_str, 0);
 382                 print_stats(STAT_HUNGER);
 383         }
 384         if (rogue.moves_left == WEAK) {
 385                 (void) strcpy(hunger_str, "weak");
 386                 message(hunger_str, 1);
 387                 print_stats(STAT_HUNGER);
 388         }
 389         if (rogue.moves_left <= FAINT) {
 390                 if (rogue.moves_left == FAINT) {
 391                         (void) strcpy(hunger_str, "faint");
 392                         message(hunger_str, 1);
 393                         print_stats(STAT_HUNGER);
 394                 }
 395                 n = get_rand(0, (FAINT - rogue.moves_left));
 396                 if (n > 0) {
 397                         fainted = 1;
 398                         if (rand_percent(40)) {
 399                                 rogue.moves_left++;
 400                         }
 401                         message("you faint", 1);
 402                         for (i = 0; i < n; i++) {
 403                                 if (coin_toss()) {
 404                                         mv_mons();
 405                                 }
 406                         }
 407                         message(you_can_move_again, 1);
 408                 }
 409         }
 410         if (msg_only) {
 411                 return(fainted);
 412         }
 413         if (rogue.moves_left <= STARVE) {
 414                 killed_by((object *) 0, STARVATION);
 415         }
 416
 417         switch(e_rings) {
 418         /*case -2:
 419                 Subtract 0, i.e. do nothing.
 420                 break;*/
 421         case -1:
 422                 rogue.moves_left -= (rogue.moves_left % 2);
 423                 break;
 424         case 0:
 425                 rogue.moves_left--;
 426                 break;
 427         case 1:
 428                 rogue.moves_left--;
 429                 (void) check_hunger(1);
 430                 rogue.moves_left -= (rogue.moves_left % 2);
 431                 break;
 432         case 2:
 433                 rogue.moves_left--;
 434                 (void) check_hunger(1);
 435                 rogue.moves_left--;
 436                 break;
 437         }
 438         return(fainted);
 439 }
 440
 441 boolean
 442 reg_move()
 443 {
 444         boolean fainted;
 445
 446         if ((rogue.moves_left <= HUNGRY) || (cur_level >= max_level)) {
 447                 fainted = check_hunger(0);
 448         } else {
 449                 fainted = 0;
 450         }
 451
 452         mv_mons();
 453
 454         if (++m_moves >= 120) {
 455                 m_moves = 0;
 456                 wanderer();
 457         }
 458         if (halluc) {
 459                 if (!(--halluc)) {
 460                         unhallucinate();
 461                 } else {
 462                         hallucinate();
 463                 }
 464         }
 465         if (blind) {
 466                 if (!(--blind)) {
 467                         unblind();
 468                 }
 469         }
 470         if (confused) {
 471                 if (!(--confused)) {
 472                         unconfuse();
 473                 }
 474         }
 475         if (bear_trap) {
 476                 bear_trap--;
 477         }
 478         if (levitate) {
 479                 if (!(--levitate)) {
 480                         message("you float gently to the ground", 1);
 481                         if (dungeon[rogue.row][rogue.col] & TRAP) {
 482                                 trap_player(rogue.row, rogue.col);
 483                         }
 484                 }
 485         }
 486         if (haste_self) {
 487                 if (!(--haste_self)) {
 488                         message("you feel yourself slowing down", 0);
 489                 }
 490         }
 491         heal();
 492         if (auto_search > 0) {
 493                 search(auto_search, auto_search);
 494         }
 495         return(fainted);
 496 }
 497
 498 rest(count)
 499 {
 500         int i;
 501
 502         interrupted = 0;
 503
 504         for (i = 0; i < count; i++) {
 505                 if (interrupted) {
 506                         break;
 507                 }
 508                 (void) reg_move();
 509         }
 510 }
 511
 512 gr_dir()
 513 {
 514         short d;
 515
 516         d = get_rand(1, 8);
 517
 518         switch(d) {
 519                 case 1:
 520                         d = 'j';
 521                         break;
 522                 case 2:
 523                         d = 'k';
 524                         break;
 525                 case 3:
 526                         d = 'l';
 527                         break;
 528                 case 4:
 529                         d = 'h';
 530                         break;
 531                 case 5:
 532                         d = 'y';
 533                         break;
 534                 case 6:
 535                         d = 'u';
 536                         break;
 537                 case 7:
 538                         d = 'b';
 539                         break;
 540                 case 8:
 541                         d = 'n';
 542                         break;
 543         }
 544         return(d);
 545 }
 546
 547 heal()
 548 {
 549         static short heal_exp = -1, n, c = 0;
 550         static boolean alt;
 551
 552         if (rogue.hp_current == rogue.hp_max) {
 553                 c = 0;
 554                 return;
 555         }
 556         if (rogue.exp != heal_exp) {
 557                 heal_exp = rogue.exp;
 558
 559                 switch(heal_exp) {
 560                 case 1:
 561                         n = 20;
 562                         break;
 563                 case 2:
 564                         n = 18;
 565                         break;
 566                 case 3:
 567                         n = 17;
 568                         break;
 569                 case 4:
 570                         n = 14;
 571                         break;
 572                 case 5:
 573                         n = 13;
 574                         break;
 575                 case 6:
 576                         n = 10;
 577                         break;
 578                 case 7:
 579                         n = 9;
 580                         break;
 581                 case 8:
 582                         n = 8;
 583                         break;
 584                 case 9:
 585                         n = 7;
 586                         break;
 587                 case 10:
 588                         n = 4;
 589                         break;
 590                 case 11:
 591                         n = 3;
 592                         break;
 593                 case 12:
 594                 default:
 595                         n = 2;
 596                 }
 597         }
 598         if (++c >= n) {
 599                 c = 0;
 600                 rogue.hp_current++;
 601                 if (alt = !alt) {
 602                         rogue.hp_current++;
 603                 }
 604                 if ((rogue.hp_current += regeneration) > rogue.hp_max) {
 605                         rogue.hp_current = rogue.hp_max;
 606                 }
 607                 print_stats(STAT_HP);
 608         }
 609 }
 610
 611 static boolean
 612 can_turn(nrow, ncol)
 613 short nrow, ncol;
 614 {
 615         if ((dungeon[nrow][ncol] & TUNNEL) && is_passable(nrow, ncol)) {
 616                 return(1);
 617         }
 618         return(0);
 619 }
 620
 621 turn_passage(dir, fast)
 622 short dir;
 623 boolean fast;
 624 {
 625         short crow = rogue.row, ccol = rogue.col, turns = 0;
 626         short ndir;
 627
 628         if ((dir != 'h') && can_turn(crow, ccol + 1)) {
 629                 turns++;
 630                 ndir = 'l';
 631         }
 632         if ((dir != 'l') && can_turn(crow, ccol - 1)) {
 633                 turns++;
 634                 ndir = 'h';
 635         }
 636         if ((dir != 'k') && can_turn(crow + 1, ccol)) {
 637                 turns++;
 638                 ndir = 'j';
 639         }
 640         if ((dir != 'j') && can_turn(crow - 1, ccol)) {
 641                 turns++;
 642                 ndir = 'k';
 643         }
 644         if (turns == 1) {
 645                 multiple_move_rogue(ndir - (fast ? 32 : 96));
 646         }
 647 }