hack/hack.pri.c

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