Faster episode booting

LunaDll/GameConfig/GameAutostart.h

@@ -9,15 +9,6 @@ struct StartupEpisodeSettings;
 
 class GameAutostart
 {
-private:
-    //Settings
-    std::string selectedEpisode;
-    std::wstring selectedWldPath;
-    bool singleplayer;
-    Characters firstCharacter;
-    Characters secondCharacter;
-    int saveSlot;
-
 public:
     GameAutostart();
     ~GameAutostart();
@@ -29,6 +20,14 @@ class GameAutostart
     void setSaveSlot(int val) { saveSlot = val; }
 
     bool applyAutostart();
+
+    //Settings
+    std::string selectedEpisode;
+    std::wstring selectedWldPath;
+    bool singleplayer;
+    Characters firstCharacter;
+    Characters secondCharacter;
+    int saveSlot;
 };
 
 #endif

LunaDll/GlobalFuncs.cpp

@@ -19,6 +19,7 @@
 #include <iomanip>
 #include <fstream>
 #include <mutex>
+#include <cstddef>
 
 #include "Misc/MiscFuncs.h"
 #include "Input/Input.h"
@@ -727,6 +728,20 @@ std::string resolveIfNotAbsolutePath(std::string filename) {
     return filename;
 }
 
+std::string splitPathFromFilename(std::string str)
+{
+    replaceSubStr(str, "/", "\\");
+    std::string finalStr = str.substr(str.find_last_of("/\\") + 1);
+    return finalStr;
+}
+
+std::string splitFilenameFromPath(std::string str)
+{
+    replaceSubStr(str, "/", "\\");
+    std::string finalStr = str.substr(0, str.find_last_of("/\\"));
+    return finalStr;
+}
+
 
 std::string generateTimestamp(std::string format)
 {
@@ -852,6 +867,62 @@ std::wstring getCustomFolderPath()
     return full_path;
 }
 
+int findEpisodeIDFromWorldFileAndPath(std::string worldName)
+{
+    int id = 0;
+    for (int i = 1; i <= 100; i++) {
+        auto ep = EpisodeListItem::Get(i - 1);
+        if(worldName == std::string(ep->episodePath) + std::string(ep->episodeWorldFile))
+        {
+            id = i;
+            break;
+        }
+    }
+    return id - 1;
+}
+
+std::string findEpisodeWorldPathFromName(std::string name)
+{
+    if(name.empty())
+    {
+        return "";
+    }
+    std::string finalWldPath;
+    for (int i = 1; i <= 100; i++) {
+        auto ep = EpisodeListItem::Get(i - 1);
+        if(name == std::string(ep->episodeName))
+        {
+            finalWldPath = std::string(ep->episodePath) + std::string(ep->episodeWorldFile);
+            break;
+        }
+    }
+    return finalWldPath;
+}
+
+bool isBootingSinglePlayer()
+{
+    if(GM_PLAYERS_COUNT <= 1)
+    {
+        return true;
+    }
+    else if(GM_PLAYERS_COUNT > 1)
+    {
+        return false;
+    }
+}
+
+int getPlayer2Character()
+{
+    if(GM_PLAYERS_COUNT > 1)
+    {
+        return static_cast<int>(Player::Get(2)->Identity);
+    }
+    else
+    {
+        return 0;
+    }
+}
+
 std::wstring getLatestFile(const std::initializer_list<std::wstring>& paths)
 {
     FILETIME newest = { 0 };

LunaDll/GlobalFuncs.h

@@ -61,6 +61,8 @@ bool isAbsolutePath(const std::string& path);
 std::wstring resolveCwdOrWorldsPath(const std::wstring& path);
 std::wstring resolveIfNotAbsolutePath(std::wstring filename);
 std::string resolveIfNotAbsolutePath(std::string filename);
+std::string splitPathFromFilename(std::string str);
+std::string splitFilenameFromPath(std::string str);
 
 extern void removeFilePathW(std::wstring &path);
 extern void removeFilePathW(wchar_t*path, int length);
@@ -122,6 +124,10 @@ std::wstring getEpisodeFolderPath();
 std::wstring getCustomFolderPath();
 std::wstring getLatestFile(const std::initializer_list<std::wstring>& paths);
 std::wstring getLatestConfigFile(const std::wstring& configname);
+int findEpisodeIDFromWorldFileAndPath(std::string worldName);
+std::string findEpisodeWorldPathFromName(std::string name);
+bool isBootingSinglePlayer();
+int getPlayer2Character();
 
 template <typename T>
 T normalizeToBackslashAndResolvePath(const T& path)

LunaDll/Globals.cpp

@@ -134,3 +134,5 @@ void printBoxA(const char *fmt, ...)
 
 std::string gEditorPlacedItem = "nil";
 std::mutex g_editorIPCMutex;
+
+bool episodeLoadedOnBoot = false;

LunaDll/Globals.h

@@ -212,3 +212,5 @@ return;
 
 extern std::string gEditorPlacedItem;
 extern std::mutex g_editorIPCMutex;
+
+extern bool episodeLoadedOnBoot;

LunaDll/LuaMain/LuaProxy.h

@@ -909,7 +909,7 @@ namespace LuaProxy {
         void exitGame();
         void exitEngine();
         bool didGameOver();
-        bool loadEpisode(const std::string& episodeName);
+        bool loadEpisode(std::string episodeName);
         void pause();
         void pause(bool atFrameEnd);
         void unpause();

LunaDll/LuaMain/LuaProxyComponent/LuaProxyGlobalFunctions/LuaProxyGlobalFuncMisc.cpp

@@ -234,17 +234,36 @@ bool LuaProxy::Misc::didGameOver()
     return luaDidGameOverFlag;
 }
 
-bool LuaProxy::Misc::loadEpisode(const std::string& episodeName)
+bool LuaProxy::Misc::loadEpisode(std::string episodeName)
 {
-    GameAutostart autoStartEpisode;
-    autoStartEpisode.setSelectedEpisode(episodeName);
-    autoStartEpisode.setSaveSlot(GM_CUR_SAVE_SLOT);
-    bool success = autoStartEpisode.applyAutostart();
-    if (success)
+    bool success = false;
+
+    Characters storedIdentity1 = Player::Get(1)->Identity;
+    Characters storedIdentity2;
+
+    if(GM_PLAYERS_COUNT > 1)
+    {
+        storedIdentity2 = Player::Get(2)->Identity;
+    }
+    else if(GM_PLAYERS_COUNT <= 1)
     {
-        GM_EPISODE_MODE = 0;
-        GM_LEVEL_MODE = 0xFFFF;
+        storedIdentity2 = static_cast<Characters>(0);
     }
+
+    std::string worldPth = findEpisodeWorldPathFromName(episodeName);
+
+    if(!worldPth.empty() || worldPth != "")
+    {
+        success = true;
+    }
+
+    std::wstring finalWorldPth = Str2WStr(worldPth);
+
+    if(success)
+    {
+        LaunchEpisode(finalWorldPth, GM_CUR_SAVE_SLOT, isBootingSinglePlayer(), storedIdentity1, storedIdentity2);
+    }
+
     return success;
 }
 

LunaDll/LuaMain/LunaLuaMain.cpp

@@ -32,6 +32,8 @@
 #include "LunaPathValidator.h"
 #include "../Misc/CollisionMatrix.h"
 
+#include "../FileManager/SMBXFileManager.h"
+
 /*static*/ DWORD CLunaFFILock::currentLockTlsIdx = TlsAlloc();
 
 extern bool luaDidGameOverFlag;
@@ -1606,3 +1608,141 @@ void CLunaLua::queuePlayerSectionChangeEvent(int playerIdx) {
     m_playerSectionChangeList.push_back(playerIdx);
     m_executeSectionChangeFlag = true;
 }
+
+extern PlayerMOB* getTemplateForCharacter(int id);
+extern "C" void __cdecl LunaLuaSetGameData(const char* dataPtr, int dataLen);
+
+void LaunchEpisode(std::wstring wldPath, int saveSlot, bool singleplayer, Characters firstCharacter, Characters secondCharacter)
+{
+    // make sure the game unpauses and Lua is gone before starting after the episode has loaded successfully after boot
+    if(episodeLoadedOnBoot)
+    {
+        g_EventHandler.requestUnpause();
+
+        gLunaLua.exitContext();
+        gCachedFileMetadata.purge();
+    }
+
+    if(!episodeLoadedOnBoot)
+    {
+        // cleanup the level
+        native_cleanupLevel();
+    }
+
+    if(episodeLoadedOnBoot)
+    {
+        // cleanup either the level or world, depending on where we are at
+        if(GM_EPISODE_MODE && GM_LEVEL_MODE) // level
+        {
+            native_cleanupLevel();
+        }
+
+        if(GM_EPISODE_MODE && !GM_LEVEL_MODE) // world
+        {
+            runtimeHookCleanupWorld();
+        }
+    }
+
+    // setup SFXs
+    native_setupSFX();
+
+    // show loadscreen while loading everything
+    LunaLoadScreenStart();
+
+    // clear gamedata
+    LunaLuaSetGameData(0, 0);
+
+    // put the world together
+    std::wstring fullPath = resolveCwdOrWorldsPath(wldPath);
+
+    // make sure we also get the path without the wld file
+    std::string fullPathStr = WStr2Str(fullPath);
+    std::string fullPathNoWorldPth = splitFilenameFromPath(fullPathStr);
+    std::string fullPathNoWorldPthWithEndSlash = fullPathNoWorldPth + "\\";
+
+    VB6StrPtr pathVb6 = WStr2Str(fullPath);
+    VB6StrPtr pathNoWldVb6 = Str2WStr(fullPathNoWorldPthWithEndSlash);
+
+    // specify the save slot, the fulldir, and the menu level for the wld file
+    SMBXWorldFileBase::PopulateEpisodeList();
+    GM_CUR_MENULEVEL = findEpisodeIDFromWorldFileAndPath(WStr2Str(fullPath));
+    GM_CUR_SAVE_SLOT = saveSlot;
+    GM_FULLDIR = pathNoWldVb6;
+
+    // implement player count if it's 0
+    if(GM_PLAYERS_COUNT == 0)
+    {
+        if(singleplayer)
+        {
+            GM_PLAYERS_COUNT = 1;
+        }
+        else if(!singleplayer)
+        {
+            GM_PLAYERS_COUNT = 2;
+        }
+    }
+
+    native_loadWorld(&pathVb6);
+
+    // load save
+    if (saveFileExists())
+    {
+        native_loadGame();
+    }
+
+    // put the player on the world map
+    GM_EPISODE_MODE = COMBOOL(true);
+    GM_TITLE_INTRO_MODE = COMBOOL(false);
+    GM_LEVEL_MODE = COMBOOL(false);
+
+    // reset checkpoints
+    GM_STR_CHECKPOINT = "";
+
+    // add players' characters
+    auto p = Player::Get(1);
+    // implement the 1st player's character
+    p->Identity = firstCharacter;
+    // implement the 2nd player's character
+    if(!singleplayer && GM_PLAYERS_COUNT >= 2)
+    {
+        auto p2 = Player::Get(2);
+        if(secondCharacter != static_cast<Characters>(0))
+        {
+            p2->Identity = secondCharacter;
+        }
+        else
+        {
+            p2->Identity = static_cast<Characters>(1);
+        }
+    }
+
+    // unlikely that we'll get more than 3 players loading on boot, but Misc.loadEpisode exists, so this check needs to exist
+    if(GM_PLAYERS_COUNT > 2)
+    {
+        for (int i = 3; i <= GM_PLAYERS_COUNT; i++) {
+            auto p = Player::Get(i);
+            p->Identity = firstCharacter;
+        }
+    }
+
+    // apply templates
+    if(!episodeLoadedOnBoot)
+    {
+        for (int i = 1; i <= GM_PLAYERS_COUNT; i++) {
+
+            auto t = getTemplateForCharacter(p->Identity);
+            if (t != nullptr) {
+                memcpy(p, t, sizeof(PlayerMOB));
+            }
+        }
+    }
+
+    // make sure that lunadll knows the game loaded on boot, so that loadEpisode can know
+    if(!episodeLoadedOnBoot)
+    {
+        episodeLoadedOnBoot = true;
+    }
+
+    // hide loadscreen
+    LunaLoadScreenKill();
+}

LunaDll/LuaMain/LunaLuaMain.h

@@ -205,4 +205,6 @@ namespace CachedReadFile {
     void releaseCached(bool isWorld);
 };
 
+extern void LaunchEpisode(std::wstring wldPath, int saveSlot, bool singleplayer, Characters firstCharacter, Characters secondCharacter);
+
 #endif

LunaDll/Misc/RuntimeHookComponents/RuntimeHookHooks.cpp

@@ -1602,6 +1602,27 @@ Characters playerStoredCharacters[] = {CHARACTER_MARIO,CHARACTER_MARIO,CHARACTER
 
 void __stdcall runtimeHookLoadLevel(VB6StrPtr* filename)
 {
+    std::wstring filenameWS = static_cast<std::wstring>(*filename);
+    size_t findLastSlash = filenameWS.find_last_of(L"/\\");
+    std::wstring dirWS = filenameWS.substr(0U, findLastSlash);
+    std::wstring nameWS = filenameWS.substr(findLastSlash + 1);
+    std::string dirST = WStr2Str(dirWS);
+    std::string nameST = WStr2Str(nameWS);
+
+    //If the legacy title screen is about to boot, prevent that and go straight to loading the episode
+    if(nameST == "intro.lvl" && dirST == gAppPathUTF8)
+    {
+        GameAutostart autostarter = GameAutostart::createGameAutostartByStartupEpisodeSettings(gStartupSettings.epSettings);
+        if(autostarter.selectedWldPath == L"")
+        {
+            std::string msg = "There is no world file loaded on starting the engine. This means that you booted LunaLoader.exe with no arguments regarding selecting a world or level. Please load a world or level with SMBX2 by loading the X2 launcher instead.";
+            MessageBoxA(gMainWindowHwnd, msg.c_str(), "Error", MB_ICONWARNING | MB_OK);
+            _exit(0);
+        }
+        LaunchEpisode(autostarter.selectedWldPath, autostarter.saveSlot, autostarter.singleplayer, autostarter.firstCharacter, autostarter.secondCharacter);
+        return;
+    }
+
     if (!GM_CREDITS_MODE)
     {
         for (int i = 1; i <= min(GM_PLAYERS_COUNT, (WORD)4); i++) {