hack/hack.pri.c

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