Merge pull request #3510 from BlisterB/master

[WideScreen] Various fixes related with FakeResolution Mode (Pictures/Panoramas' position & Camera Scrolling)

Author: Ghabry

src/game_interpreter_control_variables.cpp

@@ -190,21 +190,11 @@ int ControlVariables::Event(int op, int event_id, const Game_BaseInterpreterCont
 				break;
 			case 4: {
 				// Screen X
-				if (Player::game_config.fake_resolution.Get()) {
-					int pan_delta = (Game_Player::GetDefaultPanX() - lcf::rpg::SavePartyLocation::kPanXDefault) / TILE_SIZE;
-					return character->GetScreenX() - pan_delta;
-				} else {
-					return character->GetScreenX();
-				}
+				return character->GetScreenX();
 			}
 			case 5: {
 				// Screen Y
-				if (Player::game_config.fake_resolution.Get()) {
-					int pan_delta = (Game_Player::GetDefaultPanY() - lcf::rpg::SavePartyLocation::kPanYDefault) / TILE_SIZE;
-					return character->GetScreenY() - pan_delta;
-				} else {
-					return character->GetScreenY();
-				}
+				return character->GetScreenY();
 			}
 			case 6:
 				// Event ID

src/game_map.cpp

@@ -1723,6 +1723,14 @@ void Game_Map::SetPositionX(int x, bool reset_panorama) {
 	const int map_width = GetTilesX() * SCREEN_TILE_SIZE;
 	if (LoopHorizontal()) {
 		x = Utils::PositiveModulo(x, map_width);
+		
+		// If the map is too small to fit in the screen, add an offset corresponding to the black border's size
+		if (Player::game_config.fake_resolution.Get()) {
+			int map_width_in_pixels = Game_Map::GetTilesX() * TILE_SIZE;
+			if (map_width_in_pixels < Player::screen_width) {
+				x += ((Player::screen_width - map_width_in_pixels) / 2 / TILE_SIZE) * SCREEN_TILE_SIZE;
+			}
+		}
 	} else {
 		// Do not use std::clamp here. When the map is smaller than the screen the
 		// upper bound is smaller than the lower bound making the function fail.
@@ -1747,6 +1755,14 @@ void Game_Map::SetPositionY(int y, bool reset_panorama) {
 	const int map_height = GetTilesY() * SCREEN_TILE_SIZE;
 	if (LoopVertical()) {
 		y = Utils::PositiveModulo(y, map_height);
+
+		// If the map is too small to fit in the screen, add an offset corresponding to the black border's size
+		if (Player::game_config.fake_resolution.Get()) {
+			int map_height_in_pixels = Game_Map::GetTilesY() * TILE_SIZE;
+			if (map_height_in_pixels < Player::screen_height) {
+				y += ((Player::screen_height - map_height_in_pixels) / 2 / TILE_SIZE) * SCREEN_TILE_SIZE;
+			}
+		}
 	} else {
 		// Do not use std::clamp here. When the map is smaller than the screen the
 		// upper bound is smaller than the lower bound making the function fail.
@@ -2035,9 +2051,6 @@ void Game_Map::Caching::MapEventCache::RemoveEvent(const lcf::rpg::Event& ev) {
 namespace {
 	int parallax_width;
 	int parallax_height;
-
-	bool parallax_fake_x;
-	bool parallax_fake_y;
 }
 
 /* Helper function to get the current parallax parameters. If the default
@@ -2141,12 +2154,14 @@ void Game_Map::Parallax::ResetPositionX() {
 		return;
 	}
 
-	parallax_fake_x = false;
-
 	if (!params.scroll_horz && !LoopHorizontal()) {
+		// What is the width of the panorama to display on screen?
 		int pan_screen_width = Player::screen_width;
-		if (Player::game_config.fake_resolution.Get()) {
-			pan_screen_width = SCREEN_TARGET_WIDTH;
+		if (Player::game_config.fake_resolution.Get()) {			
+			int map_width = Game_Map::GetTilesX() * TILE_SIZE;
+			if (map_width < pan_screen_width) {
+				pan_screen_width = map_width;
+			}
 		}
 
 		int tiles_per_screen = pan_screen_width / TILE_SIZE;
@@ -2165,10 +2180,7 @@ void Game_Map::Parallax::ResetPositionX() {
 			}
 		} else {
 			panorama.pan_x = 0;
-			parallax_fake_x = true;
 		}
-	} else {
-		parallax_fake_x = true;
 	}
 }
 
@@ -2179,12 +2191,14 @@ void Game_Map::Parallax::ResetPositionY() {
 		return;
 	}
 
-	parallax_fake_y = false;
-
 	if (!params.scroll_vert && !Game_Map::LoopVertical()) {
+		// What is the height of the panorama to display on screen?
 		int pan_screen_height = Player::screen_height;
 		if (Player::game_config.fake_resolution.Get()) {
-			pan_screen_height = SCREEN_TARGET_HEIGHT;
+			int map_height = Game_Map::GetTilesY() * TILE_SIZE;
+			if (map_height < pan_screen_height) {
+				pan_screen_height = map_height;
+			}
 		}
 
 		int tiles_per_screen = pan_screen_height / TILE_SIZE;
@@ -2198,10 +2212,7 @@ void Game_Map::Parallax::ResetPositionY() {
 			SetPositionY(pv);
 		} else {
 			panorama.pan_y = 0;
-			parallax_fake_y = true;
 		}
-	} else {
-		parallax_fake_y = true;
 	}
 }
 
@@ -2296,11 +2307,3 @@ void Game_Map::Parallax::ClearChangedBG() {
 	Params params {}; // default Param indicates no override
 	ChangeBG(params);
 }
-
-bool Game_Map::Parallax::FakeXPosition() {
-	return parallax_fake_x;
-}
-
-bool Game_Map::Parallax::FakeYPosition() {
-	return parallax_fake_y;
-}

src/game_map.h

@@ -826,12 +826,6 @@ namespace Game_Map {
 		 * the map properties.
 		 */
 		void ClearChangedBG();
-
-		/** @return Whether ox adjustment is required for fake resolution mode */
-		bool FakeXPosition();
-
-		/** @return Whether oy adjustment is required for fake resolution mode */
-		bool FakeYPosition();
 	}
 }
 

src/game_player.cpp

@@ -191,15 +191,33 @@ void Game_Player::UpdateScroll(int amount, bool was_jumping) {
 		return;
 	}
 
-	auto dx = (GetX() * SCREEN_TILE_SIZE) - Game_Map::GetPositionX() - GetPanX();
-	auto dy = (GetY() * SCREEN_TILE_SIZE) - Game_Map::GetPositionY() - GetPanY();
+	const auto map_width = Game_Map::GetTilesX() * SCREEN_TILE_SIZE;
+	const auto map_height = Game_Map::GetTilesY() * SCREEN_TILE_SIZE;
+
+	// When using FakeResolution mode, if the map is too small to fit the screen
+	// we need to calculate the black border offset, in case of a looping map for example
+	int screen_offset_x = 0;
+	if (Player::game_config.fake_resolution.Get()) {
+		int map_width_in_pixels = Game_Map::GetTilesX() * TILE_SIZE;
+		if (map_width_in_pixels < Player::screen_width) {
+			screen_offset_x = ((Player::screen_width - map_width_in_pixels) / 2 / TILE_SIZE) * SCREEN_TILE_SIZE;
+		}
+	}
+	int screen_offset_y = 0;
+	if (Player::game_config.fake_resolution.Get()) {
+		int map_height_in_pixels = Game_Map::GetTilesY() * TILE_SIZE;
+		if (map_height_in_pixels < Player::screen_height) {
+			screen_offset_y = ((Player::screen_height - map_height_in_pixels) / 2 / TILE_SIZE) * SCREEN_TILE_SIZE;
+		}
+	}
 
-	const auto w = Game_Map::GetTilesX() * SCREEN_TILE_SIZE;
-	const auto h = Game_Map::GetTilesY() * SCREEN_TILE_SIZE;
+	auto dx = (GetX() * SCREEN_TILE_SIZE) - Game_Map::GetPositionX() - GetPanX() + screen_offset_x;
+	auto dy = (GetY() * SCREEN_TILE_SIZE) - Game_Map::GetPositionY() - GetPanY() + screen_offset_y;
 
-	dx = Utils::PositiveModulo(dx + w / 2, w) - w / 2;
-	dy = Utils::PositiveModulo(dy + h / 2, h) - h / 2;
+	dx = Utils::PositiveModulo(dx + map_width / 2, map_width) - map_width / 2;
+	dy = Utils::PositiveModulo(dy + map_height / 2, map_height) - map_height / 2;
 
+	// If sx or sy equals zero, no scrolling is needed in the corresponding direction
 	const auto sx = Utils::Signum(dx);
 	const auto sy = Utils::Signum(dy);
 

src/plane.cpp

@@ -84,11 +84,6 @@ void Plane::Draw(Bitmap& dst) {
 		dst_rect.x = bg_x;
 		dst_rect.width = bg_width;
 
-		if (Game_Map::GetDisplayX() / 16 + Player::screen_width > Game_Map::GetTilesX() * TILE_SIZE) {
-			// Do not draw out of bounds to the right
-			dst_rect.width -= (Game_Map::GetDisplayX() / 16 + Player::screen_width) - (Game_Map::GetTilesX() * TILE_SIZE);
-		}
-
 		// Correct the offset if the top-left corner moved.
 		offset_x = shake_x + bg_x;
 	}

src/sprite_picture.cpp

@@ -24,6 +24,7 @@
 #include "game_windows.h"
 #include "player.h"
 #include "bitmap.h"
+#include "game_map.h"
 
 Sprite_Picture::Sprite_Picture(int pic_id, Drawable::Flags flags)
 	: Sprite(flags),
@@ -106,8 +107,26 @@ void Sprite_Picture::Draw(Bitmap& dst) {
 	}
 
 	if (Player::game_config.fake_resolution.Get()) {
-		SetX(x + Player::menu_offset_x);
-		SetY(y + Player::menu_offset_y);
+		if (data.fixed_to_map) {
+			// If the picture scrolls with the map, apply the black border if the map is too small
+			int offset_x = 0;
+			int map_width = Game_Map::GetTilesX() * TILE_SIZE;
+			if (map_width < Player::screen_width) {
+				offset_x += (Player::screen_width - map_width) / 2;
+			}
+			SetX(x + offset_x);
+			
+			int offset_y = 0;
+			int map_height = Game_Map::GetTilesY() * TILE_SIZE;
+			if (map_height < Player::screen_height) {
+				offset_y += (Player::screen_height - map_height) / 2;
+			}
+			SetY(y + offset_y);
+		} else {
+			// If the picture doesn't scroll with the map, simulate the 340x240 screen
+			SetX(x + Player::menu_offset_x);
+			SetY(y + Player::menu_offset_y);
+		}
 	} else {
 		SetX(x);
 		SetY(y);

src/spriteset_map.cpp

@@ -326,12 +326,16 @@ void Spriteset_Map::CalculateMapRenderOffset() {
 
 void Spriteset_Map::CalculatePanoramaRenderOffset() {
 	// Resolution hack for Panorama
+	// If the map is too small to fit in the screen, add an offset corresponding to the black border's size
 	if (Player::game_config.fake_resolution.Get()) {
-		if (Game_Map::Parallax::FakeXPosition()) {
-			panorama->SetRenderOx((Player::screen_width - SCREEN_TARGET_WIDTH) / 2);
+		int map_width_in_pixels = Game_Map::GetTilesX() * TILE_SIZE;
+		if (map_width_in_pixels < Player::screen_width) {
+			panorama->SetRenderOx((Player::screen_width - map_width_in_pixels) / 2);
 		}
-		if (Game_Map::Parallax::FakeYPosition()) {
-			panorama->SetRenderOy((Player::screen_height - SCREEN_TARGET_HEIGHT) / 2);
+
+		int map_height_in_pixels = Game_Map::GetTilesY() * TILE_SIZE;
+		if (map_height_in_pixels < Player::screen_height) {
+			panorama->SetRenderOy((Player::screen_height - map_height_in_pixels) / 2);
 		}
 	}
 }