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