}
}
+#if 1
+
+static void RedrawPlayfield_RND()
+{
+ if (game.envelope_active)
+ return;
+
+#if 1
+ DrawLevel(REDRAW_ALL);
+#else
+ int x, y;
+
+ SetMainBackgroundImage(IMG_BACKGROUND_PLAYING);
+ // SetDrawBackgroundMask(REDRAW_FIELD); // !!! CHECK THIS !!!
+ SetDrawBackgroundMask(REDRAW_ALL); // !!! CHECK THIS !!!
+
+ for (x = BX1; x <= BX2; x++)
+ for (y = BY1; y <= BY2; y++)
+ DrawScreenField(x, y);
+
+ redraw_mask |= REDRAW_FIELD;
+#endif
+ DrawAllPlayers();
+
+#if 0
+#if NEW_TILESIZE
+ BlitScreenToBitmap(backbuffer);
+#else
+ /* blit playfield from scroll buffer to normal back buffer */
+ if (setup.soft_scrolling)
+ {
+ int fx = FX, fy = FY;
+
+ fx += (ScreenMovDir & (MV_LEFT|MV_RIGHT) ? ScreenGfxPos : 0);
+ fy += (ScreenMovDir & (MV_UP|MV_DOWN) ? ScreenGfxPos : 0);
+
+ BlitBitmap(fieldbuffer, backbuffer, fx,fy, SXSIZE,SYSIZE, SX,SY);
+ }
+#endif
+#endif
+}
+
+void RedrawPlayfield()
+{
+ if (game_status != GAME_MODE_PLAYING)
+ return;
+
+ if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
+ RedrawPlayfield_EM(TRUE);
+ else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
+ RedrawPlayfield_SP(TRUE);
+ else if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
+ RedrawPlayfield_RND();
+
+ BlitScreenToBitmap(backbuffer);
+
+ BlitBitmap(drawto, window, gfx.sx, gfx.sy, gfx.sxsize, gfx.sysize,
+ gfx.sx, gfx.sy);
+}
+
+#else
+
void RedrawPlayfield(boolean force_redraw, int x, int y, int width, int height)
{
if (game_status == GAME_MODE_PLAYING &&
BlitBitmap(drawto, window, x, y, width, height, x, y);
}
+#endif
+
void DrawMaskedBorder_Rect(int x, int y, int width, int height)
{
Bitmap *bitmap = graphic_info[IMG_GLOBAL_BORDER].bitmap;
}
}
-void BlitScreenToBitmap(Bitmap *target_bitmap)
+static void BlitScreenToBitmap_RND(Bitmap *target_bitmap)
{
DrawBuffer *buffer = (drawto_field == window ? backbuffer : drawto_field);
int fx = FX, fy = FY;
+ int full_lev_fieldx = lev_fieldx + (BorderElement != EL_EMPTY ? 2 : 0);
+ int full_lev_fieldy = lev_fieldy + (BorderElement != EL_EMPTY ? 2 : 0);
#if NEW_TILESIZE
int dx = (ScreenMovDir & (MV_LEFT | MV_RIGHT) ? ScreenGfxPos : 0);
fx, fy);
#endif
+#if 1
+ if (full_lev_fieldx <= SCR_FIELDX)
+ {
+ // printf(":1: PLAYFIELD FITS TO SCREEN [%d, %d, %d]\n", fx, ffx, dx_var);
+
+ if (EVEN(SCR_FIELDX))
+ fx = 2 * TILEX_VAR - (ODD(lev_fieldx) ? TILEX_VAR / 2 : 0);
+ else
+ fx = 2 * TILEX_VAR - (EVEN(lev_fieldx) ? TILEX_VAR / 2 : 0);
+
+ // printf(":2: PLAYFIELD FITS TO SCREEN [%d, %d, %d]\n", fx, ffx, dx_var);
+ }
+
+ if (full_lev_fieldy <= SCR_FIELDY)
+ {
+ if (EVEN(SCR_FIELDY))
+ fy = 2 * TILEY_VAR - (ODD(lev_fieldy) ? TILEY_VAR / 2 : 0);
+ else
+ fy = 2 * TILEY_VAR - (EVEN(lev_fieldy) ? TILEY_VAR / 2 : 0);
+ }
+#endif
+
if (border.draw_masked[GAME_MODE_PLAYING])
{
if (buffer != backbuffer)
}
}
+void BlitScreenToBitmap(Bitmap *target_bitmap)
+{
+ if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
+ BlitScreenToBitmap_EM(target_bitmap);
+ else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
+ BlitScreenToBitmap_SP(target_bitmap);
+ else if (level.game_engine_type == GAME_ENGINE_TYPE_RND)
+ BlitScreenToBitmap_RND(target_bitmap);
+}
+
void BackToFront()
{
int x, y;
else
{
#if 1
- BlitScreenToBitmap(window);
+ BlitScreenToBitmap_RND(window);
#else
int fx = FX, fy = FY;
ClearRectangle(backbuffer, x, y, width, height);
#endif
+#if 1
+
+#if 1
+ BlitBitmap(backbuffer, window, x, y, width, height, x, y);
+
+ redraw_mask &= ~fade_mask;
+#else
+ /* always redraw area that was explicitly marked to fade */
+ redraw_mask |= fade_mask;
+
+ BackToFront();
+#endif
+
+#else
+
#if 1
BlitBitmap(backbuffer, window, x, y, width, height, x, y);
redraw_mask = REDRAW_NONE;
+ // (^^^ WRONG; should be "redraw_mask &= ~fade_mask" if done this way)
#else
BackToFront();
+#endif
#endif
return;
int src_y = g->src_y + (get_backside ? g->offset2_y : 0);
#if NEW_TILESIZE
+
if (TILESIZE_VAR != TILESIZE)
return getSizedGraphicSourceExt(graphic, frame, TILESIZE_VAR, bitmap, x, y,
get_backside);
dst_x + xsize_size_left, dst_y + ysize_size_top);
#endif
-#if 1
+#if 0
redraw_mask = REDRAW_FIELD | REDRAW_FROM_BACKBUFFER;
// redraw_mask |= REDRAW_ALL | REDRAW_FROM_BACKBUFFER;
#else
+ /* CHECK AGAIN (previous code reactivated) */
redraw_mask |= REDRAW_FIELD | REDRAW_FROM_BACKBUFFER;
#endif
#if 1
if (game_status == GAME_MODE_PLAYING)
{
+#if 1
+#if 1
+ BlitScreenToBitmap(backbuffer);
+#else
+ if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
+ BlitScreenToBitmap_EM(backbuffer);
+ else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
+ BlitScreenToBitmap_SP(backbuffer);
+ else
+ BlitScreenToBitmap_RND(backbuffer);
+#endif
+#else
if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
BlitScreenToBitmap_EM(backbuffer);
else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
{
BlitBitmap(fieldbuffer, backbuffer, FX, FY, SXSIZE, SYSIZE, SX, SY);
}
+#endif
}
SetDrawtoField(DRAW_BACKBUFFER);
#if 1
// game_status = last_game_status; /* restore current game status */
+#if 1
+ /* !!! CHECK AGAIN (SEE BELOW) !!! */
+ game_status = last_game_status; /* restore current game status */
+#endif
+
if (action == ACTION_CLOSING)
{
if (game_status != GAME_MODE_MAIN)
// SetDrawBackgroundMask(last_draw_background_mask);
-#if 1
+#if 0
redraw_mask = REDRAW_FIELD;
// redraw_mask |= REDRAW_ALL;
#else
+ /* CHECK AGAIN (previous code reactivated) */
redraw_mask |= REDRAW_FIELD;
#endif
BackToFront();
+#if 0
/* (important: after "BackToFront()", but before "SetDrawtoField()") */
game_status = last_game_status; /* restore current game status */
+#endif
#if 1
if (action == ACTION_CLOSING &&
BlitBitmap(src_bitmap, drawto, src_x, src_y, tilesize, tilesize, dst_x,dst_y);
}
-void DrawLevel()
+void DrawLevel(int draw_background_mask)
{
int x,y;
+#if 1
+ SetMainBackgroundImage(IMG_BACKGROUND_PLAYING);
+ SetDrawBackgroundMask(draw_background_mask);
+#else
#if 1
SetMainBackgroundImage(IMG_BACKGROUND_PLAYING);
SetDrawBackgroundMask(REDRAW_FIELD);
#else
SetDrawBackgroundMask(REDRAW_NONE);
+#endif
#endif
ClearField();
if (game_status == GAME_MODE_PLAYING)
{
+#if 1
+ BlitScreenToBitmap(backbuffer);
+#else
if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
BlitScreenToBitmap_EM(backbuffer);
else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
BlitScreenToBitmap_SP(backbuffer);
+#endif
}
/* disable deactivated drawing when quick-loading level tape recording */
if (game_status == GAME_MODE_PLAYING)
{
+#if 1
+#if 1
+ BlitScreenToBitmap(backbuffer);
+#else
+ if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
+ BlitScreenToBitmap_EM(backbuffer);
+ else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
+ BlitScreenToBitmap_SP(backbuffer);
+ else
+ BlitScreenToBitmap_RND(backbuffer);
+#endif
+#else
if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
BlitScreenToBitmap_EM(backbuffer);
else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
BlitScreenToBitmap_SP(backbuffer);
+#endif
}
/* disable deactivated drawing when quick-loading level tape recording */
if (game_status == GAME_MODE_PLAYING)
{
+#if 1
+ BlitScreenToBitmap(backbuffer);
+#else
if (level.game_engine_type == GAME_ENGINE_TYPE_EM)
BlitScreenToBitmap_EM(backbuffer);
else if (level.game_engine_type == GAME_ENGINE_TYPE_SP)
BlitScreenToBitmap_SP(backbuffer);
+#endif
}
/* disable deactivated drawing when quick-loading level tape recording */
if (door_state & DOOR_ACTION)
{
boolean door_panel_drawn[NUM_DOORS];
+ boolean panel_has_doors[NUM_DOORS];
boolean door_part_skip[MAX_DOOR_PARTS];
boolean door_part_done[MAX_DOOR_PARTS];
boolean door_part_done_all;
int current_move_delay = 0;
int k;
+ for (i = 0; i < NUM_DOORS; i++)
+ panel_has_doors[i] = FALSE;
+
for (i = 0; i < MAX_DOOR_PARTS; i++)
{
struct DoorPartControlInfo *dpc = &door_part_controls[i];
struct DoorPartPosInfo *pos = dpc->pos;
struct GraphicInfo *g = &graphic_info[dpc->graphic];
int door_token = dpc->door_token;
+ int door_index = DOOR_INDEX_FROM_TOKEN(door_token);
boolean is_panel = DOOR_PART_IS_PANEL(nr);
int step_xoffset = ABS(pos->step_xoffset);
int step_yoffset = ABS(pos->step_yoffset);
if (door_part_skip[nr])
continue;
+ if (!is_panel)
+ panel_has_doors[door_index] = TRUE;
+
max_move_delay = MAX(max_move_delay, move_delay);
max_step_delay = (max_step_delay == 0 ? step_delay :
euclid(max_step_delay, step_delay));
door_part_done[nr] = TRUE;
#endif
+#if 1
+ // continue door part animations, but not panel after door has closed
+ if (!door_part_done[nr] &&
+ !(is_panel && door_closing && panel_has_doors[door_index]))
+ door_part_done_all = FALSE;
+#else
// continue door part animations, but not panel after door has closed
if (!door_part_done[nr] && !(is_panel && door_closing))
door_part_done_all = FALSE;
+#endif
#if 0
if (!door_part_done[nr])
int *door_2_x = (game_status == GAME_MODE_EDITOR ? &EX : &VX);
int *door_2_y = (game_status == GAME_MODE_EDITOR ? &EY : &VY);
#endif
+#if 1
+ int gfx_game_mode = game_status;
+#else
int gfx_game_mode = (game_status == GAME_MODE_PLAYING ||
game_status == GAME_MODE_EDITOR ? game_status :
GAME_MODE_MAIN);
+#endif
int gfx_game_mode2 = (game_status == GAME_MODE_EDITOR ? GAME_MODE_DEFAULT :
game_status);
struct RectWithBorder *vp_playfield = &viewport.playfield[gfx_game_mode];
boolean init_gfx_buffers = FALSE;
boolean init_video_buffer = FALSE;
boolean init_gadgets_and_toons = FALSE;
+ boolean init_em_graphics = FALSE;
#if 0
/* !!! TEST ONLY !!! */
#endif
)
{
+#if 1
+ if (new_tilesize_var != TILESIZE_VAR)
+ {
+ // printf("::: new_tilesize_var != TILESIZE_VAR\n");
+
+ // changing tile size invalidates scroll values of engine snapshots
+ FreeEngineSnapshot();
+
+ // changing tile size requires update of graphic mapping for EM engine
+ init_em_graphics = TRUE;
+ }
+#endif
+
SX = new_sx;
SY = new_sy;
DX = new_dx;
InitToons();
}
+ if (init_em_graphics)
+ {
+ InitGraphicInfo_EM();
+ }
+
#if 0
printf("::: %d, %d / %d, %d [%d]\n", VX, VY, EX, EY, game_status);
#endif