games/hack/hack.pri.c

   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 }