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
  30 static struct option options[] = {
  31         { "ascii",              2, 0, 'a' },
  32         { "connect",    1, 0, 'c' },
  33         { "port",               1, 0, 'p' },
  34         { "level",              1, 0, 'l' },
  35         { "team",               1, 0, 't' },
  36         { "spy",                1, 0,  1  },
  37         { "robot",              1, 0, 'r' },
  38         { "fair-robot", 0, 0, 'F' },
  39         { "dropmode",   2, 0, 'd' },
  40         { "instadrop",  2, 0, 'D' },
  41         { "color",              2, 0, 'C' },
  42         { "slowterm",   2, 0, 'S' },
  43         { "keys",               1, 0, 'k' },
  44         { "rules",              0, 0, 'R' },
  45         { "info",               0, 0, 'H' },
  46         { "help",               0, 0, 'h' },
  47         { 0,                    0, 0,  0 }
  48 };
  49
  50 enum { KT_left, KT_right, KT_rotright, KT_rotleft, KT_drop, KT_down,
  51                 KT_faster, KT_pause, KT_redraw, KT_quit, KT_numKeys };
  52
  53 static char *keyNames[KT_numKeys+1] = {
  54         "Left", "Right", "RotRight", "RotLeft", "Drop", "Down",
  55         "Faster", "Pause", "Redraw", "Quit", NULL };
  56
  57 static char *gameNames[GT_len] = { "OnePlayer", "ClassicTwo" };
  58
  59 static char keyTable[KT_numKeys+1];
  60
  61 static char *hostStr;
  62 static int paused = 0;
  63
  64
  65 ExtFunc void MapKeys(char *newKeys)
  66 {
  67         int i, k, ch;
  68         char used[256];
  69         int errs = 0;
  70
  71         /* XXX assumptions about ASCII encoding here */
  72         for (i = k = 0; newKeys[i] && k < KT_numKeys; i++,k++) {
  73                 if (newKeys[i] == '^' && newKeys[i+1])
  74                         keyTable[k] = toupper(newKeys[++i]) - ('A' - 1);
  75                 else
  76                         keyTable[k] = newKeys[i];
  77         }
  78         memset(used, 0, sizeof(used));
  79         for (k = 0; k < KT_numKeys; k++) {
  80                 ch = (unsigned char) keyTable[k];
  81                 if (used[ch]) {
  82                         if (iscntrl(ch) && ch < ' ')
  83                                 sprintf(scratch, "Ctrl-%c", ch + ('A' - 1));
  84                         else if (isprint(ch))
  85                                 sprintf(scratch, "\"%c\"", ch);
  86                         else
  87                                 sprintf(scratch, "0x%X", ch);
  88                         if (!errs)
  89                                 fprintf(stderr, "Duplicate key mappings:\n");
  90                         errs++;
  91                         fprintf(stderr, "  %s mapped to both %s and %s\n",
  92                                         scratch, keyNames[used[ch]-1], keyNames[k]);
  93                 }
  94                 used[ch] = k + 1;
  95         }
  96         if (errs)
  97                 exit(1);
  98 } //MapKeys
  99
 100 ExtFunc void WriteConf(void)
 101 {
 102         FILE *file_out;
 103
 104         file_out = fopen(CONFIG_FILE, "w");
 105         if (file_out == NULL)
 106                 die("Error writing config file");
 107
 108         fprintf(file_out, "### NETRIS %s Config file ###\n\n", version_string);
 109
 110         fclose(file_out);
 111         fprintf(stderr, "Wrote new game configuration to %s\n", CONFIG_FILE);
 112 } //WriteConf
 113
 114 ExtFunc void HandleOption(char tag, char *value)
 115 {
 116         switch (tag) {
 117                 case 'a':       //ascii
 118                         if (value && !strcasecmp(value, "0")) Game.ascii = 0;
 119                         else Game.ascii = 1;
 120                         break;
 121                 case 'c':       //connect
 122                         initConn = 1;
 123                         hostStr = value;
 124                         break;
 125                 case 'p':       //port
 126                         port = atoi(value);
 127                         break;
 128                 case 'i':       //speed (of level 1)
 129                         Game.initspeed = atof(value) * 1e6;
 130                         break;
 131                 case 'l':       //level
 132                         if ((Players[0].score.level = atof(value)) < 1)
 133                                 Players[0].score.level = 1;
 134                         if (Players[0].score.level > 15)
 135                                 Players[0].score.level = 15;
 136                         break;
 137                 case 't':       //team
 138                         Players[0].team = atoi(value);
 139                         break;
 140                 case 1:         //spy
 141                         {
 142                                 int i;
 143                                 i = atof(value);
 144                                 Players[i / 10].spy = i % 10;
 145                         }
 146                         break;
 147                 case 'r':       //robot
 148                         robotEnable = 1;
 149                         Players[0].flags |= SCF_usingRobot;
 150                         InitRobot(value);
 151                         break;
 152                 case 'F':       //fair robot
 153                         fairRobot = 1;
 154                         Players[0].flags |= SCF_fairRobot;
 155                         break;
 156                 case 'd':       //drop mode
 157                         if (value && !strcasecmp(value, "0")) Players[0].dropmode &= 254;
 158                         else Players[0].dropmode |= 1;
 159                         break;
 160                 case 'D':       //instadrop
 161                         if (value && !strcasecmp(value, "0")) Players[0].dropmode &= 253;
 162                         else Players[0].dropmode |= 2;
 163                         break;
 164                 case 'C':       //color
 165                         if (value && !strcasecmp(value, "1")) Game.color = 1;
 166                         else Game.color = 0;
 167                         break;
 168                 case 'S':       //slowterm
 169                         if (value && !strcasecmp(value, "1")) Game.standout = 1;
 170                         else Game.standout = 0;
 171                         break;
 172                 case 'k':       //keys
 173                         MapKeys(value); break;
 174                 case 'H':       //info
 175                         DistInfo(); exit(0);
 176                 case 'R':       //rules
 177                         Rules(); exit(0);
 178                 case 'h':       //help
 179                         Usage(); exit(0);
 180                 default:
 181                         Usage(); exit(1);
 182         }
 183 } //HandleParam
 184
 185 ExtFunc void ReadConf(char *filename)
 186 {
 187         FILE *file_in;
 188         char buf[513];
 189         int i;
 190         char *ch;
 191         char tag[81], value[81];
 192
 193         file_in = fopen(filename, "r");
 194         if (file_in) {
 195                 while (fgets(buf, 512, file_in) != NULL) {
 196                         if ((ch = strchr(buf, '#')))
 197                                 *ch = '\0'; // truncate string from # char
 198                         for (i = strlen(buf)-1; i >= 0; i--)
 199                                 if (buf[i] == ' ' || buf[i] == '\n' || buf[i] == '\t' || buf[i] == 13)
 200                                         buf[i] = '\0';
 201                                 else break;
 202
 203                         sscanf(buf, "%80[^= \t] = %80[^\n]", tag, value);
 204                         for (i = 0; options[i].name; i++){
 205                                 if (!strcasecmp(options[i].name, tag)) {
 206                                         HandleOption(options[i].val, value);
 207                                         break;
 208                                 }
 209                         }
 210                 }
 211                 fclose(file_in);
 212         } //read file
 213         else {
 214                 fprintf(stderr, "Unable to open config file %s.\n", filename);
 215         } //defaults
 216
 217 } //ReadConf
 218
 219 ExtFunc int StartNewPiece(int scr, Shape *shape)
 220 {
 221         if (Players[scr].nextShape) {
 222                 Players[scr].curShape = Players[scr].nextShape;
 223                 Players[scr].nextShape = shape;
 224         }
 225         else
 226                 Players[scr].curShape = shape;
 227         Players[scr].curY = Players[scr].boardVisible + 4;
 228         Players[scr].curX = Players[scr].boardWidth / 2;
 229         while (!ShapeVisible(Players[scr].curShape, scr,
 230                         Players[scr].curY, Players[scr].curX))
 231                 Players[scr].curY--;
 232         if (!ShapeFits(Players[scr].curShape, scr,
 233                         Players[scr].curY, Players[scr].curX))
 234                 return 0;
 235         PlotShape(Players[scr].curShape, scr,
 236                 Players[scr].curY, Players[scr].curX, 1);
 237         return 1;
 238 }
 239
 240 ExtFunc void checkPaused(void)
 241 { //check whether anyone paused the game
 242         int i;
 243
 244         paused = 0;
 245         for (i = 1; i <= totalPlayers; i++)
 246                 if (Players[i].alive)
 247                         paused |= Players[i].flags & SCF_paused;
 248 } //checkPaused
 249
 250 ExtFunc void OneGame(int scr)
 251 {
 252         MyEvent event;
 253         int linesCleared, changed = 0;
 254         int spied = 0, dropMode = 0;
 255         int oldPaused = 0;
 256         long pauseTimeLeft;
 257         int pieceCount = 0;
 258         int key;
 259         char *p, *cmd;
 260         int playercount;
 261         int linevalues[4] = { 40, 100, 400, 1200 }; //= 50*lines! - 10*(lines==1)
 262         int i;
 263
 264         Game.speed = Game.initspeed;
 265         for (i = 1; i < Players[scr].score.level; i++)
 266                 Game.speed /= SPEEDINC;
 267         if (Game.speed < SPEEDMINIMUM)
 268                 Game.speed = SPEEDMINIMUM;
 269         ResetBaseTime();
 270         InitFields();
 271         for (i = 1; i <= totalPlayers; i++)
 272                 if (Players[i].spy) DrawField(i);
 273         if (totalPlayers > 1) {
 274                 spied = 1;
 275         }
 276         SetITimer(Game.speed, Game.speed);
 277         if (robotEnable) {
 278                 RobotCmd(0, "GameType %s\n", gameNames[game]);
 279                 RobotCmd(0, "BoardSize 0 %d %d\n",
 280                         Players[scr].boardVisible, Players[scr].boardWidth);
 281                 for (i = 1; i <= totalPlayers; i++) {
 282                         RobotCmd(0, "BoardSize %d %d %d\n",
 283                                 i, Players[i].boardVisible, Players[i].boardWidth);
 284                         RobotCmd(0, "Opponent %d %s %s\n",
 285                                 i, Players[i].name, Players[i].host);
 286                         if (Players[i].flags & SCF_usingRobot)
 287                                 RobotCmd(0, "OpponentFlag %d robot\n", i);
 288                         if (Players[i].flags & SCF_fairRobot)
 289                                 RobotCmd(0, "OpponentFlag %d fairRobot\n", i);
 290                 }
 291                 RobotCmd(0, "TickLength %.3f\n", Game.speed / 1.0e6);
 292                 RobotCmd(0, "BeginGame\n");
 293                 RobotTimeStamp();
 294         }
 295         Players[scr].nextShape = ChooseOption(stdOptions);
 296         while (1) {
 297                 if (Players[scr].alive) {
 298                         if (!StartNewPiece(scr, ChooseOption(stdOptions))) {
 299                                         netint4 data[4];
 300                                 Players[scr].alive = 0;
 301                                 FieldMessage(scr, "G A M E  O V E R");
 302                                 changed = 1;
 303                                 if (game == GT_classicTwo)
 304                                         SendPacket(scr, NP_argghhh,
 305                                                 sizeof(Players[0].alive), &Players[scr].alive);
 306                         } //die
 307                         else {
 308                                 ShowScore(scr, Players[scr].score);
 309                                 if (robotEnable && !fairRobot)
 310                                         RobotCmd(1, "NewPiece %d\n", ++pieceCount);
 311                                 if (spied) {
 312                                         short shapeNum;
 313                                         netint2 data[1];
 314
 315                                         shapeNum = ShapeToNetNum(Players[scr].curShape);
 316                                         data[0] = hton2(shapeNum);
 317                                         SendPacket(scr, NP_newPiece, sizeof(data), data);
 318                                 } //send new piece
 319                         }
 320                 }
 321                 for (;;) {
 322                         for (i = 1; i <= totalPlayers; i++) if (Players[i].spy)
 323                                 changed |= RefreshBoard(i);
 324                         if (changed) {
 325                                 if (!paused) ShowTime();
 326                                 refresh();
 327                                 changed = 0;
 328                         }
 329                         playercount = 0;
 330                         for (i = 1; i <= totalPlayers; i++)
 331                                 if (Players[i].alive) playercount++;
 332                         if (playercount < game + 1) goto gameOver;
 333                         CheckNetConn();
 334                         switch (WaitMyEvent(&event, EM_any)) {
 335                                 case E_alarm:
 336                                         if (Players[scr].alive)
 337                                                 if (!MovePiece(scr, -1, 0))
 338                                                         goto nextPiece;
 339                                                 else if (spied)
 340                                                         SendPacket(scr, NP_down, 0, NULL);
 341                                         break;
 342                                 case E_key:
 343                                         p = strchr(keyTable, tolower(event.u.key));
 344                                         key = p - keyTable;
 345                                         if (robotEnable) {
 346                                                 RobotCmd(1, "UserKey %d %s\n",
 347                                                                 (int)(unsigned char)event.u.key,
 348                                                                 p ? keyNames[key] : "?");
 349                                                 break;
 350                                         } //let robot handle keypress
 351                                         if (!p) break;
 352                                 keyEvent:
 353                                         if (!Players[scr].alive && key != KT_quit) break;
 354                                         if (paused && key < KT_pause) break;
 355                                         switch(key) {
 356                                                 case KT_left:
 357                                                         if (MovePiece(scr, 0, -1) && spied)
 358                                                                 SendPacket(scr, NP_left, 0, NULL);
 359                                                         break;
 360                                                 case KT_right:
 361                                                         if (MovePiece(scr, 0, 1) && spied)
 362                                                                 SendPacket(scr, NP_right, 0, NULL);
 363                                                         break;
 364                                                 case KT_rotleft:
 365                                                         if (RotatePiece(scr, 0) && spied)
 366                                                                 SendPacket(scr, NP_rotleft, 0, NULL);
 367                                                         break;
 368                                                 case KT_rotright:
 369                                                         if (RotatePiece(scr, 1) && spied)
 370                                                                 SendPacket(scr, NP_rotright, 0, NULL);
 371                                                         break;
 372                                                 case KT_down:
 373                                                         SetITimer(Game.speed, Game.speed);
 374                                                         if (MovePiece(scr, -1, 0)) {
 375                                                                 if (spied) SendPacket(scr, NP_down, 0, NULL);
 376                                                         }
 377                                                         else goto nextPiece;
 378                                                         break;
 379                                                 case KT_drop:
 380                                                         SetITimer(Game.speed, Game.speed);
 381                                                         if (DropPiece(scr)) {
 382                                                                 if (spied) SendPacket(scr, NP_drop, 0, NULL);
 383                                                                 if (Players[scr].dropmode == 2) goto nextPiece;
 384                                                         }
 385                                                         else goto nextPiece;
 386                                                         dropMode = Players[scr].dropmode;
 387                                                         break;
 388                                                 case KT_pause:
 389                                                         Players[scr].flags ^= SCF_paused;
 390                                                         checkPaused();
 391                                                         if (game == GT_classicTwo)
 392                                                                 SendPacket(scr, NP_pause, 0, NULL);
 393                                                         if (robotEnable) RobotCmd(1, "Pause %d\n", paused);
 394                                                         ShowPause(scr);
 395                                                         changed = 1;
 396                                                         break;
 397                                                 case KT_faster:
 398                                                         if (game != GT_onePlayer)
 399                                                                 break;
 400                                                         if ((Game.speed /= SPEEDINC) < SPEEDMINIMUM)
 401                                                                 Game.speed = SPEEDMINIMUM;
 402                                                         SetITimer(Game.speed, SetITimer(0, 0));
 403                                                         Players[scr].score.level++;
 404                                                         ShowScore(scr, Players[scr].score);
 405                                                         changed = 1;
 406                                                         break;
 407                                                 case KT_redraw:
 408                                                         ScheduleFullRedraw();
 409 //                                                      if (paused)
 410 //                                                              RefreshScreen();
 411                                                         break;
 412                                                 case KT_quit:
 413                                                         FieldMessage(me, "G A M E  O V E R");
 414                                                         refresh();
 415                                                         goto gameOver;
 416                                         } //E_key
 417                                         if (dropMode && DropPiece(scr) > 0) {
 418                                                 SetITimer(Game.speed, Game.speed);
 419                                                 if (spied)
 420                                                         SendPacket(scr, NP_drop, 0, NULL);
 421                                         }
 422                                         break;
 423                                 case E_robot:
 424                                 {
 425                                         int num;
 426
 427                                         cmd = event.u.robot.data;
 428                                         if ((p = strchr(cmd, ' ')))
 429                                                 *p++ = 0;
 430                                         else
 431                                                 p = cmd + strlen(cmd);
 432                                         for (key = 0; keyNames[key]; ++key)
 433                                                 if (!strcmp(keyNames[key], cmd) &&
 434                                                                 (fairRobot || (1 == sscanf(p, "%d", &num) &&
 435                                                                         num == pieceCount)))
 436                                                         goto keyEvent;
 437                                         if (!strcmp(cmd, "Message")) {
 438                                                 Message(p);
 439                                                 changed = 1;
 440                                         }
 441                                         break;
 442                                 } //E_robot
 443                                 case E_net:
 444                                         switch(event.u.net.type) {
 445                                                 case NP_giveJunk:
 446                                                 {
 447                                                         netint2 data[2];
 448                                                         short column;
 449
 450                                                         if (!Players[scr].alive) break;
 451                                                         memcpy(data, event.u.net.data, sizeof(data[0]));
 452                                                         column = Random(0, Players[scr].boardWidth);
 453                                                         data[1] = hton2(column);
 454                                                         InsertJunk(scr, ntoh2(data[0]), column);
 455                                                         if (spied)
 456                                                                 SendPacket(scr, NP_insertJunk, sizeof(data), data);
 457 //                                                      Message("Opponent added %d lines");
 458                                                         break;
 459                                                 } //receive junklines
 460                                                 case NP_newPiece:
 461                                                 {
 462                                                         short shapeNum;
 463                                                         netint2 data[1];
 464
 465                                                         FreezePiece(event.u.net.uid);
 466                                                         memcpy(data, event.u.net.data, sizeof(data));
 467                                                         shapeNum = ntoh2(data[0]);
 468                                                         StartNewPiece(event.u.net.uid, NetNumToShape(shapeNum));
 469                                                         break;
 470                                                 } //new piece
 471                                                 case NP_down:
 472                                                         MovePiece(event.u.net.uid, -1, 0);
 473                                                         break;
 474                                                 case NP_left:
 475                                                         MovePiece(event.u.net.uid, 0, -1);
 476                                                         break;
 477                                                 case NP_right:
 478                                                         MovePiece(event.u.net.uid, 0, 1);
 479                                                         break;
 480                                                 case NP_rotleft:
 481                                                         RotatePiece(event.u.net.uid, 0);
 482                                                         break;
 483                                                 case NP_rotright:
 484                                                         RotatePiece(event.u.net.uid, 1);
 485                                                         break;
 486                                                 case NP_drop:
 487                                                         DropPiece(event.u.net.uid);
 488                                                         break;
 489                                                 case NP_clear:
 490                                                         ClearFullLines(event.u.net.uid);
 491                                                         break;
 492                                                 case NP_insertJunk:
 493                                                 {
 494                                                         netint2 data[2];
 495
 496                                                         memcpy(data, event.u.net.data, sizeof(data));
 497                                                         InsertJunk(event.u.net.uid, ntoh2(data[0]), ntoh2(data[1]));
 498                                                         break;
 499                                                 } //player added junklines
 500                                                 case NP_pause:
 501                                                 {
 502                                                         Players[event.u.net.uid].flags ^= SCF_paused;
 503                                                         checkPaused();
 504                                                         if (robotEnable) RobotCmd(1, "Pause %d\n", paused);
 505                                                         ShowPause(event.u.net.uid);
 506                                                         changed = 1;
 507                                                         break;
 508                                                 } //(un)pause
 509                                                 case NP_argghhh:
 510                                                 {
 511                                                         memcpy(&Players[event.u.net.uid].alive,
 512                                                                 event.u.net.data, sizeof(Players[0].alive));
 513 //                                                      checkPaused();
 514                                                         FieldMessage(event.u.net.uid, "G A M E  O V E R");
 515                                                         changed = 1;
 516                                                         break;
 517                                                 } //G/O
 518                                                 default:
 519                                                         break;
 520                                         } //E_net
 521                                         break;
 522                                 case E_lostRobot:
 523                                 case E_lostConn:
 524                                         goto gameOver;
 525                                 default:
 526                                         break;
 527                         } //handle event
 528                         if (paused != oldPaused) {
 529                                 if (paused) {
 530                                         PauseTime();
 531                                         pauseTimeLeft = SetITimer(0, 0);
 532                                 }
 533                                 else {
 534                                         SetITimer(Game.speed, pauseTimeLeft);
 535                                         ResumeTime();
 536                                 }
 537                                 oldPaused = paused;
 538                         } //(un)pause
 539                 } //game loop
 540         nextPiece:
 541                 dropMode = 0;
 542                 FreezePiece(scr);
 543                 Players[scr].score.drops++;
 544                 Players[scr].score.score++;
 545                 if ((linesCleared = ClearFullLines(scr)) > 0) {
 546                         if (game == GT_onePlayer)
 547                                 if ((Players[scr].score.lines / 10) <
 548                                                 ((Players[scr].score.lines + linesCleared) / 10)) {
 549                                         if ((Game.speed /= SPEEDINC) < SPEEDMINIMUM)
 550                                                 Game.speed = SPEEDMINIMUM;
 551                                         SetITimer(Game.speed, SetITimer(0, 0));
 552                                         Players[scr].score.level++;
 553                                 } //level up
 554                         Players[scr].score.score += linevalues[linesCleared];
 555                         Players[scr].score.lines += linesCleared;
 556                         Players[scr].score.adds += linesCleared - (linesCleared < 4);
 557                         if (spied)
 558                                 SendPacket(scr, NP_clear, 0, NULL);
 559                 }
 560                 if (game == GT_classicTwo && linesCleared > 1) {
 561                         short junkLines;
 562                         netint2 data[1];
 563
 564                         junkLines = linesCleared - (linesCleared < 4);
 565                         data[0] = hton2(junkLines);
 566                         SendPacket(scr, NP_giveJunk, sizeof(data), data);
 567                 }
 568         } //new piece loop
 569 gameOver:
 570         SetITimer(0, 0);
 571 }
 572
 573 ExtFunc int main(int argc, char **argv)
 574 {
 575         char ch;
 576
 577         port = DEFAULT_PORT;
 578         Game.standout = Game.color = 1;
 579         Game.initspeed = DEFAULT_INTERVAL;
 580         MapKeys(DEFAULT_KEYS);
 581         {
 582                 int i;
 583                 char *userName;
 584
 585                 for (i = 0; i <= MAX_SCREENS; i++)
 586                         Players[i].score.level = Players[i].spy = 1;
 587                 if (!(userName = getenv("LOGNAME")) || !userName[0])
 588                         if (!(userName = getenv("USER")) || !userName[0])
 589                                 userName = "Anonymous";
 590                 strncpy(Players[0].name, userName, 16); //sizeof(Player.name)
 591                 Players[0].name[16] = 0;
 592                 Players[0].boardWidth = 10;
 593                 Players[0].boardHeight = MAX_BOARD_HEIGHT;
 594                 Players[0].boardVisible = 20;
 595                 Players[0].spy = 1;
 596                 Players[0].alive = 1;
 597         }
 598
 599 //      if (getopt(argc, argv, "f:") == 'f')
 600 //              ReadConf(optarg);
 601 //      else
 602         ReadConf(CONFIG_FILE);
 603         while ((ch = getopt_long(argc, argv,
 604                         "hHRr:Fk:c:odDSCap:i:l:t:", options, NULL)) != -1)
 605                 HandleOption(ch, optarg);
 606         if (optind < argc) {
 607                 Usage();
 608                 exit(1);
 609         }
 610         if (fairRobot && !robotEnable)
 611                 fatal("You can't use the -F option without the -r option");
 612 //      WriteConf();
 613
 614         InitUtil();
 615         InitScreens();
 616         if (initConn) {
 617                 game = GT_classicTwo;
 618                 Players[0].flags |= SCF_paused;
 619                 paused = SCF_paused;
 620                 InitiateConnection(hostStr, port);
 621                 HandShake();
 622                 OneGame(me);
 623         } //client
 624         else {
 625                 game = GT_onePlayer;
 626                 totalPlayers = 1;
 627                 me = 1;
 628                 memcpy(&Players[me], &Players[0], sizeof(Player));
 629                 OneGame(me);
 630         } //singleplay
 631         return 0;
 632 }
 633
 634 /*
 635  * vi: ts=4 ai
 636  * vim: noai si
 637  */