savestate.h

   1 /*
   2     Copyright (C) 2005-2007 Tom Beaumont
   3
   4     This program is free software; you can redistribute it and/or modify
   5     it under the terms of the GNU General Public License as published by
   6     the Free Software Foundation; either version 2 of the License, or
   7     (at your option) any later version.
   8
   9     This program is distributed in the hope that it will be useful,
  10     but WITHOUT ANY WARRANTY; without even the implied warranty of
  11     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  12     GNU General Public License for more details.
  13
  14     You should have received a copy of the GNU General Public License
  15     along with this program; if not, write to the Free Software
  16     Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
  17 */
  18
  19
  20 struct HexPuzzle;
  21
  22 class LevelSave
  23 {
  24         friend struct HexPuzzle;
  25
  26         char * bestSolution;
  27         int bestSolutionLength;
  28         int bestScore;
  29         #define NUM_LAST_SCORES 19
  30         int lastScores[NUM_LAST_SCORES];
  31         int unlocked;
  32 public:
  33         LevelSave()
  34         {
  35                 Clear();
  36         }
  37         void Clear()
  38         {
  39                 unlocked = 0;
  40                 bestSolution = 0;
  41                 bestScore = 0;
  42                 bestSolutionLength = 0;
  43                 memset(lastScores, 0, sizeof(lastScores));
  44         }
  45         void LoadSave(FILE* f, bool save)
  46         {
  47                 typedef unsigned int _fn(void*, unsigned int, unsigned int, FILE*);
  48                 _fn * fn = save ? (_fn*)fwrite : (_fn*)fread;
  49
  50                 fn(&bestSolutionLength, sizeof(bestSolutionLength), 1, f);
  51                 fn(&bestScore, sizeof(bestScore), 1, f);
  52                 fn(&lastScores, sizeof(lastScores), 1, f);
  53                 fn(&unlocked, sizeof(unlocked), 1, f);
  54
  55                 if (bestSolutionLength)
  56                 {
  57                         if (!save) SetSolution(bestSolutionLength);
  58                         fn(bestSolution, sizeof(bestSolution[0]), bestSolutionLength, f);
  59                 }
  60         }
  61
  62         void Dump()
  63         {
  64                 for (int j=1; j<NUM_LAST_SCORES; j++)
  65                         if (lastScores[j]==lastScores[0])
  66                                 lastScores[j] = 0;
  67
  68 /*              for (int i=0; i<NUM_LAST_SCORES && lastScores[i]; i++)
  69                         if (lastScores[i] != bestScore)
  70                                 printf("\t% 8d\n", lastScores[i]);*/
  71         }
  72         bool Completed()
  73         {
  74                 return bestScore != 0;
  75         }
  76         bool IsNewCompletionBetter(int score)
  77         {
  78                 for (int i=0; i<NUM_LAST_SCORES; i++)
  79                 {
  80                         if (lastScores[i]==0)
  81                                 lastScores[i] = score;
  82                         if (lastScores[i]==score)
  83                                 break;
  84                 }
  85
  86                 if (!Completed())
  87                         return true;
  88
  89                 return score <= bestScore;
  90         }
  91         bool PassesPar(int par)
  92         {
  93                 if (!Completed())
  94                         return false;
  95                 return bestScore <= par;
  96         }
  97         int GetScore()
  98         {
  99                 return bestScore;
 100         }
 101         void SetScore(int s)
 102         {
 103                 bestScore = s;
 104         }
 105         void SetSolution(int l) {
 106                 delete [] bestSolution;
 107                 bestSolutionLength = l;
 108                 bestSolution = new char [ l ];
 109         }
 110         void SetSolutionStep(int pos, int val)
 111         {
 112                 bestSolution[pos] = val;
 113         }
 114 };
 115
 116 class SaveState
 117 {
 118         struct X : public LevelSave
 119         {
 120                 X* next;
 121                 char* name;
 122
 123                 X(const char* n, X* nx=0) : next(nx)
 124                 {
 125                         name = new char[strlen(n)+1];
 126                         strcpy(name, n);
 127                 }
 128                 ~X()
 129                 {
 130                         delete [] name;
 131                 }
 132         };
 133
 134         struct General {
 135                 int scoringOn;
 136                 int hintFlags;
 137                 int completionPercentage;
 138                 int endSequence;
 139                 int masteredPercentage;
 140                 int pad[6];
 141         };
 142
 143         X* first;
 144
 145         void ClearRaw()
 146         {
 147                 memset(&general, 0, sizeof(general));
 148                 general.hintFlags = 1<<31 | 1<<30;
 149
 150                 X* x=first;
 151                 while (x)
 152                 {
 153                         X* nx = x->next;
 154                         delete x;
 155                         x = nx;
 156                 }
 157                 first = 0;
 158
 159         }
 160
 161 public:
 162
 163         General general;
 164
 165
 166         SaveState() : first(0)
 167         {
 168                 Clear();
 169         }
 170
 171         ~SaveState()
 172         {
 173                 ClearRaw();
 174         }
 175
 176         void Clear()
 177         {
 178                 ClearRaw();
 179                 ApplyStuff();
 180         }
 181
 182         void GetStuff();
 183         void ApplyStuff();
 184
 185         void LoadSave(FILE* f, bool save)
 186         {
 187                 if (save)
 188                 {
 189                         GetStuff();
 190
 191                         //printf("----\n");
 192
 193                         fputc('2', f);
 194                         fwrite(&general, sizeof(general), 1, f);
 195                         for(X* x=first; x; x=x->next)
 196                         {
 197                                 short len = strlen(x->name);
 198                                 fwrite(&len, sizeof(len), 1, f);
 199                                 fwrite(x->name, len, 1, f);
 200
 201                                 x->LoadSave(f,save);
 202
 203                                 if (x->Completed())
 204                                 {
 205                                         //printf("% 8d %s\n", x->GetScore(), x->name);
 206                                         x->Dump();
 207                                 }
 208                         }
 209                 }
 210                 else
 211                 {
 212                         ClearRaw();
 213                         int v = fgetc(f);
 214                         if (v=='2')
 215                         {
 216                                 fread(&general, sizeof(general), 1, f);
 217                                 v = '1';
 218                         }
 219                         if (v=='1')
 220                         {
 221                                 while(!feof(f))
 222                                 {
 223                                         char temp[1000];
 224                                         short len;
 225                                         fread(&len, sizeof(len), 1, f);
 226                                         if (feof(f)) break;
 227                                         fread(temp, len, 1, f);
 228                                         temp[len] = 0;
 229                                         first = new X(temp, first);
 230
 231                                         first->LoadSave(f,save);
 232                                 }
 233                         }
 234
 235                         ApplyStuff();
 236                 }
 237         }
 238
 239         LevelSave* GetLevel(const char * name, bool create)
 240         {
 241                 char * l = strstr(name, "Levels");
 242                 if (l)
 243                         name = l;
 244
 245                 X* x = first;
 246                 if (x && strcmp(name, x->name)==0) return x;
 247                 while (x && x->next)
 248                 {
 249                         if (strcmp(name, x->next->name)==0) return x->next;
 250                         x = x->next;
 251                 }
 252                 if (create)
 253                 {
 254                         X* n = new X(name);
 255                         if (x)
 256                                 x->next = n;
 257                         else
 258                                 first = n;
 259                         return n;
 260                 }
 261                 else
 262                 {
 263                         return 0;
 264                 }
 265         }
 266 };