mandoc(1): Update to 1.9.19.
[dragonfly.git] / games / atc / graphics.c
1 /*-
2  * Copyright (c) 1990, 1993
3  *      The Regents of the University of California.  All rights reserved.
4  *
5  * This code is derived from software contributed to Berkeley by
6  * Ed James.
7  *
8  * Redistribution and use in source and binary forms, with or without
9  * modification, are permitted provided that the following conditions
10  * are met:
11  * 1. Redistributions of source code must retain the above copyright
12  *    notice, this list of conditions and the following disclaimer.
13  * 2. Redistributions in binary form must reproduce the above copyright
14  *    notice, this list of conditions and the following disclaimer in the
15  *    documentation and/or other materials provided with the distribution.
16  * 3. Neither the name of the University nor the names of its contributors
17  *    may be used to endorse or promote products derived from this software
18  *    without specific prior written permission.
19  *
20  * THIS SOFTWARE IS PROVIDED BY THE REGENTS AND CONTRIBUTORS ``AS IS'' AND
21  * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
22  * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
23  * ARE DISCLAIMED.  IN NO EVENT SHALL THE REGENTS OR CONTRIBUTORS BE LIABLE
24  * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
25  * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS
26  * OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
27  * HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
28  * LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY
29  * OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF
30  * SUCH DAMAGE.
31  *
32  * @(#)graphics.c       8.1 (Berkeley) 5/31/93
33  * $FreeBSD: src/games/atc/graphics.c,v 1.7 1999/11/30 03:48:19 billf Exp $
34  * $DragonFly: src/games/atc/graphics.c,v 1.3 2006/08/08 15:03:02 pavalos Exp $
35  */
36
37 /*
38  * Copyright (c) 1987 by Ed James, UC Berkeley.  All rights reserved.
39  *
40  * Copy permission is hereby granted provided that this notice is
41  * retained on all partial or complete copies.
42  *
43  * For more info on this and all of my stuff, mail edjames@berkeley.edu.
44  */
45
46 #include <stdlib.h>
47 #include "include.h"
48 #include <errno.h>
49
50 #define C_TOPBOTTOM             '-'
51 #define C_LEFTRIGHT             '|'
52 #define C_AIRPORT               '='
53 #define C_LINE                  '+'
54 #define C_BACKROUND             '.'
55 #define C_BEACON                '*'
56 #define C_CREDIT                '*'
57
58 static void draw_line(WINDOW *, int, int, int, int, const char *);
59
60 WINDOW *radar, *cleanradar, *credit, *input, *planes;
61
62 int
63 getAChar(void)
64 {
65         int c;
66
67         errno = 0;
68         while ((c = getchar()) == -1 && errno == EINTR) {
69                 errno = 0;
70                 clearerr(stdin);
71         }
72         return(c);
73 }
74
75 void
76 erase_all(void)
77 {
78         PLANE   *pp;
79
80         for (pp = air.head; pp != NULL; pp = pp->next) {
81                 wmove(cleanradar, pp->ypos, pp->xpos * 2);
82                 wmove(radar, pp->ypos, pp->xpos * 2);
83                 waddch(radar, winch(cleanradar));
84                 wmove(cleanradar, pp->ypos, pp->xpos * 2 + 1);
85                 wmove(radar, pp->ypos, pp->xpos * 2 + 1);
86                 waddch(radar, winch(cleanradar));
87         }
88 }
89
90 void
91 draw_all(void)
92 {
93         PLANE   *pp;
94
95         for (pp = air.head; pp != NULL; pp = pp->next) {
96                 if (pp->status == S_MARKED)
97                         wstandout(radar);
98                 wmove(radar, pp->ypos, pp->xpos * 2);
99                 waddch(radar, name(pp));
100                 waddch(radar, '0' + pp->altitude);
101                 if (pp->status == S_MARKED)
102                         wstandend(radar);
103         }
104         wrefresh(radar);
105         planewin();
106         wrefresh(input);                /* return cursor */
107         fflush(stdout);
108 }
109
110 void
111 init_gr(void)
112 {
113         static char     buffer[BUFSIZ];
114
115         initscr();
116         setbuf(stdout, buffer);
117         input = newwin(INPUT_LINES, COLS - PLANE_COLS, LINES - INPUT_LINES, 0);
118         credit = newwin(INPUT_LINES, PLANE_COLS, LINES - INPUT_LINES,
119                 COLS - PLANE_COLS);
120         planes = newwin(LINES - INPUT_LINES, PLANE_COLS, 0, COLS - PLANE_COLS);
121 }
122
123 void
124 setup_screen(const C_SCREEN *scp)
125 {
126         int             i, j;
127         char            str[3];
128         const char      *airstr;
129
130         str[2] = '\0';
131
132         if (radar != NULL)
133                 delwin(radar);
134         radar = newwin(scp->height, scp->width * 2, 0, 0);
135
136         if (cleanradar != NULL)
137                 delwin(cleanradar);
138         cleanradar = newwin(scp->height, scp->width * 2, 0, 0);
139
140         /* minus one here to prevent a scroll */
141         for (i = 0; i < PLANE_COLS - 1; i++) {
142                 wmove(credit, 0, i);
143                 waddch(credit, C_CREDIT);
144                 wmove(credit, INPUT_LINES - 1, i);
145                 waddch(credit, C_CREDIT);
146         }
147         wmove(credit, INPUT_LINES / 2, 1);
148         waddstr(credit, AUTHOR_STR);
149
150         for (i = 1; i < scp->height - 1; i++) {
151                 for (j = 1; j < scp->width - 1; j++) {
152                         wmove(radar, i, j * 2);
153                         waddch(radar, C_BACKROUND);
154                 }
155         }
156
157         /*
158          * Draw the lines first, since people like to draw lines
159          * through beacons and exit points.
160          */
161         str[0] = C_LINE;
162         for (i = 0; i < scp->num_lines; i++) {
163                 str[1] = ' ';
164                 draw_line(radar, scp->line[i].p1.x, scp->line[i].p1.y,
165                         scp->line[i].p2.x, scp->line[i].p2.y, str);
166         }
167
168         str[0] = C_TOPBOTTOM;
169         str[1] = C_TOPBOTTOM;
170         wmove(radar, 0, 0);
171         for (i = 0; i < scp->width - 1; i++)
172                 waddstr(radar, str);
173         waddch(radar, C_TOPBOTTOM);
174
175         str[0] = C_TOPBOTTOM;
176         str[1] = C_TOPBOTTOM;
177         wmove(radar, scp->height - 1, 0);
178         for (i = 0; i < scp->width - 1; i++)
179                 waddstr(radar, str);
180         waddch(radar, C_TOPBOTTOM);
181
182         for (i = 1; i < scp->height - 1; i++) {
183                 wmove(radar, i, 0);
184                 waddch(radar, C_LEFTRIGHT);
185                 wmove(radar, i, (scp->width - 1) * 2);
186                 waddch(radar, C_LEFTRIGHT);
187         }
188
189         str[0] = C_BEACON;
190         for (i = 0; i < scp->num_beacons; i++) {
191                 str[1] = '0' + i;
192                 wmove(radar, scp->beacon[i].y, scp->beacon[i].x * 2);
193                 waddstr(radar, str);
194         }
195
196         for (i = 0; i < scp->num_exits; i++) {
197                 wmove(radar, scp->exit[i].y, scp->exit[i].x * 2);
198                 waddch(radar, '0' + i);
199         }
200
201         airstr = "^?>?v?<?";
202         for (i = 0; i < scp->num_airports; i++) {
203                 str[0] = airstr[scp->airport[i].dir];
204                 str[1] = '0' + i;
205                 wmove(radar, scp->airport[i].y, scp->airport[i].x * 2);
206                 waddstr(radar, str);
207         }
208
209         overwrite(radar, cleanradar);
210         wrefresh(radar);
211         wrefresh(credit);
212         fflush(stdout);
213 }
214
215 static void
216 draw_line(WINDOW *w, int x, int y, int lx, int ly, const char *s)
217 {
218         int     dx, dy;
219
220         dx = SGN(lx - x);
221         dy = SGN(ly - y);
222         for (;;) {
223                 wmove(w, y, x * 2);
224                 waddstr(w, s);
225                 if (x == lx && y == ly)
226                         break;
227                 x += dx;
228                 y += dy;
229         }
230 }
231
232 void
233 ioclrtoeol(int pos)
234 {
235         wmove(input, 0, pos);
236         wclrtoeol(input);
237         wrefresh(input);
238         fflush(stdout);
239 }
240
241 void
242 iomove(int pos)
243 {
244         wmove(input, 0, pos);
245         wrefresh(input);
246         fflush(stdout);
247 }
248
249 void
250 ioaddstr(int pos, const char *str)
251 {
252         wmove(input, 0, pos);
253         waddstr(input, str);
254         wrefresh(input);
255         fflush(stdout);
256 }
257
258 void
259 ioclrtobot(void)
260 {
261         wclrtobot(input);
262         wrefresh(input);
263         fflush(stdout);
264 }
265
266 void
267 ioerror(int pos, int len, const char *str)
268 {
269         int     i;
270
271         wmove(input, 1, pos);
272         for (i = 0; i < len; i++)
273                 waddch(input, '^');
274         wmove(input, 2, 0);
275         waddstr(input, str);
276         wrefresh(input);
277         fflush(stdout);
278 }
279
280 void
281 quit(void)
282 {
283         int                     c, y, x;
284         struct itimerval        itv;
285
286         getyx(input, y, x);
287         wmove(input, 2, 0);
288         waddstr(input, "Really quit? (y/n) ");
289         wclrtobot(input);
290         wrefresh(input);
291         fflush(stdout);
292
293         c = getchar();
294         if (c == EOF || c == 'y') {
295                 /* disable timer */
296                 itv.it_value.tv_sec = 0;
297                 itv.it_value.tv_usec = 0;
298                 setitimer(ITIMER_REAL, &itv, NULL);
299                 fflush(stdout);
300                 clear();
301                 refresh();
302                 endwin();
303                 log_score(0);
304                 exit(0);
305         }
306         wmove(input, 2, 0);
307         wclrtobot(input);
308         wmove(input, y, x);
309         wrefresh(input);
310         fflush(stdout);
311 }
312
313 void
314 planewin(void)
315 {
316         PLANE   *pp;
317         int     warning = 0;
318
319         wclear(planes);
320         wmove(planes, 0, 0);
321         wprintw(planes, "Time: %-4d Safe: %d", clck, safe_planes);
322         wmove(planes, 2, 0);
323         waddstr(planes, "pl dt  comm");
324         for (pp = air.head; pp != NULL; pp = pp->next) {
325                 if (waddch(planes, '\n') == ERR) {
326                         warning++;
327                         break;
328                 }
329                 waddstr(planes, command(pp));
330         }
331         waddch(planes, '\n');
332         for (pp = ground.head; pp != NULL; pp = pp->next) {
333                 if (waddch(planes, '\n') == ERR) {
334                         warning++;
335                         break;
336                 }
337                 waddstr(planes, command(pp));
338         }
339         if (warning) {
340                 wmove(planes, LINES - INPUT_LINES - 1, 0);
341                 waddstr(planes, "---- more ----");
342                 wclrtoeol(planes);
343         }
344         wrefresh(planes);
345         fflush(stdout);
346 }
347
348 void
349 loser(const PLANE *p, const char *s)
350 {
351         int                     c;
352         struct itimerval        itv;
353
354         /* disable timer */
355         itv.it_value.tv_sec = 0;
356         itv.it_value.tv_usec = 0;
357         setitimer(ITIMER_REAL, &itv, NULL);
358
359         wmove(input, 0, 0);
360         wclrtobot(input);
361         wprintw(input, "Plane '%c' %s\n\nHit space for top players list...",
362                 name(p), s);
363         wrefresh(input);
364         fflush(stdout);
365         while ((c = getchar()) != EOF && c != ' ')
366                 ;
367         clear();        /* move to top of screen */
368         refresh();
369         endwin();
370         log_score(0);
371         exit(0);
372 }
373
374 void
375 redraw(void)
376 {
377         clear();
378         refresh();
379
380         touchwin(radar);
381         wrefresh(radar);
382         touchwin(planes);
383         wrefresh(planes);
384         touchwin(credit);
385         wrefresh(credit);
386
387         /* refresh input last to get cursor in right place */
388         touchwin(input);
389         wrefresh(input);
390         fflush(stdout);
391 }
392
393 void
394 done_screen(void)
395 {
396         clear();
397         refresh();
398         endwin();         /* clean up curses */
399 }