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