int screen_x, screen_y; /* current scroll position */
/* tiles currently on screen */
-static int screentiles[MAX_PLAYFIELD_HEIGHT + 2][MAX_PLAYFIELD_WIDTH + 2];
-static int crumbled_state[MAX_PLAYFIELD_HEIGHT + 2][MAX_PLAYFIELD_WIDTH + 2];
-static boolean redraw[MAX_PLAYFIELD_WIDTH + 2][MAX_PLAYFIELD_HEIGHT + 2];
+static int screentiles[MAX_PLAYFIELD_WIDTH + 2][MAX_PLAYFIELD_HEIGHT + 2];
+static int crumbled_state[MAX_PLAYFIELD_WIDTH + 2][MAX_PLAYFIELD_HEIGHT + 2];
-/* copy the entire screen to the window at the scroll position */
+int getFieldbufferOffsetX_EM(void)
+{
+ return screen_x % TILEX;
+}
+
+int getFieldbufferOffsetY_EM(void)
+{
+ return screen_y % TILEY;
+}
void BlitScreenToBitmap_EM(Bitmap *target_bitmap)
{
+ /* blit all (up to four) parts of the scroll buffer to the target bitmap */
+
int x = screen_x % (MAX_BUF_XSIZE * TILEX);
int y = screen_y % (MAX_BUF_YSIZE * TILEY);
- int sx, sy, sxsize, sysize;
int xsize = SXSIZE;
int ysize = SYSIZE;
int full_xsize = lev.width * TILEX;
int full_ysize = lev.height * TILEY;
-
- sxsize = (full_xsize < xsize ? full_xsize : xsize);
- sysize = (full_ysize < ysize ? full_ysize : ysize);
- sx = SX + (full_xsize < xsize ? (xsize - full_xsize) / 2 : 0);
- sy = SY + (full_ysize < ysize ? (ysize - full_ysize) / 2 : 0);
+ int sx = SX + (full_xsize < xsize ? (xsize - full_xsize) / 2 : 0);
+ int sy = SY + (full_ysize < ysize ? (ysize - full_ysize) / 2 : 0);
+ int sxsize = (full_xsize < xsize ? full_xsize : xsize);
+ int sysize = (full_ysize < ysize ? full_ysize : ysize);
if (x < 2 * TILEX && y < 2 * TILEY)
{
void BackToFront_EM(void)
{
- int x, y;
-
- /* blit all (up to four) parts of the scroll buffer to the backbuffer */
- BlitScreenToBitmap_EM(backbuffer);
-
- /* blit the completely updated backbuffer to the window (in one blit) */
BlitBitmap(backbuffer, window, SX, SY, SXSIZE, SYSIZE, SX, SY);
-
- for (x = 0; x < MAX_BUF_XSIZE; x++)
- for (y = 0; y < MAX_BUF_YSIZE; y++)
- redraw[x][y] = FALSE;
- redraw_tiles = 0;
-}
-
-void blitscreen(void)
-{
- BackToFront_EM();
}
static struct GraphicInfo_EM *getObjectGraphic(int x, int y)
{
- int tile = Draw[y][x];
+ int tile = Draw[x][y];
struct GraphicInfo_EM *g = &graphic_info_em_object[tile][frame];
if (!game.use_native_emc_graphics_engine)
g = getObjectGraphic(x, y);
- crumbled_border_size = g->crumbled_border_size * TILESIZE_VAR / TILESIZE;
+ crumbled_border_size =
+ g->crumbled_border_size * TILESIZE_VAR / g->crumbled_tile_size;
for (i = 0; i < 4; i++)
{
if (!game.use_native_emc_graphics_engine)
for (y = 2; y < EM_MAX_CAVE_HEIGHT - 2; y++)
for (x = 2; x < EM_MAX_CAVE_WIDTH - 2; x++)
- SetGfxAnimation_EM(&graphic_info_em_object[Draw[y][x]][frame],
- Draw[y][x], 7 - frame, x - 2, y - 2);
+ SetGfxAnimation_EM(&graphic_info_em_object[Draw[x][y]][frame],
+ Draw[x][y], 7 - frame, x - 2, y - 2);
for (y = top; y < top + MAX_BUF_YSIZE; y++)
{
{
int sx = x % MAX_BUF_XSIZE;
int sy = y % MAX_BUF_YSIZE;
- int tile = Draw[y][x];
+ int tile = Draw[x][y];
struct GraphicInfo_EM *g = &graphic_info_em_object[tile][frame];
int obj = g->unique_identifier;
int crm = 0;
yy < 0 || yy >= EM_MAX_CAVE_HEIGHT)
continue;
- tile_next = Draw[yy][xx];
+ tile_next = Draw[xx][yy];
if (!graphic_info_em_object[tile_next][frame].has_crumbled_graphics)
crm |= (1 << i);
}
}
- redraw_screen_tile = (screentiles[sy][sx] != obj ||
- crumbled_state[sy][sx] != crm);
+ redraw_screen_tile = (screentiles[sx][sy] != obj ||
+ crumbled_state[sx][sy] != crm);
/* only redraw screen tiles if they (or their crumbled state) changed */
if (redraw_screen_tile)
DrawLevelField_EM(x, y, sx, sy, FALSE);
DrawLevelFieldCrumbled_EM(x, y, sx, sy, crm, FALSE);
- screentiles[sy][sx] = obj;
- crumbled_state[sy][sx] = crm;
-
- redraw[sx][sy] = TRUE;
- redraw_tiles++;
+ screentiles[sx][sy] = obj;
+ crumbled_state[sx][sy] = crm;
}
}
}
int old_sy = old_y % MAX_BUF_YSIZE;
int new_sx = new_x % MAX_BUF_XSIZE;
int new_sy = new_y % MAX_BUF_YSIZE;
- int new_crm = crumbled_state[new_sy][new_sx];
+ int new_crm = crumbled_state[new_sx][new_sy];
/* only diggable elements can be crumbled in the classic EM engine */
boolean player_is_digging = (new_crm != 0);
}
/* redraw screen tiles in the next frame (player may have left the tiles) */
- screentiles[old_sy][old_sx] = -1;
- screentiles[new_sy][new_sx] = -1;
-
- /* mark screen tiles as dirty (force screen refresh with changed content) */
- redraw[old_sx][old_sy] = TRUE;
- redraw[new_sx][new_sy] = TRUE;
- redraw_tiles += 2;
+ screentiles[old_sx][old_sy] = -1;
+ screentiles[new_sx][new_sy] = -1;
}
}
{
for (x = 0; x < MAX_BUF_XSIZE; x++)
{
- screentiles[y][x] = -1;
- crumbled_state[y][x] = 0;
+ screentiles[x][y] = -1;
+ crumbled_state[x][y] = 0;
}
}
}
}
}
-boolean checkIfAllPlayersFitToScreen()
+boolean checkIfAllPlayersFitToScreen(void)
{
int sx1 = 0, sy1 = 0, sx2 = 0, sy2 = 0;
int max_center_distance_player_nr =
getMaxCenterDistancePlayerNr(screen_x, screen_y);
int stepsize = TILEX / 8;
- int offset = game.scroll_delay_value * TILEX;
- int offset_x = offset;
- int offset_y = offset;
+ int offset_raw = game.scroll_delay_value;
+ int offset_x = MIN(offset_raw, (SCR_FIELDX - 2) / 2) * TILEX;
+ int offset_y = MIN(offset_raw, (SCR_FIELDY - 2) / 2) * TILEY;
int screen_x_old = screen_x;
int screen_y_old = screen_y;
int x, y, sx, sy;
if (game.centered_player_nr == -1)
{
- if (draw_new_player_location || offset == 0)
+ if (draw_new_player_location || offset_raw == 0)
{
setScreenCenteredToAllPlayers(&sx, &sy);
}
for (i = 0; i < MAX_PLAYERS; i++)
blitplayer(&ply[i]);
- blitscreen();
+ BlitScreenToBitmap_EM(backbuffer);
+ BackToFront_EM();
Delay(wait_delay_value);
for (i = 0; i < MAX_PLAYERS; i++)
blitplayer(&ply[i]);
- blitscreen();
+ BlitScreenToBitmap_EM(backbuffer);
+ BackToFront_EM();
Delay(wait_delay_value);
}
{
for (x = 0; x < MAX_BUF_XSIZE; x++)
{
- screentiles[y][x] = -1;
- crumbled_state[y][x] = 0;
+ screentiles[x][y] = -1;
+ crumbled_state[x][y] = 0;
}
}
}
screen_y = screen_y_old;
}
+ // skip redrawing playfield in warp mode or when testing tapes with "autotest"
+ if (DrawingDeactivatedField())
+ return;
+
animscreen();
for (i = 0; i < MAX_PLAYERS; i++)
blitplayer(&ply[i]);
}
-
-void game_animscreen(void)
-{
- RedrawPlayfield_EM(FALSE);
-}