CSMAPI_BaseModeInstance.h

Go to the documentation of this file.

/*
  Cavestory Multiplayer API
  Copyright (C) 2021 Johnny Ledger
 
  This software is provided 'as-is', without any express or implied
  warranty.  In no event will the authors be held liable for any damages
  arising from the use of this software.
 
  Permission is granted to anyone to use this software for any purpose,
  including commercial applications, and to alter it and redistribute it
  freely, subject to the following restrictions:
 
  1. The origin of this software must not be misrepresented; you must not
     claim that you wrote the original software. If you use this software
     in a product, an acknowledgment in the product documentation would be
     appreciated but is not required.
  2. Altered source versions must be plainly marked as such, and must not be
     misrepresented as being the original software.
  3. This notice may not be removed or altered from any source distribution.
*/
 
#pragma once
 
class VideoTexture;
 
#include <CSMAPI_begincode.h>
class CAVESTORY_MOD_API BaseModeInstance;
class CAVESTORY_MOD_API ModeInputVector;
class CAVESTORY_MOD_API ExternalWindow;
#include <CSMAPI_endcode.h>
 
//------------------------------------------------------------------------------------------------------------------------------------
 
namespace Platform
{
    void OpenBugReporter();
}
 
namespace ChatEmotes
{
    extern int CheckOpenList(BaseModeInstance*);
}
 
#include <CSMAPI_begincode.h>
extern void CAVESTORY_MOD_API MessageBox_DrawMode(void*);
 
//------------------------------------------------------------------------------------------------------------------------------------
 
typedef unsigned int ModeThreadId;
 
typedef unsigned int EventScheduleId;
 
typedef void(*EventSchedulePayloadFunc)(BaseModeInstance* pOwner, void* pUserData);
 
//------------------------------------------------------------------------------------------------------------------------------------
 
#define MODE_INSTANCE_MAX_TEXTURES 64
 
#define MODE_INSTANCE_MAX_SURFACES 64
 
#define MODE_INSTANCE_MAX_THREADS 8
 
#define MODE_INSTANCE_DEBUG
 
#define MODE_INSTANCE_GUARDS
 
//------------------------------------------------------------------------------------------------------------------------------------
// Configuration
 
#define MODE_TOOLTIP_ANIMATION_TIME 1000
 
#define MODE_DRAW_CENTERED_SURFACE -0x7FFFFFF
 
#define MODE_IM_STILL_RUNNING 0x7FFFFFFF
 
#define CONTROL_MARGIN 4
 
#define MODE_INVALID_THREAD_ID 0
 
#define INVALID_SCHEDULE_ID 0xFFFFFFFF
 
 
//------------------------------------------------------------------------------------------------------------------------------------
// Helper macros
 
#define DefineKeyControlStruct(INPUT_TYPE, KEY, DESC) { INPUT_TYPE, KEY, DESC }
 
//------------------------------------------------------------------------------------------------------------------------------------
 
enum MODE_GLOBAL_CONFIG_TYPE
{
    GCT_IGNORE_WINDOW_DEFAULT = 0
};
 
enum MENU_CONTROLS_DRAW_POSITION
{
    CDP_TOP_LEFT  = 0,
 
    CDP_TOP_RIGHT = 1,
 
    CDP_BTM_LEFT  = 2,
 
    CDP_BTM_RIGHT = 3,
 
    CDP_CENTER    = 4
};
 
enum MENU_CONTROLS_DRAW_FRAME
{
    ANIMATED  = 0,
 
    NORMAL    = 1,
 
    DEPRESSED = 2
};
 
enum MENU_CONTROLS_ACTS
{
    MCA_FIRST_OPEN = 0,
 
    MCA_OPENED     = 1,
 
    MCA_CLOSING    = 2,
 
    MCA_CLOSED     = 3,
 
    MCA_OPENING    = 4
};
 
enum KEY_CONTROL_INPUT_TYPE
{
    KCIT_KEY   = 0,
 
    KCIT_KEY2  = 1,
 
    KCIT_KEY3  = 2,
    
    KCIT_MOUSE = 3
};
 
//------------------------------------------------------------------------------------------------------------------------------------
 
struct KeyControlStruct
{
    KEY_CONTROL_INPUT_TYPE Type;
 
    int Key;
 
    char Desc[128];
};
 
//------------------------------------------------------------------------------------------------------------------------------------
 
struct EventScheduleStruct
{
    EventScheduleId id;
 
    unsigned long long int end_time;
 
    BaseModeInstance* executor;
 
    EventSchedulePayloadFunc payload;
 
    void* user_data;
 
    bool is_executing;
 
    EventScheduleStruct* next;
};
 
//------------------------------------------------------------------------------------------------------------------------------------
 
struct ToolTipStruct
{
    bool shown;
 
    GUI_RECT rect;
 
    int surface_idx;
    
    int texture_idx;
 
    int start_time;
 
    int life_time;
};
 
//------------------------------------------------------------------------------------------------------------------------------------
 
class CAVESTORY_MOD_API ModeThreadInstance
{
    friend class BaseModeInstance;
    friend int ModeThreadInstance_AsyncFunc(void* ptr);
 
private: // Static variables
 
    static void* sMainModeMutex;
 
    static ModeThreadId sNextThreadId;
 
public: // Enumerations
 
    enum ThreadState
    {
        THREAD_NOT_RUNNING = 0,
 
        THREAD_STARTING    = 1,
 
        THREAD_RUNNING     = 2,
 
        THREAD_STOPPING    = 3,
 
        THREAD_DELETABLE   = 4,
    };
 
public: // Typedefs
 
    typedef void(*ModeCallback_OnThreadComplete)(BaseModeInstance* pMode, ModeThreadInstance* pThread, void* pUserData);
    
    typedef void(*ModeCallback_OnThreadLoop)(BaseModeInstance* pMode, ModeThreadInstance* pThread, void* pUserData);
 
protected: // Variables
 
    char m_ThreadName[128];
 
    ModeThreadId m_ThreadId;
 
    ModeCallback_OnThreadComplete m_OnComplete;
 
    ModeCallback_OnThreadComplete m_OnLoop;
 
    BaseModeInstance* m_Owner;
 
    void* m_Thread;
    
    void* m_Mutex;
 
    ThreadState m_State;
 
    bool m_Running;
    
    int m_Result;
 
    void* m_UserData;
 
public: // Constructor & deconstructor
    
    ModeThreadInstance();
 
    ~ModeThreadInstance();
 
protected: // Internal methods
 
    bool InitThread(BaseModeInstance* pOwner, ModeCallback_OnThreadLoop pOnLoopFunc, ModeCallback_OnThreadComplete pOnCompleteFunc, void* pUserData = NULL);
 
    void __Complete_And_Send_Result__();
 
public: // Locking & unlocking
 
    static bool TryLock();
    
    static void Lock();
 
    static void Unlock();
    
public: // Unique mutex locking & unlocking
 
    bool TryLockUnique();
    
    void LockUnique();
 
    void UnlockUnique();
 
public: // Methods
 
    bool Start();
 
    void End(int iResult = 0);
 
    void WaitToFinish();
 
    void Detach();
 
    int GetResult();
};
 
//------------------------------------------------------------------------------------------------------------------------------------
 
class CAVESTORY_MOD_API BaseModeInstance
{
    friend class ModeInputVector;
    friend class ModeThreadInstance;
    friend ModeThreadInstance::ModeCallback_OnThreadLoop;
    friend ModeThreadInstance::ModeCallback_OnThreadComplete;
    friend extern void SetGameResolution(int iNewWidth, int iNewHeight, int iNewMagnification);
    friend extern void CAVESTORY_MOD_API MessageBox_DrawMode(void*);
    friend extern int ChatEmotes::CheckOpenList(BaseModeInstance* pMode);
    friend extern void Platform::OpenBugReporter();
 
public: // Exposed internal structs
 
    struct ModeConfiguration
    {
        ExternalWindow* Window;
 
        bool IgnoreWindow;
 
        bool AllowKeyControl;
 
        bool AllowMouseControl;
 
        bool ProcessMouseOnMove;
 
        int AltF4RetValue;
        
        unsigned int CustomMagnification;
 
        struct
        {
            bool Enabled;
 
            MENU_CONTROLS_DRAW_POSITION DrawPosition;
 
            bool AllowAutoHide;
 
            bool OpenOnTab;
 
            bool OpenOnHover;
 
            int ClosedAlpha;
 
            int OpenedAlpha;
 
            int FrameTime;
 
            int HideTime;
        } MenuControls;
    };
 
private: // Screen grab stuff
 
    struct BASEMODE_SCREEN_GRAB_CACHE
    {
        Surface_Ids surf;
 
        bool used;
    };
 
    static BASEMODE_SCREEN_GRAB_CACHE m_szScreenGrabData[3];
 
protected: // Global configuration
 
    class GLOBAL_CONFIG_STRUCT
    {
    public:
        bool IgnoreWindow;
        
        bool RefreshAllModes;
 
        GLOBAL_CONFIG_STRUCT()
        {
            IgnoreWindow    = false;
            RefreshAllModes = false;
        }
    };
 
    static GLOBAL_CONFIG_STRUCT g_GlobalConfig;
 
public: // Typedefs
 
    typedef void(*ModeCallback_OnEnd)(BaseModeInstance* pMode, const int& iResult, bool& bDelete);
 
public: // Linkage
    
    static BaseModeInstance* m_FocusedInstance;
 
    static BaseModeInstance* m_FirstInstance;
 
    static BaseModeInstance* m_FreeRun_Start;
 
    BaseModeInstance* m_FreeRun_Next;
 
    BaseModeInstance* m_NextInstance;
 
private: // Variables for free-running mode
 
    GUI_POINT m_OldMousePoint;
 
    GUI_POINT m_MousePoint;
 
private: // Schedule stuff
 
    static EventScheduleStruct* m_ScheduleLink;
 
    static EventScheduleId m_NextScheduleId;
 
private: // Private data
 
    static int m_ModeCursorCount;
 
    static FontObject* m_DefaultFont[10];
 
    Surface_Ids m_SurfaceIDList[MODE_INSTANCE_MAX_SURFACES];
 
    VideoTexture* m_TextureList[MODE_INSTANCE_MAX_TEXTURES];
 
    ModeThreadInstance* m_ThreadList[MODE_INSTANCE_MAX_THREADS];
 
    int m_AllocThreadCount;
 
protected: // Tooltip data
 
    ToolTipStruct m_OldTooltip;
 
    ToolTipStruct m_CurTooltip;
 
private: // Control table surfaces
 
    struct
    {
        int Indices[2];
 
        GUI_POINT MenuSize;
 
        int AnimTimer;
 
        int FrameTimer;
 
        MENU_CONTROLS_ACTS ActNo;
 
        bool Joypad;
    } m_MenuControls;
 
public: // Callbacks
 
    struct
    {
        ModeCallback_OnEnd OnEnd;
    } m_Callbacks;
 
private: // 'Mouse Rect Check' (MRC)
 
    GUI_RECT m_MRC_Last;
 
    GUI_RECT m_MRC_Curr;
 
    unsigned int m_MRC_Time;
 
private: // Key input private variables
 
    unsigned int m_KeyOld;
 
    unsigned int m_KeyOld2;
 
    unsigned int m_KeyOld_JOY;
 
protected: // Shared data
 
    ModeConfiguration m_ModeConfig;
 
    struct ModeInput
    {
        unsigned int Key;
 
        unsigned int KeyTrg;
 
        unsigned int Key2;
 
        unsigned int KeyTrg2;
 
        unsigned int Key_JOY;
 
        unsigned int KeyTrg_JOY;
    } m_ModeInput;
 
    Surface_Ids m_ScreenGrabSurf;
 
    bool m_Dirty;
 
    bool m_End;
 
    bool m_FreeCall;
    
    bool m_FreeCall_Paused;
 
    int m_RetValue;
 
public: // Data
 
    void* m_PrivData;
 
public: // Constructor
 
    BaseModeInstance();
    ~BaseModeInstance();
 
protected: // Main protected methods
 
    virtual int Init() = 0;
 
    virtual int Free() = 0;
 
    virtual int GetMagnification();
    
    virtual int ModePixelToScreenPixel(int iInput);
 
    virtual void QueryMenuControls(KeyControlStruct pControlBuffer[32], int& pControlCount, bool& bStackControls);
 
    virtual void ProcessLogic() = 0;
 
    virtual void ProcessMouse(GUI_POINT mouse_point) = 0;
 
    virtual void ProcessKeys() = 0;
 
    virtual void PreRender() = 0;
 
    virtual void Draw() = 0;
 
    virtual void PostDraw() {}
 
public: // Global Configuration
 
    static void SetGlobalConfig(MODE_GLOBAL_CONFIG_TYPE eType, const char* pValue);
 
protected: // HELPER: Internal schedule methods
 
    static void CancelAllModeSchedules(BaseModeInstance* pMode);
 
public: // HELPER: Schedule methods
 
    static void ProcessScheduleList();
 
    static EventScheduleId Schedule(unsigned int iDelay, EventSchedulePayloadFunc pPayloadFunc, void* pUserData = NULL, BaseModeInstance* pOwner = NULL);
 
    static bool CancelSchedule(EventScheduleId iEventId);
 
    static bool IsSchedulePending(EventScheduleId iEventId);
 
public: // HELPER: Static helper methods
 
    static void ShowCursor();
 
    static void HideCursor();
 
    static void SetCursor(CSMP_CURSOR_TYPE iType, int iEventId = -1, GUI_RECT* pRect = NULL);
 
    static CSMP_CURSOR_TYPE GetCursor(GUI_RECT** pRect = NULL, int* pEventId = NULL);
 
    static void ReloadOpenModes();
    
    static void ScheduleReloadOpenModes();
 
    static FontObject* GetDefaultFont(unsigned int iMagnification = 0);
    
    static void ReloadFont(const char* pFontName, const char* pFontPath, int iFontW = -1, int iFontH = -1, unsigned int iMagnification = 0);
 
    static GameProcessMode ShowTutorialPages(BaseModeInstance* pCaller, int iPageCount, ...);
 
protected: // HELPER: Tooltip methods
 
    bool IsTooltipOpen();
 
    bool CreateTooltip(GUI_POINT point, FontObject* font, const char* text, int life_time = 5000);
 
    bool CreateTextureTooltip(GUI_POINT point, FontObject* font, const char* text, int life_time = 5000, int Magnification = -1);
 
    bool CloseTooltip(bool fade_out = true);
 
    GUI_RECT* GetTooltipRect();
 
    void SetTooltipPosition(GUI_POINT new_position);
 
    void ProcessTooltips();
 
    void DrawTooltips();
 
protected: // HELPER: Rect timers
 
    uint32_t GetRectHoverTime(GUI_POINT mouse_point, GUI_RECT rect);
 
    void ResetRectHover();
 
public: // HELPER: Static uniform drawing methods
 
    static void RunGameLogic(bool AllowACT = true);
    
    static void DrawGame(bool AllowACT = true, int OffsetX = 0, int OffsetY = 0, bool DoPutFade = true, bool bRunGameLogic = true);
 
    static void DrawHUD(int OffsetX = 0, int OffsetY = 0);
 
    static GUI_POINT GetControlKeySize(const KeyControlStruct* Buttons, int ButtonCount, bool StackControls = false, unsigned int CustomMagnification = 0);
 
    static void DrawControls(MENU_CONTROLS_DRAW_POSITION DrawPosition, Surface_Ids destSID, const KeyControlStruct* Buttons, int ButtonCount, bool Flash = false, bool StackControls = false, int Alpha = 255, unsigned int CustomMagnification = 0);
 
private: // HELPER: Asynchronous methods (private)
 
    void CompleteAsyncOperation(ModeThreadInstance* pCompleteThread);
 
public: // HELPER: Asynchronous methods
 
    ModeThreadId StartAsyncOperation(ModeThreadInstance::ModeCallback_OnThreadLoop pOnLoopFunc, ModeThreadInstance::ModeCallback_OnThreadComplete pOnCompleteFunc = NULL, void* pUserData = NULL);
 
    bool StopThread(ModeThreadId iThreadId, bool bWaitForFinish = false);
 
    void StartAllNewThreads();
 
    void FreeAllThreads();
 
public: // HELPER: Uniform drawing methods
 
    void EnforceBasicWindowSize(GUI_RECT* pRect);
 
    int DrawBasicWindow(GUI_RECT* pRect = NULL);
 
protected: // Menu Control Table
 
    bool CreateMenuControls(const KeyControlStruct* Buttons, int ButtonCount, bool StackControls = false);
 
    void DrawMenuControls(MENU_CONTROLS_DRAW_POSITION DrawPosition, MENU_CONTROLS_DRAW_FRAME DrawFrame);
 
    MENU_CONTROLS_ACTS GetMenuControlsAct();
 
    void SetMenuControlsAct(MENU_CONTROLS_ACTS NewAct);
 
protected: // Non-overridable protected methods
 
    bool GrabScreen();
 
    void DrawScreenGrab();
    
    void UpdateScreenGrab();
 
    void ReleaseScreenGrab();
 
    void DoEscapeMenu();
 
    int AllocSurface(int InsertIndex = -1, int Width = WINDOW_WIDTH, int Height = WINDOW_HEIGHT, unsigned int iMagnification = 0);
 
    int LoadImageToSurface(const char* FileName, int InsertIndex = -1);
    
    int LoadImageToTexture(const char* FileName, int InsertIndex = -1);
    
    int LoadSurfaceIDToSurface(Surface_Ids SurfaceID, int InsertIndex = -1);
    
    int LoadSurfaceIDToTexture(Surface_Ids SurfaceID, int InsertIndex = -1);
 
    void FreeSurface(int Index);
 
    void FreeAllSurfaces();
 
    bool IsLocalSurfaceAllocated(int Index);
 
    void SelectSurface(int Index);
 
    int GetSelectedSurface();
 
    Surface_Ids LocalSurfaceIndexToGlobal(int Index);
 
    int GlobalSurfaceIndexToLocal(Surface_Ids sId);
 
    void DrawSurface(int Index, int X = 0, int Y = 0, unsigned char Alpha = 255, bool AbsolutePos = false);
 
    int GetSurfaceWidth(int Index);
 
    int GetSurfaceHeight(int Index);
 
    int GetCenteredX(int Index);
 
    int GetCenteredY(int Index);
    
    virtual GUI_POINT TranslateMousePosition(GUI_POINT* pMouseInput, const GUI_POINT& pWindowOffset);
    
    virtual GUI_POINT TranslateMousePosition(GUI_POINT* pMouseInput);
 
    virtual int GetRelativeScreenWidth();
    
    virtual int GetRelativeScreenHeight();
 
    bool IsFocusedMode();
 
public: // Texture methods
 
    VideoTexture* GetLocalVideoTexture(int LocalIndex);
 
    int AllocTexture(int InsertIndex = -1, int Width = WINDOW_WIDTH, int Height = WINDOW_HEIGHT, int BitsPerPixel = 32, int Magnification = -1, int WindowIndex = 0);
 
    void FreeTexture(int Index);
 
    void FreeAllTextures();
 
    bool IsLocalTextureAllocated(int Index);
 
    void SelectTexture(int Index);
 
    int GetSelectedTexture();
 
    void FinishTexture(int Index);
 
    void DrawTexture(int Index, int X = 0, int Y = 0, unsigned char Alpha = 255, bool bSubPixels = false, bool bWrapCoordinates = false);
 
    int GetTextureCenteredX(int Index);
 
    int GetTextureCenteredY(int Index);
    
    GUI_POINT GetTextureCentered(int Index);
 
    int GetTextureWidth(int Index, bool Magnified = true);
 
    int GetTextureHeight(int Index, bool Magnified = true);
 
    GUI_POINT GetTextureRelativeMousePoint(int Index);
 
protected: // Control menu methods
 
    void InitControlMenu();
 
    bool IsControlMenuOpen();
 
private: // Input methods
 
    void ProcKey();
 
protected: // Protected input methods
 
    void RemoveKey(int iInputFlags, KeyInputType iType = KeyInputType::KIT_Key);
 
    GUI_POINT GetRelativeMousePosition(int iIndex);
 
public: // Free-call methods
 
    virtual bool StartMode();
 
    virtual void EndMode(int value = 0x6FFFFFFF, bool bSchedule = false);
 
    void SetModePaused(bool bValue);
 
    virtual bool ModeTick();
 
    int GetRetValue();
 
    bool IsModeFreeRunning();
 
public: // General methods
 
    ModeConfiguration* GetModeConfig();
 
    virtual void SetDirty();
 
    void ReloadMode();
 
    void ResetMode();
 
    void SetRetValue(int value);
 
    virtual int DoMode();
 
#ifdef _DEBUG
public: // Debugging methods
 
    void DumpMemory();
#endif
};
 
//------------------------------------------------------------------------------------------------------------------------------------
 
inline BaseModeInstance::ModeConfiguration* BaseModeInstance::GetModeConfig()
{
    return &m_ModeConfig;
}
 
inline void BaseModeInstance::SetDirty()
{
    m_Dirty = true;
}
 
inline bool BaseModeInstance::IsTooltipOpen()
{
    return m_CurTooltip.shown;
}
 
#include <CSMAPI_endcode.h>