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