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