games/hack/hack.read.c

   1 /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
   2 /* hack.read.c - version 1.0.3 */
   3 /* $FreeBSD: src/games/hack/hack.read.c,v 1.6 1999/11/16 10:26:37 marcel Exp $ */
   4 /* $DragonFly: src/games/hack/hack.read.c,v 1.4 2006/08/21 19:45:32 pavalos Exp $ */
   5
   6 #include "hack.h"
   7
   8 static bool     monstersym(char);
   9
  10 int
  11 doread(void)
  12 {
  13         struct obj *scroll;
  14         boolean confused = (Confusion != 0);
  15         boolean known = FALSE;
  16
  17         scroll = getobj("?", "read");
  18         if(!scroll) return(0);
  19         if(!scroll->dknown && Blind) {
  20             pline("Being blind, you cannot read the formula on the scroll.");
  21             return(0);
  22         }
  23         if(Blind)
  24           pline("As you pronounce the formula on it, the scroll disappears.");
  25         else
  26           pline("As you read the scroll, it disappears.");
  27         if(confused)
  28           pline("Being confused, you mispronounce the magic words ... ");
  29
  30         switch(scroll->otyp) {
  31 #ifdef MAIL
  32         case SCR_MAIL:
  33                 readmail(/* scroll */);
  34                 break;
  35 #endif /* MAIL */
  36         case SCR_ENCHANT_ARMOR:
  37             {   struct obj *otmp = some_armor();
  38                 if(!otmp) {
  39                         strange_feeling(scroll,"Your skin glows then fades.");
  40                         return(1);
  41                 }
  42                 if(confused) {
  43                         pline("Your %s glows silver for a moment.",
  44                                 objects[otmp->otyp].oc_name);
  45                         otmp->rustfree = 1;
  46                         break;
  47                 }
  48                 if(otmp->spe > 3 && rn2(otmp->spe)) {
  49         pline("Your %s glows violently green for a while, then evaporates.",
  50                         objects[otmp->otyp].oc_name);
  51                         useup(otmp);
  52                         break;
  53                 }
  54                 pline("Your %s glows green for a moment.",
  55                         objects[otmp->otyp].oc_name);
  56                 otmp->cursed = 0;
  57                 otmp->spe++;
  58                 break;
  59             }
  60         case SCR_DESTROY_ARMOR:
  61                 if(confused) {
  62                         struct obj *otmp = some_armor();
  63                         if(!otmp) {
  64                                 strange_feeling(scroll,"Your bones itch.");
  65                                 return(1);
  66                         }
  67                         pline("Your %s glows purple for a moment.",
  68                                 objects[otmp->otyp].oc_name);
  69                         otmp->rustfree = 0;
  70                         break;
  71                 }
  72                 if(uarm) {
  73                     pline("Your armor turns to dust and falls to the floor!");
  74                     useup(uarm);
  75                 } else if(uarmh) {
  76                     pline("Your helmet turns to dust and is blown away!");
  77                     useup(uarmh);
  78                 } else if(uarmg) {
  79                         pline("Your gloves vanish!");
  80                         useup(uarmg);
  81                         selftouch("You");
  82                 } else {
  83                         strange_feeling(scroll,"Your skin itches.");
  84                         return(1);
  85                 }
  86                 break;
  87         case SCR_CONFUSE_MONSTER:
  88                 if(confused) {
  89                         pline("Your hands begin to glow purple.");
  90                         Confusion += rnd(100);
  91                 } else {
  92                         pline("Your hands begin to glow blue.");
  93                         u.umconf = 1;
  94                 }
  95                 break;
  96         case SCR_SCARE_MONSTER:
  97             {   int ct = 0;
  98                 struct monst *mtmp;
  99
 100                 for(mtmp = fmon; mtmp; mtmp = mtmp->nmon)
 101                         if(cansee(mtmp->mx,mtmp->my)) {
 102                                 if(confused)
 103                                         mtmp->mflee = mtmp->mfroz =
 104                                         mtmp->msleep = 0;
 105                                 else
 106                                         mtmp->mflee = 1;
 107                                 ct++;
 108                         }
 109                 if(!ct) {
 110                     if(confused)
 111                         pline("You hear sad wailing in the distance.");
 112                     else
 113                         pline("You hear maniacal laughter in the distance.");
 114                 }
 115                 break;
 116             }
 117         case SCR_BLANK_PAPER:
 118                 if(confused)
 119                     pline("You see strange patterns on this scroll.");
 120                 else
 121                     pline("This scroll seems to be blank.");
 122                 break;
 123         case SCR_REMOVE_CURSE:
 124             {   struct obj *obj;
 125                 if(confused)
 126                   pline("You feel like you need some help.");
 127                 else
 128                   pline("You feel like someone is helping you.");
 129                 for(obj = invent; obj ; obj = obj->nobj)
 130                         if(obj->owornmask)
 131                                 obj->cursed = confused;
 132                 if(Punished && !confused) {
 133                         Punished = 0;
 134                         freeobj(uchain);
 135                         unpobj(uchain);
 136                         free((char *) uchain);
 137                         uball->spe = 0;
 138                         uball->owornmask &= ~W_BALL;
 139                         uchain = uball = (struct obj *) 0;
 140                 }
 141                 break;
 142             }
 143         case SCR_CREATE_MONSTER:
 144             {   int cnt = 1;
 145
 146                 if(!rn2(73)) cnt += rnd(4);
 147                 if(confused) cnt += 12;
 148                 while(cnt--)
 149                     makemon(confused ? PM_ACID_BLOB :
 150                         (struct permonst *) 0, u.ux, u.uy);
 151                 break;
 152             }
 153         case SCR_ENCHANT_WEAPON:
 154                 if(uwep && confused) {
 155                         pline("Your %s glows silver for a moment.",
 156                                 objects[uwep->otyp].oc_name);
 157                         uwep->rustfree = 1;
 158                 } else
 159                         if(!chwepon(scroll, 1))         /* tests for !uwep */
 160                                 return(1);
 161                 break;
 162         case SCR_DAMAGE_WEAPON:
 163                 if(uwep && confused) {
 164                         pline("Your %s glows purple for a moment.",
 165                                 objects[uwep->otyp].oc_name);
 166                         uwep->rustfree = 0;
 167                 } else
 168                         if(!chwepon(scroll, -1))        /* tests for !uwep */
 169                                 return(1);
 170                 break;
 171         case SCR_TAMING:
 172             {   int i,j;
 173                 int bd = confused ? 5 : 1;
 174                 struct monst *mtmp;
 175
 176                 for(i = -bd; i <= bd; i++) for(j = -bd; j <= bd; j++)
 177                 if((mtmp = m_at(u.ux+i, u.uy+j)))
 178                         tamedog(mtmp, (struct obj *) 0);
 179                 break;
 180             }
 181         case SCR_GENOCIDE:
 182             {
 183                 char buf[BUFSZ];
 184                 struct monst *mtmp, *mtmp2;
 185
 186                 pline("You have found a scroll of genocide!");
 187                 known = TRUE;
 188                 if(confused)
 189                         *buf = u.usym;
 190                 else do {
 191             pline("What monster do you want to genocide (Type the letter)? ");
 192                         getlin(buf);
 193                 } while(strlen(buf) != 1 || !monstersym(*buf));
 194                 if(!index(fut_geno, *buf))
 195                         charcat(fut_geno, *buf);
 196                 if(!index(genocided, *buf))
 197                         charcat(genocided, *buf);
 198                 else {
 199                         pline("Such monsters do not exist in this world.");
 200                         break;
 201                 }
 202                 for(mtmp = fmon; mtmp; mtmp = mtmp2){
 203                         mtmp2 = mtmp->nmon;
 204                         if(mtmp->data->mlet == *buf)
 205                                 mondead(mtmp);
 206                 }
 207                 pline("Wiped out all %c's.", *buf);
 208                 if(*buf == u.usym) {
 209                         killer = "scroll of genocide";
 210                         u.uhp = -1;
 211                 }
 212                 break;
 213                 }
 214         case SCR_LIGHT:
 215                 if(!Blind) known = TRUE;
 216                 litroom(!confused);
 217                 break;
 218         case SCR_TELEPORTATION:
 219                 if(confused)
 220                         level_tele();
 221                 else {
 222 #ifdef QUEST
 223                         int oux = u.ux, ouy = u.uy;
 224                         tele();
 225                         if(dist(oux, ouy) > 100) known = TRUE;
 226 #else /* QUEST */
 227                         int uroom = inroom(u.ux, u.uy);
 228                         tele();
 229                         if(uroom != inroom(u.ux, u.uy)) known = TRUE;
 230 #endif /* QUEST */
 231                 }
 232                 break;
 233         case SCR_GOLD_DETECTION:
 234             /* Unfortunately this code has become slightly less elegant,
 235                now that gold and traps no longer are of the same type. */
 236             if(confused) {
 237                 struct trap *ttmp;
 238
 239                 if(!ftrap) {
 240                         strange_feeling(scroll, "Your toes stop itching.");
 241                         return(1);
 242                 } else {
 243                         for(ttmp = ftrap; ttmp; ttmp = ttmp->ntrap)
 244                                 if(ttmp->tx != u.ux || ttmp->ty != u.uy)
 245                                         goto outtrapmap;
 246                         /* only under me - no separate display required */
 247                         pline("Your toes itch!");
 248                         break;
 249                 outtrapmap:
 250                         cls();
 251                         for(ttmp = ftrap; ttmp; ttmp = ttmp->ntrap)
 252                                 at(ttmp->tx, ttmp->ty, '$');
 253                         prme();
 254                         pline("You feel very greedy!");
 255                 }
 256             } else {
 257                 struct gold *gtmp;
 258
 259                 if(!fgold) {
 260                         strange_feeling(scroll, "You feel materially poor.");
 261                         return(1);
 262                 } else {
 263                         known = TRUE;
 264                         for(gtmp = fgold; gtmp; gtmp = gtmp->ngold)
 265                                 if(gtmp->gx != u.ux || gtmp->gy != u.uy)
 266                                         goto outgoldmap;
 267                         /* only under me - no separate display required */
 268                         pline("You notice some gold between your feet.");
 269                         break;
 270                 outgoldmap:
 271                         cls();
 272                         for(gtmp = fgold; gtmp; gtmp = gtmp->ngold)
 273                                 at(gtmp->gx, gtmp->gy, '$');
 274                         prme();
 275                         pline("You feel very greedy, and sense gold!");
 276                 }
 277             }
 278                 /* common sequel */
 279                 more();
 280                 docrt();
 281                 break;
 282         case SCR_FOOD_DETECTION:
 283             {   int ct = 0, ctu = 0;
 284                 struct obj *obj;
 285                 char foodsym = confused ? POTION_SYM : FOOD_SYM;
 286
 287                 for(obj = fobj; obj; obj = obj->nobj)
 288                         if(obj->olet == FOOD_SYM) {
 289                                 if(obj->ox == u.ux && obj->oy == u.uy) ctu++;
 290                                 else ct++;
 291                         }
 292                 if(!ct && !ctu) {
 293                         strange_feeling(scroll,"Your nose twitches.");
 294                         return(1);
 295                 } else if(!ct) {
 296                         known = TRUE;
 297                         pline("You smell %s close nearby.",
 298                                 confused ? "something" : "food");
 299
 300                 } else {
 301                         known = TRUE;
 302                         cls();
 303                         for(obj = fobj; obj; obj = obj->nobj)
 304                             if(obj->olet == foodsym)
 305                                 at(obj->ox, obj->oy, FOOD_SYM);
 306                         prme();
 307                         pline("Your nose tingles and you smell %s!",
 308                                 confused ? "something" : "food");
 309                         more();
 310                         docrt();
 311                 }
 312                 break;
 313             }
 314         case SCR_IDENTIFY:
 315                 /* known = TRUE; */
 316                 if(confused)
 317                         pline("You identify this as an identify scroll.");
 318                 else
 319                         pline("This is an identify scroll.");
 320                 useup(scroll);
 321                 objects[SCR_IDENTIFY].oc_name_known = 1;
 322                 if(!confused)
 323                     while(
 324                         !ggetobj("identify", identify, rn2(5) ? 1 : rn2(5))
 325                         && invent
 326                     );
 327                 return(1);
 328         case SCR_MAGIC_MAPPING:
 329             {   struct rm *lev;
 330                 int num, zx, zy;
 331
 332                 known = TRUE;
 333                 pline("On this scroll %s a map!",
 334                         confused ? "was" : "is");
 335                 for(zy = 0; zy < ROWNO; zy++)
 336                         for(zx = 0; zx < COLNO; zx++) {
 337                                 if(confused && rn2(7)) continue;
 338                                 lev = &(levl[zx][zy]);
 339                                 if((num = lev->typ) == 0)
 340                                         continue;
 341                                 if(num == SCORR) {
 342                                         lev->typ = CORR;
 343                                         lev->scrsym = CORR_SYM;
 344                                 } else
 345                                 if(num == SDOOR) {
 346                                         lev->typ = DOOR;
 347                                         lev->scrsym = '+';
 348                                         /* do sth in doors ? */
 349                                 } else if(lev->seen) continue;
 350 #ifndef QUEST
 351                                 if(num != ROOM)
 352 #endif /* QUEST */
 353                                 {
 354                                   lev->seen = lev->new = 1;
 355                                   if(lev->scrsym == ' ' || !lev->scrsym)
 356                                     newsym(zx,zy);
 357                                   else
 358                                     on_scr(zx,zy);
 359                                 }
 360                         }
 361                 break;
 362             }
 363         case SCR_AMNESIA:
 364             {   int zx, zy;
 365
 366                 known = TRUE;
 367                 for(zx = 0; zx < COLNO; zx++) for(zy = 0; zy < ROWNO; zy++)
 368                     if(!confused || rn2(7))
 369                         if(!cansee(zx,zy))
 370                             levl[zx][zy].seen = 0;
 371                 docrt();
 372                 pline("Thinking of Maud you forget everything else.");
 373                 break;
 374             }
 375         case SCR_FIRE:
 376             {   int num = 0;
 377                 struct monst *mtmp;
 378
 379                 known = TRUE;
 380                 if(confused) {
 381                     pline("The scroll catches fire and you burn your hands.");
 382                     losehp(1, "scroll of fire");
 383                 } else {
 384                     pline("The scroll erupts in a tower of flame!");
 385                     if(Fire_resistance)
 386                         pline("You are uninjured.");
 387                     else {
 388                         num = rnd(6);
 389                         u.uhpmax -= num;
 390                         losehp(num, "scroll of fire");
 391                     }
 392                 }
 393                 num = (2*num + 1)/3;
 394                 for(mtmp = fmon; mtmp; mtmp = mtmp->nmon) {
 395                     if(dist(mtmp->mx,mtmp->my) < 3) {
 396                         mtmp->mhp -= num;
 397                         if(index("FY", mtmp->data->mlet))
 398                             mtmp->mhp -= 3*num; /* this might well kill 'F's */
 399                         if(mtmp->mhp < 1) {
 400                             killed(mtmp);
 401                             break;              /* primitive */
 402                         }
 403                     }
 404                 }
 405                 break;
 406             }
 407         case SCR_PUNISHMENT:
 408                 known = TRUE;
 409                 if(confused) {
 410                         pline("You feel guilty.");
 411                         break;
 412                 }
 413                 pline("You are being punished for your misbehaviour!");
 414                 if(Punished){
 415                         pline("Your iron ball gets heavier.");
 416                         uball->owt += 15;
 417                         break;
 418                 }
 419                 Punished = INTRINSIC;
 420                 setworn(mkobj_at(CHAIN_SYM, u.ux, u.uy), W_CHAIN);
 421                 setworn(mkobj_at(BALL_SYM, u.ux, u.uy), W_BALL);
 422                 uball->spe = 1;         /* special ball (see save) */
 423                 break;
 424         default:
 425                 impossible("What weird language is this written in? (%u)",
 426                         scroll->otyp);
 427         }
 428         if(!objects[scroll->otyp].oc_name_known) {
 429                 if(known && !confused) {
 430                         objects[scroll->otyp].oc_name_known = 1;
 431                         more_experienced(0,10);
 432                 } else if(!objects[scroll->otyp].oc_uname)
 433                         docall(scroll);
 434         }
 435         useup(scroll);
 436         return(1);
 437 }
 438
 439 int
 440 identify(struct obj *otmp)      /* also called by newmail() */
 441 {
 442         objects[otmp->otyp].oc_name_known = 1;
 443         otmp->known = otmp->dknown = 1;
 444         prinv(otmp);
 445         return(1);
 446 }
 447
 448 void
 449 litroom(bool on)
 450 {
 451         int num,zx,zy;
 452
 453         /* first produce the text (provided he is not blind) */
 454         if(Blind) goto do_it;
 455         if(!on) {
 456                 if(u.uswallow || !xdnstair || levl[u.ux][u.uy].typ == CORR ||
 457                     !levl[u.ux][u.uy].lit) {
 458                         pline("It seems even darker in here than before.");
 459                         return;
 460                 } else
 461                         pline("It suddenly becomes dark in here.");
 462         } else {
 463                 if(u.uswallow){
 464                         pline("%s's stomach is lit.", Monnam(u.ustuck));
 465                         return;
 466                 }
 467                 if(!xdnstair){
 468                         pline("Nothing Happens.");
 469                         return;
 470                 }
 471 #ifdef QUEST
 472                 pline("The cave lights up around you, then fades.");
 473                 return;
 474 #else /* QUEST */
 475                 if(levl[u.ux][u.uy].typ == CORR) {
 476                     pline("The corridor lights up around you, then fades.");
 477                     return;
 478                 } else if(levl[u.ux][u.uy].lit) {
 479                     pline("The light here seems better now.");
 480                     return;
 481                 } else
 482                     pline("The room is lit.");
 483 #endif /* QUEST */
 484         }
 485
 486 do_it:
 487 #ifdef QUEST
 488         return;
 489 #else /* QUEST */
 490         if(levl[u.ux][u.uy].lit == on)
 491                 return;
 492         if(levl[u.ux][u.uy].typ == DOOR) {
 493                 if(IS_ROOM(levl[u.ux][u.uy+1].typ)) zy = u.uy+1;
 494                 else if(IS_ROOM(levl[u.ux][u.uy-1].typ)) zy = u.uy-1;
 495                 else zy = u.uy;
 496                 if(IS_ROOM(levl[u.ux+1][u.uy].typ)) zx = u.ux+1;
 497                 else if(IS_ROOM(levl[u.ux-1][u.uy].typ)) zx = u.ux-1;
 498                 else zx = u.ux;
 499         } else {
 500                 zx = u.ux;
 501                 zy = u.uy;
 502         }
 503         for(seelx = u.ux; (num = levl[seelx-1][zy].typ) != CORR && num != 0;
 504                 seelx--);
 505         for(seehx = u.ux; (num = levl[seehx+1][zy].typ) != CORR && num != 0;
 506                 seehx++);
 507         for(seely = u.uy; (num = levl[zx][seely-1].typ) != CORR && num != 0;
 508                 seely--);
 509         for(seehy = u.uy; (num = levl[zx][seehy+1].typ) != CORR && num != 0;
 510                 seehy++);
 511         for(zy = seely; zy <= seehy; zy++)
 512                 for(zx = seelx; zx <= seehx; zx++) {
 513                         levl[zx][zy].lit = on;
 514                         if(!Blind && dist(zx,zy) > 2) {
 515                                 if(on) prl(zx,zy); else nosee(zx,zy);
 516                         }
 517                 }
 518         if(!on) seehx = 0;
 519 #endif /* QUEST */
 520 }
 521
 522 /* Test whether we may genocide all monsters with symbol  ch  */
 523 static bool
 524 monstersym(char ch)                     /* arnold@ucsfcgl */
 525 {
 526         struct permonst *mp;
 527
 528         /*
 529          * can't genocide certain monsters
 530          */
 531         if (index("12 &:", ch))
 532                 return FALSE;
 533
 534         if (ch == pm_eel.mlet)
 535                 return TRUE;
 536         for (mp = mons; mp < &mons[CMNUM+2]; mp++)
 537                 if (mp->mlet == ch)
 538                         return TRUE;
 539         return FALSE;
 540 }