game.c

   1 /*
   2  * Netris -- A free networked version of T*tris
   3  * Copyright (C) 1994,1995,1996  Mark H. Weaver <mhw@netris.org>
   4  *
   5  * This program is free software; you can redistribute it and/or
   6  * modify it under the terms of the GNU General Public License
   7  * as published by the Free Software Foundation; either version 2
   8  * of the License, or (at your option) any later version.
   9  *
  10  * This program is distributed in the hope that it will be useful,
  11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13  * GNU General Public License for more details.
  14  *
  15  * You should have received a copy of the GNU General Public License
  16  * along with this program; if not, write to the Free Software
  17  * Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18  *
  19  * $Id: game.c,v 1.39 1999/05/16 06:56:27 mhw Exp $
  20  */
  21
  22 #define NOEXT
  23 #include "netris.h"
  24 #include <stdlib.h>
  25 #include <ctype.h>
  26 #include <string.h>
  27 #include <sys/types.h>
  28 #include <netinet/in.h>
  29 #include <setjmp.h>
  30
  31 static struct option options[] = {
  32         { "ascii",              2, 0, 'a' },
  33         { "connect",    1, 0, 'c' },
  34         { "port",               1, 0, 'p' },
  35         { "level",              1, 0, 'l' },
  36         { "team",               1, 0, 't' },
  37         { "spy",                1, 0,  1  },
  38         { "robot",              1, 0, 'r' },
  39         { "fair-robot", 0, 0, 'F' },
  40         { "dropmode",   2, 0, 'd' },
  41         { "instadrop",  2, 0, 'D' },
  42         { "color",              2, 0, 'C' },
  43         { "slowterm",   2, 0, 'S' },
  44         { "keys",               1, 0, 'k' },
  45         { "rules",              0, 0, 'R' },
  46         { "info",               0, 0, 'H' },
  47         { "help",               0, 0, 'h' },
  48         { 0,                    0, 0,  0 }
  49 };
  50
  51 enum { KT_left, KT_right, KT_rotright, KT_rotleft, KT_drop, KT_down,
  52                 KT_faster, KT_pause, KT_redraw, KT_quit, KT_numKeys };
  53
  54 static char *keyNames[KT_numKeys+1] = {
  55         "Left", "Right", "RotRight", "RotLeft", "Drop", "Down",
  56         "Faster", "Pause", "Redraw", "Quit", NULL };
  57
  58 static char *gameNames[GT_len] = { "OnePlayer", "ClassicTwo" };
  59
  60 static char keyTable[KT_numKeys+1];
  61
  62 static char *hostStr;
  63 static int paused = 0;
  64
  65 static sigjmp_buf close_env;
  66
  67
  68 ExtFunc void MapKeys(char *newKeys)
  69 {
  70         int i, k, ch;
  71         char used[256];
  72         int errs = 0;
  73
  74         /* XXX assumptions about ASCII encoding here */
  75         for (i = k = 0; newKeys[i] && k < KT_numKeys; i++,k++) {
  76                 if (newKeys[i] == '^' && newKeys[i+1])
  77                         keyTable[k] = toupper(newKeys[++i]) - ('A' - 1);
  78                 else
  79                         keyTable[k] = newKeys[i];
  80         }
  81         memset(used, 0, sizeof(used));
  82         for (k = 0; k < KT_numKeys; k++) {
  83                 ch = (unsigned char) keyTable[k];
  84                 if (used[ch]) {
  85                         if (iscntrl(ch) && ch < ' ')
  86                                 sprintf(scratch, "Ctrl-%c", ch + ('A' - 1));
  87                         else if (isprint(ch))
  88                                 sprintf(scratch, "\"%c\"", ch);
  89                         else
  90                                 sprintf(scratch, "0x%X", ch);
  91                         if (!errs)
  92                                 fprintf(stderr, "Duplicate key mappings:\n");
  93                         errs++;
  94                         fprintf(stderr, "  %s mapped to both %s and %s\n",
  95                                         scratch, keyNames[used[ch]-1], keyNames[k]);
  96                 }
  97                 used[ch] = k + 1;
  98         }
  99         if (errs)
 100                 exit(1);
 101 } //MapKeys
 102
 103 ExtFunc void WriteConf(void)
 104 {
 105         FILE *file_out;
 106
 107         file_out = fopen(CONFIG_FILE, "w");
 108         if (file_out == NULL)
 109                 die("Error writing config file");
 110
 111         fprintf(file_out, "### NETRIS %s Config file ###\n\n", version_string);
 112
 113         fclose(file_out);
 114         fprintf(stderr, "Wrote new game configuration to %s\n", CONFIG_FILE);
 115 } //WriteConf
 116
 117 ExtFunc void HandleOption(char tag, char *value)
 118 {
 119         switch (tag) {
 120                 case 'a':       //ascii
 121                         if (value && !strcasecmp(value, "0")) Game.ascii = 0;
 122                         else Game.ascii = 1;
 123                         break;
 124                 case 'c':       //connect
 125                         initConn = 1;
 126                         hostStr = value;
 127                         break;
 128                 case 'p':       //port
 129                         port = atoi(value);
 130                         break;
 131                 case 'i':       //speed (of level 1)
 132                         Game.initspeed = atof(value) * 1e6;
 133                         break;
 134                 case 'l':       //level
 135                         if ((Players[0].score.level = atof(value)) < 1)
 136                                 Players[0].score.level = 1;
 137                         if (Players[0].score.level > 15)
 138                                 Players[0].score.level = 15;
 139                         break;
 140                 case 't':       //team
 141                         Players[0].team = atoi(value);
 142                         break;
 143                 case 1:         //spy
 144                         {
 145                                 int i;
 146                                 i = atof(value);
 147                                 Players[i / 10].spy = i % 10;
 148                         }
 149                         break;
 150                 case 'r':       //robot
 151                         robotEnable = 1;
 152                         Players[0].flags |= SCF_usingRobot;
 153                         InitRobot(value);
 154                         break;
 155                 case 'F':       //fair robot
 156                         fairRobot = 1;
 157                         Players[0].flags |= SCF_fairRobot;
 158                         break;
 159                 case 'd':       //drop mode
 160                         if (value && !strcasecmp(value, "0")) Players[0].dropmode &= 254;
 161                         else Players[0].dropmode |= 1;
 162                         break;
 163                 case 'D':       //instadrop
 164                         if (value && !strcasecmp(value, "0")) Players[0].dropmode &= 253;
 165                         else Players[0].dropmode |= 2;
 166                         break;
 167                 case 'C':       //color
 168                         if (value && !strcasecmp(value, "1")) Game.color = 1;
 169                         else Game.color = 0;
 170                         break;
 171                 case 'S':       //slowterm
 172                         if (value && !strcasecmp(value, "1")) Game.standout = 1;
 173                         else Game.standout = 0;
 174                         break;
 175                 case 'k':       //keys
 176                         MapKeys(value); break;
 177                 case 'H':       //info
 178                         DistInfo(); exit(0);
 179                 case 'R':       //rules
 180                         Rules(); exit(0);
 181                 case 'h':       //help
 182                         Usage(); exit(0);
 183                 default:
 184                         Usage(); exit(1);
 185         }
 186 } //HandleParam
 187
 188 ExtFunc void ReadConf(char *filename)
 189 {
 190         FILE *file_in;
 191         char buf[513];
 192         int i;
 193         char *ch;
 194         char tag[81], value[81];
 195
 196         file_in = fopen(filename, "r");
 197         if (file_in) {
 198                 while (fgets(buf, 512, file_in) != NULL) {
 199                         if ((ch = strchr(buf, '#')))
 200                                 *ch = '\0'; // truncate string from # char
 201                         for (i = strlen(buf)-1; i >= 0; i--)
 202                                 if (buf[i] == ' ' || buf[i] == '\n' || buf[i] == '\t' || buf[i] == 13)
 203                                         buf[i] = '\0';
 204                                 else break;
 205
 206                         sscanf(buf, "%80[^= \t] = %80[^\n]", tag, value);
 207                         for (i = 0; options[i].name; i++){
 208                                 if (!strcasecmp(options[i].name, tag)) {
 209                                         HandleOption(options[i].val, value);
 210                                         break;
 211                                 }
 212                         }
 213                 }
 214                 fclose(file_in);
 215         } //read file
 216         else {
 217                 fprintf(stderr, "Unable to open config file %s.\n", filename);
 218         } //defaults
 219
 220 } //ReadConf
 221
 222 ExtFunc int StartNewPiece(int scr, Shape *shape)
 223 {
 224         if (Players[scr].nextShape) {
 225                 Players[scr].curShape = Players[scr].nextShape;
 226                 Players[scr].nextShape = shape;
 227         }
 228         else
 229                 Players[scr].curShape = shape;
 230         Players[scr].curY = Players[scr].boardVisible + 4;
 231         Players[scr].curX = Players[scr].boardWidth / 2;
 232         while (!ShapeVisible(Players[scr].curShape, scr,
 233                         Players[scr].curY, Players[scr].curX))
 234                 Players[scr].curY--;
 235         if (!ShapeFits(Players[scr].curShape, scr,
 236                         Players[scr].curY, Players[scr].curX))
 237                 return 0;
 238         PlotShape(Players[scr].curShape, scr,
 239                 Players[scr].curY, Players[scr].curX, 1, 1);
 240         return 1;
 241 }
 242
 243 ExtFunc void checkPaused(void)
 244 { //check whether anyone paused the game
 245         int i;
 246
 247         paused = Game.started < 1;
 248         for (i = 1; i < MAX_SCREENS; i++) if (Players[i].alive)
 249                 paused |= Players[i].flags & SCF_paused;
 250         if (paused) paused = 1;
 251         else if (Game.started == 1) {
 252                 Game.started = 2;
 253                 Messagef("The game has started");
 254                 for (i = 1; i < MAX_SCREENS; i++) if (Players[i].alive)
 255                         ShowPause(i);
 256         } //everybody ready
 257 } //checkPaused
 258
 259 ExtFunc void OneGame(void)
 260 {
 261         MyEvent event;
 262         int linesCleared, changed = 0;
 263         int dropMode = 0;
 264         int oldPaused = 0;
 265         long pauseTimeLeft;
 266         int pieceCount = 0;
 267         int key;
 268         char *p, *cmd;
 269         int playercount;
 270         char lastadd;
 271         int linevalues[4] = { 40, 100, 400, 1200 }; //= 50*lines! - 10*(lines==1)
 272         int i;
 273
 274         maxPlayer = lastadd = me;
 275         Game.speed = Game.initspeed;
 276         for (i = 1; i < Players[me].score.level; i++)
 277                 Game.speed /= SPEEDINC;
 278         if (Game.speed < SPEEDMINIMUM)
 279                 Game.speed = SPEEDMINIMUM;
 280         ResetBaseTime();                        //reset timer
 281         ClearField(me);
 282         InitFields();
 283         SetITimer(Game.speed, Game.speed);
 284         if (robotEnable) {
 285                 int counter;
 286                 RobotCmd(0, "GameType %s\n", gameNames[game]);
 287                 RobotCmd(0, "BoardSize 0 %d %d\n",
 288                         Players[me].boardVisible, Players[me].boardWidth);
 289                 for (i = 1; i < MAX_SCREENS; i++) if (Players[i].alive && i != me) {
 290                         RobotCmd(0, "BoardSize %d %d %d\n",
 291                                 counter, Players[i].boardVisible, Players[i].boardWidth);
 292                         RobotCmd(0, "Opponent %d %s %s\n",
 293                                 counter, Players[i].name, Players[i].host);
 294                         if (Players[i].flags & SCF_usingRobot)
 295                                 RobotCmd(0, "OpponentFlag %d robot\n", i);
 296                         if (Players[i].flags & SCF_fairRobot)
 297                                 RobotCmd(0, "OpponentFlag %d fairRobot\n", i);
 298                         counter++;
 299                 }
 300                 RobotCmd(0, "TickLength %.3f\n", Game.speed / 1.0e6);
 301                 RobotCmd(0, "BeginGame\n");
 302                 RobotTimeStamp();
 303         }
 304         Players[me].nextShape = ChooseOption(stdOptions);
 305         while (1) {
 306                 if (Players[me].alive) {
 307                         if (!StartNewPiece(me, ChooseOption(stdOptions))) {
 308                                         netint4 data[4];
 309                                 Players[me].alive = 0;
 310                                 if (lastadd == me) Messagef("You died");
 311                                 else Messagef("\\%d%s fragged you",
 312                                         Players[lastadd].team > 7 ? 7 : Players[lastadd].team,
 313                                         Players[lastadd].name);
 314                                 if (game == GT_classicTwo)
 315                                         SendPacket(me, NP_argghhh, sizeof(lastadd), &lastadd);
 316                                 ShowPause(me);
 317                                 changed = 1;
 318                         } //die
 319                         else {
 320                                 ShowScore(me, Players[me].score);
 321                                 if (robotEnable && !fairRobot)
 322                                         RobotCmd(1, "NewPiece %d\n", ++pieceCount);
 323                                 if (spied) {
 324                                         short shapeNum;
 325                                         netint2 data[1];
 326
 327                                         shapeNum = ShapeToNetNum(Players[me].curShape);
 328                                         data[0] = hton2(shapeNum);
 329                                         SendPacket(me, NP_newPiece, sizeof(data), data);
 330                                 } //send new piece
 331                         }
 332                 } //new piece
 333                 while (1) {
 334                         for (i = 1; i < MAX_SCREENS; i++)
 335                                 if (Players[i].alive && Players[i].spy)
 336                                         changed |= RefreshBoard(i);
 337                         if (changed) {
 338                                 if (!paused) ShowTime();
 339                                 refresh();
 340                                 changed = 0;
 341                         } //screen update
 342                         playercount = 0;
 343                         for (i = 1; i < MAX_SCREENS; i++)
 344                                 if (Players[i].alive) playercount++;
 345                         if (playercount < 1) goto gameOver;
 346                         CheckNetConn();
 347                         switch (WaitMyEvent(&event, EM_any)) {
 348                                 case E_alarm:
 349                                         if (!paused && Players[me].alive)
 350                                                 if (!MovePiece(me, -1, 0))
 351                                                         goto nextPiece;
 352                                                 else if (spied)
 353                                                         SendPacket(me, NP_down, 0, NULL);
 354                                         break;
 355                                 case E_key:
 356                                         p = strchr(keyTable, tolower(event.u.key));
 357                                         key = p - keyTable;
 358                                         if (robotEnable) {
 359                                                 RobotCmd(1, "UserKey %d %s\n",
 360                                                                 (int)(unsigned char)event.u.key,
 361                                                                 p ? keyNames[key] : "?");
 362                                                 break;
 363                                         } //let robot handle keypress
 364                                         if (!p) break;
 365                                 keyEvent:
 366                                         if (!Players[me].alive && key != KT_quit) break;
 367                                         if (paused && key < KT_pause) break;
 368                                         switch(key) {
 369                                                 case KT_left:
 370                                                         if (MovePiece(me, 0, -1) && spied)
 371                                                                 SendPacket(me, NP_left, 0, NULL);
 372                                                         break;
 373                                                 case KT_right:
 374                                                         if (MovePiece(me, 0, 1) && spied)
 375                                                                 SendPacket(me, NP_right, 0, NULL);
 376                                                         break;
 377                                                 case KT_rotleft:
 378                                                         if (RotatePiece(me, 0) && spied)
 379                                                                 SendPacket(me, NP_rotleft, 0, NULL);
 380                                                         break;
 381                                                 case KT_rotright:
 382                                                         if (RotatePiece(me, 1) && spied)
 383                                                                 SendPacket(me, NP_rotright, 0, NULL);
 384                                                         break;
 385                                                 case KT_down:
 386                                                         SetITimer(Game.speed, Game.speed);
 387                                                         if (MovePiece(me, -1, 0)) {
 388                                                                 if (spied) SendPacket(me, NP_down, 0, NULL);
 389                                                         }
 390                                                         else goto nextPiece;
 391                                                         break;
 392                                                 case KT_drop:
 393                                                         SetITimer(Game.speed, Game.speed);
 394                                                         if (DropPiece(me)) {
 395                                                                 if (spied) SendPacket(me, NP_drop, 0, NULL);
 396                                                                 if (Players[me].dropmode == 2) goto nextPiece;
 397                                                         }
 398                                                         else goto nextPiece;
 399                                                         dropMode = Players[me].dropmode;
 400                                                         break;
 401                                                 case KT_faster:
 402                                                         if (game != GT_onePlayer)
 403                                                                 break;
 404                                                         if ((Game.speed /= SPEEDINC) < SPEEDMINIMUM)
 405                                                                 Game.speed = SPEEDMINIMUM;
 406                                                         SetITimer(Game.speed, SetITimer(0, 0));
 407                                                         Players[me].score.level++;
 408                                                         ShowScore(me, Players[me].score);
 409                                                         changed = 1;
 410                                                         break;
 411                                                 case KT_pause:
 412                                                         Players[me].flags ^= SCF_paused;
 413                                                         if (Game.started > 1)
 414                                                                 Messagef(Players[me].flags & SCF_paused
 415                                                                         ? "You paused the game"
 416                                                                         : "You unpaused the game");
 417                                                         else
 418                                                                 Messagef(Players[me].flags & SCF_paused
 419                                                                         ? "You are not ready" : "You are ready");
 420                                                         checkPaused();
 421                                                         if (game == GT_classicTwo)
 422                                                                 SendPacket(me, NP_pause, 0, NULL);
 423                                                         if (robotEnable) RobotCmd(1, "Pause %d\n", paused);
 424                                                         ShowPause(me);
 425                                                         changed = 1;
 426                                                         break;
 427                                                 case KT_redraw:
 428                                                         DrawTitle();
 429                                                         InitFields();
 430 //                                                      ScheduleFullRedraw();
 431                                                         for (i = 1; i < MAX_SCREENS; i++)
 432                                                                 if (Players[i].alive && Players[i].spy)
 433                                                                         RefreshBoard(i);
 434                                                         refresh();
 435                                                         break;
 436                                                 case KT_quit:
 437                                                         ShowPause(me);
 438                                                         refresh();
 439                                                         goto gameOver;
 440                                         } //E_key
 441                                         if (dropMode && DropPiece(me) > 0) {
 442                                                 SetITimer(Game.speed, Game.speed);
 443                                                 if (spied)
 444                                                         SendPacket(me, NP_drop, 0, NULL);
 445                                         }
 446                                         break;
 447                                 case E_robot:
 448                                 {
 449                                         int num;
 450
 451                                         cmd = event.u.robot.data;
 452                                         if ((p = strchr(cmd, ' ')))
 453                                                 *p++ = 0;
 454                                         else
 455                                                 p = cmd + strlen(cmd);
 456                                         for (key = 0; keyNames[key]; ++key)
 457                                                 if (!strcmp(keyNames[key], cmd) &&
 458                                                                 (fairRobot || (1 == sscanf(p, "%d", &num) &&
 459                                                                         num == pieceCount)))
 460                                                         goto keyEvent;
 461                                         if (!strcmp(cmd, "Message")) {
 462                                                 Messagef(p);
 463                                                 changed = 1;
 464                                         }
 465                                         break;
 466                                 } //E_robot
 467                                 case E_net:
 468                                         switch(event.u.net.type) {
 469                                                 case NP_newPiece:
 470                                                 {
 471                                                         short shapeNum;
 472                                                         netint2 data[1];
 473
 474                                                         FreezePiece(event.u.net.uid);
 475                                                         memcpy(data, event.u.net.data, sizeof(data));
 476                                                         shapeNum = ntoh2(data[0]);
 477                                                         StartNewPiece(event.u.net.uid,
 478                                                                 NetNumToShape(shapeNum));
 479                                                         break;
 480                                                 } //new piece
 481                                                 case NP_down:
 482                                                         MovePiece(event.u.net.uid, -1, 0);
 483                                                         break;
 484                                                 case NP_left:
 485                                                         MovePiece(event.u.net.uid, 0, -1);
 486                                                         break;
 487                                                 case NP_right:
 488                                                         MovePiece(event.u.net.uid, 0, 1);
 489                                                         break;
 490                                                 case NP_rotleft:
 491                                                         RotatePiece(event.u.net.uid, 0);
 492                                                         break;
 493                                                 case NP_rotright:
 494                                                         RotatePiece(event.u.net.uid, 1);
 495                                                         break;
 496                                                 case NP_drop:
 497                                                         DropPiece(event.u.net.uid);
 498                                                         break;
 499                                                 case NP_clear:
 500                                                         ClearFullLines(event.u.net.uid);
 501                                                         break;
 502                                                 case NP_insertJunk:
 503                                                 {
 504                                                         netint2 data[2];
 505
 506                                                         memcpy(data, event.u.net.data, sizeof(data));
 507                                                         InsertJunk(event.u.net.uid, ntoh2(data[0]),
 508                                                                 ntoh2(data[1]));
 509                                                         break;
 510                                                 } //player added junklines
 511                                                 case NP_giveJunk:
 512                                                 {
 513                                                         netint2 data[2];
 514                                                         short column;
 515
 516                                                         if (!Players[me].alive) break;
 517                                                         memcpy(data, event.u.net.data, sizeof(data[0]));
 518                                                         column = Random(0, Players[me].boardWidth);
 519                                                         data[1] = hton2(column);
 520                                                         Messagef("\\%d%s sends %d lines",
 521                                                                 Players[event.u.net.uid].team > 7 ? 7
 522                                                                 : Players[event.u.net.uid].team,
 523                                                                 Players[event.u.net.uid].name, ntoh2(data[0]));
 524                                                         lastadd = event.u.net.uid;
 525                                                         InsertJunk(me, ntoh2(data[0]), column);
 526                                                         if (spied)
 527                                                                 SendPacket(me, NP_insertJunk, sizeof(data),
 528                                                                         data);
 529                                                         break;
 530                                                 } //receive junklines
 531                                                 case NP_start:
 532                                                 {
 533                                                         Game.started = 1;
 534                                                         checkPaused();
 535                                                         break;
 536                                                 } //start game
 537                                                 case NP_newPlayer:
 538                                                 {
 539                                                         if (event.u.net.uid > maxPlayer)
 540                                                                 maxPlayer = event.u.net.uid;
 541                                                         memcpy(&Players[event.u.net.uid],
 542                                                                 event.u.net.data, event.u.net.size);
 543                                                         ClearField(event.u.net.uid);
 544                                                         Messagef("\\%d%s joins the game",
 545                                                                 Players[event.u.net.uid].team > 7 ? 7
 546                                                                 : Players[event.u.net.uid].team,
 547                                                                 Players[event.u.net.uid].name);
 548                                                         if (Players[event.u.net.uid].flags & SCF_paused) {
 549                                                                 checkPaused();
 550                                                                 if (robotEnable)
 551                                                                         RobotCmd(1, "Pause %d\n", paused);
 552                                                         } //player has paused
 553                                                         DrawField(event.u.net.uid);
 554 //                                                      ShowPause(event.u.net.uid);
 555                                                         changed = 1;
 556                                                         break;
 557                                                 } //player joined
 558                                                 case NP_pause:
 559                                                 {
 560                                                         char s[20];
 561
 562                                                         Players[event.u.net.uid].flags ^= SCF_paused;
 563                                                         if (Game.started > 1)
 564                                                                 strcpy(s,
 565                                                                         Players[event.u.net.uid].flags & SCF_paused
 566                                                                         ? "paused the game" : "unpaused the game");
 567                                                         else
 568                                                                 strcpy(s,
 569                                                                         Players[event.u.net.uid].flags & SCF_paused
 570                                                                         ? "is not ready" : "is good to go");
 571                                                         Messagef("\\%d%s %s",
 572                                                                 Players[event.u.net.uid].team > 7 ? 7
 573                                                                 : Players[event.u.net.uid].team,
 574                                                                 Players[event.u.net.uid].name, s);
 575                                                         checkPaused();
 576                                                         if (robotEnable) RobotCmd(1, "Pause %d\n", paused);
 577                                                         ShowPause(event.u.net.uid);
 578                                                         changed = 1;
 579                                                         break;
 580                                                 } //(un)pause
 581                                                 case NP_argghhh:
 582                                                 {
 583                                                         char i;
 584                                                         memcpy(&i, event.u.net.data, sizeof(i));
 585                                                         Players[event.u.net.uid].alive = 0;
 586                                                         if (i == me) Messagef("You fragged %s",
 587                                                                         Players[event.u.net.uid].name);
 588                                                         else if (i == event.u.net.uid)
 589                                                                 Messagef("\\%d%s died",
 590                                                                         Players[i].team > 7 ? 7 : Players[i].team,
 591                                                                         Players[i].name);
 592                                                         else Messagef("\\%d%s fragged %s",
 593                                                                         Players[i].team > 7 ? 7 : Players[i].team,
 594                                                                         Players[i].name,
 595                                                                         Players[event.u.net.uid].name);
 596                                                         checkPaused();
 597                                                         ShowPause(event.u.net.uid);
 598                                                         changed = 1;
 599                                                         break;
 600                                                 } //G/O
 601                                                 default:
 602                                                         break;
 603                                         } //E_net
 604                                         break;
 605                                 case E_lostRobot:
 606                                 case E_lostConn:
 607                                         goto gameOver;
 608                                 default:
 609                                         break;
 610                         } //handle event
 611                         if (paused != oldPaused) {
 612                                 if (paused) {
 613                                         PauseTime();
 614                                         pauseTimeLeft = SetITimer(0, 0);
 615                                 }
 616                                 else {
 617                                         SetITimer(Game.speed, pauseTimeLeft);
 618                                         ResumeTime();
 619                                 }
 620                                 oldPaused = paused;
 621                         } //(un)pause
 622                 } //game loop
 623         nextPiece:
 624                 dropMode = 0;
 625                 FreezePiece(me);
 626                 Players[me].score.drops++;
 627                 Players[me].score.score++;
 628                 if ((linesCleared = ClearFullLines(me)) > 0) {
 629                         if (game == GT_onePlayer)
 630                                 if ((Players[me].score.lines / 10) <
 631                                                 ((Players[me].score.lines + linesCleared) / 10)) {
 632                                         if ((Game.speed /= SPEEDINC) < SPEEDMINIMUM)
 633                                                 Game.speed = SPEEDMINIMUM;
 634                                         SetITimer(Game.speed, SetITimer(0, 0));
 635                                         Players[me].score.level++;
 636                                 } //level up
 637                         Players[me].score.score += linevalues[linesCleared - 1];
 638                         Players[me].score.lines += linesCleared;
 639                         Players[me].score.adds += linesCleared - (linesCleared < 4);
 640                         if (spied)
 641                                 SendPacket(me, NP_clear, 0, NULL);
 642                 }
 643                 if (game == GT_classicTwo && linesCleared > 1) {
 644                         short junkLines;
 645                         netint2 data[1];
 646
 647                         junkLines = linesCleared - (linesCleared < 4);
 648                         data[0] = hton2(junkLines);
 649                         SendPacket(me, NP_giveJunk, sizeof(data), data);
 650                         Messagef("You sent %d lines", junkLines);
 651                 } //send junk to others
 652         } //new piece loop
 653 gameOver:
 654         SetITimer(0, 0);
 655 }
 656
 657 ExtFunc void CatchInt(int sig)
 658 {
 659         siglongjmp(close_env, 1);
 660 }
 661
 662 ExtFunc int main(int argc, char **argv)
 663 {
 664         char ch;
 665
 666         port = DEFAULT_PORT;
 667         Game.standout = Game.color = 1;
 668         Game.initspeed = DEFAULT_INTERVAL;
 669         MapKeys(DEFAULT_KEYS);
 670         {
 671                 int i;
 672                 char *userName;
 673
 674                 for (i = 0; i < MAX_SCREENS; i++) {
 675                         Players[i].score.level = Players[i].spy = 1;
 676                         Players[i].boardWidth = 10;
 677                         Players[i].boardHeight = MAX_BOARD_HEIGHT;
 678                         Players[i].boardVisible = 20;
 679                         strcpy(Players[i].name, "???");
 680                 }
 681                 if (!(userName = getenv("LOGNAME")) || !userName[0])
 682                         if (!(userName = getenv("USER")) || !userName[0])
 683                                 userName = "Anonymous";
 684                 strncpy(Players[0].name, userName, 16); //sizeof(Player.name)
 685                 Players[0].name[16] = 0;
 686                 Players[0].alive = 1;
 687         } //set defaults
 688
 689 //      if (getopt(argc, argv, "f:") == 'f')
 690 //              ReadConf(optarg);
 691 //      else
 692         ReadConf(CONFIG_FILE);
 693         while ((ch = getopt_long(argc, argv,
 694                         "hHRr:Fk:c:odDSCap:i:l:t:", options, NULL)) != -1)
 695                 HandleOption(ch, optarg);
 696         if (optind < argc) {
 697                 Usage();
 698                 exit(1);
 699         }
 700         if (fairRobot && !robotEnable)
 701                 fatal("You can't use the -F option without the -r option");
 702 //      WriteConf();
 703
 704         SRandom(time(0));                       //randomize
 705         if (sigsetjmp(close_env, 1))
 706                 exit(0);
 707         signal(SIGINT, CatchInt);       //handle exit (^C)
 708         InitScreens();                          //setup screen
 709         DrawTitle();
 710         if (initConn) {
 711                 game = GT_classicTwo;
 712                 spied = 1;
 713                 InitiateConnection(hostStr, port);
 714                 HandShake();
 715                 checkPaused();
 716                 OneGame();
 717         } //client
 718         else {
 719                 game = GT_onePlayer;
 720                 Game.started = 2;
 721                 Game.maxplayers = 1;
 722                 me = 1;
 723                 memcpy(&Players[me], &Players[0], sizeof(Player));
 724                 OneGame();
 725         } //singleplay
 726         return 0;
 727 }
 728
 729 /*
 730  * vi: ts=4 ai
 731  * vim: noai si
 732  */