From f9f38e98d9b6623cfa143e52d1506db01684103b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andr=C3=A9s=20S=C3=A1nchez?= <55501523+andresj-sanchez@users.noreply.github.com> Date: Tue, 31 Mar 2026 20:06:48 -0400 Subject: [PATCH 1/3] Update objdiff and compiler flags --- configure.py | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/configure.py b/configure.py index 46f27ef..e68fd38 100644 --- a/configure.py +++ b/configure.py @@ -190,7 +190,7 @@ def do_clean(version: str, build_dir: Path) -> None: config.binutils_tag = "2.45" config.compilers_tag = "20250812" config.mwccps2_tag = "3.0.1b198-051011" -config.objdiff_tag = "v3.5.1" +config.objdiff_tag = "v3.7.1" config.wibo_tag = "1.0.0-beta.5" # Project @@ -209,7 +209,8 @@ def do_clean(version: str, build_dir: Path) -> None: # Base flags for MWCCPS2 (C++ game code) cflags_base = [ "-lang=c++", - "-O3", + "-O3,p", + "-sdatathreshold 0", "-i include", f"-DBUILD_VERSION={version_num}", ] @@ -217,7 +218,8 @@ def do_clean(version: str, build_dir: Path) -> None: # Flags for C SDK libraries (no -lang=c++ override) cflags_c = [ "-lang=c", - "-O3", + "-O3,p", + "-sdatathreshold 0", "-i include", f"-DBUILD_VERSION={version_num}", ] From dca125dc6230883055233497a2408ed2d23f5119 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andr=C3=A9s=20S=C3=A1nchez?= <55501523+andresj-sanchez@users.noreply.github.com> Date: Tue, 31 Mar 2026 20:22:08 -0400 Subject: [PATCH 2/3] Match: Performance (except 2 functions) --- .../Projects/SR2/pgm/lib/OO/PS2/PS2System.hpp | 10 + .../Projects/SR2/pgm/lib/OO/core/OOSystem.hpp | 16 + .../SR2/pgm/lib/OO/core/Singleton.hpp | 11 + .../Projects/SR2/pgm/src/Game/Game.hpp | 78 ++ .../SR2/pgm/src/Game/Story/StoryMgr.hpp | 28 + .../pgm/src/Game/TimeAttack/TimeAtkMgr.hpp | 25 + .../SR2/pgm/src/Game/WorldGp/WorldGpMgr.hpp | 18 + .../Projects/SR2/pgm/src/Havok/Havok.hpp | 62 ++ .../src/Object/Player/Character/Character.hpp | 43 ++ .../SR2/pgm/src/Object/Player/Gear/Gear.hpp | 3 + .../pgm/src/Object/Player/Gear/GearCtrl.hpp | 10 +- .../GravityAction/GravityActionManager.hpp | 34 + .../Player/GravityAction/GravityControl.hpp | 51 ++ .../SR2/pgm/src/Object/Player/Performance.hpp | 147 ++-- .../SR2/pgm/src/Object/Player/Player.hpp | 708 ++++++++++++++++++ .../pgm/src/Object/Player/PlayerPhysic.hpp | 31 + include/types.h | 37 + include/usr/local/sega/nn/NNS.hpp | 133 ++++ .../SR2/pgm/src/Object/Player/Performance.cpp | 592 ++++++++------- 19 files changed, 1684 insertions(+), 353 deletions(-) create mode 100644 include/Develop/Projects/SR2/pgm/lib/OO/core/Singleton.hpp create mode 100644 include/types.h diff --git a/include/Develop/Projects/SR2/pgm/lib/OO/PS2/PS2System.hpp b/include/Develop/Projects/SR2/pgm/lib/OO/PS2/PS2System.hpp index e69de29..09c59a2 100644 --- a/include/Develop/Projects/SR2/pgm/lib/OO/PS2/PS2System.hpp +++ b/include/Develop/Projects/SR2/pgm/lib/OO/PS2/PS2System.hpp @@ -0,0 +1,10 @@ +#ifndef PS2SYSTEM_HPP +#define PS2SYSTEM_HPP + +#include "Develop/Projects/SR2/pgm/lib/OO/core/Singleton.hpp" +#include "Develop/Projects/SR2/pgm/lib/OO/core/OOSystem.hpp" + +// total size: 0x4 +class clsPfSystem : public clsSingleton, public clsOOSystem {}; + +#endif // PS2SYSTEM_HPP diff --git a/include/Develop/Projects/SR2/pgm/lib/OO/core/OOSystem.hpp b/include/Develop/Projects/SR2/pgm/lib/OO/core/OOSystem.hpp index e69de29..740c0af 100644 --- a/include/Develop/Projects/SR2/pgm/lib/OO/core/OOSystem.hpp +++ b/include/Develop/Projects/SR2/pgm/lib/OO/core/OOSystem.hpp @@ -0,0 +1,16 @@ +#ifndef OOSYSTEM_HPP +#define OOSYSTEM_HPP + +// OO system base +class clsOOSystem { +public: + void* __vtable; // 0x00 + int m_eSoundMode; // 0x04 + int m_eMessageLanguage; // 0x08 + int m_eVoiceLanguage; // 0x0C + float m_f32FrameRate; // 0x10 + float m_f32FrameRateAdd; // 0x14 + float m_f32FrameRateAdd2; // 0x18 +}; + +#endif // OOSYSTEM_HPP diff --git a/include/Develop/Projects/SR2/pgm/lib/OO/core/Singleton.hpp b/include/Develop/Projects/SR2/pgm/lib/OO/core/Singleton.hpp new file mode 100644 index 0000000..d091f94 --- /dev/null +++ b/include/Develop/Projects/SR2/pgm/lib/OO/core/Singleton.hpp @@ -0,0 +1,11 @@ +#ifndef SINGLETON_HPP +#define SINGLETON_HPP + +// Singleton base class — provides a global instance pointer per type (header-only template) +template +class clsSingleton { +public: + static T* m_tpcSingleton; +}; + +#endif // SINGLETON_HPP diff --git a/include/Develop/Projects/SR2/pgm/src/Game/Game.hpp b/include/Develop/Projects/SR2/pgm/src/Game/Game.hpp index e69de29..80a0aea 100644 --- a/include/Develop/Projects/SR2/pgm/src/Game/Game.hpp +++ b/include/Develop/Projects/SR2/pgm/src/Game/Game.hpp @@ -0,0 +1,78 @@ +#ifndef GAME_HPP +#define GAME_HPP + +#include "Develop/Projects/SR2/pgm/lib/OO/core/Singleton.hpp" +#include "Develop/Projects/SR2/pgm/src/Game/Story/StoryMgr.hpp" +#include "Develop/Projects/SR2/pgm/src/Game/WorldGp/WorldGpMgr.hpp" +#include "Develop/Projects/SR2/pgm/src/Game/TimeAttack/TimeAtkMgr.hpp" + +// Enum for game modes +enum enmMode { + GAME_MODE___NONE = 0, + GAME_MODE___ADVERTISE = 1, + GAME_MODE___TITLE_DEMO = 2, + GAME_MODE___FREE_RACE = 3, + GAME_MODE___TIME_ATTACK = 4, + GAME_MODE___STORY = 5, + GAME_MODE___WORLD_GP = 6, + GAME_MODE___MISSION = 7, + GAME_MODE___TUTORIAL = 8, + GAME_MODE___SURVIVAL_RELAY = 9, + GAME_MODE___SURVIVAL_BALL = 10, + GAME_MODE___SURVIVAL_BATTLE = 11, + GAME_MODE___EVENT = 12, + GAME_MODE___CREDIT = 13, + GAME_MODE___EASY_MENU = 14, + GAME_MODE___MODEL_VIEWER = 15, + GAME_MODE___MAX = 16, +}; + +// class stcSendAdv - used by stcSendNextModeData +class stcSendAdv { +public: + unsigned int u5CharaId : 5; // offset 0x0, size 0x4 + unsigned int u2PadNo : 2; // offset 0x0, size 0x4 + unsigned int u1Paddin : 1; // offset 0x0, size 0x4 + unsigned int u8GearCtrlNo : 8; // offset 0x0, size 0x4 + unsigned int u8Padding1 : 8; // offset 0x0, size 0x4 + unsigned int u8Padding2 : 8; // offset 0x0, size 0x4 +}; + +// class stcSendNextModeData - used by clsGameMgr +class stcSendNextModeData { +public: + class stcSendAdv sSendAdv[8]; // offset 0x0, size 0x20 + enum enmMode eNextMode; // offset 0x20, size 0x4 + signed char s8StageNo; // offset 0x24, size 0x1 + signed char s8PlayerNum; // offset 0x25, size 0x1 + signed char s8UserNum; // offset 0x26, size 0x1 + signed char s8UniqueData; // offset 0x27, size 0x1 +}; + +// class clsGameMgr +class clsGameMgr : public clsSingleton { +public: + class stcSendNextModeData m_sSendNextModeData; // offset 0x4, size 0x28 + class clsStoryMgr cStoryMgr; // offset 0x2C, size 0x14 + class clsWorldGpMgr cWorldGpMgr; // offset 0x40, size 0x28 + class clsTimeAtkMgr cTimeAtkMgr; // offset 0x68, size 0x14 + unsigned char * m_pu8MapBuffer; // offset 0x7C, size 0x4 + enum enmMode m_eMode; // offset 0x80, size 0x4 + unsigned int m_u32EtcUnlock; // offset 0x84, size 0x4 + unsigned char m_eResultSelect; // offset 0x88, size 0x1 + signed char m_s8TitleDemoNo; // offset 0x89, size 0x1 + signed char m_s8SecretTrickType; // offset 0x8A, size 0x1 + signed char m_s8SecretCommnadCount[2]; // offset 0x8B, size 0x2 + unsigned char m_bLogoSkip; // offset 0x8D, size 0x1 + unsigned char m_bStartLoad; // offset 0x8E, size 0x1 + unsigned char m_bStartTutorial; // offset 0x8F, size 0x1 + unsigned char m_abMissionUnLock[16][4]; // offset 0x90, size 0x40 + unsigned char m_abStageUnLock[16]; // offset 0xD0, size 0x10 + unsigned char m_abCharaUnLock[11]; // offset 0xE0, size 0xB + unsigned char m_bEnableRenderNowLodingExpand; // offset 0xEB, size 0x1 + + signed int getFreeAgp_Option() const; + signed int getRelayAgp_Option() const; +}; + +#endif // GAME_HPP diff --git a/include/Develop/Projects/SR2/pgm/src/Game/Story/StoryMgr.hpp b/include/Develop/Projects/SR2/pgm/src/Game/Story/StoryMgr.hpp index e69de29..6f32ad2 100644 --- a/include/Develop/Projects/SR2/pgm/src/Game/Story/StoryMgr.hpp +++ b/include/Develop/Projects/SR2/pgm/src/Game/Story/StoryMgr.hpp @@ -0,0 +1,28 @@ +#ifndef STORYMGR_HPP +#define STORYMGR_HPP + +#include "usr/local/sega/nn/NNS.hpp" + +class _NNS_TEXLIST; + +// struct stcFormer - used by clsStoryMgr +struct stcFormer { + unsigned char u8StoryNo; // offset 0x0, size 0x1 + unsigned char u8StageNo; // offset 0x1, size 0x1 + unsigned char u8EventNo; // offset 0x2, size 0x1 + unsigned char u8MovieNo; // offset 0x3, size 0x1 +}; + +// class clsStoryMgr +class clsStoryMgr { +public: + class _NNS_TEXLIST * m_psTexList_Loading; // offset 0x4, size 0x4 + unsigned int m_u32VictoryLimitMilliSec; // offset 0x8, size 0x4 + struct stcFormer m_sFormer; // offset 0xC, size 0x4 + unsigned char m_eVictoryType; // offset 0x10, size 0x1 + unsigned char m_eHbMode; // offset 0x11, size 0x1 + signed char m_s8StoryNo; // offset 0x12, size 0x1 + signed char m_s8DetailNo; // offset 0x13, size 0x1 +}; + +#endif // STORYMGR_HPP diff --git a/include/Develop/Projects/SR2/pgm/src/Game/TimeAttack/TimeAtkMgr.hpp b/include/Develop/Projects/SR2/pgm/src/Game/TimeAttack/TimeAtkMgr.hpp index e69de29..9e4ea52 100644 --- a/include/Develop/Projects/SR2/pgm/src/Game/TimeAttack/TimeAtkMgr.hpp +++ b/include/Develop/Projects/SR2/pgm/src/Game/TimeAttack/TimeAtkMgr.hpp @@ -0,0 +1,25 @@ +#ifndef TIMEATKMGR_HPP +#define TIMEATKMGR_HPP + +// Enum for TimeAtkMgr start modes +enum enmStartMode { + START_NORMAL = 0, + START_GHOST_VS = 1, + START_WORLD_RANKING = 2, + START_FORCE_NORMAL = 3, +}; + +// class clsTimeAtkMgr +class clsTimeAtkMgr { +public: + enum enmStartMode m_eStartMode; // offset 0x4, size 0x4 + signed int m_s32StageNo; // offset 0x8, size 0x4 + unsigned char m_u8CharaId; // offset 0xC, size 0x1 + unsigned char m_u8PadNo; // offset 0xD, size 0x1 + unsigned char m_u8GearId; // offset 0xE, size 0x1 + unsigned char m_bNextWorldRanking; // offset 0xF, size 0x1 + unsigned char m_bStartWorldRanking; // offset 0x10, size 0x1 + unsigned char m_bModeWorldRanking; // offset 0x11, size 0x1 +}; + +#endif // TIMEATKMGR_HPP diff --git a/include/Develop/Projects/SR2/pgm/src/Game/WorldGp/WorldGpMgr.hpp b/include/Develop/Projects/SR2/pgm/src/Game/WorldGp/WorldGpMgr.hpp index e69de29..1c8fa2c 100644 --- a/include/Develop/Projects/SR2/pgm/src/Game/WorldGp/WorldGpMgr.hpp +++ b/include/Develop/Projects/SR2/pgm/src/Game/WorldGp/WorldGpMgr.hpp @@ -0,0 +1,18 @@ +#ifndef WORLDGPMGR_HPP +#define WORLDGPMGR_HPP + +// class clsWorldGpMgr +class clsWorldGpMgr { +public: + unsigned int m_u32TotalTime; // offset 0x4, size 0x4 + unsigned char m_eHbMode; // offset 0x8, size 0x1 + unsigned char m_au8Points[8]; // offset 0x9, size 0x8 + unsigned char m_au8Ranking[8]; // offset 0x11, size 0x8 + unsigned char m_au8RankingPlayer[8]; // offset 0x19, size 0x8 + unsigned char m_u8TopComCharacterId; // offset 0x21, size 0x1 + signed char m_s8WorldGpStageNo; // offset 0x22, size 0x1 + signed char m_s8DetailNo; // offset 0x23, size 0x1 + unsigned char m_u8PlannedTopComId; // offset 0x24, size 0x1 +}; + +#endif // WORLDGPMGR_HPP diff --git a/include/Develop/Projects/SR2/pgm/src/Havok/Havok.hpp b/include/Develop/Projects/SR2/pgm/src/Havok/Havok.hpp index e69de29..b7d374c 100644 --- a/include/Develop/Projects/SR2/pgm/src/Havok/Havok.hpp +++ b/include/Develop/Projects/SR2/pgm/src/Havok/Havok.hpp @@ -0,0 +1,62 @@ +#ifndef HAVOK_HPP +#define HAVOK_HPP + +#include "Develop/Projects/SR2/pgm/lib/OO/core/Singleton.hpp" + +// total size: 0x4 +class hkPadSpu { +public: + void* m_storage; // offset 0x0, size 0x4 +}; + +// total size: 0x0 +class hkCollisionListener {}; + +// total size: 0x10 +class hkStepInfo { +public: + hkPadSpu m_startTime; // offset 0x0, size 0x4 + hkPadSpu m_endTime; // offset 0x4, size 0x4 + hkPadSpu m_deltaTime; // offset 0x8, size 0x4 + hkPadSpu m_invDeltaTime; // offset 0xC, size 0x4 +}; + +// total size: 0x20 +class clsStepInfo : public hkStepInfo { +public: + hkPadSpu m_invDeltaTimeCaret2; // offset 0x10, size 0x4 +}; + +// Used by hkWorld::updateCollisionFilterOnPhantom +enum hkUpdateCollectionFilterMode { + HK_UPDATE_COLLECTION_FILTER_IGNORE_SHAPE_COLLECTIONS = 0, + HK_UPDATE_COLLECTION_FILTER_PROCESS_SHAPE_COLLECTIONS = 1, +}; + +class hkWorldObject {}; +class hkPhantom : public hkWorldObject {}; +class hkShapePhantom : public hkPhantom {}; +class hkSimpleShapePhantom : public hkShapePhantom {}; + +class hkCharacterProxy { +public: + hkPhantom* getShapePhantom(); +}; + +class hkWorld { +public: + void updateCollisionFilterOnPhantom(hkPhantom* phantom, hkUpdateCollectionFilterMode mode); +}; + +// total size: 0x40 +class clsHavok : public clsSingleton { +public: + virtual ~clsHavok(); // vtable at 0x0 + hkWorld* m_pcWorld; // offset 0x4, size 0x4 + char* m_pu8StackBuff; // offset 0x8, size 0x4 + hkCollisionListener* m_pcRigidListener; // offset 0xC, size 0x4 + clsStepInfo m_cStepInfo; // offset 0x10, size 0x20 + signed int m_s32ProcNum; // offset 0x30, size 0x4 +}; + +#endif // HAVOK_HPP diff --git a/include/Develop/Projects/SR2/pgm/src/Object/Player/Character/Character.hpp b/include/Develop/Projects/SR2/pgm/src/Object/Player/Character/Character.hpp index e69de29..1ac81ee 100644 --- a/include/Develop/Projects/SR2/pgm/src/Object/Player/Character/Character.hpp +++ b/include/Develop/Projects/SR2/pgm/src/Object/Player/Character/Character.hpp @@ -0,0 +1,43 @@ +#ifndef CHARACTER_HPP +#define CHARACTER_HPP + +#include "Develop/Projects/SR2/pgm/src/Object/Player/Performance.hpp" + +class clsModelType_OB_TX; +class clsDrawAttackEffect_Task; +class clsPlayerTask; + +// total size: 0x24 +class stcData { +public: + char ac8Name_Debug[16]; // offset 0x00, size 0x10 + float f32Height; // offset 0x10, size 0x4 + float f32Weight; // offset 0x14, size 0x4 + unsigned char u8Style; // offset 0x18, size 0x1 + unsigned char u8SkillType; // offset 0x19, size 0x1 + unsigned char u8BaseType; // offset 0x1A, size 0x1 + unsigned char u8Reserve[1]; // offset 0x1B, size 0x1 + float f32AttackLFrame; // offset 0x1C, size 0x4 + float f32AttackRFrame; // offset 0x20, size 0x4 +}; + +// total size: 0x60 +class clsCharacter { +public: + clsModelType_OB_TX* m_pcModel; // 0x00, size 0x4 + stcData* m_posData; // 0x04, size 0x4 + clsPlayerTask* m_pcPlayer; // 0x08, size 0x4 + float m_f32OffsetPosition; // 0x0C, size 0x4 + unsigned char m_u8Type; // 0x10, size 0x1 + enmBaseType m_eBaseType; // 0x14, size 0x4 + enmWalkType m_eWalkType; // 0x18, size 0x4 + unsigned char m_u8ModelType; // 0x1C, size 0x1 + float m_f32DrawAlpha; // 0x20, size 0x4 + float m_f32behaviorCnt; // 0x24, size 0x4 + clsDrawAttackEffect_Task* m_pcDrawEffTsk; // 0x28, size 0x4 + float m_sFollowOffsetVF[4]; // 0x30, size 0x10 (NNS_VECTORFAST) + float m_sFollowVF[4]; // 0x40, size 0x10 (NNS_VECTORFAST) + unsigned int m_u32FollowCalcNodeIdx; // 0x50, size 0x4 +}; + +#endif // CHARACTER_HPP diff --git a/include/Develop/Projects/SR2/pgm/src/Object/Player/Gear/Gear.hpp b/include/Develop/Projects/SR2/pgm/src/Object/Player/Gear/Gear.hpp index 99058e3..4670cad 100644 --- a/include/Develop/Projects/SR2/pgm/src/Object/Player/Gear/Gear.hpp +++ b/include/Develop/Projects/SR2/pgm/src/Object/Player/Gear/Gear.hpp @@ -4,6 +4,7 @@ class clsGearCtrl; // forward decl +namespace nspGear { enum enmLevel { LV_ERROR = -1, LV_BASE = 0, @@ -14,6 +15,8 @@ enum enmLevel { MAX_LV_TABLE_NUM = 4, MAX_MODELS = 9, }; +} // namespace nspGear +using namespace nspGear; // For now, we assume this to be the correctly associated enum enum enmRet { diff --git a/include/Develop/Projects/SR2/pgm/src/Object/Player/Gear/GearCtrl.hpp b/include/Develop/Projects/SR2/pgm/src/Object/Player/Gear/GearCtrl.hpp index 9d0245b..5d3346a 100644 --- a/include/Develop/Projects/SR2/pgm/src/Object/Player/Gear/GearCtrl.hpp +++ b/include/Develop/Projects/SR2/pgm/src/Object/Player/Gear/GearCtrl.hpp @@ -1,9 +1,13 @@ +#ifndef GEARCTRL_HPP +#define GEARCTRL_HPP + +#include "Develop/Projects/SR2/pgm/lib/OO/core/Singleton.hpp" +#include "Develop/Projects/SR2/pgm/lib/OO/PS2/PS2System.hpp" #include "Develop/Projects/SR2/pgm/src/Object/Player/Gear/Gear.hpp" #include "Develop/Projects/SR2/pgm/src/Object/Player/Performance.hpp" + class clsGear; // forward decl class clsPrfm; // forward decl -#ifndef GEARCTRL_HPP -#define GEARCTRL_HPP enum enmGearType { GEAR_TYPE_BOARD = 0, @@ -290,7 +294,7 @@ class clsGearCtrl : public clsGearCtrlBase { // Class funcs void behavior(); - void setUnuseGearLevel(enum enmLevel eLevel /* r2 */); + void setUnuseGearLevel(nspGear::enmLevel eLevel /* r2 */); void changeInitGearModel(enum enmInitBoard eBoard /* r2 */); unsigned char getEquipsGearFlags(); //enum enmMotionType getEquipsGearBaseMotionType(); diff --git a/include/Develop/Projects/SR2/pgm/src/Object/Player/GravityAction/GravityActionManager.hpp b/include/Develop/Projects/SR2/pgm/src/Object/Player/GravityAction/GravityActionManager.hpp index e69de29..15c8230 100644 --- a/include/Develop/Projects/SR2/pgm/src/Object/Player/GravityAction/GravityActionManager.hpp +++ b/include/Develop/Projects/SR2/pgm/src/Object/Player/GravityAction/GravityActionManager.hpp @@ -0,0 +1,34 @@ +#ifndef GRAVITYACTIONMANAGER_HPP +#define GRAVITYACTIONMANAGER_HPP + +class clsPlayerTask; +class hkSimpleShapePhantom; +class clsBaseGravityAction; +class clsAdjustGravityAction_Object; + +// total size: 0x50 +class clsGravityActionManager { +public: + class clsPlayerTask* m_pcPlayer; // offset 0x00, size 0x4 + class hkSimpleShapePhantom* m_pcPhantom; // offset 0x04, size 0x4 + class clsBaseGravityAction* m_pcActions[3]; // offset 0x08, size 0xC + class clsAdjustGravityAction_Object* m_pcAdjustGravityAction; // offset 0x14, size 0x4 + int m_eAction; // offset 0x18, size 0x4 + int m_eType; // offset 0x1C, size 0x4 + int m_eSoundStatus; // offset 0x20, size 0x4 + int m_eActionStatus; // offset 0x24, size 0x4 + int m_cFlag; // offset 0x28, size 0x4 + float m_f32Point; // offset 0x2C, size 0x4 + float m_f32LinkBonusPoint; // offset 0x30, size 0x4 + float m_f32DrawPoint; // offset 0x34, size 0x4 + signed int m_s32LinkNum; // offset 0x38, size 0x4 + signed int m_s32BreakNum; // offset 0x3C, size 0x4 + float m_f32Radius; // offset 0x40, size 0x4 + float m_f32CtrlFrame; // offset 0x44, size 0x4 + float m_f32InvalidGCtrlFrame; // offset 0x48, size 0x4 + float m_f32DefaultInvalidGCtrlFrame; // offset 0x4C, size 0x4 + + void checkLimitPoint(); +}; + +#endif // GRAVITYACTIONMANAGER_HPP diff --git a/include/Develop/Projects/SR2/pgm/src/Object/Player/GravityAction/GravityControl.hpp b/include/Develop/Projects/SR2/pgm/src/Object/Player/GravityAction/GravityControl.hpp index e69de29..dba883d 100644 --- a/include/Develop/Projects/SR2/pgm/src/Object/Player/GravityAction/GravityControl.hpp +++ b/include/Develop/Projects/SR2/pgm/src/Object/Player/GravityAction/GravityControl.hpp @@ -0,0 +1,51 @@ +#ifndef GRAVITYCONTROL_HPP +#define GRAVITYCONTROL_HPP + +// total size: 0x98 +struct stcCommonSetting { + float f32RebootFrame; // 0x00 + float f32BonusAccele; // 0x04 + float f32BonusMinSpeed; // 0x08 + float f32TrackingRadRate; // 0x0C + float f32MinSpeed; // 0x10 + float f32MaxSpeed; // 0x14 + float f32SlideReadyFrame; // 0x18 + float f32SlideCancelFrame; // 0x1C + float f32SlideLimitFrame; // 0x20 + float f32SlideChargeFrame; // 0x24 + float f32SlideSlowDownFrame; // 0x28 + float f32SlideCurveDecayRate; // 0x2C + float f32SlideReadyJumpSpeed; // 0x30 + signed int s32SlideRotateAcceleFrameX; // 0x34 + signed int s32SlideRotateAcceleFrameY; // 0x38 + float f32SlideRotateAcceleRadX; // 0x3C + float f32SlideRotateAcceleRadY; // 0x40 + float f32SlideMaxRotateX; // 0x44 + float f32SlideMaxRotateY; // 0x48 + float f32SlideMoveFrame; // 0x4C + float f32TrickReadyFrame; // 0x50 + float f32TrickCancelFrame; // 0x54 + float f32TrickLimitFrame; // 0x58 + float f32TrickChargeFrame; // 0x5C + float f32TrickSlowDownFrame; // 0x60 + signed int s32TrickRotateAcceleFrameX; // 0x64 + signed int s32TrickRotateAcceleFrameY; // 0x68 + float f32TrickRotateAcceleRadX; // 0x6C + float f32TrickRotateAcceleRadY; // 0x70 + float f32TrickMaxRotateX; // 0x74 + float f32TrickMaxRotateY; // 0x78 + float f32TrickMoveFrame; // 0x7C + float f32TrickLandStiffFrame; // 0x80 + float f32SlowdownSpeed; // 0x84 + float f32SlideGpZeroLimitFrame; // 0x88 + float f32SlideGpZeroRotateAcceleRadX; // 0x8C + float f32TrickGpZeroLimitFrame; // 0x90 + float f32GCtrlWheelDischargeRate; // 0x94 +}; + +class clsGravityControl { +public: + static stcCommonSetting t_sCommonSetting; +}; + +#endif // GRAVITYCONTROL_HPP diff --git a/include/Develop/Projects/SR2/pgm/src/Object/Player/Performance.hpp b/include/Develop/Projects/SR2/pgm/src/Object/Player/Performance.hpp index 5b465f7..2e2e356 100644 --- a/include/Develop/Projects/SR2/pgm/src/Object/Player/Performance.hpp +++ b/include/Develop/Projects/SR2/pgm/src/Object/Player/Performance.hpp @@ -1,83 +1,43 @@ #ifndef PERFORMANCE_HPP #define PERFORMANCE_HPP -class clsGearCtrl; // forward decl -typedef signed char int8_t; -typedef short int16_t; -typedef int int32_t; -typedef long long int64_t; - -typedef unsigned char uint8_t; -typedef unsigned short uint16_t; -typedef unsigned int uint32_t; -typedef unsigned long long uint64_t; - -typedef uint8_t uchar; -typedef uint16_t ushort; -typedef uint32_t uint; - -typedef uchar undefined1; -typedef ushort undefined2; -typedef uint undefined4; - -#ifdef _WIN32 - typedef unsigned long ulong; -#else - typedef unsigned int ulong; -#endif - -typedef ulong undefined8; - -typedef int32_t s32; -typedef unsigned int size_t; - -// Enums -//typedef enum { - //CTRL_MODE_WALK = 0, - //CTRL_MODE_NORMAL = 1 -//} enmCtrlMode; - -// typedef enum { -// GEAR_CTRL_0 = 0 -//} enmGearCtrl; +#include "types.h" +#include "Develop/Projects/SR2/pgm/src/Object/Player/GravityAction/GravityControl.hpp" +#include "Develop/Projects/SR2/pgm/src/Game/Game.hpp" + +class clsGearCtrl; // forward decl +class clsCharacter; // forward decl +class clsPlayerTask; // forward decl + +enum enmBaseType { + BASE_PRFM_SPEED = 0, + BASE_PRFM_FLY = 1, + BASE_PRFM_POWER = 2, + BASE_PRFM_SVBALL = 3, + BASE_PRFM_SVBATTLE = 4, + MAX_BASE_PRFM_NUM = 5, +}; -//typedef enum { - //ACTION_MODE_0 = 0 -//} enmActionMode; +enum enmWalkType { + WALK_PRFM_NORMAL = 0, + WALK_PRFM_SVLRACE_FAST = 1, + WALK_PRFM_SVLRACE_USUALLY = 2, + WALK_PRFM_SVLRACE_SLOW = 3, + MAX_WALK_PRFM_NUM = 4, +}; // Structs -// enum enmGearPrfm was here, should probably be here, but the include errors are wack. - -typedef struct stcData { - float f32Speed[3]; // 0x00 - float f32Accele[3]; // 0x0C - float f32RotateSpeed; // 0x18 - float f32RotateAccele; // 0x1C - float f32Grip; // 0x20 - float f32JumpSpeed; // 0x24 - float f32JumpAccele; // 0x28 - float f32Durability; // 0x2C - uint32_t u32Ability; // 0x30 - float f32MaxAgp; // 0x34 - float f32GCtrlDischargeSpeed; // 0x38 - float f32GDiveSpeedRate; // 0x3C - float f32GPTakeRate; // 0x40 - float f32GCtrlGpUseRate; // 0x44 - float f32GDiveGpUseRate; // 0x48 - int32_t s32AttackEnableFrame; // 0x4C - int16_t s16RingCapacity; // 0x50 - int8_t s8TrickRank; // 0x52 - int8_t s8ItemRank; // 0x53 -} stcData; // total size: 0x54 - -//class clsGearCtrl { -//public: - //uint8_t pad[0xCC]; // 0x00 - 0xCB - //enmCtrlMode m_eCtrlMode; // 0xCC - //uint8_t pad2[0x44]; // 0xD0 - 0x10F (rest of struct) -//}; // total size: 0x110 - +// total size: 0x2C +struct stcBasePrfm { + float f32Speed[3]; // 0x00 + float f32Accele[3]; // 0x0C + float f32RotateSpeed; // 0x18 + float f32RotateAccele; // 0x1C + float f32Grip; // 0x20 + float f32Durability; // 0x24 + unsigned int u32Ability;// 0x28 +}; class stcAddPrfm { // total size: 0x6C @@ -111,6 +71,28 @@ class stcAddPrfm { class clsPrfm { public: + struct stcData { + float f32Speed[3]; // 0x00 + float f32Accele[3]; // 0x0C + float f32RotateSpeed; // 0x18 + float f32RotateAccele; // 0x1C + float f32Grip; // 0x20 + float f32JumpSpeed; // 0x24 + float f32JumpAccele; // 0x28 + float f32Durability; // 0x2C + uint32_t u32Ability; // 0x30 + float f32MaxAgp; // 0x34 + float f32GCtrlDischargeSpeed; // 0x38 + float f32GDiveSpeedRate; // 0x3C + float f32GPTakeRate; // 0x40 + float f32GCtrlGpUseRate; // 0x44 + float f32GDiveGpUseRate; // 0x48 + int32_t s32AttackEnableFrame; // 0x4C + int16_t s16RingCapacity; // 0x50 + int8_t s8TrickRank; // 0x52 + int8_t s8ItemRank; // 0x53 + }; // total size: 0x54 + stcData m_sBase; // 0x00 stcData m_sWalk; // 0x54 stcData m_sData; // 0xA8 @@ -119,10 +101,25 @@ class clsPrfm { float m_f32InfiniGpFrame; // 0x104 float m_f32AdjustSpeedRate; // 0x108 float m_f32AdjustAcceleRate; // 0x10C - - stcData* getDataPtr(); + + const stcData* getDataPtr() const; void setMaxAgp(float f32MaxAGP); void setRingCapacity(signed short s16Ring); + void reset(); + void setup(clsCharacter* pcChara, clsGearCtrl* pcGearCtrl); + void updateFrame(); + void updateData(); + void Limit(stcData& rsData); }; // total size: 0x110 +namespace nspChara { + extern stcBasePrfm osWalkPrfm[MAX_WALK_PRFM_NUM]; + extern stcBasePrfm oasBasePrfm[MAX_BASE_PRFM_NUM]; +} +using namespace nspChara; + +namespace nspAgp { + extern float toaf32GpUsedRate[5]; // address: 0x664D80 +} + #endif // PERFORMANCE_HPP \ No newline at end of file diff --git a/include/Develop/Projects/SR2/pgm/src/Object/Player/Player.hpp b/include/Develop/Projects/SR2/pgm/src/Object/Player/Player.hpp index e69de29..9537267 100644 --- a/include/Develop/Projects/SR2/pgm/src/Object/Player/Player.hpp +++ b/include/Develop/Projects/SR2/pgm/src/Object/Player/Player.hpp @@ -0,0 +1,708 @@ +#ifndef PLAYER_HPP +#define PLAYER_HPP + +#include "Develop/Projects/SR2/pgm/src/Object/Player/GravityAction/GravityActionManager.hpp" +#include "Develop/Projects/SR2/pgm/src/Object/Player/Performance.hpp" +#include "Develop/Projects/SR2/pgm/src/Object/Player/Gear/Gear.hpp" +#include "usr/local/sega/nn/NNS.hpp" + +class clsCharacter; +class clsPlayerPhysic; +class clsPrfm; +class clsGearCtrl; +class clsLap; +class clsObject; +class clsTask; +class clsBackLineEffectTask; +class clsVaporTrail_Task; +class clsWeather_Task; +class clsBaseEffect_Task; +class clsDashPanel_Obj; +class clsEggConfetti; +class clsNightsAtkEffect; +class clsModelType_OB_TX; +class clsPlayerTask; +class clsPlaySe_2D; +class clsPlayerKey; +class clsComKey; +class clsUserKey; +class clsPlayerDebug; +class clsPlayerMotion; +class stcInfo; +class clsThroughCollision; +class hkContactPoint; +class clsModelType_OB_TX_MO_MA; + +namespace clsPack { +struct stcSetDataDetail; +} + +enum enmPlayerType { + PLAYER_TYPE__NORMAL = 0, + PLAYER_TYPE__GHOST = 1, +}; + +enum enmStatus { + STATUS_NULL = 0, + STATUS_END = 1, + STATUS_STOP = 2, + STATUS_BLEND = 4, + STATUS_UNLOOP = 8, + STATUS_LINK_ONE = 16, + STATUS_LINK_SYNC = 32, + STATUS_NEXT_UNLOOP = 64, + STATUS_NEXT_STOP = 128, +}; + +enum enmSystemFlag { + SYSTEM_FLAG__CLEAR = 0, + SYSTEM_FLAG__OBJ_PORTAL_FORWARD = 1, +}; + +class clsFlag { +public: + enum enmSystemFlag m_tData; // offset 0x0, size 0x4 +}; + +enum enmNo { + PLAYER_00 = 0, + PLAYER_01 = 1, + PLAYER_02 = 2, + PLAYER_03 = 3, + PLAYER_04 = 4, + PLAYER_05 = 5, + PLAYER_06 = 6, + PLAYER_07 = 7, + MAX_PLAYER = 8, + MAX_COM = 7, +}; + +enum enmFlag { + FLAG_CLEAR = 0, + FLAG_UPDATE_POSTURAL_QUAT = 1, + FLAG_UPDATE_BEHAVIOR = 2, + FLAG_FACE_ROTATE = 4, + FLAG_SLOPE_SLOWDOWN = 8, + FLAG_CENTRIFUGAL_FORCE = 16, + FLAG_REVERSE = 32, + FLAG_NON_MOVE = 64, + FLAG_ALL_TIME_ATTACK = 128, + FLAG_LOSE = 256, + FLAG_INIT = 59, +}; + +enum enmActionType { + ACTION_TYPE_NULL = 0, + ACTION_TYPE_DAMAGE00 = 1, + ACTION_TYPE_DAMAGE01 = 2, + ACTION_TYPE_DEMO = 3, + ACTION_TYPE_WALK_WAIT = 4, + ACTION_TYPE_WALK_RUN = 5, + ACTION_TYPE_WALK_BACK = 6, + ACTION_TYPE_WALK_BRAKE = 7, + ACTION_TYPE_WALK_FLIGHT = 8, + ACTION_TYPE_WALK_SPRING = 9, + ACTION_TYPE_INERTIA = 10, + ACTION_TYPE_RUN = 11, + ACTION_TYPE_BRAKE = 12, + ACTION_TYPE_FLIGHT = 13, + ACTION_TYPE_JUMP = 14, + ACTION_TYPE_TRICK = 15, + ACTION_TYPE_PATH = 16, + ACTION_TYPE_ATTACK = 17, + ACTION_TYPE_RAIL = 18, + ACTION_TYPE_FLY = 19, + ACTION_TYPE_POWER = 20, + ACTION_TYPE_GDIVE = 21, + ACTION_TYPE_GDIVE_AUTO = 22, + ACTION_TYPE_GCTRL_SLIDE = 23, + ACTION_TYPE_GCTRL_TRICK = 24, + ACTION_TYPE_GCTRL_FLIGHT = 25, + ACTION_TYPE_DIR_REGULATE_RUN = 26, + ACTION_TYPE_TRANSLATION_MOVE_PATH = 27, + ACTION_TYPE_WHEELDRIFT = 28, + ACTION_TYPE_AUTOWALLRUN = 29, + ACTION_TYPE_FALSE_START = 30, + ACTION_TYPE_RESTART = 31, + ACTION_TYPE_ATTACKDAMAGE = 32, + ACTION_TYPE_BOOST = 33, + ACTION_TYPE_MAX = 34, + ACTION_TYPE_ = 35, +}; + +enum enmMoveFlag { + MOVE_FLAG_NULL = 0, + MOVE_FLAG_SPEED = 1, + MOVE_FLAG_GRAVITY = 2, + MOVE_FLAG_JUMP = 4, + MOVE_FLAG_VECTOR = 8, + MOVE_FLAG_PATH = 16, + MOVE_FLAG_SURFACE_ADJUST = 32, + DEFAULT_FLAG = 47, +}; + +enum enmLinkType { + LINK_TYPE_NULL = 0, + LINK_TYPE_SPEED = 1, + LINK_TYPE_FLY = 2, + LINK_TYPE_POWER = 3, +}; + +class clsOOList { +public: + unsigned int m_u32Data[5]; // size 0x14 +}; + +enum enmAttackLR { + TARGET_LEFT = 0, + TARGET_RIGHT = 1, +}; + +enum enmComType { + COM_AI_TYPE_LEADER = 0, + COM_AI_TYPE_NORMAL = 1, + MAX_COM_AI_TYPE = 2, +}; + +enum enPlayerCtrlType { + CTRL_TYPE_1P = 0, + CTRL_TYPE_2P = 1, + CTRL_TYPE_3P = 2, + CTRL_TYPE_4P = 3, + CTRL_TYPE_COM = 4, + CTRL_TYPE_REPLAY = 5, + CTRL_TYPE_GHOST = 6, +}; + +class stcRateTime { +public: + signed int s32Sec; // offset 0x0, size 0x4 + signed int s32PassageSec; // offset 0x4, size 0x4 + float f32MSec; // offset 0x8, size 0x4 + float f32PassageMSec; // offset 0xC, size 0x4 +}; + +class clsLimitTime { +public: + class stcRateTime m_sRateTime; // offset 0x0, size 0x10 + float m_f32LimitTime; // offset 0x10, size 0x4 +}; + +class clsCharaVoice { +public: + class clsPlayerTask * m_pcPlayer; // offset 0x4, size 0x4 + float m_f32VoiceDelayFrameRunPast; // offset 0x8, size 0x4 + float m_f32VoiceDelayFrameAttack; // offset 0xC, size 0x4 +}; + +class stcSpeedPath { +public: + signed short s16MaxSpeed; // offset 0x0, size 0x2 + signed short s16MinSpeed; // offset 0x2, size 0x2 + signed short s16Type; // offset 0x4, size 0x2 + signed short as16Reserve[5]; // offset 0x6, size 0xA +}; // total size: 0x10 + +class stcGravityPath { +public: + signed short s16MaxSpeed; // offset 0x0, size 0x2 + signed short s16MinSpeed; // offset 0x2, size 0x2 + signed short s16Flag; // offset 0x4, size 0x2 + signed short as16Reserve[5]; // offset 0x6, size 0xA +}; // total size: 0x10 + +class stcGDivePath { +public: + signed short s16MaxSpeed; // offset 0x0, size 0x2 + signed short s16MinSpeed; // offset 0x2, size 0x2 + signed short s16Flag; // offset 0x4, size 0x2 + signed short as16Reserve[5]; // offset 0x6, size 0xA +}; // total size: 0x10 + +class stcLine { +public: + class NNS_CAPSULE * psCapsule; // offset 0x0, size 0x4 + class NNS_VECTORFAST * psPointVec; // offset 0x4, size 0x4 + class NNS_VECTORFAST * psNormalVec; // offset 0x8, size 0x4 + class NNS_SPHERE sLimitSph; // offset 0xC, size 0x10 + unsigned short u16Num; // offset 0x1C, size 0x2 + unsigned short u16Attr; // offset 0x1E, size 0x2 + union { + signed char s8Data[16]; + class stcSpeedPath sSpeed; + class stcGravityPath sGravity; + class stcGDivePath sGDive; + } uniData; // offset 0x20, size 0x10 +}; // total size: 0x30 + +class clsPath { +public: + class NNS_VECTORFAST m_sUpVecFast; // offset 0x0, size 0x10 + class NNS_VECTORFAST m_sDirVecFast; // offset 0x10, size 0x10 + class NNS_VECTORFAST m_sCrossVecFast; // offset 0x20, size 0x10 + class NNS_VECTORFAST m_sMoveVecFast; // offset 0x30, size 0x10 + class stcLine * m_psLine; // offset 0x40, size 0x4 + float m_f32LengthRate; // offset 0x44, size 0x4 + float m_f32Length; // offset 0x48, size 0x4 + float m_f32DistanceLR; // offset 0x4C, size 0x4 + unsigned short m_u16HitBit; // offset 0x50, size 0x2 + unsigned short m_u16PointNo; // offset 0x52, size 0x2 + signed short m_s16PathNo; // offset 0x54, size 0x2 + unsigned short m_u16SearchHitBit; // offset 0x56, size 0x2 +}; // total size: 0x60 + +class clsFlyAction { +public: + class NNS_QUATERNION m_sFlyQuat; // offset 0x0, size 0x10 + signed int m_A32FlyPitchAngle; // offset 0x10, size 0x4 + signed int m_A32FlyRollAngle; // offset 0x14, size 0x4 + signed short m_s16OldRingNo; // offset 0x18, size 0x2 + signed short m_s16InitType; // offset 0x1A, size 0x2 +}; // total size: 0x1C + +class clsRetPath { +public: + unsigned short m_u16LineNo[8]; // offset 0x0, size 0x10 + unsigned short m_u16LineNum; // offset 0x10, size 0x2 + unsigned short m_u16ActiveLineNo; // offset 0x12, size 0x2 + unsigned short m_u16OldLineNo; // offset 0x14, size 0x2 + float m_f32DotPro; // offset 0x18, size 0x4 + float m_f32DotPro_Deg; // offset 0x1C, size 0x4 +}; // total size: 0x20 + +class clsSlipStream { +public: + class stcData { + public: + class NNS_VECTORFAST sPosVecFast; // offset 0x0, size 0x10 + class NNS_VECTORFAST sDirVecFast; // offset 0x10, size 0x10 + float f32Speed; // offset 0x20, size 0x4 + float f32Accele; // offset 0x24, size 0x4 + float f32Reserved[2]; // offset 0x28, size 0x8 + }; // total size: 0x30 + + class stcData m_sData[4]; // offset 0x0, size 0xC0 + signed int m_eStatus; // offset 0xC0, size 0x4 + float m_f32UpdateCount; // offset 0xC4, size 0x4 + unsigned int m_u32PointNo; // offset 0xC8, size 0x4 +}; // total size: 0xD0 + +class clsReaction { +public: + class NNS_VECTORFAST m_sWallVecFast; // offset 0x0, size 0x10 + class clsPlayerTask * m_pcPlayer; // offset 0x10, size 0x4 + class clsPlaySe_2D * m_pcPlaySe2D; // offset 0x14, size 0x4 + float m_f32EffectFrame; // offset 0x18, size 0x4 + float m_f32EffectSubFrame; // offset 0x1C, size 0x4 + signed int m_eWallType; // offset 0x20, size 0x4 + signed int m_eGDiveType; // offset 0x24, size 0x4 + signed char m_s8WallHitCount; // offset 0x28, size 0x1 + unsigned char m_au8ColInfo[0xC]; // offset 0x2C, size 0xC +}; // total size: 0x40 + +class clsControlMatrix { +public: + float m_sMtx[4][4]; // offset 0x0, size 0x40 + struct NNS_ROTATE_A32 m_sAutoRotA32; // offset 0x40, size 0xC + struct NNS_ROTATE_A32 m_sAutoRotRetAddA32; // offset 0x4C, size 0xC + class NNS_VECTORFAST m_sAutoRotAxisVecFast; // offset 0x60, size 0x10 + class NNS_VECTORFAST m_sVibTrsVecFast; // offset 0x70, size 0x10 + class NNS_VECTORFAST m_sVibTrsSyncVecFast; // offset 0x80, size 0x10 + class NNS_VECTORFAST m_sVibTrsSyncAddVecFast; // offset 0x90, size 0x10 + class NNS_VECTORFAST m_sVibRotVecFast; // offset 0xA0, size 0x10 + class NNS_VECTORFAST m_sVibRotSyncVecFast; // offset 0xB0, size 0x10 + class NNS_VECTORFAST m_sVibRotSyncAddVecFast; // offset 0xC0, size 0x10 + class NNS_VECTORFAST m_sVibRotAxisVecFast; // offset 0xD0, size 0x10 + float m_f32TrsDecayRate; // offset 0xE0, size 0x4 + float m_f32RotDecayRate; // offset 0xE4, size 0x4 + class NNS_VECTORFAST m_sScaleVecFast; // offset 0xF0, size 0x10 + signed int m_eFlag; // offset 0x100, size 0x4 +}; // total size: 0x110 + +class stcInitData { +public: + class NNS_VECTORFAST sPosVecFast; // offset 0x0, size 0x10 + class NNS_VECTORFAST sUpVecFast; // offset 0x10, size 0x10 + float f32LocalAngleRad; // offset 0x20, size 0x4 + unsigned int u32Padding; // offset 0x24, size 0x4 +}; // total size: 0x30 + +class clsLerpParam { +public: + float m_f32Target; // offset 0x0, size 0x4 + float m_f32Result; // offset 0x4, size 0x4 + float m_f32Add; // offset 0x8, size 0x4 + float m_f32Frame; // offset 0xC, size 0x4 +}; // total size: 0x10 + +class clsSlerpQuat { +public: + class NNS_QUATERNION m_sBaseQuat; // offset 0x0, size 0x10 + class NNS_QUATERNION m_sSlerpQuat; // offset 0x10, size 0x10 + class NNS_QUATERNION m_sResultQuat; // offset 0x20, size 0x10 + float m_f32Rate; // offset 0x30, size 0x4 + float m_f32Add; // offset 0x34, size 0x4 + unsigned char m_bIsSlerp; // offset 0x38, size 0x1 +}; // total size: 0x3C + +class clsPosturalCtrl { +public: + float m_sMtx[4][4]; // offset 0x0, size 0x40 + class NNS_VECTORFAST m_sDirVecFast; // offset 0x40, size 0x10 + class NNS_QUATERNION m_sQuat; // offset 0x50, size 0x10 + class clsSlerpQuat m_cSurface; // offset 0x60, size 0x3C + class clsLerpParam m_cRotate; // offset 0x9C, size 0x10 +}; // total size: 0xB0 + +class clsSurface { +public: + class NNS_QUATERNION m_sQuat; // offset 0x0, size 0x10 + class NNS_VECTORFAST m_sUpVecFast; // offset 0x10, size 0x10 +}; // total size: 0x20 + +class clsGravity { +public: + float m_sMtx[4][4]; // offset 0x0, size 0x40 + class NNS_VECTORFAST m_sVecFast; // offset 0x40, size 0x10 + class NNS_VECTORFAST m_sUpVecFast; // offset 0x50, size 0x10 + class clsPlayerTask * m_pcPlayer; // offset 0x60, size 0x4 + class clsPath m_cPath; // offset 0x70, size 0x60 + class clsSlerpQuat m_cSlerpQuat; // offset 0xD0, size 0x3C + float m_f32Speed; // offset 0x10C, size 0x4 + float m_f32Accele; // offset 0x110, size 0x4 + float m_f32FrameRate; // offset 0x114, size 0x4 + signed int m_eFlag; // offset 0x118, size 0x4 + signed int m_eType; // offset 0x11C, size 0x4 + float m_f32ChangeFrame; // offset 0x120, size 0x4 +}; // total size: 0x130 + +class clsObject { +public: + unsigned int m_u32VTable; // offset 0x0, size 0x4 +}; // total size: 0x4 + +class clsTask { +public: + unsigned char m_au8TaskData[0x54]; // offset 0x0, size 0x54 +}; // total size: 0x54 + +class stcBingoControl { +public: + signed char as8Rank[3]; // offset 0x0, size 0x3 + signed char s8RankNo; // offset 0x3, size 0x1 +}; // total size: 0x4 + +class clsBaseTrickAction { +public: + unsigned int m_u32Dummy; +}; // total size: 0x4 + +class clsFlipTrickAction : public clsBaseTrickAction {}; +class clsSpinTrickAction : public clsBaseTrickAction {}; +class clsPipeTrickAction : public clsBaseTrickAction {}; +class clsFreeTrickAction : public clsBaseTrickAction {}; +class clsWallTrickAction : public clsBaseTrickAction {}; +class clsTurbTrickAction : public clsBaseTrickAction {}; +class clsPartsTrickAction : public clsFreeTrickAction {}; + +class clsVerticalTrickAction : public clsBaseTrickAction { +public: + class NNS_VECTORFAST m_sUpVecFast; // offset 0x10, size 0x10 + float m_f32UpAccele; // offset 0x20, size 0x4 +}; // total size: 0x30 + +class clsTrickParam { +public: + class NNS_VECTORFAST m_sDirVecFast; // offset 0x10, size 0x10 + class stcBingoControl m_sBingoControl; // offset 0x20, size 0x4 + class clsPlayerTask * m_pcPlayer; // offset 0x24, size 0x4 + void * m_pvTrickMotionData; // offset 0x28, size 0x4 + class stcInfo * m_psColInfo; // offset 0x2C, size 0x4 + class clsRetPath m_cRetCoursePath; // offset 0x30, size 0x20 + float m_f32UpAccele; // offset 0x50, size 0x4 + float m_f32Frame; // offset 0x54, size 0x4 + float m_f32RotRadRate; // offset 0x58, size 0x4 + float m_f32StepFrame; // offset 0x5C, size 0x4 + float m_f32QuickSlowRate; // offset 0x60, size 0x4 + signed int m_eKickerType; // offset 0x64, size 0x4 + signed int m_eStartType; // offset 0x68, size 0x4 + signed int m_eBaseRank; // offset 0x6C, size 0x4 + signed int m_eRank; // offset 0x70, size 0x4 + signed char m_s8MotionStep; // offset 0x74, size 0x1 + signed char m_s8RotDir; // offset 0x75, size 0x1 + signed char m_as8KeyDir[4]; // offset 0x76, size 0x4 + signed char m_s8KeySaveCount; // offset 0x7A, size 0x1 + float m_f32BonusSpeed; // offset 0x7C, size 0x4 + unsigned char m_bEnableKickerDebug; // offset 0x80, size 0x1 + float m_f32DebugSpeed; // offset 0x84, size 0x4 + float m_f32DebugGravity; // offset 0x88, size 0x4 + float m_f32DebugJump; // offset 0x8C, size 0x4 + signed int m_s32EnableAcceleKickerDebug; // offset 0x90, size 0x4 + float m_f32DebugUpSpeed; // offset 0x94, size 0x4 + float m_f32DebugUpAccele; // offset 0x98, size 0x4 + float m_f32DebugDownSpeed; // offset 0x9C, size 0x4 + float m_f32DebugDownAccele; // offset 0xA0, size 0x4 + float m_f32DebugVelocityY; // offset 0xA4, size 0x4 + float m_f32DebugUpGravityAccele; // offset 0xA8, size 0x4 + float m_f32DebugDownGravityAccele; // offset 0xAC, size 0x4 + float m_f32DebugFrame; // offset 0xB0, size 0x4 + unsigned char m_bEnableTrickDebug; // offset 0xB4, size 0x1 + unsigned char m_bTrickRecordDispDebug; // offset 0xB5, size 0x1 + signed int m_eDebugKickerType; // offset 0xB8, size 0x4 + signed int m_eDebugTrickRank; // offset 0xBC, size 0x4 + signed char m_s8DebugKeyDir; // offset 0xC0, size 0x1 +}; // total size: 0xD0 + +class clsTrickManager { +public: + class clsBaseTrickAction * m_apcActionTable[9]; // offset 0x0, size 0x24 + class clsTrickParam m_cParam; // offset 0x30, size 0xD0 + class clsFlipTrickAction m_cFlipTrickAction; // offset 0x100, size 0x4 + class clsSpinTrickAction m_cSpinTrickAction; // offset 0x104, size 0x4 + class clsPipeTrickAction m_cPipeTrickAction; // offset 0x108, size 0x4 + class clsFreeTrickAction m_cFreeTrickAction; // offset 0x10C, size 0x4 + class clsWallTrickAction m_cWallTrickAction; // offset 0x110, size 0x4 + class clsVerticalTrickAction m_cVerticalTrickAction; // offset 0x120, size 0x30 + class clsTurbTrickAction m_cTurbTrickAction; // offset 0x150, size 0x4 + class clsPartsTrickAction m_cPartsTrickAction; // offset 0x154, size 0x4 +}; // total size: 0x160 + +// total size: 0x12F0 +class clsPlayerTask : public clsObject, public clsTask { +public: + virtual ~clsPlayerTask(); + virtual void reset(); + virtual void draw(); + virtual void execute(); + virtual int getPlayerType() const { return PLAYER_TYPE__NORMAL; } // vtable slot 0x58 + + bool isDemo() const; + void setBoardMtx(unsigned int, int); + void setRingNum(int); + void updateLightNo(); + void deleteLightCollision(clsThroughCollision *); + void registLightCollision(clsThroughCollision *); + bool isReverse(); + void contactTriggerEvent(hkContactPoint *, clsObject *); + void changeUserToCom(); + void calcNodePos(); + void stopSlipStreamEffect(); + void updateSlipStreamEffect(); + void setSlipStreamEffect(); + void setStartDemoEffect(); + void setDrawBackLineFlg(); + void demoMotionWeather(); + void setWeather(unsigned char); + bool checkLoopEffect(unsigned char); + void stopLoopEffect(unsigned char); + void setLoopEffect(unsigned char, clsTask *); + void setLoopEffect(unsigned char, unsigned int, clsModelType_OB_TX_MO_MA *, unsigned int); + void stopLoopParticle(unsigned char); + void setLoopParticle(unsigned char, unsigned int, unsigned int, unsigned char); + void setVaporTrail(bool); + void setFalseStartAction(int, int); + void setGoalComPlayer(); + void GoalPlayer(); + void changeCameraRq(unsigned int); + void changeTrickCameraRq(unsigned char, int); + void reconfigurationVelocity(const NNS_VECTORFAST *); + void setInertia(const NNS_VECTORFAST *, float, float); + + signed int m_s32EnableMovePathDebug; // 0x58, size 0x4 + class stcLine m_sDebugLine; // 0x5C, size 0x30 + unsigned char m_bEnableFlyDebug; // 0x8C, size 0x1 + float m_f32Debug_StiffFrame; // 0x90, size 0x4 + float m_f32Debug_StallSpeed; // 0x94, size 0x4 + float m_f32Debug_AirResist; // 0x98, size 0x4 + float m_f32Debug_UpDownAccele; // 0x9C, size 0x4 + float m_f32Debug_FallAccele; // 0xA0, size 0x4 + float m_f32Debug_DescentAccele; // 0xA4, size 0x4 + float m_f32Debug_RollSpeed; // 0xA8, size 0x4 + float m_f32Debug_PitchSpeed; // 0xAC, size 0x4 + float m_f32Debug_UpPitch_Limit; // 0xB0, size 0x4 + float m_f32Debug_DownPitch_Limit; // 0xB4, size 0x4 + float m_af32Debug_PitchGravityTable[3]; // 0xB8, size 0xC + unsigned char m_bDispReturnPoint; // 0xC4, size 0x1 + unsigned char m_bDispCoursePoint; // 0xC5, size 0x1 + class clsPlayerDebug * m_pcDebug; // 0xC8, size 0x4 + signed int m_s32SfId[23]; // 0xCC, size 0x5C + float m_sDrawMtx[2][4][4]; // 0x130, size 0x80 + float m_sEffMtx[4][4]; // 0x1B0, size 0x40 + float m_asBoardMtx[4][4][4]; // 0x1F0, size 0x100 + float m_sGearDrawMtx[4][4]; // 0x2F0, size 0x40 + class NNS_VECTORFAST m_sPosVecFast[2]; // 0x330, size 0x20 + class NNS_VECTORFAST m_sUpVecFast; // 0x350, size 0x10 + class NNS_VECTORFAST m_sPreUpVecFast; // 0x360, size 0x10 + class NNS_VECTORFAST m_sVelocityVecFast; // 0x370, size 0x10 + class NNS_VECTORFAST m_sSpeedVecFast; // 0x380, size 0x10 + class NNS_VECTORFAST m_sAirVecFast; // 0x390, size 0x10 + class NNS_VECTORFAST m_sVectorMoveVecFast; // 0x3A0, size 0x10 + class NNS_VECTORFAST m_sPathMoveVecFast; // 0x3B0, size 0x10 + class NNS_VECTORFAST m_sContactCharaDirVecFast; // 0x3C0, size 0x10 + class NNS_VECTORFAST m_sInertiaVecFast; // 0x3D0, size 0x10 + class NNS_VECTORFAST m_sInertiaDecayVecFast; // 0x3E0, size 0x10 + class NNS_VECTORFAST m_sFaceDirVecFast; // 0x3F0, size 0x10 + class NNS_VECTORFAST m_sContactVecFast; // 0x400, size 0x10 + class NNS_VECTORFAST m_sRelativeVecFast; // 0x410, size 0x10 + class NNS_VECTORFAST m_sExCamTargetPosVecFast; // 0x420, size 0x10 + class NNS_VECTORFAST m_sOffsetDrawVecFast; // 0x430, size 0x10 + class NNS_VECTORFAST m_sMoveNrmVecFast; // 0x440, size 0x10 + class stcInitData m_sInitData; // 0x450, size 0x30 + class stcInitData m_sBackUpData; // 0x480, size 0x30 + class clsPrfm m_cPrfm; // 0x4B0, size 0x110 + class clsPlayerMotion * m_pcMotion; // 0x5C0, size 0x4 + class clsSurface m_cSurface; // 0x5D0, size 0x20 + class clsGravity m_cGravity; // 0x5F0, size 0x130 + class clsGravity m_cBackUpGravity; // 0x720, size 0x130 + class clsPosturalCtrl m_cVelocity; // 0x850, size 0xB0 + class clsPosturalCtrl m_cPostural; // 0x900, size 0xB0 + class clsTrickManager m_cTrick; // 0x9B0, size 0x160 + clsGravityActionManager m_cGravityActionManager; // 0xB10, size 0x50 + class clsControlMatrix m_cControlMatrix; // 0xB60, size 0x110 + class clsReaction m_cReaction; // 0xC70, size 0x40 + class clsPath m_cPath; // 0xCB0, size 0x60 + class clsFlyAction m_cFlyAction; // 0xD10, size 0x1C + class clsRetPath m_cRetCoursePath; // 0xD2C, size 0x20 + class clsSlipStream m_cSlipStream; // 0xD50, size 0xD0 + class clsPlayerKey* m_pcKey; // 0xE20, size 0x4 + class clsComKey* m_pcAutoRunKey; // 0xE24, size 0x4 + class clsUserKey* m_pcUserKeyTmp; // 0xE28, size 0x4 + class clsCharacter* m_pcCharacter; // 0xE2C, size 0x4 + class clsGearCtrl* m_pcGearCtrl; // 0xE30, size 0x4 + class clsPlayerPhysic* m_pcPhysic; // 0xE34, size 0x4 + class clsLap* m_pcLap; // 0xE38, size 0x4 + class clsObject* m_pcGroundObject; // 0xE3C, size 0x4 + class clsOOList m_lstLightCollision; // 0xE40, size 0x14 + class clsFlag m_cSystemFlag; // 0xE54, size 0x4 + enum enmNo m_ePlayerNo; // 0xE58, size 0x4 + enum enmFlag m_eFlag; // 0xE5C, size 0x4 + enum enmStatus m_eStatus; // 0xE60, size 0x4 + enum enmStatus m_eStatusOld; // 0xE64, size 0x4 + enum enmStatus m_eStatusTrigger; // 0xE68, size 0x4 + enum enmStatus m_eStatusRemove; // 0xE6C, size 0x4 + enum enmActionType m_eActionType; // 0xE70, size 0x4 + enum enmActionType m_eOldActionType; // 0xE74, size 0x4 + enum enmMoveFlag m_eMoveFlag; // 0xE78, size 0x4 + float m_f32FrameRate; // 0xE7C, size 0x4 + float m_f32CurveRotateRate; // 0xE80, size 0x4 + float m_f32CurveMotionRate; // 0xE84, size 0x4 + float m_f32CurveRad; // 0xE88, size 0x4 + float m_f32CurveWaitFrame; // 0xE8C, size 0x4 + float m_f32vibrationCurveRate; // 0xE90, size 0x4 + float m_f32CurveFrame; // 0xE94, size 0x4 + float m_f32CentrifugalForce; // 0xE98, size 0x4 + float m_f32MinSpeed; // 0xE9C, size 0x4 + float m_f32MaxSpeed; // 0xEA0, size 0x4 + float m_f32Speed; // 0xEA4, size 0x4 + float m_f32Accele; // 0xEA8, size 0x4 + float m_f32SpeedRate; // 0xEAC, size 0x4 + float m_f32AdjustAcceleRate; // 0xEB0, size 0x4 + float m_f32AdjustMaxSpeed; // 0xEB4, size 0x4 + signed int m_s32NodeVibCycle; // 0xEB8, size 0x4 + float m_f32FaceRotateRate; // 0xEBC, size 0x4 + signed int m_s32RingNum; // 0xEC0, size 0x4 + signed int m_s32GoalRingNum; // 0xEC4, size 0x4 + float m_f32GoalRingRate; // 0xEC8, size 0x4 + signed int m_s32LinkCount; // 0xECC, size 0x4 + enum enmLinkType m_eLinkType; // 0xED0, size 0x4 + float m_f32Val; // 0xED4, size 0x4 + float m_f32ApproachVal; // 0xED8, size 0x4 + float m_af32ActionVal[3]; // 0xEDC, size 0xC + float m_f32ObstacleFrame; // 0xEE8, size 0x4 + float m_f32InertiaDecayFrame; // 0xEEC, size 0x4 + signed int m_s32ActionMode; // 0xEF0, size 0x4 + enum enPlayerCtrlType m_eCtrlType; // 0xEF4, size 0x4 + enum enPlayerCtrlType m_eDefaultCtrlType; // 0xEF8, size 0x4 + signed char m_s8BaseMotionNo; // 0xEFC, size 0x1 + unsigned char m_u8CurrentDrawMtxNo; // 0xEFD, size 0x1 + unsigned char m_u8BadTrackCnt; // 0xEFE, size 0x1 + signed char m_s8Ranking; // 0xEFF, size 0x1 + signed int m_s32FalseStartShockFrame; // 0xF00, size 0x4 + signed int m_s32FalseStartDamageFrame; // 0xF04, size 0x4 + float m_f32DamageFrame; // 0xF08, size 0x4 + float m_f32InvincibilityFrame; // 0xF0C, size 0x4 + float m_f32TrapColorBallFrame; // 0xF10, size 0x4 + float m_f32TrapColorBallDropFrame; // 0xF14, size 0x4 + unsigned int m_u32TrapColorBallDropCnt; // 0xF18, size 0x4 + unsigned int m_u32TrapColorBallDropMaxCnt; // 0xF1C, size 0x4 + float m_f32TrapPartsLockFrame; // 0xF20, size 0x4 + float m_f32EggConfettiFrame; // 0xF24, size 0x4 + float m_f32EggConfettiDropFrame; // 0xF28, size 0x4 + float m_f32NightsAtkEffectFrame; // 0xF2C, size 0x4 + float m_f32NightsAtkEffectDropFrame; // 0xF30, size 0x4 + unsigned int m_u32NightsAtkEffectDropCnt; // 0xF34, size 0x4 + float m_f32DriftSideSign; // 0xF38, size 0x4 + float m_f32DriftOffsetPosturalRotate; // 0xF3C, size 0x4 + float m_f32DriftStartSpeed; // 0xF40, size 0x4 + float m_f32DriftLimitSpeed; // 0xF44, size 0x4 + float m_f32DriftDashSpeed; // 0xF48, size 0x4 + float m_f32DriftHandlingRate; // 0xF4C, size 0x4 + float m_f32DriftFrame; // 0xF50, size 0x4 + unsigned int m_u32DriftDashType; // 0xF54, size 0x4 + float m_f32ReverseRestartCountFrame; // 0xF58, size 0x4 + float m_f32ReverseStartCountFrame; // 0xF5C, size 0x4 + class clsTask * m_apcLoopParticle[4]; // 0xF60, size 0x10 + class clsTask * m_apcLoopEffect[4]; // 0xF70, size 0x10 + class NNS_VECTORFAST m_asNodePos[8]; // 0xF80, size 0x80 + float m_asNodeMatrix[8][4][4]; // 0x1000, size 0x200 + class clsBackLineEffectTask * m_pcBackLineTask; // 0x1200, size 0x4 + class clsVaporTrail_Task * m_pcVaporTrailTask; // 0x1204, size 0x4 + class clsVaporTrail_Task * m_pcSlipStreamTask; // 0x1208, size 0x4 + class clsWeather_Task * m_pcWeatherTask; // 0x120C, size 0x4 + class clsCharaVoice m_cCharaVoice; // 0x1210, size 0x10 + enum enmRet m_aeClipperRet[4]; // 0x1220, size 0x10 + float m_of32DrawClipDistx2; // 0x1230, size 0x4 + float m_of32MotionClipDistx1; // 0x1234, size 0x4 + float m_f32CamMostDistRet; // 0x1238, size 0x4 + float m_f32RandMotionFrame; // 0x123C, size 0x4 + float m_f32RankChangeMotionFrame; // 0x1240, size 0x4 + unsigned int m_u32CamDelayRqType; // 0x1244, size 0x4 + float m_f32CamDelayRqTime; // 0x1248, size 0x4 + float m_f32AttackFrame; // 0x124C, size 0x4 + float m_f32FlightFrame; // 0x1250, size 0x4 + float m_f32SystemScale; // 0x1254, size 0x4 + class clsModelType_OB_TX * m_opcResidenceTexModel_PS2; // 0x1258, size 0x4 + unsigned short m_u16ReturnLineNo; // 0x125C, size 0x2 + unsigned char m_bForcedUpdateFlag; // 0x125E, size 0x1 + unsigned char m_bDrawVisible; // 0x125F, size 0x1 + unsigned char m_bMotionVisible; // 0x1260, size 0x1 + unsigned char m_bDrawFlag; // 0x1261, size 0x1 + signed char m_s8Channel_ICS; // 0x1262, size 0x1 + signed char m_s8FollowNum; // 0x1263, size 0x1 + unsigned char m_u8BaseLightNo; // 0x1264, size 0x1 + unsigned char m_u8LightNo; // 0x1265, size 0x1 + unsigned char m_u8BackUpLightNo; // 0x1266, size 0x1 + unsigned char m_u8BackUpFogNo; // 0x1267, size 0x1 + signed char m_s8OldPathNo; // 0x1268, size 0x1 + unsigned char m_bDisableFog; // 0x1269, size 0x1 + signed char m_s8CameraNo; // 0x126A, size 0x1 + signed char m_s8ViewNo; // 0x126B, size 0x1 + unsigned char m_u8JumpCount; // 0x126C, size 0x1 + signed char m_s8CurAttackTarget; // 0x126D, size 0x1 + float m_f32Attack_Speed; // 0x1270, size 0x4 + float m_f32Attack_Accele; // 0x1274, size 0x4 + float m_f32Attack_SpeedRate; // 0x1278, size 0x4 + enum enmAttackLR m_eTargetSide; // 0x127C, size 0x4 + unsigned char m_bDamageFlag; // 0x1280, size 0x1 + class clsBaseEffect_Task * m_pcDmgEffectTask; // 0x1284, size 0x4 + class clsBaseEffect_Task * m_pcDmgEffectTask2; // 0x1288, size 0x4 + unsigned char m_bIsAttackDmgScale; // 0x128C, size 0x1 + float m_f32AttackDmgScale; // 0x1290, size 0x4 + signed int m_s32SuperSonic; // 0x1294, size 0x4 + enum enmComType m_eComType; // 0x1298, size 0x4 + float m_f32BoostAttackFrame; // 0x129C, size 0x4 + float m_f32GpRateEffectCnt; // 0x12A0, size 0x4 + float m_f32TrickXNegaWaitFrame; // 0x12A4, size 0x4 + unsigned char m_bTrickXNegaFlg; // 0x12A8, size 0x1 + signed int m_s32GoalMotionRequest; // 0x12AC, size 0x4 + class clsLimitTime m_cRingLimitTime; // 0x12B0, size 0x14 + class clsLimitTime m_cRingGravityLimitTime; // 0x12C4, size 0x14 + float m_f32ItemFrame; // 0x12D8, size 0x4 + signed int m_s32ReplayCamIdx; // 0x12DC, size 0x4 + signed int m_s32AutoWallRunPathNo; // 0x12E0, size 0x4 + class clsDashPanel_Obj * m_pcDashPanel; // 0x12E4, size 0x4 + class clsEggConfetti * m_pcEggConfetti; // 0x12E8, size 0x4 + class clsNightsAtkEffect * m_pcNightsAtkEffect; // 0x12EC, size 0x4 +}; + +#endif // PLAYER_HPP diff --git a/include/Develop/Projects/SR2/pgm/src/Object/Player/PlayerPhysic.hpp b/include/Develop/Projects/SR2/pgm/src/Object/Player/PlayerPhysic.hpp index e69de29..da63822 100644 --- a/include/Develop/Projects/SR2/pgm/src/Object/Player/PlayerPhysic.hpp +++ b/include/Develop/Projects/SR2/pgm/src/Object/Player/PlayerPhysic.hpp @@ -0,0 +1,31 @@ +#ifndef PLAYERPHYSIC_HPP +#define PLAYERPHYSIC_HPP + +class clsPlayerTask; +class hkCharacterProxy; +class hkSimpleShapePhantom; +class hkShape; +class clsSimpleShapePhantom; + +// total size: 0x2E0 +class clsPlayerPhysic { +public: + class clsPlayerTask* m_pcPlayer; // offset 0x000, size 0x4 + class hkCharacterProxy* m_pcProxy; // offset 0x004, size 0x4 + class hkSimpleShapePhantom* m_pcPhantom; // offset 0x008, size 0x4 + class hkShape* m_pcShape; // offset 0x00C, size 0x4 + class clsSimpleShapePhantom* m_pcAttackPhantom; // offset 0x010, size 0x4 + unsigned char pad_0x14[0x2A0]; // offset 0x014 + float m_f32AttackRadius; // offset 0x2B4, size 0x4 + float m_f32Radius; // offset 0x2B8, size 0x4 + unsigned int m_u32HitFlg; // offset 0x2BC, size 0x4 + float m_f32InvalidFrame; // offset 0x2C0, size 0x4 + unsigned char m_bIsAttack; // offset 0x2C4, size 0x1 + unsigned char m_u8ColInfoNo; // offset 0x2C5, size 0x1 + unsigned char pad_0x2C6[2]; // offset 0x2C6 + unsigned int m_cMaskColFilter; // offset 0x2C8, size 0x4 (clsFlag) + int m_enColUpdateType; // offset 0x2CC, size 0x4 + unsigned char pad_0x2D0[0x10]; // offset 0x2D0 (hkVector4 m_cBackupVelocity) +}; + +#endif // PLAYERPHYSIC_HPP diff --git a/include/types.h b/include/types.h new file mode 100644 index 0000000..a1c5724 --- /dev/null +++ b/include/types.h @@ -0,0 +1,37 @@ +#ifndef TYPES_H +#define TYPES_H + +typedef signed char int8_t; +typedef short int16_t; +typedef int int32_t; +typedef long long int64_t; + +typedef unsigned char uint8_t; +typedef unsigned short uint16_t; +typedef unsigned int uint32_t; +typedef unsigned long long uint64_t; + +typedef uint8_t uchar; +typedef uint16_t ushort; +typedef uint32_t uint; + +typedef uchar undefined1; +typedef ushort undefined2; +typedef uint undefined4; + +#ifdef _WIN32 + typedef unsigned long ulong; +#else + typedef unsigned int ulong; +#endif + +typedef ulong undefined8; + +typedef int32_t s32; + +#ifndef _SIZE_T_DEFINED +#define _SIZE_T_DEFINED +typedef unsigned int size_t; +#endif + +#endif // TYPES_H diff --git a/include/usr/local/sega/nn/NNS.hpp b/include/usr/local/sega/nn/NNS.hpp index 43b51c1..2cbe97f 100644 --- a/include/usr/local/sega/nn/NNS.hpp +++ b/include/usr/local/sega/nn/NNS.hpp @@ -18,6 +18,30 @@ class NNS_VECTORFAST { float w; // offset 0xC, size 0x4 }; +// total size: 0x10 +class NNS_QUATERNION { +public: + float x; // offset 0x0, size 0x4 + float y; // offset 0x4, size 0x4 + float z; // offset 0x8, size 0x4 + float w; // offset 0xC, size 0x4 +}; + +// total size: 0x10 +class NNS_SPHERE { +public: + class NNS_VECTOR c; // offset 0x0, size 0xC + float r; // offset 0xC, size 0x4 +}; + +// total size: 0x1C +class NNS_CAPSULE { +public: + class NNS_VECTOR c1; // offset 0x0, size 0xC + class NNS_VECTOR c2; // offset 0xC, size 0xC + float r; // offset 0x18, size 0x4 +}; + // total size: 0xC struct NNS_ROTATE { float x; // offset 0x0, size 0x4 @@ -58,6 +82,115 @@ class NNS_MESHSET; class _NNS_NODEEX; class _NNS_TEXLIST; +class sceGsTex1 { +public: + unsigned long LCM : 1; + unsigned long pad01 : 1; + unsigned long MXL : 3; + unsigned long MMAG : 1; + unsigned long MMIN : 3; + unsigned long MTBA : 1; + unsigned long pad10 : 9; + unsigned long L : 2; + unsigned long pad21 : 11; + unsigned long K : 12; + unsigned long pad44 : 20; +}; + +class sceGsTex0 { +public: + unsigned long TBP0 : 14; + unsigned long TBW : 6; + unsigned long PSM : 6; + unsigned long TW : 4; + unsigned long TH : 4; + unsigned long TCC : 1; + unsigned long TFX : 2; + unsigned long CBP : 14; + unsigned long CPSM : 4; + unsigned long CSM : 1; + unsigned long CSA : 5; + unsigned long CLD : 3; +}; + +class sceGsMiptbp1 { +public: + unsigned long TBP1 : 14; + unsigned long TBW1 : 6; + unsigned long TBP2 : 14; + unsigned long TBW2 : 6; + unsigned long TBP3 : 14; + unsigned long TBW3 : 6; + unsigned long pad60 : 4; +}; + +class sceGsMiptbp2 { +public: + unsigned long TBP4 : 14; + unsigned long TBW4 : 6; + unsigned long TBP5 : 14; + unsigned long TBW5 : 6; + unsigned long TBP6 : 14; + unsigned long TBW6 : 6; + unsigned long pad60 : 4; +}; + +class PXS_TEXREG { +public: + class sceGsTex1 tex1; // offset 0x0, size 0x8 + class sceGsTex0 tex0; // offset 0x8, size 0x8 + class sceGsMiptbp1 miptbp1; // offset 0x10, size 0x8 + class sceGsMiptbp2 miptbp2; // offset 0x18, size 0x8 +}; + +class PXS_TEXOBJ { +public: + class PXS_TEXREG texReg; // offset 0x0, size 0x20 +}; + +class NVS_GBIXHEADER { +public: + unsigned int globalIndex; // offset 0x0, size 0x4 + unsigned int bank; // offset 0x4, size 0x4 +}; + +class NVS_SVRHEADER { +public: + unsigned short type; // offset 0x0, size 0x2 + unsigned short miplevel; // offset 0x2, size 0x2 + unsigned short width; // offset 0x4, size 0x2 + unsigned short height; // offset 0x6, size 0x2 +}; + +class NVS_SVROBJ { +public: + class NVS_GBIXHEADER gbixh; // offset 0x0, size 0x8 + class NVS_SVRHEADER svrh; // offset 0x8, size 0x8 + class PXS_TEXOBJ texobj; // offset 0x10, size 0x20 +}; + +// total size: 0x50 +class _NNS_TEXINFO { +public: + class NVS_SVROBJ SvrObj; // offset 0x0, size 0x30 + void * pMainMemory; // offset 0x30, size 0x4 + void * pLocalMemory; // offset 0x34, size 0x4 + unsigned int nLocalBytes; // offset 0x38, size 0x4 + unsigned int nDmaTagBytes; // offset 0x3C, size 0x4 + unsigned int GlobalIndex; // offset 0x40, size 0x4 + unsigned int Bank; // offset 0x44, size 0x4 + unsigned short MinFilter; // offset 0x48, size 0x2 + unsigned short MagFilter; // offset 0x4A, size 0x2 + unsigned int Flag; // offset 0x4C, size 0x4 +}; + +// total size: 0x8 +class _NNS_TEXLIST { +public: + signed int nTex; // offset 0x0, size 0x4 + class _NNS_TEXINFO * pTexInfoList; // offset 0x4, size 0x4 +}; + // total size: 0x4 class NNS_NODEEXPTR { public: diff --git a/src/Develop/Projects/SR2/pgm/src/Object/Player/Performance.cpp b/src/Develop/Projects/SR2/pgm/src/Object/Player/Performance.cpp index f4210f8..69bb6af 100644 --- a/src/Develop/Projects/SR2/pgm/src/Object/Player/Performance.cpp +++ b/src/Develop/Projects/SR2/pgm/src/Object/Player/Performance.cpp @@ -1,275 +1,317 @@ -#include "Develop/Projects/SR2/pgm/src/Object/Player/Gear/GearCtrl.hpp" - -stcData* clsPrfm::getDataPtr() { - if (this->m_pcGearCtrl->m_eCtrlMode != CTRL_MODE_WALK) { - return &this->m_sData; - } - return &this->m_sWalk; -} - -void clsPrfm::setMaxAgp(float f32MaxAGP) { - (this->m_sWalk).f32MaxAgp = f32MaxAGP; - (this->m_sBase).f32MaxAgp = f32MaxAGP; - return; -} - -void clsPrfm::setRingCapacity(signed short s16Ring) { - (this->m_sWalk).s16RingCapacity = s16Ring; - (this->m_sBase).s16RingCapacity = s16Ring; - return; -} - -// Range: 0x1E17F0 -> 0x1E1C0C -// this: r18 -/* -void clsPrfm::updateData() -{ - clsGearCtrl *pcVar1; - clsPlayerTask *pcVar2; - enmBaseType eVar3; - uint uVar4; - enmFlag eVar5; - clsPlayerPhysic *pcVar6; - int iVar7; - long lVar8; - enmFlag eVar9; - float fVar10; - - pcVar1 = this->m_pcGearCtrl; - pcVar2 = pcVar1->m_pcPlayer; - eVar3 = pcVar2->m_pcCharacter->m_eBaseType; - (this->m_sData).f32Speed[0] = - this->m_f32AdjustSpeedRate * - ((pcVar1->m_sAddPrfmData).f32MaxSpeedRate * (this->m_sBase).f32Speed[0] + - (pcVar1->m_sAddPrfmData).af32MaxSpeed[0] + 0.0); - fVar10 = toaf32GpUsedRate[eVar3]; - (this->m_sData).f32Accele[0] = - this->m_f32AdjustAcceleRate * - ((this->m_sBase).f32Accele[0] * (pcVar1->m_sAddPrfmData).f32AcceleRate + - (pcVar1->m_sAddPrfmData).af32Accele[0] + 0.0); - (this->m_sData).f32Speed[1] = - this->m_f32AdjustSpeedRate * - ((pcVar1->m_sAddPrfmData).f32MaxSpeedRate * (this->m_sBase).f32Speed[1] + - (pcVar1->m_sAddPrfmData).af32MaxSpeed[1] + 0.0); - (this->m_sData).f32Accele[1] = - this->m_f32AdjustAcceleRate * - ((this->m_sBase).f32Accele[1] * (pcVar1->m_sAddPrfmData).f32AcceleRate + - (pcVar1->m_sAddPrfmData).af32Accele[1] + 0.0); - (this->m_sData).f32Speed[2] = - this->m_f32AdjustSpeedRate * - ((pcVar1->m_sAddPrfmData).f32MaxSpeedRate * (this->m_sBase).f32Speed[2] + - (pcVar1->m_sAddPrfmData).af32MaxSpeed[2] + 0.0); - (this->m_sData).f32Accele[2] = - this->m_f32AdjustAcceleRate * - ((this->m_sBase).f32Accele[2] * (pcVar1->m_sAddPrfmData).f32AcceleRate + - (pcVar1->m_sAddPrfmData).af32Accele[2] + 0.0); - (this->m_sData).f32RotateSpeed = - (this->m_sBase).f32RotateSpeed * (pcVar1->m_sAddPrfmData).f32RotateSpeedRate + - (pcVar1->m_sAddPrfmData).f32RotateSpeed + 0.0; - (this->m_sData).f32RotateAccele = - (this->m_sBase).f32RotateAccele * (pcVar1->m_sAddPrfmData).f32RotateAcceleRate + - (pcVar1->m_sAddPrfmData).f32RotateAccele + 0.0; - (this->m_sData).f32Grip = - (this->m_sBase).f32Grip * (pcVar1->m_sAddPrfmData).f32GripRate + - (pcVar1->m_sAddPrfmData).f32Grip + 0.0; - (this->m_sData).f32JumpSpeed = (this->m_sBase).f32JumpSpeed; - (this->m_sData).f32JumpAccele = (this->m_sWalk).f32JumpAccele; - (this->m_sData).f32Durability = - (this->m_sBase).f32Durability * (pcVar1->m_sAddPrfmData).f32DurabilityRate + - (pcVar1->m_sAddPrfmData).f32GCtrlDischargeSpeed + 0.0; - (this->m_sData).f32MaxAgp = (this->m_sBase).f32MaxAgp + (pcVar1->m_sAddPrfmData).f32GPTakeRate; - (this->m_sData).u32Ability = - (this->m_sBase).u32Ability | (uint)(pcVar1->m_sAddPrfmData).f32GDiveSpeedRate; - (this->m_sData).f32GCtrlDischargeSpeed = - (this->m_sBase).f32GCtrlDischargeSpeed + (pcVar1->m_sAddPrfmData).f32GCtrlGpUseRate; - (this->m_sData).f32GDiveSpeedRate = - (this->m_sBase).f32GDiveSpeedRate * (pcVar1->m_sAddPrfmData).f32GDiveGpUseRate; - (this->m_sData).f32GPTakeRate = - (this->m_sBase).f32GPTakeRate + (float)(pcVar1->m_sAddPrfmData).s32AttackEnableFrame; - (this->m_sData).f32GCtrlGpUseRate = - (this->m_sBase).f32GCtrlGpUseRate * fVar10 + - *(float *)&(pcVar1->m_sAddPrfmData).s16RingCapacity + 0.0; - (this->m_sData).f32GDiveGpUseRate = - (this->m_sBase).f32GDiveGpUseRate * fVar10 + *(float *)&pcVar1->field_0xbc + 0.0; - (this->m_sData).s32AttackEnableFrame = - (this->m_sBase).s32AttackEnableFrame + *(int *)&pcVar1->field_0xc0; - (this->m_sData).s16RingCapacity = (this->m_sBase).s16RingCapacity + *(short *)&pcVar1->field_0xc4; - (this->m_sData).s8TrickRank = (this->m_sBase).s8TrickRank + pcVar1->field_0xc6; - (this->m_sData).s8ItemRank = (this->m_sBase).s8ItemRank + pcVar1->field_0xc7; - (this->m_sWalk).s16RingCapacity = (this->m_sBase).s16RingCapacity + *(short *)&pcVar1->field_0xc4; - (this->m_sWalk).f32MaxAgp = (this->m_sBase).f32MaxAgp + (pcVar1->m_sAddPrfmData).f32GPTakeRate; - if ((pcVar2->m_eStatus & STATUS_LINK_ONE) != STATUS_NULL) { - (this->m_sData).u32Ability = 0; - } - lVar8 = (**(code **)(*(int *)&(pcVar2->__base).__base + 0x58))(pcVar2); - if (lVar8 == 1) { - uVar4 = (this->m_sData).u32Ability; - } - else { - if (((this->m_sData).u32Ability & 0x20) == 0) { - pcVar2->m_pcCharacter->m_f32DrawAlpha = 1.0; - pcVar6 = pcVar2->m_pcPhysic; - (pcVar6->m_cMaskColFilter).m_tData = ~FLAG_DEFAULT; - uVar4 = (pcVar6->m_pcPhantom->__base).__base.__base.m_collidable.__base.m_broadPhaseHandle. - m_collisionFilterInfo; - iVar7 = getShapePhantom__16hkCharacterProxyFv(pcVar6->m_pcProxy); - *(uint *)(iVar7 + 0x2c) = uVar4; - updateCollisionFilterOnPhantom__7hkWorldFP9hkPhantom28hkUpdateCollectionFilterMode - (*(undefined4 *)(_m_tpcSingleton__23clsSingleton<8clsHavok> + 4),pcVar6->m_pcPhantom - ,0); - } - else { - pcVar2->m_pcCharacter->m_f32DrawAlpha = 0.3; - pcVar6 = pcVar2->m_pcPhysic; - eVar9 = (pcVar6->m_cMaskColFilter).m_tData & 0xfffbfffb; - (pcVar6->m_cMaskColFilter).m_tData = eVar9; - eVar5 = (pcVar6->m_pcPhantom->__base).__base.__base.m_collidable.__base.m_broadPhaseHandle. - m_collisionFilterInfo; - iVar7 = getShapePhantom__16hkCharacterProxyFv(pcVar6->m_pcProxy); - *(enmFlag *)(iVar7 + 0x2c) = eVar5 & eVar9; - updateCollisionFilterOnPhantom__7hkWorldFP9hkPhantom28hkUpdateCollectionFilterMode - (*(undefined4 *)(_m_tpcSingleton__23clsSingleton<8clsHavok> + 4),pcVar6->m_pcPhantom - ,0); - } - uVar4 = (this->m_sData).u32Ability; - } - if (((uVar4 & 8) == 0) || (((this->m_sBase).u32Ability & 8) != 0)) { - this->m_f32InfiniGpFrame = -10.0; - if (this->m_pcGearCtrl->m_eCtrlNo == CTRL_MAG) { - clsGearCtrl::setUnuseGearLevel(this->m_pcGearCtrl,LV_03); - } - } - else if (this->m_f32InfiniGpFrame == -10.0) { - this->m_f32InfiniGpFrame = 1500.0; - (pcVar2->m_cGravityActionManager).m_f32Point = (this->m_sData).f32MaxAgp; - clsGravityActionManager::checkLimitPoint(&pcVar2->m_cGravityActionManager); - } - else if (this->m_f32InfiniGpFrame == -1.0) { - (this->m_sData).u32Ability = uVar4 & 0xfffffff7; - } - if (*(int *)(_m_tpcSingleton__26clsSingleton<10clsGameMgr> + 0x80) == 0xb) { - fVar10 = (this->m_sData).f32Speed[2]; - } - else { - Limit(&this->m_sBase); - fVar10 = (this->m_sData).f32Speed[2]; - } - pcVar2->m_f32MaxSpeed = fVar10; - return; -} -*/ - - -/* -void clsPrfm::setup(class clsCharacter * pcChara, class clsGearCtrl * pcGearCtrl) { - enmWalkType eVar1; - stcData *psVar2; - stcCtrlData *psVar3; - enmBaseType eVar4; - uint uVar5; - char cVar6; - float fVar8; - float fVar9; - float fVar10; - float fVar11; - float fVar12; - int iVar7; - - eVar1 = pcChara->m_eWalkType; - psVar2 = pcChara->m_posData; - psVar3 = pcGearCtrl->m_posData; - eVar4 = pcChara->m_eBaseType; - this->m_pcGearCtrl = pcGearCtrl; - fVar8 = osWalkPrfm[eVar1].f32Accele[0]; - fVar9 = osWalkPrfm[eVar1].f32Speed[1]; - (this->m_sWalk).f32Speed[0] = osWalkPrfm[eVar1].f32Speed[0]; - (this->m_sWalk).f32Accele[0] = fVar8; - (this->m_sWalk).f32Speed[1] = fVar9; - fVar8 = osWalkPrfm[eVar1].f32Speed[2]; - fVar9 = osWalkPrfm[eVar1].f32Accele[2]; - (this->m_sWalk).f32Accele[1] = osWalkPrfm[eVar1].f32Accele[1]; - (this->m_sWalk).f32Speed[2] = fVar8; - (this->m_sWalk).f32Accele[2] = fVar9; - fVar8 = osWalkPrfm[eVar1].f32RotateAccele; - fVar9 = osWalkPrfm[eVar1].f32Grip; - (this->m_sWalk).f32RotateSpeed = osWalkPrfm[eVar1].f32RotateSpeed; - (this->m_sWalk).f32RotateAccele = fVar8; - (this->m_sWalk).f32Grip = fVar9; - (this->m_sWalk).f32JumpSpeed = 0.31578946; - fVar8 = osWalkPrfm[eVar1].f32Durability; - (this->m_sWalk).f32JumpAccele = 0.01754386; - (this->m_sWalk).f32MaxAgp = 100.0; - (this->m_sWalk).f32Durability = fVar8; - (this->m_sWalk).s16RingCapacity = 100; - (this->m_sWalk).s8TrickRank = '\0'; - (this->m_sWalk).s8ItemRank = '\0'; - (this->m_sWalk).f32GPTakeRate = 1.0; - (this->m_sWalk).f32GCtrlGpUseRate = 1.0; - (this->m_sWalk).f32GDiveGpUseRate = 1.0; - (this->m_sWalk).u32Ability = 0; - if (*(int *)(m_tpcSingleton->m_eMode) != 0xb) { - Limit(&this->m_sBase); - } - fVar8 = psVar2->f32Accele[2] + psVar3->f32Weight; - uVar5 = oasBasePrfm[eVar4].u32Ability; - fVar12 = fVar8 + 1.0; - fVar10 = 1.0 - fVar8; - this->m_f32WeightRate = fVar8; - fVar8 = oasBasePrfm[eVar4].f32Accele[0]; - fVar9 = oasBasePrfm[eVar4].f32Speed[1]; - (this->m_sBase).f32Speed[0] = fVar12 * oasBasePrfm[eVar4].f32Speed[0]; - (this->m_sBase).f32Accele[0] = fVar10 * fVar8; - fVar11 = oasBasePrfm[eVar4].f32Accele[1]; - (this->m_sBase).f32Speed[1] = fVar12 * fVar9; - fVar8 = oasBasePrfm[eVar4].f32Speed[2]; - fVar9 = oasBasePrfm[eVar4].f32Accele[2]; - (this->m_sBase).f32Accele[1] = fVar10 * fVar11; - (this->m_sBase).f32Speed[2] = fVar12 * fVar8; - fVar11 = oasBasePrfm[eVar4].f32RotateSpeed; - (this->m_sBase).f32Accele[2] = fVar10 * fVar9; - fVar8 = oasBasePrfm[eVar4].f32RotateAccele; - fVar9 = oasBasePrfm[eVar4].f32Grip; - (this->m_sBase).f32RotateSpeed = fVar10 * fVar11; - (this->m_sBase).f32RotateAccele = fVar10 * fVar8; - (this->m_sBase).f32Grip = fVar10 * fVar9; - fVar8 = oasBasePrfm[eVar4].f32Durability; - (this->m_sBase).f32JumpSpeed = 0.31578946; - (this->m_sBase).f32JumpAccele = 0.01754386; - (this->m_sBase).f32MaxAgp = 100.0; - (this->m_sBase).f32Durability = fVar12 * fVar8; - (this->m_sBase).s16RingCapacity = 100; - (this->m_sBase).s8TrickRank = '\0'; - (this->m_sBase).s8ItemRank = '\0'; - (this->m_sBase).f32GPTakeRate = 1.0; - (this->m_sBase).f32GCtrlGpUseRate = 1.0; - (this->m_sBase).f32GDiveGpUseRate = 1.0; - (this->m_sBase).u32Ability = uVar5; - (this->m_sBase).f32GCtrlDischargeSpeed = fRam00b163e4; - (this->m_sBase).f32GDiveSpeedRate = 1.0; - iVar7 = *(int *)(m_tpcSingleton->m_eMode); - if ((iVar7 == 3) || (iVar7 == 9)) { - if (iVar7 == 3) { - iVar7 = getFreeAgp_Option(); - cVar6 = (char)iVar7; - } - else { - iVar7 = getRelayAgp_Option(); - cVar6 = (char)iVar7; - } - if (cVar6 == '\x02') { - (this->m_sBase).f32GPTakeRate = (this->m_sBase).f32GPTakeRate * 1.5; - } - else if ((cVar6 != '\x01') && (cVar6 == '\0')) { - (this->m_sBase).f32GPTakeRate = (this->m_sBase).f32GPTakeRate * 0.5; - } - } - if (*(int *)(m_tpcSingleton->m_eMode) != 0xb) { - Limit(&this->m_sBase); - } - clsPrfm::updateData(this); - return; -} -*/ - - - +#include "Develop/Projects/SR2/pgm/src/Object/Player/Gear/GearCtrl.hpp" +#include "Develop/Projects/SR2/pgm/src/Object/Player/Player.hpp" +#include "Develop/Projects/SR2/pgm/src/Object/Player/PlayerPhysic.hpp" +#include "Develop/Projects/SR2/pgm/src/Object/Player/Character/Character.hpp" +#include "Develop/Projects/SR2/pgm/src/Havok/Havok.hpp" + +void clsPrfm::reset() { + this->m_f32InfiniGpFrame = -10.0f; +} + +const clsPrfm::stcData* clsPrfm::getDataPtr() const { + if (this->m_pcGearCtrl->m_eCtrlMode != CTRL_MODE_WALK) { + return &this->m_sData; + } + return &this->m_sWalk; +} + +void clsPrfm::setMaxAgp(float f32MaxAGP) { + (this->m_sWalk).f32MaxAgp = f32MaxAGP; + (this->m_sBase).f32MaxAgp = f32MaxAGP; + return; +} + +void clsPrfm::setRingCapacity(signed short s16Ring) { + (this->m_sWalk).s16RingCapacity = s16Ring; + (this->m_sBase).s16RingCapacity = s16Ring; + return; +} + +void clsPrfm::updateFrame() { + if (this->m_sBase.u32Ability & 0x8) { + return; + } + if (this->m_f32InfiniGpFrame <= 0.0f) { + return; + } + this->m_f32InfiniGpFrame -= clsSingleton::m_tpcSingleton->m_f32FrameRateAdd2; + if (this->m_f32InfiniGpFrame > 0.0f) { + return; + } + this->m_sData.u32Ability &= ~0x8; + this->m_f32InfiniGpFrame = -10.0f; + if (this->m_pcGearCtrl->m_eCtrlNo == CTRL_MAG) { + this->m_pcGearCtrl->setUnuseGearLevel(LV_03); + } +} + +void clsPrfm::Limit(stcData& rsData) { + if (rsData.f32Speed[0] > 1.1574074f) { + rsData.f32Speed[0] = 1.1574074f; + } else if (rsData.f32Speed[0] < 0.5555556f) { + rsData.f32Speed[0] = 0.5555556f; + } + if (rsData.f32Speed[1] > 1.1574074f) { + rsData.f32Speed[1] = 1.1574074f; + } else if (rsData.f32Speed[1] < 0.5555556f) { + rsData.f32Speed[1] = 0.5555556f; + } + if (rsData.f32Speed[2] > 1.1574074f) { + rsData.f32Speed[2] = 1.1574074f; + } else if (rsData.f32Speed[2] < 0.5555556f) { + rsData.f32Speed[2] = 0.5555556f; + } + if (rsData.f32Accele[0] > 0.011574074f) { + rsData.f32Accele[0] = 0.011574074f; + } else if (rsData.f32Accele[0] < 0.0015432098f) { + rsData.f32Accele[0] = 0.0015432098f; + } + if (rsData.f32Accele[1] > 0.0077160494f) { + rsData.f32Accele[1] = 0.0077160494f; + } else if (rsData.f32Accele[1] < 0.00023148148f) { + rsData.f32Accele[1] = 0.00023148148f; + } + if (rsData.f32Accele[2] > 0.0077160494f) { + rsData.f32Accele[2] = 0.0077160494f; + } else if (rsData.f32Accele[2] < 0.00010802469f) { + rsData.f32Accele[2] = 0.00010802469f; + } + if (rsData.f32Durability > 200.0f) { + rsData.f32Durability = 200.0f; + } else if (rsData.f32Durability < 10.0f) { + rsData.f32Durability = 10.0f; + } + if (rsData.f32Grip > 1.0f) { + rsData.f32Grip = 1.0f; + } else if (rsData.f32Grip < 0.0f) { + rsData.f32Grip = 0.0f; + } + if (rsData.f32RotateSpeed > 0.17453292f) { + rsData.f32RotateSpeed = 0.17453292f; + } else if (rsData.f32RotateSpeed < 0.0f) { + rsData.f32RotateSpeed = 0.0f; + } + if (rsData.f32RotateAccele > 0.17453292f) { + rsData.f32RotateAccele = 0.17453292f; + } else if (rsData.f32RotateAccele < 0.0f) { + rsData.f32RotateAccele = 0.0f; + } +} + +void clsPrfm::setup(clsCharacter* pcChara, clsGearCtrl* pcGearCtrl) { + ::stcData* psVar2 = pcChara->m_posData; + stcCtrlData* psVar3 = pcGearCtrl->m_posData; + stcBasePrfm& rcWalk = nspChara::osWalkPrfm[pcChara->m_eWalkType]; + stcBasePrfm& rcBase = nspChara::oasBasePrfm[pcChara->m_eBaseType]; + signed char s8Agp; + this->m_pcGearCtrl = pcGearCtrl; + float fVar9 = rcWalk.f32Speed[1]; + fVar9 = rcWalk.f32Accele[2]; + float fVar8 = rcWalk.f32Accele[0]; + this->m_sWalk.f32Speed[0] = rcWalk.f32Speed[0]; + this->m_sWalk.f32Accele[0] = fVar8; + fVar8 = rcWalk.f32Speed[2]; + this->m_sWalk.f32Speed[1] = fVar9; + this->m_sWalk.f32Accele[1] = rcWalk.f32Accele[1]; + this->m_sWalk.f32Speed[2] = fVar8; + this->m_sWalk.f32Accele[2] = fVar9; + fVar9 = rcWalk.f32Grip; + fVar8 = rcWalk.f32RotateAccele; + this->m_sWalk.f32RotateSpeed = rcWalk.f32RotateSpeed; + this->m_sWalk.f32RotateAccele = fVar8; + this->m_sWalk.f32Grip = fVar9; + this->m_sWalk.f32JumpSpeed = 0.31578946f; + fVar8 = rcWalk.f32Durability; + this->m_sWalk.f32JumpAccele = 0.01754386f; + this->m_sWalk.f32MaxAgp = 100.0f; + this->m_sWalk.f32Durability = fVar8; + this->m_sWalk.s16RingCapacity = 100; + this->m_sWalk.s8TrickRank = '\0'; + this->m_sWalk.s8ItemRank = '\0'; + this->m_sWalk.f32GPTakeRate = 1.0f; + this->m_sWalk.f32GCtrlGpUseRate = 1.0f; + this->m_sWalk.f32GDiveGpUseRate = 1.0f; + this->m_sWalk.u32Ability = 0; + + if (clsSingleton::m_tpcSingleton->m_eMode != 0xB) { + this->Limit(this->m_sWalk); + } + + unsigned int uVar5 = rcBase.u32Ability; + fVar8 = psVar2->f32Weight + psVar3->f32Weight; + this->m_sBase.f32JumpSpeed = 0.31578946f; + this->m_sBase.f32JumpAccele = 0.01754386f; + float fVar12 = fVar8 + 1.0f; + float fVar10 = 1.0f - fVar8; + this->m_f32WeightRate = fVar8; + + fVar8 = rcBase.f32Speed[0]; + float fVar11 = rcBase.f32Accele[0]; + fVar9 = rcBase.f32Speed[1]; + this->m_sBase.f32Speed[0] = fVar12 * fVar8; + this->m_sBase.f32Accele[0] = fVar10 * fVar11; + fVar11 = rcBase.f32Accele[1]; + this->m_sBase.f32Speed[1] = fVar12 * fVar9; + fVar8 = rcBase.f32Speed[2]; + fVar9 = rcBase.f32Accele[2]; + this->m_sBase.f32Accele[1] = fVar10 * fVar11; + this->m_sBase.f32Speed[2] = fVar12 * fVar8; + fVar11 = rcBase.f32RotateSpeed; + this->m_sBase.f32Accele[2] = fVar10 * fVar9; + fVar8 = rcBase.f32RotateAccele; + fVar9 = rcBase.f32Grip; + this->m_sBase.f32RotateSpeed = fVar10 * fVar11; + this->m_sBase.f32RotateAccele = fVar10 * fVar8; + this->m_sBase.f32Grip = fVar10 * fVar9; + fVar8 = rcBase.f32Durability; + this->m_sBase.f32JumpSpeed = 0.31578946f; + this->m_sBase.f32JumpAccele = 0.01754386f; + this->m_sBase.f32MaxAgp = 100.0f; + this->m_sBase.f32Durability = fVar12 * fVar8; + this->m_sBase.s16RingCapacity = 100; + this->m_sBase.s8TrickRank = '\0'; + this->m_sBase.s8ItemRank = '\0'; + this->m_sBase.f32GPTakeRate = 1.0f; + this->m_sBase.f32GCtrlGpUseRate = 1.0f; + this->m_sBase.f32GDiveGpUseRate = 1.0f; + this->m_sBase.u32Ability = uVar5; + this->m_sBase.f32GCtrlDischargeSpeed = clsGravityControl::t_sCommonSetting.f32MaxSpeed; + this->m_sBase.f32GDiveSpeedRate = 1.0f; + + if (clsSingleton::m_tpcSingleton->m_eMode == 3 || clsSingleton::m_tpcSingleton->m_eMode == 9) { + if (clsSingleton::m_tpcSingleton->m_eMode == 3) + s8Agp = clsSingleton::m_tpcSingleton->getFreeAgp_Option(); + else + s8Agp = clsSingleton::m_tpcSingleton->getRelayAgp_Option(); + + switch (s8Agp) { + case 0: + m_sBase.f32GPTakeRate *= 0.5f; + break; + case 1: + break; + case 2: + m_sBase.f32GPTakeRate *= 1.5f; + break; + } + } + + if (clsSingleton::m_tpcSingleton->m_eMode != 0xB) { + this->Limit(this->m_sBase); + } + + this->updateData(); +} + +void clsPrfm::updateData() { + clsGearCtrl& rcGearCtrl = *this->m_pcGearCtrl; + float f32GpUsedRate = nspAgp::toaf32GpUsedRate[rcGearCtrl.m_pcPlayer->m_pcCharacter->m_eBaseType]; + + this->m_sData.f32Speed[0] = + this->m_f32AdjustSpeedRate * + (rcGearCtrl.m_sAddPrfmData.f32MaxSpeedRate * this->m_sBase.f32Speed[0] + + rcGearCtrl.m_sAddPrfmData.f32Speed[0] + 0.0f); + this->m_sData.f32Accele[0] = + this->m_f32AdjustAcceleRate * + (this->m_sBase.f32Accele[0] * rcGearCtrl.m_sAddPrfmData.f32AcceleRate + + rcGearCtrl.m_sAddPrfmData.f32Accele[0] + 0.0f); + this->m_sData.f32Speed[1] = + this->m_f32AdjustSpeedRate * + (rcGearCtrl.m_sAddPrfmData.f32MaxSpeedRate * this->m_sBase.f32Speed[1] + + rcGearCtrl.m_sAddPrfmData.f32Speed[1] + 0.0f); + this->m_sData.f32Accele[1] = + this->m_f32AdjustAcceleRate * + (this->m_sBase.f32Accele[1] * rcGearCtrl.m_sAddPrfmData.f32AcceleRate + + rcGearCtrl.m_sAddPrfmData.f32Accele[1] + 0.0f); + this->m_sData.f32Speed[2] = + this->m_f32AdjustSpeedRate * + (rcGearCtrl.m_sAddPrfmData.f32MaxSpeedRate * this->m_sBase.f32Speed[2] + + rcGearCtrl.m_sAddPrfmData.f32Speed[2] + 0.0f); + this->m_sData.f32Accele[2] = + this->m_f32AdjustAcceleRate * + (this->m_sBase.f32Accele[2] * rcGearCtrl.m_sAddPrfmData.f32AcceleRate + + rcGearCtrl.m_sAddPrfmData.f32Accele[2] + 0.0f); + this->m_sData.f32RotateSpeed = + this->m_sBase.f32RotateSpeed * rcGearCtrl.m_sAddPrfmData.f32RotateSpeedRate + + rcGearCtrl.m_sAddPrfmData.f32RotateSpeed + 0.0f; + this->m_sData.f32RotateAccele = + this->m_sBase.f32RotateAccele * rcGearCtrl.m_sAddPrfmData.f32RotateAcceleRate + + rcGearCtrl.m_sAddPrfmData.f32RotateAccele + 0.0f; + this->m_sData.f32Grip = + this->m_sBase.f32Grip * rcGearCtrl.m_sAddPrfmData.f32GripRate + + rcGearCtrl.m_sAddPrfmData.f32Grip + 0.0f; + this->m_sData.f32JumpSpeed = this->m_sBase.f32JumpSpeed; + this->m_sData.f32JumpAccele = this->m_sWalk.f32JumpAccele; + this->m_sData.f32Durability = + this->m_sBase.f32Durability * rcGearCtrl.m_sAddPrfmData.f32DurabilityRate + + rcGearCtrl.m_sAddPrfmData.f32Durability + 0.0f; + this->m_sData.f32MaxAgp = this->m_sBase.f32MaxAgp + rcGearCtrl.m_sAddPrfmData.f32MaxAgp; + this->m_sData.u32Ability = + this->m_sBase.u32Ability | rcGearCtrl.m_sAddPrfmData.u32Ability; + this->m_sData.f32GCtrlDischargeSpeed = + this->m_sBase.f32GCtrlDischargeSpeed + rcGearCtrl.m_sAddPrfmData.f32GCtrlDischargeSpeed; + this->m_sData.f32GDiveSpeedRate = + this->m_sBase.f32GDiveSpeedRate * rcGearCtrl.m_sAddPrfmData.f32GDiveSpeedRate; + this->m_sData.f32GPTakeRate = + this->m_sBase.f32GPTakeRate + rcGearCtrl.m_sAddPrfmData.f32GPTakeRate; + this->m_sData.f32GCtrlGpUseRate = + this->m_sBase.f32GCtrlGpUseRate * f32GpUsedRate + + rcGearCtrl.m_sAddPrfmData.f32GCtrlGpUseRate + 0.0f; + this->m_sData.f32GDiveGpUseRate = + this->m_sBase.f32GDiveGpUseRate * f32GpUsedRate + + rcGearCtrl.m_sAddPrfmData.f32GDiveGpUseRate + 0.0f; + this->m_sData.s32AttackEnableFrame = + this->m_sBase.s32AttackEnableFrame + rcGearCtrl.m_sAddPrfmData.s32AttackEnableFrame; + this->m_sData.s16RingCapacity = + this->m_sBase.s16RingCapacity + rcGearCtrl.m_sAddPrfmData.s16RingCapacity; + this->m_sData.s8TrickRank = this->m_sBase.s8TrickRank + rcGearCtrl.m_sAddPrfmData.s8TrickRank; + this->m_sData.s8ItemRank = this->m_sBase.s8ItemRank + rcGearCtrl.m_sAddPrfmData.s8ItemRank; + this->m_sWalk.s16RingCapacity = + this->m_sBase.s16RingCapacity + rcGearCtrl.m_sAddPrfmData.s16RingCapacity; + this->m_sWalk.f32MaxAgp = this->m_sBase.f32MaxAgp + rcGearCtrl.m_sAddPrfmData.f32MaxAgp; + + if ((rcGearCtrl.m_pcPlayer->m_eStatus & STATUS_LINK_ONE) != STATUS_NULL) { + this->m_sData.u32Ability = 0; + } + + if (rcGearCtrl.m_pcPlayer->getPlayerType() != PLAYER_TYPE__GHOST) { + if (this->m_sData.u32Ability & 0x20) { + rcGearCtrl.m_pcPlayer->m_pcCharacter->m_f32DrawAlpha = 0.3f; + rcGearCtrl.m_pcPlayer->m_pcPhysic->m_cMaskColFilter &= 0xFFFBFFFBu; + *(unsigned int*)((char*)rcGearCtrl.m_pcPlayer->m_pcPhysic->m_pcProxy->getShapePhantom() + 0x2c) = + *(unsigned int*)((char*)rcGearCtrl.m_pcPlayer->m_pcPhysic->m_pcPhantom + 0x2c) & + rcGearCtrl.m_pcPlayer->m_pcPhysic->m_cMaskColFilter; + clsSingleton::m_tpcSingleton->m_pcWorld->updateCollisionFilterOnPhantom( + rcGearCtrl.m_pcPlayer->m_pcPhysic->m_pcPhantom, + HK_UPDATE_COLLECTION_FILTER_IGNORE_SHAPE_COLLECTIONS); + } else { + rcGearCtrl.m_pcPlayer->m_pcCharacter->m_f32DrawAlpha = 1.0f; + rcGearCtrl.m_pcPlayer->m_pcPhysic->m_cMaskColFilter = ~0u; + *(unsigned int*)((char*)rcGearCtrl.m_pcPlayer->m_pcPhysic->m_pcProxy->getShapePhantom() + 0x2c) = + *(unsigned int*)((char*)rcGearCtrl.m_pcPlayer->m_pcPhysic->m_pcPhantom + 0x2c); + clsSingleton::m_tpcSingleton->m_pcWorld->updateCollisionFilterOnPhantom( + rcGearCtrl.m_pcPlayer->m_pcPhysic->m_pcPhantom, + HK_UPDATE_COLLECTION_FILTER_IGNORE_SHAPE_COLLECTIONS); + } + } + + if ((this->m_sData.u32Ability & 8) && !(this->m_sBase.u32Ability & 8)) { + if (this->m_f32InfiniGpFrame == -10.0f) { + this->m_f32InfiniGpFrame = 1500.0f; + rcGearCtrl.m_pcPlayer->m_cGravityActionManager.m_f32Point = this->m_sData.f32MaxAgp; + rcGearCtrl.m_pcPlayer->m_cGravityActionManager.checkLimitPoint(); + } else if (this->m_f32InfiniGpFrame == -1.0f) { + this->m_sData.u32Ability &= ~8u; + } + } else { + this->m_f32InfiniGpFrame = -10.0f; + if (this->m_pcGearCtrl->m_eCtrlNo == CTRL_MAG) { + this->m_pcGearCtrl->setUnuseGearLevel(LV_03); + } + } + + if (clsSingleton::m_tpcSingleton->m_eMode != 0xb) { + this->Limit(this->m_sData); + } + rcGearCtrl.m_pcPlayer->m_f32MaxSpeed = this->m_sData.f32Speed[2]; +} From 658414ae9a5ff1b0eb46c8fbe69f19cefb483154 Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Andr=C3=A9s=20S=C3=A1nchez?= <55501523+andresj-sanchez@users.noreply.github.com> Date: Tue, 31 Mar 2026 20:37:47 -0400 Subject: [PATCH 3/3] Remove -sdatathreshold 0 flag for C files --- configure.py | 1 - 1 file changed, 1 deletion(-) diff --git a/configure.py b/configure.py index e68fd38..69592d0 100644 --- a/configure.py +++ b/configure.py @@ -219,7 +219,6 @@ def do_clean(version: str, build_dir: Path) -> None: cflags_c = [ "-lang=c", "-O3,p", - "-sdatathreshold 0", "-i include", f"-DBUILD_VERSION={version_num}", ]