X-Git-Url: https://git.artsoft.org/?a=blobdiff_plain;f=src%2Fgame_em%2Fgraphics.c;h=331491cfb25c7c0209bbae411d2d54e7a009645a;hb=f772f882546ab982dc61074f298d6115c9909f32;hp=d64863b4c46fba0bf68ddacdbc2da226c63de9d7;hpb=a765d70dda7da4500e7005ffa5913e24cd32c0fa;p=rocksndiamonds.git

diff --git a/src/game_em/graphics.c b/src/game_em/graphics.c
index d64863b4..331491cf 100644
--- a/src/game_em/graphics.c
+++ b/src/game_em/graphics.c
@@ -31,13 +31,8 @@
 
 
 int frame;			/* current screen frame */
-#if 0
-int screen_x;			/* current scroll position */
-int screen_y;
-#else
 int screen_x;			/* current scroll position */
 int screen_y;
-#endif
 
 /* tiles currently on screen */
 static int screentiles[MAX_BUF_YSIZE][MAX_BUF_XSIZE];
@@ -45,12 +40,13 @@ static int crumbled_state[MAX_BUF_YSIZE][MAX_BUF_XSIZE];
 
 static boolean redraw[MAX_BUF_XSIZE][MAX_BUF_YSIZE];
 
+#if 1
+int centered_player_nr;
+#else
 static int centered_player_nr;
+#endif
 
-/* copy the entire screen to the window at the scroll position
- *
- * perhaps use mit-shm to speed this up
- */
+/* copy the entire screen to the window at the scroll position */
 
 void BlitScreenToBitmap_EM(Bitmap *target_bitmap)
 {
@@ -99,18 +95,12 @@ void BlitScreenToBitmap_EM(Bitmap *target_bitmap)
 
 void blitscreen(void)
 {
-#if 1
-
   static boolean scrolling_last = FALSE;
   int left = screen_x / TILEX;
   int top  = screen_y / TILEY;
   boolean scrolling = (screen_x % TILEX != 0 || screen_y % TILEY != 0);
   int x, y;
 
-#if 0
-  SyncDisplay();
-#endif
-
   if (redraw_tiles > REDRAWTILES_THRESHOLD || scrolling || scrolling_last)
   {
     /* blit all (up to four) parts of the scroll buffer to the backbuffer */
@@ -142,13 +132,6 @@ void blitscreen(void)
   redraw_tiles = 0;
 
   scrolling_last = scrolling;
-
-#else
-
-  /* blit all (up to four) parts of the scroll buffer to the window */
-  BlitScreenToBitmap_EM(window);
-
-#endif
 }
 
 static void DrawLevelField_EM(int x, int y, int sx, int sy,
@@ -162,15 +145,13 @@ static void DrawLevelField_EM(int x, int y, int sx, int sy,
   int dst_y = sy * TILEY + g->dst_offset_y;
   int width = g->width;
   int height = g->height;
-
-#if 1
   int left = screen_x / TILEX;
   int top  = screen_y / TILEY;
 
+  /* do not draw fields that are outside the visible screen area */
   if (x < left || x >= left + MAX_BUF_XSIZE ||
       y < top  || y >= top  + MAX_BUF_YSIZE)
     return;
-#endif
 
   if (draw_masked)
   {
@@ -198,16 +179,14 @@ static void DrawLevelFieldCrumbled_EM(int x, int y, int sx, int sy,
 {
   int tile = Draw[y][x];
   struct GraphicInfo_EM *g = &graphic_info_em_object[tile][frame];
-  int i;
-
-#if 1
   int left = screen_x / TILEX;
   int top  = screen_y / TILEY;
+  int i;
 
+  /* do not draw fields that are outside the visible screen area */
   if (x < left || x >= left + MAX_BUF_XSIZE ||
       y < top  || y >= top  + MAX_BUF_YSIZE)
     return;
-#endif
 
   if (crm == 0)		/* no crumbled edges for this tile */
     return;
@@ -263,14 +242,13 @@ static void DrawLevelPlayer_EM(int x1, int y1, int player_nr, int anim,
   int src_x = g->src_x, src_y = g->src_y;
   int dst_x, dst_y;
 
-#if 1
+  /* do not draw fields that are outside the visible screen area */
   if (x1 < screen_x - TILEX || x1 >= screen_x + MAX_BUF_XSIZE * TILEX ||
       y1 < screen_y - TILEY || y1 >= screen_y + MAX_BUF_YSIZE * TILEY)
     return;
 
   x1 %= MAX_BUF_XSIZE * TILEX;
   y1 %= MAX_BUF_YSIZE * TILEY;
-#endif
 
   if (draw_masked)
   {
@@ -323,8 +301,6 @@ static void DrawLevelPlayer_EM(int x1, int y1, int player_nr, int anim,
 /* draw differences between game tiles and screen tiles
  *
  * implicitly handles scrolling and restoring background under the sprites
- *
- * perhaps use mit-shm to speed this up
  */
 
 static void animscreen(void)
@@ -478,28 +454,16 @@ void game_initscreen(void)
   int x,y;
   int dynamite_state = ply[0].dynamite;		/* !!! ONLY PLAYER 1 !!! */
   int all_keys_state = ply[0].keys | ply[1].keys | ply[2].keys | ply[3].keys;
-#if 1
   int player_nr;
-#else
-#if 1
-  int player_nr = getCenteredPlayerNr_EM();
-#else
-  int player_nr = 0;		/* !!! FIX THIS (CENTERED TO PLAYER 1) !!! */
-#endif
-#endif
+
+  frame = 6;
 
   centered_player_nr = getCenteredPlayerNr_EM();
 
   player_nr = (centered_player_nr != -1 ? centered_player_nr : 0);
 
-  frame = 6;
-#if 1
   screen_x = VALID_SCREEN_X(PLAYER_SCREEN_X(player_nr));
   screen_y = VALID_SCREEN_Y(PLAYER_SCREEN_Y(player_nr));
-#else
-  screen_x = 0;
-  screen_y = 0;
-#endif
 
   for (y = 0; y < MAX_BUF_YSIZE; y++)
   {
@@ -510,13 +474,8 @@ void game_initscreen(void)
     }
   }
 
-#if 1
   DrawAllGameValues(lev.required, dynamite_state, lev.score,
 		    lev.time, all_keys_state);
-#else
-  DrawAllGameValues(lev.required, ply1.dynamite, lev.score,
-		    DISPLAY_TIME(lev.time + 4), ply1.keys | ply2.keys);
-#endif
 }
 
 #if 0
@@ -615,34 +574,173 @@ void DrawRelocatePlayer(struct PlayerInfo *player, boolean quick_relocation)
 }
 #endif
 
+static void setMinimalPlayerBoundaries(int *sx1, int *sy1, int *sx2, int *sy2)
+{
+  boolean num_checked_players = 0;
+  int i;
+
+  for (i = 0; i < MAX_PLAYERS; i++)
+  {
+    if (ply[i].alive)
+    {
+      int sx = PLAYER_SCREEN_X(i);
+      int sy = PLAYER_SCREEN_Y(i);
+
+      if (num_checked_players == 0)
+      {
+	*sx1 = *sx2 = sx;
+	*sy1 = *sy2 = sy;
+      }
+      else
+      {
+	*sx1 = MIN(*sx1, sx);
+	*sy1 = MIN(*sy1, sy);
+	*sx2 = MAX(*sx2, sx);
+	*sy2 = MAX(*sy2, sy);
+      }
+
+      num_checked_players++;
+    }
+  }
+}
+
+boolean checkIfAllPlayersFitToScreen()
+{
+  int sx1 = 0, sy1 = 0, sx2 = 0, sy2 = 0;
+
+  setMinimalPlayerBoundaries(&sx1, &sy1, &sx2, &sy2);
+
+  return (sx2 - sx1 <= SCR_FIELDX * TILEX &&
+	  sy2 - sy1 <= SCR_FIELDY * TILEY);
+}
+
+static void setScreenCenteredToAllPlayers(int *sx, int *sy)
+{
+  int sx1 = screen_x, sy1 = screen_y, sx2 = screen_x, sy2 = screen_y;
+
+  setMinimalPlayerBoundaries(&sx1, &sy1, &sx2, &sy2);
+
+  *sx = (sx1 + sx2) / 2;
+  *sy = (sy1 + sy2) / 2;
+}
+
+static void setMaxCenterDistanceForAllPlayers(int *max_dx, int *max_dy,
+					      int center_x, int center_y)
+{
+  int sx1 = center_x, sy1 = center_y, sx2 = center_x, sy2 = center_y;
+
+  setMinimalPlayerBoundaries(&sx1, &sy1, &sx2, &sy2);
+
+  *max_dx = MAX(ABS(sx1 - center_x), ABS(sx2 - center_x));
+  *max_dy = MAX(ABS(sy1 - center_y), ABS(sy2 - center_y));
+}
+
+static boolean checkIfAllPlayersAreVisible(int center_x, int center_y)
+{
+  int max_dx, max_dy;
+
+  setMaxCenterDistanceForAllPlayers(&max_dx, &max_dy, center_x, center_y);
+
+  return (max_dx <= SCR_FIELDX * TILEX / 2 &&
+	  max_dy <= SCR_FIELDY * TILEY / 2);
+}
+
 void RedrawPlayfield_EM(boolean force_redraw)
 {
-#if 1
-  int centered_player_nr_next = getCenteredPlayerNr_EM();
-  int player_nr = (centered_player_nr_next != -1 ? centered_player_nr_next :0);
+#if 0
+  boolean all_players_visible = checkIfAllPlayersAreVisible();
+#endif
   boolean draw_new_player_location = FALSE;
   boolean quick_relocation = setup.quick_switch;
-#else
-  int player_nr = 0;		/* !!! FIX THIS (CENTERED TO PLAYER 1) !!! */
+#if 0
+  boolean scrolling = (screen_x % TILEX != 0 || screen_y % TILEY != 0);
 #endif
-  int sx = PLAYER_SCREEN_X(player_nr);
-  int sy = PLAYER_SCREEN_Y(player_nr);
-  int i, x, y;
+  boolean set_centered_player = getSetCenteredPlayer_EM();
+  int centered_player_nr_next = getCenteredPlayerNr_EM();
+  int offset = (setup.scroll_delay ? 3 : 0) * TILEX;
+  int offset_x = offset;
+  int offset_y = offset;
+  int screen_x_old = screen_x;
+  int screen_y_old = screen_y;
+  int x, y, sx, sy;
+  int i;
 
-#if 1
-  boolean scrolling = (screen_x % TILEX != 0 || screen_y % TILEY != 0);
+  if (set_centered_player)
+  {
+    boolean all_players_fit_to_screen = checkIfAllPlayersFitToScreen();
+
+    /* switching to "all players" only possible if all players fit to screen */
+    if (centered_player_nr_next == -1 && !all_players_fit_to_screen)
+    {
+      centered_player_nr_next = centered_player_nr;
+      setCenteredPlayerNr_EM(centered_player_nr);
 
+      set_centered_player = FALSE;
+      setSetCenteredPlayer_EM(FALSE);
+    }
+
+    /* do not switch focus to non-existing (or non-active) player */
+    if (centered_player_nr_next >= 0 && !ply[centered_player_nr_next].alive)
+    {
+      centered_player_nr_next = centered_player_nr;
+      setCenteredPlayerNr_EM(centered_player_nr);
+
+      set_centered_player = FALSE;
+      setSetCenteredPlayer_EM(FALSE);
+    }
+  }
+
+#if 1
+  /* also allow focus switching when screen is scrolled to half tile */
+#else
   if (!scrolling)	/* screen currently aligned at tile position */
+#endif
   {
+#if 1
+    if (set_centered_player)
+#else
     if (centered_player_nr != centered_player_nr_next)
+#endif
     {
       centered_player_nr = centered_player_nr_next;
 
       draw_new_player_location = TRUE;
       force_redraw = TRUE;
+
+      setSetCenteredPlayer_EM(FALSE);
     }
   }
+
+  if (centered_player_nr == -1)
+  {
+    if (draw_new_player_location)
+    {
+      setScreenCenteredToAllPlayers(&sx, &sy);
+    }
+    else
+    {
+      sx = PLAYER_SCREEN_X(game_em.last_moving_player);
+      sy = PLAYER_SCREEN_Y(game_em.last_moving_player);
+    }
+  }
+  else
+  {
+    sx = PLAYER_SCREEN_X(centered_player_nr);
+    sy = PLAYER_SCREEN_Y(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)
   {
@@ -652,12 +750,11 @@ void RedrawPlayfield_EM(boolean force_redraw)
     unsigned long game_frame_delay_value = getGameFrameDelay_EM(25);
 #endif
     int wait_delay_value = game_frame_delay_value;
-    int screen_xx = -999, screen_yy = -999;
+    int screen_xx = VALID_SCREEN_X(sx);
+    int screen_yy = VALID_SCREEN_Y(sy);
 
-    while (screen_xx != screen_x || screen_yy != screen_y)
+    while (screen_x != screen_xx || screen_y != screen_yy)
     {
-      int screen_xx = VALID_SCREEN_X(PLAYER_SCREEN_X(player_nr));
-      int screen_yy = VALID_SCREEN_Y(PLAYER_SCREEN_Y(player_nr));
       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;
@@ -665,11 +762,59 @@ void RedrawPlayfield_EM(boolean force_redraw)
       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;
@@ -699,9 +844,11 @@ void RedrawPlayfield_EM(boolean force_redraw)
       FlushDisplay();
       Delay(wait_delay_value);
     }
+
+    screen_x_old = screen_x;
+    screen_y_old = screen_y;
   }
 
-#if 1
   if (force_redraw)
   {
     for (y = 0; y < MAX_BUF_YSIZE; y++)
@@ -713,34 +860,76 @@ void RedrawPlayfield_EM(boolean force_redraw)
       }
     }
   }
-#endif
-
-#if 1
-
-  int offset = (setup.scroll_delay ? 3 : 0) * TILEX;
 
   /* calculate new screen scrolling position, with regard to scroll delay */
-  screen_x = VALID_SCREEN_X(sx + offset < screen_x ? sx + offset :
-			    sx - offset > screen_x ? sx - offset : screen_x);
-  screen_y = VALID_SCREEN_Y(sy + offset < screen_y ? sy + offset :
-			    sy - offset > screen_y ? sy - offset : screen_y);
+  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);
+
+  /* prevent scrolling further than player step size screen when scrolling */
+  if (ABS(screen_x - screen_x_old) > TILEX / 8 ||
+      ABS(screen_y - screen_y_old) > TILEY / 8)
+  {
+    int dx = SIGN(screen_x - screen_x_old);
+    int dy = SIGN(screen_y - screen_y_old);
 
-#else
+    screen_x = screen_x_old + dx * TILEX / 8;
+    screen_y = screen_y_old + dy * TILEY / 8;
+  }
 
-  if (sx > lev.width * TILEX)
-    sx = lev.width * TILEX;
-  if (sy > lev.height * TILEY)
-    sy = lev.height * TILEY;
+  /* prevent scrolling away from the other players when focus on all players */
+  if (centered_player_nr == -1)
+  {
+#if 1
+    /* check if all players are still visible with new scrolling position */
+    if (!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;
 
-  if (sx < SCR_FIELDX * TILEX)
-    sx = SCR_FIELDX * TILEY;
-  if (sy < SCR_FIELDY * TILEY)
-    sy = SCR_FIELDY * TILEY;
+      /* 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();
 
-  screen_x = sx - (SCR_FIELDX - 1) * TILEX;
-  screen_y = sy - (SCR_FIELDY - 1) * TILEY;
+    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 */
+    int player_nr = game_em.last_moving_player;
+    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;
+  }
 
   animscreen();