rogue/move.c

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