?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ChangeLog update
[tetrinet.git] / tty.c
blobf4f635d666f4ca379c5a88386cc0de1f4f8be57f
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(SIGQUIT, SIG_IGN);
229 signal(SIGTSTP, SIG_IGN);
230
231 initscr();
232 cbreak();
233 noecho();
234 nodelay(stdscr, TRUE);
235 keypad(stdscr, TRUE);
236 leaveok(stdscr, TRUE);
237 if ((has_color = has_colors()))
238 start_color();
239 getmaxyx(stdscr, scrheight, scrwidth);
240 scrwidth--; /* Don't draw in last column--this can cause scroll */
241
242 /* Cancel all this when we exit. */
243 atexit(screen_cleanup);
244
245 /* Catch signals so we can exit cleanly. */
246 signal(SIGINT, sighandler);
247 signal(SIGQUIT, sighandler);
248 signal(SIGTERM, sighandler);
249 signal(SIGHUP, sighandler);
250 signal(SIGSEGV, sighandler);
251 signal(SIGABRT, sighandler);
252 signal(SIGIOT, sighandler);
253 signal(SIGTRAP, sighandler);
254 signal(SIGBUS, sighandler);
255 signal(SIGFPE, sighandler);
256 signal(SIGUSR1, sighandler);
257 signal(SIGUSR2, sighandler);
258 signal(SIGALRM, sighandler);
259 #ifdef SIGSTKFLT
260 signal(SIGSTKFLT, sighandler);
261 #endif
262 signal(SIGTSTP, sighandler);
263 signal(SIGXCPU, sighandler);
264 signal(SIGXFSZ, sighandler);
265 signal(SIGVTALRM, sighandler);
266
267 /* Broken pipes don't want to bother us at all. */
268 signal(SIGPIPE, SIG_IGN);
269 }
270
271 /*************************************************************************/
272
273 /* Redraw everything on the screen. */
274
275 static void screen_refresh(void)
276 {
277 if (gmsg_inputwin)
278 touchline(stdscr, gmsg_inputpos, gmsg_inputheight);
279 if (plinebuf.win)
280 touchline(stdscr, plinebuf.y, plinebuf.height);
281 if (gmsgbuf.win)
282 touchline(stdscr, gmsgbuf.y, gmsgbuf.height);
283 if (attdefbuf.win)
284 touchline(stdscr, attdefbuf.y, attdefbuf.height);
285 wnoutrefresh(stdscr);
286 doupdate();
287 }
288
289 /*************************************************************************/
290
291 /* Like screen_refresh(), but clear the screen first. */
292
293 static void screen_redraw(void)
294 {
295 clearok(stdscr, TRUE);
296 screen_refresh();
297 }
298
299 /*************************************************************************/
300 /************************* Text buffer routines **************************/
301 /*************************************************************************/
302
303 /* Put a line of text in a text buffer. */
304
305 static void outline(TextBuffer *buf, const char *s)
306 {
307 if (buf->line == buf->height) {
308 if (buf->win)
309 scroll(buf->win);
310 memmove(buf->text, buf->text+1, (buf->height-1) * sizeof(char *));
311 buf->line--;
312 }
313 if (buf->win)
314 mvwaddstr(buf->win, buf->line, 0, s);
315 if (s != buf->text[buf->line]) /* check for restoring display */
316 buf->text[buf->line] = strdup(s);
317 buf->line++;
318 }
319
320 static void draw_text(int bufnum, const char *s)
321 {
322 char str[1024]; /* hopefully scrwidth < 1024 */
323 const char *t;
324 int indent = 0;
325 int x = 0, y = 0;
326 TextBuffer *buf;
327
328 switch (bufnum) {
329 case BUFFER_PLINE: buf = &plinebuf; break;
330 case BUFFER_GMSG: buf = &gmsgbuf; break;
331 case BUFFER_ATTDEF: buf = &attdefbuf; break;
332 default: return;
333 }
334 if (!buf->text)
335 return;
336 if (buf->win) {
337 getyx(stdscr, y, x);
338 attrset(getcolor(COLOR_WHITE, COLOR_BLACK));
339 }
340 while (*s && isspace(*s))
341 s++;
342 while (strlen(s) > buf->width - indent) {
343 t = s + buf->width - indent;
344 while (t >= s && !isspace(*t))
345 t--;
346 while (t >= s && isspace(*t))
347 t--;
348 t++;
349 if (t < s)
350 t = s + buf->width - indent;
351 if (indent > 0)
352 sprintf(str, "%*s", indent, "");
353 strncpy(str+indent, s, t-s);
354 str[t-s+indent] = 0;
355 outline(buf, str);
356 indent = 2;
357 while (isspace(*t))
358 t++;
359 s = t;
360 }
361 if (indent > 0)
362 sprintf(str, "%*s", indent, "");
363 strcpy(str+indent, s);
364 outline(buf, str);
365 if (buf->win) {
366 move(y, x);
367 screen_refresh();
368 }
369 }
370
371 /*************************************************************************/
372
373 /* Clear the contents of a text buffer. */
374
375 static void clear_text(int bufnum)
376 {
377 TextBuffer *buf;
378 int i;
379
380 switch (bufnum) {
381 case BUFFER_PLINE: buf = &plinebuf; break;
382 case BUFFER_GMSG: buf = &gmsgbuf; break;
383 case BUFFER_ATTDEF: buf = &attdefbuf; break;
384 default: return;
385 }
386 if (buf->text) {
387 for (i = 0; i < buf->height; i++) {
388 if (buf->text[i]) {
389 free(buf->text[i]);
390 buf->text[i] = NULL;
391 }
392 }
393 buf->line = 0;
394 }
395 if (buf->win) {
396 werase(buf->win);
397 screen_refresh();
398 }
399 }
400
401 /*************************************************************************/
402
403 /* Restore the contents of the given text buffer. */
404
405 static void restore_text(TextBuffer *buf)
406 {
407 buf->line = 0;
408 while (buf->line < buf->height && buf->text[buf->line])
409 outline(buf, buf->text[buf->line]);
410 }
411
412 /*************************************************************************/
413
414 /* Open a window for the given text buffer. */
415
416 static void open_textwin(TextBuffer *buf)
417 {
418 if (buf->height <= 0 || buf->width <= 0) {
419 char str[256];
420 move(scrheight-1, 0);
421 snprintf(str, sizeof(str), "ERROR: bad textwin size (%d,%d)",
422 buf->width, buf->height);
423 addstr(str);
424 exit(1);
425 }
426 if (!buf->win) {
427 buf->win = subwin(stdscr, buf->height, buf->width, buf->y, buf->x);
428 scrollok(buf->win, TRUE);
429 }
430 if (!buf->text)
431 buf->text = calloc(buf->height, sizeof(char *));
432 else
433 restore_text(buf);
434 }
435
436 /*************************************************************************/
437
438 /* Close the window for the given text buffer, if it's open. */
439
440 static void close_textwin(TextBuffer *buf)
441 {
442 if (buf->win) {
443 delwin(buf->win);
444 buf->win = NULL;
445 }
446 }
447
448 /*************************************************************************/
449 /************************ Field drawing routines *************************/
450 /*************************************************************************/
451
452 /* Are we on a wide screen (>=92 columns)? */
453 static int wide_screen = 0;
454
455 /* Field display X/Y coordinates. */
456 static const int own_coord[2] = {0,0};
457 static int other_coord[5][2] = /* Recomputed based on screen width */
458 { {30,0}, {47,0}, {64,0}, {47,24}, {64,24} };
459
460 /* Position of the status window. */
461 static const int status_coord[2] = {28,25};
462 static const int next_coord[2] = {40,24};
463 static const int alt_status_coord[2] = {28,2};
464 static const int alt_next_coord[2] = {29,8};
465
466 /* Position of the attacks/defenses window. */
467 static const int attdef_coord[2] = {28,28};
468 static const int alt_attdef_coord[2] = {28,24};
469
470 /* Position of the text window. X coordinate is ignored. */
471 static const int field_text_coord[2] = {0,47};
472
473 /* Information for drawing blocks. Color attributes are added to blocks in
474 * the setup_fields() routine. */
475 static int tile_chars[15] =
476 { ' ','#','#','#','#','#','a','c','n','r','s','b','g','q','o' };
477
478 /* Are we redrawing the entire display? */
479 static int field_redraw = 0;
480
481 /*************************************************************************/
482 /*************************************************************************/
483
484 /* Set up the field display. */
485
486 static void draw_own_field(void);
487 static void draw_other_field(int player);
488 static void draw_status(void);
489 static void draw_specials(void);
490 static void draw_gmsg_input(const char *s, int pos);
491
492 static void setup_fields(void)
493 {
494 int i, j, x, y, base, delta, attdefbot;
495 char buf[32];
496
497 if (!(tile_chars[0] & A_ATTRIBUTES)) {
498 for (i = 1; i < 15; i++)
499 tile_chars[i] |= A_BOLD;
500 tile_chars[1] |= getcolor(COLOR_BLUE, COLOR_BLACK);
501 tile_chars[2] |= getcolor(COLOR_YELLOW, COLOR_BLACK);
502 tile_chars[3] |= getcolor(COLOR_GREEN, COLOR_BLACK);
503 tile_chars[4] |= getcolor(COLOR_MAGENTA, COLOR_BLACK);
504 tile_chars[5] |= getcolor(COLOR_RED, COLOR_BLACK);
505 }
506
507 field_redraw = 1;
508 leaveok(stdscr, TRUE);
509 close_textwin(&plinebuf);
510 clear();
511 attrset(getcolor(COLOR_WHITE,COLOR_BLACK));
512
513 if (scrwidth >= 92) {
514 wide_screen = 1;
515 base = 41;
516 } else {
517 base = 28;
518 }
519 delta = (scrwidth - base) / 3;
520 base += 2 + (delta - (FIELD_WIDTH+5)) / 2;
521 other_coord[0][0] = base;
522 other_coord[1][0] = base + delta;
523 other_coord[2][0] = base + delta*2;
524 other_coord[3][0] = base + delta;
525 other_coord[4][0] = base + delta*2;
526
527 attdefbot = field_text_coord[1] - 1;
528 if (scrheight - field_text_coord[1] > 3) {
529 move(field_text_coord[1], 0);
530 hline(MY_HLINE2, scrwidth);
531 attdefbot--;
532 if (scrheight - field_text_coord[1] > 5) {
533 move(scrheight-2, 0);
534 hline(MY_HLINE2, scrwidth);
535 attrset(MY_BOLD);
536 move(scrheight-1, 0);
537 addstr("F1=Show Fields F2=Partyline F3=Winlist");
538 move(scrheight-1, scrwidth-8);
539 addstr("F10=Quit");
540 attrset(A_NORMAL);
541 gmsgbuf.y = field_text_coord[1]+1;
542 gmsgbuf.height = scrheight - field_text_coord[1] - 3;
543 } else {
544 gmsgbuf.y = field_text_coord[1]+1;
545 gmsgbuf.height = scrheight - field_text_coord[1] - 1;
546 }
547 } else {
548 gmsgbuf.y = field_text_coord[1];
549 gmsgbuf.height = scrheight - field_text_coord[1];
550 }
551 gmsgbuf.x = field_text_coord[0];
552 gmsgbuf.width = scrwidth;
553 open_textwin(&gmsgbuf);
554
555 x = own_coord[0];
556 y = own_coord[1];
557 sprintf(buf, "%d", my_playernum);
558 mvaddstr(y, x+FIELD_WIDTH*2+2, buf);
559 for (i = 2; i < FIELD_HEIGHT*2 && players[my_playernum-1][i-2]; i++)
560 mvaddch(y+i, x+FIELD_WIDTH*2+2, players[my_playernum-1][i-2]);
561 move(y, x);
562 vline(MY_VLINE, FIELD_HEIGHT*2);
563 move(y, x+FIELD_WIDTH*2+1);
564 vline(MY_VLINE, FIELD_HEIGHT*2);
565 move(y+FIELD_HEIGHT*2, x);
566 addch(MY_LLCORNER);
567 hline(MY_HLINE, FIELD_WIDTH*2);
568 move(y+FIELD_HEIGHT*2, x+FIELD_WIDTH*2+1);
569 addch(MY_LRCORNER);
570 mvaddstr(y+FIELD_HEIGHT*2+2, x, "Specials:");
571 draw_own_field();
572 draw_specials();
573
574 for (j = 0; j < 5; j++) {
575 x = other_coord[j][0];
576 y = other_coord[j][1];
577 move(y, x);
578 vline(MY_VLINE, FIELD_HEIGHT);
579 move(y, x+FIELD_WIDTH+1);
580 vline(MY_VLINE, FIELD_HEIGHT);
581 move(y+FIELD_HEIGHT, x);
582 addch(MY_LLCORNER);
583 hline(MY_HLINE, FIELD_WIDTH);
584 move(y+FIELD_HEIGHT, x+FIELD_WIDTH+1);
585 addch(MY_LRCORNER);
586 if (j+1 >= my_playernum) {
587 sprintf(buf, "%d", j+2);
588 mvaddstr(y, x+FIELD_WIDTH+2, buf);
589 if (players[j+1]) {
590 for (i = 0; i < FIELD_HEIGHT-2 && players[j+1][i]; i++)
591 mvaddch(y+i+2, x+FIELD_WIDTH+2, players[j+1][i]);
592 }
593 draw_other_field(j+2);
594 } else {
595 sprintf(buf, "%d", j+1);
596 mvaddstr(y, x+FIELD_WIDTH+2, buf);
597 if (players[j]) {
598 for (i = 0; i < FIELD_HEIGHT-2 && players[j][i]; i++)
599 mvaddch(y+i+2, x+FIELD_WIDTH+2, players[j][i]);
600 }
601 draw_other_field(j+1);
602 }
603 }
604
605 if (wide_screen) {
606 x = alt_status_coord[0];
607 y = alt_status_coord[1];
608 mvaddstr(y, x, "Lines:");
609 mvaddstr(y+1, x, "Level:");
610 x = alt_next_coord[0];
611 y = alt_next_coord[1];
612 mvaddstr(y-2, x-1, "Next piece:");
613 move(y-1, x-1);
614 addch(MY_ULCORNER);
615 hline(MY_HLINE, 8);
616 mvaddch(y-1, x+8, MY_URCORNER);
617 move(y, x-1);
618 vline(MY_VLINE, 8);
619 move(y, x+8);
620 vline(MY_VLINE, 8);
621 move(y+8, x-1);
622 addch(MY_LLCORNER);
623 hline(MY_HLINE, 8);
624 mvaddch(y+8, x+8, MY_LRCORNER);
625 } else {
626 x = status_coord[0];
627 y = status_coord[1];
628 mvaddstr(y-1, x, "Next piece:");
629 mvaddstr(y, x, "Lines:");
630 mvaddstr(y+1, x, "Level:");
631 }
632 if (playing_game)
633 draw_status();
634
635 attdefbuf.x = wide_screen ? alt_attdef_coord[0] : attdef_coord[0];
636 attdefbuf.y = wide_screen ? alt_attdef_coord[1] : attdef_coord[1];
637 attdefbuf.width = (other_coord[3][0]-1) - attdefbuf.x;
638 attdefbuf.height = (attdefbot+1) - attdefbuf.y;
639 open_textwin(&attdefbuf);
640
641 if (gmsg_inputwin) {
642 delwin(gmsg_inputwin);
643 gmsg_inputwin = NULL;
644 draw_gmsg_input(NULL, -1);
645 }
646
647 screen_refresh();
648 field_redraw = 0;
649 }
650
651 /*************************************************************************/
652
653 /* Display the player's own field. */
654
655 static void draw_own_field(void)
656 {
657 int x, y, x0, y0;
658 Field *f = &fields[my_playernum-1];
659 int shadow[4] = { -1, -1, -1, -1 };
660
661 if (dispmode != MODE_FIELDS)
662 return;
663
664 /* XXX: Code duplication with tetris.c:draw_piece(). --pasky */
665 if (playing_game && cast_shadow) {
666 int y = current_y - piecedata[current_piece][current_rotation].hot_y;
667 char *shape = (char *) piecedata[current_piece][current_rotation].shape;
668 int i, j;
669
670 for (j = 0; j < 4; j++) {
671 if (y+j < 0) {
672 shape += 4;
673 continue;
674 }
675 for (i = 0; i < 4; i++) {
676 if (*shape++)
677 shadow[i] = y + j;
678 }
679 }
680 }
681
682 x0 = own_coord[0]+1;
683 y0 = own_coord[1];
684 for (y = 0; y < 22; y++) {
685 for (x = 0; x < 12; x++) {
686 int c = tile_chars[(int) (*f)[y][x]];
687
688 if (playing_game && cast_shadow) {
689 PieceData *piece = &piecedata[current_piece][current_rotation];
690 int piece_x = current_x - piece->hot_x;
691
692 if (x >= piece_x && x <= piece_x + 3
693 && shadow[(x - piece_x)] >= 0
694 && shadow[(x - piece_x)] < y
695 && ((c & 0x7f) == ' ')) {
696 c = (c & (~0x7f)) | '.'
697 | getcolor(COLOR_BLACK, COLOR_BLACK) | A_BOLD;
698 }
699 }
700
701 mvaddch(y0+y*2, x0+x*2, c);
702 addch(c);
703 mvaddch(y0+y*2+1, x0+x*2, c);
704 addch(c);
705 }
706 }
707 if (gmsg_inputwin) {
708 delwin(gmsg_inputwin);
709 gmsg_inputwin = NULL;
710 draw_gmsg_input(NULL, -1);
711 }
712 if (!field_redraw)
713 screen_refresh();
714 }
715
716 /*************************************************************************/
717
718 /* Display another player's field. */
719
720 static void draw_other_field(int player)
721 {
722 int x, y, x0, y0;
723 Field *f;
724
725 if (dispmode != MODE_FIELDS)
726 return;
727 f = &fields[player-1];
728 if (player > my_playernum)
729 player--;
730 player--;
731 x0 = other_coord[player][0]+1;
732 y0 = other_coord[player][1];
733 for (y = 0; y < 22; y++) {
734 move(y0+y, x0);
735 for (x = 0; x < 12; x++) {
736 addch(tile_chars[(int) (*f)[y][x]]);
737 }
738 }
739 if (gmsg_inputwin) {
740 delwin(gmsg_inputwin);
741 gmsg_inputwin = NULL;
742 draw_gmsg_input(NULL, -1);
743 }
744 if (!field_redraw)
745 screen_refresh();
746 }
747
748 /*************************************************************************/
749
750 /* Display the current game status (level, lines, next piece). */
751
752 static void draw_status(void)
753 {
754 int x, y, i, j;
755 char buf[32], shape[4][4];
756
757 x = wide_screen ? alt_status_coord[0] : status_coord[0];
758 y = wide_screen ? alt_status_coord[1] : status_coord[1];
759 sprintf(buf, "%d", lines>99999 ? 99999 : lines);
760 mvaddstr(y, x+7, buf);
761 sprintf(buf, "%d", levels[my_playernum]);
762 mvaddstr(y+1, x+7, buf);
763 x = wide_screen ? alt_next_coord[0] : next_coord[0];
764 y = wide_screen ? alt_next_coord[1] : next_coord[1];
765 if (get_shape(next_piece, 0, shape) == 0) {
766 for (j = 0; j < 4; j++) {
767 if (!wide_screen)
768 move(y+j, x);
769 for (i = 0; i < 4; i++) {
770 if (wide_screen) {
771 move(y+j*2, x+i*2);
772 addch(tile_chars[(int) shape[j][i]]);
773 addch(tile_chars[(int) shape[j][i]]);
774 move(y+j*2+1, x+i*2);
775 addch(tile_chars[(int) shape[j][i]]);
776 addch(tile_chars[(int) shape[j][i]]);
777 } else
778 addch(tile_chars[(int) shape[j][i]]);
779 }
780 }
781 }
782 }
783
784 /*************************************************************************/
785
786 /* Display the special inventory and description of the current special. */
787
788 static const char *descs[] = {
789 " ",
790 "Add Line ",
791 "Clear Line ",
792 "Nuke Field ",
793 "Clear Random Blocks ",
794 "Switch Fields ",
795 "Clear Special Blocks",
796 "Block Gravity ",
797 "Blockquake ",
798 "Block Bomb "
799 };
800
801 static void draw_specials(void)
802 {
803 int x, y, i;
804
805 if (dispmode != MODE_FIELDS)
806 return;
807 x = own_coord[0];
808 y = own_coord[1]+45;
809 mvaddstr(y, x, descs[specials[0]+1]);
810 move(y+1, x+10);
811 i = 0;
812 while (i < special_capacity && specials[i] >= 0 && x < attdef_coord[0]-1) {
813 addch(tile_chars[specials[i]+6]);
814 i++;
815 x++;
816 }
817 while (x < attdef_coord[0]-1) {
818 addch(tile_chars[0]);
819 x++;
820 }
821 if (!field_redraw)
822 screen_refresh();
823 }
824
825 /*************************************************************************/
826
827 /* Display an attack/defense message. */
828
829 static const char *msgs[][2] = {
830 { "cs1", "1 Line Added to All" },
831 { "cs2", "2 Lines Added to All" },
832 { "cs4", "4 Lines Added to All" },
833 { "a", "Add Line" },
834 { "c", "Clear Line" },
835 { "n", "Nuke Field" },
836 { "r", "Clear Random Blocks" },
837 { "s", "Switch Fields" },
838 { "b", "Clear Special Blocks" },
839 { "g", "Block Gravity" },
840 { "q", "Blockquake" },
841 { "o", "Block Bomb" },
842 { NULL }
843 };
844
845 static void draw_attdef(const char *type, int from, int to)
846 {
847 int i, width;
848 char buf[512];
849
850 width = other_coord[4][0] - attdef_coord[0] - 1;
851 for (i = 0; msgs[i][0]; i++) {
852 if (strcmp(type, msgs[i][0]) == 0)
853 break;
854 }
855 if (!msgs[i][0])
856 return;
857 strcpy(buf, msgs[i][1]);
858 if (to != 0)
859 sprintf(buf+strlen(buf), " on %s", players[to-1]);
860 if (from == 0)
861 sprintf(buf+strlen(buf), " by Server");
862 else
863 sprintf(buf+strlen(buf), " by %s", players[from-1]);
864 draw_text(BUFFER_ATTDEF, buf);
865 }
866
867 /*************************************************************************/
868
869 /* Display the in-game text window. */
870
871 static void draw_gmsg_input(const char *s, int pos)
872 {
873 static int start = 0; /* Start of displayed part of input line */
874 static const char *last_s;
875 static int last_pos;
876
877 if (s)
878 last_s = s;
879 else
880 s = last_s;
881 if (pos >= 0)
882 last_pos = pos;
883 else
884 pos = last_pos;
885
886 attrset(getcolor(COLOR_WHITE,COLOR_BLACK));
887
888 if (!gmsg_inputwin) {
889 gmsg_inputpos = scrheight/2 - 1;
890 gmsg_inputheight = 3;
891 gmsg_inputwin =
892 subwin(stdscr, gmsg_inputheight, scrwidth, gmsg_inputpos, 0);
893 werase(gmsg_inputwin);
894 leaveok(gmsg_inputwin, FALSE);
895 leaveok(stdscr, FALSE);
896 mvwaddstr(gmsg_inputwin, 1, 0, "Text>");
897 }
898
899 if (strlen(s) < scrwidth-7) {
900 start = 0;
901 mvwaddstr(gmsg_inputwin, 1, 6, s);
902 wmove(gmsg_inputwin, 1, 6+strlen(s));
903 move(gmsg_inputpos+1, 6+strlen(s));
904 wclrtoeol(gmsg_inputwin);
905 wmove(gmsg_inputwin, 1, 6+pos);
906 move(gmsg_inputpos+1, 6+pos);
907 } else {
908 if (pos < start+8) {
909 start = pos-8;
910 if (start < 0)
911 start = 0;
912 } else if (pos > start + scrwidth-15) {
913 start = pos - (scrwidth-15);
914 if (start > strlen(s) - (scrwidth-7))
915 start = strlen(s) - (scrwidth-7);
916 }
917 mvwaddnstr(gmsg_inputwin, 1, 6, s+start, scrwidth-6);
918 wmove(gmsg_inputwin, 1, 6 + (pos-start));
919 move(gmsg_inputpos+1, 6 + (pos-start));
920 }
921 screen_refresh();
922 }
923
924 /*************************************************************************/
925
926 /* Clear the in-game text window. */
927
928 static void clear_gmsg_input(void)
929 {
930 if (gmsg_inputwin) {
931 delwin(gmsg_inputwin);
932 gmsg_inputwin = NULL;
933 leaveok(stdscr, TRUE);
934 touchline(stdscr, gmsg_inputpos, gmsg_inputheight);
935 setup_fields();
936 screen_refresh();
937 }
938 }
939
940 /*************************************************************************/
941 /*************************** Partyline display ***************************/
942 /*************************************************************************/
943
944 static void setup_partyline(void)
945 {
946 close_textwin(&gmsgbuf);
947 close_textwin(&attdefbuf);
948 clear();
949
950 attrset(getcolor(COLOR_WHITE,COLOR_BLACK));
951
952 plinebuf.x = plinebuf.y = 0;
953 plinebuf.width = scrwidth;
954 plinebuf.height = scrheight-4;
955 open_textwin(&plinebuf);
956
957 move(scrheight-4, 0);
958 hline(MY_HLINE, scrwidth);
959 move(scrheight-3, 0);
960 addstr("> ");
961
962 move(scrheight-2, 0);
963 hline(MY_HLINE2, scrwidth);
964 attrset(MY_BOLD);
965 move(scrheight-1, 0);
966 addstr("F1=Show Fields F2=Partyline F3=Winlist");
967 move(scrheight-1, scrwidth-8);
968 addstr("F10=Quit");
969 attrset(A_NORMAL);
970
971 move(scrheight-3, 2);
972 leaveok(stdscr, FALSE);
973 screen_refresh();
974 }
975
976 /*************************************************************************/
977
978 static void draw_partyline_input(const char *s, int pos)
979 {
980 static int start = 0; /* Start of displayed part of input line */
981
982 attrset(getcolor(COLOR_WHITE,COLOR_BLACK));
983 if (strlen(s) < scrwidth-3) {
984 start = 0;
985 mvaddstr(scrheight-3, 2, s);
986 move(scrheight-3, 2+strlen(s));
987 clrtoeol();
988 move(scrheight-3, 2+pos);
989 } else {
990 if (pos < start+8) {
991 start = pos-8;
992 if (start < 0)
993 start = 0;
994 } else if (pos > start + scrwidth-11) {
995 start = pos - (scrwidth-11);
996 if (start > strlen(s) - (scrwidth-3))
997 start = strlen(s) - (scrwidth-3);
998 }
999 mvaddnstr(scrheight-3, 2, s+start, scrwidth-2);
1000 move(scrheight-3, 2 + (pos-start));
1001 }
1002 screen_refresh();
1003 }
1004
1005 /*************************************************************************/
1006 /**************************** Winlist display ****************************/
1007 /*************************************************************************/
1008
1009 static void setup_winlist(void)
1010 {
1011 int i, x;
1012 char buf[32];
1013
1014 leaveok(stdscr, TRUE);
1015 close_textwin(&plinebuf);
1016 clear();
1017 attrset(getcolor(COLOR_WHITE,COLOR_BLACK));
1018
1019 for (i = 0; i < MAXWINLIST && *winlist[i].name; i++) {
1020 x = scrwidth/2 - strlen(winlist[i].name);
1021 if (x < 0)
1022 x = 0;
1023 if (winlist[i].team) {
1024 if (x < 4)
1025 x = 4;
1026 mvaddstr(i*2, x-4, "<T>");
1027 }
1028 mvaddstr(i*2, x, winlist[i].name);
1029 snprintf(buf, sizeof(buf), "%4d", winlist[i].points);
1030 if (winlist[i].games) {
1031 int avg100 = winlist[i].points*100 / winlist[i].games;
1032 snprintf(buf+strlen(buf), sizeof(buf)-strlen(buf),
1033 " %d.%02d",avg100/100, avg100%100);
1034 }
1035 x += strlen(winlist[i].name) + 2;
1036 if (x > scrwidth - strlen(buf))
1037 x = scrwidth - strlen(buf);
1038 mvaddstr(i*2, x, buf);
1039 }
1040
1041 move(scrheight-2, 0);
1042 hline(MY_HLINE2, scrwidth);
1043 attrset(MY_BOLD);
1044 move(scrheight-1, 0);
1045 addstr("F1=Show Fields F2=Partyline F3=Winlist");
1046 move(scrheight-1, scrwidth-8);
1047 addstr("F10=Quit");
1048 attrset(A_NORMAL);
1049
1050 screen_refresh();
1051 }
1052
1053 /*************************************************************************/
1054 /************************** Interface declaration ************************/
1055 /*************************************************************************/
1056
1057 Interface tty_interface = {
1058
1059 wait_for_input,
1060
1061 screen_setup,
1062 screen_refresh,
1063 screen_redraw,
1064
1065 draw_text,
1066 clear_text,
1067
1068 setup_fields,
1069 draw_own_field,
1070 draw_other_field,
1071 draw_status,
1072 draw_specials,
1073 draw_attdef,
1074 draw_gmsg_input,
1075 clear_gmsg_input,
1076
1077 setup_partyline,
1078 draw_partyline_input,
1079
1080 setup_winlist
1081 };
1082
1083 /*************************************************************************/
Tetrinet GIT Repository