mirror of https://github.com/AxioDL/metaforce.git
417 lines
18 KiB
C++
417 lines
18 KiB
C++
#include "Runtime/MP1/World/CThardusRockProjectile.hpp"
|
|
|
|
#include "Runtime/CStateManager.hpp"
|
|
#include "Runtime/Camera/CCameraManager.hpp"
|
|
#include "Runtime/Camera/CFirstPersonCamera.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
|
|
namespace metaforce::MP1 {
|
|
namespace {
|
|
constexpr std::array<SSphereJointInfo, 1> skRockCollisions{{
|
|
{"Rock_01_Collision_LCTR", 1.5f},
|
|
}};
|
|
} // namespace
|
|
|
|
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<CStaticRes>&& 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))
|
|
, 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<CThardus*>(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<CCollisionActor> colAct = mgr.ObjectById(other)) {
|
|
if (TCastToPtr<CPlayer> 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<CDestroyableRock*>(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->SetThermalMag(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<CCollisionActor> 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<CDestroyableRock*>(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<const CThardus*>(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); }
|
|
|
|
void CThardusRockProjectile::Patrol(CStateManager& mgr, EStateMsg msg, float dt) {
|
|
if (msg != EStateMsg::Update) {
|
|
return;
|
|
}
|
|
|
|
GetBodyController()->GetCommandMgr().DeliverCmd(
|
|
CBCLocomotionCmd(zeus::skZero3f, (mgr.GetPlayer().GetTranslation() - GetTranslation()).normalized(), 1.f));
|
|
}
|
|
|
|
void CThardusRockProjectile::Dead(CStateManager& mgr, EStateMsg msg, float dt) {
|
|
if (msg != EStateMsg::Activate) {
|
|
return;
|
|
}
|
|
|
|
mgr.FreeScriptObject(GetUniqueId());
|
|
SendScriptMsgs(EScriptObjectState::MassiveDeath, mgr, EScriptObjectMessage::None);
|
|
GenerateDeathExplosion(mgr);
|
|
}
|
|
|
|
void CThardusRockProjectile::LoopedAttack(CStateManager& mgr, EStateMsg msg, float dt) {
|
|
if (msg == EStateMsg::Activate) {
|
|
x5a4_ = true;
|
|
} else if (msg == EStateMsg::Update) {
|
|
zeus::CVector3f aimPos = mgr.GetPlayer().GetAimPosition(mgr, 0.f);
|
|
if (!x5bc_ || (aimPos - GetTranslation()).magSquared() <= x5c0_ * x5c0_) {
|
|
x5bc_ = false;
|
|
} else {
|
|
x5b0_ = x45c_steeringBehaviors.Arrival(*this, aimPos, 0.f);
|
|
x5bc_ = true;
|
|
}
|
|
|
|
zeus::CVector3f movePos = x5b0_;
|
|
float radius = skRockCollisions[0].radius;
|
|
auto result = mgr.RayStaticIntersection(GetTranslation(), zeus::skDown, 100.f,
|
|
CMaterialFilter::MakeInclude({EMaterialTypes::Solid}));
|
|
|
|
if (result.IsValid()) {
|
|
movePos = (x45c_steeringBehaviors.Separation(*this, result.GetPoint(), 2.f * radius) + x5b0_).normalized();
|
|
}
|
|
GetBodyController()->GetCommandMgr().DeliverCmd(CBCLocomotionCmd{movePos, zeus::skZero3f, 1.f});
|
|
}
|
|
}
|
|
|
|
void CThardusRockProjectile::GetUp(CStateManager& mgr, EStateMsg msg, float dt) {
|
|
if (msg == EStateMsg::Activate) {
|
|
x574_ = EAnimState::NotReady;
|
|
} else if (msg == EStateMsg::Update) {
|
|
auto result = mgr.RayStaticIntersection(GetTranslation(), zeus::skDown, 2.f,
|
|
CMaterialFilter::MakeInclude({EMaterialTypes::Solid}));
|
|
if (result.IsInvalid()) {
|
|
CThardus* thardus = static_cast<CThardus*>(mgr.ObjectById(x5d0_thardusId));
|
|
if (thardus != nullptr && !x5dc_) {
|
|
x5dc_ = true;
|
|
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);
|
|
}
|
|
} else if (mgr.GetCameraManager()->GetCurrentCameraId() ==
|
|
mgr.GetCameraManager()->GetFirstPersonCamera()->GetUniqueId()) {
|
|
const CCameraShakeData data = CCameraShakeData::BuildMissileCameraShake(0.25f, 0.5f, 50.f, GetTranslation());
|
|
mgr.GetCameraManager()->AddCameraShaker(data, true);
|
|
}
|
|
|
|
if (x574_ == EAnimState::NotReady) {
|
|
if (GetBodyController()->GetBodyStateInfo().GetCurrentStateId() == pas::EAnimationState::Getup) {
|
|
x574_ = EAnimState::Repeat;
|
|
} else {
|
|
GetBodyController()->GetCommandMgr().DeliverCmd(CBCGetupCmd{pas::EGetupType::Zero});
|
|
}
|
|
} else if (x574_ == EAnimState::Repeat &&
|
|
GetBodyController()->GetBodyStateInfo().GetCurrentStateId() != pas::EAnimationState::Getup) {
|
|
x574_ = EAnimState::Over;
|
|
}
|
|
}
|
|
}
|
|
|
|
void CThardusRockProjectile::Lurk(CStateManager& mgr, EStateMsg msg, float dt) {
|
|
if (msg != EStateMsg::Update) {
|
|
return;
|
|
}
|
|
|
|
GetBodyController()->GetCommandMgr().DeliverCmd(
|
|
CBCLocomotionCmd{zeus::skZero3f, (mgr.GetPlayer().GetTranslation() - GetTranslation()).normalized(), 1.f});
|
|
}
|
|
|
|
bool CThardusRockProjectile::Delay(CStateManager& mgr, float arg) { return x5a8_ < x330_stateMachineState.GetTime(); }
|
|
|
|
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) {
|
|
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<CDestroyableRock*>(mgr.ObjectById(uid))) {
|
|
if (auto colAct = static_cast<CCollisionActor*>(mgr.ObjectById(jInfo.GetCollisionActorId()))) {
|
|
rock->SetActive(active);
|
|
colAct->SetActive(active);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void CThardusRockProjectile::InitializeCollisionManager(CStateManager& mgr) {
|
|
std::vector<CJointCollisionDescription> joints;
|
|
AddSphereCollisionList(skRockCollisions.data(), 1, joints);
|
|
x578_collisionManager = std::make_unique<CCollisionActorManager>(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<const CDestroyableRock*>(mgr.GetObjectById(x58c_destroyableRocks[j]));
|
|
if (rock != nullptr) {
|
|
if (TCastToPtr<CCollisionActor> 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<CJointCollisionDescription>& 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<CCollisionActorManager>& colMgr,
|
|
CStateManager& mgr) {
|
|
for (size_t j = 0; j < colMgr->GetNumCollisionActors(); ++j) {
|
|
const CJointCollisionDescription& desc = colMgr->GetCollisionDescFromIndex(j);
|
|
if (auto colAct = static_cast<CCollisionActor*>(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<CGenDescription> 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<CThardus*>(mgr.ObjectById(x5d0_thardusId))) {
|
|
DoExplosion(mgr, x5c8_, pos, GetModelData()->GetScale(), 0);
|
|
thardus->ApplyCameraShake(0.75f, 125.f, 1.f, mgr, 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<CActor> colAct = mgr.ObjectById(jInfo.GetCollisionActorId())) {
|
|
if (TCastToPtr<CActor> 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<CActor> 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<CCollisionActor> colAct = mgr.ObjectById(jInfo.GetCollisionActorId())) {
|
|
if (!colAct->GetActive()) {
|
|
continue;
|
|
}
|
|
if (auto rock = static_cast<CDestroyableRock*>(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 metaforce::MP1
|