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

##### Functions

    abon              X
    cansee            X
    dbon              X
    domove            X
    dopickup          X
    inv_cnt           X
    inv_weight        X
    lookaround        X
    losehp            X
    losehp_m          X
    losestr           X
    losexp            X
    monster_nearby    X
    movobj            X
    newuexp           X
    nomul             X
    pickup            X
    rroom             X
    seeoff            X
    setsee            X
    sgn               X
    unsee             X

       1: /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
       2: /* hack.c - version 1.0.3 */
       3:
       4: #include "hack.h"
       5: #include <stdio.h>
       6:
       7: extern char news0();
       8: extern char *nomovemsg;
       9: extern char *exclam();
      10: extern struct obj *addinv();
      11: extern boolean hmon();
      12:
      13: /* called on movement:
      14: 	1. when throwing ball+chain far away
      15: 	2. when teleporting
      16: 	3. when walking out of a lit room
      17:  */
      18: unsee() {
      19:     register x,y;
      20:     register struct rm *lev;
      21:
      22: /*
      23: 	if(u.udispl){
      24: 		u.udispl = 0;
      25: 		newsym(u.udisx, u.udisy);
      26: 	}
      27: */
      28: #ifndef QUEST
      29:     if(seehx){
      30:         seehx = 0;
      31:     } else
      32: #endif QUEST
      33:     for(x = u.ux-1; x < u.ux+2; x++)
      34:       for(y = u.uy-1; y < u.uy+2; y++) {
      35:         if(!isok(x, y)) continue;
      36:         lev = &levl[x][y];
      37:         if(!lev->lit && lev->scrsym == '.') {
      38:             lev->scrsym =' ';
      39:             lev->new = 1;
      40:             on_scr(x,y);
      41:         }
      42:     }
      43: }
      44:
      45: /* called:
      46: 	in hack.eat.c: seeoff(0) - blind after eating rotten food
      47: 	in hack.mon.c: seeoff(0) - blinded by a yellow light
      48: 	in hack.mon.c: seeoff(1) - swallowed
      49: 	in hack.do.c:  seeoff(0) - blind after drinking potion
      50: 	in hack.do.c:  seeoff(1) - go up or down the stairs
      51: 	in hack.trap.c:seeoff(1) - fall through trapdoor
      52:  */
      53: seeoff(mode)    /* 1 to redo @, 0 to leave them */
      54: {   /* 1 means misc movement, 0 means blindness */
      55:     register x,y;
      56:     register struct rm *lev;
      57:
      58:     if(u.udispl && mode){
      59:         u.udispl = 0;
      60:         levl[u.udisx][u.udisy].scrsym = news0(u.udisx,u.udisy);
      61:     }
      62: #ifndef QUEST
      63:     if(seehx) {
      64:         seehx = 0;
      65:     } else
      66: #endif QUEST
      67:     if(!mode) {
      68:         for(x = u.ux-1; x < u.ux+2; x++)
      69:             for(y = u.uy-1; y < u.uy+2; y++) {
      70:                 if(!isok(x, y)) continue;
      71:                 lev = &levl[x][y];
      72:                 if(!lev->lit && lev->scrsym == '.')
      73:                     lev->seen = 0;
      74:             }
      75:     }
      76: }
      77:
      78: domove()
      79: {
      80:     xchar oldx,oldy;
      81:     register struct monst *mtmp;
      82:     register struct rm *tmpr,*ust;
      83:     struct trap *trap;
      84:     register struct obj *otmp;
      85:
      86:     u_wipe_engr(rnd(5));
      87:
      88:     if(inv_weight() > 0){
      89:         pline("You collapse under your load.");
      90:         nomul(0);
      91:         return;
      92:     }
      93:     if(u.uswallow) {
      94:         u.dx = u.dy = 0;
      95:         u.ux = u.ustuck->mx;
      96:         u.uy = u.ustuck->my;
      97:     } else {
      98:         if(Confusion) {
      99:             do {
     100:                 confdir();
     101:             } while(!isok(u.ux+u.dx, u.uy+u.dy) ||
     102:                 IS_ROCK(levl[u.ux+u.dx][u.uy+u.dy].typ));
     103:         }
     104:         if(!isok(u.ux+u.dx, u.uy+u.dy)){
     105:             nomul(0);
     106:             return;
     107:         }
     108:     }
     109:
     110:     ust = &levl[u.ux][u.uy];
     111:     oldx = u.ux;
     112:     oldy = u.uy;
     113:     if(!u.uswallow && (trap = t_at(u.ux+u.dx, u.uy+u.dy)) && trap->tseen)
     114:         nomul(0);
     115:     if(u.ustuck && !u.uswallow && (u.ux+u.dx != u.ustuck->mx ||
     116:         u.uy+u.dy != u.ustuck->my)) {
     117:         if(dist(u.ustuck->mx, u.ustuck->my) > 2){
     118:             /* perhaps it fled (or was teleported or ... ) */
     119:             u.ustuck = 0;
     120:         } else {
     121:             if(Blind) pline("You cannot escape from it!");
     122:             else pline("You cannot escape from %s!",
     123:                 monnam(u.ustuck));
     124:             nomul(0);
     125:             return;
     126:         }
     127:     }
     128:     if(u.uswallow || (mtmp = m_at(u.ux+u.dx,u.uy+u.dy))) {
     129:     /* attack monster */
     130:
     131:         nomul(0);
     132:         gethungry();
     133:         if(multi < 0) return;   /* we just fainted */
     134:
     135:         /* try to attack; note that it might evade */
     136:         if(attack(u.uswallow ? u.ustuck : mtmp))
     137:             return;
     138:     }
     139:     /* not attacking an animal, so we try to move */
     140:     if(u.utrap) {
     141:         if(u.utraptype == TT_PIT) {
     142:             pline("You are still in a pit.");
     143:             u.utrap--;
     144:         } else {
     145:             pline("You are caught in a beartrap.");
     146:             if((u.dx && u.dy) || !rn2(5)) u.utrap--;
     147:         }
     148:         return;
     149:     }
     150:     tmpr = &levl[u.ux+u.dx][u.uy+u.dy];
     151:     if(IS_ROCK(tmpr->typ) ||
     152:        (u.dx && u.dy && (tmpr->typ == DOOR || ust->typ == DOOR))){
     153:         flags.move = 0;
     154:         nomul(0);
     155:         return;
     156:     }
     157:     while(otmp = sobj_at(ENORMOUS_ROCK, u.ux+u.dx, u.uy+u.dy)) {
     158:         register xchar rx = u.ux+2*u.dx, ry = u.uy+2*u.dy;
     159:         register struct trap *ttmp;
     160:         nomul(0);
     161:         if(isok(rx,ry) && !IS_ROCK(levl[rx][ry].typ) &&
     162:             (levl[rx][ry].typ != DOOR || !(u.dx && u.dy)) &&
     163:             !sobj_at(ENORMOUS_ROCK, rx, ry)) {
     164:             if(m_at(rx,ry)) {
     165:                 pline("You hear a monster behind the rock.");
     166:                 pline("Perhaps that's why you cannot move it.");
     167:                 goto cannot_push;
     168:             }
     169:             if(ttmp = t_at(rx,ry))
     170:                 switch(ttmp->ttyp) {
     171:                 case PIT:
     172:                 pline("You push the rock into a pit!");
     173:                 deltrap(ttmp);
     174:                 delobj(otmp);
     175:                 pline("It completely fills the pit!");
     176:                 continue;
     177:                 case TELEP_TRAP:
     178:                 pline("You push the rock and suddenly it disappears!");
     179:                 delobj(otmp);
     180:                 continue;
     181:                 }
     182:             if(levl[rx][ry].typ == POOL) {
     183:                 levl[rx][ry].typ = ROOM;
     184:                 mnewsym(rx,ry);
     185:                 prl(rx,ry);
     186:                 pline("You push the rock into the water.");
     187:                 pline("Now you can cross the water!");
     188:                 delobj(otmp);
     189:                 continue;
     190:             }
     191:             otmp->ox = rx;
     192:             otmp->oy = ry;
     193:             /* pobj(otmp); */
     194:             if(cansee(rx,ry)) atl(rx,ry,otmp->olet);
     195:             if(Invisible) newsym(u.ux+u.dx, u.uy+u.dy);
     196:
     197:             { static long lastmovetime;
     198:             /* note: this var contains garbage initially and
     199: 			   after a restore */
     200:             if(moves > lastmovetime+2 || moves < lastmovetime)
     201:             pline("With great effort you move the enormous rock.");
     202:             lastmovetime = moves;
     203:             }
     204:         } else {
     205:             pline("You try to move the enormous rock, but in vain.");
     206:         cannot_push:
     207:             if((!invent || inv_weight()+90 <= 0) &&
     208:             (!u.dx || !u.dy || (IS_ROCK(levl[u.ux][u.uy+u.dy].typ)
     209:                     && IS_ROCK(levl[u.ux+u.dx][u.uy].typ)))){
     210:             pline("However, you can squeeze yourself into a small opening.");
     211:             break;
     212:             } else
     213:             return;
     214:         }
     215:         }
     216:     if(u.dx && u.dy && IS_ROCK(levl[u.ux][u.uy+u.dy].typ) &&
     217:         IS_ROCK(levl[u.ux+u.dx][u.uy].typ) &&
     218:         invent && inv_weight()+40 > 0) {
     219:         pline("You are carrying too much to get through.");
     220:         nomul(0);
     221:         return;
     222:     }
     223:     if(Punished &&
     224:        DIST(u.ux+u.dx, u.uy+u.dy, uchain->ox, uchain->oy) > 2){
     225:         if(carried(uball)) {
     226:             movobj(uchain, u.ux, u.uy);
     227:             goto nodrag;
     228:         }
     229:
     230:         if(DIST(u.ux+u.dx, u.uy+u.dy, uball->ox, uball->oy) < 3){
     231:             /* leave ball, move chain under/over ball */
     232:             movobj(uchain, uball->ox, uball->oy);
     233:             goto nodrag;
     234:         }
     235:
     236:         if(inv_weight() + (int) uball->owt/2 > 0) {
     237:             pline("You cannot %sdrag the heavy iron ball.",
     238:             invent ? "carry all that and also " : "");
     239:             nomul(0);
     240:             return;
     241:         }
     242:
     243:         movobj(uball, uchain->ox, uchain->oy);
     244:         unpobj(uball);      /* BAH %% */
     245:         uchain->ox = u.ux;
     246:         uchain->oy = u.uy;
     247:         nomul(-2);
     248:         nomovemsg = "";
     249:     nodrag: ;
     250:     }
     251:     u.ux += u.dx;
     252:     u.uy += u.dy;
     253:     if(flags.run) {
     254:         if(tmpr->typ == DOOR ||
     255:         (xupstair == u.ux && yupstair == u.uy) ||
     256:         (xdnstair == u.ux && ydnstair == u.uy))
     257:             nomul(0);
     258:     }
     259:
     260:     if(tmpr->typ == POOL && !Levitation)
     261:         drown();    /* not necessarily fatal */
     262:
     263: /*
     264: 	if(u.udispl) {
     265: 		u.udispl = 0;
     266: 		newsym(oldx,oldy);
     267: 	}
     268: */
     269:     if(!Blind) {
     270: #ifdef QUEST
     271:         setsee();
     272: #else
     273:         if(ust->lit) {
     274:             if(tmpr->lit) {
     275:                 if(tmpr->typ == DOOR)
     276:                     prl1(u.ux+u.dx,u.uy+u.dy);
     277:                 else if(ust->typ == DOOR)
     278:                     nose1(oldx-u.dx,oldy-u.dy);
     279:             } else {
     280:                 unsee();
     281:                 prl1(u.ux+u.dx,u.uy+u.dy);
     282:             }
     283:         } else {
     284:             if(tmpr->lit) setsee();
     285:             else {
     286:                 prl1(u.ux+u.dx,u.uy+u.dy);
     287:                 if(tmpr->typ == DOOR) {
     288:                     if(u.dy) {
     289:                         prl(u.ux-1,u.uy);
     290:                         prl(u.ux+1,u.uy);
     291:                     } else {
     292:                         prl(u.ux,u.uy-1);
     293:                         prl(u.ux,u.uy+1);
     294:                     }
     295:                 }
     296:             }
     297:             nose1(oldx-u.dx,oldy-u.dy);
     298:         }
     299: #endif QUEST
     300:     } else {
     301:         pru();
     302:     }
     303:     if(!flags.nopick) pickup(1);
     304:     if(trap) dotrap(trap);      /* fall into pit, arrow trap, etc. */
     305:     (void) inshop();
     306:     if(!Blind) read_engr_at(u.ux,u.uy);
     307: }
     308:
     309: movobj(obj, ox, oy)
     310: register struct obj *obj;
     311: register int ox, oy;
     312: {
     313:     /* Some dirty programming to get display right */
     314:     freeobj(obj);
     315:     unpobj(obj);
     316:     obj->nobj = fobj;
     317:     fobj = obj;
     318:     obj->ox = ox;
     319:     obj->oy = oy;
     320: }
     321:
     322: dopickup(){
     323:     if(!g_at(u.ux,u.uy) && !o_at(u.ux,u.uy)) {
     324:         pline("There is nothing here to pick up.");
     325:         return(0);
     326:     }
     327:     if(Levitation) {
     328:         pline("You cannot reach the floor.");
     329:         return(1);
     330:     }
     331:     pickup(0);
     332:     return(1);
     333: }
     334:
     335: pickup(all)
     336: {
     337:     register struct gold *gold;
     338:     register struct obj *obj, *obj2;
     339:     register int wt;
     340:
     341:     if(Levitation) return;
     342:     while(gold = g_at(u.ux,u.uy)) {
     343:         pline("%ld gold piece%s.", gold->amount, plur(gold->amount));
     344:         u.ugold += gold->amount;
     345:         flags.botl = 1;
     346:         freegold(gold);
     347:         if(flags.run) nomul(0);
     348:         if(Invisible) newsym(u.ux,u.uy);
     349:     }
     350:
     351:     /* check for more than one object */
     352:     if(!all) {
     353:         register int ct = 0;
     354:
     355:         for(obj = fobj; obj; obj = obj->nobj)
     356:             if(obj->ox == u.ux && obj->oy == u.uy)
     357:                 if(!Punished || obj != uchain)
     358:                     ct++;
     359:         if(ct < 2)
     360:             all++;
     361:         else
     362:             pline("There are several objects here.");
     363:     }
     364:
     365:     for(obj = fobj; obj; obj = obj2) {
     366:         obj2 = obj->nobj;   /* perhaps obj will be picked up */
     367:         if(obj->ox == u.ux && obj->oy == u.uy) {
     368:         if(flags.run) nomul(0);
     369:
     370:         /* do not pick up uchain */
     371:         if(Punished && obj == uchain)
     372:             continue;
     373:
     374:         if(!all) {
     375:             char c;
     376:
     377:             pline("Pick up %s ? [ynaq]", doname(obj));
     378:             while(!index("ynaq ", (c = readchar())))
     379:                 bell();
     380:             if(c == 'q') return;
     381:             if(c == 'n') continue;
     382:             if(c == 'a') all = 1;
     383:         }
     384:
     385:         if(obj->otyp == DEAD_COCKATRICE && !uarmg){
     386:             pline("Touching the dead cockatrice is a fatal mistake.");
     387:             pline("You turn to stone.");
     388:             killer = "cockatrice cadaver";
     389:             done("died");
     390:         }
     391:
     392:         if(obj->otyp == SCR_SCARE_MONSTER){
     393:           if(!obj->spe) obj->spe = 1;
     394:           else {
     395:             /* Note: perhaps the 1st pickup failed: you cannot
     396: 			carry anymore, and so we never dropped it -
     397: 			let's assume that treading on it twice also
     398: 			destroys the scroll */
     399:             pline("The scroll turns to dust as you pick it up.");
     400:             delobj(obj);
     401:             continue;
     402:           }
     403:         }
     404:
     405:         wt = inv_weight() + obj->owt;
     406:         if(wt > 0) {
     407:             if(obj->quan > 1) {
     408:                 /* see how many we can lift */
     409:                 extern struct obj *splitobj();
     410:                 int savequan = obj->quan;
     411:                 int iw = inv_weight();
     412:                 int qq;
     413:                 for(qq = 1; qq < savequan; qq++){
     414:                     obj->quan = qq;
     415:                     if(iw + weight(obj) > 0)
     416:                         break;
     417:                 }
     418:                 obj->quan = savequan;
     419:                 qq--;
     420:                 /* we can carry qq of them */
     421:                 if(!qq) goto too_heavy;
     422:             pline("You can only carry %s of the %s lying here.",
     423:                     (qq == 1) ? "one" : "some",
     424:                     doname(obj));
     425:                 (void) splitobj(obj, qq);
     426:                 /* note: obj2 is set already, so we'll never
     427: 				 * encounter the other half; if it should be
     428: 				 * otherwise then write
     429: 				 *	obj2 = splitobj(obj,qq);
     430: 				 */
     431:                 goto lift_some;
     432:             }
     433:         too_heavy:
     434:             pline("There %s %s here, but %s.",
     435:                 (obj->quan == 1) ? "is" : "are",
     436:                 doname(obj),
     437:                 !invent ? "it is too heavy for you to lift"
     438:                     : "you cannot carry anymore");
     439:             break;
     440:         }
     441:     lift_some:
     442:         if(inv_cnt() >= 52) {
     443:             pline("Your knapsack cannot accomodate anymore items.");
     444:             break;
     445:         }
     446:         if(wt > -5) pline("You have a little trouble lifting");
     447:         freeobj(obj);
     448:         if(Invisible) newsym(u.ux,u.uy);
     449:         addtobill(obj);       /* sets obj->unpaid if necessary */
     450:         { int pickquan = obj->quan;
     451:           int mergquan;
     452:         if(!Blind) obj->dknown = 1; /* this is done by prinv(),
     453: 				 but addinv() needs it already for merging */
     454:         obj = addinv(obj);    /* might merge it with other objects */
     455:           mergquan = obj->quan;
     456:           obj->quan = pickquan; /* to fool prinv() */
     457:         prinv(obj);
     458:           obj->quan = mergquan;
     459:         }
     460:         }
     461:     }
     462: }
     463:
     464: /* stop running if we see something interesting */
     465: /* turn around a corner if that is the only way we can proceed */
     466: /* do not turn left or right twice */
     467: lookaround(){
     468: register x,y,i,x0,y0,m0,i0 = 9;
     469: register int corrct = 0, noturn = 0;
     470: register struct monst *mtmp;
     471: #ifdef lint
     472:     /* suppress "used before set" message */
     473:     x0 = y0 = 0;
     474: #endif lint
     475:     if(Blind || flags.run == 0) return;
     476:     if(flags.run == 1 && levl[u.ux][u.uy].typ == ROOM) return;
     477: #ifdef QUEST
     478:     if(u.ux0 == u.ux+u.dx && u.uy0 == u.uy+u.dy) goto stop;
     479: #endif QUEST
     480:     for(x = u.ux-1; x <= u.ux+1; x++) for(y = u.uy-1; y <= u.uy+1; y++){
     481:         if(x == u.ux && y == u.uy) continue;
     482:         if(!levl[x][y].typ) continue;
     483:         if((mtmp = m_at(x,y)) && !mtmp->mimic &&
     484:             (!mtmp->minvis || See_invisible)){
     485:             if(!mtmp->mtame || (x == u.ux+u.dx && y == u.uy+u.dy))
     486:                 goto stop;
     487:         } else mtmp = 0; /* invisible M cannot influence us */
     488:         if(x == u.ux-u.dx && y == u.uy-u.dy) continue;
     489:         switch(levl[x][y].scrsym){
     490:         case '|':
     491:         case '-':
     492:         case '.':
     493:         case ' ':
     494:             break;
     495:         case '+':
     496:             if(x != u.ux && y != u.uy) break;
     497:             if(flags.run != 1) goto stop;
     498:             /* fall into next case */
     499:         case CORR_SYM:
     500:         corr:
     501:             if(flags.run == 1 || flags.run == 3) {
     502:                 i = DIST(x,y,u.ux+u.dx,u.uy+u.dy);
     503:                 if(i > 2) break;
     504:                 if(corrct == 1 && DIST(x,y,x0,y0) != 1)
     505:                     noturn = 1;
     506:                 if(i < i0) {
     507:                     i0 = i;
     508:                     x0 = x;
     509:                     y0 = y;
     510:                     m0 = mtmp ? 1 : 0;
     511:                 }
     512:             }
     513:             corrct++;
     514:             break;
     515:         case '^':
     516:             if(flags.run == 1) goto corr;   /* if you must */
     517:             if(x == u.ux+u.dx && y == u.uy+u.dy) goto stop;
     518:             break;
     519:         default:    /* e.g. objects or trap or stairs */
     520:             if(flags.run == 1) goto corr;
     521:             if(mtmp) break;     /* d */
     522:         stop:
     523:             nomul(0);
     524:             return;
     525:         }
     526:     }
     527: #ifdef QUEST
     528:     if(corrct > 0 && (flags.run == 4 || flags.run == 5)) goto stop;
     529: #endif QUEST
     530:     if(corrct > 1 && flags.run == 2) goto stop;
     531:     if((flags.run == 1 || flags.run == 3) && !noturn && !m0 && i0 &&
     532:         (corrct == 1 || (corrct == 2 && i0 == 1))) {
     533:         /* make sure that we do not turn too far */
     534:         if(i0 == 2) {
     535:             if(u.dx == y0-u.uy && u.dy == u.ux-x0)
     536:             i = 2;      /* straight turn right */
     537:             else
     538:             i = -2;     /* straight turn left */
     539:         } else if(u.dx && u.dy) {
     540:             if((u.dx == u.dy && y0 == u.uy) ||
     541:             (u.dx != u.dy && y0 != u.uy))
     542:             i = -1;     /* half turn left */
     543:             else
     544:             i = 1;      /* half turn right */
     545:         } else {
     546:             if((x0-u.ux == y0-u.uy && !u.dy) ||
     547:             (x0-u.ux != y0-u.uy && u.dy))
     548:             i = 1;      /* half turn right */
     549:             else
     550:             i = -1;     /* half turn left */
     551:         }
     552:         i += u.last_str_turn;
     553:         if(i <= 2 && i >= -2) {
     554:             u.last_str_turn = i;
     555:             u.dx = x0-u.ux, u.dy = y0-u.uy;
     556:         }
     557:     }
     558: }
     559:
     560: /* something like lookaround, but we are not running */
     561: /* react only to monsters that might hit us */
     562: monster_nearby() {
     563: register int x,y;
     564: register struct monst *mtmp;
     565:     if(!Blind)
     566:     for(x = u.ux-1; x <= u.ux+1; x++) for(y = u.uy-1; y <= u.uy+1; y++){
     567:         if(x == u.ux && y == u.uy) continue;
     568:         if((mtmp = m_at(x,y)) && !mtmp->mimic && !mtmp->mtame &&
     569:             !mtmp->mpeaceful && !index("Ea", mtmp->data->mlet) &&
     570:             !mtmp->mfroz && !mtmp->msleep &&  /* aplvax!jcn */
     571:             (!mtmp->minvis || See_invisible))
     572:             return(1);
     573:     }
     574:     return(0);
     575: }
     576:
     577: #ifdef QUEST
     578: cansee(x,y) xchar x,y; {
     579: register int dx,dy,adx,ady,sdx,sdy,dmax,d;
     580:     if(Blind) return(0);
     581:     if(!isok(x,y)) return(0);
     582:     d = dist(x,y);
     583:     if(d < 3) return(1);
     584:     if(d > u.uhorizon*u.uhorizon) return(0);
     585:     if(!levl[x][y].lit)
     586:         return(0);
     587:     dx = x - u.ux;  adx = abs(dx);  sdx = sgn(dx);
     588:     dy = y - u.uy;  ady = abs(dy);  sdy = sgn(dy);
     589:     if(dx == 0 || dy == 0 || adx == ady){
     590:         dmax = (dx == 0) ? ady : adx;
     591:         for(d = 1; d <= dmax; d++)
     592:             if(!rroom(sdx*d,sdy*d))
     593:                 return(0);
     594:         return(1);
     595:     } else if(ady > adx){
     596:         for(d = 1; d <= ady; d++){
     597:             if(!rroom(sdx*( (d*adx)/ady ), sdy*d) ||
     598:                !rroom(sdx*( (d*adx-1)/ady+1 ), sdy*d))
     599:                 return(0);
     600:         }
     601:         return(1);
     602:     } else {
     603:         for(d = 1; d <= adx; d++){
     604:             if(!rroom(sdx*d, sdy*( (d*ady)/adx )) ||
     605:                !rroom(sdx*d, sdy*( (d*ady-1)/adx+1 )))
     606:                 return(0);
     607:         }
     608:         return(1);
     609:     }
     610: }
     611:
     612: rroom(x,y) register int x,y; {
     613:     return(IS_ROOM(levl[u.ux+x][u.uy+y].typ));
     614: }
     615:
     616: #else
     617:
     618: cansee(x,y) xchar x,y; {
     619:     if(Blind || u.uswallow) return(0);
     620:     if(dist(x,y) < 3) return(1);
     621:     if(levl[x][y].lit && seelx <= x && x <= seehx && seely <= y &&
     622:         y <= seehy) return(1);
     623:     return(0);
     624: }
     625: #endif QUEST
     626:
     627: sgn(a) register int a; {
     628:     return((a > 0) ? 1 : (a == 0) ? 0 : -1);
     629: }
     630:
     631: #ifdef QUEST
     632: setsee()
     633: {
     634:     register x,y;
     635:
     636:     if(Blind) {
     637:         pru();
     638:         return;
     639:     }
     640:     for(y = u.uy-u.uhorizon; y <= u.uy+u.uhorizon; y++)
     641:         for(x = u.ux-u.uhorizon; x <= u.ux+u.uhorizon; x++) {
     642:             if(cansee(x,y))
     643:                 prl(x,y);
     644:     }
     645: }
     646:
     647: #else
     648:
     649: setsee()
     650: {
     651:     register x,y;
     652:
     653:     if(Blind) {
     654:         pru();
     655:         return;
     656:     }
     657:     if(!levl[u.ux][u.uy].lit) {
     658:         seelx = u.ux-1;
     659:         seehx = u.ux+1;
     660:         seely = u.uy-1;
     661:         seehy = u.uy+1;
     662:     } else {
     663:         for(seelx = u.ux; levl[seelx-1][u.uy].lit; seelx--);
     664:         for(seehx = u.ux; levl[seehx+1][u.uy].lit; seehx++);
     665:         for(seely = u.uy; levl[u.ux][seely-1].lit; seely--);
     666:         for(seehy = u.uy; levl[u.ux][seehy+1].lit; seehy++);
     667:     }
     668:     for(y = seely; y <= seehy; y++)
     669:         for(x = seelx; x <= seehx; x++) {
     670:             prl(x,y);
     671:     }
     672:     if(!levl[u.ux][u.uy].lit) seehx = 0; /* seems necessary elsewhere */
     673:     else {
     674:         if(seely == u.uy) for(x = u.ux-1; x <= u.ux+1; x++) prl(x,seely-1);
     675:         if(seehy == u.uy) for(x = u.ux-1; x <= u.ux+1; x++) prl(x,seehy+1);
     676:         if(seelx == u.ux) for(y = u.uy-1; y <= u.uy+1; y++) prl(seelx-1,y);
     677:         if(seehx == u.ux) for(y = u.uy-1; y <= u.uy+1; y++) prl(seehx+1,y);
     678:     }
     679: }
     680: #endif QUEST
     681:
     682: nomul(nval)
     683: register nval;
     684: {
     685:     if(multi < 0) return;
     686:     multi = nval;
     687:     flags.mv = flags.run = 0;
     688: }
     689:
     690: abon()
     691: {
     692:     if(u.ustr == 3) return(-3);
     693:     else if(u.ustr < 6) return(-2);
     694:     else if(u.ustr < 8) return(-1);
     695:     else if(u.ustr < 17) return(0);
     696:     else if(u.ustr < 69) return(1); /* up to 18/50 */
     697:     else if(u.ustr < 118) return(2);
     698:     else return(3);
     699: }
     700:
     701: dbon()
     702: {
     703:     if(u.ustr < 6) return(-1);
     704:     else if(u.ustr < 16) return(0);
     705:     else if(u.ustr < 18) return(1);
     706:     else if(u.ustr == 18) return(2);    /* up to 18 */
     707:     else if(u.ustr < 94) return(3);     /* up to 18/75 */
     708:     else if(u.ustr < 109) return(4);    /* up to 18/90 */
     709:     else if(u.ustr < 118) return(5);    /* up to 18/99 */
     710:     else return(6);
     711: }
     712:
     713: losestr(num)    /* may kill you; cause may be poison or monster like 'A' */
     714: register num;
     715: {
     716:     u.ustr -= num;
     717:     while(u.ustr < 3) {
     718:         u.ustr++;
     719:         u.uhp -= 6;
     720:         u.uhpmax -= 6;
     721:     }
     722:     flags.botl = 1;
     723: }
     724:
     725: losehp(n,knam)
     726: register n;
     727: register char *knam;
     728: {
     729:     u.uhp -= n;
     730:     if(u.uhp > u.uhpmax)
     731:         u.uhpmax = u.uhp;   /* perhaps n was negative */
     732:     flags.botl = 1;
     733:     if(u.uhp < 1) {
     734:         killer = knam;  /* the thing that killed you */
     735:         done("died");
     736:     }
     737: }
     738:
     739: losehp_m(n,mtmp)
     740: register n;
     741: register struct monst *mtmp;
     742: {
     743:     u.uhp -= n;
     744:     flags.botl = 1;
     745:     if(u.uhp < 1)
     746:         done_in_by(mtmp);
     747: }
     748:
     749: losexp()    /* hit by V or W */
     750: {
     751:     register num;
     752:     extern long newuexp();
     753:
     754:     if(u.ulevel > 1)
     755:         pline("Goodbye level %u.", u.ulevel--);
     756:     else
     757:         u.uhp = -1;
     758:     num = rnd(10);
     759:     u.uhp -= num;
     760:     u.uhpmax -= num;
     761:     u.uexp = newuexp();
     762:     flags.botl = 1;
     763: }
     764:
     765: inv_weight(){
     766: register struct obj *otmp = invent;
     767: register int wt = (u.ugold + 500)/1000;
     768: register int carrcap;
     769:     if(Levitation)          /* pugh@cornell */
     770:         carrcap = MAX_CARR_CAP;
     771:     else {
     772:         carrcap = 5*(((u.ustr > 18) ? 20 : u.ustr) + u.ulevel);
     773:         if(carrcap > MAX_CARR_CAP) carrcap = MAX_CARR_CAP;
     774:         if(Wounded_legs & LEFT_SIDE) carrcap -= 10;
     775:         if(Wounded_legs & RIGHT_SIDE) carrcap -= 10;
     776:     }
     777:     while(otmp){
     778:         wt += otmp->owt;
     779:         otmp = otmp->nobj;
     780:     }
     781:     return(wt - carrcap);
     782: }
     783:
     784: inv_cnt(){
     785: register struct obj *otmp = invent;
     786: register int ct = 0;
     787:     while(otmp){
     788:         ct++;
     789:         otmp = otmp->nobj;
     790:     }
     791:     return(ct);
     792: }
     793:
     794: long
     795: newuexp()
     796: {
     797:     return(10*(1L << (u.ulevel-1)));
     798: }

#### Defined functions

abon defined in line 690; used 4 times

- in /usr/src/games/hack/hack.apply.c line 263
- in /usr/src/games/hack/hack.do.c line 335, 361
- in /usr/src/games/hack/hack.fight.c line 294

cansee defined in line 618; used 45 times

- in line 194, 642
- in /usr/src/games/hack/hack.apply.c line 88
- in /usr/src/games/hack/hack.do.c line 372, 437
- in /usr/src/games/hack/hack.do_name.c line 70
- in /usr/src/games/hack/hack.dog.c line 132-137(2), 316, 400
- in /usr/src/games/hack/hack.fight.c line 27(2), 74, 90
- in /usr/src/games/hack/hack.mhitu.c line 57
- in /usr/src/games/hack/hack.mon.c line 43, 63, 182, 760, 845
- in /usr/src/games/hack/hack.pri.c line 96, 102, 138, 369, 482
- in /usr/src/games/hack/hack.read.c line 100, 368
- in /usr/src/games/hack/hack.shk.c line 838
- in /usr/src/games/hack/hack.steal.c line 191, 200
- in /usr/src/games/hack/hack.trap.c line 148, 186
- in /usr/src/games/hack/hack.vault.c line 45, 126, 230
- in /usr/src/games/hack/hack.worm.c line 44, 97
- in /usr/src/games/hack/hack.zap.c line 276, 284, 425, 452, 465, 510, 607, 619

dbon defined in line 701; used 1 times

- in /usr/src/games/hack/hack.fight.c line 207

domove defined in line 78; used 3 times

- in /usr/src/games/hack/hack.cmd.c line 112, 130
- in /usr/src/games/hack/hack.main.c line 388

dopickup defined in line 322; used 2 times

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

inv_cnt defined in line 784; used 1 times

- in line 442

inv_weight defined in line 765; used 10 times

- in line 88, 207, 218, 236, 405, 411
- in /usr/src/games/hack/hack.do.c line 112, 195
- in /usr/src/games/hack/hack.fight.c line 316
- in /usr/src/games/hack/hack.u_init.c line 248

lookaround defined in line 467; used 1 times

- in /usr/src/games/hack/hack.main.c line 380

losehp defined in line 725; used 20 times

- in /usr/src/games/hack/hack.do.c line 197-201(2), 221, 295, 425
- in /usr/src/games/hack/hack.eat.c line 376, 382
- in /usr/src/games/hack/hack.fight.c line 122
- in /usr/src/games/hack/hack.mon.c line 579
- in /usr/src/games/hack/hack.potion.c line 35, 114, 237
- in /usr/src/games/hack/hack.read.c line 381, 389
- in /usr/src/games/hack/hack.trap.c line 82, 129
- in /usr/src/games/hack/hack.zap.c line 203, 504, 637-640(2)

losehp_m defined in line 739; used 4 times

- in /usr/src/games/hack/hack.fight.c line 341
- in /usr/src/games/hack/hack.mhitu.c line 157, 300, 358

losestr defined in line 713; used 6 times

- in /usr/src/games/hack/hack.eat.c line 326-329(2), 375
- in /usr/src/games/hack/hack.mhitu.c line 110
- in /usr/src/games/hack/hack.mon.c line 577
- in /usr/src/games/hack/hack.potion.c line 113

losexp defined in line 749; used 2 times

- in /usr/src/games/hack/hack.mhitu.c line 280-283(2)

monster_nearby defined in line 562; never used
movobj defined in line 309; used 3 times

- in line 226, 232, 243

newuexp defined in line 794; used 6 times

- in line 752, 761
- in /usr/src/games/hack/hack.mon.c line 667, 729
- in /usr/src/games/hack/hack.potion.c line 200-202(2)

nomul defined in line 682; used 41 times

- in line 90, 105, 114, 124, 131, 154, 160, 220, 239, 247, 257, 347, 368, 523
- in /usr/src/games/hack/hack.apply.c line 55-58(2)
- in /usr/src/games/hack/hack.do.c line 248
- in /usr/src/games/hack/hack.do_wear.c line 91, 160
- in /usr/src/games/hack/hack.eat.c line 176, 309, 451
- in /usr/src/games/hack/hack.end.c line 21
- in /usr/src/games/hack/hack.fight.c line 351
- in /usr/src/games/hack/hack.mhitu.c line 17, 164-169(2), 326
- in /usr/src/games/hack/hack.potion.c line 72, 324, 385
- in /usr/src/games/hack/hack.search.c line 67, 73, 84
- in /usr/src/games/hack/hack.timeout.c line 61
- in /usr/src/games/hack/hack.trap.c line 42, 50, 320
- in /usr/src/games/hack/hack.wizard.c line 123
- in /usr/src/games/hack/hack.zap.c line 477, 494

pickup defined in line 335; used 6 times

- in line 303, 331
- in /usr/src/games/hack/hack.do.c line 238
- in /usr/src/games/hack/hack.main.c line 283
- in /usr/src/games/hack/hack.trap.c line 262, 324

rroom defined in line 612; used 5 times

- in line 592-598(3), 604-605(2)

seeoff defined in line 53; used 6 times

- in /usr/src/games/hack/hack.do.c line 151
- in /usr/src/games/hack/hack.eat.c line 170
- in /usr/src/games/hack/hack.mhitu.c line 309
- in /usr/src/games/hack/hack.mon.c line 120
- in /usr/src/games/hack/hack.potion.c line 149, 333

setsee defined in line 649; used 10 times

- in line 271, 284
- in /usr/src/games/hack/hack.do.c line 235, 434
- in /usr/src/games/hack/hack.eat.c line 225
- in /usr/src/games/hack/hack.main.c line 267
- in /usr/src/games/hack/hack.mon.c line 652
- in /usr/src/games/hack/hack.save.c line 165
- in /usr/src/games/hack/hack.timeout.c line 30
- in /usr/src/games/hack/hack.trap.c line 314

sgn defined in line 627; used 6 times

- in line 587-588(2)
- in /usr/src/games/hack/hack.wizard.c line 100(2), 158(2)

unsee defined in line 18; used 3 times

- in line 280
- in /usr/src/games/hack/hack.do.c line 429
- in /usr/src/games/hack/hack.trap.c line 309

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