~mdw / xor / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Initial checkin. Not there yet.
[xor] / ui-curses.c
1 /* -*-c-*-
2 *
3 * $Id: ui-curses.c,v 1.1 2003/12/12 10:55:30 mdw Exp $
4 *
5 * Curses user interface
6 *
7 * (c) 2003 Straylight/Edgeware
8 */
9
10 /*----- Licensing notice --------------------------------------------------*
11 *
12 * This file is part of XOR.
13 *
14 * XOR is free software; you can redistribute it and/or modify
15 * it under the terms of the GNU General Public License as published by
16 * the Free Software Foundation; either version 2 of the License, or
17 * (at your option) any later version.
18 *
19 * XOR is distributed in the hope that it will be useful,
20 * but WITHOUT ANY WARRANTY; without even the implied warranty of
21 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
22 * GNU General Public License for more details.
23 *
24 * You should have received a copy of the GNU General Public License
25 * along with XOR; if not, write to the Free Software Foundation,
26 * Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
27 */
28
29 /*----- Revision history --------------------------------------------------*
30 *
31 * $Log: ui-curses.c,v $
32 * Revision 1.1 2003/12/12 10:55:30 mdw
33 * Initial checkin. Not there yet.
34 *
35 */
36
37 /*----- Header files ------------------------------------------------------*/
38
39 #include "xor.h"
40
41 #if defined(HAVE_NCURSES_H)
42 # include <ncurses.h>
43 #elif defined(HAVE_NCURSES_NCURSES_H)
44 # include <ncurses/ncurses.h>
45 #else
46 # include <curses.h>
47 #endif
48
49 #ifdef __CYGWIN__
50 # include <windows.h>
51 # undef usleep
52 # define usleep(n) Sleep(n / 1000);
53 #endif
54
55 /*----- Data structures ---------------------------------------------------*/
56
57 struct ui_state {
58 int vx, vy;
59 level *l;
60 };
61
62 /*---- Display setup ------------------------------------------------------*/
63
64 #define VIEWX 5
65 #define VIEWY 3
66 #define VIEWWD 8
67 #define VIEWHT 8
68 #define CELLHT 2
69 #define CELLWD 3
70
71 #define STATUSX 40
72 #define STATUSY 10
73 #define STATUSWD 36
74 #define STATUSHT 2
75
76 #define MESSAGEY 16
77
78 static chtype *dispmap[CHAR_MAX], mdispmap[CHAR_MAX];
79
80 static struct { int c; chtype m; chtype d[CELLHT * CELLWD]; } disptab[] = {
81 { C_EMPTY, ' ', { ' ', ' ', ' ', ' ', ' ', ' ' } },
82 { C_PLAYER, '$', { '|', '~', '|', '\\', '_', '/' } },
83 { C_SPARE, '%', { '|', 'X', '|', '\\', '_', '/' } },
84 { C_EXIT, '=', { '|', '=', '|', '|', '_', '|' } },
85 { C_WALL, '#', { '#', '#', '#', '#', '#', '#' } },
86 { C_MASK, '+', { 'o', ' ', 'o', ' ', '>', ' ' } },
87 { C_NWMAP, 'M', { '|', '~', '|', '|', '_', '|' } },
88 { C_NEMAP, 'M', { '|', '~', '|', '|', '_', '|' } },
89 { C_SWMAP, 'M', { '|', '~', '|', '|', '_', '|' } },
90 { C_SEMAP, 'M', { '|', '~', '|', '|', '_', '|' } },
91 { C_DOT, ':', { ':', ':', ':', ':', ':', ':' } },
92 { C_WAVE, '~', { '~', '~', '~', '~', '~', '~' } },
93 { C_CHICKEN, '<', { '<', 'o', ')', ' ', '(', ')' } },
94 { C_FISH, 'V', { ' ', 'V', ' ', ' ', 'V', ' ' } },
95 { C_HBOMB, 'U', { '_', 'T', '_', '|', '_', '|' } },
96 { C_VBOMB, 'C', { ' ', ',', '*', '(', ')', ' ' } },
97 { C_DOLLY, '@', { '\\', '@', '/', '/', '=', '\\' } },
98 { C_SWITCH, '~', { 'o', ' ', 'o', ' ', '*', ' ' } },
99 { C_BMUS, 'O', { '/', '~', '\\', '\\', '_', '/' } },
100 { 0, 0, { 0 } }
101 };
102
103 /*----- Main code ---------------------------------------------------------*/
104
105 static void rect(int x, int y, int w, int h)
106 {
107 int i;
108
109 mvaddch(y - 1, x - 1, ACS_ULCORNER);
110 for (i = 0; i < w; i++) addch(ACS_HLINE);
111 addch(ACS_URCORNER);
112 for (i = 0; i < h; i++) {
113 mvaddch(y + i, x - 1, ACS_VLINE);
114 mvaddch(y + i, x + w, ACS_VLINE);
115 }
116 mvaddch(y + h, x - 1, ACS_LLCORNER);
117 for (i = 0; i < w; i++) addch(ACS_HLINE);
118 addch(ACS_LRCORNER);
119 }
120
121 static void hbar(int x, int y, int w)
122 {
123 int i;
124
125 move(y, x - 1);
126 addch(ACS_LTEE);
127 for (i = 0; i < w; i++) addch(ACS_HLINE);
128 addch(ACS_RTEE);
129 }
130
131 static void vbar(int x, int y, int h)
132 {
133 int i;
134
135 mvaddch(y - 1, x, ACS_TTEE);
136 for (i = 0; i < h; i++) mvaddch(y + i, x, ACS_VLINE);
137 mvaddch(y + h, x, ACS_BTEE);
138 }
139
140 static void draw(void)
141 {
142 erase();
143 rect(VIEWX, VIEWY, VIEWWD * CELLWD, VIEWHT * CELLHT);
144 rect(STATUSX, STATUSY - 2, STATUSWD, STATUSHT + 2);
145 hbar(STATUSX, STATUSY - 1, STATUSWD);
146 vbar(STATUSX + STATUSWD - 5, STATUSY, STATUSHT);
147 }
148
149 void ui_init(void)
150 {
151 int i;
152
153 /* --- Kick curses --- */
154
155 initscr();
156 if (LINES < 25 || COLS < 80) {
157 endwin();
158 fprintf(stderr, "terminal too small\n");
159 exit(1);
160 }
161 cbreak();
162 noecho();
163 nonl();
164 intrflush(stdscr, FALSE);
165 keypad(stdscr, TRUE);
166 draw();
167
168 /* --- Initialize the display map --- */
169
170 for (i = 0; disptab[i].c; i++) {
171 dispmap[disptab[i].c] = disptab[i].d;
172 mdispmap[disptab[i].c] = disptab[i].m;
173 }
174 for (i = 0; i < CELLWD * CELLHT; i++)
175 dispmap[C_WALL][i] = ' ' | A_REVERSE;
176 mdispmap[C_WALL] = ' ' | A_REVERSE;
177 }
178
179 static void redraw(ui_state *u)
180 {
181 const level *l = u->l;
182 int x, y, i, j, c;
183
184 for (y = 0; y < VIEWHT; y++) {
185 for (j = 0; j < CELLHT; j++) {
186 move(VIEWY + y * CELLHT + j, VIEWX);
187 for (x = 0; x < VIEWWD; x++) {
188 c = CELL(l, u->vx + x, u->vy + y) & CF_CELLMASK;
189 if ((l->f & LF_DARK) && (cellmap[c]->f & CF_HIDE)) c = C_EMPTY;
190 for (i = 0; i < CELLWD; i++) {
191 addch(dispmap[c][i + j * CELLWD]);
192 }
193 }
194 }
195 }
196
197 mvaddstr(STATUSY - 2, STATUSX + (STATUSWD - strlen(u->l->name))/2,
198 u->l->name);
199
200 mvprintw(STATUSY, STATUSX, "Masks: %2d/%2d", l->m, l->mtot);
201 mvprintw(STATUSY + 1, STATUSX, "Moves: %4d/%4d", l->v, l->vtot);
202 move(STATUSY, STATUSX + STATUSWD - 4);
203 if (l->f & LF_NWMAP) { addch(' ' | A_REVERSE); addch(' ' | A_REVERSE); }
204 else { addch(' '); addch(' '); }
205 if (l->f & LF_NEMAP) { addch(' ' | A_REVERSE); addch(' ' | A_REVERSE); }
206 else { addch(' '); addch(' '); }
207 move(STATUSY + 1, STATUSX + STATUSWD - 4);
208 if (l->f & LF_SWMAP) { addch(' ' | A_REVERSE); addch(' ' | A_REVERSE); }
209 else { addch(' '); addch(' '); }
210 if (l->f & LF_SEMAP) { addch(' ' | A_REVERSE); addch(' ' | A_REVERSE); }
211 else { addch(' '); addch(' '); }
212 }
213
214 void ui_update(ui_state *u)
215 {
216 redraw(u);
217 refresh();
218 }
219
220 void ui_explode(struct ui_state *u, const point *pt, int n)
221 {
222 int i, j, x, y;
223 static const chtype frame[][CELLWD * CELLHT] = {
224 { '\\', '|', '/', '/', '|', '\\' },
225 { '*', '*', '*', '*', '*', '*' },
226 { ':', ':', ':', ':', ':', ':' },
227 { '.', '.', '.', ':', ':', ':' },
228 { ' ', ' ', ' ', ':', ':', ':' },
229 { ' ', ' ', ' ', '.', '.', '.' }
230 };
231
232 redraw(u);
233 refresh();
234 for (i = 0; i < sizeof(frame)/sizeof(frame[0]); i++) {
235 for (j = 0; j < n; j++) {
236 if (pt[j].x < u->vx || pt[j].x >= u->vx + VIEWWD ||
237 pt[j].y < u->vy || pt[j].y >= u->vy + VIEWHT)
238 continue;
239 for (y = 0; y < CELLHT; y++) {
240 move(VIEWY + (pt[j].y - u->vy) * CELLHT + y,
241 VIEWX + (pt[j].x - u->vx) * CELLWD);
242 for (x = 0; x < CELLWD; x++)
243 addch(frame[i][x + CELLWD * y]);
244 }
245 }
246 refresh();
247 usleep(10000);
248 }
249 }
250
251 void ui_track(ui_state *u, int x, int y)
252 {
253 if (u->vx == -1) {
254 u->vx = x - VIEWWD/2;
255 u->vy = y - VIEWHT/2;
256 if (u->vx < 0) u->vx = 0;
257 else if (u->vx > u->l->w - VIEWWD) u->vx = u->l->w - VIEWWD;
258 if (u->vy < 0) u->vy = 0;
259 else if (u->vy > u->l->h - VIEWHT) u->vy = u->l->h - VIEWHT;
260 } else {
261 if (u->vx + 1 > x) u->vx = x - 1;
262 else if (u->vx + VIEWWD - 2 < x) u->vx = x - VIEWWD + 2;
263 if (u->vy + 1 > y) u->vy = y - 1;
264 else if (u->vy + VIEWHT - 2 < y) u->vy = y - VIEWHT + 2;
265 }
266 }
267
268 ui_state *ui_start(level *l, int x, int y)
269 {
270 ui_state *u = CREATE(ui_state);
271
272 u->l = l;
273 u->vx = u->vy = -1;
274 ui_track(u, x, y);
275 return (u);
276 }
277
278 void ui_switch(ui_state *u)
279 {
280 redraw(u);
281 }
282
283 void ui_frame(struct ui_state *u)
284 {
285 redraw(u);
286 refresh();
287 usleep(20000);
288 }
289
290 void ui_message(struct ui_state *u, const char *p)
291 {
292 size_t n = strlen(p);
293 rect((COLS - n)/2, MESSAGEY, n, 1);
294 mvaddstr(MESSAGEY, (COLS - n)/2, p);
295 refresh();
296 usleep(500000);
297 draw();
298 redraw(u);
299 }
300
301 static void showmap(ui_state *u)
302 {
303 const level *l = u->l;
304 int wd, ht, x, y;
305 int vs = 0, hs = 0, maxv, maxh;
306 int i, j;
307 int bit;
308 int c;
309
310 erase();
311 wd = l->w; if (wd + 6 > COLS) wd = COLS - 6;
312 ht = l->h; if (ht + 6 > LINES) ht = LINES - 6;
313 x = (COLS - wd)/2; y = (LINES - ht)/2;
314 rect(x, y, wd, ht);
315 maxh = l->w - wd; maxv = l->h - ht;
316
317 for (;;) {
318 for (j = 0; j < ht; j++) {
319 move(y + j, x);
320 for (i = 0; i < wd; i++) {
321 bit = LF_NWMAP;
322 if (hs + i >= l->w/2) bit <<= 1;
323 if (vs + j >= l->h/2) bit <<= 2;
324 if (!(l->f & bit))
325 c = C_EMPTY;
326 else {
327 c = CELL(l, hs + i, vs + j) & CF_CELLMASK;
328 if (!(cellmap[c]->f & CF_MAP)) c = C_EMPTY;
329 }
330 addch(mdispmap[c]);
331 }
332 }
333 switch (getch()) {
334 case 'q': case 'Q': case 'm': case 'M': case 0x1b: goto done;
335 case KEY_UP: case 'k': case 'K': vs--; break;
336 case KEY_DOWN: case 'j': case 'J': vs++; break;
337 case KEY_LEFT: case 'h': case 'H': hs--; break;
338 case KEY_RIGHT: case 'l': case 'L': hs++; break;
339 }
340 if (hs < 0) hs = 0; else if (hs > maxh) hs = maxh;
341 if (vs < 0) vs = 0; else if (vs > maxv) vs = maxv;
342 }
343 done:
344 draw();
345 redraw(u);
346 return;
347 }
348
349 void ui_go(struct game_state *g, ui_state *u)
350 {
351 refresh();
352 switch (getch()) {
353 case KEY_UP: case 'k': case 'K': game_move(g, 0, -1); break;
354 case KEY_DOWN: case 'j': case 'J': game_move(g, 0, +1); break;
355 case KEY_LEFT: case 'h': case 'H': game_move(g, -1, 0); break;
356 case KEY_RIGHT: case 'l': case 'L': game_move(g, +1, 0); break;
357 case 'u': case 'U': undo(g); break;
358 case 'r': case 'R': redo(g); break;
359 case ' ': case '\r': game_switch(g); break;
360 case 'm': case 'M': showmap(u); break;
361 case 0x1b: case 'q': case 'Q': game_quit(g); break;
362 }
363 }
364
365 void ui_destroy(ui_state *u)
366 {
367 DESTROY(u);
368 }
369
370 void ui_exit(void)
371 {
372 endwin();
373 }
374
375 /*----- That's all, folks -------------------------------------------------*/
XOR puzzle game, reimplemented with curses interface