1 /* $NetBSD: hack.pri.c,v 1.9 2008/01/28 06:55:42 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 <sys/cdefs.h> 65 #ifndef lint 66 __RCSID("$NetBSD: hack.pri.c,v 1.9 2008/01/28 06:55:42 dholland Exp $"); 67 #endif /* not lint */ 68 69 #include "hack.h" 70 #include "extern.h" 71 xchar scrlx, scrhx, scrly, scrhy; /* corners of new area on 72 * screen */ 73 74 void 75 swallowed() 76 { 77 char ulook[] = "|@|"; 78 ulook[1] = u.usym; 79 80 cls(); 81 curs(u.ux - 1, u.uy + 1); 82 fputs("/-\\", stdout); 83 curx = u.ux + 2; 84 curs(u.ux - 1, u.uy + 2); 85 fputs(ulook, stdout); 86 curx = u.ux + 2; 87 curs(u.ux - 1, u.uy + 3); 88 fputs("\\-/", stdout); 89 curx = u.ux + 2; 90 u.udispl = 1; 91 u.udisx = u.ux; 92 u.udisy = u.uy; 93 } 94 95 96 /* VARARGS1 */ 97 boolean panicking; 98 99 void 100 panic(const char *fmt, ...) 101 { 102 va_list ap; 103 104 va_start(ap, fmt); 105 if (panicking++) 106 exit(1); /* avoid loops - this should never happen */ 107 home(); 108 puts(" Suddenly, the dungeon collapses."); 109 fputs(" ERROR: ", stdout); 110 vprintf(fmt, ap); 111 va_end(ap); 112 #ifdef DEBUG 113 #ifdef UNIX 114 if (!fork()) 115 abort(); /* generate core dump */ 116 #endif /* UNIX */ 117 #endif /* DEBUG */ 118 more(); /* contains a fflush() */ 119 done("panicked"); 120 } 121 122 void 123 atl(x, y, ch) 124 int x, y, ch; 125 { 126 struct rm *crm = &levl[x][y]; 127 128 if (x < 0 || x > COLNO - 1 || y < 0 || y > ROWNO - 1) { 129 impossible("atl(%d,%d,%c)", x, y, ch); 130 return; 131 } 132 if (crm->seen && crm->scrsym == ch) 133 return; 134 crm->scrsym = ch; 135 crm->new = 1; 136 on_scr(x, y); 137 } 138 139 void 140 on_scr(x, y) 141 int x, y; 142 { 143 if (x < scrlx) 144 scrlx = x; 145 if (x > scrhx) 146 scrhx = x; 147 if (y < scrly) 148 scrly = y; 149 if (y > scrhy) 150 scrhy = y; 151 } 152 153 /* 154 * call: (x,y) - display (-1,0) - close (leave last symbol) (-1,-1)- close 155 * (undo last symbol) (-1,let)-open: initialize symbol (-2,let)-change let 156 */ 157 158 void 159 tmp_at(x, y) 160 schar x, y; 161 { 162 static schar prevx, prevy; 163 static char let; 164 if ((int) x == -2) { /* change let call */ 165 let = y; 166 return; 167 } 168 if ((int) x == -1 && (int) y >= 0) { /* open or close call */ 169 let = y; 170 prevx = -1; 171 return; 172 } 173 if (prevx >= 0 && cansee(prevx, prevy)) { 174 delay_output(); 175 prl(prevx, prevy); /* in case there was a monster */ 176 at(prevx, prevy, levl[prevx][prevy].scrsym); 177 } 178 if (x >= 0) { /* normal call */ 179 if (cansee(x, y)) 180 at(x, y, let); 181 prevx = x; 182 prevy = y; 183 } else { /* close call */ 184 let = 0; 185 prevx = -1; 186 } 187 } 188 189 /* like the previous, but the symbols are first erased on completion */ 190 void 191 Tmp_at(x, y) 192 schar x, y; 193 { 194 static char let; 195 static xchar cnt; 196 static coord tc[COLNO]; /* but watch reflecting beams! */ 197 int xx, yy; 198 if ((int) x == -1) { 199 if (y > 0) { /* open call */ 200 let = y; 201 cnt = 0; 202 return; 203 } 204 /* close call (do not distinguish y==0 and y==-1) */ 205 while (cnt--) { 206 xx = tc[cnt].x; 207 yy = tc[cnt].y; 208 prl(xx, yy); 209 at(xx, yy, levl[xx][yy].scrsym); 210 } 211 cnt = let = 0; /* superfluous */ 212 return; 213 } 214 if ((int) x == -2) { /* change let call */ 215 let = y; 216 return; 217 } 218 /* normal call */ 219 if (cansee(x, y)) { 220 if (cnt) 221 delay_output(); 222 at(x, y, let); 223 tc[cnt].x = x; 224 tc[cnt].y = y; 225 if (++cnt >= COLNO) 226 panic("Tmp_at overflow?"); 227 levl[x][y].new = 0; /* prevent pline-nscr erasing --- */ 228 } 229 } 230 231 void 232 setclipped() 233 { 234 error("Hack needs a screen of size at least %d by %d.\n", 235 ROWNO + 2, COLNO); 236 } 237 238 void 239 at(x, y, ch) 240 xchar x, y; 241 char ch; 242 { 243 #ifndef lint 244 /* if xchar is unsigned, lint will complain about if(x < 0) */ 245 if (x < 0 || x > COLNO - 1 || y < 0 || y > ROWNO - 1) { 246 impossible("At gets 0%o at %d %d.", ch, x, y); 247 return; 248 } 249 #endif /* lint */ 250 if (!ch) { 251 impossible("At gets null at %d %d.", x, y); 252 return; 253 } 254 y += 2; 255 curs(x, y); 256 (void) putchar(ch); 257 curx++; 258 } 259 260 void 261 prme() 262 { 263 if (!Invisible) 264 at(u.ux, u.uy, u.usym); 265 } 266 267 int 268 doredraw() 269 { 270 docrt(); 271 return (0); 272 } 273 274 void 275 docrt() 276 { 277 int x, y; 278 struct rm *room; 279 struct monst *mtmp; 280 281 if (u.uswallow) { 282 swallowed(); 283 return; 284 } 285 cls(); 286 287 /* 288 * Some ridiculous code to get display of @ and monsters (almost) 289 * right 290 */ 291 if (!Invisible) { 292 levl[(u.udisx = u.ux)][(u.udisy = u.uy)].scrsym = u.usym; 293 levl[u.udisx][u.udisy].seen = 1; 294 u.udispl = 1; 295 } else 296 u.udispl = 0; 297 298 seemons(); /* reset old positions */ 299 for (mtmp = fmon; mtmp; mtmp = mtmp->nmon) 300 mtmp->mdispl = 0; 301 seemons(); /* force new positions to be shown */ 302 /* 303 * This nonsense should disappear soon 304 * --------------------------------- 305 */ 306 307 for (y = 0; y < ROWNO; y++) 308 for (x = 0; x < COLNO; x++) 309 if ((room = &levl[x][y])->new) { 310 room->new = 0; 311 at(x, y, room->scrsym); 312 } else if (room->seen) 313 at(x, y, room->scrsym); 314 scrlx = COLNO; 315 scrly = ROWNO; 316 scrhx = scrhy = 0; 317 flags.botlx = 1; 318 bot(); 319 } 320 321 void 322 docorner(xmin, ymax) 323 int xmin, ymax; 324 { 325 int x, y; 326 struct rm *room; 327 struct monst *mtmp; 328 329 if (u.uswallow) { /* Can be done more efficiently */ 330 swallowed(); 331 return; 332 } 333 seemons(); /* reset old positions */ 334 for (mtmp = fmon; mtmp; mtmp = mtmp->nmon) 335 if (mtmp->mx >= xmin && mtmp->my < ymax) 336 mtmp->mdispl = 0; 337 seemons(); /* force new positions to be shown */ 338 339 for (y = 0; y < ymax; y++) { 340 if (y > ROWNO && CD) 341 break; 342 curs(xmin, y + 2); 343 cl_end(); 344 if (y < ROWNO) { 345 for (x = xmin; x < COLNO; x++) { 346 if ((room = &levl[x][y])->new) { 347 room->new = 0; 348 at(x, y, room->scrsym); 349 } else if (room->seen) 350 at(x, y, room->scrsym); 351 } 352 } 353 } 354 if (ymax > ROWNO) { 355 cornbot(xmin - 1); 356 if (ymax > ROWNO + 1 && CD) { 357 curs(1, ROWNO + 3); 358 cl_eos(); 359 } 360 } 361 } 362 363 void 364 curs_on_u() 365 { 366 curs(u.ux, u.uy + 2); 367 } 368 369 void 370 pru() 371 { 372 if (u.udispl && (Invisible || u.udisx != u.ux || u.udisy != u.uy)) 373 /* if(! levl[u.udisx][u.udisy].new) */ 374 if (!vism_at(u.udisx, u.udisy)) 375 newsym(u.udisx, u.udisy); 376 if (Invisible) { 377 u.udispl = 0; 378 prl(u.ux, u.uy); 379 } else if (!u.udispl || u.udisx != u.ux || u.udisy != u.uy) { 380 atl(u.ux, u.uy, u.usym); 381 u.udispl = 1; 382 u.udisx = u.ux; 383 u.udisy = u.uy; 384 } 385 levl[u.ux][u.uy].seen = 1; 386 } 387 388 #ifndef NOWORM 389 #include "def.wseg.h" 390 #endif /* NOWORM */ 391 392 /* print a position that is visible for @ */ 393 void 394 prl(int x, int y) 395 { 396 struct rm *room; 397 struct monst *mtmp; 398 struct obj *otmp; 399 400 if (x == u.ux && y == u.uy && (!Invisible)) { 401 pru(); 402 return; 403 } 404 if (!isok(x, y)) 405 return; 406 room = &levl[x][y]; 407 if ((!room->typ) || 408 (IS_ROCK(room->typ) && levl[u.ux][u.uy].typ == CORR)) 409 return; 410 if ((mtmp = m_at(x, y)) && !mtmp->mhide && 411 (!mtmp->minvis || See_invisible)) { 412 #ifndef NOWORM 413 if (m_atseg) 414 pwseg(m_atseg); 415 else 416 #endif /* NOWORM */ 417 pmon(mtmp); 418 } else if ((otmp = o_at(x, y)) && room->typ != POOL) 419 atl(x, y, otmp->olet); 420 else if (mtmp && (!mtmp->minvis || See_invisible)) { 421 /* must be a hiding monster, but not hiding right now */ 422 /* assume for the moment that long worms do not hide */ 423 pmon(mtmp); 424 } else if (g_at(x, y) && room->typ != POOL) 425 atl(x, y, '$'); 426 else if (!room->seen || room->scrsym == ' ') { 427 room->new = room->seen = 1; 428 newsym(x, y); 429 on_scr(x, y); 430 } 431 room->seen = 1; 432 } 433 434 char 435 news0(x, y) 436 xchar x, y; 437 { 438 struct obj *otmp; 439 struct trap *ttmp; 440 struct rm *room; 441 char tmp; 442 443 room = &levl[x][y]; 444 if (!room->seen) 445 tmp = ' '; 446 else if (room->typ == POOL) 447 tmp = POOL_SYM; 448 else if (!Blind && (otmp = o_at(x, y))) 449 tmp = otmp->olet; 450 else if (!Blind && g_at(x, y)) 451 tmp = '$'; 452 else if (x == xupstair && y == yupstair) 453 tmp = '<'; 454 else if (x == xdnstair && y == ydnstair) 455 tmp = '>'; 456 else if ((ttmp = t_at(x, y)) && ttmp->tseen) 457 tmp = '^'; 458 else 459 switch (room->typ) { 460 case SCORR: 461 case SDOOR: 462 tmp = room->scrsym; /* %% wrong after killing 463 * mimic ! */ 464 break; 465 case HWALL: 466 tmp = '-'; 467 break; 468 case VWALL: 469 tmp = '|'; 470 break; 471 case LDOOR: 472 case DOOR: 473 tmp = '+'; 474 break; 475 case CORR: 476 tmp = CORR_SYM; 477 break; 478 case ROOM: 479 if (room->lit || cansee(x, y) || Blind) 480 tmp = '.'; 481 else 482 tmp = ' '; 483 break; 484 /* 485 case POOL: 486 tmp = POOL_SYM; 487 break; 488 */ 489 default: 490 tmp = ERRCHAR; 491 } 492 return (tmp); 493 } 494 495 void 496 newsym(x, y) 497 int x, y; 498 { 499 atl(x, y, news0(x, y)); 500 } 501 502 /* used with wand of digging (or pick-axe): fill scrsym and force display */ 503 /* also when a POOL evaporates */ 504 void 505 mnewsym(x, y) 506 int x, y; 507 { 508 struct rm *room; 509 char newscrsym; 510 511 if (!vism_at(x, y)) { 512 room = &levl[x][y]; 513 newscrsym = news0(x, y); 514 if (room->scrsym != newscrsym) { 515 room->scrsym = newscrsym; 516 room->seen = 0; 517 } 518 } 519 } 520 521 void 522 nosee(x, y) 523 int x, y; 524 { 525 struct rm *room; 526 527 if (!isok(x, y)) 528 return; 529 room = &levl[x][y]; 530 if (room->scrsym == '.' && !room->lit && !Blind) { 531 room->scrsym = ' '; 532 room->new = 1; 533 on_scr(x, y); 534 } 535 } 536 537 #ifndef QUEST 538 void 539 prl1(x, y) 540 int x, y; 541 { 542 if (u.dx) { 543 if (u.dy) { 544 prl(x - (2 * u.dx), y); 545 prl(x - u.dx, y); 546 prl(x, y); 547 prl(x, y - u.dy); 548 prl(x, y - (2 * u.dy)); 549 } else { 550 prl(x, y - 1); 551 prl(x, y); 552 prl(x, y + 1); 553 } 554 } else { 555 prl(x - 1, y); 556 prl(x, y); 557 prl(x + 1, y); 558 } 559 } 560 561 void 562 nose1(x, y) 563 int x, y; 564 { 565 if (u.dx) { 566 if (u.dy) { 567 nosee(x, u.uy); 568 nosee(x, u.uy - u.dy); 569 nosee(x, y); 570 nosee(u.ux - u.dx, y); 571 nosee(u.ux, y); 572 } else { 573 nosee(x, y - 1); 574 nosee(x, y); 575 nosee(x, y + 1); 576 } 577 } else { 578 nosee(x - 1, y); 579 nosee(x, y); 580 nosee(x + 1, y); 581 } 582 } 583 #endif /* QUEST */ 584 585 int 586 vism_at(x, y) 587 int x, y; 588 { 589 struct monst *mtmp; 590 591 return ((x == u.ux && y == u.uy && !Invisible) 592 ? 1 : 593 (mtmp = m_at(x, y)) 594 ? ((Blind && Telepat) || canseemon(mtmp)) : 595 0); 596 } 597 598 #ifdef NEWSCR 599 void 600 pobj(obj) 601 struct obj *obj; 602 { 603 int show = (!obj->oinvis || See_invisible) && 604 cansee(obj->ox, obj->oy); 605 if (obj->odispl) { 606 if (obj->odx != obj->ox || obj->ody != obj->oy || !show) 607 if (!vism_at(obj->odx, obj->ody)) { 608 newsym(obj->odx, obj->ody); 609 obj->odispl = 0; 610 } 611 } 612 if (show && !vism_at(obj->ox, obj->oy)) { 613 atl(obj->ox, obj->oy, obj->olet); 614 obj->odispl = 1; 615 obj->odx = obj->ox; 616 obj->ody = obj->oy; 617 } 618 } 619 #endif /* NEWSCR */ 620 621 void 622 unpobj(obj) 623 struct obj *obj; 624 { 625 /* 626 * if(obj->odispl){ if(!vism_at(obj->odx, obj->ody)) newsym(obj->odx, 627 * obj->ody); obj->odispl = 0; } 628 */ 629 if (!vism_at(obj->ox, obj->oy)) 630 newsym(obj->ox, obj->oy); 631 } 632 633 void 634 seeobjs() 635 { 636 struct obj *obj, *obj2; 637 for (obj = fobj; obj; obj = obj2) { 638 obj2 = obj->nobj; 639 if (obj->olet == FOOD_SYM && obj->otyp >= CORPSE 640 && obj->age + 250 < moves) 641 delobj(obj); 642 } 643 for (obj = invent; obj; obj = obj2) { 644 obj2 = obj->nobj; 645 if (obj->olet == FOOD_SYM && obj->otyp >= CORPSE 646 && obj->age + 250 < moves) 647 useup(obj); 648 } 649 } 650 651 void 652 seemons() 653 { 654 struct monst *mtmp; 655 for (mtmp = fmon; mtmp; mtmp = mtmp->nmon) { 656 if (mtmp->data->mlet == ';') 657 mtmp->minvis = (u.ustuck != mtmp && 658 levl[mtmp->mx][mtmp->my].typ == POOL); 659 pmon(mtmp); 660 #ifndef NOWORM 661 if (mtmp->wormno) 662 wormsee(mtmp->wormno); 663 #endif /* NOWORM */ 664 } 665 } 666 667 void 668 pmon(mon) 669 struct monst *mon; 670 { 671 int show = (Blind && Telepat) || canseemon(mon); 672 if (mon->mdispl) { 673 if (mon->mdx != mon->mx || mon->mdy != mon->my || !show) 674 unpmon(mon); 675 } 676 if (show && !mon->mdispl) { 677 atl(mon->mx, mon->my, 678 (!mon->mappearance 679 || u.uprops[PROP(RIN_PROTECTION_FROM_SHAPE_CHANGERS)].p_flgs 680 ) ? mon->data->mlet : mon->mappearance); 681 mon->mdispl = 1; 682 mon->mdx = mon->mx; 683 mon->mdy = mon->my; 684 } 685 } 686 687 void 688 unpmon(mon) 689 struct monst *mon; 690 { 691 if (mon->mdispl) { 692 newsym(mon->mdx, mon->mdy); 693 mon->mdispl = 0; 694 } 695 } 696 697 void 698 nscr() 699 { 700 int x, y; 701 struct rm *room; 702 703 if (u.uswallow || u.ux == FAR || flags.nscrinh) 704 return; 705 pru(); 706 for (y = scrly; y <= scrhy; y++) 707 for (x = scrlx; x <= scrhx; x++) 708 if ((room = &levl[x][y])->new) { 709 room->new = 0; 710 at(x, y, room->scrsym); 711 } 712 scrhx = scrhy = 0; 713 scrlx = COLNO; 714 scrly = ROWNO; 715 } 716 717 /* 100 suffices for bot(); no relation with COLNO */ 718 char oldbot[100], newbot[100]; 719 void 720 cornbot(lth) 721 int lth; 722 { 723 if ((unsigned)lth < sizeof(oldbot)) { 724 oldbot[lth] = 0; 725 flags.botl = 1; 726 } 727 } 728 729 void 730 bot() 731 { 732 char *ob = oldbot, *nb = newbot; 733 int i; 734 if (flags.botlx) 735 *ob = 0; 736 flags.botl = flags.botlx = 0; 737 #ifdef GOLD_ON_BOTL 738 (void) sprintf(newbot, 739 "Level %-2d Gold %-5lu Hp %3d(%d) Ac %-2d Str ", 740 dlevel, u.ugold, u.uhp, u.uhpmax, u.uac); 741 #else 742 (void) sprintf(newbot, 743 "Level %-2d Hp %3d(%d) Ac %-2d Str ", 744 dlevel, u.uhp, u.uhpmax, u.uac); 745 #endif /* GOLD_ON_BOTL */ 746 if (u.ustr > 18) { 747 if (u.ustr > 117) 748 (void) strcat(newbot, "18/**"); 749 else 750 (void) sprintf(eos(newbot), "18/%02d", u.ustr - 18); 751 } else 752 (void) sprintf(eos(newbot), "%-2d ", u.ustr); 753 #ifdef EXP_ON_BOTL 754 (void) sprintf(eos(newbot), " Exp %2d/%-5lu ", u.ulevel, u.uexp); 755 #else 756 (void) sprintf(eos(newbot), " Exp %2u ", u.ulevel); 757 #endif /* EXP_ON_BOTL */ 758 (void) strcat(newbot, hu_stat[u.uhs]); 759 if (flags.time) 760 (void) sprintf(eos(newbot), " %ld", moves); 761 if (strlen(newbot) >= COLNO) { 762 char *bp0, *bp1; 763 bp0 = bp1 = newbot; 764 do { 765 if (*bp0 != ' ' || bp0[1] != ' ' || bp0[2] != ' ') 766 *bp1++ = *bp0; 767 } while (*bp0++); 768 } 769 for (i = 1; i < COLNO; i++) { 770 if (*ob != *nb) { 771 curs(i, ROWNO + 2); 772 (void) putchar(*nb ? *nb : ' '); 773 curx++; 774 } 775 if (*ob) 776 ob++; 777 if (*nb) 778 nb++; 779 } 780 (void) strcpy(oldbot, newbot); 781 } 782 783 #ifdef WAN_PROBING 784 void 785 mstatusline(mtmp) 786 struct monst *mtmp; 787 { 788 pline("Status of %s: ", monnam(mtmp)); 789 pline("Level %-2d Gold %-5lu Hp %3d(%d) Ac %-2d Dam %d", 790 mtmp->data->mlevel, mtmp->mgold, mtmp->mhp, mtmp->mhpmax, 791 mtmp->data->ac, (mtmp->data->damn + 1) * (mtmp->data->damd + 1)); 792 } 793 #endif /* WAN_PROBING */ 794 795 void 796 cls() 797 { 798 if (flags.toplin == 1) 799 more(); 800 flags.toplin = 0; 801 802 clear_screen(); 803 804 flags.botlx = 1; 805 } 806