From e6cdbb2e71ee443ae1931c39bb8589135ee24c60 Mon Sep 17 00:00:00 2001 From: Oliver Hamlet Date: Fri, 28 Jun 2024 18:38:36 +0100 Subject: [PATCH] Use Starfield plugins in Starfield tests --- cmake/tests.cmake | 4 +- src/tests/api/interface/game_interface_test.h | 140 +++++++++++------- src/tests/api/internals/game/game_test.h | 55 ++++--- src/tests/api/internals/plugin_test.h | 71 ++++++--- src/tests/common_game_test_fixture.h | 114 ++++++++++---- 5 files changed, 263 insertions(+), 121 deletions(-) diff --git a/cmake/tests.cmake b/cmake/tests.cmake index 5241d78b..c94c6305 100644 --- a/cmake/tests.cmake +++ b/cmake/tests.cmake @@ -20,8 +20,8 @@ FetchContent_Declare( FetchContent_Declare( testing-plugins - URL "https://github.com/Ortham/testing-plugins/archive/1.5.0.tar.gz" - URL_HASH "SHA256=98c9094fb0f0152b1af7a6206950207f7ddc6602cd44ed67ebf70603ef490791") + URL "https://github.com/Ortham/testing-plugins/archive/1.6.2.tar.gz" + URL_HASH "SHA256=f6e5b55e2669993ab650ba470424b725d1fab71ace979134a77de3373bd55620") FetchContent_MakeAvailable(GTest testing-plugins) diff --git a/src/tests/api/interface/game_interface_test.h b/src/tests/api/interface/game_interface_test.h index 459114bf..f56be290 100644 --- a/src/tests/api/interface/game_interface_test.h +++ b/src/tests/api/interface/game_interface_test.h @@ -33,9 +33,22 @@ namespace test { class GameInterfaceTest : public ApiGameOperationsTest { protected: GameInterfaceTest() : - emptyFile("EmptyFile.esm"), - nonAsciiEsm(u8"non\u00C1scii.esm"), - pluginsToLoad({ + emptyFile("EmptyFile.esm"), nonAsciiEsm(u8"non\u00C1scii.esm") { + // Make sure the plugin with a non-ASCII filename exists. + std::filesystem::copy_file(dataPath / blankEsm, + dataPath / std::filesystem::u8path(nonAsciiEsm)); + + if (GetParam() == GameType::starfield) { + pluginsToLoad = { + masterFile, + blankEsm, + blankFullEsm, + blankMasterDependentEsm, + blankEsp, + blankMasterDependentEsp, + }; + } else { + pluginsToLoad = { // These are all ASCII filenames. masterFile, blankEsm, @@ -48,15 +61,13 @@ protected: blankDifferentMasterDependentEsp, blankPluginDependentEsp, blankDifferentPluginDependentEsp, - }) { - // Make sure the plugin with a non-ASCII filename exists. - std::filesystem::copy_file(dataPath / blankEsm, - dataPath / std::filesystem::u8path(nonAsciiEsm)); + }; + } } const std::string emptyFile; const std::string nonAsciiEsm; - const std::vector pluginsToLoad; + std::vector pluginsToLoad; }; // Pass an empty first argument, as it's a prefix for the test instantation, @@ -108,7 +119,11 @@ TEST_P( GameInterfaceTest, loadPluginsWithHeadersOnlyTrueShouldLoadTheHeadersOfAllInstalledPlugins) { handle_->LoadPlugins(pluginsToLoad, true); - EXPECT_EQ(11, handle_->GetLoadedPlugins().size()); + if (GetParam() == GameType::starfield) { + EXPECT_EQ(6, handle_->GetLoadedPlugins().size()); + } else { + EXPECT_EQ(11, handle_->GetLoadedPlugins().size()); + } // Check that one plugin's header has been read. ASSERT_NO_THROW(handle_->GetPlugin(masterFile)); @@ -132,7 +147,11 @@ TEST_P(GameInterfaceTest, loadPluginsShouldTrimDotGhostFileExtensions) { TEST_P(GameInterfaceTest, loadPluginsWithHeadersOnlyFalseShouldFullyLoadAllInstalledPlugins) { handle_->LoadPlugins(pluginsToLoad, false); - EXPECT_EQ(11, handle_->GetLoadedPlugins().size()); + if (GetParam() == GameType::starfield) { + EXPECT_EQ(6, handle_->GetLoadedPlugins().size()); + } else { + EXPECT_EQ(11, handle_->GetLoadedPlugins().size()); + } // Check that one plugin's header has been read. ASSERT_NO_THROW(handle_->GetPlugin(masterFile)); @@ -165,19 +184,31 @@ TEST_P(GameInterfaceTest, } TEST_P(GameInterfaceTest, sortPluginsShouldSucceedIfPassedValidArguments) { - std::vector expectedOrder = { - masterFile, - blankEsm, - blankMasterDependentEsm, - blankDifferentEsm, - blankDifferentMasterDependentEsm, - blankMasterDependentEsp, - blankDifferentMasterDependentEsp, - blankEsp, - blankPluginDependentEsp, - blankDifferentEsp, - blankDifferentPluginDependentEsp, - }; + std::vector expectedOrder; + if (GetParam() == GameType::starfield) { + expectedOrder = { + masterFile, + blankEsm, + blankFullEsm, + blankMasterDependentEsm, + blankEsp, + blankMasterDependentEsp, + }; + } else { + expectedOrder = { + masterFile, + blankEsm, + blankMasterDependentEsm, + blankDifferentEsm, + blankDifferentMasterDependentEsm, + blankMasterDependentEsp, + blankDifferentMasterDependentEsp, + blankEsp, + blankPluginDependentEsp, + blankDifferentEsp, + blankDifferentPluginDependentEsp, + }; + } if (GetParam() == GameType::fo4 || GetParam() == GameType::tes5se) { expectedOrder.insert(expectedOrder.begin() + 5, blankEsl); @@ -186,27 +217,12 @@ TEST_P(GameInterfaceTest, sortPluginsShouldSucceedIfPassedValidArguments) { ASSERT_NO_THROW(GenerateMasterlist()); ASSERT_NO_THROW(handle_->GetDatabase().LoadLists(masterlistPath, "")); - std::vector pluginsToSort({ - // These are all ASCII filenames. - blankEsp, - blankPluginDependentEsp, - blankDifferentMasterDependentEsm, - blankMasterDependentEsp, - blankDifferentMasterDependentEsp, - blankDifferentEsp, - blankDifferentPluginDependentEsp, - masterFile, - blankEsm, - blankMasterDependentEsm, - blankDifferentEsm, - }); - if (GetParam() == GameType::fo4 || GetParam() == GameType::tes5se) { - pluginsToSort.push_back(blankEsl); + pluginsToLoad.push_back(blankEsl); } handle_->LoadCurrentLoadOrderState(); - std::vector actualOrder = handle_->SortPlugins(pluginsToSort); + std::vector actualOrder = handle_->SortPlugins(pluginsToLoad); EXPECT_EQ(expectedOrder, actualOrder); } @@ -245,27 +261,41 @@ TEST_P(GameInterfaceTest, setLoadOrderShouldSetTheLoadOrder) { handle_->SetAdditionalDataPaths({}); handle_->LoadCurrentLoadOrderState(); - std::vector loadOrder({ - masterFile, - blankEsm, - blankMasterDependentEsm, - blankDifferentEsm, - blankDifferentMasterDependentEsm, - blankDifferentEsp, - blankDifferentPluginDependentEsp, - blankEsp, - blankMasterDependentEsp, - blankDifferentMasterDependentEsp, - blankPluginDependentEsp, - }); const auto gameSupportsEsl = GetParam() == GameType::fo4 || GetParam() == GameType::fo4vr || GetParam() == GameType::tes5se || GetParam() == GameType::tes5vr || GetParam() == GameType::starfield; - if (gameSupportsEsl) { - loadOrder.insert(loadOrder.begin() + 5, blankEsl); + std::vector loadOrder; + if (GetParam() == GameType::starfield) { + loadOrder = { + masterFile, + blankEsm, + blankMasterDependentEsm, + blankDifferentEsm, + blankDifferentEsp, + blankEsp, + blankMasterDependentEsp, + }; + } else { + loadOrder = { + masterFile, + blankEsm, + blankMasterDependentEsm, + blankDifferentEsm, + blankDifferentMasterDependentEsm, + blankDifferentEsp, + blankDifferentPluginDependentEsp, + blankEsp, + blankMasterDependentEsp, + blankDifferentMasterDependentEsp, + blankPluginDependentEsp, + }; + + if (gameSupportsEsl) { + loadOrder.insert(loadOrder.begin() + 5, blankEsl); + } } EXPECT_NO_THROW(handle_->SetLoadOrder(loadOrder)); diff --git a/src/tests/api/internals/game/game_test.h b/src/tests/api/internals/game/game_test.h index ee1fa334..a76a266b 100644 --- a/src/tests/api/internals/game/game_test.h +++ b/src/tests/api/internals/game/game_test.h @@ -37,21 +37,34 @@ protected: } void loadInstalledPlugins(Game& game, bool headersOnly) { - const std::vector plugins({ - // These are all ASCII filenames. - masterFile, - blankEsm, - blankDifferentEsm, - blankMasterDependentEsm, - blankDifferentMasterDependentEsm, - blankEsp, - blankDifferentEsp, - blankMasterDependentEsp, - blankDifferentMasterDependentEsp, - blankPluginDependentEsp, - blankDifferentPluginDependentEsp, - }); - game.LoadPlugins(plugins, headersOnly); + if (GetParam() == GameType::starfield) { + const std::vector plugins({ + // These are all ASCII filenames. + masterFile, + blankEsm, + blankFullEsm, + blankMasterDependentEsm, + blankEsp, + blankMasterDependentEsp, + }); + game.LoadPlugins(plugins, headersOnly); + } else { + const std::vector plugins({ + // These are all ASCII filenames. + masterFile, + blankEsm, + blankDifferentEsm, + blankMasterDependentEsm, + blankDifferentMasterDependentEsm, + blankEsp, + blankDifferentEsp, + blankMasterDependentEsp, + blankDifferentMasterDependentEsp, + blankPluginDependentEsp, + blankDifferentPluginDependentEsp, + }); + game.LoadPlugins(plugins, headersOnly); + } } const std::string blankArchive; @@ -208,7 +221,11 @@ TEST_P( Game game = Game(GetParam(), dataPath.parent_path(), localPath); EXPECT_NO_THROW(loadInstalledPlugins(game, true)); - EXPECT_EQ(11, game.GetCache().GetPlugins().size()); + if (GetParam() == GameType::starfield) { + EXPECT_EQ(6, game.GetCache().GetPlugins().size()); + } else { + EXPECT_EQ(11, game.GetCache().GetPlugins().size()); + } // Check that one plugin's header has been read. ASSERT_NO_THROW(game.GetPlugin(masterFile)); @@ -252,7 +269,11 @@ TEST_P(GameTest, Game game = Game(GetParam(), dataPath.parent_path(), localPath); EXPECT_NO_THROW(loadInstalledPlugins(game, false)); - EXPECT_EQ(11, game.GetCache().GetPlugins().size()); + if (GetParam() == GameType::starfield) { + EXPECT_EQ(6, game.GetCache().GetPlugins().size()); + } else { + EXPECT_EQ(11, game.GetCache().GetPlugins().size()); + } // Check that one plugin's header has been read. ASSERT_NO_THROW(game.GetPlugin(blankEsm)); diff --git a/src/tests/api/internals/plugin_test.h b/src/tests/api/internals/plugin_test.h index a7fe3a59..3c4817b5 100644 --- a/src/tests/api/internals/plugin_test.h +++ b/src/tests/api/internals/plugin_test.h @@ -71,14 +71,6 @@ protected: std::filesystem::copy(dataPath / blankEsp, dataPath / blankEsl)); } - if (GetParam() == GameType::starfield) { - // The ESL flag is not the same as in Skyrim SE, so modify the file - // accordingly. - auto bytes = ReadFile(dataPath / blankEsl); - bytes[9] = 0x1; - WriteFile(dataPath / blankEsl, bytes); - } - // Copy across archive files. std::filesystem::path blankMasterDependentArchive; if (GetParam() == GameType::fo4 || GetParam() == GameType::fo4vr || @@ -265,6 +257,8 @@ TEST_P(PluginTest, loadingHeaderOnlyShouldReadHeaderData) { EXPECT_FLOAT_EQ(1.2f, plugin.GetHeaderVersion().value()); } else if (GetParam() == GameType::tes4) { EXPECT_FLOAT_EQ(0.8f, plugin.GetHeaderVersion().value()); + } else if (GetParam() == GameType::starfield) { + EXPECT_FLOAT_EQ(0.96f, plugin.GetHeaderVersion().value()); } else { EXPECT_FLOAT_EQ(0.94f, plugin.GetHeaderVersion().value()); } @@ -291,6 +285,8 @@ TEST_P(PluginTest, loadingWholePluginShouldReadHeaderData) { EXPECT_FLOAT_EQ(1.2f, plugin.GetHeaderVersion().value()); } else if (GetParam() == GameType::tes4) { EXPECT_FLOAT_EQ(0.8f, plugin.GetHeaderVersion().value()); + } else if (GetParam() == GameType::starfield) { + EXPECT_FLOAT_EQ(0.96f, plugin.GetHeaderVersion().value()); } else { EXPECT_FLOAT_EQ(0.94f, plugin.GetHeaderVersion().value()); } @@ -304,6 +300,8 @@ TEST_P(PluginTest, loadingWholePluginShouldReadFields) { if (GetParam() == GameType::tes3) { EXPECT_EQ(0, plugin.GetOverrideRecordCount()); + } else if (GetParam() == GameType::starfield) { + EXPECT_EQ(1, plugin.GetOverrideRecordCount()); } else { EXPECT_EQ(4, plugin.GetOverrideRecordCount()); } @@ -348,15 +346,15 @@ TEST_P( TEST_P(PluginTest, isOverridePluginShouldOnlyBeTrueForAStarfieldOverridePlugin) { - auto bytes = ReadFile(dataPath / blankDifferentPluginDependentEsp); + auto bytes = ReadFile(dataPath / blankMasterDependentEsp); bytes[9] = 0x2; - WriteFile(dataPath / blankDifferentPluginDependentEsp, bytes); + WriteFile(dataPath / blankMasterDependentEsp, bytes); Plugin plugin1( game_.GetType(), game_.GetCache(), game_.DataPath() / blankEsp, true); Plugin plugin2(game_.GetType(), game_.GetCache(), - game_.DataPath() / blankDifferentPluginDependentEsp, + game_.DataPath() / blankMasterDependentEsp, true); EXPECT_FALSE(plugin1.IsOverridePlugin()); @@ -369,7 +367,11 @@ TEST_P(PluginTest, loadingAPluginWithMastersShouldReadThemCorrectly) { game_.DataPath() / blankMasterDependentEsp, true); - EXPECT_EQ(std::vector({blankEsm}), plugin.GetMasters()); + if (GetParam() == GameType::starfield) { + EXPECT_EQ(std::vector({blankFullEsm}), plugin.GetMasters()); + } else { + EXPECT_EQ(std::vector({blankEsm}), plugin.GetMasters()); + } } TEST_P(PluginTest, loadingAPluginThatDoesNotExistShouldThrow) { @@ -484,9 +486,12 @@ TEST_P( TEST_P(PluginTest, loadsArchiveShouldReturnFalseForAPluginThatDoesNotLoadAnArchive) { + const auto pluginName = GetParam() == GameType::starfield + ? blankDifferentEsp + : blankDifferentMasterDependentEsp; EXPECT_FALSE(Plugin(game_.GetType(), game_.GetCache(), - game_.DataPath() / blankDifferentMasterDependentEsp, + game_.DataPath() / pluginName, true) .LoadsArchive()); } @@ -529,11 +534,18 @@ TEST_P( TEST_P( PluginTest, IsValidAsOverridePluginShouldOnlyReturnTrueForAStarfieldPluginWithNoNewRecords) { - Plugin plugin1( - game_.GetType(), game_.GetCache(), game_.DataPath() / blankEsp, false); + const auto sourcePluginName = + GetParam() == GameType::starfield ? blankFullEsm : blankEsp; + const auto overridePluginName = GetParam() == GameType::starfield + ? blankMasterDependentEsp + : blankDifferentPluginDependentEsp; + Plugin plugin1(game_.GetType(), + game_.GetCache(), + game_.DataPath() / sourcePluginName, + false); Plugin plugin2(game_.GetType(), game_.GetCache(), - game_.DataPath() / blankDifferentPluginDependentEsp, + game_.DataPath() / overridePluginName, false); EXPECT_FALSE(plugin1.IsValidAsOverridePlugin()); @@ -577,8 +589,11 @@ TEST_P(PluginTest, TEST_P(PluginTest, doRecordsOverlapShouldReturnTrueIfOnePluginOverridesTheOthersRecords) { + const auto plugin1Name = + GetParam() == GameType::starfield ? blankFullEsm : blankEsm; + Plugin plugin1( - game_.GetType(), game_.GetCache(), game_.DataPath() / blankEsm, false); + game_.GetType(), game_.GetCache(), game_.DataPath() / plugin1Name, false); Plugin plugin2(game_.GetType(), game_.GetCache(), game_.DataPath() / (blankMasterDependentEsm + ".ghost"), @@ -600,19 +615,29 @@ TEST_P(PluginTest, } TEST_P(PluginTest, getOverlapSizeShouldCountEachRecordOnce) { + const auto plugin1Name = + GetParam() == GameType::starfield ? blankFullEsm : blankEsm; + Plugin plugin1( - game_.GetType(), game_.GetCache(), game_.DataPath() / blankEsm, false); + game_.GetType(), game_.GetCache(), game_.DataPath() / plugin1Name, false); Plugin plugin2(game_.GetType(), game_.GetCache(), game_.DataPath() / (blankMasterDependentEsm + ".ghost"), false); - EXPECT_EQ(4, plugin1.GetOverlapSize({&plugin2, &plugin2})); + if (GetParam() == GameType::starfield) { + EXPECT_EQ(1, plugin1.GetOverlapSize({&plugin2, &plugin2})); + } else { + EXPECT_EQ(4, plugin1.GetOverlapSize({&plugin2, &plugin2})); + } } TEST_P(PluginTest, getOverlapSizeShouldCheckAgainstAllGivenPlugins) { + const auto plugin1Name = + GetParam() == GameType::starfield ? blankFullEsm : blankEsm; + Plugin plugin1( - game_.GetType(), game_.GetCache(), game_.DataPath() / blankEsm, false); + game_.GetType(), game_.GetCache(), game_.DataPath() / plugin1Name, false); Plugin plugin2( game_.GetType(), game_.GetCache(), game_.DataPath() / blankEsp, false); Plugin plugin3(game_.GetType(), @@ -620,7 +645,11 @@ TEST_P(PluginTest, getOverlapSizeShouldCheckAgainstAllGivenPlugins) { game_.DataPath() / (blankMasterDependentEsm + ".ghost"), false); - EXPECT_EQ(4, plugin1.GetOverlapSize({&plugin2, &plugin3})); + if (GetParam() == GameType::starfield) { + EXPECT_EQ(1, plugin1.GetOverlapSize({&plugin2, &plugin3})); + } else { + EXPECT_EQ(4, plugin1.GetOverlapSize({&plugin2, &plugin3})); + } } TEST_P(PluginTest, diff --git a/src/tests/common_game_test_fixture.h b/src/tests/common_game_test_fixture.h index 38fa86ec..dede8b85 100644 --- a/src/tests/common_game_test_fixture.h +++ b/src/tests/common_game_test_fixture.h @@ -65,6 +65,8 @@ protected: nonPluginFile("NotAPlugin.esm"), invalidPlugin("Invalid.esm"), blankEsm("Blank.esm"), + blankFullEsm("Blank.full.esm"), + blankMediumEsm("Blank.medium.esm"), blankDifferentEsm("Blank - Different.esm"), blankMasterDependentEsm("Blank - Master Dependent.esm"), blankDifferentMasterDependentEsm( @@ -97,19 +99,55 @@ protected: auto sourcePluginsPath = getSourcePluginsPath(); - copyPlugin(sourcePluginsPath, blankEsm); - copyPlugin(sourcePluginsPath, blankDifferentEsm); - copyPlugin(sourcePluginsPath, blankMasterDependentEsm); - copyPlugin(sourcePluginsPath, blankDifferentMasterDependentEsm); - copyPlugin(sourcePluginsPath, blankEsp); - copyPlugin(sourcePluginsPath, blankDifferentEsp); - copyPlugin(sourcePluginsPath, blankMasterDependentEsp); - copyPlugin(sourcePluginsPath, blankDifferentMasterDependentEsp); - copyPlugin(sourcePluginsPath, blankPluginDependentEsp); - copyPlugin(sourcePluginsPath, blankDifferentPluginDependentEsp); + if (GetParam() == GameType::starfield) { + copyPlugin(sourcePluginsPath, blankFullEsm); + copyPlugin(sourcePluginsPath, blankMediumEsm); + + std::filesystem::copy_file(sourcePluginsPath / blankFullEsm, + dataPath / blankEsm); + ASSERT_TRUE(exists(dataPath / blankEsm)); + + std::filesystem::copy_file(sourcePluginsPath / blankFullEsm, + dataPath / blankDifferentEsm); + ASSERT_TRUE(exists(dataPath / blankDifferentEsm)); + + std::filesystem::copy_file( + sourcePluginsPath / "Blank - Override.full.esm", + dataPath / blankMasterDependentEsm); + ASSERT_TRUE(exists(dataPath / blankMasterDependentEsm)); + + std::filesystem::copy_file(sourcePluginsPath / "Blank.esp", + dataPath / blankEsp); + ASSERT_TRUE(exists(dataPath / blankEsp)); + + std::filesystem::copy_file(sourcePluginsPath / blankEsp, + dataPath / blankDifferentEsp); + ASSERT_TRUE(exists(dataPath / blankDifferentEsp)); + + std::filesystem::copy_file(sourcePluginsPath / "Blank - Override.esp", + dataPath / blankMasterDependentEsp); + ASSERT_TRUE(exists(dataPath / blankMasterDependentEsp)); + } else { + copyPlugin(sourcePluginsPath, blankEsm); + copyPlugin(sourcePluginsPath, blankDifferentEsm); + copyPlugin(sourcePluginsPath, blankMasterDependentEsm); + copyPlugin(sourcePluginsPath, blankDifferentMasterDependentEsm); + copyPlugin(sourcePluginsPath, blankEsp); + copyPlugin(sourcePluginsPath, blankDifferentEsp); + copyPlugin(sourcePluginsPath, blankMasterDependentEsp); + copyPlugin(sourcePluginsPath, blankDifferentMasterDependentEsp); + copyPlugin(sourcePluginsPath, blankPluginDependentEsp); + copyPlugin(sourcePluginsPath, blankDifferentPluginDependentEsp); + } if (supportsLightPlugins(GetParam())) { - copyPlugin(sourcePluginsPath, blankEsl); + if (GetParam() == GameType::starfield) { + std::filesystem::copy_file(sourcePluginsPath / "Blank.small.esm", + dataPath / blankEsl); + ASSERT_TRUE(exists(dataPath / blankEsl)); + } else { + copyPlugin(sourcePluginsPath, blankEsl); + } } // Make sure the game master file exists. @@ -211,22 +249,40 @@ protected: } std::vector> getInitialLoadOrder() const { - auto loadOrder = std::vector>({ - {masterFile, true}, - {blankEsm, true}, - {blankDifferentEsm, false}, - {blankMasterDependentEsm, false}, - {blankDifferentMasterDependentEsm, false}, - {blankEsp, false}, - {blankDifferentEsp, false}, - {blankMasterDependentEsp, false}, - {blankDifferentMasterDependentEsp, true}, - {blankPluginDependentEsp, false}, - {blankDifferentPluginDependentEsp, false}, - }); + std::vector> loadOrder; - if (supportsLightPlugins(GetParam())) { - loadOrder.insert(loadOrder.begin() + 5, std::make_pair(blankEsl, false)); + if (GetParam() == GameType::starfield) { + loadOrder = { + {masterFile, true}, + {blankEsm, true}, + {blankDifferentEsm, false}, + {blankFullEsm, false}, + {blankMasterDependentEsm, false}, + {blankMediumEsm, false}, + {blankEsl, false}, + {blankEsp, false}, + {blankDifferentEsp, false}, + {blankMasterDependentEsp, false}, + }; + } else { + loadOrder = { + {masterFile, true}, + {blankEsm, true}, + {blankDifferentEsm, false}, + {blankMasterDependentEsm, false}, + {blankDifferentMasterDependentEsm, false}, + {blankEsp, false}, + {blankDifferentEsp, false}, + {blankMasterDependentEsp, false}, + {blankDifferentMasterDependentEsp, true}, + {blankPluginDependentEsp, false}, + {blankDifferentPluginDependentEsp, false}, + }; + + if (supportsLightPlugins(GetParam())) { + loadOrder.insert(loadOrder.begin() + 5, + std::make_pair(blankEsl, false)); + } } return loadOrder; @@ -238,6 +294,8 @@ protected: return absolute("./Morrowind/Data Files"); else if (GetParam() == GameType::tes4) return absolute("./Oblivion/Data"); + else if (GetParam() == GameType::starfield) + return absolute("./Starfield/Data"); else if (supportsLightPlugins(GetParam())) return absolute("./SkyrimSE/Data"); else @@ -267,6 +325,8 @@ protected: const std::string nonPluginFile; const std::string invalidPlugin; const std::string blankEsm; + const std::string blankFullEsm; + const std::string blankMediumEsm; const std::string blankDifferentEsm; const std::string blankMasterDependentEsm; const std::string blankDifferentMasterDependentEsm; @@ -315,6 +375,8 @@ private: return 0x790DC6FB; case GameType::tes4: return 0x374E2A6F; + case GameType::starfield: + return 0xDE586309; default: return 0x6A1273DC; }