src/Score.h

   1 /*
   2  * Score.h
   3  * Daniel Nelson - 8/24/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
  26 #ifndef SCORE_H
  27 #define SCORE_H
  28
  29 using namespace std;
  30
  31 #include "Game.h"
  32 #include "ComboTabulator.h"
  33 #include "MetaState.h"
  34
  35 class Rank {
  36 public:
  37   char name[GC_PLAYER_NAME_LENGTH];
  38   int score;
  39 };
  40
  41 class ComboRank {
  42 public:
  43   char name[GC_PLAYER_NAME_LENGTH];
  44   int multiplier;
  45   int score;
  46 };
  47
  48 /* static */ class Score {
  49 public:
  50   static void initialize (   );
  51   static void cleanUp (   );
  52   static int gameFinish (   );
  53
  54   static bool readScoreRecord (   );
  55   static bool readMultRecord (   );
  56   static void writeScoreRecord (   );
  57   static void setupDefaultScoreRecord (   );
  58   static void setupDefaultMultRecord (   );
  59
  60   static inline void timeStepMeta (   )
  61   {
  62     if (!(MetaState::mode & CM_SOLO)) return;
  63
  64     if (fade_timer == 0) return;
  65     fade_timer--;
  66   }
  67
  68   static inline void timeStepPlay (   )
  69   {
  70     if (!(MetaState::mode & CM_SOLO)) return;
  71
  72     if (fade_timer == 0) {
  73       if (backlog > 0) {
  74         backlog--;
  75         score++;
  76         incrementDigits();
  77         fade_timer = GC_MAX_SCORE_INCREMENT_DELAY
  78          - (GC_SCORE_DELAY_SLOPE * backlog);
  79         if (fade_timer < GC_MIN_SCORE_INCREMENT_DELAY) {
  80           fade_timer = GC_MIN_SCORE_INCREMENT_DELAY;
  81           inverse_timer_start = 1.0f / (GLfloat) GC_MIN_SCORE_INCREMENT_DELAY;
  82         } else
  83           inverse_timer_start = 1.0f / (GLfloat) fade_timer;
  84       }
  85     } else
  86       fade_timer--;
  87   }
  88
  89   static inline void incrementDigits (   )
  90   {
  91     for (int i = GC_NUMBER_DIGITS; i--; )
  92       previous_digits[i] = digits[i];
  93
  94     int i;
  95     for (i = 0; i < GC_NUMBER_DIGITS; i++) {
  96       digits[i]++;
  97       if (digits[i] != 10) break;
  98       digits[i] = 0;
  99     }
 100     if (++i > n_digits_displayed && i <= GC_NUMBER_DIGITS)
 101       n_digits_displayed = i;
 102   }
 103
 104   static inline void reportMultiplier ( ComboTabulator &combo )
 105   {
 106     // check for highest multiplier
 107     if (combo.multiplier > top_combo_multiplier)
 108       top_combo_multiplier = combo.multiplier;
 109
 110     if (!(MetaState::mode & CM_SOLO)) return;
 111
 112     // multiply this step's score
 113     backlog += combo.base_score_this_step
 114      * (combo.multiplier - combo.n_multipliers_this_step - 1);
 115
 116     // give another helping of the accumulated score
 117     backlog += combo.base_accumulated_score
 118      * combo.n_multipliers_this_step;
 119
 120     combo.n_multipliers_this_step = 0;
 121   }
 122
 123   static inline int reportElimination ( ComboTabulator &combo )
 124   {
 125     if (!(MetaState::mode & CM_SOLO)) return 0;
 126
 127     int points = 0;
 128
 129     // gray elimination score
 130     if (combo.special_magnitude > 0)
 131       points
 132        += GC_GRAY_SCORE * (combo.special_magnitude == GC_MIN_PATTERN_LENGTH
 133        ? GC_MIN_PATTERN_SCORE
 134        : combo.special_magnitude);
 135
 136     // colored elimination score
 137     else
 138       points += (combo.magnitude == GC_MIN_PATTERN_LENGTH
 139        ? GC_MIN_PATTERN_SCORE
 140        : combo.magnitude);
 141
 142     // special block bonuses
 143     for (int n = BF_NUMBER_SPECIAL; n--; )
 144       points += combo.special[n] * special_block_scores[n];
 145
 146     backlog += points;
 147
 148     return points;
 149   }
 150
 151   static inline bool topRank (   )
 152   {
 153     return player_rank == GC_SCORE_REC_LENGTH - 1;
 154   }
 155
 156   static int score;
 157   static int backlog;
 158   static short digits[GC_NUMBER_DIGITS];
 159   static short previous_digits[GC_NUMBER_DIGITS];
 160   static int fade_timer;
 161   static GLfloat inverse_timer_start;
 162   static int n_digits_displayed;
 163
 164   static int player_rank;
 165   static Rank record[GC_SCORE_REC_LENGTH];
 166
 167   static int special_block_scores[BF_NUMBER_SPECIAL];
 168
 169   static int top_combo_multiplier;
 170   static int top_combo_score;
 171   static ComboRank combo_record[GC_SCORE_MULT_LENGTH];
 172 };
 173
 174 #endif