Bug Summary

File:src/games/hack/hack.c
Warning:line 374, column 5
Branch condition evaluates to a garbage value

Annotated Source Code

Press '?' to see keyboard shortcuts

clang -cc1 -cc1 -triple amd64-unknown-openbsd7.4 -analyze -disable-free -clear-ast-before-backend -disable-llvm-verifier -discard-value-names -main-file-name hack.c -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -pic-is-pie -mframe-pointer=all -relaxed-aliasing -ffp-contract=on -fno-rounding-math -mconstructor-aliases -funwind-tables=2 -target-cpu x86-64 -target-feature +retpoline-indirect-calls -target-feature +retpoline-indirect-branches -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/games/hack/obj -resource-dir /usr/local/llvm16/lib/clang/16 -I . -internal-isystem /usr/local/llvm16/lib/clang/16/include -internal-externc-isystem /usr/include -O2 -fdebug-compilation-dir=/usr/src/games/hack/obj -ferror-limit 19 -fwrapv -D_RET_PROTECTOR -ret-protector -fcf-protection=branch -fno-jump-tables -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/scan/2024-01-11-140451-98009-1 -x c /usr/src/games/hack/hack.c
1/* $OpenBSD: hack.c,v 1.12 2023/09/06 11:53:56 jsg 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 <stdio.h>
65#ifdef QUEST
66#include <stdlib.h>
67#endif
68
69#include "hack.h"
70
71extern char *nomovemsg;
72
73static void movobj(struct obj *, int, int);
74#ifdef QUEST
75static int rroom(int, int);
76#endif
77static int inv_cnt(void);
78
79/* called on movement:
80 * 1. when throwing ball+chain far away
81 * 2. when teleporting
82 * 3. when walking out of a lit room
83 */
84void
85unsee(void)
86{
87 int x,y;
88 struct rm *lev;
89
90/*
91 if(u.udispl){
92 u.udispl = 0;
93 newsym(u.udisx, u.udisy);
94 }
95*/
96#ifndef QUEST
97 if(seehx){
98 seehx = 0;
99 } else
100#endif /* QUEST */
101 for(x = u.ux-1; x < u.ux+2; x++)
102 for(y = u.uy-1; y < u.uy+2; y++) {
103 if(!isok(x, y)) continue;
104 lev = &levl[x][y];
105 if(!lev->lit && lev->scrsym == '.') {
106 lev->scrsym =' ';
107 lev->new = 1;
108 on_scr(x,y);
109 }
110 }
111}
112
113/* called:
114 * in hack.eat.c: seeoff(0) - blind after eating rotten food
115 * in hack.mon.c: seeoff(0) - blinded by a yellow light
116 * in hack.mon.c: seeoff(1) - swallowed
117 * in hack.do.c: seeoff(0) - blind after drinking potion
118 * in hack.do.c: seeoff(1) - go up or down the stairs
119 * in hack.trap.c:seeoff(1) - fall through trapdoor
120 */
121void
122seeoff(int mode) /* 1 to redo @, 0 to leave them */
123{ /* 1 means misc movement, 0 means blindness */
124 int x,y;
125 struct rm *lev;
126
127 if(u.udispl && mode){
128 u.udispl = 0;
129 levl[(int)u.udisx][(int)u.udisy].scrsym = news0(u.udisx,u.udisy);
130 }
131#ifndef QUEST
132 if(seehx) {
133 seehx = 0;
134 } else
135#endif /* QUEST */
136 if(!mode) {
137 for(x = u.ux-1; x < u.ux+2; x++)
138 for(y = u.uy-1; y < u.uy+2; y++) {
139 if(!isok(x, y)) continue;
140 lev = &levl[x][y];
141 if(!lev->lit && lev->scrsym == '.')
142 lev->seen = 0;
143 }
144 }
145}
146
147void
148domove(void)
149{
150 xchar oldx,oldy;
151 struct monst *mtmp;
152 struct rm *tmpr,*ust;
153 struct trap *trap;
1
'trap' declared without an initial value
→
154 struct obj *otmp;
155
156 u_wipe_engr(rnd(5));
157
158 if(inv_weight() > 0){
2
←
Assuming the condition is false
→
3
←
Taking false branch
→
159 pline("You collapse under your load.");
160 nomul(0);
161 return;
162 }
163 if(u.uswallow) {
4
←
Assuming field 'uswallow' is 0
→
5
←
Taking false branch
→
164 u.dx = u.dy = 0;
165 u.ux = u.ustuck->mx;
166 u.uy = u.ustuck->my;
167 } else {
168 if(Confusionu.uprops[(19 +2)].p_flgs) {
6
←
Assuming field 'p_flgs' is 0
→
7
←
Taking false branch
→
169 do {
170 confdir();
171 } while(!isok(u.ux+u.dx, u.uy+u.dy) ||
172 IS_ROCK(levl[u.ux+u.dx][u.uy+u.dy].typ)((levl[u.ux+u.dx][u.uy+u.dy].typ) < 6));
173 }
174 if(!isok(u.ux+u.dx, u.uy+u.dy)){
8
←
Assuming the condition is false
→
9
←
Taking false branch
→
175 nomul(0);
176 return;
177 }
178 }
179
180 ust = &levl[(int)u.ux][(int)u.uy];
181 oldx = u.ux;
182 oldy = u.uy;
183 if(!u.uswallow && (trap = t_at(u.ux+u.dx, u.uy+u.dy)) && trap->tseen)
10
←
Assuming field 'uswallow' is not equal to 0
→
184 nomul(0);
185 if(u.ustuck && !u.uswallow && (u.ux+u.dx != u.ustuck->mx ||
11
←
Assuming field 'ustuck' is null
→
186 u.uy+u.dy != u.ustuck->my)) {
187 if(dist(u.ustuck->mx, u.ustuck->my) > 2){
188 /* perhaps it fled (or was teleported or ... ) */
189 u.ustuck = 0;
190 } else {
191 if(Blindu.uprops[(19 +7)].p_flgs) pline("You cannot escape from it!");
192 else pline("You cannot escape from %s!",
193 monnam(u.ustuck));
194 nomul(0);
195 return;
196 }
197 }
198 if(u.uswallow
11.1
Field 'uswallow' is not equal to 0
 || (mtmp = m_at(u.ux+u.dx,u.uy+u.dy))) {
199 /* attack monster */
200
201 nomul(0);
202 gethungry();
203 if(multi < 0) return; /* we just fainted */
12
←
Assuming 'multi' is >= 0
→
13
←
Taking false branch
→
204
205 /* try to attack; note that it might evade */
206 if(attack(u.uswallow ? u.ustuck : mtmp))
14
←
Assuming field 'uswallow' is not equal to 0
→
15
←
'?' condition is true
→
16
←
Assuming the condition is false
→
17
←
Taking false branch
→
207 return;
208 }
209 /* not attacking an animal, so we try to move */
210 if(u.utrap) {
18
←
Assuming field 'utrap' is 0
→
19
←
Taking false branch
→
211 if(u.utraptype == TT_PIT1) {
212 pline("You are still in a pit.");
213 u.utrap--;
214 } else {
215 pline("You are caught in a beartrap.");
216 if((u.dx && u.dy) || !rn2(5)) u.utrap--;
217 }
218 return;
219 }
220 tmpr = &levl[u.ux+u.dx][u.uy+u.dy];
221 if(IS_ROCK(tmpr->typ)((tmpr->typ) < 6) ||
20
←
Assuming field 'typ' is >= 6
→
222 (u.dx && u.dy && (tmpr->typ == DOOR7 || ust->typ == DOOR7))){
21
←
Assuming field 'dx' is 0
→
223 flags.move = 0;
224 nomul(0);
225 return;
226 }
227 while ((otmp = sobj_at(ENORMOUS_ROCK97, u.ux+u.dx, u.uy+u.dy))) {
228 xchar rx = u.ux+2*u.dx, ry = u.uy+2*u.dy;
229 struct trap *ttmp;
230 nomul(0);
231 if (isok(rx,ry) && !IS_ROCK(levl[(int)rx][(int)ry].typ)((levl[(int)rx][(int)ry].typ) < 6) &&
232 (levl[(int)rx][(int)ry].typ != DOOR7 || !(u.dx && u.dy)) &&
233 !sobj_at(ENORMOUS_ROCK97, rx, ry)) {
234 if(m_at(rx,ry)) {
235 pline("You hear a monster behind the rock.");
236 pline("Perhaps that's why you cannot move it.");
237 goto cannot_push;
238 }
239 if ((ttmp = t_at(rx,ry)))
240 switch(ttmp->ttyp) {
241 case PIT5:
242 pline("You push the rock into a pit!");
243 deltrap(ttmp);
244 delobj(otmp);
245 pline("It completely fills the pit!");
246 continue;
247 case TELEP_TRAP4:
248 pline("You push the rock and suddenly it disappears!");
249 delobj(otmp);
250 continue;
251 }
252 if (levl[(int)rx][(int)ry].typ == POOL6) {
253 levl[(int)rx][(int)ry].typ = ROOM9;
254 mnewsym(rx,ry);
255 prl(rx,ry);
256 pline("You push the rock into the water.");
257 pline("Now you can cross the water!");
258 delobj(otmp);
259 continue;
260 }
261 otmp->ox = rx;
262 otmp->oy = ry;
263 /* pobj(otmp); */
264 if(cansee(rx,ry)) atl(rx,ry,otmp->olet);
265 if(Invisible(u.uprops[(19 +3)].p_flgs && !u.uprops[4].p_flgs)) newsym(u.ux+u.dx, u.uy+u.dy);
266
267 { static long lastmovetime;
268 /* note: this var contains garbage initially and
269 after a restore */
270 if(moves > lastmovetime+2 || moves < lastmovetime)
271 pline("With great effort you move the enormous rock.");
272 lastmovetime = moves;
273 }
274 } else {
275 pline("You try to move the enormous rock, but in vain.");
276 cannot_push:
277 if((!invent || inv_weight()+90 <= 0) &&
278 (!u.dx || !u.dy || (IS_ROCK(levl[(int)u.ux][u.uy+u.dy].typ)((levl[(int)u.ux][u.uy+u.dy].typ) < 6)
279 && IS_ROCK(levl[u.ux+u.dx][(int)u.uy].typ)((levl[u.ux+u.dx][(int)u.uy].typ) < 6)))){
280 pline("However, you can squeeze yourself into a small opening.");
281 break;
282 } else
283 return;
284 }
285 }
286 if(u.dx && u.dy && IS_ROCK(levl[(int)u.ux][u.uy+u.dy].typ)((levl[(int)u.ux][u.uy+u.dy].typ) < 6) &&
22
←
Assuming field 'dx' is 0
→
287 IS_ROCK(levl[u.ux+u.dx][(int)u.uy].typ)((levl[u.ux+u.dx][(int)u.uy].typ) < 6) &&
288 invent && inv_weight()+40 > 0) {
289 pline("You are carrying too much to get through.");
290 nomul(0);
291 return;
292 }
293 if(Punishedu.uprops[(19 +5)].p_flgs &&
23
←
Assuming field 'p_flgs' is 0
→
294 DIST(u.ux+u.dx, u.uy+u.dy, uchain->ox, uchain->oy)(((u.ux+u.dx)-(uchain->ox))*((u.ux+u.dx)-(uchain->ox)) +
((u.uy+u.dy)-(uchain->oy))*((u.uy+u.dy)-(uchain->oy))) > 2){
295 if(carried(uball)) {
296 movobj(uchain, u.ux, u.uy);
297 goto nodrag;
298 }
299
300 if(DIST(u.ux+u.dx, u.uy+u.dy, uball->ox, uball->oy)(((u.ux+u.dx)-(uball->ox))*((u.ux+u.dx)-(uball->ox)) + (
(u.uy+u.dy)-(uball->oy))*((u.uy+u.dy)-(uball->oy))) < 3){
301 /* leave ball, move chain under/over ball */
302 movobj(uchain, uball->ox, uball->oy);
303 goto nodrag;
304 }
305
306 if(inv_weight() + (int) uball->owt/2 > 0) {
307 pline("You cannot %sdrag the heavy iron ball.",
308 invent ? "carry all that and also " : "");
309 nomul(0);
310 return;
311 }
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) {
24
←
Assuming field 'run' is 0
→
324 if(tmpr->typ == DOOR7 ||
325 (xupstair == u.ux && yupstair == u.uy) ||
326 (xdnstair == u.ux && ydnstair == u.uy))
327 nomul(0);
328 }
329
330 if(tmpr->typ == POOL6 && !Levitationu.uprops[6].p_flgs)
25
←
Assuming field 'typ' is not equal to POOL
→
331 drown(); /* not necessarily fatal */
332
333/*
334 if(u.udispl) {
335 u.udispl = 0;
336 newsym(oldx,oldy);
337 }
338*/
339 if(!Blindu.uprops[(19 +7)].p_flgs) {
26
←
Assuming field 'p_flgs' is not equal to 0
→
27
←
Taking false branch
→
340#ifdef QUEST
341 setsee();
342#else
343 if(ust->lit) {
344 if(tmpr->lit) {
345 if(tmpr->typ == DOOR7)
346 prl1(u.ux+u.dx,u.uy+u.dy);
347 else if(ust->typ == DOOR7)
348 nose1(oldx-u.dx,oldy-u.dy);
349 } else {
350 unsee();
351 prl1(u.ux+u.dx,u.uy+u.dy);
352 }
353 } else {
354 if(tmpr->lit) setsee();
355 else {
356 prl1(u.ux+u.dx,u.uy+u.dy);
357 if(tmpr->typ == DOOR7) {
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) pickup(1);
28
←
Assuming field 'nopick' is not equal to 0
→
29
←
Taking false branch
→
374 if(trap) dotrap(trap); /* fall into pit, arrow trap, etc. */
30
←
Branch condition evaluates to a garbage value
375 (void) inshop();
376 if(!Blindu.uprops[(19 +7)].p_flgs) read_engr_at(u.ux,u.uy);
377}
378
379static void
380movobj(struct obj *obj, int ox, int oy)
381{
382 /* Some dirty programming to get display right */
383 freeobj(obj);
384 unpobj(obj);
385 obj->nobj = fobj;
386 fobj = obj;
387 obj->ox = ox;
388 obj->oy = oy;
389}
390
391int
392dopickup(void)
393{
394 if(!g_at(u.ux,u.uy) && !o_at(u.ux,u.uy)) {
395 pline("There is nothing here to pick up.");
396 return(0);
397 }
398 if(Levitationu.uprops[6].p_flgs) {
399 pline("You cannot reach the floor.");
400 return(1);
401 }
402 pickup(0);
403 return(1);
404}
405
406void
407pickup(int all)
408{
409 struct gold *gold;
410 struct obj *obj, *obj2;
411 int wt;
412
413 if (Levitationu.uprops[6].p_flgs)
414 return;
415 while ((gold = g_at(u.ux,u.uy))) {
416 pline("%ld gold piece%s.", gold->amount, plur(gold->amount)(((gold->amount) == 1) ? "" : "s"));
417 u.ugold += gold->amount;
418 flags.botl = 1;
419 freegold(gold);
420 if(flags.run) nomul(0);
421 if(Invisible(u.uprops[(19 +3)].p_flgs && !u.uprops[4].p_flgs)) newsym(u.ux,u.uy);
422 }
423
424 /* check for more than one object */
425 if(!all) {
426 int ct = 0;
427
428 for(obj = fobj; obj; obj = obj->nobj)
429 if(obj->ox == u.ux && obj->oy == u.uy)
430 if(!Punishedu.uprops[(19 +5)].p_flgs || obj != uchain)
431 ct++;
432 if(ct < 2)
433 all++;
434 else
435 pline("There are several objects here.");
436 }
437
438 for(obj = fobj; obj; obj = obj2) {
439 obj2 = obj->nobj; /* perhaps obj will be picked up */
440 if(obj->ox == u.ux && obj->oy == u.uy) {
441 if(flags.run) nomul(0);
442
443 /* do not pick up uchain */
444 if(Punishedu.uprops[(19 +5)].p_flgs && obj == uchain)
445 continue;
446
447 if(!all) {
448 char c;
449
450 pline("Pick up %s ? [ynaq]", doname(obj));
451 while(!strchr("ynaq ", (c = readchar())))
452 hackbell();
453 if(c == 'q') return;
454 if(c == 'n') continue;
455 if(c == 'a') all = 1;
456 }
457
458 if(obj->otyp == DEAD_COCKATRICE47 && !uarmg){
459 pline("Touching the dead cockatrice is a fatal mistake.");
460 pline("You turn to stone.");
461 killer = "cockatrice cadaver";
462 done("died");
463 }
464
465 if(obj->otyp == SCR_SCARE_MONSTER134){
466 if(!obj->spe) obj->spe = 1;
467 else {
468 /* Note: perhaps the 1st pickup failed: you cannot
469 carry anymore, and so we never dropped it -
470 let's assume that treading on it twice also
471 destroys the scroll */
472 pline("The scroll turns to dust as you pick it up.");
473 delobj(obj);
474 continue;
475 }
476 }
477
478 wt = inv_weight() + obj->owt;
479 if(wt > 0) {
480 if(obj->quan > 1) {
481 /* see how many we can lift */
482 int savequan = obj->quan;
483 int iw = inv_weight();
484 int qq;
485 for(qq = 1; qq < savequan; qq++){
486 obj->quan = qq;
487 if(iw + weight(obj) > 0)
488 break;
489 }
490 obj->quan = savequan;
491 qq--;
492 /* we can carry qq of them */
493 if(!qq) goto too_heavy;
494 pline("You can only carry %s of the %s lying here.",
495 (qq == 1) ? "one" : "some",
496 doname(obj));
497 (void) splitobj(obj, qq);
498 /* note: obj2 is set already, so we'll never
499 * encounter the other half; if it should be
500 * otherwise then write
501 * obj2 = splitobj(obj,qq);
502 */
503 goto lift_some;
504 }
505 too_heavy:
506 pline("There %s %s here, but %s.",
507 (obj->quan == 1) ? "is" : "are",
508 doname(obj),
509 !invent ? "it is too heavy for you to lift"
510 : "you cannot carry anymore");
511 break;
512 }
513 lift_some:
514 if(inv_cnt() >= 52) {
515 pline("Your knapsack cannot accommodate anymore items.");
516 break;
517 }
518 if(wt > -5) pline("You have a little trouble lifting");
519 freeobj(obj);
520 if(Invisible(u.uprops[(19 +3)].p_flgs && !u.uprops[4].p_flgs)) newsym(u.ux,u.uy);
521 addtobill(obj); /* sets obj->unpaid if necessary */
522 { int pickquan = obj->quan;
523 int mergquan;
524 if(!Blindu.uprops[(19 +7)].p_flgs) obj->dknown = 1; /* this is done by prinv(),
525 but addinv() needs it already for merging */
526 obj = addinv(obj); /* might merge it with other objects */
527 mergquan = obj->quan;
528 obj->quan = pickquan; /* to fool prinv() */
529 prinv(obj);
530 obj->quan = mergquan;
531 }
532 }
533 }
534}
535
536/* stop running if we see something interesting */
537/* turn around a corner if that is the only way we can proceed */
538/* do not turn left or right twice */
539void
540lookaround(void)
541{
542 int x, y, i, x0, y0, m0, i0 = 9;
543 int corrct = 0, noturn = 0;
544 struct monst *mtmp;
545
546 if (Blindu.uprops[(19 +7)].p_flgs || flags.run == 0) return;
547 if (flags.run == 1 && levl[(int)u.ux][(int)u.uy].typ == ROOM9)
548 return;
549#ifdef QUEST
550 if(u.ux0 == u.ux+u.dx && u.uy0 == u.uy+u.dy) goto stop;
551#endif /* QUEST */
552 for(x = u.ux-1; x <= u.ux+1; x++) for(y = u.uy-1; y <= u.uy+1; y++){
553 if(x == u.ux && y == u.uy) continue;
554 if(!levl[x][y].typ) continue;
555 if((mtmp = m_at(x,y)) && !mtmp->mimic &&
556 (!mtmp->minvis || See_invisibleu.uprops[4].p_flgs)){
557 if(!mtmp->mtame || (x == u.ux+u.dx && y == u.uy+u.dy))
558 goto stop;
559 } else mtmp = 0; /* invisible M cannot influence us */
560 if(x == u.ux-u.dx && y == u.uy-u.dy) continue;
561 switch(levl[x][y].scrsym){
562 case '|':
563 case '-':
564 case '.':
565 case ' ':
566 break;
567 case '+':
568 if(x != u.ux && y != u.uy) break;
569 if(flags.run != 1) goto stop;
570 /* fall into next case */
571 case CORR_SYM'#':
572 corr:
573 if(flags.run == 1 || flags.run == 3) {
574 i = DIST(x,y,u.ux+u.dx,u.uy+u.dy)(((x)-(u.ux+u.dx))*((x)-(u.ux+u.dx)) + ((y)-(u.uy+u.dy))*((y)
-(u.uy+u.dy)));
575 if(i > 2) break;
576 if(corrct == 1 && DIST(x,y,x0,y0)(((x)-(x0))*((x)-(x0)) + ((y)-(y0))*((y)-(y0))) != 1)
577 noturn = 1;
578 if(i < i0) {
579 i0 = i;
580 x0 = x;
581 y0 = y;
582 m0 = mtmp ? 1 : 0;
583 }
584 }
585 corrct++;
586 break;
587 case '^':
588 if(flags.run == 1) goto corr; /* if you must */
589 if(x == u.ux+u.dx && y == u.uy+u.dy) goto stop;
590 break;
591 default: /* e.g. objects or trap or stairs */
592 if(flags.run == 1) goto corr;
593 if(mtmp) break; /* d */
594 stop:
595 nomul(0);
596 return;
597 }
598 }
599#ifdef QUEST
600 if(corrct > 0 && (flags.run == 4 || flags.run == 5)) goto stop;
601#endif /* QUEST */
602 if(corrct > 1 && flags.run == 2) goto stop;
603 if((flags.run == 1 || flags.run == 3) && !noturn && !m0 && i0 &&
604 (corrct == 1 || (corrct == 2 && i0 == 1))) {
605 /* make sure that we do not turn too far */
606 if(i0 == 2) {
607 if(u.dx == y0-u.uy && u.dy == u.ux-x0)
608 i = 2; /* straight turn right */
609 else
610 i = -2; /* straight turn left */
611 } else if(u.dx && u.dy) {
612 if((u.dx == u.dy && y0 == u.uy) ||
613 (u.dx != u.dy && y0 != u.uy))
614 i = -1; /* half turn left */
615 else
616 i = 1; /* half turn right */
617 } else {
618 if((x0-u.ux == y0-u.uy && !u.dy) ||
619 (x0-u.ux != y0-u.uy && u.dy))
620 i = 1; /* half turn right */
621 else
622 i = -1; /* half turn left */
623 }
624 i += u.last_str_turn;
625 if(i <= 2 && i >= -2) {
626 u.last_str_turn = i;
627 u.dx = x0-u.ux, u.dy = y0-u.uy;
628 }
629 }
630}
631
632/* something like lookaround, but we are not running */
633/* react only to monsters that might hit us */
634int
635monster_nearby(void)
636{
637 int x,y;
638 struct monst *mtmp;
639
640 if(!Blindu.uprops[(19 +7)].p_flgs)
641 for(x = u.ux-1; x <= u.ux+1; x++) for(y = u.uy-1; y <= u.uy+1; y++){
642 if(x == u.ux && y == u.uy) continue;
643 if((mtmp = m_at(x,y)) && !mtmp->mimic && !mtmp->mtame &&
644 !mtmp->mpeaceful && !strchr("Ea", mtmp->data->mlet) &&
645 !mtmp->mfroz && !mtmp->msleep && /* aplvax!jcn */
646 (!mtmp->minvis || See_invisibleu.uprops[4].p_flgs))
647 return(1);
648 }
649 return(0);
650}
651
652#ifdef QUEST
653int
654cansee(xchar x, xchar y)
655{
656 int dx,dy,adx,ady,sdx,sdy,dmax,d;
657
658 if(Blindu.uprops[(19 +7)].p_flgs) return(0);
659 if(!isok(x,y)) return(0);
660 d = dist(x,y);
661 if(d < 3) return(1);
662 if(d > u.uhorizon*u.uhorizon) return(0);
663 if(!levl[x][y].lit)
664 return(0);
665 dx = x - u.ux; adx = abs(dx); sdx = sgn(dx);
666 dy = y - u.uy; ady = abs(dy); sdy = sgn(dy);
667 if(dx == 0 || dy == 0 || adx == ady){
668 dmax = (dx == 0) ? ady : adx;
669 for(d = 1; d <= dmax; d++)
670 if(!rroom(sdx*d,sdy*d))
671 return(0);
672 return(1);
673 } else if(ady > adx){
674 for(d = 1; d <= ady; d++){
675 if(!rroom(sdx*( (d*adx)/ady ), sdy*d) ||
676 !rroom(sdx*( (d*adx-1)/ady+1 ), sdy*d))
677 return(0);
678 }
679 return(1);
680 } else {
681 for(d = 1; d <= adx; d++){
682 if(!rroom(sdx*d, sdy*( (d*ady)/adx )) ||
683 !rroom(sdx*d, sdy*( (d*ady-1)/adx+1 )))
684 return(0);
685 }
686 return(1);
687 }
688}
689
690static int
691rroom(int x, int y)
692{
693 return(IS_ROOM(levl[u.ux+x][u.uy+y].typ)((levl[u.ux+x][u.uy+y].typ) >= 9));
694}
695
696#else
697
698int
699cansee(xchar x, xchar y)
700{
701 if (Blindu.uprops[(19 +7)].p_flgs || u.uswallow)
702 return(0);
703 if (dist(x,y) < 3)
704 return(1);
705 if (levl[(int)x][(int)y].lit && seelx <= x && x <= seehx &&
706 seely <= y && y <= seehy)
707 return(1);
708 return(0);
709}
710#endif /* QUEST */
711
712int
713sgn(int a)
714{
715 return((a > 0) ? 1 : (a == 0) ? 0 : -1);
716}
717
718#ifdef QUEST
719void
720setsee(void)
721{
722 int x,y;
723
724 if(Blindu.uprops[(19 +7)].p_flgs) {
725 pru();
726 return;
727 }
728 for(y = u.uy-u.uhorizon; y <= u.uy+u.uhorizon; y++)
729 for(x = u.ux-u.uhorizon; x <= u.ux+u.uhorizon; x++) {
730 if(cansee(x,y))
731 prl(x,y);
732 }
733}
734
735#else
736void
737setsee(void)
738{
739 int x,y;
740
741 if (Blindu.uprops[(19 +7)].p_flgs) {
742 pru();
743 return;
744 }
745 if (!levl[(int)u.ux][(int)u.uy].lit) {
746 seelx = u.ux-1;
747 seehx = u.ux+1;
748 seely = u.uy-1;
749 seehy = u.uy+1;
750 } else {
751 for(seelx = u.ux; levl[seelx-1][(int)u.uy].lit; seelx--);
752 for(seehx = u.ux; levl[seehx+1][(int)u.uy].lit; seehx++);
753 for(seely = u.uy; levl[(int)u.ux][seely-1].lit; seely--);
754 for(seehy = u.uy; levl[(int)u.ux][seehy+1].lit; seehy++);
755 }
756 for (y = seely; y <= seehy; y++)
757 for (x = seelx; x <= seehx; x++) {
758 prl(x,y);
759 }
760 if (!levl[(int)u.ux][(int)u.uy].lit)
761 seehx = 0; /* seems necessary elsewhere */
762 else {
763 if(seely == u.uy) for(x = u.ux-1; x <= u.ux+1; x++) prl(x,seely-1);
764 if(seehy == u.uy) for(x = u.ux-1; x <= u.ux+1; x++) prl(x,seehy+1);
765 if(seelx == u.ux) for(y = u.uy-1; y <= u.uy+1; y++) prl(seelx-1,y);
766 if(seehx == u.ux) for(y = u.uy-1; y <= u.uy+1; y++) prl(seehx+1,y);
767 }
768}
769#endif /* QUEST */
770
771void
772nomul(int nval)
773{
774 if(multi < 0) return;
775 multi = nval;
776 flags.mv = flags.run = 0;
777}
778
779int
780abon(void)
781{
782 if(u.ustr == 3) return(-3);
783 else if(u.ustr < 6) return(-2);
784 else if(u.ustr < 8) return(-1);
785 else if(u.ustr < 17) return(0);
786 else if(u.ustr < 69) return(1); /* up to 18/50 */
787 else if(u.ustr < 118) return(2);
788 else return(3);
789}
790
791int
792dbon(void)
793{
794 if(u.ustr < 6) return(-1);
795 else if(u.ustr < 16) return(0);
796 else if(u.ustr < 18) return(1);
797 else if(u.ustr == 18) return(2); /* up to 18 */
798 else if(u.ustr < 94) return(3); /* up to 18/75 */
799 else if(u.ustr < 109) return(4); /* up to 18/90 */
800 else if(u.ustr < 118) return(5); /* up to 18/99 */
801 else return(6);
802}
803
804void
805losestr(int num) /* may kill you; cause may be poison or monster like 'A' */
806{
807 u.ustr -= num;
808 while(u.ustr < 3) {
809 u.ustr++;
810 u.uhp -= 6;
811 u.uhpmax -= 6;
812 }
813 flags.botl = 1;
814}
815
816void
817losehp(int n, char *knam)
818{
819 u.uhp -= n;
820 if(u.uhp > u.uhpmax)
821 u.uhpmax = u.uhp; /* perhaps n was negative */
822 flags.botl = 1;
823 if(u.uhp < 1) {
824 killer = knam; /* the thing that killed you */
825 done("died");
826 }
827}
828
829void
830losehp_m(int n, struct monst *mtmp)
831{
832 u.uhp -= n;
833 flags.botl = 1;
834 if(u.uhp < 1)
835 done_in_by(mtmp);
836}
837
838/* hit by V or W */
839void
840losexp(void)
841{
842 int num;
843
844 if(u.ulevel > 1)
845 pline("Goodbye level %u.", u.ulevel--);
846 else
847 u.uhp = -1;
848 num = rnd(10);
849 u.uhp -= num;
850 u.uhpmax -= num;
851 u.uexp = newuexp();
852 flags.botl = 1;
853}
854
855int
856inv_weight(void)
857{
858 struct obj *otmp = invent;
859 int wt = (u.ugold + 500)/1000;
860 int carrcap;
861
862 if(Levitationu.uprops[6].p_flgs) /* pugh@cornell */
863 carrcap = MAX_CARR_CAP120;
864 else {
865 carrcap = 5*(((u.ustr > 18) ? 20 : u.ustr) + u.ulevel);
866 if(carrcap > MAX_CARR_CAP120) carrcap = MAX_CARR_CAP120;
867 if(Wounded_legsu.uprops[(19 +8)].p_flgs & LEFT_SIDE010000L) carrcap -= 10;
868 if(Wounded_legsu.uprops[(19 +8)].p_flgs & RIGHT_SIDE020000L) carrcap -= 10;
869 }
870 while(otmp){
871 wt += otmp->owt;
872 otmp = otmp->nobj;
873 }
874 return(wt - carrcap);
875}
876
877static int
878inv_cnt(void)
879{
880 struct obj *otmp = invent;
881 int ct = 0;
882
883 while(otmp){
884 ct++;
885 otmp = otmp->nobj;
886 }
887 return(ct);
888}
889
890long
891newuexp(void)
892{
893 return(10*(1L << (u.ulevel-1)));
894}