rogue/monster.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[] = "@(#)monster.c   5.3 (Berkeley) 6/1/90";
  39 #endif /* not lint */
  40
  41 /*
  42  * monster.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 object level_monsters;
  56 boolean mon_disappeared;
  57
  58 char *m_names[] = {
  59         "aquator",
  60         "bat",
  61         "centaur",
  62         "dragon",
  63         "emu",
  64         "venus fly-trap",
  65         "griffin",
  66         "hobgoblin",
  67         "ice monster",
  68         "jabberwock",
  69         "kestrel",
  70         "leprechaun",
  71         "medusa",
  72         "nymph",
  73         "orc",
  74         "phantom",
  75         "quagga",
  76         "rattlesnake",
  77         "snake",
  78         "troll",
  79         "black unicorn",
  80         "vampire",
  81         "wraith",
  82         "xeroc",
  83         "yeti",
  84         "zombie"
  85 };
  86
  87 object mon_tab[MONSTERS] = {
  88         {(ASLEEP|WAKENS|WANDERS|RUSTS),"0d0",25,'A',20,9,18,100,0,0,0,0,0},
  89         {(ASLEEP|WANDERS|FLITS|FLIES),"1d3",10,'B',2,1,8,60,0,0,0,0,0},
  90         {(ASLEEP|WANDERS),"3d3/2d5",32,'C',15,7,16,85,0,10,0,0,0},
  91         {(ASLEEP|WAKENS|FLAMES),"4d6/4d9",145,'D',5000,21,126,100,0,90,0,0,0},
  92         {(ASLEEP|WAKENS),"1d3",11,'E',2,1,7,65,0,0,0,0,0},
  93         {(HOLDS|STATIONARY),"5d5",73,'F',91,12,126,80,0,0,0,0,0},
  94         {(ASLEEP|WAKENS|WANDERS|FLIES),"5d5/5d5",115,'G',
  95                         2000,20,126,85,0,10,0,0,0},
  96         {(ASLEEP|WAKENS|WANDERS),"1d3/1d2",15,'H',3,1,10,67,0,0,0,0,0},
  97         {(ASLEEP|FREEZES),"0d0",15,'I',5,2,11,68,0,0,0,0,0},
  98         {(ASLEEP|WANDERS),"3d10/4d5",132,'J',3000,21,126,100,0,0,0,0,0},
  99         {(ASLEEP|WAKENS|WANDERS|FLIES),"1d4",10,'K',2,1,6,60,0,0,0,0,0},
 100         {(ASLEEP|STEALS_GOLD),"0d0",25,'L',21,6,16,75,0,0,0,0,0},
 101         {(ASLEEP|WAKENS|WANDERS|CONFUSES),"4d4/3d7",97,'M',
 102                         250,18,126,85,0,25,0,0,0},
 103         {(ASLEEP|STEALS_ITEM),"0d0",25,'N',39,10,19,75,0,100,0,0,0},
 104         {(ASLEEP|WANDERS|WAKENS|SEEKS_GOLD),"1d6",25,'O',5,4,13,70,0,10,0,0,0},
 105         {(ASLEEP|INVISIBLE|WANDERS|FLITS),"5d4",76,'P',120,15,24,80,0,50,0,0,0},
 106         {(ASLEEP|WAKENS|WANDERS),"3d5",30,'Q',20,8,17,78,0,20,0,0,0},
 107         {(ASLEEP|WAKENS|WANDERS|STINGS),"2d5",19,'R',10,3,12,70,0,0,0,0,0},
 108         {(ASLEEP|WAKENS|WANDERS),"1d3",8,'S',2,1,9,50,0,0,0,0,0},
 109         {(ASLEEP|WAKENS|WANDERS),"4d6/1d4",75,'T',125,13,22,75,0,33,0,0,0},
 110         {(ASLEEP|WAKENS|WANDERS),"4d10",90,'U',
 111                         200,17,26,85,0,33,0,0,0},
 112         {(ASLEEP|WAKENS|WANDERS|DRAINS_LIFE),"1d14/1d4",55,'V',
 113                         350,19,126,85,0,18,0,0,0},
 114         {(ASLEEP|WANDERS|DROPS_LEVEL),"2d8",45,'W',55,14,23,75,0,0,0,0,0},
 115         {(ASLEEP|IMITATES),"4d6",42,'X',110,16,25,75,0,0,0,0,0},
 116         {(ASLEEP|WANDERS),"3d6",35,'Y',50,11,20,80,0,20,0,0,0},
 117         {(ASLEEP|WAKENS|WANDERS),"1d7",21,'Z',8,5,14,69,0,0,0,0,0}
 118 };
 119
 120 extern short cur_level;
 121 extern short cur_room, party_room;
 122 extern short blind, halluc, haste_self;
 123 extern boolean detect_monster, see_invisible, r_see_invisible;
 124 extern short stealthy;
 125
 126 put_mons()
 127 {
 128         short i;
 129         short n;
 130         object *monster;
 131         short row, col;
 132
 133         n = get_rand(4, 6);
 134
 135         for (i = 0; i < n; i++) {
 136                 monster = gr_monster((object *) 0, 0);
 137                 if ((monster->m_flags & WANDERS) && coin_toss()) {
 138                         wake_up(monster);
 139                 }
 140                 gr_row_col(&row, &col, (FLOOR | TUNNEL | STAIRS | OBJECT));
 141                 put_m_at(row, col, monster);
 142         }
 143 }
 144
 145 object *
 146 gr_monster(monster, mn)
 147 register object *monster;
 148 register mn;
 149 {
 150         if (!monster) {
 151                 monster = alloc_object();
 152
 153                 for (;;) {
 154                         mn = get_rand(0, MONSTERS-1);
 155                         if ((cur_level >= mon_tab[mn].first_level) &&
 156                         (cur_level <= mon_tab[mn].last_level)) {
 157                                 break;
 158                         }
 159                 }
 160         }
 161         *monster = mon_tab[mn];
 162         if (monster->m_flags & IMITATES) {
 163                 monster->disguise = gr_obj_char();
 164         }
 165         if (cur_level > (AMULET_LEVEL + 2)) {
 166                 monster->m_flags |= HASTED;
 167         }
 168         monster->trow = NO_ROOM;
 169         return(monster);
 170 }
 171
 172 mv_mons()
 173 {
 174         register object *monster, *next_monster;
 175         boolean flew;
 176
 177         if (haste_self % 2) {
 178                 return;
 179         }
 180
 181         monster = level_monsters.next_monster;
 182
 183         while (monster) {
 184                 next_monster = monster->next_monster;
 185                 mon_disappeared = 0;
 186                 if (monster->m_flags & HASTED) {
 187                         mv_1_monster(monster, rogue.row, rogue.col);
 188                         if (mon_disappeared) {
 189                                 goto NM;
 190                         }
 191                 } else if (monster->m_flags & SLOWED) {
 192                         monster->slowed_toggle = !monster->slowed_toggle;
 193                         if (monster->slowed_toggle) {
 194                                 goto NM;
 195                         }
 196                 }
 197                 if ((monster->m_flags & CONFUSED) && move_confused(monster)) {
 198                         goto NM;
 199                 }
 200                 flew = 0;
 201                 if (    (monster->m_flags & FLIES) &&
 202                                 !(monster->m_flags & NAPPING) &&
 203                                 !mon_can_go(monster, rogue.row, rogue.col)) {
 204                         flew = 1;
 205                         mv_1_monster(monster, rogue.row, rogue.col);
 206                         if (mon_disappeared) {
 207                                 goto NM;
 208                         }
 209                 }
 210                 if (!(flew && mon_can_go(monster, rogue.row, rogue.col))) {
 211                         mv_1_monster(monster, rogue.row, rogue.col);
 212                 }
 213 NM:             monster = next_monster;
 214         }
 215 }
 216
 217 party_monsters(rn, n)
 218 int rn, n;
 219 {
 220         short i, j;
 221         short row, col;
 222         object *monster;
 223         boolean found;
 224
 225         n += n;
 226
 227         for (i = 0; i < MONSTERS; i++) {
 228                 mon_tab[i].first_level -= (cur_level % 3);
 229         }
 230         for (i = 0; i < n; i++) {
 231                 if (no_room_for_monster(rn)) {
 232                         break;
 233                 }
 234                 for (j = found = 0; ((!found) && (j < 250)); j++) {
 235                         row = get_rand(rooms[rn].top_row+1,
 236                                 rooms[rn].bottom_row-1);
 237                         col = get_rand(rooms[rn].left_col+1,
 238                                 rooms[rn].right_col-1);
 239                         if ((!(dungeon[row][col] & MONSTER)) &&
 240                                 (dungeon[row][col] & (FLOOR | TUNNEL))) {
 241                                 found = 1;
 242                         }
 243                 }
 244                 if (found) {
 245                         monster = gr_monster((object *) 0, 0);
 246                         if (!(monster->m_flags & IMITATES)) {
 247                                 monster->m_flags |= WAKENS;
 248                         }
 249                         put_m_at(row, col, monster);
 250                 }
 251         }
 252         for (i = 0; i < MONSTERS; i++) {
 253                 mon_tab[i].first_level += (cur_level % 3);
 254         }
 255 }
 256
 257 gmc_row_col(row, col)
 258 register row, col;
 259 {
 260         register object *monster;
 261
 262         if (monster = object_at(&level_monsters, row, col)) {
 263                 if ((!(detect_monster || see_invisible || r_see_invisible) &&
 264                         (monster->m_flags & INVISIBLE)) || blind) {
 265                         return(monster->trail_char);
 266                 }
 267                 if (monster->m_flags & IMITATES) {
 268                         return(monster->disguise);
 269                 }
 270                 return(monster->m_char);
 271         } else {
 272                 return('&');    /* BUG if this ever happens */
 273         }
 274 }
 275
 276 gmc(monster)
 277 object *monster;
 278 {
 279         if ((!(detect_monster || see_invisible || r_see_invisible) &&
 280                 (monster->m_flags & INVISIBLE))
 281                 || blind) {
 282                 return(monster->trail_char);
 283         }
 284         if (monster->m_flags & IMITATES) {
 285                 return(monster->disguise);
 286         }
 287         return(monster->m_char);
 288 }
 289
 290 mv_1_monster(monster, row, col)
 291 register object *monster;
 292 short row, col;
 293 {
 294         short i, n;
 295         boolean tried[6];
 296
 297         if (monster->m_flags & ASLEEP) {
 298                 if (monster->m_flags & NAPPING) {
 299                         if (--monster->nap_length <= 0) {
 300                                 monster->m_flags &= (~(NAPPING | ASLEEP));
 301                         }
 302                         return;
 303                 }
 304                 if ((monster->m_flags & WAKENS) &&
 305                          rogue_is_around(monster->row, monster->col) &&
 306                          rand_percent(((stealthy > 0) ?
 307                                 (WAKE_PERCENT / (STEALTH_FACTOR + stealthy)) :
 308                                 WAKE_PERCENT))) {
 309                         wake_up(monster);
 310                 }
 311                 return;
 312         } else if (monster->m_flags & ALREADY_MOVED) {
 313                 monster->m_flags &= (~ALREADY_MOVED);
 314                 return;
 315         }
 316         if ((monster->m_flags & FLITS) && flit(monster)) {
 317                 return;
 318         }
 319         if ((monster->m_flags & STATIONARY) &&
 320                 (!mon_can_go(monster, rogue.row, rogue.col))) {
 321                 return;
 322         }
 323         if (monster->m_flags & FREEZING_ROGUE) {
 324                 return;
 325         }
 326         if ((monster->m_flags & CONFUSES) && m_confuse(monster)) {
 327                 return;
 328         }
 329         if (mon_can_go(monster, rogue.row, rogue.col)) {
 330                 mon_hit(monster);
 331                 return;
 332         }
 333         if ((monster->m_flags & FLAMES) && flame_broil(monster)) {
 334                 return;
 335         }
 336         if ((monster->m_flags & SEEKS_GOLD) && seek_gold(monster)) {
 337                 return;
 338         }
 339         if ((monster->trow == monster->row) &&
 340                    (monster->tcol == monster->col)) {
 341                 monster->trow = NO_ROOM;
 342         } else if (monster->trow != NO_ROOM) {
 343                 row = monster->trow;
 344                 col = monster->tcol;
 345         }
 346         if (monster->row > row) {
 347                 row = monster->row - 1;
 348         } else if (monster->row < row) {
 349                 row = monster->row + 1;
 350         }
 351         if ((dungeon[row][monster->col] & DOOR) &&
 352                  mtry(monster, row, monster->col)) {
 353                 return;
 354         }
 355         if (monster->col > col) {
 356                 col = monster->col - 1;
 357         } else if (monster->col < col) {
 358                 col = monster->col + 1;
 359         }
 360         if ((dungeon[monster->row][col] & DOOR) &&
 361                  mtry(monster, monster->row, col)) {
 362                 return;
 363         }
 364         if (mtry(monster, row, col)) {
 365                 return;
 366         }
 367
 368         for (i = 0; i <= 5; i++) tried[i] = 0;
 369
 370         for (i = 0; i < 6; i++) {
 371 NEXT_TRY:       n = get_rand(0, 5);
 372                 switch(n) {
 373                 case 0:
 374                         if (!tried[n] && mtry(monster, row, monster->col-1)) {
 375                                 goto O;
 376                         }
 377                         break;
 378                 case 1:
 379                         if (!tried[n] && mtry(monster, row, monster->col)) {
 380                                 goto O;
 381                         }
 382                         break;
 383                 case 2:
 384                         if (!tried[n] && mtry(monster, row, monster->col+1)) {
 385                                 goto O;
 386                         }
 387                         break;
 388                 case 3:
 389                         if (!tried[n] && mtry(monster, monster->row-1, col)) {
 390                                 goto O;
 391                         }
 392                         break;
 393                 case 4:
 394                         if (!tried[n] && mtry(monster, monster->row, col)) {
 395                                 goto O;
 396                         }
 397                         break;
 398                 case 5:
 399                         if (!tried[n] && mtry(monster, monster->row+1, col)) {
 400                                 goto O;
 401                         }
 402                         break;
 403                 }
 404                 if (!tried[n]) {
 405                         tried[n] = 1;
 406                 } else {
 407                         goto NEXT_TRY;
 408                 }
 409         }
 410 O:
 411         if ((monster->row == monster->o_row) && (monster->col == monster->o_col)) {
 412                 if (++(monster->o) > 4) {
 413                         if ((monster->trow == NO_ROOM) &&
 414                                         (!mon_sees(monster, rogue.row, rogue.col))) {
 415                                 monster->trow = get_rand(1, (DROWS - 2));
 416                                 monster->tcol = get_rand(0, (DCOLS - 1));
 417                         } else {
 418                                 monster->trow = NO_ROOM;
 419                                 monster->o = 0;
 420                         }
 421                 }
 422         } else {
 423                 monster->o_row = monster->row;
 424                 monster->o_col = monster->col;
 425                 monster->o = 0;
 426         }
 427 }
 428
 429 mtry(monster, row, col)
 430 register object *monster;
 431 register short row, col;
 432 {
 433         if (mon_can_go(monster, row, col)) {
 434                 move_mon_to(monster, row, col);
 435                 return(1);
 436         }
 437         return(0);
 438 }
 439
 440 move_mon_to(monster, row, col)
 441 register object *monster;
 442 register short row, col;
 443 {
 444         short c;
 445         register mrow, mcol;
 446
 447         mrow = monster->row;
 448         mcol = monster->col;
 449
 450         dungeon[mrow][mcol] &= ~MONSTER;
 451         dungeon[row][col] |= MONSTER;
 452
 453         c = mvinch(mrow, mcol);
 454
 455         if ((c >= 'A') && (c <= 'Z')) {
 456                 if (!detect_monster) {
 457                         mvaddch(mrow, mcol, monster->trail_char);
 458                 } else {
 459                         if (rogue_can_see(mrow, mcol)) {
 460                                 mvaddch(mrow, mcol, monster->trail_char);
 461                         } else {
 462                                 if (monster->trail_char == '.') {
 463                                         monster->trail_char = ' ';
 464                                 }
 465                                 mvaddch(mrow, mcol, monster->trail_char);
 466                         }
 467                 }
 468         }
 469         monster->trail_char = mvinch(row, col);
 470         if (!blind && (detect_monster || rogue_can_see(row, col))) {
 471                 if ((!(monster->m_flags & INVISIBLE) ||
 472                         (detect_monster || see_invisible || r_see_invisible))) {
 473                         mvaddch(row, col, gmc(monster));
 474                 }
 475         }
 476         if ((dungeon[row][col] & DOOR) &&
 477                 (get_room_number(row, col) != cur_room) &&
 478                 (dungeon[mrow][mcol] == FLOOR) && !blind) {
 479                         mvaddch(mrow, mcol, ' ');
 480         }
 481         if (dungeon[row][col] & DOOR) {
 482                         dr_course(monster, ((dungeon[mrow][mcol] & TUNNEL) ? 1 : 0),
 483                                 row, col);
 484         } else {
 485                 monster->row = row;
 486                 monster->col = col;
 487         }
 488 }
 489
 490 mon_can_go(monster, row, col)
 491 register object *monster;
 492 register short row, col;
 493 {
 494         object *obj;
 495         short dr, dc;
 496
 497         dr = monster->row - row;        /* check if move distance > 1 */
 498         if ((dr >= 2) || (dr <= -2)) {
 499                 return(0);
 500         }
 501         dc = monster->col - col;
 502         if ((dc >= 2) || (dc <= -2)) {
 503                 return(0);
 504         }
 505         if ((!dungeon[monster->row][col]) || (!dungeon[row][monster->col])) {
 506                 return(0);
 507         }
 508         if ((!is_passable(row, col)) || (dungeon[row][col] & MONSTER)) {
 509                 return(0);
 510         }
 511         if ((monster->row!=row)&&(monster->col!=col)&&((dungeon[row][col]&DOOR) ||
 512                 (dungeon[monster->row][monster->col]&DOOR))) {
 513                 return(0);
 514         }
 515         if (!(monster->m_flags & (FLITS | CONFUSED | CAN_FLIT)) &&
 516                 (monster->trow == NO_ROOM)) {
 517                 if ((monster->row < rogue.row) && (row < monster->row)) return(0);
 518                 if ((monster->row > rogue.row) && (row > monster->row)) return(0);
 519                 if ((monster->col < rogue.col) && (col < monster->col)) return(0);
 520                 if ((monster->col > rogue.col) && (col > monster->col)) return(0);
 521         }
 522         if (dungeon[row][col] & OBJECT) {
 523                 obj = object_at(&level_objects, row, col);
 524                 if ((obj->what_is == SCROL) && (obj->which_kind == SCARE_MONSTER)) {
 525                         return(0);
 526                 }
 527         }
 528         return(1);
 529 }
 530
 531 wake_up(monster)
 532 object *monster;
 533 {
 534         if (!(monster->m_flags & NAPPING)) {
 535                 monster->m_flags &= (~(ASLEEP | IMITATES | WAKENS));
 536         }
 537 }
 538
 539 wake_room(rn, entering, row, col)
 540 short rn;
 541 boolean entering;
 542 short row, col;
 543 {
 544         object *monster;
 545         short wake_percent;
 546         boolean in_room;
 547
 548         wake_percent = (rn == party_room) ? PARTY_WAKE_PERCENT : WAKE_PERCENT;
 549         if (stealthy > 0) {
 550                 wake_percent /= (STEALTH_FACTOR + stealthy);
 551         }
 552
 553         monster = level_monsters.next_monster;
 554
 555         while (monster) {
 556                 in_room = (rn == get_room_number(monster->row, monster->col));
 557                 if (in_room) {
 558                         if (entering) {
 559                                 monster->trow = NO_ROOM;
 560                         } else {
 561                                 monster->trow = row;
 562                                 monster->tcol = col;
 563                         }
 564                 }
 565                 if ((monster->m_flags & WAKENS) &&
 566                         (rn == get_room_number(monster->row, monster->col))) {
 567                         if (rand_percent(wake_percent)) {
 568                                 wake_up(monster);
 569                         }
 570                 }
 571                 monster = monster->next_monster;
 572         }
 573 }
 574
 575 char *
 576 mon_name(monster)
 577 object *monster;
 578 {
 579         short ch;
 580
 581         if (blind || ((monster->m_flags & INVISIBLE) &&
 582                 !(detect_monster || see_invisible || r_see_invisible))) {
 583                 return("something");
 584         }
 585         if (halluc) {
 586                 ch = get_rand('A', 'Z') - 'A';
 587                 return(m_names[ch]);
 588         }
 589         ch = monster->m_char - 'A';
 590         return(m_names[ch]);
 591 }
 592
 593 rogue_is_around(row, col)
 594 register row, col;
 595 {
 596         short rdif, cdif, retval;
 597
 598         rdif = row - rogue.row;
 599         cdif = col - rogue.col;
 600
 601         retval = (rdif >= -1) && (rdif <= 1) && (cdif >= -1) && (cdif <= 1);
 602         return(retval);
 603 }
 604
 605 wanderer()
 606 {
 607         object *monster;
 608         short row, col, i;
 609         boolean found = 0;
 610
 611         for (i = 0; ((i < 15) && (!found)); i++) {
 612                 monster = gr_monster((object *) 0, 0);
 613                 if (!(monster->m_flags & (WAKENS | WANDERS))) {
 614                         free_object(monster);
 615                 } else {
 616                         found = 1;
 617                 }
 618         }
 619         if (found) {
 620                 found = 0;
 621                 wake_up(monster);
 622                 for (i = 0; ((i < 25) && (!found)); i++) {
 623                         gr_row_col(&row, &col, (FLOOR | TUNNEL | STAIRS | OBJECT));
 624                         if (!rogue_can_see(row, col)) {
 625                                 put_m_at(row, col, monster);
 626                                 found = 1;
 627                         }
 628                 }
 629                 if (!found) {
 630                         free_object(monster);
 631                 }
 632         }
 633 }
 634
 635 show_monsters()
 636 {
 637         object *monster;
 638
 639         detect_monster = 1;
 640
 641         if (blind) {
 642                 return;
 643         }
 644         monster = level_monsters.next_monster;
 645
 646         while (monster) {
 647                 mvaddch(monster->row, monster->col, monster->m_char);
 648                 if (monster->m_flags & IMITATES) {
 649                         monster->m_flags &= (~IMITATES);
 650                         monster->m_flags |= WAKENS;
 651                 }
 652                 monster = monster->next_monster;
 653         }
 654 }
 655
 656 create_monster()
 657 {
 658         short row, col;
 659         short i;
 660         boolean found = 0;
 661         object *monster;
 662
 663         row = rogue.row;
 664         col = rogue.col;
 665
 666         for (i = 0; i < 9; i++) {
 667                 rand_around(i, &row, &col);
 668                 if (((row == rogue.row) && (col = rogue.col)) ||
 669                                 (row < MIN_ROW) || (row > (DROWS-2)) ||
 670                                 (col < 0) || (col > (DCOLS-1))) {
 671                         continue;
 672                 }
 673                 if ((!(dungeon[row][col] & MONSTER)) &&
 674                           (dungeon[row][col] & (FLOOR|TUNNEL|STAIRS|DOOR))) {
 675                         found = 1;
 676                         break;
 677                 }
 678         }
 679         if (found) {
 680                 monster = gr_monster((object *) 0, 0);
 681                 put_m_at(row, col, monster);
 682                 mvaddch(row, col, gmc(monster));
 683                 if (monster->m_flags & (WANDERS | WAKENS)) {
 684                         wake_up(monster);
 685                 }
 686         } else {
 687                 message("you hear a faint cry of anguish in the distance", 0);
 688         }
 689 }
 690
 691 put_m_at(row, col, monster)
 692 short row, col;
 693 object *monster;
 694 {
 695         monster->row = row;
 696         monster->col = col;
 697         dungeon[row][col] |= MONSTER;
 698         monster->trail_char = mvinch(row, col);
 699         (void) add_to_pack(monster, &level_monsters, 0);
 700         aim_monster(monster);
 701 }
 702
 703 aim_monster(monster)
 704 object *monster;
 705 {
 706         short i, rn, d, r;
 707
 708         rn = get_room_number(monster->row, monster->col);
 709         r = get_rand(0, 12);
 710
 711         for (i = 0; i < 4; i++) {
 712                 d = (r + i) % 4;
 713                 if (rooms[rn].doors[d].oth_room != NO_ROOM) {
 714                         monster->trow = rooms[rn].doors[d].door_row;
 715                         monster->tcol = rooms[rn].doors[d].door_col;
 716                         break;
 717                 }
 718         }
 719 }
 720
 721 rogue_can_see(row, col)
 722 register row, col;
 723 {
 724         register retval;
 725
 726         retval = !blind &&
 727                         (((get_room_number(row, col) == cur_room) &&
 728                                         !(rooms[cur_room].is_room & R_MAZE)) ||
 729                         rogue_is_around(row, col));
 730
 731         return(retval);
 732 }
 733
 734 move_confused(monster)
 735 object *monster;
 736 {
 737         short i, row, col;
 738
 739         if (!(monster->m_flags & ASLEEP)) {
 740                 if (--monster->moves_confused <= 0) {
 741                         monster->m_flags &= (~CONFUSED);
 742                 }
 743                 if (monster->m_flags & STATIONARY) {
 744                         return(coin_toss() ? 1 : 0);
 745                 } else if (rand_percent(15)) {
 746                         return(1);
 747                 }
 748                 row = monster->row;
 749                 col = monster->col;
 750
 751                 for (i = 0; i < 9; i++) {
 752                         rand_around(i, &row, &col);
 753                         if ((row == rogue.row) && (col == rogue.col)) {
 754                                 return(0);
 755                         }
 756                         if (mtry(monster, row, col)) {
 757                                 return(1);
 758                         }
 759                 }
 760         }
 761         return(0);
 762 }
 763
 764 flit(monster)
 765 object *monster;
 766 {
 767         short i, row, col;
 768
 769         if (!rand_percent(FLIT_PERCENT + ((monster->m_flags & FLIES) ? 20 : 0))) {
 770                 return(0);
 771         }
 772         if (rand_percent(10)) {
 773                 return(1);
 774         }
 775         row = monster->row;
 776         col = monster->col;
 777
 778         for (i = 0; i < 9; i++) {
 779                 rand_around(i, &row, &col);
 780                 if ((row == rogue.row) && (col == rogue.col)) {
 781                         continue;
 782                 }
 783                 if (mtry(monster, row, col)) {
 784                         return(1);
 785                 }
 786         }
 787         return(1);
 788 }
 789
 790 gr_obj_char()
 791 {
 792         short r;
 793         char *rs = "%!?]=/):*";
 794
 795         r = get_rand(0, 8);
 796
 797         return(rs[r]);
 798 }
 799
 800 no_room_for_monster(rn)
 801 int rn;
 802 {
 803         short i, j;
 804
 805         for (i = rooms[rn].top_row+1; i < rooms[rn].bottom_row; i++) {
 806                 for (j = rooms[rn].left_col+1; j < rooms[rn].right_col; j++) {
 807                         if (!(dungeon[i][j] & MONSTER)) {
 808                                 return(0);
 809                         }
 810                 }
 811         }
 812         return(1);
 813 }
 814
 815 aggravate()
 816 {
 817         object *monster;
 818
 819         message("you hear a high pitched humming noise", 0);
 820
 821         monster = level_monsters.next_monster;
 822
 823         while (monster) {
 824                 wake_up(monster);
 825                 monster->m_flags &= (~IMITATES);
 826                 if (rogue_can_see(monster->row, monster->col)) {
 827                         mvaddch(monster->row, monster->col, monster->m_char);
 828                 }
 829                 monster = monster->next_monster;
 830         }
 831 }
 832
 833 boolean
 834 mon_sees(monster, row, col)
 835 object *monster;
 836 {
 837         short rn, rdif, cdif, retval;
 838
 839         rn = get_room_number(row, col);
 840
 841         if (    (rn != NO_ROOM) &&
 842                         (rn == get_room_number(monster->row, monster->col)) &&
 843                         !(rooms[rn].is_room & R_MAZE)) {
 844                 return(1);
 845         }
 846         rdif = row - monster->row;
 847         cdif = col - monster->col;
 848
 849         retval = (rdif >= -1) && (rdif <= 1) && (cdif >= -1) && (cdif <= 1);
 850         return(retval);
 851 }
 852
 853 mv_aquatars()
 854 {
 855         object *monster;
 856
 857         monster = level_monsters.next_monster;
 858
 859         while (monster) {
 860                 if ((monster->m_char == 'A') &&
 861                         mon_can_go(monster, rogue.row, rogue.col)) {
 862                         mv_1_monster(monster, rogue.row, rogue.col);
 863                         monster->m_flags |= ALREADY_MOVED;
 864                 }
 865                 monster = monster->next_monster;
 866         }
 867 }