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