AxioDL/metaforce
2
0
Fork 0
mirror of https://github.com/AxioDL/metaforce.git synced 2025-05-13 23:11:20 +00:00
Code Issues Projects Releases Wiki Activity

RuntimeCommon: Use override where applicable

Browse Source 
Continues the override modernization by applying it to the main
RuntimeCommon target. Resolves around 1100+ cases where override can be
used.
This commit is contained in:
Lioncash 2019-08-09 15:46:49 -04:00
parent 5eaa7a23e8
commit 9312eef905
86 changed files with 1173 additions and 1130 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

41
Editor/ProjectResourceFactoryBase.hpp
View File

@ -61,10 +61,10 @@ public:
void EnsurePath(const urde::SObjectTag& tag, const hecl::ProjectPath& path); void EnsurePath(const urde::SObjectTag& tag, const hecl::ProjectPath& path);
void CookComplete(); void CookComplete();
bool AsyncPump(); bool AsyncPump();
void WaitUntilComplete(); void WaitUntilComplete() override;
bool IsComplete() { return m_complete; } bool IsComplete() override { return m_complete; }
void PostCancelRequest() {} void PostCancelRequest() override {}
EMediaType GetMediaType() const { return EMediaType::Real; } EMediaType GetMediaType() const override { return EMediaType::Real; }
}; };
protected: protected:
@ -102,7 +102,7 @@ protected:
SObjectTag BuildTagFromPath(const hecl::ProjectPath& path) const { SObjectTag BuildTagFromPath(const hecl::ProjectPath& path) const {
return static_cast<DataSpec::SpecBase&>(*m_cookSpec).buildTagFromPath(path); return static_cast<DataSpec::SpecBase&>(*m_cookSpec).buildTagFromPath(path);
} }
void GetTagListForFile(const char* pakName, std::vector<SObjectTag>& out) const { void GetTagListForFile(const char* pakName, std::vector<SObjectTag>& out) const override {
return static_cast<DataSpec::SpecBase&>(*m_cookSpec).getTagListForFile(pakName, out); return static_cast<DataSpec::SpecBase&>(*m_cookSpec).getTagListForFile(pakName, out);
} }
void CancelBackgroundIndex() { void CancelBackgroundIndex() {
@ -120,32 +120,33 @@ protected:
public: public:
ProjectResourceFactoryBase(hecl::ClientProcess& clientProc) : m_clientProc(clientProc) {} ProjectResourceFactoryBase(hecl::ClientProcess& clientProc) : m_clientProc(clientProc) {}
std::unique_ptr<urde::IObj> Build(const urde::SObjectTag&, const urde::CVParamTransfer&, CObjectReference* selfRef); std::unique_ptr<urde::IObj> Build(const urde::SObjectTag&, const urde::CVParamTransfer&,
CObjectReference* selfRef) override;
void BuildAsync(const urde::SObjectTag&, const urde::CVParamTransfer&, std::unique_ptr<urde::IObj>*, void BuildAsync(const urde::SObjectTag&, const urde::CVParamTransfer&, std::unique_ptr<urde::IObj>*,
CObjectReference* selfRef); CObjectReference* selfRef) override;
void CancelBuild(const urde::SObjectTag&); void CancelBuild(const urde::SObjectTag&) override;
bool CanBuild(const urde::SObjectTag&); bool CanBuild(const urde::SObjectTag&) override;
const urde::SObjectTag* GetResourceIdByName(std::string_view) const; const urde::SObjectTag* GetResourceIdByName(std::string_view) const override;
FourCC GetResourceTypeById(CAssetId id) const; FourCC GetResourceTypeById(CAssetId id) const override;
hecl::ProjectPath GetCookedPath(const hecl::ProjectPath& working, bool pcTarget) const { hecl::ProjectPath GetCookedPath(const hecl::ProjectPath& working, bool pcTarget) const {
return static_cast<DataSpec::SpecBase&>(*m_cookSpec).getCookedPath(working, pcTarget); return static_cast<DataSpec::SpecBase&>(*m_cookSpec).getCookedPath(working, pcTarget);
} }
void EnumerateResources(const std::function<bool(const SObjectTag&)>& lambda) const; void EnumerateResources(const std::function<bool(const SObjectTag&)>& lambda) const override;
void EnumerateNamedResources(const std::function<bool(std::string_view, const SObjectTag&)>& lambda) const; void EnumerateNamedResources(const std::function<bool(std::string_view, const SObjectTag&)>& lambda) const override;
u32 ResourceSize(const SObjectTag& tag); u32 ResourceSize(const SObjectTag& tag) override;
std::shared_ptr<urde::IDvdRequest> LoadResourceAsync(const urde::SObjectTag& tag, void* target); std::shared_ptr<urde::IDvdRequest> LoadResourceAsync(const urde::SObjectTag& tag, void* target) override;
std::shared_ptr<urde::IDvdRequest> LoadResourcePartAsync(const urde::SObjectTag& tag, u32 off, u32 size, std::shared_ptr<urde::IDvdRequest> LoadResourcePartAsync(const urde::SObjectTag& tag, u32 off, u32 size,
void* target); void* target) override;
std::unique_ptr<u8[]> LoadResourceSync(const urde::SObjectTag& tag); std::unique_ptr<u8[]> LoadResourceSync(const urde::SObjectTag& tag) override;
std::unique_ptr<u8[]> LoadNewResourcePartSync(const urde::SObjectTag& tag, u32 off, u32 size); std::unique_ptr<u8[]> LoadNewResourcePartSync(const urde::SObjectTag& tag, u32 off, u32 size) override;
std::shared_ptr<AsyncTask> CookResourceAsync(const urde::SObjectTag& tag); std::shared_ptr<AsyncTask> CookResourceAsync(const urde::SObjectTag& tag);
template <typename ItType> template <typename ItType>
bool AsyncPumpTask(ItType& it); bool AsyncPumpTask(ItType& it);
void AsyncIdle(); void AsyncIdle() override;
void Shutdown() { CancelBackgroundIndex(); } void Shutdown() { CancelBackgroundIndex(); }
bool IsBusy() const { return m_asyncLoadMap.size() != 0; } bool IsBusy() const { return m_asyncLoadMap.size() != 0; }
@ -153,7 +154,7 @@ public:
return TagFromPath(hecl::ProjectPath(*(hecl::Database::Project*)m_proj, path)); return TagFromPath(hecl::ProjectPath(*(hecl::Database::Project*)m_proj, path));
} }
~ProjectResourceFactoryBase() { Shutdown(); } ~ProjectResourceFactoryBase() override { Shutdown(); }
}; };
} // namespace urde } // namespace urde

4
Editor/ProjectResourceFactoryMP1.hpp
View File

@ -15,8 +15,8 @@ public:
void IndexMP1Resources(hecl::Database::Project& proj, CSimplePool& sp); void IndexMP1Resources(hecl::Database::Project& proj, CSimplePool& sp);
void Shutdown(); void Shutdown();
CAssetId TranslateOriginalToNew(CAssetId id) const; CAssetId TranslateOriginalToNew(CAssetId id) const override;
CAssetId TranslateNewToOriginal(CAssetId id) const; CAssetId TranslateNewToOriginal(CAssetId id) const override;
}; };
} // namespace urde } // namespace urde

4
Runtime/Audio/CStreamAudioManager.cpp
View File

@ -148,7 +148,7 @@ struct SDSPStream : boo::IAudioVoiceCallback {
s16 m_prev1 = 0; s16 m_prev1 = 0;
s16 m_prev2 = 0; s16 m_prev2 = 0;
void preSupplyAudio(boo::IAudioVoice&, double) {} void preSupplyAudio(boo::IAudioVoice&, double) override {}
unsigned decompressChunk(unsigned readToSample, int16_t*& data) { unsigned decompressChunk(unsigned readToSample, int16_t*& data) {
unsigned startSamp = m_curSample; unsigned startSamp = m_curSample;
@ -173,7 +173,7 @@ struct SDSPStream : boo::IAudioVoiceCallback {
return m_curSample - startSamp; return m_curSample - startSamp;
} }
size_t supplyAudio(boo::IAudioVoice&, size_t frames, int16_t* data) { size_t supplyAudio(boo::IAudioVoice&, size_t frames, int16_t* data) override {
if (!x0_active) { if (!x0_active) {
memset(data, 0, frames * 2); memset(data, 0, frames * 2);
return frames; return frames;

12
Runtime/Camera/CBallCamera.hpp
View File

@ -235,15 +235,15 @@ public:
CBallCamera(TUniqueId uid, TUniqueId watchedId, const zeus::CTransform& xf, float fovy, float znear, float zfar, CBallCamera(TUniqueId uid, TUniqueId watchedId, const zeus::CTransform& xf, float fovy, float znear, float zfar,
float aspect); float aspect);
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId objId, CStateManager& stateMgr); void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId objId, CStateManager& stateMgr) override;
void ProcessInput(const CFinalInput& input, CStateManager& mgr); void ProcessInput(const CFinalInput& input, CStateManager& mgr) override;
void Reset(const zeus::CTransform&, CStateManager& mgr); void Reset(const zeus::CTransform&, CStateManager& mgr) override;
void Render(const CStateManager& mgr) const; void Render(const CStateManager& mgr) const override;
EBallCameraBehaviour GetBehaviour() const { return x188_behaviour; } EBallCameraBehaviour GetBehaviour() const { return x188_behaviour; }
EBallCameraState GetState() const { return x400_state; } EBallCameraState GetState() const { return x400_state; }
void SetState(EBallCameraState state, CStateManager& mgr); void SetState(EBallCameraState state, CStateManager& mgr);
void Think(float dt, CStateManager& mgr); void Think(float dt, CStateManager& mgr) override;
bool TransitionFromMorphBallState(CStateManager& mgr); bool TransitionFromMorphBallState(CStateManager& mgr);
TUniqueId GetTooCloseActorId() const { return x3dc_tooCloseActorId; } TUniqueId GetTooCloseActorId() const { return x3dc_tooCloseActorId; }
float GetTooCloseActorDistance() const { return x3e0_tooCloseActorDist; } float GetTooCloseActorDistance() const { return x3e0_tooCloseActorDist; }

8
Runtime/Camera/CCameraFilter.hpp
View File

@ -62,10 +62,10 @@ class CCameraFilterPass final : public CCameraFilterPassBase {
std::optional<S> m_shader; std::optional<S> m_shader;
public: public:
void Update(float dt); void Update(float dt) override;
void SetFilter(EFilterType type, EFilterShape shape, float time, const zeus::CColor& color, CAssetId txtr); void SetFilter(EFilterType type, EFilterShape shape, float time, const zeus::CColor& color, CAssetId txtr) override;
void DisableFilter(float time); void DisableFilter(float time) override;
void Draw() const; void Draw() const override;
}; };
class CCameraFilterPassPoly { class CCameraFilterPassPoly {

10
Runtime/Camera/CCinematicCamera.hpp
View File

@ -38,11 +38,11 @@ public:
CCinematicCamera(TUniqueId uid, std::string_view name, const CEntityInfo& info, const zeus::CTransform& xf, CCinematicCamera(TUniqueId uid, std::string_view name, const CEntityInfo& info, const zeus::CTransform& xf,
bool active, float shotDuration, float fovy, float znear, float zfar, float aspect, u32 flags); bool active, float shotDuration, float fovy, float znear, float zfar, float aspect, u32 flags);
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
void Think(float dt, CStateManager& mgr); void Think(float dt, CStateManager& mgr) override;
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager& mgr); void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager& mgr) override;
void ProcessInput(const CFinalInput&, CStateManager& mgr); void ProcessInput(const CFinalInput&, CStateManager& mgr) override;
void Reset(const zeus::CTransform&, CStateManager& mgr); void Reset(const zeus::CTransform&, CStateManager& mgr) override;
u32 GetFlags() const { return x21c_flags; } u32 GetFlags() const { return x21c_flags; }
void WasDeactivated(CStateManager& mgr); void WasDeactivated(CStateManager& mgr);
void SendArrivedMsg(TUniqueId reciever, CStateManager& mgr); void SendArrivedMsg(TUniqueId reciever, CStateManager& mgr);

10
Runtime/Camera/CFirstPersonCamera.hpp
View File

@ -18,11 +18,11 @@ public:
CFirstPersonCamera(TUniqueId, const zeus::CTransform& xf, TUniqueId, float orbitCameraSpeed, float fov, CFirstPersonCamera(TUniqueId, const zeus::CTransform& xf, TUniqueId, float orbitCameraSpeed, float fov,
float nearplane, float farplane, float aspect); float nearplane, float farplane, float aspect);
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
void PreThink(float dt, CStateManager& mgr); void PreThink(float dt, CStateManager& mgr) override;
void Think(float dt, CStateManager& mgr); void Think(float dt, CStateManager& mgr) override;
void ProcessInput(const CFinalInput&, CStateManager& mgr); void ProcessInput(const CFinalInput&, CStateManager& mgr) override;
void Reset(const zeus::CTransform&, CStateManager& mgr); void Reset(const zeus::CTransform&, CStateManager& mgr) override;
void SkipCinematic(); void SkipCinematic();
const zeus::CTransform& GetGunFollowTransform() const { return x190_gunFollowXf; } const zeus::CTransform& GetGunFollowTransform() const { return x190_gunFollowXf; }

4
Runtime/Camera/CGameCamera.hpp
View File

@ -32,8 +32,8 @@ public:
float fov, float nearz, float farz, float aspect, TUniqueId watchedId, bool disableInput, float fov, float nearz, float farz, float aspect, TUniqueId watchedId, bool disableInput,
u32 controllerIdx); u32 controllerIdx);
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&); void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void SetActive(bool active); void SetActive(bool active) override;
virtual void ProcessInput(const CFinalInput&, CStateManager& mgr) = 0; virtual void ProcessInput(const CFinalInput&, CStateManager& mgr) = 0;
virtual void Reset(const zeus::CTransform&, CStateManager& mgr) = 0; virtual void Reset(const zeus::CTransform&, CStateManager& mgr) = 0;

12
Runtime/Camera/CInterpolationCamera.hpp
View File

@ -24,12 +24,12 @@ class CInterpolationCamera : public CGameCamera {
public: public:
CInterpolationCamera(TUniqueId uid, const zeus::CTransform& xf); CInterpolationCamera(TUniqueId uid, const zeus::CTransform& xf);
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&); void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void ProcessInput(const CFinalInput&, CStateManager& mgr); void ProcessInput(const CFinalInput&, CStateManager& mgr) override;
void Render(const CStateManager&) const; void Render(const CStateManager&) const override;
void Reset(const zeus::CTransform&, CStateManager& mgr); void Reset(const zeus::CTransform&, CStateManager& mgr) override;
void Think(float, CStateManager&); void Think(float, CStateManager&) override;
void SetInterpolation(const zeus::CTransform& xf, const zeus::CVector3f& lookPos, float maxTime, float positionSpeed, void SetInterpolation(const zeus::CTransform& xf, const zeus::CVector3f& lookPos, float maxTime, float positionSpeed,
float rotationSpeed, TUniqueId camId, bool sinusoidal, CStateManager& mgr); float rotationSpeed, TUniqueId camId, bool sinusoidal, CStateManager& mgr);
void DeactivateInterpCamera(CStateManager&); void DeactivateInterpCamera(CStateManager&);

12
Runtime/Camera/CPathCamera.hpp
View File

@ -26,12 +26,12 @@ public:
float lengthExtent, float filterMag, float filterProportion, float minEaseDist, float maxEaseDist, float lengthExtent, float filterMag, float filterProportion, float minEaseDist, float maxEaseDist,
u32 flags, EInitialSplinePosition initPos); u32 flags, EInitialSplinePosition initPos);
void Accept(IVisitor&); void Accept(IVisitor&) override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&); void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void Think(float, CStateManager&); void Think(float, CStateManager&) override;
void Render(const CStateManager&) const {} void Render(const CStateManager&) const override {}
void ProcessInput(const CFinalInput&, CStateManager& mgr); void ProcessInput(const CFinalInput&, CStateManager& mgr) override;
void Reset(const zeus::CTransform&, CStateManager& mgr); void Reset(const zeus::CTransform&, CStateManager& mgr) override;
zeus::CTransform MoveAlongSpline(float, CStateManager&); zeus::CTransform MoveAlongSpline(float, CStateManager&);
void ClampToClosedDoor(CStateManager&); void ClampToClosedDoor(CStateManager&);
}; };

20
Runtime/Character/CAdditiveBodyState.hpp
View File

@ -29,9 +29,9 @@ class CABSAim : public CAdditiveBodyState {
pas::EAnimationState GetBodyStateTransition(float dt, CBodyController& bc); pas::EAnimationState GetBodyStateTransition(float dt, CBodyController& bc);
public: public:
void Start(CBodyController& bc, CStateManager& mgr); void Start(CBodyController& bc, CStateManager& mgr) override;
pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr); pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
void Shutdown(CBodyController& bc); void Shutdown(CBodyController& bc) override;
}; };
class CABSFlinch : public CAdditiveBodyState { class CABSFlinch : public CAdditiveBodyState {
@ -41,8 +41,8 @@ class CABSFlinch : public CAdditiveBodyState {
public: public:
void Start(CBodyController& bc, CStateManager& mgr); void Start(CBodyController& bc, CStateManager& mgr);
pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr); pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
void Shutdown(CBodyController& bc) {} void Shutdown(CBodyController& bc) override {}
}; };
class CABSIdle : public CAdditiveBodyState { class CABSIdle : public CAdditiveBodyState {
@ -50,8 +50,8 @@ class CABSIdle : public CAdditiveBodyState {
public: public:
void Start(CBodyController& bc, CStateManager& mgr) {} void Start(CBodyController& bc, CStateManager& mgr) {}
pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr); pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
void Shutdown(CBodyController& bc) {} void Shutdown(CBodyController& bc) override {}
}; };
class CABSReaction : public CAdditiveBodyState { class CABSReaction : public CAdditiveBodyState {
@ -63,9 +63,9 @@ class CABSReaction : public CAdditiveBodyState {
void StopAnimation(CBodyController& bc); void StopAnimation(CBodyController& bc);
public: public:
void Start(CBodyController& bc, CStateManager& mgr); void Start(CBodyController& bc, CStateManager& mgr) override;
pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr); pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
void Shutdown(CBodyController& bc) { StopAnimation(bc); } void Shutdown(CBodyController& bc) override { StopAnimation(bc); }
}; };
} // namespace urde } // namespace urde

57
Runtime/Character/CAnimSourceReader.hpp
View File

@ -24,12 +24,12 @@ class CAnimSourceInfo : public IAnimSourceInfo {
public: public:
CAnimSourceInfo(const TSubAnimTypeToken<CAnimSource>& token); CAnimSourceInfo(const TSubAnimTypeToken<CAnimSource>& token);
bool HasPOIData() const; bool HasPOIData() const override;
const std::vector<CBoolPOINode>& GetBoolPOIStream() const; const std::vector<CBoolPOINode>& GetBoolPOIStream() const override;
const std::vector<CInt32POINode>& GetInt32POIStream() const; const std::vector<CInt32POINode>& GetInt32POIStream() const override;
const std::vector<CParticlePOINode>& GetParticlePOIStream() const; const std::vector<CParticlePOINode>& GetParticlePOIStream() const override;
const std::vector<CSoundPOINode>& GetSoundPOIStream() const; const std::vector<CSoundPOINode>& GetSoundPOIStream() const override;
CCharAnimTime GetAnimationDuration() const; CCharAnimTime GetAnimationDuration() const override;
}; };
class CAnimSourceReaderBase : public IAnimReader { class CAnimSourceReaderBase : public IAnimReader {
@ -56,13 +56,16 @@ protected:
public: public:
CAnimSourceReaderBase(std::unique_ptr<IAnimSourceInfo>&& sourceInfo, const CCharAnimTime& time); CAnimSourceReaderBase(std::unique_ptr<IAnimSourceInfo>&& sourceInfo, const CCharAnimTime& time);
u32 VGetBoolPOIList(const CCharAnimTime& time, CBoolPOINode* listOut, u32 capacity, u32 iterator, u32) const; u32 VGetBoolPOIList(const CCharAnimTime& time, CBoolPOINode* listOut, u32 capacity, u32 iterator, u32) const override;
u32 VGetInt32POIList(const CCharAnimTime& time, CInt32POINode* listOut, u32 capacity, u32 iterator, u32) const; u32 VGetInt32POIList(const CCharAnimTime& time, CInt32POINode* listOut, u32 capacity, u32 iterator,
u32 VGetParticlePOIList(const CCharAnimTime& time, CParticlePOINode* listOut, u32 capacity, u32 iterator, u32) const; u32) const override;
u32 VGetSoundPOIList(const CCharAnimTime& time, CSoundPOINode* listOut, u32 capacity, u32 iterator, u32) const; u32 VGetParticlePOIList(const CCharAnimTime& time, CParticlePOINode* listOut, u32 capacity, u32 iterator,
bool VGetBoolPOIState(const char* name) const; u32) const override;
s32 VGetInt32POIState(const char* name) const; u32 VGetSoundPOIList(const CCharAnimTime& time, CSoundPOINode* listOut, u32 capacity, u32 iterator,
CParticleData::EParentedMode VGetParticlePOIState(const char* name) const; u32) const override;
bool VGetBoolPOIState(const char* name) const override;
s32 VGetInt32POIState(const char* name) const override;
CParticleData::EParentedMode VGetParticlePOIState(const char* name) const override;
using IAnimReader::VGetOffset; using IAnimReader::VGetOffset;
virtual zeus::CVector3f VGetOffset(const CSegId& seg, const CCharAnimTime& b) const = 0; virtual zeus::CVector3f VGetOffset(const CSegId& seg, const CCharAnimTime& b) const = 0;
@ -80,20 +83,20 @@ public:
CAnimSourceReader(const TSubAnimTypeToken<CAnimSource>& source, const CCharAnimTime& time); CAnimSourceReader(const TSubAnimTypeToken<CAnimSource>& source, const CCharAnimTime& time);
CAnimSourceReader(const CAnimSourceReader& other); CAnimSourceReader(const CAnimSourceReader& other);
SAdvancementResults VGetAdvancementResults(const CCharAnimTime& a, const CCharAnimTime& b) const; SAdvancementResults VGetAdvancementResults(const CCharAnimTime& a, const CCharAnimTime& b) const override;
bool VSupportsReverseView() const { return true; } bool VSupportsReverseView() const override { return true; }
void VSetPhase(float); void VSetPhase(float) override;
SAdvancementResults VReverseView(const CCharAnimTime& time); SAdvancementResults VReverseView(const CCharAnimTime& time) override;
std::unique_ptr<IAnimReader> VClone() const; std::unique_ptr<IAnimReader> VClone() const override;
void VGetSegStatementSet(const CSegIdList& list, CSegStatementSet& setOut) const; void VGetSegStatementSet(const CSegIdList& list, CSegStatementSet& setOut) const override;
void VGetSegStatementSet(const CSegIdList& list, CSegStatementSet& setOut, const CCharAnimTime& time) const; void VGetSegStatementSet(const CSegIdList& list, CSegStatementSet& setOut, const CCharAnimTime& time) const override;
SAdvancementResults VAdvanceView(const CCharAnimTime& a); SAdvancementResults VAdvanceView(const CCharAnimTime& a) override;
CCharAnimTime VGetTimeRemaining() const; CCharAnimTime VGetTimeRemaining() const override;
CSteadyStateAnimInfo VGetSteadyStateAnimInfo() const; CSteadyStateAnimInfo VGetSteadyStateAnimInfo() const override;
bool VHasOffset(const CSegId& seg) const; bool VHasOffset(const CSegId& seg) const override;
zeus::CVector3f VGetOffset(const CSegId& seg) const; zeus::CVector3f VGetOffset(const CSegId& seg) const override;
zeus::CVector3f VGetOffset(const CSegId& seg, const CCharAnimTime& time) const; zeus::CVector3f VGetOffset(const CSegId& seg, const CCharAnimTime& time) const override;
zeus::CQuaternion VGetRotation(const CSegId& seg) const; zeus::CQuaternion VGetRotation(const CSegId& seg) const override;
}; };
} // namespace urde } // namespace urde

52
Runtime/Character/CAnimTreeAnimReaderContainer.hpp
View File

@ -11,31 +11,35 @@ class CAnimTreeAnimReaderContainer : public CAnimTreeNode {
public: public:
CAnimTreeAnimReaderContainer(std::string_view name, std::shared_ptr<IAnimReader> reader, u32 animDbIdx); CAnimTreeAnimReaderContainer(std::string_view name, std::shared_ptr<IAnimReader> reader, u32 animDbIdx);
u32 Depth() const; u32 Depth() const override;
CAnimTreeEffectiveContribution VGetContributionOfHighestInfluence() const; CAnimTreeEffectiveContribution VGetContributionOfHighestInfluence() const override;
u32 VGetNumChildren() const; u32 VGetNumChildren() const override;
std::shared_ptr<IAnimReader> VGetBestUnblendedChild() const; std::shared_ptr<IAnimReader> VGetBestUnblendedChild() const override;
void VGetWeightedReaders(rstl::reserved_vector<std::pair<float, std::weak_ptr<IAnimReader>>, 16>& out, float w) const; void VGetWeightedReaders(rstl::reserved_vector<std::pair<float, std::weak_ptr<IAnimReader>>, 16>& out,
float w) const override;
SAdvancementResults VAdvanceView(const CCharAnimTime& a); SAdvancementResults VAdvanceView(const CCharAnimTime& a) override;
CCharAnimTime VGetTimeRemaining() const; CCharAnimTime VGetTimeRemaining() const override;
CSteadyStateAnimInfo VGetSteadyStateAnimInfo() const; CSteadyStateAnimInfo VGetSteadyStateAnimInfo() const override;
bool VHasOffset(const CSegId& seg) const; bool VHasOffset(const CSegId& seg) const override;
zeus::CVector3f VGetOffset(const CSegId& seg) const; zeus::CVector3f VGetOffset(const CSegId& seg) const override;
zeus::CQuaternion VGetRotation(const CSegId& seg) const; zeus::CQuaternion VGetRotation(const CSegId& seg) const override;
u32 VGetBoolPOIList(const CCharAnimTime& time, CBoolPOINode* listOut, u32 capacity, u32 iterator, u32) const; u32 VGetBoolPOIList(const CCharAnimTime& time, CBoolPOINode* listOut, u32 capacity, u32 iterator, u32) const override;
u32 VGetInt32POIList(const CCharAnimTime& time, CInt32POINode* listOut, u32 capacity, u32 iterator, u32) const; u32 VGetInt32POIList(const CCharAnimTime& time, CInt32POINode* listOut, u32 capacity, u32 iterator,
u32 VGetParticlePOIList(const CCharAnimTime& time, CParticlePOINode* listOut, u32 capacity, u32 iterator, u32) const; u32) const override;
u32 VGetSoundPOIList(const CCharAnimTime& time, CSoundPOINode* listOut, u32 capacity, u32 iterator, u32) const; u32 VGetParticlePOIList(const CCharAnimTime& time, CParticlePOINode* listOut, u32 capacity, u32 iterator,
bool VGetBoolPOIState(const char*) const; u32) const override;
s32 VGetInt32POIState(const char*) const; u32 VGetSoundPOIList(const CCharAnimTime& time, CSoundPOINode* listOut, u32 capacity, u32 iterator,
CParticleData::EParentedMode VGetParticlePOIState(const char*) const; u32) const override;
void VGetSegStatementSet(const CSegIdList& list, CSegStatementSet& setOut) const; bool VGetBoolPOIState(const char*) const override;
void VGetSegStatementSet(const CSegIdList& list, CSegStatementSet& setOut, const CCharAnimTime& time) const; s32 VGetInt32POIState(const char*) const override;
std::unique_ptr<IAnimReader> VClone() const; CParticleData::EParentedMode VGetParticlePOIState(const char*) const override;
std::optional<std::unique_ptr<IAnimReader>> VSimplified(); void VGetSegStatementSet(const CSegIdList& list, CSegStatementSet& setOut) const override;
void VSetPhase(float); void VGetSegStatementSet(const CSegIdList& list, CSegStatementSet& setOut, const CCharAnimTime& time) const override;
SAdvancementResults VGetAdvancementResults(const CCharAnimTime& a, const CCharAnimTime& b) const; std::unique_ptr<IAnimReader> VClone() const override;
std::optional<std::unique_ptr<IAnimReader>> VSimplified() override;
void VSetPhase(float) override;
SAdvancementResults VGetAdvancementResults(const CCharAnimTime& a, const CCharAnimTime& b) const override;
}; };
} // namespace urde } // namespace urde

12
Runtime/Character/CAnimTreeBlend.hpp
View File

@ -14,12 +14,12 @@ public:
CAnimTreeBlend(bool, const std::shared_ptr<CAnimTreeNode>& a, const std::shared_ptr<CAnimTreeNode>& b, CAnimTreeBlend(bool, const std::shared_ptr<CAnimTreeNode>& a, const std::shared_ptr<CAnimTreeNode>& b,
float blendWeight, std::string_view name); float blendWeight, std::string_view name);
SAdvancementResults VAdvanceView(const CCharAnimTime& dt); SAdvancementResults VAdvanceView(const CCharAnimTime& dt) override;
CCharAnimTime VGetTimeRemaining() const; CCharAnimTime VGetTimeRemaining() const override;
CSteadyStateAnimInfo VGetSteadyStateAnimInfo() const; CSteadyStateAnimInfo VGetSteadyStateAnimInfo() const override;
std::unique_ptr<IAnimReader> VClone() const; std::unique_ptr<IAnimReader> VClone() const override;
void SetBlendingWeight(float w); void SetBlendingWeight(float w) override;
float VGetBlendingWeight() const; float VGetBlendingWeight() const override;
}; };
} // namespace urde } // namespace urde

34
Runtime/Character/CAnimTreeDoubleChild.hpp
View File

@ -29,21 +29,25 @@ protected:
public: public:
CAnimTreeDoubleChild(const std::weak_ptr<CAnimTreeNode>& a, const std::weak_ptr<CAnimTreeNode>& b, CAnimTreeDoubleChild(const std::weak_ptr<CAnimTreeNode>& a, const std::weak_ptr<CAnimTreeNode>& b,
std::string_view name); std::string_view name);
SAdvancementResults VAdvanceView(const CCharAnimTime& a); SAdvancementResults VAdvanceView(const CCharAnimTime& a) override;
u32 VGetBoolPOIList(const CCharAnimTime& time, CBoolPOINode* listOut, u32 capacity, u32 iterator, u32) const; u32 VGetBoolPOIList(const CCharAnimTime& time, CBoolPOINode* listOut, u32 capacity, u32 iterator, u32) const override;
u32 VGetInt32POIList(const CCharAnimTime& time, CInt32POINode* listOut, u32 capacity, u32 iterator, u32) const; u32 VGetInt32POIList(const CCharAnimTime& time, CInt32POINode* listOut, u32 capacity, u32 iterator,
u32 VGetParticlePOIList(const CCharAnimTime& time, CParticlePOINode* listOut, u32 capacity, u32 iterator, u32) const; u32) const override;
u32 VGetSoundPOIList(const CCharAnimTime& time, CSoundPOINode* listOut, u32 capacity, u32 iterator, u32) const; u32 VGetParticlePOIList(const CCharAnimTime& time, CParticlePOINode* listOut, u32 capacity, u32 iterator,
bool VGetBoolPOIState(const char* name) const; u32) const override;
s32 VGetInt32POIState(const char* name) const; u32 VGetSoundPOIList(const CCharAnimTime& time, CSoundPOINode* listOut, u32 capacity, u32 iterator,
CParticleData::EParentedMode VGetParticlePOIState(const char* name) const; u32) const override;
void VSetPhase(float); bool VGetBoolPOIState(const char* name) const override;
SAdvancementResults VGetAdvancementResults(const CCharAnimTime& a, const CCharAnimTime& b) const; s32 VGetInt32POIState(const char* name) const override;
u32 Depth() const; CParticleData::EParentedMode VGetParticlePOIState(const char* name) const override;
CAnimTreeEffectiveContribution VGetContributionOfHighestInfluence() const; void VSetPhase(float) override;
u32 VGetNumChildren() const; SAdvancementResults VGetAdvancementResults(const CCharAnimTime& a, const CCharAnimTime& b) const override;
std::shared_ptr<IAnimReader> VGetBestUnblendedChild() const; u32 Depth() const override;
void VGetWeightedReaders(rstl::reserved_vector<std::pair<float, std::weak_ptr<IAnimReader>>, 16>& out, float w) const; CAnimTreeEffectiveContribution VGetContributionOfHighestInfluence() const override;
u32 VGetNumChildren() const override;
std::shared_ptr<IAnimReader> VGetBestUnblendedChild() const override;
void VGetWeightedReaders(rstl::reserved_vector<std::pair<float, std::weak_ptr<IAnimReader>>, 16>& out,
float w) const override;
virtual float VGetRightChildWeight() const = 0; virtual float VGetRightChildWeight() const = 0;
float GetRightChildWeight() const { return VGetRightChildWeight(); } float GetRightChildWeight() const { return VGetRightChildWeight(); }

25
Runtime/Character/CAnimTreeLoopIn.hpp
View File

@ -21,18 +21,21 @@ public:
CAnimTreeLoopIn(const std::weak_ptr<CAnimTreeNode>& a, const std::weak_ptr<CAnimTreeNode>& b, bool didLoopIn, CAnimTreeLoopIn(const std::weak_ptr<CAnimTreeNode>& a, const std::weak_ptr<CAnimTreeNode>& b, bool didLoopIn,
const CAnimSysContext& animCtx, std::string_view name, const CSequenceFundamentals& fundamentals, const CAnimSysContext& animCtx, std::string_view name, const CSequenceFundamentals& fundamentals,
const CCharAnimTime& time); const CCharAnimTime& time);
CAnimTreeEffectiveContribution VGetContributionOfHighestInfluence() const; CAnimTreeEffectiveContribution VGetContributionOfHighestInfluence() const override;
bool VSupportsReverseView() const { return false; } bool VSupportsReverseView() const { return false; }
std::optional<std::unique_ptr<IAnimReader>> VSimplified(); std::optional<std::unique_ptr<IAnimReader>> VSimplified() override;
std::shared_ptr<IAnimReader> VGetBestUnblendedChild() const; std::shared_ptr<IAnimReader> VGetBestUnblendedChild() const override;
std::unique_ptr<IAnimReader> VClone() const; std::unique_ptr<IAnimReader> VClone() const override;
u32 VGetBoolPOIList(const CCharAnimTime& time, CBoolPOINode* listOut, u32 capacity, u32 iterator, u32) const; u32 VGetBoolPOIList(const CCharAnimTime& time, CBoolPOINode* listOut, u32 capacity, u32 iterator, u32) const override;
u32 VGetInt32POIList(const CCharAnimTime& time, CInt32POINode* listOut, u32 capacity, u32 iterator, u32) const; u32 VGetInt32POIList(const CCharAnimTime& time, CInt32POINode* listOut, u32 capacity, u32 iterator,
u32 VGetParticlePOIList(const CCharAnimTime& time, CParticlePOINode* listOut, u32 capacity, u32 iterator, u32) const; u32) const override;
u32 VGetSoundPOIList(const CCharAnimTime& time, CSoundPOINode* listOut, u32 capacity, u32 iterator, u32) const; u32 VGetParticlePOIList(const CCharAnimTime& time, CParticlePOINode* listOut, u32 capacity, u32 iterator,
CSteadyStateAnimInfo VGetSteadyStateAnimInfo() const; u32) const override;
CCharAnimTime VGetTimeRemaining() const; u32 VGetSoundPOIList(const CCharAnimTime& time, CSoundPOINode* listOut, u32 capacity, u32 iterator,
SAdvancementResults VAdvanceView(const CCharAnimTime& dt); u32) const override;
CSteadyStateAnimInfo VGetSteadyStateAnimInfo() const override;
CCharAnimTime VGetTimeRemaining() const override;
SAdvancementResults VAdvanceView(const CCharAnimTime& dt) override;
}; };
} // namespace urde } // namespace urde

2
Runtime/Character/CAnimTreeNode.hpp
View File

@ -10,7 +10,7 @@ protected:
public: public:
CAnimTreeNode(std::string_view name) : x4_name(name) {} CAnimTreeNode(std::string_view name) : x4_name(name) {}
bool IsCAnimTreeNode() const { return true; } bool IsCAnimTreeNode() const override { return true; }
static std::shared_ptr<CAnimTreeNode> Cast(std::unique_ptr<IAnimReader>&& ptr) { static std::shared_ptr<CAnimTreeNode> Cast(std::unique_ptr<IAnimReader>&& ptr) {
if (ptr->IsCAnimTreeNode()) if (ptr->IsCAnimTreeNode())
return std::static_pointer_cast<CAnimTreeNode>(std::shared_ptr<IAnimReader>(std::move(ptr))); return std::static_pointer_cast<CAnimTreeNode>(std::shared_ptr<IAnimReader>(std::move(ptr)));

23
Runtime/Character/CAnimTreeSequence.hpp
View File

@ -22,18 +22,21 @@ public:
const std::vector<std::shared_ptr<IMetaAnim>>& metaAnims, const CAnimSysContext& animSys, const std::vector<std::shared_ptr<IMetaAnim>>& metaAnims, const CAnimSysContext& animSys,
std::string_view name, const CSequenceFundamentals& fundamentals, const CCharAnimTime& time); std::string_view name, const CSequenceFundamentals& fundamentals, const CCharAnimTime& time);
CAnimTreeEffectiveContribution VGetContributionOfHighestInfluence() const; CAnimTreeEffectiveContribution VGetContributionOfHighestInfluence() const override;
std::shared_ptr<IAnimReader> VGetBestUnblendedChild() const; std::shared_ptr<IAnimReader> VGetBestUnblendedChild() const override;
bool VSupportsReverseView() const { return false; } bool VSupportsReverseView() const { return false; }
SAdvancementResults VAdvanceView(const CCharAnimTime& dt); SAdvancementResults VAdvanceView(const CCharAnimTime& dt) override;
CCharAnimTime VGetTimeRemaining() const; CCharAnimTime VGetTimeRemaining() const override;
CSteadyStateAnimInfo VGetSteadyStateAnimInfo() const; CSteadyStateAnimInfo VGetSteadyStateAnimInfo() const override;
u32 VGetBoolPOIList(const CCharAnimTime& time, CBoolPOINode* listOut, u32 capacity, u32 iterator, u32) const; u32 VGetBoolPOIList(const CCharAnimTime& time, CBoolPOINode* listOut, u32 capacity, u32 iterator, u32) const override;
u32 VGetInt32POIList(const CCharAnimTime& time, CInt32POINode* listOut, u32 capacity, u32 iterator, u32) const; u32 VGetInt32POIList(const CCharAnimTime& time, CInt32POINode* listOut, u32 capacity, u32 iterator,
u32 VGetParticlePOIList(const CCharAnimTime& time, CParticlePOINode* listOut, u32 capacity, u32 iterator, u32) const; u32) const override;
u32 VGetSoundPOIList(const CCharAnimTime& time, CSoundPOINode* listOut, u32 capacity, u32 iterator, u32) const; u32 VGetParticlePOIList(const CCharAnimTime& time, CParticlePOINode* listOut, u32 capacity, u32 iterator,
std::unique_ptr<IAnimReader> VClone() const; u32) const override;
u32 VGetSoundPOIList(const CCharAnimTime& time, CSoundPOINode* listOut, u32 capacity, u32 iterator,
u32) const override;
std::unique_ptr<IAnimReader> VClone() const override;
}; };
} // namespace urde } // namespace urde

41
Runtime/Character/CAnimTreeSingleChild.hpp
View File

@ -11,26 +11,29 @@ protected:
public: public:
CAnimTreeSingleChild(const std::weak_ptr<CAnimTreeNode>& node, std::string_view name); CAnimTreeSingleChild(const std::weak_ptr<CAnimTreeNode>& node, std::string_view name);
SAdvancementResults VAdvanceView(const CCharAnimTime& dt); SAdvancementResults VAdvanceView(const CCharAnimTime& dt) override;
CCharAnimTime VGetTimeRemaining() const; CCharAnimTime VGetTimeRemaining() const override;
bool VHasOffset(const CSegId& seg) const; bool VHasOffset(const CSegId& seg) const override;
zeus::CVector3f VGetOffset(const CSegId& seg) const; zeus::CVector3f VGetOffset(const CSegId& seg) const override;
zeus::CQuaternion VGetRotation(const CSegId& seg) const; zeus::CQuaternion VGetRotation(const CSegId& seg) const override;
u32 VGetBoolPOIList(const CCharAnimTime& time, CBoolPOINode* listOut, u32 capacity, u32 iterator, u32) const; u32 VGetBoolPOIList(const CCharAnimTime& time, CBoolPOINode* listOut, u32 capacity, u32 iterator, u32) const override;
u32 VGetInt32POIList(const CCharAnimTime& time, CInt32POINode* listOut, u32 capacity, u32 iterator, u32) const; u32 VGetInt32POIList(const CCharAnimTime& time, CInt32POINode* listOut, u32 capacity, u32 iterator,
u32 VGetParticlePOIList(const CCharAnimTime& time, CParticlePOINode* listOut, u32 capacity, u32 iterator, u32) const; u32) const override;
u32 VGetSoundPOIList(const CCharAnimTime& time, CSoundPOINode* listOut, u32 capacity, u32 iterator, u32) const; u32 VGetParticlePOIList(const CCharAnimTime& time, CParticlePOINode* listOut, u32 capacity, u32 iterator,
bool VGetBoolPOIState(const char* name) const; u32) const override;
s32 VGetInt32POIState(const char* name) const; u32 VGetSoundPOIList(const CCharAnimTime& time, CSoundPOINode* listOut, u32 capacity, u32 iterator,
CParticleData::EParentedMode VGetParticlePOIState(const char* name) const; u32) const override;
void VGetSegStatementSet(const CSegIdList& list, CSegStatementSet& setOut) const; bool VGetBoolPOIState(const char* name) const override;
void VGetSegStatementSet(const CSegIdList& list, CSegStatementSet& setOut, const CCharAnimTime& time) const; s32 VGetInt32POIState(const char* name) const override;
void VSetPhase(float); CParticleData::EParentedMode VGetParticlePOIState(const char* name) const override;
SAdvancementResults VGetAdvancementResults(const CCharAnimTime& a, const CCharAnimTime& b) const; void VGetSegStatementSet(const CSegIdList& list, CSegStatementSet& setOut) const override;
u32 Depth() const; void VGetSegStatementSet(const CSegIdList& list, CSegStatementSet& setOut, const CCharAnimTime& time) const override;
u32 VGetNumChildren() const; void VSetPhase(float) override;
SAdvancementResults VGetAdvancementResults(const CCharAnimTime& a, const CCharAnimTime& b) const override;
u32 Depth() const override;
u32 VGetNumChildren() const override;
void VGetWeightedReaders(rstl::reserved_vector<std::pair<float, std::weak_ptr<IAnimReader>>, 16>& out, void VGetWeightedReaders(rstl::reserved_vector<std::pair<float, std::weak_ptr<IAnimReader>>, 16>& out,
float w) const { float w) const override {
x14_child->VGetWeightedReaders(out, w); x14_child->VGetWeightedReaders(out, w);
} }
}; };

33
Runtime/Character/CAnimTreeTimeScale.hpp
View File

@ -19,23 +19,26 @@ public:
static std::string CreatePrimitiveName(const std::weak_ptr<CAnimTreeNode>&, float, const CCharAnimTime&, float); static std::string CreatePrimitiveName(const std::weak_ptr<CAnimTreeNode>&, float, const CCharAnimTime&, float);
CCharAnimTime GetRealLifeTime(const CCharAnimTime&) const; CCharAnimTime GetRealLifeTime(const CCharAnimTime&) const;
void VSetPhase(float); void VSetPhase(float) override;
std::optional<std::unique_ptr<IAnimReader>> VSimplified(); std::optional<std::unique_ptr<IAnimReader>> VSimplified() override;
u32 VGetBoolPOIList(const CCharAnimTime& time, CBoolPOINode* listOut, u32 capacity, u32 iterator, u32) const; u32 VGetBoolPOIList(const CCharAnimTime& time, CBoolPOINode* listOut, u32 capacity, u32 iterator, u32) const override;
u32 VGetInt32POIList(const CCharAnimTime& time, CInt32POINode* listOut, u32 capacity, u32 iterator, u32) const; u32 VGetInt32POIList(const CCharAnimTime& time, CInt32POINode* listOut, u32 capacity, u32 iterator,
u32 VGetParticlePOIList(const CCharAnimTime& time, CParticlePOINode* listOut, u32 capacity, u32 iterator, u32) const; u32) const override;
u32 VGetSoundPOIList(const CCharAnimTime& time, CSoundPOINode* listOut, u32 capacity, u32 iterator, u32) const; u32 VGetParticlePOIList(const CCharAnimTime& time, CParticlePOINode* listOut, u32 capacity, u32 iterator,
bool VGetBoolPOIState(const char* name) const; u32) const override;
s32 VGetInt32POIState(const char* name) const; u32 VGetSoundPOIList(const CCharAnimTime& time, CSoundPOINode* listOut, u32 capacity, u32 iterator,
CParticleData::EParentedMode VGetParticlePOIState(const char* name) const; u32) const override;
bool VGetBoolPOIState(const char* name) const override;
s32 VGetInt32POIState(const char* name) const override;
CParticleData::EParentedMode VGetParticlePOIState(const char* name) const override;
CAnimTreeEffectiveContribution VGetContributionOfHighestInfluence() const; CAnimTreeEffectiveContribution VGetContributionOfHighestInfluence() const override;
std::shared_ptr<IAnimReader> VGetBestUnblendedChild() const; std::shared_ptr<IAnimReader> VGetBestUnblendedChild() const override;
std::unique_ptr<IAnimReader> VClone() const; std::unique_ptr<IAnimReader> VClone() const override;
CSteadyStateAnimInfo VGetSteadyStateAnimInfo() const; CSteadyStateAnimInfo VGetSteadyStateAnimInfo() const override;
CCharAnimTime VGetTimeRemaining() const; CCharAnimTime VGetTimeRemaining() const override;
SAdvancementResults VAdvanceView(const CCharAnimTime& dt); SAdvancementResults VAdvanceView(const CCharAnimTime& dt) override;
}; };
} // namespace urde } // namespace urde

18
Runtime/Character/CAnimTreeTransition.hpp
View File

@ -23,14 +23,14 @@ public:
std::string_view name, bool initialized); std::string_view name, bool initialized);
CAnimTreeTransition(bool b1, const std::weak_ptr<CAnimTreeNode>& a, const std::weak_ptr<CAnimTreeNode>& b, CAnimTreeTransition(bool b1, const std::weak_ptr<CAnimTreeNode>& a, const std::weak_ptr<CAnimTreeNode>& b,
const CCharAnimTime& transDur, bool runA, int flags, std::string_view name); const CCharAnimTime& transDur, bool runA, int flags, std::string_view name);
std::shared_ptr<IAnimReader> VGetBestUnblendedChild() const; std::shared_ptr<IAnimReader> VGetBestUnblendedChild() const override;
CCharAnimTime VGetTimeRemaining() const; CCharAnimTime VGetTimeRemaining() const override;
CSteadyStateAnimInfo VGetSteadyStateAnimInfo() const; CSteadyStateAnimInfo VGetSteadyStateAnimInfo() const override;
std::unique_ptr<IAnimReader> VClone() const; std::unique_ptr<IAnimReader> VClone() const override;
std::optional<std::unique_ptr<IAnimReader>> VSimplified(); std::optional<std::unique_ptr<IAnimReader>> VSimplified() override;
std::optional<std::unique_ptr<IAnimReader>> VReverseSimplified(); std::optional<std::unique_ptr<IAnimReader>> VReverseSimplified() override;
SAdvancementResults VAdvanceView(const CCharAnimTime& a); SAdvancementResults VAdvanceView(const CCharAnimTime& a) override;
void SetBlendingWeight(float w); void SetBlendingWeight(float w) override;
float VGetBlendingWeight() const; float VGetBlendingWeight() const override;
}; };
} // namespace urde } // namespace urde

17
Runtime/Character/CAnimTreeTweenBase.hpp
View File

@ -21,16 +21,17 @@ public:
float GetBlendingWeight() const { return VGetBlendingWeight(); } float GetBlendingWeight() const { return VGetBlendingWeight(); }
void VGetWeightedReaders(rstl::reserved_vector<std::pair<float, std::weak_ptr<IAnimReader>>, 16>& out, float w) const; void VGetWeightedReaders(rstl::reserved_vector<std::pair<float, std::weak_ptr<IAnimReader>>, 16>& out,
float VGetRightChildWeight() const { return GetBlendingWeight(); } float w) const override;
float VGetRightChildWeight() const override { return GetBlendingWeight(); }
void VGetSegStatementSet(const CSegIdList& list, CSegStatementSet& setOut) const; void VGetSegStatementSet(const CSegIdList& list, CSegStatementSet& setOut) const override;
void VGetSegStatementSet(const CSegIdList& list, CSegStatementSet& setOut, const CCharAnimTime& time) const; void VGetSegStatementSet(const CSegIdList& list, CSegStatementSet& setOut, const CCharAnimTime& time) const override;
bool VHasOffset(const CSegId& seg) const; bool VHasOffset(const CSegId& seg) const override;
zeus::CVector3f VGetOffset(const CSegId& seg) const; zeus::CVector3f VGetOffset(const CSegId& seg) const override;
zeus::CQuaternion VGetRotation(const CSegId& seg) const; zeus::CQuaternion VGetRotation(const CSegId& seg) const override;
std::optional<std::unique_ptr<IAnimReader>> VSimplified(); std::optional<std::unique_ptr<IAnimReader>> VSimplified() override;
virtual std::optional<std::unique_ptr<IAnimReader>> VReverseSimplified() { virtual std::optional<std::unique_ptr<IAnimReader>> VReverseSimplified() {
return CAnimTreeTweenBase::VSimplified(); return CAnimTreeTweenBase::VSimplified();
} }

10
Runtime/Character/CAnimationDatabaseGame.hpp
View File

@ -10,11 +10,11 @@ class CAnimationDatabaseGame final : public CAnimationDatabase {
public: public:
CAnimationDatabaseGame(const std::vector<CAnimation>& anims); CAnimationDatabaseGame(const std::vector<CAnimation>& anims);
const std::shared_ptr<IMetaAnim>& GetMetaAnim(s32 idx) const; const std::shared_ptr<IMetaAnim>& GetMetaAnim(s32 idx) const override;
u32 GetNumMetaAnims() const; u32 GetNumMetaAnims() const override;
const char* GetMetaAnimName(s32 idx) const; const char* GetMetaAnimName(s32 idx) const override;
void GetAllUniquePrimitives(std::vector<CPrimitive>& primsOut) const; void GetAllUniquePrimitives(std::vector<CPrimitive>& primsOut) const override;
void GetUniquePrimitivesFromMetaAnim(std::set<CPrimitive>& primsOut, std::string_view name) const; void GetUniquePrimitivesFromMetaAnim(std::set<CPrimitive>& primsOut, std::string_view name) const override;
}; };
} // namespace urde } // namespace urde

28
Runtime/Character/CAssetFactory.hpp
View File

@ -13,21 +13,23 @@ class CCharacterFactoryBuilder {
public: public:
class CDummyFactory : public IFactory { class CDummyFactory : public IFactory {
public: public:
CFactoryFnReturn Build(const SObjectTag&, const CVParamTransfer&, CObjectReference* selfRef); CFactoryFnReturn Build(const SObjectTag&, const CVParamTransfer&, CObjectReference* selfRef) override;
void BuildAsync(const SObjectTag&, const CVParamTransfer&, std::unique_ptr<IObj>*, CObjectReference* selfRef); void BuildAsync(const SObjectTag&, const CVParamTransfer&, std::unique_ptr<IObj>*,
void CancelBuild(const SObjectTag&); CObjectReference* selfRef) override;
bool CanBuild(const SObjectTag&); void CancelBuild(const SObjectTag&) override;
const SObjectTag* GetResourceIdByName(std::string_view) const; bool CanBuild(const SObjectTag&) override;
FourCC GetResourceTypeById(CAssetId id) const; const SObjectTag* GetResourceIdByName(std::string_view) const override;
FourCC GetResourceTypeById(CAssetId id) const override;
void EnumerateResources(const std::function<bool(const SObjectTag&)>& lambda) const; void EnumerateResources(const std::function<bool(const SObjectTag&)>& lambda) const override;
void EnumerateNamedResources(const std::function<bool(std::string_view, const SObjectTag&)>& lambda) const; void EnumerateNamedResources(const std::function<bool(std::string_view, const SObjectTag&)>& lambda) const override;
u32 ResourceSize(const urde::SObjectTag& tag); u32 ResourceSize(const urde::SObjectTag& tag) override;
std::shared_ptr<IDvdRequest> LoadResourceAsync(const urde::SObjectTag& tag, void* target); std::shared_ptr<IDvdRequest> LoadResourceAsync(const urde::SObjectTag& tag, void* target) override;
std::shared_ptr<IDvdRequest> LoadResourcePartAsync(const urde::SObjectTag& tag, u32 off, u32 size, void* target); std::shared_ptr<IDvdRequest> LoadResourcePartAsync(const urde::SObjectTag& tag, u32 off, u32 size,
std::unique_ptr<u8[]> LoadResourceSync(const urde::SObjectTag& tag); void* target) override;
std::unique_ptr<u8[]> LoadNewResourcePartSync(const urde::SObjectTag& tag, u32 off, u32 size); std::unique_ptr<u8[]> LoadResourceSync(const urde::SObjectTag& tag) override;
std::unique_ptr<u8[]> LoadNewResourcePartSync(const urde::SObjectTag& tag, u32 off, u32 size) override;
}; };
private: private:

220
Runtime/Character/CBodyState.hpp
View File

@ -35,20 +35,20 @@ class CBSAttack : public CBodyState {
void UpdatePhysicsActor(CBodyController& bc, float dt); void UpdatePhysicsActor(CBodyController& bc, float dt);
public: public:
bool CanShoot() const { return false; } bool CanShoot() const override { return false; }
void Start(CBodyController& bc, CStateManager& mgr); void Start(CBodyController& bc, CStateManager& mgr) override;
pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr); pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
void Shutdown(CBodyController&) {} void Shutdown(CBodyController&) override {}
}; };
class CBSProjectileAttack : public CBodyState { class CBSProjectileAttack : public CBodyState {
pas::EAnimationState GetBodyStateTransition(float dt, CBodyController& bc); pas::EAnimationState GetBodyStateTransition(float dt, CBodyController& bc);
public: public:
bool CanShoot() const { return true; } bool CanShoot() const override { return true; }
void Start(CBodyController& bc, CStateManager& mgr); void Start(CBodyController& bc, CStateManager& mgr) override;
pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr); pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
void Shutdown(CBodyController&) {} void Shutdown(CBodyController&) override {}
}; };
class CBSDie : public CBodyState { class CBSDie : public CBodyState {
@ -56,11 +56,11 @@ class CBSDie : public CBodyState {
bool x8_isDead = false; bool x8_isDead = false;
public: public:
bool IsDead() const { return x8_isDead; } bool IsDead() const override { return x8_isDead; }
bool IsDying() const { return true; } bool IsDying() const override { return true; }
void Start(CBodyController& bc, CStateManager& mgr); void Start(CBodyController& bc, CStateManager& mgr) override;
pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr); pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
void Shutdown(CBodyController&) {} void Shutdown(CBodyController&) override {}
}; };
class CBSFall : public CBodyState { class CBSFall : public CBodyState {
@ -70,9 +70,9 @@ class CBSFall : public CBodyState {
pas::EAnimationState GetBodyStateTransition(float dt, CBodyController& bc); pas::EAnimationState GetBodyStateTransition(float dt, CBodyController& bc);
public: public:
void Start(CBodyController& bc, CStateManager& mgr); void Start(CBodyController& bc, CStateManager& mgr) override;
pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr); pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
void Shutdown(CBodyController& bc); void Shutdown(CBodyController& bc) override;
}; };
class CBSGetup : public CBodyState { class CBSGetup : public CBodyState {
@ -80,9 +80,9 @@ class CBSGetup : public CBodyState {
pas::EAnimationState GetBodyStateTransition(float dt, CBodyController& bc); pas::EAnimationState GetBodyStateTransition(float dt, CBodyController& bc);
public: public:
void Start(CBodyController& bc, CStateManager& mgr); void Start(CBodyController& bc, CStateManager& mgr) override;
pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr); pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
void Shutdown(CBodyController& bc); void Shutdown(CBodyController& bc) override;
}; };
class CBSKnockBack : public CBodyState { class CBSKnockBack : public CBodyState {
@ -92,10 +92,10 @@ class CBSKnockBack : public CBodyState {
pas::EAnimationState GetBodyStateTransition(float dt, CBodyController& bc); pas::EAnimationState GetBodyStateTransition(float dt, CBodyController& bc);
public: public:
bool IsMoving() const { return true; } bool IsMoving() const override { return true; }
void Start(CBodyController& bc, CStateManager& mgr); void Start(CBodyController& bc, CStateManager& mgr) override;
pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr); pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
void Shutdown(CBodyController&) {} void Shutdown(CBodyController&) override {}
}; };
class CBSLieOnGround : public CBodyState { class CBSLieOnGround : public CBodyState {
@ -104,20 +104,20 @@ class CBSLieOnGround : public CBodyState {
public: public:
CBSLieOnGround(CActor& actor); CBSLieOnGround(CActor& actor);
void Start(CBodyController& bc, CStateManager& mgr); void Start(CBodyController& bc, CStateManager& mgr) override;
pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr); pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
void Shutdown(CBodyController& bc); void Shutdown(CBodyController& bc) override;
}; };
class CBSStep : public CBodyState { class CBSStep : public CBodyState {
pas::EAnimationState GetBodyStateTransition(float dt, CBodyController& bc); pas::EAnimationState GetBodyStateTransition(float dt, CBodyController& bc);
public: public:
bool IsMoving() const { return true; } bool IsMoving() const override { return true; }
bool CanShoot() const { return true; } bool CanShoot() const override { return true; }
void Start(CBodyController& bc, CStateManager& mgr); void Start(CBodyController& bc, CStateManager& mgr) override;
pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr); pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
void Shutdown(CBodyController&) {} void Shutdown(CBodyController&) override {}
}; };
class CBSTurn : public CBodyState { class CBSTurn : public CBodyState {
@ -128,17 +128,17 @@ protected:
bool FacingDest(CBodyController& bc) const; bool FacingDest(CBodyController& bc) const;
public: public:
bool CanShoot() const { return true; } bool CanShoot() const override { return true; }
void Start(CBodyController& bc, CStateManager& mgr); void Start(CBodyController& bc, CStateManager& mgr) override;
pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr); pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
void Shutdown(CBodyController&) {} void Shutdown(CBodyController&) override {}
virtual pas::EAnimationState GetBodyStateTransition(float dt, CBodyController& bc); virtual pas::EAnimationState GetBodyStateTransition(float dt, CBodyController& bc);
}; };
class CBSFlyerTurn : public CBSTurn { class CBSFlyerTurn : public CBSTurn {
public: public:
void Start(CBodyController& bc, CStateManager& mgr); void Start(CBodyController& bc, CStateManager& mgr) override;
pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr); pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
}; };
class CBSLoopAttack : public CBodyState { class CBSLoopAttack : public CBodyState {
@ -153,10 +153,10 @@ public:
xc_24_waitForAnimOver = false; xc_24_waitForAnimOver = false;
xc_25_advance = false; xc_25_advance = false;
} }
bool CanShoot() const { return true; } bool CanShoot() const override { return true; }
void Start(CBodyController& bc, CStateManager& mgr); void Start(CBodyController& bc, CStateManager& mgr) override;
pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr); pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
void Shutdown(CBodyController&) {} void Shutdown(CBodyController&) override {}
}; };
class CBSLoopReaction : public CBodyState { class CBSLoopReaction : public CBodyState {
@ -168,9 +168,9 @@ class CBSLoopReaction : public CBodyState {
public: public:
CBSLoopReaction() { xc_24_loopHit = false; } CBSLoopReaction() { xc_24_loopHit = false; }
void Start(CBodyController& bc, CStateManager& mgr); void Start(CBodyController& bc, CStateManager& mgr) override;
pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr); pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
void Shutdown(CBodyController&) {} void Shutdown(CBodyController&) override {}
}; };
class CBSGroundHit : public CBodyState { class CBSGroundHit : public CBodyState {
@ -180,18 +180,18 @@ class CBSGroundHit : public CBodyState {
pas::EAnimationState GetBodyStateTransition(float dt, CBodyController& bc); pas::EAnimationState GetBodyStateTransition(float dt, CBodyController& bc);
public: public:
void Start(CBodyController& bc, CStateManager& mgr); void Start(CBodyController& bc, CStateManager& mgr) override;
pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr); pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
void Shutdown(CBodyController& bc); void Shutdown(CBodyController& bc) override;
}; };
class CBSGenerate : public CBodyState { class CBSGenerate : public CBodyState {
pas::EAnimationState GetBodyStateTransition(float dt, CBodyController& bc); pas::EAnimationState GetBodyStateTransition(float dt, CBodyController& bc);
public: public:
void Start(CBodyController& bc, CStateManager& mgr); void Start(CBodyController& bc, CStateManager& mgr) override;
pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr); pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
void Shutdown(CBodyController&) {} void Shutdown(CBodyController&) override {}
}; };
class CBSJump : public CBodyState { class CBSJump : public CBodyState {
@ -216,14 +216,14 @@ class CBSJump : public CBodyState {
void PlayJumpLoop(CStateManager& mgr, CBodyController& bc); void PlayJumpLoop(CStateManager& mgr, CBodyController& bc);
public: public:
bool IsMoving() const { return true; } bool IsMoving() const override { return true; }
bool ApplyHeadTracking() const { return false; } bool ApplyHeadTracking() const override { return false; }
bool CanShoot() const; bool CanShoot() const override;
void Start(CBodyController& bc, CStateManager& mgr); void Start(CBodyController& bc, CStateManager& mgr) override;
pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr); pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
bool ApplyAnimationDeltas() const; bool ApplyAnimationDeltas() const override;
bool IsInAir(const CBodyController& bc) const; bool IsInAir(const CBodyController& bc) const override;
void Shutdown(CBodyController&) {} void Shutdown(CBodyController&) override {}
}; };
class CBSHurled : public CBodyState { class CBSHurled : public CBodyState {
@ -245,12 +245,12 @@ class CBSHurled : public CBodyState {
public: public:
CBSHurled() { x2c_24_needsRecover = false; } CBSHurled() { x2c_24_needsRecover = false; }
bool IsMoving() const { return true; } bool IsMoving() const override { return true; }
bool IsInAir(const CBodyController&) const { return true; } bool IsInAir(const CBodyController&) const override { return true; }
bool ApplyHeadTracking() const { return false; } bool ApplyHeadTracking() const override { return false; }
void Start(CBodyController& bc, CStateManager& mgr); void Start(CBodyController& bc, CStateManager& mgr) override;
pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr); pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
void Shutdown(CBodyController&) {} void Shutdown(CBodyController&) override {}
}; };
class CBSSlide : public CBodyState { class CBSSlide : public CBodyState {
@ -258,20 +258,20 @@ class CBSSlide : public CBodyState {
pas::EAnimationState GetBodyStateTransition(float dt, CBodyController& bc); pas::EAnimationState GetBodyStateTransition(float dt, CBodyController& bc);
public: public:
bool ApplyHeadTracking() const { return false; } bool ApplyHeadTracking() const override { return false; }
bool IsMoving() const { return true; } bool IsMoving() const override { return true; }
void Start(CBodyController& bc, CStateManager& mgr); void Start(CBodyController& bc, CStateManager& mgr) override;
pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr); pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
void Shutdown(CBodyController&) {} void Shutdown(CBodyController&) override {}
}; };
class CBSTaunt : public CBodyState { class CBSTaunt : public CBodyState {
pas::EAnimationState GetBodyStateTransition(float dt, CBodyController& bc); pas::EAnimationState GetBodyStateTransition(float dt, CBodyController& bc);
public: public:
void Start(CBodyController& bc, CStateManager& mgr); void Start(CBodyController& bc, CStateManager& mgr) override;
pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr); pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
void Shutdown(CBodyController&) {} void Shutdown(CBodyController&) override {}
}; };
class CBSScripted : public CBodyState { class CBSScripted : public CBodyState {
@ -286,10 +286,10 @@ class CBSScripted : public CBodyState {
pas::EAnimationState GetBodyStateTransition(float dt, CBodyController& bc); pas::EAnimationState GetBodyStateTransition(float dt, CBodyController& bc);
public: public:
bool ApplyHeadTracking() const { return false; } bool ApplyHeadTracking() const override { return false; }
void Start(CBodyController& bc, CStateManager& mgr); void Start(CBodyController& bc, CStateManager& mgr) override;
pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr); pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
void Shutdown(CBodyController&) {} void Shutdown(CBodyController&) override {}
}; };
class CBSCover : public CBodyState { class CBSCover : public CBodyState {
@ -299,12 +299,12 @@ class CBSCover : public CBodyState {
pas::EAnimationState GetBodyStateTransition(float dt, CBodyController& bc); pas::EAnimationState GetBodyStateTransition(float dt, CBodyController& bc);
public: public:
bool ApplyHeadTracking() const { return false; } bool ApplyHeadTracking() const override { return false; }
bool IsMoving() const { return true; } bool IsMoving() const override { return true; }
bool CanShoot() const { return x4_state == pas::ECoverState::Lean; } bool CanShoot() const override { return x4_state == pas::ECoverState::Lean; }
void Start(CBodyController& bc, CStateManager& mgr); void Start(CBodyController& bc, CStateManager& mgr) override;
pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr); pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
void Shutdown(CBodyController&) {} void Shutdown(CBodyController&) override {}
}; };
class CBSWallHang : public CBodyState { class CBSWallHang : public CBodyState {
@ -325,15 +325,15 @@ class CBSWallHang : public CBodyState {
void SetLaunchVelocity(CBodyController& bc); void SetLaunchVelocity(CBodyController& bc);
public: public:
bool IsMoving() const { return true; } bool IsMoving() const override { return true; }
bool CanShoot() const { return x4_state == pas::EWallHangState::WallHang; } bool CanShoot() const override { return x4_state == pas::EWallHangState::WallHang; }
bool IsInAir(const CBodyController& bc) const; bool IsInAir(const CBodyController& bc) const override;
bool ApplyGravity() const; bool ApplyGravity() const override;
bool ApplyHeadTracking() const; bool ApplyHeadTracking() const override;
bool ApplyAnimationDeltas() const; bool ApplyAnimationDeltas() const override;
void Start(CBodyController& bc, CStateManager& mgr); void Start(CBodyController& bc, CStateManager& mgr) override;
pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr); pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
void Shutdown(CBodyController&) {} void Shutdown(CBodyController&) override {}
}; };
class CBSLocomotion : public CBodyState { class CBSLocomotion : public CBodyState {
@ -344,11 +344,11 @@ protected:
float ComputeWeightPercentage(const std::pair<s32, float>& a, const std::pair<s32, float>& b, float f) const; float ComputeWeightPercentage(const std::pair<s32, float>& a, const std::pair<s32, float>& b, float f) const;
public: public:
bool IsMoving() const = 0; bool IsMoving() const override = 0;
bool CanShoot() const { return true; } bool CanShoot() const override { return true; }
void Start(CBodyController& bc, CStateManager& mgr); void Start(CBodyController& bc, CStateManager& mgr) override;
pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr); pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
void Shutdown(CBodyController& bc); void Shutdown(CBodyController& bc) override;
virtual bool IsPitchable() const { return false; } virtual bool IsPitchable() const { return false; }
virtual float GetLocomotionSpeed(pas::ELocomotionType type, pas::ELocomotionAnim anim) const = 0; virtual float GetLocomotionSpeed(pas::ELocomotionType type, pas::ELocomotionAnim anim) const = 0;
virtual float ApplyLocomotionPhysics(float dt, CBodyController& bc); virtual float ApplyLocomotionPhysics(float dt, CBodyController& bc);
@ -370,11 +370,11 @@ protected:
public: public:
CBSBiPedLocomotion(CActor& actor); CBSBiPedLocomotion(CActor& actor);
bool IsMoving() const { return x3c4_anim != pas::ELocomotionAnim::Idle; } bool IsMoving() const override { return x3c4_anim != pas::ELocomotionAnim::Idle; }
void Start(CBodyController& bc, CStateManager& mgr); void Start(CBodyController& bc, CStateManager& mgr) override;
pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr); pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
float GetLocomotionSpeed(pas::ELocomotionType type, pas::ELocomotionAnim anim) const; float GetLocomotionSpeed(pas::ELocomotionType type, pas::ELocomotionAnim anim) const override;
float UpdateLocomotionAnimation(float dt, float velMag, CBodyController& bc, bool init); float UpdateLocomotionAnimation(float dt, float velMag, CBodyController& bc, bool init) override;
virtual bool IsStrafing(const CBodyController& bc) const; virtual bool IsStrafing(const CBodyController& bc) const;
}; };
@ -383,22 +383,22 @@ class CBSFlyerLocomotion : public CBSBiPedLocomotion {
public: public:
CBSFlyerLocomotion(CActor& actor, bool pitchable); CBSFlyerLocomotion(CActor& actor, bool pitchable);
bool IsPitchable() const { return x3cc_pitchable; } bool IsPitchable() const override { return x3cc_pitchable; }
float ApplyLocomotionPhysics(float dt, CBodyController& bc); float ApplyLocomotionPhysics(float dt, CBodyController& bc) override;
virtual bool IsBackPedal(CBodyController& bc) const { return false; } virtual bool IsBackPedal(CBodyController& bc) const { return false; }
}; };
class CBSWallWalkerLocomotion : public CBSBiPedLocomotion { class CBSWallWalkerLocomotion : public CBSBiPedLocomotion {
public: public:
CBSWallWalkerLocomotion(CActor& actor); CBSWallWalkerLocomotion(CActor& actor);
float ApplyLocomotionPhysics(float dt, CBodyController& bc); float ApplyLocomotionPhysics(float dt, CBodyController& bc) override;
}; };
class CBSNewFlyerLocomotion : public CBSBiPedLocomotion { class CBSNewFlyerLocomotion : public CBSBiPedLocomotion {
public: public:
CBSNewFlyerLocomotion(CActor& actor); CBSNewFlyerLocomotion(CActor& actor);
float ApplyLocomotionPhysics(float dt, CBodyController& bc); float ApplyLocomotionPhysics(float dt, CBodyController& bc) override;
float UpdateLocomotionAnimation(float dt, float velMag, CBodyController& bc, bool init); float UpdateLocomotionAnimation(float dt, float velMag, CBodyController& bc, bool init) override;
}; };
class CBSRestrictedLocomotion : public CBSLocomotion { class CBSRestrictedLocomotion : public CBSLocomotion {
@ -407,14 +407,14 @@ class CBSRestrictedLocomotion : public CBSLocomotion {
public: public:
CBSRestrictedLocomotion(CActor& actor); CBSRestrictedLocomotion(CActor& actor);
bool IsMoving() const { return false; } bool IsMoving() const override { return false; }
float GetLocomotionSpeed(pas::ELocomotionType type, pas::ELocomotionAnim anim) const { return 0.f; } float GetLocomotionSpeed(pas::ELocomotionType type, pas::ELocomotionAnim anim) const override { return 0.f; }
float UpdateLocomotionAnimation(float dt, float velMag, CBodyController& bc, bool init); float UpdateLocomotionAnimation(float dt, float velMag, CBodyController& bc, bool init) override;
}; };
class CBSRestrictedFlyerLocomotion : public CBSRestrictedLocomotion { class CBSRestrictedFlyerLocomotion : public CBSRestrictedLocomotion {
public: public:
CBSRestrictedFlyerLocomotion(CActor& actor); CBSRestrictedFlyerLocomotion(CActor& actor);
float ApplyLocomotionPhysics(float dt, CBodyController& bc); float ApplyLocomotionPhysics(float dt, CBodyController& bc) override;
}; };
} // namespace urde } // namespace urde

28
Runtime/Character/CCharacterFactory.hpp
View File

@ -22,21 +22,23 @@ class CCharacterFactory : public IObjFactory {
public: public:
class CDummyFactory : public IFactory { class CDummyFactory : public IFactory {
public: public:
CFactoryFnReturn Build(const SObjectTag&, const CVParamTransfer&, CObjectReference* selfRef); CFactoryFnReturn Build(const SObjectTag&, const CVParamTransfer&, CObjectReference* selfRef) override;
void BuildAsync(const SObjectTag&, const CVParamTransfer&, std::unique_ptr<IObj>*, CObjectReference* selfRef); void BuildAsync(const SObjectTag&, const CVParamTransfer&, std::unique_ptr<IObj>*,
void CancelBuild(const SObjectTag&); CObjectReference* selfRef) override;
bool CanBuild(const SObjectTag&); void CancelBuild(const SObjectTag&) override;
const SObjectTag* GetResourceIdByName(std::string_view) const; bool CanBuild(const SObjectTag&) override;
FourCC GetResourceTypeById(CAssetId id) const; const SObjectTag* GetResourceIdByName(std::string_view) const override;
FourCC GetResourceTypeById(CAssetId id) const override;
void EnumerateResources(const std::function<bool(const SObjectTag&)>& lambda) const; void EnumerateResources(const std::function<bool(const SObjectTag&)>& lambda) const override;
void EnumerateNamedResources(const std::function<bool(std::string_view, const SObjectTag&)>& lambda) const; void EnumerateNamedResources(const std::function<bool(std::string_view, const SObjectTag&)>& lambda) const override;
u32 ResourceSize(const urde::SObjectTag& tag); u32 ResourceSize(const urde::SObjectTag& tag) override;
std::shared_ptr<IDvdRequest> LoadResourceAsync(const urde::SObjectTag& tag, void* target); std::shared_ptr<IDvdRequest> LoadResourceAsync(const urde::SObjectTag& tag, void* target) override;
std::shared_ptr<IDvdRequest> LoadResourcePartAsync(const urde::SObjectTag& tag, u32 off, u32 size, void* target); std::shared_ptr<IDvdRequest> LoadResourcePartAsync(const urde::SObjectTag& tag, u32 off, u32 size,
std::unique_ptr<u8[]> LoadResourceSync(const urde::SObjectTag& tag); void* target) override;
std::unique_ptr<u8[]> LoadNewResourcePartSync(const urde::SObjectTag& tag, u32 off, u32 size); std::unique_ptr<u8[]> LoadResourceSync(const urde::SObjectTag& tag) override;
std::unique_ptr<u8[]> LoadNewResourcePartSync(const urde::SObjectTag& tag, u32 off, u32 size) override;
}; };
private: private:

42
Runtime/Character/CFBStreamedAnimReader.hpp
View File

@ -12,12 +12,14 @@ class TAnimSourceInfo : public IAnimSourceInfo {
public: public:
TAnimSourceInfo(const TSubAnimTypeToken<T>& token) : x4_token(token) {} TAnimSourceInfo(const TSubAnimTypeToken<T>& token) : x4_token(token) {}
bool HasPOIData() const { return x4_token->HasPOIData(); } bool HasPOIData() const override { return x4_token->HasPOIData(); }
const std::vector<CBoolPOINode>& GetBoolPOIStream() const { return x4_token->GetBoolPOIStream(); } const std::vector<CBoolPOINode>& GetBoolPOIStream() const override { return x4_token->GetBoolPOIStream(); }
const std::vector<CInt32POINode>& GetInt32POIStream() const { return x4_token->GetInt32POIStream(); } const std::vector<CInt32POINode>& GetInt32POIStream() const override { return x4_token->GetInt32POIStream(); }
const std::vector<CParticlePOINode>& GetParticlePOIStream() const { return x4_token->GetParticlePOIStream(); } const std::vector<CParticlePOINode>& GetParticlePOIStream() const override {
const std::vector<CSoundPOINode>& GetSoundPOIStream() const { return x4_token->GetSoundPOIStream(); } return x4_token->GetParticlePOIStream();
CCharAnimTime GetAnimationDuration() const { return x4_token->GetAnimationDuration(); } }
const std::vector<CSoundPOINode>& GetSoundPOIStream() const override { return x4_token->GetSoundPOIStream(); }
CCharAnimTime GetAnimationDuration() const override { return x4_token->GetAnimationDuration(); }
}; };
class CFBStreamedAnimReaderTotals { class CFBStreamedAnimReaderTotals {
@ -101,20 +103,20 @@ class CFBStreamedAnimReader : public CAnimSourceReaderBase {
public: public:
CFBStreamedAnimReader(const TSubAnimTypeToken<CFBStreamedCompression>& source, const CCharAnimTime& time); CFBStreamedAnimReader(const TSubAnimTypeToken<CFBStreamedCompression>& source, const CCharAnimTime& time);
SAdvancementResults VGetAdvancementResults(const CCharAnimTime& a, const CCharAnimTime& b) const; SAdvancementResults VGetAdvancementResults(const CCharAnimTime& a, const CCharAnimTime& b) const override;
bool VSupportsReverseView() const { return false; } bool VSupportsReverseView() const override { return false; }
void VSetPhase(float); void VSetPhase(float) override;
SAdvancementResults VReverseView(const CCharAnimTime& time); SAdvancementResults VReverseView(const CCharAnimTime& time) override;
std::unique_ptr<IAnimReader> VClone() const; std::unique_ptr<IAnimReader> VClone() const override;
void VGetSegStatementSet(const CSegIdList& list, CSegStatementSet& setOut) const; void VGetSegStatementSet(const CSegIdList& list, CSegStatementSet& setOut) const override;
void VGetSegStatementSet(const CSegIdList& list, CSegStatementSet& setOut, const CCharAnimTime& time) const; void VGetSegStatementSet(const CSegIdList& list, CSegStatementSet& setOut, const CCharAnimTime& time) const override;
SAdvancementResults VAdvanceView(const CCharAnimTime& a); SAdvancementResults VAdvanceView(const CCharAnimTime& a) override;
CCharAnimTime VGetTimeRemaining() const; CCharAnimTime VGetTimeRemaining() const override;
CSteadyStateAnimInfo VGetSteadyStateAnimInfo() const; CSteadyStateAnimInfo VGetSteadyStateAnimInfo() const override;
bool VHasOffset(const CSegId& seg) const; bool VHasOffset(const CSegId& seg) const override;
zeus::CVector3f VGetOffset(const CSegId& seg) const; zeus::CVector3f VGetOffset(const CSegId& seg) const override;
zeus::CVector3f VGetOffset(const CSegId& seg, const CCharAnimTime& time) const; zeus::CVector3f VGetOffset(const CSegId& seg, const CCharAnimTime& time) const override;
zeus::CQuaternion VGetRotation(const CSegId& seg) const; zeus::CQuaternion VGetRotation(const CSegId& seg) const override;
}; };
} // namespace urde } // namespace urde

6
Runtime/Character/CMetaAnimBlend.hpp
View File

@ -13,11 +13,11 @@ class CMetaAnimBlend : public IMetaAnim {
public: public:
CMetaAnimBlend(CInputStream& in); CMetaAnimBlend(CInputStream& in);
EMetaAnimType GetType() const { return EMetaAnimType::Blend; } EMetaAnimType GetType() const override { return EMetaAnimType::Blend; }
void GetUniquePrimitives(std::set<CPrimitive>& primsOut) const; void GetUniquePrimitives(std::set<CPrimitive>& primsOut) const override;
std::shared_ptr<CAnimTreeNode> VGetAnimationTree(const CAnimSysContext& animSys, std::shared_ptr<CAnimTreeNode> VGetAnimationTree(const CAnimSysContext& animSys,
const CMetaAnimTreeBuildOrders& orders) const; const CMetaAnimTreeBuildOrders& orders) const override;
}; };
} // namespace urde } // namespace urde

6
Runtime/Character/CMetaAnimPhaseBlend.hpp
View File

@ -13,11 +13,11 @@ class CMetaAnimPhaseBlend : public IMetaAnim {
public: public:
CMetaAnimPhaseBlend(CInputStream& in); CMetaAnimPhaseBlend(CInputStream& in);
EMetaAnimType GetType() const { return EMetaAnimType::PhaseBlend; } EMetaAnimType GetType() const override { return EMetaAnimType::PhaseBlend; }
void GetUniquePrimitives(std::set<CPrimitive>& primsOut) const; void GetUniquePrimitives(std::set<CPrimitive>& primsOut) const override;
std::shared_ptr<CAnimTreeNode> VGetAnimationTree(const CAnimSysContext& animSys, std::shared_ptr<CAnimTreeNode> VGetAnimationTree(const CAnimSysContext& animSys,
const CMetaAnimTreeBuildOrders& orders) const; const CMetaAnimTreeBuildOrders& orders) const override;
}; };
} // namespace urde } // namespace urde

6
Runtime/Character/CMetaAnimPlay.hpp
View File

@ -12,11 +12,11 @@ class CMetaAnimPlay : public IMetaAnim {
public: public:
CMetaAnimPlay(CInputStream& in); CMetaAnimPlay(CInputStream& in);
EMetaAnimType GetType() const { return EMetaAnimType::Play; } EMetaAnimType GetType() const override { return EMetaAnimType::Play; }
void GetUniquePrimitives(std::set<CPrimitive>& primsOut) const; void GetUniquePrimitives(std::set<CPrimitive>& primsOut) const override;
std::shared_ptr<CAnimTreeNode> VGetAnimationTree(const CAnimSysContext& animSys, std::shared_ptr<CAnimTreeNode> VGetAnimationTree(const CAnimSysContext& animSys,
const CMetaAnimTreeBuildOrders& orders) const; const CMetaAnimTreeBuildOrders& orders) const override;
}; };
} // namespace urde } // namespace urde

6
Runtime/Character/CMetaAnimRandom.hpp
View File

@ -12,11 +12,11 @@ class CMetaAnimRandom : public IMetaAnim {
public: public:
CMetaAnimRandom(CInputStream& in); CMetaAnimRandom(CInputStream& in);
EMetaAnimType GetType() const { return EMetaAnimType::Random; } EMetaAnimType GetType() const override { return EMetaAnimType::Random; }
void GetUniquePrimitives(std::set<CPrimitive>& primsOut) const; void GetUniquePrimitives(std::set<CPrimitive>& primsOut) const override;
std::shared_ptr<CAnimTreeNode> VGetAnimationTree(const CAnimSysContext& animSys, std::shared_ptr<CAnimTreeNode> VGetAnimationTree(const CAnimSysContext& animSys,
const CMetaAnimTreeBuildOrders& orders) const; const CMetaAnimTreeBuildOrders& orders) const override;
}; };
} // namespace urde } // namespace urde

6
Runtime/Character/CMetaAnimSequence.hpp
View File

@ -11,11 +11,11 @@ class CMetaAnimSequence : public IMetaAnim {
public: public:
CMetaAnimSequence(CInputStream& in); CMetaAnimSequence(CInputStream& in);
EMetaAnimType GetType() const { return EMetaAnimType::Sequence; } EMetaAnimType GetType() const override { return EMetaAnimType::Sequence; }
void GetUniquePrimitives(std::set<CPrimitive>& primsOut) const; void GetUniquePrimitives(std::set<CPrimitive>& primsOut) const override;
std::shared_ptr<CAnimTreeNode> VGetAnimationTree(const CAnimSysContext& animSys, std::shared_ptr<CAnimTreeNode> VGetAnimationTree(const CAnimSysContext& animSys,
const CMetaAnimTreeBuildOrders& orders) const; const CMetaAnimTreeBuildOrders& orders) const override;
}; };
} // namespace urde } // namespace urde

4
Runtime/Character/CMetaTransMetaAnim.hpp
View File

@ -11,11 +11,11 @@ class CMetaTransMetaAnim : public IMetaTrans {
public: public:
CMetaTransMetaAnim(CInputStream& in); CMetaTransMetaAnim(CInputStream& in);
EMetaTransType GetType() const { return EMetaTransType::MetaAnim; } EMetaTransType GetType() const override { return EMetaTransType::MetaAnim; }
std::shared_ptr<CAnimTreeNode> VGetTransitionTree(const std::weak_ptr<CAnimTreeNode>& a, std::shared_ptr<CAnimTreeNode> VGetTransitionTree(const std::weak_ptr<CAnimTreeNode>& a,
const std::weak_ptr<CAnimTreeNode>& b, const std::weak_ptr<CAnimTreeNode>& b,
const CAnimSysContext& animSys) const; const CAnimSysContext& animSys) const override;
}; };
} // namespace urde } // namespace urde

4
Runtime/Character/CMetaTransPhaseTrans.hpp
View File

@ -14,11 +14,11 @@ class CMetaTransPhaseTrans : public IMetaTrans {
public: public:
CMetaTransPhaseTrans(CInputStream& in); CMetaTransPhaseTrans(CInputStream& in);
EMetaTransType GetType() const { return EMetaTransType::PhaseTrans; } EMetaTransType GetType() const override { return EMetaTransType::PhaseTrans; }
std::shared_ptr<CAnimTreeNode> VGetTransitionTree(const std::weak_ptr<CAnimTreeNode>& a, std::shared_ptr<CAnimTreeNode> VGetTransitionTree(const std::weak_ptr<CAnimTreeNode>& a,
const std::weak_ptr<CAnimTreeNode>& b, const std::weak_ptr<CAnimTreeNode>& b,
const CAnimSysContext& animSys) const; const CAnimSysContext& animSys) const override;
}; };
} // namespace urde } // namespace urde

4
Runtime/Character/CMetaTransSnap.hpp
View File

@ -7,11 +7,11 @@ namespace urde {
class CMetaTransSnap : public IMetaTrans { class CMetaTransSnap : public IMetaTrans {
public: public:
EMetaTransType GetType() const { return EMetaTransType::Snap; } EMetaTransType GetType() const override { return EMetaTransType::Snap; }
std::shared_ptr<CAnimTreeNode> VGetTransitionTree(const std::weak_ptr<CAnimTreeNode>& a, std::shared_ptr<CAnimTreeNode> VGetTransitionTree(const std::weak_ptr<CAnimTreeNode>& a,
const std::weak_ptr<CAnimTreeNode>& b, const std::weak_ptr<CAnimTreeNode>& b,
const CAnimSysContext& animSys) const; const CAnimSysContext& animSys) const override;
}; };
} // namespace urde } // namespace urde

4
Runtime/Character/CMetaTransTrans.hpp
View File

@ -14,11 +14,11 @@ class CMetaTransTrans : public IMetaTrans {
public: public:
CMetaTransTrans(CInputStream& in); CMetaTransTrans(CInputStream& in);
EMetaTransType GetType() const { return EMetaTransType::Trans; } EMetaTransType GetType() const override { return EMetaTransType::Trans; }
std::shared_ptr<CAnimTreeNode> VGetTransitionTree(const std::weak_ptr<CAnimTreeNode>& a, std::shared_ptr<CAnimTreeNode> VGetTransitionTree(const std::weak_ptr<CAnimTreeNode>& a,
const std::weak_ptr<CAnimTreeNode>& b, const std::weak_ptr<CAnimTreeNode>& b,
const CAnimSysContext& animSys) const; const CAnimSysContext& animSys) const override;
}; };
} // namespace urde } // namespace urde

34
Runtime/Character/CParticleGenInfo.hpp
View File

@ -85,23 +85,23 @@ public:
CParticleData::EParentedMode parentMode, int flags, CStateManager& stateMgr, TAreaId, CParticleData::EParentedMode parentMode, int flags, CStateManager& stateMgr, TAreaId,
int lightId, EParticleGenType state); int lightId, EParticleGenType state);
void AddToRenderer(); void AddToRenderer() override;
void Render(); void Render() override;
void Update(float dt, CStateManager& stateMgr); void Update(float dt, CStateManager& stateMgr) override;
void SetOrientation(const zeus::CTransform& xf, CStateManager& stateMgr); void SetOrientation(const zeus::CTransform& xf, CStateManager& stateMgr) override;
void SetTranslation(const zeus::CVector3f& trans, CStateManager& stateMgr); void SetTranslation(const zeus::CVector3f& trans, CStateManager& stateMgr) override;
void SetGlobalOrientation(const zeus::CTransform& xf, CStateManager& stateMgr); void SetGlobalOrientation(const zeus::CTransform& xf, CStateManager& stateMgr) override;
void SetGlobalTranslation(const zeus::CVector3f& trans, CStateManager& stateMgr); void SetGlobalTranslation(const zeus::CVector3f& trans, CStateManager& stateMgr) override;
void SetGlobalScale(const zeus::CVector3f& scale); void SetGlobalScale(const zeus::CVector3f& scale) override;
void SetParticleEmission(bool, CStateManager& stateMgr); void SetParticleEmission(bool, CStateManager& stateMgr) override;
bool IsSystemDeletable() const; bool IsSystemDeletable() const override;
std::optional<zeus::CAABox> GetBounds() const; std::optional<zeus::CAABox> GetBounds() const override;
bool HasActiveParticles() const; bool HasActiveParticles() const override;
void DestroyParticles(); void DestroyParticles() override;
bool HasLight() const; bool HasLight() const override;
TUniqueId GetLightId() const; TUniqueId GetLightId() const override;
void DeleteLight(CStateManager& mgr); void DeleteLight(CStateManager& mgr) override;
void SetModulationColor(const zeus::CColor& color); void SetModulationColor(const zeus::CColor& color) override;
const std::shared_ptr<CParticleGen> GetParticleSystem() const { return x84_system; } const std::shared_ptr<CParticleGen> GetParticleSystem() const { return x84_system; }
}; };
} // namespace urde } // namespace urde

20
Runtime/Character/CTimeScaleFunctions.hpp
View File

@ -25,11 +25,11 @@ private:
public: public:
CConstantAnimationTimeScale(float scale) : x4_scale(scale) {} CConstantAnimationTimeScale(float scale) : x4_scale(scale) {}
EVaryingAnimationTimeScaleType GetType() const { return EVaryingAnimationTimeScaleType::Constant; } EVaryingAnimationTimeScaleType GetType() const override { return EVaryingAnimationTimeScaleType::Constant; }
float VTimeScaleIntegral(float lowerLimit, float upperLimit) const; float VTimeScaleIntegral(float lowerLimit, float upperLimit) const override;
float VFindUpperLimit(float lowerLimit, float root) const; float VFindUpperLimit(float lowerLimit, float root) const override;
std::unique_ptr<IVaryingAnimationTimeScale> VClone() const; std::unique_ptr<IVaryingAnimationTimeScale> VClone() const override;
std::unique_ptr<IVaryingAnimationTimeScale> VGetFunctionMirrored(float value) const; std::unique_ptr<IVaryingAnimationTimeScale> VGetFunctionMirrored(float value) const override;
}; };
class CLinearAnimationTimeScale : public IVaryingAnimationTimeScale { class CLinearAnimationTimeScale : public IVaryingAnimationTimeScale {
@ -46,11 +46,11 @@ class CLinearAnimationTimeScale : public IVaryingAnimationTimeScale {
public: public:
CLinearAnimationTimeScale(const CCharAnimTime& t1, float y1, const CCharAnimTime& t2, float y2); CLinearAnimationTimeScale(const CCharAnimTime& t1, float y1, const CCharAnimTime& t2, float y2);
EVaryingAnimationTimeScaleType GetType() const { return EVaryingAnimationTimeScaleType::Linear; } EVaryingAnimationTimeScaleType GetType() const override { return EVaryingAnimationTimeScaleType::Linear; }
float VTimeScaleIntegral(float lowerLimit, float upperLimit) const; float VTimeScaleIntegral(float lowerLimit, float upperLimit) const override;
float VFindUpperLimit(float lowerLimit, float root) const; float VFindUpperLimit(float lowerLimit, float root) const override;
std::unique_ptr<IVaryingAnimationTimeScale> VClone() const; std::unique_ptr<IVaryingAnimationTimeScale> VClone() const override;
std::unique_ptr<IVaryingAnimationTimeScale> VGetFunctionMirrored(float value) const; std::unique_ptr<IVaryingAnimationTimeScale> VGetFunctionMirrored(float value) const override;
}; };
} // namespace urde } // namespace urde

2
Runtime/Character/CTransitionDatabaseGame.hpp
View File

@ -15,7 +15,7 @@ public:
CTransitionDatabaseGame(const std::vector<CTransition>& transitions, CTransitionDatabaseGame(const std::vector<CTransition>& transitions,
const std::vector<CHalfTransition>& halfTransitions, const std::vector<CHalfTransition>& halfTransitions,
const std::shared_ptr<IMetaTrans>& defaultTrans); const std::shared_ptr<IMetaTrans>& defaultTrans);
const std::shared_ptr<IMetaTrans>& GetMetaTrans(u32, u32) const; const std::shared_ptr<IMetaTrans>& GetMetaTrans(u32, u32) const override;
}; };
} // namespace urde } // namespace urde

2
Runtime/Collision/CAABoxFilter.hpp
View File

@ -7,7 +7,7 @@ namespace urde {
class CAABoxFilter : public ICollisionFilter { class CAABoxFilter : public ICollisionFilter {
public: public:
CAABoxFilter(CActor& actor) : ICollisionFilter(actor) {} CAABoxFilter(CActor& actor) : ICollisionFilter(actor) {}
void Filter(const CCollisionInfoList& in, CCollisionInfoList& out) const; void Filter(const CCollisionInfoList& in, CCollisionInfoList& out) const override;
static void FilterBoxFloorCollisions(const CCollisionInfoList& in, CCollisionInfoList& out); static void FilterBoxFloorCollisions(const CCollisionInfoList& in, CCollisionInfoList& out);
}; };

2
Runtime/Collision/CBallFilter.hpp
View File

@ -8,7 +8,7 @@ class CPhysicsActor;
class CBallFilter : public ICollisionFilter { class CBallFilter : public ICollisionFilter {
public: public:
CBallFilter(CActor& actor) : ICollisionFilter(actor) {} CBallFilter(CActor& actor) : ICollisionFilter(actor) {}
void Filter(const CCollisionInfoList& in, CCollisionInfoList& out) const; void Filter(const CCollisionInfoList& in, CCollisionInfoList& out) const override;
}; };
} // namespace urde } // namespace urde

10
Runtime/Collision/CCollidableAABox.hpp
View File

@ -19,11 +19,11 @@ public:
CCollidableAABox(const zeus::CAABox&, const CMaterialList&); CCollidableAABox(const zeus::CAABox&, const CMaterialList&);
zeus::CAABox Transform(const zeus::CTransform&) const; zeus::CAABox Transform(const zeus::CTransform&) const;
virtual u32 GetTableIndex() const; u32 GetTableIndex() const override;
virtual zeus::CAABox CalculateAABox(const zeus::CTransform&) const; zeus::CAABox CalculateAABox(const zeus::CTransform&) const override;
virtual zeus::CAABox CalculateLocalAABox() const; zeus::CAABox CalculateLocalAABox() const override;
virtual FourCC GetPrimType() const; FourCC GetPrimType() const override;
virtual CRayCastResult CastRayInternal(const CInternalRayCastStructure&) const; CRayCastResult CastRayInternal(const CInternalRayCastStructure&) const override;
const zeus::CAABox& GetBox() const { return x10_aabox; } const zeus::CAABox& GetBox() const { return x10_aabox; }
zeus::CAABox& Box() { return x10_aabox; } zeus::CAABox& Box() { return x10_aabox; }

12
Runtime/Collision/CCollidableOBBTree.hpp
View File

@ -73,14 +73,14 @@ class CCollidableOBBTree : public CCollisionPrimitive {
public: public:
CCollidableOBBTree(const COBBTree* tree, const CMaterialList& material); CCollidableOBBTree(const COBBTree* tree, const CMaterialList& material);
virtual ~CCollidableOBBTree() = default; ~CCollidableOBBTree() override = default;
void ResetTestStats() const; void ResetTestStats() const;
void ResetTestStatsRecurse(const COBBTree::CNode&) const; void ResetTestStatsRecurse(const COBBTree::CNode&) const;
u32 GetTableIndex() const { return sTableIndex; } u32 GetTableIndex() const override { return sTableIndex; }
zeus::CAABox CalculateAABox(const zeus::CTransform&) const; zeus::CAABox CalculateAABox(const zeus::CTransform&) const override;
zeus::CAABox CalculateLocalAABox() const; zeus::CAABox CalculateLocalAABox() const override;
FourCC GetPrimType() const; FourCC GetPrimType() const override;
CRayCastResult CastRayInternal(const CInternalRayCastStructure&) const; CRayCastResult CastRayInternal(const CInternalRayCastStructure&) const override;
}; };
} // namespace urde } // namespace urde

12
Runtime/Collision/CCollidableOBBTreeGroup.hpp
View File

@ -25,14 +25,14 @@ class CCollidableOBBTreeGroup : public CCollisionPrimitive {
public: public:
CCollidableOBBTreeGroup(const CCollidableOBBTreeGroupContainer*, const CMaterialList&); CCollidableOBBTreeGroup(const CCollidableOBBTreeGroupContainer*, const CMaterialList&);
virtual ~CCollidableOBBTreeGroup() = default; ~CCollidableOBBTreeGroup() override = default;
void ResetTestStats() const; void ResetTestStats() const;
virtual u32 GetTableIndex() const; u32 GetTableIndex() const override;
virtual zeus::CAABox CalculateAABox(const zeus::CTransform&) const; zeus::CAABox CalculateAABox(const zeus::CTransform&) const override;
virtual zeus::CAABox CalculateLocalAABox() const; zeus::CAABox CalculateLocalAABox() const override;
virtual FourCC GetPrimType() const; FourCC GetPrimType() const override;
virtual CRayCastResult CastRayInternal(const CInternalRayCastStructure&) const; CRayCastResult CastRayInternal(const CInternalRayCastStructure&) const override;
static const Type& GetType(); static const Type& GetType();
static void SetStaticTableIndex(u32 index); static void SetStaticTableIndex(u32 index);

10
Runtime/Collision/CCollidableSphere.hpp
View File

@ -23,11 +23,11 @@ public:
void SetSphereCenter(const zeus::CVector3f& center) { x10_sphere.position = center; } void SetSphereCenter(const zeus::CVector3f& center) { x10_sphere.position = center; }
zeus::CSphere Transform(const zeus::CTransform& xf) const; zeus::CSphere Transform(const zeus::CTransform& xf) const;
virtual u32 GetTableIndex() const; u32 GetTableIndex() const override;
virtual zeus::CAABox CalculateAABox(const zeus::CTransform&) const; zeus::CAABox CalculateAABox(const zeus::CTransform&) const override;
virtual zeus::CAABox CalculateLocalAABox() const; zeus::CAABox CalculateLocalAABox() const override;
virtual FourCC GetPrimType() const; FourCC GetPrimType() const override;
virtual CRayCastResult CastRayInternal(const CInternalRayCastStructure&) const; CRayCastResult CastRayInternal(const CInternalRayCastStructure&) const override;
static const Type& GetType() { return sType; } static const Type& GetType() { return sType; }
static void SetStaticTableIndex(u32 index) { sTableIndex = index; } static void SetStaticTableIndex(u32 index) { sTableIndex = index; }

26
Runtime/Collision/CCollisionActor.hpp
View File

@ -31,27 +31,27 @@ public:
CCollisionActor(TUniqueId, TAreaId, TUniqueId, const zeus::CVector3f&, bool, float, std::string_view name); CCollisionActor(TUniqueId, TAreaId, TUniqueId, const zeus::CVector3f&, bool, float, std::string_view name);
CCollisionActor(TUniqueId, TAreaId, TUniqueId, bool, float, float, std::string_view name); CCollisionActor(TUniqueId, TAreaId, TUniqueId, bool, float, float, std::string_view name);
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&); void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
CHealthInfo* HealthInfo(CStateManager&); CHealthInfo* HealthInfo(CStateManager&) override;
const CDamageVulnerability* GetDamageVulnerability() const; const CDamageVulnerability* GetDamageVulnerability() const override;
const CDamageVulnerability* GetDamageVulnerability(const zeus::CVector3f&, const zeus::CVector3f&, const CDamageVulnerability* GetDamageVulnerability(const zeus::CVector3f&, const zeus::CVector3f&,
const CDamageInfo&) const; const CDamageInfo&) const override;
void OnScanStateChanged(EScanState, CStateManager&); void OnScanStateChanged(EScanState, CStateManager&) override;
void Touch(CActor&, CStateManager&); void Touch(CActor&, CStateManager&) override;
zeus::CVector3f GetOrbitPosition(const CStateManager&) const; zeus::CVector3f GetOrbitPosition(const CStateManager&) const override;
const CCollisionPrimitive* GetCollisionPrimitive() const; const CCollisionPrimitive* GetCollisionPrimitive() const override;
EWeaponCollisionResponseTypes GetCollisionResponseType(const zeus::CVector3f&, const zeus::CVector3f&, EWeaponCollisionResponseTypes GetCollisionResponseType(const zeus::CVector3f&, const zeus::CVector3f&,
const CWeaponMode&, EProjectileAttrib) const; const CWeaponMode&, EProjectileAttrib) const override;
void SetWeaponCollisionResponseType(EWeaponCollisionResponseTypes type) { x300_responseType = type; } void SetWeaponCollisionResponseType(EWeaponCollisionResponseTypes type) { x300_responseType = type; }
zeus::CTransform GetPrimitiveTransform() const; zeus::CTransform GetPrimitiveTransform() const override;
std::optional<zeus::CAABox> GetTouchBounds() const; std::optional<zeus::CAABox> GetTouchBounds() const override;
void SetDamageVulnerability(const CDamageVulnerability& vuln); void SetDamageVulnerability(const CDamageVulnerability& vuln);
const zeus::CVector3f& GetBoxSize() const { return x260_boxSize; } const zeus::CVector3f& GetBoxSize() const { return x260_boxSize; }
TUniqueId GetOwnerId() const { return x25c_owner; } TUniqueId GetOwnerId() const { return x25c_owner; }
TUniqueId GetLastTouchedObject() const { return x2fc_lastTouched; } TUniqueId GetLastTouchedObject() const { return x2fc_lastTouched; }
zeus::CVector3f GetScanObjectIndicatorPosition(const CStateManager&) const; zeus::CVector3f GetScanObjectIndicatorPosition(const CStateManager&) const override;
void SetExtendedTouchBounds(const zeus::CVector3f& boundExt) { x304_extendedTouchBounds = boundExt; } void SetExtendedTouchBounds(const zeus::CVector3f& boundExt) { x304_extendedTouchBounds = boundExt; }
float GetSphereRadius() const { return x288_sphereRadius; } float GetSphereRadius() const { return x288_sphereRadius; }
}; };

87
Runtime/Graphics/CBooRenderer.hpp
View File

@ -200,35 +200,35 @@ class CBooRenderer final : public IRenderer {
public: public:
CBooRenderer(IObjectStore& store, IFactory& resFac); CBooRenderer(IObjectStore& store, IFactory& resFac);
~CBooRenderer(); ~CBooRenderer() override;
void AddWorldSurfaces(CBooModel& model); void AddWorldSurfaces(CBooModel& model);
std::list<CAreaListItem>::iterator FindStaticGeometry(const std::vector<CMetroidModelInstance>*); std::list<CAreaListItem>::iterator FindStaticGeometry(const std::vector<CMetroidModelInstance>*);
void AddStaticGeometry(const std::vector<CMetroidModelInstance>*, const CAreaRenderOctTree*, int areaIdx, void AddStaticGeometry(const std::vector<CMetroidModelInstance>*, const CAreaRenderOctTree*, int areaIdx,
const SShader* shaderSet); const SShader* shaderSet) override;
void EnablePVS(const CPVSVisSet&, u32); void EnablePVS(const CPVSVisSet&, u32) override;
void DisablePVS(); void DisablePVS() override;
void UpdateAreaUniforms(int areaIdx, EWorldShadowMode shadowMode = EWorldShadowMode::None, void UpdateAreaUniforms(int areaIdx, EWorldShadowMode shadowMode = EWorldShadowMode::None,
bool activateLights = true, int cubeFace = -1, const CModelFlags* ballShadowFlags = nullptr); bool activateLights = true, int cubeFace = -1, const CModelFlags* ballShadowFlags = nullptr);
void RemoveStaticGeometry(const std::vector<CMetroidModelInstance>*); void RemoveStaticGeometry(const std::vector<CMetroidModelInstance>*) override;
void DrawAreaGeometry(int areaIdx, int mask, int targetMask); void DrawAreaGeometry(int areaIdx, int mask, int targetMask) override;
void DrawUnsortedGeometry(int areaIdx, int mask, int targetMask, bool shadowRender = false); void DrawUnsortedGeometry(int areaIdx, int mask, int targetMask, bool shadowRender = false) override;
void DrawSortedGeometry(int areaIdx, int mask, int targetMask); void DrawSortedGeometry(int areaIdx, int mask, int targetMask) override;
void DrawStaticGeometry(int areaIdx, int mask, int targetMask); void DrawStaticGeometry(int areaIdx, int mask, int targetMask) override;
void DrawModelFlat(const CModel& model, const CModelFlags& flags, bool unsortedOnly); void DrawModelFlat(const CModel& model, const CModelFlags& flags, bool unsortedOnly) override;
void PostRenderFogs(); void PostRenderFogs() override;
void AddParticleGen(const CParticleGen&); void AddParticleGen(const CParticleGen&) override;
void AddParticleGen(const CParticleGen&, const zeus::CVector3f&, const zeus::CAABox&); void AddParticleGen(const CParticleGen&, const zeus::CVector3f&, const zeus::CAABox&) override;
void AddPlaneObject(const void*, const zeus::CAABox&, const zeus::CPlane&, int); void AddPlaneObject(const void*, const zeus::CAABox&, const zeus::CPlane&, int) override;
void AddDrawable(void const*, const zeus::CVector3f&, const zeus::CAABox&, int, EDrawableSorting); void AddDrawable(void const*, const zeus::CVector3f&, const zeus::CAABox&, int, EDrawableSorting) override;
void SetDrawableCallback(TDrawableCallback, const void*); void SetDrawableCallback(TDrawableCallback, const void*) override;
void SetWorldViewpoint(const zeus::CTransform&); void SetWorldViewpoint(const zeus::CTransform&) override;
void SetPerspective(float, float, float, float, float); void SetPerspective(float, float, float, float, float) override;
void SetPerspective(float, float, float, float); void SetPerspective(float, float, float, float) override;
std::pair<zeus::CVector2f, zeus::CVector2f> SetViewportOrtho(bool, float, float); std::pair<zeus::CVector2f, zeus::CVector2f> SetViewportOrtho(bool, float, float) override;
void SetClippingPlanes(const zeus::CFrustum& frustum); void SetClippingPlanes(const zeus::CFrustum& frustum) override;
void SetViewport(int, int, int, int); void SetViewport(int, int, int, int) override;
// void SetDepthReadWrite(bool, bool); // void SetDepthReadWrite(bool, bool);
// void SetBlendMode_AdditiveAlpha(); // void SetBlendMode_AdditiveAlpha();
// void SetBlendMode_AlphaBlended(); // void SetBlendMode_AlphaBlended();
@ -238,9 +238,9 @@ public:
// void SetBlendMode_InvertSrc(); // void SetBlendMode_InvertSrc();
// void SetBlendMode_Replace(); // void SetBlendMode_Replace();
// void SetBlendMode_AdditiveDestColor(); // void SetBlendMode_AdditiveDestColor();
void SetDebugOption(EDebugOption, int); void SetDebugOption(EDebugOption, int) override;
void BeginScene(); void BeginScene() override;
void EndScene(); void EndScene() override;
// void BeginPrimitive(EPrimitiveType, int); // void BeginPrimitive(EPrimitiveType, int);
// void BeginLines(int); // void BeginLines(int);
// void BeginLineStrip(int); // void BeginLineStrip(int);
@ -252,24 +252,25 @@ public:
// void PrimColor(float, float, float, float); // void PrimColor(float, float, float, float);
// void PrimColor(const zeus::CColor&); // void PrimColor(const zeus::CColor&);
// void EndPrimitive(); // void EndPrimitive();
void SetAmbientColor(const zeus::CColor&); void SetAmbientColor(const zeus::CColor&) override;
void DrawString(const char*, int, int); void DrawString(const char*, int, int) override;
u32 GetFPS(); u32 GetFPS() override;
void CacheReflection(TReflectionCallback, void*, bool); void CacheReflection(TReflectionCallback, void*, bool) override;
void DrawSpaceWarp(const zeus::CVector3f&, float); void DrawSpaceWarp(const zeus::CVector3f&, float) override;
void DrawThermalModel(const CModel& model, const zeus::CColor& multCol, const zeus::CColor& addCol); void DrawThermalModel(const CModel& model, const zeus::CColor& multCol, const zeus::CColor& addCol) override;
void DrawXRayOutline(const zeus::CAABox&); void DrawXRayOutline(const zeus::CAABox&) override;
void SetWireframeFlags(int); void SetWireframeFlags(int) override;
void SetWorldFog(ERglFogMode, float, float, const zeus::CColor&); void SetWorldFog(ERglFogMode, float, float, const zeus::CColor&) override;
void RenderFogVolume(const zeus::CColor&, const zeus::CAABox&, const TLockedToken<CModel>*, const CSkinnedModel*); void RenderFogVolume(const zeus::CColor&, const zeus::CAABox&, const TLockedToken<CModel>*,
void SetThermal(bool, float, const zeus::CColor&); const CSkinnedModel*) override;
void SetThermalColdScale(float scale); void SetThermal(bool, float, const zeus::CColor&) override;
void DoThermalBlendCold(); void SetThermalColdScale(float scale) override;
void DoThermalBlendHot(); void DoThermalBlendCold() override;
u32 GetStaticWorldDataSize(); void DoThermalBlendHot() override;
void PrepareDynamicLights(const std::vector<CLight>& lights); u32 GetStaticWorldDataSize() override;
void SetGXRegister1Color(const zeus::CColor& color); void PrepareDynamicLights(const std::vector<CLight>& lights) override;
void SetWorldLightFadeLevel(float level); void SetGXRegister1Color(const zeus::CColor& color) override;
void SetWorldLightFadeLevel(float level) override;
void DrawPhazonSuitIndirectEffect(const zeus::CColor& nonIndirectMod, const TLockedToken<CTexture>& indTex, void DrawPhazonSuitIndirectEffect(const zeus::CColor& nonIndirectMod, const TLockedToken<CTexture>& indTex,
const zeus::CColor& indirectMod, float blurRadius, float indScale, float indOffX, const zeus::CColor& indirectMod, float blurRadius, float indScale, float indOffX,
float indOffY); float indOffY);

2
Runtime/Graphics/IWeaponRenderer.hpp
View File

@ -11,7 +11,7 @@ public:
class CDefaultWeaponRenderer : public IWeaponRenderer { class CDefaultWeaponRenderer : public IWeaponRenderer {
public: public:
void AddParticleGen(const CParticleGen&); void AddParticleGen(const CParticleGen&) override;
}; };
} // namespace urde } // namespace urde

2
Runtime/MP1/CAudioStateWin.hpp
View File

@ -6,7 +6,7 @@ namespace urde::MP1 {
class CAudioStateWin : public CIOWin { class CAudioStateWin : public CIOWin {
public: public:
CAudioStateWin() : CIOWin("CAudioStateWin") {} CAudioStateWin() : CIOWin("CAudioStateWin") {}
CIOWin::EMessageReturn OnMessage(const CArchitectureMessage& msg, CArchitectureQueue& queue); CIOWin::EMessageReturn OnMessage(const CArchitectureMessage& msg, CArchitectureQueue& queue) override;
}; };
} // namespace urde::MP1 } // namespace urde::MP1

6
Runtime/MP1/CCredits.hpp
View File

@ -7,9 +7,9 @@ namespace urde::MP1 {
class CCredits : public CIOWin { class CCredits : public CIOWin {
public: public:
CCredits(); CCredits();
EMessageReturn OnMessage(const CArchitectureMessage&, CArchitectureQueue&); EMessageReturn OnMessage(const CArchitectureMessage&, CArchitectureQueue&) override;
bool GetIsContinueDraw() const { return false; } bool GetIsContinueDraw() const override { return false; }
void Draw() const; void Draw() const override;
}; };
} // namespace urde::MP1 } // namespace urde::MP1

4
Runtime/MP1/CFrontEndUI.hpp
View File

@ -379,12 +379,12 @@ public:
void StartStateTransition(EScreen screen); void StartStateTransition(EScreen screen);
void CompleteStateTransition(); void CompleteStateTransition();
void HandleDebugMenuReturnValue(CGameDebug::EReturnValue val, CArchitectureQueue& queue); void HandleDebugMenuReturnValue(CGameDebug::EReturnValue val, CArchitectureQueue& queue);
void Draw() const; void Draw() const override;
void UpdateMovies(float dt); void UpdateMovies(float dt);
bool PumpMovieLoad(); bool PumpMovieLoad();
void ProcessUserInput(const CFinalInput& input, CArchitectureQueue& queue); void ProcessUserInput(const CFinalInput& input, CArchitectureQueue& queue);
EMessageReturn Update(float dt, CArchitectureQueue& queue); EMessageReturn Update(float dt, CArchitectureQueue& queue);
EMessageReturn OnMessage(const CArchitectureMessage& msg, CArchitectureQueue& queue); EMessageReturn OnMessage(const CArchitectureMessage& msg, CArchitectureQueue& queue) override;
}; };
} // namespace MP1 } // namespace MP1

38
Runtime/MP1/CInventoryScreen.hpp
View File

@ -32,27 +32,27 @@ class CInventoryScreen : public CPauseScreenBase {
public: public:
CInventoryScreen(const CStateManager& mgr, CGuiFrame& frame, const CStringTable& pauseStrg, CInventoryScreen(const CStateManager& mgr, CGuiFrame& frame, const CStringTable& pauseStrg,
const CDependencyGroup& suitDgrp, const CDependencyGroup& ballDgrp); const CDependencyGroup& suitDgrp, const CDependencyGroup& ballDgrp);
~CInventoryScreen(); ~CInventoryScreen() override;
bool InputDisabled() const; bool InputDisabled() const override;
void TransitioningAway(); void TransitioningAway() override;
void Update(float dt, CRandom16& rand, CArchitectureQueue& archQueue); void Update(float dt, CRandom16& rand, CArchitectureQueue& archQueue) override;
void Touch(); void Touch() override;
void ProcessControllerInput(const CFinalInput& input); void ProcessControllerInput(const CFinalInput& input) override;
void Draw(float transInterp, float totalAlpha, float yOff); void Draw(float transInterp, float totalAlpha, float yOff) override;
float GetCameraYBias() const; float GetCameraYBias() const override;
bool VReady() const; bool VReady() const override;
void VActivate(); void VActivate() override;
void RightTableSelectionChanged(int oldSel, int newSel); void RightTableSelectionChanged(int oldSel, int newSel) override;
void ChangedMode(EMode oldMode); void ChangedMode(EMode oldMode) override;
void UpdateRightTable(); void UpdateRightTable() override;
bool ShouldLeftTableAdvance() const; bool ShouldLeftTableAdvance() const override;
bool ShouldRightTableAdvance() const; bool ShouldRightTableAdvance() const override;
u32 GetRightTableCount() const; u32 GetRightTableCount() const override;
bool IsRightLogDynamic() const; bool IsRightLogDynamic() const override;
void UpdateRightLogColors(bool active, const zeus::CColor& activeColor, const zeus::CColor& inactiveColor); void UpdateRightLogColors(bool active, const zeus::CColor& activeColor, const zeus::CColor& inactiveColor) override;
void UpdateRightLogHighlight(bool active, int idx, const zeus::CColor& activeColor, void UpdateRightLogHighlight(bool active, int idx, const zeus::CColor& activeColor,
const zeus::CColor& inactiveColor); const zeus::CColor& inactiveColor) override;
}; };
} // namespace MP1 } // namespace MP1

30
Runtime/MP1/CLogBookScreen.hpp
View File

@ -39,22 +39,22 @@ class CLogBookScreen : public CPauseScreenBase {
public: public:
CLogBookScreen(const CStateManager& mgr, CGuiFrame& frame, const CStringTable& pauseStrg); CLogBookScreen(const CStateManager& mgr, CGuiFrame& frame, const CStringTable& pauseStrg);
~CLogBookScreen(); ~CLogBookScreen() override;
bool InputDisabled() const; bool InputDisabled() const override;
void TransitioningAway(); void TransitioningAway() override;
void Update(float dt, CRandom16& rand, CArchitectureQueue& archQueue); void Update(float dt, CRandom16& rand, CArchitectureQueue& archQueue) override;
void Touch(); void Touch() override;
void ProcessControllerInput(const CFinalInput& input); void ProcessControllerInput(const CFinalInput& input) override;
void Draw(float transInterp, float totalAlpha, float yOff); void Draw(float transInterp, float totalAlpha, float yOff) override;
bool VReady() const; bool VReady() const override;
void VActivate(); void VActivate() override;
void RightTableSelectionChanged(int oldSel, int newSel); void RightTableSelectionChanged(int oldSel, int newSel) override;
void ChangedMode(EMode oldMode); void ChangedMode(EMode oldMode) override;
void UpdateRightTable(); void UpdateRightTable() override;
bool ShouldLeftTableAdvance() const; bool ShouldLeftTableAdvance() const override;
bool ShouldRightTableAdvance() const; bool ShouldRightTableAdvance() const override;
u32 GetRightTableCount() const; u32 GetRightTableCount() const override;
}; };
} // namespace urde::MP1 } // namespace urde::MP1

12
Runtime/MP1/CMFGame.hpp
View File

@ -36,10 +36,10 @@ class CMFGame : public CMFGameBase {
public: public:
CMFGame(const std::weak_ptr<CStateManager>& stateMgr, const std::weak_ptr<CInGameGuiManager>& guiMgr, CMFGame(const std::weak_ptr<CStateManager>& stateMgr, const std::weak_ptr<CInGameGuiManager>& guiMgr,
const CArchitectureQueue&); const CArchitectureQueue&);
~CMFGame(); ~CMFGame() override;
CIOWin::EMessageReturn OnMessage(const CArchitectureMessage& msg, CArchitectureQueue& queue); CIOWin::EMessageReturn OnMessage(const CArchitectureMessage& msg, CArchitectureQueue& queue) override;
void Touch(); void Touch();
void Draw() const; void Draw() const override;
void PlayerDied(); void PlayerDied();
void UnpauseGame(); void UnpauseGame();
void EnterMessageScreen(float time); void EnterMessageScreen(float time);
@ -66,9 +66,9 @@ class CMFGameLoader : public CMFGameLoaderBase {
public: public:
CMFGameLoader(); CMFGameLoader();
~CMFGameLoader(); ~CMFGameLoader() override;
EMessageReturn OnMessage(const CArchitectureMessage& msg, CArchitectureQueue& queue); EMessageReturn OnMessage(const CArchitectureMessage& msg, CArchitectureQueue& queue) override;
void Draw() const; void Draw() const override;
}; };
} // namespace MP1 } // namespace MP1

8
Runtime/MP1/CMainFlow.hpp
View File

@ -11,10 +11,10 @@ namespace MP1 {
class CMainFlow : public CMainFlowBase { class CMainFlow : public CMainFlowBase {
public: public:
CMainFlow() : CMainFlowBase("CMainFlow") {} CMainFlow() : CMainFlowBase("CMainFlow") {}
void AdvanceGameState(CArchitectureQueue& queue); void AdvanceGameState(CArchitectureQueue& queue) override;
void SetGameState(EClientFlowStates state, CArchitectureQueue& queue); void SetGameState(EClientFlowStates state, CArchitectureQueue& queue) override;
bool GetIsContinueDraw() const { return false; } bool GetIsContinueDraw() const override { return false; }
void Draw() const {} void Draw() const override {}
}; };
} // namespace MP1 } // namespace MP1

28
Runtime/MP1/COptionsScreen.hpp
View File

@ -22,21 +22,21 @@ class COptionsScreen : public CPauseScreenBase {
public: public:
COptionsScreen(const CStateManager& mgr, CGuiFrame& frame, const CStringTable& pauseStrg); COptionsScreen(const CStateManager& mgr, CGuiFrame& frame, const CStringTable& pauseStrg);
~COptionsScreen(); ~COptionsScreen() override;
bool InputDisabled() const; bool InputDisabled() const override;
void Update(float dt, CRandom16& rand, CArchitectureQueue& archQueue); void Update(float dt, CRandom16& rand, CArchitectureQueue& archQueue) override;
void Touch(); void Touch() override;
void ProcessControllerInput(const CFinalInput& input); void ProcessControllerInput(const CFinalInput& input) override;
void Draw(float transInterp, float totalAlpha, float yOff); void Draw(float transInterp, float totalAlpha, float yOff) override;
bool VReady() const; bool VReady() const override;
void VActivate(); void VActivate() override;
void RightTableSelectionChanged(int oldSel, int newSel); void RightTableSelectionChanged(int oldSel, int newSel) override;
void ChangedMode(EMode oldMode); void ChangedMode(EMode oldMode) override;
void UpdateRightTable(); void UpdateRightTable() override;
bool ShouldLeftTableAdvance() const; bool ShouldLeftTableAdvance() const override;
bool ShouldRightTableAdvance() const; bool ShouldRightTableAdvance() const override;
u32 GetRightTableCount() const; u32 GetRightTableCount() const override;
}; };
} // namespace urde::MP1 } // namespace urde::MP1

2
Runtime/MP1/CPreFrontEnd.hpp
View File

@ -9,7 +9,7 @@ class CPreFrontEnd : public CIOWin {
public: public:
CPreFrontEnd(); CPreFrontEnd();
EMessageReturn OnMessage(const CArchitectureMessage&, CArchitectureQueue&); EMessageReturn OnMessage(const CArchitectureMessage&, CArchitectureQueue&) override;
}; };
} // namespace urde::MP1 } // namespace urde::MP1

6
Runtime/MP1/CSlideShow.hpp
View File

@ -100,9 +100,9 @@ private:
public: public:
CSlideShow(); CSlideShow();
EMessageReturn OnMessage(const CArchitectureMessage&, CArchitectureQueue&); EMessageReturn OnMessage(const CArchitectureMessage&, CArchitectureQueue&) override;
bool GetIsContinueDraw() const { return false; } bool GetIsContinueDraw() const override { return false; }
void Draw() const; void Draw() const override;
static u32 SlideShowGalleryFlags(); static u32 SlideShowGalleryFlags();
}; };

2
Runtime/MP1/CStateSetterFlow.hpp
View File

@ -7,7 +7,7 @@ namespace urde::MP1 {
class CStateSetterFlow : public CIOWin { class CStateSetterFlow : public CIOWin {
public: public:
CStateSetterFlow(); CStateSetterFlow();
EMessageReturn OnMessage(const CArchitectureMessage&, CArchitectureQueue&); EMessageReturn OnMessage(const CArchitectureMessage&, CArchitectureQueue&) override;
}; };
} // namespace urde::MP1 } // namespace urde::MP1

20
Runtime/MP1/MP1.hpp
View File

@ -269,12 +269,12 @@ public:
// int RsMain(int argc, const boo::SystemChar* argv[]); // int RsMain(int argc, const boo::SystemChar* argv[]);
void Init(const hecl::Runtime::FileStoreManager& storeMgr, hecl::CVarManager* cvarManager, boo::IWindow* window, void Init(const hecl::Runtime::FileStoreManager& storeMgr, hecl::CVarManager* cvarManager, boo::IWindow* window,
boo::IAudioVoiceEngine* voiceEngine, amuse::IBackendVoiceAllocator& backend); boo::IAudioVoiceEngine* voiceEngine, amuse::IBackendVoiceAllocator& backend) override;
void WarmupShaders(); void WarmupShaders() override;
bool Proc(); bool Proc() override;
void Draw(); void Draw() override;
void Shutdown(); void Shutdown() override;
boo::IWindow* GetMainWindow() const; boo::IWindow* GetMainWindow() const override;
void MemoryCardInitializePump(); void MemoryCardInitializePump();
@ -294,14 +294,14 @@ public:
static void EnsureWorldPaksReady(); static void EnsureWorldPaksReady();
static void EnsureWorldPakReady(CAssetId mlvl); static void EnsureWorldPakReady(CAssetId mlvl);
EFlowState GetFlowState() const { return x12c_flowState; } EFlowState GetFlowState() const override { return x12c_flowState; }
void SetFlowState(EFlowState s) { x12c_flowState = s; } void SetFlowState(EFlowState s) override { x12c_flowState = s; }
void SetX30(bool v) { x160_30_ = v; } void SetX30(bool v) { x160_30_ = v; }
CGameArchitectureSupport* GetArchSupport() const { return x164_archSupport.get(); } CGameArchitectureSupport* GetArchSupport() const { return x164_archSupport.get(); }
size_t GetExpectedIdSize() const { return sizeof(u32); } size_t GetExpectedIdSize() const override { return sizeof(u32); }
void quit(hecl::Console*, const std::vector<std::string>&) { m_doQuit = true; } void quit(hecl::Console*, const std::vector<std::string>&) { m_doQuit = true; }
void Give(hecl::Console*, const std::vector<std::string>&); void Give(hecl::Console*, const std::vector<std::string>&);
void Remove(hecl::Console*, const std::vector<std::string>&); void Remove(hecl::Console*, const std::vector<std::string>&);
@ -309,7 +309,7 @@ public:
void Teleport(hecl::Console*, const std::vector<std::string>&); void Teleport(hecl::Console*, const std::vector<std::string>&);
void ListWorlds(hecl::Console*, const std::vector<std::string>&); void ListWorlds(hecl::Console*, const std::vector<std::string>&);
void Warp(hecl::Console*, const std::vector<std::string>&); void Warp(hecl::Console*, const std::vector<std::string>&);
hecl::Console* Console() const { return m_console.get(); } hecl::Console* Console() const override { return m_console.get(); }
int m_warpWorldIdx = -1; int m_warpWorldIdx = -1;
TAreaId m_warpAreaId = 0; TAreaId m_warpAreaId = 0;

8
Runtime/MP1/World/CActorContraption.hpp
View File

@ -18,10 +18,10 @@ public:
const zeus::CAABox&, const CMaterialList&, float, float, const CHealthInfo&, const zeus::CAABox&, const CMaterialList&, float, float, const CHealthInfo&,
const CDamageVulnerability&, const CActorParameters&, CAssetId, const CDamageInfo&, bool); const CDamageVulnerability&, const CActorParameters&, CAssetId, const CDamageInfo&, bool);
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&); void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void Think(float, CStateManager&); void Think(float, CStateManager&) override;
void DoUserAnimEvent(CStateManager&, const CInt32POINode&, EUserEventType, float dt); void DoUserAnimEvent(CStateManager&, const CInt32POINode&, EUserEventType, float dt) override;
CFlameThrower* CreateFlameThrower(std::string_view, CStateManager&); CFlameThrower* CreateFlameThrower(std::string_view, CStateManager&);
void ResetFlameThrowers(CStateManager& mgr); void ResetFlameThrowers(CStateManager& mgr);
}; };

26
Runtime/MP1/World/CAtomicAlpha.hpp
View File

@ -36,26 +36,26 @@ public:
const CActorParameters&, const CPatternedInfo&, CAssetId, const CDamageInfo&, float, float, float, const CActorParameters&, const CPatternedInfo&, CAssetId, const CDamageInfo&, float, float, float,
CAssetId, bool, bool); CAssetId, bool, bool);
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&); void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void Render(const CStateManager&) const; void Render(const CStateManager&) const override;
void AddToRenderer(const zeus::CFrustum& frustum, const CStateManager& mgr) const; void AddToRenderer(const zeus::CFrustum& frustum, const CStateManager& mgr) const override;
void Think(float, CStateManager&); void Think(float, CStateManager&) override;
void DoUserAnimEvent(CStateManager& mgr, const CInt32POINode& node, EUserEventType type, float dt); void DoUserAnimEvent(CStateManager& mgr, const CInt32POINode& node, EUserEventType type, float dt) override;
CPathFindSearch* GetSearchPath() { return &x580_pathFind; } CPathFindSearch* GetSearchPath() override { return &x580_pathFind; }
EWeaponCollisionResponseTypes GetCollisionResponseType(const zeus::CVector3f&, const zeus::CVector3f&, EWeaponCollisionResponseTypes GetCollisionResponseType(const zeus::CVector3f&, const zeus::CVector3f&,
const CWeaponMode& wMode, EProjectileAttrib) const { const CWeaponMode& wMode, EProjectileAttrib) const override {
return GetDamageVulnerability()->WeaponHits(wMode, false) ? EWeaponCollisionResponseTypes::AtomicAlpha return GetDamageVulnerability()->WeaponHits(wMode, false) ? EWeaponCollisionResponseTypes::AtomicAlpha
: EWeaponCollisionResponseTypes::AtomicAlphaReflect; : EWeaponCollisionResponseTypes::AtomicAlphaReflect;
} }
bool Leash(CStateManager& mgr, float); bool Leash(CStateManager& mgr, float) override;
bool AggressionCheck(CStateManager&, float); bool AggressionCheck(CStateManager&, float) override;
void CollidedWith(TUniqueId, const CCollisionInfoList&, CStateManager&); void CollidedWith(TUniqueId, const CCollisionInfoList&, CStateManager&) override;
void Patrol(CStateManager&, EStateMsg, float); void Patrol(CStateManager&, EStateMsg, float) override;
void Attack(CStateManager&, EStateMsg, float); void Attack(CStateManager&, EStateMsg, float) override;
CProjectileInfo* GetProjectileInfo() { return &x668_bombProjectile; } CProjectileInfo* GetProjectileInfo() override { return &x668_bombProjectile; }
}; };
} // namespace urde::MP1 } // namespace urde::MP1

10
Runtime/MP1/World/CAtomicBeta.hpp
View File

@ -46,16 +46,16 @@ public:
const CActorParameters&, const CPatternedInfo&, CAssetId, CAssetId, const CDamageInfo&, CAssetId, float, const CActorParameters&, const CPatternedInfo&, CAssetId, CAssetId, const CDamageInfo&, CAssetId, float,
float, float, const CDamageVulnerability&, float, float, float, s16, s16, s16, float); float, float, const CDamageVulnerability&, float, float, float, s16, s16, s16, float);
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&); void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void Think(float, CStateManager&); void Think(float, CStateManager&) override;
const CDamageVulnerability* GetDamageVulnerability() const; const CDamageVulnerability* GetDamageVulnerability() const override;
EWeaponCollisionResponseTypes GetCollisionResponseType(const zeus::CVector3f&, const zeus::CVector3f&, EWeaponCollisionResponseTypes GetCollisionResponseType(const zeus::CVector3f&, const zeus::CVector3f&,
const CWeaponMode& mode, EProjectileAttrib) const { const CWeaponMode& mode, EProjectileAttrib) const override {
return GetDamageVulnerability()->WeaponHits(mode, false) ? EWeaponCollisionResponseTypes::AtomicBeta return GetDamageVulnerability()->WeaponHits(mode, false) ? EWeaponCollisionResponseTypes::AtomicBeta
: EWeaponCollisionResponseTypes::AtomicBetaReflect; : EWeaponCollisionResponseTypes::AtomicBetaReflect;
} }
void Death(CStateManager&, const zeus::CVector3f&, EScriptObjectState); void Death(CStateManager&, const zeus::CVector3f&, EScriptObjectState) override;
static bool IsPlayerBeamChargedEnough(const CStateManager& mgr); static bool IsPlayerBeamChargedEnough(const CStateManager& mgr);
}; };
} // namespace urde::MP1 } // namespace urde::MP1

99
Runtime/MP1/World/CBabygoth.hpp
View File

@ -186,25 +186,26 @@ public:
CBabygoth(TUniqueId, std::string_view, const CEntityInfo&, const zeus::CTransform&, CModelData&&, CBabygoth(TUniqueId, std::string_view, const CEntityInfo&, const zeus::CTransform&, CModelData&&,
const CPatternedInfo&, const CActorParameters&, const CBabygothData&); const CPatternedInfo&, const CActorParameters&, const CBabygothData&);
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager& mgr); void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager& mgr) override;
void PreRender(CStateManager& mgr, const zeus::CFrustum& frustum) { void PreRender(CStateManager& mgr, const zeus::CFrustum& frustum) override {
CPatterned::PreRender(mgr, frustum); CPatterned::PreRender(mgr, frustum);
xb4_drawFlags.x1_matSetIdx = u8(xa04_drawMaterialIdx); xb4_drawFlags.x1_matSetIdx = u8(xa04_drawMaterialIdx);
} }
void Think(float, CStateManager&); void Think(float, CStateManager&) override;
void DoUserAnimEvent(CStateManager& mgr, const CInt32POINode& node, EUserEventType type, float dt); void DoUserAnimEvent(CStateManager& mgr, const CInt32POINode& node, EUserEventType type, float dt) override;
float GetGravityConstant() const { return 10.f * CPhysicsActor::GravityConstant(); } float GetGravityConstant() const override { return 10.f * CPhysicsActor::GravityConstant(); }
void SetPathFindMode(EPathFindMode mode) { x8b4_pathFindMode = mode; } void SetPathFindMode(EPathFindMode mode) { x8b4_pathFindMode = mode; }
const CCollisionPrimitive* GetCollisionPrimitive() const { return &x930_aabox; } const CCollisionPrimitive* GetCollisionPrimitive() const override { return &x930_aabox; }
EWeaponCollisionResponseTypes GetCollisionResponseType(const zeus::CVector3f& v1, const zeus::CVector3f& v2, EWeaponCollisionResponseTypes GetCollisionResponseType(const zeus::CVector3f& v1, const zeus::CVector3f& v2,
const CWeaponMode& wMode, EProjectileAttrib attrib) const { const CWeaponMode& wMode,
EProjectileAttrib attrib) const override {
if (wMode.GetType() == EWeaponType::Ice) if (wMode.GetType() == EWeaponType::Ice)
return EWeaponCollisionResponseTypes::None; return EWeaponCollisionResponseTypes::None;
if (x56c_shellState != EShellState::Destroyed) if (x56c_shellState != EShellState::Destroyed)
@ -212,110 +213,110 @@ public:
return CPatterned::GetCollisionResponseType(v1, v2, wMode, attrib); return CPatterned::GetCollisionResponseType(v1, v2, wMode, attrib);
} }
const CDamageVulnerability* GetDamageVulnerability() const { const CDamageVulnerability* GetDamageVulnerability() const override {
return &CDamageVulnerability::ReflectVulnerabilty(); return &CDamageVulnerability::ReflectVulnerabilty();
} }
const CDamageVulnerability* GetDamageVulnerability(const zeus::CVector3f&, const zeus::CVector3f&, const CDamageVulnerability* GetDamageVulnerability(const zeus::CVector3f&, const zeus::CVector3f&,
const CDamageInfo&) const { const CDamageInfo&) const override {
return &CDamageVulnerability::ReflectVulnerabilty(); return &CDamageVulnerability::ReflectVulnerabilty();
} }
zeus::CVector3f GetAimPosition(const CStateManager& mgr, float dt) const; zeus::CVector3f GetAimPosition(const CStateManager& mgr, float dt) const override;
zeus::CVector3f GetOrigin(const CStateManager& mgr, const CTeamAiRole& role, zeus::CVector3f GetOrigin(const CStateManager& mgr, const CTeamAiRole& role,
const zeus::CVector3f& aimPos) const; const zeus::CVector3f& aimPos) const override;
void TakeDamage(const zeus::CVector3f&, float) { void TakeDamage(const zeus::CVector3f&, float) override {
if (x400_25_alive) if (x400_25_alive)
x428_damageCooldownTimer = 0.33f; x428_damageCooldownTimer = 0.33f;
} }
bool IsListening() const { return true; } bool IsListening() const override { return true; }
void KnockBack(const zeus::CVector3f&, CStateManager&, const CDamageInfo& info, EKnockBackType type, bool inDeferred, void KnockBack(const zeus::CVector3f&, CStateManager&, const CDamageInfo& info, EKnockBackType type, bool inDeferred,
float magnitude); float magnitude) override;
void Shock(CStateManager&, float, float); void Shock(CStateManager&, float, float) override;
void TurnAround(CStateManager&, EStateMsg, float); void TurnAround(CStateManager&, EStateMsg, float) override;
void GetUp(CStateManager&, EStateMsg, float); void GetUp(CStateManager&, EStateMsg, float) override;
void Enraged(CStateManager&, EStateMsg, float); void Enraged(CStateManager&, EStateMsg, float) override;
void FollowPattern(CStateManager&, EStateMsg, float); void FollowPattern(CStateManager&, EStateMsg, float) override;
void Taunt(CStateManager&, EStateMsg, float); void Taunt(CStateManager&, EStateMsg, float) override;
void Crouch(CStateManager&, EStateMsg, float); void Crouch(CStateManager&, EStateMsg, float) override;
void Deactivate(CStateManager&, EStateMsg, float); void Deactivate(CStateManager&, EStateMsg, float) override;
void Generate(CStateManager&, EStateMsg, float); void Generate(CStateManager&, EStateMsg, float) override;
void TargetPatrol(CStateManager&, EStateMsg, float); void TargetPatrol(CStateManager&, EStateMsg, float) override;
void Patrol(CStateManager&, EStateMsg, float); void Patrol(CStateManager&, EStateMsg, float) override;
void Approach(CStateManager&, EStateMsg, float); void Approach(CStateManager&, EStateMsg, float) override;
void PathFind(CStateManager&, EStateMsg, float); void PathFind(CStateManager&, EStateMsg, float) override;
void SpecialAttack(CStateManager&, EStateMsg, float); void SpecialAttack(CStateManager&, EStateMsg, float) override;
void Attack(CStateManager&, EStateMsg, float); void Attack(CStateManager&, EStateMsg, float) override;
void ProjectileAttack(CStateManager&, EStateMsg, float); void ProjectileAttack(CStateManager&, EStateMsg, float) override;
bool Leash(CStateManager&, float); bool Leash(CStateManager&, float) override;
bool AnimOver(CStateManager&, float) { return x568_stateProg == 4; } bool AnimOver(CStateManager&, float) override { return x568_stateProg == 4; }
bool SpotPlayer(CStateManager& mgr, float arg) { bool SpotPlayer(CStateManager& mgr, float arg) override {
if (xa48_24_isAlert) if (xa48_24_isAlert)
return true; return true;
return CPatterned::SpotPlayer(mgr, arg); return CPatterned::SpotPlayer(mgr, arg);
} }
bool InPosition(CStateManager&, float) { return (x8b8_backupDestPos - GetTranslation()).magSquared() < 9.f; } bool InPosition(CStateManager&, float) override { return (x8b8_backupDestPos - GetTranslation()).magSquared() < 9.f; }
bool InMaxRange(CStateManager&, float); bool InMaxRange(CStateManager&, float) override;
bool InDetectionRange(CStateManager&, float); bool InDetectionRange(CStateManager&, float) override;
bool ShotAt(CStateManager&, float) { return x400_24_hitByPlayerProjectile; } bool ShotAt(CStateManager&, float) override { return x400_24_hitByPlayerProjectile; }
bool OffLine(CStateManager& mgr, float arg) { bool OffLine(CStateManager& mgr, float arg) override {
SetPathFindMode(EPathFindMode::Normal); SetPathFindMode(EPathFindMode::Normal);
return PathShagged(mgr, arg); return PathShagged(mgr, arg);
} }
bool ShouldTurn(CStateManager& mgr, float arg); bool ShouldTurn(CStateManager& mgr, float arg) override;
bool ShouldAttack(CStateManager& mgr, float arg); bool ShouldAttack(CStateManager& mgr, float arg) override;
bool ShouldSpecialAttack(CStateManager& mgr, float arg); bool ShouldSpecialAttack(CStateManager& mgr, float arg) override;
bool ShouldFire(CStateManager& mgr, float arg); bool ShouldFire(CStateManager& mgr, float arg) override;
bool TooClose(CStateManager& mgr, float arg); bool TooClose(CStateManager& mgr, float arg) override;
bool LineOfSight(CStateManager& mgr, float arg); bool LineOfSight(CStateManager& mgr, float arg) override;
bool AggressionCheck(CStateManager& mgr, float arg) { bool AggressionCheck(CStateManager& mgr, float arg) override {
return x400_25_alive && !xa48_29_hasBeenEnraged && x56c_shellState == EShellState::Destroyed; return x400_25_alive && !xa48_29_hasBeenEnraged && x56c_shellState == EShellState::Destroyed;
} }
bool LostInterest(CStateManager& mgr, float arg); bool LostInterest(CStateManager& mgr, float arg) override;
bool Listen(const zeus::CVector3f&, EListenNoiseType); bool Listen(const zeus::CVector3f&, EListenNoiseType) override;
CPathFindSearch* GetSearchPath() { CPathFindSearch* GetSearchPath() override {
return x8b4_pathFindMode == EPathFindMode::Normal ? &x6ec_pathSearch : &x7d0_approachPathSearch; return x8b4_pathFindMode == EPathFindMode::Normal ? &x6ec_pathSearch : &x7d0_approachPathSearch;
} }
CProjectileInfo* GetProjectileInfo() { return &x958_iceProjectile; } CProjectileInfo* GetProjectileInfo() override { return &x958_iceProjectile; }
}; };
} // namespace urde::MP1 } // namespace urde::MP1

98
Runtime/MP1/World/CBeetle.hpp
View File

@ -58,61 +58,63 @@ public:
const CDamageVulnerability& tailVuln, const CActorParameters& aParams, const CDamageVulnerability& tailVuln, const CActorParameters& aParams,
const std::optional<CStaticRes>& tailModel); const std::optional<CStaticRes>& tailModel);
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
void Think(float dt, CStateManager& mgr); void Think(float dt, CStateManager& mgr) override;
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId sender, CStateManager& mgr); void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId sender, CStateManager& mgr) override;
void PreRender(CStateManager& mgr, const zeus::CFrustum& frustum); void PreRender(CStateManager& mgr, const zeus::CFrustum& frustum) override;
void Render(const CStateManager& mgr) const; void Render(const CStateManager& mgr) const override;
const CDamageVulnerability* GetDamageVulnerability() const; const CDamageVulnerability* GetDamageVulnerability() const override;
const CDamageVulnerability* GetDamageVulnerability(const zeus::CVector3f& pos, const zeus::CVector3f& dir, const CDamageVulnerability* GetDamageVulnerability(const zeus::CVector3f& pos, const zeus::CVector3f& dir,
const CDamageInfo& dInfo) const; const CDamageInfo& dInfo) const override;
zeus::CVector3f GetOrbitPosition(const CStateManager&) const; zeus::CVector3f GetOrbitPosition(const CStateManager&) const override;
zeus::CVector3f GetAimPosition(const CStateManager& mgr, float) const; zeus::CVector3f GetAimPosition(const CStateManager& mgr, float) const override;
EWeaponCollisionResponseTypes GetCollisionResponseType(const zeus::CVector3f& pos, const zeus::CVector3f& dir, EWeaponCollisionResponseTypes GetCollisionResponseType(const zeus::CVector3f& pos, const zeus::CVector3f& dir,
const CWeaponMode& wMode, EProjectileAttrib attribs) const; const CWeaponMode& wMode,
void DoUserAnimEvent(CStateManager&, const CInt32POINode&, EUserEventType, float dt); EProjectileAttrib attribs) const override;
void CollidedWith(TUniqueId, const CCollisionInfoList&, CStateManager& mgr); void DoUserAnimEvent(CStateManager&, const CInt32POINode&, EUserEventType, float dt) override;
void Death(CStateManager& mgr, const zeus::CVector3f& direction, EScriptObjectState state); void CollidedWith(TUniqueId, const CCollisionInfoList&, CStateManager& mgr) override;
void TakeDamage(const zeus::CVector3f& direction, float magnitude); void Death(CStateManager& mgr, const zeus::CVector3f& direction, EScriptObjectState state) override;
bool IsListening() const; void TakeDamage(const zeus::CVector3f& direction, float magnitude) override;
zeus::CVector3f GetOrigin(const CStateManager& mgr, const CTeamAiRole& role, const zeus::CVector3f& aimPos) const; bool IsListening() const override;
zeus::CVector3f GetOrigin(const CStateManager& mgr, const CTeamAiRole& role,
const zeus::CVector3f& aimPos) const override;
void FollowPattern(CStateManager&, EStateMsg msg, float dt); void FollowPattern(CStateManager&, EStateMsg msg, float dt) override;
void PathFind(CStateManager& mgr, EStateMsg msg, float dt); void PathFind(CStateManager& mgr, EStateMsg msg, float dt) override;
void TargetPlayer(CStateManager&, EStateMsg msg, float dt); void TargetPlayer(CStateManager&, EStateMsg msg, float dt) override;
void Generate(CStateManager&, EStateMsg msg, float dt); void Generate(CStateManager&, EStateMsg msg, float dt) override;
void Deactivate(CStateManager&, EStateMsg msg, float dt); void Deactivate(CStateManager&, EStateMsg msg, float dt) override;
void Attack(CStateManager&, EStateMsg msg, float dt); void Attack(CStateManager&, EStateMsg msg, float dt) override;
void JumpBack(CStateManager&, EStateMsg msg, float dt); void JumpBack(CStateManager&, EStateMsg msg, float dt) override;
void DoubleSnap(CStateManager&, EStateMsg msg, float dt); void DoubleSnap(CStateManager&, EStateMsg msg, float dt) override;
void Shuffle(CStateManager&, EStateMsg msg, float dt); void Shuffle(CStateManager&, EStateMsg msg, float dt) override;
void TurnAround(CStateManager&, EStateMsg msg, float dt); void TurnAround(CStateManager&, EStateMsg msg, float dt) override;
void Skid(CStateManager&, EStateMsg msg, float dt); void Skid(CStateManager&, EStateMsg msg, float dt) override;
void Taunt(CStateManager&, EStateMsg msg, float dt); void Taunt(CStateManager&, EStateMsg msg, float dt) override;
void Retreat(CStateManager&, EStateMsg msg, float dt); void Retreat(CStateManager&, EStateMsg msg, float dt) override;
bool InAttackPosition(CStateManager&, float arg); bool InAttackPosition(CStateManager&, float arg) override;
bool PathShagged(CStateManager&, float arg); bool PathShagged(CStateManager&, float arg) override;
bool InRange(CStateManager&, float arg); bool InRange(CStateManager&, float arg) override;
bool PatternOver(CStateManager&, float arg); bool PatternOver(CStateManager&, float arg) override;
bool HasAttackPattern(CStateManager&, float arg); bool HasAttackPattern(CStateManager&, float arg) override;
bool AnimOver(CStateManager&, float arg); bool AnimOver(CStateManager&, float arg) override;
bool ShouldAttack(CStateManager&, float arg); bool ShouldAttack(CStateManager&, float arg) override;
bool ShouldDoubleSnap(CStateManager&, float arg); bool ShouldDoubleSnap(CStateManager&, float arg) override;
bool ShouldTurn(CStateManager&, float arg); bool ShouldTurn(CStateManager&, float arg) override;
bool HitSomething(CStateManager&, float arg); bool HitSomething(CStateManager&, float arg) override;
bool ShouldJumpBack(CStateManager&, float arg); bool ShouldJumpBack(CStateManager&, float arg) override;
bool Stuck(CStateManager&, float arg); bool Stuck(CStateManager&, float arg) override;
bool NoPathNodes(CStateManager&, float arg); bool NoPathNodes(CStateManager&, float arg) override;
bool ShouldTaunt(CStateManager&, float arg); bool ShouldTaunt(CStateManager&, float arg) override;
bool ShotAt(CStateManager&, float arg); bool ShotAt(CStateManager&, float arg) override;
void Burn(float duration, float damage); void Burn(float duration, float damage) override;
void Shock(CStateManager& mgr, float duration, float damage); void Shock(CStateManager& mgr, float duration, float damage) override;
CPathFindSearch* GetSearchPath(); CPathFindSearch* GetSearchPath() override;
float GetGravityConstant() const; float GetGravityConstant() const override;
}; };
} // namespace MP1 } // namespace MP1
} // namespace urde } // namespace urde

24
Runtime/MP1/World/CBloodFlower.hpp
View File

@ -48,19 +48,19 @@ public:
const CPatternedInfo&, CAssetId, CAssetId, const CActorParameters&, CAssetId, const CDamageInfo&, const CPatternedInfo&, CAssetId, CAssetId, const CActorParameters&, CAssetId, const CDamageInfo&,
const CDamageInfo&, const CDamageInfo&, CAssetId, CAssetId, CAssetId, float, CAssetId, u32); const CDamageInfo&, const CDamageInfo&, CAssetId, CAssetId, CAssetId, float, CAssetId, u32);
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&); void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void Think(float dt, CStateManager& mgr); void Think(float dt, CStateManager& mgr) override;
void DoUserAnimEvent(CStateManager& mgr, const CInt32POINode& node, EUserEventType type, float dt); void DoUserAnimEvent(CStateManager& mgr, const CInt32POINode& node, EUserEventType type, float dt);
void Render(const CStateManager& mgr) const; void Render(const CStateManager& mgr) const override;
void Touch(CActor&, CStateManager&) {} void Touch(CActor&, CStateManager&) override {}
CProjectileInfo* GetProjectileInfo() { return &x590_projectileInfo; } CProjectileInfo* GetProjectileInfo() override { return &x590_projectileInfo; }
bool ShouldAttack(CStateManager&, float); bool ShouldAttack(CStateManager&, float) override;
bool ShouldTurn(CStateManager&, float); bool ShouldTurn(CStateManager&, float) override;
bool Leash(CStateManager&, float) { return x5c0_ < x3d0_playerLeashTime; } bool Leash(CStateManager&, float) override { return x5c0_ < x3d0_playerLeashTime; }
void Active(CStateManager&, EStateMsg, float); void Active(CStateManager&, EStateMsg, float) override;
void InActive(CStateManager&, EStateMsg, float); void InActive(CStateManager&, EStateMsg, float) override;
void BulbAttack(CStateManager&, EStateMsg, float); void BulbAttack(CStateManager&, EStateMsg, float) override;
void PodAttack(CStateManager&, EStateMsg, float); void PodAttack(CStateManager&, EStateMsg, float) override;
}; };
} // namespace urde::MP1 } // namespace urde::MP1

2
Runtime/MP1/World/CBurrower.hpp
View File

@ -13,6 +13,6 @@ public:
const CPatternedInfo&, const CActorParameters&, CAssetId, CAssetId, CAssetId, const CDamageInfo&, CAssetId, const CPatternedInfo&, const CActorParameters&, CAssetId, CAssetId, CAssetId, const CDamageInfo&, CAssetId,
u32, CAssetId); u32, CAssetId);
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&); void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
}; };
} // namespace urde::MP1 } // namespace urde::MP1

26
Runtime/MP1/World/CEyeball.hpp
View File

@ -42,21 +42,21 @@ public:
CAssetId beamPulseFxId, CAssetId beamTextureId, CAssetId beamGlowTextureId, u32 anim0, u32 anim1, u32 anim2, CAssetId beamPulseFxId, CAssetId beamTextureId, CAssetId beamGlowTextureId, u32 anim0, u32 anim1, u32 anim2,
u32 anim3, u32 beamSfx, bool attackDisabled, const CActorParameters& actParms); u32 anim3, u32 beamSfx, bool attackDisabled, const CActorParameters& actParms);
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
void PreRender(CStateManager&, const zeus::CFrustum&); void PreRender(CStateManager&, const zeus::CFrustum&) override;
void Touch(CActor&, CStateManager&){}; void Touch(CActor&, CStateManager&) override {}
void Death(CStateManager&, const zeus::CVector3f&, EScriptObjectState); void Death(CStateManager&, const zeus::CVector3f&, EScriptObjectState) override;
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager& mgr); void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager& mgr) override;
void DoUserAnimEvent(CStateManager&, const CInt32POINode&, EUserEventType, float); void DoUserAnimEvent(CStateManager&, const CInt32POINode&, EUserEventType, float) override;
void Think(float, CStateManager&); void Think(float, CStateManager&) override;
void Flinch(CStateManager&, EStateMsg, float); void Flinch(CStateManager&, EStateMsg, float) override;
void Active(CStateManager&, EStateMsg, float); void Active(CStateManager&, EStateMsg, float) override;
void InActive(CStateManager&, EStateMsg, float); void InActive(CStateManager&, EStateMsg, float) override;
void Cover(CStateManager&, EStateMsg, float); void Cover(CStateManager&, EStateMsg, float) override;
bool ShouldAttack(CStateManager&, float) { return x60c_26_alert; } bool ShouldAttack(CStateManager&, float) override { return x60c_26_alert; }
bool ShouldFire(CStateManager&, float) { return !x60c_27_attackDisabled; } bool ShouldFire(CStateManager&, float) override { return !x60c_27_attackDisabled; }
}; };
} // namespace urde::MP1 } // namespace urde::MP1

26
Runtime/MP1/World/CFireFlea.hpp
View File

@ -18,9 +18,9 @@ class CFireFlea : public CPatterned {
static zeus::CColor sCurrentFadeColor; static zeus::CColor sCurrentFadeColor;
CDeathCameraEffect(TUniqueId, TAreaId, std::string_view); CDeathCameraEffect(TUniqueId, TAreaId, std::string_view);
void Accept(IVisitor&); void Accept(IVisitor&) override;
void PreThink(float, CStateManager&); void PreThink(float, CStateManager&) override;
void Think(float, CStateManager&); void Think(float, CStateManager&) override;
}; };
float x568_ = 1.f; float x568_ = 1.f;
float x56c_; float x56c_;
@ -40,15 +40,15 @@ public:
CFireFlea(TUniqueId, std::string_view, const CEntityInfo&, const zeus::CTransform&, CModelData&&, CFireFlea(TUniqueId, std::string_view, const CEntityInfo&, const zeus::CTransform&, CModelData&&,
const CActorParameters&, const CPatternedInfo&, float); const CActorParameters&, const CPatternedInfo&, float);
void Accept(IVisitor&); void Accept(IVisitor&) override;
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager& mgr); void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager& mgr) override;
void Dead(CStateManager&, EStateMsg msg, float dt); void Dead(CStateManager&, EStateMsg msg, float dt) override;
bool Delay(CStateManager&, float arg); bool Delay(CStateManager&, float arg) override;
bool InPosition(CStateManager& mgr, float dt); bool InPosition(CStateManager& mgr, float dt) override;
bool HearShot(CStateManager&, float); bool HearShot(CStateManager&, float) override;
void TargetPatrol(CStateManager&, EStateMsg, float); void TargetPatrol(CStateManager&, EStateMsg, float) override;
void Patrol(CStateManager&, EStateMsg, float); void Patrol(CStateManager&, EStateMsg, float) override;
void Flee(CStateManager&, EStateMsg, float); void Flee(CStateManager&, EStateMsg, float) override;
CPathFindSearch* GetSearchPath() { return &xd8c_pathFind; } CPathFindSearch* GetSearchPath() override { return &xd8c_pathFind; }
}; };
} // namespace urde::MP1 } // namespace urde::MP1

84
Runtime/MP1/World/CFlaahgra.hpp
View File

@ -45,9 +45,9 @@ class CFlaahgraRenderer : public CActor {
public: public:
CFlaahgraRenderer(TUniqueId, TUniqueId, std::string_view, const CEntityInfo&, const zeus::CTransform&); CFlaahgraRenderer(TUniqueId, TUniqueId, std::string_view, const CEntityInfo&, const zeus::CTransform&);
void AddToRenderer(const zeus::CFrustum&, const CStateManager&) const; void AddToRenderer(const zeus::CFrustum&, const CStateManager&) const override;
void Accept(IVisitor&); void Accept(IVisitor&) override;
std::optional<zeus::CAABox> GetTouchBounds() const { return {}; } std::optional<zeus::CAABox> GetTouchBounds() const override { return {}; }
}; };
class CFlaahgraPlants : public CActor { class CFlaahgraPlants : public CActor {
@ -62,12 +62,12 @@ public:
CFlaahgraPlants(const TToken<CGenDescription>&, const CActorParameters&, TUniqueId, TAreaId, TUniqueId, CFlaahgraPlants(const TToken<CGenDescription>&, const CActorParameters&, TUniqueId, TAreaId, TUniqueId,
const zeus::CTransform&, const CDamageInfo&, const zeus::CVector3f&); const zeus::CTransform&, const CDamageInfo&, const zeus::CVector3f&);
void Accept(IVisitor&); void Accept(IVisitor&) override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&); void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void Think(float, CStateManager&); void Think(float, CStateManager&) override;
void AddToRenderer(const zeus::CFrustum&, const CStateManager&) const; void AddToRenderer(const zeus::CFrustum&, const CStateManager&) const override;
std::optional<zeus::CAABox> GetTouchBounds() const { return x110_aabox; } std::optional<zeus::CAABox> GetTouchBounds() const override { return x110_aabox; }
void Touch(CActor&, CStateManager&); void Touch(CActor&, CStateManager&) override;
}; };
class CFlaahgra : public CPatterned { class CFlaahgra : public CPatterned {
@ -186,44 +186,44 @@ public:
CFlaahgra(TUniqueId, std::string_view, const CEntityInfo&, const zeus::CTransform&, const CAnimRes&, CFlaahgra(TUniqueId, std::string_view, const CEntityInfo&, const zeus::CTransform&, const CAnimRes&,
const CPatternedInfo&, const CActorParameters&, const CFlaahgraData&); const CPatternedInfo&, const CActorParameters&, const CFlaahgraData&);
void Think(float, CStateManager&); void Think(float, CStateManager&) override;
void PreThink(float, CStateManager&); void PreThink(float, CStateManager&) override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&); void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void AddToRenderer(const zeus::CFrustum&, const CStateManager&) const; void AddToRenderer(const zeus::CFrustum&, const CStateManager&) const override;
bool CanRenderUnsorted(const CStateManager&) const { return true; } bool CanRenderUnsorted(const CStateManager&) const override { return true; }
zeus::CVector3f GetAimPosition(const CStateManager&, float) const { return x820_; } zeus::CVector3f GetAimPosition(const CStateManager&, float) const override { return x820_; }
void Death(CStateManager&, const zeus::CVector3f&, EScriptObjectState); void Death(CStateManager&, const zeus::CVector3f&, EScriptObjectState) override;
void DoUserAnimEvent(CStateManager&, const CInt32POINode&, EUserEventType, float dt); void DoUserAnimEvent(CStateManager&, const CInt32POINode&, EUserEventType, float dt) override;
CProjectileInfo* GetProjectileInfo() { return x8e4_30_ ? &x704_ : &x6dc_; } CProjectileInfo* GetProjectileInfo() override { return x8e4_30_ ? &x704_ : &x6dc_; }
bool AnimOver(CStateManager&, float) { return x568_ == 4; } bool AnimOver(CStateManager&, float) override { return x568_ == 4; }
bool AIStage(CStateManager&, float arg) { return x780_ == u32(arg); } bool AIStage(CStateManager&, float arg) override { return x780_ == u32(arg); }
bool HitSomething(CStateManager&, float arg) { return x7d0_ > 0.f; } bool HitSomething(CStateManager&, float arg) override { return x7d0_ > 0.f; }
bool OffLine(CStateManager&, float) { return (x8e5_29_ && x8e5_28_); } bool OffLine(CStateManager&, float) override { return (x8e5_29_ && x8e5_28_); }
bool ShouldTurn(CStateManager&, float); bool ShouldTurn(CStateManager&, float) override;
bool ShouldAttack(CStateManager&, float); bool ShouldAttack(CStateManager&, float) override;
bool BreakAttack(CStateManager&, float) { return x7d4_ >= x56c_.xc_ && !x8e4_29_getup; } bool BreakAttack(CStateManager&, float) override { return x7d4_ >= x56c_.xc_ && !x8e4_29_getup; }
bool IsDizzy(CStateManager&, float) { bool IsDizzy(CStateManager&, float) override {
return x450_bodyController->GetBodyStateInfo().GetCurrentStateId() == pas::EAnimationState::LoopReaction; return x450_bodyController->GetBodyStateInfo().GetCurrentStateId() == pas::EAnimationState::LoopReaction;
} }
bool CoverCheck(CStateManager&, float); bool CoverCheck(CStateManager&, float) override;
void FadeIn(CStateManager&, EStateMsg, float); void FadeIn(CStateManager&, EStateMsg, float) override;
void FadeOut(CStateManager&, EStateMsg, float); void FadeOut(CStateManager&, EStateMsg, float) override;
void TurnAround(CStateManager&, EStateMsg, float); void TurnAround(CStateManager&, EStateMsg, float) override;
void GetUp(CStateManager&, EStateMsg, float); void GetUp(CStateManager&, EStateMsg, float) override;
void Growth(CStateManager&, EStateMsg, float); void Growth(CStateManager&, EStateMsg, float) override;
void Generate(CStateManager&, EStateMsg, float); void Generate(CStateManager&, EStateMsg, float) override;
void Faint(CStateManager&, EStateMsg, float); void Faint(CStateManager&, EStateMsg, float) override;
void Dead(CStateManager&, EStateMsg, float); void Dead(CStateManager&, EStateMsg, float) override;
void Attack(CStateManager&, EStateMsg, float); void Attack(CStateManager&, EStateMsg, float) override;
void Dizzy(CStateManager&, EStateMsg, float); void Dizzy(CStateManager&, EStateMsg, float) override;
void Suck(CStateManager&, EStateMsg, float); void Suck(CStateManager&, EStateMsg, float) override;
void ProjectileAttack(CStateManager&, EStateMsg, float); void ProjectileAttack(CStateManager&, EStateMsg, float) override;
void Cover(CStateManager&, EStateMsg, float); void Cover(CStateManager&, EStateMsg, float) override;
void SpecialAttack(CStateManager&, EStateMsg, float); void SpecialAttack(CStateManager&, EStateMsg, float) override;
void Enraged(CStateManager&, EStateMsg, float); void Enraged(CStateManager&, EStateMsg, float) override;
}; };
} }

24
Runtime/MP1/World/CFlaahgraTentacle.hpp
View File

@ -27,18 +27,22 @@ public:
CFlaahgraTentacle(TUniqueId, std::string_view, const CEntityInfo&, const zeus::CTransform&, CModelData&&, CFlaahgraTentacle(TUniqueId, std::string_view, const CEntityInfo&, const zeus::CTransform&, CModelData&&,
const CPatternedInfo&, const CActorParameters&); const CPatternedInfo&, const CActorParameters&);
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&); void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void Think(float, CStateManager&); void Think(float, CStateManager&) override;
zeus::CVector3f GetAimPosition(const CStateManager&, float) const; zeus::CVector3f GetAimPosition(const CStateManager&, float) const override;
bool Inside(CStateManager&, float) { return x450_bodyController->GetLocomotionType() == pas::ELocomotionType::Crouch; } bool Inside(CStateManager&, float) override {
bool AnimOver(CStateManager&, float) { return x568_ == 3; } return x450_bodyController->GetLocomotionType() == pas::ELocomotionType::Crouch;
bool ShouldAttack(CStateManager&, float); }
bool AnimOver(CStateManager&, float) override { return x568_ == 3; }
bool ShouldAttack(CStateManager&, float) override;
void Dead(CStateManager&, EStateMsg, float) { x450_bodyController->SetLocomotionType(pas::ELocomotionType::Crouch); } void Dead(CStateManager&, EStateMsg, float) override {
void Attack(CStateManager&, EStateMsg, float); x450_bodyController->SetLocomotionType(pas::ELocomotionType::Crouch);
void Retreat(CStateManager&, EStateMsg, float); }
void InActive(CStateManager&, EStateMsg, float); void Attack(CStateManager&, EStateMsg, float) override;
void Retreat(CStateManager&, EStateMsg, float) override;
void InActive(CStateManager&, EStateMsg, float) override;
}; };
} }

28
Runtime/MP1/World/CFlickerBat.hpp
View File

@ -28,20 +28,20 @@ public:
CFlickerBat(TUniqueId, std::string_view name, EFlavorType, const CEntityInfo&, const zeus::CTransform&, CModelData&&, CFlickerBat(TUniqueId, std::string_view name, EFlavorType, const CEntityInfo&, const zeus::CTransform&, CModelData&&,
const CPatternedInfo&, EColliderType, bool, const CActorParameters&, bool); const CPatternedInfo&, EColliderType, bool, const CActorParameters&, bool);
void Accept(IVisitor&); void Accept(IVisitor&) override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&); void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void Think(float, CStateManager&); void Think(float, CStateManager&) override;
void Render(const CStateManager&) const; void Render(const CStateManager&) const override;
void Touch(CActor&, CStateManager&); void Touch(CActor&, CStateManager&) override;
void DoUserAnimEvent(CStateManager&, const CInt32POINode&, EUserEventType, float dt); void DoUserAnimEvent(CStateManager&, const CInt32POINode&, EUserEventType, float dt) override;
void Death(CStateManager& mgr, const zeus::CVector3f& direction, EScriptObjectState state); void Death(CStateManager& mgr, const zeus::CVector3f& direction, EScriptObjectState state) override;
bool CanBeShot(const CStateManager&, int); bool CanBeShot(const CStateManager&, int) override;
void Patrol(CStateManager&, EStateMsg, float); void Patrol(CStateManager&, EStateMsg, float) override;
void Attack(CStateManager&, EStateMsg, float); void Attack(CStateManager&, EStateMsg, float) override;
void Shuffle(CStateManager&, EStateMsg, float); void Shuffle(CStateManager&, EStateMsg, float) override;
void Taunt(CStateManager&, EStateMsg, float); void Taunt(CStateManager&, EStateMsg, float) override;
bool InPosition(CStateManager&, float); bool InPosition(CStateManager&, float) override;
bool HearShot(CStateManager&, float); bool HearShot(CStateManager&, float) override;
EFlickerBatState GetFlickerBatState() const { return x574_state; } EFlickerBatState GetFlickerBatState() const { return x574_state; }
void SetFlickerBatState(EFlickerBatState state, CStateManager&); void SetFlickerBatState(EFlickerBatState state, CStateManager&);

26
Runtime/MP1/World/CJellyZap.hpp
View File

@ -37,18 +37,18 @@ public:
bool, float, float, float, float, float, float, float, float, float, float, float, float, bool, float, float, float, float, float, float, float, float, float, float, float, float,
const CPatternedInfo&, const CActorParameters&); const CPatternedInfo&, const CActorParameters&);
void Accept(IVisitor&); void Accept(IVisitor&) override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&); void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void Think(float, CStateManager&); void Think(float, CStateManager&) override;
void DoUserAnimEvent(CStateManager&, const CInt32POINode&, EUserEventType, float dt); void DoUserAnimEvent(CStateManager&, const CInt32POINode&, EUserEventType, float dt) override;
void Attack(CStateManager&, EStateMsg, float); void Attack(CStateManager&, EStateMsg, float) override;
void Suck(CStateManager&, EStateMsg, float); void Suck(CStateManager&, EStateMsg, float) override;
void Active(CStateManager&, EStateMsg, float); void Active(CStateManager&, EStateMsg, float) override;
void InActive(CStateManager&, EStateMsg, float); void InActive(CStateManager&, EStateMsg, float) override;
void Flinch(CStateManager&, EStateMsg, float); void Flinch(CStateManager&, EStateMsg, float) override;
bool ShouldAttack(CStateManager&, float) { return x330_stateMachineState.GetTime() > x5a8_attackDelay; } bool ShouldAttack(CStateManager&, float) override { return x330_stateMachineState.GetTime() > x5a8_attackDelay; }
bool ShouldSpecialAttack(CStateManager& mgr, float) { return ClosestToPlayer(mgr); } bool ShouldSpecialAttack(CStateManager& mgr, float) override { return ClosestToPlayer(mgr); }
bool InAttackPosition(CStateManager&, float); bool InAttackPosition(CStateManager&, float) override;
bool InDetectionRange(CStateManager&, float); bool InDetectionRange(CStateManager&, float) override;
}; };
} // namespace urde::MP1 } // namespace urde::MP1

2
Runtime/MP1/World/CMagdolite.hpp
View File

@ -35,6 +35,6 @@ public:
const CDamageVulnerability&, const CDamageVulnerability&, CAssetId, CAssetId, float, float, float, float, const CDamageVulnerability&, const CDamageVulnerability&, CAssetId, CAssetId, float, float, float, float,
const CMagdoliteData&, float, float, float); const CMagdoliteData&, float, float, float);
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&); void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
}; };
} // namespace urde::MP1 } // namespace urde::MP1

32
Runtime/MP1/World/CMetaree.hpp
View File

@ -35,22 +35,22 @@ public:
const CPatternedInfo&, const CDamageInfo&, float, const zeus::CVector3f&, float, EBodyType, float, float, const CPatternedInfo&, const CDamageInfo&, float, const zeus::CVector3f&, float, EBodyType, float, float,
const CActorParameters&); const CActorParameters&);
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&); void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void Think(float, CStateManager&); void Think(float, CStateManager&) override;
void Touch(CActor&, CStateManager&); void Touch(CActor&, CStateManager&) override;
void CollidedWith(TUniqueId, const CCollisionInfoList&, CStateManager&); void CollidedWith(TUniqueId, const CCollisionInfoList&, CStateManager&) override;
void ThinkAboutMove(float){}; void ThinkAboutMove(float) override {}
bool Delay(CStateManager&, float) { return x330_stateMachineState.GetTime() > x568_delay; } bool Delay(CStateManager&, float) override { return x330_stateMachineState.GetTime() > x568_delay; }
void Explode(CStateManager&, EStateMsg, float); void Explode(CStateManager&, EStateMsg, float) override;
void Flee(CStateManager&, EStateMsg, float); void Flee(CStateManager&, EStateMsg, float) override;
void Dead(CStateManager&, EStateMsg, float); void Dead(CStateManager&, EStateMsg, float) override;
void Attack(CStateManager&, EStateMsg, float); void Attack(CStateManager&, EStateMsg, float) override;
void Halt(CStateManager&, EStateMsg, float); void Halt(CStateManager&, EStateMsg, float) override;
void Active(CStateManager&, EStateMsg, float); void Active(CStateManager&, EStateMsg, float) override;
void InActive(CStateManager&, EStateMsg, float); void InActive(CStateManager&, EStateMsg, float) override;
bool InRange(CStateManager&, float); bool InRange(CStateManager&, float) override;
bool ShouldAttack(CStateManager&, float); bool ShouldAttack(CStateManager&, float) override;
}; };
} // namespace urde::MP1 } // namespace urde::MP1

2
Runtime/MP1/World/CMetroidPrimeRelay.hpp
View File

@ -28,7 +28,7 @@ public:
const zeus::CTransform& xf, const zeus::CVector3f& scale, SPrimeExoParameters&& parms, float f1, const zeus::CTransform& xf, const zeus::CVector3f& scale, SPrimeExoParameters&& parms, float f1,
float f2, float f3, u32 w1, bool b1, u32 w2, const CHealthInfo& hInfo1, const CHealthInfo& hInfo2, float f2, float f3, u32 w1, bool b1, u32 w2, const CHealthInfo& hInfo1, const CHealthInfo& hInfo2,
u32 w3, u32 w4, u32 w5, rstl::reserved_vector<SPrimeExoRoomParameters, 4>&& roomParms); u32 w3, u32 w4, u32 w5, rstl::reserved_vector<SPrimeExoRoomParameters, 4>&& roomParms);
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
TUniqueId GetMetroidPrimeExoId() const { return x34_mpUid; } TUniqueId GetMetroidPrimeExoId() const { return x34_mpUid; }
}; };

34
Runtime/MP1/World/CNewIntroBoss.hpp
View File

@ -52,27 +52,27 @@ public:
CAssetId projectile, const CDamageInfo& dInfo, CAssetId beamContactFxId, CAssetId beamPulseFxId, CAssetId projectile, const CDamageInfo& dInfo, CAssetId beamContactFxId, CAssetId beamPulseFxId,
CAssetId beamTextureId, CAssetId beamGlowTextureId); CAssetId beamTextureId, CAssetId beamGlowTextureId);
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager&); void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager&) override;
void Think(float dt, CStateManager& mgr); void Think(float dt, CStateManager& mgr) override;
void AddToRenderer(const zeus::CFrustum&, const CStateManager&) const; void AddToRenderer(const zeus::CFrustum&, const CStateManager&) const override;
void OnScanStateChanged(EScanState, CStateManager&); void OnScanStateChanged(EScanState, CStateManager&) override;
CProjectileInfo* GetProjectileInfo() { return &x5ac_projectileInfo; } CProjectileInfo* GetProjectileInfo() override { return &x5ac_projectileInfo; }
zeus::CAABox GetSortingBounds(const CStateManager&) const { zeus::CAABox GetSortingBounds(const CStateManager&) const override {
zeus::CAABox box = GetModelData()->GetBounds(); zeus::CAABox box = GetModelData()->GetBounds();
return zeus::CAABox({-0.5f, -0.5f, box.min.z()}, {0.5f, 0.5f, box.max.z()}).getTransformedAABox(x34_transform); return zeus::CAABox({-0.5f, -0.5f, box.min.z()}, {0.5f, 0.5f, box.max.z()}).getTransformedAABox(x34_transform);
} }
std::optional<zeus::CAABox> GetTouchBounds() const { return {}; } std::optional<zeus::CAABox> GetTouchBounds() const override { return {}; }
void DoUserAnimEvent(CStateManager&, const CInt32POINode&, EUserEventType, float dt); void DoUserAnimEvent(CStateManager&, const CInt32POINode&, EUserEventType, float dt) override;
void Generate(CStateManager&, EStateMsg, float); void Generate(CStateManager&, EStateMsg, float) override;
void Attack(CStateManager&, EStateMsg, float); void Attack(CStateManager&, EStateMsg, float) override;
void Patrol(CStateManager&, EStateMsg, float); void Patrol(CStateManager&, EStateMsg, float) override;
bool ShouldTurn(CStateManager&, float); bool ShouldTurn(CStateManager&, float) override;
bool ShouldAttack(CStateManager&, float); bool ShouldAttack(CStateManager&, float) override;
bool AIStage(CStateManager&, float); bool AIStage(CStateManager&, float) override;
bool AnimOver(CStateManager&, float); bool AnimOver(CStateManager&, float) override;
bool InAttackPosition(CStateManager&, float); bool InAttackPosition(CStateManager&, float) override;
}; };
} // namespace MP1 } // namespace MP1

72
Runtime/MP1/World/CParasite.hpp
View File

@ -108,42 +108,42 @@ public:
u16 haltSfx, u16 getUpSfx, u16 crouchSfx, CAssetId modelRes, CAssetId skinRes, float iceZoomerJointHP, u16 haltSfx, u16 getUpSfx, u16 crouchSfx, CAssetId modelRes, CAssetId skinRes, float iceZoomerJointHP,
const CActorParameters& aParams); const CActorParameters& aParams);
void Accept(IVisitor&); void Accept(IVisitor&) override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&); void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void PreThink(float, CStateManager&); void PreThink(float, CStateManager&) override;
void Think(float dt, CStateManager& mgr); void Think(float dt, CStateManager& mgr) override;
void Render(const CStateManager&) const; void Render(const CStateManager&) const override;
const CDamageVulnerability* GetDamageVulnerability() const; const CDamageVulnerability* GetDamageVulnerability() const override;
CDamageInfo GetContactDamage() const; CDamageInfo GetContactDamage() const override;
void Touch(CActor& actor, CStateManager&); void Touch(CActor& actor, CStateManager&) override;
zeus::CVector3f GetAimPosition(const CStateManager&, float) const; zeus::CVector3f GetAimPosition(const CStateManager&, float) const override;
void CollidedWith(TUniqueId uid, const CCollisionInfoList&, CStateManager&); void CollidedWith(TUniqueId uid, const CCollisionInfoList&, CStateManager&) override;
void Death(CStateManager& mgr, const zeus::CVector3f& direction, EScriptObjectState state); void Death(CStateManager& mgr, const zeus::CVector3f& direction, EScriptObjectState state) override;
void Patrol(CStateManager&, EStateMsg msg, float dt); void Patrol(CStateManager&, EStateMsg msg, float dt) override;
void PathFind(CStateManager&, EStateMsg msg, float dt); void PathFind(CStateManager&, EStateMsg msg, float dt) override;
void TargetPlayer(CStateManager&, EStateMsg msg, float dt); void TargetPlayer(CStateManager&, EStateMsg msg, float dt) override;
void TargetPatrol(CStateManager&, EStateMsg msg, float dt); void TargetPatrol(CStateManager&, EStateMsg msg, float dt) override;
void Halt(CStateManager&, EStateMsg, float); void Halt(CStateManager&, EStateMsg, float) override;
void Run(CStateManager&, EStateMsg, float); void Run(CStateManager&, EStateMsg, float) override;
void Generate(CStateManager&, EStateMsg, float); void Generate(CStateManager&, EStateMsg, float) override;
void Deactivate(CStateManager&, EStateMsg, float); void Deactivate(CStateManager&, EStateMsg, float) override;
void Attack(CStateManager&, EStateMsg, float); void Attack(CStateManager&, EStateMsg, float) override;
void Crouch(CStateManager&, EStateMsg, float); void Crouch(CStateManager&, EStateMsg, float) override;
void GetUp(CStateManager&, EStateMsg, float); void GetUp(CStateManager&, EStateMsg, float) override;
void TelegraphAttack(CStateManager&, EStateMsg, float); void TelegraphAttack(CStateManager&, EStateMsg, float) override;
void Jump(CStateManager&, EStateMsg, float); void Jump(CStateManager&, EStateMsg, float) override;
void Retreat(CStateManager&, EStateMsg, float); void Retreat(CStateManager&, EStateMsg, float) override;
bool AnimOver(CStateManager&, float); bool AnimOver(CStateManager&, float) override;
bool ShouldAttack(CStateManager&, float); bool ShouldAttack(CStateManager&, float) override;
bool HitSomething(CStateManager&, float); bool HitSomething(CStateManager&, float) override;
bool Stuck(CStateManager&, float); bool Stuck(CStateManager&, float) override;
bool Landed(CStateManager&, float); bool Landed(CStateManager&, float) override;
bool AttackOver(CStateManager&, float); bool AttackOver(CStateManager&, float) override;
bool ShotAt(CStateManager&, float); bool ShotAt(CStateManager&, float) override;
void MassiveDeath(CStateManager&); void MassiveDeath(CStateManager&) override;
void MassiveFrozenDeath(CStateManager&); void MassiveFrozenDeath(CStateManager&) override;
void ThinkAboutMove(float); void ThinkAboutMove(float) override;
bool IsOnGround() const; bool IsOnGround() const override;
virtual void UpdateWalkerAnimation(CStateManager&, float); virtual void UpdateWalkerAnimation(CStateManager&, float);
}; };
} // namespace urde::MP1 } // namespace urde::MP1

44
Runtime/MP1/World/CPuddleSpore.hpp
View File

@ -40,42 +40,42 @@ public:
const CPatternedInfo&, EColliderType, CAssetId, float, float, float, float, float, const CPatternedInfo&, EColliderType, CAssetId, float, float, float, float, float,
const CActorParameters&, CAssetId, const CDamageInfo&); const CActorParameters&, CAssetId, const CDamageInfo&);
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager& mgr); void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager& mgr) override;
void PreThink(float, CStateManager&); void PreThink(float, CStateManager&) override;
void Think(float, CStateManager&); void Think(float, CStateManager&) override;
void Render(const CStateManager&) const; void Render(const CStateManager&) const override;
void Touch(CActor&, CStateManager&); void Touch(CActor&, CStateManager&) override;
void FluidFXThink(EFluidState, CScriptWater&, CStateManager&); void FluidFXThink(EFluidState, CScriptWater&, CStateManager&) override;
void KnockBack(const zeus::CVector3f& dir, CStateManager& mgr, const CDamageInfo& dInfo, EKnockBackType type, void KnockBack(const zeus::CVector3f& dir, CStateManager& mgr, const CDamageInfo& dInfo, EKnockBackType type,
bool inDeferred, float dt) { bool inDeferred, float dt) override {
if (x5c8_ == 1) if (x5c8_ == 1)
return; return;
CPatterned::KnockBack(dir, mgr, dInfo, type, inDeferred, dt); CPatterned::KnockBack(dir, mgr, dInfo, type, inDeferred, dt);
} }
EWeaponCollisionResponseTypes GetCollisionResponseType(const zeus::CVector3f& point, const zeus::CVector3f&, EWeaponCollisionResponseTypes GetCollisionResponseType(const zeus::CVector3f& point, const zeus::CVector3f&,
const CWeaponMode&, EProjectileAttrib) const { const CWeaponMode&, EProjectileAttrib) const override {
return HitShell(point) ? EWeaponCollisionResponseTypes::Unknown84 : EWeaponCollisionResponseTypes::Unknown34; return HitShell(point) ? EWeaponCollisionResponseTypes::Unknown84 : EWeaponCollisionResponseTypes::Unknown34;
} }
void DoUserAnimEvent(CStateManager&, const CInt32POINode&, EUserEventType, float); void DoUserAnimEvent(CStateManager&, const CInt32POINode&, EUserEventType, float) override;
void CollidedWith(TUniqueId uid, const CCollisionInfoList& colList, CStateManager& mgr) { void CollidedWith(TUniqueId uid, const CCollisionInfoList& colList, CStateManager& mgr) override {
if (x5c8_ == 2) if (x5c8_ == 2)
return; return;
CPatterned::CollidedWith(uid, colList, mgr); CPatterned::CollidedWith(uid, colList, mgr);
} }
const CCollisionPrimitive* GetCollisionPrimitive() const { return &x5a0_; } const CCollisionPrimitive* GetCollisionPrimitive() const override { return &x5a0_; }
zeus::CAABox CalculateBoundingBox() const; zeus::CAABox CalculateBoundingBox() const;
CProjectileInfo* GetProjectileInfo() { return &x5ec_projectileInfo; } CProjectileInfo* GetProjectileInfo() override { return &x5ec_projectileInfo; }
bool InAttackPosition(CStateManager&, float) { return x568_ >= x570_; } bool InAttackPosition(CStateManager&, float) override { return x568_ >= x570_; }
bool ShouldAttack(CStateManager&, float) { return x568_ >= x574_; } bool ShouldAttack(CStateManager&, float) override { return x568_ >= x574_; }
bool ShouldTurn(CStateManager&, float); bool ShouldTurn(CStateManager&, float) override;
bool AnimOver(CStateManager&, float) { return x5cc_ == 2; } bool AnimOver(CStateManager&, float) override { return x5cc_ == 2; }
void InActive(CStateManager&, EStateMsg, float); void InActive(CStateManager&, EStateMsg, float) override;
void Active(CStateManager&, EStateMsg, float); void Active(CStateManager&, EStateMsg, float) override;
void Run(CStateManager&, EStateMsg, float); void Run(CStateManager&, EStateMsg, float) override;
void TurnAround(CStateManager&, EStateMsg, float); void TurnAround(CStateManager&, EStateMsg, float) override;
void GetUp(CStateManager&, EStateMsg, float); void GetUp(CStateManager&, EStateMsg, float) override;
void Attack(CStateManager&, EStateMsg, float); void Attack(CStateManager&, EStateMsg, float) override;
}; };
} // namespace urde::MP1 } // namespace urde::MP1

38
Runtime/MP1/World/CPuddleToadGamma.hpp
View File

@ -45,30 +45,32 @@ public:
float spotPlayerWaitTime, const CDamageInfo& playerShootDamage, const CDamageInfo& dInfo2, float spotPlayerWaitTime, const CDamageInfo& playerShootDamage, const CDamageInfo& dInfo2,
CAssetId dcln); CAssetId dcln);
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&); void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void Think(float dt, CStateManager& mgr); void Think(float dt, CStateManager& mgr) override;
void DoUserAnimEvent(CStateManager& mgr, const CInt32POINode& node, EUserEventType type, float dt); void DoUserAnimEvent(CStateManager& mgr, const CInt32POINode& node, EUserEventType type, float dt) override;
std::optional<zeus::CAABox> GetTouchBounds() const; std::optional<zeus::CAABox> GetTouchBounds() const override;
const CDamageVulnerability* GetDamageVulnerability(const zeus::CVector3f&, const zeus::CVector3f&, const CDamageVulnerability* GetDamageVulnerability(const zeus::CVector3f&, const zeus::CVector3f&,
const CDamageInfo&) const; const CDamageInfo&) const override;
const CDamageVulnerability* GetDamageVulnerability() const { return &CDamageVulnerability::ImmuneVulnerabilty(); } const CDamageVulnerability* GetDamageVulnerability() const override {
return &CDamageVulnerability::ImmuneVulnerabilty();
}
const CCollisionPrimitive* GetCollisionPrimitive() const; const CCollisionPrimitive* GetCollisionPrimitive() const override;
zeus::CTransform GetPrimitiveTransform() const; zeus::CTransform GetPrimitiveTransform() const override;
void InActive(CStateManager&, EStateMsg, float); void InActive(CStateManager&, EStateMsg, float) override;
void Active(CStateManager&, EStateMsg, float); void Active(CStateManager&, EStateMsg, float) override;
void Suck(CStateManager&, EStateMsg, float); void Suck(CStateManager&, EStateMsg, float) override;
void Attack(CStateManager&, EStateMsg, float); void Attack(CStateManager&, EStateMsg, float) override;
void Crouch(CStateManager&, EStateMsg, float); void Crouch(CStateManager&, EStateMsg, float) override;
bool InAttackPosition(CStateManager&, float); bool InAttackPosition(CStateManager&, float) override;
bool SpotPlayer(CStateManager&, float); bool SpotPlayer(CStateManager&, float) override;
bool ShouldAttack(CStateManager&, float); bool ShouldAttack(CStateManager&, float) override;
bool LostInterest(CStateManager&, float); bool LostInterest(CStateManager&, float) override;
bool Inside(CStateManager&, float); bool Inside(CStateManager&, float) override;
}; };
} // namespace urde::MP1 } // namespace urde::MP1

12
Runtime/MP1/World/CPuffer.hpp
View File

@ -28,11 +28,11 @@ public:
const CActorParameters&, const CPatternedInfo&, float, CAssetId, const CDamageInfo&, CAssetId, float, bool, const CActorParameters&, const CPatternedInfo&, float, CAssetId, const CDamageInfo&, CAssetId, float, bool,
bool, bool, const CDamageInfo&, s16); bool, bool, const CDamageInfo&, s16);
void Accept(IVisitor&); void Accept(IVisitor&) override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&); void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void Think(float, CStateManager&); void Think(float, CStateManager&) override;
std::optional<zeus::CAABox> GetTouchBounds() const; std::optional<zeus::CAABox> GetTouchBounds() const override;
void Touch(CActor&, CStateManager&); void Touch(CActor&, CStateManager&) override;
void Death(CStateManager&, const zeus::CVector3f&, EScriptObjectState); void Death(CStateManager&, const zeus::CVector3f&, EScriptObjectState) override;
}; };
} // namespace urde::MP1 } // namespace urde::MP1

32
Runtime/MP1/World/CSeedling.hpp
View File

@ -24,21 +24,21 @@ public:
const CPatternedInfo&, const CActorParameters&, CAssetId, CAssetId, const CDamageInfo&, const CDamageInfo&, const CPatternedInfo&, const CActorParameters&, CAssetId, CAssetId, const CDamageInfo&, const CDamageInfo&,
float, float, float, float); float, float, float, float);
void Accept(IVisitor&); void Accept(IVisitor&) override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&); void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void Think(float, CStateManager&); void Think(float, CStateManager&) override;
void Render(const CStateManager&) const; void Render(const CStateManager&) const override;
void DoUserAnimEvent(CStateManager& mgr, const CInt32POINode& node, EUserEventType type, float dt); void DoUserAnimEvent(CStateManager& mgr, const CInt32POINode& node, EUserEventType type, float dt) override;
CProjectileInfo* GetProjectileInfo() { return &x6c0_projectileInfo; } CProjectileInfo* GetProjectileInfo() override { return &x6c0_projectileInfo; }
std::optional<zeus::CAABox> GetTouchBounds() const; std::optional<zeus::CAABox> GetTouchBounds() const override;
void Touch(CActor&, CStateManager&); void Touch(CActor&, CStateManager&) override;
CPathFindSearch* GetSearchPath() { return &x5d8_searchPath; } CPathFindSearch* GetSearchPath() override { return &x5d8_searchPath; }
void Patrol(CStateManager&, EStateMsg, float); void Patrol(CStateManager&, EStateMsg, float) override;
void Active(CStateManager&, EStateMsg, float); void Active(CStateManager&, EStateMsg, float) override;
void Enraged(CStateManager&, EStateMsg, float); void Enraged(CStateManager&, EStateMsg, float) override;
void ProjectileAttack(CStateManager&, EStateMsg, float); void ProjectileAttack(CStateManager&, EStateMsg, float) override;
void Generate(CStateManager&, EStateMsg, float); void Generate(CStateManager&, EStateMsg, float) override;
bool ShouldAttack(CStateManager&, float); bool ShouldAttack(CStateManager&, float) override;
void MassiveDeath(CStateManager&); void MassiveDeath(CStateManager&) override;
}; };
} // namespace urde::MP1 } // namespace urde::MP1

173
Runtime/MP1/World/CSpacePirate.hpp
View File

@ -24,9 +24,9 @@ class CPirateRagDoll : public CRagDoll {
public: public:
CPirateRagDoll(CStateManager& mgr, CSpacePirate* sp, u16 thudSfx, u32 flags); CPirateRagDoll(CStateManager& mgr, CSpacePirate* sp, u16 thudSfx, u32 flags);
void PreRender(const zeus::CVector3f& v, CModelData& mData); void PreRender(const zeus::CVector3f& v, CModelData& mData) override;
void Update(CStateManager& mgr, float dt, float waterTop); void Update(CStateManager& mgr, float dt, float waterTop) override;
void Prime(CStateManager& mgr, const zeus::CTransform& xf, CModelData& mData); void Prime(CStateManager& mgr, const zeus::CTransform& xf, CModelData& mData) override;
zeus::CVector3f& TorsoImpulse() { return x84_torsoImpulse; } zeus::CVector3f& TorsoImpulse() { return x84_torsoImpulse; }
}; };
@ -249,96 +249,97 @@ public:
CSpacePirate(TUniqueId, std::string_view, const CEntityInfo&, const zeus::CTransform&, CModelData&&, CSpacePirate(TUniqueId, std::string_view, const CEntityInfo&, const zeus::CTransform&, CModelData&&,
const CActorParameters&, const CPatternedInfo&, CInputStream&, u32); const CActorParameters&, const CPatternedInfo&, CInputStream&, u32);
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
void Think(float dt, CStateManager& mgr); void Think(float dt, CStateManager& mgr) override;
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId sender, CStateManager& mgr); void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId sender, CStateManager& mgr) override;
void PreRender(CStateManager& mgr, const zeus::CFrustum& frustum); void PreRender(CStateManager& mgr, const zeus::CFrustum& frustum) override;
void Render(const CStateManager& mgr) const; void Render(const CStateManager& mgr) const override;
void CalculateRenderBounds(); void CalculateRenderBounds() override;
void Touch(CActor& other, CStateManager& mgr); void Touch(CActor& other, CStateManager& mgr) override;
zeus::CAABox GetSortingBounds(const CStateManager& mgr) const; zeus::CAABox GetSortingBounds(const CStateManager& mgr) const override;
void DoUserAnimEvent(CStateManager& mgr, const CInt32POINode& node, EUserEventType type, float dt); void DoUserAnimEvent(CStateManager& mgr, const CInt32POINode& node, EUserEventType type, float dt) override;
void Death(CStateManager& mgr, const zeus::CVector3f& direction, EScriptObjectState state); void Death(CStateManager& mgr, const zeus::CVector3f& direction, EScriptObjectState state) override;
void KnockBack(const zeus::CVector3f&, CStateManager&, const CDamageInfo& info, EKnockBackType type, bool inDeferred, void KnockBack(const zeus::CVector3f&, CStateManager&, const CDamageInfo& info, EKnockBackType type, bool inDeferred,
float magnitude); float magnitude) override;
bool IsListening() const; bool IsListening() const override;
bool Listen(const zeus::CVector3f&, EListenNoiseType); bool Listen(const zeus::CVector3f&, EListenNoiseType) override;
zeus::CVector3f GetOrigin(const CStateManager& mgr, const CTeamAiRole& role, const zeus::CVector3f& aimPos) const; zeus::CVector3f GetOrigin(const CStateManager& mgr, const CTeamAiRole& role,
const zeus::CVector3f& aimPos) const override;
void DetachActorFromPirate() { x7b4_attachedActor = kInvalidUniqueId; } void DetachActorFromPirate() { x7b4_attachedActor = kInvalidUniqueId; }
bool AttachActorToPirate(TUniqueId id); bool AttachActorToPirate(TUniqueId id);
void SetAttackTarget(TUniqueId id); void SetAttackTarget(TUniqueId id);
void Patrol(CStateManager&, EStateMsg, float); void Patrol(CStateManager&, EStateMsg, float) override;
void Dead(CStateManager&, EStateMsg, float); void Dead(CStateManager&, EStateMsg, float) override;
void PathFind(CStateManager& mgr, EStateMsg msg, float dt); void PathFind(CStateManager& mgr, EStateMsg msg, float dt) override;
void TargetPatrol(CStateManager&, EStateMsg, float); void TargetPatrol(CStateManager&, EStateMsg, float) override;
void TargetCover(CStateManager&, EStateMsg, float); void TargetCover(CStateManager&, EStateMsg, float) override;
void Halt(CStateManager&, EStateMsg, float); void Halt(CStateManager&, EStateMsg, float) override;
void Run(CStateManager&, EStateMsg, float); void Run(CStateManager&, EStateMsg, float) override;
void Generate(CStateManager&, EStateMsg, float); void Generate(CStateManager&, EStateMsg, float) override;
void Deactivate(CStateManager&, EStateMsg, float); void Deactivate(CStateManager&, EStateMsg, float) override;
void Attack(CStateManager&, EStateMsg, float); void Attack(CStateManager&, EStateMsg, float) override;
void JumpBack(CStateManager&, EStateMsg, float); void JumpBack(CStateManager&, EStateMsg, float) override;
void DoubleSnap(CStateManager&, EStateMsg, float); void DoubleSnap(CStateManager&, EStateMsg, float) override;
void Shuffle(CStateManager&, EStateMsg, float); void Shuffle(CStateManager&, EStateMsg, float) override;
void TurnAround(CStateManager&, EStateMsg, float); void TurnAround(CStateManager&, EStateMsg, float) override;
void Skid(CStateManager&, EStateMsg, float); void Skid(CStateManager&, EStateMsg, float) override;
void CoverAttack(CStateManager&, EStateMsg, float); void CoverAttack(CStateManager&, EStateMsg, float) override;
void Crouch(CStateManager&, EStateMsg, float); void Crouch(CStateManager&, EStateMsg, float) override;
void GetUp(CStateManager&, EStateMsg, float); void GetUp(CStateManager&, EStateMsg, float) override;
void Taunt(CStateManager&, EStateMsg, float); void Taunt(CStateManager&, EStateMsg, float) override;
void Flee(CStateManager&, EStateMsg, float); void Flee(CStateManager&, EStateMsg, float) override;
void Lurk(CStateManager&, EStateMsg, float); void Lurk(CStateManager&, EStateMsg, float) override;
void Jump(CStateManager&, EStateMsg, float); void Jump(CStateManager&, EStateMsg, float) override;
void Dodge(CStateManager&, EStateMsg, float); void Dodge(CStateManager&, EStateMsg, float) override;
void Cover(CStateManager&, EStateMsg, float); void Cover(CStateManager&, EStateMsg, float) override;
void Approach(CStateManager&, EStateMsg, float); void Approach(CStateManager&, EStateMsg, float) override;
void WallHang(CStateManager&, EStateMsg, float); void WallHang(CStateManager&, EStateMsg, float) override;
void WallDetach(CStateManager&, EStateMsg, float); void WallDetach(CStateManager&, EStateMsg, float) override;
void Enraged(CStateManager&, EStateMsg, float); void Enraged(CStateManager&, EStateMsg, float) override;
void SpecialAttack(CStateManager&, EStateMsg, float); void SpecialAttack(CStateManager&, EStateMsg, float) override;
void Bounce(CStateManager&, EStateMsg, float); void Bounce(CStateManager&, EStateMsg, float) override;
void PathFindEx(CStateManager&, EStateMsg, float); void PathFindEx(CStateManager&, EStateMsg, float) override;
bool Leash(CStateManager&, float); bool Leash(CStateManager&, float) override;
bool OffLine(CStateManager&, float); bool OffLine(CStateManager&, float) override;
bool Attacked(CStateManager&, float); bool Attacked(CStateManager&, float) override;
bool InRange(CStateManager&, float); bool InRange(CStateManager&, float) override;
bool SpotPlayer(CStateManager&, float); bool SpotPlayer(CStateManager&, float) override;
bool PatternOver(CStateManager&, float); bool PatternOver(CStateManager&, float) override;
bool PatternShagged(CStateManager&, float); bool PatternShagged(CStateManager&, float) override;
bool AnimOver(CStateManager&, float); bool AnimOver(CStateManager&, float) override;
bool ShouldAttack(CStateManager&, float); bool ShouldAttack(CStateManager&, float) override;
bool ShouldJumpBack(CStateManager& mgr, float arg); bool ShouldJumpBack(CStateManager& mgr, float arg) override;
bool Stuck(CStateManager&, float); bool Stuck(CStateManager&, float) override;
bool Landed(CStateManager&, float); bool Landed(CStateManager&, float) override;
bool HearShot(CStateManager&, float); bool HearShot(CStateManager&, float) override;
bool HearPlayer(CStateManager&, float); bool HearPlayer(CStateManager&, float) override;
bool CoverCheck(CStateManager&, float); bool CoverCheck(CStateManager&, float) override;
bool CoverFind(CStateManager&, float); bool CoverFind(CStateManager&, float) override;
bool CoverBlown(CStateManager&, float); bool CoverBlown(CStateManager&, float) override;
bool CoverNearlyBlown(CStateManager&, float); bool CoverNearlyBlown(CStateManager&, float) override;
bool CoveringFire(CStateManager&, float); bool CoveringFire(CStateManager&, float) override;
bool LineOfSight(CStateManager&, float); bool LineOfSight(CStateManager&, float) override;
bool AggressionCheck(CStateManager&, float); bool AggressionCheck(CStateManager&, float) override;
bool ShouldDodge(CStateManager&, float); bool ShouldDodge(CStateManager&, float) override;
bool ShouldRetreat(CStateManager&, float); bool ShouldRetreat(CStateManager&, float) override;
bool ShouldCrouch(CStateManager&, float); bool ShouldCrouch(CStateManager&, float) override;
bool ShouldMove(CStateManager&, float); bool ShouldMove(CStateManager&, float) override;
bool ShotAt(CStateManager&, float); bool ShotAt(CStateManager&, float) override;
bool HasTargetingPoint(CStateManager&, float); bool HasTargetingPoint(CStateManager&, float) override;
bool ShouldWallHang(CStateManager&, float); bool ShouldWallHang(CStateManager&, float) override;
bool StartAttack(CStateManager&, float); bool StartAttack(CStateManager&, float) override;
bool BreakAttack(CStateManager&, float); bool BreakAttack(CStateManager&, float) override;
bool ShouldStrafe(CStateManager& mgr, float arg); bool ShouldStrafe(CStateManager& mgr, float arg) override;
bool ShouldSpecialAttack(CStateManager&, float); bool ShouldSpecialAttack(CStateManager&, float) override;
bool LostInterest(CStateManager&, float); bool LostInterest(CStateManager&, float) override;
bool BounceFind(CStateManager& mgr, float arg); bool BounceFind(CStateManager& mgr, float arg) override;
CPathFindSearch* GetSearchPath(); CPathFindSearch* GetSearchPath() override;
u8 GetModelAlphau8(const CStateManager& mgr) const; u8 GetModelAlphau8(const CStateManager& mgr) const override;
float GetGravityConstant() const; float GetGravityConstant() const override;
CProjectileInfo* GetProjectileInfo(); CProjectileInfo* GetProjectileInfo() override;
}; };
} // namespace urde::MP1 } // namespace urde::MP1

34
Runtime/MP1/World/CSpankWeed.hpp
View File

@ -30,23 +30,23 @@ public:
CSpankWeed(TUniqueId, std::string_view, const CEntityInfo&, const zeus::CTransform&, CModelData&&, CSpankWeed(TUniqueId, std::string_view, const CEntityInfo&, const zeus::CTransform&, CModelData&&,
const CActorParameters&, const CPatternedInfo&, float, float, float, float); const CActorParameters&, const CPatternedInfo&, float, float, float, float);
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&); void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void Think(float, CStateManager&); void Think(float, CStateManager&) override;
zeus::CVector3f GetOrbitPosition(const CStateManager&) const; zeus::CVector3f GetOrbitPosition(const CStateManager&) const override;
zeus::CVector3f GetAimPosition(const CStateManager&, float) const; zeus::CVector3f GetAimPosition(const CStateManager&, float) const override;
bool AnimOver(CStateManager&, float) { return x5bc_ == 3; } bool AnimOver(CStateManager&, float) override { return x5bc_ == 3; }
void Flinch(CStateManager&, EStateMsg, float); void Flinch(CStateManager&, EStateMsg, float) override;
bool Delay(CStateManager&, float); bool Delay(CStateManager&, float) override;
bool InRange(CStateManager&, float); bool InRange(CStateManager&, float) override;
bool HearPlayer(CStateManager&, float); bool HearPlayer(CStateManager&, float) override;
bool InDetectionRange(CStateManager&, float); bool InDetectionRange(CStateManager&, float) override;
void Attack(CStateManager&, EStateMsg, float); void Attack(CStateManager&, EStateMsg, float) override;
void TargetPatrol(CStateManager&, EStateMsg, float); void TargetPatrol(CStateManager&, EStateMsg, float) override;
void Lurk(CStateManager&, EStateMsg, float); void Lurk(CStateManager&, EStateMsg, float) override;
void FadeOut(CStateManager&, EStateMsg, float); void FadeOut(CStateManager&, EStateMsg, float) override;
void FadeIn(CStateManager&, EStateMsg, float); void FadeIn(CStateManager&, EStateMsg, float) override;
void Patrol(CStateManager&, EStateMsg, float); void Patrol(CStateManager&, EStateMsg, float) override;
void KnockBack(const zeus::CVector3f&, CStateManager&, const CDamageInfo& info, EKnockBackType type, bool inDeferred, void KnockBack(const zeus::CVector3f&, CStateManager&, const CDamageInfo& info, EKnockBackType type, bool inDeferred,
float magnitude); float magnitude) override;
}; };
} // namespace urde::MP1 } // namespace urde::MP1

72
Runtime/MP1/World/CTryclops.hpp
View File

@ -38,9 +38,9 @@ public:
CTryclops(TUniqueId, std::string_view, const CEntityInfo&, const zeus::CTransform&, CModelData&&, CTryclops(TUniqueId, std::string_view, const CEntityInfo&, const zeus::CTransform&, CModelData&&,
const CPatternedInfo&, const CActorParameters&, float, float, float, float); const CPatternedInfo&, const CActorParameters&, float, float, float, float);
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&); void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void Think(float, CStateManager&); void Think(float, CStateManager&) override;
const CDamageVulnerability* GetDamageVulnerability() const { const CDamageVulnerability* GetDamageVulnerability() const override {
if (x698_26_) if (x698_26_)
return CAi::GetDamageVulnerability(); return CAi::GetDamageVulnerability();
@ -48,44 +48,44 @@ public:
} }
const CDamageVulnerability* GetDamageVulnerability(const zeus::CVector3f&, const zeus::CVector3f&, const CDamageVulnerability* GetDamageVulnerability(const zeus::CVector3f&, const zeus::CVector3f&,
const CDamageInfo&) const { const CDamageInfo&) const override {
if (x698_26_) if (x698_26_)
return CAi::GetDamageVulnerability(); return CAi::GetDamageVulnerability();
return &skVulnerabilities; return &skVulnerabilities;
} }
void DoUserAnimEvent(CStateManager&, const CInt32POINode&, EUserEventType, float); void DoUserAnimEvent(CStateManager&, const CInt32POINode&, EUserEventType, float) override;
void Death(CStateManager&, const zeus::CVector3f&, EScriptObjectState); void Death(CStateManager&, const zeus::CVector3f&, EScriptObjectState) override;
bool IsListening() const { return true; } bool IsListening() const override { return true; }
void Patrol(CStateManager&, EStateMsg, float); void Patrol(CStateManager&, EStateMsg, float) override;
void PathFind(CStateManager&, EStateMsg, float); void PathFind(CStateManager&, EStateMsg, float) override;
void SelectTarget(CStateManager&, EStateMsg, float); void SelectTarget(CStateManager&, EStateMsg, float) override;
void TargetPatrol(CStateManager&, EStateMsg, float); void TargetPatrol(CStateManager&, EStateMsg, float) override;
void TargetPlayer(CStateManager&, EStateMsg, float); void TargetPlayer(CStateManager&, EStateMsg, float) override;
void TargetCover(CStateManager&, EStateMsg, float); void TargetCover(CStateManager&, EStateMsg, float) override;
void Attack(CStateManager&, EStateMsg, float); void Attack(CStateManager&, EStateMsg, float) override;
void JumpBack(CStateManager&, EStateMsg, float); void JumpBack(CStateManager&, EStateMsg, float) override;
void Shuffle(CStateManager&, EStateMsg, float); void Shuffle(CStateManager&, EStateMsg, float) override;
void TurnAround(CStateManager&, EStateMsg, float); void TurnAround(CStateManager&, EStateMsg, float) override;
void Crouch(CStateManager&, EStateMsg, float); void Crouch(CStateManager&, EStateMsg, float) override;
void GetUp(CStateManager&, EStateMsg, float); void GetUp(CStateManager&, EStateMsg, float) override;
void Suck(CStateManager&, EStateMsg, float); void Suck(CStateManager&, EStateMsg, float) override;
void Cover(CStateManager&, EStateMsg, float); void Cover(CStateManager&, EStateMsg, float) override;
void Approach(CStateManager&, EStateMsg, float); void Approach(CStateManager&, EStateMsg, float) override;
void PathFindEx(CStateManager&, EStateMsg, float); void PathFindEx(CStateManager&, EStateMsg, float) override;
void Dizzy(CStateManager&, EStateMsg, float); void Dizzy(CStateManager&, EStateMsg, float) override;
bool InAttackPosition(CStateManager&, float); bool InAttackPosition(CStateManager&, float) override;
bool InRange(CStateManager&, float); bool InRange(CStateManager&, float) override;
bool InMaxRange(CStateManager&, float); bool InMaxRange(CStateManager&, float) override;
bool InDetectionRange(CStateManager&, float); bool InDetectionRange(CStateManager&, float) override;
bool SpotPlayer(CStateManager&, float); bool SpotPlayer(CStateManager&, float) override;
bool InPosition(CStateManager&, float); bool InPosition(CStateManager&, float) override;
bool HearShot(CStateManager&, float); bool HearShot(CStateManager&, float) override;
bool CoverBlown(CStateManager&, float); bool CoverBlown(CStateManager&, float) override;
bool Inside(CStateManager&, float); bool Inside(CStateManager&, float) override;
bool ShouldRetreat(CStateManager&, float); bool ShouldRetreat(CStateManager&, float) override;
bool IsDizzy(CStateManager&, float); bool IsDizzy(CStateManager&, float) override;
CPathFindSearch* GetSearchPath() { return &x568_pathFindSearch; } CPathFindSearch* GetSearchPath() override { return &x568_pathFindSearch; }
}; };
} // namespace urde::MP1 } // namespace urde::MP1

73
Runtime/MP1/World/CWarWasp.hpp
View File

@ -75,48 +75,49 @@ public:
const CDamageInfo& dInfo1, const CActorParameters&, CAssetId projectileWeapon, const CDamageInfo& dInfo1, const CActorParameters&, CAssetId projectileWeapon,
const CDamageInfo& projectileDamage, CAssetId projectileVisorParticle, u32 projecileVisorSfx); const CDamageInfo& projectileDamage, CAssetId projectileVisorParticle, u32 projecileVisorSfx);
void Accept(IVisitor& visitor); void Accept(IVisitor& visitor) override;
void Think(float dt, CStateManager& mgr); void Think(float dt, CStateManager& mgr) override;
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId sender, CStateManager& mgr); void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId sender, CStateManager& mgr) override;
std::optional<zeus::CAABox> GetTouchBounds() const; std::optional<zeus::CAABox> GetTouchBounds() const override;
void DoUserAnimEvent(CStateManager& mgr, const CInt32POINode& node, EUserEventType type, float dt); void DoUserAnimEvent(CStateManager& mgr, const CInt32POINode& node, EUserEventType type, float dt) override;
const CCollisionPrimitive* GetCollisionPrimitive() const; const CCollisionPrimitive* GetCollisionPrimitive() const override;
void Death(CStateManager& mgr, const zeus::CVector3f& direction, EScriptObjectState state); void Death(CStateManager& mgr, const zeus::CVector3f& direction, EScriptObjectState state) override;
bool IsListening() const; bool IsListening() const override;
bool Listen(const zeus::CVector3f&, EListenNoiseType); bool Listen(const zeus::CVector3f&, EListenNoiseType) override;
zeus::CVector3f GetOrigin(const CStateManager& mgr, const CTeamAiRole& role, const zeus::CVector3f& aimPos) const; zeus::CVector3f GetOrigin(const CStateManager& mgr, const CTeamAiRole& role,
const zeus::CVector3f& aimPos) const override;
void UpdateTouchBounds(); void UpdateTouchBounds();
bool IsRetreating() const { return x72e_30_isRetreating; } bool IsRetreating() const { return x72e_30_isRetreating; }
void Patrol(CStateManager&, EStateMsg, float); void Patrol(CStateManager&, EStateMsg, float) override;
void PathFind(CStateManager& mgr, EStateMsg msg, float dt); void PathFind(CStateManager& mgr, EStateMsg msg, float dt) override;
void TargetPatrol(CStateManager&, EStateMsg, float); void TargetPatrol(CStateManager&, EStateMsg, float) override;
void Generate(CStateManager&, EStateMsg, float); void Generate(CStateManager&, EStateMsg, float) override;
void Deactivate(CStateManager&, EStateMsg, float); void Deactivate(CStateManager&, EStateMsg, float) override;
void Attack(CStateManager&, EStateMsg, float); void Attack(CStateManager&, EStateMsg, float) override;
void JumpBack(CStateManager&, EStateMsg, float); void JumpBack(CStateManager&, EStateMsg, float) override;
void Shuffle(CStateManager&, EStateMsg, float); void Shuffle(CStateManager&, EStateMsg, float) override;
void ProjectileAttack(CStateManager&, EStateMsg, float); void ProjectileAttack(CStateManager&, EStateMsg, float) override;
void TelegraphAttack(CStateManager&, EStateMsg, float); void TelegraphAttack(CStateManager&, EStateMsg, float) override;
void Dodge(CStateManager&, EStateMsg, float); void Dodge(CStateManager&, EStateMsg, float) override;
void Retreat(CStateManager&, EStateMsg, float); void Retreat(CStateManager&, EStateMsg, float) override;
void SpecialAttack(CStateManager&, EStateMsg, float); void SpecialAttack(CStateManager&, EStateMsg, float) override;
bool InAttackPosition(CStateManager&, float); bool InAttackPosition(CStateManager&, float) override;
bool Leash(CStateManager&, float); bool Leash(CStateManager&, float) override;
bool PathShagged(CStateManager&, float); bool PathShagged(CStateManager&, float) override;
bool AnimOver(CStateManager&, float); bool AnimOver(CStateManager&, float) override;
bool ShouldAttack(CStateManager&, float); bool ShouldAttack(CStateManager&, float) override;
bool InPosition(CStateManager&, float); bool InPosition(CStateManager&, float) override;
bool ShouldTurn(CStateManager&, float); bool ShouldTurn(CStateManager&, float) override;
bool HearShot(CStateManager&, float); bool HearShot(CStateManager&, float) override;
bool ShouldFire(CStateManager&, float); bool ShouldFire(CStateManager&, float) override;
bool ShouldDodge(CStateManager&, float); bool ShouldDodge(CStateManager&, float) override;
bool ShouldSpecialAttack(CStateManager&, float); bool ShouldSpecialAttack(CStateManager&, float) override;
CPathFindSearch* GetSearchPath(); CPathFindSearch* GetSearchPath() override;
CProjectileInfo* GetProjectileInfo(); CProjectileInfo* GetProjectileInfo() override;
}; };
} // namespace MP1 } // namespace MP1
} // namespace urde } // namespace urde