LCOV - code coverage report
Current view: top level - omega-rpg-0.90-pa9 - scr.c (source / functions) Hit Total Coverage
Test: lcov.info Lines: 759 1256 60.4 %
Date: 2017-08-31 19:31:11 Functions: 72 110 65.5 %
Branches: 377 815 46.3 %

           Branch data     Line data    Source code
       1                 :            : /* omega (c) 1987,1988,1989 by Laurence Raphael Brothers */
       2                 :            : /* scr.c */
       3                 :            : /* functions that use curses routines directly */
       4                 :            : /* plus a few file i/o stuff */
       5                 :            : /* also some in file.c */
       6                 :            : 
       7                 :            : #ifdef MSDOS_SUPPORTED_ANTIQUE
       8                 :            : # include "curses.h"
       9                 :            : #else
      10                 :            : # ifdef AMIGA
      11                 :            : #  include <curses210.h>
      12                 :            : # elif defined(USE_OPCURSES)
      13                 :            : #  include "../opcurses/curses.h"
      14                 :            : # else
      15                 :            : #  include <curses.h>
      16                 :            : # endif
      17                 :            : # include <sys/types.h>
      18                 :            : #endif
      19                 :            : 
      20                 :            : #if defined(MSDOS_SUPPORTED_ANTIQUE) || defined(AMIGA)
      21                 :            : # define CHARATTR(c)    ((c) >> 8)
      22                 :            : #else
      23                 :            : # define CHARATTR(c)    ((c) & ~0xff)
      24                 :            : #endif
      25                 :            : 
      26                 :            : #include "glob.h"
      27                 :            : #include <ctype.h>
      28                 :            : #include <unistd.h>
      29                 :            : 
      30                 :            : #ifdef EXCESSIVE_REDRAW
      31                 :            : #undef wclear
      32                 :            : #define wclear werase
      33                 :            : #endif
      34                 :            : 
      35                 :            : #ifdef NEW_BANK
      36                 :            : WINDOW *Bankw;
      37                 :            : #endif
      38                 :            : 
      39                 :            : /* note these variables are not exported to other files */
      40                 :            : 
      41                 :            : WINDOW *Levelw,*Dataw,*Flagw,*Timew,*Menuw,*Locw,*Morew,*Phasew;
      42                 :            : WINDOW *Comwin,*Msg1w,*Msg2w,*Msg3w,*Msgw;
      43                 :            : 
      44                 :            : WINDOW *Cinema;
      45                 :            : /* WDT: interactions and special effects which currently
      46                 :            :  * go into the message window should instead go here.  This
      47                 :            :  * should simplify history-keeping, since we only need to
      48                 :            :  * record actual messages, not special effects. */
      49                 :            : 
      50                 :            : WINDOW *Showline[MAXITEMS];
      51                 :            : 
      52                 :            : #define SL3_LEN 160
      53                 :            : char screenLine3[SL3_LEN];
      54                 :            : 
      55                 :            : /* static function prototypes */
      56                 :            : 
      57                 :            : static long input_number (WINDOW * w);
      58                 :            : 
      59                 :            : /* function definitions */
      60                 :            : 
      61                 :        335 : void phaseprint(void)
      62                 :            : {
      63                 :        335 :   wclear(Phasew);
      64                 :        335 :   wprintw(Phasew,"Moon's Phase:\n");
      65   [ -  -  -  -  :        335 :   switch(Phase/2) {
             -  +  +  - ]
      66                 :          0 :   case 0: wprintw(Phasew,"NEW"); break;
      67                 :          0 :   case 1: case 11: wprintw(Phasew,"CRESCENT"); break;
      68                 :          0 :   case 2: case 10: wprintw(Phasew,"1/4"); break;
      69                 :          0 :   case 3: case 9: wprintw(Phasew,"HALF"); break;
      70                 :          0 :   case 4: case 8: wprintw(Phasew,"3/4"); break;
      71                 :        165 :   case 5: case 7: wprintw(Phasew,"GIBBOUS"); break;
      72                 :        170 :   case 6: wprintw(Phasew,"FULL"); break;
      73                 :            :   }
      74                 :        335 :   wrefresh(Phasew);
      75                 :        335 : }
      76                 :            : 
      77                 :        835 : static void show_screen_level (int top, int left, int bottom, int right)
      78                 :            : {
      79                 :            :   int j;
      80                 :        835 :   int last_attr = 0;
      81                 :            : 
      82         [ +  + ]:      15063 :   for (j = top; j < bottom; ++j)
      83                 :            :     {
      84                 :            :       int i;
      85                 :            : 
      86                 :      14228 :       wmove(Levelw, screenmody(j), 0);
      87                 :            : 
      88         [ +  + ]:     902675 :       for (i = left; i < right; ++i)
      89                 :            :         {
      90                 :            :           int c;
      91                 :            : 
      92         [ +  + ]:     888447 :           if (loc_statusp(i, j, SEEN))
      93                 :     882987 :             c = getspot(i, j, FALSE);
      94                 :            :           else
      95                 :       5460 :             c = SPACE;
      96                 :            : 
      97 [ +  - ][ +  + ]:     888447 :           if (optionp(SHOW_COLOUR) && CHARATTR(c) != last_attr)
      98                 :            :             {
      99                 :     246091 :               last_attr = CHARATTR(c);
     100         [ +  - ]:     246091 :               wattrset(Levelw, last_attr);
     101                 :            :             }
     102                 :            : 
     103                 :     888447 :           waddch(Levelw, c & 0xff);
     104                 :            :         }
     105                 :            :     }
     106                 :        835 : }
     107                 :            : 
     108                 :         55 : static void show_screen_country (int top, int left, int bottom, int right)
     109                 :            : {
     110                 :            :   int j;
     111                 :         55 :   int last_attr = 0;
     112                 :            : 
     113         [ +  + ]:       3561 :   for (j = top; j < bottom; ++j)
     114                 :            :     {
     115                 :            :       int i;
     116                 :            : 
     117                 :       3506 :       wmove(Levelw, screenmody(j), 0);
     118                 :            : 
     119         [ +  + ]:     207265 :       for (i = left; i < right; ++i)
     120                 :            :         {
     121                 :            :           int c;
     122                 :            : 
     123         [ +  + ]:     203759 :           if (c_statusp(i, j, SEEN))
     124                 :       6026 :             c = Country[i][j].current_terrain_type;
     125                 :            :           else
     126                 :     197733 :             c = SPACE;
     127                 :            : 
     128 [ +  - ][ +  + ]:     203759 :           if (optionp(SHOW_COLOUR) && CHARATTR(c) != last_attr)
     129                 :            :             {
     130                 :       3314 :               last_attr = CHARATTR(c);
     131         [ +  - ]:       3314 :               wattrset(Levelw, last_attr);
     132                 :            :             }
     133                 :            : 
     134                 :     203759 :           waddch(Levelw, c & 0xff);
     135                 :            :         }
     136                 :            :     }
     137                 :         55 : }
     138                 :            : 
     139                 :        890 : void show_screen(void)
     140                 :            : {
     141                 :            :   int top;
     142                 :            :   int left;
     143                 :            :   int right;
     144                 :            :   int bottom;
     145                 :            : 
     146                 :        890 :   wclear(Levelw);
     147                 :            : 
     148         [ +  + ]:        890 :   if (ScreenOffset < 0) ScreenOffset = 0;
     149         [ -  + ]:        890 :   if (ScreenXOffset < 0) ScreenXOffset = 0;
     150                 :            : 
     151                 :        890 :   top = ScreenOffset;
     152                 :        890 :   left = ScreenXOffset;
     153                 :        890 :   right = ScreenXOffset + ScreenWidth;
     154                 :        890 :   bottom = ScreenOffset + ScreenLength;
     155                 :            : 
     156         [ +  + ]:        890 :   if (Current_Environment != E_COUNTRYSIDE)
     157                 :            :     {
     158         [ +  + ]:        835 :       if (right > Level->level_width) right = Level->level_width;
     159         [ +  + ]:        835 :       if (bottom > Level->level_length) bottom = Level->level_length;
     160                 :            :     }
     161                 :            :   else
     162                 :            :     {
     163         [ +  + ]:         55 :       if (right > COUNTRY_WIDTH) right = COUNTRY_WIDTH;
     164         [ +  + ]:         55 :       if (bottom > COUNTRY_LENGTH) bottom = COUNTRY_LENGTH;
     165                 :            :     }
     166                 :            : 
     167         [ +  + ]:        890 :   if (Current_Environment != E_COUNTRYSIDE)
     168                 :            :     {
     169                 :        835 :       show_screen_level(top, left, bottom, right);
     170                 :            :     }
     171                 :            :   else
     172                 :            :     {
     173                 :         55 :       show_screen_country(top, left, bottom, right);
     174                 :            : #if 0
     175                 :            :       for (j=top;j<bottom;j++)
     176                 :            :         {
     177                 :            :           for (i=left;i<right;i++)
     178                 :            :             {
     179                 :            :               wmove(Levelw,screenmody(j),screenmodx(i));
     180                 :            :               c = ((c_statusp(i,j,SEEN)) ? Country[i][j].current_terrain_type:SPACE);
     181                 :            :               if (optionp(SHOW_COLOUR) && CHARATTR(c) != last_attr)
     182                 :            :                 {
     183                 :            :                   last_attr = CHARATTR(c);
     184                 :            :                   wattrset(Levelw,last_attr);
     185                 :            :                 }
     186                 :            :               waddch(Levelw,c&0xff);
     187                 :            :             }
     188                 :            :           wrefresh(Levelw);
     189                 :            :         }
     190                 :            : #endif
     191                 :            :     }
     192                 :        890 : }
     193                 :            : 
     194                 :            : 
     195                 :            : 
     196                 :       1403 : char mgetc(void)
     197                 :            : {
     198                 :       1403 :   return(wgetch(Msgw));
     199                 :            : }
     200                 :            : 
     201                 :            : /* case insensitive mgetc -- sends uppercase to lowercase */
     202                 :        138 : int mcigetc(void)
     203                 :            : {
     204                 :            :   int c;
     205                 :            : 
     206                 :            : #ifdef MSDOS_SUPPORTED_ANTIQUE
     207                 :            : #ifndef DJGPP
     208                 :            :   keypad(Msgw,TRUE);
     209                 :            : #endif
     210                 :            : #endif
     211                 :        138 :   c = wgetch(Msgw);
     212 [ +  + ][ +  + ]:        135 :   if ((c>=(int)'A') && (c<=(int)'Z'))
     213                 :          7 :     return(c+(int)('a'-'A'));
     214                 :        128 :   else return(c);
     215                 :            : }
     216                 :            : 
     217                 :         27 : char menugetc(void)
     218                 :            : {
     219                 :         27 :   return(wgetch(Menuw));
     220                 :            : }
     221                 :            : 
     222                 :            : 
     223                 :         20 : char lgetc(void)
     224                 :            : {
     225                 :         20 :   return(wgetch(Levelw));
     226                 :            : }
     227                 :            : 
     228                 :         15 : int ynq(void)
     229                 :            : {
     230                 :         15 :   int p='*'; /* the user's choice; start with something impossible
     231                 :            :               * to prevent a loop. */
     232 [ +  + ][ +  + ]:         30 :   while ((p != 'n') && (p != 'y') && (p != 'q') && (p != ESCAPE) &&
         [ +  - ][ +  - ]
                 [ +  - ]
     233         [ +  - ]:         15 :          (p != EOF) && (p != ' '))
     234                 :         15 :     p = wgetch(Msgw);
     235   [ +  +  -  -  :         15 :   switch (p) {
                   -  - ]
     236                 :         11 :   case 'y': wprintw(Msgw,"yes. "); break;
     237                 :          4 :   case 'n': wprintw(Msgw,"no. "); break;
     238                 :            :     
     239                 :          0 :   case ESCAPE: p = 'q'; /* fall through to 'q' */
     240                 :          0 :   case ' ': p = 'q';    /* fall through to 'q' */
     241                 :          0 :   case 'q': wprintw(Msgw,"quit. "); break;
     242         [ #  # ]:          0 :   default: assert( p == EOF );
     243                 :            :   }
     244                 :         15 :   wrefresh(Msgw);
     245                 :         15 :   return(p);
     246                 :            : }
     247                 :            : 
     248                 :            : 
     249                 :          1 : int ynq1(void)
     250                 :            : {
     251                 :          1 :   int p='*'; /* the user's choice; start with something impossible
     252                 :            :               * to prevent a loop. */
     253 [ +  + ][ +  - ]:          2 :   while ((p != 'n') && (p != 'y') && (p != 'q') && (p != ESCAPE) &&
         [ +  - ][ +  - ]
                 [ +  - ]
     254         [ +  - ]:          1 :          (p != ' ') && (p != EOF))
     255                 :          1 :     p = wgetch(Msg1w);
     256   [ -  +  -  -  :          1 :   switch (p) {
                   -  - ]
     257                 :          0 :   case 'y': wprintw(Msg1w,"yes. "); break;
     258                 :          1 :   case 'n': wprintw(Msg1w,"no. "); break;
     259                 :            :     
     260                 :          0 :   case ESCAPE: p = 'q'; /* fall through to 'q' */
     261                 :          0 :   case ' ': p = 'q';    /* fall through to 'q' */
     262                 :          0 :   case 'q': wprintw(Msg1w,"quit. "); break;
     263         [ #  # ]:          0 :   default: assert( p == EOF );
     264                 :            :   }
     265                 :          1 :   wrefresh(Msg1w);
     266                 :          1 :   return(p);
     267                 :            : }
     268                 :            : 
     269                 :            : 
     270                 :          8 : int ynq2(void)
     271                 :            : {
     272                 :          8 :   int p='*'; /* the user's choice; start with something impossible
     273                 :            :               * to prevent a loop. */
     274 [ +  + ][ +  + ]:         17 :   while ((p != 'n') && (p != 'y') && (p != 'q') && (p != ESCAPE) &&
         [ +  - ][ +  - ]
                 [ +  - ]
     275         [ +  - ]:          9 :          (p != ' ') && (p != EOF))
     276                 :          9 :     p = wgetch(Msg2w);
     277   [ +  +  -  -  :          8 :   switch (p) {
                   -  - ]
     278                 :          3 :   case 'y': wprintw(Msg2w,"yes. "); break;
     279                 :          5 :   case 'n': wprintw(Msg2w,"no. "); break;
     280                 :            :     
     281                 :          0 :   case ESCAPE: p = 'q'; /* fall through to 'q' */
     282                 :          0 :   case ' ': p = 'q';    /* fall through to 'q' */
     283                 :          0 :   case 'q': wprintw(Msg2w,"quit. "); break;
     284         [ #  # ]:          0 :   default: assert( p == EOF );
     285                 :            :   }
     286                 :          8 :   wrefresh(Msg2w);
     287                 :          8 :   return(p);
     288                 :            : }
     289                 :            :     
     290                 :        514 : void erasemsg3 (void)
     291                 :            : {
     292                 :        514 :   werase(Msg3w);
     293                 :        514 :   memset(screenLine3, 0, SL3_LEN);
     294                 :        514 : }
     295                 :            : 
     296                 :            : /* puts up a morewait to allow reading if anything in top two lines */
     297                 :         41 : void checkclear(void)
     298                 :            : {
     299                 :            :   int x1,y,x2;
     300 [ +  - ][ +  - ]:         41 :   getyx(Msg1w,x1,y);
     301 [ +  - ][ +  - ]:         41 :   getyx(Msg2w,x2,y);  
     302 [ +  - ][ -  + ]:         41 :   if ((x1 != 0) || (x2 != 0)) {
     303                 :          0 :     morewait();
     304                 :          0 :     wclear(Msg1w);
     305                 :          0 :     wclear(Msg2w);
     306                 :          0 :     wrefresh(Msg1w);
     307                 :          0 :     wrefresh(Msg2w);
     308                 :            :   }
     309                 :         41 : }
     310                 :            :   
     311                 :            : /* for external call */
     312                 :        304 : void clearmsg(void)
     313                 :            : {
     314                 :        304 :   wclear(Msg1w);
     315                 :        304 :   wclear(Msg2w);
     316                 :        304 :   erasemsg3();
     317                 :        304 :   Msgw = Msg1w;
     318                 :        304 :   wrefresh(Msg1w);
     319                 :        304 :   wrefresh(Msg2w);
     320                 :        304 :   wrefresh(Msg3w);
     321                 :        304 : }
     322                 :            : 
     323                 :         24 : void clearmsg3(void)
     324                 :            : {
     325                 :         24 :   erasemsg3();
     326                 :         24 :   wrefresh(Msg3w);
     327                 :         24 : }
     328                 :            : 
     329                 :         72 : void clearmsg1(void)
     330                 :            : {
     331                 :         72 :   wclear(Msg1w);
     332                 :         72 :   wclear(Msg2w);
     333                 :         72 :   Msgw = Msg1w;
     334                 :         72 :   wrefresh(Msg1w);
     335                 :         72 :   wrefresh(Msg2w);
     336                 :         72 : }
     337                 :            : 
     338                 :            : 
     339                 :          0 : void erase_level(void)
     340                 :            : {
     341                 :          0 :   wclear(Levelw);
     342                 :          0 :   wrefresh(Levelw);
     343                 :          0 : }
     344                 :            : 
     345                 :            : /* direct print to first msg line */
     346                 :        233 : void print1(char *s)
     347                 :            : {
     348         [ +  - ]:        233 :   if (! gamestatusp(SUPPRESS_PRINTING)) {
     349                 :        233 :     buffercycle(s);
     350                 :        233 :     wclear(Msg1w);
     351                 :        233 :     wprintw(Msg1w,s);
     352                 :        233 :     wrefresh(Msg1w);
     353                 :            :   }
     354                 :        233 : }
     355                 :            : 
     356                 :            : /* for run on-messages -- print1 clears first.... */
     357                 :          5 : void nprint1(char *s)
     358                 :            : {
     359         [ +  - ]:          5 :   if (! gamestatusp(SUPPRESS_PRINTING)) {
     360         [ +  - ]:          5 :     if (bufferappend(s)) {
     361                 :          5 :       wprintw(Msg1w,s);
     362                 :          5 :       wrefresh(Msg1w);
     363                 :            :     }
     364                 :            :   }
     365                 :          5 : }
     366                 :            : 
     367                 :            : 
     368                 :            : /* direct print to second msg line */
     369                 :         76 : void print2(char *s)
     370                 :            : {
     371         [ +  - ]:         76 :   if (! gamestatusp(SUPPRESS_PRINTING)) {
     372                 :         76 :     buffercycle(s);
     373                 :         76 :     wclear(Msg2w);
     374                 :         76 :     wprintw(Msg2w,s);
     375                 :         76 :     wrefresh(Msg2w);
     376                 :            :   }
     377                 :         76 : }
     378                 :            : 
     379                 :            : /* for run on-messages -- print2 clears first.... */
     380                 :         25 : void nprint2(char *s)
     381                 :            : {
     382         [ +  - ]:         25 :   if (! gamestatusp(SUPPRESS_PRINTING)) {
     383         [ +  - ]:         25 :     if (bufferappend(s)) {
     384                 :         25 :       wprintw(Msg2w,s);
     385                 :         25 :       wrefresh(Msg2w);
     386                 :            :     }
     387                 :            :   }
     388                 :         25 : }
     389                 :            : 
     390                 :            : 
     391                 :            : /* msg line 3 is not part of the region that mprint or printm can reach */
     392                 :            : /* typical use of print3 is for "you can't do that" type error messages */
     393                 :            : /* WDT: it's also typically used for messages intended to persist a while.
     394                 :            :  * Thus I'm having print3 save its input in a global variable which other
     395                 :            :  * things can use. */
     396                 :         82 : void print3 (char *s)
     397                 :            : {
     398         [ +  - ]:         82 :   if (!gamestatusp(SUPPRESS_PRINTING))
     399                 :            :     {
     400                 :         82 :       buffercycle(s);
     401                 :         82 :       erasemsg3();
     402                 :         82 :       wprintw(Msg3w, s);
     403                 :         82 :       strcpy(screenLine3, s);
     404                 :         82 :       wrefresh(Msg3w);
     405                 :            :     }
     406                 :         82 : }
     407                 :            : 
     408                 :            : /* for run on-messages -- print3 clears first.... */
     409                 :          0 : void nprint3(char *s)
     410                 :            : {
     411         [ #  # ]:          0 :   if (!gamestatusp(SUPPRESS_PRINTING))
     412                 :            :     {
     413         [ #  # ]:          0 :       if (bufferappend(s))
     414                 :            :         {
     415                 :          0 :           strcat(screenLine3, s);
     416                 :          0 :           wprintw(Msg3w,s);
     417                 :          0 :           wrefresh(Msg3w);
     418                 :            :         }
     419                 :            :     }
     420                 :          0 : }
     421                 :            : 
     422                 :            : 
     423                 :            : 
     424                 :            : /* prints wherever cursor is in window, but checks to see if
     425                 :            : it should morewait and clear window */
     426                 :        187 : void mprint(char *s)
     427                 :            : {
     428                 :            :   int x,y;
     429         [ +  - ]:        187 :   if (! gamestatusp(SUPPRESS_PRINTING)) {
     430 [ +  - ][ +  - ]:        187 :     getyx(Msgw,y,x);
     431         [ +  + ]:        187 :     if (x+strlen(s) >= ScreenWidth) {
     432                 :         59 :       buffercycle(s);
     433         [ +  + ]:         59 :       if (Msgw == Msg1w) {
     434                 :         43 :         wclear(Msg2w);
     435                 :         43 :         Msgw = Msg2w;
     436                 :            :       }
     437                 :            :       else {
     438                 :         16 :         morewait();
     439                 :         16 :         wclear(Msg1w);
     440                 :         16 :         wclear(Msg2w);
     441                 :         16 :         wrefresh(Msg2w);
     442                 :         59 :         Msgw = Msg1w;
     443                 :            :       }
     444                 :            :     }
     445         [ +  + ]:        128 :     else if (x > 0)
     446                 :         61 :       bufferappend(s);
     447                 :            :     else
     448                 :         67 :       buffercycle(s);
     449                 :        187 :     wprintw(Msgw,s);
     450                 :        187 :     waddch(Msgw,' '); 
     451                 :        187 :     wrefresh(Msgw);
     452                 :            :   }
     453                 :        187 : }
     454                 :            : 
     455                 :            : 
     456                 :         15 : void omega_title(void)
     457                 :            : {
     458                 :         15 :   showmotd();
     459                 :         15 :   clear();
     460         [ +  - ]:         15 :   touchwin(stdscr);
     461                 :         15 :   refresh();  
     462                 :            :   /*  showscores();*/ /* DG */
     463                 :         15 : }
     464                 :            : 
     465                 :            : 
     466                 :            : 
     467                 :            : /* blanks out ith line of Menuw or Levelw */
     468                 :        968 : void hide_line(int i)
     469                 :            : {
     470                 :        968 :   wclear(Showline[i]);
     471         [ +  - ]:        968 :   touchwin(Showline[i]);
     472                 :        968 :   wrefresh(Showline[i]);
     473                 :        968 : }
     474                 :            : 
     475                 :            : #ifdef USE_OPCURSES
     476                 :            : static void load_tiles (void)
     477                 :            : {
     478                 :            :   char * path;
     479                 :            : 
     480                 :            :   path = malloc(strlen(OMEGALIB) + strlen(TILEFILE) + 1);
     481                 :            :   if (0 == path) return;
     482                 :            : 
     483                 :            :   strcpy(path, OMEGALIB);
     484                 :            :   strcat(path, TILEFILE);
     485                 :            : 
     486                 :            :   set_tiles(path);
     487                 :            : 
     488                 :            :   free(path);
     489                 :            : }
     490                 :            : #endif
     491                 :            : 
     492                 :            : /* initialize, screen, windows */
     493                 :         15 : void initgraf(void)
     494                 :            : {
     495                 :            :   int i;
     496                 :            : 
     497                 :            : #ifdef USE_OPCURSES
     498                 :            :   load_tiles();
     499                 :            : #endif
     500                 :            : 
     501                 :         15 :   initscr();
     502                 :            : #if !defined(MSDOS_SUPPORTED_ANTIQUE)
     503                 :         15 :   start_color();
     504                 :            : # ifndef AMIGA
     505                 :         15 :   clrgen_init();
     506                 :            : # endif
     507                 :            : #endif
     508 [ +  - ][ -  + ]:         15 :   if (LINES < 24 || COLS < 80) {
     509                 :          0 :     printf("Minimum Screen Size: 24 Lines by 80 Columns.");
     510                 :          0 :     exit(0);
     511                 :            :   }
     512                 :            : #ifdef AMIGA
     513                 :            :   init_color(1, 800, 800, 800); /* white */
     514                 :            :   init_color(2, 644, 164, 164); /* brown */
     515                 :            :   init_color(3, 800, 800, 0); /* yellow */
     516                 :            :   init_color(4, 200, 200, 200); /* grey */
     517                 :            :   init_color(5, 0, 1000, 0); /* green */
     518                 :            :   init_color(6, 0, 0, 1000); /* blue */
     519                 :            :   init_color(7, 1000, 0, 0); /* red */
     520                 :            :   LINES -= 2;   /* ugly, but neccessary with this curses package... */
     521                 :            : #endif
     522                 :         15 :   ScreenLength = LINES - 6;
     523                 :         15 :   ScreenWidth = 64; /* PGM */
     524                 :         15 :   Msg1w = newwin(1,80,0,0);
     525                 :         15 :   scrollok(Msg1w, 0);   /* DJGPP curses defaults to scrollable new windows */
     526                 :         15 :   Msg2w = newwin(1,80,1,0);
     527                 :         15 :   scrollok(Msg2w, 0);
     528                 :         15 :   Msg3w = newwin(1,80,2,0);
     529                 :         15 :   scrollok(Msg3w, 0);
     530                 :         15 :   Msgw = Msg1w;
     531                 :         15 :   Morew = newwin(1,15,3,65);  
     532                 :         15 :   scrollok(Morew, 0);
     533                 :            : #ifdef NEW_BANK
     534                 :         15 :   Bankw = newwin( 20, 50, ( ScreenLength - 20 ) / 2 + 3, 7 );
     535                 :         15 :   scrollok( Bankw, 0 );
     536                 :            : #endif
     537                 :         15 :   Locw = newwin(1,80,ScreenLength+3,0);
     538                 :         15 :   scrollok(Locw, 0);
     539                 :         15 :   Levelw = newwin(ScreenLength,ScreenWidth,3,0);
     540                 :         15 :   scrollok(Levelw, 0);
     541         [ +  + ]:        255 :   for(i=0;i<MAXITEMS;i++) {
     542                 :        240 :     Showline[i] = newwin(1,ScreenWidth,i+3,0);
     543                 :        240 :     scrollok(Showline[i], 0);
     544                 :        240 :     wclear(Showline[i]);
     545                 :            :   }
     546                 :         15 :   Menuw = newwin(ScreenLength,ScreenWidth,3,0);
     547                 :         15 :   scrollok(Menuw, 0);
     548                 :         15 :   Dataw = newwin(2,80,ScreenLength+4,0);
     549                 :         15 :   scrollok(Dataw, 0);
     550                 :         15 :   Timew = newwin(2,15,4,65);
     551                 :         15 :   scrollok(Timew, 0);
     552                 :         15 :   Phasew = newwin(2,15,6,65);
     553                 :         15 :   scrollok(Phasew, 0);
     554                 :         15 :   Flagw = newwin(4,15,9,65);
     555                 :         15 :   scrollok(Flagw, 0);
     556                 :         15 :   Comwin = newwin(8,15,14,65);
     557                 :         15 :   scrollok(Comwin, 0);
     558                 :         15 :   Cinema = newwin(3,80,0,0); /* the same position and size as the three 
     559                 :            :                               * message windows. */
     560                 :         15 :   scrollok(Cinema,0);
     561                 :            : 
     562                 :         15 :   noecho();
     563                 :         15 :   crmode();
     564                 :            : 
     565                 :         15 :   clear();
     566         [ +  - ]:         15 :   touchwin(stdscr);
     567                 :            :   /*  omega_title();*/
     568                 :            :   /*  clear();*/
     569                 :            :   /*  touchwin(stdscr);*/
     570                 :            :   /*  refresh();*/          /* DG */
     571                 :         15 : }
     572                 :            : 
     573                 :            : /* cinema_display: pop up a window out of the way of the screen and fill it
     574                 :            :  * with 3 lines of text.  The lines may be NULL pointers. */
     575                 :        184 : void cinema_display (char *line1, char *line2, char *line3)
     576                 :            : {
     577                 :        184 :   werase(Cinema);
     578                 :            : 
     579         [ +  - ]:        184 :   if (line1)
     580                 :            :     {
     581         [ +  + ]:        184 :       if (line2)
     582                 :            :         {
     583         [ +  + ]:        109 :           if (line3)
     584                 :            :             {
     585                 :         11 :               mvwprintw(Cinema, 0, 0, line1);
     586                 :         11 :               mvwprintw(Cinema, 1, 0, line2);
     587                 :         11 :               mvwprintw(Cinema, 2, 0, line3);
     588                 :            :             }
     589                 :            :           else
     590                 :            :             {
     591                 :         98 :               mvwprintw(Cinema, 2, 0, screenLine3);
     592                 :         98 :               mvwprintw(Cinema, 0, 0, line1);
     593                 :        109 :               mvwprintw(Cinema, 1, 0, line2);
     594                 :            :             }
     595                 :            :         }
     596                 :            :       else
     597                 :            :         {
     598         [ +  + ]:         75 :           if (line3)
     599                 :            :             {
     600                 :          3 :               mvwprintw(Cinema, 0, 0, line1);
     601                 :          3 :               mvwprintw(Cinema, 2, 0, line3);
     602                 :            :             }
     603                 :            :           else
     604                 :            :             {
     605                 :         72 :               mvwprintw(Cinema, 2, 0, screenLine3);
     606                 :        184 :               mvwprintw(Cinema, 0, 0, line1);
     607                 :            :             }
     608                 :            :         }
     609                 :            :     }
     610                 :            :   else
     611                 :            :     {
     612         [ #  # ]:          0 :       if (line2)
     613                 :            :         {
     614         [ #  # ]:          0 :           if (line3)
     615                 :            :             {
     616                 :          0 :               mvwprintw(Cinema, 1, 0, line2);
     617                 :          0 :               mvwprintw(Cinema, 2, 0, line3);
     618                 :            :             }
     619                 :            :           else
     620                 :            :             {
     621                 :          0 :               mvwprintw(Cinema, 2, 0, screenLine3);
     622                 :          0 :               mvwprintw(Cinema, 1, 0, line2);
     623                 :            :             }
     624                 :            :         }
     625                 :            :       else
     626                 :            :         {
     627         [ #  # ]:          0 :           if (line3)
     628                 :            :             {
     629                 :          0 :               mvwprintw(Cinema, 2, 0, line3);
     630                 :            :             }
     631                 :            :           else
     632                 :            :             {
     633                 :          0 :               mvwprintw(Cinema, 2, 0, screenLine3);
     634                 :            :             }
     635                 :            :         }
     636                 :            :     }
     637                 :            : 
     638                 :        184 :   wrefresh(Cinema);
     639                 :        184 : }
     640                 :            : 
     641                 :          0 : void cinema_blank (void)
     642                 :            : {
     643                 :          0 :   werase(Cinema);
     644                 :          0 : }
     645                 :            : 
     646                 :          0 : static void cinema_blank_line (int line)
     647                 :            : {
     648                 :            :   int x;
     649                 :            :   int maxy, maxx;
     650                 :            : 
     651 [ #  # ][ #  # ]:          0 :   getmaxyx(Cinema, maxy, maxx);
     652                 :          0 :   wmove(Cinema, line, 0);
     653                 :            : 
     654         [ #  # ]:          0 :   for (x = 0; x < maxx; ++x)
     655                 :          0 :     waddch(Cinema, ' ');
     656                 :            : 
     657                 :          0 :   wrefresh(Cinema);
     658                 :          0 : }
     659                 :            : 
     660                 :          0 : void cinema_print_line (int line, char * text)
     661                 :            : {
     662                 :          0 :   mvwprintw(Cinema, line, 0, text);
     663                 :          0 :   wrefresh(Cinema);
     664                 :          0 : }
     665                 :            : 
     666                 :            : /* Doggone it, there ought to be a way to simply hide a window, thereby
     667                 :            :  * redrawing anything which happened to be under it. */
     668                 :        170 : void cinema_hide (void)
     669                 :            : {
     670         [ +  - ]:        170 :   touchwin(Msg1w);
     671                 :        170 :   wrefresh(Msg1w);
     672         [ +  - ]:        170 :   touchwin(Msg2w);
     673                 :        170 :   wrefresh(Msg2w);
     674         [ +  - ]:        170 :   touchwin(Msg3w);
     675                 :        170 :   wrefresh(Msg3w);
     676                 :        170 : }
     677                 :            : 
     678                 :        181 : int cinema_getch (void)
     679                 :            : {
     680                 :            :   int response;
     681                 :        181 :   response = wgetch(Cinema);
     682 [ +  - ][ -  + ]:        181 :   if (EOF == response || ESCAPE == response) response = -1;
     683                 :        181 :   return response;
     684                 :            : }
     685                 :            : 
     686                 :            : /* cinema_interact: pop up a window out of the way of the screen, fill
     687                 :            :  * it with up to three lines of text, wait for user input, close the
     688                 :            :  * window, and return the user's input.
     689                 :            :  * 
     690                 :            :  * Params:
     691                 :            :  * 
     692                 :            :  *   choices: a \0-terminated array containing the characters which are
     693                 :            :  *         acceptable responses to this interaction.  ESC is always
     694                 :            :  *         acceptable, regardless of choices.  \0 is never acceptable
     695                 :            :  *         and may not be embedded in the string.
     696                 :            :  * 
     697                 :            :  *   line1-3: The 3 lines of text, each at most 80 chars long.  Any may
     698                 :            :  *         be NULL, and none may contain CRs or escape sequences.
     699                 :            :  * 
     700                 :            :  * Return Value:
     701                 :            :  *   -1 if ESC was pressed; otherwise the character chosen.
     702                 :            :  */
     703                 :        167 : int cinema_interact (char *choices, char *line1, char *line2, char *line3)
     704                 :            : {
     705                 :            :   int response;
     706                 :            : 
     707 [ +  - ][ -  + ]:        167 :   assert(choices && strlen(choices) > 0);
     708                 :            : 
     709                 :            :   while (1)
     710                 :            :     {
     711                 :        181 :       cinema_display(line1, line2, line3);
     712                 :        181 :       response = cinema_getch();
     713         [ -  + ]:        181 :       if (-1 == response) break;
     714         [ +  + ]:        181 :       if (strchr(choices, response)) break;
     715         [ +  + ]:         14 :       if (!line3) line3 = "What? Try again!";
     716                 :         14 :     }
     717                 :            :   
     718                 :        167 :   cinema_hide();
     719                 :        167 :   return response;
     720                 :            : }
     721                 :            : 
     722                 :          0 : int cinema_interact_line (int line, char * choices, char * text)
     723                 :            : {
     724                 :            :   int response;
     725                 :            : 
     726 [ #  # ][ #  # ]:          0 :   assert(0 == line || 1 == line);
     727 [ #  # ][ #  # ]:          0 :   assert(choices && strlen(choices) > 0);
     728                 :            : 
     729                 :            :   while (1)
     730                 :            :     {
     731                 :          0 :       cinema_print_line(line, text);
     732                 :          0 :       response = cinema_getch();
     733         [ #  # ]:          0 :       if (ABORT == response) break;
     734         [ #  # ]:          0 :       if (strchr(choices, response)) break;
     735                 :          0 :       cinema_print_line(2, "What? Try again!");
     736                 :          0 :     }
     737                 :            : 
     738                 :          0 :   return response;
     739                 :            : }
     740                 :            : 
     741                 :          0 : int cinema_ynq_line (int line, char * prompt)
     742                 :            : {
     743                 :          0 :   return cinema_interact_line(line, "ynqYNQ", prompt);
     744                 :            : }
     745                 :            : 
     746                 :          0 : int cinema_getnum_line (int line, char * prompt)
     747                 :            : {
     748                 :            :   int num;
     749                 :            : 
     750 [ #  # ][ #  # ]:          0 :   assert(0 == line || 1 == line);
     751                 :            : 
     752                 :          0 :   cinema_blank_line(line);
     753                 :          0 :   cinema_print_line(line, prompt);
     754                 :          0 :   num = (int)input_number(Cinema);
     755                 :            : 
     756                 :          0 :   return num;
     757                 :            : }
     758                 :            : 
     759                 :         75 : int cinema_confirm (char * action_description)
     760                 :            : {
     761                 :            :   char *msg;
     762                 :            : 
     763   [ +  +  +  + ]:         75 :   switch (random_range(4))
     764                 :            :     {
     765                 :         24 :     case 0: msg = "Are you sure? [yn] "; break;
     766                 :         22 :     case 1: msg = "Certain about that? [yn] "; break;
     767                 :         18 :     case 2: msg = "Do you really mean it? [yn] "; break;
     768                 :         11 :     default: msg = "Confirm that, would you? [yn] "; break;
     769                 :            :     }
     770                 :            : 
     771                 :         75 :   return cinema_interact("ynqYNQ", action_description, msg, NULL);
     772                 :            : }
     773                 :            : 
     774                 :         72 : int cinema_ynq (char *action_description)
     775                 :            : {
     776                 :         72 :   return cinema_interact("ynqYNQ", action_description, NULL, NULL);
     777                 :            : }
     778                 :            : 
     779                 :          0 : void cinema_scene (char *line1, char *line2, char *line3)
     780                 :            : {
     781                 :          0 :   cinema_display(line1, line2, line3);
     782                 :          0 :   morewait();
     783                 :          0 :   cinema_hide();
     784                 :          0 : }
     785                 :            : 
     786                 :            : int lastx= -1,lasty= -1;
     787                 :            : 
     788                 :       3102 : void drawplayer(void)
     789                 :            : {
     790                 :            :   int c;
     791                 :            : 
     792         [ +  + ]:       3102 :   if (E_COUNTRYSIDE == Current_Environment)
     793                 :            :     {
     794 [ +  + ][ +  - ]:        153 :       if (inbounds(lastx, lasty) && !offscreen(lastx, lasty))
     795                 :            :         {
     796                 :        152 :           wmove(Levelw, screenmody(lasty), screenmodx(lastx));
     797                 :        152 :           c = Country[lastx][lasty].current_terrain_type;
     798                 :            : 
     799 [ +  - ][ +  - ]:        152 :           if (optionp(SHOW_COLOUR)) wattrset(Levelw, CHARATTR(c));
     800                 :            : 
     801                 :        152 :           waddch(Levelw, c & 0xff);
     802                 :            :         }
     803                 :            : 
     804                 :        153 :       wmove(Levelw, screenmody(Player.y), screenmodx(Player.x));
     805                 :            : 
     806 [ +  - ][ +  - ]:        153 :       if (optionp(SHOW_COLOUR)) wattrset(Levelw, CHARATTR(PLAYER));
     807                 :            : 
     808                 :        153 :       waddch(Levelw, PLAYER & 0xff);
     809                 :            :     }
     810                 :            :   else
     811                 :            :     {
     812 [ +  + ][ +  - ]:       2949 :       if (inbounds(lastx, lasty) && !offscreen(lastx, lasty))
     813                 :       2941 :         plotspot(lastx, lasty, (Player.status[BLINDED] > 0 ? FALSE : TRUE));
     814                 :            : 
     815                 :       2949 :       wmove(Levelw, screenmody(Player.y), screenmodx(Player.x));
     816                 :            : 
     817 [ -  + ][ #  # ]:       2949 :       if ((!Player.status[INVISIBLE]) || Player.status[TRUESIGHT])
     818                 :            :         {
     819 [ +  - ][ +  - ]:       2949 :           if (optionp(SHOW_COLOUR)) wattrset(Levelw, CHARATTR(PLAYER));
     820                 :       2949 :           waddch(Levelw, PLAYER & 0xff);
     821                 :            :         }
     822                 :            :     }
     823                 :            : 
     824                 :       3102 :   lastx = Player.x;
     825                 :       3102 :   lasty = Player.y;
     826                 :       3102 : }
     827                 :            : 
     828                 :         17 : void setlastxy(int new_x, int new_y) /* used when changing environments */
     829                 :            : {
     830                 :         17 :   lastx = new_x;
     831                 :         17 :   lasty = new_y;
     832                 :         17 : }
     833                 :            : 
     834                 :          0 : int litroom(int x, int y)
     835                 :            : {
     836         [ #  # ]:          0 :   if (Level->site[x][y].roomnumber < ROOMBASE) return(FALSE);
     837 [ #  # ][ #  # ]:          0 :   else return(loc_statusp(x,y,LIT) ||
     838                 :          0 :               Player.status[ILLUMINATION]);
     839                 :            : }
     840                 :            : 
     841                 :       2230 : void drawvision(int x, int y)
     842                 :            : {
     843                 :            :   static int oldx = -1,oldy = -1;
     844                 :            :   int i,j,c;
     845                 :            : 
     846         [ +  + ]:       2230 :   if (Current_Environment != E_COUNTRYSIDE) {
     847         [ -  + ]:       2122 :     if (Player.status[BLINDED]) {
     848                 :          0 :       drawspot(oldx,oldy);
     849                 :          0 :       drawspot(x,y);
     850                 :          0 :       drawplayer();
     851                 :            :     }
     852                 :            :     else {
     853         [ -  + ]:       2122 :       if (Player.status[ILLUMINATION] > 0) {
     854         [ #  # ]:          0 :         for (i= -2;i<3;i++)
     855         [ #  # ]:          0 :           for (j= -2;j<3;j++)
     856         [ #  # ]:          0 :             if (inbounds(x+i,y+j))
     857         [ #  # ]:          0 :               if (view_los_p(x+i,y+j,Player.x,Player.y))
     858                 :          0 :                 dodrawspot(x+i,y+j);
     859                 :            :       }
     860                 :            :       else {
     861         [ +  + ]:       8488 :         for (i= -1;i<2;i++)
     862         [ +  + ]:      25464 :           for (j= -1;j<2;j++)
     863         [ +  + ]:      19098 :             if (inbounds(x+i,y+j))
     864                 :      18549 :               dodrawspot(x+i,y+j);
     865                 :            :       }
     866                 :       2122 :       drawplayer();
     867                 :       2122 :       drawmonsters(FALSE); /* erase all monsters */
     868                 :       2122 :       drawmonsters(TRUE);  /* draw those now visible */
     869                 :            :     }
     870 [ +  + ][ +  - ]:       2122 :     if ((! gamestatusp(FAST_MOVE)) || (! optionp(JUMPMOVE)))
     871                 :       2122 :       omshowcursor(Player.x,Player.y);
     872                 :       2122 :     oldx = x;
     873                 :       2122 :     oldy = y;
     874                 :            :   }
     875                 :            :   else {
     876         [ +  + ]:        432 :     for (i= -1;i<2;i++)
     877         [ +  + ]:       1296 :       for (j= -1;j<2;j++)
     878         [ +  - ]:        972 :         if (inbounds(x+i,y+j)) {
     879                 :        972 :           c_set(x+i, y+j, SEEN);
     880         [ +  - ]:        972 :           if (!offscreen(x+i,y+j)) {
     881                 :        972 :             wmove(Levelw,screenmody(y+j),screenmodx(x+i));
     882                 :        972 :             c = Country[x+i][y+j].current_terrain_type;
     883         [ +  - ]:        972 :             if (optionp(SHOW_COLOUR))
     884         [ +  - ]:        972 :               wattrset(Levelw, CHARATTR(c));
     885                 :        972 :             waddch(Levelw,(c&0xff));
     886                 :            :           }
     887                 :            :         }
     888                 :        108 :     drawplayer();
     889                 :        108 :     omshowcursor(Player.x,Player.y);
     890                 :            :   }
     891                 :       2230 : }
     892                 :            : 
     893                 :            : 
     894                 :       2306 : void omshowcursor(int x, int y)
     895                 :            : {
     896         [ +  - ]:       2306 :   if (! offscreen(x,y)) {
     897                 :       2306 :     wmove(Levelw,screenmody(y),screenmodx(x));
     898                 :       2306 :     wrefresh(Levelw);
     899                 :            :   }
     900                 :       2306 : }
     901                 :            : 
     902                 :          0 : void levelrefresh(void)
     903                 :            : {
     904                 :          0 :   wrefresh(Levelw);
     905                 :          0 : }
     906                 :            : 
     907                 :            : 
     908                 :            : /* draws a particular spot under if in line-of-sight */
     909                 :          0 : void drawspot(int x, int y)
     910                 :            : {
     911                 :            :   Symbol c;
     912         [ #  # ]:          0 :   if (inbounds(x,y)) {
     913                 :          0 :     c = getspot(x,y,FALSE);
     914         [ #  # ]:          0 :     if (c != Level->site[x][y].showchar)
     915         [ #  # ]:          0 :       if (view_los_p(Player.x,Player.y,x,y)) {
     916                 :          0 :         lset(x,y,SEEN);
     917                 :          0 :         Level->site[x][y].showchar = c;
     918                 :          0 :         putspot(x,y,c);
     919                 :            :       }
     920                 :            :   }
     921                 :          0 : }
     922                 :            : 
     923                 :            : 
     924                 :            : 
     925                 :            : /* draws a particular spot regardless of line-of-sight */
     926                 :      18549 : void dodrawspot(int x, int y)
     927                 :            : {
     928                 :            :   Symbol c;
     929         [ +  - ]:      18549 :   if (inbounds(x,y)) {
     930                 :      18549 :     c = getspot(x,y,FALSE);
     931         [ +  + ]:      18549 :     if (c != Level->site[x][y].showchar) {
     932                 :          9 :       lset(x,y,SEEN);
     933                 :          9 :       Level->site[x][y].showchar = c;
     934                 :          9 :       putspot(x,y,c);
     935                 :            :     }
     936                 :            :   }
     937                 :      18549 : }
     938                 :            : 
     939                 :            : /* write a blank to a spot if it is floor */
     940                 :          0 : void blankoutspot(int i, int j)
     941                 :            : {
     942         [ #  # ]:          0 :   if (inbounds(i,j)) {
     943                 :          0 :     lreset(i,j,LIT);
     944                 :          0 :     lset(i, j, CHANGED);
     945         [ #  # ]:          0 :     if (Level->site[i][j].locchar == FLOOR)  {
     946                 :          0 :       Level->site[i][j].showchar = SPACE;
     947                 :          0 :       putspot(i,j,SPACE);
     948                 :            :     }
     949                 :            :   }
     950                 :          0 : }
     951                 :            : 
     952                 :            : /* blank out a spot regardless */
     953                 :          5 : void blotspot(int i, int j)
     954                 :            : {
     955         [ +  - ]:          5 :   if (inbounds(i,j)) {
     956                 :          5 :     lreset(i,j,SEEN);
     957                 :          5 :     Level->site[i][j].showchar = SPACE;
     958         [ -  + ]:          5 :     if (! offscreen(i,j)) {
     959                 :          0 :       wmove(Levelw,screenmody(j),screenmodx(i));
     960         [ #  # ]:          0 :       wattrset(Levelw, CHARATTR(SPACE));
     961                 :          0 :       waddch(Levelw, SPACE&0xff);
     962                 :            :     }
     963                 :            :   }
     964                 :          5 : }
     965                 :            : 
     966                 :            : 
     967                 :            : /* for displaying activity specifically at some point */
     968                 :       2943 : void plotspot(int x, int y, int showmonster)
     969                 :            : {
     970         [ +  - ]:       2943 :   if (loc_statusp(x,y,SEEN))
     971                 :       2943 :     putspot(x,y,getspot(x,y,showmonster));
     972                 :            :   else 
     973                 :          0 :     putspot(x,y,SPACE);
     974                 :       2943 : }
     975                 :            : 
     976                 :            : 
     977                 :            : /* Puts c at x,y on screen. No fuss, no bother. */
     978                 :      43042 : void putspot(int x, int y, Symbol c)
     979                 :            : {
     980         [ +  + ]:      43042 :   if (! offscreen(x,y)) {
     981                 :      41229 :     wmove(Levelw,screenmody(y),screenmodx(x));
     982         [ +  - ]:      41229 :     if (optionp(SHOW_COLOUR))
     983         [ +  - ]:      41229 :       wattrset(Levelw, CHARATTR(c));
     984                 :      41229 :     waddch(Levelw,(0xff&c));
     985                 :            :   }
     986                 :      43042 : }
     987                 :            : 
     988                 :            : 
     989                 :            : /* regardless of line of sight, etc, draw a monster */
     990                 :          0 : void plotmon(pmt m)
     991                 :            : {
     992         [ #  # ]:          0 :   if (! offscreen(m->x,m->y)) {
     993                 :          0 :     wmove(Levelw,screenmody(m->y),screenmodx(m->x));
     994         [ #  # ]:          0 :     if (optionp(SHOW_COLOUR))
     995         [ #  # ]:          0 :       wattrset(Levelw, CHARATTR(m->monchar));
     996                 :          0 :     waddch(Levelw,(m->monchar&0xff));
     997                 :            :   }
     998                 :          0 : }
     999                 :            :   
    1000                 :            : /* if display, displays monsters, otherwise erases them */
    1001                 :       5071 : void drawmonsters(int display)
    1002                 :            : {
    1003                 :            :   pml ml;
    1004         [ +  + ]:      76539 :   for (ml=Level->mlist;ml!=NULL;ml=ml->next) {
    1005         [ +  + ]:      71468 :     if (ml->m->hp > 0) {
    1006         [ +  + ]:      71457 :       if (display) {
    1007         [ +  + ]:      41675 :         if (view_los_p(Player.x,Player.y,ml->m->x,ml->m->y)) {
    1008 [ +  - ][ +  - ]:      10020 :           if (Player.status[TRUESIGHT] || (! m_statusp(ml->m,M_INVISIBLE))) {
    1009 [ -  + ][ #  # ]:      10020 :             if (!optionp(SHOW_COLOUR) &&
    1010         [ #  # ]:          0 :                 (ml->m->level > 5) &&
    1011         [ #  # ]:          0 :                 ((ml->m->monchar&0xff) != '@') &&
    1012         [ #  # ]:          0 :                 ((ml->m->monchar&0xff) != '|')) wstandout(Levelw);
    1013                 :      10020 :             putspot(ml->m->x,ml->m->y,ml->m->monchar);
    1014         [ -  + ]:      10020 :             if (!optionp(SHOW_COLOUR))
    1015         [ #  # ]:      41675 :               wstandend(Levelw);
    1016                 :            :           }
    1017                 :            :         }
    1018                 :            :       }
    1019                 :      29782 :       else erase_monster(ml->m);
    1020                 :            :     }
    1021                 :            :   }
    1022                 :       5071 : }
    1023                 :            : 
    1024                 :            : /* replace monster with what would be displayed if monster weren't there */
    1025                 :      30075 : void erase_monster(pmt m)
    1026                 :            : {
    1027         [ +  + ]:      30075 :   if (loc_statusp(m->x,m->y,SEEN))
    1028                 :      30070 :     putspot(m->x,m->y,getspot(m->x,m->y,FALSE));
    1029                 :          5 :   else blotspot(m->x,m->y);
    1030                 :      30075 : }
    1031                 :            : 
    1032                 :            : /* find apt char to display at some location */
    1033                 :     934549 : Symbol getspot(int x, int y, int showmonster)
    1034                 :            : {
    1035                 :            : #ifdef CENTER_ON_PLAYER
    1036                 :            :   /* funny scrolling may cause this. PGM */
    1037                 :            :   if (!inbounds(x,y ) )
    1038                 :            :     {
    1039                 :            :       return SPACE;
    1040                 :            :     }
    1041                 :            : #endif
    1042                 :            : 
    1043         [ +  + ]:     934549 :   if (loc_statusp(x,y,SECRET))
    1044                 :            :     {
    1045         [ -  + ]:        419 :       if ( Level->site[x][y].roomnumber == RS_DRUID )
    1046                 :          0 :         return(HEDGE);  /* secret doors in druid temple are brambles -DAG */
    1047                 :            :       else
    1048                 :        419 :         return(WALL);
    1049                 :            :     }
    1050   [ +  +  +  + ]:     934130 :   else switch (Level->site[x][y].locchar) {
    1051                 :            :   case WATER:
    1052         [ +  + ]:      39287 :     if (Level->site[x][y].creature == NULL) 
    1053                 :      38868 :       return(WATER);
    1054         [ +  - ]:        419 :     else if (m_statusp(Level->site[x][y].creature,SWIMMING))
    1055                 :        419 :       return(WATER);
    1056         [ #  # ]:          0 :     else if (showmonster)
    1057                 :          0 :       return(Level->site[x][y].creature->monchar);
    1058                 :          0 :     else return(WATER);
    1059                 :            :     /* these sites never show anything but their location char's */
    1060                 :            :   case CLOSED_DOOR:
    1061                 :            :   case LAVA:
    1062                 :            :   case FIRE:
    1063                 :            :   case ABYSS:
    1064                 :      15773 :     return(Level->site[x][y].locchar);
    1065                 :            :     /* rubble and hedge don't show items on their location */
    1066                 :            :   case RUBBLE:
    1067                 :            :   case HEDGE:
    1068 [ +  + ][ -  + ]:     136908 :     if (showmonster && (Level->site[x][y].creature != NULL)) {
    1069 [ #  # ][ #  # ]:          0 :       if ((m_statusp(Level->site[x][y].creature,M_INVISIBLE)) &&
    1070                 :          0 :           (! Player.status[TRUESIGHT]))
    1071                 :          0 :         return(getspot(x,y,FALSE));
    1072                 :          0 :       else return (Level->site[x][y].creature->monchar);
    1073                 :            :     }
    1074                 :     136908 :     else return(Level->site[x][y].locchar);
    1075                 :            :     /* everywhere else, first try to show monster, next show items, next show
    1076                 :            :        location char */
    1077                 :            :   default:
    1078 [ +  + ][ +  + ]:     742162 :     if (showmonster && (Level->site[x][y].creature != NULL)) {
    1079 [ -  + ][ #  # ]:          5 :       if ((m_statusp(Level->site[x][y].creature,M_INVISIBLE)) &&
    1080                 :          0 :           (! Player.status[TRUESIGHT]))
    1081                 :          0 :         return(getspot(x,y,FALSE));
    1082                 :          5 :       else return (Level->site[x][y].creature->monchar);
    1083                 :            :     }
    1084         [ +  + ]:     742157 :     else if (Level->site[x][y].things != NULL) {
    1085         [ +  + ]:       2959 :       if (Level->site[x][y].things->next != NULL)
    1086                 :       2722 :         return(PILE);
    1087                 :        237 :       else return(Level->site[x][y].things->thing->objchar);
    1088                 :            :     }
    1089                 :     739198 :     else return(Level->site[x][y].locchar);
    1090                 :            :   }
    1091                 :            : }
    1092                 :            : 
    1093                 :         20 : void commanderror(void)
    1094                 :            : {
    1095                 :         20 :   erasemsg3();
    1096                 :         20 :   wprintw(Msg3w, "%c : unknown command", Cmd);
    1097                 :         20 :   wrefresh(Msg3w);
    1098                 :         20 : }
    1099                 :            : 
    1100                 :        147 : void timeprint(void)
    1101                 :            : {
    1102                 :            :   static char * old_month = 0;
    1103                 :            : 
    1104                 :            :   /* WSS * HACK * This shouldn't be here at all but time is so screwed up */
    1105                 :            :   /* WSS * HACK * I don't know where else I can check for a new month reliably */
    1106         [ +  + ]:        147 :   if (!old_month)
    1107                 :          9 :     old_month = month();
    1108                 :            :   else
    1109                 :            :     {
    1110                 :            :       /* WSS * HACK * ptr comparision... works cause they're static */
    1111 [ -  + ][ #  # ]:        138 :       if (old_month != month() && Player.rank[LEGION] > 0)
    1112                 :            :         {
    1113                 :            :           bank_account * account;
    1114                 :          0 :           account = bank_index_number(SalaryAccount);
    1115         [ #  # ]:          0 :           if (account) account->balance += SalaryAmount;
    1116                 :          0 :           old_month = month();
    1117                 :            :         }
    1118                 :            :     }
    1119                 :            : 
    1120                 :        147 :   wclear(Timew);
    1121                 :        147 :   wprintw(Timew,"%d:%d",showhour(),showminute());
    1122         [ +  + ]:        147 :   if (showminute()==0) waddch(Timew,'0');
    1123         [ +  + ]:        147 :   wprintw(Timew,hour()>11 ? " PM \n" : " AM \n");
    1124                 :        147 :   wprintw(Timew,month());
    1125                 :        147 :   wprintw(Timew," the %d",day());
    1126                 :        147 :   wprintw(Timew,ordinal(day()));
    1127                 :        147 :   wrefresh(Timew);
    1128                 :        147 : }
    1129                 :            : 
    1130                 :            : 
    1131                 :         72 : void comwinprint(void)
    1132                 :            : {
    1133                 :         72 :   wclear(Comwin);
    1134                 :         72 :   wprintw(Comwin,"Hit: %d  \n",Player.hit);
    1135                 :         72 :   wprintw(Comwin,"Dmg: %d  \n",Player.dmg);
    1136                 :         72 :   wprintw(Comwin,"Def: %d  \n",Player.defense);
    1137                 :         72 :   wprintw(Comwin,"Arm: %d  \n",Player.absorption);
    1138                 :         72 :   wprintw(Comwin,"Spd: %d.%d  \n", 5/Player.speed, 500/Player.speed%100);
    1139                 :         72 :   wrefresh(Comwin);
    1140                 :         72 : }
    1141                 :            : 
    1142                 :        518 : void dataprint(void)
    1143                 :            : {
    1144                 :        518 :   wclear(Dataw);
    1145                 :            :   /* WDT HACK: I should make these fields spaced and appropriately justified.
    1146                 :            :    * Maybe I don't feel like it right now. */
    1147                 :        518 :   wprintw(Dataw,"Hp:%d/%d Mana:%ld/%ld Au:%ld Level:%d/%ld Carry:%d/%d \n",
    1148                 :            :           Player.hp,Player.maxhp,Player.mana,Player.maxmana,Player.cash,
    1149                 :            :           Player.level,Player.xp,Player.itemweight,Player.maxweight);
    1150                 :        518 :   wprintw(Dataw,"Str:%d/%d Con:%d/%d Dex:%d/%d Agi:%d/%d Int:%d/%d Pow:%d/%d   ",
    1151                 :            :           Player.str,Player.maxstr,Player.con,Player.maxcon,
    1152                 :            :           Player.dex,Player.maxdex,Player.agi,Player.maxagi,
    1153                 :            :           Player.iq,Player.maxiq,Player.pow,Player.maxpow);
    1154                 :        518 :   wrefresh(Dataw);
    1155                 :        518 : }
    1156                 :            : 
    1157                 :            : 
    1158                 :            : /* redraw everything currently displayed */
    1159                 :          0 : void redraw(void)
    1160                 :            : {
    1161         [ #  # ]:          0 :   touchwin(curscr);
    1162                 :          0 :   wrefresh(curscr);
    1163                 :          0 : }  
    1164                 :            : 
    1165                 :            : /* redraw each permanent window */
    1166                 :         94 : void xredraw(void)
    1167                 :            : {
    1168         [ +  - ]:         94 :   touchwin(Msgw);
    1169         [ +  - ]:         94 :   touchwin(Msg3w);
    1170         [ +  - ]:         94 :   touchwin(Levelw);
    1171         [ +  - ]:         94 :   touchwin(Timew);
    1172         [ +  - ]:         94 :   touchwin(Flagw);
    1173         [ +  - ]:         94 :   touchwin(Dataw);
    1174         [ +  - ]:         94 :   touchwin(Locw);
    1175         [ +  - ]:         94 :   touchwin(Morew);
    1176         [ +  - ]:         94 :   touchwin(Phasew);
    1177         [ +  - ]:         94 :   touchwin(Comwin); 
    1178                 :         94 :   wrefresh(Msgw);
    1179                 :         94 :   wrefresh(Msg3w);
    1180                 :         94 :   wrefresh(Levelw);
    1181                 :         94 :   wrefresh(Timew);
    1182                 :         94 :   wrefresh(Flagw);
    1183                 :         94 :   wrefresh(Dataw);
    1184                 :         94 :   wrefresh(Locw);
    1185                 :         94 :   wrefresh(Morew);
    1186                 :         94 :   wrefresh(Phasew);
    1187                 :         94 :   wrefresh(Comwin);
    1188                 :         94 : }
    1189                 :            : 
    1190                 :            : 
    1191                 :            : 
    1192                 :          0 : void menuaddch(char c)
    1193                 :            : {
    1194                 :          0 :   waddch(Menuw,c);
    1195                 :          0 :   wrefresh(Menuw);
    1196                 :          0 : }
    1197                 :            : 
    1198                 :            : 
    1199                 :            : 
    1200                 :         68 : void morewait(void)
    1201                 :            : {
    1202                 :         68 :   int display=TRUE;
    1203                 :            :   int c;
    1204         [ -  + ]:         68 :   if (gamestatusp(SUPPRESS_PRINTING))
    1205                 :          0 :     return;
    1206                 :            :   do {
    1207                 :        101 :     wclear(Morew);
    1208         [ +  + ]:        101 :     if (display) wprintw(Morew,"***  MORE  ***");
    1209                 :         17 :     else wprintw(Morew,"+++  MORE  +++");
    1210                 :        101 :     display = ! display;
    1211                 :        101 :     wrefresh(Morew);
    1212                 :            :     /* c = wgetch(Msgw); */
    1213                 :        101 :     c = wgetch(Morew);
    1214 [ +  + ][ +  + ]:        101 :   } while ((c != ' ') && (c != RETURN) && (c != EOF));
                 [ +  - ]
    1215                 :         68 :   wclear(Morew);
    1216                 :         68 :   wrefresh(Morew);
    1217                 :            : }
    1218                 :            : 
    1219                 :          0 : int stillonblock(void)
    1220                 :            : {
    1221                 :          0 :   int display=TRUE;
    1222                 :            :   int c;
    1223                 :            :   do {
    1224                 :          0 :     wclear(Morew);
    1225         [ #  # ]:          0 :     if (display) wprintw(Morew,"<<<STAY?>>>");
    1226                 :          0 :     else wprintw(Morew,">>>STAY?<<<");
    1227                 :          0 :     display = ! display;
    1228                 :          0 :     wrefresh(Morew);
    1229                 :          0 :     c = wgetch(Msgw);
    1230 [ #  # ][ #  # ]:          0 :   } while ((c != ' ') && (c != ESCAPE) && (c != EOF));
                 [ #  # ]
    1231                 :          0 :   wclear(Morew);
    1232                 :          0 :   wrefresh(Morew);
    1233                 :          0 :   return (c == ' ');
    1234                 :            : }
    1235                 :            : 
    1236                 :         95 : void menuclear(void)
    1237                 :            : {
    1238                 :         95 :   wclear(Menuw);
    1239         [ +  - ]:         95 :   touchwin(Menuw);
    1240                 :         95 :   wrefresh(Menuw);
    1241                 :         95 : }
    1242                 :            : 
    1243                 :          0 : void menuspellprint(int i)
    1244                 :            : {
    1245                 :            :   int x,y;
    1246 [ #  # ][ #  # ]:          0 :   getyx(Menuw,y,x);
    1247         [ #  # ]:          0 :   if (y >= ScreenLength - 2) {
    1248                 :          0 :     wrefresh(Menuw);
    1249                 :          0 :     morewait();
    1250                 :          0 :     wclear(Menuw);
    1251         [ #  # ]:          0 :     touchwin(Menuw);
    1252                 :            :   }
    1253                 :          0 :   wprintw(Menuw,spellid(i));
    1254                 :          0 :   wprintw(Menuw,"(%d)\n",Spells[i].powerdrain);
    1255                 :          0 : }  
    1256                 :            : 
    1257                 :        665 : void menuprint(char *s)
    1258                 :            : {
    1259                 :            :   int x,y;
    1260 [ +  - ][ +  - ]:        665 :   getyx(Menuw,y,x);
    1261         [ -  + ]:        665 :   if (y >= ScreenLength - 2) {
    1262                 :          0 :     wrefresh(Menuw);
    1263                 :          0 :     morewait();
    1264                 :          0 :     wclear(Menuw);
    1265         [ #  # ]:          0 :     touchwin(Menuw);
    1266                 :            :   }
    1267                 :        665 :   wprintw(Menuw,s);
    1268                 :        665 : }
    1269                 :            : 
    1270                 :         63 : void showmenu(void)
    1271                 :            : {
    1272                 :         63 :   wrefresh(Menuw);
    1273                 :         63 : }
    1274                 :            : 
    1275                 :            : 
    1276                 :         15 : void endgraf(void)
    1277                 :            : {
    1278                 :         15 :   clear();
    1279         [ +  - ]:         15 :   touchwin(stdscr);
    1280                 :         15 :   refresh();
    1281                 :         15 :   endwin();
    1282                 :         15 : }
    1283                 :            : 
    1284                 :            : 
    1285                 :          0 : void plotchar(Symbol pyx, int x, int y)
    1286                 :            : {
    1287         [ #  # ]:          0 :   if (! offscreen(x,y)) {
    1288                 :          0 :     wmove(Levelw,screenmody(y),screenmodx(x));
    1289         [ #  # ]:          0 :     if (optionp(SHOW_COLOUR))
    1290         [ #  # ]:          0 :       wattrset(Levelw, CHARATTR(pyx));
    1291                 :          0 :     waddch(Levelw,(pyx&0xff));
    1292                 :          0 :     wrefresh(Levelw);
    1293                 :            :   }
    1294                 :          0 : }
    1295                 :            : 
    1296                 :            : 
    1297                 :            : 
    1298                 :          0 : void draw_explosion(Symbol pyx, int x, int y)
    1299                 :            : {
    1300                 :            :   int i,j;
    1301                 :            :   
    1302         [ #  # ]:          0 :   for(j=0;j<3;j++) {
    1303         [ #  # ]:          0 :     for(i=0;i<9;i++) 
    1304                 :          0 :       plotchar(pyx,x+Dirs[0][i],y+Dirs[1][i]);
    1305                 :          0 :     usleep(150000);
    1306         [ #  # ]:          0 :     for(i=0;i<9;i++)
    1307                 :          0 :       plotchar(SPACE,x+Dirs[0][i],y+Dirs[1][i]);
    1308                 :          0 :     usleep(150000);
    1309                 :            :   }
    1310         [ #  # ]:          0 :   for(i=0;i<9;i++) 
    1311                 :          0 :     plotspot(x+Dirs[0][i],y+Dirs[1][i],TRUE);
    1312                 :          0 :   wrefresh(Levelw);
    1313                 :          0 : }
    1314                 :            : 
    1315                 :          7 : char *msgscanstring(void)
    1316                 :            : {
    1317                 :            :   static char instring[80],byte='x';
    1318                 :          7 :   int i=0;
    1319                 :            : 
    1320                 :          7 :   instring[0]=0;
    1321                 :          7 :   byte = mgetc();
    1322         [ +  + ]:         54 :   while (byte != '\n') {
    1323 [ +  - ][ +  + ]:         48 :     if ((byte == 8) || (byte == 127)) { /* ^h or delete */
    1324         [ +  + ]:          8 :       if (i>0){ 
    1325                 :          4 :         i--;
    1326                 :          4 :         dobackspace();
    1327                 :            :       }
    1328                 :          8 :       instring[i] = 0;
    1329                 :            :     }
    1330                 :            :     else {
    1331                 :         40 :       instring[i] = byte;
    1332                 :         40 :       waddch(Msgw,byte);
    1333                 :         40 :       wrefresh(Msgw);
    1334                 :         40 :       i++;
    1335                 :         40 :       instring[i] = 0;
    1336                 :            :     }
    1337                 :         48 :     byte = mgetc();
    1338                 :            :   } 
    1339                 :          6 :   return(instring);
    1340                 :            : }
    1341                 :            : 
    1342                 :            : 
    1343                 :        131 : void locprint(char *s)
    1344                 :            : {
    1345                 :        131 :   wclear(Locw);
    1346                 :        131 :   wprintw(Locw,s);
    1347                 :        131 :   wrefresh(Locw);
    1348                 :        131 : }
    1349                 :            : 
    1350                 :            : /* draw everything whether visible or not */
    1351                 :          0 : void drawscreen(void)
    1352                 :            : {
    1353                 :            :   int i,j;
    1354         [ #  # ]:          0 :   if (Current_Environment == E_COUNTRYSIDE)
    1355         [ #  # ]:          0 :     for (i=0;i<COUNTRY_WIDTH;i++)
    1356         [ #  # ]:          0 :       for(j=0;j<COUNTRY_LENGTH;j++)
    1357                 :          0 :         c_set(i, j, SEEN);
    1358         [ #  # ]:          0 :   else for (i=0;i<Level->level_width;i++)
    1359         [ #  # ]:          0 :     for(j=0;j<Level->level_length;j++)
    1360                 :          0 :       lset(i,j,SEEN);
    1361         [ #  # ]:          0 :   if (Current_Environment == E_CITY)
    1362         [ #  # ]:          0 :     for (i = 0; i < NUMCITYSITES; i++)
    1363                 :          0 :       CitySiteList[i][0] = 1;
    1364                 :          0 :   show_screen();
    1365                 :          0 : }
    1366                 :            : 
    1367                 :            : /*selects a number up to range */
    1368                 :            : /* WDT HACK!  This should use the interaction code, and should allow
    1369                 :            :  * direct input. */
    1370                 :          2 : int getnumber(int range)
    1371                 :            : {
    1372                 :          2 :   int done=FALSE,value=1;
    1373                 :            :   int atom;
    1374                 :            : 
    1375         [ -  + ]:          2 :   if (range==1) return(1);
    1376         [ +  + ]:         19 :   else while (! done) {
    1377                 :         17 :     clearmsg();
    1378                 :         17 :     wprintw(Msg1w,"How many? Change with < or >, ESCAPE to select:");
    1379                 :         17 :     mnumprint(value);
    1380                 :            : #ifndef MSDOS
    1381                 :         19 :     do atom=mcigetc();
    1382 [ +  - ][ +  + ]:         19 :     while ((atom != '<')&&(atom != '>')&&(atom!=ESCAPE));
                 [ +  + ]
    1383 [ +  + ][ +  + ]:         17 :     if ((atom=='>') && (value < range)) value++;
    1384 [ -  + ][ #  # ]:          4 :     else if ((atom=='<') && (value > 1)) value--;
    1385         [ +  + ]:          4 :     else if (atom==ESCAPE) done = TRUE;
    1386                 :            : #else
    1387                 :            :     atom=mcigetc();
    1388                 :            :     switch (atom)
    1389                 :            :       {
    1390                 :            :       case '>':
    1391                 :            :       case 'k':
    1392                 :            : #ifdef KEY_UP
    1393                 :            :       case KEY_UP:
    1394                 :            : #endif
    1395                 :            :         if (value < range)
    1396                 :            :           value++;
    1397                 :            :         break;
    1398                 :            :       case '<':
    1399                 :            :       case 'j':
    1400                 :            : #ifdef KEY_DOWN
    1401                 :            :       case KEY_DOWN:
    1402                 :            : #endif
    1403                 :            :         if (value > 1)
    1404                 :            :           value--;
    1405                 :            :         break;
    1406                 :            : #ifdef KEY_HOME
    1407                 :            :       case KEY_HOME:
    1408                 :            : #endif
    1409                 :            :         value = 1;
    1410                 :            :         break;
    1411                 :            : #ifdef KEY_LL
    1412                 :            :       case KEY_LL:
    1413                 :            : #endif
    1414                 :            :         value = range;
    1415                 :            :         break;
    1416                 :            :       case ESCAPE:
    1417                 :            :         done = TRUE;
    1418                 :            :         break;
    1419                 :            :       }
    1420                 :            : #endif
    1421                 :            :   }
    1422                 :          2 :   return(value);
    1423                 :            : }
    1424                 :            : 
    1425                 :          0 : static long input_number (WINDOW * w)
    1426                 :            : {
    1427                 :            :   int ch;
    1428                 :            :   int ypos, xpos;
    1429                 :          0 :   int numlen = 0;
    1430                 :          0 :   int amount = 0;
    1431                 :            : 
    1432 [ #  # ][ #  # ]:          0 :   getyx(w, ypos, xpos);
    1433                 :            : 
    1434                 :            :   while (1)
    1435                 :            :     {
    1436         [ #  # ]:          0 :       ch = mvwgetch(w, ypos, xpos);
    1437                 :            : 
    1438 [ #  # ][ #  # ]:          0 :       if ('\n' == ch || '\r' == ch)
    1439                 :            :         {
    1440                 :          0 :           return amount;
    1441                 :            :         }
    1442 [ #  # ][ #  # ]:          0 :       else if (EOF == ch || ESCAPE == ch)
    1443                 :            :         {
    1444                 :          0 :           return ABORT;
    1445                 :            :         }
    1446 [ #  # ][ #  # ]:          0 :       else if (BACKSPACE == ch || DELETE == ch)
    1447                 :            :         {
    1448         [ #  # ]:          0 :           if (numlen > 0)
    1449                 :            :             {
    1450                 :          0 :               --numlen;
    1451                 :          0 :               amount /= 10;
    1452         [ #  # ]:          0 :               mvwaddch(w, ypos, --xpos, ' ');
    1453                 :            :             }
    1454                 :            :         }
    1455 [ #  # ][ #  # ]:          0 :       else if (isdigit(ch) && (numlen < 9))
    1456                 :            :         {
    1457                 :          0 :           ++xpos;
    1458                 :          0 :           ++numlen;
    1459                 :          0 :           waddch(w, ch);
    1460                 :          0 :           amount = 10 * amount + (ch - '0');
    1461                 :            :         }
    1462                 :            :       else
    1463                 :            :         {
    1464                 :          0 :           beep();
    1465                 :            :         }
    1466                 :          0 :     }
    1467                 :            : }
    1468                 :            : 
    1469                 :            : /* reads a positive number up to 999999 */
    1470                 :            : /* WDT: now asks for the number, and receives it through the cinema
    1471                 :            :  * interface.  Returns ABORT (-1) if aborted. */
    1472                 :          3 : long parsenum (char *message)
    1473                 :            : {
    1474                 :            :   int number[8];
    1475                 :          3 :   int place = -1;
    1476                 :          3 :   int i,x,y,mult=1;
    1477                 :          3 :   long num=0;
    1478                 :          3 :   char byte=' ';
    1479                 :          3 :   int entering_digits = TRUE;
    1480                 :            : 
    1481                 :          3 :   cinema_display(message, "enter a number or ESC: ", NULL);
    1482         [ +  + ]:          9 :   while (entering_digits) {
    1483                 :          6 :     byte = wgetch(Cinema);
    1484 [ +  - ][ -  + ]:          6 :     if ((byte == BACKSPACE) || (byte == DELETE)) {
    1485         [ #  # ]:          0 :       if (place > -1) {
    1486                 :          0 :         number[place] = 0;
    1487                 :          0 :         place--;
    1488 [ #  # ][ #  # ]:          0 :         getyx(Cinema,y,x);
    1489                 :          0 :         wmove(Cinema,y,x-1);
    1490                 :          0 :         waddch(Cinema,' ');
    1491                 :          0 :         wmove(Cinema,y,x-1);
    1492                 :          0 :         wrefresh(Cinema);
    1493                 :            :       }
    1494                 :            :     }
    1495 [ +  - ][ +  + ]:          6 :     else if ((byte <= '9') && (byte >= '0') && (place < 7)) {
                 [ +  - ]
    1496                 :          3 :       place++;
    1497                 :          3 :       number[place]=byte;
    1498                 :          3 :       waddch(Cinema,byte);
    1499                 :          3 :       wrefresh(Cinema);
    1500                 :            :     }
    1501         [ +  - ]:          3 :     else if (isprint(byte)) {
    1502                 :            :       /* I suppose I should beep here, to indicate that only digits belong.
    1503                 :            :        * Right now I'm just ignoring them.
    1504                 :            :        */
    1505                 :            :     }
    1506                 :          3 :     else entering_digits = 0;
    1507                 :            :   }
    1508         [ +  + ]:          3 :   if (byte != '\n') num = ABORT;
    1509                 :            :   else {
    1510         [ +  + ]:          5 :     for (i=place;i>=0;i--) {
    1511                 :          3 :       num += mult*(number[i]-'0');
    1512                 :          3 :       mult*=10;
    1513                 :            :     }
    1514                 :            :   }
    1515                 :          3 :   cinema_hide();
    1516                 :          3 :   return num;
    1517                 :            : }
    1518                 :            : 
    1519                 :            : 
    1520                 :            :     
    1521                 :          0 : void maddch(char c)
    1522                 :            : {
    1523                 :          0 :   waddch(Msgw,c);
    1524                 :          0 :   wrefresh(Msgw);
    1525                 :          0 : }
    1526                 :            : 
    1527                 :            : 
    1528                 :          0 : void display_death(char *source)
    1529                 :            : {
    1530                 :          0 :   clear();
    1531         [ #  # ]:          0 :   touchwin(stdscr);
    1532                 :          0 :   printw("\n\n\n\n");
    1533                 :          0 :   printw("Requiescat In Pace, ");
    1534                 :          0 :   printw(Player.name);
    1535                 :          0 :   printw(" (%ld points)",calc_points());
    1536                 :          0 :   strcpy(Str4,"Killed by ");
    1537                 :          0 :   strcat(Str4,source);
    1538                 :          0 :   printw("\n");
    1539                 :          0 :   printw(Str4);
    1540                 :          0 :   printw(".");
    1541                 :          0 :   printw("\n\n\n\n\nHit 'c' to continue.");
    1542                 :          0 :   refresh();
    1543         [ #  # ]:          0 :   while (wgetch(stdscr) != 'c')
    1544                 :            :         ;
    1545                 :          0 :   clear();
    1546         [ #  # ]:          0 :   touchwin(stdscr);
    1547                 :          0 :   refresh();
    1548                 :          0 :   extendlog(Str4,DEAD);
    1549                 :          0 : }
    1550                 :            : 
    1551                 :            : 
    1552                 :          0 : void display_win(void)
    1553                 :            : {
    1554                 :          0 :   clear();
    1555         [ #  # ]:          0 :   touchwin(stdscr);
    1556                 :          0 :   printw("\n\n\n\n");
    1557                 :          0 :   printw(Player.name);
    1558         [ #  # ]:          0 :   if (Player.rank[ADEPT]) {
    1559                 :          0 :     printw(" is a total master of omega with %ld points!",FixedPoints);
    1560                 :          0 :     strcpy(Str4,"A total master of omega");
    1561                 :            :   }
    1562                 :            :   else {
    1563                 :          0 :     strcpy(Str4,"retired a winner");
    1564                 :          0 :     printw(" triumphed in omega with %ld points!",calc_points());
    1565                 :            :   }
    1566                 :          0 :   printw("\n\n\n\n\nHit 'c' to continue.");
    1567                 :          0 :   refresh();
    1568         [ #  # ]:          0 :   while (wgetch(stdscr) != 'c')
    1569                 :            :         ;
    1570                 :          0 :   clear();
    1571         [ #  # ]:          0 :   touchwin(stdscr);
    1572                 :          0 :   refresh();
    1573         [ #  # ]:          0 :   if (Player.rank[ADEPT])
    1574                 :          0 :     extendlog(Str4,BIGWIN);
    1575                 :          0 :   else extendlog(Str4,WIN);
    1576                 :          0 : }
    1577                 :            : 
    1578                 :          8 : void display_quit(void)
    1579                 :            : {
    1580                 :          8 :   clear();
    1581         [ +  - ]:          8 :   touchwin(stdscr);
    1582                 :          8 :   printw("\n\n\n\n");
    1583                 :          8 :   printw(Player.name);
    1584                 :          8 :   strcpy(Str4,"A quitter.");
    1585                 :          8 :   printw(" wimped out with %ld points!",calc_points());
    1586                 :          8 :   printw("\n\n\n\n\nHit 'c' to continue.");
    1587                 :          8 :   refresh();
    1588         [ +  + ]:         10 :   while (wgetch(stdscr) != 'c')
    1589                 :            :         ;
    1590                 :          8 :   clear();
    1591         [ +  - ]:          8 :   touchwin(stdscr);
    1592                 :          8 :   refresh();
    1593                 :          8 :   extendlog(Str4,QUIT);
    1594                 :          8 : }
    1595                 :            : 
    1596                 :            : 
    1597                 :          0 : void display_bigwin(void)
    1598                 :            : {
    1599                 :          0 :   clear();
    1600         [ #  # ]:          0 :   touchwin(stdscr);
    1601                 :          0 :   printw("\n\n\n\n");
    1602                 :          0 :   printw(Player.name);
    1603                 :          0 :   strcpy(Str4,"retired, an Adept of Omega.");
    1604                 :          0 :   printw(" retired, an Adept of Omega with %ld points!",FixedPoints);
    1605                 :          0 :   printw("\n\n\n\n\nHit 'c' to continue.");
    1606                 :          0 :   refresh();
    1607         [ #  # ]:          0 :   while (wgetch(stdscr) != 'c')
    1608                 :            :         ;
    1609                 :          0 :   clear();
    1610         [ #  # ]:          0 :   touchwin(stdscr);
    1611                 :          0 :   refresh();
    1612                 :          0 :   extendlog(Str4,BIGWIN);
    1613                 :          0 : }
    1614                 :            : 
    1615                 :            : 
    1616                 :         22 : void mnumprint(int n)
    1617                 :            : {
    1618                 :            :   char numstr[20];
    1619                 :         22 :   sprintf(numstr,"%d",n);
    1620                 :         22 :   bufferappend(numstr);
    1621                 :         22 :   wprintw(Msgw,"%d",n);
    1622                 :         22 :   wrefresh(Msgw);
    1623                 :         22 : }
    1624                 :            : 
    1625                 :          1 : void mlongprint(long n)
    1626                 :            : {
    1627                 :            :   char numstr[20];
    1628                 :          1 :   sprintf(numstr,"%ld",n);
    1629                 :          1 :   bufferappend(numstr);
    1630                 :          1 :   wprintw(Msgw,"%ld",n);
    1631                 :          1 :   wrefresh(Msgw);
    1632                 :          1 : }
    1633                 :            : 
    1634                 :            : 
    1635                 :          0 : void menunumprint(int n)
    1636                 :            : {
    1637                 :            :   int x,y;
    1638 [ #  # ][ #  # ]:          0 :   getyx(Menuw,y,x);
    1639         [ #  # ]:          0 :   if (y >= ScreenLength - 2) {
    1640                 :          0 :     wrefresh(Menuw);
    1641                 :          0 :     morewait();
    1642                 :          0 :     wclear(Menuw);
    1643         [ #  # ]:          0 :     touchwin(Menuw);
    1644                 :            :   }
    1645                 :          0 :   wprintw(Menuw,"%d",n);
    1646                 :          0 : }
    1647                 :            : 
    1648                 :          0 : void menulongprint(long n)
    1649                 :            : {
    1650                 :            :   int x,y;
    1651 [ #  # ][ #  # ]:          0 :   getyx(Menuw,y,x);
    1652         [ #  # ]:          0 :   if (y >= ScreenLength - 2) {
    1653                 :          0 :     wrefresh(Menuw);
    1654                 :          0 :     morewait();
    1655                 :          0 :     wclear(Menuw);
    1656         [ #  # ]:          0 :     touchwin(Menuw);
    1657                 :            :   }
    1658                 :          0 :   wprintw(Menuw,"%ld",n);
    1659                 :          0 : }
    1660                 :            : 
    1661                 :            : 
    1662                 :          4 : void dobackspace(void)
    1663                 :            : {
    1664                 :            :   int x,y;
    1665                 :            : 
    1666 [ +  - ][ +  - ]:          4 :   getyx(Msgw,y,x);
    1667         [ +  - ]:          4 :   if (x > 0) {
    1668                 :          4 :     waddch(Msgw,' ');
    1669                 :          4 :     wmove(Msgw,y,x-1);
    1670                 :          4 :     waddch(Msgw,' ');
    1671                 :          4 :     wmove(Msgw,y,x-1);
    1672                 :            :   }
    1673                 :          4 :   wrefresh(Msgw);
    1674                 :          4 : }
    1675                 :            : 
    1676                 :            : 
    1677                 :        331 : void showflags(void)
    1678                 :            : {
    1679                 :            : 
    1680                 :        331 :   phaseprint();
    1681                 :        331 :   wclear(Flagw);
    1682         [ -  + ]:        331 :   if (Player.food < 0)
    1683                 :          0 :     wprintw(Flagw,"Starving\n");
    1684         [ -  + ]:        331 :   else if (Player.food <= 3)
    1685                 :          0 :     wprintw(Flagw,"Weak\n");
    1686         [ -  + ]:        331 :   else if (Player.food <= 10)
    1687                 :          0 :     wprintw(Flagw,"Ravenous\n");
    1688         [ +  + ]:        331 :   else if (Player.food <= 20)
    1689                 :          2 :     wprintw(Flagw,"Hungry\n");
    1690         [ +  + ]:        329 :   else if (Player.food <= 30)
    1691                 :         80 :     wprintw(Flagw,"A mite peckish\n");
    1692         [ +  + ]:        249 :   else if (Player.food <= 36)
    1693                 :        201 :     wprintw(Flagw,"Content\n");
    1694         [ +  - ]:         48 :   else if (Player.food <= 44)
    1695                 :         48 :     wprintw(Flagw,"Satiated\n");
    1696                 :          0 :   else wprintw(Flagw,"Bloated\n");
    1697                 :            : 
    1698                 :            : 
    1699         [ -  + ]:        331 :   if (Player.status[POISONED]>0)
    1700                 :          0 :     wprintw(Flagw,"Poisoned\n");
    1701                 :        331 :   else wprintw(Flagw,"Vigorous\n");
    1702                 :            : 
    1703         [ -  + ]:        331 :   if (Player.status[DISEASED]>0)
    1704                 :          0 :     wprintw(Flagw,"Diseased\n");
    1705                 :        331 :   else wprintw(Flagw,"Healthy\n");
    1706                 :            : 
    1707         [ +  + ]:        331 :   if (gamestatusp(MOUNTED)) wprintw(Flagw,"Mounted\n");
    1708         [ -  + ]:         74 :   else if (Player.status[LEVITATING]) wprintw(Flagw,"Levitating\n");
    1709                 :         74 :   else wprintw(Flagw,"Afoot\n");
    1710                 :            : 
    1711                 :        331 :   wrefresh(Flagw);
    1712                 :        331 : }
    1713                 :            : 
    1714                 :          0 : void drawomega(void)
    1715                 :            : {
    1716                 :            :   int i;
    1717                 :          0 :   clear();
    1718         [ #  # ]:          0 :   touchwin(stdscr);
    1719         [ #  # ]:          0 :   for(i=0;i<7;i++) {
    1720                 :          0 :     move(1, 1);
    1721         [ #  # ]:          0 :     if (optionp(SHOW_COLOUR))
    1722         [ #  # ]:          0 :       wattrset(stdscr, CHARATTR(CLR(LIGHT_BLUE)));
    1723                 :          0 :     printw("\n\n\n");
    1724                 :          0 :     printw("\n                                    *****");
    1725                 :          0 :     printw("\n                               ******   ******");
    1726                 :          0 :     printw("\n                             ***             ***");
    1727                 :          0 :     printw("\n                           ***                 ***");
    1728                 :          0 :     printw("\n                          **                     **");
    1729                 :          0 :     printw("\n                         ***                     ***");
    1730                 :          0 :     printw("\n                         **                       **");
    1731                 :          0 :     printw("\n                         **                       **");
    1732                 :          0 :     printw("\n                         ***                     ***");
    1733                 :          0 :     printw("\n                          ***                   ***");
    1734                 :          0 :     printw("\n                            **                 **");
    1735                 :          0 :     printw("\n                       *   ***                ***   *");
    1736                 :          0 :     printw("\n                        ****                    ****");
    1737                 :          0 :     refresh();
    1738                 :          0 :     usleep(200000);
    1739                 :          0 :     move(1, 1);
    1740         [ #  # ]:          0 :     if (optionp(SHOW_COLOUR))
    1741         [ #  # ]:          0 :       wattrset(stdscr, CHARATTR(CLR(CYAN)));
    1742                 :          0 :     printw("\n\n\n");
    1743                 :          0 :     printw("\n                                    +++++");
    1744                 :          0 :     printw("\n                               ++++++   ++++++");
    1745                 :          0 :     printw("\n                             +++             +++");
    1746                 :          0 :     printw("\n                           +++                 +++");
    1747                 :          0 :     printw("\n                          ++                     ++");
    1748                 :          0 :     printw("\n                         +++                     +++");
    1749                 :          0 :     printw("\n                         ++                       ++");
    1750                 :          0 :     printw("\n                         ++                       ++");
    1751                 :          0 :     printw("\n                         +++                     +++");
    1752                 :          0 :     printw("\n                          +++                   +++");
    1753                 :          0 :     printw("\n                            ++                 ++");
    1754                 :          0 :     printw("\n                       +   +++                +++   +");
    1755                 :          0 :     printw("\n                        ++++                    ++++");
    1756                 :          0 :     refresh();
    1757                 :          0 :     usleep(200000);
    1758                 :          0 :     move(1, 1);
    1759         [ #  # ]:          0 :     if (optionp(SHOW_COLOUR))
    1760         [ #  # ]:          0 :       wattrset(stdscr, CHARATTR(CLR(BLUE)));
    1761                 :          0 :     printw("\n\n\n");
    1762                 :          0 :     printw("\n                                    .....");
    1763                 :          0 :     printw("\n                               ......   ......");
    1764                 :          0 :     printw("\n                             ...             ...");
    1765                 :          0 :     printw("\n                           ...                 ...");
    1766                 :          0 :     printw("\n                          ..                     ..");
    1767                 :          0 :     printw("\n                         ...                     ...");
    1768                 :          0 :     printw("\n                         ..                       ..");
    1769                 :          0 :     printw("\n                         ..                       ..");
    1770                 :          0 :     printw("\n                         ...                     ...");
    1771                 :          0 :     printw("\n                          ...                   ...");
    1772                 :          0 :     printw("\n                            ..                 ..");
    1773                 :          0 :     printw("\n                       .   ...                ...   .");
    1774                 :          0 :     printw("\n                        ....                    ....");
    1775                 :          0 :     refresh();
    1776                 :          0 :     usleep(200000);
    1777                 :            :   }
    1778         [ #  # ]:          0 :   wattrset(stdscr, CHARATTR(CLR(WHITE)));
    1779                 :          0 : }
    1780                 :            : 
    1781                 :            : /* y is an absolute coordinate */
    1782                 :            : /* ScreenOffset is the upper left hand corner of the current screen
    1783                 :            :    in absolute coordinates */
    1784                 :            : #if 0
    1785                 :            : void screencheck(int y)
    1786                 :            : {
    1787                 :            :   if (((y-ScreenOffset) < (ScreenLength/8)) ||
    1788                 :            :       ((y-ScreenOffset) > (7*ScreenLength/8))) {
    1789                 :            :     ScreenOffset = y - (ScreenLength/2);
    1790                 :            :     show_screen();
    1791                 :            :     if (Current_Environment != E_COUNTRYSIDE) 
    1792                 :            :       drawmonsters(TRUE);
    1793                 :            :     if (!offscreen(Player.x,Player.y))
    1794                 :            :       drawplayer();
    1795                 :            :   }
    1796                 :            : }
    1797                 :            : #else
    1798                 :       1370 : void screencheck(int x, int y)
    1799                 :            : {
    1800                 :       1370 :   int change = 0;
    1801                 :            : #ifdef CENTER_ON_PLAYER
    1802                 :            : 
    1803                 :            :   change = 1;
    1804                 :            :   ScreenOffset = y - (ScreenLength/2);
    1805                 :            :   ScreenXOffset = x - (ScreenWidth/2);
    1806                 :            : 
    1807                 :            : 
    1808                 :            : #else
    1809                 :            : #if 0
    1810                 :            :   int width = 0;
    1811                 :            : #endif
    1812                 :            : 
    1813 [ +  + ][ +  + ]:       1370 :   if (((y-ScreenOffset) < (ScreenLength/8)) ||
    1814                 :        512 :       ((y-ScreenOffset) > (7*ScreenLength/8))) {
    1815                 :        867 :     change = 1;
    1816                 :        867 :     ScreenOffset = y - (ScreenLength/2);
    1817                 :            :   }
    1818                 :            : 
    1819 [ +  + ][ +  + ]:       1370 :   if (((x-ScreenXOffset) < (ScreenWidth/8)) ||
    1820                 :       1040 :       ((x-ScreenXOffset) > (7*ScreenWidth/8))) {
    1821                 :            : 
    1822                 :            : #if 0
    1823                 :            :     if ( Current_Environment == E_COUNTRYSIDE )
    1824                 :            :       width = COUNTRY_WIDTH;
    1825                 :            :     else
    1826                 :            :       width = Level->level_width;
    1827                 :            : 
    1828                 :            :     /*
    1829                 :            :       PGM: this code prevents scrolling when near the right edge of the level,
    1830                 :            :       but this unfortunately results in a badly placed view when, for examples,
    1831                 :            :       restoring a save near the edge of a level. Ideas on fixing this, or moving
    1832                 :            :       it, appreciated.  PGM July 1999.
    1833                 :            :     */
    1834                 :            :     if ( ( (x-ScreenXOffset) + (7*ScreenWidth/8) ) < width +( ScreenWidth/8 ) )
    1835                 :            : #endif
    1836                 :            :       {
    1837                 :        335 :         change = 1;
    1838                 :        335 :         ScreenXOffset = x - (ScreenWidth/2);
    1839         [ +  + ]:        335 :         if (ScreenXOffset < 0)
    1840                 :        328 :           ScreenXOffset = 0;
    1841                 :            :       }
    1842                 :            :   }
    1843                 :            : 
    1844                 :            : #endif
    1845         [ +  + ]:       1370 :   if ( change == 1 ) {
    1846                 :        872 :     show_screen();
    1847         [ +  + ]:        872 :     if (Current_Environment != E_COUNTRYSIDE) 
    1848                 :        827 :       drawmonsters(TRUE);
    1849         [ +  - ]:        872 :     if (!offscreen(Player.x,Player.y))
    1850                 :        872 :       drawplayer();
    1851                 :            :   }
    1852                 :       1370 : }
    1853                 :            : #endif
    1854                 :            : 
    1855                 :          0 : void spreadroomlight(int x, int y, int roomno)
    1856                 :            : {
    1857 [ #  # ][ #  # ]:          0 :   if (inbounds(x,y) && !loc_statusp(x,y,LIT) &&
                 [ #  # ]
    1858                 :          0 :       Level->site[x][y].roomnumber == roomno) {
    1859                 :          0 :     lightspot(x,y);
    1860                 :          0 :     spreadroomlight(x+1,y,roomno);
    1861                 :          0 :     spreadroomlight(x,y+1,roomno);
    1862                 :          0 :     spreadroomlight(x-1,y,roomno);
    1863                 :          0 :     spreadroomlight(x,y-1,roomno);
    1864                 :            :   }
    1865                 :          0 : }
    1866                 :            : 
    1867                 :            : /* illuminate one spot at x y */
    1868                 :          0 : void lightspot(int x, int y)
    1869                 :            : { 
    1870                 :            :   Symbol c;
    1871                 :          0 :   lset(x,y,LIT);
    1872                 :          0 :   lset(x,y,SEEN);
    1873                 :          0 :   lset(x, y, CHANGED);
    1874                 :          0 :   c = getspot(x,y,FALSE);
    1875                 :          0 :   Level->site[x][y].showchar = c;
    1876                 :          0 :   putspot(x,y,c);
    1877                 :          0 : }
    1878                 :            : 
    1879                 :            : 
    1880                 :          0 : void spreadroomdark(int x, int y, int roomno)
    1881                 :            : {
    1882         [ #  # ]:          0 :   if (inbounds(x,y))
    1883 [ #  # ][ #  # ]:          0 :     if (loc_statusp(x,y,LIT) && (Level->site[x][y].roomnumber == roomno)) {
    1884                 :          0 :       blankoutspot(x,y);
    1885                 :          0 :       spreadroomdark(x+1,y,roomno);
    1886                 :          0 :       spreadroomdark(x,y+1,roomno);
    1887                 :          0 :       spreadroomdark(x-1,y,roomno);
    1888                 :          0 :       spreadroomdark(x,y-1,roomno);
    1889                 :            :     }
    1890                 :          0 : }
    1891                 :            : 
    1892                 :            : 
    1893                 :          0 : void display_pack(void)
    1894                 :            : {
    1895                 :            :   int i;
    1896         [ #  # ]:          0 :   if (Player.packptr < 1) print3("Pack is empty.");
    1897                 :            :   else {
    1898                 :          0 :     menuclear();
    1899                 :          0 :     menuprint("Items in Pack:\n");
    1900         [ #  # ]:          0 :     for(i=0;i<Player.packptr;i++) {
    1901                 :          0 :       sprintf(Str1, "  %c: %s\n", i + 'A', itemid(Player.pack[i]));
    1902                 :          0 :       menuprint(Str1);
    1903                 :            :     }
    1904                 :          0 :     showmenu();
    1905                 :            :   }
    1906                 :          0 : }
    1907                 :            : 
    1908                 :            : 
    1909                 :         48 : void display_possessions(void)
    1910                 :            : {
    1911                 :            :   int i;
    1912         [ +  + ]:        816 :   for(i=0;i<MAXITEMS;i++) 
    1913                 :        768 :     display_inventory_slot(i,FALSE);
    1914                 :         48 : }
    1915                 :            : 
    1916                 :            : 
    1917                 :        912 : void display_inventory_slot(int slotnum, int topline)
    1918                 :            : {
    1919                 :            :   WINDOW *W;
    1920                 :        912 :   char usechar = ')', idchar = '-';
    1921         [ +  + ]:        912 :   if (Player.possessions[slotnum] != NULL)
    1922         [ +  + ]:        340 :     if (Player.possessions[slotnum]->used)
    1923                 :        108 :       usechar = '>';
    1924         [ -  + ]:        912 :   if (topline) W = Msg3w;
    1925                 :            :   else {
    1926                 :        912 :     W = Showline[slotnum];
    1927                 :        912 :     hide_line(slotnum);
    1928                 :            :   }
    1929                 :        912 :   idchar = index_to_key(slotnum);
    1930         [ +  - ]:        912 :   touchwin(W);
    1931                 :        912 :   wclear(W);
    1932   [ +  +  +  +  :        912 :   switch(slotnum) {
          +  +  +  +  +  
          +  +  +  +  +  
                +  +  - ]
    1933                 :            :   case O_UP_IN_AIR:
    1934                 :        146 :     wprintw(W,"-- Object 'up in air':",usechar);
    1935                 :        146 :     break;
    1936                 :            :   case O_READY_HAND:
    1937                 :         54 :     wprintw(W,"-- %c%c ready hand: ",idchar,usechar);
    1938                 :         54 :     break;
    1939                 :            :   case O_WEAPON_HAND:
    1940                 :         54 :     wprintw(W,"-- %c%c weapon hand: ",idchar,usechar);
    1941                 :         54 :     break;
    1942                 :            :   case O_LEFT_SHOULDER:
    1943                 :         51 :     wprintw(W,"-- %c%c left shoulder: ",idchar,usechar);
    1944                 :         51 :     break;
    1945                 :            :   case O_RIGHT_SHOULDER:
    1946                 :         50 :     wprintw(W,"-- %c%c right shoulder: ",idchar,usechar);
    1947                 :         50 :     break;
    1948                 :            :   case O_BELT1:
    1949                 :         54 :     wprintw(W,"-- %c%c belt: ",idchar,usechar);
    1950                 :         54 :     break;
    1951                 :            :   case O_BELT2:
    1952                 :         54 :     wprintw(W,"-- %c%c belt: ",idchar,usechar);
    1953                 :         54 :     break;
    1954                 :            :   case O_BELT3:
    1955                 :         59 :     wprintw(W,"-- %c%c belt: ",idchar,usechar);
    1956                 :         59 :     break;
    1957                 :            :   case O_SHIELD:
    1958                 :         48 :     wprintw(W,"-- %c%c shield: ",idchar,usechar);
    1959                 :         48 :     break;
    1960                 :            :   case O_ARMOR:
    1961                 :         54 :     wprintw(W,"-- %c%c armor: ",idchar,usechar);
    1962                 :         54 :     break;
    1963                 :            :   case O_BOOTS:
    1964                 :         48 :     wprintw(W,"-- %c%c boots: ",idchar,usechar);
    1965                 :         48 :     break;
    1966                 :            :   case O_CLOAK:
    1967                 :         48 :     wprintw(W,"-- %c%c cloak: ",idchar,usechar);
    1968                 :         48 :     break;
    1969                 :            :   case O_RING1:
    1970                 :         48 :     wprintw(W,"-- %c%c finger: ",idchar,usechar);
    1971                 :         48 :     break;
    1972                 :            :   case O_RING2:
    1973                 :         48 :     wprintw(W,"-- %c%c finger: ",idchar,usechar);
    1974                 :         48 :     break;
    1975                 :            :   case O_RING3:
    1976                 :         48 :     wprintw(W,"-- %c%c finger: ",idchar,usechar);
    1977                 :         48 :     break;
    1978                 :            :   case O_RING4:
    1979                 :         48 :     wprintw(W,"-- %c%c finger: ",idchar,usechar);
    1980                 :         48 :     break;
    1981                 :            :   }
    1982         [ +  + ]:        912 :   if (Player.possessions[slotnum]== NULL)
    1983                 :        572 :     wprintw(W,"(slot vacant)");
    1984                 :        340 :   else wprintw(W,itemid(Player.possessions[slotnum]));
    1985                 :        912 :   wrefresh(W);
    1986                 :        912 : }
    1987                 :            : 
    1988                 :         68 : int move_slot(int oldslot, int newslot, int maxslot)
    1989                 :            : {
    1990 [ +  + ][ +  - ]:         68 :   if ((newslot >= 0) && (newslot < maxslot)){
    1991                 :         67 :     wmove(Showline[oldslot],0,0);
    1992                 :         67 :     waddstr(Showline[oldslot],"--");
    1993                 :         67 :     wrefresh(Showline[oldslot]);
    1994                 :         67 :     wmove(Showline[newslot],0,0);
    1995         [ +  - ]:         67 :     wstandout(Showline[newslot]);
    1996                 :         67 :     waddstr(Showline[newslot],">>");
    1997         [ +  - ]:         67 :     wstandend(Showline[newslot]);
    1998                 :         67 :     wrefresh(Showline[newslot]);
    1999                 :         67 :     return(newslot);
    2000                 :            :   }
    2001                 :          1 :   else return(oldslot);
    2002                 :            : }
    2003                 :            : 
    2004                 :         13 : void colour_on(void)
    2005                 :            : {
    2006                 :         13 : }
    2007                 :            : 
    2008                 :          0 : void colour_off(void)
    2009                 :            : {
    2010         [ #  # ]:          0 :   wattrset(Levelw, CHARATTR(CLR(WHITE)));
    2011                 :          0 : }
    2012                 :            : 
    2013                 :         52 : void display_option_slot(int slot)
    2014                 :            : {
    2015                 :         52 :   hide_line(slot);
    2016                 :         52 :   wclear(Showline[slot]);
    2017   [ +  +  +  +  :         52 :   switch(slot) {
          +  +  +  +  +  
                +  +  - ]
    2018                 :            :   case 1:
    2019                 :         12 :     wprintw(Showline[slot],"-- Option BELLICOSE [TF]: ");
    2020         [ -  + ]:         12 :     wprintw(Showline[slot], optionp(BELLICOSE) ? "(now T) " : "(now F) ");
    2021                 :         12 :     break;
    2022                 :            :   case 2:
    2023                 :          4 :     wprintw(Showline[slot],"-- Option JUMPMOVE [TF]: ");
    2024         [ -  + ]:          4 :     wprintw(Showline[slot], optionp(JUMPMOVE) ? "(now T) " : "(now F) ");
    2025                 :          4 :     break;
    2026                 :            :   case 3:
    2027                 :          4 :     wprintw(Showline[slot],"-- Option RUNSTOP [TF]: ");
    2028         [ +  - ]:          4 :     wprintw(Showline[slot], optionp(RUNSTOP) ? "(now T) " : "(now F) ");
    2029                 :          4 :     break;
    2030                 :            :   case 4:
    2031                 :          4 :     wprintw(Showline[slot],"-- Option PICKUP [TF]: ");
    2032         [ -  + ]:          4 :     wprintw(Showline[slot], optionp(PICKUP) ? "(now T) " : "(now F) ");
    2033                 :          4 :     break;
    2034                 :            :   case 5:
    2035                 :          4 :     wprintw(Showline[slot],"-- Option CONFIRM [TF]: ");
    2036         [ +  - ]:          4 :     wprintw(Showline[slot], optionp(CONFIRM) ? "(now T) " : "(now F) ");
    2037                 :          4 :     break;
    2038                 :            :   case 6:
    2039                 :          4 :     wprintw(Showline[slot],"-- Option TOPINV [TF]: ");
    2040         [ -  + ]:          4 :     wprintw(Showline[slot], optionp(TOPINV) ? "(now T) " : "(now F) ");
    2041                 :          4 :     break;
    2042                 :            :   case 7:
    2043                 :          4 :     wprintw(Showline[slot],"-- Option PACKADD [TF]: ");
    2044         [ -  + ]:          4 :     wprintw(Showline[slot], optionp(PACKADD) ? "(now T) " : "(now F) ");
    2045                 :          4 :     break;
    2046                 :            :   case 8:
    2047                 :            : #ifdef COMPRESS_SAVE_FILES
    2048                 :            :     wprintw(Showline[slot],"-- Option COMPRESS [TF]: ");
    2049                 :            :     wprintw(Showline[slot], optionp(COMPRESS_OPTION) ? "(now T) " : "(now F) ");
    2050                 :            : #endif
    2051                 :          4 :     break;
    2052                 :            :   case 9:
    2053                 :          4 :     wprintw(Showline[slot],"-- Option COLOUR [TF]: ");
    2054         [ +  - ]:          4 :     wprintw(Showline[slot], optionp(SHOW_COLOUR) ? "(now T) " : "(now F) ");
    2055                 :          4 :     break;
    2056                 :            :   case VERBOSITY_LEVEL:
    2057                 :          4 :     wprintw(Showline[slot],
    2058                 :            :             "-- Option VERBOSITY [(T)erse,(M)edium,(V)erbose]: (now ");
    2059         [ +  - ]:          4 :     if (Verbosity == VERBOSE) wprintw(Showline[slot],"Verbose)");
    2060         [ #  # ]:          0 :     else if (Verbosity == MEDIUM) wprintw(Showline[slot],"Medium)");
    2061                 :          0 :     else wprintw(Showline[slot],"Terse)");
    2062                 :          4 :     break;
    2063                 :            :   case SEARCH_DURATION:
    2064                 :          4 :     wprintw(Showline[slot],"-- Option SEARCHNUM [0>x>10]: (now %d)",Searchnum);
    2065                 :          4 :     break;
    2066                 :            :   }
    2067                 :         52 :   wrefresh(Showline[slot]);
    2068                 :         52 : }
    2069                 :            : 
    2070                 :          0 : void display_stat_slot(int slot)
    2071                 :            : {
    2072                 :          0 :   hide_line(slot);
    2073                 :          0 :   wclear(Showline[slot]);
    2074   [ #  #  #  #  :          0 :   switch(slot) {
          #  #  #  #  #  
                #  #  # ]
    2075                 :            :   case 1:
    2076                 :          0 :     wprintw(Showline[slot],"-- Strength ... [%d]: ", Player.str);
    2077                 :          0 :     break;
    2078                 :            :   case 2:
    2079                 :          0 :     wprintw(Showline[slot],"-- Constitution [%d]: ", Player.con);
    2080                 :          0 :     break;
    2081                 :            :   case 3:
    2082                 :          0 :     wprintw(Showline[slot],"-- Dexterity .. [%d]: ", Player.dex);
    2083                 :          0 :     break;
    2084                 :            :   case 4:
    2085                 :          0 :     wprintw(Showline[slot],"-- Agility .... [%d]: ", Player.agi);
    2086                 :          0 :     break;
    2087                 :            :   case 5:
    2088                 :          0 :     wprintw(Showline[slot],"-- Intelligence [%d]: ", Player.iq);
    2089                 :          0 :     break;
    2090                 :            :   case 6:
    2091                 :          0 :     wprintw(Showline[slot],"-- Power ...... [%d]: ", Player.pow);
    2092                 :          0 :     break;
    2093                 :            :   case 7:
    2094                 :          0 :     wprintw(Showline[slot],"-- HP ......... [%d]: ", Player.hp);
    2095                 :          0 :     break;
    2096                 :            :   case 8:
    2097                 :          0 :     wprintw(Showline[slot],"-- Max HP ..... [%d]: ", Player.maxhp);
    2098                 :          0 :     break;
    2099                 :            :   case 9:
    2100                 :          0 :     wprintw(Showline[slot],"-- Mana ....... [%d]: ", Player.mana);
    2101                 :          0 :     break;
    2102                 :            :   case 10:
    2103                 :          0 :     wprintw(Showline[slot],"-- Max Mana ... [%d]: ", Player.maxmana);
    2104                 :          0 :     break;
    2105                 :            :   case 11:
    2106                 :          0 :     wprintw(Showline[slot],"-- Cash ....... [%d]: ", Player.cash);
    2107                 :          0 :     break;
    2108                 :            :   }
    2109                 :          0 :   wrefresh(Showline[slot]);
    2110                 :          0 : }
    2111                 :            : 
    2112                 :          4 : void display_options(void)
    2113                 :            : {
    2114                 :            :   int i;
    2115                 :          4 :   menuclear();
    2116                 :          4 :   hide_line(0);
    2117         [ +  + ]:         48 :   for(i=1;i<=NUMOPTIONS;i++)
    2118                 :         44 :     display_option_slot(i);
    2119                 :          4 : }
    2120                 :            : 
    2121                 :          0 : void display_stats(void)
    2122                 :            : {
    2123                 :            :   int i;
    2124                 :          0 :   menuclear();
    2125                 :          0 :   hide_line(0);
    2126         [ #  # ]:          0 :   for(i=1;i<=NUMSTATS;i++)
    2127                 :          0 :     display_stat_slot(i);
    2128                 :          0 : }
    2129                 :            : 
    2130                 :            : /* nya ha ha ha ha haaaa.... */
    2131                 :          0 : void deathprint(void)
    2132                 :            : {
    2133                 :          0 :   mgetc();
    2134                 :          0 :   waddch(Msgw,'D');
    2135                 :          0 :   wrefresh(Msgw);
    2136                 :          0 :   mgetc();
    2137                 :          0 :   waddch(Msgw,'e');
    2138                 :          0 :   wrefresh(Msgw);
    2139                 :          0 :   mgetc();
    2140                 :          0 :   waddch(Msgw,'a');
    2141                 :          0 :   wrefresh(Msgw);
    2142                 :          0 :   mgetc();
    2143                 :          0 :   waddch(Msgw,'t');
    2144                 :          0 :   wrefresh(Msgw);
    2145                 :          0 :   mgetc();
    2146                 :          0 :   waddch(Msgw,'h');
    2147                 :          0 :   wrefresh(Msgw);
    2148                 :          0 :   mgetc();
    2149                 :          0 : }
    2150                 :            :   
    2151                 :       1207 : void clear_if_necessary(void)
    2152                 :            : {
    2153                 :            :   int x,y;
    2154 [ +  - ][ +  - ]:       1207 :   getyx(Msg1w,y,x);
    2155                 :            : 
    2156         [ +  + ]:       1207 :   if (x != 0) {
    2157                 :        143 :     wclear(Msg1w);
    2158                 :        143 :     wrefresh(Msg1w);
    2159                 :            :   }  
    2160                 :            : 
    2161 [ +  - ][ +  - ]:       1207 :   getyx(Msg2w,y,x);
    2162                 :            : 
    2163         [ +  + ]:       1207 :   if (x != 0) {
    2164                 :         72 :     wclear(Msg2w);
    2165                 :         72 :     wrefresh(Msg2w);
    2166                 :            :   }  
    2167                 :            : 
    2168 [ +  - ][ +  - ]:       1207 :   getyx(Msg3w,y,x);
    2169                 :            : 
    2170         [ +  + ]:       1207 :   if (x != 0) {
    2171                 :         84 :     erasemsg3();
    2172                 :         84 :     wrefresh(Msg3w);
    2173                 :            :   }
    2174                 :            : 
    2175                 :       1207 : }
    2176                 :            : 
    2177                 :            : int bufferpos = 0;
    2178                 :            : 
    2179                 :        517 : void buffercycle(char *s)
    2180                 :            : {
    2181                 :        517 :   strcpy(Stringbuffer[bufferpos++],s);
    2182         [ +  + ]:        517 :   if (bufferpos >= STRING_BUFFER_SIZE)
    2183                 :         16 :     bufferpos = 0;
    2184                 :        517 : }
    2185                 :            : 
    2186                 :        114 : int bufferappend(char *s)
    2187                 :            : {
    2188                 :        114 :   int pos = bufferpos - 1;
    2189                 :            : 
    2190         [ +  + ]:        114 :   if (pos < 0)
    2191                 :          5 :     pos = STRING_BUFFER_SIZE - 1;
    2192         [ +  - ]:        114 :   if (strlen(Stringbuffer[pos]) + strlen(s) < 80 - 1) {
    2193                 :        114 :     strcat(Stringbuffer[pos],s);
    2194                 :        114 :     return 1;
    2195                 :            :   }
    2196                 :            :   else
    2197                 :          0 :     return 0;
    2198                 :            : }
    2199                 :            : 
    2200                 :            : 
    2201                 :          0 : void bufferprint(void)
    2202                 :            : {
    2203                 :          0 :   int i = bufferpos - 1, c, finished = 0;
    2204                 :          0 :   clearmsg();
    2205                 :            : #ifndef MSDOS_SUPPORTED_ANTIQUE
    2206                 :          0 :   wprintw(Msg1w,"^p for previous message, ^n for next, anything else to quit.");
    2207                 :            : #else
    2208                 :            :   wprintw(Msg1w,"^o for last message, ^n for next, anything else to quit.");
    2209                 :            : #endif
    2210                 :          0 :   wrefresh(Msg1w);
    2211                 :            :   do {
    2212         [ #  # ]:          0 :     if (i >= STRING_BUFFER_SIZE) i = 0;
    2213         [ #  # ]:          0 :     if (i < 0) i = STRING_BUFFER_SIZE - 1;
    2214                 :          0 :     wclear(Msg2w);
    2215                 :          0 :     wprintw(Msg2w,Stringbuffer[i]);
    2216                 :          0 :     wrefresh(Msg2w);
    2217                 :          0 :     c = mgetc();
    2218                 :            : #ifndef MSDOS_SUPPORTED_ANTIQUE
    2219         [ #  # ]:          0 :     if (c == 16)        /* ^p */
    2220                 :            : #else
    2221                 :            :     if (c == 15)        /* ^o */
    2222                 :            : #endif
    2223                 :          0 :       i--;
    2224         [ #  # ]:          0 :     else if (c == 14)   /* ^n */
    2225                 :          0 :       i++;
    2226                 :            :     else
    2227                 :          0 :       finished = 1;
    2228         [ #  # ]:          0 :   } while (!finished);
    2229                 :          0 :   clearmsg();
    2230                 :          0 :   omshowcursor(Player.x,Player.y);
    2231                 :          0 : }
    2232                 :            : 
    2233                 :         15 : void clear_screen(void)
    2234                 :            : {
    2235                 :         15 :   clear();
    2236         [ +  - ]:         15 :   touchwin(stdscr);
    2237                 :         15 :   refresh();
    2238                 :         15 : }

Generated by: LCOV version 1.11