hack/hack.zap.c

   1 /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
   2 /* hack.zap.c - version 1.0.3 */
   3
   4 #include "hack.h"
   5
   6 extern struct obj *mkobj_at();
   7 extern struct monst *makemon(), *mkmon_at(), youmonst;
   8 struct monst *bhit();
   9 char *exclam();
  10
  11 char *fl[]= {
  12         "magic missile",
  13         "bolt of fire",
  14         "sleep ray",
  15         "bolt of cold",
  16         "death ray"
  17 };
  18
  19 /* Routines for IMMEDIATE wands. */
  20 /* bhitm: monster mtmp was hit by the effect of wand otmp */
  21 bhitm(mtmp, otmp)
  22 register struct monst *mtmp;
  23 register struct obj *otmp;
  24 {
  25         wakeup(mtmp);
  26         switch(otmp->otyp) {
  27         case WAN_STRIKING:
  28                 if(u.uswallow || rnd(20) < 10+mtmp->data->ac) {
  29                         register int tmp = d(2,12);
  30                         hit("wand", mtmp, exclam(tmp));
  31                         mtmp->mhp -= tmp;
  32                         if(mtmp->mhp < 1) killed(mtmp);
  33                 } else miss("wand", mtmp);
  34                 break;
  35         case WAN_SLOW_MONSTER:
  36                 mtmp->mspeed = MSLOW;
  37                 break;
  38         case WAN_SPEED_MONSTER:
  39                 mtmp->mspeed = MFAST;
  40                 break;
  41         case WAN_UNDEAD_TURNING:
  42                 if(index(UNDEAD,mtmp->data->mlet)) {
  43                         mtmp->mhp -= rnd(8);
  44                         if(mtmp->mhp < 1) killed(mtmp);
  45                         else mtmp->mflee = 1;
  46                 }
  47                 break;
  48         case WAN_POLYMORPH:
  49                 if( newcham(mtmp,&mons[rn2(CMNUM)]) )
  50                         objects[otmp->otyp].oc_name_known = 1;
  51                 break;
  52         case WAN_CANCELLATION:
  53                 mtmp->mcan = 1;
  54                 break;
  55         case WAN_TELEPORTATION:
  56                 rloc(mtmp);
  57                 break;
  58         case WAN_MAKE_INVISIBLE:
  59                 mtmp->minvis = 1;
  60                 break;
  61 #ifdef WAN_PROBING
  62         case WAN_PROBING:
  63                 mstatusline(mtmp);
  64                 break;
  65 #endif WAN_PROBING
  66         default:
  67                 impossible("What an interesting wand (%u)", otmp->otyp);
  68         }
  69 }
  70
  71 bhito(obj, otmp)        /* object obj was hit by the effect of wand otmp */
  72 register struct obj *obj, *otmp;        /* returns TRUE if sth was done */
  73 {
  74         register int res = TRUE;
  75
  76         if(obj == uball || obj == uchain)
  77                 res = FALSE;
  78         else
  79         switch(otmp->otyp) {
  80         case WAN_POLYMORPH:
  81                 /* preserve symbol and quantity, but turn rocks into gems */
  82                 mkobj_at((obj->otyp == ROCK || obj->otyp == ENORMOUS_ROCK)
  83                         ? GEM_SYM : obj->olet,
  84                         obj->ox, obj->oy) -> quan = obj->quan;
  85                 delobj(obj);
  86                 break;
  87         case WAN_STRIKING:
  88                 if(obj->otyp == ENORMOUS_ROCK)
  89                         fracture_rock(obj);
  90                 else
  91                         res = FALSE;
  92                 break;
  93         case WAN_CANCELLATION:
  94                 if(obj->spe && obj->olet != AMULET_SYM) {
  95                         obj->known = 0;
  96                         obj->spe = 0;
  97                 }
  98                 break;
  99         case WAN_TELEPORTATION:
 100                 rloco(obj);
 101                 break;
 102         case WAN_MAKE_INVISIBLE:
 103                 obj->oinvis = 1;
 104                 break;
 105         case WAN_UNDEAD_TURNING:
 106                 res = revive(obj);
 107                 break;
 108         case WAN_SLOW_MONSTER:          /* no effect on objects */
 109         case WAN_SPEED_MONSTER:
 110 #ifdef WAN_PROBING
 111         case WAN_PROBING:
 112 #endif WAN_PROBING
 113                 res = FALSE;
 114                 break;
 115         default:
 116                 impossible("What an interesting wand (%u)", otmp->otyp);
 117         }
 118         return(res);
 119 }
 120
 121 dozap()
 122 {
 123         register struct obj *obj;
 124         xchar zx,zy;
 125
 126         obj = getobj("/", "zap");
 127         if(!obj) return(0);
 128         if(obj->spe < 0 || (obj->spe == 0 && rn2(121))) {
 129                 pline("Nothing Happens.");
 130                 return(1);
 131         }
 132         if(obj->spe == 0)
 133                 pline("You wrest one more spell from the worn-out wand.");
 134         if(!(objects[obj->otyp].bits & NODIR) && !getdir(1))
 135                 return(1);      /* make him pay for knowing !NODIR */
 136         obj->spe--;
 137         if(objects[obj->otyp].bits & IMMEDIATE) {
 138                 if(u.uswallow)
 139                         bhitm(u.ustuck, obj);
 140                 else if(u.dz) {
 141                         if(u.dz > 0) {
 142                                 register struct obj *otmp = o_at(u.ux, u.uy);
 143                                 if(otmp)
 144                                         (void) bhito(otmp, obj);
 145                         }
 146                 } else
 147                         (void) bhit(u.dx,u.dy,rn1(8,6),0,bhitm,bhito,obj);
 148         } else {
 149             switch(obj->otyp){
 150                 case WAN_LIGHT:
 151                         litroom(TRUE);
 152                         break;
 153                 case WAN_SECRET_DOOR_DETECTION:
 154                         if(!findit()) return(1);
 155                         break;
 156                 case WAN_CREATE_MONSTER:
 157                         { register int cnt = 1;
 158                         if(!rn2(23)) cnt += rn2(7) + 1;
 159                         while(cnt--)
 160                             (void) makemon((struct permonst *) 0, u.ux, u.uy);
 161                         }
 162                         break;
 163                 case WAN_WISHING:
 164                         { char buf[BUFSZ];
 165                           register struct obj *otmp;
 166                           extern struct obj *readobjnam(), *addinv();
 167                       if(u.uluck + rn2(5) < 0) {
 168                         pline("Unfortunately, nothing happens.");
 169                         break;
 170                       }
 171                       pline("You may wish for an object. What do you want? ");
 172                       getlin(buf);
 173                       if(buf[0] == '\033') buf[0] = 0;
 174                       otmp = readobjnam(buf);
 175                       otmp = addinv(otmp);
 176                       prinv(otmp);
 177                       break;
 178                         }
 179                 case WAN_DIGGING:
 180                         /* Original effect (approximately):
 181                          * from CORR: dig until we pierce a wall
 182                          * from ROOM: piece wall and dig until we reach
 183                          * an ACCESSIBLE place.
 184                          * Currently: dig for digdepth positions;
 185                          * also down on request of Lennart Augustsson.
 186                          */
 187                         { register struct rm *room;
 188                           register int digdepth;
 189                         if(u.uswallow) {
 190                                 register struct monst *mtmp = u.ustuck;
 191
 192                                 pline("You pierce %s's stomach wall!",
 193                                         monnam(mtmp));
 194                                 mtmp->mhp = 1;  /* almost dead */
 195                                 unstuck(mtmp);
 196                                 mnexto(mtmp);
 197                                 break;
 198                         }
 199                         if(u.dz) {
 200                             if(u.dz < 0) {
 201                                 pline("You loosen a rock from the ceiling.");
 202                                 pline("It falls on your head!");
 203                                 losehp(1, "falling rock");
 204                                 mksobj_at(ROCK, u.ux, u.uy);
 205                                 fobj->quan = 1;
 206                                 stackobj(fobj);
 207                                 if(Invisible) newsym(u.ux, u.uy);
 208                             } else {
 209                                 dighole();
 210                             }
 211                             break;
 212                         }
 213                         zx = u.ux+u.dx;
 214                         zy = u.uy+u.dy;
 215                         digdepth = 8 + rn2(18);
 216                         Tmp_at(-1, '*');        /* open call */
 217                         while(--digdepth >= 0) {
 218                                 if(!isok(zx,zy)) break;
 219                                 room = &levl[zx][zy];
 220                                 Tmp_at(zx,zy);
 221                                 if(!xdnstair){
 222                                         if(zx < 3 || zx > COLNO-3 ||
 223                                             zy < 3 || zy > ROWNO-3)
 224                                                 break;
 225                                         if(room->typ == HWALL ||
 226                                             room->typ == VWALL){
 227                                                 room->typ = ROOM;
 228                                                 break;
 229                                         }
 230                                 } else
 231                                 if(room->typ == HWALL || room->typ == VWALL ||
 232                                    room->typ == SDOOR || room->typ == LDOOR){
 233                                         room->typ = DOOR;
 234                                         digdepth -= 2;
 235                                 } else
 236                                 if(room->typ == SCORR || !room->typ) {
 237                                         room->typ = CORR;
 238                                         digdepth--;
 239                                 }
 240                                 mnewsym(zx,zy);
 241                                 zx += u.dx;
 242                                 zy += u.dy;
 243                         }
 244                         mnewsym(zx,zy); /* not always necessary */
 245                         Tmp_at(-1,-1);  /* closing call */
 246                         break;
 247                         }
 248                 default:
 249                         buzz((int) obj->otyp - WAN_MAGIC_MISSILE,
 250                                 u.ux, u.uy, u.dx, u.dy);
 251                         break;
 252                 }
 253                 if(!objects[obj->otyp].oc_name_known) {
 254                         objects[obj->otyp].oc_name_known = 1;
 255                         more_experienced(0,10);
 256                 }
 257         }
 258         return(1);
 259 }
 260
 261 char *
 262 exclam(force)
 263 register int force;
 264 {
 265         /* force == 0 occurs e.g. with sleep ray */
 266         /* note that large force is usual with wands so that !! would
 267                 require information about hand/weapon/wand */
 268         return( (force < 0) ? "?" : (force <= 4) ? "." : "!" );
 269 }
 270
 271 hit(str,mtmp,force)
 272 register char *str;
 273 register struct monst *mtmp;
 274 register char *force;           /* usually either "." or "!" */
 275 {
 276         if(!cansee(mtmp->mx,mtmp->my)) pline("The %s hits it.", str);
 277         else pline("The %s hits %s%s", str, monnam(mtmp), force);
 278 }
 279
 280 miss(str,mtmp)
 281 register char *str;
 282 register struct monst *mtmp;
 283 {
 284         if(!cansee(mtmp->mx,mtmp->my)) pline("The %s misses it.",str);
 285         else pline("The %s misses %s.",str,monnam(mtmp));
 286 }
 287
 288 /* bhit: called when a weapon is thrown (sym = obj->olet) or when an
 289    IMMEDIATE wand is zapped (sym = 0); the weapon falls down at end of
 290    range or when a monster is hit; the monster is returned, and bhitpos
 291    is set to the final position of the weapon thrown; the ray of a wand
 292    may affect several objects and monsters on its path - for each of
 293    these an argument function is called. */
 294 /* check !u.uswallow before calling bhit() */
 295
 296 struct monst *
 297 bhit(ddx,ddy,range,sym,fhitm,fhito,obj)
 298 register int ddx,ddy,range;             /* direction and range */
 299 char sym;                               /* symbol displayed on path */
 300 int (*fhitm)(), (*fhito)();             /* fns called when mon/obj hit */
 301 struct obj *obj;                        /* 2nd arg to fhitm/fhito */
 302 {
 303         register struct monst *mtmp;
 304         register struct obj *otmp;
 305         register int typ;
 306
 307         bhitpos.x = u.ux;
 308         bhitpos.y = u.uy;
 309
 310         if(sym) tmp_at(-1, sym);        /* open call */
 311         while(range-- > 0) {
 312                 bhitpos.x += ddx;
 313                 bhitpos.y += ddy;
 314                 typ = levl[bhitpos.x][bhitpos.y].typ;
 315                 if(mtmp = m_at(bhitpos.x,bhitpos.y)){
 316                         if(sym) {
 317                                 tmp_at(-1, -1); /* close call */
 318                                 return(mtmp);
 319                         }
 320                         (*fhitm)(mtmp, obj);
 321                         range -= 3;
 322                 }
 323                 if(fhito && (otmp = o_at(bhitpos.x,bhitpos.y))){
 324                         if((*fhito)(otmp, obj))
 325                                 range--;
 326                 }
 327                 if(!ZAP_POS(typ)) {
 328                         bhitpos.x -= ddx;
 329                         bhitpos.y -= ddy;
 330                         break;
 331                 }
 332                 if(sym) tmp_at(bhitpos.x, bhitpos.y);
 333         }
 334
 335         /* leave last symbol unless in a pool */
 336         if(sym)
 337            tmp_at(-1, (levl[bhitpos.x][bhitpos.y].typ == POOL) ? -1 : 0);
 338         return(0);
 339 }
 340
 341 struct monst *
 342 boomhit(dx,dy) {
 343         register int i, ct;
 344         register struct monst *mtmp;
 345         char sym = ')';
 346         extern schar xdir[], ydir[];
 347
 348         bhitpos.x = u.ux;
 349         bhitpos.y = u.uy;
 350
 351         for(i=0; i<8; i++) if(xdir[i] == dx && ydir[i] == dy) break;
 352         tmp_at(-1, sym);        /* open call */
 353         for(ct=0; ct<10; ct++) {
 354                 if(i == 8) i = 0;
 355                 sym = ')' + '(' - sym;
 356                 tmp_at(-2, sym);        /* change let call */
 357                 dx = xdir[i];
 358                 dy = ydir[i];
 359                 bhitpos.x += dx;
 360                 bhitpos.y += dy;
 361                 if(mtmp = m_at(bhitpos.x, bhitpos.y)){
 362                         tmp_at(-1,-1);
 363                         return(mtmp);
 364                 }
 365                 if(!ZAP_POS(levl[bhitpos.x][bhitpos.y].typ)) {
 366                         bhitpos.x -= dx;
 367                         bhitpos.y -= dy;
 368                         break;
 369                 }
 370                 if(bhitpos.x == u.ux && bhitpos.y == u.uy) { /* ct == 9 */
 371                         if(rn2(20) >= 10+u.ulevel){     /* we hit ourselves */
 372                                 (void) thitu(10, rnd(10), "boomerang");
 373                                 break;
 374                         } else {        /* we catch it */
 375                                 tmp_at(-1,-1);
 376                                 pline("Skillfully, you catch the boomerang.");
 377                                 return(&youmonst);
 378                         }
 379                 }
 380                 tmp_at(bhitpos.x, bhitpos.y);
 381                 if(ct % 5 != 0) i++;
 382         }
 383         tmp_at(-1, -1); /* do not leave last symbol */
 384         return(0);
 385 }
 386
 387 char
 388 dirlet(dx,dy) register dx,dy; {
 389         return
 390                 (dx == dy) ? '\\' : (dx && dy) ? '/' : dx ? '-' : '|';
 391 }
 392
 393 /* type == -1: monster spitting fire at you */
 394 /* type == -1,-2,-3: bolts sent out by wizard */
 395 /* called with dx = dy = 0 with vertical bolts */
 396 buzz(type,sx,sy,dx,dy)
 397 register int type;
 398 register xchar sx,sy;
 399 register int dx,dy;
 400 {
 401         int abstype = abs(type);
 402         register char *fltxt = (type == -1) ? "blaze of fire" : fl[abstype];
 403         struct rm *lev;
 404         xchar range;
 405         struct monst *mon;
 406
 407         if(u.uswallow) {
 408                 register int tmp;
 409
 410                 if(type < 0) return;
 411                 tmp = zhit(u.ustuck, type);
 412                 pline("The %s rips into %s%s",
 413                         fltxt, monnam(u.ustuck), exclam(tmp));
 414                 return;
 415         }
 416         if(type < 0) pru();
 417         range = rn1(7,7);
 418         Tmp_at(-1, dirlet(dx,dy));      /* open call */
 419         while(range-- > 0) {
 420                 sx += dx;
 421                 sy += dy;
 422                 if((lev = &levl[sx][sy])->typ) Tmp_at(sx,sy);
 423                 else {
 424                         int bounce = 0;
 425                         if(cansee(sx-dx,sy-dy))
 426                                 pline("The %s bounces!", fltxt);
 427                         if(ZAP_POS(levl[sx][sy-dy].typ))
 428                                 bounce = 1;
 429                         if(ZAP_POS(levl[sx-dx][sy].typ)) {
 430                                 if(!bounce || rn2(2)) bounce = 2;
 431                         }
 432                         switch(bounce){
 433                         case 0:
 434                                 dx = -dx;
 435                                 dy = -dy;
 436                                 continue;
 437                         case 1:
 438                                 dy = -dy;
 439                                 sx -= dx;
 440                                 break;
 441                         case 2:
 442                                 dx = -dx;
 443                                 sy -= dy;
 444                                 break;
 445                         }
 446                         Tmp_at(-2,dirlet(dx,dy));
 447                         continue;
 448                 }
 449                 if(lev->typ == POOL && abstype == 1 /* fire */) {
 450                         range -= 3;
 451                         lev->typ = ROOM;
 452                         if(cansee(sx,sy)) {
 453                                 mnewsym(sx,sy);
 454                                 pline("The water evaporates.");
 455                         } else
 456                                 pline("You hear a hissing sound.");
 457                 }
 458                 if((mon = m_at(sx,sy)) &&
 459                    (type != -1 || mon->data->mlet != 'D')) {
 460                         wakeup(mon);
 461                         if(rnd(20) < 18 + mon->data->ac) {
 462                                 register int tmp = zhit(mon,abstype);
 463                                 if(mon->mhp < 1) {
 464                                         if(type < 0) {
 465                                             if(cansee(mon->mx,mon->my))
 466                                               pline("%s is killed by the %s!",
 467                                                 Monnam(mon), fltxt);
 468                                             mondied(mon);
 469                                         } else
 470                                             killed(mon);
 471                                 } else
 472                                         hit(fltxt, mon, exclam(tmp));
 473                                 range -= 2;
 474                         } else
 475                                 miss(fltxt,mon);
 476                 } else if(sx == u.ux && sy == u.uy) {
 477                         nomul(0);
 478                         if(rnd(20) < 18+u.uac) {
 479                                 register int dam = 0;
 480                                 range -= 2;
 481                                 pline("The %s hits you!",fltxt);
 482                                 switch(abstype) {
 483                                 case 0:
 484                                         dam = d(2,6);
 485                                         break;
 486                                 case 1:
 487                                         if(Fire_resistance)
 488                                                 pline("You don't feel hot!");
 489                                         else dam = d(6,6);
 490                                         if(!rn2(3))
 491                                                 burn_scrolls();
 492                                         break;
 493                                 case 2:
 494                                         nomul(-rnd(25)); /* sleep ray */
 495                                         break;
 496                                 case 3:
 497                                         if(Cold_resistance)
 498                                                 pline("You don't feel cold!");
 499                                         else dam = d(6,6);
 500                                         break;
 501                                 case 4:
 502                                         u.uhp = -1;
 503                                 }
 504                                 losehp(dam,fltxt);
 505                         } else pline("The %s whizzes by you!",fltxt);
 506                         stop_occupation();
 507                 }
 508                 if(!ZAP_POS(lev->typ)) {
 509                         int bounce = 0, rmn;
 510                         if(cansee(sx,sy)) pline("The %s bounces!",fltxt);
 511                         range--;
 512                         if(!dx || !dy || !rn2(20)){
 513                                 dx = -dx;
 514                                 dy = -dy;
 515                         } else {
 516                           if(ZAP_POS(rmn = levl[sx][sy-dy].typ) &&
 517                             (IS_ROOM(rmn) || ZAP_POS(levl[sx+dx][sy-dy].typ)))
 518                                 bounce = 1;
 519                           if(ZAP_POS(rmn = levl[sx-dx][sy].typ) &&
 520                             (IS_ROOM(rmn) || ZAP_POS(levl[sx-dx][sy+dy].typ)))
 521                                 if(!bounce || rn2(2))
 522                                         bounce = 2;
 523
 524                           switch(bounce){
 525                           case 0:
 526                                 dy = -dy;
 527                                 dx = -dx;
 528                                 break;
 529                           case 1:
 530                                 dy = -dy;
 531                                 break;
 532                           case 2:
 533                                 dx = -dx;
 534                                 break;
 535                           }
 536                           Tmp_at(-2, dirlet(dx,dy));
 537                         }
 538                 }
 539         }
 540         Tmp_at(-1,-1);
 541 }
 542
 543 zhit(mon,type)                  /* returns damage to mon */
 544 register struct monst *mon;
 545 register type;
 546 {
 547         register int tmp = 0;
 548
 549         switch(type) {
 550         case 0:                 /* magic missile */
 551                 tmp = d(2,6);
 552                 break;
 553         case -1:                /* Dragon blazing fire */
 554         case 1:                 /* fire */
 555                 if(index("Dg", mon->data->mlet)) break;
 556                 tmp = d(6,6);
 557                 if(index("YF", mon->data->mlet)) tmp += 7;
 558                 break;
 559         case 2:                 /* sleep*/
 560                 mon->mfroz = 1;
 561                 break;
 562         case 3:                 /* cold */
 563                 if(index("YFgf", mon->data->mlet)) break;
 564                 tmp = d(6,6);
 565                 if(mon->data->mlet == 'D') tmp += 7;
 566                 break;
 567         case 4:                 /* death*/
 568                 if(index(UNDEAD, mon->data->mlet)) break;
 569                 tmp = mon->mhp+1;
 570                 break;
 571         }
 572         mon->mhp -= tmp;
 573         return(tmp);
 574 }
 575
 576 #define CORPSE_I_TO_C(otyp)     (char) ((otyp >= DEAD_ACID_BLOB)\
 577                      ?  'a' + (otyp - DEAD_ACID_BLOB)\
 578                      :  '@' + (otyp - DEAD_HUMAN))
 579 revive(obj)
 580 register struct obj *obj;
 581 {
 582         register struct monst *mtmp;
 583
 584         if(obj->olet == FOOD_SYM && obj->otyp > CORPSE) {
 585                 /* do not (yet) revive shopkeepers */
 586                 /* Note: this might conceivably produce two monsters
 587                         at the same position - strange, but harmless */
 588                 mtmp = mkmon_at(CORPSE_I_TO_C(obj->otyp),obj->ox,obj->oy);
 589                 delobj(obj);
 590         }
 591         return(!!mtmp);         /* TRUE if some monster created */
 592 }
 593
 594 rloco(obj)
 595 register struct obj *obj;
 596 {
 597         register tx,ty,otx,oty;
 598
 599         otx = obj->ox;
 600         oty = obj->oy;
 601         do {
 602                 tx = rn1(COLNO-3,2);
 603                 ty = rn2(ROWNO);
 604         } while(!goodpos(tx,ty));
 605         obj->ox = tx;
 606         obj->oy = ty;
 607         if(cansee(otx,oty))
 608                 newsym(otx,oty);
 609 }
 610
 611 fracture_rock(obj)      /* fractured by pick-axe or wand of striking */
 612 register struct obj *obj;                          /* no texts here! */
 613 {
 614         /* unpobj(obj); */
 615         obj->otyp = ROCK;
 616         obj->quan = 7 + rn2(60);
 617         obj->owt = weight(obj);
 618         obj->olet = WEAPON_SYM;
 619         if(cansee(obj->ox,obj->oy))
 620                 prl(obj->ox,obj->oy);
 621 }
 622
 623 burn_scrolls()
 624 {
 625         register struct obj *obj, *obj2;
 626         register int cnt = 0;
 627
 628         for(obj = invent; obj; obj = obj2) {
 629                 obj2 = obj->nobj;
 630                 if(obj->olet == SCROLL_SYM) {
 631                         cnt++;
 632                         useup(obj);
 633                 }
 634         }
 635         if(cnt > 1) {
 636                 pline("Your scrolls catch fire!");
 637                 losehp(cnt, "burning scrolls");
 638         } else if(cnt) {
 639                 pline("Your scroll catches fire!");
 640                 losehp(1, "burning scroll");
 641         }
 642 }