?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ChangeLog update
[tetrinet.git] / xwin.c
blob1f1c1199b39aca298e64d32fe1f9f7185007b2e1
1 /* Tetrinet for Linux, by Andrew Church <achurch@achurch.org>
2 * This program is public domain.
3 *
4 * Text terminal I/O routines.
5 */
6
7 #include <stdio.h>
8 #include <stdlib.h>
9 #include <string.h>
10 #include <unistd.h>
11 #include <ctype.h>
12 #include <curses.h>
13 #include <errno.h>
14 #include <signal.h>
15 #include <sys/time.h>
16 #include "tetrinet.h"
17 #include "tetris.h"
18 #include "io.h"
19
20 /*************************************************************************/
21
22 #define MY_HLINE (fancy ? ACS_HLINE : '-')
23 #define MY_VLINE (fancy ? ACS_VLINE : '|')
24 #define MY_ULCORNER (fancy ? ACS_ULCORNER : '+')
25 #define MY_URCORNER (fancy ? ACS_URCORNER : '+')
26 #define MY_LLCORNER (fancy ? ACS_LLCORNER : '+')
27 #define MY_LRCORNER (fancy ? ACS_LRCORNER : '+')
28
29 #define MY_HLINE2 (fancy ? (ACS_HLINE | A_BOLD) : '=')
30 #define MY_BOLD (fancy ? A_BOLD : 0)
31
32 /*************************************************************************/
33 /******************************* Input stuff *****************************/
34 /*************************************************************************/
35
36 /* Return either an ASCII code 0-255, a K_* value, or -1 if server input is
37 * waiting. Return -2 if we run out of time with no input.
38 */
39
40 static int wait_for_input(int msec)
41 {
42 fd_set fds;
43 struct timeval tv;
44 int c;
45
46 FD_ZERO(&fds);
47 FD_SET(0, &fds);
48 FD_SET(server_sock, &fds);
49 tv.tv_sec = msec/1000;
50 tv.tv_usec = (msec*1000) % 1000000;
51 while (select(server_sock+1, &fds, NULL, NULL, msec<0 ? NULL : &tv) < 0) {
52 if (errno != EINTR)
53 perror("Warning: select() failed");
54 }
55 if (FD_ISSET(0, &fds)) {
56 c = getch();
57 if (c == KEY_UP)
58 return K_UP;
59 else if (c == KEY_DOWN)
60 return K_DOWN;
61 else if (c == KEY_LEFT)
62 return K_LEFT;
63 else if (c == KEY_RIGHT)
64 return K_RIGHT;
65 else if (c == KEY_F(1))
66 return K_F1;
67 else if (c == KEY_F(2))
68 return K_F2;
69 else if (c == KEY_F(3))
70 return K_F3;
71 else if (c == KEY_F(4))
72 return K_F4;
73 else if (c == KEY_F(5))
74 return K_F5;
75 else if (c == KEY_F(6))
76 return K_F6;
77 else if (c == KEY_F(7))
78 return K_F7;
79 else if (c == KEY_F(8))
80 return K_F8;
81 else if (c == KEY_F(9))
82 return K_F9;
83 else if (c == KEY_F(10))
84 return K_F10;
85 else if (c == KEY_F(11))
86 return K_F11;
87 else if (c == KEY_F(12))
88 return K_F12;
89 else if (c == KEY_BACKSPACE)
90 return 8;
91 else if (c >= 0x0100)
92 return K_INVALID;
93 else if (c == 7) /* ^G */
94 return 27; /* Escape */
95 else
96 return c;
97 } /* if (FD_ISSET(0, &fds)) */
98 else if (FD_ISSET(server_sock, &fds))
99 return -1;
100 else
101 return -2; /* out of time */
102 }
103
104 /*************************************************************************/
105 /****************************** Output stuff *****************************/
106 /*************************************************************************/
107
108 /* Size of the screen */
109 static int scrwidth, scrheight;
110
111 /* Is color available? */
112 static int has_color;
113
114 /*************************************************************************/
115
116 /* Text buffers: */
117
118 typedef struct {
119 int x, y, width, height;
120 int line;
121 WINDOW *win; /* NULL if not currently displayed */
122 char **text;
123 } TextBuffer;
124
125 static TextBuffer plinebuf, gmsgbuf, attdefbuf;
126
127 /*************************************************************************/
128
129 /* Window for typing in-game text, and its coordinates: */
130
131 static WINDOW *gmsg_inputwin;
132 static int gmsg_inputpos, gmsg_inputheight;
133
134 /*************************************************************************/
135 /*************************************************************************/
136
137 /* Clean up the screen on exit. */
138
139 static void screen_cleanup()
140 {
141 wmove(stdscr, scrheight-1, 0);
142 wrefresh(stdscr);
143 endwin();
144 printf("\n");
145 }
146
147 /*************************************************************************/
148
149 /* Little signal handler that just does an exit(1) (thereby getting our
150 * cleanup routine called), except for TSTP, which does a clean suspend.
151 */
152
153 static void (*old_tstp)(int sig);
154
155 static void sighandler(int sig)
156 {
157 if (sig != SIGTSTP) {
158 endwin();
159 if (sig != SIGINT)
160 fprintf(stderr, "%s\n", strsignal(sig));
161 exit(1);
162 }
163 endwin();
164 signal(SIGTSTP, old_tstp);
165 raise(SIGTSTP);
166 doupdate();
167 signal(SIGTSTP, sighandler);
168 }
169
170 /*************************************************************************/
171 /*************************************************************************/
172
173 #define MAXCOLORS 256
174
175 static int colors[MAXCOLORS][2] = { {-1,-1} };
176
177 /* Return a color attribute value. */
178
179 static long getcolor(int fg, int bg)
180 {
181 int i;
182
183 if (colors[0][0] < 0) {
184 start_color();
185 memset(colors, -1, sizeof(colors));
186 colors[0][0] = COLOR_WHITE;
187 colors[0][1] = COLOR_BLACK;
188 }
189 if (fg == COLOR_WHITE && bg == COLOR_BLACK)
190 return COLOR_PAIR(0);
191 for (i = 1; i < MAXCOLORS; i++) {
192 if (colors[i][0] == fg && colors[i][1] == bg)
193 return COLOR_PAIR(i);
194 }
195 for (i = 1; i < MAXCOLORS; i++) {
196 if (colors[i][0] < 0) {
197 if (init_pair(i, fg, bg) == ERR)
198 continue;
199 colors[i][0] = fg;
200 colors[i][1] = bg;
201 return COLOR_PAIR(i);
202 }
203 }
204 return -1;
205 }
206
207 /*************************************************************************/
208 /*************************************************************************/
209
210 /* Set up the screen stuff. */
211
212 static void screen_setup(void)
213 {
214 /* Avoid messy keyfield signals while we're setting up */
215 signal(SIGINT, SIG_IGN);
216 signal(SIGQUIT, SIG_IGN);
217 signal(SIGTSTP, SIG_IGN);
218
219 initscr();
220 cbreak();
221 noecho();
222 nodelay(stdscr, TRUE);
223 keypad(stdscr, TRUE);
224 leaveok(stdscr, TRUE);
225 if ((has_color = has_colors()))
226 start_color();
227 getmaxyx(stdscr, scrheight, scrwidth);
228 scrwidth--; /* Don't draw in last column--this can cause scroll */
229
230 /* Cancel all this when we exit. */
231 atexit(screen_cleanup);
232
233 /* Catch signals so we can exit cleanly. */
234 signal(SIGINT, sighandler);
235 signal(SIGQUIT, sighandler);
236 signal(SIGTERM, sighandler);
237 signal(SIGHUP, sighandler);
238 /* signal(SIGSEGV, sighandler); */
239 signal(SIGABRT, sighandler);
240 signal(SIGIOT, sighandler);
241 signal(SIGTRAP, sighandler);
242 signal(SIGBUS, sighandler);
243 signal(SIGFPE, sighandler);
244 signal(SIGUSR1, sighandler);
245 signal(SIGUSR2, sighandler);
246 signal(SIGALRM, sighandler);
247 #ifdef linux
248 signal(SIGSTKFLT, sighandler);
249 #endif
250 signal(SIGTSTP, sighandler);
251 signal(SIGXCPU, sighandler);
252 signal(SIGXFSZ, sighandler);
253 signal(SIGVTALRM, sighandler);
254
255 /* Broken pipes don't want to bother us at all. */
256 signal(SIGPIPE, SIG_IGN);
257 }
258
259 /*************************************************************************/
260
261 /* Redraw everything on the screen. */
262
263 static void screen_refresh(void)
264 {
265 if (gmsg_inputwin)
266 touchline(stdscr, gmsg_inputpos, gmsg_inputheight);
267 if (plinebuf.win)
268 touchline(stdscr, plinebuf.y, plinebuf.height);
269 if (gmsgbuf.win)
270 touchline(stdscr, gmsgbuf.y, gmsgbuf.height);
271 if (attdefbuf.win)
272 touchline(stdscr, attdefbuf.y, attdefbuf.height);
273 wnoutrefresh(stdscr);
274 doupdate();
275 }
276
277 /*************************************************************************/
278
279 /* Like screen_refresh(), but clear the screen first. */
280
281 static void screen_redraw(void)
282 {
283 clearok(stdscr, TRUE);
284 screen_refresh();
285 }
286
287 /*************************************************************************/
288 /************************* Text buffer routines **************************/
289 /*************************************************************************/
290
291 /* Put a line of text in a text buffer. */
292
293 static void outline(TextBuffer *buf, const char *s)
294 {
295 if (buf->line == buf->height) {
296 if (buf->win)
297 scroll(buf->win);
298 memmove(buf->text, buf->text+1, (buf->height-1) * sizeof(char *));
299 buf->line--;
300 }
301 if (buf->win)
302 mvwaddstr(buf->win, buf->line, 0, s);
303 if (s != buf->text[buf->line]) /* check for restoring display */
304 buf->text[buf->line] = strdup(s);
305 buf->line++;
306 }
307
308 static void draw_text(int bufnum, const char *s)
309 {
310 char str[1024]; /* hopefully scrwidth < 1024 */
311 const char *t;
312 int indent = 0;
313 int x, y;
314 TextBuffer *buf;
315
316 switch (bufnum) {
317 case BUFFER_PLINE: buf = &plinebuf; break;
318 case BUFFER_GMSG: buf = &gmsgbuf; break;
319 case BUFFER_ATTDEF: buf = &attdefbuf; break;
320 default: return;
321 }
322 if (!buf->text)
323 return;
324 if (buf->win) {
325 getyx(stdscr, y, x);
326 attrset(getcolor(COLOR_WHITE, COLOR_BLACK));
327 }
328 while (*s && isspace(*s))
329 s++;
330 while (strlen(s) > buf->width - indent) {
331 t = s + buf->width - indent;
332 while (t >= s && !isspace(*t))
333 t--;
334 while (t >= s && isspace(*t))
335 t--;
336 t++;
337 if (t < s)
338 t = s + buf->width - indent;
339 if (indent > 0)
340 sprintf(str, "%*s", indent, "");
341 strncpy(str+indent, s, t-s);
342 str[t-s+indent] = 0;
343 outline(buf, str);
344 indent = 2;
345 while (isspace(*t))
346 t++;
347 s = t;
348 }
349 if (indent > 0)
350 sprintf(str, "%*s", indent, "");
351 strcpy(str+indent, s);
352 outline(buf, str);
353 if (buf->win) {
354 move(y, x);
355 screen_refresh();
356 }
357 }
358
359 /*************************************************************************/
360
361 /* Clear the contents of a text buffer. */
362
363 static void clear_text(int bufnum)
364 {
365 TextBuffer *buf;
366 int i;
367
368 switch (bufnum) {
369 case BUFFER_PLINE: buf = &plinebuf; break;
370 case BUFFER_GMSG: buf = &gmsgbuf; break;
371 case BUFFER_ATTDEF: buf = &attdefbuf; break;
372 default: return;
373 }
374 if (buf->text) {
375 for (i = 0; i < buf->height; i++) {
376 if (buf->text[i]) {
377 free(buf->text[i]);
378 buf->text[i] = NULL;
379 }
380 }
381 buf->line = 0;
382 }
383 if (buf->win) {
384 werase(buf->win);
385 screen_refresh();
386 }
387 }
388
389 /*************************************************************************/
390
391 /* Restore the contents of the given text buffer. */
392
393 static void restore_text(TextBuffer *buf)
394 {
395 buf->line = 0;
396 while (buf->line < buf->height && buf->text[buf->line])
397 outline(buf, buf->text[buf->line]);
398 }
399
400 /*************************************************************************/
401
402 /* Open a window for the given text buffer. */
403
404 static void open_textwin(TextBuffer *buf)
405 {
406 if (buf->height <= 0 || buf->width <= 0) {
407 char str[256];
408 move(scrheight-1, 0);
409 snprintf(str, sizeof(str), "ERROR: bad textwin size (%d,%d)",
410 buf->width, buf->height);
411 addstr(str);
412 exit(1);
413 }
414 if (!buf->win) {
415 buf->win = subwin(stdscr, buf->height, buf->width, buf->y, buf->x);
416 scrollok(buf->win, TRUE);
417 }
418 if (!buf->text)
419 buf->text = calloc(buf->height, sizeof(char *));
420 else
421 restore_text(buf);
422 }
423
424 /*************************************************************************/
425
426 /* Close the window for the given text buffer, if it's open. */
427
428 static void close_textwin(TextBuffer *buf)
429 {
430 if (buf->win) {
431 delwin(buf->win);
432 buf->win = NULL;
433 }
434 }
435
436 /*************************************************************************/
437 /************************ Field drawing routines *************************/
438 /*************************************************************************/
439
440 /* Are we on a wide screen (>=92 columns)? */
441 static int wide_screen = 0;
442
443 /* Field display X/Y coordinates. */
444 static const int own_coord[2] = {0,0};
445 static int other_coord[5][2] = /* Recomputed based on screen width */
446 { {30,0}, {47,0}, {64,0}, {47,24}, {64,24} };
447
448 /* Position of the status window. */
449 static const int status_coord[2] = {28,25};
450 static const int next_coord[2] = {40,24};
451 static const int alt_status_coord[2] = {28,2};
452 static const int alt_next_coord[2] = {29,8};
453
454 /* Position of the attacks/defenses window. */
455 static const int attdef_coord[2] = {28,28};
456 static const int alt_attdef_coord[2] = {28,24};
457
458 /* Position of the text window. X coordinate is ignored. */
459 static const int field_text_coord[2] = {0,47};
460
461 /* Information for drawing blocks. Color attributes are added to blocks in
462 * the setup_fields() routine. */
463 static int tile_chars[15] =
464 { ' ','#','#','#','#','#','a','c','n','r','s','b','g','q','o' };
465
466 static int attdef_size;
467 static int attdef_line;
468 static char **attdef_text;
469
470 /* Are we redrawing the entire display? */
471 static int field_redraw = 0;
472
473 /*************************************************************************/
474 /*************************************************************************/
475
476 /* Set up the field display. */
477
478 static void draw_own_field(void);
479 static void draw_other_field(int player);
480 static void draw_status(void);
481 static void draw_specials(void);
482 static void draw_gmsg_input(const char *s, int pos);
483
484 static void setup_fields(void)
485 {
486 int i, j, x, y, base, delta, attdefbot;
487 char buf[32];
488
489 if (!(tile_chars[0] & A_ATTRIBUTES)) {
490 for (i = 1; i < 15; i++)
491 tile_chars[i] |= A_BOLD;
492 tile_chars[1] |= getcolor(COLOR_BLUE, COLOR_BLACK);
493 tile_chars[2] |= getcolor(COLOR_YELLOW, COLOR_BLACK);
494 tile_chars[3] |= getcolor(COLOR_GREEN, COLOR_BLACK);
495 tile_chars[4] |= getcolor(COLOR_MAGENTA, COLOR_BLACK);
496 tile_chars[5] |= getcolor(COLOR_RED, COLOR_BLACK);
497 }
498
499 field_redraw = 1;
500 leaveok(stdscr, TRUE);
501 close_textwin(&plinebuf);
502 clear();
503 attrset(getcolor(COLOR_WHITE,COLOR_BLACK));
504
505 if (scrwidth >= 92) {
506 wide_screen = 1;
507 base = 41;
508 } else {
509 base = 28;
510 }
511 delta = (scrwidth - base) / 3;
512 base += 2 + (delta - (FIELD_WIDTH+5)) / 2;
513 other_coord[0][0] = base;
514 other_coord[1][0] = base + delta;
515 other_coord[2][0] = base + delta*2;
516 other_coord[3][0] = base + delta;
517 other_coord[4][0] = base + delta*2;
518
519 attdefbot = field_text_coord[1] - 1;
520 if (scrheight - field_text_coord[1] > 3) {
521 move(field_text_coord[1], 0);
522 hline(MY_HLINE2, scrwidth);
523 attdefbot--;
524 if (scrheight - field_text_coord[1] > 5) {
525 move(scrheight-2, 0);
526 hline(MY_HLINE2, scrwidth);
527 attrset(MY_BOLD);
528 move(scrheight-1, 0);
529 addstr("F1=Show Fields F2=Partyline F3=Winlist");
530 move(scrheight-1, scrwidth-8);
531 addstr("F10=Quit");
532 attrset(A_NORMAL);
533 gmsgbuf.y = field_text_coord[1]+1;
534 gmsgbuf.height = scrheight - field_text_coord[1] - 3;
535 } else {
536 gmsgbuf.y = field_text_coord[1]+1;
537 gmsgbuf.height = scrheight - field_text_coord[1] - 1;
538 }
539 } else {
540 gmsgbuf.y = field_text_coord[1];
541 gmsgbuf.height = scrheight - field_text_coord[1];
542 }
543 gmsgbuf.x = field_text_coord[0];
544 gmsgbuf.width = scrwidth;
545 open_textwin(&gmsgbuf);
546
547 x = own_coord[0];
548 y = own_coord[1];
549 sprintf(buf, "%d", my_playernum);
550 mvaddstr(y, x+FIELD_WIDTH*2+2, buf);
551 for (i = 2; i < FIELD_HEIGHT*2 && players[my_playernum-1][i-2]; i++)
552 mvaddch(y+i, x+FIELD_WIDTH*2+2, players[my_playernum-1][i-2]);
553 move(y, x);
554 vline(MY_VLINE, FIELD_HEIGHT*2);
555 move(y, x+FIELD_WIDTH*2+1);
556 vline(MY_VLINE, FIELD_HEIGHT*2);
557 move(y+FIELD_HEIGHT*2, x);
558 addch(MY_LLCORNER);
559 hline(MY_HLINE, FIELD_WIDTH*2);
560 move(y+FIELD_HEIGHT*2, x+FIELD_WIDTH*2+1);
561 addch(MY_LRCORNER);
562 mvaddstr(y+FIELD_HEIGHT*2+2, x, "Specials:");
563 draw_own_field();
564 draw_specials();
565
566 for (j = 0; j < 5; j++) {
567 x = other_coord[j][0];
568 y = other_coord[j][1];
569 move(y, x);
570 vline(MY_VLINE, FIELD_HEIGHT);
571 move(y, x+FIELD_WIDTH+1);
572 vline(MY_VLINE, FIELD_HEIGHT);
573 move(y+FIELD_HEIGHT, x);
574 addch(MY_LLCORNER);
575 hline(MY_HLINE, FIELD_WIDTH);
576 move(y+FIELD_HEIGHT, x+FIELD_WIDTH+1);
577 addch(MY_LRCORNER);
578 if (j+1 >= my_playernum) {
579 sprintf(buf, "%d", j+2);
580 mvaddstr(y, x+FIELD_WIDTH+2, buf);
581 if (players[j+1]) {
582 for (i = 0; i < FIELD_HEIGHT-2 && players[j+1][i]; i++)
583 mvaddch(y+i+2, x+FIELD_WIDTH+2, players[j+1][i]);
584 }
585 draw_other_field(j+2);
586 } else {
587 sprintf(buf, "%d", j+1);
588 mvaddstr(y, x+FIELD_WIDTH+2, buf);
589 if (players[j]) {
590 for (i = 0; i < FIELD_HEIGHT-2 && players[j][i]; i++)
591 mvaddch(y+i+2, x+FIELD_WIDTH+2, players[j][i]);
592 }
593 draw_other_field(j+1);
594 }
595 }
596
597 if (wide_screen) {
598 x = alt_status_coord[0];
599 y = alt_status_coord[1];
600 mvaddstr(y, x, "Lines:");
601 mvaddstr(y+1, x, "Level:");
602 x = alt_next_coord[0];
603 y = alt_next_coord[1];
604 mvaddstr(y-2, x-1, "Next piece:");
605 move(y-1, x-1);
606 addch(MY_ULCORNER);
607 hline(MY_HLINE, 8);
608 mvaddch(y-1, x+8, MY_URCORNER);
609 move(y, x-1);
610 vline(MY_VLINE, 8);
611 move(y, x+8);
612 vline(MY_VLINE, 8);
613 move(y+8, x-1);
614 addch(MY_LLCORNER);
615 hline(MY_HLINE, 8);
616 mvaddch(y+8, x+8, MY_LRCORNER);
617 } else {
618 x = status_coord[0];
619 y = status_coord[1];
620 mvaddstr(y-1, x, "Next piece:");
621 mvaddstr(y, x, "Lines:");
622 mvaddstr(y+1, x, "Level:");
623 }
624 if (playing_game)
625 draw_status();
626
627 attdefbuf.x = wide_screen ? alt_attdef_coord[0] : attdef_coord[0];
628 attdefbuf.y = wide_screen ? alt_attdef_coord[1] : attdef_coord[1];
629 attdefbuf.width = (other_coord[3][0]-1) - attdefbuf.x;
630 attdefbuf.height = (attdefbot+1) - attdefbuf.y;
631 open_textwin(&attdefbuf);
632
633 if (gmsg_inputwin) {
634 delwin(gmsg_inputwin);
635 gmsg_inputwin = NULL;
636 draw_gmsg_input(NULL, -1);
637 }
638
639 screen_refresh();
640 field_redraw = 0;
641 }
642
643 /*************************************************************************/
644
645 /* Display the player's own field. */
646
647 static void draw_own_field(void)
648 {
649 int x, y, x0, y0;
650 Field *f = &fields[my_playernum-1];
651
652 if (dispmode != MODE_FIELDS)
653 return;
654 x0 = own_coord[0]+1;
655 y0 = own_coord[1];
656 for (y = 0; y < 22; y++) {
657 for (x = 0; x < 12; x++) {
658 int c = tile_chars[(*f)[y][x]];
659 mvaddch(y0+y*2, x0+x*2, c);
660 addch(c);
661 mvaddch(y0+y*2+1, x0+x*2, c);
662 addch(c);
663 }
664 }
665 if (gmsg_inputwin) {
666 delwin(gmsg_inputwin);
667 gmsg_inputwin = NULL;
668 draw_gmsg_input(NULL, -1);
669 }
670 if (!field_redraw)
671 screen_refresh();
672 }
673
674 /*************************************************************************/
675
676 /* Display another player's field. */
677
678 static void draw_other_field(int player)
679 {
680 int x, y, x0, y0;
681 Field *f;
682
683 if (dispmode != MODE_FIELDS)
684 return;
685 f = &fields[player-1];
686 if (player > my_playernum)
687 player--;
688 player--;
689 x0 = other_coord[player][0]+1;
690 y0 = other_coord[player][1];
691 for (y = 0; y < 22; y++) {
692 move(y0+y, x0);
693 for (x = 0; x < 12; x++)
694 addch(tile_chars[(*f)[y][x]]);
695 }
696 if (gmsg_inputwin) {
697 delwin(gmsg_inputwin);
698 gmsg_inputwin = NULL;
699 draw_gmsg_input(NULL, -1);
700 }
701 if (!field_redraw)
702 screen_refresh();
703 }
704
705 /*************************************************************************/
706
707 /* Display the current game status (level, lines, next piece). */
708
709 static void draw_status(void)
710 {
711 int x, y, i, j;
712 char buf[32], shape[4][4];
713
714 x = wide_screen ? alt_status_coord[0] : status_coord[0];
715 y = wide_screen ? alt_status_coord[1] : status_coord[1];
716 sprintf(buf, "%d", lines>99999 ? 99999 : lines);
717 mvaddstr(y+1, x+7, buf);
718 sprintf(buf, "%d", levels[my_playernum]);
719 mvaddstr(y+2, x+7, buf);
720 x = wide_screen ? alt_next_coord[0] : next_coord[0];
721 y = wide_screen ? alt_next_coord[1] : next_coord[1];
722 if (get_shape(next_piece, 0, shape) == 0) {
723 for (j = 0; j < 4; j++) {
724 if (!wide_screen)
725 move(y+j, x);
726 for (i = 0; i < 4; i++) {
727 if (wide_screen) {
728 move(y+j*2, x+i*2);
729 addch(tile_chars[shape[j][i]]);
730 addch(tile_chars[shape[j][i]]);
731 move(y+j*2+1, x+i*2);
732 addch(tile_chars[shape[j][i]]);
733 addch(tile_chars[shape[j][i]]);
734 } else
735 addch(tile_chars[shape[j][i]]);
736 }
737 }
738 }
739 }
740
741 /*************************************************************************/
742
743 /* Display the special inventory and description of the current special. */
744
745 static const char *descs[] = {
746 " ",
747 "Add Line ",
748 "Clear Line ",
749 "Nuke Field ",
750 "Clear Random Blocks ",
751 "Switch Fields ",
752 "Clear Special Blocks",
753 "Block Gravity ",
754 "Blockquake ",
755 "Block Bomb "
756 };
757
758 static void draw_specials(void)
759 {
760 int x, y, i;
761
762 if (dispmode != MODE_FIELDS)
763 return;
764 x = own_coord[0];
765 y = own_coord[1]+45;
766 mvaddstr(y, x, descs[specials[0]+1]);
767 move(y+1, x+10);
768 i = 0;
769 while (i < special_capacity && specials[i] >= 0 && x < attdef_coord[0]-1) {
770 addch(tile_chars[specials[i]+6]);
771 i++;
772 x++;
773 }
774 while (x < attdef_coord[0]-1) {
775 addch(tile_chars[0]);
776 x++;
777 }
778 if (!field_redraw)
779 screen_refresh();
780 }
781
782 /*************************************************************************/
783
784 /* Display an attack/defense message. */
785
786 static const char *msgs[][2] = {
787 { "cs1", "1 Line Added to All" },
788 { "cs2", "2 Lines Added to All" },
789 { "cs4", "4 Lines Added to All" },
790 { "a", "Add Line" },
791 { "c", "Clear Line" },
792 { "n", "Nuke Field" },
793 { "r", "Clear Random Blocks" },
794 { "s", "Switch Fields" },
795 { "b", "Clear Special Blocks" },
796 { "g", "Block Gravity" },
797 { "q", "Blockquake" },
798 { "o", "Block Bomb" },
799 { NULL }
800 };
801
802 static void draw_attdef(const char *type, int from, int to)
803 {
804 int i, width;
805 char *s, buf[512];
806
807 width = other_coord[4][0] - attdef_coord[0] - 1;
808 for (i = 0; msgs[i][0]; i++) {
809 if (strcmp(type, msgs[i][0]) == 0)
810 break;
811 }
812 if (!msgs[i][0])
813 return;
814 strcpy(buf, msgs[i][1]);
815 if (to != 0)
816 sprintf(buf+strlen(buf), " on %s", players[to-1]);
817 if (from == 0)
818 sprintf(buf+strlen(buf), " by Server");
819 else
820 sprintf(buf+strlen(buf), " by %s", players[from-1]);
821 draw_text(BUFFER_ATTDEF, buf);
822 }
823
824 /*************************************************************************/
825
826 /* Display the in-game text window. */
827
828 static void draw_gmsg_input(const char *s, int pos)
829 {
830 static int start = 0; /* Start of displayed part of input line */
831 static const char *last_s;
832 static int last_pos;
833
834 if (s)
835 last_s = s;
836 else
837 s = last_s;
838 if (pos >= 0)
839 last_pos = pos;
840 else
841 pos = last_pos;
842
843 attrset(getcolor(COLOR_WHITE,COLOR_BLACK));
844
845 if (!gmsg_inputwin) {
846 gmsg_inputpos = scrheight/2 - 1;
847 gmsg_inputheight = 3;
848 gmsg_inputwin =
849 subwin(stdscr, gmsg_inputheight, scrwidth, gmsg_inputpos, 0);
850 werase(gmsg_inputwin);
851 leaveok(gmsg_inputwin, FALSE);
852 leaveok(stdscr, FALSE);
853 mvwaddstr(gmsg_inputwin, 1, 0, "Text>");
854 }
855
856 if (strlen(s) < scrwidth-7) {
857 start = 0;
858 mvwaddstr(gmsg_inputwin, 1, 6, s);
859 wmove(gmsg_inputwin, 1, 6+strlen(s));
860 move(gmsg_inputpos+1, 6+strlen(s));
861 wclrtoeol(gmsg_inputwin);
862 wmove(gmsg_inputwin, 1, 6+pos);
863 move(gmsg_inputpos+1, 6+pos);
864 } else {
865 if (pos < start+8) {
866 start = pos-8;
867 if (start < 0)
868 start = 0;
869 } else if (pos > start + scrwidth-15) {
870 start = pos - (scrwidth-15);
871 if (start > strlen(s) - (scrwidth-7))
872 start = strlen(s) - (scrwidth-7);
873 }
874 mvwaddnstr(gmsg_inputwin, 1, 6, s+start, scrwidth-6);
875 wmove(gmsg_inputwin, 1, 6 + (pos-start));
876 move(gmsg_inputpos+1, 6 + (pos-start));
877 }
878 screen_refresh();
879 }
880
881 /*************************************************************************/
882
883 /* Clear the in-game text window. */
884
885 static void clear_gmsg_input(void)
886 {
887 if (gmsg_inputwin) {
888 delwin(gmsg_inputwin);
889 gmsg_inputwin = NULL;
890 leaveok(stdscr, TRUE);
891 touchline(stdscr, gmsg_inputpos, gmsg_inputheight);
892 setup_fields();
893 screen_refresh();
894 }
895 }
896
897 /*************************************************************************/
898 /*************************** Partyline display ***************************/
899 /*************************************************************************/
900
901 static void setup_partyline(void)
902 {
903 int i;
904
905 close_textwin(&gmsgbuf);
906 close_textwin(&attdefbuf);
907 clear();
908
909 attrset(getcolor(COLOR_WHITE,COLOR_BLACK));
910
911 plinebuf.x = plinebuf.y = 0;
912 plinebuf.width = scrwidth;
913 plinebuf.height = scrheight-4;
914 open_textwin(&plinebuf);
915
916 move(scrheight-4, 0);
917 hline(MY_HLINE, scrwidth);
918 move(scrheight-3, 0);
919 addstr("> ");
920
921 move(scrheight-2, 0);
922 hline(MY_HLINE2, scrwidth);
923 attrset(MY_BOLD);
924 move(scrheight-1, 0);
925 addstr("F1=Show Fields F2=Partyline F3=Winlist");
926 move(scrheight-1, scrwidth-8);
927 addstr("F10=Quit");
928 attrset(A_NORMAL);
929
930 move(scrheight-3, 2);
931 leaveok(stdscr, FALSE);
932 screen_refresh();
933 }
934
935 /*************************************************************************/
936
937 static void draw_partyline_input(const char *s, int pos)
938 {
939 static int start = 0; /* Start of displayed part of input line */
940
941 attrset(getcolor(COLOR_WHITE,COLOR_BLACK));
942 if (strlen(s) < scrwidth-3) {
943 start = 0;
944 mvaddstr(scrheight-3, 2, s);
945 move(scrheight-3, 2+strlen(s));
946 clrtoeol();
947 move(scrheight-3, 2+pos);
948 } else {
949 if (pos < start+8) {
950 start = pos-8;
951 if (start < 0)
952 start = 0;
953 } else if (pos > start + scrwidth-11) {
954 start = pos - (scrwidth-11);
955 if (start > strlen(s) - (scrwidth-3))
956 start = strlen(s) - (scrwidth-3);
957 }
958 mvaddnstr(scrheight-3, 2, s+start, scrwidth-2);
959 move(scrheight-3, 2 + (pos-start));
960 }
961 screen_refresh();
962 }
963
964 /*************************************************************************/
965 /**************************** Winlist display ****************************/
966 /*************************************************************************/
967
968 static void setup_winlist(void)
969 {
970 int i, x;
971 char buf[32];
972
973 leaveok(stdscr, TRUE);
974 close_textwin(&plinebuf);
975 clear();
976 attrset(getcolor(COLOR_WHITE,COLOR_BLACK));
977
978 for (i = 0; i < MAXWINLIST && *winlist[i].name; i++) {
979 x = scrwidth/2 - strlen(winlist[i].name);
980 if (x < 0)
981 x = 0;
982 if (winlist[i].team) {
983 if (x < 4)
984 x = 4;
985 mvaddstr(i*2, x-4, "<T>");
986 }
987 mvaddstr(i*2, x, winlist[i].name);
988 snprintf(buf, sizeof(buf), "%4d", winlist[i].points);
989 if (winlist[i].games) {
990 int avg100 = winlist[i].points*100 / winlist[i].games;
991 snprintf(buf+strlen(buf), sizeof(buf)-strlen(buf),
992 " %d.%02d",avg100/100, avg100%100);
993 }
994 x += strlen(winlist[i].name) + 2;
995 if (x > scrwidth - strlen(buf))
996 x = scrwidth - strlen(buf);
997 mvaddstr(i*2, x, buf);
998 }
999
1000 move(scrheight-2, 0);
1001 hline(MY_HLINE2, scrwidth);
1002 attrset(MY_BOLD);
1003 move(scrheight-1, 0);
1004 addstr("F1=Show Fields F2=Partyline F3=Winlist");
1005 move(scrheight-1, scrwidth-8);
1006 addstr("F10=Quit");
1007 attrset(A_NORMAL);
1008
1009 screen_refresh();
1010 }
1011
1012 /*************************************************************************/
1013 /************************** Interface declaration ************************/
1014 /*************************************************************************/
1015
1016 Interface xwin_interface = {
1017
1018 wait_for_input,
1019
1020 screen_setup,
1021 screen_refresh,
1022 screen_redraw,
1023
1024 draw_text,
1025 clear_text,
1026
1027 setup_fields,
1028 draw_own_field,
1029 draw_other_field,
1030 draw_status,
1031 draw_specials,
1032 draw_attdef,
1033 draw_gmsg_input,
1034 clear_gmsg_input,
1035
1036 setup_partyline,
1037 draw_partyline_input,
1038
1039 setup_winlist
1040 };
1041
1042 /*************************************************************************/
Tetrinet GIT Repository