Ask Question

Name:
Title:
Your Question:

Answer Question

Name:
Your Answer:
User Submitted Source Code!


Description:
  صص
Language: C/C++
Code:
1.    /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1984. */


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