?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
We don't need a .cvsignore file
[tetrinet.git] / tetrinet.c
blobaa687a28a6819f82707c26f70ce8c6b3a1cb4459
1 /* Tetrinet for Linux, by Andrew Church <achurch@achurch.org>
2 * This program is public domain.
3 *
4 * Tetrinet main program.
5 */
6
7 /*************************************************************************/
8
9 #include <stdio.h>
10 #include <stdlib.h>
11 #include <string.h>
12 #include <time.h>
13 #include <errno.h>
14 #include "tetrinet.h"
15 #include "io.h"
16 #include "server.h"
17 #include "sockets.h"
18 #include "tetris.h"
19 #include "version.h"
20
21 /*************************************************************************/
22
23 int fancy = 0; /* Fancy TTY graphics? */
24 int log = 0; /* Log network traffic to file? */
25 char *logname; /* Log filename */
26 int windows_mode = 0; /* Try to be just like the Windows version? */
27 int noslide = 0; /* Disallow piece sliding? */
28 int tetrifast = 0; /* TetriFast mode? */
29 int cast_shadow = 1; /* Make pieces cast shadow? */
30
31 int my_playernum = -1; /* What player number are we? */
32 char *my_nick; /* And what is our nick? */
33 WinInfo winlist[MAXWINLIST]; /* Winners' list from server */
34 int server_sock; /* Socket for server communication */
35 int dispmode; /* Current display mode */
36 char *players[6]; /* Player names (NULL for no such player) */
37 char *teams[6]; /* Team names (NULL for not on a team) */
38 int playing_game; /* Are we currently playing a game? */
39 int not_playing_game; /* Are we currently watching people play a game? */
40 int game_paused; /* Is the game currently paused? */
41
42 Interface *io; /* Input/output routines */
43
44 /*************************************************************************/
45 /*************************************************************************/
46
47 #ifndef SERVER_ONLY
48
49 /*************************************************************************/
50
51 /* Output message to a message buffer, possibly decoding the text attributes
52 * tetrinet code. */
53
54 void msg_text(int bufnum, const char *s)
55 {
56 /* Stolen from gtetrinet: (leading space <=> undefined) */
57 static enum tattr map[32] = {
58 0, /* N/A */
59 TATTR_CBLACK,
60 TATTR_BOLD,
61 TATTR_CCYAN | TATTR_CXBRIGHT,
62 TATTR_CBLACK,
63 TATTR_CBLUE | TATTR_CXBRIGHT,
64 TATTR_CGREY,
65 TATTR_CBLACK,
66 TATTR_CMAGENTA,
67 TATTR_CBLACK,
68 TATTR_CBLACK,
69 TATTR_CBLACK | TATTR_CXBRIGHT,
70 TATTR_CGREEN,
71 TATTR_CBLACK,
72 TATTR_CGREEN | TATTR_CXBRIGHT,
73 TATTR_CGREY,
74 TATTR_CRED,
75 TATTR_CBLUE,
76 TATTR_CBROWN,
77 TATTR_CMAGENTA | TATTR_CXBRIGHT,
78 TATTR_CRED | TATTR_CXBRIGHT,
79 TATTR_CGREY,
80 TATTR_ITALIC,
81 TATTR_CCYAN,
82 TATTR_CGREY | TATTR_CXBRIGHT,
83 TATTR_CBROWN | TATTR_CXBRIGHT,
84 TATTR_CBLACK,
85 TATTR_CBLACK,
86 TATTR_CBLACK,
87 TATTR_CBLACK,
88 TATTR_CBLACK,
89 TATTR_UNDERLINE,
90 };
91 char tb[1024], *t;
92
93 for (t = tb; *s && t - tb < 1024; t++, s++) {
94 if (*s == 0xFF) {
95 *t = TATTR_RESET + 1;
96 } else if (*s < 32) {
97 *t = map[(int) *s] + 1;
98 } else {
99 *t = *s;
100 }
101 }
102 if (t - tb >= 1024) t = &tb[1023];
103 *t = 0;
104
105 io->draw_text(bufnum, tb);
106 }
107
108
109 /* Parse a line from the server. Destroys the buffer it's given as a side
110 * effect.
111 */
112
113 void parse(char *buf)
114 {
115 char *cmd, *s, *t;
116
117 cmd = strtok(buf, " ");
118
119 if (!cmd) {
120 return;
121
122 } else if (strcmp(cmd, "noconnecting") == 0) {
123 s = strtok(NULL, "");
124 if (!s)
125 s = "Unknown";
126 /* XXX not to stderr, please! -- we need to stay running w/o server */
127 fprintf(stderr, "Server error: %s\n", s);
128 exit(1);
129
130 } else if (strcmp(cmd, "winlist") == 0) {
131 int i = 0;
132
133 while (i < MAXWINLIST && (s = strtok(NULL, " "))) {
134 t = strchr(s, ';');
135 if (!t)
136 break;
137 *t++ = 0;
138 if (*s == 't')
139 winlist[i].team = 1;
140 else
141 winlist[i].team = 0;
142 s++;
143 strncpy(winlist[i].name, s, sizeof(winlist[i].name)-1);
144 winlist[i].points = atoi(t);
145 if ((t = strchr(t, ';')) != NULL)
146 winlist[i].games = atoi(t+1);
147 i++;
148 }
149 if (i < MAXWINLIST)
150 winlist[i].name[0] = 0;
151 if (dispmode == MODE_WINLIST)
152 io->setup_winlist();
153
154 } else if (strcmp(cmd, tetrifast ? ")#)(!@(*3" : "playernum") == 0) {
155 if ((s = strtok(NULL, " ")))
156 my_playernum = atoi(s);
157 /* Note: players[my_playernum-1] is set in init() */
158 /* But that doesn't work when joining other channel. */
159 players[my_playernum-1] = strdup(my_nick);
160
161 } else if (strcmp(cmd, "playerjoin") == 0) {
162 int player;
163 char buf[1024];
164
165 s = strtok(NULL, " ");
166 t = strtok(NULL, "");
167 if (!s || !t)
168 return;
169 player = atoi(s)-1;
170 if (player < 0 || player > 5)
171 return;
172 players[player] = strdup(t);
173 if (teams[player]) {
174 free(teams[player]);
175 teams[player] = NULL;
176 }
177 snprintf(buf, sizeof(buf), "*** %s is Now Playing", t);
178 msg_text(BUFFER_PLINE, buf);
179 if (dispmode == MODE_FIELDS)
180 io->setup_fields();
181
182 } else if (strcmp(cmd, "playerleave") == 0) {
183 int player;
184 char buf[1024];
185
186 s = strtok(NULL, " ");
187 if (!s)
188 return;
189 player = atoi(s)-1;
190 if (player < 0 || player > 5 || !players[player])
191 return;
192 snprintf(buf, sizeof(buf), "*** %s has Left", players[player]);
193 msg_text(BUFFER_PLINE, buf);
194 free(players[player]);
195 players[player] = NULL;
196 if (dispmode == MODE_FIELDS)
197 io->setup_fields();
198
199 } else if (strcmp(cmd, "team") == 0) {
200 int player;
201 char buf[1024];
202
203 s = strtok(NULL, " ");
204 t = strtok(NULL, "");
205 if (!s)
206 return;
207 player = atoi(s)-1;
208 if (player < 0 || player > 5 || !players[player])
209 return;
210 if (teams[player])
211 free(teams[player]);
212 if (t)
213 teams[player] = strdup(t);
214 else
215 teams[player] = NULL;
216 if (t)
217 snprintf(buf, sizeof(buf), "*** %s is Now on Team %s", players[player], t);
218 else
219 snprintf(buf, sizeof(buf), "*** %s is Now Alone", players[player]);
220 msg_text(BUFFER_PLINE, buf);
221
222 } else if (strcmp(cmd, "pline") == 0) {
223 int playernum;
224 char buf[1024], *name;
225
226 s = strtok(NULL, " ");
227 t = strtok(NULL, "");
228 if (!s)
229 return;
230 if (!t)
231 t = "";
232 playernum = atoi(s)-1;
233 if (playernum == -1) {
234 name = "Server";
235 } else {
236 if (playernum < 0 || playernum > 5 || !players[playernum])
237 return;
238 name = players[playernum];
239 }
240 snprintf(buf, sizeof(buf), "<%s> %s", name, t);
241 msg_text(BUFFER_PLINE, buf);
242
243 } else if (strcmp(cmd, "plineact") == 0) {
244 int playernum;
245 char buf[1024], *name;
246
247 s = strtok(NULL, " ");
248 t = strtok(NULL, "");
249 if (!s)
250 return;
251 if (!t)
252 t = "";
253 playernum = atoi(s)-1;
254 if (playernum == -1) {
255 name = "Server";
256 } else {
257 if (playernum < 0 || playernum > 5 || !players[playernum])
258 return;
259 name = players[playernum];
260 }
261 snprintf(buf, sizeof(buf), "* %s %s", name, t);
262 msg_text(BUFFER_PLINE, buf);
263
264 } else if (strcmp(cmd, tetrifast ? "*******" : "newgame") == 0) {
265 int i;
266
267 if ((s = strtok(NULL, " ")))
268 /* stack height */;
269 if ((s = strtok(NULL, " ")))
270 initial_level = atoi(s);
271 if ((s = strtok(NULL, " ")))
272 lines_per_level = atoi(s);
273 if ((s = strtok(NULL, " ")))
274 level_inc = atoi(s);
275 if ((s = strtok(NULL, " ")))
276 special_lines = atoi(s);
277 if ((s = strtok(NULL, " ")))
278 special_count = atoi(s);
279 if ((s = strtok(NULL, " "))) {
280 special_capacity = atoi(s);
281 if (special_capacity > MAX_SPECIALS)
282 special_capacity = MAX_SPECIALS;
283 }
284 if ((s = strtok(NULL, " "))) {
285 memset(piecefreq, 0, sizeof(piecefreq));
286 while (*s) {
287 i = *s - '1';
288 if (i >= 0 && i < 7)
289 piecefreq[i]++;
290 s++;
291 }
292 }
293 if ((s = strtok(NULL, " "))) {
294 memset(specialfreq, 0, sizeof(specialfreq));
295 while (*s) {
296 i = *s - '1';
297 if (i >= 0 && i < 9)
298 specialfreq[i]++;
299 s++;
300 }
301 }
302 if ((s = strtok(NULL, " ")))
303 level_average = atoi(s);
304 if ((s = strtok(NULL, " ")))
305 old_mode = atoi(s);
306 lines = 0;
307 for (i = 0; i < 6; i++)
308 levels[i] = initial_level;
309 memset(&fields[my_playernum-1], 0, sizeof(Field));
310 specials[0] = -1;
311 io->clear_text(BUFFER_GMSG);
312 io->clear_text(BUFFER_ATTDEF);
313 new_game();
314 playing_game = 1;
315 game_paused = 0;
316 msg_text(BUFFER_PLINE, "*** The Game Has Started");
317 if (dispmode != MODE_FIELDS) {
318 dispmode = MODE_FIELDS;
319 io->setup_fields();
320 }
321
322 } else if (strcmp(cmd, "ingame") == 0) {
323 /* Sent when a player connects in the middle of a game */
324 int x, y;
325 char buf[1024], *s;
326
327 s = buf + sprintf(buf, "f %d ", my_playernum);
328 for (y = 0; y < FIELD_HEIGHT; y++) {
329 for (x = 0; x < FIELD_WIDTH; x++) {
330 fields[my_playernum-1][y][x] = rand()%5 + 1;
331 *s++ = '0' + fields[my_playernum-1][y][x];
332 }
333 }
334 *s = 0;
335 sputs(buf, server_sock);
336 playing_game = 0;
337 not_playing_game = 1;
338
339 } else if (strcmp(cmd, "pause") == 0) {
340 if ((s = strtok(NULL, " ")))
341 game_paused = atoi(s);
342 if (game_paused) {
343 msg_text(BUFFER_PLINE, "*** The Game Has Been Paused");
344 msg_text(BUFFER_GMSG, "*** The Game Has Been Paused");
345 } else {
346 msg_text(BUFFER_PLINE, "*** The Game Has Been Unpaused");
347 msg_text(BUFFER_GMSG, "*** The Game Has Been Unpaused");
348 }
349
350 } else if (strcmp(cmd, "endgame") == 0) {
351 playing_game = 0;
352 not_playing_game = 0;
353 memset(fields, 0, sizeof(fields));
354 specials[0] = -1;
355 io->clear_text(BUFFER_ATTDEF);
356 msg_text(BUFFER_PLINE, "*** The Game Has Ended");
357 if (dispmode == MODE_FIELDS) {
358 int i;
359 io->draw_own_field();
360 for (i = 1; i <= 6; i++) {
361 if (i != my_playernum)
362 io->draw_other_field(i);
363 }
364 }
365 if (dispmode != MODE_PARTYLINE) {
366 dispmode = MODE_PARTYLINE;
367 io->setup_partyline();
368 }
369
370 } else if (strcmp(cmd, "playerwon") == 0) {
371 /* Syntax: playerwon # -- sent when all but one player lose */
372
373 } else if (strcmp(cmd, "playerlost") == 0) {
374 /* Syntax: playerlost # -- sent after playerleave on disconnect
375 * during a game, or when a player loses (sent by the losing
376 * player and from the server to all other players */
377
378 } else if (strcmp(cmd, "f") == 0) { /* field */
379 int player, x, y, tile;
380
381 /* This looks confusing, but what it means is, ignore this message
382 * if a game isn't going on. */
383 if (!playing_game && !not_playing_game)
384 return;
385 if (!(s = strtok(NULL, " ")))
386 return;
387 player = atoi(s);
388 player--;
389 if (!(s = strtok(NULL, "")))
390 return;
391 if (*s >= '0') {
392 /* Set field directly */
393 char *ptr = (char *) fields[player];
394 while (*s) {
395 if (*s <= '5')
396 *ptr++ = (*s++) - '0';
397 else switch (*s++) {
398 case 'a': *ptr++ = 6 + SPECIAL_A; break;
399 case 'b': *ptr++ = 6 + SPECIAL_B; break;
400 case 'c': *ptr++ = 6 + SPECIAL_C; break;
401 case 'g': *ptr++ = 6 + SPECIAL_G; break;
402 case 'n': *ptr++ = 6 + SPECIAL_N; break;
403 case 'o': *ptr++ = 6 + SPECIAL_O; break;
404 case 'q': *ptr++ = 6 + SPECIAL_Q; break;
405 case 'r': *ptr++ = 6 + SPECIAL_R; break;
406 case 's': *ptr++ = 6 + SPECIAL_S; break;
407 }
408 }
409 } else {
410 /* Set specific locations on field */
411 tile = 0;
412 while (*s) {
413 if (*s < '0') {
414 tile = *s - '!';
415 } else {
416 x = *s - '3';
417 y = (*++s) - '3';
418 fields[player][y][x] = tile;
419 }
420 s++;
421 }
422 }
423 if (player == my_playernum-1)
424 io->draw_own_field();
425 else
426 io->draw_other_field(player+1);
427 } else if (strcmp(cmd, "lvl") == 0) {
428 int player;
429
430 if (!(s = strtok(NULL, " ")))
431 return;
432 player = atoi(s)-1;
433 if (!(s = strtok(NULL, "")))
434 return;
435 levels[player] = atoi(s);
436
437 } else if (strcmp(cmd, "sb") == 0) {
438 int from, to;
439 char *type;
440
441 if (!(s = strtok(NULL, " ")))
442 return;
443 to = atoi(s);
444 if (!(type = strtok(NULL, " ")))
445 return;
446 if (!(s = strtok(NULL, " ")))
447 return;
448 from = atoi(s);
449 do_special(type, from, to);
450
451 } else if (strcmp(cmd, "gmsg") == 0) {
452 if (!(s = strtok(NULL, "")))
453 return;
454 msg_text(BUFFER_GMSG, s);
455
456 }
457 }
458
459 /*************************************************************************/
460 /*************************************************************************/
461
462 static char partyline_buffer[512];
463 static int partyline_pos = 0;
464
465 #define curpos (partyline_buffer+partyline_pos)
466
467 /*************************************************************************/
468
469 /* Add a character to the partyline buffer. */
470
471 void partyline_input(int c)
472 {
473 if (partyline_pos < sizeof(partyline_buffer) - 1) {
474 memmove(curpos+1, curpos, strlen(curpos)+1);
475 partyline_buffer[partyline_pos++] = c;
476 io->draw_partyline_input(partyline_buffer, partyline_pos);
477 }
478 }
479
480 /*************************************************************************/
481
482 /* Delete the current character from the partyline buffer. */
483
484 void partyline_delete(void)
485 {
486 if (partyline_buffer[partyline_pos]) {
487 memmove(curpos, curpos+1, strlen(curpos)-1+1);
488 io->draw_partyline_input(partyline_buffer, partyline_pos);
489 }
490 }
491
492 /*************************************************************************/
493
494 /* Backspace a character from the partyline buffer. */
495
496 void partyline_backspace(void)
497 {
498 if (partyline_pos > 0) {
499 partyline_pos--;
500 partyline_delete();
501 }
502 }
503
504 /*************************************************************************/
505
506 /* Kill the entire partyline input buffer. */
507
508 void partyline_kill(void)
509 {
510 partyline_pos = 0;
511 *partyline_buffer = 0;
512 io->draw_partyline_input(partyline_buffer, partyline_pos);
513 }
514
515 /*************************************************************************/
516
517 /* Move around the input buffer. Sign indicates direction; absolute value
518 * of 1 means one character, 2 means the whole line.
519 */
520
521 void partyline_move(int how)
522 {
523 if (how == -2) {
524 partyline_pos = 0;
525 io->draw_partyline_input(partyline_buffer, partyline_pos);
526 } else if (how == -1 && partyline_pos > 0) {
527 partyline_pos--;
528 io->draw_partyline_input(partyline_buffer, partyline_pos);
529 } else if (how == 1 && partyline_buffer[partyline_pos]) {
530 partyline_pos++;
531 io->draw_partyline_input(partyline_buffer, partyline_pos);
532 } else if (how == 2) {
533 partyline_pos = strlen(partyline_buffer);
534 io->draw_partyline_input(partyline_buffer, partyline_pos);
535 }
536 }
537
538 /*************************************************************************/
539
540 /* Send the input line to the server. */
541
542 void partyline_enter(void)
543 {
544 char buf[1024];
545
546 if (*partyline_buffer) {
547 if (strncasecmp(partyline_buffer, "/me ", 4) == 0) {
548 sockprintf(server_sock, "plineact %d %s", my_playernum, partyline_buffer+4);
549 snprintf(buf, sizeof(buf), "* %s %s", players[my_playernum-1], partyline_buffer+4);
550 msg_text(BUFFER_PLINE, buf);
551 } else if (strcasecmp(partyline_buffer, "/start") == 0) {
552 sockprintf(server_sock, "startgame 1 %d", my_playernum);
553 } else if (strcasecmp(partyline_buffer, "/end") == 0) {
554 sockprintf(server_sock, "startgame 0 %d", my_playernum);
555 } else if (strcasecmp(partyline_buffer, "/pause") == 0) {
556 sockprintf(server_sock, "pause 1 %d", my_playernum);
557 } else if (strcasecmp(partyline_buffer, "/unpause") == 0) {
558 sockprintf(server_sock, "pause 0 %d", my_playernum);
559 } else if (strncasecmp(partyline_buffer, "/team", 5) == 0) {
560 if (strlen(partyline_buffer) == 5)
561 strcpy(partyline_buffer+5, " "); /* make it "/team " */
562 sockprintf(server_sock, "team %d %s", my_playernum, partyline_buffer+6);
563 if (partyline_buffer[6]) {
564 if (teams[my_playernum-1])
565 free(teams[my_playernum-1]);
566 teams[my_playernum-1] = strdup(partyline_buffer+6);
567 snprintf(buf, sizeof(buf), "*** %s is Now on Team %s", players[my_playernum-1], partyline_buffer+6);
568 msg_text(BUFFER_PLINE, buf);
569 } else {
570 if (teams[my_playernum-1])
571 free(teams[my_playernum-1]);
572 teams[my_playernum-1] = NULL;
573 snprintf(buf, sizeof(buf), "*** %s is Now Alone", players[my_playernum-1]);
574 msg_text(BUFFER_PLINE, buf);
575 }
576 } else {
577 sockprintf(server_sock, "pline %d %s", my_playernum, partyline_buffer);
578 if (*partyline_buffer != '/'
579 || partyline_buffer[1] == 0 || partyline_buffer[1] == ' ') {
580 /* We do not show server-side commands. */
581 snprintf(buf, sizeof(buf), "<%s> %s", players[my_playernum-1], partyline_buffer);
582 msg_text(BUFFER_PLINE, buf);
583 }
584 }
585 partyline_pos = 0;
586 *partyline_buffer = 0;
587 io->draw_partyline_input(partyline_buffer, partyline_pos);
588 }
589 }
590
591 #undef curpos
592
593 /*************************************************************************/
594 /*************************************************************************/
595
596 void help()
597 {
598 fprintf(stderr,
599 "Tetrinet " VERSION " - Text-mode tetrinet client\n"
600 "\n"
601 "Usage: tetrinet [OPTION]... NICK SERVER\n"
602 "\n"
603 "Options (see README for details):\n"
604 " -fancy Use \"fancy\" TTY graphics.\n"
605 " -fast Connect to the server in the tetrifast mode.\n"
606 " -log <file> Log network traffic to the given file.\n"
607 " -noshadow Do not make the pieces cast shadow.\n"
608 " -noslide Do not allow pieces to \"slide\" after being dropped\n"
609 " with the spacebar.\n"
610 " -server Start the server instead of the client.\n"
611 " -shadow Make the pieces cast shadow. Can speed up gameplay\n"
612 " considerably, but it can be considered as cheating by\n"
613 " some people since some other tetrinet clients lack this.\n"
614 " -slide Opposite of -noslide; allows pieces to \"slide\" after\n"
615 " being dropped. If both -slide and -noslide are given,\n"
616 " -slide takes precedence.\n"
617 " -windows Behave as much like the Windows version of Tetrinet as\n"
618 " possible. Implies -noslide and -noshadow.\n"
619 );
620 }
621
622 int init(int ac, char **av)
623 {
624 int i;
625 char *nick = NULL, *server = NULL;
626 char buf[1024];
627 char nickmsg[1024];
628 char ip[4];
629 char iphashbuf[32];
630 int len;
631 #ifdef BUILTIN_SERVER
632 int start_server = 0; /* Start the server? (-server) */
633 #endif
634 int slide = 0; /* Do we definitely want to slide? (-slide) */
635
636
637 /* If there's a DISPLAY variable set in the environment, default to
638 * Xwindows I/O, else default to terminal I/O. */
639 /* if (getenv("DISPLAY"))
640 io = &xwin_interface;
641 else
642 io = &tty_interface; */
643 io=&tty_interface; /* because Xwin isn't done yet */
644
645 srand(time(NULL));
646 init_shapes();
647
648 for (i = 1; i < ac; i++) {
649 if (*av[i] == '-') {
650 #ifdef BUILTIN_SERVER
651 if (strcmp(av[i], "-server") == 0) {
652 start_server = 1;
653 } else
654 #endif
655 if (strcmp(av[i], "-fancy") == 0) {
656 fancy = 1;
657 } else if (strcmp(av[i], "-log") == 0) {
658 log = 1;
659 i++;
660 if (i >= ac) {
661 fprintf(stderr, "Option -log requires an argument\n");
662 return 1;
663 }
664 logname = av[i];
665 } else if (strcmp(av[i], "-noslide") == 0) {
666 noslide = 1;
667 } else if (strcmp(av[i], "-noshadow") == 0) {
668 cast_shadow = 0;
669 } else if (strcmp(av[i], "-shadow") == 0) {
670 cast_shadow = 1;
671 } else if (strcmp(av[i], "-slide") == 0) {
672 slide = 1;
673 } else if (strcmp(av[i], "-windows") == 0) {
674 windows_mode = 1;
675 noslide = 1;
676 cast_shadow = 0;
677 } else if (strcmp(av[i], "-fast") == 0) {
678 tetrifast = 1;
679 } else {
680 fprintf(stderr, "Unknown option %s\n", av[i]);
681 help();
682 return 1;
683 }
684 } else if (!nick) {
685 my_nick = nick = av[i];
686 } else if (!server) {
687 server = av[i];
688 } else {
689 help();
690 return 1;
691 }
692 }
693 if (slide)
694 noslide = 0;
695 #ifdef BUILTIN_SERVER
696 if (start_server)
697 exit(server_main());
698 #endif
699 if (!server) {
700 help();
701 return 1;
702 }
703 if (strlen(nick) > 63) /* put a reasonable limit on nick length */
704 nick[63] = 0;
705
706 if ((server_sock = conn(server, 31457, ip)) < 0) {
707 fprintf(stderr, "Couldn't connect to server %s: %s\n",
708 server, strerror(errno));
709 return 1;
710 }
711 sprintf(nickmsg, "tetri%s %s 1.13", tetrifast ? "faster" : "sstart", nick);
712 sprintf(iphashbuf, "%d", ip[0]*54 + ip[1]*41 + ip[2]*29 + ip[3]*17);
713 /* buf[0] does not need to be initialized for this algorithm */
714 len = strlen(nickmsg);
715 for (i = 0; i < len; i++)
716 buf[i+1] = (((buf[i]&0xFF) + (nickmsg[i]&0xFF)) % 255) ^ iphashbuf[i % strlen(iphashbuf)];
717 len++;
718 for (i = 0; i < len; i++)
719 sprintf(nickmsg+i*2, "%02X", buf[i] & 0xFF);
720 sputs(nickmsg, server_sock);
721
722 do {
723 if (!sgets(buf, sizeof(buf), server_sock)) {
724 fprintf(stderr, "Server %s closed connection\n", server);
725 disconn(server_sock);
726 return 1;
727 }
728 parse(buf);
729 } while (my_playernum < 0);
730 sockprintf(server_sock, "team %d ", my_playernum);
731
732 players[my_playernum-1] = strdup(nick);
733 dispmode = MODE_PARTYLINE;
734 io->screen_setup();
735 io->setup_partyline();
736
737 return 0;
738 }
739
740 /*************************************************************************/
741
742 int main(int ac, char **av)
743 {
744 int i;
745
746 if ((i = init(ac, av)) != 0)
747 return i;
748
749 for (;;) {
750 int timeout;
751 if (playing_game && !game_paused)
752 timeout = tetris_timeout();
753 else
754 timeout = -1;
755 i = io->wait_for_input(timeout);
756 if (i == -1) {
757 char buf[1024];
758 if (sgets(buf, sizeof(buf), server_sock))
759 parse(buf);
760 else {
761 msg_text(BUFFER_PLINE, "*** Disconnected from Server");
762 break;
763 }
764 } else if (i == -2) {
765 tetris_timeout_action();
766 } else if (i == 12) { /* Ctrl-L */
767 io->screen_redraw();
768 } else if (i == K_F10) {
769 break; /* out of main loop */
770 } else if (i == K_F1) {
771 if (dispmode != MODE_FIELDS) {
772 dispmode = MODE_FIELDS;
773 io->setup_fields();
774 }
775 } else if (i == K_F2) {
776 if (dispmode != MODE_PARTYLINE) {
777 dispmode = MODE_PARTYLINE;
778 io->setup_partyline();
779 }
780 } else if (i == K_F3) {
781 if (dispmode != MODE_WINLIST) {
782 dispmode = MODE_WINLIST;
783 io->setup_winlist();
784 }
785 } else if (dispmode == MODE_FIELDS) {
786 tetris_input(i);
787 } else if (dispmode == MODE_PARTYLINE) {
788 if (i == 8 || i == 127) /* Backspace or Delete */
789 partyline_backspace();
790 else if (i == 4) /* Ctrl-D */
791 partyline_delete();
792 else if (i == 21) /* Ctrl-U */
793 partyline_kill();
794 else if (i == '\r' || i == '\n')
795 partyline_enter();
796 else if (i == K_LEFT)
797 partyline_move(-1);
798 else if (i == K_RIGHT)
799 partyline_move(1);
800 else if (i == 1) /* Ctrl-A */
801 partyline_move(-2);
802 else if (i == 5) /* Ctrl-E */
803 partyline_move(2);
804 else if (i >= 1 && i <= 0xFF)
805 partyline_input(i);
806 }
807 }
808
809 disconn(server_sock);
810 return 0;
811 }
812
813 /*************************************************************************/
814
815 #endif /* !SERVER_ONLY */
816
817 /*************************************************************************/
Tetrinet GIT Repository