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 #include "glext.h"
  32
  33 #include <sys/time.h>
  34
  35 #include <cassert>
  36
  37 using namespace std;
  38
  39 #include "Game.h"
  40 #include "BlockManager.h"
  41 #include "CelebrationManager.h"
  42 #include "Clock.h"
  43 #include "Controller.h"
  44 #include "ActionRecorder.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 #include "ComputerPlayer.h"
  67 #ifdef AUDIO_ENABLED
  68 #include "Music.h"
  69 #endif
  70
  71 int Game::time_step;
  72 int Game::state;
  73 int Game::awaking_count;
  74 int Game::dying_count;
  75 int Game::dying_count_2;
  76 int Game::previous_time;
  77 int Game::remaining_time;
  78 bool Game::button_down_pause;
  79 bool Game::step_play;
  80 int Game::sync_wait;
  81 double Game::lastframe = 0.0;
  82
  83 void Game::initialize (   )
  84 {
  85   Random::initialize();
  86   WinRecord::initialize();
  87   LevelLights::initialize();
  88   Score::initialize();
  89   Sine::initialize();
  90   LoseBar::initialize();
  91   ActionRecorder::initialize();
  92
  93   gameFinish();
  94 }
  95
  96 void Game::gameStart (   )
  97 {
  98   state = GS_NORMAL;
  99
 100   awaking_count = 0;
 101   dying_count = 0;
 102
 103   WinRecord::gameStart();
 104
 105   BlockManager::gameStart();
 106   GarbageManager::gameStart();
 107   ComboManager::gameStart();
 108   GarbageGenerator::gameStart();
 109   X::gameStart();
 110   Grid::gameStart();
 111   Controller::gameStart();
 112   Creep::gameStart();
 113   Swapper::gameStart();
 114   Spring::gameStart();
 115   LevelLights::gameStart();
 116   CountDownManager::gameStart();
 117   Clock::gameStart();
 118   LoseBar::gameStart();
 119         ComputerPlayer::gameStart();
 120
 121   button_down_pause = false;
 122
 123   step_play = true;
 124
 125   remaining_time = 0;
 126   time_step = 1;
 127 }
 128
 129 void Game::gameFinish (   )
 130 {
 131   remaining_time = 0;
 132   time_step = 1;
 133 }
 134
 135 void Game::cleanUp (   )
 136 {
 137   CountDownManager::cleanUp();
 138   Score::cleanUp();
 139 }
 140
 141 void Game::loss (   )
 142 /*
 143  * Called when creep detects a game loss condition; opponent may have already
 144  * lost, so me must wait for confirmation.
 145  */
 146 {
 147   if (!(MetaState::mode & CM_SOLO)) {
 148     if (!(state & (GS_MAY_HAVE_LOST | GS_WON))) {
 149       state = GS_MAY_HAVE_LOST;
 150       Communicator::setLossTimeStep();
 151     }
 152   } else
 153     state |= GS_END_PLAY;
 154 }
 155
 156 void Game::lossConfirmation (   )
 157 /*
 158  * Called by Communicator when opponent confirms game loss.  Now we must only
 159  * wait for the level lights to end play.
 160  */
 161 {
 162   state = GS_LOST | GS_END_PLAY;
 163 }
 164
 165 void Game::aiPlayerLoss (   )
 166 {
 167   if (!(state & GS_WON) && !(state & GS_END_PLAY))
 168     state = GS_WON | GS_END_PLAY;
 169 }
 170
 171 void Game::won (   )
 172 /*
 173  * Called by Communicator when opponent signals a game loss that predates
 174  * ours or signals a reverse of our game loss.  Now we must wait to confirm
 175  * our opponent's loss and for the level lights to end play.
 176  */
 177 {
 178   if (!(state & GS_WON))
 179     state = GS_WON | GS_MUST_CONFIRM_LOSS;
 180 }
 181
 182 void Game::concession (   )
 183 /*
 184  * Called by the controller upon player concession.
 185  */
 186 {
 187   if (CountDownManager::start_pause_alarm != 0) return;
 188
 189   loss();
 190   MetaState::state |= MS_CONCESSION;
 191 }
 192
 193 void Game::buttonPause (   )
 194 // run time step during pause (for Communicator); then reset the clock to the
 195 // value at the pause time
 196 {
 197   // unpause
 198   if ((state & (GS_PAUSED | GS_SYNC_WAIT)) == GS_PAUSED) {
 199     state = GS_NORMAL;
 200
 201     MessageManager::freeMessage();
 202     if (CountDownManager::state != -1)
 203       MessageManager::readyMessage(CountDownManager::state);
 204
 205     if (!(MetaState::mode & CM_SOLO)) {
 206       Communicator::unpauseSyncCheck();
 207       Communicator::signalUnpaused();
 208     }
 209 #ifdef AUDIO_ENABLED
 210     Music::resume();
 211 #endif
 212
 213   // pause
 214   } else {
 215     // to simplify things, you can't pause if you're about to lose
 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     if (!(MetaState::mode & CM_SOLO))
 225       Communicator::signalPaused();
 226 #ifdef AUDIO_ENABLED
 227     Music::pause();
 228 #endif
 229   }
 230 }
 231
 232 void Game::netSignalPause (   )
 233 {
 234   if (!(state & GS_NORMAL)) return;
 235
 236   state = GS_PAUSED;
 237
 238   if (CountDownManager::state != -1)
 239     MessageManager::freeMessage();
 240   MessageManager::readyMessage(MS_PAUSED);
 241 }
 242
 243 void Game::netSignalUnpause (   )
 244 {
 245   if ((state & (GS_PAUSED | GS_SYNC_WAIT)) != GS_PAUSED) return;
 246
 247   state = GS_NORMAL;
 248
 249   MessageManager::freeMessage();
 250   if (CountDownManager::state != -1)
 251     MessageManager::readyMessage(CountDownManager::state);
 252 }
 253
 254 void Game::syncPause ( int delay )
 255 {
 256   assert(delay > 0);
 257
 258   state = GS_PAUSED | GS_SYNC_WAIT;
 259   sync_wait = delay;
 260
 261   if (CountDownManager::state != -1)
 262     MessageManager::freeMessage();
 263   MessageManager::readyMessage(MS_WAITING);
 264 }
 265
 266 void Game::syncUnpause (   )
 267 {
 268   state = GS_NORMAL;
 269
 270   MessageManager::freeMessage();
 271   if (CountDownManager::state != -1)
 272     MessageManager::readyMessage(CountDownManager::state);
 273 }
 274
 275 void Game::idleMeta (   )
 276 {
 277 #ifndef _WIN32
 278   timeval now;
 279   double nowd;
 280   gettimeofday(&now,NULL);
 281   #define FPSDIFF (1.0f/30.0f)
 282   nowd = now.tv_sec;
 283   nowd += (double)now.tv_usec / 1000000.0f;
 284
 285   if ( (nowd - lastframe) > FPSDIFF ) {
 286     lastframe = nowd;
 287   } else {
 288     usleep(1000);
 289   }
 290 #endif
 291
 292   int modified_and_complete = false;
 293
 294   do {
 295
 296     int time = glutGet((GLenum) GLUT_ELAPSED_TIME);
 297     remaining_time += time - previous_time;
 298     previous_time = time;
 299
 300     // no time step yet
 301     if (remaining_time < GC_TIME_STEP_PERIOD) break;
 302
 303     remaining_time -= GC_TIME_STEP_PERIOD;
 304     time_step++;
 305
 306     if (remaining_time < GC_TIME_STEP_PERIOD)
 307       modified_and_complete = true;
 308     else
 309       DOT(3);
 310
 311     // communicate state and other stuff
 312     if (!(MetaState::state & MS_GAME_OVER_KEY_WAIT) &&
 313      !(MetaState::mode & CM_SOLO))
 314       Communicator::timeStepMeta();
 315
 316     // advance celebration
 317     CelebrationManager::timeStep();
 318
 319     // advance the score record
 320     ScoreRecordManager::timeStep();
 321
 322     // update message pulse
 323     MessageManager::timeStep();
 324
 325     // update the pretty stuff too
 326     SparkleManager::timeStep();
 327     SignManager::timeStep();
 328     if (!(MetaState::mode & CM_REALLY_LOW_GRAPHICS))
 329       WinRecord::timeStep();
 330     LevelLights::timeStep();
 331
 332     // advance the clock through its final tick fade
 333     Clock::timeStepMeta();
 334
 335     // advance the score through its final increment fade
 336     Score::timeStepMeta();
 337
 338   } while (false);
 339
 340   if (modified_and_complete) {
 341     glFinish();
 342     glutPostRedisplay();
 343   }
 344 }
 345
 346 void Game::idlePlay (   )
 347 {
 348 #ifndef _WIN32
 349   timeval now;
 350   double nowd;
 351   gettimeofday(&now,NULL);
 352   #define FPSDIFF (1.0f/30.0f)
 353   nowd = now.tv_sec;
 354   nowd += (double)now.tv_usec / 1000000.0f;
 355
 356   if ( (nowd - lastframe) > FPSDIFF ) {
 357     lastframe = nowd;
 358   } else {
 359     usleep(1000);
 360   }
 361 #endif
 362
 363   int modified_and_complete = false;
 364
 365   do {
 366
 367     int time = glutGet((GLenum) GLUT_ELAPSED_TIME);
 368     remaining_time += time - previous_time;
 369     previous_time = time;
 370
 371     // no time step yet
 372     if (remaining_time < GC_TIME_STEP_PERIOD) break;
 373
 374     remaining_time -= GC_TIME_STEP_PERIOD;
 375
 376     if (remaining_time < GC_TIME_STEP_PERIOD)
 377       modified_and_complete = true;
 378     else
 379       DOT(2);
 380
 381     if (!(state & GS_PAUSED)) {
 382       if (step_play) {
 383
 384         time_step++;
 385
 386         // check for and continue swaps and moves
 387         Swapper::timeStep();
 388
 389         // update the level lights
 390         LevelLights::timeStep();
 391
 392         // update message pulse
 393         MessageManager::timeStep();
 394
 395         // move the win record stars
 396         WinRecord::timeStep();
 397
 398         // update the starting count down
 399         CountDownManager::timeStep();
 400         if (CountDownManager::start_pause_alarm != 0) {
 401           // some objects require a time step during start pause
 402
 403           if (!(MetaState::mode & CM_SOLO))
 404             Communicator::timeStepPlay();
 405
 406           // reset the clock
 407           Clock::timeStepMeta();
 408
 409           continue;
 410         }
 411
 412                                 if (MetaState::mode & CM_AI)
 413                                         ComputerPlayer::timeStep();
 414
 415         // loop over the grid, bottom to top; garbage will advance x and y
 416         for (int y = 1; y < GC_PLAY_HEIGHT; y++)
 417           for (int x = 0; x < GC_PLAY_WIDTH; x++) {
 418             if (Grid::residentTypeAt(x, y) & GR_EMPTY) continue;
 419
 420             if (Grid::residentTypeAt(x, y) & GR_BLOCK)
 421               Grid::blockAt(x, y).timeStep();
 422             else
 423               Grid::garbageAt(x, y).timeStep(x, y);
 424           }
 425
 426         // perhaps creep upward
 427         Creep::timeStep();
 428
 429         // process elimination check requests and update top_occupied_row
 430         Grid::timeStep();
 431
 432         // handle new and finished combos
 433         ComboManager::timeStep();
 434       }
 435
 436       // communicate garbage and other stuff
 437       if (!(MetaState::mode & CM_SOLO))
 438         Communicator::timeStepPlay();
 439
 440       if (step_play) {
 441
 442         // drop queued garbage
 443         GarbageGenerator::timeStep();
 444
 445         // move the sparkles and signs
 446         SparkleManager::timeStep();
 447         SignManager::timeStep();
 448
 449         // update the impact spring
 450         if (!(MetaState::mode & CM_REALLY_LOW_GRAPHICS))
 451           Spring::timeStep();
 452
 453         // update the clock
 454         Clock::timeStepPlay();
 455
 456         // update the score
 457         Score::timeStepPlay();
 458
 459         // update the losebar
 460         LoseBar::timeStep();
 461
 462         // advance extreme effects
 463         if (MetaState::mode & CM_X)
 464           X::timeStep();
 465       }
 466
 467     } else {
 468
 469       // if this is a sync pause, count down the waiting period
 470       if (state & GS_SYNC_WAIT && !--sync_wait)
 471         syncUnpause();
 472
 473       // communicate when paused
 474       if (!(MetaState::mode & CM_SOLO))
 475         Communicator::timeStepPlay();
 476
 477       // update message pulse
 478       MessageManager::timeStep();
 479     }
 480
 481     if (state & (GS_MAY_HAVE_LOST | GS_MUST_CONFIRM_LOSS))
 482       step_play = false;
 483
 484     if (state & GS_END_PLAY) {
 485       // step_play = false;
 486       if (state & GS_PAUSED)
 487         MessageManager::freeMessage();
 488
 489       if ((MetaState::mode & CM_SOLO) && !(MetaState::mode & CM_AI))
 490         state = Score::gameFinish();
 491
 492       if (MetaState::mode & CM_AI)
 493         state = ComputerPlayer::gameFinish();
 494
 495       ActionRecorder::gameFinish();
 496
 497       if (state & GS_LOST)
 498         MetaState::gameLoss();
 499       else
 500         MetaState::gameWon();
 501
 502       break;
 503     }
 504
 505   } while (false);
 506
 507   if (!button_down_pause) {
 508     if (Controller::pauseCommand()) {
 509       button_down_pause = true;
 510       buttonPause();
 511     }
 512   } else
 513     if (!Controller::pauseCommand())
 514       button_down_pause = false;
 515
 516   if (modified_and_complete) {
 517     glFinish();
 518     glutPostRedisplay();
 519   }
 520 }