X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Fgame_em%2Fgraphics.c;h=398ae6e0e303254f319e69931debc5d4b8b0b291;hb=HEAD;hp=12c621809b2f589440727cddabcc2e7b525643d9;hpb=3ff2e8a0b5c27b99a9920bdf5ed82bc41bf40181;p=rocksndiamonds.git

diff --git a/src/game_em/graphics.c b/src/game_em/graphics.c
index 12c62180..a3e941a5 100644
--- a/src/game_em/graphics.c
+++ b/src/game_em/graphics.c
@@ -5,10 +5,15 @@
 
 #include "main_em.h"
 
-#define MIN_SCREEN_XPOS		1
-#define MIN_SCREEN_YPOS		1
-#define MAX_SCREEN_XPOS		MAX(1, lev.width  - (SCR_FIELDX - 1))
-#define MAX_SCREEN_YPOS		MAX(1, lev.height - (SCR_FIELDY - 1))
+#define MIN_SCREEN_XPOS_RAW	0
+#define MIN_SCREEN_YPOS_RAW	0
+#define MAX_SCREEN_XPOS_RAW	MAX(0, lev.width  - SCR_FIELDX)
+#define MAX_SCREEN_YPOS_RAW	MAX(0, lev.height - SCR_FIELDY)
+
+#define MIN_SCREEN_XPOS		(MIN_SCREEN_XPOS_RAW + CAVE_BUFFER_XOFFSET)
+#define MIN_SCREEN_YPOS		(MIN_SCREEN_YPOS_RAW + CAVE_BUFFER_YOFFSET)
+#define MAX_SCREEN_XPOS		(MAX_SCREEN_XPOS_RAW + CAVE_BUFFER_XOFFSET)
+#define MAX_SCREEN_YPOS		(MAX_SCREEN_YPOS_RAW + CAVE_BUFFER_YOFFSET)
 
 #define MIN_SCREEN_X		(MIN_SCREEN_XPOS * TILEX)
 #define MIN_SCREEN_Y		(MIN_SCREEN_YPOS * TILEY)
@@ -20,12 +25,15 @@
 #define VALID_SCREEN_Y(y)	((y) < MIN_SCREEN_Y ? MIN_SCREEN_Y :	\
 				 (y) > MAX_SCREEN_Y ? MAX_SCREEN_Y : (y))
 
-#define PLAYER_SCREEN_X(p)	(((    frame) * ply[p].oldx +		\
-				  (8 - frame) * ply[p].x) * TILEX / 8	\
-				 - ((SCR_FIELDX - 1) * TILEX) / 2)
-#define PLAYER_SCREEN_Y(p)	(((    frame) * ply[p].oldy +		\
-				  (8 - frame) * ply[p].y) * TILEY / 8	\
-				 - ((SCR_FIELDY - 1) * TILEY) / 2)
+#define PLAYER_POS_X(nr)	(((7 - frame) * ply[nr].prev_x +	\
+				  (1 + frame) * ply[nr].x) * TILEX / 8)
+#define PLAYER_POS_Y(nr)	(((7 - frame) * ply[nr].prev_y +	\
+				  (1 + frame) * ply[nr].y) * TILEY / 8)
+
+#define PLAYER_SCREEN_X(nr)	(PLAYER_POS_X(nr) -			\
+				 (SCR_FIELDX - 1) * TILEX / 2)
+#define PLAYER_SCREEN_Y(nr)	(PLAYER_POS_Y(nr) -			\
+				 (SCR_FIELDY - 1) * TILEY / 2)
 
 #define USE_EXTENDED_GRAPHICS_ENGINE		1
 
@@ -34,149 +42,96 @@ int frame;				/* current screen frame */
 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 screen_tiles[MAX_PLAYFIELD_WIDTH + 2][MAX_PLAYFIELD_HEIGHT + 2];
+static int crumbled_state[MAX_PLAYFIELD_WIDTH + 2][MAX_PLAYFIELD_HEIGHT + 2];
+
+/* graphic info for game objects/frames and players/actions/frames */
+struct GraphicInfo_EM graphic_info_em_object[GAME_TILE_MAX][8];
+struct GraphicInfo_EM graphic_info_em_player[MAX_PLAYERS][PLY_MAX][8];
+
+static struct XY xy_topdown[] =
+{
+  {  0, -1 },
+  { -1,  0 },
+  { +1,  0 },
+  {  0, +1 }
+};
+
+static void setScreenCenteredToAllPlayers(int *, int *);
 
-/* 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);
-
-  if (x < 2 * TILEX && y < 2 * TILEY)
+  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);
+  int xxsize = MAX_BUF_XSIZE * TILEX - x;
+  int yysize = MAX_BUF_YSIZE * TILEY - y;
+  int xoffset = 2 * CAVE_BUFFER_XOFFSET * TILEX;
+  int yoffset = 2 * CAVE_BUFFER_YOFFSET * TILEY;
+
+  if (x < xoffset && y < yoffset)
   {
-    BlitBitmap(screenBitmap, target_bitmap, x, y,
-	       sxsize, sysize, sx, sy);
-  }
-  else if (x < 2 * TILEX && y >= 2 * TILEY)
-  {
-    BlitBitmap(screenBitmap, target_bitmap, x, y,
-	       sxsize, MAX_BUF_YSIZE * TILEY - y,
+    BlitBitmap(screenBitmap, target_bitmap, x, y, sxsize, sysize,
 	       sx, sy);
-    BlitBitmap(screenBitmap, target_bitmap, x, 0,
-	       sxsize, y - 2 * TILEY,
-	       sx, sy + MAX_BUF_YSIZE * TILEY - y);
   }
-  else if (x >= 2 * TILEX && y < 2 * TILEY)
+  else if (x < xoffset && y >= yoffset)
   {
-    BlitBitmap(screenBitmap, target_bitmap, x, y,
-	       MAX_BUF_XSIZE * TILEX - x, sysize,
+    BlitBitmap(screenBitmap, target_bitmap, x, y, sxsize, yysize,
 	       sx, sy);
-    BlitBitmap(screenBitmap, target_bitmap, 0, y,
-	       x - 2 * TILEX, sysize,
-	       sx + MAX_BUF_XSIZE * TILEX - x, sy);
+    BlitBitmap(screenBitmap, target_bitmap, x, 0, sxsize, y - yoffset,
+	       sx, sy + yysize);
   }
-  else
+  else if (x >= xoffset && y < yoffset)
   {
-    BlitBitmap(screenBitmap, target_bitmap, x, y,
-	       MAX_BUF_XSIZE * TILEX - x, MAX_BUF_YSIZE * TILEY - y,
+    BlitBitmap(screenBitmap, target_bitmap, x, y, xxsize, sysize,
 	       sx, sy);
-    BlitBitmap(screenBitmap, target_bitmap, 0, y,
-	       x - 2 * TILEX, MAX_BUF_YSIZE * TILEY - y,
-	       sx + MAX_BUF_XSIZE * TILEX - x, sy);
-    BlitBitmap(screenBitmap, target_bitmap, x, 0,
-	       MAX_BUF_XSIZE * TILEX - x, y - 2 * TILEY,
-	       sx, sy + MAX_BUF_YSIZE * TILEY - y);
-    BlitBitmap(screenBitmap, target_bitmap, 0, 0,
-	       x - 2 * TILEX, y - 2 * TILEY,
-	       sx + MAX_BUF_XSIZE * TILEX - x, sy + MAX_BUF_YSIZE * TILEY - y);
-  }
-}
-
-void BackToFront_EM(void)
-{
-  static int screen_x_last = -1, screen_y_last = -1;
-  static boolean scrolling_last = FALSE;
-  int left = screen_x / TILEX;
-  int top  = screen_y / TILEY;
-  boolean scrolling = (screen_x != screen_x_last || screen_y != screen_y_last);
-  int x, y;
-
-  SyncDisplay();
-
-  if (redraw_tiles > REDRAWTILES_THRESHOLD || scrolling || scrolling_last)
-  {
-    /* 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);
+    BlitBitmap(screenBitmap, target_bitmap, 0, y, x - xoffset, sysize,
+	       sx + xxsize, sy);
   }
   else
   {
-    boolean half_shifted_x = (screen_x % TILEX != 0);
-    boolean half_shifted_y = (screen_y % TILEY != 0);
-
-    int sx, sy;
-    int xsize = SXSIZE;
-    int ysize = SYSIZE;
-    int full_xsize = lev.width  * TILEX;
-    int full_ysize = lev.height * TILEY;
-
-    sx = SX + (full_xsize < xsize ? (xsize - full_xsize) / 2 : 0);
-    sy = SY + (full_ysize < ysize ? (ysize - full_ysize) / 2 : 0);
-
-    int x1 = 0, x2 = SCR_FIELDX - (half_shifted_x ? 0 : 1);
-    int y1 = 0, y2 = SCR_FIELDY - (half_shifted_y ? 0 : 1);
-    int scroll_xoffset = (half_shifted_x ? TILEX / 2 : 0);
-    int scroll_yoffset = (half_shifted_y ? TILEY / 2 : 0);
-
-    InitGfxClipRegion(TRUE, SX, SY, SXSIZE, SYSIZE);
-
-    for (x = x1; x <= x2; x++)
-    {
-      for (y = y1; y <= y2; y++)
-      {
-	int xx = (left + x) % MAX_BUF_XSIZE;
-	int yy = (top  + y) % MAX_BUF_YSIZE;
-
-	if (redraw[xx][yy])
-	  BlitBitmap(screenBitmap, window,
-		     xx * TILEX, yy * TILEY, TILEX, TILEY,
-		     sx + x * TILEX - scroll_xoffset,
-		     sy + y * TILEY - scroll_yoffset);
-      }
-    }
-
-    InitGfxClipRegion(FALSE, -1, -1, -1, -1);
+    BlitBitmap(screenBitmap, target_bitmap, x, y, xxsize, yysize,
+	       sx, sy);
+    BlitBitmap(screenBitmap, target_bitmap, 0, y, x - xoffset, yysize,
+	       sx + xxsize, sy);
+    BlitBitmap(screenBitmap, target_bitmap, x, 0, xxsize, y - yoffset,
+	       sx, sy + yysize);
+    BlitBitmap(screenBitmap, target_bitmap, 0, 0, x - xoffset, y - yoffset,
+	       sx + xxsize, sy + yysize);
   }
-
-  FlushDisplay();
-
-  for (x = 0; x < MAX_BUF_XSIZE; x++)
-    for (y = 0; y < MAX_BUF_YSIZE; y++)
-      redraw[x][y] = FALSE;
-  redraw_tiles = 0;
-
-  screen_x_last = screen_x;
-  screen_y_last = screen_y;
-  scrolling_last = scrolling;
 }
 
-void blitscreen(void)
+static void BackToFront_EM(void)
 {
-  BackToFront_EM();
+  BlitBitmap(backbuffer, window, SX, SY, SXSIZE, SYSIZE, SX, SY);
 }
 
 static struct GraphicInfo_EM *getObjectGraphic(int x, int y)
 {
-  int tile = Draw[y][x];
+  int tile = lev.draw[x][y];
   struct GraphicInfo_EM *g = &graphic_info_em_object[tile][frame];
 
   if (!game.use_native_emc_graphics_engine)
-    getGraphicSourceObjectExt_EM(g, tile, 7 - frame, x - 2, y - 2);
+    getGraphicSourceObjectExt_EM(g, tile, frame, x - lev.left, y - lev.top);
 
   return g;
 }
@@ -186,7 +141,7 @@ static struct GraphicInfo_EM *getPlayerGraphic(int player_nr, int anim)
   struct GraphicInfo_EM *g = &graphic_info_em_player[player_nr][anim][frame];
 
   if (!game.use_native_emc_graphics_engine)
-    getGraphicSourcePlayerExt_EM(g, player_nr, anim, 7 - frame);
+    getGraphicSourcePlayerExt_EM(g, player_nr, anim, frame);
 
   return g;
 }
@@ -212,12 +167,8 @@ static void DrawLevelField_EM(int x, int y, int sx, int sy,
   if (draw_masked)
   {
     if (width > 0 && height > 0)
-    {
-      SetClipOrigin(g->bitmap, g->bitmap->stored_clip_gc,
-		    dst_x - src_x, dst_y - src_y);
       BlitBitmapMasked(g->bitmap, screenBitmap,
 		       src_x, src_y, width, height, dst_x, dst_y);
-    }
   }
   else
   {
@@ -249,7 +200,8 @@ static void DrawLevelFieldCrumbled_EM(int x, int y, int sx, int sy,
 
   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++)
   {
@@ -280,12 +232,8 @@ static void DrawLevelFieldCrumbled_EM(int x, int y, int sx, int sy,
 	int dst_y = sy * TILEY + cy;
 
 	if (draw_masked)
-	{
-	  SetClipOrigin(g->crumbled_bitmap, g->crumbled_bitmap->stored_clip_gc,
-			dst_x - src_x, dst_y - src_y);
 	  BlitBitmapMasked(g->crumbled_bitmap, screenBitmap,
 			   src_x, src_y, width, height, dst_x, dst_y);
-	}
 	else
 	  BlitBitmap(g->crumbled_bitmap, screenBitmap,
 		     src_x, src_y, width, height, dst_x, dst_y);
@@ -314,24 +262,18 @@ static void DrawLevelPlayer_EM(int x1, int y1, int player_nr, int anim,
     /* draw the player to current location */
     dst_x = x1;
     dst_y = y1;
-    SetClipOrigin(g->bitmap, g->bitmap->stored_clip_gc,
-		  dst_x - src_x, dst_y - src_y);
     BlitBitmapMasked(g->bitmap, screenBitmap,
 		     src_x, src_y, TILEX, TILEY, dst_x, dst_y);
 
     /* draw the player to opposite wrap-around column */
     dst_x = x1 - MAX_BUF_XSIZE * TILEX;
     dst_y = y1;
-    SetClipOrigin(g->bitmap, g->bitmap->stored_clip_gc,
-		  dst_x - src_x, dst_y - src_y);
     BlitBitmapMasked(g->bitmap, screenBitmap,
 		     g->src_x, g->src_y, TILEX, TILEY, dst_x, dst_y);
 
     /* draw the player to opposite wrap-around row */
     dst_x = x1;
     dst_y = y1 - MAX_BUF_YSIZE * TILEY;
-    SetClipOrigin(g->bitmap, g->bitmap->stored_clip_gc,
-		  dst_x - src_x, dst_y - src_y);
     BlitBitmapMasked(g->bitmap, screenBitmap,
 		     g->src_x, g->src_y, TILEX, TILEY, dst_x, dst_y);
   }
@@ -367,19 +309,14 @@ static void animscreen(void)
   int x, y, i;
   int left = screen_x / TILEX;
   int top  = screen_y / TILEY;
-  static int xy[4][2] =
-  {
-    { 0, -1 },
-    { -1, 0 },
-    { +1, 0 },
-    { 0, +1 }
-  };
+  struct XY *xy = xy_topdown;
 
   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);
+    for (y = lev.top; y < lev.bottom; y++)
+      for (x = lev.left; x < lev.right; x++)
+	SetGfxAnimation_EM(&graphic_info_em_object[lev.draw[x][y]][frame],
+			   lev.draw[x][y], frame,
+			   x - lev.left, y - lev.top);
 
   for (y = top; y < top + MAX_BUF_YSIZE; y++)
   {
@@ -387,7 +324,7 @@ static void animscreen(void)
     {
       int sx = x % MAX_BUF_XSIZE;
       int sy = y % MAX_BUF_YSIZE;    
-      int tile = Draw[y][x];
+      int tile = lev.draw[x][y];
       struct GraphicInfo_EM *g = &graphic_info_em_object[tile][frame];
       int obj = g->unique_identifier;
       int crm = 0;
@@ -398,23 +335,23 @@ static void animscreen(void)
       {
 	for (i = 0; i < 4; i++)
 	{
-	  int xx = x + xy[i][0];
-	  int yy = y + xy[i][1];
+	  int xx = x + xy[i].x;
+	  int yy = y + xy[i].y;
 	  int tile_next;
 
-	  if (xx < 0 || xx >= EM_MAX_CAVE_WIDTH ||
-	      yy < 0 || yy >= EM_MAX_CAVE_HEIGHT)
+	  if (xx < 0 || xx >= CAVE_BUFFER_WIDTH ||
+	      yy < 0 || yy >= CAVE_BUFFER_HEIGHT)
 	    continue;
 
-	  tile_next = Draw[yy][xx];
+	  tile_next = lev.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 = (screen_tiles[sx][sy]   != obj ||
+			    crumbled_state[sx][sy] != crm);
 
       /* only redraw screen tiles if they (or their crumbled state) changed */
       if (redraw_screen_tile)
@@ -422,11 +359,8 @@ static void animscreen(void)
 	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++;
+	screen_tiles[sx][sy] = obj;
+	crumbled_state[sx][sy] = crm;
       }
     }
   }
@@ -438,16 +372,16 @@ static void animscreen(void)
  * handles transparency and movement
  */
 
-static void blitplayer(struct PLAYER *ply)
+static void blitplayer_ext(int nr)
 {
   int x1, y1, x2, y2;
 
-  if (!ply->alive)
+  if (!ply[nr].alive)
     return;
 
   /* x1/y1 are left/top and x2/y2 are right/down part of the player movement */
-  x1 = (frame * ply->oldx + (8 - frame) * ply->x) * TILEX / 8;
-  y1 = (frame * ply->oldy + (8 - frame) * ply->y) * TILEY / 8;
+  x1 = PLAYER_POS_X(nr);
+  y1 = PLAYER_POS_Y(nr);
   x2 = x1 + TILEX - 1;
   y2 = y1 + TILEY - 1;
 
@@ -455,17 +389,17 @@ static void blitplayer(struct PLAYER *ply)
       (int)(y2 - screen_y) < ((MAX_BUF_YSIZE - 1) * TILEY - 1))
   {
     /* some casts to "int" are needed because of negative calculation values */
-    int dx = (int)ply->x - (int)ply->oldx;
-    int dy = (int)ply->y - (int)ply->oldy;
-    int old_x = (int)ply->oldx + (7 - (int)frame) * dx / 8;
-    int old_y = (int)ply->oldy + (7 - (int)frame) * dy / 8;
+    int dx = (int)ply[nr].x - (int)ply[nr].prev_x;
+    int dy = (int)ply[nr].y - (int)ply[nr].prev_y;
+    int old_x = (int)ply[nr].prev_x + (int)frame * dx / 8;
+    int old_y = (int)ply[nr].prev_y + (int)frame * dy / 8;
     int new_x = old_x + SIGN(dx);
     int new_y = old_y + SIGN(dy);
     int old_sx = old_x % MAX_BUF_XSIZE;
     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);
@@ -477,7 +411,7 @@ static void blitplayer(struct PLAYER *ply)
       DrawLevelFieldCrumbled_EM(new_x, new_y, new_sx, new_sy, new_crm, FALSE);
 
       /* draw the player (masked) over the element he is just digging away */
-      DrawLevelPlayer_EM(x1, y1, ply->num, ply->anim, TRUE);
+      DrawLevelPlayer_EM(x1, y1, ply[nr].num, ply[nr].anim, TRUE);
 
       /* draw the field the player is moving from (masked over the player) */
       DrawLevelField_EM(old_x, old_y, old_sx, old_sy, TRUE);
@@ -485,7 +419,7 @@ static void blitplayer(struct PLAYER *ply)
     else
     {
       /* draw the player under the element which is on the same field */
-      DrawLevelPlayer_EM(x1, y1, ply->num, ply->anim, FALSE);
+      DrawLevelPlayer_EM(x1, y1, ply[nr].num, ply[nr].anim, FALSE);
 
       /* draw the field the player is moving from (masked over the player) */
       DrawLevelField_EM(old_x, old_y, old_sx, old_sy, TRUE);
@@ -495,34 +429,67 @@ static void blitplayer(struct PLAYER *ply)
     }
 
     /* 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;
+    screen_tiles[old_sx][old_sy] = -1;
+    screen_tiles[new_sx][new_sy] = -1;
+  }
+}
+
+static void blitplayer(int nr)
+{
+  blitplayer_ext(nr);
+
+  /* check for wrap-around movement ... */
+  if (ply[nr].x < lev.left ||
+      ply[nr].x > lev.right - 1)
+  {
+    struct PLAYER ply_last = ply[nr];
+    int direction = (ply[nr].x < lev.left ? -1 : 1);
+    int dx = ply[nr].x - ply[nr].prev_x;
+
+    ply[nr].x += -direction * lev.width;
+    ply[nr].prev_x = ply[nr].x - dx;
 
-    /* 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;
+    if (!lev.infinite_true)
+    {
+      int dy = ply[nr].y - ply[nr].prev_y;
+
+      ply[nr].y += direction;
+      ply[nr].prev_y = ply[nr].y - dy;
+    }
+
+    /* draw player entering playfield from the opposite side */
+    blitplayer_ext(nr);
+
+    /* ... but keep the old player position until game logic */
+    ply[nr] = ply_last;
   }
 }
 
 void game_initscreen(void)
 {
-  int player_nr;
-  int x,y;
+  int x, y, sx, sy;
 
-  frame = 6;
+  frame = 1;
 
-  player_nr = (game.centered_player_nr != -1 ? game.centered_player_nr : 0);
+  if (game.centered_player_nr == -1)
+  {
+    setScreenCenteredToAllPlayers(&sx, &sy);
+  }
+  else
+  {
+    sx = PLAYER_SCREEN_X(game.centered_player_nr);
+    sy = PLAYER_SCREEN_Y(game.centered_player_nr);
+  }
 
-  screen_x = VALID_SCREEN_X(PLAYER_SCREEN_X(player_nr));
-  screen_y = VALID_SCREEN_Y(PLAYER_SCREEN_Y(player_nr));
+  screen_x = VALID_SCREEN_X(sx);
+  screen_y = VALID_SCREEN_Y(sy);
 
   for (y = 0; y < MAX_BUF_YSIZE; y++)
   {
     for (x = 0; x < MAX_BUF_XSIZE; x++)
     {
-      screentiles[y][x] = -1;
-      crumbled_state[y][x] = 0;
+      screen_tiles[x][y] = -1;
+      crumbled_state[x][y] = 0;
     }
   }
 }
@@ -585,14 +552,16 @@ static void setMinimalPlayerBoundaries(int *sx1, int *sy1, int *sx2, int *sy2)
   }
 }
 
-boolean checkIfAllPlayersFitToScreen()
+boolean checkIfAllPlayersFitToScreen(void)
 {
   int sx1 = 0, sy1 = 0, sx2 = 0, sy2 = 0;
+  int scr_fieldx = getScreenFieldSizeX();
+  int scr_fieldy = getScreenFieldSizeY();
 
   setMinimalPlayerBoundaries(&sx1, &sy1, &sx2, &sy2);
 
-  return (sx2 - sx1 <= SCR_FIELDX * TILEX &&
-	  sy2 - sy1 <= SCR_FIELDY * TILEY);
+  return (sx2 - sx1 <= scr_fieldx * TILEX &&
+	  sy2 - sy1 <= scr_fieldy * TILEY);
 }
 
 static void setScreenCenteredToAllPlayers(int *sx, int *sy)
@@ -629,13 +598,14 @@ static boolean checkIfAllPlayersAreVisible(int center_x, int center_y)
 void RedrawPlayfield_EM(boolean force_redraw)
 {
   boolean draw_new_player_location = FALSE;
+  boolean draw_new_player_location_wrap = FALSE;
   boolean quick_relocation = setup.quick_switch;
   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;
@@ -667,14 +637,16 @@ void RedrawPlayfield_EM(boolean force_redraw)
     game.centered_player_nr = game.centered_player_nr_next;
 
     draw_new_player_location = TRUE;
+    draw_new_player_location_wrap = game.set_centered_player_wrap;
     force_redraw = TRUE;
 
     game.set_centered_player = FALSE;
+    game.set_centered_player_wrap = FALSE;
   }
 
   if (game.centered_player_nr == -1)
   {
-    if (draw_new_player_location || offset == 0)
+    if (draw_new_player_location || offset_raw == 0)
     {
       setScreenCenteredToAllPlayers(&sx, &sy);
     }
@@ -700,11 +672,25 @@ void RedrawPlayfield_EM(boolean force_redraw)
 
   if (draw_new_player_location && !quick_relocation)
   {
-    unsigned int game_frame_delay_value = getGameFrameDelay_EM(20);
-    int wait_delay_value = game_frame_delay_value;
+    unsigned int frame_delay_value_old = GetVideoFrameDelay();
+    int wait_delay_value = frame_delay_value_old;
     int screen_xx = VALID_SCREEN_X(sx);
     int screen_yy = VALID_SCREEN_Y(sy);
 
+    if (draw_new_player_location_wrap)
+    {
+      if (lev.infinite_true)
+      {
+	// when wrapping around (horizontally), keep vertical player position
+	screen_yy = screen_y;
+      }
+
+      // scrolling for wrapping should be faster than for switching players
+      wait_delay_value /= 4;
+    }
+
+    SetVideoFrameDelay(wait_delay_value);
+
     while (screen_x != screen_xx || screen_y != screen_yy)
     {
       int dx = (screen_xx < screen_x ? +1 : screen_xx > screen_x ? -1 : 0);
@@ -743,11 +729,10 @@ void RedrawPlayfield_EM(boolean force_redraw)
       animscreen();
 
       for (i = 0; i < MAX_PLAYERS; i++)
-	blitplayer(&ply[i]);
-
-      blitscreen();
+	blitplayer(i);
 
-      Delay(wait_delay_value);
+      BlitScreenToBitmap_EM(backbuffer);
+      BackToFront_EM();
 
       /* scroll second step to align at full tile size */
       screen_x -= dxx;
@@ -756,13 +741,14 @@ void RedrawPlayfield_EM(boolean force_redraw)
       animscreen();
 
       for (i = 0; i < MAX_PLAYERS; i++)
-	blitplayer(&ply[i]);
+	blitplayer(i);
 
-      blitscreen();
-
-      Delay(wait_delay_value);
+      BlitScreenToBitmap_EM(backbuffer);
+      BackToFront_EM();
     }
 
+    SetVideoFrameDelay(frame_delay_value_old);
+
     screen_x_old = screen_x;
     screen_y_old = screen_y;
   }
@@ -773,8 +759,8 @@ void RedrawPlayfield_EM(boolean force_redraw)
     {
       for (x = 0; x < MAX_BUF_XSIZE; x++)
       {
-	screentiles[y][x] = -1;
-	crumbled_state[y][x] = 0;
+	screen_tiles[x][y] = -1;
+	crumbled_state[x][y] = 0;
       }
     }
   }
@@ -842,17 +828,12 @@ void RedrawPlayfield_EM(boolean force_redraw)
       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);
-}
-
-void DrawGameDoorValues_EM()
-{
+    blitplayer(i);
 }