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