added button to level editor to set random level colors for BD engine
[rocksndiamonds.git] / src / game_bd / bd_cave.h
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 #ifndef BD_CAVE_H
18 #define BD_CAVE_H
19
20 #include "bd_elements.h"
21 #include "bd_colors.h"
22 #include "bd_random.h"
23
24
25 // ============================================================================
26 // BIG STRUCT HANDLING
27 // ============================================================================
28
29 // possible types handled
30 typedef enum _gd_type
31 {
32   // not real types, only used by editor to build ui
33   GD_TAB,
34   GD_LABEL,
35
36   // gd types
37   GD_TYPE_STRING,               // static string, fixed array of characters
38   GD_TYPE_LONGSTRING,           // long string which has its own notebook page in the editor
39   GD_TYPE_INT,
40   GD_TYPE_RATIO,
41   GD_TYPE_ELEMENT,
42   GD_TYPE_BOOLEAN,
43   GD_TYPE_PROBABILITY,          // probabilities are stored in parts per million,
44                                 // ie. *1E6, converted to int.
45   GD_TYPE_COLOR,
46   GD_TYPE_EFFECT,
47   GD_TYPE_DIRECTION,
48   GD_TYPE_SCHEDULING,
49 } GdType;
50
51 enum _gd_property_flags
52 {
53   GD_ALWAYS_SAVE           = 1 << 0,
54   GD_DONT_SAVE             = 1 << 1,
55   GD_DONT_SHOW_IN_EDITOR   = 1 << 2,
56   GD_SHOW_LEVEL_LABEL      = 1 << 3,
57   GD_COMPATIBILITY_SETTING = 1 << 4,
58 };
59
60 typedef struct _gd_struct_descriptor
61 {
62   char *identifier;             // bdcff identifier
63   GdType type;                  // data type
64   int flags;                    // flags for bdcff saving/loading
65   char *name;                   // name in editor
66   int offset;                   // byte offset in a GdCave structure. use the CAVE_OFFSET macro
67   int count;                    // size of array; usually 1, for non-arrays.
68   char *tooltip;                // tooltip text in editor
69   int min, max;                 // integers have minimum and maximum
70 } GdStructDescriptor;
71
72 typedef struct _gd_property_default
73 {
74   int offset;                   // data offset (bytes) in a cave structure
75   int defval;                   // default value, converted to int. if type is a float, *1000000
76
77   int property_index;           // index in gd_cave_properties; created at runtime
78 } GdPropertyDefault;
79
80
81 void gd_struct_set_defaults_from_array(void *str, const GdStructDescriptor *properties, GdPropertyDefault *defaults);
82
83 // these define the number of the cells in the png file
84 #define GD_NUM_OF_CELLS_X       8
85 #define GD_NUM_OF_CELLS_Y       47
86
87 // +80: placeholder for cells which are rendered by the game;
88 // for example diamond + arrow = falling diamond
89 #define GD_NUM_OF_CELLS         (GD_NUM_OF_CELLS_X * GD_NUM_OF_CELLS_Y + 80)
90
91 // maximum replay size (maximum seconds x game cycles per second)
92 #define MAX_REPLAY_LEN          (10000 * FRAMES_PER_SECOND / 8)
93
94 extern const GdColor gd_flash_color;
95 extern const GdColor gd_select_color;
96
97 enum _element_property
98 {
99   E_P_SLOPED_LEFT,              // stones and diamonds roll down to left on this
100   E_P_SLOPED_RIGHT,             // stones and diamonds roll down to right on this
101   E_P_SLOPED_UP,
102   E_P_SLOPED_DOWN,
103   E_P_BLADDER_SLOPED,           // element act sloped also for the bladder
104
105   E_P_AMOEBA_CONSUMES,          // amoeba can eat this
106   E_P_DIRT,                     // it is dirt, or something similar (dirt2 or sloped dirt)
107   E_P_BLOWS_UP_FLIES,           // flies blow up, if they touch this
108   E_P_EXPLODES_BY_HIT,          // explodes if hit by a stone
109
110   E_P_EXPLOSION,                // set for every stage of every explosion.
111   E_P_EXPLOSION_FIRST_STAGE,    // set for first stage of every explosion.
112                                 // helps slower/faster explosions changing
113
114   E_P_NON_EXPLODABLE,           // selfexplaining
115   E_P_CCW,                      // this creature has a default counterclockwise
116                                 // rotation (for example, o_fire_1)
117   E_P_CAN_BE_HAMMERED,          // can be broken by pneumatic hammer
118   E_P_VISUAL_EFFECT,            // if the element can use a visual effect.
119                                 // used to check consistency of the code
120   E_P_PLAYER,                   // easier to find out if it is a player element
121   E_P_MOVED_BY_CONVEYOR_TOP,    // can be moved by conveyor belt
122   E_P_MOVED_BY_CONVEYOR_BOTTOM, // can be moved UNDER the conveyor belt
123
124   E_P_DIGGABLE,                 // can be digged
125   E_P_COLLECTIBLE,              // can be collected
126   E_P_PUSHABLE,                 // can be pushed
127   E_P_CAN_MOVE,                 // can move
128   E_P_CAN_FALL,                 // can fall
129 };
130
131 // properties
132 #define P_SLOPED_LEFT                   (1 << E_P_SLOPED_LEFT)
133 #define P_SLOPED_RIGHT                  (1 << E_P_SLOPED_RIGHT)
134 #define P_SLOPED_UP                     (1 << E_P_SLOPED_UP)
135 #define P_SLOPED_DOWN                   (1 << E_P_SLOPED_DOWN)
136
137 // flag to say "any direction"
138 #define P_SLOPED                        (P_SLOPED_LEFT  |               \
139                                          P_SLOPED_RIGHT |               \
140                                          P_SLOPED_UP    |               \
141                                          P_SLOPED_DOWN)
142
143 #define P_BLADDER_SLOPED                (1 << E_P_BLADDER_SLOPED)
144
145 #define P_AMOEBA_CONSUMES               (1 << E_P_AMOEBA_CONSUMES)
146 #define P_DIRT                          (1 << E_P_DIRT)
147 #define P_BLOWS_UP_FLIES                (1 << E_P_BLOWS_UP_FLIES)
148
149 #define P_EXPLODES_BY_HIT               (1 << E_P_EXPLODES_BY_HIT)
150 #define P_EXPLOSION                     (1 << E_P_EXPLOSION)
151 #define P_EXPLOSION_FIRST_STAGE         (1 << E_P_EXPLOSION_FIRST_STAGE)
152
153 #define P_NON_EXPLODABLE                (1 << E_P_NON_EXPLODABLE)
154 #define P_CCW                           (1 << E_P_CCW)
155 #define P_CAN_BE_HAMMERED               (1 << E_P_CAN_BE_HAMMERED)
156 #define P_VISUAL_EFFECT                 (1 << E_P_VISUAL_EFFECT)
157 #define P_PLAYER                        (1 << E_P_PLAYER)
158 #define P_MOVED_BY_CONVEYOR_TOP         (1 << E_P_MOVED_BY_CONVEYOR_TOP)
159 #define P_MOVED_BY_CONVEYOR_BOTTOM      (1 << E_P_MOVED_BY_CONVEYOR_BOTTOM)
160
161 #define P_DIGGABLE                      (1 << E_P_DIGGABLE)
162 #define P_COLLECTIBLE                   (1 << E_P_COLLECTIBLE)
163 #define P_PUSHABLE                      (1 << E_P_PUSHABLE)
164 #define P_CAN_MOVE                      (1 << E_P_CAN_MOVE)
165 #define P_CAN_FALL                      (1 << E_P_CAN_FALL)
166
167 // These are states of the magic wall.
168 typedef enum _magic_wall_state
169 {
170   GD_MW_DORMANT,                // Starting with this.
171   GD_MW_ACTIVE,                 // Boulder or diamond dropped into.
172   GD_MW_EXPIRED                 // Turned off after magic_wall_milling_time.
173 } GdMagicWallState;
174
175 // These are states of Player.
176 typedef enum _player_state
177 {
178   GD_PL_NOT_YET,                // Not yet living. Beginning of cave time.
179   GD_PL_LIVING,                 // Ok.
180   GD_PL_TIMEOUT,                // Time is up
181   GD_PL_DIED,                   // Died.
182   GD_PL_EXITED                  // Exited the cave, proceed to next one
183 } GdPlayerState;
184
185 // States of amoeba
186 typedef enum _amoeba_state
187 {
188   GD_AM_SLEEPING,               // sleeping - not yet let out.
189   GD_AM_AWAKE,                  // living, growing
190   GD_AM_TOO_BIG,                // grown too big, will convert to stones
191   GD_AM_ENCLOSED,               // enclosed, will convert to diamonds
192 } GdAmoebaState;
193
194 typedef enum _direction
195 {
196   // not moving
197   GD_MV_STILL           = 0,
198   GD_MV_THIS            = 0,
199
200   // directions
201   GD_MV_UP              = 1,
202   GD_MV_UP_RIGHT        = 2,
203   GD_MV_RIGHT           = 3,
204   GD_MV_DOWN_RIGHT      = 4,
205   GD_MV_DOWN            = 5,
206   GD_MV_DOWN_LEFT       = 6,
207   GD_MV_LEFT            = 7,
208   GD_MV_UP_LEFT         = 8,
209
210   // to be able to type GD_MV_TWICE + GD_MV_DOWN, for example
211   GD_MV_TWICE           = 8,
212
213   // directions * 2
214   GD_MV_UP_2            = 9,
215   GD_MV_UP_RIGHT_2      = 10,
216   GD_MV_RIGHT_2         = 11,
217   GD_MV_DOWN_RIGHT_2    = 12,
218   GD_MV_DOWN_2          = 13,
219   GD_MV_DOWN_LEFT_2     = 14,
220   GD_MV_LEFT_2          = 15,
221   GD_MV_UP_LEFT_2       = 16,
222
223   GD_MV_MAX,
224 } GdDirection;
225
226 enum
227 {
228   GD_REPLAY_MOVE_MASK    = 0x0f,
229   GD_REPLAY_FIRE_MASK    = 0x10,
230   GD_REPLAY_SUICIDE_MASK = 0x20,
231 };
232
233
234 // ELEMENTS DESCRIPTION
235 typedef struct _elements
236 {
237   GdElement element;            // element number. for example O_DIRT
238   char *name;                   // name in editor, for example "Dirt". some have
239                                 // different names than their real engine meaning!
240   unsigned int properties;      // engine properties, like P_SLOPED or P_EXPLODES
241   char *filename;               // name in bdcff file, like "DIRT"
242   char character;               // character representation in bdcff file, like '.'
243   int image;                    // image in editor (index in cells.png)
244   int image_simple;             // image in editor (index in cells.png) (simple view / combo box)
245   int image_game;               // image for game. negative if animated
246   int ckdelay;                  // ckdelay ratio - how much time required for a c64 to
247                                 // process this element - in microseconds.
248
249   char *lowercase_name;         // lowercase of translated name. for editor;
250                                 // generated inside the game.
251   char character_new;           // character given automatically for elements which
252                                 // don't have one defined in original bdcff description
253 } GdElements;
254
255
256 typedef char GdString[MAX_LINE_LEN];
257
258 typedef struct _highscore
259 {
260   GdString name;
261   int score;
262 } GdHighScore;
263
264 typedef struct _replay_movements
265 {
266   unsigned char data[MAX_REPLAY_LEN];
267   unsigned int len;
268 } GdReplayMovements;
269
270 // maximum seed value for the cave random generator. should be smaller than a signed int.
271 #define GD_CAVE_SEED_MAX        (1 << 30)
272
273 typedef struct _gd_cave_replay
274 {
275   int level;                    // replay for level n
276   unsigned int seed;            // seed the cave is to be rendered with
277   boolean saved;                // also store it in the saved bdcff
278   GdString recorded_with;       // recorded with - application name and version
279
280   GdString player_name;         // who played this
281   GdString date;                // when played
282   char *comment;                // some comments from the player
283
284   int score;                    // score collected
285   int duration;                 // number of seconds played
286   boolean success;              // successful playing of cave?
287   unsigned int checksum;        // checksum of the rendered cave.
288
289   boolean wrong_checksum;
290   GdReplayMovements *movements;
291   int current_playing_pos;
292 } GdReplay;
293
294 typedef enum _gd_scheduling
295 {
296   GD_SCHEDULING_MILLISECONDS,
297   GD_SCHEDULING_BD1,
298   GD_SCHEDULING_BD2,
299   GD_SCHEDULING_PLCK,
300   GD_SCHEDULING_CRDR,
301   GD_SCHEDULING_BD1_ATARI,
302   GD_SCHEDULING_BD2_PLCK_ATARI,
303   GD_SCHEDULING_MAX
304 } GdScheduling;
305
306 typedef struct _gd_c64_random_generator
307 {
308   int rand_seed_1, rand_seed_2;
309 } GdC64RandomGenerator;
310
311 // ----------------------------------------------------------------------------
312 // Structure holding all data belonging to a cave.
313 // ----------------------------------------------------------------------------
314
315 #define GD_HIGHSCORE_NUM 20
316
317 typedef struct _gd_cave
318 {
319   // Defined by the editor. public data :)
320   GdString name;                        // name of cave
321   GdString description;                 // some words about the cave
322   GdString author;                      // author
323   GdString difficulty;                  // difficulty of the game, for info purposes
324   GdString www;                         // link to author's webpage
325   GdString date;                        // date of creation
326   char *story;                          // story for the cave - will be shown when cave is played.
327   char *remark;                         // some note
328
329   GdString charset;                     // these are not used by gdash
330   GdString fontset;
331
332   // and this one the highscores
333   GdHighScore highscore[GD_HIGHSCORE_NUM];
334
335   HashTable *tags;                      // stores read-but-not-understood strings from bdcff,
336                                         // so we can save them later.
337
338   GdElement **map;                      // pointer to data for map, non-null if has a map
339   List *objects;
340   List *replays;
341
342   boolean intermission;                 // is this cave an intermission?
343   boolean intermission_instantlife;     // one life extra, if the intermission is reached
344   boolean intermission_rewardlife;      // one life extra, if the intermission is finished
345   boolean selectable;                   // is this selectable as an initial cave for a game?
346   boolean diagonal_movements;           // are diagonal movements allowed?
347   GdElement snap_element;               // snapping (press fire+move) usually leaves space behind,
348                                         // but can be other
349   boolean short_explosions;             // in >= 1stb, diamond/creature explosions were of 5 stages
350
351   GdScheduling scheduling;              // scheduling type; see above
352   boolean pal_timing;                   // use faster seconds
353
354   boolean active_is_first_found;        // active player is the uppermost.
355   boolean lineshift;                    // true is line shifting emulation,
356                                         // false is perfect borders emulation
357   boolean border_scan_first_and_last;   // if true, scans the first and last line of the border.
358                                         // false for plck
359   boolean wraparound_objects;           // if this is true, object drawing (cave rendering)
360                                         // will wraparound as well.
361
362   GdElement initial_fill;
363   GdElement initial_border;
364   GdElement random_fill[4];             // Random fill elements.
365   int random_fill_probability[4];       // Random fill, probability of each element.
366
367   int level_rand[5];                    // Random seed.
368   int level_diamonds[5];                // Must collect diamonds, on level x
369   int level_speed[5];                   // Time between game cycles in ms
370   int level_ckdelay[5];                 // Timing in original game units
371   int level_time[5];                    // Available time, per level
372   int level_timevalue[5];               // points for each second remaining, when exiting level
373
374   int max_time;                         // the maximum time in seconds. if above, it overflows
375
376   int w, h;                             // Sizes of cave, width and height.
377   int x1,y1,x2,y2;                      // Visible part of the cave
378   GdColor colorb;                       // border color
379   GdColor color0, color1, color2, color3, color4, color5;    // c64-style colors;
380                                                              // color 4 and 5 are amoeba and slime.
381
382   int diamond_value;                    // Score for a diamond.
383   int extra_diamond_value;              // Score for a diamond, when gate is open.
384
385   boolean stone_sound;
386   boolean nut_sound;
387   boolean diamond_sound;
388   boolean nitro_sound;
389   boolean falling_wall_sound;
390   boolean expanding_wall_sound;
391   boolean bladder_spender_sound;
392   boolean bladder_convert_sound;
393
394   int level_magic_wall_time[5];         // magic wall 'on' state for each level (seconds)
395   boolean magic_wall_stops_amoeba;      // Turning on magic wall changes amoeba to diamonds.
396                                         // Original BD: yes, constkit: no
397   boolean magic_wall_breakscan;         // Currently this setting enabled will turn the amoeba to
398                                         // an enclosed state. To implement buggy BD1 behaviour.
399   boolean magic_timer_zero_is_infinite; // magic wall timer 0 is interpreted as infinite
400   boolean magic_timer_wait_for_hatching;// magic wall timer does not start before player's birth
401   boolean magic_wall_sound;             // magic wall has sound
402
403   int level_amoeba_time[5];             // amoeba time for each level
404   int amoeba_growth_prob;               // Amoeba slow growth probability
405   int amoeba_fast_growth_prob;          // Amoeba fast growth probability
406   int level_amoeba_threshold[5];        // amoeba turns to stones; if count is bigger than this
407                                         // (number of cells)
408   GdElement amoeba_enclosed_effect;     // an enclosed amoeba converts to this element
409   GdElement amoeba_too_big_effect;      // an amoeba grown too big converts to this element
410
411   int level_amoeba_2_time[5];           // amoeba time for each level
412   int amoeba_2_growth_prob;             // Amoeba slow growth probability
413   int amoeba_2_fast_growth_prob;        // Amoeba fast growth probability
414   int level_amoeba_2_threshold[5];      // amoeba turns to stones; if count is bigger than this
415                                         // (number of cells)
416   GdElement amoeba_2_enclosed_effect;   // an enclosed amoeba converts to this element
417   GdElement amoeba_2_too_big_effect;    // an amoeba grown too big converts to this element
418   boolean amoeba_2_explodes_by_amoeba;  // amoeba 2 will explode if touched by amoeba1
419   GdElement amoeba_2_explosion_effect;  // amoeba 2 explosion ends in ...
420   GdElement amoeba_2_looks_like;        // an amoeba 2 looks like this element
421
422   boolean amoeba_timer_started_immediately; // FALSE: amoeba will start life at the first
423                                             //        possibility of growing.
424   boolean amoeba_timer_wait_for_hatching;   // amoeba timer does not start before player's birth
425   boolean amoeba_sound;                 // if the living amoeba has sound.
426
427   GdElement acid_eats_this;             // acid eats this element
428   int acid_spread_ratio;                // Probability of acid blowing up, each frame
429   boolean acid_spread_sound;            // acid has sound
430   GdElement acid_turns_to;              // whether acid converts to explosion on spreading or other
431
432   GdElement nut_turns_to_when_crushed;  // when nut is hit by stone, it converts to this element
433
434   int level_slime_permeability[5];      // true random slime
435   int level_slime_permeability_c64[5];  // Appearing in bd 2
436   int level_slime_seed_c64[5];          // predictable slime random seed
437   boolean slime_predictable;            // predictable random start for slime. yes for plck.
438   boolean slime_correct_random;         // correct random number generator for rendered caves
439   GdElement slime_eats_1, slime_converts_1; // slime eats element x and converts to element x;
440                                             // for example diamond -> falling diamond
441   GdElement slime_eats_2, slime_converts_2; // this is usually stone -> stone_f
442   GdElement slime_eats_3, slime_converts_3; // this is usually nut -> nut_f
443   boolean slime_sound;                  // slime has sound
444
445   boolean lava_sound;                   // elements sinking in lava have sound
446
447   int level_hatching_delay_frame[5];    // Scan frames before Player's birth.
448   int level_hatching_delay_time[5];     // Scan frames before Player's birth.
449
450   int level_bonus_time[5];              // bonus time for clock collected.
451   int level_penalty_time[5];            // Time penalty when voodoo destroyed.
452   boolean voodoo_collects_diamonds;     // Voodoo can collect diamonds
453   boolean voodoo_dies_by_stone;         // Voodoo can be killed by a falling stone
454   boolean voodoo_disappear_in_explosion;// Voodoo can be destroyed by and explosion
455   boolean voodoo_any_hurt_kills_player; // If any voodoo hurt in any way, player is killed.
456
457   boolean water_does_not_flow_down;     // if true, water will not grow downwards,
458                                         // only in other directions.
459   boolean water_sound;                  // water has sound
460
461   boolean bladder_sound;                // bladder moving and pushing has sound
462   GdElement bladder_converts_by;        // bladder converts to clock by touching this element
463
464   int biter_delay_frame;                // frame count biters do move
465   GdElement biter_eat;                  // biters eat this
466   boolean biter_sound;                  // biters have sound
467
468   boolean expanding_wall_changed;       // expanding wall direction is changed
469
470   int    replicator_delay_frame;        // replicator delay in frames (number of frames
471                                         // to wait between creating a new element)
472   boolean replicators_active;           // replicators are active.
473   boolean replicator_sound;             // when replicating an element, play sound or not.
474
475   boolean conveyor_belts_active;
476   boolean conveyor_belts_direction_changed;
477
478   // effects
479   GdElement explosion_effect;           // explosion converts to this element after its last stage.
480                                         // diego effect.
481   GdElement diamond_birth_effect;       // a diamond birth converts to this element after its last
482                                         // stage. diego effect.
483   GdElement bomb_explosion_effect;      // bombs explode to this element. diego effect (almost).
484   GdElement nitro_explosion_effect;     // nitros explode to this
485
486   GdElement firefly_explode_to;         // fireflies explode to this when hit by stone
487   GdElement alt_firefly_explode_to;     // alternative fireflies explode to this when hit by stone
488   GdElement butterfly_explode_to;       // butterflies explode to this when hit by stone
489   GdElement alt_butterfly_explode_to;   // alternative butterflies explode to this when hit by stone
490   GdElement stonefly_explode_to;        // stoneflies explode to this when hit by stone
491   GdElement dragonfly_explode_to;       // dragonflies explode to this when hit by stone
492
493   GdElement stone_falling_effect;       // falling stone converts to this element. diego effect.
494   GdElement diamond_falling_effect;     // falling diamond converts to this element. diego effect.
495   GdElement stone_bouncing_effect;      // bouncing stone converts to this element. diego effect.
496   GdElement diamond_bouncing_effect;    // bouncing diamond converts to this element. diego effect.
497
498   GdElement expanding_wall_looks_like;  // an expanding wall looks like this element. diego effect.
499   GdElement dirt_looks_like;            // dirt looks like this element. diego effect.
500
501   GdElement magic_stone_to;             // magic wall converts falling stone to
502   GdElement magic_diamond_to;           // magic wall converts falling diamond to
503   GdElement magic_mega_stone_to;        // magic wall converts a falling mega stone to
504   GdElement magic_nitro_pack_to;        // magic wall converts a falling nitro pack to
505   GdElement magic_nut_to;               // magic wall converts a falling nut to
506   GdElement magic_flying_stone_to;      // flying stones are converted to
507   GdElement magic_flying_diamond_to;    // flying diamonds are converted to
508
509   int pushing_stone_prob;               // probability of pushing stone
510   int pushing_stone_prob_sweet;         // probability of pushing, after eating sweet
511   boolean mega_stones_pushable_with_sweet; // mega stones may be pushed with sweet
512
513   boolean creatures_backwards;          // creatures changed direction
514   boolean creatures_direction_auto_change_on_start; // the change occurs also at the start signal
515   int creatures_direction_auto_change_time; // creatures automatically change direction every x
516                                             // seconds
517   boolean creature_direction_auto_change_sound; // automatically changing creature direction may
518                                                 // have the sound of the creature dir switch
519
520   int skeletons_needed_for_pot;         // how many skeletons to be collected, to use a pot
521   int skeletons_worth_diamonds;         // for crazy dream 7 compatibility: collecting skeletons
522                                         // might open the cave door.
523
524   GdDirection gravity;
525   int gravity_change_time;
526   boolean gravity_change_sound;
527   boolean gravity_affects_all;          // if true, gravity also affects falling wall, bladder
528                                         // and waiting stones
529   boolean gravity_switch_active;        // true if gravity switch is activated, and can be used.
530
531   boolean hammered_walls_reappear;
532   int pneumatic_hammer_frame;
533   int hammered_wall_reappear_frame;
534   boolean pneumatic_hammer_sound;
535
536   boolean infinite_rockets;             // if true, the player which got a rocket launcher will be
537                                         // able to launch an infinite number of rockets
538
539   // internal variables, used during the game. private data :)
540
541   // returns range corrected x/y position (points to perfect or line shifting get function)
542   int (*getx) (const struct _gd_cave*, int x, int y);
543   int (*gety) (const struct _gd_cave*, int x, int y);
544
545   // returns pointer to element at x, y (points to perfect border or a line shifting get function)
546   GdElement* (*getp) (const struct _gd_cave*, int x, int y);
547
548   boolean hatched;                      // hatching has happened. (timers may run, ...)
549   boolean gate_open;                    // self-explaining
550   unsigned int render_seed;             // the seed value, which was used to render the cave,
551                                         // is saved here. will be used by record&playback
552   GdRand *random;                       // random number generator of rendered cave
553   int rendered;                         // if not zero, rendered at level x
554   int timing_factor;                    // number of "milliseconds" in each second :)
555                                         // 1000 for ntsc, 1200 for pal.
556   void ***objects_order;                // two-dimensional map of cave; each cell is a pointer
557                                         // to the drawing object, which created this element.
558                                         // NULL if map or random.
559   int **hammered_reappear;              // integer map of cave; if non-zero, a brick wall will
560                                         // appear there
561
562   int speed;                            // Time between game cycles in ms
563   int c64_timing;                       // a ckdelay value for the level this cave is rendered for
564   int ckdelay;                          // ckdelay value for the current iteration
565   int ckdelay_extra_for_animation;      // bd1 and similar engines had animation bits in cave data,
566                                         // to set which elements to animate (firefly, butterfly,
567                                         // amoeba).
568                                         // animating an element also caused some delay each frame;
569                                         //  according to my measurements, around 2.6 ms/element.
570
571   int frame;  // XXX
572
573   int hatching_delay_frame;
574   int hatching_delay_time;
575   int time_bonus;                       // bonus time for clock collected.
576   int time_penalty;                     // Time penalty when voodoo destroyed.
577   int time;                             // milliseconds remaining to finish cave
578   int timevalue;                        // points for remaining seconds - for current level
579   int diamonds_needed;                  // diamonds needed to open outbox
580   int diamonds_collected;               // diamonds collected
581   int skeletons_collected;              // number of skeletons collected
582   int gate_open_flash;                  // flashing of screen when gate opens
583   int score;                            // Score got this frame.
584   int amoeba_time;                      // Amoeba growing slow (low probability, default 3%) for
585                                         // milliseconds. After that, fast growth default (25%)
586   int amoeba_2_time;                    // Amoeba growing slow (low probability, default 3%) for
587                                         // milliseconds. After that, fast growth default (25%)
588   int amoeba_max_count;                 // selected amoeba 1 threshold for this level
589   int amoeba_2_max_count;               // selected amoeba 2 threshold for this level
590   GdAmoebaState amoeba_state;           // state of amoeba 1
591   GdAmoebaState amoeba_2_state;         // state of amoeba 2
592   boolean convert_amoeba_this_frame;    // To implement BD1 buggy amoeba+magic wall behaviour.
593   int magic_wall_time;                  // magic wall 'on' state for seconds
594   int slime_permeability;               // true random slime
595   int slime_permeability_c64;           // Appearing in bd 2
596   GdMagicWallState magic_wall_state;    // State of magic wall
597   GdPlayerState player_state;           // Player state. not yet living, living, exited...
598   int player_seen_ago;                  // player was seen this number of scans ago
599   boolean voodoo_touched;               // as its name says
600   boolean kill_player;                  // Voodoo died, or used pressed escape to restart level.
601   boolean sweet_eaten;                  // player ate sweet, he's strong. prob_sweet applies,
602                                         // and also able to push chasing stones
603   int player_x, player_y;               // Coordinates of player (for scrolling)
604   int px[16], py[16];                   // coordinates of player, for chasing stone
605   int key1, key2, key3;                 // The player is holding this number of keys of each color
606   boolean diamond_key_collected;        // Key collected, so trapped diamonds convert to diamonds
607   boolean inbox_flash_toggle;           // negated every scan. helps drawing inboxes, and making
608                                         // players be born at different times.
609   GdDirection last_direction;           // last direction player moved. used by draw routines
610   GdDirection last_horizontal_direction;
611   int biters_wait_frame;                // number of frames to wait until biters will move again
612   int replicators_wait_frame;           // number of frames to wait until replicators are
613                                         // activated again
614   int creatures_direction_will_change;  // creatures automatically change direction every x seconds
615   GdC64RandomGenerator c64_rand;        // used for predictable random generator during the game.
616
617   int gravity_will_change;              // gravity will change in this number of milliseconds
618   boolean gravity_disabled;             // when player is stirring the pot, there is no gravity.
619   GdDirection gravity_next_direction;   // next direction when the gravity changes.
620                                         // will be set by the player "getting" a gravity switch
621   boolean got_pneumatic_hammer;         // true if the player has a pneumatic hammer
622   int pneumatic_hammer_active_delay;    // number of frames to wait, till pneumatic hammer will
623                                         // destroy the wall
624   GdSound sound1, sound2, sound3;       // sound set for 3 channels after each iteration
625 } GdCave;
626
627
628 #define CAVE_OFFSET(property) (STRUCT_OFFSET(GdCave, property))
629
630 // arrays for movements
631 // also no1 and bd2 cave data import helpers; line direction coordinates
632 extern const int gd_dx[], gd_dy[];
633
634 extern GdElement gd_char_to_element[];
635
636 void gd_create_char_to_element_table(void);
637 GdElement gd_get_element_from_character(unsigned char character);
638 GdElement gd_get_element_from_string(const char *string);
639
640 // init cave engine
641 void gd_cave_init(void);
642
643 // for cave tags hash table
644 int gd_str_case_equal(void *s1, void *s2);
645 unsigned int gd_str_case_hash(void *v);
646
647 // cave highscore functions
648 int gd_highscore_compare(const void *a, const void *b);
649 boolean gd_is_highscore(GdHighScore *scores, int score);
650 int gd_add_highscore(GdHighScore *highscores, const char *name, int score);
651 void gd_clear_highscore(GdHighScore *hs);
652 boolean gd_has_highscore(GdHighScore *hs);
653
654 // cave creator and destructor functions
655 GdCave *gd_cave_new(void);
656 GdCave *gd_cave_new_from_cave(const GdCave *orig);
657 void gd_cave_copy(GdCave *dest, const GdCave *src);
658 void gd_cave_free(GdCave *cave);
659
660 // cave manipulation
661 void gd_cave_set_gdash_defaults(GdCave *cave);
662 void gd_cave_set_defaults_from_array(GdCave* cave, GdPropertyDefault *defaults);
663 void gd_cave_correct_visible_size(GdCave *cave);
664 void gd_cave_set_random_colors(GdCave *cave, GdColorType type);
665 void gd_cave_auto_shrink(GdCave *cave);
666
667 void gd_cave_setup_for_game(GdCave *cave);
668 void gd_cave_count_diamonds(GdCave *cave);
669
670 // c64 random generator support for cave fill
671 unsigned int gd_c64_random(GdC64RandomGenerator *rand);
672 unsigned int gd_cave_c64_random(GdCave *);
673 void gd_c64_random_set_seed(GdC64RandomGenerator *rand, int seed1, int seed2);
674 void gd_cave_c64_random_set_seed(GdCave *cave, int seed1, int seed2);
675 void gd_cave_set_random_c64_colors(GdCave *cave);
676
677 // support
678 void *gd_cave_map_new_for_cave(const GdCave *cave, const int cell_size);
679 void *gd_cave_map_dup_size(const GdCave * cave, const void *map, const int cell_size);
680 #define gd_cave_map_new(CAVE, TYPE) ((TYPE **)gd_cave_map_new_for_cave((CAVE), sizeof(TYPE)))
681 #define gd_cave_map_dup(CAVE, MAP) ((void *)gd_cave_map_dup_size((CAVE), (void **)(CAVE)->MAP, sizeof((CAVE)->MAP[0][0])))
682 void gd_cave_map_free(void *map);
683
684 void gd_cave_store_rc(GdCave * cave, int x, int y, const GdElement element, const void* order);
685 GdElement gd_cave_get_rc (const GdCave *cave, int x, int y);
686
687 // direction
688 const char *gd_direction_get_visible_name(GdDirection dir);
689 const char *gd_direction_get_filename(GdDirection dir);
690 GdDirection gd_direction_from_string(const char *str);
691
692 // scheduling
693 const char *gd_scheduling_get_visible_name(GdScheduling sched);
694 const char *gd_scheduling_get_filename(GdScheduling sched);
695 GdScheduling gd_scheduling_from_string(const char *str);
696
697 // game playing helpers
698 #define GD_REDRAW (1 << 10)
699
700 void gd_drawcave_game(const GdCave *cave, int **element_buffer, int **gfx_buffer,
701                       boolean bonus_life_flash, int animcycle, boolean hate_invisible_outbox);
702
703 // function to copy a GdString
704 static inline char *gd_strcpy(GdString dest, const GdString src)
705 {
706     return strncpy(dest, src, sizeof(GdString));
707 }
708
709 int gd_cave_time_show(const GdCave *cave, int internal_time);
710
711 GdReplay *gd_replay_new(void);
712 GdReplay *gd_replay_new_from_replay(GdReplay *orig);
713 void gd_replay_free(GdReplay *replay);
714 void gd_replay_store_movement(GdReplay *replay, GdDirection player_move, boolean player_fire, boolean suicide);
715
716 unsigned int gd_cave_adler_checksum(GdCave *cave);
717 void gd_cave_adler_checksum_more(GdCave *cave, unsigned int *a, unsigned int *b);
718
719 #endif  // BD_CAVE_H