games/hack/hack.mon.c

   1 /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
   2 /* hack.mon.c - version 1.0.3 */
   3 /* $FreeBSD: src/games/hack/hack.mon.c,v 1.5 1999/11/16 10:26:37 marcel Exp $ */
   4 /* $DragonFly: src/games/hack/hack.mon.c,v 1.5 2006/08/21 19:45:32 pavalos Exp $ */
   5
   6 #include "hack.h"
   7 #include "hack.mfndpos.h"
   8
   9 #ifndef NULL
  10 #define NULL    (char *) 0
  11 #endif
  12
  13 int warnlevel;          /* used by movemon and dochugw */
  14 long lastwarntime;
  15 int lastwarnlev;
  16 static const char *warnings[] = {
  17         "white", "pink", "red", "ruby", "purple", "black"
  18 };
  19
  20 static int      dochugw(struct monst *);
  21 static void     mpickgold(struct monst *);
  22 static void     mpickgems(struct monst *);
  23 static void     dmonsfree(void);
  24 static bool     ishuman(struct monst *);
  25
  26 void
  27 movemon(void)
  28 {
  29         struct monst *mtmp;
  30         int fr;
  31
  32         warnlevel = 0;
  33
  34         while(1) {
  35                 /* find a monster that we haven't treated yet */
  36                 /* note that mtmp or mtmp->nmon might get killed
  37                    while mtmp moves, so we cannot just walk down the
  38                    chain (even new monsters might get created!) */
  39                 for(mtmp = fmon; mtmp; mtmp = mtmp->nmon)
  40                         if(mtmp->mlstmv < moves) goto next_mon;
  41                 /* treated all monsters */
  42                 break;
  43
  44         next_mon:
  45                 mtmp->mlstmv = moves;
  46
  47                 /* most monsters drown in pools */
  48                 { boolean inpool, iseel;
  49
  50                   inpool = (levl[mtmp->mx][mtmp->my].typ == POOL);
  51                   iseel = (mtmp->data->mlet == ';');
  52                   if(inpool && !iseel) {
  53                         if(cansee(mtmp->mx,mtmp->my))
  54                             pline("%s drowns.", Monnam(mtmp));
  55                         mondead(mtmp);
  56                         continue;
  57                   }
  58                 /* but eels have a difficult time outside */
  59                   if(iseel && !inpool) {
  60                         if(mtmp->mhp > 1) mtmp->mhp--;
  61                         mtmp->mflee = 1;
  62                         mtmp->mfleetim += 2;
  63                   }
  64                 }
  65                 if(mtmp->mblinded && !--mtmp->mblinded)
  66                         mtmp->mcansee = 1;
  67                 if(mtmp->mfleetim && !--mtmp->mfleetim)
  68                         mtmp->mflee = 0;
  69                 if(mtmp->mimic) continue;
  70                 if(mtmp->mspeed != MSLOW || !(moves%2)){
  71                         /* continue if the monster died fighting */
  72                         fr = -1;
  73                         if(Conflict && cansee(mtmp->mx,mtmp->my)
  74                                 && (fr = fightm(mtmp)) == 2)
  75                                 continue;
  76                         if(fr<0 && dochugw(mtmp))
  77                                 continue;
  78                 }
  79                 if(mtmp->mspeed == MFAST && dochugw(mtmp))
  80                         continue;
  81         }
  82
  83         warnlevel -= u.ulevel;
  84         if(warnlevel >= SIZE(warnings))
  85                 warnlevel = SIZE(warnings)-1;
  86         if(warnlevel >= 0)
  87         if(warnlevel > lastwarnlev || moves > lastwarntime + 5){
  88             const char *rr;
  89             switch(Warning & (LEFT_RING | RIGHT_RING)){
  90             case LEFT_RING:
  91                 rr = "Your left ring glows";
  92                 break;
  93             case RIGHT_RING:
  94                 rr = "Your right ring glows";
  95                 break;
  96             case LEFT_RING | RIGHT_RING:
  97                 rr = "Both your rings glow";
  98                 break;
  99             default:
 100                 rr = "Your fingertips glow";
 101                 break;
 102             }
 103             pline("%s %s!", rr, warnings[warnlevel]);
 104             lastwarntime = moves;
 105             lastwarnlev = warnlevel;
 106         }
 107
 108         dmonsfree();    /* remove all dead monsters */
 109 }
 110
 111 void
 112 justswld(struct monst *mtmp, const char *name)
 113 {
 114
 115         mtmp->mx = u.ux;
 116         mtmp->my = u.uy;
 117         u.ustuck = mtmp;
 118         pmon(mtmp);
 119         kludge("%s swallows you!",name);
 120         more();
 121         seeoff(1);
 122         u.uswallow = 1;
 123         u.uswldtim = 0;
 124         swallowed();
 125 }
 126
 127 void
 128 youswld(struct monst *mtmp, int dam, int die, const char *name)
 129 {
 130         if(mtmp != u.ustuck) return;
 131         kludge("%s digests you!",name);
 132         u.uhp -= dam;
 133         if((int)u.uswldtim++ >= die){   /* a3 */
 134                 pline("It totally digests you!");
 135                 u.uhp = -1;
 136         }
 137         if(u.uhp < 1) done_in_by(mtmp);
 138         /* flags.botlx = 1; */          /* should we show status line ? */
 139 }
 140
 141 static int
 142 dochugw(struct monst *mtmp)
 143 {
 144 int x = mtmp->mx;
 145 int y = mtmp->my;
 146 int d1 = dochug(mtmp);
 147 int dd;
 148         if(!d1)         /* monster still alive */
 149         if(Warning)
 150         if(!mtmp->mpeaceful)
 151         if(mtmp->data->mlevel > warnlevel)
 152         if((dd = dist(mtmp->mx,mtmp->my)) < dist(x,y))
 153         if(dd < 100)
 154         if(!canseemon(mtmp))
 155                 warnlevel = mtmp->data->mlevel;
 156         return(d1);
 157 }
 158
 159 /* returns 1 if monster died moving, 0 otherwise */
 160 bool
 161 dochug(struct monst *mtmp)
 162 {
 163         struct permonst *mdat;
 164         int tmp = 0, nearby, scared;
 165
 166         if(mtmp->cham && !rn2(6))
 167                 newcham(mtmp, &mons[dlevel+14+rn2(CMNUM-14-dlevel)]);
 168         mdat = mtmp->data;
 169         if(mdat->mlevel < 0)
 170                 panic("bad monster %c (%d)",mdat->mlet,mdat->mlevel);
 171
 172         /* regenerate monsters */
 173         if((!(moves%20) || index(MREGEN, mdat->mlet)) &&
 174             mtmp->mhp < mtmp->mhpmax)
 175                 mtmp->mhp++;
 176
 177         if(mtmp->mfroz) return(0); /* frozen monsters don't do anything */
 178
 179         if(mtmp->msleep) {
 180                 /* wake up, or get out of here. */
 181                 /* ettins are hard to surprise */
 182                 /* Nymphs and Leprechauns do not easily wake up */
 183                 if(cansee(mtmp->mx,mtmp->my) &&
 184                         (!Stealth || (mdat->mlet == 'e' && rn2(10))) &&
 185                         (!index("NL",mdat->mlet) || !rn2(50)) &&
 186                         (Aggravate_monster || index("d1", mdat->mlet)
 187                                 || (!rn2(7) && !mtmp->mimic)))
 188                         mtmp->msleep = 0;
 189                 else return(0);
 190         }
 191
 192         /* not frozen or sleeping: wipe out texts written in the dust */
 193         wipe_engr_at(mtmp->mx, mtmp->my, 1);
 194
 195         /* confused monsters get unconfused with small probability */
 196         if(mtmp->mconf && !rn2(50)) mtmp->mconf = 0;
 197
 198         /* some monsters teleport */
 199         if(mtmp->mflee && index("tNL", mdat->mlet) && !rn2(40)){
 200                 rloc(mtmp);
 201                 return(0);
 202         }
 203         if(mdat->mmove < rnd(6)) return(0);
 204
 205         /* fleeing monsters might regain courage */
 206         if(mtmp->mflee && !mtmp->mfleetim
 207             && mtmp->mhp == mtmp->mhpmax && !rn2(25))
 208                 mtmp->mflee = 0;
 209
 210         nearby = (dist(mtmp->mx, mtmp->my) < 3);
 211         scared = (nearby && (sengr_at("Elbereth", u.ux, u.uy) ||
 212                         sobj_at(SCR_SCARE_MONSTER, u.ux, u.uy)));
 213         if(scared && !mtmp->mflee) {
 214                 mtmp->mflee = 1;
 215                 mtmp->mfleetim = (rn2(7) ? rnd(10) : rnd(100));
 216         }
 217
 218         if(!nearby ||
 219                 mtmp->mflee ||
 220                 mtmp->mconf ||
 221                 (mtmp->minvis && !rn2(3)) ||
 222                 (index("BIuy", mdat->mlet) && !rn2(4)) ||
 223                 (mdat->mlet == 'L' && !u.ugold && (mtmp->mgold || rn2(2))) ||
 224                 (!mtmp->mcansee && !rn2(4)) ||
 225                 mtmp->mpeaceful
 226            ) {
 227                 tmp = m_move(mtmp,0);   /* 2: monster died moving */
 228                 if(tmp == 2 || (tmp && mdat->mmove <= 12))
 229                         return(tmp == 2);
 230         }
 231
 232         if(!index("Ea", mdat->mlet) && nearby &&
 233          !mtmp->mpeaceful && u.uhp > 0 && !scared) {
 234                 if(mhitu(mtmp))
 235                         return(1);      /* monster died (e.g. 'y' or 'F') */
 236         }
 237         /* extra movement for fast monsters */
 238         if(mdat->mmove-12 > rnd(12)) tmp = m_move(mtmp,1);
 239         return(tmp == 2);
 240 }
 241
 242 int
 243 m_move(struct monst *mtmp, int after)
 244 {
 245         struct monst *mtmp2;
 246         int nx,ny,omx,omy,appr,nearer,cnt,i,j;
 247         xchar gx,gy,nix,niy,chcnt;
 248         schar chi;
 249         boolean likegold = 0, likegems = 0, likeobjs;
 250         char msym = mtmp->data->mlet;
 251         schar mmoved = 0;       /* not strictly nec.: chi >= 0 will do */
 252         coord poss[9];
 253         int info[9];
 254
 255         if(mtmp->mfroz || mtmp->msleep)
 256                 return(0);
 257         if(mtmp->mtrapped) {
 258                 i = mintrap(mtmp);
 259                 if(i == 2) return(2);   /* he died */
 260                 if(i == 1) return(0);   /* still in trap, so didnt move */
 261         }
 262         if(mtmp->mhide && o_at(mtmp->mx,mtmp->my) && rn2(10))
 263                 return(0);              /* do not leave hiding place */
 264
 265 #ifndef NOWORM
 266         if(mtmp->wormno)
 267                 goto not_special;
 268 #endif /* NOWORM */
 269
 270         /* my dog gets a special treatment */
 271         if(mtmp->mtame) {
 272                 return( dog_move(mtmp, after) );
 273         }
 274
 275         /* likewise for shopkeeper */
 276         if(mtmp->isshk) {
 277                 mmoved = shk_move(mtmp);
 278                 if(mmoved >= 0)
 279                         goto postmov;
 280                 mmoved = 0;             /* follow player outside shop */
 281         }
 282
 283         /* and for the guard */
 284         if(mtmp->isgd) {
 285                 mmoved = gd_move();
 286                 goto postmov;
 287         }
 288
 289 /* teleport if that lies in our nature ('t') or when badly wounded ('1') */
 290         if((msym == 't' && !rn2(5))
 291         || (msym == '1' && (mtmp->mhp < 7 || (!xdnstair && !rn2(5))
 292                 || levl[u.ux][u.uy].typ == STAIRS))) {
 293                 if(mtmp->mhp < 7 || (msym == 't' && rn2(2)))
 294                         rloc(mtmp);
 295                 else
 296                         mnexto(mtmp);
 297                 mmoved = 1;
 298                 goto postmov;
 299         }
 300
 301         /* spit fire ('D') or use a wand ('1') when appropriate */
 302         if(index("D1", msym))
 303                 inrange(mtmp);
 304
 305         if(msym == 'U' && !mtmp->mcan && canseemon(mtmp) &&
 306             mtmp->mcansee && rn2(5)) {
 307                 if(!Confusion)
 308                         pline("%s's gaze has confused you!", Monnam(mtmp));
 309                 else
 310                         pline("You are getting more and more confused.");
 311                 if(rn2(3)) mtmp->mcan = 1;
 312                 Confusion += d(3,4);            /* timeout */
 313         }
 314 not_special:
 315         if(!mtmp->mflee && u.uswallow && u.ustuck != mtmp) return(1);
 316         appr = 1;
 317         if(mtmp->mflee) appr = -1;
 318         if(mtmp->mconf || Invis ||  !mtmp->mcansee ||
 319                 (index("BIy", msym) && !rn2(3)))
 320                 appr = 0;
 321         omx = mtmp->mx;
 322         omy = mtmp->my;
 323         gx = u.ux;
 324         gy = u.uy;
 325         if(msym == 'L' && appr == 1 && mtmp->mgold > u.ugold)
 326                 appr = -1;
 327
 328         /* random criterion for 'smell' or track finding ability
 329            should use mtmp->msmell or sth
 330          */
 331         if(msym == '@' ||
 332           ('a' <= msym && msym <= 'z')) {
 333         coord *cp;
 334         schar mroom;
 335                 mroom = inroom(omx,omy);
 336                 if(mroom < 0 || mroom != inroom(u.ux,u.uy)){
 337                     cp = gettrack(omx,omy);
 338                     if(cp){
 339                         gx = cp->x;
 340                         gy = cp->y;
 341                     }
 342                 }
 343         }
 344
 345         /* look for gold or jewels nearby */
 346         likegold = (index("LOD", msym) != NULL);
 347         likegems = (index("ODu", msym) != NULL);
 348         likeobjs = mtmp->mhide;
 349 #define SRCHRADIUS      25
 350         { xchar mind = SRCHRADIUS;              /* not too far away */
 351           int dd;
 352           if(likegold){
 353                 struct gold *gold;
 354                 for(gold = fgold; gold; gold = gold->ngold)
 355                   if((dd = DIST(omx,omy,gold->gx,gold->gy)) < mind){
 356                     mind = dd;
 357                     gx = gold->gx;
 358                     gy = gold->gy;
 359                 }
 360           }
 361           if(likegems || likeobjs){
 362                 struct obj *otmp;
 363                 for(otmp = fobj; otmp; otmp = otmp->nobj)
 364                 if(likeobjs || otmp->olet == GEM_SYM)
 365                 if(msym != 'u' ||
 366                         objects[otmp->otyp].g_val != 0)
 367                 if((dd = DIST(omx,omy,otmp->ox,otmp->oy)) < mind){
 368                     mind = dd;
 369                     gx = otmp->ox;
 370                     gy = otmp->oy;
 371                 }
 372           }
 373           if(mind < SRCHRADIUS && appr == -1) {
 374                 if(dist(omx,omy) < 10) {
 375                     gx = u.ux;
 376                     gy = u.uy;
 377                 } else
 378                     appr = 1;
 379           }
 380         }
 381         nix = omx;
 382         niy = omy;
 383         cnt = mfndpos(mtmp,poss,info,
 384                 msym == 'u' ? NOTONL :
 385                 (msym == '@' || msym == '1') ? (ALLOW_SSM | ALLOW_TRAPS) :
 386                 index(UNDEAD, msym) ? NOGARLIC : ALLOW_TRAPS);
 387                 /* ALLOW_ROCK for some monsters ? */
 388         chcnt = 0;
 389         chi = -1;
 390         for(i=0; i<cnt; i++) {
 391                 nx = poss[i].x;
 392                 ny = poss[i].y;
 393                 for(j=0; j<MTSZ && j<cnt-1; j++)
 394                         if(nx == mtmp->mtrack[j].x && ny == mtmp->mtrack[j].y)
 395                                 if(rn2(4*(cnt-j))) goto nxti;
 396 #ifdef STUPID
 397                 /* some stupid compilers think that this is too complicated */
 398                 { int d1 = DIST(nx,ny,gx,gy);
 399                   int d2 = DIST(nix,niy,gx,gy);
 400                   nearer = (d1 < d2);
 401                 }
 402 #else
 403                 nearer = (DIST(nx,ny,gx,gy) < DIST(nix,niy,gx,gy));
 404 #endif /* STUPID */
 405                 if((appr == 1 && nearer) || (appr == -1 && !nearer) ||
 406                         !mmoved ||
 407                         (!appr && !rn2(++chcnt))){
 408                         nix = nx;
 409                         niy = ny;
 410                         chi = i;
 411                         mmoved = 1;
 412                 }
 413         nxti:   ;
 414         }
 415         if(mmoved){
 416                 if(info[chi] & ALLOW_M){
 417                         mtmp2 = m_at(nix,niy);
 418                         if(hitmm(mtmp,mtmp2) == 1 && rn2(4) &&
 419                           hitmm(mtmp2,mtmp) == 2) return(2);
 420                         return(0);
 421                 }
 422                 if(info[chi] & ALLOW_U){
 423                   hitu(mtmp, d(mtmp->data->damn, mtmp->data->damd)+1);
 424                   return(0);
 425                 }
 426                 mtmp->mx = nix;
 427                 mtmp->my = niy;
 428                 for(j=MTSZ-1; j>0; j--) mtmp->mtrack[j] = mtmp->mtrack[j-1];
 429                 mtmp->mtrack[0].x = omx;
 430                 mtmp->mtrack[0].y = omy;
 431 #ifndef NOWORM
 432                 if(mtmp->wormno) worm_move(mtmp);
 433 #endif /* NOWORM */
 434         } else {
 435                 if(msym == 'u' && rn2(2)){
 436                         rloc(mtmp);
 437                         return(0);
 438                 }
 439 #ifndef NOWORM
 440                 if(mtmp->wormno) worm_nomove(mtmp);
 441 #endif /* NOWORM */
 442         }
 443 postmov:
 444         if(mmoved == 1) {
 445                 if(mintrap(mtmp) == 2)  /* he died */
 446                         return(2);
 447                 if(likegold) mpickgold(mtmp);
 448                 if(likegems) mpickgems(mtmp);
 449                 if(mtmp->mhide) mtmp->mundetected = 1;
 450         }
 451         pmon(mtmp);
 452         return(mmoved);
 453 }
 454
 455 static void
 456 mpickgold(struct monst *mtmp)
 457 {
 458 struct gold *gold;
 459         while((gold = g_at(mtmp->mx, mtmp->my))){
 460                 mtmp->mgold += gold->amount;
 461                 freegold(gold);
 462                 if(levl[mtmp->mx][mtmp->my].scrsym == '$')
 463                         newsym(mtmp->mx, mtmp->my);
 464         }
 465 }
 466
 467 static void
 468 mpickgems(struct monst *mtmp)
 469 {
 470 struct obj *otmp;
 471         for(otmp = fobj; otmp; otmp = otmp->nobj)
 472         if(otmp->olet == GEM_SYM)
 473         if(otmp->ox == mtmp->mx && otmp->oy == mtmp->my)
 474         if(mtmp->data->mlet != 'u' || objects[otmp->otyp].g_val != 0){
 475                 freeobj(otmp);
 476                 mpickobj(mtmp, otmp);
 477                 if(levl[mtmp->mx][mtmp->my].scrsym == GEM_SYM)
 478                         newsym(mtmp->mx, mtmp->my);     /* %% */
 479                 return; /* pick only one object */
 480         }
 481 }
 482
 483 /* return number of acceptable neighbour positions */
 484 int
 485 mfndpos(struct monst *mon, coord poss[9], int info[9], int flag)
 486 {
 487         int x,y,nx,ny,cnt = 0,ntyp;
 488         struct monst *mtmp;
 489         int nowtyp;
 490         boolean pool;
 491
 492         x = mon->mx;
 493         y = mon->my;
 494         nowtyp = levl[x][y].typ;
 495
 496         pool = (mon->data->mlet == ';');
 497 nexttry:        /* eels prefer the water, but if there is no water nearby,
 498                    they will crawl over land */
 499         if(mon->mconf) {
 500                 flag |= ALLOW_ALL;
 501                 flag &= ~NOTONL;
 502         }
 503         for(nx = x-1; nx <= x+1; nx++) for(ny = y-1; ny <= y+1; ny++)
 504         if(nx != x || ny != y) if(isok(nx,ny))
 505         if(!IS_ROCK(ntyp = levl[nx][ny].typ))
 506         if(!(nx != x && ny != y && (nowtyp == DOOR || ntyp == DOOR)))
 507         if((ntyp == POOL) == pool) {
 508                 info[cnt] = 0;
 509                 if(nx == u.ux && ny == u.uy){
 510                         if(!(flag & ALLOW_U)) continue;
 511                         info[cnt] = ALLOW_U;
 512                 } else if((mtmp = m_at(nx,ny))){
 513                         if(!(flag & ALLOW_M)) continue;
 514                         info[cnt] = ALLOW_M;
 515                         if(mtmp->mtame){
 516                                 if(!(flag & ALLOW_TM)) continue;
 517                                 info[cnt] |= ALLOW_TM;
 518                         }
 519                 }
 520                 if(sobj_at(CLOVE_OF_GARLIC, nx, ny)) {
 521                         if(flag & NOGARLIC) continue;
 522                         info[cnt] |= NOGARLIC;
 523                 }
 524                 if(sobj_at(SCR_SCARE_MONSTER, nx, ny) ||
 525                    (!mon->mpeaceful && sengr_at("Elbereth", nx, ny))) {
 526                         if(!(flag & ALLOW_SSM)) continue;
 527                         info[cnt] |= ALLOW_SSM;
 528                 }
 529                 if(sobj_at(ENORMOUS_ROCK, nx, ny)) {
 530                         if(!(flag & ALLOW_ROCK)) continue;
 531                         info[cnt] |= ALLOW_ROCK;
 532                 }
 533                 if(!Invis && online(nx,ny)){
 534                         if(flag & NOTONL) continue;
 535                         info[cnt] |= NOTONL;
 536                 }
 537                 /* we cannot avoid traps of an unknown kind */
 538                 { struct trap *ttmp = t_at(nx, ny);
 539                   int tt;
 540                         if(ttmp) {
 541                                 tt = 1 << ttmp->ttyp;
 542                                 if(mon->mtrapseen & tt){
 543                                         if(!(flag & tt)) continue;
 544                                         info[cnt] |= tt;
 545                                 }
 546                         }
 547                 }
 548                 poss[cnt].x = nx;
 549                 poss[cnt].y = ny;
 550                 cnt++;
 551         }
 552         if(!cnt && pool && nowtyp != POOL) {
 553                 pool = FALSE;
 554                 goto nexttry;
 555         }
 556         return(cnt);
 557 }
 558
 559 int
 560 dist(int x, int y)
 561 {
 562         return((x-u.ux)*(x-u.ux) + (y-u.uy)*(y-u.uy));
 563 }
 564
 565 void
 566 poisoned(const char *string, const char *pname)
 567 {
 568         int i;
 569
 570         if(Blind) pline("It was poisoned.");
 571         else pline("The %s was poisoned!",string);
 572         if(Poison_resistance) {
 573                 pline("The poison doesn't seem to affect you.");
 574                 return;
 575         }
 576         i = rn2(10);
 577         if(i == 0) {
 578                 u.uhp = -1;
 579                 pline("I am afraid the poison was deadly ...");
 580         } else if(i <= 5) {
 581                 losestr(rn1(3,3));
 582         } else {
 583                 losehp(rn1(10,6), pname);
 584         }
 585         if(u.uhp < 1) {
 586                 killer = pname;
 587                 done("died");
 588         }
 589 }
 590
 591 void
 592 mondead(struct monst *mtmp)
 593 {
 594         relobj(mtmp,1);
 595         unpmon(mtmp);
 596         relmon(mtmp);
 597         unstuck(mtmp);
 598         if(mtmp->isshk) shkdead(mtmp);
 599         if(mtmp->isgd) gddead();
 600 #ifndef NOWORM
 601         if(mtmp->wormno) wormdead(mtmp);
 602 #endif /* NOWORM */
 603         monfree(mtmp);
 604 }
 605
 606 /* called when monster is moved to larger structure */
 607 void
 608 replmon(struct monst *mtmp, struct monst *mtmp2)
 609 {
 610         relmon(mtmp);
 611         monfree(mtmp);
 612         mtmp2->nmon = fmon;
 613         fmon = mtmp2;
 614         if(u.ustuck == mtmp) u.ustuck = mtmp2;
 615         if(mtmp2->isshk) replshk(mtmp,mtmp2);
 616         if(mtmp2->isgd) replgd(mtmp,mtmp2);
 617 }
 618
 619 void
 620 relmon(struct monst *mon)
 621 {
 622         struct monst *mtmp;
 623
 624         if(mon == fmon) fmon = fmon->nmon;
 625         else {
 626                 for(mtmp = fmon; mtmp->nmon != mon; mtmp = mtmp->nmon) ;
 627                 mtmp->nmon = mon->nmon;
 628         }
 629 }
 630
 631 /* we do not free monsters immediately, in order to have their name
 632    available shortly after their demise */
 633 struct monst *fdmon;    /* chain of dead monsters, need not to be saved */
 634
 635 void
 636 monfree(struct monst *mtmp)
 637 {
 638         mtmp->nmon = fdmon;
 639         fdmon = mtmp;
 640 }
 641
 642 static void
 643 dmonsfree(void)
 644 {
 645 struct monst *mtmp;
 646         while((mtmp = fdmon)){
 647                 fdmon = mtmp->nmon;
 648                 free((char *) mtmp);
 649         }
 650 }
 651
 652 void
 653 unstuck(struct monst *mtmp)
 654 {
 655         if(u.ustuck == mtmp) {
 656                 if(u.uswallow){
 657                         u.ux = mtmp->mx;
 658                         u.uy = mtmp->my;
 659                         u.uswallow = 0;
 660                         setsee();
 661                         docrt();
 662                 }
 663                 u.ustuck = 0;
 664         }
 665 }
 666
 667 void
 668 killed(struct monst *mtmp)
 669 {
 670 #ifdef lint
 671 #define NEW_SCORING
 672         int tmp2;
 673 #endif /* lint */
 674         int tmp,nk,x,y;
 675         struct permonst *mdat;
 676
 677         if(mtmp->cham) mtmp->data = PM_CHAMELEON;
 678         mdat = mtmp->data;
 679         if(Blind) pline("You destroy it!");
 680         else {
 681                 pline("You destroy %s!",
 682                         mtmp->mtame ? amonnam(mtmp, "poor") : monnam(mtmp));
 683         }
 684         if(u.umconf) {
 685                 if(!Blind) pline("Your hands stop glowing blue.");
 686                 u.umconf = 0;
 687         }
 688
 689         /* count killed monsters */
 690 #define MAXMONNO        100
 691         nk = 1;               /* in case we cannot find it in mons */
 692         tmp = mdat - mons;    /* index in mons array (if not 'd', '@', ...) */
 693         if(tmp >= 0 && tmp < CMNUM+2) {
 694             u.nr_killed[tmp]++;
 695             if((nk = u.nr_killed[tmp]) > MAXMONNO &&
 696                 !index(fut_geno, mdat->mlet))
 697                     charcat(fut_geno,  mdat->mlet);
 698         }
 699
 700         /* punish bad behaviour */
 701         if(mdat->mlet == '@') Telepat = 0, u.uluck -= 2;
 702         if(mtmp->mpeaceful || mtmp->mtame) u.uluck--;
 703         if(mdat->mlet == 'u') u.uluck -= 5;
 704         if((int)u.uluck < LUCKMIN) u.uluck = LUCKMIN;
 705
 706         /* give experience points */
 707         tmp = 1 + mdat->mlevel * mdat->mlevel;
 708         if(mdat->ac < 3) tmp += 2*(7 - mdat->ac);
 709         if(index("AcsSDXaeRTVWU&In:P", mdat->mlet))
 710                 tmp += 2*mdat->mlevel;
 711         if(index("DeV&P",mdat->mlet)) tmp += (7*mdat->mlevel);
 712         if(mdat->mlevel > 6) tmp += 50;
 713         if(mdat->mlet == ';') tmp += 1000;
 714
 715 #ifdef NEW_SCORING
 716         /* ------- recent addition: make nr of points decrease
 717                    when this is not the first of this kind */
 718         { int ul = u.ulevel;
 719           int ml = mdat->mlevel;
 720
 721         if(ul < 14)    /* points are given based on present and future level */
 722             for(tmp2 = 0; !tmp2 || ul + tmp2 <= ml; tmp2++)
 723                 if(u.uexp + 1 + (tmp + ((tmp2 <= 0) ? 0 : 4<<(tmp2-1)))/nk
 724                     >= 10*pow((unsigned)(ul-1)))
 725                         if(++ul == 14) break;
 726
 727         tmp2 = ml - ul -1;
 728         tmp = (tmp + ((tmp2 < 0) ? 0 : 4<<tmp2))/nk;
 729         if(!tmp) tmp = 1;
 730         }
 731         /* note: ul is not necessarily the future value of u.ulevel */
 732         /* ------- end of recent valuation change ------- */
 733 #endif /* NEW_SCORING */
 734
 735         more_experienced(tmp,0);
 736         flags.botl = 1;
 737         while(u.ulevel < 14 && u.uexp >= newuexp()){
 738                 pline("Welcome to experience level %u.", ++u.ulevel);
 739                 tmp = rnd(10);
 740                 if(tmp < 3) tmp = rnd(10);
 741                 u.uhpmax += tmp;
 742                 u.uhp += tmp;
 743                 flags.botl = 1;
 744         }
 745
 746         /* dispose of monster and make cadaver */
 747         x = mtmp->mx;   y = mtmp->my;
 748         mondead(mtmp);
 749         tmp = mdat->mlet;
 750         if(tmp == 'm') { /* he killed a minotaur, give him a wand of digging */
 751                         /* note: the dead minotaur will be on top of it! */
 752                 mksobj_at(WAN_DIGGING, x, y);
 753                 /* if(cansee(x,y)) atl(x,y,fobj->olet); */
 754                 stackobj(fobj);
 755         } else
 756 #ifndef NOWORM
 757         if(tmp == 'w') {
 758                 mksobj_at(WORM_TOOTH, x, y);
 759                 stackobj(fobj);
 760         } else
 761 #endif /* NOWORM */
 762         if(!letter(tmp) || (!index("mw", tmp) && !rn2(3))) tmp = 0;
 763
 764         if(ACCESSIBLE(levl[x][y].typ))  /* might be mimic in wall or dead eel*/
 765             if(x != u.ux || y != u.uy)  /* might be here after swallowed */
 766                 if(index("NTVm&",mdat->mlet) || rn2(5)) {
 767                 struct obj *obj2 = mkobj_at(tmp,x,y);
 768                 if(cansee(x,y))
 769                         atl(x,y,obj2->olet);
 770                 stackobj(obj2);
 771         }
 772 }
 773
 774 void
 775 kludge(const char *str, const char *arg)
 776 {
 777         if(Blind) {
 778                 if(*str == '%') pline(str,"It");
 779                 else pline(str,"it");
 780         } else pline(str,arg);
 781 }
 782
 783 void
 784 rescham(void)   /* force all chameleons to become normal */
 785 {
 786         struct monst *mtmp;
 787
 788         for(mtmp = fmon; mtmp; mtmp = mtmp->nmon)
 789                 if(mtmp->cham) {
 790                         mtmp->cham = 0;
 791                         newcham(mtmp, PM_CHAMELEON);
 792                 }
 793 }
 794
 795 /* make a chameleon look like a new monster */
 796 /* returns 1 if the monster actually changed */
 797 bool
 798 newcham(struct monst *mtmp, struct permonst *mdat)
 799 {
 800         int mhp, hpn, hpd;
 801
 802         if(mdat == mtmp->data) return(0);       /* still the same monster */
 803 #ifndef NOWORM
 804         if(mtmp->wormno) wormdead(mtmp);        /* throw tail away */
 805 #endif /* NOWORM */
 806         if (u.ustuck == mtmp) {
 807                 if (u.uswallow) {
 808                         u.uswallow = 0;
 809                         u.uswldtim = 0;
 810                         mnexto (mtmp);
 811                         docrt ();
 812                         prme ();
 813                 }
 814                 u.ustuck = 0;
 815         }
 816         hpn = mtmp->mhp;
 817         hpd = (mtmp->data->mlevel)*8;
 818         if(!hpd) hpd = 4;
 819         mtmp->data = mdat;
 820         mhp = (mdat->mlevel)*8;
 821         /* new hp: same fraction of max as before */
 822         mtmp->mhp = 2 + (hpn*mhp)/hpd;
 823         hpn = mtmp->mhpmax;
 824         mtmp->mhpmax = 2 + (hpn*mhp)/hpd;
 825         mtmp->minvis = (mdat->mlet == 'I') ? 1 : 0;
 826 #ifndef NOWORM
 827         if(mdat->mlet == 'w' && getwn(mtmp)) initworm(mtmp);
 828                         /* perhaps we should clear mtmp->mtame here? */
 829 #endif /* NOWORM */
 830         unpmon(mtmp);   /* necessary for 'I' and to force pmon */
 831         pmon(mtmp);
 832         return(1);
 833 }
 834
 835 /* Make monster mtmp next to you (if possible) */
 836 void
 837 mnexto(struct monst *mtmp)
 838 {
 839         coord mm;
 840         mm = enexto(u.ux, u.uy);
 841         mtmp->mx = mm.x;
 842         mtmp->my = mm.y;
 843         pmon(mtmp);
 844 }
 845
 846 static bool
 847 ishuman(struct monst *mtmp)
 848 {
 849         return(mtmp->data->mlet == '@');
 850 }
 851
 852 void
 853 setmangry(struct monst *mtmp)
 854 {
 855         if(!mtmp->mpeaceful) return;
 856         if(mtmp->mtame) return;
 857         mtmp->mpeaceful = 0;
 858         if(ishuman(mtmp)) pline("%s gets angry!", Monnam(mtmp));
 859 }
 860
 861 /* not one hundred procent correct: now a snake may hide under an
 862    invisible object */
 863 bool
 864 canseemon(struct monst *mtmp)
 865 {
 866         return((!mtmp->minvis || See_invisible)
 867                 && (!mtmp->mhide || !o_at(mtmp->mx,mtmp->my))
 868                 && cansee(mtmp->mx, mtmp->my));
 869 }