?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Remove *.o in binonly as well.
[tetrinet.git] / tty.c
blob8c055f58338450c82466bd9b9020aa0129edad9c
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] = {1,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] = {29,25};
462 static const int next_coord[2] = {41,24};
463 static const int alt_status_coord[2] = {29,2};
464 static const int alt_next_coord[2] = {30,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-1, buf);
559 for (i = 2; i < FIELD_HEIGHT*2 && players[my_playernum-1][i-2]; i++)
560 mvaddch(y+i, x-1, players[my_playernum-1][i-2]);
561 if (teams[my_playernum-1] != '\0') {
562 mvaddstr(y, x+FIELD_WIDTH*2+2, "T");
563 for (i = 2; i < FIELD_HEIGHT*2 && teams[my_playernum-1][i-2]; i++)
564 mvaddch(y+i, x+FIELD_WIDTH*2+2, teams[my_playernum-1][i-2]);
565 }
566 move(y, x);
567 vline(MY_VLINE, FIELD_HEIGHT*2);
568 move(y, x+FIELD_WIDTH*2+1);
569 vline(MY_VLINE, FIELD_HEIGHT*2);
570 move(y+FIELD_HEIGHT*2, x);
571 addch(MY_LLCORNER);
572 hline(MY_HLINE, FIELD_WIDTH*2);
573 move(y+FIELD_HEIGHT*2, x+FIELD_WIDTH*2+1);
574 addch(MY_LRCORNER);
575 mvaddstr(y+FIELD_HEIGHT*2+2, x, "Specials:");
576 draw_own_field();
577 draw_specials();
578
579 for (j = 0; j < 5; j++) {
580 x = other_coord[j][0];
581 y = other_coord[j][1];
582 move(y, x);
583 vline(MY_VLINE, FIELD_HEIGHT);
584 move(y, x+FIELD_WIDTH+1);
585 vline(MY_VLINE, FIELD_HEIGHT);
586 move(y+FIELD_HEIGHT, x);
587 addch(MY_LLCORNER);
588 hline(MY_HLINE, FIELD_WIDTH);
589 move(y+FIELD_HEIGHT, x+FIELD_WIDTH+1);
590 addch(MY_LRCORNER);
591 if (j+1 >= my_playernum) {
592 sprintf(buf, "%d", j+2);
593 mvaddstr(y, x-1, buf);
594 if (players[j+1]) {
595 for (i = 0; i < FIELD_HEIGHT-2 && players[j+1][i]; i++)
596 mvaddch(y+i+2, x-1, players[j+1][i]);
597 if (teams[j+1] != '\0') {
598 mvaddstr(y, x+FIELD_WIDTH+2, "T");
599 for (i = 0; i < FIELD_HEIGHT-2 && teams[j+1][i]; i++)
600 mvaddch(y+i+2, x+FIELD_WIDTH+2, teams[j+1][i]);
601 }
602 }
603 draw_other_field(j+2);
604 } else {
605 sprintf(buf, "%d", j+1);
606 mvaddstr(y, x-1, buf);
607 if (players[j]) {
608 for (i = 0; i < FIELD_HEIGHT-2 && players[j][i]; i++)
609 mvaddch(y+i+2, x-1, players[j][i]);
610 if (teams[j] != '\0') {
611 mvaddstr(y, x+FIELD_WIDTH+2, "T");
612 for (i = 0; i < FIELD_HEIGHT-2 && teams[j][i]; i++)
613 mvaddch(y+i+2, x+FIELD_WIDTH+2, teams[j][i]);
614 }
615 }
616 draw_other_field(j+1);
617 }
618 }
619
620 if (wide_screen) {
621 x = alt_status_coord[0];
622 y = alt_status_coord[1];
623 mvaddstr(y, x, "Lines:");
624 mvaddstr(y+1, x, "Level:");
625 x = alt_next_coord[0];
626 y = alt_next_coord[1];
627 mvaddstr(y-2, x-1, "Next piece:");
628 move(y-1, x-1);
629 addch(MY_ULCORNER);
630 hline(MY_HLINE, 8);
631 mvaddch(y-1, x+8, MY_URCORNER);
632 move(y, x-1);
633 vline(MY_VLINE, 8);
634 move(y, x+8);
635 vline(MY_VLINE, 8);
636 move(y+8, x-1);
637 addch(MY_LLCORNER);
638 hline(MY_HLINE, 8);
639 mvaddch(y+8, x+8, MY_LRCORNER);
640 } else {
641 x = status_coord[0];
642 y = status_coord[1];
643 mvaddstr(y-1, x, "Next piece:");
644 mvaddstr(y, x, "Lines:");
645 mvaddstr(y+1, x, "Level:");
646 }
647 if (playing_game)
648 draw_status();
649
650 attdefbuf.x = wide_screen ? alt_attdef_coord[0] : attdef_coord[0];
651 attdefbuf.y = wide_screen ? alt_attdef_coord[1] : attdef_coord[1];
652 attdefbuf.width = (other_coord[3][0]-1) - attdefbuf.x;
653 attdefbuf.height = (attdefbot+1) - attdefbuf.y;
654 open_textwin(&attdefbuf);
655
656 if (gmsg_inputwin) {
657 delwin(gmsg_inputwin);
658 gmsg_inputwin = NULL;
659 draw_gmsg_input(NULL, -1);
660 }
661
662 screen_refresh();
663 field_redraw = 0;
664 }
665
666 /*************************************************************************/
667
668 /* Display the player's own field. */
669
670 static void draw_own_field(void)
671 {
672 int x, y, x0, y0;
673 Field *f = &fields[my_playernum-1];
674 int shadow[4] = { -1, -1, -1, -1 };
675
676 if (dispmode != MODE_FIELDS)
677 return;
678
679 /* XXX: Code duplication with tetris.c:draw_piece(). --pasky */
680 if (playing_game && cast_shadow) {
681 int y = current_y - piecedata[current_piece][current_rotation].hot_y;
682 char *shape = (char *) piecedata[current_piece][current_rotation].shape;
683 int i, j;
684
685 for (j = 0; j < 4; j++) {
686 if (y+j < 0) {
687 shape += 4;
688 continue;
689 }
690 for (i = 0; i < 4; i++) {
691 if (*shape++)
692 shadow[i] = y + j;
693 }
694 }
695 }
696
697 x0 = own_coord[0]+1;
698 y0 = own_coord[1];
699 for (y = 0; y < 22; y++) {
700 for (x = 0; x < 12; x++) {
701 int c = tile_chars[(int) (*f)[y][x]];
702
703 if (playing_game && cast_shadow) {
704 PieceData *piece = &piecedata[current_piece][current_rotation];
705 int piece_x = current_x - piece->hot_x;
706
707 if (x >= piece_x && x <= piece_x + 3
708 && shadow[(x - piece_x)] >= 0
709 && shadow[(x - piece_x)] < y
710 && ((c & 0x7f) == ' ')) {
711 c = (c & (~0x7f)) | '.'
712 | getcolor(COLOR_BLACK, COLOR_BLACK) | A_BOLD;
713 }
714 }
715
716 mvaddch(y0+y*2, x0+x*2, c);
717 addch(c);
718 mvaddch(y0+y*2+1, x0+x*2, c);
719 addch(c);
720 }
721 }
722 if (gmsg_inputwin) {
723 delwin(gmsg_inputwin);
724 gmsg_inputwin = NULL;
725 draw_gmsg_input(NULL, -1);
726 }
727 if (!field_redraw)
728 screen_refresh();
729 }
730
731 /*************************************************************************/
732
733 /* Display another player's field. */
734
735 static void draw_other_field(int player)
736 {
737 int x, y, x0, y0;
738 Field *f;
739
740 if (dispmode != MODE_FIELDS)
741 return;
742 f = &fields[player-1];
743 if (player > my_playernum)
744 player--;
745 player--;
746 x0 = other_coord[player][0]+1;
747 y0 = other_coord[player][1];
748 for (y = 0; y < 22; y++) {
749 move(y0+y, x0);
750 for (x = 0; x < 12; x++) {
751 addch(tile_chars[(int) (*f)[y][x]]);
752 }
753 }
754 if (gmsg_inputwin) {
755 delwin(gmsg_inputwin);
756 gmsg_inputwin = NULL;
757 draw_gmsg_input(NULL, -1);
758 }
759 if (!field_redraw)
760 screen_refresh();
761 }
762
763 /*************************************************************************/
764
765 /* Display the current game status (level, lines, next piece). */
766
767 static void draw_status(void)
768 {
769 int x, y, i, j;
770 char buf[32], shape[4][4];
771
772 x = wide_screen ? alt_status_coord[0] : status_coord[0];
773 y = wide_screen ? alt_status_coord[1] : status_coord[1];
774 sprintf(buf, "%d", lines>99999 ? 99999 : lines);
775 mvaddstr(y, x+7, buf);
776 sprintf(buf, "%d", levels[my_playernum]);
777 mvaddstr(y+1, x+7, buf);
778 x = wide_screen ? alt_next_coord[0] : next_coord[0];
779 y = wide_screen ? alt_next_coord[1] : next_coord[1];
780 if (get_shape(next_piece, 0, shape) == 0) {
781 for (j = 0; j < 4; j++) {
782 if (!wide_screen)
783 move(y+j, x);
784 for (i = 0; i < 4; i++) {
785 if (wide_screen) {
786 move(y+j*2, x+i*2);
787 addch(tile_chars[(int) shape[j][i]]);
788 addch(tile_chars[(int) shape[j][i]]);
789 move(y+j*2+1, x+i*2);
790 addch(tile_chars[(int) shape[j][i]]);
791 addch(tile_chars[(int) shape[j][i]]);
792 } else
793 addch(tile_chars[(int) shape[j][i]]);
794 }
795 }
796 }
797 }
798
799 /*************************************************************************/
800
801 /* Display the special inventory and description of the current special. */
802
803 static const char *descs[] = {
804 " ",
805 "Add Line ",
806 "Clear Line ",
807 "Nuke Field ",
808 "Clear Random Blocks ",
809 "Switch Fields ",
810 "Clear Special Blocks",
811 "Block Gravity ",
812 "Blockquake ",
813 "Block Bomb "
814 };
815
816 static void draw_specials(void)
817 {
818 int x, y, i;
819
820 if (dispmode != MODE_FIELDS)
821 return;
822 x = own_coord[0];
823 y = own_coord[1]+45;
824 mvaddstr(y, x, descs[specials[0]+1]);
825 move(y+1, x+10);
826 i = 0;
827 while (i < special_capacity && specials[i] >= 0 && x < attdef_coord[0]-1) {
828 addch(tile_chars[specials[i]+6]);
829 i++;
830 x++;
831 }
832 while (x < attdef_coord[0]-1) {
833 addch(tile_chars[0]);
834 x++;
835 }
836 if (!field_redraw)
837 screen_refresh();
838 }
839
840 /*************************************************************************/
841
842 /* Display an attack/defense message. */
843
844 static const char *msgs[][2] = {
845 { "cs1", "1 Line Added to All" },
846 { "cs2", "2 Lines Added to All" },
847 { "cs4", "4 Lines Added to All" },
848 { "a", "Add Line" },
849 { "c", "Clear Line" },
850 { "n", "Nuke Field" },
851 { "r", "Clear Random Blocks" },
852 { "s", "Switch Fields" },
853 { "b", "Clear Special Blocks" },
854 { "g", "Block Gravity" },
855 { "q", "Blockquake" },
856 { "o", "Block Bomb" },
857 { NULL }
858 };
859
860 static void draw_attdef(const char *type, int from, int to)
861 {
862 int i, width;
863 char buf[512];
864
865 width = other_coord[4][0] - attdef_coord[0] - 1;
866 for (i = 0; msgs[i][0]; i++) {
867 if (strcmp(type, msgs[i][0]) == 0)
868 break;
869 }
870 if (!msgs[i][0])
871 return;
872 strcpy(buf, msgs[i][1]);
873 if (to != 0)
874 sprintf(buf+strlen(buf), " on %s", players[to-1]);
875 if (from == 0)
876 sprintf(buf+strlen(buf), " by Server");
877 else
878 sprintf(buf+strlen(buf), " by %s", players[from-1]);
879 draw_text(BUFFER_ATTDEF, buf);
880 }
881
882 /*************************************************************************/
883
884 /* Display the in-game text window. */
885
886 static void draw_gmsg_input(const char *s, int pos)
887 {
888 static int start = 0; /* Start of displayed part of input line */
889 static const char *last_s;
890 static int last_pos;
891
892 if (s)
893 last_s = s;
894 else
895 s = last_s;
896 if (pos >= 0)
897 last_pos = pos;
898 else
899 pos = last_pos;
900
901 attrset(getcolor(COLOR_WHITE,COLOR_BLACK));
902
903 if (!gmsg_inputwin) {
904 gmsg_inputpos = scrheight/2 - 1;
905 gmsg_inputheight = 3;
906 gmsg_inputwin =
907 subwin(stdscr, gmsg_inputheight, scrwidth, gmsg_inputpos, 0);
908 werase(gmsg_inputwin);
909 leaveok(gmsg_inputwin, FALSE);
910 leaveok(stdscr, FALSE);
911 mvwaddstr(gmsg_inputwin, 1, 0, "Text>");
912 }
913
914 if (strlen(s) < scrwidth-7) {
915 start = 0;
916 mvwaddstr(gmsg_inputwin, 1, 6, s);
917 wmove(gmsg_inputwin, 1, 6+strlen(s));
918 move(gmsg_inputpos+1, 6+strlen(s));
919 wclrtoeol(gmsg_inputwin);
920 wmove(gmsg_inputwin, 1, 6+pos);
921 move(gmsg_inputpos+1, 6+pos);
922 } else {
923 if (pos < start+8) {
924 start = pos-8;
925 if (start < 0)
926 start = 0;
927 } else if (pos > start + scrwidth-15) {
928 start = pos - (scrwidth-15);
929 if (start > strlen(s) - (scrwidth-7))
930 start = strlen(s) - (scrwidth-7);
931 }
932 mvwaddnstr(gmsg_inputwin, 1, 6, s+start, scrwidth-6);
933 wmove(gmsg_inputwin, 1, 6 + (pos-start));
934 move(gmsg_inputpos+1, 6 + (pos-start));
935 }
936 screen_refresh();
937 }
938
939 /*************************************************************************/
940
941 /* Clear the in-game text window. */
942
943 static void clear_gmsg_input(void)
944 {
945 if (gmsg_inputwin) {
946 delwin(gmsg_inputwin);
947 gmsg_inputwin = NULL;
948 leaveok(stdscr, TRUE);
949 touchline(stdscr, gmsg_inputpos, gmsg_inputheight);
950 setup_fields();
951 screen_refresh();
952 }
953 }
954
955 /*************************************************************************/
956 /*************************** Partyline display ***************************/
957 /*************************************************************************/
958
959 static void setup_partyline(void)
960 {
961 close_textwin(&gmsgbuf);
962 close_textwin(&attdefbuf);
963 clear();
964
965 attrset(getcolor(COLOR_WHITE,COLOR_BLACK));
966
967 plinebuf.x = plinebuf.y = 0;
968 plinebuf.width = scrwidth;
969 plinebuf.height = scrheight-4;
970 open_textwin(&plinebuf);
971
972 move(scrheight-4, 0);
973 hline(MY_HLINE, scrwidth);
974 move(scrheight-3, 0);
975 addstr("> ");
976
977 move(scrheight-2, 0);
978 hline(MY_HLINE2, scrwidth);
979 attrset(MY_BOLD);
980 move(scrheight-1, 0);
981 addstr("F1=Show Fields F2=Partyline F3=Winlist");
982 move(scrheight-1, scrwidth-8);
983 addstr("F10=Quit");
984 attrset(A_NORMAL);
985
986 move(scrheight-3, 2);
987 leaveok(stdscr, FALSE);
988 screen_refresh();
989 }
990
991 /*************************************************************************/
992
993 static void draw_partyline_input(const char *s, int pos)
994 {
995 static int start = 0; /* Start of displayed part of input line */
996
997 attrset(getcolor(COLOR_WHITE,COLOR_BLACK));
998 if (strlen(s) < scrwidth-3) {
999 start = 0;
1000 mvaddstr(scrheight-3, 2, s);
1001 move(scrheight-3, 2+strlen(s));
1002 clrtoeol();
1003 move(scrheight-3, 2+pos);
1004 } else {
1005 if (pos < start+8) {
1006 start = pos-8;
1007 if (start < 0)
1008 start = 0;
1009 } else if (pos > start + scrwidth-11) {
1010 start = pos - (scrwidth-11);
1011 if (start > strlen(s) - (scrwidth-3))
1012 start = strlen(s) - (scrwidth-3);
1013 }
1014 mvaddnstr(scrheight-3, 2, s+start, scrwidth-2);
1015 move(scrheight-3, 2 + (pos-start));
1016 }
1017 screen_refresh();
1018 }
1019
1020 /*************************************************************************/
1021 /**************************** Winlist display ****************************/
1022 /*************************************************************************/
1023
1024 static void setup_winlist(void)
1025 {
1026 int i, x;
1027 char buf[32];
1028
1029 leaveok(stdscr, TRUE);
1030 close_textwin(&plinebuf);
1031 clear();
1032 attrset(getcolor(COLOR_WHITE,COLOR_BLACK));
1033
1034 for (i = 0; i < MAXWINLIST && *winlist[i].name; i++) {
1035 x = scrwidth/2 - strlen(winlist[i].name);
1036 if (x < 0)
1037 x = 0;
1038 if (winlist[i].team) {
1039 if (x < 4)
1040 x = 4;
1041 mvaddstr(i*2, x-4, "<T>");
1042 }
1043 mvaddstr(i*2, x, winlist[i].name);
1044 snprintf(buf, sizeof(buf), "%4d", winlist[i].points);
1045 if (winlist[i].games) {
1046 int avg100 = winlist[i].points*100 / winlist[i].games;
1047 snprintf(buf+strlen(buf), sizeof(buf)-strlen(buf),
1048 " %d.%02d",avg100/100, avg100%100);
1049 }
1050 x += strlen(winlist[i].name) + 2;
1051 if (x > scrwidth - strlen(buf))
1052 x = scrwidth - strlen(buf);
1053 mvaddstr(i*2, x, buf);
1054 }
1055
1056 move(scrheight-2, 0);
1057 hline(MY_HLINE2, scrwidth);
1058 attrset(MY_BOLD);
1059 move(scrheight-1, 0);
1060 addstr("F1=Show Fields F2=Partyline F3=Winlist");
1061 move(scrheight-1, scrwidth-8);
1062 addstr("F10=Quit");
1063 attrset(A_NORMAL);
1064
1065 screen_refresh();
1066 }
1067
1068 /*************************************************************************/
1069 /************************** Interface declaration ************************/
1070 /*************************************************************************/
1071
1072 Interface tty_interface = {
1073
1074 wait_for_input,
1075
1076 screen_setup,
1077 screen_refresh,
1078 screen_redraw,
1079
1080 draw_text,
1081 clear_text,
1082
1083 setup_fields,
1084 draw_own_field,
1085 draw_other_field,
1086 draw_status,
1087 draw_specials,
1088 draw_attdef,
1089 draw_gmsg_input,
1090 clear_gmsg_input,
1091
1092 setup_partyline,
1093 draw_partyline_input,
1094
1095 setup_winlist
1096 };
1097
1098 /*************************************************************************/
Tetrinet GIT Repository