GameDemo.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.
*/
 
#ifndef CAVESTORY_MOD_API_H_
#error "Please include CavestoryModAPI.h before including sub-classes."
#endif
 
#include <CSMAPI_begincode.h>
 
#pragma once
 
 
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
enum PXDEMO_EVENT_TYPE : unsigned char
{
    PXDET_INVALID_EVENT    = 0,
 
    PXDET_SET_PLAYER_STATE = 1,
 
    PXDET_SET_STAGE        = 2,
 
    PXDET_SET_RANDOM_SEED  = 3,
 
    PXDET_SET_NPC_STATE    = 4,
 
    PXDET_DO_SCREEN_FADE   = 5,
 
    PXDET_SET_CAMERA       = 6,
 
    PXDET_SET_TIMER        = 7,
    
    PXDET_SET_NPC_DATA     = 8,
    
    PXDET_SET_MAP_TILE     = 9,
 
    PXDET_MAX_EVENTS
};
 
enum PXDEMO_FADE_TYPE : unsigned char
{
    PXDFT_CLEAR_FADE = 0,
 
    PXDFT_FADE_IN    = 1,
 
    PXDFT_FADE_OUT   = 2,
 
    PXDFT_MAX_FADES
};
 
enum PXDEMO_PLAYERSTATE_CHANGE : unsigned int
{
    PXDPSC_cond               = 0x00000001,
 
    PXDPSC_x                  = 0x00000002,
 
    PXDPSC_y                  = 0x00000004,
 
    PXDPSC_xm                 = 0x00000008,
 
    PXDPSC_ym                 = 0x00000010,
 
    PXDPSC_life               = 0x00000020,
 
    PXDPSC_max_life           = 0x00000040,
 
    PXDPSC_input_flags        = 0x00000080,
 
    PXDPSC_input_flags_trg    = 0x00000100,
 
    PXDPSC_weapon_code        = 0x00000200,
 
    PXDPSC_weapon_ammo        = 0x00000400,
 
    PXDPSC_weapon_max_ammo    = 0x00000800,
 
    PXDPSC_weapon_level       = 0x00001000,
 
    PXDPSC_weapon_exp         = 0x00002000,
 
    PXDPSC_selectedArms       = 0x00004000,
 
    PXDPSC_direct             = 0x00008000,
 
    PXDPSC_ani_no             = 0x00010000,
 
    PXDPSC_ani_wait           = 0x00020000,
 
    PXDPSC_equip              = 0x00040000,
 
    PXDPSC_star               = 0x00080000,
 
    PXDPSC_shock              = 0x00100000,
 
    PXDPSC_netanim            = 0x00200000,
 
    PXDPSC_physics_normal     = 0x00400000,
 
    PXDPSC_physics_underwater = 0x00800000,
 
    PXDPSC_ignore_water       = 0x01000000,
 
    PXDPSC_boost_sw           = 0x02000000,
 
    PXDPSC_boost_cnt          = 0x04000000,
 
    PXDPSC_flag               = 0x08000000,
 
    PXDPSC_updown             = 0x10000000,
 
    PXDPSC_counts             = 0x20000000,
 
    PXDPSC_act_wait           = 0x40000000,
 
    PXDPSC_act_no             = 0x80000000,
 
    PXDPSC_ALL_FLAGS          = 0xFFFFFFFF,
 
    PXDPSC_COUNT              = 34 + /* MYCHAR_PHYSICS */(8 * 2),
 
    PXDPSC_UNIQUE_COUNT       = PXDPSC_COUNT - (/* MYCHAR_PHYSICS */(8 * 2) + /* UP/DOWN */1),
 
    PXDPSC_BIGGEST_TYPE       = sizeof(MYCHAR_PHYSICS)
};
 
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
struct PXDEMO_DEMOINFO_STRUCT
{
    unsigned int cavenet_version;
 
    char* mod_name;
 
    int mod_version;
 
    int total_sim_frames;
 
    int play_frame;
 
    int random_seed;
 
    unsigned char flags[1000];
 
    unsigned char skip_flags[8];
    
    unsigned long long int* npc_transmit_flags;
    
    unsigned int npc_count;
 
    int game_flags;
};
 
struct PXDEMO_PLAYERSTATE_STRUCT
{
    unsigned char cond;
 
    int x;
 
    int y;
 
    int xm;
    
    int ym;
 
    short life;
 
    short max_life;
 
    int input_flags;
 
    int input_flags_trg;
 
    int weapon_code;
 
    int weapon_ammo;
    
    int weapon_max_ammo;
 
    unsigned char weapon_level;
 
    int weapon_exp;
 
    int selectedArms;
 
    int direct;
 
    int ani_no;
 
    int ani_wait;
 
    int equip;
 
    short star;
 
    unsigned char shock;
 
    int netanim;
 
    MYCHAR_PHYSICS physics_normal;
 
    MYCHAR_PHYSICS physics_underwater;
 
    bool ignore_water;
 
    signed char boost_sw;
 
    int boost_cnt;
 
    unsigned int flag;
 
    int up;
 
    int down;
 
    signed char a;
 
    int tgt_x;
 
    int tgt_y;
 
    int air;
 
    int count1;
 
    int count2;
 
    int count3;
 
    int count4;
 
    int act_no;
 
    int act_wait;
 
};
 
struct PXDEMO_PLAYER_STRUCT
{
    char* name;
 
    ARMS arms[ARMS_MAX];
 
    CustomPlayer* character;
 
    char* character_name;
 
    PXDEMO_PLAYERSTATE_STRUCT state;
 
    int last_state_frame_idx;
 
    int last_state_event_idx;
 
    GUI_COLOR char_color;
 
    bool use_color;
};
 
struct PXDEMO_EVENT_STRUCT;
 
struct PXDEMO_FRAME_STRUCT
{
    PXDEMO_EVENT_STRUCT* event_list;
 
    int event_count;
 
    int frame_no;
};
 
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
struct EVENT_SETPLAYERSTATE_STRUCT
{
    int player_idx;
 
    unsigned int change_flags;
 
    PXDEMO_PLAYERSTATE_STRUCT state;
};
 
struct EVENT_SETSTAGE_STRUCT
{
    int stage_idx;
};
 
struct EVENT_SETRANDOMSEED_STRUCT
{
    int seed;
};
 
struct EVENT_SETNPCSTATE_STRUCT
{
    unsigned int npc_idx;
 
    unsigned int random_seed;
 
    NPCHAR state;
};
 
struct EVENT_DOSCREENFADE_STRUCT
{
    PXDEMO_FADE_TYPE type;
 
    unsigned char direct;
};
 
struct EVENT_SETCAMERA_STRUCT
{
    int x;
 
    int y;
 
    int target;
 
    int wait;
 
    int quake;
 
    int quake2;
};
 
struct EVENT_SETTIMER_STRUCT
{
    int time_passed;
};
 
struct EVENT_SETNPCDATA_STRUCT
{
    unsigned int code_char;
 
    unsigned long long int transmit_flags;
};
 
struct EVENT_SETMAPTILE_STRUCT
{
    unsigned short tile_x;
    
    unsigned short tile_y;
    
    unsigned short old_tile_id;
    
    unsigned short new_tile_id;
    
    bool show_smoke;
    
    bool only_undo;
};
 
union PXDEMO_EVENT_UNION
{
    EVENT_SETPLAYERSTATE_STRUCT player_state;
 
    EVENT_SETSTAGE_STRUCT stage;
 
    EVENT_SETRANDOMSEED_STRUCT random_seed;
    
    EVENT_SETNPCSTATE_STRUCT npc_state;
 
    EVENT_DOSCREENFADE_STRUCT screen_fade;
 
    EVENT_SETCAMERA_STRUCT camera;
 
    EVENT_SETTIMER_STRUCT timer;
    
    EVENT_SETNPCDATA_STRUCT npc_data;
    
    EVENT_SETMAPTILE_STRUCT map_tile;
};
 
struct PXDEMO_EVENT_STRUCT
{
    PXDEMO_EVENT_TYPE type;
 
    union PXDEMO_EVENT_UNION data;
};
 
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
struct PXDEMO_PLAYER_CHUNK
{
    PXDEMO_PLAYER_STRUCT* list;
 
    unsigned int count;
};
 
struct PXDEMO_FRAME_CHUNK
{
    PXDEMO_FRAME_STRUCT* list;
 
    unsigned int count;
};
 
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
struct GAME_DEMO_STATE
{
    static GAME_DEMO_STATE* first;
 
    PXDEMO_DEMOINFO_STRUCT mInfo;
 
    PXDEMO_PLAYER_CHUNK mPlayers;
 
    PXDEMO_FRAME_CHUNK mFrames;
 
    GAME_DEMO_STATE* mNext;
 
    int mChecksum;
};
 
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
extern CAVESTORY_MOD_API void CSM_GameDemo_Link(
    GAME_DEMO_STATE* pState
);
 
extern CAVESTORY_MOD_API void CSM_GameDemo_Unlink(
    GAME_DEMO_STATE* pState
);
 
extern CAVESTORY_MOD_API bool CSM_GameDemo_FirstLink(
    GAME_DEMO_STATE** pFirst
);
 
extern CAVESTORY_MOD_API void CSM_GameDemo_Init(
    GAME_DEMO_STATE* pState
);
 
extern CAVESTORY_MOD_API void CSM_GameDemo_Init_Relink(
    GAME_DEMO_STATE* pState
);
 
extern CAVESTORY_MOD_API void CSM_GameDemo_Free(
    GAME_DEMO_STATE* pState
);
 
extern CAVESTORY_MOD_API int CSM_GameDemo_Load(
    GAME_DEMO_STATE* pState,
    const char*      pFileName
);
 
extern CAVESTORY_MOD_API int CSM_GameDemo_Save(
    GAME_DEMO_STATE* pState,
    const char*      pFileName
);
 
extern CAVESTORY_MOD_API bool CSM_GameDemo_CombineDemos(
    GAME_DEMO_STATE* pDst,
    GAME_DEMO_STATE* pSource,
    unsigned int     iFrameOffset = 0xFFFFFFFF
);
 
extern CAVESTORY_MOD_API bool CSM_GameDemo_Optimize(
    GAME_DEMO_STATE* pState,
    bool             bSaveAndLoad
);
 
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
extern CAVESTORY_MOD_API PXDEMO_PLAYER_STRUCT* CSM_GameDemo_Players_Add(
    GAME_DEMO_STATE*     pState,
    const char*          pName,
    SafeClientInterface* pInterface
);
 
extern CAVESTORY_MOD_API bool CSM_GameDemo_Players_Remove(
    GAME_DEMO_STATE* pState,
    const char*      pName
);
 
extern CAVESTORY_MOD_API PXDEMO_PLAYER_STRUCT* CSM_GameDemo_Players_Find(
    GAME_DEMO_STATE* pState,
    const char*      pName,
    int*             pIndex = NULL
);
 
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
extern CAVESTORY_MOD_API PXDEMO_EVENT_STRUCT* CSM_GameDemo_Events_Add(
    GAME_DEMO_STATE*  pState,
    PXDEMO_EVENT_TYPE iType,
    unsigned int      iFrameNo,
    unsigned int      iInsertNo = 0xFFFFFFFF
);
 
extern CAVESTORY_MOD_API bool CSM_GameDemo_Events_Remove(
    GAME_DEMO_STATE*  pState,
    PXDEMO_EVENT_TYPE iType,
    int               iFrameNo,
    int               iStartIndex = 0
);
 
extern CAVESTORY_MOD_API PXDEMO_EVENT_STRUCT* CSM_GameDemo_Events_Find(
    GAME_DEMO_STATE*      pState,
    PXDEMO_EVENT_TYPE     iType,
    int                   iFrameNo,
    int                   iStartIndex = 0,
    PXDEMO_FRAME_STRUCT** pFramePtr   = NULL,
    int*                  pFrameIndex = NULL,
    int*                  pEventIndex = NULL
);
 
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
extern CAVESTORY_MOD_API PXDEMO_FRAME_STRUCT* CSM_GameDemo_Frames_Add(
    GAME_DEMO_STATE* pState,
    int              iFrameNo
);
 
extern CAVESTORY_MOD_API bool CSM_GameDemo_Frames_Remove(
    GAME_DEMO_STATE* pState,
    int              iFrameNo
);
 
extern CAVESTORY_MOD_API PXDEMO_FRAME_STRUCT* CSM_GameDemo_Frames_Find(
    GAME_DEMO_STATE* pState,
    int              iFrameNo,
    int*             pIndex = NULL
);
 
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
extern CAVESTORY_MOD_API void CSM_GameDemo_LoadGamestate(
    GAME_DEMO_STATE* pState
);
 
extern CAVESTORY_MOD_API void CSM_GameDemo_Act(
    GAME_DEMO_STATE* pState,
    bool             bFreezeFrame = false,
    bool             bDontDraw    = false,
    bool             bDrawHUD     = true,
    bool             bDrawFade    = true
);
 
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
extern CAVESTORY_MOD_API void CSM_GameDemo_StartRecord();
 
extern CAVESTORY_MOD_API void CSM_GameDemo_StopRecord(
    GAME_DEMO_STATE* pState
);
 
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
extern CAVESTORY_MOD_API PXDEMO_EVENT_STRUCT* CSM_GameDemo_Record_PlayerState(
    GAME_DEMO_STATE*     pState,
    const char*          pName,
    SafeClientInterface* pInterface
);
 
extern CAVESTORY_MOD_API PXDEMO_EVENT_STRUCT* CSM_GameDemo_Record_Stage(
    GAME_DEMO_STATE* pState
);
 
extern CAVESTORY_MOD_API PXDEMO_EVENT_STRUCT* CSM_GameDemo_Record_RandomSeed(
    GAME_DEMO_STATE* pState
);
 
extern CAVESTORY_MOD_API PXDEMO_EVENT_STRUCT* CSM_GameDemo_Record_NpcState(
    GAME_DEMO_STATE* pState,
    NPCHAR*          pNpc,
    int              iIndex
);
 
extern CAVESTORY_MOD_API PXDEMO_EVENT_STRUCT* CSM_GameDemo_Record_Fade(
    GAME_DEMO_STATE* pState,
    PXDEMO_FADE_TYPE iType,
    Directions       iDirect
);
 
extern CAVESTORY_MOD_API PXDEMO_EVENT_STRUCT* CSM_GameDemo_Record_Camera(
    GAME_DEMO_STATE* pState
);
 
extern CAVESTORY_MOD_API PXDEMO_EVENT_STRUCT* CSM_GameDemo_Record_Timer(
    GAME_DEMO_STATE* pState
);
 
extern CAVESTORY_MOD_API PXDEMO_EVENT_STRUCT* CSM_GameDemo_Record_MapTileChange(
    GAME_DEMO_STATE* pState,
    unsigned short   iTileX,
    unsigned short   iTileY,
    unsigned int     iOldTileID,
    unsigned int     iNewTileID,
    bool             bCreateSmoke,
    bool             bOnlyUndo
);
 
extern CAVESTORY_MOD_API int CSM_GameDemo_Record_NewFrame(
    GAME_DEMO_STATE* pState
);
 
//------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
 
extern CAVESTORY_MOD_API GAME_DEMO_STATE* gRecordingDemo;
 
#include <CSMAPI_endcode.h>
 
///