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