Merge bea6f90a7d into 7bb4940ebd

Removes manual memory management with new/delete.

src/ai/ai_instance.cpp

@@ -83,7 +83,7 @@ void AIInstance::Died()
 
 void AIInstance::LoadDummyScript()
 {
-	ScriptAllocatorScope alloc_scope(this->engine);
+	ScriptAllocatorScope alloc_scope(this->engine.get());
 	Script_CreateDummy(this->engine->GetVM(), STR_ERROR_AI_NO_AI_FOUND, "AI");
 }
 

src/heightmap.cpp

@@ -9,6 +9,7 @@
 
 #include "stdafx.h"
 #include "heightmap.h"
+#include "landscape.h"
 #include "clear_map.h"
 #include "strings_func.h"
 #include "void_map.h"
@@ -523,6 +524,10 @@ bool LoadHeightmap(DetailedFileType dft, std::string_view filename)
 	GrayscaleToMapHeights(x, y, map);
 
 	FixSlopes();
+
+	/* If all map borders are water, we will draw infinite water. */
+	_settings_game.game_creation.water_borders = (CheckWaterBorders(false) ? BORDERFLAGS_ALL : BorderFlag{});
+
 	MarkWholeScreenDirty();
 
 	return true;

src/landscape.cpp

@@ -635,6 +635,41 @@ void ClearSnowLine()
 	_snow_line = nullptr;
 }
 
+/**
+ * Check if all tiles on the map edge should be considered water borders.
+ * @param allow_non_flat_void Should we allow non-flat void tiles? (if map edge raised, then flattened to sea level)
+ * @return true If the edge of the map is flat and height 0, allowing for infinite water borders.
+ */
+bool CheckWaterBorders(bool allow_non_flat_void)
+{
+	auto check_tile = [allow_non_flat_void](uint x, uint y, Slope inner_edge) -> bool {
+		auto [slope, h] = GetTilePixelSlopeOutsideMap(x, y);
+
+		/* The edge tile is flat. */
+		if ((slope == SLOPE_FLAT) && (h == 0)) return true;
+		if (allow_non_flat_void && h == 0 && (slope & inner_edge) == 0 && IsTileType(TileXY(x, y), MP_VOID)) return true;
+		return false;
+	};
+
+	/* Check the map corners. */
+	if (!check_tile(0, 0, SLOPE_S)) return false;
+	if (!check_tile(0, Map::SizeY(), SLOPE_W)) return false;
+	if (!check_tile(Map::SizeX(), 0, SLOPE_E)) return false;
+	if (!check_tile(Map::SizeX(), Map::SizeY(), SLOPE_N)) return false;
+
+	/* Check the map edges.*/
+	for (uint x = 0; x <= Map::SizeX(); x++) {
+		if (!check_tile(x, 0, SLOPE_SE)) return false;
+		if (!check_tile(x, Map::SizeY(), SLOPE_NW)) return false;
+	}
+	for (uint y = 1; y < Map::SizeY(); y++) {
+		if (!check_tile(0, y, SLOPE_SW)) return false;
+		if (!check_tile(Map::SizeX(), y, SLOPE_NE)) return false;
+	}
+
+	return true;
+}
+
 /**
  * Clear a piece of landscape
  * @param flags of operation to conduct

src/landscape.h

@@ -33,6 +33,8 @@ uint8_t HighestSnowLine();
 uint8_t LowestSnowLine();
 void ClearSnowLine();
 
+bool CheckWaterBorders(bool allow_non_flat_void);
+
 int GetSlopeZInCorner(Slope tileh, Corner corner);
 std::tuple<Slope, int> GetFoundationSlope(TileIndex tile);
 

src/saveload/afterload.cpp

@@ -1024,6 +1024,27 @@ bool AfterLoadGame()
 		_settings_game.construction.freeform_edges = false;
 	}
 
+	/* Handle infinite water borders. */
+	if (IsSavegameVersionBefore(SLV_INFINITE_WATER_BORDERS)) {
+		if (CheckWaterBorders(true)) {
+			/* We passed the water borders check, yay! */
+			_settings_game.game_creation.water_borders = BORDERFLAGS_ALL;
+
+			/* Flatten void tiles, which may have been affected by terraforming near the map edge. */
+			for (uint x = 0; x <= Map::SizeX(); x++) {
+				SetTileHeightOutsideMap(x, 0, 0);
+				SetTileHeightOutsideMap(x, Map::SizeY(), 0);
+			}
+			for (uint y = 1; y < Map::SizeY(); y++) {
+				SetTileHeightOutsideMap(0, y, 0);
+				SetTileHeightOutsideMap(Map::SizeX(), y, 0);
+			}
+		} else {
+			/* Not all edges are ocean. */
+			_settings_game.game_creation.water_borders = BorderFlag{};
+		}
+	}
+
 	/* From version 9.0, we update the max passengers of a town (was sometimes negative
 	 *  before that. */
 	if (IsSavegameVersionBefore(SLV_9)) {

src/saveload/saveload.h

@@ -405,6 +405,7 @@ enum SaveLoadVersion : uint16_t {
 
 	SLV_FACE_STYLES,                        ///< 355  PR#14319 Addition of face styles, replacing gender and ethnicity.
 	SLV_INDUSTRY_NUM_VALID_HISTORY,         ///< 356  PR#14416 Store number of valid history records for industries.
+	SLV_INFINITE_WATER_BORDERS,             ///< 357  PR#13289 Draw infinite water when all borders are water.
 
 	SL_MAX_VERSION,                         ///< Highest possible saveload version
 };

src/script/api/script_object.cpp

@@ -53,7 +53,7 @@ static ScriptStorage &GetStorage()
 
 /* static */ ScriptInstance *ScriptObject::ActiveInstance::active = nullptr;
 
-ScriptObject::ActiveInstance::ActiveInstance(ScriptInstance &instance) : alc_scope(instance.engine)
+ScriptObject::ActiveInstance::ActiveInstance(ScriptInstance &instance) : alc_scope(instance.engine.get())
 {
 	this->last_active = ScriptObject::ActiveInstance::active;
 	ScriptObject::ActiveInstance::active = &instance;
@@ -230,8 +230,8 @@ ScriptObject::DisableDoCommandScope::DisableDoCommandScope()
 
 /* static */ bool ScriptObject::CanSuspend()
 {
-	Squirrel *squirrel = ScriptObject::GetActiveInstance().engine;
+	Squirrel &squirrel = *ScriptObject::GetActiveInstance().engine;
-	return GetStorage().allow_do_command && squirrel->CanSuspend();
+	return GetStorage().allow_do_command && squirrel.CanSuspend();
 }
 
 /* static */ ScriptEventQueue &ScriptObject::GetEventQueue()

src/script/script_instance.cpp

@@ -50,8 +50,8 @@ static void PrintFunc(bool error_msg, std::string_view message)
 
 ScriptInstance::ScriptInstance(std::string_view api_name)
 {
-	this->storage = new ScriptStorage();
+	this->storage = std::make_unique<ScriptStorage>();
-	this->engine  = new Squirrel(api_name);
+	this->engine = std::make_unique<Squirrel>(api_name);
 	this->engine->SetPrintFunction(&PrintFunc);
 }
 
@@ -59,10 +59,10 @@ void ScriptInstance::Initialize(const std::string &main_script, const std::strin
 {
 	ScriptObject::ActiveInstance active(*this);
 
-	this->controller = new ScriptController(company);
+	this->controller = std::make_unique<ScriptController>(company);
 
 	/* Register the API functions and classes */
-	this->engine->SetGlobalPointer(this->engine);
+	this->engine->SetGlobalPointer(this->engine.get());
 	this->RegisterAPI();
 	if (this->IsDead()) {
 		/* Failed to register API; a message has already been logged. */
@@ -81,12 +81,11 @@ void ScriptInstance::Initialize(const std::string &main_script, const std::strin
 		}
 
 		/* Create the main-class */
-		this->instance = new SQObject();
+		this->instance = std::make_unique<SQObject>();
-		if (!this->engine->CreateClassInstance(instance_name, this->controller, this->instance)) {
+		if (!this->engine->CreateClassInstance(instance_name, this->controller.get(), this->instance.get())) {
 			/* If CreateClassInstance has returned false instance has not been
 			 * registered with squirrel, so avoid trying to Release it by clearing it now */
-			delete this->instance;
+			this->instance.reset();
-			this->instance = nullptr;
 			this->Died();
 			return;
 		}
@@ -158,11 +157,10 @@ ScriptInstance::~ScriptInstance()
 	ScriptObject::ActiveInstance active(*this);
 	this->in_shutdown = true;
 
-	if (instance != nullptr) this->engine->ReleaseObject(this->instance);
+	if (instance != nullptr) this->engine->ReleaseObject(this->instance.get());
-	if (engine != nullptr) delete this->engine;
+
-	delete this->storage;
+	/* Engine must be reset explicitly in scope of the active instance. */
-	delete this->controller;
+	this->engine.reset();
-	delete this->instance;
 }
 
 void ScriptInstance::Continue()
@@ -179,11 +177,9 @@ void ScriptInstance::Died()
 
 	this->last_allocated_memory = this->GetAllocatedMemory(); // Update cache
 
-	if (this->instance != nullptr) this->engine->ReleaseObject(this->instance);
+	if (this->instance != nullptr) this->engine->ReleaseObject(this->instance.get());
-	delete this->instance;
+	this->engine.reset();
-	delete this->engine;
+	this->instance.reset();
-	this->instance = nullptr;
-	this->engine = nullptr;
 }
 
 void ScriptInstance::GameLoop()

src/script/script_instance.hpp

@@ -256,7 +256,7 @@ public:
 	void ReleaseSQObject(HSQOBJECT *obj);
 
 protected:
-	class Squirrel *engine = nullptr; ///< A wrapper around the squirrel vm.
+	std::unique_ptr<class Squirrel> engine; ///< A wrapper around the squirrel vm.
 	std::string api_version{}; ///< Current API used by this script.
 
 	/**
@@ -288,9 +288,9 @@ protected:
 	virtual void LoadDummyScript() = 0;
 
 private:
-	class ScriptController *controller = nullptr; ///< The script main class.
+	std::unique_ptr<class ScriptStorage> storage; ///< Some global information for each running script.
-	class ScriptStorage *storage = nullptr; ///< Some global information for each running script.
+	std::unique_ptr<class ScriptController> controller; ///< The script main class.
-	SQObject *instance = nullptr; ///< Squirrel-pointer to the script main class.
+	std::unique_ptr<SQObject> instance; ///< Squirrel-pointer to the script main class.
 
 	bool is_started = false; ///< Is the scripts constructor executed?
 	bool is_dead = false; ///< True if the script has been stopped.

src/table/settings/world_settings.ini

@@ -264,6 +264,7 @@ cat      = SC_BASIC
 var      = game_creation.water_borders
 type     = SLE_UINT8
 from     = SLV_111
+flags    = SettingFlag::NewgameOnly
 def      = 15
 min      = 0
 max      = 16

src/terraform_cmd.cpp

@@ -111,16 +111,25 @@ static std::tuple<CommandCost, TileIndex> TerraformTileHeight(TerraformerState *
 	 */
 	if (height == TerraformGetHeightOfTile(ts, tile)) return { CMD_ERROR, INVALID_TILE };
 
-	/* Check "too close to edge of map". Only possible when freeform-edges is off. */
+	/* If the map has infinite water borders, don't allow terraforming the outer ring of tiles to avoid blocking ships in a confusing way. */
-	uint x = TileX(tile);
+	if (_settings_game.game_creation.water_borders == BORDERFLAGS_ALL) {
-	uint y = TileY(tile);
+		uint x = TileX(tile);
-	if (!_settings_game.construction.freeform_edges && ((x <= 1) || (y <= 1) || (x >= Map::MaxX() - 1) || (y >= Map::MaxY() - 1))) {
+		uint y = TileY(tile);
-		/*
+
-		 * Determine a sensible error tile
+		auto check_tile = [&](uint x_min, uint y_min, uint x_max, uint y_max) -> bool {
-		 */
+			return ((x <= x_min) || (y <= y_min) || (x >= Map::MaxX() - x_max) || (y >= Map::MaxY() - y_max));
-		if (x == 1) x = 0;
+		};
-		if (y == 1) y = 0;
+
-		return { CommandCost(STR_ERROR_TOO_CLOSE_TO_EDGE_OF_MAP), TileXY(x, y) };
+		/* If free-form edges is off, distances are a bit different. */
+		if (!_settings_game.construction.freeform_edges && check_tile(1, 1, 1, 1)) {
+			/* Determine a sensible error tile. */
+			if (x == 1) x = 0;
+			if (y == 1) y = 0;
+			return { CommandCost(STR_ERROR_TOO_CLOSE_TO_EDGE_OF_MAP), TileXY(x, y) };
+		}
+
+		/* Freeform edges are enabled. */
+		if (check_tile(2, 2, 1, 1)) return { CommandCost(STR_ERROR_TOO_CLOSE_TO_EDGE_OF_MAP), TileXY(x, y) };
 	}
 
 	/* Mark incident tiles that are involved in the terraforming. */
@@ -209,7 +218,11 @@ std::tuple<CommandCost, Money, TileIndex> CmdTerraformLand(DoCommandFlags flags,
 			assert(t < Map::Size());
 			/* MP_VOID tiles can be terraformed but as tunnels and bridges
 			 * cannot go under / over these tiles they don't need checking. */
-			if (IsTileType(t, MP_VOID)) continue;
+			if (IsTileType(t, MP_VOID)) {
+				/* All water borders are drawn with infinite water, so don't allow terraforming off the map edge. */
+				if (_settings_game.game_creation.water_borders == BORDERFLAGS_ALL) return { CommandCost(STR_ERROR_TOO_CLOSE_TO_EDGE_OF_MAP), 0, t };
+				continue;
+			}
 
 			/* Find new heights of tile corners */
 			int z_N = TerraformGetHeightOfTile(&ts, t + TileDiffXY(0, 0));

src/tile_map.h

@@ -61,6 +61,18 @@ inline void SetTileHeight(Tile tile, uint height)
 	tile.height() = height;
 }
 
+/**
+ * Sets the height of a tile, also for tiles outside the map (virtual "black" tiles).
+ *
+ * @param tile The tile to change the height
+ * @param height The new height value of the tile
+ * @pre height <= MAX_TILE_HEIGHT
+ */
+inline void SetTileHeightOutsideMap(int x, int y, uint height)
+{
+	SetTileHeight(TileXY(Clamp(x, 0, Map::MaxX()), Clamp(y, 0, Map::MaxY())), height);
+}
+
 /**
  * Returns the height of a tile in pixels.
  *

src/void_cmd.cpp

@@ -21,7 +21,12 @@
 
 static void DrawTile_Void(TileInfo *ti)
 {
-	DrawGroundSprite(SPR_FLAT_BARE_LAND + SlopeToSpriteOffset(ti->tileh), PALETTE_ALL_BLACK);
+	/* If all borders are water, draw infinite water off the edges of the map. */
+	if (_settings_game.game_creation.water_borders == BORDERFLAGS_ALL) {
+		DrawGroundSprite(SPR_FLAT_WATER_TILE + SlopeToSpriteOffset(ti->tileh), PAL_NONE);
+	} else {
+		DrawGroundSprite(SPR_FLAT_BARE_LAND + SlopeToSpriteOffset(ti->tileh), PALETTE_ALL_BLACK);
+	}
 }