2.11BSD#431 - /usr/src/games/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: }

Defined functions

Defined variables