2 * Copyright (c) 2007, 2008, 2009, Czirkos Zoltan <cirix@fw.hu>
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.
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.
20 #include "bd_elements.h"
21 #include "bd_colors.h"
22 #include "bd_random.h"
25 // ============================================================================
26 // BIG STRUCT HANDLING
27 // ============================================================================
29 // possible types handled
32 // not real types, only used by editor to build ui
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
43 GD_TYPE_PROBABILITY, // probabilities are stored in parts per million,
44 // ie. *1E6, converted to int.
51 enum _gd_property_flags
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,
60 typedef struct _gd_struct_descriptor
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
72 typedef struct _gd_property_default
74 int offset; // data offset (bytes) in a cave structure
75 int defval; // default value, converted to int. if type is a float, *1000000
77 int property_index; // index in gd_cave_properties; created at runtime
81 void gd_struct_set_defaults_from_array(void *str, const GdStructDescriptor *properties, GdPropertyDefault *defaults);
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 46
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)
91 // maximum replay size (maximum seconds x game cycles per second)
92 #define MAX_REPLAY_LEN (10000 * FRAMES_PER_SECOND / 8)
94 extern const GdColor gd_flash_color;
95 extern const GdColor gd_select_color;
97 enum _element_property
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
103 E_P_BLADDER_SLOPED, // element act sloped also for the bladder
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
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
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
124 E_P_COLLECTIBLE, // can be collected
128 #define P_SLOPED_LEFT (1 << E_P_SLOPED_LEFT)
129 #define P_SLOPED_RIGHT (1 << E_P_SLOPED_RIGHT)
130 #define P_SLOPED_UP (1 << E_P_SLOPED_UP)
131 #define P_SLOPED_DOWN (1 << E_P_SLOPED_DOWN)
133 // flag to say "any direction"
134 #define P_SLOPED (P_SLOPED_LEFT | \
139 #define P_BLADDER_SLOPED (1 << E_P_BLADDER_SLOPED)
141 #define P_AMOEBA_CONSUMES (1 << E_P_AMOEBA_CONSUMES)
142 #define P_DIRT (1 << E_P_DIRT)
143 #define P_BLOWS_UP_FLIES (1 << E_P_BLOWS_UP_FLIES)
145 #define P_EXPLODES_BY_HIT (1 << E_P_EXPLODES_BY_HIT)
146 #define P_EXPLOSION (1 << E_P_EXPLOSION)
147 #define P_EXPLOSION_FIRST_STAGE (1 << E_P_EXPLOSION_FIRST_STAGE)
149 #define P_NON_EXPLODABLE (1 << E_P_NON_EXPLODABLE)
150 #define P_CCW (1 << E_P_CCW)
151 #define P_CAN_BE_HAMMERED (1 << E_P_CAN_BE_HAMMERED)
152 #define P_VISUAL_EFFECT (1 << E_P_VISUAL_EFFECT)
153 #define P_PLAYER (1 << E_P_PLAYER)
154 #define P_MOVED_BY_CONVEYOR_TOP (1 << E_P_MOVED_BY_CONVEYOR_TOP)
155 #define P_MOVED_BY_CONVEYOR_BOTTOM (1 << E_P_MOVED_BY_CONVEYOR_BOTTOM)
157 #define P_COLLECTIBLE (1 << E_P_COLLECTIBLE)
159 // These are states of the magic wall.
160 typedef enum _magic_wall_state
162 GD_MW_DORMANT, // Starting with this.
163 GD_MW_ACTIVE, // Boulder or diamond dropped into.
164 GD_MW_EXPIRED // Turned off after magic_wall_milling_time.
167 // These are states of Player.
168 typedef enum _player_state
170 GD_PL_NOT_YET, // Not yet living. Beginning of cave time.
172 GD_PL_TIMEOUT, // Time is up
174 GD_PL_EXITED // Exited the cave, proceed to next one
178 typedef enum _amoeba_state
180 GD_AM_SLEEPING, // sleeping - not yet let out.
181 GD_AM_AWAKE, // living, growing
182 GD_AM_TOO_BIG, // grown too big, will convert to stones
183 GD_AM_ENCLOSED, // enclosed, will convert to diamonds
186 typedef enum _direction
196 GD_MV_DOWN_RIGHT = 4,
202 // to be able to type GD_MV_TWICE + GD_MV_DOWN, for example
207 GD_MV_UP_RIGHT_2 = 10,
209 GD_MV_DOWN_RIGHT_2 = 12,
211 GD_MV_DOWN_LEFT_2 = 14,
213 GD_MV_UP_LEFT_2 = 16,
220 GD_REPLAY_MOVE_MASK = 0x0f,
221 GD_REPLAY_FIRE_MASK = 0x10,
222 GD_REPLAY_SUICIDE_MASK = 0x20,
226 // ELEMENTS DESCRIPTION
227 typedef struct _elements
229 GdElement element; // element number. for example O_DIRT
230 char *name; // name in editor, for example "Dirt". some have
231 // different names than their real engine meaning!
232 unsigned int properties; // engine properties, like P_SLOPED or P_EXPLODES
233 char *filename; // name in bdcff file, like "DIRT"
234 char character; // character representation in bdcff file, like '.'
235 int image; // image in editor (index in cells.png)
236 int image_simple; // image in editor (index in cells.png) (simple view / combo box)
237 int image_game; // image for game. negative if animated
238 int ckdelay; // ckdelay ratio - how much time required for a c64 to
239 // process this element - in microseconds.
241 char *lowercase_name; // lowercase of translated name. for editor;
242 // generated inside the game.
243 char character_new; // character given automatically for elements which
244 // don't have one defined in original bdcff description
248 typedef char GdString[128];
250 typedef struct _highscore
256 typedef struct _replay_movements
258 unsigned char data[MAX_REPLAY_LEN];
262 // maximum seed value for the cave random generator. should be smaller than a signed int.
263 #define GD_CAVE_SEED_MAX (1 << 30)
265 typedef struct _gd_cave_replay
267 int level; // replay for level n
268 unsigned int seed; // seed the cave is to be rendered with
269 boolean saved; // also store it in the saved bdcff
270 GdString recorded_with; // recorded with - application name and version
272 GdString player_name; // who played this
273 GdString date; // when played
274 char *comment; // some comments from the player
276 int score; // score collected
277 int duration; // number of seconds played
278 boolean success; // successful playing of cave?
279 unsigned int checksum; // checksum of the rendered cave.
281 boolean wrong_checksum;
282 GdReplayMovements *movements;
283 int current_playing_pos;
286 typedef enum _gd_scheduling
288 GD_SCHEDULING_MILLISECONDS,
293 GD_SCHEDULING_BD1_ATARI,
294 GD_SCHEDULING_BD2_PLCK_ATARI,
298 typedef struct _gd_c64_random_generator
300 int rand_seed_1, rand_seed_2;
301 } GdC64RandomGenerator;
303 // ----------------------------------------------------------------------------
304 // Structure holding all data belonging to a cave.
305 // ----------------------------------------------------------------------------
307 #define GD_HIGHSCORE_NUM 20
309 typedef struct _gd_cave
311 // Defined by the editor. public data :)
312 GdString name; // name of cave
313 GdString description; // some words about the cave
314 GdString author; // author
315 GdString difficulty; // difficulty of the game, for info purposes
316 GdString www; // link to author's webpage
317 GdString date; // date of creation
318 char *story; // story for the cave - will be shown when cave is played.
319 char *remark; // some note
321 GdString charset; // these are not used by gdash
324 // and this one the highscores
325 GdHighScore highscore[GD_HIGHSCORE_NUM];
327 HashTable *tags; // stores read-but-not-understood strings from bdcff,
328 // so we can save them later.
330 GdElement **map; // pointer to data for map, non-null if has a map
334 boolean intermission; // is this cave an intermission?
335 boolean intermission_instantlife; // one life extra, if the intermission is reached
336 boolean intermission_rewardlife; // one life extra, if the intermission is finished
337 boolean selectable; // is this selectable as an initial cave for a game?
338 boolean diagonal_movements; // are diagonal movements allowed?
339 GdElement snap_element; // snapping (press fire+move) usually leaves space behind,
341 boolean short_explosions; // in >= 1stb, diamond/creature explosions were of 5 stages
343 GdScheduling scheduling; // scheduling type; see above
344 boolean pal_timing; // use faster seconds
346 boolean active_is_first_found; // active player is the uppermost.
347 boolean lineshift; // true is line shifting emulation,
348 // false is perfect borders emulation
349 boolean border_scan_first_and_last; // if true, scans the first and last line of the border.
351 boolean wraparound_objects; // if this is true, object drawing (cave rendering)
352 // will wraparound as well.
354 GdElement initial_fill;
355 GdElement initial_border;
356 GdElement random_fill[4]; // Random fill elements.
357 int random_fill_probability[4]; // Random fill, probability of each element.
359 int level_rand[5]; // Random seed.
360 int level_diamonds[5]; // Must collect diamonds, on level x
361 int level_speed[5]; // Time between game cycles in ms
362 int level_ckdelay[5]; // Timing in original game units
363 int level_time[5]; // Available time, per level
364 int level_timevalue[5]; // points for each second remaining, when exiting level
366 int max_time; // the maximum time in seconds. if above, it overflows
368 int w, h; // Sizes of cave, width and height.
369 int x1,y1,x2,y2; // Visible part of the cave
370 GdColor colorb; // border color
371 GdColor color0, color1, color2, color3, color4, color5; // c64-style colors;
372 // color 4 and 5 are amoeba and slime.
374 int diamond_value; // Score for a diamond.
375 int extra_diamond_value; // Score for a diamond, when gate is open.
379 boolean diamond_sound;
381 boolean falling_wall_sound;
382 boolean expanding_wall_sound;
383 boolean bladder_spender_sound;
384 boolean bladder_convert_sound;
386 int level_magic_wall_time[5]; // magic wall 'on' state for each level (seconds)
387 boolean magic_wall_stops_amoeba; // Turning on magic wall changes amoeba to diamonds.
388 // Original BD: yes, constkit: no
389 boolean magic_timer_wait_for_hatching;// magic wall timer does not start before player's birth
390 boolean magic_wall_sound; // magic wall has sound
392 int level_amoeba_time[5]; // amoeba time for each level
393 int amoeba_growth_prob; // Amoeba slow growth probability
394 int amoeba_fast_growth_prob; // Amoeba fast growth probability
395 int level_amoeba_threshold[5]; // amoeba turns to stones; if count is bigger than this
397 GdElement amoeba_enclosed_effect; // an enclosed amoeba converts to this element
398 GdElement amoeba_too_big_effect; // an amoeba grown too big converts to this element
400 int level_amoeba_2_time[5]; // amoeba time for each level
401 int amoeba_2_growth_prob; // Amoeba slow growth probability
402 int amoeba_2_fast_growth_prob; // Amoeba fast growth probability
403 int level_amoeba_2_threshold[5]; // amoeba turns to stones; if count is bigger than this
405 GdElement amoeba_2_enclosed_effect; // an enclosed amoeba converts to this element
406 GdElement amoeba_2_too_big_effect; // an amoeba grown too big converts to this element
407 boolean amoeba_2_explodes_by_amoeba; // amoeba 2 will explode if touched by amoeba1
408 GdElement amoeba_2_explosion_effect; // amoeba 2 explosion ends in ...
409 GdElement amoeba_2_looks_like; // an amoeba 2 looks like this element
411 boolean amoeba_timer_started_immediately; // FALSE: amoeba will start life at the first
412 // possibility of growing.
413 boolean amoeba_timer_wait_for_hatching; // amoeba timer does not start before player's birth
414 boolean amoeba_sound; // if the living amoeba has sound.
416 GdElement acid_eats_this; // acid eats this element
417 int acid_spread_ratio; // Probability of acid blowing up, each frame
418 boolean acid_spread_sound; // acid has sound
419 GdElement acid_turns_to; // whether acid converts to explosion on spreading or other
421 GdElement nut_turns_to_when_crushed; // when nut is hit by stone, it converts to this element
423 int level_slime_permeability[5]; // true random slime
424 int level_slime_permeability_c64[5]; // Appearing in bd 2
425 int level_slime_seed_c64[5]; // predictable slime random seed
426 boolean slime_predictable; // predictable random start for slime. yes for plck.
427 GdElement slime_eats_1, slime_converts_1; // slime eats element x and converts to element x;
428 // for example diamond -> falling diamond
429 GdElement slime_eats_2, slime_converts_2; // this is usually stone -> stone_f
430 GdElement slime_eats_3, slime_converts_3; // this is usually nut -> nut_f
431 boolean slime_sound; // slime has sound
433 boolean lava_sound; // elements sinking in lava have sound
435 int level_hatching_delay_frame[5]; // Scan frames before Player's birth.
436 int level_hatching_delay_time[5]; // Scan frames before Player's birth.
438 int level_bonus_time[5]; // bonus time for clock collected.
439 int level_penalty_time[5]; // Time penalty when voodoo destroyed.
440 boolean voodoo_collects_diamonds; // Voodoo can collect diamonds
441 boolean voodoo_dies_by_stone; // Voodoo can be killed by a falling stone
442 boolean voodoo_disappear_in_explosion;// Voodoo can be destroyed by and explosion
443 boolean voodoo_any_hurt_kills_player; // If any voodoo hurt in any way, player is killed.
445 boolean water_does_not_flow_down; // if true, water will not grow downwards,
446 // only in other directions.
447 boolean water_sound; // water has sound
449 boolean bladder_sound; // bladder moving and pushing has sound
450 GdElement bladder_converts_by; // bladder converts to clock by touching this element
452 int biter_delay_frame; // frame count biters do move
453 GdElement biter_eat; // biters eat this
454 boolean biter_sound; // biters have sound
456 boolean expanding_wall_changed; // expanding wall direction is changed
458 int replicator_delay_frame; // replicator delay in frames (number of frames
459 // to wait between creating a new element)
460 boolean replicators_active; // replicators are active.
461 boolean replicator_sound; // when replicating an element, play sound or not.
463 boolean conveyor_belts_active;
464 boolean conveyor_belts_direction_changed;
467 GdElement explosion_effect; // explosion converts to this element after its last stage.
469 GdElement diamond_birth_effect; // a diamond birth converts to this element after its last
470 // stage. diego effect.
471 GdElement bomb_explosion_effect; // bombs explode to this element. diego effect (almost).
472 GdElement nitro_explosion_effect; // nitros explode to this
474 GdElement firefly_explode_to; // fireflies explode to this when hit by stone
475 GdElement alt_firefly_explode_to; // alternative fireflies explode to this when hit by stone
476 GdElement butterfly_explode_to; // butterflies explode to this when hit by stone
477 GdElement alt_butterfly_explode_to; // alternative butterflies explode to this when hit by stone
478 GdElement stonefly_explode_to; // stoneflies explode to this when hit by stone
479 GdElement dragonfly_explode_to; // dragonflies explode to this when hit by stone
481 GdElement stone_falling_effect; // falling stone converts to this element. diego effect.
482 GdElement diamond_falling_effect; // falling diamond converts to this element. diego effect.
483 GdElement stone_bouncing_effect; // bouncing stone converts to this element. diego effect.
484 GdElement diamond_bouncing_effect; // bouncing diamond converts to this element. diego effect.
486 GdElement expanding_wall_looks_like; // an expanding wall looks like this element. diego effect.
487 GdElement dirt_looks_like; // dirt looks like this element. diego effect.
489 GdElement magic_stone_to; // magic wall converts falling stone to
490 GdElement magic_diamond_to; // magic wall converts falling diamond to
491 GdElement magic_mega_stone_to; // magic wall converts a falling mega stone to
492 GdElement magic_nitro_pack_to; // magic wall converts a falling nitro pack to
493 GdElement magic_nut_to; // magic wall converts a falling nut to
494 GdElement magic_flying_stone_to; // flying stones are converted to
495 GdElement magic_flying_diamond_to; // flying diamonds are converted to
497 int pushing_stone_prob; // probability of pushing stone
498 int pushing_stone_prob_sweet; // probability of pushing, after eating sweet
499 boolean mega_stones_pushable_with_sweet; // mega stones may be pushed with sweet
501 boolean creatures_backwards; // creatures changed direction
502 boolean creatures_direction_auto_change_on_start; // the change occurs also at the start signal
503 int creatures_direction_auto_change_time; // creatures automatically change direction every x
505 boolean creature_direction_auto_change_sound; // automatically changing creature direction may
506 // have the sound of the creature dir switch
508 int skeletons_needed_for_pot; // how many skeletons to be collected, to use a pot
509 int skeletons_worth_diamonds; // for crazy dream 7 compatibility: collecting skeletons
510 // might open the cave door.
513 int gravity_change_time;
514 boolean gravity_change_sound;
515 boolean gravity_affects_all; // if true, gravity also affects falling wall, bladder
516 // and waiting stones
517 boolean gravity_switch_active; // true if gravity switch is activated, and can be used.
519 boolean hammered_walls_reappear;
520 int pneumatic_hammer_frame;
521 int hammered_wall_reappear_frame;
522 boolean pneumatic_hammer_sound;
524 // internal variables, used during the game. private data :)
526 // returns range corrected x/y position (points to perfect or line shifting get function)
527 int (*getx) (const struct _gd_cave*, int x, int y);
528 int (*gety) (const struct _gd_cave*, int x, int y);
530 // returns pointer to element at x, y (points to perfect border or a line shifting get function)
531 GdElement* (*getp) (const struct _gd_cave*, int x, int y);
533 boolean hatched; // hatching has happened. (timers may run, ...)
534 boolean gate_open; // self-explaining
535 unsigned int render_seed; // the seed value, which was used to render the cave,
536 // is saved here. will be used by record&playback
537 GdRand *random; // random number generator of rendered cave
538 int rendered; // if not zero, rendered at level x
539 int timing_factor; // number of "milliseconds" in each second :)
540 // 1000 for ntsc, 1200 for pal.
541 void ***objects_order; // two-dimensional map of cave; each cell is a pointer
542 // to the drawing object, which created this element.
543 // NULL if map or random.
544 int **hammered_reappear; // integer map of cave; if non-zero, a brick wall will
547 int speed; // Time between game cycles in ms
548 int c64_timing; // a ckdelay value for the level this cave is rendered for
549 int ckdelay; // ckdelay value for the current iteration
550 int ckdelay_extra_for_animation; // bd1 and similar engines had animation bits in cave data,
551 // to set which elements to animate (firefly, butterfly,
553 // animating an element also caused some delay each frame;
554 // according to my measurements, around 2.6 ms/element.
558 int hatching_delay_frame;
559 int hatching_delay_time;
560 int time_bonus; // bonus time for clock collected.
561 int time_penalty; // Time penalty when voodoo destroyed.
562 int time; // milliseconds remaining to finish cave
563 int timevalue; // points for remaining seconds - for current level
564 int diamonds_needed; // diamonds needed to open outbox
565 int diamonds_collected; // diamonds collected
566 int skeletons_collected; // number of skeletons collected
567 int gate_open_flash; // flashing of screen when gate opens
568 int score; // Score got this frame.
569 int amoeba_time; // Amoeba growing slow (low probability, default 3%) for
570 // milliseconds. After that, fast growth default (25%)
571 int amoeba_2_time; // Amoeba growing slow (low probability, default 3%) for
572 // milliseconds. After that, fast growth default (25%)
573 int amoeba_max_count; // selected amoeba 1 threshold for this level
574 int amoeba_2_max_count; // selected amoeba 2 threshold for this level
575 GdAmoebaState amoeba_state; // state of amoeba 1
576 GdAmoebaState amoeba_2_state; // state of amoeba 2
577 int magic_wall_time; // magic wall 'on' state for seconds
578 int slime_permeability; // true random slime
579 int slime_permeability_c64; // Appearing in bd 2
580 GdMagicWallState magic_wall_state; // State of magic wall
581 GdPlayerState player_state; // Player state. not yet living, living, exited...
582 int player_seen_ago; // player was seen this number of scans ago
583 boolean voodoo_touched; // as its name says
584 boolean kill_player; // Voodoo died, or used pressed escape to restart level.
585 boolean sweet_eaten; // player ate sweet, he's strong. prob_sweet applies,
586 // and also able to push chasing stones
587 int player_x, player_y; // Coordinates of player (for scrolling)
588 int px[16], py[16]; // coordinates of player, for chasing stone
589 int key1, key2, key3; // The player is holding this number of keys of each color
590 boolean diamond_key_collected; // Key collected, so trapped diamonds convert to diamonds
591 boolean inbox_flash_toggle; // negated every scan. helps drawing inboxes, and making
592 // players be born at different times.
593 GdDirection last_direction; // last direction player moved. used by draw routines
594 GdDirection last_horizontal_direction;
595 int biters_wait_frame; // number of frames to wait until biters will move again
596 int replicators_wait_frame; // number of frames to wait until replicators are
598 int creatures_direction_will_change; // creatures automatically change direction every x seconds
599 GdC64RandomGenerator c64_rand; // used for predictable random generator during the game.
601 int gravity_will_change; // gravity will change in this number of milliseconds
602 boolean gravity_disabled; // when player is stirring the pot, there is no gravity.
603 GdDirection gravity_next_direction; // next direction when the gravity changes.
604 // will be set by the player "getting" a gravity switch
605 boolean got_pneumatic_hammer; // true if the player has a pneumatic hammer
606 int pneumatic_hammer_active_delay; // number of frames to wait, till pneumatic hammer will
608 GdSound sound1, sound2, sound3; // sound set for 3 channels after each iteration
612 #define CAVE_OFFSET(property) (STRUCT_OFFSET(GdCave, property))
614 // arrays for movements
615 // also no1 and bd2 cave data import helpers; line direction coordinates
616 extern const int gd_dx[], gd_dy[];
618 extern GdElement gd_char_to_element[];
620 void gd_create_char_to_element_table(void);
621 GdElement gd_get_element_from_character(unsigned char character);
622 GdElement gd_get_element_from_string(const char *string);
625 void gd_cave_init(void);
627 // for cave tags hash table
628 int gd_str_case_equal(void *s1, void *s2);
629 unsigned int gd_str_case_hash(void *v);
631 // cave highscore functions
632 int gd_highscore_compare(const void *a, const void *b);
633 boolean gd_is_highscore(GdHighScore *scores, int score);
634 int gd_add_highscore(GdHighScore *highscores, const char *name, int score);
635 void gd_clear_highscore(GdHighScore *hs);
636 boolean gd_has_highscore(GdHighScore *hs);
638 // cave creator and destructor functions
639 GdCave *gd_cave_new(void);
640 GdCave *gd_cave_new_from_cave(const GdCave *orig);
641 void gd_cave_copy(GdCave *dest, const GdCave *src);
642 void gd_cave_free(GdCave *cave);
645 void gd_cave_set_gdash_defaults(GdCave *cave);
646 void gd_cave_set_defaults_from_array(GdCave* cave, GdPropertyDefault *defaults);
647 void gd_cave_correct_visible_size(GdCave *cave);
648 void gd_cave_auto_shrink(GdCave *cave);
650 void gd_cave_setup_for_game(GdCave *cave);
651 void gd_cave_count_diamonds(GdCave *cave);
653 // c64 random generator support for cave fill
654 unsigned int gd_c64_random(GdC64RandomGenerator *rand);
655 unsigned int gd_cave_c64_random(GdCave *);
656 void gd_c64_random_set_seed(GdC64RandomGenerator *rand, int seed1, int seed2);
657 void gd_cave_c64_random_set_seed(GdCave *cave, int seed1, int seed2);
658 void gd_cave_set_random_c64_colors(GdCave *cave);
661 void *gd_cave_map_new_for_cave(const GdCave *cave, const int cell_size);
662 void *gd_cave_map_dup_size(const GdCave * cave, const void *map, const int cell_size);
663 #define gd_cave_map_new(CAVE, TYPE) ((TYPE **)gd_cave_map_new_for_cave((CAVE), sizeof(TYPE)))
664 #define gd_cave_map_dup(CAVE, MAP) ((void *)gd_cave_map_dup_size((CAVE), (void **)(CAVE)->MAP, sizeof((CAVE)->MAP[0][0])))
665 void gd_cave_map_free(void *map);
667 void gd_cave_store_rc(GdCave * cave, int x, int y, const GdElement element, const void* order);
668 GdElement gd_cave_get_rc (const GdCave *cave, int x, int y);
671 const char *gd_direction_get_visible_name(GdDirection dir);
672 const char *gd_direction_get_filename(GdDirection dir);
673 GdDirection gd_direction_from_string(const char *str);
676 const char *gd_scheduling_get_visible_name(GdScheduling sched);
677 const char *gd_scheduling_get_filename(GdScheduling sched);
678 GdScheduling gd_scheduling_from_string(const char *str);
680 // game playing helpers
681 #define GD_REDRAW (1 << 10)
683 void gd_drawcave_game(const GdCave *cave, int **element_buffer, int **gfx_buffer,
684 boolean bonus_life_flash, int animcycle, boolean hate_invisible_outbox);
686 // function to copy a GdString
687 static inline char *gd_strcpy(GdString dest, const GdString src)
689 return strncpy(dest, src, sizeof(GdString));
692 int gd_cave_time_show(const GdCave *cave, int internal_time);
694 GdReplay *gd_replay_new(void);
695 GdReplay *gd_replay_new_from_replay(GdReplay *orig);
696 void gd_replay_free(GdReplay *replay);
697 void gd_replay_store_movement(GdReplay *replay, GdDirection player_move, boolean player_fire, boolean suicide);
699 unsigned int gd_cave_adler_checksum(GdCave *cave);
700 void gd_cave_adler_checksum_more(GdCave *cave, unsigned int *a, unsigned int *b);