games/rogue/room.c

   1 /*
   2  * Copyright (c) 1988, 1993
   3  *      The Regents of the University of California.  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  * @(#)room.c   8.1 (Berkeley) 5/31/93
  37  * $FreeBSD: src/games/rogue/room.c,v 1.7 1999/11/30 03:49:26 billf Exp $
  38  * $DragonFly: src/games/rogue/room.c,v 1.2 2003/06/17 04:25:25 dillon Exp $
  39  */
  40
  41 /*
  42  * room.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 room rooms[MAXROOMS];
  56 boolean rooms_visited[MAXROOMS];
  57
  58 extern short blind;
  59 extern boolean detect_monster, jump, passgo, no_skull, ask_quit, flush;
  60 extern char *nick_name, *fruit, *save_file, *press_space;
  61
  62 #define NOPTS 8
  63
  64 struct option {
  65         const char *prompt;
  66         boolean is_bool;
  67         char **strval;
  68         boolean *bval;
  69 } options[NOPTS] = {
  70         {
  71                 "Flush typeahead during battle (\"flush\"): ",
  72                 1, (char **) 0, &flush
  73         },
  74         {
  75                 "Show position only at end of run (\"jump\"): ",
  76                 1, (char **) 0, &jump
  77         },
  78         {
  79                 "Follow turnings in passageways (\"passgo\"): ",
  80                 1, (char **) 0, &passgo
  81         },
  82         {
  83                 "Don't print skull when killed (\"noskull\" or \"notombstone\"): ",
  84                 1, (char **) 0, &no_skull
  85         },
  86         {
  87                 "Ask player before saying 'Okay, bye-bye!' (\"askquit\"): ",
  88                 1, (char **) 0, &ask_quit
  89         },
  90         {
  91                 "Name (\"name\"): ",
  92                 0, &nick_name
  93         },
  94         {
  95                 "Fruit (\"fruit\"): ",
  96                 0, &fruit
  97         },
  98         {
  99                 "Save file (\"file\"): ",
 100                 0, &save_file
 101         }
 102 };
 103
 104 light_up_room(rn)
 105 int rn;
 106 {
 107         short i, j;
 108
 109         if (!blind) {
 110                 for (i = rooms[rn].top_row;
 111                         i <= rooms[rn].bottom_row; i++) {
 112                         for (j = rooms[rn].left_col;
 113                                 j <= rooms[rn].right_col; j++) {
 114                                 if (dungeon[i][j] & MONSTER) {
 115                                         object *monster;
 116
 117                                         if (monster = object_at(&level_monsters, i, j)) {
 118                                                 dungeon[monster->row][monster->col] &= (~MONSTER);
 119                                                 monster->trail_char =
 120                                                         get_dungeon_char(monster->row, monster->col);
 121                                                 dungeon[monster->row][monster->col] |= MONSTER;
 122                                         }
 123                                 }
 124                                 mvaddch(i, j, get_dungeon_char(i, j));
 125                         }
 126                 }
 127                 mvaddch(rogue.row, rogue.col, rogue.fchar);
 128         }
 129 }
 130
 131 light_passage(row, col)
 132 int row, col;
 133 {
 134         short i, j, i_end, j_end;
 135
 136         if (blind) {
 137                 return;
 138         }
 139         i_end = (row < (DROWS-2)) ? 1 : 0;
 140         j_end = (col < (DCOLS-1)) ? 1 : 0;
 141
 142         for (i = ((row > MIN_ROW) ? -1 : 0); i <= i_end; i++) {
 143                 for (j = ((col > 0) ? -1 : 0); j <= j_end; j++) {
 144                         if (can_move(row, col, row+i, col+j)) {
 145                                 mvaddch(row+i, col+j, get_dungeon_char(row+i, col+j));
 146                         }
 147                 }
 148         }
 149 }
 150
 151 darken_room(rn)
 152 short rn;
 153 {
 154         short i, j;
 155
 156         for (i = rooms[rn].top_row + 1; i < rooms[rn].bottom_row; i++) {
 157                 for (j = rooms[rn].left_col + 1; j < rooms[rn].right_col; j++) {
 158                         if (blind) {
 159                                 mvaddch(i, j, ' ');
 160                         } else {
 161                                 if (!(dungeon[i][j] & (OBJECT | STAIRS)) &&
 162                                         !(detect_monster && (dungeon[i][j] & MONSTER))) {
 163                                         if (!imitating(i, j)) {
 164                                                 mvaddch(i, j, ' ');
 165                                         }
 166                                         if ((dungeon[i][j] & TRAP) && (!(dungeon[i][j] & HIDDEN))) {
 167                                                 mvaddch(i, j, '^');
 168                                         }
 169                                 }
 170                         }
 171                 }
 172         }
 173 }
 174
 175 get_dungeon_char(row, col)
 176 int row, col;
 177 {
 178         unsigned short mask = dungeon[row][col];
 179
 180         if (mask & MONSTER) {
 181                 return(gmc_row_col(row, col));
 182         }
 183         if (mask & OBJECT) {
 184                 object *obj;
 185
 186                 obj = object_at(&level_objects, row, col);
 187                 return(get_mask_char(obj->what_is));
 188         }
 189         if (mask & (TUNNEL | STAIRS | HORWALL | VERTWALL | FLOOR | DOOR)) {
 190                 if ((mask & (TUNNEL| STAIRS)) && (!(mask & HIDDEN))) {
 191                         return(((mask & STAIRS) ? '%' : '#'));
 192                 }
 193                 if (mask & HORWALL) {
 194                         return('-');
 195                 }
 196                 if (mask & VERTWALL) {
 197                         return('|');
 198                 }
 199                 if (mask & FLOOR) {
 200                         if (mask & TRAP) {
 201                                 if (!(dungeon[row][col] & HIDDEN)) {
 202                                         return('^');
 203                                 }
 204                         }
 205                         return('.');
 206                 }
 207                 if (mask & DOOR) {
 208                         if (mask & HIDDEN) {
 209                                 if (((col > 0) && (dungeon[row][col-1] & HORWALL)) ||
 210                                         ((col < (DCOLS-1)) && (dungeon[row][col+1] & HORWALL))) {
 211                                         return('-');
 212                                 } else {
 213                                         return('|');
 214                                 }
 215                         } else {
 216                                 return('+');
 217                         }
 218                 }
 219         }
 220         return(' ');
 221 }
 222
 223 get_mask_char(mask)
 224 unsigned short mask;
 225 {
 226                 switch(mask) {
 227                 case SCROL:
 228                         return('?');
 229                 case POTION:
 230                         return('!');
 231                 case GOLD:
 232                         return('*');
 233                 case FOOD:
 234                         return(':');
 235                 case WAND:
 236                         return('/');
 237                 case ARMOR:
 238                         return(']');
 239                 case WEAPON:
 240                         return(')');
 241                 case RING:
 242                         return('=');
 243                 case AMULET:
 244                         return(',');
 245                 default:
 246                         return('~');    /* unknown, something is wrong */
 247                 }
 248 }
 249
 250 gr_row_col(row, col, mask)
 251 short *row, *col;
 252 unsigned short mask;
 253 {
 254         short rn;
 255         short r, c;
 256
 257         do {
 258                 r = get_rand(MIN_ROW, DROWS-2);
 259                 c = get_rand(0, DCOLS-1);
 260                 rn = get_room_number(r, c);
 261         } while ((rn == NO_ROOM) ||
 262                 (!(dungeon[r][c] & mask)) ||
 263                 (dungeon[r][c] & (~mask)) ||
 264                 (!(rooms[rn].is_room & (R_ROOM | R_MAZE))) ||
 265                 ((r == rogue.row) && (c == rogue.col)));
 266
 267         *row = r;
 268         *col = c;
 269 }
 270
 271 gr_room()
 272 {
 273         short i;
 274
 275         do {
 276                 i = get_rand(0, MAXROOMS-1);
 277         } while (!(rooms[i].is_room & (R_ROOM | R_MAZE)));
 278
 279         return(i);
 280 }
 281
 282 party_objects(rn)
 283 {
 284         short i, j, nf = 0;
 285         object *obj;
 286         short n, N, row, col;
 287         boolean found;
 288
 289         N = ((rooms[rn].bottom_row - rooms[rn].top_row) - 1) *
 290                 ((rooms[rn].right_col - rooms[rn].left_col) - 1);
 291         n =  get_rand(5, 10);
 292         if (n > N) {
 293                 n = N - 2;
 294         }
 295         for (i = 0; i < n; i++) {
 296                 for (j = found = 0; ((!found) && (j < 250)); j++) {
 297                         row = get_rand(rooms[rn].top_row+1,
 298                                            rooms[rn].bottom_row-1);
 299                         col = get_rand(rooms[rn].left_col+1,
 300                                            rooms[rn].right_col-1);
 301                         if ((dungeon[row][col] == FLOOR) || (dungeon[row][col] == TUNNEL)) {
 302                                 found = 1;
 303                         }
 304                 }
 305                 if (found) {
 306                         obj = gr_object();
 307                         place_at(obj, row, col);
 308                         nf++;
 309                 }
 310         }
 311         return(nf);
 312 }
 313
 314 get_room_number(row, col)
 315 int row, col;
 316 {
 317         short i;
 318
 319         for (i = 0; i < MAXROOMS; i++) {
 320                 if ((row >= rooms[i].top_row) && (row <= rooms[i].bottom_row) &&
 321                         (col >= rooms[i].left_col) && (col <= rooms[i].right_col)) {
 322                         return(i);
 323                 }
 324         }
 325         return(NO_ROOM);
 326 }
 327
 328 is_all_connected()
 329 {
 330         short i, starting_room;
 331
 332         for (i = 0; i < MAXROOMS; i++) {
 333                 rooms_visited[i] = 0;
 334                 if (rooms[i].is_room & (R_ROOM | R_MAZE)) {
 335                         starting_room = i;
 336                 }
 337         }
 338
 339         visit_rooms(starting_room);
 340
 341         for (i = 0; i < MAXROOMS; i++) {
 342                 if ((rooms[i].is_room & (R_ROOM | R_MAZE)) && (!rooms_visited[i])) {
 343                         return(0);
 344                 }
 345         }
 346         return(1);
 347 }
 348
 349 visit_rooms(rn)
 350 int rn;
 351 {
 352         short i;
 353         short oth_rn;
 354
 355         rooms_visited[rn] = 1;
 356
 357         for (i = 0; i < 4; i++) {
 358                 oth_rn = rooms[rn].doors[i].oth_room;
 359                 if ((oth_rn >= 0) && (!rooms_visited[oth_rn])) {
 360                         visit_rooms(oth_rn);
 361                 }
 362         }
 363 }
 364
 365 draw_magic_map()
 366 {
 367         short i, j, ch, och;
 368         unsigned short mask = (HORWALL | VERTWALL | DOOR | TUNNEL | TRAP | STAIRS |
 369                         MONSTER);
 370         unsigned short s;
 371
 372         for (i = 0; i < DROWS; i++) {
 373                 for (j = 0; j < DCOLS; j++) {
 374                         s = dungeon[i][j];
 375                         if (s & mask) {
 376                                 if (((ch = mvinch(i, j)) == ' ') ||
 377                                         ((ch >= 'A') && (ch <= 'Z')) || (s & (TRAP | HIDDEN))) {
 378                                         och = ch;
 379                                         dungeon[i][j] &= (~HIDDEN);
 380                                         if (s & HORWALL) {
 381                                                 ch = '-';
 382                                         } else if (s & VERTWALL) {
 383                                                 ch = '|';
 384                                         } else if (s & DOOR) {
 385                                                 ch = '+';
 386                                         } else if (s & TRAP) {
 387                                                 ch = '^';
 388                                         } else if (s & STAIRS) {
 389                                                 ch = '%';
 390                                         } else if (s & TUNNEL) {
 391                                                 ch = '#';
 392                                         } else {
 393                                                 continue;
 394                                         }
 395                                         if ((!(s & MONSTER)) || (och == ' ')) {
 396                                                 addch(ch);
 397                                         }
 398                                         if (s & MONSTER) {
 399                                                 object *monster;
 400
 401                                                 if (monster = object_at(&level_monsters, i, j)) {
 402                                                         monster->trail_char = ch;
 403                                                 }
 404                                         }
 405                                 }
 406                         }
 407                 }
 408         }
 409 }
 410
 411 dr_course(monster, entering, row, col)
 412 object *monster;
 413 boolean entering;
 414 short row, col;
 415 {
 416         short i, j, k, rn;
 417         short r, rr;
 418
 419         monster->row = row;
 420         monster->col = col;
 421
 422         if (mon_sees(monster, rogue.row, rogue.col)) {
 423                 monster->trow = NO_ROOM;
 424                 return;
 425         }
 426         rn = get_room_number(row, col);
 427
 428         if (entering) {         /* entering room */
 429                 /* look for door to some other room */
 430                 r = get_rand(0, MAXROOMS-1);
 431                 for (i = 0; i < MAXROOMS; i++) {
 432                         rr = (r + i) % MAXROOMS;
 433                         if ((!(rooms[rr].is_room & (R_ROOM | R_MAZE))) || (rr == rn)) {
 434                                 continue;
 435                         }
 436                         for (k = 0; k < 4; k++) {
 437                                 if (rooms[rr].doors[k].oth_room == rn) {
 438                                         monster->trow = rooms[rr].doors[k].oth_row;
 439                                         monster->tcol = rooms[rr].doors[k].oth_col;
 440                                         if ((monster->trow == row) &&
 441                                                 (monster->tcol == col)) {
 442                                                 continue;
 443                                         }
 444                                         return;
 445                                 }
 446                         }
 447                 }
 448                 /* look for door to dead end */
 449                 for (i = rooms[rn].top_row; i <= rooms[rn].bottom_row; i++) {
 450                         for (j = rooms[rn].left_col; j <= rooms[rn].right_col; j++) {
 451                                 if ((i != monster->row) && (j != monster->col) &&
 452                                         (dungeon[i][j] & DOOR)) {
 453                                         monster->trow = i;
 454                                         monster->tcol = j;
 455                                         return;
 456                                 }
 457                         }
 458                 }
 459                 /* return monster to room that he came from */
 460                 for (i = 0; i < MAXROOMS; i++) {
 461                         for (j = 0; j < 4; j++) {
 462                                 if (rooms[i].doors[j].oth_room == rn) {
 463                                         for (k = 0; k < 4; k++) {
 464                                                 if (rooms[rn].doors[k].oth_room == i) {
 465                                                         monster->trow = rooms[rn].doors[k].oth_row;
 466                                                         monster->tcol = rooms[rn].doors[k].oth_col;
 467                                                         return;
 468                                                 }
 469                                         }
 470                                 }
 471                         }
 472                 }
 473                 /* no place to send monster */
 474                 monster->trow = NO_ROOM;
 475         } else {                /* exiting room */
 476                 if (!get_oth_room(rn, &row, &col)) {
 477                         monster->trow = NO_ROOM;
 478                 } else {
 479                         monster->trow = row;
 480                         monster->tcol = col;
 481                 }
 482         }
 483 }
 484
 485 get_oth_room(rn, row, col)
 486 short rn, *row, *col;
 487 {
 488         short d = -1;
 489
 490         if (*row == rooms[rn].top_row) {
 491                 d = UPWARD/2;
 492         } else if (*row == rooms[rn].bottom_row) {
 493                 d = DOWN/2;
 494         } else if (*col == rooms[rn].left_col) {
 495                 d = LEFT/2;
 496         } else if (*col == rooms[rn].right_col) {
 497                 d = RIGHT/2;
 498         }
 499         if ((d != -1) && (rooms[rn].doors[d].oth_room >= 0)) {
 500                 *row = rooms[rn].doors[d].oth_row;
 501                 *col = rooms[rn].doors[d].oth_col;
 502                 return(1);
 503         }
 504         return(0);
 505 }
 506
 507 edit_opts()
 508 {
 509         char save[NOPTS+1][DCOLS];
 510         short i, j;
 511         short ch;
 512         boolean done = 0;
 513         char buf[MAX_OPT_LEN + 2];
 514
 515         for (i = 0; i < NOPTS+1; i++) {
 516                 for (j = 0; j < DCOLS; j++) {
 517                         save[i][j] = mvinch(i, j);
 518                 }
 519                 if (i < NOPTS) {
 520                         opt_show(i);
 521                 }
 522         }
 523         opt_go(0);
 524         i = 0;
 525
 526         while (!done) {
 527                 refresh();
 528                 ch = rgetchar();
 529 CH:
 530                 switch(ch) {
 531                 case '\033':
 532                         done = 1;
 533                         break;
 534                 case '\012':
 535                 case '\015':
 536                         if (i == (NOPTS - 1)) {
 537                                 mvaddstr(NOPTS, 0, press_space);
 538                                 refresh();
 539                                 wait_for_ack();
 540                                 done = 1;
 541                         } else {
 542                                 i++;
 543                                 opt_go(i);
 544                         }
 545                         break;
 546                 case '-':
 547                         if (i > 0) {
 548                                 opt_go(--i);
 549                         } else {
 550                                 sound_bell();
 551                         }
 552                         break;
 553                 case 't':
 554                 case 'T':
 555                 case 'f':
 556                 case 'F':
 557                         if (options[i].is_bool) {
 558                                 *(options[i].bval) = (((ch == 't') || (ch == 'T')) ? 1 : 0);
 559                                 opt_show(i);
 560                                 opt_go(++i);
 561                                 break;
 562                         }
 563                 default:
 564                         if (options[i].is_bool) {
 565                                 sound_bell();
 566                                 break;
 567                         }
 568                         j = 0;
 569                         if ((ch == '\010') || ((ch >= ' ') && (ch <= '~'))) {
 570                                 opt_erase(i);
 571                                 do {
 572                                         if ((ch >= ' ') && (ch <= '~') && (j < MAX_OPT_LEN)) {
 573                                                 buf[j++] = ch;
 574                                                 buf[j] = '\0';
 575                                                 addch(ch);
 576                                         } else if ((ch == '\010') && (j > 0)) {
 577                                                 buf[--j] = '\0';
 578                                                 move(i, j + strlen(options[i].prompt));
 579                                                 addch(' ');
 580                                                 move(i, j + strlen(options[i].prompt));
 581                                         }
 582                                         refresh();
 583                                         ch = rgetchar();
 584                                 } while ((ch != '\012') && (ch != '\015') && (ch != '\033'));
 585                                 if (j != 0) {
 586                                         (void) strcpy(*(options[i].strval), buf);
 587                                 }
 588                                 opt_show(i);
 589                                 goto CH;
 590                         } else {
 591                                 sound_bell();
 592                         }
 593                         break;
 594                 }
 595         }
 596
 597         for (i = 0; i < NOPTS+1; i++) {
 598                 move(i, 0);
 599                 for (j = 0; j < DCOLS; j++) {
 600                         addch(save[i][j]);
 601                 }
 602         }
 603 }
 604
 605 opt_show(i)
 606 int i;
 607 {
 608         const char *s;
 609         struct option *opt = &options[i];
 610
 611         opt_erase(i);
 612
 613         if (opt->is_bool) {
 614                 s = *(opt->bval) ? "True" : "False";
 615         } else {
 616                 s = *(opt->strval);
 617         }
 618         addstr(s);
 619 }
 620
 621 opt_erase(i)
 622 int i;
 623 {
 624         struct option *opt = &options[i];
 625
 626         mvaddstr(i, 0, opt->prompt);
 627         clrtoeol();
 628 }
 629
 630 opt_go(i)
 631 int i;
 632 {
 633         move(i, strlen(options[i].prompt));
 634 }
 635
 636 do_shell()
 637 {
 638 #ifdef UNIX
 639         const char *sh;
 640
 641         md_ignore_signals();
 642         if (!(sh = md_getenv("SHELL"))) {
 643                 sh = "/bin/sh";
 644         }
 645         move(LINES-1, 0);
 646         refresh();
 647         stop_window();
 648         printf("\nCreating new shell...\n");
 649         md_shell(sh);
 650         start_window();
 651         wrefresh(curscr);
 652         md_heed_signals();
 653 #endif
 654 }