if (!global.fps_slowdown)
info1[0] = '\0';
- sprintf(text, "%.1f fps%s", global.frames_per_second, info1);
+ sprintf(text, "%04.1f fps%s", global.frames_per_second, info1);
+#if 1
+ DrawTextExt(window, SX + SXSIZE + SX, 0, text, FONT_TEXT_2, BLIT_OPAQUE);
+#else
DrawTextExt(window, SX, SY, text, FONT_TEXT_2, BLIT_OPAQUE);
+#endif
}
FlushDisplay();
DrawLevelElementExt(x, y, 0, 0, Feld[x][y], NO_CUTTING, USE_MASKING);
}
+/* !!! implementation of quicksand is totally broken !!! */
+#define IS_CRUMBLED_TILE(x, y, e) \
+ (GFX_CRUMBLED(e) && (!IN_LEV_FIELD(x, y) || \
+ !IS_MOVING(x, y) || \
+ (e) == EL_QUICKSAND_EMPTYING || \
+ (e) == EL_QUICKSAND_FAST_EMPTYING))
+
static void DrawLevelFieldCrumbledSandExt(int x, int y, int graphic, int frame)
{
Bitmap *src_bitmap;
element = TILE_GFX_ELEMENT(x, y);
/* crumble field itself */
+#if 1
+ if (IS_CRUMBLED_TILE(x, y, element))
+#else
if (GFX_CRUMBLED(element) && !IS_MOVING(x, y))
+#endif
{
if (!IN_SCR_FIELD(sx, sy))
return;
BorderElement);
/* check if neighbour field is of same type */
+#if 1
+ if (IS_CRUMBLED_TILE(xx, yy, element))
+ continue;
+#else
if (GFX_CRUMBLED(element) && !IS_MOVING(xx, yy))
continue;
+#endif
if (i == 1 || i == 2)
{
int sxx = sx + xy[i][0];
int syy = sy + xy[i][1];
+#if 1
+ if (!IN_LEV_FIELD(xx, yy) ||
+ !IN_SCR_FIELD(sxx, syy))
+ continue;
+#else
if (!IN_LEV_FIELD(xx, yy) ||
!IN_SCR_FIELD(sxx, syy) ||
IS_MOVING(xx, yy))
continue;
+#endif
if (Feld[xx][yy] == EL_ELEMENT_SNAPPING)
continue;
element = TILE_GFX_ELEMENT(xx, yy);
+#if 1
+ if (!IS_CRUMBLED_TILE(xx, yy, element))
+ continue;
+#else
if (!GFX_CRUMBLED(element))
continue;
+#endif
graphic = el_act2crm(element, ACTION_DEFAULT);
crumbled_border_size = graphic_info[graphic].border_size;
element = getBorderElement(lx, ly);
DrawScreenElement(x, y, element);
+
return;
}
element == EL_DC_MAGIC_WALL_FILLING)
cut_mode = CUT_BELOW;
+#if 0
+ if (lx == 9 && ly == 1)
+ printf("::: %s [%d] [%d, %d] [%d]\n",
+ EL_NAME(TILE_GFX_ELEMENT(lx, ly)),
+ el_act2crm(TILE_GFX_ELEMENT(lx, ly), ACTION_DEFAULT),
+ element_info[EL_QUICKSAND_EMPTYING].graphic[ACTION_DEFAULT],
+ element_info[EL_QUICKSAND_EMPTYING].crumbled[ACTION_DEFAULT],
+ GFX_CRUMBLED(TILE_GFX_ELEMENT(lx, ly)));
+#endif
+
if (cut_mode == CUT_ABOVE)
+#if 1
+ DrawScreenElement(x, y, element);
+#else
DrawScreenElementShifted(x, y, 0, 0, element, NO_CUTTING);
+#endif
else
DrawScreenElement(x, y, EL_EMPTY);
else if (cut_mode == NO_CUTTING)
DrawScreenElementShifted(x, y, 0, MovPos[lx][ly], element, cut_mode);
else
+ {
DrawScreenElementShifted(x, y, 0, MovPos[lx][ly], content, cut_mode);
+#if 1
+ if (cut_mode == CUT_BELOW &&
+ IN_LEV_FIELD(lx, ly + 1) && IN_SCR_FIELD(x, y + 1))
+ DrawLevelElement(lx, ly + 1, element);
+#endif
+ }
+
if (content == EL_ACID)
{
int dir = MovDir[lx][ly];
{
int x,y;
+#if 1
+ SetMainBackgroundImage(IMG_BACKGROUND_PLAYING);
+ SetDrawBackgroundMask(REDRAW_FIELD);
+#else
SetDrawBackgroundMask(REDRAW_NONE);
+#endif
+
ClearField();
for (x = BX1; x <= BX2; x++)
door_state &= ~DOOR_CLOSE_ALL;
}
+#if 1
+ if (game_status == GAME_MODE_EDITOR)
+ door_state |= DOOR_NO_DELAY;
+#endif
+
if (door_state & DOOR_ACTION)
{
boolean handle_door_1 = (door_state & DOOR_ACTION_1);
Xsand_stonein_4, FALSE, TRUE,
EL_ROCK, ACTION_FILLING, -1
},
+#if 1
+ {
+ Xsand_stonesand_1, FALSE, FALSE,
+ EL_QUICKSAND_EMPTYING, -1, -1
+ },
+ {
+ Xsand_stonesand_2, FALSE, FALSE,
+ EL_QUICKSAND_EMPTYING, -1, -1
+ },
+ {
+ Xsand_stonesand_3, FALSE, FALSE,
+ EL_QUICKSAND_EMPTYING, -1, -1
+ },
+ {
+ Xsand_stonesand_4, FALSE, FALSE,
+ EL_QUICKSAND_EMPTYING, -1, -1
+ },
+ {
+ Xsand_stonesand_quickout_1, FALSE, FALSE,
+ EL_QUICKSAND_EMPTYING, -1, -1
+ },
+ {
+ Xsand_stonesand_quickout_2, FALSE, FALSE,
+ EL_QUICKSAND_EMPTYING, -1, -1
+ },
+#else
{
Xsand_stonesand_1, FALSE, FALSE,
EL_QUICKSAND_FULL, -1, -1
Xsand_stonesand_4, FALSE, FALSE,
EL_QUICKSAND_FULL, -1, -1
},
+#endif
{
Xsand_stoneout_1, FALSE, FALSE,
EL_ROCK, ACTION_EMPTYING, -1
Xsand_stoneout_2, FALSE, FALSE,
EL_ROCK, ACTION_EMPTYING, -1
},
+#if 1
+ {
+ Xsand_sandstone_1, FALSE, FALSE,
+ EL_QUICKSAND_FILLING, -1, -1
+ },
+ {
+ Xsand_sandstone_2, FALSE, FALSE,
+ EL_QUICKSAND_FILLING, -1, -1
+ },
+ {
+ Xsand_sandstone_3, FALSE, FALSE,
+ EL_QUICKSAND_FILLING, -1, -1
+ },
+ {
+ Xsand_sandstone_4, FALSE, FALSE,
+ EL_QUICKSAND_FILLING, -1, -1
+ },
+#else
{
Xsand_sandstone_1, FALSE, FALSE,
EL_QUICKSAND_FULL, -1, -1
Xsand_sandstone_4, FALSE, FALSE,
EL_QUICKSAND_FULL, -1, -1
},
+#endif
{
Xplant, TRUE, FALSE,
EL_EMC_PLANT, -1, -1
static struct Mapping_EM_to_RND_player player_mapping[MAX_PLAYERS][SPR_MAX];
#endif
+inline static int get_effective_element_EM(int tile, int frame_em)
+{
+ int element = object_mapping[tile].element_rnd;
+ int action = object_mapping[tile].action;
+ boolean is_backside = object_mapping[tile].is_backside;
+ boolean action_removing = (action == ACTION_DIGGING ||
+ action == ACTION_SNAPPING ||
+ action == ACTION_COLLECTING);
+
+ if (frame_em < 7)
+ {
+ switch (tile)
+ {
+ case Yacid_splash_eB:
+ case Yacid_splash_wB:
+ return (frame_em > 5 ? EL_EMPTY : element);
+
+ default:
+ return element;
+ }
+ }
+ else /* frame_em == 7 */
+ {
+ switch (tile)
+ {
+ case Yacid_splash_eB:
+ case Yacid_splash_wB:
+ return EL_EMPTY;
+
+ case Yemerald_stone:
+ return EL_EMERALD;
+
+ case Ydiamond_stone:
+ return EL_ROCK;
+
+ case Xdrip_stretch:
+ case Xdrip_stretchB:
+ case Ydrip_s1:
+ case Ydrip_s1B:
+ case Xball_1B:
+ case Xball_2:
+ case Xball_2B:
+ case Yball_eat:
+ case Ykey_1_eat:
+ case Ykey_2_eat:
+ case Ykey_3_eat:
+ case Ykey_4_eat:
+ case Ykey_5_eat:
+ case Ykey_6_eat:
+ case Ykey_7_eat:
+ case Ykey_8_eat:
+ case Ylenses_eat:
+ case Ymagnify_eat:
+ case Ygrass_eat:
+ case Ydirt_eat:
+ case Xsand_stonein_1:
+ case Xsand_stonein_2:
+ case Xsand_stonein_3:
+ case Xsand_stonein_4:
+ return element;
+
+ default:
+ return (is_backside || action_removing ? EL_EMPTY : element);
+ }
+ }
+}
+
+inline static boolean check_linear_animation_EM(int tile)
+{
+ switch (tile)
+ {
+ case Xsand_stonesand_1:
+ case Xsand_stonesand_quickout_1:
+ case Xsand_sandstone_1:
+ case Xsand_stonein_1:
+ case Xsand_stoneout_1:
+ case Xboom_1:
+ case Xdynamite_1:
+ case Ybug_w_n:
+ case Ybug_n_e:
+ case Ybug_e_s:
+ case Ybug_s_w:
+ case Ybug_e_n:
+ case Ybug_s_e:
+ case Ybug_w_s:
+ case Ybug_n_w:
+ case Ytank_w_n:
+ case Ytank_n_e:
+ case Ytank_e_s:
+ case Ytank_s_w:
+ case Ytank_e_n:
+ case Ytank_s_e:
+ case Ytank_w_s:
+ case Ytank_n_w:
+ return TRUE;
+ }
+
+ return FALSE;
+}
+
+inline static void set_crumbled_graphics_EM(struct GraphicInfo_EM *g_em,
+ boolean has_crumbled_graphics,
+ int crumbled, int sync_frame)
+{
+ /* if element can be crumbled, but certain action graphics are just empty
+ space (like instantly snapping sand to empty space in 1 frame), do not
+ treat these empty space graphics as crumbled graphics in EMC engine */
+ if (crumbled == IMG_EMPTY_SPACE)
+ has_crumbled_graphics = FALSE;
+
+ if (has_crumbled_graphics)
+ {
+ struct GraphicInfo *g_crumbled = &graphic_info[crumbled];
+ int frame_crumbled = getAnimationFrame(g_crumbled->anim_frames,
+ g_crumbled->anim_delay,
+ g_crumbled->anim_mode,
+ g_crumbled->anim_start_frame,
+ sync_frame);
+
+ getGraphicSource(crumbled, frame_crumbled, &g_em->crumbled_bitmap,
+ &g_em->crumbled_src_x, &g_em->crumbled_src_y);
+
+ g_em->crumbled_border_size = graphic_info[crumbled].border_size;
+
+ g_em->has_crumbled_graphics = TRUE;
+ }
+ else
+ {
+ g_em->crumbled_bitmap = NULL;
+ g_em->crumbled_src_x = 0;
+ g_em->crumbled_src_y = 0;
+ g_em->crumbled_border_size = 0;
+
+ g_em->has_crumbled_graphics = FALSE;
+ }
+}
+
void ResetGfxAnimation_EM(int x, int y, int tile)
{
GfxFrame[x][y] = 0;
}
-void SetGfxAnimation_EM(int tile, int frame_em, int x, int y)
+void SetGfxAnimation_EM(struct GraphicInfo_EM *g_em,
+ int tile, int frame_em, int x, int y)
{
-#if 0
- int element = object_mapping[tile].element_rnd;
+ int action = object_mapping[tile].action;
+#if 1
+ int direction = object_mapping[tile].direction;
+ int effective_element = get_effective_element_EM(tile, frame_em);
+ int graphic = (direction == MV_NONE ?
+ el_act2img(effective_element, action) :
+ el_act_dir2img(effective_element, action, direction));
+ struct GraphicInfo *g = &graphic_info[graphic];
+ int sync_frame;
#endif
- int action = object_mapping[tile].action;
- int direction = object_mapping[tile].direction;
- boolean is_backside = object_mapping[tile].is_backside;
boolean action_removing = (action == ACTION_DIGGING ||
action == ACTION_SNAPPING ||
action == ACTION_COLLECTING);
+ boolean action_moving = (action == ACTION_FALLING ||
+ action == ACTION_MOVING ||
+ action == ACTION_PUSHING ||
+ action == ACTION_EATING ||
+ action == ACTION_FILLING ||
+ action == ACTION_EMPTYING);
+ boolean action_falling = (action == ACTION_FALLING ||
+ action == ACTION_FILLING ||
+ action == ACTION_EMPTYING);
#if 0
- printf("::: SET: %d, %d: '%s'\n", x, y, EL_NAME(element));
+ if (tile == Xsand_stonesand_1 ||
+ tile == Xsand_stonesand_2 ||
+ tile == Xsand_stonesand_3 ||
+ tile == Xsand_stonesand_4)
+ printf("::: 1: quicksand frame %d [%d]\n", GfxFrame[x][y], tile);
#endif
#if 1
- if (action_removing)
+ if ((action_removing || check_linear_animation_EM(tile)) && frame_em == 0)
{
-#if 0
- printf("::: %d, %d: action_removing [%s]\n", x, y, EL_NAME(element));
-#endif
+ GfxFrame[x][y] = 0;
+
+ // printf("::: resetting... [%d]\n", tile);
+ }
+#else
+ if (action_removing || check_linear_animation_EM(tile))
+ {
+ GfxFrame[x][y] = frame_em;
- GfxFrame[x][y] = 7 - frame_em;
+ // printf("::: resetting... [%d]\n", tile);
}
- else if (action == ACTION_FALLING ||
- action == ACTION_MOVING ||
- action == ACTION_PUSHING ||
- action == ACTION_EATING ||
- action == ACTION_FILLING ||
- action == ACTION_EMPTYING)
- {
- int move_dir =
- (action == ACTION_FALLING ||
- action == ACTION_FILLING ||
- action == ACTION_EMPTYING ? MV_DOWN : direction);
+#endif
+ else if (action_moving)
+ {
+ boolean is_backside = object_mapping[tile].is_backside;
if (is_backside)
{
+ int direction = object_mapping[tile].direction;
+ int move_dir = (action_falling ? MV_DOWN : direction);
+
GfxFrame[x][y]++;
if (move_dir == MV_LEFT)
else if (move_dir == MV_DOWN)
GfxFrame[x][y + 1] = GfxFrame[x][y];
}
-
-#if 0
- printf("::: %d, %d: %s, %d, %d [%d]\n", x, y, EL_NAME(element), is_backside,
- move_dir, GfxFrame[x][y]);
-#endif
}
else
- GfxFrame[x][y]++;
-#else
- GfxFrame[x][y] = 7 - frame_em;
-#endif
-}
-
-#if 1
-
-int get_effective_element_EM(int tile, int frame)
-{
- int i = tile;
- int j = 7 - frame;
-
- int element = object_mapping[tile].element_rnd;
- int action = object_mapping[tile].action;
- int direction = object_mapping[tile].direction;
- boolean is_backside = object_mapping[tile].is_backside;
- boolean action_removing = (action == ACTION_DIGGING ||
- action == ACTION_SNAPPING ||
- action == ACTION_COLLECTING);
-#if 0
- boolean action_exploding = ((action == ACTION_EXPLODING ||
- action == ACTION_SMASHED_BY_ROCK ||
- action == ACTION_SMASHED_BY_SPRING) &&
- element != EL_DIAMOND);
- boolean action_active = (action == ACTION_ACTIVE);
- boolean action_other = (action == ACTION_OTHER);
-#endif
-
{
- {
- int effective_element = (j > 5 && i == Yacid_splash_eB ? EL_EMPTY :
- j > 5 && i == Yacid_splash_wB ? EL_EMPTY :
- j < 7 ? element :
- i == Xdrip_stretch ? element :
- i == Xdrip_stretchB ? element :
- i == Ydrip_s1 ? element :
- i == Ydrip_s1B ? element :
- i == Xball_1B ? element :
- i == Xball_2 ? element :
- i == Xball_2B ? element :
- i == Yball_eat ? element :
- i == Ykey_1_eat ? element :
- i == Ykey_2_eat ? element :
- i == Ykey_3_eat ? element :
- i == Ykey_4_eat ? element :
- i == Ykey_5_eat ? element :
- i == Ykey_6_eat ? element :
- i == Ykey_7_eat ? element :
- i == Ykey_8_eat ? element :
- i == Ylenses_eat ? element :
- i == Ymagnify_eat ? element :
- i == Ygrass_eat ? element :
- i == Ydirt_eat ? element :
- i == Yemerald_stone ? EL_EMERALD :
- i == Ydiamond_stone ? EL_ROCK :
- i == Xsand_stonein_1 ? element :
- i == Xsand_stonein_2 ? element :
- i == Xsand_stonein_3 ? element :
- i == Xsand_stonein_4 ? element :
- is_backside ? EL_EMPTY :
- action_removing ? EL_EMPTY :
- element);
+ GfxFrame[x][y]++;
- return effective_element;
- }
+ /* special case: animation for Xsand_stonesand_quickout_1/2 twice as fast */
+ if (tile == Xsand_stonesand_quickout_1 ||
+ tile == Xsand_stonesand_quickout_2)
+ GfxFrame[x][y]++;
}
-}
-
-void getGraphicSourceObjectExt_EM(struct GraphicInfo_EM *g_em,
- int tile, int frame_em, int x, int y)
-{
- int element = object_mapping[tile].element_rnd;
- int action = object_mapping[tile].action;
- int direction = object_mapping[tile].direction;
- boolean is_backside = object_mapping[tile].is_backside;
- boolean action_removing = (action == ACTION_DIGGING ||
- action == ACTION_SNAPPING ||
- action == ACTION_COLLECTING);
-#if 1
- int effective_element = get_effective_element_EM(tile, frame_em);
-#else
- int effective_element = (frame_em > 0 ? element :
- is_backside ? EL_EMPTY :
- action_removing ? EL_EMPTY :
- element);
-#endif
- int graphic = (direction == MV_NONE ?
- el_act2img(effective_element, action) :
- el_act_dir2img(effective_element, action, direction));
- int crumbled = (direction == MV_NONE ?
- el_act2crm(effective_element, action) :
- el_act_dir2crm(effective_element, action, direction));
- int base_graphic = el_act2img(effective_element, ACTION_DEFAULT);
- int base_crumbled = el_act2crm(effective_element, ACTION_DEFAULT);
- boolean has_crumbled_graphics = (base_crumbled != base_graphic);
- struct GraphicInfo *g = &graphic_info[graphic];
- struct GraphicInfo *g_crumbled = &graphic_info[crumbled];
- int sync_frame;
-
-#if 0
- printf("::: GET: %d, %d: '%s'\n", x, y, EL_NAME(element));
-#endif
#if 0
- if (GfxFrame[x][y] < 8)
- printf("::: %d, %d: %d [%s]\n", x, y, GfxFrame[x][y], EL_NAME(element));
-#endif
-
-#if 1
- if (frame_em == 7) /* reset animation frame for certain elements */
- {
- if (tile == Xboom_1 ||
- tile == Xdynamite_1 ||
- tile == Ybug_w_n ||
- tile == Ybug_n_e ||
- tile == Ybug_e_s ||
- tile == Ybug_s_w ||
- tile == Ybug_e_n ||
- tile == Ybug_s_e ||
- tile == Ybug_w_s ||
- tile == Ybug_n_w ||
- tile == Ytank_w_n ||
- tile == Ytank_n_e ||
- tile == Ytank_e_s ||
- tile == Ytank_s_w ||
- tile == Ytank_e_n ||
- tile == Ytank_s_e ||
- tile == Ytank_w_s ||
- tile == Ytank_n_w)
- GfxFrame[x][y] = 0;
- }
+ if (tile == Xsand_stonesand_1 ||
+ tile == Xsand_stonesand_2 ||
+ tile == Xsand_stonesand_3 ||
+ tile == Xsand_stonesand_4)
+ printf("::: 2: quicksand frame %d [%d]\n", GfxFrame[x][y], tile);
#endif
#if 1
else if (IN_FIELD(x, y, MAX_LEV_FIELDX, MAX_LEV_FIELDY))
sync_frame = GfxFrame[x][y];
else
- sync_frame = 0; /* steel border */
-#else
- if (graphic_info[graphic].anim_global_sync)
- sync_frame = FrameCounter;
- else
- sync_frame = 7 - frame_em;
-#endif
+ sync_frame = 0; /* playfield border (pseudo steel) */
SetRandomAnimationValue(x, y);
g->anim_start_frame,
sync_frame);
-#if 0
- if (graphic == IMG_DEFAULT_EXPLODING)
- printf("::: IMG_DEFAULT_EXPLODING: (%d, %d), %d => %d [%d]\n",
- tile, frame_em, sync_frame, frame, Xboom_1);
-#endif
-
- getGraphicSourceExt(graphic, frame, &g_em->bitmap,
- &g_em->src_x, &g_em->src_y, FALSE);
-
-#if 0
- if (x == 1 && y == 1 && frame == 0)
- printf("--> %d, %d, %d\n", *crumbled_src_x, *crumbled_src_y, tile);
-#endif
-
-#if 0
- getGraphicSource(crumbled, frame, crumbled_src_bitmap,
- crumbled_src_x, crumbled_src_y);
-#endif
-
-#if 1
- /* (updating the "crumbled" graphic definitions is probably not really needed,
- as animations for crumbled graphics can't be longer than one EMC cycle) */
-
-#if 0
- if (g_em->crumbled_bitmap != NULL &&
- !(has_crumbled_graphics && crumbled != IMG_EMPTY_SPACE))
- printf("::: CRUMBLED CHANGES FOR tile %d [%s] [%d]\n",
- tile, EL_NAME(element), Ydirt_eat);
-#endif
-
- g_em->crumbled_bitmap = NULL;
- g_em->crumbled_src_x = 0;
- g_em->crumbled_src_y = 0;
-
- g_em->has_crumbled_graphics = FALSE;
-
- if (has_crumbled_graphics && crumbled != IMG_EMPTY_SPACE)
- {
- int frame_crumbled = getAnimationFrame(g_crumbled->anim_frames,
- g_crumbled->anim_delay,
- g_crumbled->anim_mode,
- g_crumbled->anim_start_frame,
- sync_frame);
-
- getGraphicSource(crumbled, frame_crumbled, &g_em->crumbled_bitmap,
- &g_em->crumbled_src_x, &g_em->crumbled_src_y);
-
- g_em->has_crumbled_graphics = TRUE;
- }
+ g_em->unique_identifier =
+ (graphic << 16) | ((frame % 8) << 12) | (g_em->width << 6) | g_em->height;
#endif
}
-#else
-
-void getGraphicSourceObjectExt_EM(int tile, int frame_em,
- Bitmap **src_bitmap, int *src_x, int *src_y,
- Bitmap **crumbled_src_bitmap,
- int *crumbled_src_x, int *crumbled_src_y,
- int x, int y)
+void getGraphicSourceObjectExt_EM(struct GraphicInfo_EM *g_em,
+ int tile, int frame_em, int x, int y)
{
- int element = object_mapping[tile].element_rnd;
- int action = object_mapping[tile].action;
- int direction = object_mapping[tile].direction;
- boolean is_backside = object_mapping[tile].is_backside;
- boolean action_removing = (action == ACTION_DIGGING ||
- action == ACTION_SNAPPING ||
- action == ACTION_COLLECTING);
- int effective_element = (frame_em > 0 ? element :
- is_backside ? EL_EMPTY :
- action_removing ? EL_EMPTY :
- element);
+ int action = object_mapping[tile].action;
+ int direction = object_mapping[tile].direction;
+ int effective_element = get_effective_element_EM(tile, frame_em);
int graphic = (direction == MV_NONE ?
el_act2img(effective_element, action) :
el_act_dir2img(effective_element, action, direction));
int base_crumbled = el_act2crm(effective_element, ACTION_DEFAULT);
boolean has_crumbled_graphics = (base_crumbled != base_graphic);
struct GraphicInfo *g = &graphic_info[graphic];
- struct GraphicInfo *g_crumbled = &graphic_info[crumbled];
- int sync_frame;
-
#if 0
- printf("::: GET: %d, %d: '%s'\n", x, y, EL_NAME(element));
+ struct GraphicInfo *g_crumbled = &graphic_info[crumbled];
#endif
+ int sync_frame;
#if 0
- if (GfxFrame[x][y] < 8)
- printf("::: %d, %d: %d [%s]\n", x, y, GfxFrame[x][y], EL_NAME(element));
-#endif
-
-#if 1
- if (frame_em == 7) /* reset animation frame for certain elements */
- {
- if (tile == Xboom_1 ||
- tile == Ybug_w_n ||
- tile == Ybug_n_e ||
- tile == Ybug_e_s ||
- tile == Ybug_s_w ||
- tile == Ybug_e_n ||
- tile == Ybug_s_e ||
- tile == Ybug_w_s ||
- tile == Ybug_n_w ||
- tile == Ytank_w_n ||
- tile == Ytank_n_e ||
- tile == Ytank_e_s ||
- tile == Ytank_s_w ||
- tile == Ytank_e_n ||
- tile == Ytank_s_e ||
- tile == Ytank_w_s ||
- tile == Ytank_n_w)
+ if (frame_em == 0) /* reset animation frame for certain elements */
+ {
+ if (check_linear_animation_EM(tile))
GfxFrame[x][y] = 0;
}
#endif
-#if 1
if (graphic_info[graphic].anim_global_sync)
sync_frame = FrameCounter;
else if (IN_FIELD(x, y, MAX_LEV_FIELDX, MAX_LEV_FIELDY))
sync_frame = GfxFrame[x][y];
else
- sync_frame = 0; /* steel border */
-#else
- if (graphic_info[graphic].anim_global_sync)
- sync_frame = FrameCounter;
- else
- sync_frame = 7 - frame_em;
-#endif
+ sync_frame = 0; /* playfield border (pseudo steel) */
SetRandomAnimationValue(x, y);
g->anim_start_frame,
sync_frame);
-#if 0
- if (graphic == IMG_DEFAULT_EXPLODING)
- printf("::: IMG_DEFAULT_EXPLODING: (%d, %d), %d => %d [%d]\n",
- tile, frame_em, sync_frame, frame, Xboom_1);
-#endif
-
- getGraphicSourceExt(graphic, frame, src_bitmap, src_x, src_y, FALSE);
-
-#if 0
- if (x == 1 && y == 1 && frame == 0)
- printf("--> %d, %d, %d\n", *crumbled_src_x, *crumbled_src_y, tile);
-#endif
-
-#if 0
- getGraphicSource(crumbled, frame, crumbled_src_bitmap,
- crumbled_src_x, crumbled_src_y);
-#endif
+ getGraphicSourceExt(graphic, frame, &g_em->bitmap,
+ &g_em->src_x, &g_em->src_y, FALSE);
-#if 1
/* (updating the "crumbled" graphic definitions is probably not really needed,
as animations for crumbled graphics can't be longer than one EMC cycle) */
+#if 1
+ set_crumbled_graphics_EM(g_em, has_crumbled_graphics, crumbled,
+ sync_frame);
+
+#else
+
+ g_em->crumbled_bitmap = NULL;
+ g_em->crumbled_src_x = 0;
+ g_em->crumbled_src_y = 0;
- *crumbled_src_bitmap = NULL;
- *crumbled_src_x = 0;
- *crumbled_src_y = 0;
+ g_em->has_crumbled_graphics = FALSE;
if (has_crumbled_graphics && crumbled != IMG_EMPTY_SPACE)
{
g_crumbled->anim_start_frame,
sync_frame);
- getGraphicSource(crumbled, frame_crumbled, crumbled_src_bitmap,
- crumbled_src_x, crumbled_src_y);
+ getGraphicSource(crumbled, frame_crumbled, &g_em->crumbled_bitmap,
+ &g_em->crumbled_src_x, &g_em->crumbled_src_y);
+
+ g_em->has_crumbled_graphics = TRUE;
}
#endif
}
-#endif
-
-void getGraphicSourcePlayerExt_EM(int player_nr, int anim, int frame_em,
- Bitmap **src_bitmap, int *src_x, int *src_y)
+void getGraphicSourcePlayerExt_EM(struct GraphicInfo_EM *g_em,
+ int player_nr, int anim, int frame_em)
{
int element = player_mapping[player_nr][anim].element_rnd;
int action = player_mapping[player_nr][anim].action;
InitPlayerGfxAnimation(&stored_player[player_nr], action, direction);
- stored_player[player_nr].StepFrame = 7 - frame_em;
+ stored_player[player_nr].StepFrame = frame_em;
sync_frame = stored_player[player_nr].Frame;
+ int frame = getAnimationFrame(g->anim_frames,
+ g->anim_delay,
+ g->anim_mode,
+ g->anim_start_frame,
+ sync_frame);
+
+ getGraphicSourceExt(graphic, frame, &g_em->bitmap,
+ &g_em->src_x, &g_em->src_y, FALSE);
+
#if 0
printf("::: %d: %d, %d [%d]\n",
player_nr,
stored_player[player_nr].StepFrame,
FrameCounter);
#endif
-
- int frame = getAnimationFrame(g->anim_frames,
- g->anim_delay,
- g->anim_mode,
- g->anim_start_frame,
- sync_frame);
-
- getGraphicSourceExt(graphic, frame, src_bitmap, src_x, src_y, FALSE);
}
void InitGraphicInfo_EM(void)
int action = object_mapping[i].action;
int direction = object_mapping[i].direction;
boolean is_backside = object_mapping[i].is_backside;
+#if 0
boolean action_removing = (action == ACTION_DIGGING ||
action == ACTION_SNAPPING ||
action == ACTION_COLLECTING);
+#endif
boolean action_exploding = ((action == ACTION_EXPLODING ||
action == ACTION_SMASHED_BY_ROCK ||
action == ACTION_SMASHED_BY_SPRING) &&
for (j = 0; j < 8; j++)
{
+#if 1
+ int effective_element = get_effective_element_EM(i, j);
+#else
int effective_element = (j > 5 && i == Yacid_splash_eB ? EL_EMPTY :
j > 5 && i == Yacid_splash_wB ? EL_EMPTY :
j < 7 ? element :
is_backside ? EL_EMPTY :
action_removing ? EL_EMPTY :
element);
+#endif
int effective_action = (j < 7 ? action :
i == Xdrip_stretch ? action :
i == Xdrip_stretchB ? action :
boolean has_action_graphics = (graphic != base_graphic);
boolean has_crumbled_graphics = (base_crumbled != base_graphic);
struct GraphicInfo *g = &graphic_info[graphic];
+#if 0
struct GraphicInfo *g_crumbled = &graphic_info[crumbled];
+#endif
struct GraphicInfo_EM *g_em = &graphic_info_em_object[i][7 - j];
Bitmap *src_bitmap;
int src_x, src_y;
g_em->width = TILEX;
g_em->height = TILEY;
+ g_em->preserve_background = FALSE;
+
+#if 1
+ set_crumbled_graphics_EM(g_em, has_crumbled_graphics, crumbled,
+ sync_frame);
+
+#else
+
g_em->crumbled_bitmap = NULL;
g_em->crumbled_src_x = 0;
g_em->crumbled_src_y = 0;
g_em->crumbled_border_size = 0;
g_em->has_crumbled_graphics = FALSE;
- g_em->preserve_background = FALSE;
#if 0
if (has_crumbled_graphics && crumbled == IMG_EMPTY_SPACE)
printf("::: EMC tile %d is crumbled\n", i);
#endif
}
+#endif
#if 0
if (element == EL_ROCK &&
projects / rocksndiamonds.git / blobdiff