#define CONFIG_TOKEN_FONT_INITIAL "font.initial"
-struct FontBitmapInfo font_initial[NUM_INITIAL_FONTS];
+static struct FontBitmapInfo font_initial[NUM_INITIAL_FONTS];
-
-static void InitTileClipmasks()
+static int copy_properties[][5] =
{
-#if 0
-#if defined(TARGET_X11)
- XGCValues clip_gc_values;
- unsigned long clip_gc_valuemask;
-
-#if defined(TARGET_X11_NATIVE)
-
-#if 0
- GC copy_clipmask_gc;
-
- static struct
{
- int start;
- int count;
- }
- tile_needs_clipping[] =
- {
- { GFX_SPIELER1_UP, 4 },
- { GFX_SPIELER1_DOWN, 4 },
- { GFX_SPIELER1_LEFT, 4 },
- { GFX_SPIELER1_RIGHT, 4 },
- { GFX_SPIELER1_PUSH_LEFT, 4 },
- { GFX_SPIELER1_PUSH_RIGHT, 4 },
- { GFX_SPIELER2_UP, 4 },
- { GFX_SPIELER2_DOWN, 4 },
- { GFX_SPIELER2_LEFT, 4 },
- { GFX_SPIELER2_RIGHT, 4 },
- { GFX_SPIELER2_PUSH_LEFT, 4 },
- { GFX_SPIELER2_PUSH_RIGHT, 4 },
- { GFX_SPIELER3_UP, 4 },
- { GFX_SPIELER3_DOWN, 4 },
- { GFX_SPIELER3_LEFT, 4 },
- { GFX_SPIELER3_RIGHT, 4 },
- { GFX_SPIELER3_PUSH_LEFT, 4 },
- { GFX_SPIELER3_PUSH_RIGHT, 4 },
- { GFX_SPIELER4_UP, 4 },
- { GFX_SPIELER4_DOWN, 4 },
- { GFX_SPIELER4_LEFT, 4 },
- { GFX_SPIELER4_RIGHT, 4 },
- { GFX_SPIELER4_PUSH_LEFT, 4 },
- { GFX_SPIELER4_PUSH_RIGHT, 4 },
- { GFX_SP_MURPHY, 1 },
- { GFX_MURPHY_GO_LEFT, 3 },
- { GFX_MURPHY_GO_RIGHT, 3 },
- { GFX_MURPHY_SNAP_UP, 1 },
- { GFX_MURPHY_SNAP_DOWN, 1 },
- { GFX_MURPHY_SNAP_RIGHT, 1 },
- { GFX_MURPHY_SNAP_LEFT, 1 },
- { GFX_MURPHY_PUSH_RIGHT, 1 },
- { GFX_MURPHY_PUSH_LEFT, 1 },
- { GFX_GEBLUBBER, 4 },
- { GFX_DYNAMIT, 7 },
- { GFX_DYNABOMB, 4 },
- { GFX_EXPLOSION, 8 },
- { GFX_SOKOBAN_OBJEKT, 1 },
- { GFX_FUNKELN_BLAU, 3 },
- { GFX_FUNKELN_WEISS, 3 },
- { GFX2_SHIELD_PASSIVE, 3 },
- { GFX2_SHIELD_ACTIVE, 3 },
- { -1, 0 }
- };
-#endif
-
-#endif /* TARGET_X11_NATIVE */
-#endif /* TARGET_X11 */
-
- int i;
-
- /* initialize pixmap array for special X11 tile clipping to Pixmap 'None' */
- for (i = 0; i < NUM_TILES; i++)
- tile_clipmask[i] = None;
-
-#if defined(TARGET_X11)
- /* This stuff is needed because X11 (XSetClipOrigin(), to be precise) is
- often very slow when preparing a masked XCopyArea() for big Pixmaps.
- To prevent this, create small (tile-sized) mask Pixmaps which will then
- be set much faster with XSetClipOrigin() and speed things up a lot. */
-
- clip_gc_values.graphics_exposures = False;
- clip_gc_valuemask = GCGraphicsExposures;
- tile_clip_gc = XCreateGC(display, window->drawable,
- clip_gc_valuemask, &clip_gc_values);
-
-#if 0
- for (i = 0; i < NUM_BITMAPS; i++)
+ EL_BUG,
+ EL_BUG_LEFT, EL_BUG_RIGHT,
+ EL_BUG_UP, EL_BUG_DOWN
+ },
{
- if (pix[i]->clip_mask)
- {
- clip_gc_values.graphics_exposures = False;
- clip_gc_values.clip_mask = pix[i]->clip_mask;
- clip_gc_valuemask = GCGraphicsExposures | GCClipMask;
- pix[i]->stored_clip_gc = XCreateGC(display, window->drawable,
- clip_gc_valuemask, &clip_gc_values);
- }
- }
-#endif
-
-#if defined(TARGET_X11_NATIVE)
-
-#if 0
- /* create graphic context structures needed for clipping */
- clip_gc_values.graphics_exposures = False;
- clip_gc_valuemask = GCGraphicsExposures;
- copy_clipmask_gc = XCreateGC(display, pix[PIX_BACK]->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++)
+ EL_SPACESHIP,
+ EL_SPACESHIP_LEFT, EL_SPACESHIP_RIGHT,
+ EL_SPACESHIP_UP, EL_SPACESHIP_DOWN
+ },
{
- int j;
-
- for (j = 0; j < tile_needs_clipping[i].count; j++)
- {
- int tile = tile_needs_clipping[i].start + j;
- int graphic = tile;
- int src_x, src_y;
- Bitmap *src_bitmap;
- Pixmap src_pixmap;
-
- getGraphicSource(graphic, &src_bitmap, &src_x, &src_y);
- src_pixmap = src_bitmap->clip_mask;
-
- tile_clipmask[tile] = XCreatePixmap(display, window->drawable,
- TILEX, TILEY, 1);
-
- XCopyArea(display, src_pixmap, tile_clipmask[tile], copy_clipmask_gc,
- src_x, src_y, TILEX, TILEY, 0, 0);
- }
- }
-
- XFreeGC(display, copy_clipmask_gc);
-#endif
-
-#endif /* TARGET_X11_NATIVE */
-#endif /* TARGET_X11 */
-#endif
-}
-
-void FreeTileClipmasks()
-{
-#if 0
-#if defined(TARGET_X11)
- int i;
-
- for (i = 0; i < NUM_TILES; i++)
+ EL_BD_BUTTERFLY,
+ EL_BD_BUTTERFLY_LEFT, EL_BD_BUTTERFLY_RIGHT,
+ EL_BD_BUTTERFLY_UP, EL_BD_BUTTERFLY_DOWN
+ },
{
- if (tile_clipmask[i] != None)
- {
- XFreePixmap(display, tile_clipmask[i]);
- tile_clipmask[i] = None;
- }
- }
-
- if (tile_clip_gc)
- XFreeGC(display, tile_clip_gc);
- tile_clip_gc = None;
-
-#if 0
- for (i = 0; i < NUM_BITMAPS; i++)
+ EL_BD_FIREFLY,
+ EL_BD_FIREFLY_LEFT, EL_BD_FIREFLY_RIGHT,
+ EL_BD_FIREFLY_UP, EL_BD_FIREFLY_DOWN
+ },
{
- if (pix[i] != NULL && pix[i]->stored_clip_gc)
- {
- XFreeGC(display, pix[i]->stored_clip_gc);
- pix[i]->stored_clip_gc = None;
- }
+ EL_PACMAN,
+ 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,
+ EL_MOLE_UP, EL_MOLE_DOWN
+ },
+ {
+ -1,
+ -1, -1, -1, -1
}
-#endif
-
-#endif /* TARGET_X11 */
-#endif
-}
+};
void FreeGadgets()
{
gadgets_initialized = TRUE;
}
+inline void InitElementSmallImagesScaledUp(int graphic)
+{
+ 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 normal images from static configuration */
for (i = 0; element_to_graphic[i].element > -1; i++)
- CreateImageWithSmallImages(element_to_graphic[i].graphic);
+ InitElementSmallImagesScaledUp(element_to_graphic[i].graphic);
/* initialize special images from static configuration */
for (i = 0; element_to_special_graphic[i].element > -1; i++)
- CreateImageWithSmallImages(element_to_special_graphic[i].graphic);
+ InitElementSmallImagesScaledUp(element_to_special_graphic[i].graphic);
- /* initialize images from dynamic configuration */
+ /* initialize images from dynamic configuration (may be elements or other) */
for (i = 0; i < num_property_mappings; i++)
- if (property_mapping[i].artwork_index < MAX_NUM_ELEMENTS)
- CreateImageWithSmallImages(property_mapping[i].artwork_index);
+ 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
+/* !!! FIX THIS (CHANGE TO USING NORMAL ELEMENT GRAPHIC DEFINITIONS) !!! */
+void SetBitmaps_EM(Bitmap **em_bitmap)
+{
+ em_bitmap[0] = graphic_info[IMG_EMC_OBJECT].bitmap;
+ em_bitmap[1] = graphic_info[IMG_EMC_SPRITE].bitmap;
+}
+#endif
+
static int getFontBitmapID(int font_nr)
{
int special = -1;
/* ---------- initialize font graphic definitions ---------- */
/* always start with reliable default values (normal font graphics) */
-#if 1
for (i = 0; i < NUM_FONTS; i++)
font_info[i].graphic = IMG_FONT_INITIAL_1;
-#else
- 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++)
/* initialize special font/graphic mapping from static configuration */
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;
+ int font_nr = font_to_graphic[i].font_nr;
+ int special = font_to_graphic[i].special;
+ int graphic = font_to_graphic[i].graphic;
+ int base_graphic = font2baseimg(font_nr);
if (special >= 0 && special < NUM_SPECIAL_GFX_ARGS)
{
+ boolean base_redefined =
+ getImageListEntryFromImageID(base_graphic)->redefined;
+ boolean special_redefined =
+ getImageListEntryFromImageID(graphic)->redefined;
+
+ /* 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)
+ continue;
+
font_info[font_nr].special_graphic[special] = graphic;
font_info[font_nr].special_bitmap_id[special] = num_font_bitmaps;
num_font_bitmaps++;
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;
int direction = element_to_graphic[i].direction;
boolean crumbled = element_to_graphic[i].crumbled;
int graphic = element_to_graphic[i].graphic;
+ int base_graphic = el2baseimg(element);
if (graphic_info[graphic].bitmap == NULL)
continue;
if ((action > -1 || direction > -1 || crumbled == TRUE) &&
- el2img(element) != -1)
+ base_graphic != -1)
{
- boolean base_redefined = getImageListEntry(el2img(element))->redefined;
- boolean act_dir_redefined = getImageListEntry(graphic)->redefined;
+ boolean base_redefined =
+ getImageListEntryFromImageID(base_graphic)->redefined;
+ boolean act_dir_redefined =
+ getImageListEntryFromImageID(graphic)->redefined;
/* if the base graphic ("emerald", for example) has been redefined,
but not the action graphic ("emerald.falling", for example), do not
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];
}
}
#if 1
+ /* set hardcoded definitions for some runtime elements without graphic */
+ 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)
}
}
}
-#endif
+
+ /* 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_FULL; dir++)
+ {
+ int graphic = element_info[i].direction_graphic[act][dir];
+ int move_dir = (act == ACTION_FALLING ? MV_BIT_DOWN : dir);
+
+ if (act == ACTION_FALLING) /* special case */
+ graphic = element_info[i].graphic[act];
+
+ if (graphic != -1 &&
+ graphic_info[graphic].double_movement &&
+ graphic_info[graphic].swap_double_tiles != 0)
+ {
+ struct GraphicInfo *g = &graphic_info[graphic];
+ int src_x_front = g->src_x;
+ int src_y_front = g->src_y;
+ int src_x_back = g->src_x + g->offset2_x;
+ int src_y_back = g->src_y + g->offset2_y;
+ boolean frames_are_ordered_diagonally = (g->offset_x != 0 &&
+ g->offset_y != 0);
+ boolean front_is_left_or_upper = (src_x_front < src_x_back ||
+ src_y_front < src_y_back);
+ boolean swap_movement_tiles_always = (g->swap_double_tiles == 1);
+ boolean swap_movement_tiles_autodetected =
+ (!frames_are_ordered_diagonally &&
+ ((move_dir == MV_BIT_LEFT && !front_is_left_or_upper) ||
+ (move_dir == MV_BIT_UP && !front_is_left_or_upper) ||
+ (move_dir == MV_BIT_RIGHT && front_is_left_or_upper) ||
+ (move_dir == MV_BIT_DOWN && front_is_left_or_upper)));
+ Bitmap *dummy;
+
+ /* swap frontside and backside graphic tile coordinates, if needed */
+ if (swap_movement_tiles_always || swap_movement_tiles_autodetected)
+ {
+ /* get current (wrong) backside tile coordinates */
+ getGraphicSourceExt(graphic, 0, &dummy, &src_x_back, &src_y_back,
+ TRUE);
+
+ /* set frontside tile coordinates to backside tile coordinates */
+ g->src_x = src_x_back;
+ g->src_y = src_y_back;
+
+ /* invert tile offset to point to new backside tile coordinates */
+ g->offset2_x *= -1;
+ g->offset2_y *= -1;
+
+ /* do not swap front and backside tiles again after correction */
+ g->swap_double_tiles = 0;
+ }
+ }
+ }
+ }
+ }
/* 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;
+#if 1
+ if (default_crumbled == -1)
+ default_crumbled = default_graphic;
+#else
+ /* !!! THIS LOOKS CRAPPY FOR SAND ETC. WITHOUT CRUMBLED GRAPHICS !!! */
if (default_crumbled == -1)
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];
if (default_direction_graphic[dir] == -1)
default_direction_graphic[dir] = default_graphic;
+#if 1
+ if (default_direction_crumbled[dir] == -1)
+ default_direction_crumbled[dir] = default_direction_graphic[dir];
+#else
+ /* !!! THIS LOOKS CRAPPY FOR SAND ETC. WITHOUT CRUMBLED GRAPHICS !!! */
if (default_direction_crumbled[dir] == -1)
default_direction_crumbled[dir] = default_crumbled;
+#endif
}
for (act = 0; act < NUM_ACTIONS; act++)
/* generic default action graphic (defined by "[default]" directive) */
int default_action_graphic = element_info[EL_DEFAULT].graphic[act];
int default_action_crumbled = element_info[EL_DEFAULT].crumbled[act];
+ int default_remove_graphic = IMG_EMPTY;
+
+ if (act_remove && default_action_graphic != -1)
+ default_remove_graphic = default_action_graphic;
/* look for special default action graphic (classic game specific) */
if (IS_BD_ELEMENT(i) && element_info[EL_BD_DEFAULT].graphic[act] != -1)
default_action_crumbled = element_info[EL_SB_DEFAULT].crumbled[act];
#if 1
+ /* !!! needed because EL_EMPTY_SPACE treated as IS_SP_ELEMENT !!! */
/* !!! make this better !!! */
if (i == EL_EMPTY_SPACE)
{
if (default_action_graphic == -1)
default_action_graphic = default_graphic;
+#if 1
+ if (default_action_crumbled == -1)
+ default_action_crumbled = default_action_graphic;
+#else
+ /* !!! THIS LOOKS CRAPPY FOR SAND ETC. WITHOUT CRUMBLED GRAPHICS !!! */
if (default_action_crumbled == -1)
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];
int default_action_direction_crumbled = element_info[i].crumbled[act];
/* no graphic for current action -- use default direction graphic */
if (default_action_direction_graphic == -1)
default_action_direction_graphic =
- (act_remove ? IMG_EMPTY :
+ (act_remove ? default_remove_graphic :
act_turning ?
element_info[i].direction_graphic[ACTION_TURNING][dir] :
+ default_action_graphic != default_graphic ?
+ default_action_graphic :
default_direction_graphic[dir]);
+
+ if (element_info[i].direction_graphic[act][dir] == -1)
+ element_info[i].direction_graphic[act][dir] =
+ default_action_direction_graphic;
+
+#if 1
+ if (default_action_direction_crumbled == -1)
+ default_action_direction_crumbled =
+ element_info[i].direction_graphic[act][dir];
+#else
if (default_action_direction_crumbled == -1)
default_action_direction_crumbled =
- (act_remove ? IMG_EMPTY :
+ (act_remove ? default_remove_graphic :
act_turning ?
element_info[i].direction_crumbled[ACTION_TURNING][dir] :
+ default_action_crumbled != default_crumbled ?
+ default_action_crumbled :
default_direction_crumbled[dir]);
+#endif
- if (element_info[i].direction_graphic[act][dir] == -1)
- element_info[i].direction_graphic[act][dir] =
- default_action_direction_graphic;
if (element_info[i].direction_crumbled[act][dir] == -1)
element_info[i].direction_crumbled[act][dir] =
default_action_direction_crumbled;
/* no graphic for this specific action -- use default action graphic */
if (element_info[i].graphic[act] == -1)
element_info[i].graphic[act] =
- (act_remove ? IMG_EMPTY :
+ (act_remove ? default_remove_graphic :
act_turning ? element_info[i].graphic[ACTION_TURNING] :
default_action_graphic);
+#if 1
+ if (element_info[i].crumbled[act] == -1)
+ element_info[i].crumbled[act] = element_info[i].graphic[act];
+#else
if (element_info[i].crumbled[act] == -1)
element_info[i].crumbled[act] =
- (act_remove ? IMG_EMPTY :
+ (act_remove ? default_remove_graphic :
act_turning ? element_info[i].crumbled[ACTION_TURNING] :
default_action_crumbled);
+#endif
}
}
-#if 1
+#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];
int element = element_to_special_graphic[i].element;
int special = element_to_special_graphic[i].special;
int graphic = element_to_special_graphic[i].graphic;
- boolean base_redefined = getImageListEntry(el2img(element))->redefined;
- boolean special_redefined = getImageListEntry(graphic)->redefined;
+ int base_graphic = el2baseimg(element);
+ boolean base_redefined =
+ getImageListEntryFromImageID(base_graphic)->redefined;
+ boolean special_redefined =
+ getImageListEntryFromImageID(graphic)->redefined;
/* if the base graphic ("emerald", for example) has been redefined,
but not the special graphic ("emerald.EDITOR", for example), do not
element_info[element].special_graphic[special] = graphic;
}
-#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++)
if (graphic_info[element_info[i].special_graphic[j]].bitmap == NULL)
element_info[i].special_graphic[j] =
element_info[i].graphic[ACTION_DEFAULT];
-#endif
}
-static int get_element_from_token(char *token)
+static int get_graphic_parameter_value(char *value_raw, char *suffix, int type)
{
int i;
+ int x = 0;
+
+ if (type != TYPE_TOKEN)
+ return get_parameter_value(value_raw, suffix, type);
+
+ 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, token) == 0)
+ 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++;
+ }
+
return -1;
}
-static void set_graphic_parameters(int graphic, char **parameter_raw)
+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(int graphic)
+{
+ struct FileInfo *image = getImageListEntryFromImageID(graphic);
+ char **parameter_raw = image->parameter;
Bitmap *src_bitmap = getBitmapFromImageID(graphic);
int parameter[NUM_GFX_ARGS];
int anim_frames_per_row = 1, anim_frames_per_col = 1;
int anim_frames_per_line = 1;
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_parameter_value(image_config_suffix[i].token, parameter_raw[i],
- image_config_suffix[i].type);
-
- if (image_config_suffix[i].type == TYPE_TOKEN)
- parameter[i] = get_element_from_token(parameter_raw[i]);
- }
+ parameter[i] = get_graphic_parameter_value(parameter_raw[i],
+ image_config_suffix[i].token,
+ image_config_suffix[i].type);
graphic_info[graphic].bitmap = src_bitmap;
/* 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].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].offset2_y = 0; /* ... will be corrected later */
+ graphic_info[graphic].swap_double_tiles = -1; /* auto-detect tile swapping */
graphic_info[graphic].crumbled_like = -1; /* do not use clone element */
graphic_info[graphic].diggable_like = -1; /* do not use clone element */
graphic_info[graphic].border_size = TILEX / 8; /* "CRUMBLED" border size */
+ graphic_info[graphic].scale_up_factor = 1; /* default: no scaling up */
+ graphic_info[graphic].clone_from = -1; /* do not use clone graphic */
graphic_info[graphic].anim_delay_fixed = 0;
graphic_info[graphic].anim_delay_random = 0;
graphic_info[graphic].post_delay_fixed = 0;
if (parameter[GFX_ARG_HEIGHT] != ARG_UNDEFINED_VALUE)
graphic_info[graphic].height = parameter[GFX_ARG_HEIGHT];
+ /* 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 */
+
if (src_bitmap)
{
- anim_frames_per_row = src_bitmap->width / graphic_info[graphic].width;
- anim_frames_per_col = src_bitmap->height / graphic_info[graphic].height;
+ /* 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 / graphic_info[graphic].width;
+ anim_frames_per_col = src_image_height / graphic_info[graphic].height;
+
+ graphic_info[graphic].src_image_width = src_image_width;
+ graphic_info[graphic].src_image_height = src_image_height;
}
/* correct x or y offset dependent of vertical or horizontal frame order */
if (parameter[GFX_ARG_YOFFSET] != ARG_UNDEFINED_VALUE)
graphic_info[graphic].offset_y = parameter[GFX_ARG_YOFFSET];
+ /* optionally, moving animations may have separate start and end graphics */
+ graphic_info[graphic].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];
+
+ /* correct x or y offset2 dependent of vertical or horizontal frame order */
+ if (parameter[GFX_ARG_2ND_VERTICAL]) /* frames are ordered vertically */
+ graphic_info[graphic].offset2_y =
+ (parameter[GFX_ARG_2ND_OFFSET] != ARG_UNDEFINED_VALUE ?
+ parameter[GFX_ARG_2ND_OFFSET] : graphic_info[graphic].height);
+ else /* frames are ordered horizontally */
+ graphic_info[graphic].offset2_x =
+ (parameter[GFX_ARG_2ND_OFFSET] != ARG_UNDEFINED_VALUE ?
+ parameter[GFX_ARG_2ND_OFFSET] : graphic_info[graphic].width);
+
+ /* optionally, the x and y offset of 2nd graphic can be specified directly */
+ if (parameter[GFX_ARG_2ND_XOFFSET] != ARG_UNDEFINED_VALUE)
+ graphic_info[graphic].offset2_x = parameter[GFX_ARG_2ND_XOFFSET];
+ if (parameter[GFX_ARG_2ND_YOFFSET] != ARG_UNDEFINED_VALUE)
+ graphic_info[graphic].offset2_y = parameter[GFX_ARG_2ND_YOFFSET];
+
+ /* optionally, the second movement tile can be specified as start tile */
+ if (parameter[GFX_ARG_2ND_SWAP_TILES] != ARG_UNDEFINED_VALUE)
+ graphic_info[graphic].swap_double_tiles= parameter[GFX_ARG_2ND_SWAP_TILES];
+
/* automatically determine correct number of frames, if not defined */
if (parameter[GFX_ARG_FRAMES] != ARG_UNDEFINED_VALUE)
graphic_info[graphic].anim_frames = parameter[GFX_ARG_FRAMES];
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];
+}
+
+static void set_cloned_graphic_parameters(int graphic)
+{
+ int fallback_graphic = IMG_CHAR_EXCLAM;
+ int max_num_images = getImageListSize();
+ int clone_graphic = graphic_info[graphic].clone_from;
+ int num_references_followed = 1;
+
+ while (graphic_info[clone_graphic].clone_from != -1 &&
+ num_references_followed < max_num_images)
+ {
+ clone_graphic = graphic_info[clone_graphic].clone_from;
+
+ num_references_followed++;
+ }
+
+ 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");
+
+ 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, "-");
+
+ graphic_info[graphic] = graphic_info[fallback_graphic];
+ }
+ else
+ {
+ graphic_info[graphic] = graphic_info[clone_graphic];
+ graphic_info[graphic].clone_from = clone_graphic;
+ }
}
static void InitGraphicInfo()
{
int fallback_graphic = IMG_CHAR_EXCLAM;
- struct FileInfo *fallback_image = getImageListEntry(fallback_graphic);
- Bitmap *fallback_bitmap = getBitmapFromImageID(fallback_graphic);
int num_images = getImageListSize();
int i;
graphic_info = checked_calloc(num_images * sizeof(struct GraphicInfo));
-#if 0
- printf("::: graphic_info: %d entries\n", num_images);
-#endif
-
#if defined(TARGET_X11_NATIVE_PERFORMANCE_WORKAROUND)
if (clipmasks_initialized)
{
}
#endif
+ /* first set all graphic paramaters ... */
+ for (i = 0; i < num_images; i++)
+ set_graphic_parameters(i);
+
+ /* ... then copy these parameters for cloned graphics */
+ for (i = 0; i < num_images; i++)
+ if (graphic_info[i].clone_from != -1)
+ set_cloned_graphic_parameters(i);
+
for (i = 0; i < num_images; i++)
{
- struct FileInfo *image = getImageListEntry(i);
Bitmap *src_bitmap;
int src_x, src_y;
int first_frame, last_frame;
-
-#if 0
- printf("::: image: '%s' [%d]\n", image->token, i);
-#endif
-
-#if 0
- printf("::: image # %d: '%s' ['%s']\n",
- i, image->token,
- getTokenFromImageID(i));
-#endif
-
- set_graphic_parameters(i, image->parameter);
+ int src_bitmap_width, src_bitmap_height;
/* now check if no animation frames are outside of the loaded image */
if (graphic_info[i].bitmap == NULL)
continue; /* skip check for optional images that are undefined */
+ /* 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;
+
+ /* check if first animation frame is inside specified bitmap */
+
first_frame = 0;
getGraphicSource(i, first_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 + TILEX > src_bitmap_width ||
+ src_y + TILEY > 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, "- 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: first animation frame out of bounds (%d, %d)",
- src_x, src_y);
+ "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");
if (i == fallback_graphic)
Error(ERR_RETURN, "fallback done to 'char_exclam' for this graphic");
Error(ERR_RETURN_LINE, "-");
- set_graphic_parameters(i, fallback_image->default_parameter);
- graphic_info[i].bitmap = fallback_bitmap;
+ graphic_info[i] = graphic_info[fallback_graphic];
}
+ /* check if last animation frame is inside specified bitmap */
+
last_frame = graphic_info[i].anim_frames - 1;
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 + TILEX > src_bitmap_width ||
+ src_y + TILEY > 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, "- 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: last animation frame (%d) out of bounds (%d, %d)",
- last_frame, src_x, src_y);
+ "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");
if (i == fallback_graphic)
Error(ERR_RETURN, "fallback done to 'char_exclam' for this graphic");
Error(ERR_RETURN_LINE, "-");
- set_graphic_parameters(i, fallback_image->default_parameter);
- graphic_info[i].bitmap = fallback_bitmap;
+ graphic_info[i] = graphic_info[fallback_graphic];
}
#if defined(TARGET_X11_NATIVE_PERFORMANCE_WORKAROUND)
- /* currently we need only a tile clip mask from the first frame */
+ /* currently we only need a tile clip mask from the first frame */
getGraphicSource(i, first_frame, &src_bitmap, &src_x, &src_y);
if (copy_clipmask_gc == None)
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;
}
default_action_sound = element_info[i].sound[ACTION_DEFAULT];
#endif
+#if 1
+ /* !!! needed because EL_EMPTY_SPACE treated as IS_SP_ELEMENT !!! */
+ /* !!! make this better !!! */
+ if (i == EL_EMPTY_SPACE)
+ default_action_sound = element_info[EL_DEFAULT].sound[act];
+#endif
+
/* no sound for this specific action -- use default action sound */
if (element_info[i].sound[act] == -1)
element_info[i].sound[act] = default_action_sound;
}
}
+
+ /* copy sound settings to some elements that are only stored in level file
+ in native R'n'D levels, but are used by game engine in native EM levels */
+ for (i = 0; copy_properties[i][0] != -1; i++)
+ for (j = 1; j <= 4; j++)
+ for (act = 0; act < NUM_ACTIONS; act++)
+ element_info[copy_properties[i][j]].sound[act] =
+ element_info[copy_properties[i][0]].sound[act];
}
static void InitGameModeSoundInfo()
menu.sound[i] = menu.sound[GAME_MODE_DEFAULT];
#if 0
- /* TEST ONLY */
for (i = 0; i < NUM_SPECIAL_GFX_ARGS; i++)
if (menu.sound[i] != -1)
printf("::: menu.sound[%d] == %d\n", i, menu.sound[i]);
/* get integer values from string parameters */
for (i = 0; i < NUM_SND_ARGS; i++)
parameter[i] =
- get_parameter_value(sound_config_suffix[i].token, parameter_raw[i],
+ get_parameter_value(parameter_raw[i],
+ sound_config_suffix[i].token,
sound_config_suffix[i].type);
/* explicit loop mode setting in configuration overrides default value */
if (parameter[SND_ARG_MODE_LOOP] != ARG_UNDEFINED_VALUE)
sound_info[sound].loop = parameter[SND_ARG_MODE_LOOP];
+
+ /* sound volume to change the original volume when loading the sound file */
+ 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];
}
static void InitSoundInfo()
{
-#if 0
- struct PropertyMapping *property_mapping = getSoundListPropertyMapping();
- int num_property_mappings = getSoundListPropertyMappingSize();
-#endif
int *sound_effect_properties;
int num_sounds = getSoundListSize();
int i, j;
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;
}
}
-#if 0
- if (strcmp(sound->token, "custom_42") == 0)
- printf("::: '%s' -> %d\n", sound->token, sound_info[i].loop);
-#endif
-
/* associate elements and some selected sound actions */
for (j = 0; j < MAX_NUM_ELEMENTS; j++)
}
free(sound_effect_properties);
-
-#if 0
- /* !!! now handled in InitElementSoundInfo() !!! */
- /* initialize element/sound 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 sound = property_mapping[i].artwork_index;
-
- if (action < 0)
- action = ACTION_DEFAULT;
-
- printf("::: %d: %d, %d, %d ['%s']\n",
- i, element, action, sound, element_info[element].token_name);
-
- element_info[element].sound[action] = sound;
- }
-#endif
-
-#if 0
- /* TEST ONLY */
- {
- int element = EL_CUSTOM_11;
- int j = 0;
-
- while (element_action_info[j].suffix)
- {
- printf("element %d, sound action '%s' == %d\n",
- element, element_action_info[j].suffix,
- element_info[element].sound[j]);
- j++;
- }
- }
-
- PlaySoundLevelElementAction(0,0, EL_CUSTOM_11, ACTION_PUSHING);
-#endif
-
-#if 0
- /* TEST ONLY */
- {
- int element = EL_SAND;
- int sound_action = ACTION_DIGGING;
- int j = 0;
-
- while (element_action_info[j].suffix)
- {
- if (element_action_info[j].value == sound_action)
- printf("element %d, sound action '%s' == %d\n",
- element, element_action_info[j].suffix,
- element_info[element].sound[sound_action]);
- j++;
- }
- }
-#endif
}
static void InitGameModeMusicInfo()
menu.music[i] = menu.music[GAME_MODE_DEFAULT];
#if 0
- /* TEST ONLY */
for (i = 0; i < MAX_LEVELS; i++)
if (levelset.music[i] != -1)
printf("::: levelset.music[%d] == %d\n", i, levelset.music[i]);
/* get integer values from string parameters */
for (i = 0; i < NUM_MUS_ARGS; i++)
parameter[i] =
- get_parameter_value(music_config_suffix[i].token, parameter_raw[i],
+ get_parameter_value(parameter_raw[i],
+ music_config_suffix[i].token,
music_config_suffix[i].type);
/* explicit loop mode setting in configuration overrides default value */
InitElementGraphicInfo(); /* element game graphic mapping */
InitElementSpecialGraphicInfo(); /* element special graphic mapping */
- InitElementSmallImages(); /* create editor and preview images */
+ 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 */
+
SetMainBackgroundImage(IMG_BACKGROUND);
SetDoorBackgroundImage(IMG_BACKGROUND_DOOR);
{ EL_PLAYER_3, 0 },
{ EL_PLAYER_4, 0 },
{ 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 -1;
}
-#if 1
void setBitfieldProperty(int *bitfield, int property_bit_nr, int element,
boolean property_value)
{
return FALSE;
}
-#else
-
-void setMoveIntoAcidProperty(struct LevelInfo *level, int element, boolean set)
+#if 1
+static void resolve_group_element(int group_element, int recursion_depth)
{
- int bit_nr = get_special_property_bit(element, EP_CAN_MOVE_INTO_ACID);
+ static int group_nr;
+ static struct ElementGroupInfo *group;
+ struct ElementGroupInfo *actual_group = element_info[group_element].group;
+ int i;
- if (bit_nr > -1)
+ if (actual_group == NULL) /* not yet initialized */
+ return;
+
+ if (recursion_depth > NUM_GROUP_ELEMENTS) /* recursion too deep */
{
- level->can_move_into_acid_bits &= ~(1 << bit_nr);
+ Error(ERR_WARN, "recursion too deep when resolving group element %d",
+ group_element - EL_GROUP_START + 1);
- if (set)
- level->can_move_into_acid_bits |= (1 << bit_nr);
+ /* replace element which caused too deep recursion by question mark */
+ group->element_resolved[group->num_elements_resolved++] = EL_UNKNOWN;
+
+ return;
}
-}
-boolean getMoveIntoAcidProperty(struct LevelInfo *level, int element)
-{
- int bit_nr = get_special_property_bit(element, EP_CAN_MOVE_INTO_ACID);
+ if (recursion_depth == 0) /* initialization */
+ {
+ group = actual_group;
+ group_nr = group_element - EL_GROUP_START;
- if (bit_nr > -1)
- return ((level->can_move_into_acid_bits & (1 << bit_nr)) != 0);
+ group->num_elements_resolved = 0;
+ group->choice_pos = 0;
+ }
- return 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))
+ resolve_group_element(element, recursion_depth + 1);
+ else
+ {
+ group->element_resolved[group->num_elements_resolved++] = element;
+ element_info[element].in_group[group_nr] = TRUE;
+ }
+ }
}
#endif
EL_TRAP,
EL_INVISIBLE_SAND,
EL_INVISIBLE_SAND_ACTIVE,
+ EL_EMC_GRASS,
/* !!! currently not diggable, but handled by 'ep_dont_run_into' !!! */
+ /* (if amoeba can grow into anything diggable, maybe keep these out) */
#if 0
EL_LANDMINE,
EL_TRAP_ACTIVE,
EL_SP_BUGGY_BASE_ACTIVE,
+ EL_EMC_PLANT,
#endif
+
-1
};
EL_EM_KEY_2,
EL_EM_KEY_3,
EL_EM_KEY_4,
+ EL_EMC_KEY_5,
+ EL_EMC_KEY_6,
+ 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_ENVELOPE_3,
EL_ENVELOPE_4,
EL_SPEED_PILL,
+ EL_EMC_LENSES,
+ EL_EMC_MAGNIFIER,
+
-1
};
EL_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_GATE_2_GRAY,
EL_GATE_3_GRAY,
EL_GATE_4_GRAY,
+ EL_GATE_1_GRAY_ACTIVE,
+ EL_GATE_2_GRAY_ACTIVE,
+ EL_GATE_3_GRAY_ACTIVE,
+ EL_GATE_4_GRAY_ACTIVE,
EL_EM_GATE_1,
EL_EM_GATE_2,
EL_EM_GATE_3,
EL_EM_GATE_2_GRAY,
EL_EM_GATE_3_GRAY,
EL_EM_GATE_4_GRAY,
+ EL_EM_GATE_1_GRAY_ACTIVE,
+ EL_EM_GATE_2_GRAY_ACTIVE,
+ EL_EM_GATE_3_GRAY_ACTIVE,
+ EL_EM_GATE_4_GRAY_ACTIVE,
+ EL_EMC_GATE_5,
+ EL_EMC_GATE_6,
+ EL_EMC_GATE_7,
+ EL_EMC_GATE_8,
+ EL_EMC_GATE_5_GRAY,
+ EL_EMC_GATE_6_GRAY,
+ EL_EMC_GATE_7_GRAY,
+ EL_EMC_GATE_8_GRAY,
+ EL_EMC_GATE_5_GRAY_ACTIVE,
+ EL_EMC_GATE_6_GRAY_ACTIVE,
+ EL_EMC_GATE_7_GRAY_ACTIVE,
+ EL_EMC_GATE_8_GRAY_ACTIVE,
EL_SWITCHGATE_OPEN,
EL_SWITCHGATE_OPENING,
EL_SWITCHGATE_CLOSED,
EL_TUBE_LEFT_DOWN,
EL_TUBE_RIGHT_UP,
EL_TUBE_RIGHT_DOWN,
+
-1
};
EL_STEELWALL_SLIPPERY,
EL_PEARL,
EL_CRYSTAL,
+ EL_EMC_WALL_SLIPPERY_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_SP_ELECTRON,
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
};
- static int ep_can_explode_by_fire[] =
+ static int ep_explodes_by_fire[] =
{
- /* same elements as in 'ep_can_explode_impact' */
+ /* same elements as in 'ep_explodes_impact' */
EL_BOMB,
EL_SP_DISK_ORANGE,
EL_DX_SUPABOMB,
- /* same elements as in 'ep_can_explode_smashed' */
+ /* same elements as in 'ep_explodes_smashed' */
EL_SATELLITE,
EL_PIG,
EL_DRAGON,
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
};
- static int ep_can_explode_smashed[] =
+ static int ep_explodes_smashed[] =
{
- /* same elements as in 'ep_can_explode_impact' */
+ /* same elements as in 'ep_explodes_impact' */
EL_BOMB,
EL_SP_DISK_ORANGE,
EL_DX_SUPABOMB,
EL_PIG,
EL_DRAGON,
EL_MOLE,
+
-1
};
- static int ep_can_explode_impact[] =
+ static int ep_explodes_impact[] =
{
EL_BOMB,
EL_SP_DISK_ORANGE,
EL_DX_SUPABOMB,
+
-1
};
EL_GATE_2_GRAY,
EL_GATE_3_GRAY,
EL_GATE_4_GRAY,
+ EL_GATE_1_GRAY_ACTIVE,
+ EL_GATE_2_GRAY_ACTIVE,
+ EL_GATE_3_GRAY_ACTIVE,
+ EL_GATE_4_GRAY_ACTIVE,
EL_PENGUIN,
EL_PIG,
EL_DRAGON,
+
-1
};
EL_TUBE_LEFT_DOWN,
EL_TUBE_RIGHT_UP,
EL_TUBE_RIGHT_DOWN,
+
-1
};
EL_EM_GATE_2_GRAY,
EL_EM_GATE_3_GRAY,
EL_EM_GATE_4_GRAY,
+ EL_EM_GATE_1_GRAY_ACTIVE,
+ EL_EM_GATE_2_GRAY_ACTIVE,
+ EL_EM_GATE_3_GRAY_ACTIVE,
+ EL_EM_GATE_4_GRAY_ACTIVE,
+ EL_EMC_GATE_5,
+ EL_EMC_GATE_6,
+ EL_EMC_GATE_7,
+ EL_EMC_GATE_8,
+ EL_EMC_GATE_5_GRAY,
+ EL_EMC_GATE_6_GRAY,
+ EL_EMC_GATE_7_GRAY,
+ EL_EMC_GATE_8_GRAY,
+ EL_EMC_GATE_5_GRAY_ACTIVE,
+ EL_EMC_GATE_6_GRAY_ACTIVE,
+ EL_EMC_GATE_7_GRAY_ACTIVE,
+ EL_EMC_GATE_8_GRAY_ACTIVE,
EL_SWITCHGATE_OPEN,
EL_TIMEGATE_OPEN,
+
-1
};
EL_SP_GRAVITY_PORT_RIGHT,
EL_SP_GRAVITY_PORT_UP,
EL_SP_GRAVITY_PORT_DOWN,
+ EL_SP_GRAVITY_ON_PORT_LEFT,
+ EL_SP_GRAVITY_ON_PORT_RIGHT,
+ EL_SP_GRAVITY_ON_PORT_UP,
+ EL_SP_GRAVITY_ON_PORT_DOWN,
+ EL_SP_GRAVITY_OFF_PORT_LEFT,
+ EL_SP_GRAVITY_OFF_PORT_RIGHT,
+ EL_SP_GRAVITY_OFF_PORT_UP,
+ EL_SP_GRAVITY_OFF_PORT_DOWN,
+
-1
};
-1
};
- static int ep_can_explode_1x1[] =
+ static int ep_explodes_1x1_old[] =
{
-1
};
EL_SATELLITE,
EL_SP_DISK_YELLOW,
EL_BALLOON,
+ EL_EMC_ANDROID,
+
-1
};
- static int ep_can_explode_dyna[] =
+ static int ep_explodes_cross_old[] =
{
-1
};
static int ep_protected[] =
{
+ /* same elements as in 'ep_walkable_inside' */
+ EL_TUBE_ANY,
+ EL_TUBE_VERTICAL,
+ EL_TUBE_HORIZONTAL,
+ EL_TUBE_VERTICAL_LEFT,
+ EL_TUBE_VERTICAL_RIGHT,
+ EL_TUBE_HORIZONTAL_UP,
+ EL_TUBE_HORIZONTAL_DOWN,
+ EL_TUBE_LEFT_UP,
+ EL_TUBE_LEFT_DOWN,
+ EL_TUBE_RIGHT_UP,
+ EL_TUBE_RIGHT_DOWN,
+
+ /* same elements as in 'ep_passable_over' */
EL_EM_GATE_1,
EL_EM_GATE_2,
EL_EM_GATE_3,
EL_EM_GATE_2_GRAY,
EL_EM_GATE_3_GRAY,
EL_EM_GATE_4_GRAY,
+ EL_EM_GATE_1_GRAY_ACTIVE,
+ EL_EM_GATE_2_GRAY_ACTIVE,
+ EL_EM_GATE_3_GRAY_ACTIVE,
+ EL_EM_GATE_4_GRAY_ACTIVE,
+ EL_EMC_GATE_5,
+ EL_EMC_GATE_6,
+ EL_EMC_GATE_7,
+ EL_EMC_GATE_8,
+ EL_EMC_GATE_5_GRAY,
+ EL_EMC_GATE_6_GRAY,
+ EL_EMC_GATE_7_GRAY,
+ EL_EMC_GATE_8_GRAY,
+ EL_EMC_GATE_5_GRAY_ACTIVE,
+ EL_EMC_GATE_6_GRAY_ACTIVE,
+ EL_EMC_GATE_7_GRAY_ACTIVE,
+ EL_EMC_GATE_8_GRAY_ACTIVE,
EL_SWITCHGATE_OPEN,
EL_TIMEGATE_OPEN,
+
+ /* same elements as in 'ep_passable_inside' */
+ EL_SP_PORT_LEFT,
+ EL_SP_PORT_RIGHT,
+ EL_SP_PORT_UP,
+ EL_SP_PORT_DOWN,
+ EL_SP_PORT_HORIZONTAL,
+ EL_SP_PORT_VERTICAL,
+ EL_SP_PORT_ANY,
+ EL_SP_GRAVITY_PORT_LEFT,
+ EL_SP_GRAVITY_PORT_RIGHT,
+ EL_SP_GRAVITY_PORT_UP,
+ EL_SP_GRAVITY_PORT_DOWN,
+ EL_SP_GRAVITY_ON_PORT_LEFT,
+ EL_SP_GRAVITY_ON_PORT_RIGHT,
+ EL_SP_GRAVITY_ON_PORT_UP,
+ EL_SP_GRAVITY_ON_PORT_DOWN,
+ EL_SP_GRAVITY_OFF_PORT_LEFT,
+ EL_SP_GRAVITY_OFF_PORT_RIGHT,
+ EL_SP_GRAVITY_OFF_PORT_UP,
+ EL_SP_GRAVITY_OFF_PORT_DOWN,
+
+ -1
+ };
+
+ static int ep_throwable[] =
+ {
+ -1
+ };
+
+ static int ep_can_explode[] =
+ {
+ /* same elements as in 'ep_explodes_impact' */
+ EL_BOMB,
+ EL_SP_DISK_ORANGE,
+ EL_DX_SUPABOMB,
+
+ /* same elements as in 'ep_explodes_smashed' */
+ EL_SATELLITE,
+ EL_PIG,
+ EL_DRAGON,
+ EL_MOLE,
+
+ /* elements that can explode by explosion or by dragonfire */
+ 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,
+ EL_DYNABOMB_PLAYER_4_ACTIVE,
+ EL_DYNABOMB_INCREASE_NUMBER,
+ EL_DYNABOMB_INCREASE_SIZE,
+ EL_DYNABOMB_INCREASE_POWER,
+ EL_SP_DISK_RED_ACTIVE,
+ EL_BUG,
+ EL_PENGUIN,
+ EL_SP_DISK_RED,
+ EL_SP_DISK_YELLOW,
+ EL_SP_SNIKSNAK,
+ EL_SP_ELECTRON,
+
+ /* elements that can explode only by explosion */
+ EL_BLACK_ORB,
+
+ -1
+ };
+
+ static int ep_gravity_reachable[] =
+ {
+ EL_SAND,
+ EL_SP_BASE,
+ EL_TRAP,
+ EL_INVISIBLE_SAND,
+ EL_INVISIBLE_SAND_ACTIVE,
+ EL_SP_PORT_LEFT,
+ EL_SP_PORT_RIGHT,
+ EL_SP_PORT_UP,
+ EL_SP_PORT_DOWN,
+ EL_SP_PORT_HORIZONTAL,
+ EL_SP_PORT_VERTICAL,
+ EL_SP_PORT_ANY,
+ EL_SP_GRAVITY_PORT_LEFT,
+ EL_SP_GRAVITY_PORT_RIGHT,
+ EL_SP_GRAVITY_PORT_UP,
+ EL_SP_GRAVITY_PORT_DOWN,
+ EL_SP_GRAVITY_ON_PORT_LEFT,
+ EL_SP_GRAVITY_ON_PORT_RIGHT,
+ EL_SP_GRAVITY_ON_PORT_UP,
+ EL_SP_GRAVITY_ON_PORT_DOWN,
+ EL_SP_GRAVITY_OFF_PORT_LEFT,
+ EL_SP_GRAVITY_OFF_PORT_RIGHT,
+ EL_SP_GRAVITY_OFF_PORT_UP,
+ EL_SP_GRAVITY_OFF_PORT_DOWN,
+ EL_EMC_GRASS,
+
-1
};
EL_PLAYER_3,
EL_PLAYER_4,
EL_SP_MURPHY,
+ EL_SOKOBAN_FIELD_PLAYER,
+ EL_TRIGGER_PLAYER,
+
-1
};
EL_EMERALD_RED,
EL_EMERALD_PURPLE,
EL_DIAMOND,
+
-1
};
EL_BALLOON_SWITCH_UP,
EL_BALLOON_SWITCH_DOWN,
EL_BALLOON_SWITCH_ANY,
+ EL_BALLOON_SWITCH_NONE,
EL_LAMP,
EL_TIME_ORB_FULL,
+ EL_EMC_MAGIC_BALL_SWITCH,
+ EL_EMC_MAGIC_BALL_SWITCH_ACTIVE,
+
-1
};
EL_EXIT_OPEN,
EL_STEELWALL,
EL_PLAYER_1,
+ EL_PLAYER_2,
+ EL_PLAYER_3,
+ EL_PLAYER_4,
EL_BD_FIREFLY,
EL_BD_FIREFLY_1,
EL_BD_FIREFLY_2,
EL_BD_AMOEBA,
EL_CHAR_QUESTION,
EL_UNKNOWN,
+
-1
};
/* should always be valid */
EL_EMPTY,
+ /* standard classic Supaplex elements */
EL_SP_EMPTY,
EL_SP_ZONK,
EL_SP_BASE,
EL_SP_HARDWARE_BASE_6,
EL_SP_CHIP_TOP,
EL_SP_CHIP_BOTTOM,
+
/* additional elements that appeared in newer Supaplex levels */
EL_INVISIBLE_WALL,
- /* more than one murphy in a level results in an inactive clone */
+
+ /* additional gravity port elements (not switching, but setting gravity) */
+ EL_SP_GRAVITY_ON_PORT_LEFT,
+ EL_SP_GRAVITY_ON_PORT_RIGHT,
+ EL_SP_GRAVITY_ON_PORT_UP,
+ EL_SP_GRAVITY_ON_PORT_DOWN,
+ EL_SP_GRAVITY_OFF_PORT_LEFT,
+ EL_SP_GRAVITY_OFF_PORT_RIGHT,
+ EL_SP_GRAVITY_OFF_PORT_UP,
+ EL_SP_GRAVITY_OFF_PORT_DOWN,
+
+ /* more than one Murphy in a level results in an inactive clone */
EL_SP_MURPHY_CLONE,
- /* runtime elements*/
+
+ /* runtime Supaplex elements */
EL_SP_DISK_RED_ACTIVE,
EL_SP_TERMINAL_ACTIVE,
EL_SP_BUGGY_BASE_ACTIVATING,
EL_SP_BUGGY_BASE_ACTIVE,
EL_SP_EXIT_OPENING,
EL_SP_EXIT_CLOSING,
+
-1
};
EL_SOKOBAN_OBJECT,
EL_SOKOBAN_FIELD_EMPTY,
EL_SOKOBAN_FIELD_FULL,
+ EL_SOKOBAN_FIELD_PLAYER,
EL_PLAYER_1,
+ EL_PLAYER_2,
+ 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_GATE_2_GRAY,
EL_GATE_3_GRAY,
EL_GATE_4_GRAY,
+ EL_GATE_1_GRAY_ACTIVE,
+ EL_GATE_2_GRAY_ACTIVE,
+ EL_GATE_3_GRAY_ACTIVE,
+ EL_GATE_4_GRAY_ACTIVE,
EL_EM_GATE_1,
EL_EM_GATE_2,
EL_EM_GATE_3,
EL_EM_GATE_2_GRAY,
EL_EM_GATE_3_GRAY,
EL_EM_GATE_4_GRAY,
+ EL_EM_GATE_1_GRAY_ACTIVE,
+ EL_EM_GATE_2_GRAY_ACTIVE,
+ EL_EM_GATE_3_GRAY_ACTIVE,
+ EL_EM_GATE_4_GRAY_ACTIVE,
EL_EXIT_CLOSED,
EL_EXIT_OPENING,
EL_EXIT_OPEN,
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_GATE_2_GRAY,
EL_GATE_3_GRAY,
EL_GATE_4_GRAY,
+ EL_GATE_1_GRAY_ACTIVE,
+ EL_GATE_2_GRAY_ACTIVE,
+ EL_GATE_3_GRAY_ACTIVE,
+ EL_GATE_4_GRAY_ACTIVE,
EL_EM_GATE_1,
EL_EM_GATE_2,
EL_EM_GATE_3,
EL_EM_GATE_2_GRAY,
EL_EM_GATE_3_GRAY,
EL_EM_GATE_4_GRAY,
+ EL_EM_GATE_1_GRAY_ACTIVE,
+ EL_EM_GATE_2_GRAY_ACTIVE,
+ EL_EM_GATE_3_GRAY_ACTIVE,
+ EL_EM_GATE_4_GRAY_ACTIVE,
EL_SWITCHGATE_OPEN,
EL_SWITCHGATE_OPENING,
EL_SWITCHGATE_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_GATE_2_GRAY,
EL_GATE_3_GRAY,
EL_GATE_4_GRAY,
+ EL_GATE_1_GRAY_ACTIVE,
+ EL_GATE_2_GRAY_ACTIVE,
+ EL_GATE_3_GRAY_ACTIVE,
+ EL_GATE_4_GRAY_ACTIVE,
EL_EM_GATE_1,
EL_EM_GATE_2,
EL_EM_GATE_3,
EL_EM_GATE_2_GRAY,
EL_EM_GATE_3_GRAY,
EL_EM_GATE_4_GRAY,
+ EL_EM_GATE_1_GRAY_ACTIVE,
+ EL_EM_GATE_2_GRAY_ACTIVE,
+ EL_EM_GATE_3_GRAY_ACTIVE,
+ EL_EM_GATE_4_GRAY_ACTIVE,
+ EL_EMC_GATE_5,
+ EL_EMC_GATE_6,
+ EL_EMC_GATE_7,
+ EL_EMC_GATE_8,
+ EL_EMC_GATE_5_GRAY,
+ EL_EMC_GATE_6_GRAY,
+ EL_EMC_GATE_7_GRAY,
+ EL_EMC_GATE_8_GRAY,
+ EL_EMC_GATE_5_GRAY_ACTIVE,
+ 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
+ };
+
+ static int ep_can_turn_each_move[] =
+ {
+ /* !!! do something with this one !!! */
+ -1
+ };
+
+ static int ep_can_grow[] =
+ {
+ EL_BD_AMOEBA,
+ EL_AMOEBA_DROP,
+ EL_AMOEBA_WET,
+ EL_AMOEBA_DRY,
+ 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_EM_KEY_2,
EL_EM_KEY_3,
EL_EM_KEY_4,
+ EL_EMC_KEY_5,
+ EL_EMC_KEY_6,
+ EL_EMC_KEY_7,
+ EL_EMC_KEY_8,
EL_GATE_1,
EL_GATE_2,
EL_GATE_3,
EL_GATE_2_GRAY,
EL_GATE_3_GRAY,
EL_GATE_4_GRAY,
+ EL_GATE_1_GRAY_ACTIVE,
+ EL_GATE_2_GRAY_ACTIVE,
+ EL_GATE_3_GRAY_ACTIVE,
+ EL_GATE_4_GRAY_ACTIVE,
EL_EM_GATE_1,
EL_EM_GATE_2,
EL_EM_GATE_3,
EL_EM_GATE_2_GRAY,
EL_EM_GATE_3_GRAY,
EL_EM_GATE_4_GRAY,
+ EL_EM_GATE_1_GRAY_ACTIVE,
+ EL_EM_GATE_2_GRAY_ACTIVE,
+ EL_EM_GATE_3_GRAY_ACTIVE,
+ EL_EM_GATE_4_GRAY_ACTIVE,
+ EL_EMC_GATE_5,
+ EL_EMC_GATE_6,
+ EL_EMC_GATE_7,
+ EL_EMC_GATE_8,
+ EL_EMC_GATE_5_GRAY,
+ EL_EMC_GATE_6_GRAY,
+ EL_EMC_GATE_7_GRAY,
+ EL_EMC_GATE_8_GRAY,
+ EL_EMC_GATE_5_GRAY_ACTIVE,
+ EL_EMC_GATE_6_GRAY_ACTIVE,
+ 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_SP_HARDWARE_BASE_4,
EL_SP_HARDWARE_BASE_5,
EL_SP_HARDWARE_BASE_6,
+ EL_SP_GRAVITY_ON_PORT_LEFT,
+ EL_SP_GRAVITY_ON_PORT_RIGHT,
+ EL_SP_GRAVITY_ON_PORT_UP,
+ EL_SP_GRAVITY_ON_PORT_DOWN,
+ EL_SP_GRAVITY_OFF_PORT_LEFT,
+ EL_SP_GRAVITY_OFF_PORT_RIGHT,
+ EL_SP_GRAVITY_OFF_PORT_UP,
+ EL_SP_GRAVITY_OFF_PORT_DOWN,
EL_CONVEYOR_BELT_1_SWITCH_LEFT,
EL_CONVEYOR_BELT_1_SWITCH_MIDDLE,
EL_CONVEYOR_BELT_1_SWITCH_RIGHT,
EL_EMC_STEELWALL_2,
EL_EMC_STEELWALL_3,
EL_EMC_STEELWALL_4,
+ EL_EMC_WALL_SLIPPERY_1,
+ EL_EMC_WALL_SLIPPERY_2,
+ EL_EMC_WALL_SLIPPERY_3,
+ EL_EMC_WALL_SLIPPERY_4,
EL_EMC_WALL_1,
EL_EMC_WALL_2,
EL_EMC_WALL_3,
EL_EMC_WALL_6,
EL_EMC_WALL_7,
EL_EMC_WALL_8,
+ EL_EMC_WALL_9,
+ EL_EMC_WALL_10,
+ EL_EMC_WALL_11,
+ EL_EMC_WALL_12,
+ EL_EMC_WALL_13,
+ 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_USER_ACTIVE,
+ EL_INTERNAL_CASCADE_GENERIC_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_USER,
+ EL_INTERNAL_CASCADE_GENERIC,
+ 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_can_explode_by_fire, EP_CAN_EXPLODE_BY_FIRE },
- { ep_can_explode_smashed, EP_CAN_EXPLODE_SMASHED },
- { ep_can_explode_impact, EP_CAN_EXPLODE_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_can_explode_1x1, EP_CAN_EXPLODE_1X1 },
- { ep_pushable, EP_PUSHABLE },
- { ep_can_explode_dyna, EP_CAN_EXPLODE_DYNA },
- { ep_protected, EP_PROTECTED },
-
- { 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_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 }
- };
-
- static int copy_properties[][5] =
- {
- {
- EL_BUG,
- EL_BUG_LEFT, EL_BUG_RIGHT,
- EL_BUG_UP, EL_BUG_DOWN
- },
- {
- EL_SPACESHIP,
- EL_SPACESHIP_LEFT, EL_SPACESHIP_RIGHT,
- EL_SPACESHIP_UP, EL_SPACESHIP_DOWN
- },
- {
- EL_BD_BUTTERFLY,
- EL_BD_BUTTERFLY_LEFT, EL_BD_BUTTERFLY_RIGHT,
- EL_BD_BUTTERFLY_UP, EL_BD_BUTTERFLY_DOWN
- },
- {
- EL_BD_FIREFLY,
- EL_BD_FIREFLY_LEFT, EL_BD_FIREFLY_RIGHT,
- EL_BD_FIREFLY_UP, EL_BD_FIREFLY_DOWN
- },
- {
- EL_PACMAN,
- 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
- }
+ { 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;
void InitElementPropertiesEngine(int engine_version)
{
-#if 0
- static int active_properties[] =
- {
- EP_AMOEBALIVE,
- EP_AMOEBOID,
- EP_PFORTE,
- EP_DONT_COLLIDE_WITH,
- EP_MAUER,
- EP_CAN_FALL,
- EP_CAN_SMASH,
- EP_CAN_PASS_MAGIC_WALL,
- EP_CAN_MOVE,
- EP_DONT_TOUCH,
- EP_DONT_RUN_INTO,
- EP_GEM,
- EP_CAN_EXPLODE_BY_FIRE,
- EP_PUSHABLE,
- EP_PLAYER,
- EP_HAS_CONTENT,
- EP_DIGGABLE,
- EP_PASSABLE_INSIDE,
- EP_OVER_PLAYER,
- EP_ACTIVE_BOMB,
-
- EP_BELT,
- EP_BELT_ACTIVE,
- EP_BELT_SWITCH,
- EP_WALKABLE_UNDER,
- EP_EM_SLIPPERY_WALL,
- };
-#endif
-
static int no_wall_properties[] =
{
EP_DIGGABLE,
int i, j;
-#if 0
- 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 */
+#if 1
+ /* ---------- recursively resolve group elements ------------------------- */
+
for (i = 0; i < MAX_NUM_ELEMENTS; i++)
- {
-#if 0
- for (j = EP_ACCESSIBLE_OVER; j < NUM_ELEMENT_PROPERTIES; j++)
- SET_PROPERTY(i, j, FALSE);
+ 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);
#endif
+ /* set all special, combined or engine dependent element properties */
+ for (i = 0; i < MAX_NUM_ELEMENTS; i++)
+ {
/* ---------- INACTIVE ------------------------------------------------- */
SET_PROPERTY(i, EP_INACTIVE, (i >= EL_CHAR_START && i <= EL_CHAR_END));
/* ---------- COLLECTIBLE ---------------------------------------------- */
SET_PROPERTY(i, EP_COLLECTIBLE, (IS_COLLECTIBLE_ONLY(i) ||
- IS_DROPPABLE(i)));
+ IS_DROPPABLE(i) ||
+ IS_THROWABLE(i)));
/* ---------- SNAPPABLE ------------------------------------------------ */
SET_PROPERTY(i, EP_SNAPPABLE, (IS_DIGGABLE(i) ||
!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))
{
CAN_SMASH_ENEMIES(i) ||
CAN_SMASH_EVERYTHING(i)));
- /* ---------- CAN_EXPLODE ---------------------------------------------- */
- SET_PROPERTY(i, EP_CAN_EXPLODE, (CAN_EXPLODE_BY_FIRE(i) ||
- CAN_EXPLODE_SMASHED(i) ||
- CAN_EXPLODE_IMPACT(i)));
+ /* ---------- CAN_EXPLODE_BY_FIRE -------------------------------------- */
+ SET_PROPERTY(i, EP_CAN_EXPLODE_BY_FIRE, (CAN_EXPLODE(i) &&
+ EXPLODES_BY_FIRE(i)));
+
+ /* ---------- CAN_EXPLODE_SMASHED -------------------------------------- */
+ SET_PROPERTY(i, EP_CAN_EXPLODE_SMASHED, (CAN_EXPLODE(i) &&
+ EXPLODES_SMASHED(i)));
- /* ---------- CAN_EXPLODE_3X3 ------------------------------------------ */
- SET_PROPERTY(i, EP_CAN_EXPLODE_3X3, (CAN_EXPLODE(i) &&
- !CAN_EXPLODE_1X1(i) &&
- !CAN_EXPLODE_DYNA(i)));
+ /* ---------- CAN_EXPLODE_IMPACT --------------------------------------- */
+ SET_PROPERTY(i, EP_CAN_EXPLODE_IMPACT, (CAN_EXPLODE(i) &&
+ EXPLODES_IMPACT(i)));
/* ---------- CAN_EXPLODE_BY_DRAGONFIRE -------------------------------- */
SET_PROPERTY(i, EP_CAN_EXPLODE_BY_DRAGONFIRE, CAN_EXPLODE_BY_FIRE(i));
i == EL_BLACK_ORB));
/* ---------- COULD_MOVE_INTO_ACID ------------------------------------- */
- SET_PROPERTY(i, EP_COULD_MOVE_INTO_ACID, (CAN_MOVE(i) ||
+ 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_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_DYNA(i),
- CAN_EXPLODE(i));
-#endif
+ /* ---------- 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 */
if (element_info[i].change_page[j].can_change)
SET_PROPERTY(i, EP_CAN_CHANGE, TRUE);
+ /* ---------- HAS_ACTION ----------------------------------------------- */
+ SET_PROPERTY(i, EP_HAS_ACTION, FALSE); /* default: has no action */
+ for (j = 0; j < element_info[i].num_change_pages; j++)
+ if (element_info[i].change_page[j].has_action)
+ SET_PROPERTY(i, EP_HAS_ACTION, TRUE);
+
+ /* ---------- CAN_CHANGE_OR_HAS_ACTION --------------------------------- */
+ SET_PROPERTY(i, EP_CAN_CHANGE_OR_HAS_ACTION, (CAN_CHANGE(i) ||
+ HAS_ACTION(i)));
+
/* ---------- GFX_CRUMBLED --------------------------------------------- */
+#if 1
+ SET_PROPERTY(i, EP_GFX_CRUMBLED,
+ element_info[i].crumbled[ACTION_DEFAULT] !=
+ element_info[i].graphic[ACTION_DEFAULT]);
+#else
+ /* !!! THIS LOOKS CRAPPY FOR SAND ETC. WITHOUT CRUMBLED GRAPHICS !!! */
SET_PROPERTY(i, EP_GFX_CRUMBLED,
element_info[i].crumbled[ACTION_DEFAULT] != IMG_EMPTY);
- }
-
-#if 0
- /* determine inactive elements (used for engine main loop optimization) */
- for (i = 0; i < MAX_NUM_ELEMENTS; i++)
- {
- boolean active = FALSE;
-
- for (j = 0; i < NUM_ELEMENT_PROPERTIES; j++)
- {
- if (HAS_PROPERTY(i, j))
- active = TRUE;
- }
-
-#if 0
- if (!active)
- SET_PROPERTY(i, EP_INACTIVE, TRUE);
#endif
+
+ /* ---------- EDITOR_CASCADE ------------------------------------------- */
+ SET_PROPERTY(i, EP_EDITOR_CASCADE, (IS_EDITOR_CASCADE_ACTIVE(i) ||
+ IS_EDITOR_CASCADE_INACTIVE(i)));
}
-#endif
/* dynamically adjust element properties according to game engine version */
{
engine_version > VERSION_IDENT(2,0,1,0)));
}
-#if 1
+#if 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 = 8;
game.default_push_delay_random = 8;
}
+#endif
+#if 0
/* set uninitialized push delay values of custom elements in older levels */
for (i = 0; i < NUM_CUSTOM_ELEMENTS; i++)
{
if (element_info[element].push_delay_random == -1)
element_info[element].push_delay_random = game.default_push_delay_random;
}
+#endif
+#if 0
/* set some other uninitialized values of custom elements in older levels */
if (engine_version < VERSION_IDENT(3,1,0,0))
{
element_info[element].access_direction = MV_ALL_DIRECTIONS;
- element_info[element].explosion_delay = 18;
+ element_info[element].explosion_delay = 17;
element_info[element].ignition_delay = 8;
}
}
+#endif
#if 0
/* set element properties that were handled incorrectly in older levels */
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 */
InitElementGraphicInfo();
}
+void InitElementPropertiesAfterLoading(int engine_version)
+{
+ int i;
+
+#if 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;
+ }
+#endif
+
+#if 0
+ /* 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;
+
+ 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;
+ }
+#endif
+
+#if 1
+ /* 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;
+ }
+ }
+#endif
+}
+
static void InitGlobal()
{
+ int i;
+
+ for (i = 0; i < MAX_NUM_ELEMENTS + 1; i++)
+ {
+ /* check if element_name_info entry defined for each element in "main.h" */
+ if (i < MAX_NUM_ELEMENTS && element_name_info[i].token_name == NULL)
+ Error(ERR_EXIT, "undefined 'element_name_info' entry for element %d", 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;
+ }
+
global.autoplay_leveldir = NULL;
+ global.convert_leveldir = NULL;
global.frames_per_second = 0;
global.fps_slowdown = FALSE;
{
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");
{
char *filename = &command[11];
- if (access(filename, F_OK) != 0)
+ if (!fileExists(filename))
Error(ERR_EXIT, "cannot open file '%s'", filename);
LoadLevelFromFilename(&level, filename);
{
char *filename = &command[10];
- if (access(filename, F_OK) != 0)
+ if (!fileExists(filename))
Error(ERR_EXIT, "cannot open file '%s'", filename);
LoadTapeFromFilename(filename);
}
else if (strncmp(command, "autoplay ", 9) == 0)
{
- char *str_copy = getStringCopy(&command[9]);
+ char *str_ptr = getStringCopy(&command[9]); /* read command parameters */
+
+ while (*str_ptr != '\0') /* continue parsing string */
+ {
+ /* cut leading whitespace from string, replace it by string terminator */
+ while (*str_ptr == ' ' || *str_ptr == '\t')
+ *str_ptr++ = '\0';
+
+ if (*str_ptr == '\0') /* end of string reached */
+ break;
+
+ if (global.autoplay_leveldir == NULL) /* read level set string */
+ {
+ global.autoplay_leveldir = str_ptr;
+ global.autoplay_all = TRUE; /* default: play all tapes */
+
+ for (i = 0; i < MAX_TAPES_PER_SET; i++)
+ global.autoplay_level[i] = FALSE;
+ }
+ else /* read level number string */
+ {
+ int level_nr = atoi(str_ptr); /* get level_nr value */
+
+ if (level_nr >= 0 && level_nr < MAX_TAPES_PER_SET)
+ global.autoplay_level[level_nr] = TRUE;
+
+ global.autoplay_all = FALSE;
+ }
+
+ /* advance string pointer to the next whitespace (or end of string) */
+ while (*str_ptr != ' ' && *str_ptr != '\t' && *str_ptr != '\0')
+ str_ptr++;
+ }
+ }
+ else if (strncmp(command, "convert ", 8) == 0)
+ {
+ char *str_copy = getStringCopy(&command[8]);
char *str_ptr = strchr(str_copy, ' ');
- global.autoplay_leveldir = str_copy;
- global.autoplay_level_nr = -1;
+ global.convert_leveldir = str_copy;
+ global.convert_level_nr = -1;
- if (str_ptr != NULL)
+ if (str_ptr != NULL) /* level number follows */
{
*str_ptr++ = '\0'; /* terminate leveldir string */
- global.autoplay_level_nr = atoi(str_ptr); /* get level_nr value */
+ global.convert_level_nr = atoi(str_ptr); /* get level_nr value */
}
}
else
options.verbose = TRUE;
}
+static void InitGameInfo()
+{
+ game.restart_level = FALSE;
+}
+
static void InitPlayerInfo()
{
int i;
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 };
for (i = 0; i < NUM_MUSIC_PREFIXES; i++)
music_id_prefix[i] = music_prefix_info[i].prefix;
- music_id_prefix[MAX_LEVELS] = NULL;
+ music_id_prefix[NUM_MUSIC_PREFIXES] = NULL;
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_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;
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_title = CreateBitmap(WIN_XSIZE, WIN_YSIZE, DEFAULT_DEPTH);
bitmap_db_field = CreateBitmap(FXSIZE, FYSIZE, DEFAULT_DEPTH);
bitmap_db_door = CreateBitmap(3 * DXSIZE, DYSIZE + VYSIZE, DEFAULT_DEPTH);
DrawInitText(PROGRAM_COPYRIGHT_STRING, 50, 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);
- InitTileClipmasks();
+ redraw_mask = REDRAW_ALL;
}
void InitGfxBackground()
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);
static void InitImages()
{
-#if 1
setLevelArtworkDir(artwork.gfx_first);
-#endif
#if 0
printf("::: InitImages for '%s' ['%s', '%s'] ['%s', '%s']\n",
if (identifier == NULL)
identifier = artwork.snd_current->identifier;
-#if 1
/* set artwork path to send it to the sound server process */
setLevelArtworkDir(artwork.snd_first);
-#endif
InitReloadCustomSounds(identifier);
ReinitializeSounds();
if (identifier == NULL)
identifier = artwork.mus_current->identifier;
-#if 1
/* set artwork path to send it to the sound server process */
setLevelArtworkDir(artwork.mus_first);
-#endif
InitReloadCustomMusic(identifier);
ReinitializeMusic();
void InitNetworkServer()
{
-#if defined(PLATFORM_UNIX)
+#if defined(NETWORK_AVALIABLE)
int nr_wanted;
#endif
if (!options.network)
return;
-#if defined(PLATFORM_UNIX)
+#if defined(NETWORK_AVALIABLE)
nr_wanted = Request("Choose player", REQ_PLAYER | REQ_STAY_CLOSED);
if (!ConnectToServer(options.server_host, options.server_port))
#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(artwork, type))) = artwork_current_identifier;
+ *(ARTWORK_CURRENT_IDENTIFIER_PTR(artwork, type))= artwork_current_identifier;
#if 0
if (type == ARTWORK_TYPE_GRAPHICS)
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
InitImages();
-#if 0
- printf("... '%s'\n",
- leveldir_current->graphics_set);
-#endif
-
- FreeTileClipmasks();
- InitTileClipmasks();
-
redraw_screen = TRUE;
}
if (redraw_screen)
{
+#if 1
+ RedrawBackground();
+#else
InitGfxBackground();
+#endif
/* force redraw of (open or closed) door graphics */
SetDoorState(DOOR_OPEN_ALL);
void OpenAll()
{
- InitGlobal(); /* initialize some global variables */
+ InitGlobal(); /* initialize some global variables */
if (options.execute_command)
Execute_Command(options.execute_command);
#else
Error(ERR_WARN, "networking only supported in Unix version");
#endif
- exit(0); /* never reached */
+
+ exit(0); /* never reached, server loops forever */
}
InitSetup();
+ InitGameInfo();
InitPlayerInfo();
InitArtworkInfo(); /* needed before loading gfx, sound & music */
InitArtworkConfig(); /* needed before forking sound child process */
AutoPlayTape();
return;
}
+ else if (global.convert_leveldir)
+ {
+ ConvertLevels();
+ return;
+ }
game_status = GAME_MODE_MAIN;
+#if 1
+ em_open_all();
+#endif
+
DrawMainMenu();
InitNetworkServer();
FreeAllMusic();
CloseAudio(); /* called after freeing sounds (needed for SDL) */
+#if 1
+ em_close_all();
+#endif
+
FreeAllImages();
- FreeTileClipmasks();
+
+#if defined(TARGET_SDL)
+ if (network_server) /* terminate network server */
+ SDL_KillThread(server_thread);
+#endif
CloseVideoDisplay();
ClosePlatformDependentStuff();