drawto_field = fieldbuffer;
}
- else /* DRAW_DIRECT, DRAW_BACKBUFFER */
+ else /* DRAW_BACKBUFFER */
{
FX = SX;
FY = SY;
redraw_x1 = 0;
redraw_y1 = 0;
- drawto_field = (mode == DRAW_DIRECT ? window : backbuffer);
+ drawto_field = backbuffer;
}
}
height = gfx.sysize + 2 * TILEY;
}
- if (force_redraw || setup.direct_draw)
+ if (force_redraw)
{
int xx, yy;
int x1 = (x - SX) / TILEX, y1 = (y - SY) / TILEY;
int x2 = (x - SX + width) / TILEX, y2 = (y - SY + height) / TILEY;
- if (setup.direct_draw)
- SetDrawtoField(DRAW_BACKBUFFER);
-
for (xx = BX1; xx <= BX2; xx++)
for (yy = BY1; yy <= BY2; yy++)
if (xx >= x1 && xx <= x2 && yy >= y1 && yy <= y2)
DrawScreenField(xx, yy);
DrawAllPlayers();
-
- if (setup.direct_draw)
- SetDrawtoField(DRAW_DIRECT);
}
if (setup.soft_scrolling)
void DrawMaskedBorder(int redraw_mask)
{
- /* do not draw masked screen borders when displaying title screens */
- if (effectiveGameStatus() == GAME_MODE_TITLE)
+ /* never draw masked screen borders on borderless screens */
+ if (effectiveGameStatus() == GAME_MODE_LOADING ||
+ effectiveGameStatus() == GAME_MODE_TITLE)
return;
if (redraw_mask & REDRAW_ALL)
int x,y;
DrawBuffer *buffer = (drawto_field == window ? backbuffer : drawto_field);
- if (setup.direct_draw && game_status == GAME_MODE_PLAYING)
- redraw_mask &= ~REDRAW_MAIN;
-
if (redraw_mask & REDRAW_TILES && redraw_tiles > REDRAWTILES_THRESHOLD)
redraw_mask |= REDRAW_FIELD;
redraw_mask = REDRAW_NONE;
}
-void FadeToFront()
+static void FadeCrossSaveBackbuffer()
{
-#if 0
- long fading_delay = 300;
-
- if (setup.fading && (redraw_mask & REDRAW_FIELD))
- {
-#endif
-
-#if 0
- int x,y;
+ BlitBitmap(backbuffer, bitmap_db_cross, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
+}
- ClearRectangle(window, REAL_SX,REAL_SY,FULL_SXSIZE,FULL_SYSIZE);
- FlushDisplay();
+static void FadeExt(int fade_mask, int fade_mode, int fade_type)
+{
+ static int fade_type_skip = FADE_TYPE_NONE;
+ void (*draw_border_function)(void) = NULL;
+ Bitmap *bitmap = (fade_mode & FADE_TYPE_TRANSFORM ? bitmap_db_cross : NULL);
+ int x, y, width, height;
+ int fade_delay, post_delay;
- for (i = 0; i < 2 * FULL_SYSIZE; i++)
+ if (fade_type == FADE_TYPE_FADE_OUT)
+ {
+ if (fade_type_skip != FADE_TYPE_NONE)
{
- for (y = 0; y < FULL_SYSIZE; y++)
- {
- BlitBitmap(backbuffer, window,
- REAL_SX,REAL_SY+i, FULL_SXSIZE,1, REAL_SX,REAL_SY+i);
- }
- FlushDisplay();
- Delay(10);
- }
-#endif
-
#if 0
- for (i = 1; i < FULL_SYSIZE; i+=2)
- BlitBitmap(backbuffer, window,
- REAL_SX,REAL_SY+i, FULL_SXSIZE,1, REAL_SX,REAL_SY+i);
- FlushDisplay();
- Delay(fading_delay);
+ printf("::: skipping %d ... [%d] (X)\n", fade_mode, fade_type_skip);
#endif
-#if 0
- SetClipOrigin(clip_gc[PIX_FADEMASK], 0, 0);
- BlitBitmapMasked(backbuffer, window,
- REAL_SX,REAL_SY, FULL_SXSIZE,FULL_SYSIZE,
- REAL_SX,REAL_SY);
- FlushDisplay();
- Delay(fading_delay);
-
- SetClipOrigin(clip_gc[PIX_FADEMASK], -1, -1);
- BlitBitmapMasked(backbuffer, window,
- REAL_SX,REAL_SY, FULL_SXSIZE,FULL_SYSIZE,
- REAL_SX,REAL_SY);
- FlushDisplay();
- Delay(fading_delay);
-
- SetClipOrigin(clip_gc[PIX_FADEMASK], 0, -1);
- BlitBitmapMasked(backbuffer, window,
- REAL_SX,REAL_SY, FULL_SXSIZE,FULL_SYSIZE,
- REAL_SX,REAL_SY);
- FlushDisplay();
- Delay(fading_delay);
-
- SetClipOrigin(clip_gc[PIX_FADEMASK], -1, 0);
- BlitBitmapMasked(backbuffer, window,
- REAL_SX,REAL_SY, FULL_SXSIZE,FULL_SYSIZE,
- REAL_SX,REAL_SY);
- FlushDisplay();
- Delay(fading_delay);
+ /* skip all fade operations until specified fade operation */
+ if (fade_type & fade_type_skip)
+ fade_type_skip = FADE_TYPE_NONE;
- redraw_mask &= ~REDRAW_MAIN;
- }
-#endif
+ return;
+ }
- BackToFront();
-}
+ if (fading.fade_mode & FADE_TYPE_TRANSFORM)
+ {
+ FadeCrossSaveBackbuffer();
-void FadeExt(int fade_mask, int fade_mode)
-{
- static int fade_mode_skip = FADE_MODE_NONE;
- void (*draw_border_function)(void) = NULL;
-#if 0
- Bitmap *bitmap = (fade_mode != FADE_MODE_FADE_IN ? bitmap_db_cross : NULL);
-#else
- Bitmap *bitmap = (fade_mode & FADE_TYPE_TRANSFORM ? bitmap_db_cross : NULL);
-#endif
- int x, y, width, height;
- int fade_delay, post_delay;
+ return;
+ }
+ }
redraw_mask |= fade_mask;
- if (fade_mode & FADE_TYPE_SKIP)
+ if (fade_type == FADE_TYPE_SKIP)
{
#if 0
- printf("::: will skip %d ... [%d]\n", fade_mode, fade_mode_skip);
+ printf("::: will skip %d ... [%d]\n", fade_mode, fade_type_skip);
#endif
- fade_mode_skip = fade_mode;
+ fade_type_skip = fade_mode;
return;
}
- if (fade_mode_skip & FADE_TYPE_SKIP)
+ if (fade_type_skip != FADE_TYPE_NONE)
{
#if 0
- printf("::: skipping %d ... [%d]\n", fade_mode, fade_mode_skip);
+ printf("::: skipping %d ... [%d]\n", fade_mode, fade_type_skip);
#endif
/* skip all fade operations until specified fade operation */
- if (fade_mode & fade_mode_skip)
- fade_mode_skip = FADE_MODE_NONE;
+ if (fade_type & fade_type_skip)
+ fade_type_skip = FADE_TYPE_NONE;
return;
}
}
#endif
-#if 1
+#if 0
if (fading.fade_mode == FADE_MODE_NONE)
{
BackToFront();
}
#endif
- if (fade_mask & REDRAW_FIELD)
+ /* !!! what abount fade_mask == REDRAW_FIELD | REDRAW_ALL ??? !!! */
+
+#if 0
+ printf("::: NOW FADING %d ... [%d]\n", fade_mode, fade_type);
+#endif
+
+#if 0
+ if (fade_mask == REDRAW_NONE)
+ fade_mask = REDRAW_FIELD;
+#endif
+
+ // if (fade_mask & REDRAW_FIELD)
+ if (fade_mask == REDRAW_FIELD)
{
x = REAL_SX;
y = REAL_SY;
fade_delay = fading.fade_delay;
post_delay = (fade_mode == FADE_MODE_FADE_OUT ? fading.post_delay : 0);
- draw_border_function = DrawMaskedBorder_FIELD;
+ if (border.draw_masked_when_fading)
+ draw_border_function = DrawMaskedBorder_FIELD; /* update when fading */
+ else
+ DrawMaskedBorder_FIELD(); /* draw once */
}
else /* REDRAW_ALL */
{
}
#if 1
- if (!setup.fade_screens || fade_delay == 0)
+ if (!setup.fade_screens ||
+ fade_delay == 0 ||
+ fading.fade_mode == FADE_MODE_NONE)
#else
- if (!setup.fade_screens || fade_delay == 0 || fading.anim_mode == ANIM_NONE)
+ if (!setup.fade_screens || fade_delay == 0)
#endif
{
if (fade_mode == FADE_MODE_FADE_OUT)
+ return;
+
+#if 0
+ if (fade_mode == FADE_MODE_FADE_OUT &&
+ fading.fade_mode != FADE_MODE_NONE)
ClearRectangle(backbuffer, x, y, width, height);
+#endif
+#if 1
+ BlitBitmap(backbuffer, window, x, y, width, height, x, y);
+ redraw_mask = REDRAW_NONE;
+#else
BackToFront();
+#endif
return;
}
void FadeIn(int fade_mask)
{
- global.border_status = game_status;
-
-#if 0
- global.fading_status = game_status;
-
- if (global.fading_type == TYPE_ENTER_MENU)
- fading = menu.enter_menu;
- else if (global.fading_type == TYPE_LEAVE_MENU)
- fading = menu.leave_menu;
- else if (global.fading_type == TYPE_ENTER_SCREEN)
- fading = menu.enter_screen[global.fading_status];
- else if (global.fading_type == TYPE_LEAVE_SCREEN)
- fading = menu.leave_screen[global.fading_status];
-
- printf("::: FadeIn: %s [0x%08x] [%d]\n",
- global.fading_type == TYPE_ENTER_MENU ? "enter_menu" :
- global.fading_type == TYPE_LEAVE_MENU ? "leave_menu" :
- global.fading_type == TYPE_ENTER_SCREEN ? "enter_screen" :
- global.fading_type == TYPE_LEAVE_SCREEN ? "leave_screen" : "(?)",
- global.fading_type,
- global.fading_status);
-#endif
-
-#if 1
- // printf("::: now fading in...\n");
-
if (fading.fade_mode & FADE_TYPE_TRANSFORM)
- FadeExt(fade_mask, fading.fade_mode);
+ FadeExt(fade_mask, fading.fade_mode, FADE_TYPE_FADE_IN);
else
- FadeExt(fade_mask, FADE_MODE_FADE_IN);
-#else
-#if 1
- if (fading.fade_mode == FADE_MODE_CROSSFADE)
- FadeExt(fade_mask, FADE_MODE_CROSSFADE);
- else
- FadeExt(fade_mask, FADE_MODE_FADE_IN);
-#else
- FadeExt(fade_mask, FADE_MODE_FADE_IN);
-#endif
-#endif
+ FadeExt(fade_mask, FADE_MODE_FADE_IN, FADE_TYPE_FADE_IN);
}
void FadeOut(int fade_mask)
{
-#if 0
- if (global.fading_type == TYPE_ENTER_MENU)
- fading = menu.enter_menu;
- else if (global.fading_type == TYPE_LEAVE_MENU)
- fading = menu.leave_menu;
- else if (global.fading_type == TYPE_ENTER_SCREEN)
- fading = menu.enter_screen[global.fading_status];
- else if (global.fading_type == TYPE_LEAVE_SCREEN)
- fading = menu.leave_screen[global.fading_status];
-
- printf("::: FadeOut: %s [0x%08x] [%d]\n",
- global.fading_type == TYPE_ENTER_MENU ? "enter_menu" :
- global.fading_type == TYPE_LEAVE_MENU ? "leave_menu" :
- global.fading_type == TYPE_ENTER_SCREEN ? "enter_screen" :
- global.fading_type == TYPE_LEAVE_SCREEN ? "leave_screen" : "(?)",
- global.fading_type,
- global.fading_status);
-#endif
-
-#if 1
- // printf("::: fading.fade_mode == %d\n", fading.fade_mode);
-
if (fading.fade_mode & FADE_TYPE_TRANSFORM)
- FadeCrossSaveBackbuffer();
+ FadeExt(fade_mask, fading.fade_mode, FADE_TYPE_FADE_OUT);
else
- FadeExt(fade_mask, FADE_MODE_FADE_OUT);
-#else
-#if 1
- if (fading.fade_mode == FADE_MODE_CROSSFADE)
- FadeCrossSaveBackbuffer();
- else
- FadeExt(fade_mask, FADE_MODE_FADE_OUT);
-#else
- FadeExt(fade_mask, FADE_MODE_FADE_OUT);
-#endif
-#endif
-}
-
-void FadeCross(int fade_mask)
-{
- FadeExt(fade_mask, FADE_MODE_CROSSFADE);
-}
-
-void FadeCrossSaveBackbuffer()
-{
- BlitBitmap(backbuffer, bitmap_db_cross, 0, 0, WIN_XSIZE, WIN_YSIZE, 0, 0);
-}
+ FadeExt(fade_mask, FADE_MODE_FADE_OUT, FADE_TYPE_FADE_OUT);
-#if 0
-void FadeSetEnterMenu()
-{
- global.fading_type = TYPE_ENTER_MENU;
-}
-
-void FadeSetLeaveMenu()
-{
- global.fading_type = TYPE_LEAVE_MENU;
-}
-
-void FadeSetEnterScreen()
-{
- global.fading_type = TYPE_ENTER_SCREEN;
-}
-
-void FadeSetLeaveScreen()
-{
- // global.fading_type = TYPE_LEAVE_SCREEN;
-
- global.fading_type = (global.fading_type == TYPE_ENTER_SCREEN ?
- TYPE_LEAVE_SCREEN : TYPE_LEAVE_MENU);
+ global.border_status = game_status;
}
-#else
-
static void FadeSetLeaveNext(struct TitleFadingInfo fading_leave, boolean set)
{
static struct TitleFadingInfo fading_leave_stored;
printf("::: storing leave_screen[%d]\n", game_status);
#endif
+ FadeSetLeaveNext(menu.leave_screen[game_status], TRUE); /* store */
+}
+
+void FadeSetNextScreen()
+{
+ fading = menu.next_screen;
+
#if 0
- printf("::: - %d, %d / %d, %d\n",
- menu.enter_screen[game_status].fade_mode,
- menu.enter_screen[game_status].fade_delay,
- menu.leave_screen[game_status].fade_mode,
- menu.leave_screen[game_status].fade_delay);
+ printf("::: storing next_screen\n");
#endif
- FadeSetLeaveNext(menu.leave_screen[game_status], TRUE); /* store */
+ // (do not overwrite fade mode set by FadeSetEnterScreen)
+ // FadeSetLeaveNext(fading, TRUE); /* (keep same fade mode) */
}
void FadeSetLeaveScreen()
FadeSetLeaveNext(menu.leave_screen[game_status], FALSE); /* recall */
}
-#endif
-
void FadeSetFromType(int type)
{
if (type & TYPE_ENTER_SCREEN)
void FadeSkipNextFadeIn()
{
- FadeExt(0, FADE_MODE_SKIP_FADE_IN);
+ FadeExt(0, FADE_MODE_SKIP_FADE_IN, FADE_TYPE_SKIP);
}
void FadeSkipNextFadeOut()
{
- FadeExt(0, FADE_MODE_SKIP_FADE_OUT);
+ FadeExt(0, FADE_MODE_SKIP_FADE_OUT, FADE_TYPE_SKIP);
}
void SetWindowBackgroundImageIfDefined(int graphic)
DrawBackground(x, y, width, height);
}
-void ClearWindow()
+void ClearField()
{
/* !!! "drawto" might still point to playfield buffer here (see above) !!! */
/* (when entering hall of fame after playing) */
}
else
SetDrawtoField(DRAW_BACKBUFFER);
-
- if (setup.direct_draw && game_status == GAME_MODE_PLAYING)
- {
- ClearRectangle(window, REAL_SX, REAL_SY, FULL_SXSIZE, FULL_SYSIZE);
- SetDrawtoField(DRAW_DIRECT);
- }
}
void MarkTileDirty(int x, int y)
int x,y;
SetDrawBackgroundMask(REDRAW_NONE);
- ClearWindow();
+ ClearField();
for (x = BX1; x <= BX2; x++)
for (y = BY1; y <= BY2; y++)
if (!IN_SCR_FIELD(sx, sy))
return;
- if (setup.direct_draw)
- SetDrawtoField(DRAW_BUFFERED);
-
/* ----------------------------------------------------------------------- */
/* draw things behind the player, if needed */
/* ----------------------------------------------------------------------- */
DrawLevelFieldThruMask(jx, jy);
}
- if (setup.direct_draw)
- {
- int dst_x = SX + SCREENX(MIN(jx, last_jx)) * TILEX;
- int dst_y = SY + SCREENY(MIN(jy, last_jy)) * TILEY;
- int x_size = TILEX * (1 + ABS(jx - last_jx));
- int y_size = TILEY * (1 + ABS(jy - last_jy));
-
- BlitBitmap(drawto_field, window,
- dst_x, dst_y, x_size, y_size, dst_x, dst_y);
- SetDrawtoField(DRAW_DIRECT);
- }
-
MarkTileDirty(sx, sy);
}
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 getGraphicSourceObjectExt_EM(int tile, int frame_em,
- Bitmap **src_bitmap, int *src_x, int *src_y,
- int x, int y)
+void SetGfxAnimation_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;
+ 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
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);
+ 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
+ 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 || check_linear_animation_EM(tile)) && frame_em == 0)
+ {
+ GfxFrame[x][y] = 0;
+
+ // printf("::: resetting... [%d]\n", tile);
+ }
+#else
+ if (action_removing || check_linear_animation_EM(tile))
+ {
+ GfxFrame[x][y] = frame_em;
+
+ // printf("::: resetting... [%d]\n", tile);
+ }
+#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)
+ GfxFrame[x - 1][y] = GfxFrame[x][y];
+ else if (move_dir == MV_RIGHT)
+ GfxFrame[x + 1][y] = GfxFrame[x][y];
+ else if (move_dir == MV_UP)
+ GfxFrame[x][y - 1] = GfxFrame[x][y];
+ else if (move_dir == MV_DOWN)
+ GfxFrame[x][y + 1] = GfxFrame[x][y];
+ }
+ }
+ else
+ {
+ GfxFrame[x][y]++;
+
+ /* 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]++;
+ }
+
+#if 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
+ 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; /* playfield border (pseudo steel) */
+
+ SetRandomAnimationValue(x, y);
+
+ int frame = getAnimationFrame(g->anim_frames,
+ g->anim_delay,
+ g->anim_mode,
+ g->anim_start_frame,
+ sync_frame);
+
+ g_em->unique_identifier =
+ (graphic << 16) | ((frame % 8) << 12) | (g_em->width << 6) | g_em->height;
+#endif
+}
+
+void getGraphicSourceObjectExt_EM(struct GraphicInfo_EM *g_em,
+ int tile, int frame_em, int x, int y)
+{
+ 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 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];
+#if 0
+ struct GraphicInfo *g_crumbled = &graphic_info[crumbled];
+#endif
int sync_frame;
+#if 0
+ if (frame_em == 0) /* reset animation frame for certain elements */
+ {
+ if (check_linear_animation_EM(tile))
+ GfxFrame[x][y] = 0;
+ }
+#endif
+
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 = 7 - frame_em;
+ sync_frame = 0; /* playfield border (pseudo steel) */
SetRandomAnimationValue(x, y);
g->anim_start_frame,
sync_frame);
- getGraphicSourceExt(graphic, frame, src_bitmap, src_x, src_y, FALSE);
+ getGraphicSourceExt(graphic, frame, &g_em->bitmap,
+ &g_em->src_x, &g_em->src_y, FALSE);
+
+ /* (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;
+
+ 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;
+ }
+#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)
#endif
/* if element can be crumbled, but certain action graphics are just empty
- space (like snapping sand with the original R'n'D graphics), do not
+ 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 (has_crumbled_graphics && crumbled != IMG_EMPTY_SPACE)
{
- getGraphicSource(crumbled, frame, &src_bitmap, &src_x, &src_y);
+ 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, &src_bitmap, &src_x, &src_y);
g_em->has_crumbled_graphics = TRUE;
g_em->crumbled_bitmap = src_bitmap;
g_em->crumbled_src_x = src_x;
g_em->crumbled_src_y = src_y;
g_em->crumbled_border_size = graphic_info[crumbled].border_size;
+
+
+#if 0
+ if (g_em == &graphic_info_em_object[207][0])
+ printf("... %d, %d [%d, %d, %d, %d] [%d, %d, %d, %d, %d, %d => %d]\n",
+ graphic_info_em_object[207][0].crumbled_src_x,
+ graphic_info_em_object[207][0].crumbled_src_y,
+
+ crumbled, frame, src_x, src_y,
+
+ g->anim_frames,
+ g->anim_delay,
+ g->anim_mode,
+ g->anim_start_frame,
+ sync_frame,
+ gfx.anim_random_frame,
+ frame);
+#endif
+
+#if 0
+ printf("::: EMC tile %d is crumbled\n", i);
+#endif
}
+#endif
#if 0
if (element == EL_ROCK &&