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 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 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 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 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 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 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 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 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 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 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 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 756 sgn(int a) 757 { 758 return ((a > 0) ? 1 : (a == 0) ? 0 : -1); 759 } 760 761 #ifdef QUEST 762 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 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 824 nomul(int nval) 825 { 826 if (multi < 0) 827 return; 828 multi = nval; 829 flags.mv = flags.run = 0; 830 } 831 832 int 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 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 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 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 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 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 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 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 961 newuexp(void) 962 { 963 return (10 * (1L << (u.ulevel - 1))); 964 } 965