hack/hack.pri.c

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