Codefix 3fde611012: AirportMovingDataFlag should be `enum class`

`AirportMovingDataFlag` was changed to use `enum class` naming style, but wasn't actually changed to be `enum class`.

src/ai/ai_info.cpp

@@ -90,7 +90,7 @@ template <> SQInteger PushClassName<AIInfo, ScriptType::AI>(HSQUIRRELVM vm) { sq
 	/* Remove the link to the real instance, else it might get deleted by RegisterAI() */
 	sq_setinstanceup(vm, 2, nullptr);
 	/* Register the AI to the base system */
-	info->GetScanner()->RegisterScript(info);
+	info->GetScanner()->RegisterScript(std::unique_ptr<AIInfo>{info});
 	return 0;
 }
 
@@ -136,22 +136,21 @@ bool AIInfo::CanLoadFromVersion(int version) const
 /* static */ SQInteger AILibrary::Constructor(HSQUIRRELVM vm)
 {
 	/* Create a new library */
-	AILibrary *library = new AILibrary();
+	auto library = std::make_unique<AILibrary>();
 
 	SQInteger res = ScriptInfo::Constructor(vm, *library);
 	if (res != 0) {
-		delete library;
 		return res;
 	}
 
 	/* Cache the category */
 	if (!library->CheckMethod("GetCategory") || !library->engine->CallStringMethod(library->SQ_instance, "GetCategory", &library->category, MAX_GET_OPS)) {
-		delete library;
 		return SQ_ERROR;
 	}
 
 	/* Register the Library to the base system */
-	library->GetScanner()->RegisterScript(library);
+	ScriptScanner *scanner = library->GetScanner();
+	scanner->RegisterScript(std::move(library));
 
 	return 0;
 }

src/ai/ai_scanner.cpp

@@ -29,7 +29,7 @@ void AIScannerInfo::Initialize()
 {
 	ScriptScanner::Initialize("AIScanner");
 
-	ScriptAllocatorScope alloc_scope(this->engine);
+	ScriptAllocatorScope alloc_scope(this->engine.get());
 
 	/* Create the dummy AI */
 	this->main_script = "%_dummy";

src/airport.h

@@ -44,7 +44,7 @@ enum AirportTypes : uint8_t {
 };
 
 /** Flags for airport movement data. */
-enum AirportMovingDataFlag : uint8_t {
+enum class AirportMovingDataFlag : uint8_t {
 	NoSpeedClamp, ///< No speed restrictions.
 	Takeoff, ///< Takeoff movement.
 	SlowTurn, ///< Turn slowly (mostly used in the air).

src/fontcache.cpp

@@ -22,9 +22,10 @@
 
 #include "safeguards.h"
 
-/** Default heights for the different sizes of fonts. */
-static const int _default_font_height[FS_END]   = {10, 6, 18, 10};
-static const int _default_font_ascender[FS_END] = { 8, 5, 15,  8};
+/** Default unscaled heights for the different sizes of fonts. */
+/* static */ const int FontCache::DEFAULT_FONT_HEIGHT[FS_END] = {10, 6, 18, 10};
+/** Default unscaled ascenders for the different sizes of fonts. */
+/* static */ const int FontCache::DEFAULT_FONT_ASCENDER[FS_END] = {8, 5, 15, 8};
 
 FontCacheSettings _fcsettings;
 
@@ -32,8 +33,7 @@ FontCacheSettings _fcsettings;
  * Create a new font cache.
  * @param fs The size of the font.
  */
-FontCache::FontCache(FontSize fs) : parent(FontCache::Get(fs)), fs(fs), height(_default_font_height[fs]),
-		ascender(_default_font_ascender[fs]), descender(_default_font_ascender[fs] - _default_font_height[fs])
+FontCache::FontCache(FontSize fs) : parent(FontCache::Get(fs)), fs(fs)
 {
 	assert(this->parent == nullptr || this->fs == this->parent->fs);
 	FontCache::caches[this->fs] = this;
@@ -50,7 +50,7 @@ FontCache::~FontCache()
 
 int FontCache::GetDefaultFontHeight(FontSize fs)
 {
-	return _default_font_height[fs];
+	return FontCache::DEFAULT_FONT_HEIGHT[fs];
 }
 
 /**

src/fontcache.h

@@ -23,9 +23,9 @@ protected:
 	static FontCache *caches[FS_END]; ///< All the font caches.
 	FontCache *parent;                ///< The parent of this font cache.
 	const FontSize fs;                ///< The size of the font.
-	int height;                       ///< The height of the font.
-	int ascender;                     ///< The ascender value of the font.
-	int descender;                    ///< The descender value of the font.
+	int height = 0; ///< The height of the font.
+	int ascender = 0; ///< The ascender value of the font.
+	int descender = 0; ///< The descender value of the font.
 
 public:
 	FontCache(FontSize fs);
@@ -33,6 +33,11 @@ public:
 
 	static void InitializeFontCaches();
 
+	/** Default unscaled font heights. */
+	static const int DEFAULT_FONT_HEIGHT[FS_END];
+	/** Default unscaled font ascenders. */
+	static const int DEFAULT_FONT_ASCENDER[FS_END];
+
 	static int GetDefaultFontHeight(FontSize fs);
 
 	/**

src/fontcache/spritefontcache.cpp

@@ -43,26 +43,26 @@ SpriteFontCache::SpriteFontCache(FontSize fs) : FontCache(fs)
 }
 
 /**
- * Get SpriteID associated with a GlyphID.
- * @param key Glyph to find.
- * @return SpriteID of glyph, or 0 if not present.
+ * Get SpriteID associated with a character.
+ * @param key Character to find.
+ * @return SpriteID for character, or 0 if not present.
  */
-SpriteID SpriteFontCache::GetUnicodeGlyph(GlyphID key)
+SpriteID SpriteFontCache::GetUnicodeGlyph(char32_t key)
 {
-	const auto found = this->glyph_to_spriteid_map.find(key & ~SPRITE_GLYPH);
-	if (found == std::end(this->glyph_to_spriteid_map)) return 0;
+	const auto found = this->char_map.find(key);
+	if (found == std::end(this->char_map)) return 0;
 	return found->second;
 }
 
 void SpriteFontCache::SetUnicodeGlyph(char32_t key, SpriteID sprite)
 {
-	this->glyph_to_spriteid_map[key] = sprite;
+	this->char_map[key] = sprite;
 }
 
 void SpriteFontCache::InitializeUnicodeGlyphMap()
 {
 	/* Clear out existing glyph map if it exists */
-	this->glyph_to_spriteid_map.clear();
+	this->char_map.clear();
 
 	SpriteID base;
 	switch (this->fs) {
@@ -103,14 +103,14 @@ void SpriteFontCache::ClearFontCache()
 
 const Sprite *SpriteFontCache::GetGlyph(GlyphID key)
 {
-	SpriteID sprite = this->GetUnicodeGlyph(static_cast<char32_t>(key & ~SPRITE_GLYPH));
+	SpriteID sprite = static_cast<SpriteID>(key & ~SPRITE_GLYPH);
 	if (sprite == 0) sprite = this->GetUnicodeGlyph('?');
 	return GetSprite(sprite, SpriteType::Font);
 }
 
 uint SpriteFontCache::GetGlyphWidth(GlyphID key)
 {
-	SpriteID sprite = this->GetUnicodeGlyph(static_cast<char32_t>(key & ~SPRITE_GLYPH));
+	SpriteID sprite = static_cast<SpriteID>(key & ~SPRITE_GLYPH);
 	if (sprite == 0) sprite = this->GetUnicodeGlyph('?');
 	return SpriteExists(sprite) ? GetSprite(sprite, SpriteType::Font)->width + ScaleFontTrad(this->fs != FS_NORMAL ? 1 : 0) : 0;
 }
@@ -120,7 +120,7 @@ GlyphID SpriteFontCache::MapCharToGlyph(char32_t key, [[maybe_unused]] bool allo
 	assert(IsPrintable(key));
 	SpriteID sprite = this->GetUnicodeGlyph(key);
 	if (sprite == 0) return 0;
-	return SPRITE_GLYPH | key;
+	return SPRITE_GLYPH | sprite;
 }
 
 bool SpriteFontCache::GetDrawGlyphShadow()

src/fontcache/spritefontcache.h

@@ -28,8 +28,8 @@ public:
 	bool IsBuiltInFont() override { return true; }
 
 private:
-	std::unordered_map<GlyphID, SpriteID> glyph_to_spriteid_map{}; ///< Mapping of glyphs to sprite IDs.
-	SpriteID GetUnicodeGlyph(GlyphID key);
+	std::unordered_map<char32_t, SpriteID> char_map{}; ///< Mapping of characters to sprite IDs.
+	SpriteID GetUnicodeGlyph(char32_t key);
 };
 
 #endif /* SPRITEFONTCACHE_H */

src/game/game_info.cpp

@@ -78,7 +78,7 @@ template <> SQInteger PushClassName<GameInfo, ScriptType::GS>(HSQUIRRELVM vm) {
 	/* Remove the link to the real instance, else it might get deleted by RegisterGame() */
 	sq_setinstanceup(vm, 2, nullptr);
 	/* Register the Game to the base system */
-	info->GetScanner()->RegisterScript(info);
+	info->GetScanner()->RegisterScript(std::unique_ptr<GameInfo>{info});
 	return 0;
 }
 
@@ -106,22 +106,21 @@ bool GameInfo::CanLoadFromVersion(int version) const
 /* static */ SQInteger GameLibrary::Constructor(HSQUIRRELVM vm)
 {
 	/* Create a new library */
-	GameLibrary *library = new GameLibrary();
+	auto library = std::make_unique<GameLibrary>();
 
 	SQInteger res = ScriptInfo::Constructor(vm, *library);
 	if (res != 0) {
-		delete library;
 		return res;
 	}
 
 	/* Cache the category */
 	if (!library->CheckMethod("GetCategory") || !library->engine->CallStringMethod(library->SQ_instance, "GetCategory", &library->category, MAX_GET_OPS)) {
-		delete library;
 		return SQ_ERROR;
 	}
 
 	/* Register the Library to the base system */
-	library->GetScanner()->RegisterScript(library);
+	ScriptScanner *scanner = library->GetScanner();
+	scanner->RegisterScript(std::move(library));
 
 	return 0;
 }

src/game/game_scanner.cpp

@@ -92,8 +92,8 @@ GameLibrary *GameScannerLibrary::FindLibrary(const std::string &library, int ver
 	std::string library_name = fmt::format("{}.{}", library, version);
 
 	/* Check if the library + version exists */
-	ScriptInfoList::iterator it = this->info_list.find(library_name);
+	auto it = this->info_list.find(library_name);
 	if (it == this->info_list.end()) return nullptr;
 
-	return static_cast<GameLibrary *>((*it).second);
+	return static_cast<GameLibrary *>(it->second);
 }

src/newgrf/newgrf_act0_roadstops.cpp

@@ -105,8 +105,8 @@ static ChangeInfoResult RoadStopChangeInfo(uint first, uint last, int prop, Byte
 				AddStringForMapping(GRFStringID{buf.ReadWord()}, [rs = rs.get()](StringID str) { RoadStopClass::Get(rs->class_index)->name = str; });
 				break;
 
-			case 0x0C: // The draw mode
-				rs->draw_mode = static_cast<RoadStopDrawMode>(buf.ReadByte());
+			case 0x0C: // The draw modes
+				rs->draw_mode = static_cast<RoadStopDrawModes>(buf.ReadByte());
 				break;
 
 			case 0x0D: // Cargo types for random triggers

src/newgrf_roadstop.cpp

@@ -298,7 +298,7 @@ void DrawRoadStopTile(int x, int y, RoadType roadtype, const RoadStopSpec *spec,
 
 	RoadStopDrawModes draw_mode;
 	if (spec->flags.Test(RoadStopSpecFlag::DrawModeRegister)) {
-		draw_mode = static_cast<RoadStopDrawMode>(object.GetRegister(0x100));
+		draw_mode = static_cast<RoadStopDrawModes>(object.GetRegister(0x100));
 	} else {
 		draw_mode = spec->draw_mode;
 	}

src/script/api/script_controller.cpp

@@ -76,7 +76,7 @@ ScriptController::ScriptController(::CompanyID company) :
 
 /* static */ uint ScriptController::GetTick()
 {
-	return ScriptObject::GetActiveInstance().GetController()->ticks;
+	return ScriptObject::GetActiveInstance().GetController().ticks;
 }
 
 /* static */ int ScriptController::GetOpsTillSuspend()
@@ -96,9 +96,9 @@ ScriptController::ScriptController(::CompanyID company) :
 
 /* static */ HSQOBJECT ScriptController::Import(const std::string &library, const std::string &class_name, int version)
 {
-	ScriptController *controller = ScriptObject::GetActiveInstance().GetController();
-	Squirrel *engine = ScriptObject::GetActiveInstance().engine;
-	HSQUIRRELVM vm = engine->GetVM();
+	ScriptController &controller = ScriptObject::GetActiveInstance().GetController();
+	Squirrel &engine = *ScriptObject::GetActiveInstance().engine;
+	HSQUIRRELVM vm = engine.GetVM();
 
 	ScriptInfo *lib = ScriptObject::GetActiveInstance().FindLibrary(library, version);
 	if (lib == nullptr) {
@@ -114,11 +114,11 @@ ScriptController::ScriptController(::CompanyID company) :
 
 	std::string fake_class;
 
-	LoadedLibraryList::iterator it = controller->loaded_library.find(library_name);
-	if (it != controller->loaded_library.end()) {
+	LoadedLibraryList::iterator it = controller.loaded_library.find(library_name);
+	if (it != controller.loaded_library.end()) {
 		fake_class = (*it).second;
 	} else {
-		int next_number = ++controller->loaded_library_count;
+		int next_number = ++controller.loaded_library_count;
 
 		/* Create a new fake internal name */
 		fake_class = fmt::format("_internalNA{}", next_number);
@@ -128,14 +128,14 @@ ScriptController::ScriptController(::CompanyID company) :
 		sq_pushstring(vm, fake_class);
 		sq_newclass(vm, SQFalse);
 		/* Load the library */
-		if (!engine->LoadScript(vm, lib->GetMainScript(), false)) {
+		if (!engine.LoadScript(vm, lib->GetMainScript(), false)) {
 			throw sq_throwerror(vm, fmt::format("there was a compile error when importing '{}' version {}", library, version));
 		}
 		/* Create the fake class */
 		sq_newslot(vm, -3, SQFalse);
 		sq_pop(vm, 1);
 
-		controller->loaded_library[library_name] = fake_class;
+		controller.loaded_library[library_name] = fake_class;
 	}
 
 	/* Find the real class inside the fake class (like 'sets.Vector') */

src/script/api/script_object.cpp

@@ -45,7 +45,7 @@ void SimpleCountedObject::Release()
  * Get the storage associated with the current ScriptInstance.
  * @return The storage.
  */
-static ScriptStorage *GetStorage()
+static ScriptStorage &GetStorage()
 {
 	return ScriptObject::GetActiveInstance().GetStorage();
 }
@@ -65,7 +65,7 @@ ScriptObject::ActiveInstance::~ActiveInstance()
 }
 
 ScriptObject::DisableDoCommandScope::DisableDoCommandScope()
-	: AutoRestoreBackup(GetStorage()->allow_do_command, false)
+	: AutoRestoreBackup(GetStorage().allow_do_command, false)
 {}
 
 /* static */ ScriptInstance &ScriptObject::GetActiveInstance()
@@ -78,181 +78,181 @@ ScriptObject::DisableDoCommandScope::DisableDoCommandScope()
 /* static */ void ScriptObject::SetDoCommandDelay(uint ticks)
 {
 	assert(ticks > 0);
-	GetStorage()->delay = ticks;
+	GetStorage().delay = ticks;
 }
 
 /* static */ uint ScriptObject::GetDoCommandDelay()
 {
-	return GetStorage()->delay;
+	return GetStorage().delay;
 }
 
 /* static */ void ScriptObject::SetDoCommandMode(ScriptModeProc *proc, ScriptObject *instance)
 {
-	GetStorage()->mode = proc;
-	GetStorage()->mode_instance = instance;
+	GetStorage().mode = proc;
+	GetStorage().mode_instance = instance;
 }
 
 /* static */ ScriptModeProc *ScriptObject::GetDoCommandMode()
 {
-	return GetStorage()->mode;
+	return GetStorage().mode;
 }
 
 /* static */ ScriptObject *ScriptObject::GetDoCommandModeInstance()
 {
-	return GetStorage()->mode_instance;
+	return GetStorage().mode_instance;
 }
 
 /* static */ void ScriptObject::SetDoCommandAsyncMode(ScriptAsyncModeProc *proc, ScriptObject *instance)
 {
-	GetStorage()->async_mode = proc;
-	GetStorage()->async_mode_instance = instance;
+	GetStorage().async_mode = proc;
+	GetStorage().async_mode_instance = instance;
 }
 
 /* static */ ScriptAsyncModeProc *ScriptObject::GetDoCommandAsyncMode()
 {
-	return GetStorage()->async_mode;
+	return GetStorage().async_mode;
 }
 
 /* static */ ScriptObject *ScriptObject::GetDoCommandAsyncModeInstance()
 {
-	return GetStorage()->async_mode_instance;
+	return GetStorage().async_mode_instance;
 }
 
 /* static */ void ScriptObject::SetLastCommand(const CommandDataBuffer &data, Commands cmd)
 {
-	ScriptStorage *s = GetStorage();
-	Debug(script, 6, "SetLastCommand company={:02d} cmd={} data={}", s->root_company, cmd, FormatArrayAsHex(data));
-	s->last_data = data;
-	s->last_cmd = cmd;
+	ScriptStorage &s = GetStorage();
+	Debug(script, 6, "SetLastCommand company={:02d} cmd={} data={}", s.root_company, cmd, FormatArrayAsHex(data));
+	s.last_data = data;
+	s.last_cmd = cmd;
 }
 
 /* static */ bool ScriptObject::CheckLastCommand(const CommandDataBuffer &data, Commands cmd)
 {
-	ScriptStorage *s = GetStorage();
-	Debug(script, 6, "CheckLastCommand company={:02d} cmd={} data={}", s->root_company, cmd, FormatArrayAsHex(data));
-	if (s->last_cmd != cmd) return false;
-	if (s->last_data != data) return false;
+	ScriptStorage &s = GetStorage();
+	Debug(script, 6, "CheckLastCommand company={:02d} cmd={} data={}", s.root_company, cmd, FormatArrayAsHex(data));
+	if (s.last_cmd != cmd) return false;
+	if (s.last_data != data) return false;
 	return true;
 }
 
 /* static */ void ScriptObject::SetDoCommandCosts(Money value)
 {
-	GetStorage()->costs = CommandCost(INVALID_EXPENSES, value); // Expense type is never read.
+	GetStorage().costs = CommandCost(INVALID_EXPENSES, value); // Expense type is never read.
 }
 
 /* static */ void ScriptObject::IncreaseDoCommandCosts(Money value)
 {
-	GetStorage()->costs.AddCost(value);
+	GetStorage().costs.AddCost(value);
 }
 
 /* static */ Money ScriptObject::GetDoCommandCosts()
 {
-	return GetStorage()->costs.GetCost();
+	return GetStorage().costs.GetCost();
 }
 
 /* static */ void ScriptObject::SetLastError(ScriptErrorType last_error)
 {
-	GetStorage()->last_error = last_error;
+	GetStorage().last_error = last_error;
 }
 
 /* static */ ScriptErrorType ScriptObject::GetLastError()
 {
-	return GetStorage()->last_error;
+	return GetStorage().last_error;
 }
 
 /* static */ void ScriptObject::SetLastCost(Money last_cost)
 {
-	GetStorage()->last_cost = last_cost;
+	GetStorage().last_cost = last_cost;
 }
 
 /* static */ Money ScriptObject::GetLastCost()
 {
-	return GetStorage()->last_cost;
+	return GetStorage().last_cost;
 }
 
 /* static */ void ScriptObject::SetRoadType(RoadType road_type)
 {
-	GetStorage()->road_type = road_type;
+	GetStorage().road_type = road_type;
 }
 
 /* static */ RoadType ScriptObject::GetRoadType()
 {
-	return GetStorage()->road_type;
+	return GetStorage().road_type;
 }
 
 /* static */ void ScriptObject::SetRailType(RailType rail_type)
 {
-	GetStorage()->rail_type = rail_type;
+	GetStorage().rail_type = rail_type;
 }
 
 /* static */ RailType ScriptObject::GetRailType()
 {
-	return GetStorage()->rail_type;
+	return GetStorage().rail_type;
 }
 
 /* static */ void ScriptObject::SetLastCommandRes(bool res)
 {
-	GetStorage()->last_command_res = res;
+	GetStorage().last_command_res = res;
 }
 
 /* static */ bool ScriptObject::GetLastCommandRes()
 {
-	return GetStorage()->last_command_res;
+	return GetStorage().last_command_res;
 }
 
 /* static */ void ScriptObject::SetLastCommandResData(CommandDataBuffer data)
 {
-	GetStorage()->last_cmd_ret = std::move(data);
+	GetStorage().last_cmd_ret = std::move(data);
 }
 
 /* static */ const CommandDataBuffer &ScriptObject::GetLastCommandResData()
 {
-	return GetStorage()->last_cmd_ret;
+	return GetStorage().last_cmd_ret;
 }
 
 /* static */ void ScriptObject::SetCompany(::CompanyID company)
 {
-	if (GetStorage()->root_company == INVALID_OWNER) GetStorage()->root_company = company;
-	GetStorage()->company = company;
+	if (GetStorage().root_company == INVALID_OWNER) GetStorage().root_company = company;
+	GetStorage().company = company;
 
 	_current_company = company;
 }
 
 /* static */ ::CompanyID ScriptObject::GetCompany()
 {
-	return GetStorage()->company;
+	return GetStorage().company;
 }
 
 /* static */ ::CompanyID ScriptObject::GetRootCompany()
 {
-	return GetStorage()->root_company;
+	return GetStorage().root_company;
 }
 
 /* static */ bool ScriptObject::CanSuspend()
 {
 	Squirrel *squirrel = ScriptObject::GetActiveInstance().engine;
-	return GetStorage()->allow_do_command && squirrel->CanSuspend();
+	return GetStorage().allow_do_command && squirrel->CanSuspend();
 }
 
 /* static */ ScriptEventQueue &ScriptObject::GetEventQueue()
 {
-	return GetStorage()->event_queue;
+	return GetStorage().event_queue;
 }
 
 /* static */ ScriptLogTypes::LogData &ScriptObject::GetLogData()
 {
-	return GetStorage()->log_data;
+	return GetStorage().log_data;
 }
 
 /* static */ void ScriptObject::SetCallbackVariable(int index, int value)
 {
-	if (static_cast<size_t>(index) >= GetStorage()->callback_value.size()) GetStorage()->callback_value.resize(index + 1);
-	GetStorage()->callback_value[index] = value;
+	if (static_cast<size_t>(index) >= GetStorage().callback_value.size()) GetStorage().callback_value.resize(index + 1);
+	GetStorage().callback_value[index] = value;
 }
 
 /* static */ int ScriptObject::GetCallbackVariable(int index)
 {
-	return GetStorage()->callback_value[index];
+	return GetStorage().callback_value[index];
 }
 
 /* static */ CommandCallbackData *ScriptObject::GetDoCommandCallback()
@@ -310,8 +310,8 @@ ScriptObject::DisableDoCommandScope::DisableDoCommandScope()
 		IncreaseDoCommandCosts(res.GetCost());
 		if (!_generating_world) {
 			/* Charge a nominal fee for asynchronously executed commands */
-			Squirrel *engine = ScriptObject::GetActiveInstance().engine;
-			Squirrel::DecreaseOps(engine->GetVM(), 100);
+			Squirrel &engine = *ScriptObject::GetActiveInstance().engine;
+			Squirrel::DecreaseOps(engine.GetVM(), 100);
 		}
 		if (callback != nullptr) {
 			/* Insert return value into to stack and throw a control code that

src/script/script_instance.cpp

@@ -24,10 +24,12 @@
 #include "api/script_event.hpp"
 #include "api/script_log.hpp"
 
-#include "../company_base.h"
-#include "../company_func.h"
+#include "../company_type.h"
 #include "../fileio_func.h"
+#include "../goal_type.h"
 #include "../league_type.h"
+#include "../signs_type.h"
+#include "../story_type.h"
 #include "../misc/endian_buffer.hpp"
 
 #include "../safeguards.h"
@@ -98,7 +100,7 @@ void ScriptInstance::Initialize(const std::string &main_script, const std::strin
 
 void ScriptInstance::RegisterAPI()
 {
-	squirrel_register_std(this->engine);
+	squirrel_register_std(*this->engine);
 }
 
 bool ScriptInstance::LoadCompatibilityScript(std::string_view api_version, Subdirectory dir)
@@ -316,9 +318,10 @@ void ScriptInstance::CollectGarbage()
 }
 
 
-ScriptStorage *ScriptInstance::GetStorage()
+ScriptStorage &ScriptInstance::GetStorage()
 {
-	return this->storage;
+	assert(this->storage != nullptr);
+	return *this->storage;
 }
 
 ScriptLogTypes::LogData &ScriptInstance::GetLogData()

src/script/script_instance.hpp

@@ -91,7 +91,7 @@ public:
 	/**
 	 * Get the storage of this script.
 	 */
-	class ScriptStorage *GetStorage();
+	class ScriptStorage &GetStorage();
 
 	/**
 	 * Get the log pointer of this script.
@@ -146,7 +146,11 @@ public:
 	/**
 	 * Get the controller attached to the instance.
 	 */
-	class ScriptController *GetController() { return controller; }
+	class ScriptController &GetController()
+	{
+		assert(this->controller != nullptr);
+		return *this->controller;
+	}
 
 	/**
 	 * Return the "this script died" value

src/script/script_scanner.cpp

@@ -44,10 +44,7 @@ bool ScriptScanner::AddFile(const std::string &filename, size_t, const std::stri
 	return true;
 }
 
-ScriptScanner::ScriptScanner() :
-	engine(nullptr)
-{
-}
+ScriptScanner::ScriptScanner() = default;
 
 void ScriptScanner::ResetEngine()
 {
@@ -58,7 +55,7 @@ void ScriptScanner::ResetEngine()
 
 void ScriptScanner::Initialize(std::string_view name)
 {
-	this->engine = new Squirrel(name);
+	this->engine = std::make_unique<Squirrel>(name);
 
 	this->RescanDir();
 
@@ -68,8 +65,6 @@ void ScriptScanner::Initialize(std::string_view name)
 ScriptScanner::~ScriptScanner()
 {
 	this->Reset();
-
-	delete this->engine;
 }
 
 void ScriptScanner::RescanDir()
@@ -83,15 +78,12 @@ void ScriptScanner::RescanDir()
 
 void ScriptScanner::Reset()
 {
-	for (const auto &item : this->info_list) {
-		delete item.second;
-	}
-
 	this->info_list.clear();
 	this->info_single_list.clear();
+	this->info_vector.clear();
 }
 
-void ScriptScanner::RegisterScript(ScriptInfo *info)
+void ScriptScanner::RegisterScript(std::unique_ptr<ScriptInfo> &&info)
 {
 	std::string script_original_name = this->GetScriptName(*info);
 	std::string script_name = fmt::format("{}.{}", script_original_name, info->GetVersion());
@@ -99,7 +91,6 @@ void ScriptScanner::RegisterScript(ScriptInfo *info)
 	/* Check if GetShortName follows the rules */
 	if (info->GetShortName().size() != 4) {
 		Debug(script, 0, "The script '{}' returned a string from GetShortName() which is not four characters. Unable to load the script.", info->GetName());
-		delete info;
 		return;
 	}
 
@@ -111,7 +102,6 @@ void ScriptScanner::RegisterScript(ScriptInfo *info)
 #else
 		if (it->second->GetMainScript() == info->GetMainScript()) {
 #endif
-			delete info;
 			return;
 		}
 
@@ -120,20 +110,20 @@ void ScriptScanner::RegisterScript(ScriptInfo *info)
 		Debug(script, 1, "  2: {}", info->GetMainScript());
 		Debug(script, 1, "The first is taking precedence.");
 
-		delete info;
 		return;
 	}
 
-	this->info_list[script_name] = info;
+	ScriptInfo *script_info = this->info_vector.emplace_back(std::move(info)).get();
+	this->info_list[script_name] = script_info;
 
-	if (!info->IsDeveloperOnly() || _settings_client.gui.ai_developer_tools) {
+	if (!script_info->IsDeveloperOnly() || _settings_client.gui.ai_developer_tools) {
 		/* Add the script to the 'unique' script list, where only the highest version
 		 *  of the script is registered. */
 		auto it = this->info_single_list.find(script_original_name);
 		if (it == this->info_single_list.end()) {
-			this->info_single_list[script_original_name] = info;
-		} else if (it->second->GetVersion() < info->GetVersion()) {
-			it->second = info;
+			this->info_single_list[script_original_name] = script_info;
+		} else if (it->second->GetVersion() < script_info->GetVersion()) {
+			it->second = script_info;
 		}
 	}
 }
@@ -195,17 +185,17 @@ struct ScriptFileChecksumCreator : FileScanner {
  * @param info The script to get the shortname and md5 sum from.
  * @return True iff they're the same.
  */
-static bool IsSameScript(const ContentInfo &ci, bool md5sum, ScriptInfo *info, Subdirectory dir)
+static bool IsSameScript(const ContentInfo &ci, bool md5sum, const ScriptInfo &info, Subdirectory dir)
 {
 	uint32_t id = 0;
-	auto str = std::string_view{info->GetShortName()}.substr(0, 4);
+	auto str = std::string_view{info.GetShortName()}.substr(0, 4);
 	for (size_t j = 0; j < str.size(); j++) id |= static_cast<uint8_t>(str[j]) << (8 * j);
 
 	if (id != ci.unique_id) return false;
 	if (!md5sum) return true;
 
 	ScriptFileChecksumCreator checksum(dir);
-	const auto &tar_filename = info->GetTarFile();
+	const auto &tar_filename = info.GetTarFile();
 	TarList::iterator iter;
 	if (!tar_filename.empty() && (iter = _tar_list[dir].find(tar_filename)) != _tar_list[dir].end()) {
 		/* The main script is in a tar file, so find all files that
@@ -224,7 +214,7 @@ static bool IsSameScript(const ContentInfo &ci, bool md5sum, ScriptInfo *info, S
 		/* There'll always be at least 1 path separator character in a script
 		 * main script name as the search algorithm requires the main script to
 		 * be in a subdirectory of the script directory; so <dir>/<path>/main.nut. */
-		const std::string &main_script = info->GetMainScript();
+		const std::string &main_script = info.GetMainScript();
 		std::string path = main_script.substr(0, main_script.find_last_of(PATHSEPCHAR));
 		checksum.Scan(".nut", path);
 	}
@@ -235,7 +225,7 @@ static bool IsSameScript(const ContentInfo &ci, bool md5sum, ScriptInfo *info, S
 bool ScriptScanner::HasScript(const ContentInfo &ci, bool md5sum)
 {
 	for (const auto &item : this->info_list) {
-		if (IsSameScript(ci, md5sum, item.second, this->GetDirectory())) return true;
+		if (IsSameScript(ci, md5sum, *item.second, this->GetDirectory())) return true;
 	}
 	return false;
 }
@@ -243,7 +233,7 @@ bool ScriptScanner::HasScript(const ContentInfo &ci, bool md5sum)
 std::optional<std::string_view> ScriptScanner::FindMainScript(const ContentInfo &ci, bool md5sum)
 {
 	for (const auto &item : this->info_list) {
-		if (IsSameScript(ci, md5sum, item.second, this->GetDirectory())) return item.second->GetMainScript();
+		if (IsSameScript(ci, md5sum, *item.second, this->GetDirectory())) return item.second->GetMainScript();
 	}
 	return std::nullopt;
 }

src/script/script_scanner.hpp

@@ -13,7 +13,7 @@
 #include "../fileio_func.h"
 #include "../string_func.h"
 
-typedef std::map<std::string, class ScriptInfo *, CaseInsensitiveComparator> ScriptInfoList; ///< Type for the list of scripts.
+using ScriptInfoList = std::map<std::string, class ScriptInfo *, CaseInsensitiveComparator>; ///< Type for the list of scripts.
 
 /** Scanner to help finding scripts. */
 class ScriptScanner : public FileScanner {
@@ -26,7 +26,7 @@ public:
 	/**
 	 * Get the engine of the main squirrel handler (it indexes all available scripts).
 	 */
-	class Squirrel *GetEngine() { return this->engine; }
+	class Squirrel *GetEngine() { return this->engine.get(); }
 
 	/**
 	 * Get the current main script the ScanDir is currently tracking.
@@ -51,7 +51,7 @@ public:
 	/**
 	 * Register a ScriptInfo to the scanner.
 	 */
-	void RegisterScript(class ScriptInfo *info);
+	void RegisterScript(std::unique_ptr<class ScriptInfo> &&info);
 
 	/**
 	 * Get the list of registered scripts to print on the console.
@@ -84,10 +84,12 @@ public:
 	void RescanDir();
 
 protected:
-	class Squirrel *engine;  ///< The engine we're scanning with.
+	std::unique_ptr<class Squirrel> engine; ///< The engine we're scanning with.
 	std::string main_script; ///< The full path of the script.
 	std::string tar_file;    ///< If, which tar file the script was in.
 
+	std::vector<std::unique_ptr<ScriptInfo>> info_vector;
+
 	ScriptInfoList info_list; ///< The list of all script.
 	ScriptInfoList info_single_list; ///< The list of all unique script. The best script (highest version) is shown.
 

src/script/script_storage.hpp

@@ -12,12 +12,10 @@
 
 #include <queue>
 
-#include "../signs_func.h"
-#include "../vehicle_func.h"
+#include "../command_type.h"
+#include "../company_type.h"
+#include "../rail_type.h"
 #include "../road_type.h"
-#include "../group.h"
-#include "../goal_type.h"
-#include "../story_type.h"
 
 #include "script_types.hpp"
 #include "script_log_types.hpp"

src/script/squirrel.cpp

@@ -536,7 +536,7 @@ void Squirrel::Initialize()
 	sq_setforeignptr(this->vm, this);
 
 	sq_pushroottable(this->vm);
-	squirrel_register_global_std(this);
+	squirrel_register_global_std(*this);
 
 	/* Set consts table as delegate of root table, so consts/enums defined via require() are accessible */
 	sq_pushconsttable(this->vm);

src/script/squirrel_std.cpp

@@ -82,20 +82,20 @@ SQInteger SquirrelStd::notifyallexceptions(HSQUIRRELVM vm)
 	return SQ_ERROR;
 }
 
-void squirrel_register_global_std(Squirrel *engine)
+void squirrel_register_global_std(Squirrel &engine)
 {
 	/* We don't use squirrel_helper here, as we want to register to the global
 	 *  scope and not to a class. */
-	engine->AddMethod("require",             &SquirrelStd::require,             ".s");
-	engine->AddMethod("notifyallexceptions", &SquirrelStd::notifyallexceptions, ".b");
+	engine.AddMethod("require",             &SquirrelStd::require,             ".s");
+	engine.AddMethod("notifyallexceptions", &SquirrelStd::notifyallexceptions, ".b");
 }
 
-void squirrel_register_std(Squirrel *engine)
+void squirrel_register_std(Squirrel &engine)
 {
 	/* We don't use squirrel_helper here, as we want to register to the global
 	 *  scope and not to a class. */
-	engine->AddMethod("min", &SquirrelStd::min, ".ii");
-	engine->AddMethod("max", &SquirrelStd::max, ".ii");
+	engine.AddMethod("min", &SquirrelStd::min, ".ii");
+	engine.AddMethod("max", &SquirrelStd::max, ".ii");
 
-	sqstd_register_mathlib(engine->GetVM());
+	sqstd_register_mathlib(engine.GetVM());
 }

src/script/squirrel_std.hpp

@@ -52,12 +52,12 @@ public:
 /**
  * Register all standard functions we want to give to a script.
  */
-void squirrel_register_std(Squirrel *engine);
+void squirrel_register_std(Squirrel &engine);
 
 /**
  * Register all standard functions that are available on first startup.
  * @note this set is very limited, and is only meant to load other scripts and things like that.
  */
-void squirrel_register_global_std(Squirrel *engine);
+void squirrel_register_global_std(Squirrel &engine);
 
 #endif /* SQUIRREL_STD_HPP */

src/station_cmd.cpp

@@ -3331,7 +3331,7 @@ draw_default_foundation:
 			auto result = GetRoadStopLayout(ti, stopspec, st, type, view, regs100);
 			if (result.has_value()) {
 				if (stopspec->flags.Test(RoadStopSpecFlag::DrawModeRegister)) {
-					stop_draw_mode = static_cast<RoadStopDrawMode>(regs100[0]);
+					stop_draw_mode = static_cast<RoadStopDrawModes>(regs100[0]);
 				}
 				if (type == StationType::RoadWaypoint && stop_draw_mode.Test(RoadStopDrawMode::WaypGround)) {
 					draw_ground = true;

src/timetable_gui.cpp

@@ -427,6 +427,7 @@ struct TimetableWindow : Window {
 	void DrawTimetablePanel(const Rect &r) const
 	{
 		const Vehicle *v = this->vehicle;
+		if (v->GetNumOrders() == 0) return;
 		Rect tr = r.Shrink(WidgetDimensions::scaled.framerect);
 		int i = this->vscroll->GetPosition();
 		VehicleOrderID order_id = (i + 1) / 2;

src/video/win32_v.cpp

@@ -401,6 +401,40 @@ static void CancelIMEComposition(HWND hwnd)
 	HandleTextInput({}, true);
 }
 
+#if defined(_MSC_VER) && defined(NTDDI_WIN10_RS4)
+/* We only use WinRT functions on Windows 10 or later. Unfortunately, newer Windows SDKs are now
+ * linking the two functions below directly instead of using dynamic linking as previously.
+ * To avoid any runtime linking errors on Windows 7 or older, we stub in our own dynamic
+ * linking trampoline. */
+
+static LibraryLoader _combase("combase.dll");
+
+extern "C" int32_t __stdcall WINRT_IMPL_RoOriginateLanguageException(int32_t error, void *message, void *languageException) noexcept
+{
+	typedef BOOL(WINAPI *PFNRoOriginateLanguageException)(int32_t, void *, void *);
+	static PFNRoOriginateLanguageException RoOriginateLanguageException = _combase.GetFunction("RoOriginateLanguageException");
+
+	if (RoOriginateLanguageException != nullptr) {
+		return RoOriginateLanguageException(error, message, languageException);
+	} else {
+		return TRUE;
+	}
+}
+
+extern "C" int32_t __stdcall WINRT_IMPL_RoGetActivationFactory(void *classId, winrt::guid const &iid, void **factory) noexcept
+{
+	typedef BOOL(WINAPI *PFNRoGetActivationFactory)(void *, winrt::guid const &, void **);
+	static PFNRoGetActivationFactory RoGetActivationFactory = _combase.GetFunction("RoGetActivationFactory");
+
+	if (RoGetActivationFactory != nullptr) {
+		return RoGetActivationFactory(classId, iid, factory);
+	} else {
+		*factory = nullptr;
+		return winrt::impl::error_class_not_available;
+	}
+}
+#endif
+
 static bool IsDarkModeEnabled()
 {
 	/* Only build if SDK is Windows 10 1803 or later. */