white space changes
[rocksndiamonds.git] / src / game_bd / bd_caveset.c
1 /*
2  * Copyright (c) 2007, 2008, 2009, Czirkos Zoltan <cirix@fw.hu>
3  *
4  * Permission to use, copy, modify, and distribute this software for any
5  * purpose with or without fee is hereby granted, provided that the above
6  * copyright notice and this permission notice appear in all copies.
7  *
8  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
9  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
10  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
11  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
12  * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
13  * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
14  * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
15  */
16
17 #include <sys/stat.h>
18
19 #include "main_bd.h"
20
21
22 // this stores the caves.
23 List *gd_caveset;
24
25 // the data of the caveset: name, highscore, max number of lives, etc.
26 GdCavesetData *gd_caveset_data;
27
28 // is set to true, when the caveset was edited since the last save.
29 boolean gd_caveset_edited;
30
31 // last selected-to-play cave
32 int gd_caveset_last_selected;
33 int gd_caveset_last_selected_level;
34
35 // list of possible extensions which can be opened
36 char *gd_caveset_extensions[] =
37 {
38   "*.gds",
39   "*.bd",
40   "*.bdr",
41   "*.brc",
42
43   NULL
44 };
45
46 #define CAVESET_OFFSET(property) (STRUCT_OFFSET(GdCavesetData, property))
47
48 const GdStructDescriptor gd_caveset_properties[] =
49 {
50   // default data
51   {"", GD_TAB, 0, N_("Caveset data")},
52   {"Name", GD_TYPE_STRING, 0, N_("Name"), CAVESET_OFFSET(name), 1, N_("Name of the game")},
53   {"Description", GD_TYPE_STRING, 0, N_("Description"), CAVESET_OFFSET(description), 1, N_("Some words about the game")},
54   {"Author", GD_TYPE_STRING, 0, N_("Author"), CAVESET_OFFSET(author), 1, N_("Name of author")},
55   {"Date", GD_TYPE_STRING, 0, N_("Date"), CAVESET_OFFSET(date), 1, N_("Date of creation")},
56   {"WWW", GD_TYPE_STRING, 0, N_("WWW"), CAVESET_OFFSET(www), 1, N_("Web page or e-mail address")},
57   {"Difficulty", GD_TYPE_STRING, 0, N_("Difficulty"), CAVESET_OFFSET(difficulty), 1, N_("Difficulty (informative)")},
58
59   {"Lives", GD_TYPE_INT, 0, N_("Initial lives"), CAVESET_OFFSET(initial_lives), 1, N_("Number of lives you get at game start."), 3, 9},
60   {"Lives", GD_TYPE_INT, 0, N_("Maximum lives"), CAVESET_OFFSET(maximum_lives), 1, N_("Maximum number of lives you can have by collecting bonus points."), 3, 99},
61   {"BonusLife", GD_TYPE_INT, 0, N_("Bonus life score"), CAVESET_OFFSET(bonus_life_score), 1, N_("Number of points to collect for a bonus life."), 100, 5000},
62
63   {"Story", GD_TYPE_LONGSTRING, 0, N_("Story"), CAVESET_OFFSET(story), 1, N_("Long description of the game.")},
64   {"Remark", GD_TYPE_LONGSTRING, 0, N_("Remark"), CAVESET_OFFSET(remark), 1, N_("Remark (informative).")},
65
66   {"TitleScreen", GD_TYPE_LONGSTRING, GD_DONT_SHOW_IN_EDITOR, N_("Title screen"), CAVESET_OFFSET(title_screen), 1, N_("Title screen image")},
67   {"TitleScreenScroll", GD_TYPE_LONGSTRING, GD_DONT_SHOW_IN_EDITOR, N_("Title screen, scrolling"), CAVESET_OFFSET(title_screen_scroll), 1, N_("Scrolling background for title screen image")},
68
69   {NULL},
70 };
71
72 static GdPropertyDefault caveset_defaults[] =
73 {
74   // default data
75   {CAVESET_OFFSET(initial_lives), 3},
76   {CAVESET_OFFSET(maximum_lives), 9},
77   {CAVESET_OFFSET(bonus_life_score), 500},
78
79   {-1},
80 };
81
82 GdCavesetData *gd_caveset_data_new(void)
83 {
84   GdCavesetData *data;
85
86   data = checked_calloc(sizeof(GdCavesetData));
87
88   gd_struct_set_defaults_from_array(data, gd_caveset_properties, caveset_defaults);
89
90   data->levelset_subdir = getStringCopy(leveldir_current->subdir);
91
92   return data;
93 }
94
95 void gd_caveset_data_free(GdCavesetData *data)
96 {
97   int i;
98
99   // free strings
100   for (i = 0; gd_caveset_properties[i].identifier != NULL; i++)
101     if (gd_caveset_properties[i].type == GD_TYPE_LONGSTRING)
102       checked_free(STRUCT_MEMBER(char *, data, gd_caveset_properties[i].offset));
103
104   checked_free(data->levelset_subdir);
105
106   checked_free(data);
107 }
108
109 // ============================================================================
110 // Misc caveset functions
111 // ============================================================================
112
113 // Clears all caves in the caveset. also to be called at application start
114 void gd_caveset_clear(void)
115 {
116   if (gd_caveset)
117   {
118     list_foreach(gd_caveset, (list_fn) gd_cave_free, NULL);
119     list_free(gd_caveset);
120     gd_caveset = NULL;
121   }
122
123   if (gd_caveset_data)
124   {
125     gd_caveset_data_free(gd_caveset_data);
126     gd_caveset_data = NULL;
127   }
128
129   // always newly create this
130   // create pseudo cave containing default values
131   gd_caveset_data = gd_caveset_data_new();
132   gd_strcpy(gd_caveset_data->name, getCurrentLevelsetName());
133 }
134
135 // return number of caves currently in memory.
136 int gd_caveset_count(void)
137 {
138   return list_length(gd_caveset);
139 }
140
141 // return index of first selectable cave
142 static int caveset_first_selectable_cave_index(void)
143 {
144   List *iter;
145   int i;
146
147   for (i = 0, iter = gd_caveset; iter != NULL; i++, iter = iter->next)
148   {
149     GdCave *cave = (GdCave *)iter->data;
150
151     if (cave->selectable)
152       return i;
153   }
154
155   Warn("no selectable cave in caveset!");
156
157   // and return the first one.
158   return 0;
159 }
160
161 // return a cave identified by its index
162 GdCave *gd_return_nth_cave(const int cave)
163 {
164   return list_nth_data(gd_caveset, cave);
165 }
166
167 // get a selected cave from the loaded caveset (original, unmodified cave)
168 GdCave *gd_get_original_cave_from_caveset(const int cave)
169 {
170   // get specified cave from caveset already stored in memory
171   GdCave *original_cave = gd_return_nth_cave(cave);
172
173   return original_cave;
174 }
175
176 // get a selected cave from the loaded caveset (cave prepared for playing)
177 GdCave *gd_get_prepared_cave_from_caveset(const int cave, const int level)
178 {
179   // get specified cave from caveset already stored in memory
180   GdCave *original_cave = gd_return_nth_cave(cave);
181
182   // get prepared cave from original cave
183   GdCave *prepared_cave = gd_get_prepared_cave(original_cave, level);
184
185   return prepared_cave;
186 }
187
188 // get a cave prepared for playing from a given original, unmodified cave (with seed)
189 GdCave *gd_get_prepared_cave(const GdCave *original_cave, const int level)
190 {
191   // get rendered cave using the selected seed for playing
192   GdCave *prepared_cave = gd_cave_new_rendered(original_cave, level, game_bd.random_seed);
193
194   // initialize some cave variables (like player position)
195   gd_cave_setup_for_game(prepared_cave);
196
197   return prepared_cave;
198 }
199
200 // colors: 4: purple  3: ciklamen 2: orange 1: blue 0: green
201 static GdElement brc_import_table[] =
202 {
203   /* 0 */
204   O_SPACE, O_DIRT, O_BRICK, O_MAGIC_WALL, O_PRE_OUTBOX, O_OUTBOX, O_UNKNOWN, O_STEEL,
205   O_H_EXPANDING_WALL, O_H_EXPANDING_WALL /* scanned */, O_FIREFLY_1 /* scanned */, O_FIREFLY_1 /* scanned */, O_FIREFLY_1, O_FIREFLY_2, O_FIREFLY_3, O_FIREFLY_4,
206
207   /* 1 */
208   O_BUTTER_1 /* scanned */, O_BUTTER_1 /* scanned */, O_BUTTER_1, O_BUTTER_2, O_BUTTER_3, O_BUTTER_4, O_PLAYER, O_PLAYER /* scanned */,
209   O_STONE, O_STONE /* scanned */, O_STONE_F, O_STONE_F /* scanned */, O_DIAMOND, O_DIAMOND /* scanned */, O_DIAMOND_F, O_DIAMOND_F /* scanned */,
210
211   /* 2 */
212   O_NONE /* WILL_EXPLODE_THING */, O_EXPLODE_1, O_EXPLODE_2, O_EXPLODE_3, O_EXPLODE_4, O_EXPLODE_5, O_NONE /* WILL EXPLODE TO DIAMOND_THING */, O_PRE_DIA_1,
213   O_PRE_DIA_2, O_PRE_DIA_3, O_PRE_DIA_4, O_PRE_DIA_5, O_AMOEBA, O_AMOEBA /* scanned */, O_SLIME, O_NONE,
214
215   /* 3 */
216   O_CLOCK, O_NONE /* clock eaten */, O_INBOX, O_PRE_PL_1, O_PRE_PL_2, O_PRE_PL_3, O_NONE, O_NONE,
217   O_NONE, O_NONE, O_V_EXPANDING_WALL, O_NONE, O_VOODOO, O_UNKNOWN, O_EXPANDING_WALL, O_EXPANDING_WALL /* sc */,
218
219   /* 4 */
220   O_FALLING_WALL, O_FALLING_WALL_F, O_FALLING_WALL_F /* scanned */, O_UNKNOWN, O_ACID, O_ACID /* scanned */, O_NITRO_PACK, O_NITRO_PACK /* scanned */,
221   O_NITRO_PACK_F, O_NITRO_PACK_F /* scanned */, O_NONE, O_NONE, O_NONE, O_NONE, O_NONE, O_NONE,
222
223   /* 5 */
224   O_NONE /* bomb explosion utolso */, O_UNKNOWN, O_NONE /* solid bomb glued */, O_UNKNOWN, O_STONE_GLUED, O_UNKNOWN, O_DIAMOND_GLUED, O_UNKNOWN,
225   O_UNKNOWN, O_UNKNOWN, O_NONE, O_NONE, O_NONE, O_NONE, O_NONE, O_NONE,
226
227   /* 6 */
228   O_ALT_FIREFLY_1 /* scanned */, O_ALT_FIREFLY_1 /* scanned */, O_ALT_FIREFLY_1, O_ALT_FIREFLY_2, O_ALT_FIREFLY_3, O_ALT_FIREFLY_4, O_PLAYER_BOMB, O_PLAYER_BOMB /* scanned */,
229   O_BOMB, O_BOMB_TICK_1, O_BOMB_TICK_2, O_BOMB_TICK_3, O_BOMB_TICK_4, O_BOMB_TICK_5, O_BOMB_TICK_6, O_BOMB_TICK_7,
230
231   /* 7 */
232   O_BOMB_TICK_7, O_BOMB_EXPL_1, O_BOMB_EXPL_2, O_BOMB_EXPL_3, O_BOMB_EXPL_4, O_UNKNOWN, O_UNKNOWN, O_UNKNOWN,
233   O_UNKNOWN, O_UNKNOWN, O_UNKNOWN, O_UNKNOWN, O_UNKNOWN, O_UNKNOWN, O_UNKNOWN, O_UNKNOWN,
234 };
235
236 static GdElement brc_effect_table[] =
237 {
238   O_STEEL, O_DIRT, O_SPACE, O_STONE, O_STONE_F, O_STONE_GLUED, O_DIAMOND, O_DIAMOND_F, O_DIAMOND_GLUED, O_PRE_DIA_1,
239   O_PLAYER, O_PRE_PL_1, O_PLAYER_BOMB, O_PRE_OUTBOX, O_OUTBOX, O_FIREFLY_1, O_FIREFLY_2, O_FIREFLY_3, O_FIREFLY_4,
240   O_BUTTER_1, O_BUTTER_2, O_BUTTER_3, O_BUTTER_4, O_BRICK, O_MAGIC_WALL, O_H_EXPANDING_WALL, O_V_EXPANDING_WALL, O_EXPANDING_WALL,
241   O_FALLING_WALL, O_FALLING_WALL_F, O_AMOEBA, O_SLIME, O_ACID, O_VOODOO, O_CLOCK, O_BOMB, O_UNKNOWN, O_UNKNOWN, O_UNKNOWN,
242   O_ALT_FIREFLY_1, O_ALT_FIREFLY_2, O_ALT_FIREFLY_3, O_ALT_FIREFLY_4, O_ALT_BUTTER_1, O_ALT_BUTTER_2, O_ALT_BUTTER_3, O_ALT_BUTTER_4,
243   O_EXPLODE_1, O_BOMB_EXPL_1, O_UNKNOWN,
244 };
245
246 static GdColor brc_color_table[] =
247 {
248   0x518722, 0x3a96fa, 0xdb7618, 0xff3968,
249   0x9b5fff, 0x0ee06c, 0xc25ea6, 0xf54826,
250   0xf1ff26,
251 };
252
253 static GdColor brc_color_table_comp[] =
254 {
255   0x582287, 0xfa9d39, 0x187ddb, 0x38ffd1,
256   0xc1ff5e, 0xe00d81, 0x5dc27a, 0x27d3f5,
257   0x3526ff,
258 };
259
260 static GdElement brc_effect(byte byt)
261 {
262   if (byt >= ARRAY_SIZE(brc_effect_table))
263   {
264     Warn("invalid element identifier for brc effect: %02x", byt);
265
266     return O_UNKNOWN;
267   }
268
269   return brc_effect_table[byt];
270 }
271
272 static void brc_import(byte *data)
273 {
274   int x, y;
275   int level;
276
277   // we import 100 caves, and the put them in the correct order.
278   GdCave *imported[100];
279   boolean import_effect;
280
281   gd_caveset_clear();
282
283   // this is some kind of a version number
284   import_effect = FALSE;
285
286   switch (data[23])
287   {
288     case 0x0:
289       // nothing to do
290       break;
291
292     case 0xde:
293       // import effects
294       import_effect = TRUE;
295       break;
296
297     default:
298       Warn("unknown brc version %02x", data[23]);
299       break;
300   }
301
302   for (level = 0; level < 5; level++)
303   {
304     int cavenum;
305     int i;
306
307     for (cavenum = 0; cavenum < 20; cavenum++)
308     {
309       GdCave *cave;
310
311       // 5 levels, 20 caves, 24 bytes - max 40*2 properties for each cave
312       int c = 5 * 20 * 24;
313
314       int datapos = (cavenum * 5 +level) * 24 + 22;
315       int colind;
316
317       cave = gd_cave_new();
318       imported[level * 20 + cavenum] = cave;
319
320       if (cavenum < 16)
321         snprintf(cave->name, sizeof(GdString), "Cave %c/%d", 'A' + cavenum,
322                  level + 1);
323       else
324         snprintf(cave->name, sizeof(GdString), "Intermission %d/%d",
325                  cavenum - 15, level + 1);
326
327       // fixed intermission caves; are smaller.
328       if (cavenum >= 16)
329       {
330         cave->w = 20;
331         cave->h = 12;
332       }
333
334       cave->map = gd_cave_map_new(cave, GdElement);
335
336       for (y = 0; y < cave->h; y++)
337       {
338         for (x = 0; x < cave->w; x++)
339         {
340           byte import;
341
342           import = data[y + level * 24 + cavenum * 24 * 5 + x * 24 * 5 * 20];
343
344           // if (i == printcave) g_print("%2x", import);
345           if (import < ARRAY_SIZE(brc_import_table))
346             cave->map[y][x] = brc_import_table[import];
347           else
348             cave->map[y][x] = O_UNKNOWN;
349         }
350       }
351
352       for (i = 0; i < 5; i++)
353       {
354         cave->level_time[i]             = data[0 * c + datapos];
355         cave->level_diamonds[i]         = data[1 * c + datapos];
356         cave->level_magic_wall_time[i]  = data[4 * c + datapos];
357         cave->level_amoeba_time[i]      = data[5 * c + datapos];
358         cave->level_amoeba_threshold[i] = data[6 * c + datapos];
359
360         // bonus time: 100 was added, so it could also be negative
361         cave->level_bonus_time[i]      = (int)data[11 * c + datapos + 1] - 100;
362         cave->level_hatching_delay_frame[i] = data[10 * c + datapos];
363
364         // this was not set in boulder remake.
365         cave->level_speed[i] = 150;
366       }
367
368       cave->diamond_value = data[2 * c + datapos];
369       cave->extra_diamond_value = data[3 * c +datapos];
370
371       // BRC PROBABILITIES
372       /*
373         a typical code example:
374         46:if (random(slime*4)<4) and (tab[x,y+2] = 0) then
375         Begin tab[x,y]:=0;col[x,y+2]:=col[x,y];tab[x,y+2]:=27;mat[x,y+2]:=9;Voice4:=2;end;
376         where slime is the byte loaded from the file as it is.
377         pascal random function generates a random number between 0..limit-1,
378         inclusive, for random(limit).
379
380         so a random number between 0..limit*4-1 is generated.
381         for limit=1, 0..3, which is always < 4, so P=1.
382         for limit=2, 0..7, 0..7 is < 4 in P=50%.
383         for limit=3, 0..11, is < 4 in P=33%.
384         So the probability is exactly 100%/limit.
385         just make sure we do not divide by zero for some broken input.
386       */
387
388       if (data[7 * c + datapos] == 0)
389         Warn("amoeba growth cannot be zero, error at byte %d",
390              data[7 * c + datapos]);
391       else
392         cave->amoeba_growth_prob = 1E6 / data[7 * c + datapos] + 0.5; // 0.5 for rounding
393
394       if (data[8 * c + datapos] == 0)
395         Warn("amoeba growth cannot be zero, error at byte %d",
396              data[8 * c + datapos]);
397       else
398         cave->amoeba_fast_growth_prob = 1E6 / data[8 * c + datapos] + 0.5; // 0.5 for rounding
399
400       cave->slime_predictable = FALSE;
401
402       for (i = 0; i < 5; i++)
403         cave->level_slime_permeability[i] = 1E6 / data[9 * c + datapos] + 0.5;   // 0.5 for rounding
404
405       // probability -> *1E6
406       cave->acid_spread_ratio = 1E6 / data[10 * c + datapos] + 0.5;
407
408       // br only allowed values 1..8 in here, but works the same way. prob -> *1E6
409       cave->pushing_stone_prob = 1E6 / data[11 * c + datapos] + 0.5;
410
411       cave->magic_wall_stops_amoeba = (data[12 * c + datapos + 1] != 0);
412       cave->intermission = (cavenum >= 16 || data[14 * c + datapos + 1] != 0);
413
414       // colors
415       colind = data[31 * c + datapos] % ARRAY_SIZE(brc_color_table);
416       cave->colorb = 0x000000;    // fixed rgb black
417       cave->color0 = 0x000000;    // fixed rgb black
418       cave->color1 = brc_color_table[colind];
419       cave->color2 = brc_color_table_comp[colind];    // complement
420       cave->color3 = 0xffffff;    // white for brick
421       cave->color4 = 0xe5ad23;    // fixed for amoeba
422       cave->color5 = 0x8af713;    // fixed for slime
423
424       if (import_effect)
425       {
426         cave->amoeba_enclosed_effect = brc_effect(data[14 * c + datapos + 1]);
427         cave->amoeba_too_big_effect  = brc_effect(data[15 * c + datapos + 1]);
428         cave->explosion_effect       = brc_effect(data[16 * c + datapos + 1]);
429         cave->bomb_explosion_effect  = brc_effect(data[17 * c + datapos + 1]);
430
431         // 18 solid bomb explode to
432         cave->diamond_birth_effect    = brc_effect(data[19 * c + datapos + 1]);
433         cave->stone_bouncing_effect   = brc_effect(data[20 * c + datapos + 1]);
434         cave->diamond_bouncing_effect = brc_effect(data[21 * c + datapos + 1]);
435         cave->magic_diamond_to        = brc_effect(data[22 * c + datapos + 1]);
436         cave->acid_eats_this          = brc_effect(data[23 * c + datapos + 1]);
437
438         /*
439           slime eats:
440           (diamond,boulder,bomb),
441           (diamond,boulder),
442           (diamond,bomb),
443           (boulder,bomb)
444         */
445         cave->amoeba_enclosed_effect = brc_effect(data[14 * c + datapos + 1]);
446       }
447     }
448   }
449
450   // put them in the caveset - take correct order into consideration.
451   for (level = 0; level < 5; level++)
452   {
453     int cavenum;
454
455     for (cavenum = 0; cavenum < 20; cavenum++)
456     {
457       static const int reorder[] =
458       {
459         0, 1, 2, 3, 16, 4, 5, 6, 7, 17, 8, 9, 10, 11, 18, 12, 13, 14, 15, 19
460       };
461       GdCave *cave = imported[level * 20 + reorder[cavenum]];
462       boolean only_dirt;
463       int x, y;
464
465       // check if cave contains only dirt.
466       // that is an empty cave, and do not import.
467       only_dirt = TRUE;
468
469       for (y = 1; y < cave->h - 1 && only_dirt; y++)
470         for (x = 1; x < cave->w - 1 && only_dirt; x++)
471           if (cave->map[y][x] != O_DIRT)
472             only_dirt = FALSE;
473
474       // append to caveset or forget it.
475       if (!only_dirt)
476         gd_caveset = list_append(gd_caveset, cave);
477       else
478         gd_cave_free(cave);
479     }
480   }
481 }
482
483 static void caveset_name_set_from_filename(char *filename)
484 {
485   char *name;
486   char *c;
487
488   // make up a caveset name from the filename.
489   name = getBaseName(filename);
490   gd_strcpy(gd_caveset_data->name, name);
491   free(name);
492
493   // convert underscores to spaces
494   while ((c = strchr (gd_caveset_data->name, '_')) != NULL)
495     *c = ' ';
496
497   // remove extension
498   if ((c = strrchr (gd_caveset_data->name, '.')) != NULL)
499     *c = 0;
500 }
501
502 /*
503   Load caveset from file.
504   Loads the caveset from a file.
505
506   File type is autodetected by extension.
507   param filename: Name of file.
508   result: FALSE if failed
509 */
510 boolean gd_caveset_load_from_file(char *filename)
511 {
512   size_t length;
513   char *buf;
514   List *new_caveset;
515   struct stat st;
516   File *file;
517
518   if (stat(filename, &st) != 0)
519   {
520     Warn("cannot stat() file");
521
522     return FALSE;
523   }
524
525   if (st.st_size > 1048576)
526   {
527     Warn("file bigger than 1MiB, refusing to load");
528
529     return FALSE;
530   }
531
532   if (!(file = openFile(filename, MODE_READ)))
533   {
534     Warn("cannot open file '%s'", filename);
535
536     return FALSE;
537   }
538
539   buf = checked_malloc(st.st_size + 1);
540   length = readFile(file, buf, 1, st.st_size);
541   buf[length] = '\0';
542
543   closeFile(file);
544
545   if (length < st.st_size)
546   {
547     Warn("cannot read file '%s'", filename);
548
549     return FALSE;
550   }
551
552   if (strSuffix(filename, ".brc") ||
553       strSuffix(filename, ".BRC"))
554   {
555     // loading a boulder remake file
556     if (length != 96000)
557     {
558       Warn("BRC files must be 96000 bytes long");
559
560       return FALSE;
561     }
562   }
563
564   if (strSuffix(filename, ".brc") ||
565       strSuffix(filename, ".BRC"))
566   {
567     brc_import((byte *) buf);
568     gd_caveset_edited = FALSE;    // newly loaded cave is not edited
569     gd_caveset_last_selected = caveset_first_selectable_cave_index();
570     gd_caveset_last_selected_level = 0;
571     free(buf);
572     caveset_name_set_from_filename(filename);
573
574     return TRUE;
575   }
576
577   // BDCFF
578   if (gd_caveset_imported_get_format((byte *) buf) == GD_FORMAT_UNKNOWN)
579   {
580     // try to load as bdcff
581     boolean result;
582
583     // bdcff: start another function
584     result = gd_caveset_load_from_bdcff(buf);
585
586     // newly loaded file is not edited.
587     gd_caveset_edited = FALSE;
588
589     gd_caveset_last_selected = caveset_first_selectable_cave_index();
590     gd_caveset_last_selected_level = 0;
591     free(buf);
592
593     return result;
594   }
595
596   // try to load as a binary file, as we know the format
597   new_caveset = gd_caveset_import_from_buffer ((byte *) buf, length);
598   free(buf);
599
600   // if unable to load, exit here. error was reported by import_from_buffer()
601   if (!new_caveset)
602     return FALSE;
603
604   // no serious error :)
605
606   // only clear caveset here. if file read was unsuccessful, caveset remains in memory.
607   gd_caveset_clear();
608
609   gd_caveset = new_caveset;
610
611   // newly loaded cave is not edited
612   gd_caveset_edited = FALSE;
613
614   gd_caveset_last_selected = caveset_first_selectable_cave_index();
615   gd_caveset_last_selected_level = 0;
616   caveset_name_set_from_filename(filename);
617
618   return TRUE;
619 }
620
621 boolean gd_caveset_save_to_file(const char *filename)
622 {
623   GdPtrArray *saved = gd_caveset_save_to_bdcff();
624   boolean success;
625   File *file;
626   int i;
627
628   if ((file = openFile(filename, MODE_WRITE)) != NULL)
629   {
630     for (i = 0; i < saved->size; i++)
631     {
632       writeFile(file, saved->data[i], 1, strlen(saved->data[i]));
633       writeFile(file, "\n", 1, 1);
634     }
635
636     closeFile(file);
637
638     // remember that it is saved
639     gd_caveset_edited = FALSE;
640
641     success = TRUE;
642   }
643   else
644   {
645     Warn("cannot open file '%s'", filename);
646
647     success = FALSE;
648   }
649
650   gd_ptr_array_free(saved, TRUE);
651
652   return success;
653 }
654
655
656 int gd_cave_check_replays(GdCave *cave, boolean report, boolean remove, boolean repair)
657 {
658   List *riter;
659   int wrong = 0;
660
661   riter = cave->replays;
662   while (riter != NULL)
663   {
664     GdReplay *replay = (GdReplay *)riter->data;
665     unsigned int checksum;
666     GdCave *rendered;
667     List *next = riter->next;
668
669     rendered = gd_cave_new_rendered(cave, replay->level, replay->seed);
670     checksum = gd_cave_adler_checksum(rendered);
671     gd_cave_free(rendered);
672
673     replay->wrong_checksum = FALSE;
674
675     // count wrong ones... the checksum might be changed later to "repair"
676     if (replay->checksum != 0 && checksum != replay->checksum)
677       wrong++;
678
679     if (replay->checksum == 0 || repair)
680     {
681       // if no checksum found, add one. or if repair requested, overwrite old one.
682       replay->checksum = checksum;
683     }
684     else
685     {
686       // if has a checksum, compare with this one.
687       if (replay->checksum != checksum)
688       {
689         replay->wrong_checksum = TRUE;
690
691         if (report)
692           Warn("%s: replay played by %s at %s has wrong checksum",
693                cave->name, replay->player_name, replay->date);
694
695         if (remove)
696         {
697           // may remove
698           cave->replays = list_remove_link(cave->replays, riter);
699           gd_replay_free(replay);
700         }
701       }
702     }
703
704     // advance to next list item which we remembered. the current one might have been deleted
705     riter = next;
706   }
707
708   return wrong;
709 }
710
711 boolean gd_caveset_has_replays(void)
712 {
713   List *citer;
714
715   // for all caves
716   for (citer = gd_caveset; citer != NULL; citer = citer->next)
717   {
718     GdCave *cave = (GdCave *)citer->data;
719
720     if (cave->replays)
721       return TRUE;
722   }
723
724   // if neither of the caves had a replay,
725   return FALSE;
726 }