/***********************************************************
* Rocks'n'Diamonds -- McDuffin Strikes Back! *
*----------------------------------------------------------*
-* (c) 1995-2002 Artsoft Entertainment *
+* (c) 1995-2006 Artsoft Entertainment *
* Holger Schemel *
* Detmolder Strasse 189 *
* 33604 Bielefeld *
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,
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
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;
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;
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)
{
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);
{
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];
}
}
+#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
if (type != TYPE_TOKEN)
return get_parameter_value(value_raw, suffix, type);
- if (strcmp(value_raw, ARG_UNDEFINED) == 0)
+ if (strEqual(value_raw, ARG_UNDEFINED))
return ARG_UNDEFINED_VALUE;
/* !!! OPTIMIZE THIS BY USING HASH !!! */
for (i = 0; i < MAX_NUM_ELEMENTS; i++)
- if (strcmp(element_info[i].token_name, value_raw) == 0)
+ if (strEqual(element_info[i].token_name, value_raw))
return i;
/* !!! OPTIMIZE THIS BY USING HASH !!! */
{
int len_config_value = strlen(image_config[i].value);
- 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)
+ 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 (strcmp(image_config[i].token, value_raw) == 0)
+ if (strEqual(image_config[i].token, value_raw))
return x;
x++;
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];
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;
}
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;
InitElementGraphicInfo(); /* element game graphic mapping */
InitElementSpecialGraphicInfo(); /* element special graphic mapping */
- InitElementSmallImages(); /* scale images to all needed sizes */
+ InitElementSmallImages(); /* scale elements to all needed sizes */
+ InitScaledImages(); /* scale all other images, if needed */
InitFontGraphicInfo(); /* initialize text drawing functions */
InitGraphicInfo_EM(); /* graphic mapping for EM engine */
{ 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 resolve_group_element(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_element - EL_GROUP_START;
+
+ group->num_elements_resolved = 0;
+ group->choice_pos = 0;
+ }
+
+ 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))
+ resolve_group_element(element, recursion_depth + 1);
+ else
+ {
+ group->element_resolved[group->num_elements_resolved++] = element;
+ element_info[element].in_group[group_nr] = TRUE;
+ }
+ }
+}
+
void InitElementPropertiesStatic()
{
static int ep_diggable[] =
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_SPEED_PILL,
EL_EMC_LENSES,
EL_EMC_MAGNIFIER,
+
-1
};
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_TUBE_LEFT_DOWN,
EL_TUBE_RIGHT_UP,
EL_TUBE_RIGHT_DOWN,
+
-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_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_PENGUIN,
EL_PIG,
EL_DRAGON,
+
-1
};
EL_TUBE_LEFT_DOWN,
EL_TUBE_RIGHT_UP,
EL_TUBE_RIGHT_DOWN,
+
-1
};
EL_EMC_GATE_8_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_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
};
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_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
};
EL_EMC_GATE_6_GRAY_ACTIVE,
EL_EMC_GATE_7_GRAY_ACTIVE,
EL_EMC_GATE_8_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_EMC_GATE_7_GRAY_ACTIVE,
EL_EMC_GATE_8_GRAY_ACTIVE,
EL_DYNAMITE,
+ EL_EM_DYNAMITE,
EL_INVISIBLE_STEELWALL,
EL_INVISIBLE_WALL,
EL_INVISIBLE_SAND,
EL_EMC_WALL_14,
EL_EMC_WALL_15,
EL_EMC_WALL_16,
+
-1
};
EL_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_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_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_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_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;
property (which means that conditional property changes must be set to
a reliable default value before) */
+ /* ---------- recursively resolve group elements ------------------------- */
+
+ for (i = 0; i < MAX_NUM_ELEMENTS; i++)
+ for (j = 0; j < NUM_GROUP_ELEMENTS; j++)
+ element_info[i].in_group[j] = FALSE;
+
+ for (i = 0; i < NUM_GROUP_ELEMENTS; i++)
+ resolve_group_element(EL_GROUP_START + i, 0);
+
/* set all special, combined or engine dependent element properties */
for (i = 0; i < MAX_NUM_ELEMENTS; i++)
{
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 */
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 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;
{
char *filename_font_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);
/* initialize screen properties */
InitFontGraphicInfo();
+ font_height = getFontHeight(FC_RED);
+
DrawInitText(getProgramInitString(), 20, FC_YELLOW);
DrawInitText(PROGRAM_COPYRIGHT_STRING, 50, FC_RED);
+ DrawInitText(PROGRAM_WEBSITE_STRING, WIN_YSIZE - 20 - font_height, FC_RED);
DrawInitText("Loading graphics:", 120, FC_GREEN);
}
+void RedrawBackground()
+{
+ BlitBitmap(graphic_info[IMG_GLOBAL_BORDER].bitmap, backbuffer,
+ 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
+
+ redraw_mask = REDRAW_ALL;
+}
+
void InitGfxBackground()
{
int x, y;
fieldbuffer = bitmap_db_field;
SetDrawtoField(DRAW_BACKBUFFER);
- BlitBitmap(graphic_info[IMG_GLOBAL_BORDER].bitmap, backbuffer,
- 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
+ RedrawBackground();
+
ClearRectangle(backbuffer, REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE);
ClearRectangle(bitmap_db_door, 0, 0, 3 * DXSIZE, DYSIZE + VYSIZE);
#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);
+ 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;
+ 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);
+
if (gfx_new_identifier != NULL || force_reload_gfx)
{
#if 0
if (redraw_screen)
{
- InitGfxBackground();
+ RedrawBackground();
/* force redraw of (open or closed) door graphics */
SetDoorState(DOOR_OPEN_ALL);
InitGfxBackground();
+#if 1
+ em_open_all();
+#endif
+
if (global.autoplay_leveldir)
{
AutoPlayTape();
game_status = GAME_MODE_MAIN;
-#if 1
- em_open_all();
-#endif
-
DrawMainMenu();
InitNetworkServer();
CloseVideoDisplay();
ClosePlatformDependentStuff();
+ if (exit_value != 0)
+ NotifyUserAboutErrorFile();
+
exit(exit_value);
}