src/WinRecord.cxx

   1 /*
   2  * WinRecord.cxx
   3  * Daniel Nelson - 10/22/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  * Handles the win/loss record.
  26  */
  27
  28 #include <GL/glut.h>
  29
  30 #ifndef _WIN32
  31 #else
  32 #  include <glext.h>
  33 #endif
  34
  35 using namespace std;
  36
  37 #include "Game.h"
  38 #include "WinRecord.h"
  39 #include "Displayer.h"
  40 #include "Random.h"
  41
  42 int WinRecord::current_game;
  43 bool WinRecord::won;
  44 bool WinRecord::concession;
  45 int WinRecord::games_won;
  46 int WinRecord::games_lost;
  47 int WinRecord::record[GC_GAMES_PER_MATCH];
  48
  49 Star WinRecord::stars[GC_GAMES_PER_MATCH];
  50 int WinRecord::dynamic_star;
  51 int WinRecord::displaced_star;
  52 GLfloat WinRecord::win_star_x;
  53 GLfloat WinRecord::win_star_y;
  54 GLfloat WinRecord::win_star_v_x;
  55 GLfloat WinRecord::win_star_v_y;
  56 GLfloat WinRecord::old_star_a;
  57 GLfloat WinRecord::old_star_size;
  58 bool WinRecord::draw_old_star;
  59
  60 void WinRecord::initialize (   )
  61 {
  62   for (int n = GC_GAMES_PER_MATCH; n--; )
  63     record[n] = GR_NOT_PLAYED;
  64   current_game = -1;
  65   concession = false;
  66   games_won = 0;
  67   games_lost = 0;
  68
  69   dynamic_star = -1;
  70   displaced_star = -1;
  71   for (int n = GC_GAMES_PER_MATCH; n--; )
  72     stars[n].a = 0.0f;
  73 }
  74
  75 void WinRecord::gameStart (   )
  76 {
  77   if (MetaState::mode & CM_SOLO)
  78     current_game = 1;
  79   else
  80     current_game++;
  81
  82   record[current_game] = GR_BEING_PLAYED;
  83 }
  84
  85 void WinRecord::gameWon (   )
  86 {
  87   won = true;
  88   games_won++;
  89   record[current_game] = GR_WON;
  90
  91   // The star will disappear and pop into existance in the play area.  After a
  92   // few moments, it will fly to it's original location.
  93
  94   // record star's old location; for a time, two stars will be drawn, as one
  95   // pops in and the other pops away
  96   draw_old_star = true;
  97   old_star_a = stars[current_game].a;
  98   old_star_size = 5.0f;
  99
 100   // displace the star into the play area and set it's starting parameters
 101   displaced_star = current_game;
 102   stars[current_game].a = DC_STAR_WIN_MIN_ANGULAR_DEVIATION
 103    + DC_STAR_WIN_SPREAD_ANGULAR_DEVIATION * Random::number();
 104   if (Random::chanceIn2(2))
 105     stars[current_game].a = -stars[current_game].a;
 106   stars[current_game].v_a = 0.0f;
 107   stars[current_game].size = 0.0f;
 108   stars[current_game].v_size = 0.0f;
 109   win_star_x = (-DC_LEFT_EXTERNAL_CENTER + DC_STAR_DISPLACEMENT
 110    * (GC_GAMES_PER_MATCH - 1) / 2.0f + DC_STAR_WIN_OFFSET_X)
 111    - DC_STAR_DISPLACEMENT * current_game;
 112
 113   if (MetaState::mode & CM_SOLO)
 114     win_star_y = -DC_STAR_OFFSET_Y + DC_STAR_WIN_SOLO_OFFSET_Y;
 115   else
 116     win_star_y = -DC_STAR_OFFSET_Y + DC_STAR_WIN_OFFSET_Y;
 117
 118   // set the kick velocity; choice of two aesthetically pleasing preset values
 119   // or, for variety, a random 270 degree arc
 120   switch (Random::number(3)) {
 121   case 0:
 122     win_star_v_x = DC_STAR_WIN_PRESET_1_VELOCITY_X;
 123     win_star_v_y = DC_STAR_WIN_PRESET_1_VELOCITY_Y;
 124     break;
 125   case 1:
 126     win_star_v_x = DC_STAR_WIN_PRESET_2_VELOCITY_X;
 127     win_star_v_y = DC_STAR_WIN_PRESET_2_VELOCITY_Y;
 128     break;
 129   default:
 130     // too infrequent to warrent a random direction table
 131     float v = DC_STAR_WIN_MIN_VELOCITY
 132      + DC_STAR_WIN_SPREAD_VELOCITY * Random::number();
 133     float angle = Random::number() * (3.0f * PI / 2.0f) - (PI / 2.0f);
 134     win_star_v_x = v * cos(angle);
 135     win_star_v_y = v * sin(angle);
 136     break;
 137   }
 138 }
 139
 140 void WinRecord::gameLoss (   )
 141 {
 142   won = false;
 143   games_lost++;
 144   record[current_game] = GR_LOST;
 145 }
 146
 147 void WinRecord::timeStep (   )
 148 {
 149   for (int n = GC_GAMES_PER_MATCH; n--; ) {
 150     Star &star = stars[n];
 151
 152     switch (record[n]) {
 153
 154     // game being played
 155     case GR_BEING_PLAYED:
 156       if (Game::time_step >= GC_START_PAUSE_DELAY)
 157         star.a += DC_STAR_PLAY_ANGULAR_VELOCITY;
 158       else
 159         star.a += Game::time_step
 160          * (DC_STAR_PLAY_ANGULAR_VELOCITY / (float) GC_START_PAUSE_DELAY);
 161       break;
 162
 163     // game has been lost
 164     case GR_LOST:
 165       if (current_game == n && Game::time_step < DC_CELEBRATION_TIME)
 166         star.a += (DC_CELEBRATION_TIME - Game::time_step)
 167          * (DC_STAR_PLAY_ANGULAR_VELOCITY / (float) DC_CELEBRATION_TIME);
 168       break;
 169
 170     // game has been won
 171     case GR_WON:
 172       // wait for win message to hit before dynamics
 173       if (current_game != n || Game::time_step > DC_WIN_FADE_TIME) {
 174
 175         star.size += star.v_size;
 176         if (star.size < 0.0f) star.size = 0.0f;
 177         star.v_size += -DC_STAR_WIN_SIZE_DRAG * star.v_size
 178          - DC_STAR_WIN_SIZE_SPRING * (star.size - DC_STAR_SIZE_EQUILIBRIUM);
 179
 180         if (fabs(star.v_size) < DC_STAR_WIN_SIZE_EPSILON
 181          && Random::chanceIn(DC_STAR_WIN_SIZE_PULSE_CHANCE_IN))
 182           star.v_size += DC_STAR_WIN_SIZE_PULSE_VELOCITY * Random::number();
 183
 184         star.v_a += -DC_STAR_WIN_ANGULAR_SPRING * star.a;
 185
 186         star.a += star.v_a;
 187
 188         // begin motion
 189         if (Game::time_step == DC_WIN_FADE_TIME + DC_STAR_WIN_KICK_DELAY
 190          && current_game == n) {
 191           displaced_star = -1;
 192           dynamic_star = n;
 193         }
 194
 195         // if we're dynamic;
 196         if (dynamic_star == n) {
 197           win_star_x += win_star_v_x;
 198           win_star_y += win_star_v_y;
 199
 200           win_star_v_x += -DC_STAR_WIN_SPRING * win_star_x
 201            - DC_STAR_WIN_DRAG * win_star_v_x;
 202           win_star_v_y += -DC_STAR_WIN_SPRING * win_star_y
 203            - DC_STAR_WIN_DRAG * win_star_v_y;
 204
 205           // if we're there, stop being dynamic
 206           if (fabs(win_star_v_x) < DC_STAR_WIN_VELOCITY_EPSILON
 207            && fabs(win_star_v_y) < DC_STAR_WIN_VELOCITY_EPSILON
 208            && fabs(win_star_x) < DC_STAR_WIN_EPSILON
 209            && fabs(win_star_y) < DC_STAR_WIN_EPSILON)
 210             dynamic_star = -1;
 211         }
 212       }
 213
 214       // shrink the old star as the new one apears
 215       if (draw_old_star && current_game == n) {
 216         if (star.size < DC_STAR_SIZE_EQUILIBRIUM) {
 217           old_star_size = DC_STAR_SIZE_EQUILIBRIUM - star.size;
 218           old_star_a += DC_STAR_PLAY_ANGULAR_VELOCITY;
 219         } else
 220           draw_old_star = false;
 221       }
 222
 223       break;
 224     }
 225   }
 226 }