From 2ca0cd2bddf9592d2485e1a34d48c0b0ec51ab26 Mon Sep 17 00:00:00 2001 From: Phillip Stephens Date: Sat, 5 Sep 2020 14:51:21 -0700 Subject: [PATCH] Final CThardusRockProjectile imps, cleanup needed --- Runtime/MP1/World/CThardus.cpp | 43 ++- Runtime/MP1/World/CThardus.hpp | 6 +- Runtime/MP1/World/CThardusRockProjectile.cpp | 294 ++++++++++++++++++- Runtime/MP1/World/CThardusRockProjectile.hpp | 31 +- Runtime/World/CDestroyableRock.hpp | 3 + Runtime/World/ScriptLoader.cpp | 4 +- 6 files changed, 356 insertions(+), 25 deletions(-) diff --git a/Runtime/MP1/World/CThardus.cpp b/Runtime/MP1/World/CThardus.cpp index e0fb5df3c..ae815ad8d 100644 --- a/Runtime/MP1/World/CThardus.cpp +++ b/Runtime/MP1/World/CThardus.cpp @@ -616,8 +616,8 @@ void CThardus::LoopedAttack(CStateManager& mgr, EStateMsg msg, float arg) { if (x658_ == 1) { const zeus::CVector3f offset = thisPos + zeus::CVector3f{0.f, 0.f, 10.f}; CRayCastResult result = mgr.RayStaticIntersection( - offset, zeus::CQuaternion(GetTransform().buildMatrix3f()).toTransform() * zeus::CVector3f{0.f, 1.f, 0.f}, 100.f, - CMaterialFilter::MakeInclude({EMaterialTypes::Wall, EMaterialTypes::Floor, EMaterialTypes::Ceiling})); + offset, zeus::CQuaternion(GetTransform().buildMatrix3f()).toTransform() * zeus::CVector3f{0.f, 1.f, 0.f}, + 100.f, CMaterialFilter::MakeInclude({EMaterialTypes::Wall, EMaterialTypes::Floor, EMaterialTypes::Ceiling})); if (result.IsValid()) { zeus::CVector2f vec = sub801dac30(mgr); if (vec != zeus::skZero2f) { @@ -1131,4 +1131,43 @@ zeus::CVector3f CThardus::sub801de550(const CStateManager& mgr) const { return {}; } zeus::CVector2f CThardus::sub801dac30(CStateManager& mgr) const { return {}; } +bool CThardus::sub801db5b4(CStateManager& mgr) const { + if (mgr.GetPlayerState()->GetActiveVisor(mgr) == CPlayerState::EPlayerVisor::Thermal) { + return !x93a_ || x7c4_ == 0; + } + + return true; +} +void CThardus::ApplyCameraShake(float magnitude, float sfxDistance, float duration, CStateManager& mgr, const zeus::CVector3f& v1, + const zeus::CVector3f& v2) { + float bounceIntensity = std::max(0.f, -((v1 - mgr.GetPlayer().GetTranslation()).magnitude() * (magnitude / sfxDistance) - magnitude)); + if (mgr.GetCameraManager()->GetFirstPersonCamera()->GetUniqueId() == mgr.GetCameraManager()->GetCurrentCameraId()) { + mgr.GetCameraManager()->AddCameraShaker( + CCameraShakeData::BuildMissileCameraShake(duration, magnitude, sfxDistance, GetTranslation()), true); + } + + if (x908_) { + BouncePlayer(bounceIntensity, mgr); + } +} +void CThardus::BouncePlayer(float intensity, CStateManager& mgr) { + if (intensity <= 0.f) { + return; + } + + zeus::CVector3f posDiff = GetTranslation() - mgr.GetPlayer().GetTranslation(); + CPlayer::ESurfaceRestraints restraints = mgr.GetPlayer().GetSurfaceRestraint(); + if (restraints != CPlayer::ESurfaceRestraints::Air && !mgr.GetPlayer().IsInWaterMovement()) { + zeus::CVector3f baseImpulse = intensity * (40.f * zeus::skUp); + zeus::CVector3f additionalImpulse; + if (posDiff.magnitude() > 10.f) { + zeus::CVector3f tmpVec = posDiff.toVec2f(); + if (tmpVec.canBeNormalized()) { + additionalImpulse = intensity * (12.5f * tmpVec.normalized()); + } + } + mgr.GetPlayer().ApplyImpulseWR(mgr.GetPlayer().GetMass() * (baseImpulse + additionalImpulse), zeus::CAxisAngle()); + mgr.GetPlayer().SetMoveState(CPlayer::EPlayerMovementState::ApplyJump, mgr); + } +} } // namespace urde::MP1 diff --git a/Runtime/MP1/World/CThardus.hpp b/Runtime/MP1/World/CThardus.hpp index 732688c7c..ff942740f 100644 --- a/Runtime/MP1/World/CThardus.hpp +++ b/Runtime/MP1/World/CThardus.hpp @@ -173,7 +173,7 @@ class CThardus : public CPatterned { zeus::CVector2f sub801dac30(CStateManager& mgr) const; void sub801db148(CStateManager& mgr) const {} - + void BouncePlayer(float f1, CStateManager& mgr); public: DEFINE_PATTERNED(Thardus); CThardus(TUniqueId uid, std::string_view name, const CEntityInfo& info, const zeus::CTransform& xf, @@ -234,6 +234,10 @@ public: bool ShouldCallForBackup(CStateManager& mgr, float arg) override { return x330_stateMachineState.GetTime() > .5f; } CPathFindSearch* GetSearchPath() override { return &x7f0_pathFindSearch; } + + u32 Get_x7c4() const { return x7c4_; } + bool sub801db5b4(CStateManager& mgr) const; + void ApplyCameraShake(float magnitude, float sfxDistance, float duration, CStateManager& mgr, const zeus::CVector3f& v1, const zeus::CVector3f& v2); }; } // namespace MP1 } // namespace urde diff --git a/Runtime/MP1/World/CThardusRockProjectile.cpp b/Runtime/MP1/World/CThardusRockProjectile.cpp index e172109fe..e77bea220 100644 --- a/Runtime/MP1/World/CThardusRockProjectile.cpp +++ b/Runtime/MP1/World/CThardusRockProjectile.cpp @@ -1,11 +1,20 @@ #include "Runtime/MP1/World/CThardusRockProjectile.hpp" +#include "Runtime/CStateManager.hpp" #include "Runtime/Camera/CCameraManager.hpp" #include "Runtime/Camera/CFirstPersonCamera.hpp" -#include "Runtime/CStateManager.hpp" -#include "Runtime/Collision/CJointCollisionDescription.hpp" +#include "Runtime/Collision/CCollisionActor.hpp" +#include "Runtime/Collision/CCollisionActorManager.hpp" +#include "Runtime/Collision/CGameCollision.hpp" +#include "Runtime/World/CActorParameters.hpp" +#include "Runtime/World/CDestroyableRock.hpp" +#include "Runtime/World/CExplosion.hpp" +#include "Runtime/World/CLightParameters.hpp" #include "Runtime/World/CPlayer.hpp" +#include "Runtime/CSimplePool.hpp" +#include "Runtime/GameGlobalObjects.hpp" + #include "Runtime/MP1/World/CThardus.hpp" #include "TCastTo.hpp" // Generated file, do not modify include path @@ -19,23 +28,159 @@ constexpr std::array skRockCollisions{{ CThardusRockProjectile::CThardusRockProjectile(TUniqueId uid, std::string_view name, const CEntityInfo& info, const zeus::CTransform& xf, CModelData&& modelData, const CActorParameters& aParms, const CPatternedInfo& patternedInfo, - std::vector>&& mDataVec, - CAssetId stateMachine, float) + std::vector&& mDataVec, CAssetId stateMachine, float f1) : CPatterned(ECharacter::ThardusRockProjectile, uid, name, EFlavorType::Zero, info, xf, std::move(modelData), patternedInfo, EMovementType::Flyer, EColliderType::One, EBodyType::Flyer, aParms, EKnockBackVariant::Medium) -, x57c_(std::move(mDataVec)) {} +, x57c_(std::move(mDataVec)) +, x59c_stateMachine(stateMachine) +, x5c0_(f1) { + CMaterialList exclude = GetMaterialFilter().GetExcludeList(); + exclude.Add(EMaterialTypes::Player); + exclude.Add(EMaterialTypes::Character); + exclude.Add(EMaterialTypes::NoPlatformCollision); + SetMaterialFilter(CMaterialFilter::MakeIncludeExclude(GetMaterialFilter().GetIncludeList(), exclude)); + x50c_baseDamageMag = 1.f; +} void CThardusRockProjectile::Think(float dt, CStateManager& mgr) { if (!GetActive()) { return; } + if (auto* thardus = static_cast(mgr.ObjectById(x5d0_thardusId))) { + if (!thardus->sub801db5b4(mgr)) { + RemoveMaterial(EMaterialTypes::Orbit, mgr); + RemoveMaterial(EMaterialTypes::Target, mgr); + ModifyActorMaterial(mgr, true, EMaterialTypes::Orbit); + ModifyActorMaterial(mgr, true, EMaterialTypes::Target); + } else { + AddMaterial(EMaterialTypes::Orbit, mgr); + AddMaterial(EMaterialTypes::Target, mgr); + ModifyActorMaterial(mgr, false, EMaterialTypes::Orbit); + ModifyActorMaterial(mgr, false, EMaterialTypes::Target); + } + } CPatterned::Think(dt, mgr); + x3b4_speed = x5de_ ? 0.7f : 0.65f; + xe6_27_thermalVisorFlags = 1; + x578_collisionManager->Update(dt, mgr, CCollisionActorManager::EUpdateOptions::ObjectSpace); + UpdateDestroyableRockPositions(mgr); + UpdateDestroyableRockCollisionActors(mgr); + if (x58c_destroyableRocks.size() <= x5a0_) { + ExplodeAndShake(mgr, GetTranslation()); + DeathDelete(mgr); + } } void CThardusRockProjectile::AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId other, CStateManager& mgr) { CPatterned::AcceptScriptMsg(msg, other, mgr); + + switch (msg) { + case EScriptObjectMessage::Touched: { + if (TCastToPtr colAct = mgr.ObjectById(other)) { + if (TCastToPtr player = mgr.ObjectById(colAct->GetLastTouchedObject())) { + if (x420_curDamageRemTime <= 0.f) { + mgr.ApplyDamage(GetUniqueId(), player->GetUniqueId(), GetUniqueId(), GetContactDamage(), + CMaterialFilter::MakeIncludeExclude({EMaterialTypes::Solid}, {}), zeus::skZero3f); + x420_curDamageRemTime = x424_damageWaitTime; + if (mgr.GetPlayer().GetFrozenState()) { + mgr.GetPlayer().UnFreeze(mgr); + } + } + + TUniqueId rockId = kInvalidUniqueId; + for (size_t j = 0; j < x578_collisionManager->GetNumCollisionActors(); ++j) { + if (x578_collisionManager->GetCollisionDescFromIndex(j).GetCollisionActorId() == other) { + rockId = x58c_destroyableRocks[j]; + } + } + + if (rockId != kInvalidUniqueId) { + if (auto rock = static_cast(mgr.ObjectById(rockId))) { + if (rock->GetActive()) { + rock->SetActive(false); + colAct->SetActive(false); + ++x5a0_; + } + } + } + } + } + break; + } + case EScriptObjectMessage::Deactivate: { + SetChildrenActive(mgr, false); + break; + } + case EScriptObjectMessage::Activate: { + SetChildrenActive(mgr, true); + break; + } + case EScriptObjectMessage::Deleted: { + x578_collisionManager->Destroy(mgr); + for (TUniqueId& uid : x58c_destroyableRocks) { + mgr.FreeScriptObject(uid); + } + break; + } + case EScriptObjectMessage::Registered: { + RemoveMaterial(EMaterialTypes::Solid, mgr); + x58c_destroyableRocks.reserve(x57c_.size()); + + for (size_t i = 0; i < x57c_.size(); ++i) { + TUniqueId uid = mgr.AllocateUniqueId(); + CModelData mData{x57c_[i]}; + CHealthInfo hInfo = *GetHealthInfo(mgr); + CActorParameters actParms(CLightParameters(false, 0.f, CLightParameters::EShadowTesselation::Invalid, 0.f, 0.f, + zeus::skWhite, true, + CLightParameters::EWorldLightingOptions::NoShadowCast, + CLightParameters::ELightRecalculationOptions::LargeFrameCount, + zeus::skZero3f, -1, -1, false, 0), + CScannableParameters(), {}, {}, {}, true, true, false, false, 0.f, 0.f, 1.f); + auto rock = new CDestroyableRock(uid, true, skRockCollisions[i].name, + CEntityInfo(GetAreaIdAlways(), CEntity::NullConnectionList), zeus::CTransform(), + std::move(mData), 0.f, hInfo, CDamageVulnerability::NormalVulnerabilty(), + GetMaterialList(), x59c_stateMachine, actParms, x57c_[i], 1); + rock->Set_x340(false); + rock->Set_x32c(x50c_baseDamageMag); + mgr.AddObject(rock); + x58c_destroyableRocks.push_back(uid); + } + AddMaterial(EMaterialTypes::ScanPassthrough); + InitializeCollisionManager(mgr); + x450_bodyController->Activate(mgr); + SetActive(false); + SetChildrenActive(mgr, false); + break; + } + case EScriptObjectMessage::Damage: { + if (TCastToPtr colAct = mgr.ObjectById(other)) { + TUniqueId rockId = kInvalidUniqueId; + for (size_t j = 0; j < x578_collisionManager->GetNumCollisionActors(); ++j) { + if (other == x578_collisionManager->GetCollisionDescFromIndex(j).GetCollisionActorId()) { + rockId = x58c_destroyableRocks[j]; + } + } + if (auto rock = static_cast(mgr.ObjectById(rockId))) { + rock->TakeDamage(zeus::skZero3f, 0.f); + // NOTE(phil): Accessing Thardus as const here rather than non-const like the vanilla version + // since we're not modifying him in any way + if (const auto* thardus = static_cast(mgr.GetObjectById(x5d0_thardusId))) { + if (mgr.GetPlayerState()->GetCurrentVisor() != CPlayerState::EPlayerVisor::Thermal || + thardus->Get_x7c4() != 3) { + DoExplosion(mgr, x5c4_, GetTranslation(), GetModelData()->GetScale(), 0); + } + ProcessSoundEvent(x5d4_, 1.f, 0, 0.1f, 1000.f, 0.16f, 1.f, zeus::skZero3f, GetTranslation(), + mgr.GetNextAreaId(), mgr, true); + } + } + } + break; + } + default: + break; + } } void CThardusRockProjectile::Render(CStateManager& mgr) { CPatterned::Render(mgr); } @@ -93,7 +238,7 @@ void CThardusRockProjectile::GetUp(CStateManager& mgr, EStateMsg msg, float dt) CThardus* thardus = static_cast(mgr.ObjectById(x5d0_thardusId)); if (thardus != nullptr && !x5dc_) { x5dc_ = true; - sub80203824(mgr, x5cc_, result.GetPoint(), GetModelData()->GetScale(), 0); + DoExplosion(mgr, x5cc_, result.GetPoint(), GetModelData()->GetScale(), 0); ProcessSoundEvent(SFXsfx07AE, 1.f, 0, 0.1f, 1.f, 0.16f, 1.f, zeus::skZero3f, GetTranslation(), mgr.GetNextAreaId(), mgr, false); } @@ -130,15 +275,142 @@ bool CThardusRockProjectile::Delay(CStateManager& mgr, float arg) { return x5a8_ bool CThardusRockProjectile::AnimOver(CStateManager& mgr, float arg) { return x574_ == EAnimState::Over; } bool CThardusRockProjectile::ShouldAttack(CStateManager& mgr, float arg) { - if (x5ac_ < x330_stateMachineState.GetTime() && x56c_ != 3) { - x56c_ = 2; - return true; + if (x5ac_ >= x330_stateMachineState.GetTime() || x56c_ == 3) { + return false; } - - return false; + x56c_ = 2; + return true; } bool CThardusRockProjectile::HitSomething(CStateManager& mgr, float arg) { return x572_; } bool CThardusRockProjectile::ShouldMove(CStateManager& mgr, float arg) { return x56c_ != 0; } + +void CThardusRockProjectile::SetChildrenActive(CStateManager& mgr, bool active) { + for (size_t i = 0; i < x58c_destroyableRocks.size(); ++i) { + const TUniqueId uid = x58c_destroyableRocks[i]; + const auto& jInfo = x578_collisionManager->GetCollisionDescFromIndex(i); + if (auto rock = static_cast(mgr.ObjectById(uid))) { + if (auto colAct = static_cast(mgr.ObjectById(jInfo.GetCollisionActorId()))) { + rock->SetActive(active); + colAct->SetActive(active); + } + } + } +} + +void CThardusRockProjectile::InitializeCollisionManager(CStateManager& mgr) { + std::vector joints; + AddSphereCollisionList(skRockCollisions.data(), 1, joints); + x578_collisionManager = std::make_unique(mgr, GetUniqueId(), GetAreaIdAlways(), joints, true); + SetMaterialProperties(x578_collisionManager, mgr); + + for (size_t j = 0; j < x578_collisionManager->GetNumCollisionActors(); ++j) { + const CJointCollisionDescription& colDesc = x578_collisionManager->GetCollisionDescFromIndex(j); + auto rock = static_cast(mgr.GetObjectById(x58c_destroyableRocks[j])); + if (rock != nullptr) { + if (TCastToPtr colAct = mgr.ObjectById(colDesc.GetCollisionActorId())) { + colAct->SetDamageVulnerability(*rock->GetDamageVulnerability()); + *colAct->HealthInfo(mgr) = *rock->GetHealthInfo(mgr); + } + } + } +} +void CThardusRockProjectile::AddSphereCollisionList(const SSphereJointInfo* info, size_t count, + std::vector& vecOut) { + const auto* animData = GetModelData()->GetAnimationData(); + for (size_t i = 0; i < count; ++i) { + CSegId seg = animData->GetLocatorSegId(info[i].name); + if (seg.IsInvalid()) { + continue; + } + vecOut.push_back(CJointCollisionDescription::SphereCollision(seg, info[i].radius, info[i].name, 0.001f)); + } +} +void CThardusRockProjectile::SetMaterialProperties(const std::unique_ptr& colMgr, + CStateManager& mgr) { + for (size_t j = 0; j < colMgr->GetNumCollisionActors(); ++j) { + const CJointCollisionDescription& desc = colMgr->GetCollisionDescFromIndex(j); + if (auto colAct = static_cast(mgr.ObjectById(desc.GetCollisionActorId()))) { + CMaterialList include = GetMaterialFilter().GetIncludeList(); + CMaterialList exclude = GetMaterialFilter().GetExcludeList(); + include.Add(colAct->GetMaterialFilter().GetIncludeList()); + exclude.Add(colAct->GetMaterialFilter().GetExcludeList()); + colAct->SetMaterialFilter(CMaterialFilter::MakeIncludeExclude(include, exclude)); + } + } +} +void CThardusRockProjectile::DoExplosion(CStateManager& mgr, CAssetId particleId, const zeus::CVector3f& pos, + const zeus::CVector3f& scale, u32 w2) { + TUniqueId uid = mgr.AllocateUniqueId(); + std::string name = fmt::format(FMT_STRING("ROCK_PROJECTILE_EFFECT-{}-{}"), particleId.Value(), uid.Value()); + TLockedToken descTok = g_SimplePool->GetObj({SBIG('PART'), particleId}); + mgr.AddObject(new CExplosion(descTok, uid, true, CEntityInfo(mgr.GetNextAreaId(), NullConnectionList), name, + zeus::CTransform(zeus::CMatrix3f(), pos), w2, scale, zeus::skWhite)); +} +void CThardusRockProjectile::ExplodeAndShake(CStateManager& mgr, const zeus::CVector3f& pos) { + if (x5d0_thardusId == kInvalidUniqueId) { + return; + } + + if (auto thardus = static_cast(mgr.ObjectById(x5d0_thardusId))) { + DoExplosion(mgr, x5c8_, pos, GetModelData()->GetScale(), 0); + thardus->ApplyCameraShake(0.75f, 125.f, 1.f, mgr, pos, pos); + } +} +void CThardusRockProjectile::ModifyActorMaterial(CStateManager& mgr, bool remove, EMaterialTypes mat) { + for (size_t i = 0; i < x58c_destroyableRocks.size(); ++i) { + TUniqueId rockId = x58c_destroyableRocks[i]; + const auto& jInfo = x578_collisionManager->GetCollisionDescFromIndex(i); + if (TCastToPtr colAct = mgr.ObjectById(jInfo.GetCollisionActorId())) { + if (TCastToPtr rock = mgr.ObjectById(rockId)) { + if (remove) { + colAct->RemoveMaterial(mat, mgr); + rock->RemoveMaterial(mat, mgr); + } else { + colAct->AddMaterial(mat, mgr); + rock->AddMaterial(mat, mgr); + } + } + } + } +} +void CThardusRockProjectile::UpdateDestroyableRockPositions(CStateManager& mgr) { + const zeus::CVector3f scale = GetModelData()->GetScale(); + for (size_t i = 0; i < x58c_destroyableRocks.size(); ++i) { + zeus::CTransform locatorXf = + GetModelData()->GetAnimationData()->GetLocatorTransform(skRockCollisions[i].name, nullptr); + if (TCastToPtr rock = mgr.ObjectById(x58c_destroyableRocks[i])) { + locatorXf = GetTransform() * (zeus::CTransform::Scale(scale) * locatorXf); + rock->SetTransform(locatorXf); + } + } +} +void CThardusRockProjectile::UpdateDestroyableRockCollisionActors(CStateManager& mgr) { + for (size_t j = 0; j < x578_collisionManager->GetNumCollisionActors(); ++j) { + const auto jInfo = x578_collisionManager->GetCollisionDescFromIndex(j); + if (TCastToPtr colAct = mgr.ObjectById(jInfo.GetCollisionActorId())) { + if (!colAct->GetActive()) { + continue; + } + if (auto rock = static_cast(mgr.ObjectById(x58c_destroyableRocks[j]))) { + colAct->SetDamageVulnerability(*rock->GetDamageVulnerability()); + const CHealthInfo* hInfo = colAct->GetHealthInfo(mgr); + *rock->HealthInfo(mgr) = *hInfo; + CMaterialFilter filter = (x5bc_ && x56c_ != 3) ? CMaterialFilter::MakeInclude({EMaterialTypes::Wall}) + : CMaterialFilter::MakeInclude({EMaterialTypes::Solid}); + bool collided = CGameCollision::DetectStaticCollisionBoolean(mgr, *colAct->GetCollisionPrimitive(), + colAct->GetTransform(), filter); + if (hInfo->GetHP() <= 0.f || (collided && x5a4_)) { + rock->SetActive(false); + colAct->SetActive(false); + ++x5a0_; + if (hInfo->GetHP() <= 0.f) { + x5dd_ = true; + } + } + } + } + } +} } // namespace urde::MP1 diff --git a/Runtime/MP1/World/CThardusRockProjectile.hpp b/Runtime/MP1/World/CThardusRockProjectile.hpp index e89686157..0716a03ec 100644 --- a/Runtime/MP1/World/CThardusRockProjectile.hpp +++ b/Runtime/MP1/World/CThardusRockProjectile.hpp @@ -1,17 +1,20 @@ #pragma once #include "Runtime/World/CPatterned.hpp" - -namespace urde::MP1 { +#include "Runtime/Collision/CJointCollisionDescription.hpp" +namespace urde { +class CCollisionActorManager; +struct SSphereJointInfo; +namespace MP1 { class CThardusRockProjectile : public CPatterned { float x568_ = 1.f; u32 x56c_ = 0; TUniqueId x570_ = kInvalidUniqueId; bool x572_ = false; EAnimState x574_ = EAnimState::Invalid; - u32 x578_ = 0; - std::vector> x57c_; - std::vector x58c_; + std::unique_ptr x578_collisionManager; + std::vector x57c_; // Used to be a pointers to CModelData + std::vector x58c_destroyableRocks; CAssetId x59c_stateMachine; u32 x5a0_ = 0; bool x5a4_ = true; @@ -28,12 +31,21 @@ class CThardusRockProjectile : public CPatterned { u32 x5d8_ = 0; bool x5dc_ = false; bool x5dd_ = false; - void sub80203824(CStateManager& mgr, u32 w1, const zeus::CVector3f& pos, const zeus::CVector3f& scale, u32 w2) {} + bool x5de_; + void DoExplosion(CStateManager& mgr, CAssetId particleId, const zeus::CVector3f& pos, const zeus::CVector3f& scale, u32 w2); + void ExplodeAndShake(CStateManager& mgr, const zeus::CVector3f& pos); + void ModifyActorMaterial(CStateManager& mgr, bool remove, EMaterialTypes mat); + void SetChildrenActive(CStateManager& mgr, bool active); + void InitializeCollisionManager(CStateManager& mgr); + void AddSphereCollisionList(const SSphereJointInfo* info, size_t count, std::vector& vecOut); + void SetMaterialProperties(const std::unique_ptr& colMgr, CStateManager& mgr); + void UpdateDestroyableRockPositions(CStateManager& mgr); + void UpdateDestroyableRockCollisionActors(CStateManager& mgr); public: DEFINE_PATTERNED(ThardusRockProjectile); CThardusRockProjectile(TUniqueId uid, std::string_view name, const CEntityInfo& info, const zeus::CTransform& xf, CModelData&& modelData, const CActorParameters& aParms, const CPatternedInfo& patternedInfo, - std::vector>&& mDataVec, CAssetId stateMachine, float); + std::vector&& mDataVec, CAssetId stateMachine, float); void Think(float dt, CStateManager& mgr) override; void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId other, CStateManager& mgr) override; @@ -41,7 +53,7 @@ public: void sub80203d58() { x328_25_verticalMovement = false; x150_momentum = {0.f, 0.f, 2.f * -GetWeight()}; - x56c_= 3; + x56c_ = 3; } void Patrol(CStateManager& mgr, EStateMsg msg, float dt) override; @@ -55,4 +67,5 @@ public: bool HitSomething(CStateManager& mgr, float arg) override; bool ShouldMove(CStateManager& mgr, float arg) override; }; -} // namespace urde::MP1 +} // namespace MP1 +} // namespace urde diff --git a/Runtime/World/CDestroyableRock.hpp b/Runtime/World/CDestroyableRock.hpp index cd4a79d25..994c507f9 100644 --- a/Runtime/World/CDestroyableRock.hpp +++ b/Runtime/World/CDestroyableRock.hpp @@ -17,6 +17,7 @@ class CDestroyableRock : public CAi { bool x334_isCold = false; bool x335_usePhazonModel = false; CHealthInfo x338_healthInfo; + bool x340_; bool x341_; public: @@ -61,6 +62,8 @@ public: /* This used to be in the constructor, since we can't store CModelData directly in the class we must set it here */ GetModelData()->SetSortThermal(true); } + + void Set_x340(bool v) { x340_ = v; } }; } // namespace urde diff --git a/Runtime/World/ScriptLoader.cpp b/Runtime/World/ScriptLoader.cpp index 78e5270b3..e7b167714 100644 --- a/Runtime/World/ScriptLoader.cpp +++ b/Runtime/World/ScriptLoader.cpp @@ -2878,11 +2878,11 @@ CEntity* ScriptLoader::LoadThardusRockProjectile(CStateManager& mgr, CInputStrea if (!pInfo.GetAnimationParameters().GetACSFile().IsValid()) return nullptr; - std::vector> mDataVec; + std::vector mDataVec; CModelData mData(CAnimRes(pInfo.GetAnimationParameters().GetACSFile(), 0, actorHead.x40_scale, pInfo.GetAnimationParameters().GetInitialAnimation(), true)); mDataVec.reserve(3); - mDataVec.emplace_back(std::make_unique(CStaticRes(modelId, zeus::skOne3f))); + mDataVec.emplace_back(modelId, zeus::skOne3f); return new MP1::CThardusRockProjectile(mgr.AllocateUniqueId(), actorHead.x0_name, info, actorHead.x10_transform, std::move(mData), actParms, pInfo, std::move(mDataVec), stateMachine, f1); }