Comment out the homepage URL
[pkg/netris.git] / curses.c
1 /*
2  * Netris -- A free networked version of T*tris
3  * Copyright (C) 1994-1996,1999  Mark H. Weaver <mhw@netris.org>
4  * 
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License
7  * as published by the Free Software Foundation; either version 2
8  * of the License, or (at your option) any later version.
9  * 
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13  * GNU General Public License for more details.
14  * 
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
18  *
19  * $Id: curses.c,v 1.33 1999/05/16 06:56:25 mhw Exp $
20  */
21
22 #include "netris.h"
23 #include <sys/types.h>
24 #include <unistd.h>
25 #include <curses.h>
26 #include <string.h>
27 #include <stdlib.h>
28
29 #ifdef NCURSES_VERSION
30 # define HAVE_NCURSES
31 #endif
32
33 #ifdef HAVE_NCURSES
34 static struct
35 {
36         BlockType type;
37         short color;
38 } myColorTable[] =
39 {
40         { BT_white,             COLOR_WHITE },
41         { BT_blue,              COLOR_BLUE },
42         { BT_magenta,   COLOR_MAGENTA },
43         { BT_cyan,              COLOR_CYAN },
44         { BT_yellow,    COLOR_YELLOW },
45         { BT_green,             COLOR_GREEN },
46         { BT_red,               COLOR_RED },
47         { BT_none, 0 }
48 };
49 #endif
50
51 static void PlotBlock1(int scr, int y, int x, BlockType type);
52 static MyEventType KeyGenFunc(EventGenRec *gen, MyEvent *event);
53
54 static EventGenRec keyGen =
55                 { NULL, 0, FT_read, STDIN_FILENO, KeyGenFunc, EM_key };
56
57 static int boardYPos[MAX_SCREENS], boardXPos[MAX_SCREENS];
58 static int statusYPos, statusXPos;
59 static int haveColor;
60
61 static char *term_vi;   /* String to make cursor invisible */
62 static char *term_ve;   /* String to make cursor visible */
63
64 ExtFunc void InitScreens(void)
65 {
66         MySigSet oldMask;
67
68         GetTermcapInfo();
69
70         /*
71          * Block signals while initializing curses.  Otherwise a badly timed
72          * Ctrl-C during initialization might leave the terminal in a bad state.
73          */
74         BlockSignals(&oldMask, SIGINT, 0);
75         initscr();
76
77 #ifdef CURSES_HACK
78         {
79                 extern char *CS;
80
81                 CS = 0;
82         }
83 #endif
84
85 #ifdef HAVE_NCURSES
86         haveColor = colorEnable && has_colors();
87         if (haveColor)
88         {
89                 int i = 0;
90
91                 start_color();
92                 for (i = 0; myColorTable[i].type != BT_none; ++i)
93                         init_pair(myColorTable[i].type, COLOR_BLACK,
94                                         myColorTable[i].color);
95         }
96 #else
97         haveColor = 0;
98 #endif
99
100         AtExit(CleanupScreens);
101         RestoreSignals(NULL, &oldMask);
102
103         cbreak();
104         noecho();
105         OutputTermStr(term_vi, 0);
106         AddEventGen(&keyGen);
107
108         move(0, 0);
109         addstr("Netris ");
110         addstr(version_string);
111         addstr(" (C) 1994-1996,1999  Mark H. Weaver     "
112                         "\"netris -h\" for more info");
113         statusYPos = 22;
114         statusXPos = 0;
115 }
116
117 ExtFunc void CleanupScreens(void)
118 {
119         RemoveEventGen(&keyGen);
120         endwin();
121         OutputTermStr(term_ve, 1);
122 }
123
124 ExtFunc void GetTermcapInfo(void)
125 {
126         char *term, *buf, *data;
127         int bufSize = 10240;
128
129         if (!(term = getenv("TERM")))
130                 return;
131         if (tgetent(scratch, term) == 1) {
132                 /*
133                  * Make the buffer HUGE, since tgetstr is unsafe.
134                  * Allocate it on the heap too.
135                  */
136                 data = buf = malloc(bufSize);
137
138                 /*
139                  * There is no standard include file for tgetstr, no prototype
140                  * definitions.  I like casting better than using my own prototypes
141                  * because if I guess the prototype, I might be wrong, especially
142                  * with regards to "const".
143                  */
144                 term_vi = (char *)tgetstr("vi", &data);
145                 term_ve = (char *)tgetstr("ve", &data);
146
147                 /* Okay, so I'm paranoid; I just don't like unsafe routines */
148                 if (data > buf + bufSize)
149                         fatal("tgetstr overflow, you must have a very sick termcap");
150
151                 /* Trim off the unused portion of buffer */
152                 buf = realloc(buf, data - buf);
153         }
154
155         /*
156          * If that fails, use hardcoded vt220 codes.
157          * They don't seem to do anything bad on vt100's, so
158          * we'll try them just in case they work.
159          */
160         if (!term_vi || !term_ve) {
161                 static char *vts[] = {
162                                 "vt100", "vt101", "vt102",
163                                 "vt200", "vt220", "vt300",
164                                 "vt320", "vt400", "vt420",
165                                 "screen", "xterm", NULL };
166                 int i;
167
168                 for (i = 0; vts[i]; i++)
169                         if (!strcmp(term, vts[i]))
170                         {
171                                 term_vi = "\033[?25l";
172                                 term_ve = "\033[?25h";
173                                 break;
174                         }
175         }
176         if (!term_vi || !term_ve)
177                 term_vi = term_ve = NULL;
178 }
179
180 ExtFunc void OutputTermStr(char *str, int flush)
181 {
182         if (str) {
183                 fputs(str, stdout);
184                 if (flush)
185                         fflush(stdout);
186         }
187 }
188
189 ExtFunc void InitScreen(int scr)
190 {
191         int y, x;
192
193         if (scr == 0)
194                 boardXPos[scr] = 1;
195         else
196                 boardXPos[scr] = boardXPos[scr - 1] +
197                                         2 * boardWidth[scr - 1] + 3;
198         boardYPos[scr] = 22;
199         if (statusXPos < boardXPos[scr] + 2 * boardWidth[scr] + 3)
200                 statusXPos = boardXPos[scr] + 2 * boardWidth[scr] + 3;
201         for (y = boardVisible[scr] - 1; y >= 0; --y) {
202                 move(boardYPos[scr] - y, boardXPos[scr] - 1);
203                 addch('|');
204                 move(boardYPos[scr] - y, boardXPos[scr] + 2 * boardWidth[scr]);
205                 addch('|');
206         }
207         for (y = boardVisible[scr]; y >= -1; y -= boardVisible[scr] + 1) {
208                 move(boardYPos[scr] - y, boardXPos[scr] - 1);
209                 addch('+');
210                 for (x = boardWidth[scr] - 1; x >= 0; --x)
211                         addstr("--");
212                 addch('+');
213         }
214 }
215
216 ExtFunc void CleanupScreen(int scr)
217 {
218 }
219
220 static void PlotBlock1(int scr, int y, int x, BlockType type)
221 {
222         int colorIndex = abs(type);
223
224         move(boardYPos[scr] - y, boardXPos[scr] + 2 * x);
225
226         if (type == BT_none)
227                 addstr("  ");
228         else
229         {
230                 if (standoutEnable)
231                 {
232 #ifdef HAVE_NCURSES
233                         if (haveColor)
234                                 attrset(COLOR_PAIR(colorIndex));
235                         else
236 #endif
237                                 standout();
238                 }
239
240                 addstr(type > 0 ? "[]" : "$$");
241                 standend();
242         }
243 }
244
245 ExtFunc void PlotBlock(int scr, int y, int x, BlockType type)
246 {
247         if (y >= 0 && y < boardVisible[scr] && x >= 0 && x < boardWidth[scr])
248                 PlotBlock1(scr, y, x, type);
249 }
250
251 ExtFunc void PlotUnderline(int scr, int x, int flag)
252 {
253         move(boardYPos[scr] + 1, boardXPos[scr] + 2 * x);
254         addstr(flag ? "==" : "--");
255 }
256
257 ExtFunc void ShowDisplayInfo(void)
258 {
259         move(statusYPos - 9, statusXPos);
260         printw("Seed: %d", initSeed);
261         clrtoeol();
262         move(statusYPos - 8, statusXPos);
263         printw("Speed: %dms", speed / 1000);
264         clrtoeol();
265         if (robotEnable) {
266                 move(statusYPos - 6, statusXPos);
267                 if (fairRobot)
268                         addstr("Controlled by a fair robot");
269                 else
270                         addstr("Controlled by a robot");
271                 clrtoeol();
272         }
273         if (opponentFlags & SCF_usingRobot) {
274                 move(statusYPos - 5, statusXPos);
275                 if (opponentFlags & SCF_fairRobot)
276                         addstr("The opponent is a fair robot");
277                 else
278                         addstr("The opponent is a robot");
279                 clrtoeol();
280         }
281 }
282
283 ExtFunc void UpdateOpponentDisplay(void)
284 {
285         move(1, 0);
286         printw("Playing %s@%s", opponentName, opponentHost);
287         clrtoeol();
288 }
289
290 ExtFunc void ShowPause(int pausedByMe, int pausedByThem)
291 {
292         move(statusYPos - 3, statusXPos);
293         if (pausedByThem)
294                 addstr("Game paused by opponent");
295         else
296                 clrtoeol();
297         move(statusYPos - 2, statusXPos);
298         if (pausedByMe)
299                 addstr("Game paused by you");
300         else
301                 clrtoeol();
302 }
303
304 ExtFunc void Message(char *s)
305 {
306         static int line = 0;
307
308         move(statusYPos - 20 + line, statusXPos);
309         addstr(s);      /* XXX Should truncate long lines */
310         clrtoeol();
311         line = (line + 1) % 10;
312         move(statusYPos - 20 + line, statusXPos);
313         clrtoeol();
314 }
315
316 ExtFunc void RefreshScreen(void)
317 {
318         static char timeStr[2][32];
319         time_t theTime;
320
321         time(&theTime);
322         strftime(timeStr[0], 30, "%I:%M %p", localtime(&theTime));
323         /* Just in case the local curses library sucks */
324         if (strcmp(timeStr[0], timeStr[1]))
325         {
326                 move(statusYPos, statusXPos);
327                 addstr(timeStr[0]);
328                 strcpy(timeStr[1], timeStr[0]);
329         }
330         move(boardYPos[0] + 1, boardXPos[0] + 2 * boardWidth[0] + 1);
331         refresh();
332 }
333
334 ExtFunc void ScheduleFullRedraw(void)
335 {
336         touchwin(stdscr);
337 }
338
339 static MyEventType KeyGenFunc(EventGenRec *gen, MyEvent *event)
340 {
341         if (MyRead(gen->fd, &event->u.key, 1))
342                 return E_key;
343         else
344                 return E_none;
345 }
346
347 /*
348  * vi: ts=4 ai
349  * vim: noai si
350  */