+ game.set_centered_player = FALSE;
+ }
+ }
+
+ if (game.centered_player_nr == -1)
+ {
+#if 1
+ if (draw_new_player_location || offset == 0)
+#else
+ if (draw_new_player_location)
+#endif
+ {
+ setScreenCenteredToAllPlayers(&sx, &sy);
+ }
+ else
+ {
+#if 1
+ sx = PLAYER_SCREEN_X(max_center_distance_player_nr);
+ sy = PLAYER_SCREEN_Y(max_center_distance_player_nr);
+#else
+ sx = PLAYER_SCREEN_X(game_em.last_moving_player);
+ sy = PLAYER_SCREEN_Y(game_em.last_moving_player);
+#endif
+ }
+ }
+ else
+ {
+ sx = PLAYER_SCREEN_X(game.centered_player_nr);
+ sy = PLAYER_SCREEN_Y(game.centered_player_nr);
+ }
+
+ if (draw_new_player_location && quick_relocation)
+ {
+ screen_x = VALID_SCREEN_X(sx);
+ screen_y = VALID_SCREEN_Y(sy);
+ screen_x_old = screen_x;
+ screen_y_old = screen_y;
+
+#if 0
+ offset_x = 0;
+ offset_y = 0;
+#endif
+ }
+
+ if (draw_new_player_location && !quick_relocation)
+ {
+#if 1
+ unsigned long game_frame_delay_value = getGameFrameDelay_EM(20);
+#else
+ unsigned long game_frame_delay_value = getGameFrameDelay_EM(25);
+#endif
+ int wait_delay_value = game_frame_delay_value;
+ int screen_xx = VALID_SCREEN_X(sx);
+ int screen_yy = VALID_SCREEN_Y(sy);
+
+ while (screen_x != screen_xx || screen_y != screen_yy)
+ {
+ int dx = (screen_xx < screen_x ? +1 : screen_xx > screen_x ? -1 : 0);
+ int dy = (screen_yy < screen_y ? +1 : screen_yy > screen_y ? -1 : 0);
+ int dxx = 0, dyy = 0;
+
+ if (dx == 0 && dy == 0) /* no scrolling needed at all */
+ break;
+
+#if 1
+
+ if (ABS(screen_xx - screen_x) >= TILEX)
+ {
+ screen_x -= dx * TILEX;
+ dxx = dx * TILEX / 2;
+ }
+ else
+ {
+ screen_x = screen_xx;
+ dxx = 0;
+ }
+
+ if (ABS(screen_yy - screen_y) >= TILEY)
+ {
+ screen_y -= dy * TILEY;
+ dyy = dy * TILEY / 2;
+ }
+ else
+ {
+ screen_y = screen_yy;
+ dyy = 0;
+ }
+
+#else
+
+#if 1
+ if (ABS(screen_xx - screen_x) >= TILEX ||
+ ABS(screen_yy - screen_y) >= TILEY)
+ {
+ screen_x -= dx * TILEX;
+ screen_y -= dy * TILEY;
+
+ dxx = dx * TILEX / 2;
+ dyy = dy * TILEY / 2;
+ }
+ else
+ {
+ screen_x = screen_xx;
+ screen_y = screen_yy;
+
+ dxx = 0;
+ dyy = 0;
+ }
+#else
+ screen_x -= dx * TILEX;
+ screen_y -= dy * TILEY;
+
+ dxx += dx * TILEX / 2;
+ dyy += dy * TILEY / 2;
+#endif
+
+#endif
+
+ /* scroll in two steps of half tile size to make things smoother */
+ screen_x += dxx;
+ screen_y += dyy;
+
+ animscreen();
+
+ for (i = 0; i < MAX_PLAYERS; i++)
+ blitplayer(&ply[i]);
+
+ blitscreen();
+
+ Delay(wait_delay_value);
+
+ /* scroll second step to align at full tile size */
+ screen_x -= dxx;
+ screen_y -= dyy;
+
+#if 0
+ SyncDisplay();
+#endif
+
+ animscreen();
+
+ for (i = 0; i < MAX_PLAYERS; i++)
+ blitplayer(&ply[i]);
+
+ blitscreen();
+
+ Delay(wait_delay_value);
+ }
+
+ screen_x_old = screen_x;
+ screen_y_old = screen_y;
+ }
+
+ if (force_redraw)
+ {
+ 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;
+ }
+ }
+ }
+
+ /* calculate new screen scrolling position, with regard to scroll delay */
+ screen_x = VALID_SCREEN_X(sx + offset_x < screen_x ? sx + offset_x :
+ sx - offset_x > screen_x ? sx - offset_x :
+ screen_x);
+ screen_y = VALID_SCREEN_Y(sy + offset_y < screen_y ? sy + offset_y :
+ sy - offset_y > screen_y ? sy - offset_y :
+ screen_y);
+
+#if 0
+ printf("::: (%d, %d) => (%d, %d) [(%d, %d), (%d, %d)] [%d, %d] [%d / %d]\n",
+ screen_x_old, screen_y_old,
+ screen_x, screen_y,
+ ply[max_center_distance_player_nr].oldx,
+ ply[max_center_distance_player_nr].x,
+ ply[max_center_distance_player_nr].oldy,
+ ply[max_center_distance_player_nr].y,
+ sx, sy,
+ ABS(screen_x - screen_x_old),
+ ABS(screen_y - screen_y_old));
+#endif
+
+#if 1
+
+#if 1
+ /* prevent scrolling further than double player step size when scrolling */
+ if (ABS(screen_x - screen_x_old) > 2 * stepsize)
+ {
+ int dx = SIGN(screen_x - screen_x_old);
+
+ screen_x = screen_x_old + dx * 2 * stepsize;
+ }
+ if (ABS(screen_y - screen_y_old) > 2 * stepsize)
+ {
+ int dy = SIGN(screen_y - screen_y_old);
+
+ screen_y = screen_y_old + dy * 2 * stepsize;
+ }
+#else
+ /* prevent scrolling further than double player step size when scrolling */
+ if (ABS(screen_x - screen_x_old) > 2 * stepsize ||
+ ABS(screen_y - screen_y_old) > 2 * stepsize)
+ {
+ int dx = SIGN(screen_x - screen_x_old);
+ int dy = SIGN(screen_y - screen_y_old);
+
+ screen_x = screen_x_old + dx * 2 * stepsize;
+ screen_y = screen_y_old + dy * 2 * stepsize;
+ }
+#endif
+
+#else
+ /* prevent scrolling further than player step size when scrolling */
+ if (ABS(screen_x - screen_x_old) > stepsize ||
+ ABS(screen_y - screen_y_old) > stepsize)
+ {
+ int dx = SIGN(screen_x - screen_x_old);
+ int dy = SIGN(screen_y - screen_y_old);
+
+ screen_x = screen_x_old + dx * stepsize;
+ screen_y = screen_y_old + dy * stepsize;
+ }
+#endif
+
+ /* prevent scrolling away from the other players when focus on all players */
+ if (game.centered_player_nr == -1)
+ {
+#if 1
+ /* check if all players are still visible with new scrolling position */
+ if (checkIfAllPlayersAreVisible(screen_x_old, screen_y_old) &&
+ !checkIfAllPlayersAreVisible(screen_x, screen_y))
+ {
+ /* reset horizontal scroll position to last value, if needed */
+ if (!checkIfAllPlayersAreVisible(screen_x, screen_y_old))
+ screen_x = screen_x_old;
+
+ /* reset vertical scroll position to last value, if needed */
+ if (!checkIfAllPlayersAreVisible(screen_x_old, screen_y))
+ screen_y = screen_y_old;
+ }
+#else
+ boolean all_players_visible = checkIfAllPlayersAreVisible();
+
+ if (!all_players_visible)
+ {
+ printf("::: not all players visible\n");
+
+ screen_x = screen_x_old;
+ screen_y = screen_y_old;
+ }
+#endif
+ }
+
+ /* prevent scrolling (for screen correcting) if no player is moving */
+ if (!game_em.any_player_moving)
+ {
+ screen_x = screen_x_old;
+ screen_y = screen_y_old;
+ }
+ else
+ {
+ /* prevent scrolling against the players move direction */
+#if 0
+ int player_nr = game_em.last_moving_player;
+#endif
+ int player_nr = (game.centered_player_nr == -1 ?
+ max_center_distance_player_nr : game.centered_player_nr);
+ int player_move_dir = game_em.last_player_direction[player_nr];
+ int dx = SIGN(screen_x - screen_x_old);
+ int dy = SIGN(screen_y - screen_y_old);
+
+ if ((dx < 0 && player_move_dir != MV_LEFT) ||
+ (dx > 0 && player_move_dir != MV_RIGHT))
+ screen_x = screen_x_old;
+
+ if ((dy < 0 && player_move_dir != MV_UP) ||
+ (dy > 0 && player_move_dir != MV_DOWN))
+ screen_y = screen_y_old;
+ }