hack/hack.pri.c

   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 }