/***********************************************************
* Rocks'n'Diamonds -- McDuffin Strikes Back! *
*----------------------------------------------------------*
-* (c) 1995-2002 Artsoft Entertainment *
+* (c) 1995-2006 Artsoft Entertainment *
* Holger Schemel *
* Detmolder Strasse 189 *
* 33604 Bielefeld *
#include "conf_fnt.c" /* include auto-generated data structure definitions */
#include "conf_g2s.c" /* include auto-generated data structure definitions */
#include "conf_g2m.c" /* include auto-generated data structure definitions */
+#include "conf_act.c" /* include auto-generated data structure definitions */
#define CONFIG_TOKEN_FONT_INITIAL "font.initial"
+#define CONFIG_TOKEN_GLOBAL_BUSY "global.busy"
+
+#define DEBUG_PRINT_INIT_TIMESTAMPS TRUE
+#define DEBUG_PRINT_INIT_TIMESTAMPS_DEPTH 1
static struct FontBitmapInfo font_initial[NUM_INITIAL_FONTS];
+static struct GraphicInfo anim_initial;
static int copy_properties[][5] =
{
EL_PACMAN_LEFT, EL_PACMAN_RIGHT,
EL_PACMAN_UP, EL_PACMAN_DOWN
},
+ {
+ EL_YAMYAM,
+ EL_YAMYAM_LEFT, EL_YAMYAM_RIGHT,
+ EL_YAMYAM_UP, EL_YAMYAM_DOWN
+ },
{
EL_MOLE,
EL_MOLE_LEFT, EL_MOLE_RIGHT,
}
};
+
+static void print_timestamp_ext(char *message, char *mode)
+{
+#if DEBUG
+#if DEBUG_PRINT_INIT_TIMESTAMPS
+ static char *debug_message = NULL;
+ static char *last_message = NULL;
+ static int counter_nr = 0;
+ int max_depth = DEBUG_PRINT_INIT_TIMESTAMPS_DEPTH;
+
+ checked_free(debug_message);
+ debug_message = getStringCat3(mode, " ", message);
+
+ if (strEqual(mode, "INIT"))
+ {
+ debug_print_timestamp(counter_nr, NULL);
+
+ if (counter_nr + 1 < max_depth)
+ debug_print_timestamp(counter_nr, debug_message);
+
+ counter_nr++;
+
+ debug_print_timestamp(counter_nr, NULL);
+ }
+ else if (strEqual(mode, "DONE"))
+ {
+ counter_nr--;
+
+ if (counter_nr + 1 < max_depth ||
+ (counter_nr == 0 && max_depth == 1))
+ {
+ last_message = message;
+
+ if (counter_nr == 0 && max_depth == 1)
+ {
+ checked_free(debug_message);
+ debug_message = getStringCat3("TIME", " ", message);
+ }
+
+ debug_print_timestamp(counter_nr, debug_message);
+ }
+ }
+ else if (!strEqual(mode, "TIME") ||
+ !strEqual(message, last_message))
+ {
+ if (counter_nr < max_depth)
+ debug_print_timestamp(counter_nr, debug_message);
+ }
+#endif
+#endif
+}
+
+static void print_timestamp_init(char *message)
+{
+ print_timestamp_ext(message, "INIT");
+}
+
+static void print_timestamp_time(char *message)
+{
+ print_timestamp_ext(message, "TIME");
+}
+
+static void print_timestamp_done(char *message)
+{
+ print_timestamp_ext(message, "DONE");
+}
+
+void DrawInitAnim()
+{
+ struct GraphicInfo *graphic_info_last = graphic_info;
+ int graphic = 0;
+ static unsigned long action_delay = 0;
+ unsigned long action_delay_value = GameFrameDelay;
+ int sync_frame = FrameCounter;
+ int x, y;
+
+ if (game_status != GAME_MODE_LOADING)
+ return;
+
+ if (anim_initial.bitmap == NULL || window == NULL)
+ return;
+
+ if (!DelayReached(&action_delay, action_delay_value))
+ return;
+
+#if 0
+ {
+ static unsigned long last_counter = -1;
+ unsigned long current_counter = Counter();
+ unsigned long delay = current_counter - last_counter;
+
+ if (last_counter != -1 && delay > action_delay_value + 5)
+ printf("::: DrawInitAnim: DELAY TOO LONG: %ld\n", delay);
+
+ last_counter = current_counter;
+ }
+#endif
+
+#if 0
+ anim_initial.anim_mode = ANIM_LOOP;
+ anim_initial.anim_start_frame = 0;
+ anim_initial.offset_x = anim_initial.width;
+ anim_initial.offset_y = 0;
+#endif
+
+#if 1
+ x = ALIGNED_TEXT_XPOS(&init.busy);
+ y = ALIGNED_TEXT_YPOS(&init.busy);
+#else
+ x = WIN_XSIZE / 2 - TILESIZE / 2;
+ y = WIN_YSIZE / 2 - TILESIZE / 2;
+#endif
+
+#if 0
+ {
+ static boolean done = FALSE;
+
+ if (!done)
+ printf("::: %d, %d, %d, %d => %d, %d\n",
+ init.busy.x, init.busy.y,
+ init.busy.align, init.busy.valign,
+ x, y);
+
+ done = TRUE;
+ }
+#endif
+
+ graphic_info = &anim_initial; /* graphic == 0 => anim_initial */
+
+ if (sync_frame % anim_initial.anim_delay == 0)
+ DrawGraphicAnimationExt(window, x, y, graphic, sync_frame, NO_MASKING);
+
+ graphic_info = graphic_info_last;
+
+ FrameCounter++;
+}
+
void FreeGadgets()
{
FreeLevelEditorGadgets();
CreateToolButtons();
CreateScreenGadgets();
+ InitGadgetsSoundCallback(PlaySoundActivating, PlaySoundSelecting);
+
gadgets_initialized = TRUE;
}
inline void InitElementSmallImagesScaledUp(int graphic)
{
+#if 0
+ struct FileInfo *fi = getImageListEntryFromImageID(graphic);
+
+ printf("::: '%s' -> '%s'\n", fi->token, fi->filename);
+#endif
+
CreateImageWithSmallImages(graphic, graphic_info[graphic].scale_up_factor);
}
void InitElementSmallImages()
{
+ static int special_graphics[] =
+ {
+ IMG_EDITOR_ELEMENT_BORDER,
+ IMG_EDITOR_ELEMENT_BORDER_INPUT,
+ IMG_EDITOR_CASCADE_LIST,
+ IMG_EDITOR_CASCADE_LIST_ACTIVE,
+ -1
+ };
struct PropertyMapping *property_mapping = getImageListPropertyMapping();
int num_property_mappings = getImageListPropertyMappingSize();
int i;
/* initialize images from dynamic configuration (may be elements or other) */
for (i = 0; i < num_property_mappings; i++)
InitElementSmallImagesScaledUp(property_mapping[i].artwork_index);
+
+ /* initialize special images from above list (non-element images) */
+ for (i = 0; special_graphics[i] > -1; i++)
+ InitElementSmallImagesScaledUp(special_graphics[i]);
+}
+
+void InitScaledImages()
+{
+ int i;
+
+ /* scale normal images from static configuration, if not already scaled */
+ for (i = 0; i < NUM_IMAGE_FILES; i++)
+ ScaleImage(i, graphic_info[i].scale_up_factor);
}
#if 1
{
int special = -1;
- if (game_status >= GAME_MODE_MAIN && game_status <= GAME_MODE_PSEUDO_PREVIEW)
+ /* (special case: do not use special font for GAME_MODE_LOADING) */
+ if (game_status >= GAME_MODE_TITLE_INITIAL &&
+ game_status <= GAME_MODE_PSEUDO_PREVIEW)
special = game_status;
else if (game_status == GAME_MODE_PSEUDO_TYPENAME)
special = GFX_SPECIAL_ARG_MAIN;
+#if 0
else if (game_status == GAME_MODE_PLAYING)
special = GFX_SPECIAL_ARG_DOOR;
+#endif
if (special != -1)
return font_info[font_nr].special_bitmap_id[special];
return font_nr;
}
+static int getFontFromToken(char *token)
+{
+#if 1
+ char *value = getHashEntry(font_token_hash, token);
+
+ if (value != NULL)
+ return atoi(value);
+#else
+ int i;
+
+ /* !!! OPTIMIZE THIS BY USING HASH !!! */
+ for (i = 0; i < NUM_FONTS; i++)
+ if (strEqual(token, font_info[i].token_name))
+ return i;
+#endif
+
+ /* if font not found, use reliable default value */
+ return FONT_INITIAL_1;
+}
+
void InitFontGraphicInfo()
{
static struct FontBitmapInfo *font_bitmap_info = NULL;
if (graphic_info == NULL) /* still at startup phase */
{
- InitFontInfo(font_initial, NUM_INITIAL_FONTS, getFontBitmapID);
+ InitFontInfo(font_initial, NUM_INITIAL_FONTS,
+ getFontBitmapID, getFontFromToken);
return;
}
int graphic = font_to_graphic[i].graphic;
int base_graphic = font2baseimg(font_nr);
- if (special >= 0 && special < NUM_SPECIAL_GFX_ARGS)
+ if (IS_SPECIAL_GFX_ARG(special))
{
boolean base_redefined =
getImageListEntryFromImageID(base_graphic)->redefined;
boolean special_redefined =
getImageListEntryFromImageID(graphic)->redefined;
+ boolean special_cloned = (graphic_info[graphic].clone_from != -1);
/* if the base font ("font.title_1", for example) has been redefined,
but not the special font ("font.title_1.LEVELS", for example), do not
use an existing (in this case considered obsolete) special font
anymore, but use the automatically determined default font */
- if (base_redefined && !special_redefined)
+ /* special case: cloned special fonts must be explicitly redefined,
+ but are not automatically redefined by redefining base font */
+ if (base_redefined && !special_redefined && !special_cloned)
continue;
font_info[font_nr].special_graphic[special] = graphic;
}
}
- /* initialize special element/graphic mapping from dynamic configuration */
+ /* initialize special font/graphic mapping from dynamic configuration */
for (i = 0; i < num_property_mappings; i++)
{
int font_nr = property_mapping[i].base_index - MAX_NUM_ELEMENTS;
if (font_nr < 0)
continue;
- if (special >= 0 && special < NUM_SPECIAL_GFX_ARGS)
+ if (IS_SPECIAL_GFX_ARG(special))
{
font_info[font_nr].special_graphic[special] = graphic;
font_info[font_nr].special_bitmap_id[special] = num_font_bitmaps;
}
}
+ /* correct special font/graphic mapping for cloned fonts for downwards
+ compatibility of PREVIEW fonts -- this is only needed for implicit
+ redefinition of special font by redefined base font, and only if other
+ fonts are cloned from this special font (like in the "Zelda" level set) */
+ for (i = 0; font_to_graphic[i].font_nr > -1; i++)
+ {
+ int font_nr = font_to_graphic[i].font_nr;
+ int special = font_to_graphic[i].special;
+ int graphic = font_to_graphic[i].graphic;
+
+ if (IS_SPECIAL_GFX_ARG(special))
+ {
+ boolean special_redefined =
+ getImageListEntryFromImageID(graphic)->redefined;
+ boolean special_cloned = (graphic_info[graphic].clone_from != -1);
+
+ if (special_cloned && !special_redefined)
+ {
+ int j;
+
+ for (j = 0; font_to_graphic[j].font_nr > -1; j++)
+ {
+ int font_nr2 = font_to_graphic[j].font_nr;
+ int special2 = font_to_graphic[j].special;
+ int graphic2 = font_to_graphic[j].graphic;
+
+ if (IS_SPECIAL_GFX_ARG(special2) &&
+ graphic2 == graphic_info[graphic].clone_from)
+ {
+ font_info[font_nr].special_graphic[special] =
+ font_info[font_nr2].special_graphic[special2];
+ font_info[font_nr].special_bitmap_id[special] =
+ font_info[font_nr2].special_bitmap_id[special2];
+ }
+ }
+ }
+ }
+ }
+
+ /* reset non-redefined ".active" font graphics if normal font is redefined */
+ /* (this different treatment is needed because normal and active fonts are
+ independently defined ("active" is not a property of font definitions!) */
+ for (i = 0; i < NUM_FONTS; i++)
+ {
+ int font_nr_base = i;
+ int font_nr_active = FONT_ACTIVE(font_nr_base);
+
+ /* check only those fonts with exist as normal and ".active" variant */
+ if (font_nr_base != font_nr_active)
+ {
+ int base_graphic = font_info[font_nr_base].graphic;
+ int active_graphic = font_info[font_nr_active].graphic;
+ boolean base_redefined =
+ getImageListEntryFromImageID(base_graphic)->redefined;
+ boolean active_redefined =
+ getImageListEntryFromImageID(active_graphic)->redefined;
+
+ /* if the base font ("font.menu_1", for example) has been redefined,
+ but not the active font ("font.menu_1.active", for example), do not
+ use an existing (in this case considered obsolete) active font
+ anymore, but use the automatically determined default font */
+ if (base_redefined && !active_redefined)
+ font_info[font_nr_active].graphic = base_graphic;
+
+ /* now also check each "special" font (which may be the same as above) */
+ for (j = 0; j < NUM_SPECIAL_GFX_ARGS; j++)
+ {
+ int base_graphic = font_info[font_nr_base].special_graphic[j];
+ int active_graphic = font_info[font_nr_active].special_graphic[j];
+ boolean base_redefined =
+ getImageListEntryFromImageID(base_graphic)->redefined;
+ boolean active_redefined =
+ getImageListEntryFromImageID(active_graphic)->redefined;
+
+ /* same as above, but check special graphic definitions, for example:
+ redefined "font.menu_1.MAIN" invalidates "font.menu_1.active.MAIN" */
+ if (base_redefined && !active_redefined)
+ {
+ font_info[font_nr_active].special_graphic[j] =
+ font_info[font_nr_base].special_graphic[j];
+ font_info[font_nr_active].special_bitmap_id[j] =
+ font_info[font_nr_base].special_bitmap_id[j];
+ }
+ }
+ }
+ }
+
/* ---------- initialize font bitmap array ---------- */
if (font_bitmap_info != NULL)
if (graphic_info[graphic].anim_frames < MIN_NUM_CHARS_PER_FONT)
{
graphic_info[graphic].anim_frames = DEFAULT_NUM_CHARS_PER_FONT;
- graphic_info[graphic].anim_frames_per_line= DEFAULT_NUM_CHARS_PER_LINE;
+ graphic_info[graphic].anim_frames_per_line = DEFAULT_NUM_CHARS_PER_LINE;
}
/* copy font relevant information from graphics information */
font_bitmap_info[font_bitmap_id].src_y = graphic_info[graphic].src_y;
font_bitmap_info[font_bitmap_id].width = graphic_info[graphic].width;
font_bitmap_info[font_bitmap_id].height = graphic_info[graphic].height;
- font_bitmap_info[font_bitmap_id].draw_x = graphic_info[graphic].draw_x;
- font_bitmap_info[font_bitmap_id].draw_y = graphic_info[graphic].draw_y;
+
+ font_bitmap_info[font_bitmap_id].draw_xoffset =
+ graphic_info[graphic].draw_xoffset;
+ font_bitmap_info[font_bitmap_id].draw_yoffset =
+ graphic_info[graphic].draw_yoffset;
font_bitmap_info[font_bitmap_id].num_chars =
graphic_info[graphic].anim_frames;
}
}
- InitFontInfo(font_bitmap_info, num_font_bitmaps, getFontBitmapID);
+ InitFontInfo(font_bitmap_info, num_font_bitmaps,
+ getFontBitmapID, getFontFromToken);
+}
+
+static void CheckArtworkConfigForCustomElements(char *filename)
+{
+ SetupFileHash *setup_file_hash;
+ boolean redefined_ce_found = FALSE;
+
+ if ((setup_file_hash = loadSetupFileHash(filename)) != NULL)
+ {
+ BEGIN_HASH_ITERATION(setup_file_hash, itr)
+ {
+ char *token = HASH_ITERATION_TOKEN(itr);
+
+ if (strPrefix(token, "custom_"))
+ redefined_ce_found = TRUE;
+ }
+ END_HASH_ITERATION(setup_file_hash, itr)
+
+ freeSetupFileHash(setup_file_hash);
+ }
+
+ printf("::: redefined_ce_found == %d [%s]\n", redefined_ce_found, filename);
+}
+
+static void CheckCustomElementGraphicInfo()
+{
+ struct PropertyMapping *property_mapping = getImageListPropertyMapping();
+ int num_property_mappings = getImageListPropertyMappingSize();
+ boolean redefined_ce_found = FALSE;
+ int i;
+
+ /* check normal element/graphic mapping from static configuration */
+ for (i = 0; element_to_graphic[i].element > -1; i++)
+ {
+ int element = element_to_graphic[i].element;
+ int graphic = element_to_graphic[i].graphic;
+
+ if (IS_CUSTOM_ELEMENT(element))
+ if (getImageListEntryFromImageID(graphic)->redefined)
+ redefined_ce_found = TRUE;
+ }
+
+ /* check normal element/graphic mapping from dynamic configuration */
+ for (i = 0; i < num_property_mappings; i++)
+ {
+ int element = property_mapping[i].base_index;
+
+ if (IS_CUSTOM_ELEMENT(element))
+ redefined_ce_found = TRUE;
+ }
+
+ printf("::: redefined_ce_found == %d\n", redefined_ce_found);
}
void InitElementGraphicInfo()
element_info[i].graphic[act] = -1;
element_info[i].crumbled[act] = -1;
- for (dir = 0; dir < NUM_DIRECTIONS; dir++)
+ for (dir = 0; dir < NUM_DIRECTIONS_FULL; dir++)
{
element_info[i].direction_graphic[act][dir] = -1;
element_info[i].direction_crumbled[act][dir] = -1;
}
}
+ UPDATE_BUSY_STATE();
+
/* initialize normal element/graphic mapping from static configuration */
for (i = 0; element_to_graphic[i].element > -1; i++)
{
int graphic = property_mapping[i].artwork_index;
boolean crumbled = FALSE;
+#if 0
+ if ((element == EL_EM_DYNAMITE ||
+ element == EL_EM_DYNAMITE_ACTIVE) &&
+ action == ACTION_ACTIVE &&
+ (special == GFX_SPECIAL_ARG_EDITOR ||
+ special == GFX_SPECIAL_ARG_PANEL))
+ printf("::: DYNAMIC: %d, %d, %d -> %d\n",
+ element, action, special, graphic);
+#endif
+
if (special == GFX_SPECIAL_ARG_CRUMBLED)
{
special = -1;
if (crumbled)
{
if (direction < 0)
- for (dir = 0; dir < NUM_DIRECTIONS; dir++)
+ for (dir = 0; dir < NUM_DIRECTIONS_FULL; dir++)
element_info[element].direction_crumbled[action][dir] = -1;
if (direction > -1)
else
{
if (direction < 0)
- for (dir = 0; dir < NUM_DIRECTIONS; dir++)
+ for (dir = 0; dir < NUM_DIRECTIONS_FULL; dir++)
element_info[element].direction_graphic[action][dir] = -1;
if (direction > -1)
element_info[i].crumbled[act] =
element_info[crumbled_like].crumbled[act];
for (act = 0; act < NUM_ACTIONS; act++)
- for (dir = 0; dir < NUM_DIRECTIONS; dir++)
+ for (dir = 0; dir < NUM_DIRECTIONS_FULL; dir++)
element_info[i].direction_crumbled[act][dir] =
element_info[crumbled_like].direction_crumbled[act][dir];
}
{
element_info[i].graphic[ACTION_DIGGING] =
element_info[diggable_like].graphic[ACTION_DIGGING];
- for (dir = 0; dir < NUM_DIRECTIONS; dir++)
+ for (dir = 0; dir < NUM_DIRECTIONS_FULL; dir++)
element_info[i].direction_graphic[ACTION_DIGGING][dir] =
element_info[diggable_like].direction_graphic[ACTION_DIGGING][dir];
}
element_info[EL_AMOEBA_TO_DIAMOND].graphic[ACTION_DEFAULT] = IMG_AMOEBA_DEAD;
#endif
+#if 1
+ /* set hardcoded definitions for some internal elements without graphic */
+ for (i = 0; i < MAX_NUM_ELEMENTS; i++)
+ {
+ if (IS_EDITOR_CASCADE_INACTIVE(i))
+ element_info[i].graphic[ACTION_DEFAULT] = IMG_EDITOR_CASCADE_LIST;
+ else if (IS_EDITOR_CASCADE_ACTIVE(i))
+ element_info[i].graphic[ACTION_DEFAULT] = IMG_EDITOR_CASCADE_LIST_ACTIVE;
+ }
+#endif
+
/* now set all undefined/invalid graphics to -1 to set to default after it */
for (i = 0; i < MAX_NUM_ELEMENTS; i++)
{
if (graphic > 0 && graphic_info[graphic].bitmap == NULL)
element_info[i].crumbled[act] = -1;
- for (dir = 0; dir < NUM_DIRECTIONS; dir++)
+ for (dir = 0; dir < NUM_DIRECTIONS_FULL; dir++)
{
graphic = element_info[i].direction_graphic[act][dir];
if (graphic > 0 && graphic_info[graphic].bitmap == NULL)
}
}
+ UPDATE_BUSY_STATE();
+
/* adjust graphics with 2nd tile for movement according to direction
(do this before correcting '-1' values to minimize calculations) */
for (i = 0; i < MAX_NUM_ELEMENTS; i++)
{
for (act = 0; act < NUM_ACTIONS; act++)
{
- for (dir = 0; dir < NUM_DIRECTIONS; dir++)
+ for (dir = 0; dir < NUM_DIRECTIONS_FULL; dir++)
{
int graphic = element_info[i].direction_graphic[act][dir];
int move_dir = (act == ACTION_FALLING ? MV_BIT_DOWN : dir);
}
}
+ UPDATE_BUSY_STATE();
+
/* now set all '-1' values to element specific default values */
for (i = 0; i < MAX_NUM_ELEMENTS; i++)
{
int default_graphic = element_info[i].graphic[ACTION_DEFAULT];
int default_crumbled = element_info[i].crumbled[ACTION_DEFAULT];
- int default_direction_graphic[NUM_DIRECTIONS];
- int default_direction_crumbled[NUM_DIRECTIONS];
+ int default_direction_graphic[NUM_DIRECTIONS_FULL];
+ int default_direction_crumbled[NUM_DIRECTIONS_FULL];
if (default_graphic == -1)
default_graphic = IMG_UNKNOWN;
default_crumbled = IMG_EMPTY;
#endif
- for (dir = 0; dir < NUM_DIRECTIONS; dir++)
+ for (dir = 0; dir < NUM_DIRECTIONS_FULL; dir++)
{
default_direction_graphic[dir] =
element_info[i].direction_graphic[ACTION_DEFAULT][dir];
default_action_crumbled = default_crumbled;
#endif
- for (dir = 0; dir < NUM_DIRECTIONS; dir++)
+ for (dir = 0; dir < NUM_DIRECTIONS_FULL; dir++)
{
/* use action graphic as the default direction graphic, if undefined */
int default_action_direction_graphic = element_info[i].graphic[act];
}
}
+ UPDATE_BUSY_STATE();
+
+#if 0
+ /* !!! THIS ALSO CLEARS SPECIAL FLAGS (AND IS NOT NEEDED ANYWAY) !!! */
/* set animation mode to "none" for each graphic with only 1 frame */
for (i = 0; i < MAX_NUM_ELEMENTS; i++)
{
if (graphic_info[crumbled].anim_frames == 1)
graphic_info[crumbled].anim_mode = ANIM_NONE;
- for (dir = 0; dir < NUM_DIRECTIONS; dir++)
+ for (dir = 0; dir < NUM_DIRECTIONS_FULL; dir++)
{
graphic = element_info[i].direction_graphic[act][dir];
crumbled = element_info[i].direction_crumbled[act][dir];
}
}
}
+#endif
#if 0
#if DEBUG
for (i = 0; i < MAX_NUM_ELEMENTS; i++)
if (element_info[i].graphic[ACTION_DEFAULT] == IMG_UNKNOWN &&
i != EL_UNKNOWN)
- Error(ERR_RETURN, "warning: no graphic for element '%s' (%d)",
+ Error(ERR_INFO, "warning: no graphic for element '%s' (%d)",
element_info[i].token_name, i);
}
#endif
boolean special_redefined =
getImageListEntryFromImageID(graphic)->redefined;
+#if 0
+ if ((element == EL_EM_DYNAMITE ||
+ element == EL_EM_DYNAMITE_ACTIVE) &&
+ (special == GFX_SPECIAL_ARG_EDITOR ||
+ special == GFX_SPECIAL_ARG_PANEL))
+ printf("::: SPECIAL STATIC: %d, %d -> %d\n",
+ element, special, graphic);
+#endif
+
/* if the base graphic ("emerald", for example) has been redefined,
but not the special graphic ("emerald.EDITOR", for example), do not
use an existing (in this case considered obsolete) special graphic
if (base_redefined && !special_redefined)
continue;
- element_info[element].special_graphic[special] = graphic;
- }
+ element_info[element].special_graphic[special] = graphic;
+ }
+
+ /* initialize special element/graphic mapping from dynamic configuration */
+ for (i = 0; i < num_property_mappings; i++)
+ {
+ int element = property_mapping[i].base_index;
+ int action = property_mapping[i].ext1_index;
+ int direction = property_mapping[i].ext2_index;
+ int special = property_mapping[i].ext3_index;
+ int graphic = property_mapping[i].artwork_index;
+
+#if 0
+ if ((element == EL_EM_DYNAMITE ||
+ element == EL_EM_DYNAMITE_ACTIVE ||
+ element == EL_CONVEYOR_BELT_1_MIDDLE ||
+ element == EL_CONVEYOR_BELT_1_MIDDLE_ACTIVE) &&
+ (special == GFX_SPECIAL_ARG_EDITOR ||
+ special == GFX_SPECIAL_ARG_PANEL))
+ printf("::: SPECIAL DYNAMIC: %d, %d -> %d [%d]\n",
+ element, special, graphic, property_mapping[i].ext1_index);
+#endif
+
+#if 0
+ if (element == EL_CONVEYOR_BELT_1_MIDDLE &&
+ action == ACTION_ACTIVE)
+ {
+ element = EL_CONVEYOR_BELT_1_MIDDLE_ACTIVE;
+ action = -1;
+ }
+#endif
+
+#if 0
+ if (element == EL_MAGIC_WALL &&
+ action == ACTION_ACTIVE)
+ {
+ element = EL_MAGIC_WALL_ACTIVE;
+ action = -1;
+ }
+#endif
+
+#if 1
+ /* for action ".active", replace element with active element, if exists */
+ if (action == ACTION_ACTIVE && element != ELEMENT_ACTIVE(element))
+ {
+ element = ELEMENT_ACTIVE(element);
+ action = -1;
+ }
+#endif
+
+ if (element >= MAX_NUM_ELEMENTS)
+ continue;
+
+ /* do not change special graphic if action or direction was specified */
+ if (action != -1 || direction != -1)
+ continue;
+
+ if (IS_SPECIAL_GFX_ARG(special))
+ element_info[element].special_graphic[special] = graphic;
+ }
+
+ /* now set all undefined/invalid graphics to default */
+ for (i = 0; i < MAX_NUM_ELEMENTS; i++)
+ for (j = 0; j < NUM_SPECIAL_GFX_ARGS; j++)
+ if (graphic_info[element_info[i].special_graphic[j]].bitmap == NULL)
+ element_info[i].special_graphic[j] =
+ element_info[i].graphic[ACTION_DEFAULT];
+}
+
+static int get_graphic_parameter_value(char *value_raw, char *suffix, int type)
+{
+ if (type != TYPE_ELEMENT && type != TYPE_GRAPHIC)
+ return get_parameter_value(value_raw, suffix, type);
+
+ if (strEqual(value_raw, ARG_UNDEFINED))
+ return ARG_UNDEFINED_VALUE;
+
+#if 1
+ if (type == TYPE_ELEMENT)
+ {
+ char *value = getHashEntry(element_token_hash, value_raw);
+
+ return (value != NULL ? atoi(value) : EL_UNDEFINED);
+ }
+ else if (type == TYPE_GRAPHIC)
+ {
+ char *value = getHashEntry(graphic_token_hash, value_raw);
+
+ return (value != NULL ? atoi(value) : IMG_UNDEFINED);
+ }
+
+#else
+
+ int i;
+ int x = 0;
+
+ /* !!! THIS IS BUGGY !!! NOT SURE IF YOU GET ELEMENT ID OR GRAPHIC ID !!! */
+ /* !!! (possible reason why ".clone_from" with elements doesn't work) !!! */
+
+ /* !!! OPTIMIZE THIS BY USING HASH !!! */
+ for (i = 0; i < MAX_NUM_ELEMENTS; i++)
+ if (strEqual(element_info[i].token_name, value_raw))
+ return i;
+
+ /* !!! OPTIMIZE THIS BY USING HASH !!! */
+ for (i = 0; image_config[i].token != NULL; i++)
+ {
+ int len_config_value = strlen(image_config[i].value);
+
+ if (!strEqual(&image_config[i].value[len_config_value - 4], ".pcx") &&
+ !strEqual(&image_config[i].value[len_config_value - 4], ".wav") &&
+ !strEqual(image_config[i].value, UNDEFINED_FILENAME))
+ continue;
+
+ if (strEqual(image_config[i].token, value_raw))
+ return x;
+
+ x++;
+ }
+#endif
+
+ return -1;
+}
+
+static int get_scaled_graphic_width(int graphic)
+{
+ int original_width = getOriginalImageWidthFromImageID(graphic);
+ int scale_up_factor = graphic_info[graphic].scale_up_factor;
+
+ return original_width * scale_up_factor;
+}
+
+static int get_scaled_graphic_height(int graphic)
+{
+ int original_height = getOriginalImageHeightFromImageID(graphic);
+ int scale_up_factor = graphic_info[graphic].scale_up_factor;
+
+ return original_height * scale_up_factor;
+}
+
+static void set_graphic_parameters_ext(int graphic, struct GraphicInfo *g,
+ int *parameter, Bitmap *src_bitmap)
+{
+ int anim_frames_per_row = 1, anim_frames_per_col = 1;
+ int anim_frames_per_line = 1;
+
+ /* always start with reliable default values */
+ g->src_image_width = 0;
+ g->src_image_height = 0;
+ g->src_x = 0;
+ g->src_y = 0;
+ g->width = TILEX; /* default for element graphics */
+ g->height = TILEY; /* default for element graphics */
+ g->offset_x = 0; /* one or both of these values ... */
+ g->offset_y = 0; /* ... will be corrected later */
+ g->offset2_x = 0; /* one or both of these values ... */
+ g->offset2_y = 0; /* ... will be corrected later */
+ g->swap_double_tiles = -1; /* auto-detect tile swapping */
+ g->crumbled_like = -1; /* do not use clone element */
+ g->diggable_like = -1; /* do not use clone element */
+ g->border_size = TILEX / 8; /* "CRUMBLED" border size */
+ g->scale_up_factor = 1; /* default: no scaling up */
+ g->clone_from = -1; /* do not use clone graphic */
+ g->anim_delay_fixed = 0;
+ g->anim_delay_random = 0;
+ g->post_delay_fixed = 0;
+ g->post_delay_random = 0;
+ g->fade_mode = FADE_MODE_DEFAULT;
+ g->fade_delay = -1;
+ g->post_delay = -1;
+ g->auto_delay = -1;
+ g->align = ALIGN_CENTER; /* default for title screens */
+ g->valign = VALIGN_MIDDLE; /* default for title screens */
+ g->sort_priority = 0; /* default for title screens */
+
+ g->bitmap = src_bitmap;
+
+#if 1
+ /* optional zoom factor for scaling up the image to a larger size */
+ if (parameter[GFX_ARG_SCALE_UP_FACTOR] != ARG_UNDEFINED_VALUE)
+ g->scale_up_factor = parameter[GFX_ARG_SCALE_UP_FACTOR];
+ if (g->scale_up_factor < 1)
+ g->scale_up_factor = 1; /* no scaling */
+#endif
+
+#if 1
+ if (g->use_image_size)
+ {
+ /* set new default bitmap size (with scaling, but without small images) */
+ g->width = get_scaled_graphic_width(graphic);
+ g->height = get_scaled_graphic_height(graphic);
+ }
+#endif
+
+ /* optional x and y tile position of animation frame sequence */
+ if (parameter[GFX_ARG_XPOS] != ARG_UNDEFINED_VALUE)
+ g->src_x = parameter[GFX_ARG_XPOS] * TILEX;
+ if (parameter[GFX_ARG_YPOS] != ARG_UNDEFINED_VALUE)
+ g->src_y = parameter[GFX_ARG_YPOS] * TILEY;
+
+ /* optional x and y pixel position of animation frame sequence */
+ if (parameter[GFX_ARG_X] != ARG_UNDEFINED_VALUE)
+ g->src_x = parameter[GFX_ARG_X];
+ if (parameter[GFX_ARG_Y] != ARG_UNDEFINED_VALUE)
+ g->src_y = parameter[GFX_ARG_Y];
+
+ /* optional width and height of each animation frame */
+ if (parameter[GFX_ARG_WIDTH] != ARG_UNDEFINED_VALUE)
+ g->width = parameter[GFX_ARG_WIDTH];
+ if (parameter[GFX_ARG_HEIGHT] != ARG_UNDEFINED_VALUE)
+ g->height = parameter[GFX_ARG_HEIGHT];
+
+#if 0
+ /* optional zoom factor for scaling up the image to a larger size */
+ if (parameter[GFX_ARG_SCALE_UP_FACTOR] != ARG_UNDEFINED_VALUE)
+ g->scale_up_factor = parameter[GFX_ARG_SCALE_UP_FACTOR];
+ if (g->scale_up_factor < 1)
+ g->scale_up_factor = 1; /* no scaling */
+#endif
+
+ if (src_bitmap)
+ {
+ /* get final bitmap size (with scaling, but without small images) */
+ int src_image_width = get_scaled_graphic_width(graphic);
+ int src_image_height = get_scaled_graphic_height(graphic);
+
+ anim_frames_per_row = src_image_width / g->width;
+ anim_frames_per_col = src_image_height / g->height;
+
+ g->src_image_width = src_image_width;
+ g->src_image_height = src_image_height;
+ }
+
+ /* correct x or y offset dependent of vertical or horizontal frame order */
+ if (parameter[GFX_ARG_VERTICAL]) /* frames are ordered vertically */
+ {
+ g->offset_y = (parameter[GFX_ARG_OFFSET] != ARG_UNDEFINED_VALUE ?
+ parameter[GFX_ARG_OFFSET] : g->height);
+ anim_frames_per_line = anim_frames_per_col;
+ }
+ else /* frames are ordered horizontally */
+ {
+ g->offset_x = (parameter[GFX_ARG_OFFSET] != ARG_UNDEFINED_VALUE ?
+ parameter[GFX_ARG_OFFSET] : g->width);
+ anim_frames_per_line = anim_frames_per_row;
+ }
+
+ /* optionally, the x and y offset of frames can be specified directly */
+ if (parameter[GFX_ARG_XOFFSET] != ARG_UNDEFINED_VALUE)
+ g->offset_x = parameter[GFX_ARG_XOFFSET];
+ if (parameter[GFX_ARG_YOFFSET] != ARG_UNDEFINED_VALUE)
+ g->offset_y = parameter[GFX_ARG_YOFFSET];
+
+ /* optionally, moving animations may have separate start and end graphics */
+ g->double_movement = parameter[GFX_ARG_2ND_MOVEMENT_TILE];
+
+ if (parameter[GFX_ARG_2ND_VERTICAL] == ARG_UNDEFINED_VALUE)
+ parameter[GFX_ARG_2ND_VERTICAL] = !parameter[GFX_ARG_VERTICAL];
- /* initialize special element/graphic mapping from dynamic configuration */
- for (i = 0; i < num_property_mappings; i++)
- {
- int element = property_mapping[i].base_index;
- int special = property_mapping[i].ext3_index;
- int graphic = property_mapping[i].artwork_index;
+ /* correct x or y offset2 dependent of vertical or horizontal frame order */
+ if (parameter[GFX_ARG_2ND_VERTICAL]) /* frames are ordered vertically */
+ g->offset2_y = (parameter[GFX_ARG_2ND_OFFSET] != ARG_UNDEFINED_VALUE ?
+ parameter[GFX_ARG_2ND_OFFSET] : g->height);
+ else /* frames are ordered horizontally */
+ g->offset2_x = (parameter[GFX_ARG_2ND_OFFSET] != ARG_UNDEFINED_VALUE ?
+ parameter[GFX_ARG_2ND_OFFSET] : g->width);
- if (element >= MAX_NUM_ELEMENTS)
- continue;
+ /* optionally, the x and y offset of 2nd graphic can be specified directly */
+ if (parameter[GFX_ARG_2ND_XOFFSET] != ARG_UNDEFINED_VALUE)
+ g->offset2_x = parameter[GFX_ARG_2ND_XOFFSET];
+ if (parameter[GFX_ARG_2ND_YOFFSET] != ARG_UNDEFINED_VALUE)
+ g->offset2_y = parameter[GFX_ARG_2ND_YOFFSET];
- if (special >= 0 && special < NUM_SPECIAL_GFX_ARGS)
- element_info[element].special_graphic[special] = graphic;
- }
+ /* optionally, the second movement tile can be specified as start tile */
+ if (parameter[GFX_ARG_2ND_SWAP_TILES] != ARG_UNDEFINED_VALUE)
+ g->swap_double_tiles= parameter[GFX_ARG_2ND_SWAP_TILES];
- /* now set all undefined/invalid graphics to default */
- for (i = 0; i < MAX_NUM_ELEMENTS; i++)
- for (j = 0; j < NUM_SPECIAL_GFX_ARGS; j++)
- if (graphic_info[element_info[i].special_graphic[j]].bitmap == NULL)
- element_info[i].special_graphic[j] =
- element_info[i].graphic[ACTION_DEFAULT];
-}
+ /* automatically determine correct number of frames, if not defined */
+ if (parameter[GFX_ARG_FRAMES] != ARG_UNDEFINED_VALUE)
+ g->anim_frames = parameter[GFX_ARG_FRAMES];
+ else if (parameter[GFX_ARG_XPOS] == 0 && !parameter[GFX_ARG_VERTICAL])
+ g->anim_frames = anim_frames_per_row;
+ else if (parameter[GFX_ARG_YPOS] == 0 && parameter[GFX_ARG_VERTICAL])
+ g->anim_frames = anim_frames_per_col;
+ else
+ g->anim_frames = 1;
-static int get_graphic_parameter_value(char *value_raw, char *suffix, int type)
-{
- int i;
- int x = 0;
+ if (g->anim_frames == 0) /* frames must be at least 1 */
+ g->anim_frames = 1;
- if (type != TYPE_TOKEN)
- return get_parameter_value(value_raw, suffix, type);
+ g->anim_frames_per_line =
+ (parameter[GFX_ARG_FRAMES_PER_LINE] != ARG_UNDEFINED_VALUE ?
+ parameter[GFX_ARG_FRAMES_PER_LINE] : anim_frames_per_line);
- if (strcmp(value_raw, ARG_UNDEFINED) == 0)
- return ARG_UNDEFINED_VALUE;
+ g->anim_delay = parameter[GFX_ARG_DELAY];
+ if (g->anim_delay == 0) /* delay must be at least 1 */
+ g->anim_delay = 1;
- /* !!! OPTIMIZE THIS BY USING HASH !!! */
- for (i = 0; i < MAX_NUM_ELEMENTS; i++)
- if (strcmp(element_info[i].token_name, value_raw) == 0)
- return i;
+ g->anim_mode = parameter[GFX_ARG_ANIM_MODE];
+#if 0
+ if (g->anim_frames == 1)
+ g->anim_mode = ANIM_NONE;
+#endif
- /* !!! OPTIMIZE THIS BY USING HASH !!! */
- for (i = 0; image_config[i].token != NULL; i++)
- {
- int len_config_value = strlen(image_config[i].value);
+ /* automatically determine correct start frame, if not defined */
+ if (parameter[GFX_ARG_START_FRAME] == ARG_UNDEFINED_VALUE)
+ g->anim_start_frame = 0;
+ else if (g->anim_mode & ANIM_REVERSE)
+ g->anim_start_frame = g->anim_frames - parameter[GFX_ARG_START_FRAME] - 1;
+ else
+ g->anim_start_frame = parameter[GFX_ARG_START_FRAME];
- if (strcmp(&image_config[i].value[len_config_value - 4], ".pcx") != 0 &&
- strcmp(&image_config[i].value[len_config_value - 4], ".wav") != 0 &&
- strcmp(image_config[i].value, UNDEFINED_FILENAME) != 0)
- continue;
+ /* animation synchronized with global frame counter, not move position */
+ g->anim_global_sync = parameter[GFX_ARG_GLOBAL_SYNC];
- if (strcmp(image_config[i].token, value_raw) == 0)
- return x;
+ /* optional element for cloning crumble graphics */
+ if (parameter[GFX_ARG_CRUMBLED_LIKE] != ARG_UNDEFINED_VALUE)
+ g->crumbled_like = parameter[GFX_ARG_CRUMBLED_LIKE];
- x++;
- }
+ /* optional element for cloning digging graphics */
+ if (parameter[GFX_ARG_DIGGABLE_LIKE] != ARG_UNDEFINED_VALUE)
+ g->diggable_like = parameter[GFX_ARG_DIGGABLE_LIKE];
- return -1;
-}
+ /* optional border size for "crumbling" diggable graphics */
+ if (parameter[GFX_ARG_BORDER_SIZE] != ARG_UNDEFINED_VALUE)
+ g->border_size = parameter[GFX_ARG_BORDER_SIZE];
-static int get_scaled_graphic_width(int graphic)
-{
- int original_width = getOriginalImageWidthFromImageID(graphic);
- int scale_up_factor = graphic_info[graphic].scale_up_factor;
+ /* this is only used for player "boring" and "sleeping" actions */
+ if (parameter[GFX_ARG_ANIM_DELAY_FIXED] != ARG_UNDEFINED_VALUE)
+ g->anim_delay_fixed = parameter[GFX_ARG_ANIM_DELAY_FIXED];
+ if (parameter[GFX_ARG_ANIM_DELAY_RANDOM] != ARG_UNDEFINED_VALUE)
+ g->anim_delay_random = parameter[GFX_ARG_ANIM_DELAY_RANDOM];
+ if (parameter[GFX_ARG_POST_DELAY_FIXED] != ARG_UNDEFINED_VALUE)
+ g->post_delay_fixed = parameter[GFX_ARG_POST_DELAY_FIXED];
+ if (parameter[GFX_ARG_POST_DELAY_RANDOM] != ARG_UNDEFINED_VALUE)
+ g->post_delay_random = parameter[GFX_ARG_POST_DELAY_RANDOM];
- return original_width * scale_up_factor;
-}
+ /* this is only used for toon animations */
+ g->step_offset = parameter[GFX_ARG_STEP_OFFSET];
+ g->step_delay = parameter[GFX_ARG_STEP_DELAY];
-static int get_scaled_graphic_height(int graphic)
-{
- int original_height = getOriginalImageHeightFromImageID(graphic);
- int scale_up_factor = graphic_info[graphic].scale_up_factor;
+ /* this is only used for drawing font characters */
+ g->draw_xoffset = parameter[GFX_ARG_DRAW_XOFFSET];
+ g->draw_yoffset = parameter[GFX_ARG_DRAW_YOFFSET];
- return original_height * scale_up_factor;
+ /* this is only used for drawing envelope graphics */
+ g->draw_masked = parameter[GFX_ARG_DRAW_MASKED];
+
+ /* optional graphic for cloning all graphics settings */
+ if (parameter[GFX_ARG_CLONE_FROM] != ARG_UNDEFINED_VALUE)
+ g->clone_from = parameter[GFX_ARG_CLONE_FROM];
+
+ /* optional settings for drawing title screens and title messages */
+ if (parameter[GFX_ARG_FADE_MODE] != ARG_UNDEFINED_VALUE)
+ g->fade_mode = parameter[GFX_ARG_FADE_MODE];
+ if (parameter[GFX_ARG_FADE_DELAY] != ARG_UNDEFINED_VALUE)
+ g->fade_delay = parameter[GFX_ARG_FADE_DELAY];
+ if (parameter[GFX_ARG_POST_DELAY] != ARG_UNDEFINED_VALUE)
+ g->post_delay = parameter[GFX_ARG_POST_DELAY];
+ if (parameter[GFX_ARG_AUTO_DELAY] != ARG_UNDEFINED_VALUE)
+ g->auto_delay = parameter[GFX_ARG_AUTO_DELAY];
+ if (parameter[GFX_ARG_ALIGN] != ARG_UNDEFINED_VALUE)
+ g->align = parameter[GFX_ARG_ALIGN];
+ if (parameter[GFX_ARG_VALIGN] != ARG_UNDEFINED_VALUE)
+ g->valign = parameter[GFX_ARG_VALIGN];
+ if (parameter[GFX_ARG_SORT_PRIORITY] != ARG_UNDEFINED_VALUE)
+ g->sort_priority = parameter[GFX_ARG_SORT_PRIORITY];
}
static void set_graphic_parameters(int graphic)
{
+#if 1
+ struct FileInfo *image = getImageListEntryFromImageID(graphic);
+ char **parameter_raw = image->parameter;
+ Bitmap *src_bitmap = getBitmapFromImageID(graphic);
+ int parameter[NUM_GFX_ARGS];
+ int i;
+
+ /* if fallback to default artwork is done, also use the default parameters */
+ if (image->fallback_to_default)
+ parameter_raw = image->default_parameter;
+
+ /* get integer values from string parameters */
+ for (i = 0; i < NUM_GFX_ARGS; i++)
+ parameter[i] = get_graphic_parameter_value(parameter_raw[i],
+ image_config_suffix[i].token,
+ image_config_suffix[i].type);
+
+ set_graphic_parameters_ext(graphic, &graphic_info[graphic],
+ parameter, src_bitmap);
+
+#else
+
struct FileInfo *image = getImageListEntryFromImageID(graphic);
char **parameter_raw = image->parameter;
Bitmap *src_bitmap = getBitmapFromImageID(graphic);
graphic_info[graphic].bitmap = src_bitmap;
- /* start with reliable default values */
+ /* always start with reliable default values */
graphic_info[graphic].src_image_width = 0;
graphic_info[graphic].src_image_height = 0;
graphic_info[graphic].src_x = 0;
graphic_info[graphic].src_y = 0;
- graphic_info[graphic].width = TILEX;
- graphic_info[graphic].height = TILEY;
+ graphic_info[graphic].width = TILEX; /* default for element graphics */
+ graphic_info[graphic].height = TILEY; /* default for element graphics */
graphic_info[graphic].offset_x = 0; /* one or both of these values ... */
graphic_info[graphic].offset_y = 0; /* ... will be corrected later */
graphic_info[graphic].offset2_x = 0; /* one or both of these values ... */
graphic_info[graphic].anim_delay_random = 0;
graphic_info[graphic].post_delay_fixed = 0;
graphic_info[graphic].post_delay_random = 0;
+ graphic_info[graphic].fade_mode = FADE_MODE_DEFAULT;
+ graphic_info[graphic].fade_delay = -1;
+ graphic_info[graphic].post_delay = -1;
+ graphic_info[graphic].auto_delay = -1;
+ graphic_info[graphic].align = ALIGN_CENTER; /* default for title screens */
+ graphic_info[graphic].valign = VALIGN_MIDDLE; /* default for title screens */
+ graphic_info[graphic].sort_priority = 0; /* default for title screens */
+
+#if 1
+ /* optional zoom factor for scaling up the image to a larger size */
+ if (parameter[GFX_ARG_SCALE_UP_FACTOR] != ARG_UNDEFINED_VALUE)
+ graphic_info[graphic].scale_up_factor = parameter[GFX_ARG_SCALE_UP_FACTOR];
+ if (graphic_info[graphic].scale_up_factor < 1)
+ graphic_info[graphic].scale_up_factor = 1; /* no scaling */
+#endif
+
+#if 1
+ if (graphic_info[graphic].use_image_size)
+ {
+ /* set new default bitmap size (with scaling, but without small images) */
+ graphic_info[graphic].width = get_scaled_graphic_width(graphic);
+ graphic_info[graphic].height = get_scaled_graphic_height(graphic);
+ }
+#endif
/* optional x and y tile position of animation frame sequence */
if (parameter[GFX_ARG_XPOS] != ARG_UNDEFINED_VALUE)
if (parameter[GFX_ARG_HEIGHT] != ARG_UNDEFINED_VALUE)
graphic_info[graphic].height = parameter[GFX_ARG_HEIGHT];
+#if 0
/* optional zoom factor for scaling up the image to a larger size */
if (parameter[GFX_ARG_SCALE_UP_FACTOR] != ARG_UNDEFINED_VALUE)
graphic_info[graphic].scale_up_factor = parameter[GFX_ARG_SCALE_UP_FACTOR];
if (graphic_info[graphic].scale_up_factor < 1)
graphic_info[graphic].scale_up_factor = 1; /* no scaling */
+#endif
if (src_bitmap)
{
else
graphic_info[graphic].anim_frames = 1;
+ if (graphic_info[graphic].anim_frames == 0) /* frames must be at least 1 */
+ graphic_info[graphic].anim_frames = 1;
+
graphic_info[graphic].anim_frames_per_line =
(parameter[GFX_ARG_FRAMES_PER_LINE] != ARG_UNDEFINED_VALUE ?
parameter[GFX_ARG_FRAMES_PER_LINE] : anim_frames_per_line);
graphic_info[graphic].step_delay = parameter[GFX_ARG_STEP_DELAY];
/* this is only used for drawing font characters */
- graphic_info[graphic].draw_x = parameter[GFX_ARG_DRAW_XOFFSET];
- graphic_info[graphic].draw_y = parameter[GFX_ARG_DRAW_YOFFSET];
+ graphic_info[graphic].draw_xoffset = parameter[GFX_ARG_DRAW_XOFFSET];
+ graphic_info[graphic].draw_yoffset = parameter[GFX_ARG_DRAW_YOFFSET];
/* this is only used for drawing envelope graphics */
graphic_info[graphic].draw_masked = parameter[GFX_ARG_DRAW_MASKED];
/* optional graphic for cloning all graphics settings */
if (parameter[GFX_ARG_CLONE_FROM] != ARG_UNDEFINED_VALUE)
graphic_info[graphic].clone_from = parameter[GFX_ARG_CLONE_FROM];
+
+ /* optional settings for drawing title screens and title messages */
+ if (parameter[GFX_ARG_FADE_MODE] != ARG_UNDEFINED_VALUE)
+ graphic_info[graphic].fade_mode = parameter[GFX_ARG_FADE_MODE];
+ if (parameter[GFX_ARG_FADE_DELAY] != ARG_UNDEFINED_VALUE)
+ graphic_info[graphic].fade_delay = parameter[GFX_ARG_FADE_DELAY];
+ if (parameter[GFX_ARG_POST_DELAY] != ARG_UNDEFINED_VALUE)
+ graphic_info[graphic].post_delay = parameter[GFX_ARG_POST_DELAY];
+ if (parameter[GFX_ARG_AUTO_DELAY] != ARG_UNDEFINED_VALUE)
+ graphic_info[graphic].auto_delay = parameter[GFX_ARG_AUTO_DELAY];
+ if (parameter[GFX_ARG_ALIGN] != ARG_UNDEFINED_VALUE)
+ graphic_info[graphic].align = parameter[GFX_ARG_ALIGN];
+ if (parameter[GFX_ARG_VALIGN] != ARG_UNDEFINED_VALUE)
+ graphic_info[graphic].valign = parameter[GFX_ARG_VALIGN];
+ if (parameter[GFX_ARG_SORT_PRIORITY] != ARG_UNDEFINED_VALUE)
+ graphic_info[graphic].sort_priority = parameter[GFX_ARG_SORT_PRIORITY];
+#endif
+
+ UPDATE_BUSY_STATE();
}
static void set_cloned_graphic_parameters(int graphic)
if (num_references_followed >= max_num_images)
{
- Error(ERR_RETURN_LINE, "-");
- Error(ERR_RETURN, "warning: error found in config file:");
- Error(ERR_RETURN, "- config file: '%s'", getImageConfigFilename());
- Error(ERR_RETURN, "- config token: '%s'", getTokenFromImageID(graphic));
- Error(ERR_RETURN, "error: loop discovered when resolving cloned graphics");
- Error(ERR_RETURN, "custom graphic rejected for this element/action");
+ Error(ERR_INFO_LINE, "-");
+ Error(ERR_INFO, "warning: error found in config file:");
+ Error(ERR_INFO, "- config file: '%s'", getImageConfigFilename());
+ Error(ERR_INFO, "- config token: '%s'", getTokenFromImageID(graphic));
+ Error(ERR_INFO, "error: loop discovered when resolving cloned graphics");
+ Error(ERR_INFO, "custom graphic rejected for this element/action");
if (graphic == fallback_graphic)
Error(ERR_EXIT, "fatal error: no fallback graphic available");
- Error(ERR_RETURN, "fallback done to 'char_exclam' for this graphic");
- Error(ERR_RETURN_LINE, "-");
+ Error(ERR_INFO, "fallback done to 'char_exclam' for this graphic");
+ Error(ERR_INFO_LINE, "-");
graphic_info[graphic] = graphic_info[fallback_graphic];
}
GC copy_clipmask_gc = None;
#endif
+ /* use image size as default values for width and height for these images */
+ static int full_size_graphics[] =
+ {
+ IMG_GLOBAL_BORDER,
+ IMG_GLOBAL_DOOR,
+
+ IMG_BACKGROUND_ENVELOPE_1,
+ IMG_BACKGROUND_ENVELOPE_2,
+ IMG_BACKGROUND_ENVELOPE_3,
+ IMG_BACKGROUND_ENVELOPE_4,
+
+ IMG_BACKGROUND,
+ IMG_BACKGROUND_TITLE_INITIAL,
+ IMG_BACKGROUND_TITLE,
+ IMG_BACKGROUND_MAIN,
+ IMG_BACKGROUND_LEVELS,
+ IMG_BACKGROUND_SCORES,
+ IMG_BACKGROUND_EDITOR,
+ IMG_BACKGROUND_INFO,
+ IMG_BACKGROUND_INFO_ELEMENTS,
+ IMG_BACKGROUND_INFO_MUSIC,
+ IMG_BACKGROUND_INFO_CREDITS,
+ IMG_BACKGROUND_INFO_PROGRAM,
+ IMG_BACKGROUND_INFO_LEVELSET,
+ IMG_BACKGROUND_SETUP,
+ IMG_BACKGROUND_DOOR,
+
+ IMG_TITLESCREEN_INITIAL_1,
+ IMG_TITLESCREEN_INITIAL_2,
+ IMG_TITLESCREEN_INITIAL_3,
+ IMG_TITLESCREEN_INITIAL_4,
+ IMG_TITLESCREEN_INITIAL_5,
+ IMG_TITLESCREEN_1,
+ IMG_TITLESCREEN_2,
+ IMG_TITLESCREEN_3,
+ IMG_TITLESCREEN_4,
+ IMG_TITLESCREEN_5,
+
+ -1
+ };
+
checked_free(graphic_info);
graphic_info = checked_calloc(num_images * sizeof(struct GraphicInfo));
+#if 1
+ /* initialize "use_image_size" flag with default value */
+ for (i = 0; i < num_images; i++)
+ graphic_info[i].use_image_size = FALSE;
+
+ /* initialize "use_image_size" flag from static configuration above */
+ for (i = 0; full_size_graphics[i] != -1; i++)
+ graphic_info[full_size_graphics[i]].use_image_size = TRUE;
+#endif
+
#if defined(TARGET_X11_NATIVE_PERFORMANCE_WORKAROUND)
if (clipmasks_initialized)
{
{
Bitmap *src_bitmap;
int src_x, src_y;
+ int width, height;
int first_frame, last_frame;
int src_bitmap_width, src_bitmap_height;
if (graphic_info[i].bitmap == NULL)
continue; /* skip check for optional images that are undefined */
+ /* get image size (this can differ from the standard element tile size!) */
+ width = graphic_info[i].width;
+ height = graphic_info[i].height;
+
/* get final bitmap size (with scaling, but without small images) */
src_bitmap_width = graphic_info[i].src_image_width;
src_bitmap_height = graphic_info[i].src_image_height;
first_frame = 0;
getGraphicSource(i, first_frame, &src_bitmap, &src_x, &src_y);
+#if 1
+ /* this avoids calculating wrong start position for out-of-bounds frame */
+ src_x = graphic_info[i].src_x;
+ src_y = graphic_info[i].src_y;
+#endif
+
if (src_x < 0 || src_y < 0 ||
- src_x + TILEX > src_bitmap_width ||
- src_y + TILEY > src_bitmap_height)
+ src_x + width > src_bitmap_width ||
+ src_y + height > src_bitmap_height)
{
- Error(ERR_RETURN_LINE, "-");
- Error(ERR_RETURN, "warning: error found in config file:");
- Error(ERR_RETURN, "- config file: '%s'", getImageConfigFilename());
- Error(ERR_RETURN, "- config token: '%s'", getTokenFromImageID(i));
- Error(ERR_RETURN, "- image file: '%s'", src_bitmap->source_filename);
- Error(ERR_RETURN,
+ Error(ERR_INFO_LINE, "-");
+ Error(ERR_INFO, "warning: error found in config file:");
+ Error(ERR_INFO, "- config file: '%s'", getImageConfigFilename());
+ Error(ERR_INFO, "- config token: '%s'", getTokenFromImageID(i));
+ Error(ERR_INFO, "- image file: '%s'", src_bitmap->source_filename);
+ Error(ERR_INFO,
"error: first animation frame out of bounds (%d, %d) [%d, %d]",
src_x, src_y, src_bitmap_width, src_bitmap_height);
- Error(ERR_RETURN, "custom graphic rejected for this element/action");
+ Error(ERR_INFO, "custom graphic rejected for this element/action");
if (i == fallback_graphic)
Error(ERR_EXIT, "fatal error: no fallback graphic available");
- Error(ERR_RETURN, "fallback done to 'char_exclam' for this graphic");
- Error(ERR_RETURN_LINE, "-");
+ Error(ERR_INFO, "fallback done to 'char_exclam' for this graphic");
+ Error(ERR_INFO_LINE, "-");
graphic_info[i] = graphic_info[fallback_graphic];
}
getGraphicSource(i, last_frame, &src_bitmap, &src_x, &src_y);
if (src_x < 0 || src_y < 0 ||
- src_x + TILEX > src_bitmap_width ||
- src_y + TILEY > src_bitmap_height)
+ src_x + width > src_bitmap_width ||
+ src_y + height > src_bitmap_height)
{
- Error(ERR_RETURN_LINE, "-");
- Error(ERR_RETURN, "warning: error found in config file:");
- Error(ERR_RETURN, "- config file: '%s'", getImageConfigFilename());
- Error(ERR_RETURN, "- config token: '%s'", getTokenFromImageID(i));
- Error(ERR_RETURN, "- image file: '%s'", src_bitmap->source_filename);
- Error(ERR_RETURN,
+ Error(ERR_INFO_LINE, "-");
+ Error(ERR_INFO, "warning: error found in config file:");
+ Error(ERR_INFO, "- config file: '%s'", getImageConfigFilename());
+ Error(ERR_INFO, "- config token: '%s'", getTokenFromImageID(i));
+ Error(ERR_INFO, "- image file: '%s'", src_bitmap->source_filename);
+ Error(ERR_INFO,
"error: last animation frame (%d) out of bounds (%d, %d) [%d, %d]",
last_frame, src_x, src_y, src_bitmap_width, src_bitmap_height);
- Error(ERR_RETURN, "custom graphic rejected for this element/action");
+ Error(ERR_INFO, "custom graphic rejected for this element/action");
if (i == fallback_graphic)
Error(ERR_EXIT, "fatal error: no fallback graphic available");
- Error(ERR_RETURN, "fallback done to 'char_exclam' for this graphic");
- Error(ERR_RETURN_LINE, "-");
+ Error(ERR_INFO, "fallback done to 'char_exclam' for this graphic");
+ Error(ERR_INFO_LINE, "-");
graphic_info[i] = graphic_info[fallback_graphic];
}
element_info[element].sound[action] = sound;
else
for (j = 0; j < MAX_NUM_ELEMENTS; j++)
- if (strcmp(element_info[j].class_name,
- element_info[element].class_name) == 0)
+ if (strEqual(element_info[j].class_name,
+ element_info[element].class_name))
element_info[j].sound[action] = sound;
}
action = ACTION_DEFAULT;
for (j = 0; j < MAX_NUM_ELEMENTS; j++)
- if (strcmp(element_info[j].class_name,
- element_info[element_class].class_name) == 0)
+ if (strEqual(element_info[j].class_name,
+ element_info[element_class].class_name))
element_info[j].sound[action] = sound;
}
sound_info[sound].volume = parameter[SND_ARG_VOLUME];
/* sound priority to give certain sounds a higher or lower priority */
- sound_info[sound].volume = parameter[SND_ARG_VOLUME];
+ sound_info[sound].priority = parameter[SND_ARG_PRIORITY];
}
static void InitSoundInfo()
int len_action_text = strlen(element_action_info[j].suffix);
if (len_action_text < len_effect_text &&
- strcmp(&sound->token[len_effect_text - len_action_text],
- element_action_info[j].suffix) == 0)
+ strEqual(&sound->token[len_effect_text - len_action_text],
+ element_action_info[j].suffix))
{
sound_effect_properties[i] = element_action_info[j].value;
sound_info[i].loop = element_action_info[j].is_loop_sound;
static void ReinitializeGraphics()
{
+ print_timestamp_init("ReinitializeGraphics");
+
InitGraphicInfo(); /* graphic properties mapping */
+ print_timestamp_time("InitGraphicInfo");
InitElementGraphicInfo(); /* element game graphic mapping */
+ print_timestamp_time("InitElementGraphicInfo");
InitElementSpecialGraphicInfo(); /* element special graphic mapping */
+ print_timestamp_time("InitElementSpecialGraphicInfo");
- InitElementSmallImages(); /* scale images to all needed sizes */
+ InitElementSmallImages(); /* scale elements to all needed sizes */
+ print_timestamp_time("InitElementSmallImages");
+ InitScaledImages(); /* scale all other images, if needed */
+ print_timestamp_time("InitScaledImages");
InitFontGraphicInfo(); /* initialize text drawing functions */
+ print_timestamp_time("InitFontGraphicInfo");
InitGraphicInfo_EM(); /* graphic mapping for EM engine */
+ print_timestamp_time("InitGraphicInfo_EM");
SetMainBackgroundImage(IMG_BACKGROUND);
+ print_timestamp_time("SetMainBackgroundImage");
SetDoorBackgroundImage(IMG_BACKGROUND_DOOR);
+ print_timestamp_time("SetDoorBackgroundImage");
InitGadgets();
+ print_timestamp_time("InitGadgets");
InitToons();
+ print_timestamp_time("InitToons");
+
+ print_timestamp_done("ReinitializeGraphics");
}
static void ReinitializeSounds()
{ EL_SP_MURPHY, 0 },
{ EL_SOKOBAN_FIELD_PLAYER, 0 },
- /* all element that can move may be able to also move into acid */
+ /* all elements that can move may be able to also move into acid */
{ EL_BUG, 1 },
{ EL_BUG_LEFT, 1 },
{ EL_BUG_RIGHT, 1 },
{ EL_BD_FIREFLY_UP, 4 },
{ EL_BD_FIREFLY_DOWN, 4 },
{ EL_YAMYAM, 5 },
+ { EL_YAMYAM_LEFT, 5 },
+ { EL_YAMYAM_RIGHT, 5 },
+ { EL_YAMYAM_UP, 5 },
+ { EL_YAMYAM_DOWN, 5 },
{ EL_DARK_YAMYAM, 6 },
{ EL_ROBOT, 7 },
{ EL_PACMAN, 8 },
{ EL_SP_ELECTRON, 15 },
{ EL_BALLOON, 16 },
{ EL_SPRING, 17 },
+ { EL_EMC_ANDROID, 18 },
{ -1, -1 },
};
return FALSE;
}
+static void ResolveGroupElementExt(int group_element, int recursion_depth)
+{
+ static int group_nr;
+ static struct ElementGroupInfo *group;
+ struct ElementGroupInfo *actual_group = element_info[group_element].group;
+ int i;
+
+ if (actual_group == NULL) /* not yet initialized */
+ return;
+
+ if (recursion_depth > NUM_GROUP_ELEMENTS) /* recursion too deep */
+ {
+ Error(ERR_WARN, "recursion too deep when resolving group element %d",
+ group_element - EL_GROUP_START + 1);
+
+ /* replace element which caused too deep recursion by question mark */
+ group->element_resolved[group->num_elements_resolved++] = EL_UNKNOWN;
+
+ return;
+ }
+
+ if (recursion_depth == 0) /* initialization */
+ {
+ group = actual_group;
+ group_nr = GROUP_NR(group_element);
+
+ group->num_elements_resolved = 0;
+ group->choice_pos = 0;
+
+ for (i = 0; i < MAX_NUM_ELEMENTS; i++)
+ element_info[i].in_group[group_nr] = FALSE;
+ }
+
+ for (i = 0; i < actual_group->num_elements; i++)
+ {
+ int element = actual_group->element[i];
+
+ if (group->num_elements_resolved == NUM_FILE_ELEMENTS)
+ break;
+
+ if (IS_GROUP_ELEMENT(element))
+ ResolveGroupElementExt(element, recursion_depth + 1);
+ else
+ {
+ group->element_resolved[group->num_elements_resolved++] = element;
+ element_info[element].in_group[group_nr] = TRUE;
+ }
+ }
+}
+
+void ResolveGroupElement(int group_element)
+{
+ ResolveGroupElementExt(group_element, 0);
+}
+
void InitElementPropertiesStatic()
{
+ static boolean clipboard_elements_initialized = FALSE;
+
static int ep_diggable[] =
{
EL_SAND,
/* (if amoeba can grow into anything diggable, maybe keep these out) */
#if 0
EL_LANDMINE,
+ EL_DC_LANDMINE,
EL_TRAP_ACTIVE,
EL_SP_BUGGY_BASE_ACTIVE,
EL_EMC_PLANT,
#endif
+
-1
};
EL_EMC_KEY_7,
EL_EMC_KEY_8,
EL_DYNAMITE,
+ EL_EM_DYNAMITE,
EL_DYNABOMB_INCREASE_NUMBER,
EL_DYNABOMB_INCREASE_SIZE,
EL_DYNABOMB_INCREASE_POWER,
EL_SP_DISK_RED,
EL_PEARL,
EL_CRYSTAL,
- EL_KEY_WHITE,
+ EL_DC_KEY_WHITE,
EL_SHIELD_NORMAL,
EL_SHIELD_DEADLY,
EL_EXTRA_TIME,
EL_SPEED_PILL,
EL_EMC_LENSES,
EL_EMC_MAGNIFIER,
+
+#if 0
+ /* !!! handle separately !!! */
+ EL_DC_LANDMINE, /* deadly when running into, but can be snapped */
+#endif
+
-1
};
/* !!! maybe this should better be handled by 'ep_diggable' !!! */
#if 1
EL_LANDMINE,
+ EL_DC_LANDMINE,
EL_TRAP_ACTIVE,
EL_SP_BUGGY_BASE_ACTIVE,
EL_EMC_PLANT,
#endif
+
-1
};
EL_PACMAN,
EL_SP_SNIKSNAK,
EL_SP_ELECTRON,
+
-1
};
EL_SPACESHIP,
EL_BD_BUTTERFLY,
EL_BD_FIREFLY,
+
-1
};
EL_SIGN_STOP,
EL_SIGN_WHEELCHAIR,
EL_SIGN_PARKING,
- EL_SIGN_ONEWAY,
+ EL_SIGN_NO_ENTRY,
+ EL_SIGN_UNUSED_1,
+ EL_SIGN_GIVE_WAY,
+ EL_SIGN_ENTRY_FORBIDDEN,
+ EL_SIGN_EMERGENCY_EXIT,
+ EL_SIGN_YIN_YANG,
+ EL_SIGN_UNUSED_2,
+ EL_SIGN_SPERMS,
+ EL_SIGN_BULLET,
EL_SIGN_HEART,
- EL_SIGN_TRIANGLE,
- EL_SIGN_ROUND,
- EL_SIGN_EXIT,
- EL_SIGN_YINYANG,
- EL_SIGN_OTHER,
+ EL_SIGN_CROSS,
+ EL_SIGN_FRANKIE,
+ EL_STEEL_EXIT_CLOSED,
+ EL_STEEL_EXIT_OPEN,
+ EL_EM_STEEL_EXIT_CLOSED,
+ EL_EM_STEEL_EXIT_OPEN,
+ EL_DC_STEELWALL_1_LEFT,
+ EL_DC_STEELWALL_1_RIGHT,
+ EL_DC_STEELWALL_1_TOP,
+ EL_DC_STEELWALL_1_BOTTOM,
+ EL_DC_STEELWALL_1_HORIZONTAL,
+ EL_DC_STEELWALL_1_VERTICAL,
+ EL_DC_STEELWALL_1_TOPLEFT,
+ EL_DC_STEELWALL_1_TOPRIGHT,
+ EL_DC_STEELWALL_1_BOTTOMLEFT,
+ EL_DC_STEELWALL_1_BOTTOMRIGHT,
+ EL_DC_STEELWALL_1_TOPLEFT_2,
+ EL_DC_STEELWALL_1_TOPRIGHT_2,
+ EL_DC_STEELWALL_1_BOTTOMLEFT_2,
+ EL_DC_STEELWALL_1_BOTTOMRIGHT_2,
+ EL_DC_STEELWALL_2_LEFT,
+ EL_DC_STEELWALL_2_RIGHT,
+ EL_DC_STEELWALL_2_TOP,
+ EL_DC_STEELWALL_2_BOTTOM,
+ EL_DC_STEELWALL_2_HORIZONTAL,
+ EL_DC_STEELWALL_2_VERTICAL,
+ EL_DC_STEELWALL_2_MIDDLE,
+ EL_DC_STEELWALL_2_SINGLE,
EL_STEELWALL_SLIPPERY,
EL_EMC_STEELWALL_1,
EL_EMC_STEELWALL_2,
EL_EMC_GATE_6_GRAY_ACTIVE,
EL_EMC_GATE_7_GRAY_ACTIVE,
EL_EMC_GATE_8_GRAY_ACTIVE,
+ EL_DC_GATE_WHITE,
+ EL_DC_GATE_WHITE_GRAY,
+ EL_DC_GATE_WHITE_GRAY_ACTIVE,
+ EL_DC_GATE_FAKE_GRAY,
EL_SWITCHGATE_OPEN,
EL_SWITCHGATE_OPENING,
EL_SWITCHGATE_CLOSED,
EL_SWITCHGATE_CLOSING,
-#if 0
- EL_SWITCHGATE_SWITCH_UP,
- EL_SWITCHGATE_SWITCH_DOWN,
+#if 1
+ EL_DC_SWITCHGATE_SWITCH_UP,
+ EL_DC_SWITCHGATE_SWITCH_DOWN,
#endif
EL_TIMEGATE_OPEN,
EL_TIMEGATE_OPENING,
EL_TIMEGATE_CLOSED,
EL_TIMEGATE_CLOSING,
-#if 0
- EL_TIMEGATE_SWITCH,
- EL_TIMEGATE_SWITCH_ACTIVE,
+#if 1
+ EL_DC_TIMEGATE_SWITCH,
+ EL_DC_TIMEGATE_SWITCH_ACTIVE,
#endif
EL_TUBE_ANY,
EL_TUBE_VERTICAL,
EL_TUBE_LEFT_DOWN,
EL_TUBE_RIGHT_UP,
EL_TUBE_RIGHT_DOWN,
+ EL_EXPANDABLE_STEELWALL_HORIZONTAL,
+ EL_EXPANDABLE_STEELWALL_VERTICAL,
+ EL_EXPANDABLE_STEELWALL_ANY,
+
-1
};
EL_EMC_WALL_SLIPPERY_2,
EL_EMC_WALL_SLIPPERY_3,
EL_EMC_WALL_SLIPPERY_4,
+ EL_EMC_MAGIC_BALL,
+ EL_EMC_MAGIC_BALL_ACTIVE,
+
-1
};
EL_BALLOON,
EL_SPRING,
EL_EMC_ANDROID,
+
-1
};
EL_NUT,
EL_AMOEBA_DROP,
EL_QUICKSAND_FULL,
+ EL_QUICKSAND_FAST_FULL,
EL_MAGIC_WALL_FULL,
EL_BD_MAGIC_WALL_FULL,
+ EL_DC_MAGIC_WALL_FULL,
EL_TIME_ORB_FULL,
EL_TIME_ORB_EMPTY,
EL_SP_ZONK,
EL_CRYSTAL,
EL_SPRING,
EL_DX_SUPABOMB,
+
-1
};
EL_CRYSTAL,
EL_SPRING,
EL_DX_SUPABOMB,
+
-1
};
EL_ROCK,
EL_BD_ROCK,
EL_SP_ZONK,
+
-1
};
EL_ROCK,
EL_BD_ROCK,
EL_SP_ZONK,
+
-1
};
EL_MOLE,
/* new elements */
- EL_DYNAMITE_ACTIVE,
EL_DYNAMITE,
+ EL_DYNAMITE_ACTIVE,
+ EL_EM_DYNAMITE,
+ EL_EM_DYNAMITE_ACTIVE,
EL_DYNABOMB_PLAYER_1_ACTIVE,
EL_DYNABOMB_PLAYER_2_ACTIVE,
EL_DYNABOMB_PLAYER_3_ACTIVE,
#if 0
EL_BLACK_ORB,
#endif
+
-1
};
EL_PIG,
EL_DRAGON,
EL_MOLE,
+
-1
};
EL_BOMB,
EL_SP_DISK_ORANGE,
EL_DX_SUPABOMB,
+
-1
};
EL_SP_EMPTY_SPACE,
EL_SOKOBAN_FIELD_EMPTY,
EL_EXIT_OPEN,
+ EL_EM_EXIT_OPEN,
EL_SP_EXIT_OPEN,
EL_SP_EXIT_OPENING,
+ EL_STEEL_EXIT_OPEN,
+ EL_EM_STEEL_EXIT_OPEN,
EL_GATE_1,
EL_GATE_2,
EL_GATE_3,
EL_PENGUIN,
EL_PIG,
EL_DRAGON,
+
-1
};
EL_TUBE_LEFT_DOWN,
EL_TUBE_RIGHT_UP,
EL_TUBE_RIGHT_DOWN,
+
-1
};
EL_EMC_GATE_6_GRAY_ACTIVE,
EL_EMC_GATE_7_GRAY_ACTIVE,
EL_EMC_GATE_8_GRAY_ACTIVE,
+ EL_DC_GATE_WHITE,
+ EL_DC_GATE_WHITE_GRAY,
+ EL_DC_GATE_WHITE_GRAY_ACTIVE,
EL_SWITCHGATE_OPEN,
EL_TIMEGATE_OPEN,
+
-1
};
EL_SP_GRAVITY_OFF_PORT_RIGHT,
EL_SP_GRAVITY_OFF_PORT_UP,
EL_SP_GRAVITY_OFF_PORT_DOWN,
+
-1
};
EL_SP_DISK_YELLOW,
EL_BALLOON,
EL_EMC_ANDROID,
+
-1
};
EL_EMC_GATE_6_GRAY_ACTIVE,
EL_EMC_GATE_7_GRAY_ACTIVE,
EL_EMC_GATE_8_GRAY_ACTIVE,
+ EL_DC_GATE_WHITE,
+ EL_DC_GATE_WHITE_GRAY,
+ EL_DC_GATE_WHITE_GRAY_ACTIVE,
EL_SWITCHGATE_OPEN,
EL_TIMEGATE_OPEN,
EL_SP_GRAVITY_OFF_PORT_RIGHT,
EL_SP_GRAVITY_OFF_PORT_UP,
EL_SP_GRAVITY_OFF_PORT_DOWN,
+
-1
};
EL_MOLE,
/* elements that can explode by explosion or by dragonfire */
- EL_DYNAMITE_ACTIVE,
EL_DYNAMITE,
+ EL_DYNAMITE_ACTIVE,
+ EL_EM_DYNAMITE,
+ EL_EM_DYNAMITE_ACTIVE,
EL_DYNABOMB_PLAYER_1_ACTIVE,
EL_DYNABOMB_PLAYER_2_ACTIVE,
EL_DYNABOMB_PLAYER_3_ACTIVE,
/* elements that can explode only by explosion */
EL_BLACK_ORB,
+
-1
};
EL_SP_GRAVITY_OFF_PORT_UP,
EL_SP_GRAVITY_OFF_PORT_DOWN,
EL_EMC_GRASS,
+
-1
};
EL_SP_MURPHY,
EL_SOKOBAN_FIELD_PLAYER,
EL_TRIGGER_PLAYER,
+
-1
};
EL_EMERALD_RED,
EL_EMERALD_PURPLE,
EL_DIAMOND,
+
+ -1
+ };
+
+ static int ep_can_pass_dc_magic_wall[] =
+ {
+ EL_ROCK,
+ EL_BD_ROCK,
+ EL_EMERALD,
+ EL_BD_DIAMOND,
+ EL_EMERALD_YELLOW,
+ EL_EMERALD_RED,
+ EL_EMERALD_PURPLE,
+ EL_DIAMOND,
+ EL_PEARL,
+ EL_CRYSTAL,
+
-1
};
EL_CONVEYOR_BELT_4_SWITCH_RIGHT,
EL_SWITCHGATE_SWITCH_UP,
EL_SWITCHGATE_SWITCH_DOWN,
+ EL_DC_SWITCHGATE_SWITCH_UP,
+ EL_DC_SWITCHGATE_SWITCH_DOWN,
EL_LIGHT_SWITCH,
EL_LIGHT_SWITCH_ACTIVE,
EL_TIMEGATE_SWITCH,
+ EL_DC_TIMEGATE_SWITCH,
EL_BALLOON_SWITCH_LEFT,
EL_BALLOON_SWITCH_RIGHT,
EL_BALLOON_SWITCH_UP,
EL_LAMP,
EL_TIME_ORB_FULL,
EL_EMC_MAGIC_BALL_SWITCH,
+ EL_EMC_MAGIC_BALL_SWITCH_ACTIVE,
+
-1
};
EL_BD_AMOEBA,
EL_CHAR_QUESTION,
EL_UNKNOWN,
+
-1
};
EL_SP_BUGGY_BASE_ACTIVE,
EL_SP_EXIT_OPENING,
EL_SP_EXIT_CLOSING,
+
-1
};
EL_PLAYER_3,
EL_PLAYER_4,
EL_INVISIBLE_STEELWALL,
+
-1
};
EL_EMERALD_RED,
EL_EMERALD_PURPLE,
EL_DIAMOND,
+
-1
};
EL_DIAMOND,
EL_PEARL,
EL_CRYSTAL,
+
-1
};
EL_DIAMOND,
EL_PEARL,
EL_CRYSTAL,
+
-1
};
EL_EMERALD_RED,
EL_EMERALD_PURPLE,
EL_DIAMOND,
+
-1
};
EL_EXPANDABLE_WALL_VERTICAL,
EL_EXPANDABLE_WALL_ANY,
EL_EXPANDABLE_WALL_GROWING,
+ EL_BD_EXPANDABLE_WALL,
EL_BD_WALL,
EL_SP_CHIP_SINGLE,
EL_SP_CHIP_LEFT,
EL_EMC_WALL_6,
EL_EMC_WALL_7,
EL_EMC_WALL_8,
+
-1
};
EL_EXPANDABLE_WALL_HORIZONTAL,
EL_EXPANDABLE_WALL_VERTICAL,
EL_EXPANDABLE_WALL_ANY,
+ EL_BD_EXPANDABLE_WALL,
EL_BD_WALL,
EL_WALL_SLIPPERY,
EL_EXIT_CLOSED,
EL_INVISIBLE_WALL_ACTIVE,
EL_SWITCHGATE_SWITCH_UP,
EL_SWITCHGATE_SWITCH_DOWN,
+ EL_DC_SWITCHGATE_SWITCH_UP,
+ EL_DC_SWITCHGATE_SWITCH_DOWN,
EL_TIMEGATE_SWITCH,
EL_TIMEGATE_SWITCH_ACTIVE,
+ EL_DC_TIMEGATE_SWITCH,
+ EL_DC_TIMEGATE_SWITCH_ACTIVE,
EL_EMC_WALL_1,
EL_EMC_WALL_2,
EL_EMC_WALL_3,
EL_SIGN_STOP,
EL_SIGN_WHEELCHAIR,
EL_SIGN_PARKING,
- EL_SIGN_ONEWAY,
+ EL_SIGN_NO_ENTRY,
+ EL_SIGN_UNUSED_1,
+ EL_SIGN_GIVE_WAY,
+ EL_SIGN_ENTRY_FORBIDDEN,
+ EL_SIGN_EMERGENCY_EXIT,
+ EL_SIGN_YIN_YANG,
+ EL_SIGN_UNUSED_2,
+ EL_SIGN_SPERMS,
+ EL_SIGN_BULLET,
EL_SIGN_HEART,
- EL_SIGN_TRIANGLE,
- EL_SIGN_ROUND,
- EL_SIGN_EXIT,
- EL_SIGN_YINYANG,
- EL_SIGN_OTHER,
+ EL_SIGN_CROSS,
+ EL_SIGN_FRANKIE,
+ EL_STEEL_EXIT_CLOSED,
+ EL_STEEL_EXIT_OPEN,
+ EL_DC_STEELWALL_1_LEFT,
+ EL_DC_STEELWALL_1_RIGHT,
+ EL_DC_STEELWALL_1_TOP,
+ EL_DC_STEELWALL_1_BOTTOM,
+ EL_DC_STEELWALL_1_HORIZONTAL,
+ EL_DC_STEELWALL_1_VERTICAL,
+ EL_DC_STEELWALL_1_TOPLEFT,
+ EL_DC_STEELWALL_1_TOPRIGHT,
+ EL_DC_STEELWALL_1_BOTTOMLEFT,
+ EL_DC_STEELWALL_1_BOTTOMRIGHT,
+ EL_DC_STEELWALL_1_TOPLEFT_2,
+ EL_DC_STEELWALL_1_TOPRIGHT_2,
+ EL_DC_STEELWALL_1_BOTTOMLEFT_2,
+ EL_DC_STEELWALL_1_BOTTOMRIGHT_2,
+ EL_DC_STEELWALL_2_LEFT,
+ EL_DC_STEELWALL_2_RIGHT,
+ EL_DC_STEELWALL_2_TOP,
+ EL_DC_STEELWALL_2_BOTTOM,
+ EL_DC_STEELWALL_2_HORIZONTAL,
+ EL_DC_STEELWALL_2_VERTICAL,
+ EL_DC_STEELWALL_2_MIDDLE,
+ EL_DC_STEELWALL_2_SINGLE,
EL_STEELWALL_SLIPPERY,
EL_EMC_STEELWALL_1,
EL_EMC_STEELWALL_2,
EL_TUBE_LEFT_DOWN,
EL_TUBE_RIGHT_UP,
EL_TUBE_RIGHT_DOWN,
+
-1
};
EL_PACMAN,
EL_SP_SNIKSNAK,
EL_SP_ELECTRON,
+
-1
};
EL_CONVEYOR_BELT_4_LEFT,
EL_CONVEYOR_BELT_4_MIDDLE,
EL_CONVEYOR_BELT_4_RIGHT,
+
-1
};
EL_CONVEYOR_BELT_4_LEFT_ACTIVE,
EL_CONVEYOR_BELT_4_MIDDLE_ACTIVE,
EL_CONVEYOR_BELT_4_RIGHT_ACTIVE,
+
-1
};
EL_CONVEYOR_BELT_4_SWITCH_LEFT,
EL_CONVEYOR_BELT_4_SWITCH_MIDDLE,
EL_CONVEYOR_BELT_4_SWITCH_RIGHT,
+
-1
};
EL_TUBE_VERTICAL_LEFT,
EL_TUBE_VERTICAL_RIGHT,
EL_TUBE_ANY,
+
+ -1
+ };
+
+ static int ep_acid_pool[] =
+ {
+ EL_ACID_POOL_TOPLEFT,
+ EL_ACID_POOL_TOPRIGHT,
+ EL_ACID_POOL_BOTTOMLEFT,
+ EL_ACID_POOL_BOTTOM,
+ EL_ACID_POOL_BOTTOMRIGHT,
+
-1
};
EL_EMC_GATE_6_GRAY_ACTIVE,
EL_EMC_GATE_7_GRAY_ACTIVE,
EL_EMC_GATE_8_GRAY_ACTIVE,
+ EL_DC_GATE_WHITE,
+ EL_DC_GATE_WHITE_GRAY,
+ EL_DC_GATE_WHITE_GRAY_ACTIVE,
+
-1
};
EL_AMOEBA_DRY,
EL_AMOEBA_FULL,
EL_BD_AMOEBA,
+ EL_EMC_DRIPPER,
+
-1
};
EL_AMOEBA_DRY,
EL_AMOEBA_FULL,
EL_BD_AMOEBA,
+ EL_EMC_DRIPPER,
+
-1
};
- static int ep_has_content[] =
+ static int ep_has_editor_content[] =
{
+ EL_PLAYER_1,
+ EL_PLAYER_2,
+ EL_PLAYER_3,
+ EL_PLAYER_4,
+ EL_SP_MURPHY,
EL_YAMYAM,
+ EL_YAMYAM_LEFT,
+ EL_YAMYAM_RIGHT,
+ EL_YAMYAM_UP,
+ EL_YAMYAM_DOWN,
EL_AMOEBA_WET,
EL_AMOEBA_DRY,
EL_AMOEBA_FULL,
EL_BD_AMOEBA,
EL_EMC_MAGIC_BALL,
+ EL_EMC_ANDROID,
+
-1
};
EL_AMOEBA_FULL,
EL_GAME_OF_LIFE,
EL_BIOMAZE,
+ EL_EMC_DRIPPER,
+
-1
};
static int ep_active_bomb[] =
{
EL_DYNAMITE_ACTIVE,
+ EL_EM_DYNAMITE_ACTIVE,
EL_DYNABOMB_PLAYER_1_ACTIVE,
EL_DYNABOMB_PLAYER_2_ACTIVE,
EL_DYNABOMB_PLAYER_3_ACTIVE,
EL_DYNABOMB_PLAYER_4_ACTIVE,
EL_SP_DISK_RED_ACTIVE,
+
-1
};
EL_STEELWALL,
EL_AMOEBA_DEAD,
EL_QUICKSAND_EMPTY,
+ EL_QUICKSAND_FAST_EMPTY,
EL_STONEBLOCK,
EL_ROBOT_WHEEL,
EL_KEY_1,
EL_EMC_GATE_6_GRAY_ACTIVE,
EL_EMC_GATE_7_GRAY_ACTIVE,
EL_EMC_GATE_8_GRAY_ACTIVE,
+ EL_DC_GATE_WHITE,
+ EL_DC_GATE_WHITE_GRAY,
+ EL_DC_GATE_WHITE_GRAY_ACTIVE,
+ EL_DC_GATE_FAKE_GRAY,
EL_DYNAMITE,
+ EL_EM_DYNAMITE,
EL_INVISIBLE_STEELWALL,
EL_INVISIBLE_WALL,
EL_INVISIBLE_SAND,
EL_MAGIC_WALL_DEAD,
EL_BD_MAGIC_WALL,
EL_BD_MAGIC_WALL_DEAD,
+ EL_DC_MAGIC_WALL,
+ EL_DC_MAGIC_WALL_DEAD,
EL_AMOEBA_TO_DIAMOND,
EL_BLOCKED,
EL_SP_EMPTY,
EL_SIGN_STOP,
EL_SIGN_WHEELCHAIR,
EL_SIGN_PARKING,
- EL_SIGN_ONEWAY,
+ EL_SIGN_NO_ENTRY,
+ EL_SIGN_UNUSED_1,
+ EL_SIGN_GIVE_WAY,
+ EL_SIGN_ENTRY_FORBIDDEN,
+ EL_SIGN_EMERGENCY_EXIT,
+ EL_SIGN_YIN_YANG,
+ EL_SIGN_UNUSED_2,
+ EL_SIGN_SPERMS,
+ EL_SIGN_BULLET,
EL_SIGN_HEART,
- EL_SIGN_TRIANGLE,
- EL_SIGN_ROUND,
- EL_SIGN_EXIT,
- EL_SIGN_YINYANG,
- EL_SIGN_OTHER,
+ EL_SIGN_CROSS,
+ EL_SIGN_FRANKIE,
+ EL_DC_STEELWALL_1_LEFT,
+ EL_DC_STEELWALL_1_RIGHT,
+ EL_DC_STEELWALL_1_TOP,
+ EL_DC_STEELWALL_1_BOTTOM,
+ EL_DC_STEELWALL_1_HORIZONTAL,
+ EL_DC_STEELWALL_1_VERTICAL,
+ EL_DC_STEELWALL_1_TOPLEFT,
+ EL_DC_STEELWALL_1_TOPRIGHT,
+ EL_DC_STEELWALL_1_BOTTOMLEFT,
+ EL_DC_STEELWALL_1_BOTTOMRIGHT,
+ EL_DC_STEELWALL_1_TOPLEFT_2,
+ EL_DC_STEELWALL_1_TOPRIGHT_2,
+ EL_DC_STEELWALL_1_BOTTOMLEFT_2,
+ EL_DC_STEELWALL_1_BOTTOMRIGHT_2,
+ EL_DC_STEELWALL_2_LEFT,
+ EL_DC_STEELWALL_2_RIGHT,
+ EL_DC_STEELWALL_2_TOP,
+ EL_DC_STEELWALL_2_BOTTOM,
+ EL_DC_STEELWALL_2_HORIZONTAL,
+ EL_DC_STEELWALL_2_VERTICAL,
+ EL_DC_STEELWALL_2_MIDDLE,
+ EL_DC_STEELWALL_2_SINGLE,
EL_STEELWALL_SLIPPERY,
EL_EMC_STEELWALL_1,
EL_EMC_STEELWALL_2,
EL_EMC_WALL_14,
EL_EMC_WALL_15,
EL_EMC_WALL_16,
+
-1
};
{
EL_SAND,
EL_LANDMINE,
+ EL_DC_LANDMINE,
EL_TRAP,
EL_TRAP_ACTIVE,
+
+ -1
+ };
+
+ static int ep_editor_cascade_active[] =
+ {
+ EL_INTERNAL_CASCADE_BD_ACTIVE,
+ EL_INTERNAL_CASCADE_EM_ACTIVE,
+ EL_INTERNAL_CASCADE_EMC_ACTIVE,
+ EL_INTERNAL_CASCADE_RND_ACTIVE,
+ EL_INTERNAL_CASCADE_SB_ACTIVE,
+ EL_INTERNAL_CASCADE_SP_ACTIVE,
+ EL_INTERNAL_CASCADE_DC_ACTIVE,
+ EL_INTERNAL_CASCADE_DX_ACTIVE,
+ EL_INTERNAL_CASCADE_CHARS_ACTIVE,
+ EL_INTERNAL_CASCADE_STEEL_CHARS_ACTIVE,
+ EL_INTERNAL_CASCADE_CE_ACTIVE,
+ EL_INTERNAL_CASCADE_GE_ACTIVE,
+ EL_INTERNAL_CASCADE_REF_ACTIVE,
+ EL_INTERNAL_CASCADE_USER_ACTIVE,
+ EL_INTERNAL_CASCADE_DYNAMIC_ACTIVE,
+
+ -1
+ };
+
+ static int ep_editor_cascade_inactive[] =
+ {
+ EL_INTERNAL_CASCADE_BD,
+ EL_INTERNAL_CASCADE_EM,
+ EL_INTERNAL_CASCADE_EMC,
+ EL_INTERNAL_CASCADE_RND,
+ EL_INTERNAL_CASCADE_SB,
+ EL_INTERNAL_CASCADE_SP,
+ EL_INTERNAL_CASCADE_DC,
+ EL_INTERNAL_CASCADE_DX,
+ EL_INTERNAL_CASCADE_CHARS,
+ EL_INTERNAL_CASCADE_STEEL_CHARS,
+ EL_INTERNAL_CASCADE_CE,
+ EL_INTERNAL_CASCADE_GE,
+ EL_INTERNAL_CASCADE_REF,
+ EL_INTERNAL_CASCADE_USER,
+ EL_INTERNAL_CASCADE_DYNAMIC,
+
+ -1
+ };
+
+ static int ep_obsolete[] =
+ {
+ EL_PLAYER_OBSOLETE,
+ EL_KEY_OBSOLETE,
+ EL_EM_KEY_1_FILE_OBSOLETE,
+ EL_EM_KEY_2_FILE_OBSOLETE,
+ EL_EM_KEY_3_FILE_OBSOLETE,
+ EL_EM_KEY_4_FILE_OBSOLETE,
+ EL_ENVELOPE_OBSOLETE,
+
-1
};
int property;
} element_properties[] =
{
- { ep_diggable, EP_DIGGABLE },
- { ep_collectible_only, EP_COLLECTIBLE_ONLY },
- { ep_dont_run_into, EP_DONT_RUN_INTO },
- { ep_dont_collide_with, EP_DONT_COLLIDE_WITH },
- { ep_dont_touch, EP_DONT_TOUCH },
- { ep_indestructible, EP_INDESTRUCTIBLE },
- { ep_slippery, EP_SLIPPERY },
- { ep_can_change, EP_CAN_CHANGE },
- { ep_can_move, EP_CAN_MOVE },
- { ep_can_fall, EP_CAN_FALL },
- { ep_can_smash_player, EP_CAN_SMASH_PLAYER },
- { ep_can_smash_enemies, EP_CAN_SMASH_ENEMIES },
- { ep_can_smash_everything, EP_CAN_SMASH_EVERYTHING },
- { ep_explodes_by_fire, EP_EXPLODES_BY_FIRE },
- { ep_explodes_smashed, EP_EXPLODES_SMASHED },
- { ep_explodes_impact, EP_EXPLODES_IMPACT },
- { ep_walkable_over, EP_WALKABLE_OVER },
- { ep_walkable_inside, EP_WALKABLE_INSIDE },
- { ep_walkable_under, EP_WALKABLE_UNDER },
- { ep_passable_over, EP_PASSABLE_OVER },
- { ep_passable_inside, EP_PASSABLE_INSIDE },
- { ep_passable_under, EP_PASSABLE_UNDER },
- { ep_droppable, EP_DROPPABLE },
- { ep_explodes_1x1_old, EP_EXPLODES_1X1_OLD },
- { ep_pushable, EP_PUSHABLE },
- { ep_explodes_cross_old, EP_EXPLODES_CROSS_OLD },
- { ep_protected, EP_PROTECTED },
- { ep_throwable, EP_THROWABLE },
- { ep_can_explode, EP_CAN_EXPLODE },
- { ep_gravity_reachable, EP_GRAVITY_REACHABLE },
-
- { ep_player, EP_PLAYER },
- { ep_can_pass_magic_wall, EP_CAN_PASS_MAGIC_WALL },
- { ep_switchable, EP_SWITCHABLE },
- { ep_bd_element, EP_BD_ELEMENT },
- { ep_sp_element, EP_SP_ELEMENT },
- { ep_sb_element, EP_SB_ELEMENT },
- { ep_gem, EP_GEM },
- { ep_food_dark_yamyam, EP_FOOD_DARK_YAMYAM },
- { ep_food_penguin, EP_FOOD_PENGUIN },
- { ep_food_pig, EP_FOOD_PIG },
- { ep_historic_wall, EP_HISTORIC_WALL },
- { ep_historic_solid, EP_HISTORIC_SOLID },
- { ep_classic_enemy, EP_CLASSIC_ENEMY },
- { ep_belt, EP_BELT },
- { ep_belt_active, EP_BELT_ACTIVE },
- { ep_belt_switch, EP_BELT_SWITCH },
- { ep_tube, EP_TUBE },
- { ep_keygate, EP_KEYGATE },
- { ep_amoeboid, EP_AMOEBOID },
- { ep_amoebalive, EP_AMOEBALIVE },
- { ep_has_content, EP_HAS_CONTENT },
- { ep_can_turn_each_move, EP_CAN_TURN_EACH_MOVE },
- { ep_can_grow, EP_CAN_GROW },
- { ep_active_bomb, EP_ACTIVE_BOMB },
- { ep_inactive, EP_INACTIVE },
-
- { ep_em_slippery_wall, EP_EM_SLIPPERY_WALL },
-
- { ep_gfx_crumbled, EP_GFX_CRUMBLED },
-
- { NULL, -1 }
+ { ep_diggable, EP_DIGGABLE },
+ { ep_collectible_only, EP_COLLECTIBLE_ONLY },
+ { ep_dont_run_into, EP_DONT_RUN_INTO },
+ { ep_dont_collide_with, EP_DONT_COLLIDE_WITH },
+ { ep_dont_touch, EP_DONT_TOUCH },
+ { ep_indestructible, EP_INDESTRUCTIBLE },
+ { ep_slippery, EP_SLIPPERY },
+ { ep_can_change, EP_CAN_CHANGE },
+ { ep_can_move, EP_CAN_MOVE },
+ { ep_can_fall, EP_CAN_FALL },
+ { ep_can_smash_player, EP_CAN_SMASH_PLAYER },
+ { ep_can_smash_enemies, EP_CAN_SMASH_ENEMIES },
+ { ep_can_smash_everything, EP_CAN_SMASH_EVERYTHING },
+ { ep_explodes_by_fire, EP_EXPLODES_BY_FIRE },
+ { ep_explodes_smashed, EP_EXPLODES_SMASHED },
+ { ep_explodes_impact, EP_EXPLODES_IMPACT },
+ { ep_walkable_over, EP_WALKABLE_OVER },
+ { ep_walkable_inside, EP_WALKABLE_INSIDE },
+ { ep_walkable_under, EP_WALKABLE_UNDER },
+ { ep_passable_over, EP_PASSABLE_OVER },
+ { ep_passable_inside, EP_PASSABLE_INSIDE },
+ { ep_passable_under, EP_PASSABLE_UNDER },
+ { ep_droppable, EP_DROPPABLE },
+ { ep_explodes_1x1_old, EP_EXPLODES_1X1_OLD },
+ { ep_pushable, EP_PUSHABLE },
+ { ep_explodes_cross_old, EP_EXPLODES_CROSS_OLD },
+ { ep_protected, EP_PROTECTED },
+ { ep_throwable, EP_THROWABLE },
+ { ep_can_explode, EP_CAN_EXPLODE },
+ { ep_gravity_reachable, EP_GRAVITY_REACHABLE },
+
+ { ep_player, EP_PLAYER },
+ { ep_can_pass_magic_wall, EP_CAN_PASS_MAGIC_WALL },
+ { ep_can_pass_dc_magic_wall, EP_CAN_PASS_DC_MAGIC_WALL },
+ { ep_switchable, EP_SWITCHABLE },
+ { ep_bd_element, EP_BD_ELEMENT },
+ { ep_sp_element, EP_SP_ELEMENT },
+ { ep_sb_element, EP_SB_ELEMENT },
+ { ep_gem, EP_GEM },
+ { ep_food_dark_yamyam, EP_FOOD_DARK_YAMYAM },
+ { ep_food_penguin, EP_FOOD_PENGUIN },
+ { ep_food_pig, EP_FOOD_PIG },
+ { ep_historic_wall, EP_HISTORIC_WALL },
+ { ep_historic_solid, EP_HISTORIC_SOLID },
+ { ep_classic_enemy, EP_CLASSIC_ENEMY },
+ { ep_belt, EP_BELT },
+ { ep_belt_active, EP_BELT_ACTIVE },
+ { ep_belt_switch, EP_BELT_SWITCH },
+ { ep_tube, EP_TUBE },
+ { ep_acid_pool, EP_ACID_POOL },
+ { ep_keygate, EP_KEYGATE },
+ { ep_amoeboid, EP_AMOEBOID },
+ { ep_amoebalive, EP_AMOEBALIVE },
+ { ep_has_editor_content, EP_HAS_EDITOR_CONTENT },
+ { ep_can_turn_each_move, EP_CAN_TURN_EACH_MOVE },
+ { ep_can_grow, EP_CAN_GROW },
+ { ep_active_bomb, EP_ACTIVE_BOMB },
+ { ep_inactive, EP_INACTIVE },
+
+ { ep_em_slippery_wall, EP_EM_SLIPPERY_WALL },
+
+ { ep_gfx_crumbled, EP_GFX_CRUMBLED },
+
+ { ep_editor_cascade_active, EP_EDITOR_CASCADE_ACTIVE },
+ { ep_editor_cascade_inactive, EP_EDITOR_CASCADE_INACTIVE },
+
+ { ep_obsolete, EP_OBSOLETE },
+
+ { NULL, -1 }
};
int i, j, k;
/* always start with reliable default values (element has no properties) */
+ /* (but never initialize clipboard elements after the very first time) */
+ /* (to be able to use clipboard elements between several levels) */
for (i = 0; i < MAX_NUM_ELEMENTS; i++)
- for (j = 0; j < NUM_ELEMENT_PROPERTIES; j++)
- SET_PROPERTY(i, j, FALSE);
+ if (!IS_CLIPBOARD_ELEMENT(i) || !clipboard_elements_initialized)
+ for (j = 0; j < NUM_ELEMENT_PROPERTIES; j++)
+ SET_PROPERTY(i, j, FALSE);
/* set all base element properties from above array definitions */
for (i = 0; element_properties[i].elements != NULL; i++)
if (HAS_PROPERTY(copy_properties[j][0], i))
for (k = 1; k <= 4; k++)
SET_PROPERTY(copy_properties[j][k], i, TRUE);
+
+ /* set static element properties that are not listed in array definitions */
+ for (i = EL_STEEL_CHAR_START; i <= EL_STEEL_CHAR_END; i++)
+ SET_PROPERTY(i, EP_INDESTRUCTIBLE, TRUE);
+
+ clipboard_elements_initialized = TRUE;
}
void InitElementPropertiesEngine(int engine_version)
property (which means that conditional property changes must be set to
a reliable default value before) */
+ /* resolve group elements */
+ for (i = 0; i < NUM_GROUP_ELEMENTS; i++)
+ ResolveGroupElement(EL_GROUP_START + i);
+
/* set all special, combined or engine dependent element properties */
for (i = 0; i < MAX_NUM_ELEMENTS; i++)
{
+ /* do not change (already initialized) clipboard elements here */
+ if (IS_CLIPBOARD_ELEMENT(i))
+ continue;
+
/* ---------- INACTIVE ------------------------------------------------- */
- SET_PROPERTY(i, EP_INACTIVE, (i >= EL_CHAR_START && i <= EL_CHAR_END));
+ SET_PROPERTY(i, EP_INACTIVE, ((i >= EL_CHAR_START &&
+ i <= EL_CHAR_END) ||
+ (i >= EL_STEEL_CHAR_START &&
+ i <= EL_STEEL_CHAR_END)));
/* ---------- WALKABLE, PASSABLE, ACCESSIBLE --------------------------- */
SET_PROPERTY(i, EP_WALKABLE, (IS_WALKABLE_OVER(i) ||
!IS_COLLECTIBLE(i)));
/* ---------- DRAGONFIRE_PROOF ----------------------------------------- */
-
if (IS_HISTORIC_SOLID(i) || i == EL_EXPLOSION)
SET_PROPERTY(i, EP_DRAGONFIRE_PROOF, TRUE);
else
SET_PROPERTY(i, EP_SP_PORT, (IS_SP_ELEMENT(i) &&
IS_PASSABLE_INSIDE(i)));
+ /* ---------- CAN_BE_CLONED_BY_ANDROID --------------------------------- */
+ for (j = 0; j < level.num_android_clone_elements; j++)
+ SET_PROPERTY(i, EP_CAN_BE_CLONED_BY_ANDROID,
+ (i != EL_EMPTY &&
+ IS_EQUAL_OR_IN_GROUP(i, level.android_clone_element[j])));
+
/* ---------- CAN_CHANGE ----------------------------------------------- */
SET_PROPERTY(i, EP_CAN_CHANGE, FALSE); /* default: cannot change */
for (j = 0; j < element_info[i].num_change_pages; j++)
SET_PROPERTY(i, EP_GFX_CRUMBLED,
element_info[i].crumbled[ACTION_DEFAULT] != IMG_EMPTY);
#endif
+
+ /* ---------- EDITOR_CASCADE ------------------------------------------- */
+ SET_PROPERTY(i, EP_EDITOR_CASCADE, (IS_EDITOR_CASCADE_ACTIVE(i) ||
+ IS_EDITOR_CASCADE_INACTIVE(i)));
}
/* dynamically adjust element properties according to game engine version */
{
static int ep_em_slippery_wall[] =
{
- EL_STEELWALL,
EL_WALL,
+ EL_STEELWALL,
EL_EXPANDABLE_WALL,
EL_EXPANDABLE_WALL_HORIZONTAL,
EL_EXPANDABLE_WALL_VERTICAL,
EL_EXPANDABLE_WALL_ANY,
+ EL_EXPANDABLE_STEELWALL_HORIZONTAL,
+ EL_EXPANDABLE_STEELWALL_VERTICAL,
+ EL_EXPANDABLE_STEELWALL_ANY,
+ EL_EXPANDABLE_STEELWALL_GROWING,
-1
};
engine_version > VERSION_IDENT(2,0,1,0)));
}
- /* set default push delay values (corrected since version 3.0.7-1) */
- if (engine_version < VERSION_IDENT(3,0,7,1))
- {
- game.default_push_delay_fixed = 2;
- game.default_push_delay_random = 8;
- }
- else
- {
- game.default_push_delay_fixed = 8;
- game.default_push_delay_random = 8;
- }
-
- /* set uninitialized push delay values of custom elements in older levels */
- for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
- {
- int element = EL_CUSTOM_START + i;
+ /* this is needed because some graphics depend on element properties */
+ if (game_status == GAME_MODE_PLAYING)
+ InitElementGraphicInfo();
+}
- if (element_info[element].push_delay_fixed == -1)
- element_info[element].push_delay_fixed = game.default_push_delay_fixed;
- if (element_info[element].push_delay_random == -1)
- element_info[element].push_delay_random = game.default_push_delay_random;
- }
+void InitElementPropertiesAfterLoading(int engine_version)
+{
+ int i;
/* set some other uninitialized values of custom elements in older levels */
if (engine_version < VERSION_IDENT(3,1,0,0))
element_info[element].ignition_delay = 8;
}
}
-
-#if 0
- /* set element properties that were handled incorrectly in older levels */
- if (engine_version < VERSION_IDENT(3,1,0,0))
- {
- SET_PROPERTY(EL_SP_SNIKSNAK, EP_DONT_COLLIDE_WITH, FALSE);
- SET_PROPERTY(EL_SP_ELECTRON, EP_DONT_COLLIDE_WITH, FALSE);
- }
-#endif
-
- /* this is needed because some graphics depend on element properties */
- if (game_status == GAME_MODE_PLAYING)
- InitElementGraphicInfo();
}
static void InitGlobal()
{
+ int graphic;
int i;
for (i = 0; i < MAX_NUM_ELEMENTS + 1; i++)
element_info[i].token_name = element_name_info[i].token_name;
element_info[i].class_name = element_name_info[i].class_name;
- element_info[i].editor_description=element_name_info[i].editor_description;
+ element_info[i].editor_description= element_name_info[i].editor_description;
+
+#if 0
+ printf("%04d: %s\n", i, element_name_info[i].token_name);
+#endif
+ }
+
+ /* create hash from image config list */
+ image_config_hash = newSetupFileHash();
+ for (i = 0; image_config[i].token != NULL; i++)
+ setHashEntry(image_config_hash,
+ image_config[i].token,
+ image_config[i].value);
+
+ /* create hash from element token list */
+ element_token_hash = newSetupFileHash();
+ for (i = 0; element_name_info[i].token_name != NULL; i++)
+ setHashEntry(element_token_hash,
+ element_name_info[i].token_name,
+ int2str(i, 0));
+
+ /* create hash from graphic token list */
+ graphic_token_hash = newSetupFileHash();
+ for (graphic = 0, i = 0; image_config[i].token != NULL; i++)
+ if (strSuffix(image_config[i].value, ".pcx") ||
+ strSuffix(image_config[i].value, ".wav") ||
+ strEqual(image_config[i].value, UNDEFINED_FILENAME))
+ setHashEntry(graphic_token_hash,
+ image_config[i].token,
+ int2str(graphic++, 0));
+
+ /* create hash from font token list */
+ font_token_hash = newSetupFileHash();
+ for (i = 0; font_info[i].token_name != NULL; i++)
+ setHashEntry(font_token_hash,
+ font_info[i].token_name,
+ int2str(i, 0));
+
+ /* always start with reliable default values (all elements) */
+ for (i = 0; i < MAX_NUM_ELEMENTS; i++)
+ ActiveElement[i] = i;
+
+ /* now add all entries that have an active state (active elements) */
+ for (i = 0; element_with_active_state[i].element != -1; i++)
+ {
+ int element = element_with_active_state[i].element;
+ int element_active = element_with_active_state[i].element_active;
+
+ ActiveElement[element] = element_active;
+ }
+
+ /* always start with reliable default values (all buttons) */
+ for (i = 0; i < NUM_IMAGE_FILES; i++)
+ ActiveButton[i] = i;
+
+ /* now add all entries that have an active state (active buttons) */
+ for (i = 0; button_with_active_state[i].button != -1; i++)
+ {
+ int button = button_with_active_state[i].button;
+ int button_active = button_with_active_state[i].button_active;
+
+ ActiveButton[button] = button_active;
+ }
+
+ /* always start with reliable default values (all fonts) */
+ for (i = 0; i < NUM_FONTS; i++)
+ ActiveFont[i] = i;
+
+ /* now add all entries that have an active state (active fonts) */
+ for (i = 0; font_with_active_state[i].font_nr != -1; i++)
+ {
+ int font = font_with_active_state[i].font_nr;
+ int font_active = font_with_active_state[i].font_nr_active;
+
+ ActiveFont[font] = font_active;
}
global.autoplay_leveldir = NULL;
global.frames_per_second = 0;
global.fps_slowdown = FALSE;
global.fps_slowdown_factor = 1;
+
+ global.border_status = GAME_MODE_MAIN;
+#if 0
+ global.fading_status = GAME_MODE_MAIN;
+ global.fading_type = TYPE_ENTER_MENU;
+#endif
}
void Execute_Command(char *command)
{
int i;
- if (strcmp(command, "print graphicsinfo.conf") == 0)
+ if (strEqual(command, "print graphicsinfo.conf"))
{
printf("# You can configure additional/alternative image files here.\n");
printf("# (The entries below are default and therefore commented out.)\n");
exit(0);
}
- else if (strcmp(command, "print soundsinfo.conf") == 0)
+ else if (strEqual(command, "print soundsinfo.conf"))
{
printf("# You can configure additional/alternative sound files here.\n");
printf("# (The entries below are default and therefore commented out.)\n");
exit(0);
}
- else if (strcmp(command, "print musicinfo.conf") == 0)
+ else if (strEqual(command, "print musicinfo.conf"))
{
printf("# You can configure additional/alternative music files here.\n");
printf("# (The entries below are default and therefore commented out.)\n");
exit(0);
}
- else if (strcmp(command, "print editorsetup.conf") == 0)
+ else if (strEqual(command, "print editorsetup.conf"))
{
printf("# You can configure your personal editor element list here.\n");
printf("# (The entries below are default and therefore commented out.)\n");
printf("\n");
+ /* this is needed to be able to check element list for cascade elements */
+ InitElementPropertiesStatic();
+ InitElementPropertiesEngine(GAME_VERSION_ACTUAL);
+
PrintEditorElementList();
exit(0);
}
- else if (strcmp(command, "print helpanim.conf") == 0)
+ else if (strEqual(command, "print helpanim.conf"))
{
printf("# You can configure different element help animations here.\n");
printf("# (The entries below are default and therefore commented out.)\n");
printf("# %s\n", getFormattedSetupEntry(helpanim_config[i].token,
helpanim_config[i].value));
- if (strcmp(helpanim_config[i].token, "end") == 0)
+ if (strEqual(helpanim_config[i].token, "end"))
printf("#\n");
}
exit(0);
}
- else if (strcmp(command, "print helptext.conf") == 0)
+ else if (strEqual(command, "print helptext.conf"))
{
printf("# You can configure different element help text here.\n");
printf("# (The entries below are default and therefore commented out.)\n");
global.convert_level_nr = atoi(str_ptr); /* get level_nr value */
}
}
+
+#if DEBUG
+#if defined(TARGET_SDL)
+ else if (strEqual(command, "SDL_ListModes"))
+ {
+ SDL_Rect **modes;
+ int i;
+
+ SDL_Init(SDL_INIT_VIDEO);
+
+ /* get available fullscreen/hardware modes */
+ modes = SDL_ListModes(NULL, SDL_FULLSCREEN | SDL_HWSURFACE);
+
+ /* check if there are any modes available */
+ if (modes == NULL)
+ {
+ printf("No modes available!\n");
+
+ exit(-1);
+ }
+
+ /* check if our resolution is restricted */
+ if (modes == (SDL_Rect **)-1)
+ {
+ printf("All resolutions available.\n");
+ }
+ else
+ {
+ printf("Available Modes:\n");
+
+ for(i = 0; modes[i]; i++)
+ printf(" %d x %d\n", modes[i]->w, modes[i]->h);
+ }
+
+ exit(0);
+ }
+#endif
+#endif
+
else
{
Error(ERR_EXIT_HELP, "unrecognized command '%s'", command);
static char *sound_id_prefix[2 * MAX_NUM_ELEMENTS + 1];
static char *music_id_prefix[NUM_MUSIC_PREFIXES + 1];
static char *action_id_suffix[NUM_ACTIONS + 1];
- static char *direction_id_suffix[NUM_DIRECTIONS + 1];
+ static char *direction_id_suffix[NUM_DIRECTIONS_FULL + 1];
static char *special_id_suffix[NUM_SPECIAL_GFX_ARGS + 1];
static char *level_id_suffix[MAX_LEVELS + 1];
static char *dummy[1] = { NULL };
action_id_suffix[i] = element_action_info[i].suffix;
action_id_suffix[NUM_ACTIONS] = NULL;
- for (i = 0; i < NUM_DIRECTIONS; i++)
+ for (i = 0; i < NUM_DIRECTIONS_FULL; i++)
direction_id_suffix[i] = element_direction_info[i].suffix;
- direction_id_suffix[NUM_DIRECTIONS] = NULL;
+ direction_id_suffix[NUM_DIRECTIONS_FULL] = NULL;
for (i = 0; i < NUM_SPECIAL_GFX_ARGS; i++)
special_id_suffix[i] = special_suffix_info[i].suffix;
void InitGfx()
{
char *filename_font_initial = NULL;
+ char *filename_anim_initial = NULL;
Bitmap *bitmap_font_initial = NULL;
+ int font_height;
int i, j;
/* determine settings for initial font (for displaying startup messages) */
sprintf(font_token, "%s_%d", CONFIG_TOKEN_FONT_INITIAL, j + 1);
len_font_token = strlen(font_token);
- if (strcmp(image_config[i].token, font_token) == 0)
+ if (strEqual(image_config[i].token, font_token))
filename_font_initial = image_config[i].value;
else if (strlen(image_config[i].token) > len_font_token &&
strncmp(image_config[i].token, font_token, len_font_token) == 0)
{
- if (strcmp(&image_config[i].token[len_font_token], ".x") == 0)
+ if (strEqual(&image_config[i].token[len_font_token], ".x"))
font_initial[j].src_x = atoi(image_config[i].value);
- else if (strcmp(&image_config[i].token[len_font_token], ".y") == 0)
+ else if (strEqual(&image_config[i].token[len_font_token], ".y"))
font_initial[j].src_y = atoi(image_config[i].value);
- else if (strcmp(&image_config[i].token[len_font_token], ".width") == 0)
+ else if (strEqual(&image_config[i].token[len_font_token], ".width"))
font_initial[j].width = atoi(image_config[i].value);
- else if (strcmp(&image_config[i].token[len_font_token],".height") == 0)
+ else if (strEqual(&image_config[i].token[len_font_token], ".height"))
font_initial[j].height = atoi(image_config[i].value);
}
}
if (filename_font_initial == NULL) /* should not happen */
Error(ERR_EXIT, "cannot get filename for '%s'", CONFIG_TOKEN_FONT_INITIAL);
- /* create additional image buffers for double-buffering */
+ /* create additional image buffers for double-buffering and cross-fading */
+ bitmap_db_cross = CreateBitmap(WIN_XSIZE, WIN_YSIZE, DEFAULT_DEPTH);
bitmap_db_field = CreateBitmap(FXSIZE, FYSIZE, DEFAULT_DEPTH);
+ bitmap_db_panel = CreateBitmap(DXSIZE, DYSIZE, DEFAULT_DEPTH);
bitmap_db_door = CreateBitmap(3 * DXSIZE, DYSIZE + VYSIZE, DEFAULT_DEPTH);
+ bitmap_db_toons = CreateBitmap(FULL_SXSIZE, FULL_SYSIZE, DEFAULT_DEPTH);
/* initialize screen properties */
InitGfxFieldInfo(SX, SY, SXSIZE, SYSIZE,
InitGfxDoor1Info(DX, DY, DXSIZE, DYSIZE);
InitGfxDoor2Info(VX, VY, VXSIZE, VYSIZE);
InitGfxScrollbufferInfo(FXSIZE, FYSIZE);
+ InitGfxCustomArtworkInfo();
bitmap_font_initial = LoadCustomImage(filename_font_initial);
InitFontGraphicInfo();
+ font_height = getFontHeight(FC_RED);
+
+#if 1
+ DrawInitText(getWindowTitleString(), 20, FC_YELLOW);
+#else
DrawInitText(getProgramInitString(), 20, FC_YELLOW);
+#endif
DrawInitText(PROGRAM_COPYRIGHT_STRING, 50, FC_RED);
+ DrawInitText(PROGRAM_WEBSITE_STRING, WIN_YSIZE - 20 - font_height, FC_RED);
+
+ DrawInitText("Loading graphics", 120, FC_GREEN);
+
+#if 1
+#if 1
+ /* initialize busy animation with default values */
+ int parameter[NUM_GFX_ARGS];
+ for (i = 0; i < NUM_GFX_ARGS; i++)
+ parameter[i] = get_graphic_parameter_value(image_config_suffix[i].value,
+ image_config_suffix[i].token,
+ image_config_suffix[i].type);
+#if 0
+ for (i = 0; i < NUM_GFX_ARGS; i++)
+ printf("::: '%s' => %d\n", image_config_suffix[i].token, parameter[i]);
+#endif
+#endif
+
+ /* determine settings for busy animation (when displaying startup messages) */
+ for (i = 0; image_config[i].token != NULL; i++)
+ {
+ char *anim_token = CONFIG_TOKEN_GLOBAL_BUSY;
+ int len_anim_token = strlen(anim_token);
+
+ if (strEqual(image_config[i].token, anim_token))
+ filename_anim_initial = image_config[i].value;
+ else if (strlen(image_config[i].token) > len_anim_token &&
+ strncmp(image_config[i].token, anim_token, len_anim_token) == 0)
+ {
+#if 1
+ for (j = 0; image_config_suffix[j].token != NULL; j++)
+ {
+ if (strEqual(&image_config[i].token[len_anim_token],
+ image_config_suffix[j].token))
+ parameter[j] =
+ get_graphic_parameter_value(image_config[i].value,
+ image_config_suffix[j].token,
+ image_config_suffix[j].type);
+ }
+#else
+ if (strEqual(&image_config[i].token[len_anim_token], ".x"))
+ anim_initial.src_x = atoi(image_config[i].value);
+ else if (strEqual(&image_config[i].token[len_anim_token], ".y"))
+ anim_initial.src_y = atoi(image_config[i].value);
+ else if (strEqual(&image_config[i].token[len_anim_token], ".width"))
+ anim_initial.width = atoi(image_config[i].value);
+ else if (strEqual(&image_config[i].token[len_anim_token], ".height"))
+ anim_initial.height = atoi(image_config[i].value);
+ else if (strEqual(&image_config[i].token[len_anim_token], ".frames"))
+ anim_initial.anim_frames = atoi(image_config[i].value);
+ else if (strEqual(&image_config[i].token[len_anim_token],
+ ".frames_per_line"))
+ anim_initial.anim_frames_per_line = atoi(image_config[i].value);
+ else if (strEqual(&image_config[i].token[len_anim_token], ".delay"))
+ anim_initial.anim_delay = atoi(image_config[i].value);
+#endif
+ }
+ }
+
+ set_graphic_parameters_ext(0, &anim_initial, parameter, NULL);
+
+ if (filename_anim_initial == NULL) /* should not happen */
+ Error(ERR_EXIT, "cannot get filename for '%s'", CONFIG_TOKEN_GLOBAL_BUSY);
+
+ anim_initial.bitmap = LoadCustomImage(filename_anim_initial);
+
+ init.busy.width = anim_initial.width;
+ init.busy.height = anim_initial.height;
+
+ InitMenuDesignSettings_Static();
+ InitGfxDrawBusyAnimFunction(DrawInitAnim);
+#endif
+}
+
+void RedrawBackground()
+{
+ BlitBitmap(graphic_info[IMG_GLOBAL_BORDER].bitmap, backbuffer,
+ 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
- DrawInitText("Loading graphics:", 120, FC_GREEN);
+ redraw_mask = REDRAW_ALL;
}
void InitGfxBackground()
{
int x, y;
- drawto = backbuffer;
fieldbuffer = bitmap_db_field;
SetDrawtoField(DRAW_BACKBUFFER);
- BlitBitmap(graphic_info[IMG_GLOBAL_BORDER].bitmap, backbuffer,
- 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
+#if 1
+ ClearRectangle(backbuffer, 0, 0, WIN_XSIZE, WIN_YSIZE);
+#else
+ RedrawBackground();
+
ClearRectangle(backbuffer, REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE);
ClearRectangle(bitmap_db_door, 0, 0, 3 * DXSIZE, DYSIZE + VYSIZE);
+#endif
for (x = 0; x < MAX_BUF_XSIZE; x++)
for (y = 0; y < MAX_BUF_YSIZE; y++)
static void InitImages()
{
+ print_timestamp_init("InitImages");
+
setLevelArtworkDir(artwork.gfx_first);
#if 0
leveldir_current->graphics_path);
#endif
+ UPDATE_BUSY_STATE();
+
ReloadCustomImages();
+ print_timestamp_time("ReloadCustomImages");
+
+ UPDATE_BUSY_STATE();
LoadCustomElementDescriptions();
- LoadSpecialMenuDesignSettings();
+ print_timestamp_time("LoadCustomElementDescriptions");
+
+ UPDATE_BUSY_STATE();
+
+ LoadMenuDesignSettings();
+ print_timestamp_time("LoadMenuDesignSettings");
+
+ UPDATE_BUSY_STATE();
ReinitializeGraphics();
+ print_timestamp_time("ReinitializeGraphics");
+
+ UPDATE_BUSY_STATE();
+
+ print_timestamp_done("InitImages");
}
static void InitSound(char *identifier)
{
+ print_timestamp_init("InitSound");
+
if (identifier == NULL)
identifier = artwork.snd_current->identifier;
setLevelArtworkDir(artwork.snd_first);
InitReloadCustomSounds(identifier);
+ print_timestamp_time("InitReloadCustomSounds");
+
ReinitializeSounds();
+ print_timestamp_time("ReinitializeSounds");
+
+ print_timestamp_done("InitSound");
}
static void InitMusic(char *identifier)
{
+ print_timestamp_init("InitMusic");
+
if (identifier == NULL)
identifier = artwork.mus_current->identifier;
setLevelArtworkDir(artwork.mus_first);
InitReloadCustomMusic(identifier);
+ print_timestamp_time("InitReloadCustomMusic");
+
ReinitializeMusic();
+ print_timestamp_time("ReinitializeMusic");
+
+ print_timestamp_done("InitMusic");
}
void InitNetworkServer()
static boolean last_has_level_artwork_set[3] = { FALSE, FALSE, FALSE };
static boolean initialized[3] = { FALSE, FALSE, FALSE };
TreeInfo *artwork_first_node = ARTWORK_FIRST_NODE(artwork, type);
+#if 1
+ boolean setup_override_artwork = GFX_OVERRIDE_ARTWORK(type);
+#else
boolean setup_override_artwork = SETUP_OVERRIDE_ARTWORK(setup, type);
+#endif
char *setup_artwork_set = SETUP_ARTWORK_SET(setup, type);
char *leveldir_identifier = leveldir_current->identifier;
#if 1
#endif
/* ---------- reload if current artwork identifier has changed ----------- */
- if (strcmp(ARTWORK_CURRENT_IDENTIFIER(artwork, type),
- artwork_current_identifier) != 0)
+ if (!strEqual(ARTWORK_CURRENT_IDENTIFIER(artwork, type),
+ artwork_current_identifier))
artwork_new_identifier = artwork_current_identifier;
*(ARTWORK_CURRENT_IDENTIFIER_PTR(artwork, type))= artwork_current_identifier;
void ReloadCustomArtwork(int force_reload)
{
- char *gfx_new_identifier = getNewArtworkIdentifier(ARTWORK_TYPE_GRAPHICS);
- char *snd_new_identifier = getNewArtworkIdentifier(ARTWORK_TYPE_SOUNDS);
- char *mus_new_identifier = getNewArtworkIdentifier(ARTWORK_TYPE_MUSIC);
+ int last_game_status = game_status; /* save current game status */
+ char *gfx_new_identifier;
+ char *snd_new_identifier;
+ char *mus_new_identifier;
boolean force_reload_gfx = (force_reload & (1 << ARTWORK_TYPE_GRAPHICS));
boolean force_reload_snd = (force_reload & (1 << ARTWORK_TYPE_SOUNDS));
boolean force_reload_mus = (force_reload & (1 << ARTWORK_TYPE_MUSIC));
- boolean redraw_screen = FALSE;
+ boolean reload_needed;
+
+#if 1
+ gfx.draw_init_text = FALSE;
+
+ gfx.override_level_graphics = FALSE;
+ gfx.override_level_sounds = FALSE;
+ gfx.override_level_music = FALSE;
+
+#if 0
+ LoadImageConfig();
+#endif
+#if 0
+ CheckCustomElementGraphicInfo();
+#endif
+
+#if 1
+ {
+ char *filename_base, *filename_local;
+
+ /* first look for special artwork configured in level series config */
+ filename_base = getCustomArtworkLevelConfigFilename(ARTWORK_TYPE_GRAPHICS);
+
+ if (fileExists(filename_base))
+ CheckArtworkConfigForCustomElements(filename_base);
+
+ filename_local = getCustomArtworkConfigFilename(ARTWORK_TYPE_GRAPHICS);
+
+ if (filename_local != NULL && !strEqual(filename_base, filename_local))
+ CheckArtworkConfigForCustomElements(filename_local);
+ }
+#endif
+
+ gfx.override_level_graphics = setup.override_level_graphics;
+ gfx.override_level_sounds = setup.override_level_sounds;
+ gfx.override_level_music = setup.override_level_music;
+
+ gfx.draw_init_text = TRUE;
+#endif
+
+ force_reload_gfx |= AdjustGraphicsForEMC();
+
+ gfx_new_identifier = getNewArtworkIdentifier(ARTWORK_TYPE_GRAPHICS);
+ snd_new_identifier = getNewArtworkIdentifier(ARTWORK_TYPE_SOUNDS);
+ mus_new_identifier = getNewArtworkIdentifier(ARTWORK_TYPE_MUSIC);
+
+ reload_needed = (gfx_new_identifier != NULL || force_reload_gfx ||
+ snd_new_identifier != NULL || force_reload_snd ||
+ mus_new_identifier != NULL || force_reload_mus);
+
+ if (!reload_needed)
+ return;
+
+ print_timestamp_init("ReloadCustomArtwork");
+
+ game_status = GAME_MODE_LOADING;
+
+ FadeOut(REDRAW_ALL);
+
+#if 1
+ ClearRectangle(drawto, 0, 0, WIN_XSIZE, WIN_YSIZE);
+#else
+ ClearRectangle(window, 0, 0, WIN_XSIZE, WIN_YSIZE);
+#endif
+ print_timestamp_time("ClearRectangle");
+
+#if 0
+ printf("::: fading in ... %d\n", fading.fade_mode);
+#endif
+ FadeIn(REDRAW_ALL);
+#if 0
+ printf("::: done\n");
+#endif
if (gfx_new_identifier != NULL || force_reload_gfx)
{
leveldir_current->graphics_set);
#endif
- ClearRectangle(window, 0, 0, WIN_XSIZE, WIN_YSIZE);
-
InitImages();
-
- redraw_screen = TRUE;
+ print_timestamp_time("InitImages");
}
if (snd_new_identifier != NULL || force_reload_snd)
{
- ClearRectangle(window, 0, 0, WIN_XSIZE, WIN_YSIZE);
-
InitSound(snd_new_identifier);
-
- redraw_screen = TRUE;
+ print_timestamp_time("InitSound");
}
if (mus_new_identifier != NULL || force_reload_mus)
{
- ClearRectangle(window, 0, 0, WIN_XSIZE, WIN_YSIZE);
-
InitMusic(mus_new_identifier);
-
- redraw_screen = TRUE;
+ print_timestamp_time("InitMusic");
}
- if (redraw_screen)
- {
- InitGfxBackground();
+ game_status = last_game_status; /* restore current game status */
- /* force redraw of (open or closed) door graphics */
- SetDoorState(DOOR_OPEN_ALL);
- CloseDoor(DOOR_CLOSE_ALL | DOOR_NO_DELAY);
- }
+#if 0
+ printf("::: ----------------DELAY 1 ...\n");
+ Delay(3000);
+#endif
+
+#if 0
+ printf("::: FadeOut @ ReloadCustomArtwork ...\n");
+#endif
+ FadeOut(REDRAW_ALL);
+#if 0
+ printf("::: FadeOut @ ReloadCustomArtwork done\n");
+#endif
+
+ RedrawBackground();
+
+ /* force redraw of (open or closed) door graphics */
+ SetDoorState(DOOR_OPEN_ALL);
+ CloseDoor(DOOR_CLOSE_ALL | DOOR_NO_DELAY);
+
+#if 1
+#if 1
+#if 1
+ FadeSetEnterScreen();
+ FadeSkipNextFadeOut();
+ // FadeSetDisabled();
+#else
+ FadeSkipNext();
+#endif
+#else
+ fading = fading_none;
+#endif
+#endif
+
+#if 0
+ redraw_mask = REDRAW_ALL;
+#endif
+
+ print_timestamp_done("ReloadCustomArtwork");
}
void KeyboardAutoRepeatOffUnlessAutoplay()
void OpenAll()
{
+ print_timestamp_init("OpenAll");
+
+ game_status = GAME_MODE_LOADING;
+
InitGlobal(); /* initialize some global variables */
if (options.execute_command)
InitCounter();
InitRND(NEW_RANDOMIZE);
- InitSimpleRND(NEW_RANDOMIZE);
+ InitSimpleRandom(NEW_RANDOMIZE);
InitJoysticks();
+ print_timestamp_time("[pre-video]");
+
InitVideoDisplay();
- InitVideoBuffer(&backbuffer, &window, WIN_XSIZE, WIN_YSIZE, DEFAULT_DEPTH,
- setup.fullscreen);
+ InitVideoBuffer(WIN_XSIZE, WIN_YSIZE, DEFAULT_DEPTH, setup.fullscreen);
InitEventFilter(FilterMouseMotionEvents);
InitElementPropertiesStatic();
InitElementPropertiesEngine(GAME_VERSION_ACTUAL);
+ print_timestamp_time("[post-video]");
+
InitGfx();
+ print_timestamp_time("InitGfx");
+
InitLevelInfo();
+ print_timestamp_time("InitLevelInfo");
+
InitLevelArtworkInfo();
+ print_timestamp_time("InitLevelArtworkInfo");
InitImages(); /* needs to know current level directory */
+ print_timestamp_time("InitImages");
+
InitSound(NULL); /* needs to know current level directory */
+ print_timestamp_time("InitSound");
+
InitMusic(NULL); /* needs to know current level directory */
+ print_timestamp_time("InitMusic");
InitGfxBackground();
+#if 1
+ em_open_all();
+#endif
+
if (global.autoplay_leveldir)
{
AutoPlayTape();
game_status = GAME_MODE_MAIN;
#if 1
- em_open_all();
+ FadeSetEnterScreen();
+ if (!(fading.fade_mode & FADE_TYPE_TRANSFORM))
+ FadeSkipNextFadeOut();
+ // FadeSetDisabled();
+#else
+ fading = fading_none;
#endif
+ print_timestamp_time("[post-artwork]");
+
+ print_timestamp_done("OpenAll");
+
DrawMainMenu();
InitNetworkServer();
CloseVideoDisplay();
ClosePlatformDependentStuff();
+ if (exit_value != 0)
+ NotifyUserAboutErrorFile();
+
exit(exit_value);
}