AxioDL
/
metaforce
mirror of https://github.com/AxioDL/metaforce.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

RuntimeCommon: Use override where applicable 

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

4
Editor/ProjectResourceFactoryMP1.hpp
View File

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

4
Runtime/Audio/CStreamAudioManager.cpp
View File

@ -148,7 +148,7 @@ struct SDSPStream : boo::IAudioVoiceCallback {
s16 m_prev1 = 0;
s16 m_prev2 = 0;
void preSupplyAudio(boo::IAudioVoice&, double) {}
void preSupplyAudio(boo::IAudioVoice&, double) override {}
unsigned decompressChunk(unsigned readToSample, int16_t*& data) {
unsigned startSamp = m_curSample;
@ -173,7 +173,7 @@ struct SDSPStream : boo::IAudioVoiceCallback {
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) {
memset(data, 0, frames * 2);
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,
float aspect);
void Accept(IVisitor& visitor);
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId objId, CStateManager& stateMgr);
void ProcessInput(const CFinalInput& input, CStateManager& mgr);
void Reset(const zeus::CTransform&, CStateManager& mgr);
void Render(const CStateManager& mgr) const;
void Accept(IVisitor& visitor) override;
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId objId, CStateManager& stateMgr) override;
void ProcessInput(const CFinalInput& input, CStateManager& mgr) override;
void Reset(const zeus::CTransform&, CStateManager& mgr) override;
void Render(const CStateManager& mgr) const override;
EBallCameraBehaviour GetBehaviour() const { return x188_behaviour; }
EBallCameraState GetState() const { return x400_state; }
void SetState(EBallCameraState state, CStateManager& mgr);
void Think(float dt, CStateManager& mgr);
void Think(float dt, CStateManager& mgr) override;
bool TransitionFromMorphBallState(CStateManager& mgr);
TUniqueId GetTooCloseActorId() const { return x3dc_tooCloseActorId; }
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;
public:
void Update(float dt);
void SetFilter(EFilterType type, EFilterShape shape, float time, const zeus::CColor& color, CAssetId txtr);
void DisableFilter(float time);
void Draw() const;
void Update(float dt) override;
void SetFilter(EFilterType type, EFilterShape shape, float time, const zeus::CColor& color, CAssetId txtr) override;
void DisableFilter(float time) override;
void Draw() const override;
};
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,
bool active, float shotDuration, float fovy, float znear, float zfar, float aspect, u32 flags);
void Accept(IVisitor& visitor);
void Think(float dt, CStateManager& mgr);
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager& mgr);
void ProcessInput(const CFinalInput&, CStateManager& mgr);
void Reset(const zeus::CTransform&, CStateManager& mgr);
void Accept(IVisitor& visitor) override;
void Think(float dt, CStateManager& mgr) override;
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager& mgr) override;
void ProcessInput(const CFinalInput&, CStateManager& mgr) override;
void Reset(const zeus::CTransform&, CStateManager& mgr) override;
u32 GetFlags() const { return x21c_flags; }
void WasDeactivated(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,
float nearplane, float farplane, float aspect);
void Accept(IVisitor& visitor);
void PreThink(float dt, CStateManager& mgr);
void Think(float dt, CStateManager& mgr);
void ProcessInput(const CFinalInput&, CStateManager& mgr);
void Reset(const zeus::CTransform&, CStateManager& mgr);
void Accept(IVisitor& visitor) override;
void PreThink(float dt, CStateManager& mgr) override;
void Think(float dt, CStateManager& mgr) override;
void ProcessInput(const CFinalInput&, CStateManager& mgr) override;
void Reset(const zeus::CTransform&, CStateManager& mgr) override;
void SkipCinematic();
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,
u32 controllerIdx);
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&);
void SetActive(bool active);
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void SetActive(bool active) override;
virtual void ProcessInput(const CFinalInput&, 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:
CInterpolationCamera(TUniqueId uid, const zeus::CTransform& xf);
void Accept(IVisitor& visitor);
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&);
void ProcessInput(const CFinalInput&, CStateManager& mgr);
void Render(const CStateManager&) const;
void Reset(const zeus::CTransform&, CStateManager& mgr);
void Think(float, CStateManager&);
void Accept(IVisitor& visitor) override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void ProcessInput(const CFinalInput&, CStateManager& mgr) override;
void Render(const CStateManager&) const override;
void Reset(const zeus::CTransform&, CStateManager& mgr) override;
void Think(float, CStateManager&) override;
void SetInterpolation(const zeus::CTransform& xf, const zeus::CVector3f& lookPos, float maxTime, float positionSpeed,
float rotationSpeed, TUniqueId camId, bool sinusoidal, CStateManager& mgr);
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,
u32 flags, EInitialSplinePosition initPos);
void Accept(IVisitor&);
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&);
void Think(float, CStateManager&);
void Render(const CStateManager&) const {}
void ProcessInput(const CFinalInput&, CStateManager& mgr);
void Reset(const zeus::CTransform&, CStateManager& mgr);
void Accept(IVisitor&) override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void Think(float, CStateManager&) override;
void Render(const CStateManager&) const override {}
void ProcessInput(const CFinalInput&, CStateManager& mgr) override;
void Reset(const zeus::CTransform&, CStateManager& mgr) override;
zeus::CTransform MoveAlongSpline(float, 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);
public:
void Start(CBodyController& bc, CStateManager& mgr);
pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr);
void Shutdown(CBodyController& bc);
void Start(CBodyController& bc, CStateManager& mgr) override;
pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
void Shutdown(CBodyController& bc) override;
};
class CABSFlinch : public CAdditiveBodyState {
@ -41,8 +41,8 @@ class CABSFlinch : public CAdditiveBodyState {
public:
void Start(CBodyController& bc, CStateManager& mgr);
pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr);
void Shutdown(CBodyController& bc) {}
pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
void Shutdown(CBodyController& bc) override {}
};
class CABSIdle : public CAdditiveBodyState {
@ -50,8 +50,8 @@ class CABSIdle : public CAdditiveBodyState {
public:
void Start(CBodyController& bc, CStateManager& mgr) {}
pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr);
void Shutdown(CBodyController& bc) {}
pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
void Shutdown(CBodyController& bc) override {}
};
class CABSReaction : public CAdditiveBodyState {
@ -63,9 +63,9 @@ class CABSReaction : public CAdditiveBodyState {
void StopAnimation(CBodyController& bc);
public:
void Start(CBodyController& bc, CStateManager& mgr);
pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr);
void Shutdown(CBodyController& bc) { StopAnimation(bc); }
void Start(CBodyController& bc, CStateManager& mgr) override;
pas::EAnimationState UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) override;
void Shutdown(CBodyController& bc) override { StopAnimation(bc); }
};
} // namespace urde

57
Runtime/Character/CAnimSourceReader.hpp
View File

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

52
Runtime/Character/CAnimTreeAnimReaderContainer.hpp
View File

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

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,
float blendWeight, std::string_view name);
SAdvancementResults VAdvanceView(const CCharAnimTime& dt);
CCharAnimTime VGetTimeRemaining() const;
CSteadyStateAnimInfo VGetSteadyStateAnimInfo() const;
std::unique_ptr<IAnimReader> VClone() const;
void SetBlendingWeight(float w);
float VGetBlendingWeight() const;
SAdvancementResults VAdvanceView(const CCharAnimTime& dt) override;
CCharAnimTime VGetTimeRemaining() const override;
CSteadyStateAnimInfo VGetSteadyStateAnimInfo() const override;
std::unique_ptr<IAnimReader> VClone() const override;
void SetBlendingWeight(float w) override;
float VGetBlendingWeight() const override;
};
} // namespace urde

34
Runtime/Character/CAnimTreeDoubleChild.hpp
View File

@ -29,21 +29,25 @@ protected:
public:
CAnimTreeDoubleChild(const std::weak_ptr<CAnimTreeNode>& a, const std::weak_ptr<CAnimTreeNode>& b,
std::string_view name);
SAdvancementResults VAdvanceView(const CCharAnimTime& a);
u32 VGetBoolPOIList(const CCharAnimTime& time, CBoolPOINode* listOut, u32 capacity, u32 iterator, u32) const;
u32 VGetInt32POIList(const CCharAnimTime& time, CInt32POINode* listOut, u32 capacity, u32 iterator, u32) const;
u32 VGetParticlePOIList(const CCharAnimTime& time, CParticlePOINode* listOut, u32 capacity, u32 iterator, u32) const;
u32 VGetSoundPOIList(const CCharAnimTime& time, CSoundPOINode* listOut, u32 capacity, u32 iterator, u32) const;
bool VGetBoolPOIState(const char* name) const;
s32 VGetInt32POIState(const char* name) const;
CParticleData::EParentedMode VGetParticlePOIState(const char* name) const;
void VSetPhase(float);
SAdvancementResults VGetAdvancementResults(const CCharAnimTime& a, const CCharAnimTime& b) const;
u32 Depth() const;
CAnimTreeEffectiveContribution VGetContributionOfHighestInfluence() const;
u32 VGetNumChildren() const;
std::shared_ptr<IAnimReader> VGetBestUnblendedChild() const;
void VGetWeightedReaders(rstl::reserved_vector<std::pair<float, std::weak_ptr<IAnimReader>>, 16>& out, float w) const;
SAdvancementResults VAdvanceView(const CCharAnimTime& a) override;
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 override;
u32 VGetParticlePOIList(const CCharAnimTime& time, CParticlePOINode* listOut, u32 capacity, u32 iterator,
u32) const override;
u32 VGetSoundPOIList(const CCharAnimTime& time, CSoundPOINode* listOut, u32 capacity, u32 iterator,
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;
void VSetPhase(float) override;
SAdvancementResults VGetAdvancementResults(const CCharAnimTime& a, const CCharAnimTime& b) const override;
u32 Depth() const override;
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;
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,
const CAnimSysContext& animCtx, std::string_view name, const CSequenceFundamentals& fundamentals,
const CCharAnimTime& time);
CAnimTreeEffectiveContribution VGetContributionOfHighestInfluence() const;
CAnimTreeEffectiveContribution VGetContributionOfHighestInfluence() const override;
bool VSupportsReverseView() const { return false; }
std::optional<std::unique_ptr<IAnimReader>> VSimplified();
std::shared_ptr<IAnimReader> VGetBestUnblendedChild() const;
std::unique_ptr<IAnimReader> VClone() const;
u32 VGetBoolPOIList(const CCharAnimTime& time, CBoolPOINode* listOut, u32 capacity, u32 iterator, u32) const;
u32 VGetInt32POIList(const CCharAnimTime& time, CInt32POINode* listOut, u32 capacity, u32 iterator, u32) const;
u32 VGetParticlePOIList(const CCharAnimTime& time, CParticlePOINode* listOut, u32 capacity, u32 iterator, u32) const;
u32 VGetSoundPOIList(const CCharAnimTime& time, CSoundPOINode* listOut, u32 capacity, u32 iterator, u32) const;
CSteadyStateAnimInfo VGetSteadyStateAnimInfo() const;
CCharAnimTime VGetTimeRemaining() const;
SAdvancementResults VAdvanceView(const CCharAnimTime& dt);
std::optional<std::unique_ptr<IAnimReader>> VSimplified() override;
std::shared_ptr<IAnimReader> VGetBestUnblendedChild() const override;
std::unique_ptr<IAnimReader> VClone() const override;
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 override;
u32 VGetParticlePOIList(const CCharAnimTime& time, CParticlePOINode* listOut, u32 capacity, u32 iterator,
u32) const override;
u32 VGetSoundPOIList(const CCharAnimTime& time, CSoundPOINode* listOut, u32 capacity, u32 iterator,
u32) const override;
CSteadyStateAnimInfo VGetSteadyStateAnimInfo() const override;
CCharAnimTime VGetTimeRemaining() const override;
SAdvancementResults VAdvanceView(const CCharAnimTime& dt) override;
};
} // namespace urde

2
Runtime/Character/CAnimTreeNode.hpp
View File

@ -10,7 +10,7 @@ protected:
public:
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) {
if (ptr->IsCAnimTreeNode())
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,
std::string_view name, const CSequenceFundamentals& fundamentals, const CCharAnimTime& time);
CAnimTreeEffectiveContribution VGetContributionOfHighestInfluence() const;
std::shared_ptr<IAnimReader> VGetBestUnblendedChild() const;
CAnimTreeEffectiveContribution VGetContributionOfHighestInfluence() const override;
std::shared_ptr<IAnimReader> VGetBestUnblendedChild() const override;
bool VSupportsReverseView() const { return false; }
SAdvancementResults VAdvanceView(const CCharAnimTime& dt);
CCharAnimTime VGetTimeRemaining() const;
CSteadyStateAnimInfo VGetSteadyStateAnimInfo() const;
u32 VGetBoolPOIList(const CCharAnimTime& time, CBoolPOINode* listOut, u32 capacity, u32 iterator, u32) const;
u32 VGetInt32POIList(const CCharAnimTime& time, CInt32POINode* listOut, u32 capacity, u32 iterator, u32) const;
u32 VGetParticlePOIList(const CCharAnimTime& time, CParticlePOINode* listOut, u32 capacity, u32 iterator, u32) const;
u32 VGetSoundPOIList(const CCharAnimTime& time, CSoundPOINode* listOut, u32 capacity, u32 iterator, u32) const;
std::unique_ptr<IAnimReader> VClone() const;
SAdvancementResults VAdvanceView(const CCharAnimTime& dt) override;
CCharAnimTime VGetTimeRemaining() const override;
CSteadyStateAnimInfo VGetSteadyStateAnimInfo() const override;
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 override;
u32 VGetParticlePOIList(const CCharAnimTime& time, CParticlePOINode* listOut, u32 capacity, u32 iterator,
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

41
Runtime/Character/CAnimTreeSingleChild.hpp
View File

@ -11,26 +11,29 @@ protected:
public:
CAnimTreeSingleChild(const std::weak_ptr<CAnimTreeNode>& node, std::string_view name);
SAdvancementResults VAdvanceView(const CCharAnimTime& dt);
CCharAnimTime VGetTimeRemaining() const;
bool VHasOffset(const CSegId& seg) const;
zeus::CVector3f VGetOffset(const CSegId& seg) const;
zeus::CQuaternion VGetRotation(const CSegId& seg) const;
u32 VGetBoolPOIList(const CCharAnimTime& time, CBoolPOINode* listOut, u32 capacity, u32 iterator, u32) const;
u32 VGetInt32POIList(const CCharAnimTime& time, CInt32POINode* listOut, u32 capacity, u32 iterator, u32) const;
u32 VGetParticlePOIList(const CCharAnimTime& time, CParticlePOINode* listOut, u32 capacity, u32 iterator, u32) const;
u32 VGetSoundPOIList(const CCharAnimTime& time, CSoundPOINode* listOut, u32 capacity, u32 iterator, u32) const;
bool VGetBoolPOIState(const char* name) const;
s32 VGetInt32POIState(const char* name) const;
CParticleData::EParentedMode VGetParticlePOIState(const char* name) const;
void VGetSegStatementSet(const CSegIdList& list, CSegStatementSet& setOut) const;
void VGetSegStatementSet(const CSegIdList& list, CSegStatementSet& setOut, const CCharAnimTime& time) const;
void VSetPhase(float);
SAdvancementResults VGetAdvancementResults(const CCharAnimTime& a, const CCharAnimTime& b) const;
u32 Depth() const;
u32 VGetNumChildren() const;
SAdvancementResults VAdvanceView(const CCharAnimTime& dt) override;
CCharAnimTime VGetTimeRemaining() const override;
bool VHasOffset(const CSegId& seg) const override;
zeus::CVector3f VGetOffset(const CSegId& seg) const override;
zeus::CQuaternion VGetRotation(const CSegId& seg) const override;
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 override;
u32 VGetParticlePOIList(const CCharAnimTime& time, CParticlePOINode* listOut, u32 capacity, u32 iterator,
u32) const override;
u32 VGetSoundPOIList(const CCharAnimTime& time, CSoundPOINode* listOut, u32 capacity, u32 iterator,
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;
void VGetSegStatementSet(const CSegIdList& list, CSegStatementSet& setOut) const override;
void VGetSegStatementSet(const CSegIdList& list, CSegStatementSet& setOut, const CCharAnimTime& time) const override;
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,
float w) const {
float w) const override {
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);
CCharAnimTime GetRealLifeTime(const CCharAnimTime&) const;
void VSetPhase(float);
std::optional<std::unique_ptr<IAnimReader>> VSimplified();
void VSetPhase(float) override;
std::optional<std::unique_ptr<IAnimReader>> VSimplified() override;
u32 VGetBoolPOIList(const CCharAnimTime& time, CBoolPOINode* listOut, u32 capacity, u32 iterator, u32) const;
u32 VGetInt32POIList(const CCharAnimTime& time, CInt32POINode* listOut, u32 capacity, u32 iterator, u32) const;
u32 VGetParticlePOIList(const CCharAnimTime& time, CParticlePOINode* listOut, u32 capacity, u32 iterator, u32) const;
u32 VGetSoundPOIList(const CCharAnimTime& time, CSoundPOINode* listOut, u32 capacity, u32 iterator, u32) const;
bool VGetBoolPOIState(const char* name) const;
s32 VGetInt32POIState(const char* name) const;
CParticleData::EParentedMode VGetParticlePOIState(const char* name) 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 override;
u32 VGetParticlePOIList(const CCharAnimTime& time, CParticlePOINode* listOut, u32 capacity, u32 iterator,
u32) const override;
u32 VGetSoundPOIList(const CCharAnimTime& time, CSoundPOINode* listOut, u32 capacity, u32 iterator,
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;
std::shared_ptr<IAnimReader> VGetBestUnblendedChild() const;
std::unique_ptr<IAnimReader> VClone() const;
CSteadyStateAnimInfo VGetSteadyStateAnimInfo() const;
CCharAnimTime VGetTimeRemaining() const;
SAdvancementResults VAdvanceView(const CCharAnimTime& dt);
CAnimTreeEffectiveContribution VGetContributionOfHighestInfluence() const override;
std::shared_ptr<IAnimReader> VGetBestUnblendedChild() const override;
std::unique_ptr<IAnimReader> VClone() const override;
CSteadyStateAnimInfo VGetSteadyStateAnimInfo() const override;
CCharAnimTime VGetTimeRemaining() const override;
SAdvancementResults VAdvanceView(const CCharAnimTime& dt) override;
};
} // namespace urde

18
Runtime/Character/CAnimTreeTransition.hpp
View File

@ -23,14 +23,14 @@ public:
std::string_view name, bool initialized);
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);
std::shared_ptr<IAnimReader> VGetBestUnblendedChild() const;
CCharAnimTime VGetTimeRemaining() const;
CSteadyStateAnimInfo VGetSteadyStateAnimInfo() const;
std::unique_ptr<IAnimReader> VClone() const;
std::optional<std::unique_ptr<IAnimReader>> VSimplified();
std::optional<std::unique_ptr<IAnimReader>> VReverseSimplified();
SAdvancementResults VAdvanceView(const CCharAnimTime& a);
void SetBlendingWeight(float w);
float VGetBlendingWeight() const;
std::shared_ptr<IAnimReader> VGetBestUnblendedChild() const override;
CCharAnimTime VGetTimeRemaining() const override;
CSteadyStateAnimInfo VGetSteadyStateAnimInfo() const override;
std::unique_ptr<IAnimReader> VClone() const override;
std::optional<std::unique_ptr<IAnimReader>> VSimplified() override;
std::optional<std::unique_ptr<IAnimReader>> VReverseSimplified() override;
SAdvancementResults VAdvanceView(const CCharAnimTime& a) override;
void SetBlendingWeight(float w) override;
float VGetBlendingWeight() const override;
};
} // namespace urde

17
Runtime/Character/CAnimTreeTweenBase.hpp
View File

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

10
Runtime/Character/CAnimationDatabaseGame.hpp
View File

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

28
Runtime/Character/CAssetFactory.hpp
View File

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

220
Runtime/Character/CBodyState.hpp
View File

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

28
Runtime/Character/CCharacterFactory.hpp
View File

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

42
Runtime/Character/CFBStreamedAnimReader.hpp
View File

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

6
Runtime/Character/CMetaAnimBlend.hpp
View File

@ -13,11 +13,11 @@ class CMetaAnimBlend : public IMetaAnim {
public:
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,
const CMetaAnimTreeBuildOrders& orders) const;
const CMetaAnimTreeBuildOrders& orders) const override;
};
} // namespace urde

6
Runtime/Character/CMetaAnimPhaseBlend.hpp
View File

@ -13,11 +13,11 @@ class CMetaAnimPhaseBlend : public IMetaAnim {
public:
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,
const CMetaAnimTreeBuildOrders& orders) const;
const CMetaAnimTreeBuildOrders& orders) const override;
};
} // namespace urde

6
Runtime/Character/CMetaAnimPlay.hpp
View File

@ -12,11 +12,11 @@ class CMetaAnimPlay : public IMetaAnim {
public:
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,
const CMetaAnimTreeBuildOrders& orders) const;
const CMetaAnimTreeBuildOrders& orders) const override;
};
} // namespace urde

6
Runtime/Character/CMetaAnimRandom.hpp
View File

@ -12,11 +12,11 @@ class CMetaAnimRandom : public IMetaAnim {
public:
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,
const CMetaAnimTreeBuildOrders& orders) const;
const CMetaAnimTreeBuildOrders& orders) const override;
};
} // namespace urde

6
Runtime/Character/CMetaAnimSequence.hpp
View File

@ -11,11 +11,11 @@ class CMetaAnimSequence : public IMetaAnim {
public:
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,
const CMetaAnimTreeBuildOrders& orders) const;
const CMetaAnimTreeBuildOrders& orders) const override;
};
} // namespace urde

4
Runtime/Character/CMetaTransMetaAnim.hpp
View File

@ -11,11 +11,11 @@ class CMetaTransMetaAnim : public IMetaTrans {
public:
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,
const std::weak_ptr<CAnimTreeNode>& b,
const CAnimSysContext& animSys) const;
const CAnimSysContext& animSys) const override;
};
} // namespace urde

4
Runtime/Character/CMetaTransPhaseTrans.hpp
View File

@ -14,11 +14,11 @@ class CMetaTransPhaseTrans : public IMetaTrans {
public:
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,
const std::weak_ptr<CAnimTreeNode>& b,
const CAnimSysContext& animSys) const;
const CAnimSysContext& animSys) const override;
};
} // namespace urde

4
Runtime/Character/CMetaTransSnap.hpp
View File

@ -7,11 +7,11 @@ namespace urde {
class CMetaTransSnap : public IMetaTrans {
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,
const std::weak_ptr<CAnimTreeNode>& b,
const CAnimSysContext& animSys) const;
const CAnimSysContext& animSys) const override;
};
} // namespace urde

4
Runtime/Character/CMetaTransTrans.hpp
View File

@ -14,11 +14,11 @@ class CMetaTransTrans : public IMetaTrans {
public:
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,
const std::weak_ptr<CAnimTreeNode>& b,
const CAnimSysContext& animSys) const;
const CAnimSysContext& animSys) const override;
};
} // namespace urde

34
Runtime/Character/CParticleGenInfo.hpp
View File

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

20
Runtime/Character/CTimeScaleFunctions.hpp
View File

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

2
Runtime/Character/CTransitionDatabaseGame.hpp
View File

@ -15,7 +15,7 @@ public:
CTransitionDatabaseGame(const std::vector<CTransition>& transitions,
const std::vector<CHalfTransition>& halfTransitions,
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

2
Runtime/Collision/CAABoxFilter.hpp
View File

@ -7,7 +7,7 @@ namespace urde {
class CAABoxFilter : public ICollisionFilter {
public:
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);
};

2
Runtime/Collision/CBallFilter.hpp
View File

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

10
Runtime/Collision/CCollidableAABox.hpp
View File

@ -19,11 +19,11 @@ public:
CCollidableAABox(const zeus::CAABox&, const CMaterialList&);
zeus::CAABox Transform(const zeus::CTransform&) const;
virtual u32 GetTableIndex() const;
virtual zeus::CAABox CalculateAABox(const zeus::CTransform&) const;
virtual zeus::CAABox CalculateLocalAABox() const;
virtual FourCC GetPrimType() const;
virtual CRayCastResult CastRayInternal(const CInternalRayCastStructure&) const;
u32 GetTableIndex() const override;
zeus::CAABox CalculateAABox(const zeus::CTransform&) const override;
zeus::CAABox CalculateLocalAABox() const override;
FourCC GetPrimType() const override;
CRayCastResult CastRayInternal(const CInternalRayCastStructure&) const override;
const zeus::CAABox& GetBox() const { 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:
CCollidableOBBTree(const COBBTree* tree, const CMaterialList& material);
virtual ~CCollidableOBBTree() = default;
~CCollidableOBBTree() override = default;
void ResetTestStats() const;
void ResetTestStatsRecurse(const COBBTree::CNode&) const;
u32 GetTableIndex() const { return sTableIndex; }
zeus::CAABox CalculateAABox(const zeus::CTransform&) const;
zeus::CAABox CalculateLocalAABox() const;
FourCC GetPrimType() const;
CRayCastResult CastRayInternal(const CInternalRayCastStructure&) const;
u32 GetTableIndex() const override { return sTableIndex; }
zeus::CAABox CalculateAABox(const zeus::CTransform&) const override;
zeus::CAABox CalculateLocalAABox() const override;
FourCC GetPrimType() const override;
CRayCastResult CastRayInternal(const CInternalRayCastStructure&) const override;
};
} // namespace urde

12
Runtime/Collision/CCollidableOBBTreeGroup.hpp
View File

@ -25,14 +25,14 @@ class CCollidableOBBTreeGroup : public CCollisionPrimitive {
public:
CCollidableOBBTreeGroup(const CCollidableOBBTreeGroupContainer*, const CMaterialList&);
virtual ~CCollidableOBBTreeGroup() = default;
~CCollidableOBBTreeGroup() override = default;
void ResetTestStats() const;
virtual u32 GetTableIndex() const;
virtual zeus::CAABox CalculateAABox(const zeus::CTransform&) const;
virtual zeus::CAABox CalculateLocalAABox() const;
virtual FourCC GetPrimType() const;
virtual CRayCastResult CastRayInternal(const CInternalRayCastStructure&) const;
u32 GetTableIndex() const override;
zeus::CAABox CalculateAABox(const zeus::CTransform&) const override;
zeus::CAABox CalculateLocalAABox() const override;
FourCC GetPrimType() const override;
CRayCastResult CastRayInternal(const CInternalRayCastStructure&) const override;
static const Type& GetType();
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; }
zeus::CSphere Transform(const zeus::CTransform& xf) const;
virtual u32 GetTableIndex() const;
virtual zeus::CAABox CalculateAABox(const zeus::CTransform&) const;
virtual zeus::CAABox CalculateLocalAABox() const;
virtual FourCC GetPrimType() const;
virtual CRayCastResult CastRayInternal(const CInternalRayCastStructure&) const;
u32 GetTableIndex() const override;
zeus::CAABox CalculateAABox(const zeus::CTransform&) const override;
zeus::CAABox CalculateLocalAABox() const override;
FourCC GetPrimType() const override;
CRayCastResult CastRayInternal(const CInternalRayCastStructure&) const override;
static const Type& GetType() { return sType; }
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, bool, float, float, std::string_view name);
void Accept(IVisitor& visitor);
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&);
CHealthInfo* HealthInfo(CStateManager&);
const CDamageVulnerability* GetDamageVulnerability() const;
void Accept(IVisitor& visitor) override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
CHealthInfo* HealthInfo(CStateManager&) override;
const CDamageVulnerability* GetDamageVulnerability() const override;
const CDamageVulnerability* GetDamageVulnerability(const zeus::CVector3f&, const zeus::CVector3f&,
const CDamageInfo&) const;
void OnScanStateChanged(EScanState, CStateManager&);
const CDamageInfo&) const override;
void OnScanStateChanged(EScanState, CStateManager&) override;
void Touch(CActor&, CStateManager&);
zeus::CVector3f GetOrbitPosition(const CStateManager&) const;
const CCollisionPrimitive* GetCollisionPrimitive() const;
void Touch(CActor&, CStateManager&) override;
zeus::CVector3f GetOrbitPosition(const CStateManager&) const override;
const CCollisionPrimitive* GetCollisionPrimitive() const override;
EWeaponCollisionResponseTypes GetCollisionResponseType(const zeus::CVector3f&, const zeus::CVector3f&,
const CWeaponMode&, EProjectileAttrib) const;
const CWeaponMode&, EProjectileAttrib) const override;
void SetWeaponCollisionResponseType(EWeaponCollisionResponseTypes type) { x300_responseType = type; }
zeus::CTransform GetPrimitiveTransform() const;
std::optional<zeus::CAABox> GetTouchBounds() const;
zeus::CTransform GetPrimitiveTransform() const override;
std::optional<zeus::CAABox> GetTouchBounds() const override;
void SetDamageVulnerability(const CDamageVulnerability& vuln);
const zeus::CVector3f& GetBoxSize() const { return x260_boxSize; }
TUniqueId GetOwnerId() const { return x25c_owner; }
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; }
float GetSphereRadius() const { return x288_sphereRadius; }
};

87
Runtime/Graphics/CBooRenderer.hpp
View File

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

2
Runtime/Graphics/IWeaponRenderer.hpp
View File

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

2
Runtime/MP1/CAudioStateWin.hpp
View File

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

6
Runtime/MP1/CCredits.hpp
View File

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

4
Runtime/MP1/CFrontEndUI.hpp
View File

@ -379,12 +379,12 @@ public:
void StartStateTransition(EScreen screen);
void CompleteStateTransition();
void HandleDebugMenuReturnValue(CGameDebug::EReturnValue val, CArchitectureQueue& queue);
void Draw() const;
void Draw() const override;
void UpdateMovies(float dt);
bool PumpMovieLoad();
void ProcessUserInput(const CFinalInput& input, 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

38
Runtime/MP1/CInventoryScreen.hpp
View File

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

30
Runtime/MP1/CLogBookScreen.hpp
View File

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

12
Runtime/MP1/CMFGame.hpp
View File

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

8
Runtime/MP1/CMainFlow.hpp
View File

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

28
Runtime/MP1/COptionsScreen.hpp
View File

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

2
Runtime/MP1/CPreFrontEnd.hpp
View File

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

6
Runtime/MP1/CSlideShow.hpp
View File

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

2
Runtime/MP1/CStateSetterFlow.hpp
View File

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

20
Runtime/MP1/MP1.hpp
View File

@ -269,12 +269,12 @@ public:
// int RsMain(int argc, const boo::SystemChar* argv[]);
void Init(const hecl::Runtime::FileStoreManager& storeMgr, hecl::CVarManager* cvarManager, boo::IWindow* window,
boo::IAudioVoiceEngine* voiceEngine, amuse::IBackendVoiceAllocator& backend);
void WarmupShaders();
bool Proc();
void Draw();
void Shutdown();
boo::IWindow* GetMainWindow() const;
boo::IAudioVoiceEngine* voiceEngine, amuse::IBackendVoiceAllocator& backend) override;
void WarmupShaders() override;
bool Proc() override;
void Draw() override;
void Shutdown() override;
boo::IWindow* GetMainWindow() const override;
void MemoryCardInitializePump();
@ -294,14 +294,14 @@ public:
static void EnsureWorldPaksReady();
static void EnsureWorldPakReady(CAssetId mlvl);
EFlowState GetFlowState() const { return x12c_flowState; }
void SetFlowState(EFlowState s) { x12c_flowState = s; }
EFlowState GetFlowState() const override { return x12c_flowState; }
void SetFlowState(EFlowState s) override { x12c_flowState = s; }
void SetX30(bool v) { x160_30_ = v; }
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 Give(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 ListWorlds(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;
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 CDamageVulnerability&, const CActorParameters&, CAssetId, const CDamageInfo&, bool);
void Accept(IVisitor& visitor);
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&);
void Think(float, CStateManager&);
void DoUserAnimEvent(CStateManager&, const CInt32POINode&, EUserEventType, float dt);
void Accept(IVisitor& visitor) override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void Think(float, CStateManager&) override;
void DoUserAnimEvent(CStateManager&, const CInt32POINode&, EUserEventType, float dt) override;
CFlameThrower* CreateFlameThrower(std::string_view, CStateManager&);
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,
CAssetId, bool, bool);
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&);
void Render(const CStateManager&) const;
void AddToRenderer(const zeus::CFrustum& frustum, const CStateManager& mgr) const;
void Think(float, CStateManager&);
void DoUserAnimEvent(CStateManager& mgr, const CInt32POINode& node, EUserEventType type, float dt);
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void Render(const CStateManager&) const override;
void AddToRenderer(const zeus::CFrustum& frustum, const CStateManager& mgr) const override;
void Think(float, CStateManager&) override;
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&,
const CWeaponMode& wMode, EProjectileAttrib) const {
const CWeaponMode& wMode, EProjectileAttrib) const override {
return GetDamageVulnerability()->WeaponHits(wMode, false) ? EWeaponCollisionResponseTypes::AtomicAlpha
: EWeaponCollisionResponseTypes::AtomicAlphaReflect;
}
bool Leash(CStateManager& mgr, float);
bool AggressionCheck(CStateManager&, float);
void CollidedWith(TUniqueId, const CCollisionInfoList&, CStateManager&);
void Patrol(CStateManager&, EStateMsg, float);
void Attack(CStateManager&, EStateMsg, float);
bool Leash(CStateManager& mgr, float) override;
bool AggressionCheck(CStateManager&, float) override;
void CollidedWith(TUniqueId, const CCollisionInfoList&, CStateManager&) override;
void Patrol(CStateManager&, EStateMsg, float) override;
void Attack(CStateManager&, EStateMsg, float) override;
CProjectileInfo* GetProjectileInfo() { return &x668_bombProjectile; }
CProjectileInfo* GetProjectileInfo() override { return &x668_bombProjectile; }
};
} // 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,
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&);
const CDamageVulnerability* GetDamageVulnerability() const;
void Think(float, CStateManager&) override;
const CDamageVulnerability* GetDamageVulnerability() const override;
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
: EWeaponCollisionResponseTypes::AtomicBetaReflect;
}
void Death(CStateManager&, const zeus::CVector3f&, EScriptObjectState);
void Death(CStateManager&, const zeus::CVector3f&, EScriptObjectState) override;
static bool IsPlayerBeamChargedEnough(const CStateManager& mgr);
};
} // 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&&,
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);
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; }
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,
const CWeaponMode& wMode, EProjectileAttrib attrib) const {
const CWeaponMode& wMode,
EProjectileAttrib attrib) const override {
if (wMode.GetType() == EWeaponType::Ice)
return EWeaponCollisionResponseTypes::None;
if (x56c_shellState != EShellState::Destroyed)
@ -212,110 +213,110 @@ public:
return CPatterned::GetCollisionResponseType(v1, v2, wMode, attrib);
}
const CDamageVulnerability* GetDamageVulnerability() const {
const CDamageVulnerability* GetDamageVulnerability() const override {
return &CDamageVulnerability::ReflectVulnerabilty();
}
const CDamageVulnerability* GetDamageVulnerability(const zeus::CVector3f&, const zeus::CVector3f&,
const CDamageInfo&) const {
const CDamageInfo&) const override {
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,
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)
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,
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)
return true;
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);
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;
}
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;
}
CProjectileInfo* GetProjectileInfo() { return &x958_iceProjectile; }
CProjectileInfo* GetProjectileInfo() override { return &x958_iceProjectile; }
};
} // namespace urde::MP1

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

@ -58,61 +58,63 @@ public:
const CDamageVulnerability& tailVuln, const CActorParameters& aParams,
const std::optional<CStaticRes>& tailModel);
void Accept(IVisitor& visitor);
void Think(float dt, CStateManager& mgr);
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId sender, CStateManager& mgr);
void PreRender(CStateManager& mgr, const zeus::CFrustum& frustum);
void Render(const CStateManager& mgr) const;
void Accept(IVisitor& visitor) override;
void Think(float dt, CStateManager& mgr) override;
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId sender, CStateManager& mgr) override;
void PreRender(CStateManager& mgr, const zeus::CFrustum& frustum) override;
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 CDamageInfo& dInfo) const;
zeus::CVector3f GetOrbitPosition(const CStateManager&) const;
zeus::CVector3f GetAimPosition(const CStateManager& mgr, float) const;
const CDamageInfo& dInfo) const override;
zeus::CVector3f GetOrbitPosition(const CStateManager&) const override;
zeus::CVector3f GetAimPosition(const CStateManager& mgr, float) const override;
EWeaponCollisionResponseTypes GetCollisionResponseType(const zeus::CVector3f& pos, const zeus::CVector3f& dir,
const CWeaponMode& wMode, EProjectileAttrib attribs) const;
void DoUserAnimEvent(CStateManager&, const CInt32POINode&, EUserEventType, float dt);
void CollidedWith(TUniqueId, const CCollisionInfoList&, CStateManager& mgr);
void Death(CStateManager& mgr, const zeus::CVector3f& direction, EScriptObjectState state);
void TakeDamage(const zeus::CVector3f& direction, float magnitude);
bool IsListening() const;
zeus::CVector3f GetOrigin(const CStateManager& mgr, const CTeamAiRole& role, const zeus::CVector3f& aimPos) const;
const CWeaponMode& wMode,
EProjectileAttrib attribs) const override;
void DoUserAnimEvent(CStateManager&, const CInt32POINode&, EUserEventType, float dt) override;
void CollidedWith(TUniqueId, const CCollisionInfoList&, CStateManager& mgr) override;
void Death(CStateManager& mgr, const zeus::CVector3f& direction, EScriptObjectState state) override;
void TakeDamage(const zeus::CVector3f& direction, float magnitude) override;
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 PathFind(CStateManager& mgr, EStateMsg msg, float dt);
void TargetPlayer(CStateManager&, EStateMsg msg, float dt);
void Generate(CStateManager&, EStateMsg msg, float dt);
void Deactivate(CStateManager&, EStateMsg msg, float dt);
void Attack(CStateManager&, EStateMsg msg, float dt);
void JumpBack(CStateManager&, EStateMsg msg, float dt);
void DoubleSnap(CStateManager&, EStateMsg msg, float dt);
void Shuffle(CStateManager&, EStateMsg msg, float dt);
void TurnAround(CStateManager&, EStateMsg msg, float dt);
void Skid(CStateManager&, EStateMsg msg, float dt);
void Taunt(CStateManager&, EStateMsg msg, float dt);
void Retreat(CStateManager&, EStateMsg msg, float dt);
void FollowPattern(CStateManager&, EStateMsg msg, float dt) override;
void PathFind(CStateManager& mgr, EStateMsg msg, float dt) override;
void TargetPlayer(CStateManager&, EStateMsg msg, float dt) override;
void Generate(CStateManager&, EStateMsg msg, float dt) override;
void Deactivate(CStateManager&, EStateMsg msg, float dt) override;
void Attack(CStateManager&, EStateMsg msg, float dt) override;
void JumpBack(CStateManager&, EStateMsg msg, float dt) override;
void DoubleSnap(CStateManager&, EStateMsg msg, float dt) override;
void Shuffle(CStateManager&, EStateMsg msg, float dt) override;
void TurnAround(CStateManager&, EStateMsg msg, float dt) override;
void Skid(CStateManager&, EStateMsg msg, float dt) override;
void Taunt(CStateManager&, EStateMsg msg, float dt) override;
void Retreat(CStateManager&, EStateMsg msg, float dt) override;
bool InAttackPosition(CStateManager&, float arg);
bool PathShagged(CStateManager&, float arg);
bool InRange(CStateManager&, float arg);
bool PatternOver(CStateManager&, float arg);
bool HasAttackPattern(CStateManager&, float arg);
bool AnimOver(CStateManager&, float arg);
bool ShouldAttack(CStateManager&, float arg);
bool ShouldDoubleSnap(CStateManager&, float arg);
bool ShouldTurn(CStateManager&, float arg);
bool HitSomething(CStateManager&, float arg);
bool ShouldJumpBack(CStateManager&, float arg);
bool Stuck(CStateManager&, float arg);
bool NoPathNodes(CStateManager&, float arg);
bool ShouldTaunt(CStateManager&, float arg);
bool ShotAt(CStateManager&, float arg);
bool InAttackPosition(CStateManager&, float arg) override;
bool PathShagged(CStateManager&, float arg) override;
bool InRange(CStateManager&, float arg) override;
bool PatternOver(CStateManager&, float arg) override;
bool HasAttackPattern(CStateManager&, float arg) override;
bool AnimOver(CStateManager&, float arg) override;
bool ShouldAttack(CStateManager&, float arg) override;
bool ShouldDoubleSnap(CStateManager&, float arg) override;
bool ShouldTurn(CStateManager&, float arg) override;
bool HitSomething(CStateManager&, float arg) override;
bool ShouldJumpBack(CStateManager&, float arg) override;
bool Stuck(CStateManager&, float arg) override;
bool NoPathNodes(CStateManager&, float arg) override;
bool ShouldTaunt(CStateManager&, float arg) override;
bool ShotAt(CStateManager&, float arg) override;
void Burn(float duration, float damage);
void Shock(CStateManager& mgr, float duration, float damage);
void Burn(float duration, float damage) override;
void Shock(CStateManager& mgr, float duration, float damage) override;
CPathFindSearch* GetSearchPath();
float GetGravityConstant() const;
CPathFindSearch* GetSearchPath() override;
float GetGravityConstant() const override;
};
} // namespace MP1
} // 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 CDamageInfo&, const CDamageInfo&, CAssetId, CAssetId, CAssetId, float, CAssetId, u32);
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&);
void Think(float dt, CStateManager& mgr);
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void Think(float dt, CStateManager& mgr) override;
void DoUserAnimEvent(CStateManager& mgr, const CInt32POINode& node, EUserEventType type, float dt);
void Render(const CStateManager& mgr) const;
void Touch(CActor&, CStateManager&) {}
CProjectileInfo* GetProjectileInfo() { return &x590_projectileInfo; }
void Render(const CStateManager& mgr) const override;
void Touch(CActor&, CStateManager&) override {}
CProjectileInfo* GetProjectileInfo() override { return &x590_projectileInfo; }
bool ShouldAttack(CStateManager&, float);
bool ShouldTurn(CStateManager&, float);
bool Leash(CStateManager&, float) { return x5c0_ < x3d0_playerLeashTime; }
void Active(CStateManager&, EStateMsg, float);
void InActive(CStateManager&, EStateMsg, float);
void BulbAttack(CStateManager&, EStateMsg, float);
void PodAttack(CStateManager&, EStateMsg, float);
bool ShouldAttack(CStateManager&, float) override;
bool ShouldTurn(CStateManager&, float) override;
bool Leash(CStateManager&, float) override { return x5c0_ < x3d0_playerLeashTime; }
void Active(CStateManager&, EStateMsg, float) override;
void InActive(CStateManager&, EStateMsg, float) override;
void BulbAttack(CStateManager&, EStateMsg, float) override;
void PodAttack(CStateManager&, EStateMsg, float) override;
};
} // 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,
u32, CAssetId);
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&);
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
};
} // 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,
u32 anim3, u32 beamSfx, bool attackDisabled, const CActorParameters& actParms);
void Accept(IVisitor& visitor);
void PreRender(CStateManager&, const zeus::CFrustum&);
void Touch(CActor&, CStateManager&){};
void Death(CStateManager&, const zeus::CVector3f&, EScriptObjectState);
void Accept(IVisitor& visitor) override;
void PreRender(CStateManager&, const zeus::CFrustum&) override;
void Touch(CActor&, CStateManager&) override {}
void Death(CStateManager&, const zeus::CVector3f&, EScriptObjectState) override;
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager& mgr);
void DoUserAnimEvent(CStateManager&, const CInt32POINode&, EUserEventType, float);
void Think(float, CStateManager&);
void Flinch(CStateManager&, EStateMsg, float);
void Active(CStateManager&, EStateMsg, float);
void InActive(CStateManager&, EStateMsg, float);
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager& mgr) override;
void DoUserAnimEvent(CStateManager&, const CInt32POINode&, EUserEventType, float) override;
void Think(float, CStateManager&) override;
void Flinch(CStateManager&, EStateMsg, float) override;
void Active(CStateManager&, EStateMsg, float) override;
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 ShouldFire(CStateManager&, float) { return !x60c_27_attackDisabled; }
bool ShouldAttack(CStateManager&, float) override { return x60c_26_alert; }
bool ShouldFire(CStateManager&, float) override { return !x60c_27_attackDisabled; }
};
} // namespace urde::MP1

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

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

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

@ -45,9 +45,9 @@ class CFlaahgraRenderer : public CActor {
public:
CFlaahgraRenderer(TUniqueId, TUniqueId, std::string_view, const CEntityInfo&, const zeus::CTransform&);
void AddToRenderer(const zeus::CFrustum&, const CStateManager&) const;
void Accept(IVisitor&);
std::optional<zeus::CAABox> GetTouchBounds() const { return {}; }
void AddToRenderer(const zeus::CFrustum&, const CStateManager&) const override;
void Accept(IVisitor&) override;
std::optional<zeus::CAABox> GetTouchBounds() const override { return {}; }
};
class CFlaahgraPlants : public CActor {
@ -62,12 +62,12 @@ public:
CFlaahgraPlants(const TToken<CGenDescription>&, const CActorParameters&, TUniqueId, TAreaId, TUniqueId,
const zeus::CTransform&, const CDamageInfo&, const zeus::CVector3f&);
void Accept(IVisitor&);
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&);
void Think(float, CStateManager&);
void AddToRenderer(const zeus::CFrustum&, const CStateManager&) const;
std::optional<zeus::CAABox> GetTouchBounds() const { return x110_aabox; }
void Touch(CActor&, CStateManager&);
void Accept(IVisitor&) override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void Think(float, CStateManager&) override;
void AddToRenderer(const zeus::CFrustum&, const CStateManager&) const override;
std::optional<zeus::CAABox> GetTouchBounds() const override { return x110_aabox; }
void Touch(CActor&, CStateManager&) override;
};
class CFlaahgra : public CPatterned {
@ -186,44 +186,44 @@ public:
CFlaahgra(TUniqueId, std::string_view, const CEntityInfo&, const zeus::CTransform&, const CAnimRes&,
const CPatternedInfo&, const CActorParameters&, const CFlaahgraData&);
void Think(float, CStateManager&);
void PreThink(float, CStateManager&);
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&);
void AddToRenderer(const zeus::CFrustum&, const CStateManager&) const;
bool CanRenderUnsorted(const CStateManager&) const { return true; }
zeus::CVector3f GetAimPosition(const CStateManager&, float) const { return x820_; }
void Death(CStateManager&, const zeus::CVector3f&, EScriptObjectState);
void DoUserAnimEvent(CStateManager&, const CInt32POINode&, EUserEventType, float dt);
void Think(float, CStateManager&) override;
void PreThink(float, CStateManager&) override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void AddToRenderer(const zeus::CFrustum&, const CStateManager&) const override;
bool CanRenderUnsorted(const CStateManager&) const override { return true; }
zeus::CVector3f GetAimPosition(const CStateManager&, float) const override { return x820_; }
void Death(CStateManager&, const zeus::CVector3f&, EScriptObjectState) override;
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 AIStage(CStateManager&, float arg) { return x780_ == u32(arg); }
bool HitSomething(CStateManager&, float arg) { return x7d0_ > 0.f; }
bool OffLine(CStateManager&, float) { return (x8e5_29_ && x8e5_28_); }
bool ShouldTurn(CStateManager&, float);
bool ShouldAttack(CStateManager&, float);
bool BreakAttack(CStateManager&, float) { return x7d4_ >= x56c_.xc_ && !x8e4_29_getup; }
bool IsDizzy(CStateManager&, float) {
bool AnimOver(CStateManager&, float) override { return x568_ == 4; }
bool AIStage(CStateManager&, float arg) override { return x780_ == u32(arg); }
bool HitSomething(CStateManager&, float arg) override { return x7d0_ > 0.f; }
bool OffLine(CStateManager&, float) override { return (x8e5_29_ && x8e5_28_); }
bool ShouldTurn(CStateManager&, float) override;
bool ShouldAttack(CStateManager&, float) override;
bool BreakAttack(CStateManager&, float) override { return x7d4_ >= x56c_.xc_ && !x8e4_29_getup; }
bool IsDizzy(CStateManager&, float) override {
return x450_bodyController->GetBodyStateInfo().GetCurrentStateId() == pas::EAnimationState::LoopReaction;
}
bool CoverCheck(CStateManager&, float);
bool CoverCheck(CStateManager&, float) override;
void FadeIn(CStateManager&, EStateMsg, float);
void FadeOut(CStateManager&, EStateMsg, float);
void TurnAround(CStateManager&, EStateMsg, float);
void GetUp(CStateManager&, EStateMsg, float);
void Growth(CStateManager&, EStateMsg, float);
void Generate(CStateManager&, EStateMsg, float);
void Faint(CStateManager&, EStateMsg, float);
void Dead(CStateManager&, EStateMsg, float);
void Attack(CStateManager&, EStateMsg, float);
void Dizzy(CStateManager&, EStateMsg, float);
void Suck(CStateManager&, EStateMsg, float);
void ProjectileAttack(CStateManager&, EStateMsg, float);
void Cover(CStateManager&, EStateMsg, float);
void SpecialAttack(CStateManager&, EStateMsg, float);
void Enraged(CStateManager&, EStateMsg, float);
void FadeIn(CStateManager&, EStateMsg, float) override;
void FadeOut(CStateManager&, EStateMsg, float) override;
void TurnAround(CStateManager&, EStateMsg, float) override;
void GetUp(CStateManager&, EStateMsg, float) override;
void Growth(CStateManager&, EStateMsg, float) override;
void Generate(CStateManager&, EStateMsg, float) override;
void Faint(CStateManager&, EStateMsg, float) override;
void Dead(CStateManager&, EStateMsg, float) override;
void Attack(CStateManager&, EStateMsg, float) override;
void Dizzy(CStateManager&, EStateMsg, float) override;
void Suck(CStateManager&, EStateMsg, float) override;
void ProjectileAttack(CStateManager&, EStateMsg, float) override;
void Cover(CStateManager&, EStateMsg, float) override;
void SpecialAttack(CStateManager&, EStateMsg, float) override;
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&&,
const CPatternedInfo&, const CActorParameters&);
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&);
void Think(float, CStateManager&);
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
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 AnimOver(CStateManager&, float) { return x568_ == 3; }
bool ShouldAttack(CStateManager&, float);
bool Inside(CStateManager&, float) override {
return x450_bodyController->GetLocomotionType() == pas::ELocomotionType::Crouch;
}
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 Attack(CStateManager&, EStateMsg, float);
void Retreat(CStateManager&, EStateMsg, float);
void InActive(CStateManager&, EStateMsg, float);
void Dead(CStateManager&, EStateMsg, float) override {
x450_bodyController->SetLocomotionType(pas::ELocomotionType::Crouch);
}
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&&,
const CPatternedInfo&, EColliderType, bool, const CActorParameters&, bool);
void Accept(IVisitor&);
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&);
void Think(float, CStateManager&);
void Render(const CStateManager&) const;
void Touch(CActor&, CStateManager&);
void DoUserAnimEvent(CStateManager&, const CInt32POINode&, EUserEventType, float dt);
void Death(CStateManager& mgr, const zeus::CVector3f& direction, EScriptObjectState state);
bool CanBeShot(const CStateManager&, int);
void Patrol(CStateManager&, EStateMsg, float);
void Attack(CStateManager&, EStateMsg, float);
void Shuffle(CStateManager&, EStateMsg, float);
void Taunt(CStateManager&, EStateMsg, float);
bool InPosition(CStateManager&, float);
bool HearShot(CStateManager&, float);
void Accept(IVisitor&) override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void Think(float, CStateManager&) override;
void Render(const CStateManager&) const override;
void Touch(CActor&, CStateManager&) override;
void DoUserAnimEvent(CStateManager&, const CInt32POINode&, EUserEventType, float dt) override;
void Death(CStateManager& mgr, const zeus::CVector3f& direction, EScriptObjectState state) override;
bool CanBeShot(const CStateManager&, int) override;
void Patrol(CStateManager&, EStateMsg, float) override;
void Attack(CStateManager&, EStateMsg, float) override;
void Shuffle(CStateManager&, EStateMsg, float) override;
void Taunt(CStateManager&, EStateMsg, float) override;
bool InPosition(CStateManager&, float) override;
bool HearShot(CStateManager&, float) override;
EFlickerBatState GetFlickerBatState() const { return x574_state; }
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,
const CPatternedInfo&, const CActorParameters&);
void Accept(IVisitor&);
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&);
void Think(float, CStateManager&);
void DoUserAnimEvent(CStateManager&, const CInt32POINode&, EUserEventType, float dt);
void Attack(CStateManager&, EStateMsg, float);
void Suck(CStateManager&, EStateMsg, float);
void Active(CStateManager&, EStateMsg, float);
void InActive(CStateManager&, EStateMsg, float);
void Flinch(CStateManager&, EStateMsg, float);
bool ShouldAttack(CStateManager&, float) { return x330_stateMachineState.GetTime() > x5a8_attackDelay; }
bool ShouldSpecialAttack(CStateManager& mgr, float) { return ClosestToPlayer(mgr); }
bool InAttackPosition(CStateManager&, float);
bool InDetectionRange(CStateManager&, float);
void Accept(IVisitor&) override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void Think(float, CStateManager&) override;
void DoUserAnimEvent(CStateManager&, const CInt32POINode&, EUserEventType, float dt) override;
void Attack(CStateManager&, EStateMsg, float) override;
void Suck(CStateManager&, EStateMsg, float) override;
void Active(CStateManager&, EStateMsg, float) override;
void InActive(CStateManager&, EStateMsg, float) override;
void Flinch(CStateManager&, EStateMsg, float) override;
bool ShouldAttack(CStateManager&, float) override { return x330_stateMachineState.GetTime() > x5a8_attackDelay; }
bool ShouldSpecialAttack(CStateManager& mgr, float) override { return ClosestToPlayer(mgr); }
bool InAttackPosition(CStateManager&, float) override;
bool InDetectionRange(CStateManager&, float) override;
};
} // 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 CMagdoliteData&, float, float, float);
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&);
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
};
} // 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 CActorParameters&);
void Accept(IVisitor& visitor);
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&);
void Think(float, CStateManager&);
void Accept(IVisitor& visitor) override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void Think(float, CStateManager&) override;
void Touch(CActor&, CStateManager&);
void CollidedWith(TUniqueId, const CCollisionInfoList&, CStateManager&);
void ThinkAboutMove(float){};
bool Delay(CStateManager&, float) { return x330_stateMachineState.GetTime() > x568_delay; }
void Explode(CStateManager&, EStateMsg, float);
void Flee(CStateManager&, EStateMsg, float);
void Dead(CStateManager&, EStateMsg, float);
void Attack(CStateManager&, EStateMsg, float);
void Halt(CStateManager&, EStateMsg, float);
void Active(CStateManager&, EStateMsg, float);
void InActive(CStateManager&, EStateMsg, float);
bool InRange(CStateManager&, float);
bool ShouldAttack(CStateManager&, float);
void Touch(CActor&, CStateManager&) override;
void CollidedWith(TUniqueId, const CCollisionInfoList&, CStateManager&) override;
void ThinkAboutMove(float) override {}
bool Delay(CStateManager&, float) override { return x330_stateMachineState.GetTime() > x568_delay; }
void Explode(CStateManager&, EStateMsg, float) override;
void Flee(CStateManager&, EStateMsg, float) override;
void Dead(CStateManager&, EStateMsg, float) override;
void Attack(CStateManager&, EStateMsg, float) override;
void Halt(CStateManager&, EStateMsg, float) override;
void Active(CStateManager&, EStateMsg, float) override;
void InActive(CStateManager&, EStateMsg, float) override;
bool InRange(CStateManager&, float) override;
bool ShouldAttack(CStateManager&, float) override;
};
} // 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,
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);
void Accept(IVisitor& visitor);
void Accept(IVisitor& visitor) override;
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 beamTextureId, CAssetId beamGlowTextureId);
void Accept(IVisitor& visitor);
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager&);
void Think(float dt, CStateManager& mgr);
void AddToRenderer(const zeus::CFrustum&, const CStateManager&) const;
void OnScanStateChanged(EScanState, CStateManager&);
CProjectileInfo* GetProjectileInfo() { return &x5ac_projectileInfo; }
zeus::CAABox GetSortingBounds(const CStateManager&) const {
void Accept(IVisitor& visitor) override;
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager&) override;
void Think(float dt, CStateManager& mgr) override;
void AddToRenderer(const zeus::CFrustum&, const CStateManager&) const override;
void OnScanStateChanged(EScanState, CStateManager&) override;
CProjectileInfo* GetProjectileInfo() override { return &x5ac_projectileInfo; }
zeus::CAABox GetSortingBounds(const CStateManager&) const override {
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);
}
std::optional<zeus::CAABox> GetTouchBounds() const { return {}; }
void DoUserAnimEvent(CStateManager&, const CInt32POINode&, EUserEventType, float dt);
void Generate(CStateManager&, EStateMsg, float);
void Attack(CStateManager&, EStateMsg, float);
void Patrol(CStateManager&, EStateMsg, float);
bool ShouldTurn(CStateManager&, float);
bool ShouldAttack(CStateManager&, float);
bool AIStage(CStateManager&, float);
bool AnimOver(CStateManager&, float);
bool InAttackPosition(CStateManager&, float);
std::optional<zeus::CAABox> GetTouchBounds() const override { return {}; }
void DoUserAnimEvent(CStateManager&, const CInt32POINode&, EUserEventType, float dt) override;
void Generate(CStateManager&, EStateMsg, float) override;
void Attack(CStateManager&, EStateMsg, float) override;
void Patrol(CStateManager&, EStateMsg, float) override;
bool ShouldTurn(CStateManager&, float) override;
bool ShouldAttack(CStateManager&, float) override;
bool AIStage(CStateManager&, float) override;
bool AnimOver(CStateManager&, float) override;
bool InAttackPosition(CStateManager&, float) override;
};
} // 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,
const CActorParameters& aParams);
void Accept(IVisitor&);
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&);
void PreThink(float, CStateManager&);
void Think(float dt, CStateManager& mgr);
void Render(const CStateManager&) const;
const CDamageVulnerability* GetDamageVulnerability() const;
CDamageInfo GetContactDamage() const;
void Touch(CActor& actor, CStateManager&);
zeus::CVector3f GetAimPosition(const CStateManager&, float) const;
void CollidedWith(TUniqueId uid, const CCollisionInfoList&, CStateManager&);
void Death(CStateManager& mgr, const zeus::CVector3f& direction, EScriptObjectState state);
void Patrol(CStateManager&, EStateMsg msg, float dt);
void PathFind(CStateManager&, EStateMsg msg, float dt);
void TargetPlayer(CStateManager&, EStateMsg msg, float dt);
void TargetPatrol(CStateManager&, EStateMsg msg, float dt);
void Halt(CStateManager&, EStateMsg, float);
void Run(CStateManager&, EStateMsg, float);
void Generate(CStateManager&, EStateMsg, float);
void Deactivate(CStateManager&, EStateMsg, float);
void Attack(CStateManager&, EStateMsg, float);
void Crouch(CStateManager&, EStateMsg, float);
void GetUp(CStateManager&, EStateMsg, float);
void TelegraphAttack(CStateManager&, EStateMsg, float);
void Jump(CStateManager&, EStateMsg, float);
void Retreat(CStateManager&, EStateMsg, float);
bool AnimOver(CStateManager&, float);
bool ShouldAttack(CStateManager&, float);
bool HitSomething(CStateManager&, float);
bool Stuck(CStateManager&, float);
bool Landed(CStateManager&, float);
bool AttackOver(CStateManager&, float);
bool ShotAt(CStateManager&, float);
void MassiveDeath(CStateManager&);
void MassiveFrozenDeath(CStateManager&);
void ThinkAboutMove(float);
bool IsOnGround() const;
void Accept(IVisitor&) override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void PreThink(float, CStateManager&) override;
void Think(float dt, CStateManager& mgr) override;
void Render(const CStateManager&) const override;
const CDamageVulnerability* GetDamageVulnerability() const override;
CDamageInfo GetContactDamage() const override;
void Touch(CActor& actor, CStateManager&) override;
zeus::CVector3f GetAimPosition(const CStateManager&, float) const override;
void CollidedWith(TUniqueId uid, const CCollisionInfoList&, CStateManager&) override;
void Death(CStateManager& mgr, const zeus::CVector3f& direction, EScriptObjectState state) override;
void Patrol(CStateManager&, EStateMsg msg, float dt) override;
void PathFind(CStateManager&, EStateMsg msg, float dt) override;
void TargetPlayer(CStateManager&, EStateMsg msg, float dt) override;
void TargetPatrol(CStateManager&, EStateMsg msg, float dt) override;
void Halt(CStateManager&, EStateMsg, float) override;
void Run(CStateManager&, EStateMsg, float) override;
void Generate(CStateManager&, EStateMsg, float) override;
void Deactivate(CStateManager&, EStateMsg, float) override;
void Attack(CStateManager&, EStateMsg, float) override;
void Crouch(CStateManager&, EStateMsg, float) override;
void GetUp(CStateManager&, EStateMsg, float) override;
void TelegraphAttack(CStateManager&, EStateMsg, float) override;
void Jump(CStateManager&, EStateMsg, float) override;
void Retreat(CStateManager&, EStateMsg, float) override;
bool AnimOver(CStateManager&, float) override;
bool ShouldAttack(CStateManager&, float) override;
bool HitSomething(CStateManager&, float) override;
bool Stuck(CStateManager&, float) override;
bool Landed(CStateManager&, float) override;
bool AttackOver(CStateManager&, float) override;
bool ShotAt(CStateManager&, float) override;
void MassiveDeath(CStateManager&) override;
void MassiveFrozenDeath(CStateManager&) override;
void ThinkAboutMove(float) override;
bool IsOnGround() const override;
virtual void UpdateWalkerAnimation(CStateManager&, float);
};
} // 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 CActorParameters&, CAssetId, const CDamageInfo&);
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager& mgr);
void PreThink(float, CStateManager&);
void Think(float, CStateManager&);
void Render(const CStateManager&) const;
void Touch(CActor&, CStateManager&);
void FluidFXThink(EFluidState, CScriptWater&, CStateManager&);
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId uid, CStateManager& mgr) override;
void PreThink(float, CStateManager&) override;
void Think(float, CStateManager&) override;
void Render(const CStateManager&) const override;
void Touch(CActor&, CStateManager&) override;
void FluidFXThink(EFluidState, CScriptWater&, CStateManager&) override;
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)
return;
CPatterned::KnockBack(dir, mgr, dInfo, type, inDeferred, dt);
}
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;
}
void DoUserAnimEvent(CStateManager&, const CInt32POINode&, EUserEventType, float);
void CollidedWith(TUniqueId uid, const CCollisionInfoList& colList, CStateManager& mgr) {
void DoUserAnimEvent(CStateManager&, const CInt32POINode&, EUserEventType, float) override;
void CollidedWith(TUniqueId uid, const CCollisionInfoList& colList, CStateManager& mgr) override {
if (x5c8_ == 2)
return;
CPatterned::CollidedWith(uid, colList, mgr);
}
const CCollisionPrimitive* GetCollisionPrimitive() const { return &x5a0_; }
const CCollisionPrimitive* GetCollisionPrimitive() const override { return &x5a0_; }
zeus::CAABox CalculateBoundingBox() const;
CProjectileInfo* GetProjectileInfo() { return &x5ec_projectileInfo; }
CProjectileInfo* GetProjectileInfo() override { return &x5ec_projectileInfo; }
bool InAttackPosition(CStateManager&, float) { return x568_ >= x570_; }
bool ShouldAttack(CStateManager&, float) { return x568_ >= x574_; }
bool ShouldTurn(CStateManager&, float);
bool AnimOver(CStateManager&, float) { return x5cc_ == 2; }
bool InAttackPosition(CStateManager&, float) override { return x568_ >= x570_; }
bool ShouldAttack(CStateManager&, float) override { return x568_ >= x574_; }
bool ShouldTurn(CStateManager&, float) override;
bool AnimOver(CStateManager&, float) override { return x5cc_ == 2; }
void InActive(CStateManager&, EStateMsg, float);
void Active(CStateManager&, EStateMsg, float);
void Run(CStateManager&, EStateMsg, float);
void TurnAround(CStateManager&, EStateMsg, float);
void GetUp(CStateManager&, EStateMsg, float);
void Attack(CStateManager&, EStateMsg, float);
void InActive(CStateManager&, EStateMsg, float) override;
void Active(CStateManager&, EStateMsg, float) override;
void Run(CStateManager&, EStateMsg, float) override;
void TurnAround(CStateManager&, EStateMsg, float) override;
void GetUp(CStateManager&, EStateMsg, float) override;
void Attack(CStateManager&, EStateMsg, float) override;
};
} // namespace urde::MP1

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

@ -45,30 +45,32 @@ public:
float spotPlayerWaitTime, const CDamageInfo& playerShootDamage, const CDamageInfo& dInfo2,
CAssetId dcln);
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&);
void Think(float dt, CStateManager& mgr);
void DoUserAnimEvent(CStateManager& mgr, const CInt32POINode& node, EUserEventType type, float dt);
std::optional<zeus::CAABox> GetTouchBounds() const;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void Think(float dt, CStateManager& mgr) override;
void DoUserAnimEvent(CStateManager& mgr, const CInt32POINode& node, EUserEventType type, float dt) override;
std::optional<zeus::CAABox> GetTouchBounds() const override;
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 Active(CStateManager&, EStateMsg, float);
void Suck(CStateManager&, EStateMsg, float);
void Attack(CStateManager&, EStateMsg, float);
void Crouch(CStateManager&, EStateMsg, float);
bool InAttackPosition(CStateManager&, float);
bool SpotPlayer(CStateManager&, float);
bool ShouldAttack(CStateManager&, float);
bool LostInterest(CStateManager&, float);
bool Inside(CStateManager&, float);
void InActive(CStateManager&, EStateMsg, float) override;
void Active(CStateManager&, EStateMsg, float) override;
void Suck(CStateManager&, EStateMsg, float) override;
void Attack(CStateManager&, EStateMsg, float) override;
void Crouch(CStateManager&, EStateMsg, float) override;
bool InAttackPosition(CStateManager&, float) override;
bool SpotPlayer(CStateManager&, float) override;
bool ShouldAttack(CStateManager&, float) override;
bool LostInterest(CStateManager&, float) override;
bool Inside(CStateManager&, float) override;
};
} // 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,
bool, bool, const CDamageInfo&, s16);
void Accept(IVisitor&);
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&);
void Think(float, CStateManager&);
std::optional<zeus::CAABox> GetTouchBounds() const;
void Touch(CActor&, CStateManager&);
void Death(CStateManager&, const zeus::CVector3f&, EScriptObjectState);
void Accept(IVisitor&) override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void Think(float, CStateManager&) override;
std::optional<zeus::CAABox> GetTouchBounds() const override;
void Touch(CActor&, CStateManager&) override;
void Death(CStateManager&, const zeus::CVector3f&, EScriptObjectState) override;
};
} // 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&,
float, float, float, float);
void Accept(IVisitor&);
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&);
void Think(float, CStateManager&);
void Render(const CStateManager&) const;
void DoUserAnimEvent(CStateManager& mgr, const CInt32POINode& node, EUserEventType type, float dt);
CProjectileInfo* GetProjectileInfo() { return &x6c0_projectileInfo; }
std::optional<zeus::CAABox> GetTouchBounds() const;
void Touch(CActor&, CStateManager&);
CPathFindSearch* GetSearchPath() { return &x5d8_searchPath; }
void Patrol(CStateManager&, EStateMsg, float);
void Active(CStateManager&, EStateMsg, float);
void Enraged(CStateManager&, EStateMsg, float);
void ProjectileAttack(CStateManager&, EStateMsg, float);
void Generate(CStateManager&, EStateMsg, float);
bool ShouldAttack(CStateManager&, float);
void MassiveDeath(CStateManager&);
void Accept(IVisitor&) override;
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void Think(float, CStateManager&) override;
void Render(const CStateManager&) const override;
void DoUserAnimEvent(CStateManager& mgr, const CInt32POINode& node, EUserEventType type, float dt) override;
CProjectileInfo* GetProjectileInfo() override { return &x6c0_projectileInfo; }
std::optional<zeus::CAABox> GetTouchBounds() const override;
void Touch(CActor&, CStateManager&) override;
CPathFindSearch* GetSearchPath() override { return &x5d8_searchPath; }
void Patrol(CStateManager&, EStateMsg, float) override;
void Active(CStateManager&, EStateMsg, float) override;
void Enraged(CStateManager&, EStateMsg, float) override;
void ProjectileAttack(CStateManager&, EStateMsg, float) override;
void Generate(CStateManager&, EStateMsg, float) override;
bool ShouldAttack(CStateManager&, float) override;
void MassiveDeath(CStateManager&) override;
};
} // namespace urde::MP1

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

@ -24,9 +24,9 @@ class CPirateRagDoll : public CRagDoll {
public:
CPirateRagDoll(CStateManager& mgr, CSpacePirate* sp, u16 thudSfx, u32 flags);
void PreRender(const zeus::CVector3f& v, CModelData& mData);
void Update(CStateManager& mgr, float dt, float waterTop);
void Prime(CStateManager& mgr, const zeus::CTransform& xf, CModelData& mData);
void PreRender(const zeus::CVector3f& v, CModelData& mData) override;
void Update(CStateManager& mgr, float dt, float waterTop) override;
void Prime(CStateManager& mgr, const zeus::CTransform& xf, CModelData& mData) override;
zeus::CVector3f& TorsoImpulse() { return x84_torsoImpulse; }
};
@ -249,96 +249,97 @@ public:
CSpacePirate(TUniqueId, std::string_view, const CEntityInfo&, const zeus::CTransform&, CModelData&&,
const CActorParameters&, const CPatternedInfo&, CInputStream&, u32);
void Accept(IVisitor& visitor);
void Think(float dt, CStateManager& mgr);
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId sender, CStateManager& mgr);
void PreRender(CStateManager& mgr, const zeus::CFrustum& frustum);
void Render(const CStateManager& mgr) const;
void Accept(IVisitor& visitor) override;
void Think(float dt, CStateManager& mgr) override;
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId sender, CStateManager& mgr) override;
void PreRender(CStateManager& mgr, const zeus::CFrustum& frustum) override;
void Render(const CStateManager& mgr) const override;
void CalculateRenderBounds();
void Touch(CActor& other, CStateManager& mgr);
zeus::CAABox GetSortingBounds(const CStateManager& mgr) const;
void DoUserAnimEvent(CStateManager& mgr, const CInt32POINode& node, EUserEventType type, float dt);
void Death(CStateManager& mgr, const zeus::CVector3f& direction, EScriptObjectState state);
void CalculateRenderBounds() override;
void Touch(CActor& other, CStateManager& mgr) override;
zeus::CAABox GetSortingBounds(const CStateManager& mgr) const override;
void DoUserAnimEvent(CStateManager& mgr, const CInt32POINode& node, EUserEventType type, float dt) override;
void Death(CStateManager& mgr, const zeus::CVector3f& direction, EScriptObjectState state) override;
void KnockBack(const zeus::CVector3f&, CStateManager&, const CDamageInfo& info, EKnockBackType type, bool inDeferred,
float magnitude);
bool IsListening() const;
bool Listen(const zeus::CVector3f&, EListenNoiseType);
zeus::CVector3f GetOrigin(const CStateManager& mgr, const CTeamAiRole& role, const zeus::CVector3f& aimPos) const;
float magnitude) override;
bool IsListening() const override;
bool Listen(const zeus::CVector3f&, EListenNoiseType) override;
zeus::CVector3f GetOrigin(const CStateManager& mgr, const CTeamAiRole& role,
const zeus::CVector3f& aimPos) const override;
void DetachActorFromPirate() { x7b4_attachedActor = kInvalidUniqueId; }
bool AttachActorToPirate(TUniqueId id);
void SetAttackTarget(TUniqueId id);
void Patrol(CStateManager&, EStateMsg, float);
void Dead(CStateManager&, EStateMsg, float);
void PathFind(CStateManager& mgr, EStateMsg msg, float dt);
void TargetPatrol(CStateManager&, EStateMsg, float);
void TargetCover(CStateManager&, EStateMsg, float);
void Halt(CStateManager&, EStateMsg, float);
void Run(CStateManager&, EStateMsg, float);
void Generate(CStateManager&, EStateMsg, float);
void Deactivate(CStateManager&, EStateMsg, float);
void Attack(CStateManager&, EStateMsg, float);
void JumpBack(CStateManager&, EStateMsg, float);
void DoubleSnap(CStateManager&, EStateMsg, float);
void Shuffle(CStateManager&, EStateMsg, float);
void TurnAround(CStateManager&, EStateMsg, float);
void Skid(CStateManager&, EStateMsg, float);
void CoverAttack(CStateManager&, EStateMsg, float);
void Crouch(CStateManager&, EStateMsg, float);
void GetUp(CStateManager&, EStateMsg, float);
void Taunt(CStateManager&, EStateMsg, float);
void Flee(CStateManager&, EStateMsg, float);
void Lurk(CStateManager&, EStateMsg, float);
void Jump(CStateManager&, EStateMsg, float);
void Dodge(CStateManager&, EStateMsg, float);
void Cover(CStateManager&, EStateMsg, float);
void Approach(CStateManager&, EStateMsg, float);
void WallHang(CStateManager&, EStateMsg, float);
void WallDetach(CStateManager&, EStateMsg, float);
void Enraged(CStateManager&, EStateMsg, float);
void SpecialAttack(CStateManager&, EStateMsg, float);
void Bounce(CStateManager&, EStateMsg, float);
void PathFindEx(CStateManager&, EStateMsg, float);
void Patrol(CStateManager&, EStateMsg, float) override;
void Dead(CStateManager&, EStateMsg, float) override;
void PathFind(CStateManager& mgr, EStateMsg msg, float dt) override;
void TargetPatrol(CStateManager&, EStateMsg, float) override;
void TargetCover(CStateManager&, EStateMsg, float) override;
void Halt(CStateManager&, EStateMsg, float) override;
void Run(CStateManager&, EStateMsg, float) override;
void Generate(CStateManager&, EStateMsg, float) override;
void Deactivate(CStateManager&, EStateMsg, float) override;
void Attack(CStateManager&, EStateMsg, float) override;
void JumpBack(CStateManager&, EStateMsg, float) override;
void DoubleSnap(CStateManager&, EStateMsg, float) override;
void Shuffle(CStateManager&, EStateMsg, float) override;
void TurnAround(CStateManager&, EStateMsg, float) override;
void Skid(CStateManager&, EStateMsg, float) override;
void CoverAttack(CStateManager&, EStateMsg, float) override;
void Crouch(CStateManager&, EStateMsg, float) override;
void GetUp(CStateManager&, EStateMsg, float) override;
void Taunt(CStateManager&, EStateMsg, float) override;
void Flee(CStateManager&, EStateMsg, float) override;
void Lurk(CStateManager&, EStateMsg, float) override;
void Jump(CStateManager&, EStateMsg, float) override;
void Dodge(CStateManager&, EStateMsg, float) override;
void Cover(CStateManager&, EStateMsg, float) override;
void Approach(CStateManager&, EStateMsg, float) override;
void WallHang(CStateManager&, EStateMsg, float) override;
void WallDetach(CStateManager&, EStateMsg, float) override;
void Enraged(CStateManager&, EStateMsg, float) override;
void SpecialAttack(CStateManager&, EStateMsg, float) override;
void Bounce(CStateManager&, EStateMsg, float) override;
void PathFindEx(CStateManager&, EStateMsg, float) override;
bool Leash(CStateManager&, float);
bool OffLine(CStateManager&, float);
bool Attacked(CStateManager&, float);
bool InRange(CStateManager&, float);
bool SpotPlayer(CStateManager&, float);
bool PatternOver(CStateManager&, float);
bool PatternShagged(CStateManager&, float);
bool AnimOver(CStateManager&, float);
bool ShouldAttack(CStateManager&, float);
bool ShouldJumpBack(CStateManager& mgr, float arg);
bool Stuck(CStateManager&, float);
bool Landed(CStateManager&, float);
bool HearShot(CStateManager&, float);
bool HearPlayer(CStateManager&, float);
bool CoverCheck(CStateManager&, float);
bool CoverFind(CStateManager&, float);
bool CoverBlown(CStateManager&, float);
bool CoverNearlyBlown(CStateManager&, float);
bool CoveringFire(CStateManager&, float);
bool LineOfSight(CStateManager&, float);
bool AggressionCheck(CStateManager&, float);
bool ShouldDodge(CStateManager&, float);
bool ShouldRetreat(CStateManager&, float);
bool ShouldCrouch(CStateManager&, float);
bool ShouldMove(CStateManager&, float);
bool ShotAt(CStateManager&, float);
bool HasTargetingPoint(CStateManager&, float);
bool ShouldWallHang(CStateManager&, float);
bool StartAttack(CStateManager&, float);
bool BreakAttack(CStateManager&, float);
bool ShouldStrafe(CStateManager& mgr, float arg);
bool ShouldSpecialAttack(CStateManager&, float);
bool LostInterest(CStateManager&, float);
bool BounceFind(CStateManager& mgr, float arg);
bool Leash(CStateManager&, float) override;
bool OffLine(CStateManager&, float) override;
bool Attacked(CStateManager&, float) override;
bool InRange(CStateManager&, float) override;
bool SpotPlayer(CStateManager&, float) override;
bool PatternOver(CStateManager&, float) override;
bool PatternShagged(CStateManager&, float) override;
bool AnimOver(CStateManager&, float) override;
bool ShouldAttack(CStateManager&, float) override;
bool ShouldJumpBack(CStateManager& mgr, float arg) override;
bool Stuck(CStateManager&, float) override;
bool Landed(CStateManager&, float) override;
bool HearShot(CStateManager&, float) override;
bool HearPlayer(CStateManager&, float) override;
bool CoverCheck(CStateManager&, float) override;
bool CoverFind(CStateManager&, float) override;
bool CoverBlown(CStateManager&, float) override;
bool CoverNearlyBlown(CStateManager&, float) override;
bool CoveringFire(CStateManager&, float) override;
bool LineOfSight(CStateManager&, float) override;
bool AggressionCheck(CStateManager&, float) override;
bool ShouldDodge(CStateManager&, float) override;
bool ShouldRetreat(CStateManager&, float) override;
bool ShouldCrouch(CStateManager&, float) override;
bool ShouldMove(CStateManager&, float) override;
bool ShotAt(CStateManager&, float) override;
bool HasTargetingPoint(CStateManager&, float) override;
bool ShouldWallHang(CStateManager&, float) override;
bool StartAttack(CStateManager&, float) override;
bool BreakAttack(CStateManager&, float) override;
bool ShouldStrafe(CStateManager& mgr, float arg) override;
bool ShouldSpecialAttack(CStateManager&, float) override;
bool LostInterest(CStateManager&, float) override;
bool BounceFind(CStateManager& mgr, float arg) override;
CPathFindSearch* GetSearchPath();
u8 GetModelAlphau8(const CStateManager& mgr) const;
float GetGravityConstant() const;
CProjectileInfo* GetProjectileInfo();
CPathFindSearch* GetSearchPath() override;
u8 GetModelAlphau8(const CStateManager& mgr) const override;
float GetGravityConstant() const override;
CProjectileInfo* GetProjectileInfo() override;
};
} // 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&&,
const CActorParameters&, const CPatternedInfo&, float, float, float, float);
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&);
void Think(float, CStateManager&);
zeus::CVector3f GetOrbitPosition(const CStateManager&) const;
zeus::CVector3f GetAimPosition(const CStateManager&, float) const;
bool AnimOver(CStateManager&, float) { return x5bc_ == 3; }
void Flinch(CStateManager&, EStateMsg, float);
bool Delay(CStateManager&, float);
bool InRange(CStateManager&, float);
bool HearPlayer(CStateManager&, float);
bool InDetectionRange(CStateManager&, float);
void Attack(CStateManager&, EStateMsg, float);
void TargetPatrol(CStateManager&, EStateMsg, float);
void Lurk(CStateManager&, EStateMsg, float);
void FadeOut(CStateManager&, EStateMsg, float);
void FadeIn(CStateManager&, EStateMsg, float);
void Patrol(CStateManager&, EStateMsg, float);
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void Think(float, CStateManager&) override;
zeus::CVector3f GetOrbitPosition(const CStateManager&) const override;
zeus::CVector3f GetAimPosition(const CStateManager&, float) const override;
bool AnimOver(CStateManager&, float) override { return x5bc_ == 3; }
void Flinch(CStateManager&, EStateMsg, float) override;
bool Delay(CStateManager&, float) override;
bool InRange(CStateManager&, float) override;
bool HearPlayer(CStateManager&, float) override;
bool InDetectionRange(CStateManager&, float) override;
void Attack(CStateManager&, EStateMsg, float) override;
void TargetPatrol(CStateManager&, EStateMsg, float) override;
void Lurk(CStateManager&, EStateMsg, float) override;
void FadeOut(CStateManager&, EStateMsg, float) override;
void FadeIn(CStateManager&, EStateMsg, float) override;
void Patrol(CStateManager&, EStateMsg, float) override;
void KnockBack(const zeus::CVector3f&, CStateManager&, const CDamageInfo& info, EKnockBackType type, bool inDeferred,
float magnitude);
float magnitude) override;
};
} // 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&&,
const CPatternedInfo&, const CActorParameters&, float, float, float, float);
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&);
void Think(float, CStateManager&);
const CDamageVulnerability* GetDamageVulnerability() const {
void AcceptScriptMsg(EScriptObjectMessage, TUniqueId, CStateManager&) override;
void Think(float, CStateManager&) override;
const CDamageVulnerability* GetDamageVulnerability() const override {
if (x698_26_)
return CAi::GetDamageVulnerability();
@ -48,44 +48,44 @@ public:
}
const CDamageVulnerability* GetDamageVulnerability(const zeus::CVector3f&, const zeus::CVector3f&,
const CDamageInfo&) const {
const CDamageInfo&) const override {
if (x698_26_)
return CAi::GetDamageVulnerability();
return &skVulnerabilities;
}
void DoUserAnimEvent(CStateManager&, const CInt32POINode&, EUserEventType, float);
void Death(CStateManager&, const zeus::CVector3f&, EScriptObjectState);
bool IsListening() const { return true; }
void Patrol(CStateManager&, EStateMsg, float);
void PathFind(CStateManager&, EStateMsg, float);
void SelectTarget(CStateManager&, EStateMsg, float);
void TargetPatrol(CStateManager&, EStateMsg, float);
void TargetPlayer(CStateManager&, EStateMsg, float);
void TargetCover(CStateManager&, EStateMsg, float);
void Attack(CStateManager&, EStateMsg, float);
void JumpBack(CStateManager&, EStateMsg, float);
void Shuffle(CStateManager&, EStateMsg, float);
void TurnAround(CStateManager&, EStateMsg, float);
void Crouch(CStateManager&, EStateMsg, float);
void GetUp(CStateManager&, EStateMsg, float);
void Suck(CStateManager&, EStateMsg, float);
void Cover(CStateManager&, EStateMsg, float);
void Approach(CStateManager&, EStateMsg, float);
void PathFindEx(CStateManager&, EStateMsg, float);
void Dizzy(CStateManager&, EStateMsg, float);
bool InAttackPosition(CStateManager&, float);
bool InRange(CStateManager&, float);
bool InMaxRange(CStateManager&, float);
bool InDetectionRange(CStateManager&, float);
bool SpotPlayer(CStateManager&, float);
bool InPosition(CStateManager&, float);
bool HearShot(CStateManager&, float);
bool CoverBlown(CStateManager&, float);
bool Inside(CStateManager&, float);
bool ShouldRetreat(CStateManager&, float);
bool IsDizzy(CStateManager&, float);
CPathFindSearch* GetSearchPath() { return &x568_pathFindSearch; }
void DoUserAnimEvent(CStateManager&, const CInt32POINode&, EUserEventType, float) override;
void Death(CStateManager&, const zeus::CVector3f&, EScriptObjectState) override;
bool IsListening() const override { return true; }
void Patrol(CStateManager&, EStateMsg, float) override;
void PathFind(CStateManager&, EStateMsg, float) override;
void SelectTarget(CStateManager&, EStateMsg, float) override;
void TargetPatrol(CStateManager&, EStateMsg, float) override;
void TargetPlayer(CStateManager&, EStateMsg, float) override;
void TargetCover(CStateManager&, EStateMsg, float) override;
void Attack(CStateManager&, EStateMsg, float) override;
void JumpBack(CStateManager&, EStateMsg, float) override;
void Shuffle(CStateManager&, EStateMsg, float) override;
void TurnAround(CStateManager&, EStateMsg, float) override;
void Crouch(CStateManager&, EStateMsg, float) override;
void GetUp(CStateManager&, EStateMsg, float) override;
void Suck(CStateManager&, EStateMsg, float) override;
void Cover(CStateManager&, EStateMsg, float) override;
void Approach(CStateManager&, EStateMsg, float) override;
void PathFindEx(CStateManager&, EStateMsg, float) override;
void Dizzy(CStateManager&, EStateMsg, float) override;
bool InAttackPosition(CStateManager&, float) override;
bool InRange(CStateManager&, float) override;
bool InMaxRange(CStateManager&, float) override;
bool InDetectionRange(CStateManager&, float) override;
bool SpotPlayer(CStateManager&, float) override;
bool InPosition(CStateManager&, float) override;
bool HearShot(CStateManager&, float) override;
bool CoverBlown(CStateManager&, float) override;
bool Inside(CStateManager&, float) override;
bool ShouldRetreat(CStateManager&, float) override;
bool IsDizzy(CStateManager&, float) override;
CPathFindSearch* GetSearchPath() override { return &x568_pathFindSearch; }
};
} // 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& projectileDamage, CAssetId projectileVisorParticle, u32 projecileVisorSfx);
void Accept(IVisitor& visitor);
void Think(float dt, CStateManager& mgr);
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId sender, CStateManager& mgr);
void Accept(IVisitor& visitor) override;
void Think(float dt, CStateManager& mgr) override;
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId sender, CStateManager& mgr) override;
std::optional<zeus::CAABox> GetTouchBounds() const;
void DoUserAnimEvent(CStateManager& mgr, const CInt32POINode& node, EUserEventType type, float dt);
const CCollisionPrimitive* GetCollisionPrimitive() const;
void Death(CStateManager& mgr, const zeus::CVector3f& direction, EScriptObjectState state);
bool IsListening() const;
bool Listen(const zeus::CVector3f&, EListenNoiseType);
zeus::CVector3f GetOrigin(const CStateManager& mgr, const CTeamAiRole& role, const zeus::CVector3f& aimPos) const;
std::optional<zeus::CAABox> GetTouchBounds() const override;
void DoUserAnimEvent(CStateManager& mgr, const CInt32POINode& node, EUserEventType type, float dt) override;
const CCollisionPrimitive* GetCollisionPrimitive() const override;
void Death(CStateManager& mgr, const zeus::CVector3f& direction, EScriptObjectState state) override;
bool IsListening() const override;
bool Listen(const zeus::CVector3f&, EListenNoiseType) override;
zeus::CVector3f GetOrigin(const CStateManager& mgr, const CTeamAiRole& role,
const zeus::CVector3f& aimPos) const override;
void UpdateTouchBounds();
bool IsRetreating() const { return x72e_30_isRetreating; }
void Patrol(CStateManager&, EStateMsg, float);
void PathFind(CStateManager& mgr, EStateMsg msg, float dt);
void TargetPatrol(CStateManager&, EStateMsg, float);
void Generate(CStateManager&, EStateMsg, float);
void Deactivate(CStateManager&, EStateMsg, float);
void Attack(CStateManager&, EStateMsg, float);
void JumpBack(CStateManager&, EStateMsg, float);
void Shuffle(CStateManager&, EStateMsg, float);
void ProjectileAttack(CStateManager&, EStateMsg, float);
void TelegraphAttack(CStateManager&, EStateMsg, float);
void Dodge(CStateManager&, EStateMsg, float);
void Retreat(CStateManager&, EStateMsg, float);
void SpecialAttack(CStateManager&, EStateMsg, float);
void Patrol(CStateManager&, EStateMsg, float) override;
void PathFind(CStateManager& mgr, EStateMsg msg, float dt) override;
void TargetPatrol(CStateManager&, EStateMsg, float) override;
void Generate(CStateManager&, EStateMsg, float) override;
void Deactivate(CStateManager&, EStateMsg, float) override;
void Attack(CStateManager&, EStateMsg, float) override;
void JumpBack(CStateManager&, EStateMsg, float) override;
void Shuffle(CStateManager&, EStateMsg, float) override;
void ProjectileAttack(CStateManager&, EStateMsg, float) override;
void TelegraphAttack(CStateManager&, EStateMsg, float) override;
void Dodge(CStateManager&, EStateMsg, float) override;
void Retreat(CStateManager&, EStateMsg, float) override;
void SpecialAttack(CStateManager&, EStateMsg, float) override;
bool InAttackPosition(CStateManager&, float);
bool Leash(CStateManager&, float);
bool PathShagged(CStateManager&, float);
bool AnimOver(CStateManager&, float);
bool ShouldAttack(CStateManager&, float);
bool InPosition(CStateManager&, float);
bool ShouldTurn(CStateManager&, float);
bool HearShot(CStateManager&, float);
bool ShouldFire(CStateManager&, float);
bool ShouldDodge(CStateManager&, float);
bool ShouldSpecialAttack(CStateManager&, float);
bool InAttackPosition(CStateManager&, float) override;
bool Leash(CStateManager&, float) override;
bool PathShagged(CStateManager&, float) override;
bool AnimOver(CStateManager&, float) override;
bool ShouldAttack(CStateManager&, float) override;
bool InPosition(CStateManager&, float) override;
bool ShouldTurn(CStateManager&, float) override;
bool HearShot(CStateManager&, float) override;
bool ShouldFire(CStateManager&, float) override;
bool ShouldDodge(CStateManager&, float) override;
bool ShouldSpecialAttack(CStateManager&, float) override;
CPathFindSearch* GetSearchPath();
CProjectileInfo* GetProjectileInfo();
CPathFindSearch* GetSearchPath() override;
CProjectileInfo* GetProjectileInfo() override;
};
} // namespace MP1
} // namespace urde