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