# 2.11BSD#431 - /usr/src/games/hack/hack.read.c

##### Functions

    doread            X
    identify          X
    litroom           X
    monstersym        X

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

#### Defined functions

doread defined in line 10; used 2 times

- in /usr/src/games/hack/hack.cmd.c line 7, 48

identify defined in line 438; used 3 times

- in line 8, 323
- in /usr/src/games/hack/hack.unix.c line 347

litroom defined in line 447; used 2 times

- in line 215
- in /usr/src/games/hack/hack.zap.c line 151

monstersym defined in line 521; never used

Last modified: 1985-10-18 Generated: 2016-12-26 | Generated by src2html V0.67 page hit count: 1775 |