kernel/pf: Check size of long at compile time (fixes i386 build).
[dragonfly.git] / games / phantasia / io.c
1 /*
2  * io.c - input/output routines for Phantasia
3  *
4  * $FreeBSD: src/games/phantasia/io.c,v 1.6 1999/11/16 02:57:33 billf Exp $
5  * $DragonFly: src/games/phantasia/io.c,v 1.3 2005/05/31 00:06:26 swildner Exp $
6  */
7
8 #include <string.h>
9 #include "include.h"
10
11 /* functions which we need to know about */
12 /* misc.c */
13 extern  void    death(const char *);
14 extern  void    leavegame(void);
15 /* phantglobs.c */
16 extern  double  drandom(void);
17
18 void    catchalarm(void);
19 int     getanswer(const char *, bool);
20 void    getstring(char *, int);
21 double  infloat(void);
22 int     inputoption(void);
23 void    interrupt(void);
24 void    more(int);
25
26 /*
27  * FUNCTION: read a string from operator
28  *
29  * ARGUMENTS:
30  *      char *cp - pointer to buffer area to fill
31  *      int mx - maximum number of characters to put in buffer
32  *
33  * GLOBAL INPUTS: Echo, _iob[], Wizard, *stdscr
34  *
35  * GLOBAL OUTPUTS: _iob[]
36  *
37  * DESCRIPTION:
38  *      Read a string from the keyboard.
39  *      This routine is specially designed to:
40  *
41  *          - strip non-printing characters (unless Wizard)
42  *          - echo, if desired
43  *          - redraw the screen if CH_REDRAW is entered
44  *          - read in only 'mx - 1' characters or less characters
45  *          - nul-terminate string, and throw away newline
46  *
47  *      'mx' is assumed to be at least 2.
48  */
49
50 void
51 getstring(char *cp, int mx)
52 {
53         char *inptr;            /* pointer into string for next string */
54         int x, y;               /* original x, y coordinates on screen */
55         int ch;                 /* input */
56
57         getyx(stdscr, y, x);    /* get coordinates on screen */
58         inptr = cp;
59         *inptr = '\0';          /* clear string to start */
60         --mx;                   /* reserve room in string for nul terminator */
61
62         do {
63                 /* get characters and process */
64                 if (Echo)
65                         mvaddstr(y, x, cp);     /* print string on screen */
66                 clrtoeol();     /* clear any data after string */
67                 refresh();      /* update screen */
68
69                 ch = getchar(); /* get character */
70
71                 switch (ch) {
72                 case CH_ERASE:  /* back up one character */
73                         if (inptr > cp)
74                                 --inptr;
75                         break;
76
77                 case CH_KILL:   /* back up to original location */
78                         inptr = cp;
79                         break;
80
81                 case CH_NEWLINE:        /* terminate string */
82                         break;
83
84                 case CH_REDRAW: /* redraw screen */
85                         clearok(stdscr, TRUE);
86                         continue;
87
88                 default:        /* put data in string */
89                         if (ch >= ' ' || Wizard)
90                                 /* printing char; put in string */
91                                 *inptr++ = ch;
92                 }
93
94                 *inptr = '\0';  /* terminate string */
95         } while (ch != CH_NEWLINE && inptr < cp + mx);
96 }
97
98 /*
99  * FUNCTION: pause and prompt player
100  *
101  * ARGUMENTS:
102  *      int where - line on screen on which to pause
103  *
104  * GLOBAL INPUTS: *stdscr
105  *
106  * DESCRIPTION:
107  *      Print a message, and wait for a space character.
108  */
109
110 void
111 more(int where)
112 {
113         mvaddstr(where, 0, "-- more --");
114         getanswer(" ", FALSE);
115 }
116
117 /*
118  * FUNCTION: input a floating point number from operator
119  *
120  * RETURN VALUE: floating point number from operator
121  *
122  * GLOBAL INPUTS: Databuf[]
123  *
124  * DESCRIPTION:
125  *      Read a string from player, and scan for a floating point
126  *      number.
127  *      If no valid number is found, return 0.0.
128  */
129
130 double
131 infloat(void)
132 {
133         double result;          /* return value */
134
135         getstring(Databuf, SZ_DATABUF);
136         if (sscanf(Databuf, "%lf", &result) < 1)
137                 /* no valid number entered */
138                 result = 0.0;
139
140         return (result);
141 }
142
143 /*
144  * FUNCTION: input an option value from player
145  *
146  * GLOBAL INPUTS: Player
147  *
148  * GLOBAL OUTPUTS: Player
149  *
150  * DESCRIPTION:
151  *      Age increases with every move.
152  *      Refresh screen, and get a single character option from player.
153  *      Return a random value if player's ring has gone bad.
154  */
155
156 int
157 inputoption(void)
158 {
159         ++Player.p_age;         /* increase age */
160
161         if (Player.p_ring.ring_type != R_SPOILED)
162                 /* ring ok */
163                 return (getanswer("T ", TRUE));
164         else {
165                 /* bad ring */
166                 getanswer(" ", TRUE);
167                 return ((int)ROLL(0.0, 5.0) + '0');
168         }
169 }
170
171 /*
172  * FUNCTION: handle interrupt from operator
173  *
174  * GLOBAL INPUTS: Player, *stdscr
175  *
176  * DESCRIPTION:
177  *      Allow player to quit upon hitting the interrupt key.
178  *      If the player wants to quit while in battle, he/she automatically
179  *      dies.
180  */
181
182 void
183 interrupt(void)
184 {
185         char line[81];          /* a place to store data already on screen */
186         int loop;               /* counter */
187         int x, y;               /* coordinates on screen */
188         int ch;                 /* input */
189         unsigned savealarm;     /* to save alarm value */
190
191 #ifdef SYS3
192         signal(SIGINT, SIG_IGN);
193 #endif
194 #ifdef SYS5
195         signal(SIGINT, SIG_IGN);
196 #endif
197
198         savealarm = alarm(0);   /* turn off any alarms */
199
200         getyx(stdscr, y, x);    /* save cursor location */
201
202         for (loop = 0; loop < 80; ++loop) {     /* save line on screen */
203                 move(4, loop);
204                 line[loop] = inch();
205         }
206         line[80] = '\0';        /* nul terminate */
207
208         if (Player.p_status == S_INBATTLE || Player.p_status == S_MONSTER) {
209                 /* in midst of fighting */
210                 mvaddstr(4, 0, "Quitting now will automatically kill your character.  Still want to ? ");
211                 ch = getanswer("NY", FALSE);
212                 if (ch == 'Y')
213                         death("Bailing out");
214                 /* NOTREACHED */
215         } else {
216                 mvaddstr(4, 0, "Do you really want to quit ? ");
217                 ch = getanswer("NY", FALSE);
218                 if (ch == 'Y')
219                         leavegame();
220                 /* NOTREACHED */
221         }
222
223         mvaddstr(4, 0, line);   /* restore data on screen */
224         move(y, x);             /* restore cursor */
225         refresh();
226
227 #ifdef SYS3
228         signal(SIGINT, interrupt);
229 #endif
230 #ifdef SYS5
231         signal(SIGINT, interrupt);
232 #endif
233
234         alarm(savealarm);       /* restore alarm */
235 }
236
237 /*
238  * FUNCTION: get an answer from operator
239  *
240  * ARGUMENTS:
241  *      char *choices - string of (upper case) valid choices
242  *      bool def - set if default answer
243  *
244  * GLOBAL INPUTS: catchalarm(), Echo, _iob[], _ctype[], *stdscr, Timeout,
245  *      Timeoenv[]
246  *
247  * GLOBAL OUTPUTS: _iob[]
248  *
249  * DESCRIPTION:
250  *      Get a single character answer from operator.
251  *      Timeout waiting for response.  If we timeout, or the
252  *      answer in not in the list of valid choices, print choices,
253  *      and wait again, otherwise return the first character in ths
254  *      list of choices.
255  *      Give up after 3 tries.
256  */
257
258 int
259 getanswer(const char *choices, bool def)
260 {
261         int ch;                         /* input */
262         volatile int loop;              /* counter */
263         volatile int oldx, oldy;        /* original coordinates on screen */
264
265         getyx(stdscr, oldy, oldx);
266         alarm(0);                       /* make sure alarm is off */
267
268         for (loop = 3; loop; --loop) {
269                 /* try for 3 times */
270                 if (setjmp(Timeoenv) != 0) {
271                         /* timed out waiting for response */
272                         if (def || loop <= 1)
273                                 /* return default answer */
274                                 break;
275                         else
276                                 /* prompt, and try again */
277                                 goto YELL;
278                 } else {
279                         /* wait for response */
280                         clrtoeol();
281                         refresh();
282 #ifdef BSD41
283                         sigset(SIGALRM, catchalarm);
284 #else
285                         signal(SIGALRM, (sig_t)catchalarm);
286 #endif
287                         /* set timeout */
288                         if (Timeout)
289                                 alarm(7);       /* short */
290                         else
291                                 alarm(600);     /* long */
292
293                         ch = getchar();
294
295                         alarm(0);       /* turn off timeout */
296
297                         if (ch < 0) {
298                                 /* caught some signal */
299                                 ++loop;
300                                 continue;
301                         } else if (ch == CH_REDRAW)       {
302                                 /* redraw screen */
303                                 clearok(stdscr, TRUE);  /* force clear screen */
304                                 ++loop; /* don't count this input */
305                                 continue;
306                         } else if (Echo)       {
307                                 addch(ch);      /* echo character */
308                                 refresh();
309                         }
310
311                         if (islower(ch))
312                                 /* convert to upper case */
313                                 ch = toupper(ch);
314
315                         if (def || strchr(choices, ch) != NULL)
316                                 /* valid choice */
317                                 return (ch);
318                         else if (!def && loop > 1) {
319                                 /* bad choice; prompt, and try again */
320 YELL:                           mvprintw(oldy + 1, 0,
321                                     "Please choose one of : [%s]\n", choices);
322                                 move(oldy, oldx);
323                                 clrtoeol();
324                                 continue;
325                         } else
326                                 /* return default answer */
327                                 break;
328                 }
329         }
330
331         return (*choices);
332 }
333
334 /*
335  * FUNCTION: catch timer when waiting for input
336  *
337  * GLOBAL INPUTS: Timeoenv[]
338  *
339  * DESCRIPTION:
340  *      Come here when the alarm expires while waiting for input.
341  *      Simply longjmp() into getanswer().
342  */
343
344 void
345 catchalarm(void)
346 {
347         longjmp(Timeoenv, 1);
348 }