int i;
/* initialize pixmap array for special X11 tile clipping to Pixmap 'None' */
- for (i=0; i<NUM_TILES; i++)
+ for (i = 0; i < NUM_TILES; i++)
tile_clipmask[i] = None;
#if defined(TARGET_X11)
clip_gc_valuemask, &clip_gc_values);
#if 0
- for (i=0; i<NUM_BITMAPS; i++)
+ for (i = 0; i < NUM_BITMAPS; i++)
{
if (pix[i]->clip_mask)
{
clip_gc_valuemask, &clip_gc_values);
/* create only those clipping Pixmaps we really need */
- for (i=0; tile_needs_clipping[i].start>=0; i++)
+ for (i = 0; tile_needs_clipping[i].start >= 0; i++)
{
int j;
- for (j=0; j<tile_needs_clipping[i].count; j++)
+ for (j = 0; j < tile_needs_clipping[i].count; j++)
{
int tile = tile_needs_clipping[i].start + j;
int graphic = tile;
#if defined(TARGET_X11)
int i;
- for (i=0; i<NUM_TILES; i++)
+ for (i = 0; i < NUM_TILES; i++)
{
if (tile_clipmask[i] != None)
{
tile_clip_gc = None;
#if 0
- for (i=0; i<NUM_BITMAPS; i++)
+ for (i = 0; i < NUM_BITMAPS; i++)
{
if (pix[i] != NULL && pix[i]->stored_clip_gc)
{
int i;
/* initialize normal images from static configuration */
- for (i=0; element_to_graphic[i].element > -1; i++)
+ for (i = 0; element_to_graphic[i].element > -1; i++)
CreateImageWithSmallImages(element_to_graphic[i].graphic);
/* initialize special images from static configuration */
- for (i=0; element_to_special_graphic[i].element > -1; i++)
+ for (i = 0; element_to_special_graphic[i].element > -1; i++)
CreateImageWithSmallImages(element_to_special_graphic[i].graphic);
/* initialize images from dynamic configuration */
- for (i=0; i < num_property_mappings; i++)
+ for (i = 0; i < num_property_mappings; i++)
if (property_mapping[i].artwork_index < MAX_NUM_ELEMENTS)
CreateImageWithSmallImages(property_mapping[i].artwork_index);
}
/* always start with reliable default values (normal font graphics) */
#if 1
- for (i=0; i < NUM_FONTS; i++)
+ for (i = 0; i < NUM_FONTS; i++)
font_info[i].graphic = IMG_FONT_INITIAL_1;
#else
- for (i=0; i < NUM_FONTS; i++)
+ for (i = 0; i < NUM_FONTS; i++)
font_info[i].graphic = FONT_INITIAL_1;
#endif
/* initialize normal font/graphic mapping from static configuration */
- for (i=0; font_to_graphic[i].font_nr > -1; i++)
+ 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;
}
/* always start with reliable default values (special font graphics) */
- for (i=0; i < NUM_FONTS; i++)
+ for (i = 0; i < NUM_FONTS; i++)
{
- for (j=0; j < NUM_SPECIAL_GFX_ARGS; j++)
+ for (j = 0; j < NUM_SPECIAL_GFX_ARGS; j++)
{
font_info[i].special_graphic[j] = font_info[i].graphic;
font_info[i].special_bitmap_id[j] = i;
}
/* initialize special font/graphic mapping from static configuration */
- for (i=0; font_to_graphic[i].font_nr > -1; i++)
+ 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;
}
/* initialize special element/graphic mapping from dynamic configuration */
- for (i=0; i < num_property_mappings; i++)
+ for (i = 0; i < num_property_mappings; i++)
{
int font_nr = property_mapping[i].base_index - MAX_NUM_ELEMENTS;
int special = property_mapping[i].ext3_index;
/* ---------- initialize font bitmap definitions ---------- */
- for (i=0; i < NUM_FONTS; i++)
+ for (i = 0; i < NUM_FONTS; i++)
{
if (i < NUM_INITIAL_FONTS)
{
continue;
}
- for (j=0; j < NUM_SPECIAL_GFX_ARGS; j++)
+ for (j = 0; j < NUM_SPECIAL_GFX_ARGS; j++)
{
int font_bitmap_id = font_info[i].special_bitmap_id[j];
int graphic = font_info[i].special_graphic[j];
int num_property_mappings = getImageListPropertyMappingSize();
int i, act, dir;
+ if (graphic_info == NULL) /* still at startup phase */
+ return;
+
/* set values to -1 to identify later as "uninitialized" values */
- for (i=0; i<MAX_NUM_ELEMENTS; i++)
+ for (i = 0; i < MAX_NUM_ELEMENTS; i++)
{
- for (act=0; act<NUM_ACTIONS; act++)
+ for (act = 0; act < NUM_ACTIONS; act++)
{
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; dir++)
{
element_info[i].direction_graphic[act][dir] = -1;
element_info[i].direction_crumbled[act][dir] = -1;
}
/* initialize normal element/graphic mapping from static configuration */
- for (i=0; element_to_graphic[i].element > -1; i++)
+ for (i = 0; element_to_graphic[i].element > -1; i++)
{
int element = element_to_graphic[i].element;
int action = element_to_graphic[i].action;
}
/* initialize normal element/graphic mapping from dynamic configuration */
- for (i=0; i < num_property_mappings; i++)
+ for (i = 0; i < num_property_mappings; i++)
{
int element = property_mapping[i].base_index;
int action = property_mapping[i].ext1_index;
if (crumbled)
{
if (direction < 0)
- for (dir=0; dir<NUM_DIRECTIONS; dir++)
+ for (dir = 0; dir < NUM_DIRECTIONS; 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; dir++)
element_info[element].direction_graphic[action][dir] = -1;
if (direction > -1)
}
/* now copy all graphics that are defined to be cloned from other graphics */
- for (i=0; i<MAX_NUM_ELEMENTS; i++)
+ for (i = 0; i < MAX_NUM_ELEMENTS; i++)
{
int graphic = element_info[i].graphic[ACTION_DEFAULT];
int crumbled_like, diggable_like;
if (crumbled_like != -1 && element_info[i].crumbled[ACTION_DEFAULT] == -1)
{
- for (act=0; act<NUM_ACTIONS; act++)
+ for (act = 0; act < NUM_ACTIONS; act++)
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 (act = 0; act < NUM_ACTIONS; act++)
+ for (dir = 0; dir < NUM_DIRECTIONS; 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; dir++)
element_info[i].direction_graphic[ACTION_DIGGING][dir] =
element_info[diggable_like].direction_graphic[ACTION_DIGGING][dir];
}
#if 1
/* now set all undefined/invalid graphics to -1 to set to default after it */
- for (i=0; i<MAX_NUM_ELEMENTS; i++)
+ for (i = 0; i < MAX_NUM_ELEMENTS; i++)
{
- for (act=0; act<NUM_ACTIONS; act++)
+ for (act = 0; act < NUM_ACTIONS; act++)
{
int graphic;
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; dir++)
{
graphic = element_info[i].direction_graphic[act][dir];
if (graphic > 0 && graphic_info[graphic].bitmap == NULL)
#endif
/* now set all '-1' values to element specific default values */
- for (i=0; i<MAX_NUM_ELEMENTS; i++)
+ 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_crumbled[NUM_DIRECTIONS];
if (default_graphic == -1)
- default_graphic = IMG_CHAR_QUESTION;
+ default_graphic = IMG_UNKNOWN;
if (default_crumbled == -1)
default_crumbled = IMG_EMPTY;
- for (dir=0; dir<NUM_DIRECTIONS; dir++)
+ for (dir = 0; dir < NUM_DIRECTIONS; dir++)
{
default_direction_graphic[dir] =
element_info[i].direction_graphic[ACTION_DEFAULT][dir];
default_direction_crumbled[dir] = default_crumbled;
}
- for (act=0; act<NUM_ACTIONS; act++)
+ for (act = 0; act < NUM_ACTIONS; act++)
{
boolean act_remove = ((IS_DIGGABLE(i) && act == ACTION_DIGGING) ||
(IS_SNAPPABLE(i) && act == ACTION_SNAPPING) ||
if (IS_SB_ELEMENT(i) && element_info[EL_SB_DEFAULT].crumbled[act] != -1)
default_action_crumbled = element_info[EL_SB_DEFAULT].crumbled[act];
+#if 1
+ /* !!! make this better !!! */
+ if (i == EL_EMPTY_SPACE)
+ {
+ default_action_graphic = element_info[EL_DEFAULT].graphic[act];
+ default_action_crumbled = element_info[EL_DEFAULT].crumbled[act];
+ }
+#endif
+
if (default_action_graphic == -1)
default_action_graphic = default_graphic;
if (default_action_crumbled == -1)
default_action_crumbled = default_crumbled;
- for (dir=0; dir<NUM_DIRECTIONS; dir++)
+ for (dir = 0; dir < NUM_DIRECTIONS; dir++)
{
int default_action_direction_graphic = element_info[i].graphic[act];
int default_action_direction_crumbled = element_info[i].crumbled[act];
#if 1
/* set animation mode to "none" for each graphic with only 1 frame */
- for (i=0; i<MAX_NUM_ELEMENTS; i++)
+ for (i = 0; i < MAX_NUM_ELEMENTS; i++)
{
- for (act=0; act<NUM_ACTIONS; act++)
+ for (act = 0; act < NUM_ACTIONS; act++)
{
int graphic = element_info[i].graphic[act];
int crumbled = element_info[i].crumbled[act];
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; dir++)
{
graphic = element_info[i].direction_graphic[act][dir];
crumbled = element_info[i].direction_crumbled[act][dir];
#if DEBUG
if (options.verbose)
{
- for (i=0; i<MAX_NUM_ELEMENTS; i++)
- if (element_info[i].graphic[ACTION_DEFAULT] == IMG_CHAR_QUESTION &&
- i != EL_CHAR_QUESTION)
+ 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)",
element_info[i].token_name, i);
}
int i, j;
/* always start with reliable default values */
- for (i=0; i < MAX_NUM_ELEMENTS; i++)
- for (j=0; j < NUM_SPECIAL_GFX_ARGS; j++)
+ for (i = 0; i < MAX_NUM_ELEMENTS; i++)
+ for (j = 0; j < NUM_SPECIAL_GFX_ARGS; j++)
element_info[i].special_graphic[j] =
element_info[i].graphic[ACTION_DEFAULT];
/* initialize special element/graphic mapping from static configuration */
- for (i=0; element_to_special_graphic[i].element > -1; i++)
+ for (i = 0; element_to_special_graphic[i].element > -1; i++)
{
int element = element_to_special_graphic[i].element;
int special = element_to_special_graphic[i].special;
}
/* initialize special element/graphic mapping from dynamic configuration */
- for (i=0; i < num_property_mappings; i++)
+ for (i = 0; i < num_property_mappings; i++)
{
int element = property_mapping[i].base_index;
int special = property_mapping[i].ext3_index;
#if 1
/* 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++)
+ 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];
{
int i;
- for (i=0; i < MAX_NUM_ELEMENTS; i++)
+ for (i = 0; i < MAX_NUM_ELEMENTS; i++)
if (strcmp(element_info[i].token_name, token) == 0)
return i;
int i;
/* get integer values from string parameters */
- for (i=0; i < NUM_GFX_ARGS; i++)
+ for (i = 0; i < NUM_GFX_ARGS; i++)
{
parameter[i] =
get_parameter_value(image_config_suffix[i].token, parameter_raw[i],
GC copy_clipmask_gc = None;
#endif
- if (graphic_info != NULL)
- free(graphic_info);
+ checked_free(graphic_info);
graphic_info = checked_calloc(num_images * sizeof(struct GraphicInfo));
#if defined(TARGET_X11_NATIVE_PERFORMANCE_WORKAROUND)
if (clipmasks_initialized)
{
- for (i=0; i<num_images; i++)
+ for (i = 0; i < num_images; i++)
{
if (graphic_info[i].clip_mask)
XFreePixmap(display, graphic_info[i].clip_mask);
}
#endif
- for (i=0; i<num_images; i++)
+ for (i = 0; i < num_images; i++)
{
struct FileInfo *image = getImageListEntry(i);
Bitmap *src_bitmap;
int i, j, act;
/* set values to -1 to identify later as "uninitialized" values */
- for (i=0; i < MAX_NUM_ELEMENTS; i++)
- for (act=0; act < NUM_ACTIONS; act++)
+ for (i = 0; i < MAX_NUM_ELEMENTS; i++)
+ for (act = 0; act < NUM_ACTIONS; act++)
element_info[i].sound[act] = -1;
/* initialize element/sound mapping from static configuration */
- for (i=0; element_to_sound[i].element > -1; i++)
+ for (i = 0; element_to_sound[i].element > -1; i++)
{
int element = element_to_sound[i].element;
int action = element_to_sound[i].action;
if (!is_class)
element_info[element].sound[action] = sound;
else
- for (j=0; j < MAX_NUM_ELEMENTS; j++)
+ for (j = 0; j < MAX_NUM_ELEMENTS; j++)
if (strcmp(element_info[j].class_name,
element_info[element].class_name) == 0)
element_info[j].sound[action] = sound;
}
/* initialize element class/sound mapping from dynamic configuration */
- for (i=0; i < num_property_mappings; i++)
+ for (i = 0; i < num_property_mappings; i++)
{
int element_class = property_mapping[i].base_index - MAX_NUM_ELEMENTS;
int action = property_mapping[i].ext1_index;
if (action < 0)
action = ACTION_DEFAULT;
- for (j=0; j < MAX_NUM_ELEMENTS; j++)
+ for (j = 0; j < MAX_NUM_ELEMENTS; j++)
if (strcmp(element_info[j].class_name,
element_info[element_class].class_name) == 0)
element_info[j].sound[action] = sound;
}
/* initialize element/sound mapping from dynamic configuration */
- for (i=0; i < num_property_mappings; i++)
+ for (i = 0; i < num_property_mappings; i++)
{
int element = property_mapping[i].base_index;
int action = property_mapping[i].ext1_index;
}
/* now set all '-1' values to element specific default values */
- for (i=0; i<MAX_NUM_ELEMENTS; i++)
+ for (i = 0; i < MAX_NUM_ELEMENTS; i++)
{
- for (act=0; act < NUM_ACTIONS; act++)
+ for (act = 0; act < NUM_ACTIONS; act++)
{
/* generic default action sound (defined by "[default]" directive) */
int default_action_sound = element_info[EL_DEFAULT].sound[act];
if (IS_SB_ELEMENT(i) && element_info[EL_SB_DEFAULT].sound[act] != -1)
default_action_sound = element_info[EL_SB_DEFAULT].sound[act];
+ /* !!! there's no such thing as a "default action sound" !!! */
+#if 0
/* look for element specific default sound (independent from action) */
if (element_info[i].sound[ACTION_DEFAULT] != -1)
default_action_sound = element_info[i].sound[ACTION_DEFAULT];
+#endif
/* no sound for this specific action -- use default action sound */
if (element_info[i].sound[act] == -1)
int i;
/* set values to -1 to identify later as "uninitialized" values */
- for (i=0; i < NUM_SPECIAL_GFX_ARGS; i++)
+ for (i = 0; i < NUM_SPECIAL_GFX_ARGS; i++)
menu.sound[i] = -1;
/* initialize gamemode/sound mapping from static configuration */
- for (i=0; gamemode_to_sound[i].sound > -1; i++)
+ for (i = 0; gamemode_to_sound[i].sound > -1; i++)
{
int gamemode = gamemode_to_sound[i].gamemode;
int sound = gamemode_to_sound[i].sound;
}
/* now set all '-1' values to levelset specific default values */
- for (i=0; i < NUM_SPECIAL_GFX_ARGS; i++)
+ for (i = 0; i < NUM_SPECIAL_GFX_ARGS; i++)
if (menu.sound[i] == -1)
menu.sound[i] = menu.sound[GAME_MODE_DEFAULT];
#if 0
/* TEST ONLY */
- for (i=0; i < NUM_SPECIAL_GFX_ARGS; i++)
+ for (i = 0; i < NUM_SPECIAL_GFX_ARGS; i++)
if (menu.sound[i] != -1)
printf("::: menu.sound[%d] == %d\n", i, menu.sound[i]);
#endif
int i;
/* get integer values from string parameters */
- for (i=0; i < NUM_SND_ARGS; i++)
+ for (i = 0; i < NUM_SND_ARGS; i++)
parameter[i] =
get_parameter_value(sound_config_suffix[i].token, parameter_raw[i],
sound_config_suffix[i].type);
int num_sounds = getSoundListSize();
int i, j;
- if (sound_info != NULL)
- free(sound_info);
+ checked_free(sound_info);
sound_effect_properties = checked_calloc(num_sounds * sizeof(int));
sound_info = checked_calloc(num_sounds * sizeof(struct SoundInfo));
/* initialize sound effect for all elements to "no sound" */
- for (i=0; i < MAX_NUM_ELEMENTS; i++)
- for (j=0; j < NUM_ACTIONS; j++)
+ for (i = 0; i < MAX_NUM_ELEMENTS; i++)
+ for (j = 0; j < NUM_ACTIONS; j++)
element_info[i].sound[j] = SND_UNDEFINED;
- for (i=0; i < num_sounds; i++)
+ for (i = 0; i < num_sounds; i++)
{
struct FileInfo *sound = getSoundListEntry(i);
int len_effect_text = strlen(sound->token);
/* determine all loop sounds and identify certain sound classes */
- for (j=0; element_action_info[j].suffix; j++)
+ for (j = 0; element_action_info[j].suffix; j++)
{
int len_action_text = strlen(element_action_info[j].suffix);
/* associate elements and some selected sound actions */
- for (j=0; j < MAX_NUM_ELEMENTS; j++)
+ for (j = 0; j < MAX_NUM_ELEMENTS; j++)
{
if (element_info[j].class_name)
{
#if 0
/* !!! now handled in InitElementSoundInfo() !!! */
/* initialize element/sound mapping from dynamic configuration */
- for (i=0; i < num_property_mappings; i++)
+ for (i = 0; i < num_property_mappings; i++)
{
int element = property_mapping[i].base_index;
int action = property_mapping[i].ext1_index;
int i;
/* set values to -1 to identify later as "uninitialized" values */
- for (i=0; i < MAX_LEVELS; i++)
+ for (i = 0; i < MAX_LEVELS; i++)
levelset.music[i] = -1;
- for (i=0; i < NUM_SPECIAL_GFX_ARGS; i++)
+ for (i = 0; i < NUM_SPECIAL_GFX_ARGS; i++)
menu.music[i] = -1;
/* initialize gamemode/music mapping from static configuration */
- for (i=0; gamemode_to_music[i].music > -1; i++)
+ for (i = 0; gamemode_to_music[i].music > -1; i++)
{
int gamemode = gamemode_to_music[i].gamemode;
int music = gamemode_to_music[i].music;
}
/* initialize gamemode/music mapping from dynamic configuration */
- for (i=0; i < num_property_mappings; i++)
+ for (i = 0; i < num_property_mappings; i++)
{
int prefix = property_mapping[i].base_index;
int gamemode = property_mapping[i].ext1_index;
/* now set all '-1' values to menu specific default values */
/* (undefined values of "levelset.music[]" might stay at "-1" to
allow dynamic selection of music files from music directory!) */
- for (i=0; i < MAX_LEVELS; i++)
+ for (i = 0; i < MAX_LEVELS; i++)
if (levelset.music[i] == -1)
levelset.music[i] = default_levelset_music;
- for (i=0; i < NUM_SPECIAL_GFX_ARGS; i++)
+ for (i = 0; i < NUM_SPECIAL_GFX_ARGS; i++)
if (menu.music[i] == -1)
menu.music[i] = menu.music[GAME_MODE_DEFAULT];
#if 0
/* TEST ONLY */
- for (i=0; i < MAX_LEVELS; i++)
+ for (i = 0; i < MAX_LEVELS; i++)
if (levelset.music[i] != -1)
printf("::: levelset.music[%d] == %d\n", i, levelset.music[i]);
- for (i=0; i < NUM_SPECIAL_GFX_ARGS; i++)
+ for (i = 0; i < NUM_SPECIAL_GFX_ARGS; i++)
if (menu.music[i] != -1)
printf("::: menu.music[%d] == %d\n", i, menu.music[i]);
#endif
int i;
/* get integer values from string parameters */
- for (i=0; i < NUM_MUS_ARGS; i++)
+ for (i = 0; i < NUM_MUS_ARGS; i++)
parameter[i] =
get_parameter_value(music_config_suffix[i].token, parameter_raw[i],
music_config_suffix[i].type);
int num_music = getMusicListSize();
int i, j;
- if (music_info != NULL)
- free(music_info);
+ checked_free(music_info);
music_info = checked_calloc(num_music * sizeof(struct MusicInfo));
- for (i=0; i < num_music; i++)
+ for (i = 0; i < num_music; i++)
{
struct FileInfo *music = getMusicListEntry(i);
int len_music_text = strlen(music->token);
/* determine all loop music */
- for (j=0; music_prefix_info[j].prefix; j++)
+ for (j = 0; music_prefix_info[j].prefix; j++)
{
int len_prefix_text = strlen(music_prefix_info[j].prefix);
InitGameModeMusicInfo(); /* game mode music mapping */
}
+static int get_special_property_bit(int element, int property_bit_nr)
+{
+ struct PropertyBitInfo
+ {
+ int element;
+ int bit_nr;
+ };
+
+ static struct PropertyBitInfo pb_can_move_into_acid[] =
+ {
+ /* the player may be able fall into acid when gravity is activated */
+ { EL_PLAYER_1, 0 },
+ { EL_PLAYER_2, 0 },
+ { EL_PLAYER_3, 0 },
+ { EL_PLAYER_4, 0 },
+ { EL_SP_MURPHY, 0 },
+
+ /* all element that can move may be able to also move into acid */
+ { EL_BUG, 1 },
+ { EL_BUG_LEFT, 1 },
+ { EL_BUG_RIGHT, 1 },
+ { EL_BUG_UP, 1 },
+ { EL_BUG_DOWN, 1 },
+ { EL_SPACESHIP, 2 },
+ { EL_SPACESHIP_LEFT, 2 },
+ { EL_SPACESHIP_RIGHT, 2 },
+ { EL_SPACESHIP_UP, 2 },
+ { EL_SPACESHIP_DOWN, 2 },
+ { EL_BD_BUTTERFLY, 3 },
+ { EL_BD_BUTTERFLY_LEFT, 3 },
+ { EL_BD_BUTTERFLY_RIGHT, 3 },
+ { EL_BD_BUTTERFLY_UP, 3 },
+ { EL_BD_BUTTERFLY_DOWN, 3 },
+ { EL_BD_FIREFLY, 4 },
+ { EL_BD_FIREFLY_LEFT, 4 },
+ { EL_BD_FIREFLY_RIGHT, 4 },
+ { EL_BD_FIREFLY_UP, 4 },
+ { EL_BD_FIREFLY_DOWN, 4 },
+ { EL_YAMYAM, 5 },
+ { EL_DARK_YAMYAM, 6 },
+ { EL_ROBOT, 7 },
+ { EL_PACMAN, 8 },
+ { EL_PACMAN_LEFT, 8 },
+ { EL_PACMAN_RIGHT, 8 },
+ { EL_PACMAN_UP, 8 },
+ { EL_PACMAN_DOWN, 8 },
+ { EL_MOLE, 9 },
+ { EL_MOLE_LEFT, 9 },
+ { EL_MOLE_RIGHT, 9 },
+ { EL_MOLE_UP, 9 },
+ { EL_MOLE_DOWN, 9 },
+ { EL_PENGUIN, 10 },
+ { EL_PIG, 11 },
+ { EL_DRAGON, 12 },
+ { EL_SATELLITE, 13 },
+ { EL_SP_SNIKSNAK, 14 },
+ { EL_SP_ELECTRON, 15 },
+ { EL_BALLOON, 16 },
+ { EL_SPRING, 17 },
+
+ { -1, -1 },
+ };
+
+ static struct PropertyBitInfo pb_dont_collide_with[] =
+ {
+ { EL_SP_SNIKSNAK, 0 },
+ { EL_SP_ELECTRON, 1 },
+
+ { -1, -1 },
+ };
+
+ static struct
+ {
+ int bit_nr;
+ struct PropertyBitInfo *pb_info;
+ } pb_definition[] =
+ {
+ { EP_CAN_MOVE_INTO_ACID, pb_can_move_into_acid },
+ { EP_DONT_COLLIDE_WITH, pb_dont_collide_with },
+
+ { -1, NULL },
+ };
+
+ struct PropertyBitInfo *pb_info = NULL;
+ int i;
+
+ for (i = 0; pb_definition[i].bit_nr != -1; i++)
+ if (pb_definition[i].bit_nr == property_bit_nr)
+ pb_info = pb_definition[i].pb_info;
+
+ if (pb_info == NULL)
+ return -1;
+
+ for (i = 0; pb_info[i].element != -1; i++)
+ if (pb_info[i].element == element)
+ return pb_info[i].bit_nr;
+
+ return -1;
+}
+
+#if 1
+void setBitfieldProperty(int *bitfield, int property_bit_nr, int element,
+ boolean property_value)
+{
+ int bit_nr = get_special_property_bit(element, property_bit_nr);
+
+ if (bit_nr > -1)
+ {
+ if (property_value)
+ *bitfield |= (1 << bit_nr);
+ else
+ *bitfield &= ~(1 << bit_nr);
+ }
+}
+
+boolean getBitfieldProperty(int *bitfield, int property_bit_nr, int element)
+{
+ int bit_nr = get_special_property_bit(element, property_bit_nr);
+
+ if (bit_nr > -1)
+ return ((*bitfield & (1 << bit_nr)) != 0);
+
+ return FALSE;
+}
+
+#else
+
+void setMoveIntoAcidProperty(struct LevelInfo *level, int element, boolean set)
+{
+ int bit_nr = get_special_property_bit(element, EP_CAN_MOVE_INTO_ACID);
+
+ if (bit_nr > -1)
+ {
+ level->can_move_into_acid_bits &= ~(1 << bit_nr);
+
+ if (set)
+ level->can_move_into_acid_bits |= (1 << bit_nr);
+ }
+}
+
+boolean getMoveIntoAcidProperty(struct LevelInfo *level, int element)
+{
+ int bit_nr = get_special_property_bit(element, EP_CAN_MOVE_INTO_ACID);
+
+ if (bit_nr > -1)
+ return ((level->can_move_into_acid_bits & (1 << bit_nr)) != 0);
+
+ return FALSE;
+}
+#endif
+
void InitElementPropertiesStatic()
{
static int ep_diggable[] =
static int ep_can_move[] =
{
+ /* same elements as in 'pb_can_move_into_acid' */
EL_BUG,
EL_SPACESHIP,
EL_BD_BUTTERFLY,
EL_SP_DISK_YELLOW,
EL_SP_SNIKSNAK,
EL_SP_ELECTRON,
+#if 0
+ EL_BLACK_ORB,
+#endif
-1
};
-1
};
+ static int ep_can_explode_cross[] =
+ {
+ -1
+ };
+
+ static int ep_protected[] =
+ {
+ EL_EM_GATE_1,
+ EL_EM_GATE_2,
+ EL_EM_GATE_3,
+ EL_EM_GATE_4,
+ EL_EM_GATE_1_GRAY,
+ EL_EM_GATE_2_GRAY,
+ EL_EM_GATE_3_GRAY,
+ EL_EM_GATE_4_GRAY,
+ EL_SWITCHGATE_OPEN,
+ EL_TIMEGATE_OPEN,
+ -1
+ };
+
static int ep_player[] =
{
EL_PLAYER_1,
EL_BD_BUTTERFLY_4,
EL_BD_AMOEBA,
EL_CHAR_QUESTION,
+ EL_UNKNOWN,
-1
};
-1
};
+ static int ep_can_turn_each_move[] =
+ {
+ /* !!! do something !!! */
+ -1
+ };
+
static int ep_active_bomb[] =
{
EL_DYNAMITE_ACTIVE,
{ ep_droppable, EP_DROPPABLE },
{ ep_can_explode_1x1, EP_CAN_EXPLODE_1X1 },
{ ep_pushable, EP_PUSHABLE },
+ { ep_can_explode_cross, EP_CAN_EXPLODE_CROSS },
+ { ep_protected, EP_PROTECTED },
{ ep_player, EP_PLAYER },
{ ep_can_pass_magic_wall, EP_CAN_PASS_MAGIC_WALL },
{ 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_active_bomb, EP_ACTIVE_BOMB },
{ ep_inactive, EP_INACTIVE },
EL_PACMAN_LEFT, EL_PACMAN_RIGHT,
EL_PACMAN_UP, EL_PACMAN_DOWN
},
+ {
+ EL_MOLE,
+ EL_MOLE_LEFT, EL_MOLE_RIGHT,
+ EL_MOLE_UP, EL_MOLE_DOWN
+ },
{
-1,
-1, -1, -1, -1
int i, j, k;
/* always start with reliable default values (element has no properties) */
- for (i=0; i < MAX_NUM_ELEMENTS; i++)
- for (j=0; j < NUM_ELEMENT_PROPERTIES; j++)
+ for (i = 0; i < MAX_NUM_ELEMENTS; i++)
+ 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++)
- for (j=0; (element_properties[i].elements)[j] != -1; j++)
+ for (i = 0; element_properties[i].elements != NULL; i++)
+ for (j = 0; (element_properties[i].elements)[j] != -1; j++)
SET_PROPERTY((element_properties[i].elements)[j],
element_properties[i].property, TRUE);
/* copy properties to some elements that are only stored in level file */
- for (i=0; i < NUM_ELEMENT_PROPERTIES; i++)
- for (j=0; copy_properties[j][0] != -1; j++)
+ for (i = 0; i < NUM_ELEMENT_PROPERTIES; i++)
+ for (j = 0; copy_properties[j][0] != -1; j++)
if (HAS_PROPERTY(copy_properties[j][0], i))
- for (k=1; k<=4; k++)
+ for (k = 1; k <= 4; k++)
SET_PROPERTY(copy_properties[j][k], i, TRUE);
}
EP_ACTIVE_BOMB,
EP_ACCESSIBLE,
+
-1
};
InitElementPropertiesStatic();
#endif
+ /* important: after initialization in InitElementPropertiesStatic(), the
+ elements are not again initialized to a default value; therefore all
+ changes have to make sure that they leave the element with a defined
+ property (which means that conditional property changes must be set to
+ a reliable default value before) */
+
/* set all special, combined or engine dependent element properties */
- for (i=0; i < MAX_NUM_ELEMENTS; i++)
+ for (i = 0; i < MAX_NUM_ELEMENTS; i++)
{
#if 0
- for (j=EP_ACCESSIBLE_OVER; j < NUM_ELEMENT_PROPERTIES; j++)
+ for (j = EP_ACCESSIBLE_OVER; j < NUM_ELEMENT_PROPERTIES; j++)
SET_PROPERTY(i, j, FALSE);
#endif
/* ---------- INACTIVE ------------------------------------------------- */
- if (i >= EL_CHAR_START && i <= EL_CHAR_END)
- SET_PROPERTY(i, EP_INACTIVE, TRUE);
+ SET_PROPERTY(i, EP_INACTIVE, (i >= EL_CHAR_START && i <= EL_CHAR_END));
/* ---------- WALKABLE, PASSABLE, ACCESSIBLE --------------------------- */
SET_PROPERTY(i, EP_WALKABLE, (IS_WALKABLE_OVER(i) ||
/* ---------- WALL ----------------------------------------------------- */
SET_PROPERTY(i, EP_WALL, TRUE); /* default: element is wall */
- for (j=0; no_wall_properties[j] != -1; j++)
+ for (j = 0; no_wall_properties[j] != -1; j++)
if (HAS_PROPERTY(i, no_wall_properties[j]) ||
i >= EL_FIRST_RUNTIME_UNREAL)
SET_PROPERTY(i, EP_WALL, FALSE);
!IS_DIGGABLE(i) &&
!IS_COLLECTIBLE(i)));
+#if 1
+ /* ---------- PROTECTED ------------------------------------------------ */
+ if (IS_ACCESSIBLE_INSIDE(i))
+ SET_PROPERTY(i, EP_PROTECTED, TRUE);
+#endif
+
/* ---------- DRAGONFIRE_PROOF ----------------------------------------- */
if (IS_HISTORIC_SOLID(i) || i == EL_EXPLOSION)
else if (engine_version < VERSION_IDENT(2,2,0,0))
SET_PROPERTY(i, EP_EXPLOSION_PROOF, IS_INDESTRUCTIBLE(i));
else
+#if 1
+ SET_PROPERTY(i, EP_EXPLOSION_PROOF, (IS_INDESTRUCTIBLE(i) &&
+ (!IS_WALKABLE(i) ||
+ IS_PROTECTED(i))));
+#else
+#if 1
SET_PROPERTY(i, EP_EXPLOSION_PROOF, (IS_INDESTRUCTIBLE(i) &&
!IS_WALKABLE_OVER(i) &&
!IS_WALKABLE_UNDER(i)));
+#else
+ SET_PROPERTY(i, EP_EXPLOSION_PROOF, (IS_INDESTRUCTIBLE(i) &&
+ IS_PROTECTED(i)));
+#endif
+#endif
if (IS_CUSTOM_ELEMENT(i))
{
+ /* these are additional properties which are initially false when set */
+
/* ---------- DONT_COLLIDE_WITH / DONT_RUN_INTO ---------------------- */
if (DONT_TOUCH(i))
SET_PROPERTY(i, EP_DONT_COLLIDE_WITH, TRUE);
/* ---------- CAN_EXPLODE_3X3 ------------------------------------------ */
SET_PROPERTY(i, EP_CAN_EXPLODE_3X3, (CAN_EXPLODE(i) &&
- !CAN_EXPLODE_1X1(i)));
+ !CAN_EXPLODE_1X1(i) &&
+ !CAN_EXPLODE_CROSS(i)));
+
+ /* ---------- CAN_EXPLODE_BY_DRAGONFIRE -------------------------------- */
+ SET_PROPERTY(i, EP_CAN_EXPLODE_BY_DRAGONFIRE, CAN_EXPLODE_BY_FIRE(i));
+
+ /* ---------- CAN_EXPLODE_BY_EXPLOSION --------------------------------- */
+ SET_PROPERTY(i, EP_CAN_EXPLODE_BY_EXPLOSION, (CAN_EXPLODE_BY_FIRE(i) ||
+ i == EL_BLACK_ORB));
+
+ /* ---------- COULD_MOVE_INTO_ACID ------------------------------------- */
+ SET_PROPERTY(i, EP_COULD_MOVE_INTO_ACID, (ELEM_IS_PLAYER(i) ||
+ CAN_MOVE(i) ||
+ IS_CUSTOM_ELEMENT(i)));
+
+ /* ---------- MAYBE_DONT_COLLIDE_WITH ---------------------------------- */
+ SET_PROPERTY(i, EP_MAYBE_DONT_COLLIDE_WITH, (i == EL_SP_SNIKSNAK ||
+ i == EL_SP_ELECTRON));
+
+ /* ---------- CAN_MOVE_INTO_ACID --------------------------------------- */
+ if (COULD_MOVE_INTO_ACID(i) && !IS_CUSTOM_ELEMENT(i))
+ SET_PROPERTY(i, EP_CAN_MOVE_INTO_ACID,
+ getMoveIntoAcidProperty(&level, i));
+
+ /* ---------- DONT_COLLIDE_WITH ---------------------------------------- */
+ if (MAYBE_DONT_COLLIDE_WITH(i))
+ SET_PROPERTY(i, EP_DONT_COLLIDE_WITH,
+ getDontCollideWithProperty(&level, i));
+
+ /* ---------- SP_PORT -------------------------------------------------- */
+ SET_PROPERTY(i, EP_SP_PORT, (IS_SP_ELEMENT(i) &&
+ IS_PASSABLE_INSIDE(i)));
+
+#if 0
+ if (i == EL_CUSTOM_START + 253)
+ printf("::: %d, %d, %d -> %d\n",
+ CAN_EXPLODE_1X1(i),
+ CAN_EXPLODE_3X3(i),
+ CAN_EXPLODE_CROSS(i),
+ CAN_EXPLODE(i));
+#endif
/* ---------- CAN_CHANGE ----------------------------------------------- */
SET_PROPERTY(i, EP_CAN_CHANGE, FALSE); /* default: cannot change */
- for (j=0; j < element_info[i].num_change_pages; j++)
+ for (j = 0; j < element_info[i].num_change_pages; j++)
if (element_info[i].change_page[j].can_change)
SET_PROPERTY(i, EP_CAN_CHANGE, TRUE);
#if 0
/* determine inactive elements (used for engine main loop optimization) */
- for (i=0; i < MAX_NUM_ELEMENTS; i++)
+ for (i = 0; i < MAX_NUM_ELEMENTS; i++)
{
boolean active = FALSE;
- for (j=0; i < NUM_ELEMENT_PROPERTIES; j++)
+ for (j = 0; i < NUM_ELEMENT_PROPERTIES; j++)
{
if (HAS_PROPERTY(i, j))
active = TRUE;
};
/* special EM style gems behaviour */
- for (i=0; ep_em_slippery_wall[i] != -1; i++)
+ for (i = 0; ep_em_slippery_wall[i] != -1; i++)
SET_PROPERTY(ep_em_slippery_wall[i], EP_EM_SLIPPERY_WALL,
level.em_slippery_gems);
}
/* set uninitialized push delay values of custom elements in older levels */
- for (i=0; i < NUM_CUSTOM_ELEMENTS; i++)
+ for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
{
int element = EL_CUSTOM_START + i;
if (element_info[element].push_delay_random == -1)
element_info[element].push_delay_random = game.default_push_delay_random;
}
+
+ /* set some other uninitialized values of custom elements in older levels */
+ if (engine_version < VERSION_IDENT(3,1,0,0))
+ {
+ for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
+ {
+ int element = EL_CUSTOM_START + i;
+
+ element_info[element].access_direction = MV_ALL_DIRECTIONS;
+
+ element_info[element].explosion_delay = 17;
+ 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
+
+#endif
+
+ /* this is needed because some graphics depend on element properties */
+ if (game_status == GAME_MODE_PLAYING)
+ InitElementGraphicInfo();
}
static void InitGlobal()
void Execute_Command(char *command)
{
+ int i;
+
if (strcmp(command, "print graphicsinfo.conf") == 0)
{
- int i;
-
printf("# You can configure additional/alternative image files here.\n");
printf("# (The entries below are default and therefore commented out.)\n");
printf("\n");
printf("%s\n", getFormattedSetupEntry("sort_priority", "100"));
printf("\n");
- for (i=0; image_config[i].token != NULL; i++)
- printf("# %s\n",
- getFormattedSetupEntry(image_config[i].token,
- image_config[i].value));
+ for (i = 0; image_config[i].token != NULL; i++)
+ printf("# %s\n", getFormattedSetupEntry(image_config[i].token,
+ image_config[i].value));
exit(0);
}
else if (strcmp(command, "print soundsinfo.conf") == 0)
{
- int i;
-
printf("# You can configure additional/alternative sound files here.\n");
printf("# (The entries below are default and therefore commented out.)\n");
printf("\n");
printf("%s\n", getFormattedSetupEntry("sort_priority", "100"));
printf("\n");
- for (i=0; sound_config[i].token != NULL; i++)
- printf("# %s\n",
- getFormattedSetupEntry(sound_config[i].token,
- sound_config[i].value));
+ for (i = 0; sound_config[i].token != NULL; i++)
+ printf("# %s\n", getFormattedSetupEntry(sound_config[i].token,
+ sound_config[i].value));
exit(0);
}
else if (strcmp(command, "print musicinfo.conf") == 0)
{
- int i;
-
printf("# You can configure additional/alternative music files here.\n");
printf("# (The entries below are default and therefore commented out.)\n");
printf("\n");
printf("%s\n", getFormattedSetupEntry("sort_priority", "100"));
printf("\n");
- for (i=0; music_config[i].token != NULL; i++)
- printf("# %s\n",
- getFormattedSetupEntry(music_config[i].token,
- music_config[i].value));
+ for (i = 0; music_config[i].token != NULL; i++)
+ printf("# %s\n", getFormattedSetupEntry(music_config[i].token,
+ music_config[i].value));
exit(0);
}
exit(0);
}
+ else if (strcmp(command, "print helpanim.conf") == 0)
+ {
+ printf("# You can configure different element help animations here.\n");
+ printf("# (The entries below are default and therefore commented out.)\n");
+ printf("\n");
+
+ for (i = 0; helpanim_config[i].token != NULL; i++)
+ {
+ printf("# %s\n", getFormattedSetupEntry(helpanim_config[i].token,
+ helpanim_config[i].value));
+
+ if (strcmp(helpanim_config[i].token, "end") == 0)
+ printf("#\n");
+ }
+
+ exit(0);
+ }
+ else if (strcmp(command, "print helptext.conf") == 0)
+ {
+ printf("# You can configure different element help text here.\n");
+ printf("# (The entries below are default and therefore commented out.)\n");
+ printf("\n");
+
+ for (i = 0; helptext_config[i].token != NULL; i++)
+ printf("# %s\n", getFormattedSetupEntry(helptext_config[i].token,
+ helptext_config[i].value));
+
+ exit(0);
+ }
else if (strncmp(command, "dump level ", 11) == 0)
{
char *filename = &command[11];
/* choose default local player */
local_player = &stored_player[0];
- for (i=0; i<MAX_PLAYERS; i++)
+ for (i = 0; i < MAX_PLAYERS; i++)
stored_player[i].connected = FALSE;
local_player->connected = TRUE;
/* dynamically determine list of generic tokens to be ignored */
num_ignore_generic_tokens = 0;
- for (i=0; ignore_generic_tokens[i] != NULL; i++)
+ for (i = 0; ignore_generic_tokens[i] != NULL; i++)
num_ignore_generic_tokens++;
/* dynamically determine list of image tokens to be ignored */
num_ignore_image_tokens = num_ignore_generic_tokens;
- for (i=0; image_config_vars[i].token != NULL; i++)
+ for (i = 0; image_config_vars[i].token != NULL; i++)
num_ignore_image_tokens++;
ignore_image_tokens =
checked_malloc((num_ignore_image_tokens + 1) * sizeof(char *));
- for (i=0; i < num_ignore_generic_tokens; i++)
+ for (i = 0; i < num_ignore_generic_tokens; i++)
ignore_image_tokens[i] = ignore_generic_tokens[i];
- for (i=0; i < num_ignore_image_tokens - num_ignore_generic_tokens; i++)
+ for (i = 0; i < num_ignore_image_tokens - num_ignore_generic_tokens; i++)
ignore_image_tokens[num_ignore_generic_tokens + i] =
image_config_vars[i].token;
ignore_image_tokens[num_ignore_image_tokens] = NULL;
num_ignore_sound_tokens = num_ignore_generic_tokens;
ignore_sound_tokens =
checked_malloc((num_ignore_sound_tokens + 1) * sizeof(char *));
- for (i=0; i < num_ignore_generic_tokens; i++)
+ for (i = 0; i < num_ignore_generic_tokens; i++)
ignore_sound_tokens[i] = ignore_generic_tokens[i];
ignore_sound_tokens[num_ignore_sound_tokens] = NULL;
num_ignore_music_tokens = num_ignore_generic_tokens;
ignore_music_tokens =
checked_malloc((num_ignore_music_tokens + 1) * sizeof(char *));
- for (i=0; i < num_ignore_generic_tokens; i++)
+ for (i = 0; i < num_ignore_generic_tokens; i++)
ignore_music_tokens[i] = ignore_generic_tokens[i];
ignore_music_tokens[num_ignore_music_tokens] = NULL;
- for (i=0; i < MAX_NUM_ELEMENTS; i++)
+ for (i = 0; i < MAX_NUM_ELEMENTS; i++)
image_id_prefix[i] = element_info[i].token_name;
- for (i=0; i < NUM_FONTS; i++)
+ for (i = 0; i < NUM_FONTS; i++)
image_id_prefix[MAX_NUM_ELEMENTS + i] = font_info[i].token_name;
image_id_prefix[MAX_NUM_ELEMENTS + NUM_FONTS] = NULL;
- for (i=0; i < MAX_NUM_ELEMENTS; i++)
+ for (i = 0; i < MAX_NUM_ELEMENTS; i++)
sound_id_prefix[i] = element_info[i].token_name;
- for (i=0; i < MAX_NUM_ELEMENTS; i++)
+ for (i = 0; i < MAX_NUM_ELEMENTS; i++)
sound_id_prefix[MAX_NUM_ELEMENTS + i] =
get_string_in_brackets(element_info[i].class_name);
sound_id_prefix[2 * MAX_NUM_ELEMENTS] = NULL;
- for (i=0; i < NUM_MUSIC_PREFIXES; i++)
+ for (i = 0; i < NUM_MUSIC_PREFIXES; i++)
music_id_prefix[i] = music_prefix_info[i].prefix;
music_id_prefix[MAX_LEVELS] = NULL;
- for (i=0; i < NUM_ACTIONS; i++)
+ for (i = 0; i < NUM_ACTIONS; i++)
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; i++)
direction_id_suffix[i] = element_direction_info[i].suffix;
direction_id_suffix[NUM_DIRECTIONS] = NULL;
- for (i=0; i < NUM_SPECIAL_GFX_ARGS; i++)
+ for (i = 0; i < NUM_SPECIAL_GFX_ARGS; i++)
special_id_suffix[i] = special_suffix_info[i].suffix;
special_id_suffix[NUM_SPECIAL_GFX_ARGS] = NULL;
- for (i=0; i < MAX_LEVELS; i++)
+ for (i = 0; i < MAX_LEVELS; i++)
level_id_suffix[i] = get_level_id_suffix(i);
level_id_suffix[MAX_LEVELS] = NULL;
int i, j;
/* determine settings for initial font (for displaying startup messages) */
- for (i=0; image_config[i].token != NULL; i++)
+ for (i = 0; image_config[i].token != NULL; i++)
{
- for (j=0; j < NUM_INITIAL_FONTS; j++)
+ for (j = 0; j < NUM_INITIAL_FONTS; j++)
{
char font_token[128];
int len_font_token;
}
}
- for (j=0; j < NUM_INITIAL_FONTS; j++)
+ for (j = 0; j < NUM_INITIAL_FONTS; j++)
{
font_initial[j].num_chars = DEFAULT_NUM_CHARS_PER_FONT;
font_initial[j].num_chars_per_line = DEFAULT_NUM_CHARS_PER_LINE;
bitmap_font_initial = LoadCustomImage(filename_font_initial);
- for (j=0; j < NUM_INITIAL_FONTS; j++)
+ for (j = 0; j < NUM_INITIAL_FONTS; j++)
font_initial[j].bitmap = bitmap_font_initial;
InitFontGraphicInfo();
ClearRectangle(backbuffer, REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE);
ClearRectangle(bitmap_db_door, 0, 0, 3 * DXSIZE, DYSIZE + VYSIZE);
- for (x=0; x<MAX_BUF_XSIZE; x++)
- for (y=0; y<MAX_BUF_YSIZE; y++)
+ for (x = 0; x < MAX_BUF_XSIZE; x++)
+ for (y = 0; y < MAX_BUF_YSIZE; y++)
redraw[x][y] = 0;
redraw_tiles = 0;
redraw_mask = REDRAW_ALL;
return artwork_new_identifier;
}
-void ReloadCustomArtwork()
+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);
+ 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;
- if (gfx_new_identifier != NULL)
+ if (gfx_new_identifier != NULL || force_reload_gfx)
{
#if 0
printf("RELOADING GRAPHICS '%s' -> '%s' ['%s', '%s']\n",
redraw_screen = TRUE;
}
- if (snd_new_identifier != NULL)
+ if (snd_new_identifier != NULL || force_reload_snd)
{
ClearRectangle(window, 0, 0, WIN_XSIZE, WIN_YSIZE);
redraw_screen = TRUE;
}
- if (mus_new_identifier != NULL)
+ if (mus_new_identifier != NULL || force_reload_mus)
{
ClearRectangle(window, 0, 0, WIN_XSIZE, WIN_YSIZE);
projects / rocksndiamonds.git / blobdiff