src/Game.cxx

   1 /*
   2  * Game.cxx
   3  * Daniel Nelson - 8/25/0
   4  *
   5  * Copyright (C) 2000  Daniel Nelson
   6  *
   7  * This program is free software; you can redistribute it and/or
   8  * modify it under the terms of the GNU General Public License
   9  * as published by the Free Software Foundation; either version 2
  10  * of the License, or (at your option) any later version.
  11  *
  12  * This program is distributed in the hope that it will be useful,
  13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15  * GNU General Public License for more details.
  16  *
  17  * You should have received a copy of the GNU General Public License
  18  * along with this program; if not, write to the Free Software
  19  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.
  20  *
  21  * Daniel Nelson - aluminumangel.org
  22  * 174 W. 18th Ave.
  23  * Columbus, OH  43210
  24  *
  25  * The core loop plus extras.
  26  * Remove dying_count_2.
  27  */
  28
  29 #include <GL/glut.h>
  30
  31 #ifndef _WIN32
  32 #else
  33 #  include <glext.h>
  34 #endif
  35
  36 #include <sys/time.h>
  37
  38 using namespace std;
  39
  40 #include "Game.h"
  41 #include "BlockManager.h"
  42 #include "CelebrationManager.h"
  43 #include "Clock.h"
  44 #include "Controller.h"
  45 #include "Communicator.h"
  46 #include "ComboManager.h"
  47 #include "CountDownManager.h"
  48 #include "Creep.h"
  49 #include "GarbageGenerator.h"
  50 #include "GarbageManager.h"
  51 #include "Grid.h"
  52 #include "LevelLights.h"
  53 #include "LoseBar.h"
  54 #include "MessageManager.h"
  55 #include "MetaState.h"
  56 #include "Random.h"
  57 #include "Score.h"
  58 #include "ScoreRecordManager.h"
  59 #include "SignManager.h"
  60 #include "Sine.h"
  61 #include "SparkleManager.h"
  62 #include "Spring.h"
  63 #include "Swapper.h"
  64 #include "WinRecord.h"
  65 #include "X.h"
  66
  67 int Game::time_step;
  68 int Game::state;
  69 int Game::awaking_count;
  70 int Game::dying_count;
  71 int Game::dying_count_2;
  72 int Game::previous_time;
  73 int Game::remaining_time;
  74 bool Game::button_down_pause;
  75 bool Game::step_play;
  76 int Game::sync_wait;
  77 double Game::lastframe = 0.0;
  78
  79 void Game::initialize (   )
  80 {
  81   Random::initialize();
  82   WinRecord::initialize();
  83   LevelLights::initialize();
  84   Score::initialize();
  85   Sine::initialize();
  86   LoseBar::initialize();
  87
  88   gameFinish();
  89 }
  90
  91 void Game::gameStart (   )
  92 {
  93   state = GS_NORMAL;
  94
  95   awaking_count = 0;
  96   dying_count = 0;
  97
  98   WinRecord::gameStart();
  99
 100   BlockManager::gameStart();
 101   GarbageManager::gameStart();
 102   ComboManager::gameStart();
 103   GarbageGenerator::gameStart();
 104   X::gameStart();
 105   Grid::gameStart();
 106   Controller::gameStart();
 107   Creep::gameStart();
 108   Swapper::gameStart();
 109   Spring::gameStart();
 110   LevelLights::gameStart();
 111   CountDownManager::gameStart();
 112   Clock::gameStart();
 113   LoseBar::gameStart();
 114
 115   button_down_pause = false;
 116
 117   step_play = true;
 118
 119   remaining_time = 0;
 120   time_step = 1;
 121 }
 122
 123 void Game::gameFinish (   )
 124 {
 125   remaining_time = 0;
 126   time_step = 1;
 127 }
 128
 129 void Game::cleanUp (   )
 130 {
 131   CountDownManager::cleanUp();
 132   Score::cleanUp();
 133 }
 134
 135 void Game::loss (   )
 136 /*
 137  * Called when creep detects a game loss condition; opponent may have already
 138  * lost, so me must wait for confirmation.
 139  */
 140 {
 141   if (!(MetaState::mode & CM_SOLO)) {
 142     if (!(state & (GS_MAY_HAVE_LOST | GS_WON))) {
 143       state = GS_MAY_HAVE_LOST;
 144       Communicator::setLossTimeStep();
 145     }
 146   } else
 147     state |= GS_END_PLAY;
 148 }
 149
 150 void Game::lossConfirmation (   )
 151 /*
 152  * Called by Communicator when opponent confirms game loss.  Now we must only
 153  * wait for the level lights to end play.
 154  */
 155 {
 156   state = GS_LOST | GS_END_PLAY;
 157 }
 158
 159 void Game::won (   )
 160 /*
 161  * Called by Communicator when opponent signals a game loss that predates
 162  * ours or signals a reverse of our game loss.  Now we must wait to confirm
 163  * our opponent's loss and for the level lights to end play.
 164  */
 165 {
 166   if (!(state & GS_WON))
 167     state = GS_WON | GS_MUST_CONFIRM_LOSS;
 168 }
 169
 170 void Game::concession (   )
 171 /*
 172  * Called by the controller upon player concession.
 173  */
 174 {
 175   if (CountDownManager::start_pause_alarm != 0) return;
 176
 177   loss();
 178   MetaState::state |= MS_CONCESSION;
 179 }
 180
 181 void Game::buttonPause (   )
 182 // run time step during pause (for Communicator); then reset the clock to the
 183 // value at the pause time
 184 {
 185   // unpause
 186   if ((state & (GS_PAUSED | GS_SYNC_WAIT)) == GS_PAUSED) {
 187     state = GS_NORMAL;
 188
 189     MessageManager::freeMessage();
 190     if (CountDownManager::state != -1)
 191       MessageManager::readyMessage(CountDownManager::state);
 192
 193     if (!(MetaState::mode & CM_SOLO)) {
 194       Communicator::unpauseSyncCheck();
 195       Communicator::signalUnpaused();
 196     }
 197
 198   // pause
 199   } else {
 200     // to simplify things, you can't pause if you're about to lose
 201     if (!(state & GS_NORMAL)) return;
 202
 203     state = GS_PAUSED;
 204
 205     if (CountDownManager::state != -1)
 206       MessageManager::freeMessage();
 207     MessageManager::readyMessage(MS_PAUSED);
 208
 209     if (!(MetaState::mode & CM_SOLO))
 210       Communicator::signalPaused();
 211   }
 212 }
 213
 214 void Game::netSignalPause (   )
 215 {
 216   if (!(state & GS_NORMAL)) return;
 217
 218   state = GS_PAUSED;
 219
 220   if (CountDownManager::state != -1)
 221     MessageManager::freeMessage();
 222   MessageManager::readyMessage(MS_PAUSED);
 223 }
 224
 225 void Game::netSignalUnpause (   )
 226 {
 227   if ((state & (GS_PAUSED | GS_SYNC_WAIT)) != GS_PAUSED) return;
 228
 229   state = GS_NORMAL;
 230
 231   MessageManager::freeMessage();
 232   if (CountDownManager::state != -1)
 233     MessageManager::readyMessage(CountDownManager::state);
 234 }
 235
 236 void Game::syncPause ( int delay )
 237 {
 238   assert(delay > 0);
 239
 240   state = GS_PAUSED | GS_SYNC_WAIT;
 241   sync_wait = delay;
 242
 243   if (CountDownManager::state != -1)
 244     MessageManager::freeMessage();
 245   MessageManager::readyMessage(MS_WAITING);
 246 }
 247
 248 void Game::syncUnpause (   )
 249 {
 250   state = GS_NORMAL;
 251
 252   MessageManager::freeMessage();
 253   if (CountDownManager::state != -1)
 254     MessageManager::readyMessage(CountDownManager::state);
 255 }
 256
 257 void Game::idleMeta (   )
 258 {
 259   int modified_and_complete = false;
 260
 261   do {
 262
 263     int time = glutGet((GLenum) GLUT_ELAPSED_TIME);
 264     remaining_time += time - previous_time;
 265     previous_time = time;
 266
 267     // no time step yet
 268     if (remaining_time < GC_TIME_STEP_PERIOD) break;
 269
 270     remaining_time -= GC_TIME_STEP_PERIOD;
 271     time_step++;
 272
 273     if (remaining_time < GC_TIME_STEP_PERIOD)
 274       modified_and_complete = true;
 275     else
 276       DOT(3);
 277
 278     // communicate state and other stuff
 279     if (!(MetaState::state & MS_GAME_OVER_KEY_WAIT) &&
 280      !(MetaState::mode & CM_SOLO))
 281       Communicator::timeStepMeta();
 282
 283     // advance celebration
 284     CelebrationManager::timeStep();
 285
 286     // advance the score record
 287     ScoreRecordManager::timeStep();
 288
 289     // update message pulse
 290     MessageManager::timeStep();
 291
 292     // update the pretty stuff too
 293     SparkleManager::timeStep();
 294     SignManager::timeStep();
 295     if (!(MetaState::mode & CM_REALLY_LOW_GRAPHICS))
 296       WinRecord::timeStep();
 297     LevelLights::timeStep();
 298
 299     // advance the clock through its final tick fade
 300     Clock::timeStepMeta();
 301
 302     // advance the score through its final increment fade
 303     Score::timeStepMeta();
 304
 305   } while (false);
 306
 307   if (modified_and_complete) {
 308     glFinish();
 309     glutPostRedisplay();
 310   }
 311 }
 312
 313 void Game::idlePlay (   )
 314 {
 315   timeval now;
 316   double nowd;
 317   gettimeofday(&now,NULL);
 318   #define FPSDIFF (1.0f/30.0f)
 319   nowd = now.tv_sec;
 320   nowd += (double)now.tv_usec / 1000000.0f;
 321
 322   if ( (nowd - lastframe) > FPSDIFF ) {
 323     lastframe = nowd;
 324   } else {
 325     usleep(1000);
 326   }
 327
 328   int modified_and_complete = false;
 329
 330   do {
 331
 332     //int time = glutGet((GLenum) GLUT_ELAPSED_TIME);
 333     remaining_time += time - previous_time;
 334     previous_time = time;
 335
 336     // no time step yet
 337     if (remaining_time < GC_TIME_STEP_PERIOD) break;
 338
 339     remaining_time -= GC_TIME_STEP_PERIOD;
 340
 341     if (remaining_time < GC_TIME_STEP_PERIOD)
 342       modified_and_complete = true;
 343     else
 344       DOT(2);
 345
 346     if (!(state & GS_PAUSED)) {
 347       if (step_play) {
 348
 349         time_step++;
 350
 351         // check for and continue swaps and moves
 352         Swapper::timeStep();
 353
 354         // update the level lights
 355         LevelLights::timeStep();
 356
 357         // update message pulse
 358         MessageManager::timeStep();
 359
 360         // move the win record stars
 361         WinRecord::timeStep();
 362
 363         // update the starting count down
 364         CountDownManager::timeStep();
 365         if (CountDownManager::start_pause_alarm != 0) {
 366           // some objects require a time step during start pause
 367
 368           if (!(MetaState::mode & CM_SOLO))
 369             Communicator::timeStepPlay();
 370
 371           // reset the clock
 372           Clock::timeStepMeta();
 373
 374           continue;
 375         }
 376
 377         // loop over the grid, bottom to top; garbage will advance x and y
 378         for (int y = 1; y < GC_PLAY_HEIGHT; y++)
 379           for (int x = 0; x < GC_PLAY_WIDTH; x++) {
 380             if (Grid::residentTypeAt(x, y) & GR_EMPTY) continue;
 381
 382             if (Grid::residentTypeAt(x, y) & GR_BLOCK)
 383               Grid::blockAt(x, y).timeStep();
 384             else
 385               Grid::garbageAt(x, y).timeStep(x, y);
 386           }
 387
 388         // perhaps creep upward
 389         Creep::timeStep();
 390
 391         // process elimination check requests and update top_occupied_row
 392         Grid::timeStep();
 393
 394         // handle new and finished combos
 395         ComboManager::timeStep();
 396       }
 397
 398       // communicate garbage and other stuff
 399       if (!(MetaState::mode & CM_SOLO))
 400         Communicator::timeStepPlay();
 401
 402       if (step_play) {
 403
 404         // drop queued garbage
 405         GarbageGenerator::timeStep();
 406
 407         // move the sparkles and signs
 408         SparkleManager::timeStep();
 409         SignManager::timeStep();
 410
 411         // update the impact spring
 412         if (!(MetaState::mode & CM_REALLY_LOW_GRAPHICS))
 413           Spring::timeStep();
 414
 415         // update the clock
 416         Clock::timeStepPlay();
 417
 418         // update the score
 419         Score::timeStepPlay();
 420
 421         // update the losebar
 422         LoseBar::timeStep();
 423
 424         // advance extreme effects
 425         if (MetaState::mode & CM_X)
 426           X::timeStep();
 427       }
 428
 429     } else {
 430
 431       // if this is a sync pause, count down the waiting period
 432       if (state & GS_SYNC_WAIT && !--sync_wait)
 433         syncUnpause();
 434
 435       // communicate when paused
 436       if (!(MetaState::mode & CM_SOLO))
 437         Communicator::timeStepPlay();
 438
 439       // update message pulse
 440       MessageManager::timeStep();
 441     }
 442
 443     if (state & (GS_MAY_HAVE_LOST | GS_MUST_CONFIRM_LOSS))
 444       step_play = false;
 445
 446     if (state & GS_END_PLAY) {
 447       if (state & GS_PAUSED)
 448         MessageManager::freeMessage();
 449
 450       if (MetaState::mode & CM_SOLO)
 451         state = Score::gameFinish();
 452
 453       if (state & GS_LOST)
 454         MetaState::gameLoss();
 455       else
 456         MetaState::gameWon();
 457
 458       break;
 459     }
 460
 461   } while (false);
 462
 463   if (!button_down_pause) {
 464     if (Controller::pauseCommand()) {
 465       button_down_pause = true;
 466       buttonPause();
 467     }
 468   } else
 469     if (!Controller::pauseCommand())
 470       button_down_pause = false;
 471
 472   if (modified_and_complete) {
 473     glFinish();
 474     glutPostRedisplay();
 475   }
 476 }