home *** CD-ROM | disk | FTP | other *** search
/ Gold Fish 1 / GoldFishApril1994_CD1.img / d1xx / d190 / nethack / een.zoo / pri.c < prev    next >
C/C++ Source or Header  |  1988-07-24  |  14KB  |  610 lines
  1. /*    SCCS Id: @(#)pri.c      2.3     87/12/12
  2. /* Copyright (c) Stichting Mathematisch Centrum, Amsterdam, 1985. */
  3.  
  4. #include <stdio.h>
  5. #include "hack.h"
  6. #ifdef GENIX
  7. #define void    int    /* jhn - mod to prevent compiler from bombing */
  8. #endif
  9. #ifdef MSDOSCOLOR
  10. extern int hilite();
  11. #endif
  12.  
  13. xchar scrlx, scrhx, scrly, scrhy;    /* corners of new area on screen */
  14.  
  15. extern char *hu_stat[]; /* in eat.c */
  16. extern char *CD;
  17. extern struct monst *makemon();
  18.  
  19. swallowed()
  20. {
  21.     static char ulook[] = "|@|";   /*OIS*/
  22.     ulook[1] = u.usym;
  23.  
  24.     cls();
  25.     curs(u.ux-1, u.uy+1);
  26. #ifdef stdout_puts    /* Defined when not via normal files */
  27.     stdout_puts("/-\\");       /* OIS, for AMIGA */
  28. #else
  29.     fputs("/-\\", stdout);
  30. #endif
  31.     curx = u.ux+2;
  32.     curs(u.ux-1, u.uy+2);
  33. #ifdef stdout_puts
  34.     stdout_puts(ulook);        /* for AMIGA */
  35. #else
  36.     fputs(ulook, stdout);
  37. #endif
  38.     curx = u.ux+2;
  39.     curs(u.ux-1, u.uy+3);
  40. #ifdef stdout_puts
  41.     stdout_puts("\\-/");       /* for AMIGA */
  42. #else
  43.     fputs("\\-/", stdout);
  44. #endif
  45.     curx = u.ux+2;
  46.     u.udispl = 1;
  47.     u.udisx = u.ux;
  48.     u.udisy = u.uy;
  49. }
  50.  
  51. setclipped(){
  52.     error("Hack needs a screen of size at least %d by %d.\n",
  53.         ROWNO+2, COLNO);
  54. }
  55.  
  56. #ifdef DGK
  57. static int multipleAts;     /* TRUE if we have many at()'s to do */
  58. static int DECgraphics;     /* The graphics mode toggle */
  59.  
  60. #define DECgraphicsON() ((void) putchar('\16'), DECgraphics = TRUE)
  61. #define DECgraphicsOFF() ((void) putchar('\17'), DECgraphics = FALSE)
  62. #endif
  63.  
  64. at(x,y,ch)
  65. register xchar x,y;
  66. char ch;
  67. {
  68. #ifndef LINT
  69.     /* if xchar is unsigned, lint will complain about  if(x < 0)  */
  70.     if(x < 0 || x > COLNO-1 || y < 0 || y > ROWNO-1) {
  71.         impossible("At gets 0%o at %d %d.", ch, x, y);
  72.         return;
  73.     }
  74. #endif
  75.     if(!ch) {
  76.         impossible("At gets null at %d %d.", x, y);
  77.         return;
  78.     }
  79.     y += 2;
  80.     curs(x,y);
  81. #ifdef DGK
  82.     if (flags.DECRainbow) {
  83.         /* If there are going to be many at()s in a row without
  84.          * intervention, only change the graphics mode when the
  85.          * character changes between graphic and regular.
  86.          */
  87.         if (multipleAts) {
  88.             if (ch & 0x80) {
  89.                 if (!DECgraphics)
  90.                     DECgraphicsON();
  91.                 (void) putchar(ch ^ 0x80); /* Strip 8th bit */
  92.             } else {
  93.                 if (DECgraphics)
  94.                     DECgraphicsOFF();
  95.                 (void) putchar(ch);
  96.             }
  97.         /* Otherwise, we don't know how many at()s will be happening
  98.          * before printing of normal strings, so change to graphics
  99.          * mode when necessary, then change right back.
  100.          */
  101.         } else {
  102.             if (ch & 0x80) {
  103.                 DECgraphicsON();
  104.                 (void) putchar(ch ^ 0x80); /* Strip 8th bit */
  105.                 DECgraphicsOFF();
  106.             } else
  107.                 (void) putchar(ch);
  108.         }
  109.     } else
  110. #endif
  111. #ifdef MSDOSCOLOR
  112.         hilite(ch);
  113. #else
  114.         (void) putchar(ch);
  115. #endif
  116.     curx++;
  117. }
  118.  
  119. prme(){
  120.     if(!Invisible) at(u.ux,u.uy,u.usym);
  121. }
  122.  
  123. doredraw()
  124. {
  125.     docrt();
  126.     return(0);
  127. }
  128.  
  129. docrt()
  130. {
  131.     register x,y;
  132.     register struct rm *room;
  133.     register struct monst *mtmp;
  134.  
  135.     if(u.uswallow) {
  136.         swallowed();
  137.         return;
  138.     }
  139.     cls();
  140.  
  141. /* Some ridiculous code to get display of @ and monsters (almost) right */
  142.     if(!Invisible) {
  143.         levl[(u.udisx = u.ux)][(u.udisy = u.uy)].scrsym = u.usym;
  144.         RM_SET_SEEN(levl[u.udisx][u.udisy]);
  145.         u.udispl = 1;
  146.     } else    u.udispl = 0;
  147.  
  148.     seemons();      /* reset old positions */
  149.     for(mtmp = fmon; mtmp; mtmp = mtmp->nmon)
  150.         mtmp->mdispl = 0;
  151.     seemons();      /* force new positions to be shown */
  152. /* This nonsense should disappear soon --------------------------------- */
  153.  
  154. /* #if defined(DGK) && !defined(MSDOSCOLOR) */
  155. #ifdef DGK
  156. # define XXX
  157. #endif
  158. #ifdef MSDOSCOLOR
  159. # undef XXX
  160. #endif
  161. #ifdef XXX
  162.     /* I don't know DEC Rainbows, but if HILITE_COLOR is applicable,
  163.      * the !defined(HILITE_COLOR) will have to be compensated for.
  164.      * -kjs */
  165.     /* For DEC Rainbows, we must translate each character to strip
  166.      * out the 8th bit if necessary.
  167.      */
  168.     if (flags.DECRainbow) {
  169.         multipleAts = TRUE;
  170.         for(y = 0; y < ROWNO; y++)
  171.             for(x = 0; x < COLNO; x++)
  172.                 if((room = &levl[x][y]), RM_NEW(*room)) {
  173.                     RM_CLR_NEW(*room);
  174.                     at(x,y,room->scrsym);
  175.                 } else if(RM_SEEN(*room))
  176.                     at(x,y,room->scrsym);
  177.         multipleAts = FALSE;
  178.         if (DECgraphics)
  179.             DECgraphicsOFF();
  180.     } else {
  181.     /* Otherwise, line buffer the output to do the redraw in
  182.      * about 2/3 of the time.
  183.      */
  184.         for(y = 0; y < ROWNO; y++) {
  185.             char buf[COLNO+1];
  186.             int start, end;
  187.  
  188.             memset(buf, ' ', COLNO);
  189.             for(x = 0, start = -1, end = -1; x < COLNO; x++)
  190.                 if((room = &levl[x][y]), RM_NEW(*room)) {
  191.                     RM_CLR_NEW(*room);
  192.                     buf[x] = room->scrsym;
  193.                     if (start < 0)
  194.                         start = x;
  195.                     end = x;
  196.                 } else if(RM_SEEN(*room)) {
  197.                     buf[x] = room->scrsym;
  198.                     if (start < 0)
  199.                         start = x;
  200.                     end = x;
  201.                 }
  202.             if (end >= 0) {
  203.                 buf[end + 1] = '\0';
  204.                 curs(start, y + 2);
  205. #ifdef stdout_puts
  206.                 stdout_puts(buf + start);
  207. #else
  208.                 fputs(buf + start, stdout);
  209. #endif
  210.                 curx = end + 1;
  211.             }
  212.         }
  213.     }
  214. #else
  215.     for(y = 0; y < ROWNO; y++)
  216.         for(x = 0; x < COLNO; x++)
  217.             if((room = &levl[x][y]), RM_NEW(*room)) {
  218.                 RM_CLR_NEW(*room);
  219.                 at(x,y,room->scrsym);
  220.             } else if (RM_SEEN(*room))
  221.                 at(x,y,room->scrsym);
  222. #endif
  223. #undef XXX
  224.     scrlx = COLNO;
  225.     scrly = ROWNO;
  226.     scrhx = scrhy = 0;
  227.     flags.botlx = 1;
  228.     bot();
  229. }
  230.  
  231. docorner(xmin,ymax) register xmin,ymax; {
  232.     register x,y;
  233.     register struct rm *room;
  234.     register struct monst *mtmp;
  235.  
  236.     if(u.uswallow) {        /* Can be done more efficiently */
  237.         swallowed();
  238.         return;
  239.     }
  240.  
  241.     seemons();      /* reset old positions */
  242.     for(mtmp = fmon; mtmp; mtmp = mtmp->nmon)
  243.         if(mtmp->mx >= xmin && mtmp->my < ymax)
  244.         mtmp->mdispl = 0;
  245.     seemons();      /* force new positions to be shown */
  246.  
  247. #ifdef DGK
  248.     if (flags.DECRainbow)
  249.         multipleAts = TRUE;
  250. #endif
  251.     for(y = 0; y < ymax; y++) {
  252.         if(y > ROWNO && CD) break;
  253.         curs(xmin,y+2);
  254.         cl_end();
  255.         if(y < ROWNO) {
  256.             for(x = xmin; x < COLNO; x++) {
  257.             if((room = &levl[x][y]), RM_NEW(*room)) {
  258.                 RM_CLR_NEW(*room);
  259.                 at(x,y,room->scrsym);
  260.             } else
  261.                 if (RM_SEEN(*room))
  262.                     at(x,y,room->scrsym);
  263.             }
  264.         }
  265.     }
  266. #ifdef DGK
  267.     if (flags.DECRainbow) {
  268.         multipleAts = FALSE;
  269.         if (DECgraphics)
  270.             DECgraphicsOFF();
  271.     }
  272. #endif
  273.     if(ymax > ROWNO) {
  274.         cornbot(xmin-1);
  275.         if(ymax > ROWNO+1 && CD) {
  276.             curs(1,ROWNO+3);
  277.             cl_eos();
  278.         }
  279.     }
  280. }
  281.  
  282. /* Trolls now regenerate thanks to KAA */
  283.  
  284. seeobjs(){
  285. register struct obj *obj, *obj2;
  286.     for(obj = fobj; obj; obj = obj2) {
  287.         obj2 = obj->nobj;
  288.         if(obj->olet == FOOD_SYM && obj->otyp >= CORPSE) {
  289.  
  290.         if (obj->otyp == DEAD_TROLL && obj->age + 20 < moves) {
  291.             delobj(obj);
  292.             if (cansee(obj->ox, obj->oy))
  293.                 pline("The troll rises from the dead!");
  294.             (void) makemon(PM_TROLL,obj->ox, obj->oy);
  295.         } else if (obj->age + 250 < moves) delobj(obj);
  296.         }
  297.     }
  298.  
  299.     for(obj = invent; obj; obj = obj2) {
  300.         obj2 = obj->nobj;
  301.         if(obj->olet == FOOD_SYM && obj->otyp >= CORPSE) {
  302.  
  303.         if (obj->otyp == DEAD_TROLL && obj->age + 20 < moves) {
  304.             if (obj == uwep)
  305.             pline("The dead troll writhes out of your grasp!");
  306.             else
  307.             pline("You feel squirming in your backpack!");
  308.             (void)makemon(PM_TROLL,u.ux,u.uy);
  309.             useup(obj);
  310.         } else if (obj->age + 250 < moves) useup(obj);
  311.         }
  312.     }
  313. }
  314.  
  315. seemons(){
  316. register struct monst *mtmp;
  317.     for(mtmp = fmon; mtmp; mtmp = mtmp->nmon){
  318.         if(mtmp->data->mlet == ';')
  319.             mtmp->minvis = (u.ustuck != mtmp &&
  320.                     RM_TYP(levl[mtmp->mx][mtmp->my]) == POOL);
  321.         pmon(mtmp);
  322. #ifndef NOWORM
  323.         if(mtmp->wormno) wormsee(mtmp->wormno);
  324. #endif
  325.     }
  326. }
  327.  
  328. pmon(mon) register struct monst *mon; {
  329. register int show = (Blind && Telepat) || canseemon(mon);
  330.     if(mon->mdispl){
  331.         if(mon->mdx != mon->mx || mon->mdy != mon->my || !show)
  332.             unpmon(mon);
  333.     }
  334.  
  335. /* If you're hallucinating, the monster must be redrawn even if it has
  336.    already been printed.  Problem: the monster must also be redrawn right
  337.    after hallucination is over, so it looks normal again.  Therefore
  338.    code similar to pmon is in timeout.c. */
  339.     if(show && (!mon->mdispl || Hallucination)) {
  340.         if (Hallucination)
  341.         atl(mon->mx,mon->my,
  342.             (!mon->mimic || Protection_from_shape_changers) ?
  343.                 rndmonsym() :
  344.                 (mon->mappearance == DOOR_SYM) ? DOOR_SYM
  345.                 : rndobjsym());
  346.         else
  347.  
  348.         atl(mon->mx,mon->my,
  349.          (!mon->mappearance
  350.           || u.uprops[PROP(RIN_PROTECTION_FROM_SHAPE_CHAN)].p_flgs
  351.          ) ? mon->data->mlet : mon->mappearance);
  352.         mon->mdispl = 1;
  353.         mon->mdx = mon->mx;
  354.         mon->mdy = mon->my;
  355.     }
  356. }
  357.  
  358. unpmon(mon) register struct monst *mon; {
  359.     if(mon->mdispl){
  360.         newsym(mon->mdx, mon->mdy);
  361.         mon->mdispl = 0;
  362.     }
  363. }
  364.  
  365. nscr()
  366. {
  367.     register x,y;
  368.     register struct rm *room;
  369.  
  370.     if(u.uswallow || u.ux == FAR || flags.nscrinh) return;
  371.     pru();
  372.     for(y = scrly; y <= scrhy; y++)
  373.         for(x = scrlx; x <= scrhx; x++)
  374.             if((room = &levl[x][y]), RM_NEW(*room)) {
  375.                 RM_CLR_NEW(*room);
  376.                 at(x,y,room->scrsym);
  377.             }
  378.     scrhx = scrhy = 0;
  379.     scrlx = COLNO;
  380.     scrly = ROWNO;
  381. }
  382.  
  383. /* 100 suffices for bot(); no relation with COLNO */
  384. char oldbot[100], newbot[100];
  385. cornbot(lth)
  386. register int lth;
  387. {
  388.     if(lth < sizeof(oldbot)) {
  389.         oldbot[lth] = 0;
  390.         flags.botl = 1;
  391.     }
  392. }
  393.  
  394. bot()
  395. {
  396. register char *ob = oldbot, *nb = newbot;
  397. register int i;
  398. extern char *eos();
  399.     if(flags.botlx) *ob = 0;
  400.     flags.botl = flags.botlx = 0;
  401.     (void) sprintf(newbot,
  402. #ifdef GOLD_ON_BOTL
  403. # ifdef SPELLS
  404.         "Lev %-2d Gp %-5lu Hp %3d(%d) Ep %3d(%d) Ac %-2d  ",
  405.         dlevel, u.ugold,
  406. #  ifdef KAA
  407.         u.mtimedone ? u.mh : u.uhp, u.mtimedone ? u.mhmax : u.uhpmax,
  408.         u.uen, u.uenmax, u.uac);
  409. #  else /* !KAA */
  410.         u.uhp, u.uhpmax, u.uen, u.uenmax, u.uac);
  411. #  endif /* KAA */
  412. # else /* !SPELLS */
  413.         "Level %-2d  Gold %-5lu  Hp %3d(%d)  Ac %-2d  ",
  414.         dlevel, u.ugold,
  415. #  ifdef KAA
  416.         u.mtimedone ? u.mh : u.uhp, u.mtimedone ? u.mhmax : u.uhpmax,
  417.         u.uac);
  418. #  else /* !KAA */
  419.         u.uhp, u.uhpmax, u.uac);
  420. #  endif /* KAA */
  421. # endif /* SPELLS */
  422. #else /* !GOLD_ON_BOTL */
  423. # ifdef SPELLS
  424.         "Level %-2d Hp %3d(%d) Energy %3d(%d) Ac %-2d ",
  425.         dlevel,
  426. #  ifdef KAA
  427.         u.mtimedone ? u.mh : u.uhp, u.mtimedone ? u.mhmax, u.uhpmax,
  428.         u.uen, u.uenmax, u.uac);
  429. #  else /* !KAA */
  430.         u.uhp, u.uhpmax, u.uen, u.uenmax, u.uac);
  431. #  endif /* KAA */
  432. # else /* !SPELLS */
  433.         "Level %-2d   Hp %3d(%d)   Ac %-2d   ",
  434.         dlevel,
  435. #  ifdef KAA
  436.         u.mtimedone ? u.mh : u.uhp, u.mtimedone ? u.mhmax, u.uhpmax,
  437.         u.uac);
  438. #  else /* !KAA */
  439.         u.uhp, u.uhpmax, u.uac);
  440. #  endif /* KAA */
  441. # endif /* SPELLS */
  442. #endif /* GOLD_ON_BOTL */
  443. #ifdef KAA
  444.     if (u.mtimedone)
  445.         (void) sprintf(eos(newbot), "HD %d", mons[u.umonnum].mlevel);
  446.     else
  447. #endif
  448.         if(u.ustr>18) {
  449.         if(u.ustr>117)
  450.             (void) strcat(newbot,"Str 18/**");
  451.         else
  452.             (void) sprintf(eos(newbot), "Str 18/%02d",u.ustr-18);
  453.         } else
  454.         (void) sprintf(eos(newbot), "Str %-2d   ",u.ustr);
  455. #ifdef EXP_ON_BOTL
  456.     (void) sprintf(eos(newbot), "  Exp %2d/%-5lu ", u.ulevel,u.uexp);
  457. #else
  458.     (void) sprintf(eos(newbot), "   Exp %2u  ", u.ulevel);
  459. #endif
  460.     (void) strcat(newbot, hu_stat[u.uhs]);
  461.     if(flags.time)
  462.         (void) sprintf(eos(newbot), "  %ld", moves);
  463. #ifdef SCORE_ON_BOTL
  464.     (void) sprintf(eos(newbot)," S:%lu "
  465.         ,(u.ugold - u.ugold0 > 0 ? u.ugold - u.ugold0 : 0)
  466.         + u.urexp + (50 * maxdlevel)
  467.         + (maxdlevel > 20? 1000*((maxdlevel > 30) ? 10 : maxdlevel - 20) :0));
  468. #endif
  469.     if(strlen(newbot) >= COLNO) {
  470.         register char *bp0, *bp1;
  471.         bp0 = bp1 = newbot;
  472.         do {
  473.             if(*bp0 != ' ' || bp0[1] != ' ' || bp0[2] != ' ')
  474.                 *bp1++ = *bp0;
  475.         } while(*bp0++);
  476.     }
  477.     for(i = 1; i<COLNO; i++) {
  478.         if(*ob != *nb){
  479.             curs(i,ROWNO+2);
  480.             (void) putchar(*nb ? *nb : ' ');
  481.             curx++;
  482.         }
  483.         if(*ob) ob++;
  484.         if(*nb) nb++;
  485.     }
  486.     (void) strcpy(oldbot, newbot);
  487. }
  488.  
  489. /* #if defined(WAN_PROBING) || defined(KAA) */
  490. #ifdef WAN_PROBING
  491. # define XXX
  492. #endif
  493. #ifdef KAA
  494. # define XXX
  495. #endif
  496.  
  497. #ifdef XXX
  498. mstatusline(mtmp) register struct monst *mtmp; {
  499.     pline("Status of %s: ", monnam(mtmp));
  500.     pline("Level %-2d  Gold %-5lu  Hp %3d(%d)",
  501.         mtmp->data->mlevel, mtmp->mgold, mtmp->mhp, mtmp->mhpmax);
  502.     pline("Ac %-2d  Dam %d %s %s",
  503.         mtmp->data->ac, (mtmp->data->damn + 1) * (mtmp->data->damd + 1),
  504.         mtmp->mcan ? ", cancelled" : "" ,mtmp->mtame ? " (tame)" : "");
  505. }
  506.  
  507. extern char plname[];
  508. ustatusline() {
  509.     pline("Status of %s%s ", (Badged) ? "Officer " : "", plname);
  510.     pline("Level %d, gold %lu, hit points %d(%d), AC %d.",
  511. # ifdef KAA
  512.         u.ulevel, u.ugold, u.mtimedone ? u.mh : u.uhp,
  513.         u.mtimedone ? u.mhmax : u.uhpmax, u.uac);
  514. # else
  515.         u.ulevel, u.ugold, u.uhp, u.uhpmax, u.uac);
  516. # endif
  517. }
  518. #endif
  519. #undef XXX
  520.  
  521. cls(){
  522.     if(flags.toplin == 1)
  523.         more();
  524.     flags.toplin = 0;
  525.  
  526.     clear_screen();
  527.  
  528.     flags.botlx = 1;
  529. }
  530.  
  531. rndmonsym() {
  532.     register int x;
  533.     if((x=rn2(58)) < 26)
  534.         return('a'+x);
  535.     else if (x<52)
  536.         return('A'+x-26);
  537.     else switch(x) {
  538.         case 52: return(';');
  539.         case 53: return('&');
  540.         case 54: return(':');
  541.         case 55: return('\'');
  542.         case 56: return(',');
  543.         case 57: return('9');
  544.         default: impossible("Bad random monster %d",x); return('{');
  545.     }
  546. }
  547.  
  548. rndobjsym() {
  549.     char *rndsym=")[!?%/=*($`";
  550.     return *(rndsym+rn2(11));
  551. }
  552.  
  553. char *hcolors[] = { "ultraviolet","infrared","hot pink", "psychedelic",
  554. "bluish-orange","reddish-green","dark white","light black","loud",
  555. "salty","sweet","sour","bitter","luminescent","striped","polka-dotted",
  556. "square","round","triangular","brilliant","navy blue","cerise",
  557. "chartreuse","copper","sea green","spiral","swirly","blotchy",
  558. "fluorescent green","burnt orange","indigo","amber","tan",
  559. "sky blue-pink","lemon yellow" };
  560.  
  561. char *
  562. hcolor() {
  563.     return hcolors[rn2(35)];
  564. }
  565.  
  566. #ifdef MSDOSCOLOR
  567. /* what if a level character is the same as an object/monster? */
  568.  
  569. extern char obj_symbols[];
  570.  
  571. hilite(let)
  572. char let;
  573. {
  574.     char *isobjct = index(obj_symbols, let);
  575.     int ismnst();
  576.  
  577.     if (!HI || !HE) {
  578.         (void) putchar(let);
  579.         return;
  580.     }
  581.     if (isobjct != NULL || let == GOLD_SYM) {
  582.     /* is an object */
  583.         printf("%s%c%s", HI_OBJ, let, HE);
  584.     } else if (ismnst(let)) {
  585.     /* is a monster */
  586.         printf("%s%c%s", HI_MON, let, HE);
  587.     } else {
  588.     /* default */
  589.         (void) putchar(let);
  590.     }
  591. }
  592.  
  593. int
  594. ismnst(let)
  595. char let;
  596. {
  597.     register int ct;
  598.     register struct permonst *ptr;
  599.  
  600.     for (ct = 0 ; ct < CMNUM + 2 ; ct++) {
  601.         ptr = &mons[ct];
  602.         if(ptr->mlet == let) return(1);
  603.     }
  604.     if (let == '1') return(1);
  605.     else if (let == '2') return(1);
  606.     else if (let == ';') return(1);
  607.     else return(0);
  608. }
  609. #endif
  610.