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 : }
|
