CleoBase.cpp

#include "stdafx.h"
#include "CleoBase.h"
#include "Singleton.h"

namespace CLEO
{
    CCleoInstance CleoInstance;

    inline CCleoInstance::~CCleoInstance()
    {
        Stop();
    }

    void __cdecl CCleoInstance::OnGameProcess()
    {
        CleoInstance.CallCallbacks(eCallbackId::GameProcessBefore);
        CleoInstance.OnGameProcess_Orig();
        CleoInstance.CallCallbacks(eCallbackId::GameProcessAfter);
    }

    HWND CCleoInstance::OnCreateMainWnd(HINSTANCE hinst)
    {
        CleoSingletonCheck(); // check once for CLEO.asi duplicates

        auto window = CleoInstance.CreateMainWnd_Orig(hinst); // call original

        // redirect window handling procedure
        *((size_t*)&CleoInstance.MainWndProc_Orig) = GetWindowLongPtr(window, GWLP_WNDPROC); // store original address
        SetWindowLongPtr(window, GWLP_WNDPROC, (LONG)OnMainWndProc);

        return window;
    }

    LRESULT __stdcall CCleoInstance::OnMainWndProc(HWND wnd, UINT msg, WPARAM wparam, LPARAM lparam)
    {
        switch (msg)
        {
        case WM_ACTIVATE:
            CleoInstance.CallCallbacks(eCallbackId::MainWindowFocus, wparam != 0);
            break;

        case WM_KILLFOCUS:
            CleoInstance.CallCallbacks(eCallbackId::MainWindowFocus, false);
            break;
        }

        return CleoInstance.MainWndProc_Orig(wnd, msg, wparam, lparam);
    }

    /*******************************************************

        Order of callbacks during game start:

            First Boot → New Game      OnScmInit2
            First Boot → Load Save     OnScmInit2 → OnScmInit1 → OnScmInit3
            Later → New Game           OnScmInit1
            Later → Load Save          OnScmInit1 → OnScmInit3

    ********************************************************/

    void CCleoInstance::OnScmInit1()
    {
        CleoInstance.ScmInit1_Orig();
        if (!FrontEndMenuManager.m_bWantToLoad)
        {
            // if it's a new game, we can call GameBegin right now.
            // Otherwise, defer it to OnScmInit3
            CleoInstance.GameBegin(-1);
        }
    }

    void CCleoInstance::OnScmInit2()
    {
        TRACE("CLEO initialization: Phase 2");
        CGameVersionManager& gvm = CleoInstance.VersionManager;
        auto& inj                = CleoInstance.CodeInjector;

        inj.InjectFunction(GetScriptStringParam, gaddrof(::CRunningScript::ReadTextLabelFromScript));

        inj.ReplaceFunction(
            OnDebugDisplayTextBuffer_Idle, gvm.TranslateMemoryAddress(MA_CALL_DEBUG_DISPLAY_TEXT_BUFFER_IDLE),
            &CleoInstance.GameRestartDebugDisplayTextBuffer_IdleOrig
        );
        inj.ReplaceFunction(
            OnDebugDisplayTextBuffer_Frontend, gvm.TranslateMemoryAddress(MA_CALL_DEBUG_DISPLAY_TEXT_BUFFER_FRONTEND),
            &CleoInstance.GameRestartDebugDisplayTextBuffer_FrontendOrig
        );
        inj.ReplaceFunction(
            OnGameProcess, gvm.TranslateMemoryAddress(MA_CALL_GAME_PROCESS), &CleoInstance.OnGameProcess_Orig
        );

        CleoInstance.PluginSystem.LogLoadedPlugins();

        // limit adjusters support: get adresses from (possibly) patched references
        inj.MemoryRead(gvm.TranslateMemoryAddress(MA_SCM_BLOCK_REF), CleoInstance.ScriptEngine.scmBlock);
        inj.MemoryRead(gvm.TranslateMemoryAddress(MA_MISSION_BLOCK_REF), CleoInstance.ScriptEngine.missionBlock);

        // re-read User directory path, as it could be modified by PortableGTA.asi
        UpdateUserDirectoryPath();

        CleoInstance.ScmInit2_Orig();
        if (!FrontEndMenuManager.m_bWantToLoad)
        {
            // if it's a new game, we can call GameBegin right now.
            // Otherwise, defer it to OnScmInit3
            CleoInstance.GameBegin(-1);
        }
    }

    void CCleoInstance::OnScmInit3()
    {
        CleoInstance.ScmInit3_Orig();
        CleoInstance.GameBegin(FrontEndMenuManager.m_nSelectedSaveGame);
    }

    void __declspec(naked) CCleoInstance::OnGameShutdown()
    {
        CleoInstance.GameEnd();
        static DWORD oriFunc;
        oriFunc = (DWORD)(CleoInstance.GameShutdown_Orig);
        _asm jmp oriFunc
    }

    void __declspec(naked) CCleoInstance::OnGameRestart1()
    {
        CleoInstance.GameEnd();
        static DWORD oriFunc;
        oriFunc = (DWORD)(CleoInstance.GameRestart1_Orig);
        _asm jmp oriFunc
    }

    void __declspec(naked) CCleoInstance::OnGameRestart2()
    {
        CleoInstance.GameEnd();
        static DWORD oriFunc;
        oriFunc = (DWORD)(CleoInstance.GameRestart2_Orig);
        _asm jmp oriFunc
    }

    void __declspec(naked) CCleoInstance::OnGameRestart3()
    {
        CleoInstance.GameEnd();
        static DWORD oriFunc;
        oriFunc = (DWORD)(CleoInstance.GameRestart3_Orig);
        _asm jmp oriFunc
    }

    void __cdecl CCleoInstance::OnDebugDisplayTextBuffer_Idle()
    {
        CleoInstance.GameRestartDebugDisplayTextBuffer_IdleOrig(); // call original
        CleoInstance.CallCallbacks(eCallbackId::DrawingFinished);  // execute registered callbacks
    }

    void __cdecl CCleoInstance::OnDebugDisplayTextBuffer_Frontend()
    {
        CleoInstance.GameRestartDebugDisplayTextBuffer_FrontendOrig(); // call original
        CleoInstance.CallCallbacks(eCallbackId::DrawingFinished);      // execute registered callbacks
    }

    void CCleoInstance::Start()
    {
        TRACE("CLEO initialization: Phase 1");

        FS::create_directory(GetCleoDirectory());
        FS::create_directory(GetCleoDirectory() + "\\cleo_modules");
        FS::create_directory(GetCleoDirectory() + "\\cleo_plugins");
        FS::create_directory(GetCleoDirectory() + "\\cleo_saves");

        OpcodeInfoDb.LoadCommands((GetCleoDirectory() + "\\.config\\sa.json").c_str());

        CodeInjector.OpenReadWriteAccess(); // must do this earlier to ensure plugins write access on init
        GameMenu.Inject(CodeInjector);
        DmaFix.Inject(CodeInjector);
        OpcodeSystem.Inject(CodeInjector);
        ScriptEngine.Inject(CodeInjector);

        CodeInjector.ReplaceFunction(
            OnCreateMainWnd, VersionManager.TranslateMemoryAddress(MA_CALL_CREATE_MAIN_WINDOW), &CreateMainWnd_Orig
        );

        CodeInjector.ReplaceFunction(
            OnScmInit1, VersionManager.TranslateMemoryAddress(MA_CALL_INIT_SCM1), &ScmInit1_Orig
        );
        CodeInjector.ReplaceFunction(
            OnScmInit2, VersionManager.TranslateMemoryAddress(MA_CALL_INIT_SCM2), &ScmInit2_Orig
        );
        CodeInjector.ReplaceFunction(
            OnScmInit3, VersionManager.TranslateMemoryAddress(MA_CALL_INIT_SCM3), &ScmInit3_Orig
        );

        CodeInjector.ReplaceFunction(
            OnGameShutdown, VersionManager.TranslateMemoryAddress(MA_CALL_GAME_SHUTDOWN), &GameShutdown_Orig
        );

        CodeInjector.ReplaceFunction(
            OnGameRestart1, VersionManager.TranslateMemoryAddress(MA_CALL_GAME_RESTART_1), &GameRestart1_Orig
        );
        CodeInjector.ReplaceFunction(
            OnGameRestart2, VersionManager.TranslateMemoryAddress(MA_CALL_GAME_RESTART_2), &GameRestart2_Orig
        );
        CodeInjector.ReplaceFunction(
            OnGameRestart3, VersionManager.TranslateMemoryAddress(MA_CALL_GAME_RESTART_3), &GameRestart3_Orig
        );

        OpcodeSystem.Init();
        PluginSystem.LoadPlugins();

        m_isStarted = true;
    }

    void CCleoInstance::Stop()
    {
        m_isStarted = false;
        GameEnd();
        PluginSystem.UnloadPlugins();
    }

    void CCleoInstance::GameBegin(int saveSlot)
    {
        if (m_bGameInProgress) return;
        m_bGameInProgress = true;

        CConfigManager::Reset(); // re-read config file to apply any user changes made in background

        CleoInstance.saveSlot = saveSlot;
        TRACE("Starting new game session, save slot: %d", saveSlot);

        // log important config settings
        TRACE("Config summary:");
        TRACE(" MainScmLegacyMode = %d", CConfigManager::ReadInt("General", "MainScmLegacyMode", 0));
        TRACE(" StrictValidation = %d", CConfigManager::ReadInt("Plugins", "StrictValidation", 0));
        auto scriptLogEnabled = CConfigManager::ReadInt("Plugins", "DebugUtils.ScriptLog.Enabled", 0);
        if (scriptLogEnabled != 0)
        {
            const auto path = (GetLogDirectory() + "\\cleo_script.log").c_str();
            TRACE(" DebugUtils.ScriptLog.Enabled = %d, path: %s", scriptLogEnabled, path);
        }
        else
        {
            TRACE(" DebugUtils.ScriptLog.Enabled = 0");
        }

        // execute registered callbacks
        CleoInstance.CallCallbacks(eCallbackId::GameBegin, saveSlot);
    }

    void CCleoInstance::GameEnd()
    {
        if (!m_bGameInProgress) return;
        m_bGameInProgress = false;

        TRACE("Ending current game session");
        CleoInstance.CallCallbacks(eCallbackId::GameEnd); // execute registered callbacks
        ScriptEngine.GameEnd();
        OpcodeSystem.GameEnd();

        saveSlot = -1;
    }

    void CCleoInstance::AddCallback(eCallbackId id, void* func)
    {
        m_callbacks[id].insert(func);
    }

    void CCleoInstance::RemoveCallback(eCallbackId id, void* func)
    {
        m_callbacks[id].erase(func);
    }

    const std::set<void*>& CCleoInstance::GetCallbacks(eCallbackId id)
    {
        return m_callbacks[id];
    }

    void CCleoInstance::CallCallbacks(eCallbackId id)
    {
        for (void* func : GetCallbacks(id))
        {
            typedef void WINAPI callback(void);
            ((callback*)func)();
        }
    }

    void CCleoInstance::CallCallbacks(eCallbackId id, DWORD arg)
    {
        for (void* func : GetCallbacks(id))
        {
            typedef void WINAPI callback(DWORD);
            ((callback*)func)(arg);
        }
    }

    void WINAPI CLEO_ResolvePath(CLEO::CRunningScript* thread, char* inOutPath, DWORD pathMaxLen)
    {
        if (thread == nullptr || inOutPath == nullptr || pathMaxLen < 2)
        {
            return; // invalid param
        }

        auto resolved = reinterpret_cast<CCustomScript*>(thread)->ResolvePath(inOutPath);

        if (resolved.length() >= pathMaxLen) resolved.resize(pathMaxLen - 1); // and terminator character

        std::memcpy(inOutPath, resolved.c_str(), resolved.length() + 1); // with terminator
    }

    void WINAPI CLEO_StringListFree(StringList list)
    {
        if (list.count > 0 && list.strings != nullptr)
        {
            for (DWORD i = 0; i < list.count; i++)
            {
                free(list.strings[i]);
            }

            free(list.strings);
        }
    }

    StringList WINAPI
    CLEO_ListDirectory(CLEO::CRunningScript* thread, const char* searchPath, BOOL listDirs, BOOL listFiles)
    {
        if (searchPath == nullptr) return {}; // invalid param

        if (!listDirs && !listFiles) return {}; // nothing to list, done

        // make absolute
        auto fsSearchPath = FS::path(searchPath);
        if (!fsSearchPath.is_absolute())
        {
            const auto baseDir = thread ? ((CCustomScript*)thread)->GetWorkDir() : GetGameDirectory();
            fsSearchPath       = baseDir / fsSearchPath;
        }

        WIN32_FIND_DATA wfd = {0};
        HANDLE hSearch      = FindFirstFile(fsSearchPath.string().c_str(), &wfd);
        if (hSearch == INVALID_HANDLE_VALUE) return {}; // nothing found

        std::set<std::string> found;
        do
        {
            if (!listDirs && (wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) continue; // skip directories

            if (!listFiles && !(wfd.dwFileAttributes & FILE_ATTRIBUTE_DIRECTORY)) continue; // skip files

            auto path = FS::path(wfd.cFileName);
            if (!path.is_absolute()) // keep absolute in case somebody hooked the APIs to return so
                path = fsSearchPath.parent_path() / path;

            found.insert(path.string());
        } while (FindNextFile(hSearch, &wfd));

        FindClose(hSearch);

        return CreateStringList(found);
    }
} // namespace CLEO