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