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)
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;
}
#endif
-#if 1
+#if 0
if (fading.fade_mode == FADE_MODE_NONE)
{
BackToFront();
fade_mask = REDRAW_FIELD;
#endif
- if (fade_mask & REDRAW_FIELD)
+ // if (fade_mask & REDRAW_FIELD)
+ if (fade_mask == REDRAW_FIELD)
{
x = REAL_SX;
y = REAL_SY;
}
#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)
{
-#if 0
- global.border_status = game_status;
-#endif
-
-#if 1
- // printf("::: now fading in...\n");
-
if (fading.fade_mode & FADE_TYPE_TRANSFORM)
FadeExt(fade_mask, fading.fade_mode, FADE_TYPE_FADE_IN);
else
FadeExt(fade_mask, FADE_MODE_FADE_IN, FADE_TYPE_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
}
void FadeOut(int fade_mask)
{
-#if 1
- // printf("::: fading.fade_mode == %d\n", fading.fade_mode);
-
-#if 1
if (fading.fade_mode & FADE_TYPE_TRANSFORM)
FadeExt(fade_mask, fading.fade_mode, FADE_TYPE_FADE_OUT);
else
FadeExt(fade_mask, FADE_MODE_FADE_OUT, FADE_TYPE_FADE_OUT);
-#else
- if (fading.fade_mode & FADE_TYPE_TRANSFORM)
- FadeCrossSaveBackbuffer();
- else
- FadeExt(fade_mask, FADE_MODE_FADE_OUT, FADE_TYPE_FADE_OUT);
-#endif
-
-#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
-#if 1
global.border_status = game_status;
-#endif
}
-#if 0
-void FadeCross(int fade_mask)
-{
- FadeExt(fade_mask, FADE_MODE_CROSSFADE);
-}
-#endif
-
static void FadeSetLeaveNext(struct TitleFadingInfo fading_leave, boolean set)
{
static struct TitleFadingInfo fading_leave_stored;
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
+ },
+#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_sandstone_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);
-
-#if 0
- printf("::: SET: %d, %d: '%s'\n", x, y, EL_NAME(element));
-#endif
-
-#if 1
- if (action_removing)
- {
-#if 0
- printf("::: %d, %d: action_removing [%s]\n", x, y, EL_NAME(element));
-#endif
-
- GfxFrame[x][y] = 7 - frame_em;
+ 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 (action_removing || check_linear_animation_EM(tile))
+ {
+ GfxFrame[x][y] = frame_em;
}
- 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);
+ 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;
+ }
+
+#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(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));
+ 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);
- 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);
-#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 1
+ set_crumbled_graphics_EM(g_em, has_crumbled_graphics, crumbled,
+ sync_frame);
- *crumbled_src_bitmap = NULL;
- *crumbled_src_x = 0;
- *crumbled_src_y = 0;
+#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)
{
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
}
-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)
frame);
#endif
-
+#if 0
+ printf("::: EMC tile %d is crumbled\n", i);
+#endif
}
+#endif
#if 0
if (element == EL_ROCK &&