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

Merge branch 'prime-exo'

Browse Source
This commit is contained in:
Phillip Stephens 2020-12-15 14:52:47 -08:00
commit 3f49b06070
Signed by: Antidote
GPG Key ID: F8BEE4C83DACA60D
27 changed files with 3058 additions and 65 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
Runtime/CStateManager.cpp
View File

@ -8,6 +8,7 @@
#include "Runtime/Camera/CGameCamera.hpp"
#include "Runtime/CGameState.hpp"
#include "Runtime/CMemoryCardSys.hpp"
#include "Runtime/Collision/CCollisionActor.hpp"
#include "Runtime/Collision/CCollidableSphere.hpp"
#include "Runtime/Collision/CGameCollision.hpp"
#include "Runtime/Collision/CMaterialFilter.hpp"
@ -192,7 +193,7 @@ CStateManager::CStateManager(const std::weak_ptr<CRelayTracker>& relayTracker,
x90c_loaderFuncs[size_t(EScriptObjectType::Burrower)] = ScriptLoader::LoadBurrower;
x90c_loaderFuncs[size_t(EScriptObjectType::ScriptBeam)] = ScriptLoader::LoadBeam;
x90c_loaderFuncs[size_t(EScriptObjectType::WorldLightFader)] = ScriptLoader::LoadWorldLightFader;
x90c_loaderFuncs[size_t(EScriptObjectType::MetroidPrimeStage2)] = ScriptLoader::LoadMetroidPrimeStage2;
x90c_loaderFuncs[size_t(EScriptObjectType::MetroidPrimeStage2)] = ScriptLoader::LoadMetroidPrimeEssence;
x90c_loaderFuncs[size_t(EScriptObjectType::MetroidPrimeStage1)] = ScriptLoader::LoadMetroidPrimeStage1;
x90c_loaderFuncs[size_t(EScriptObjectType::MazeNode)] = ScriptLoader::LoadMazeNode;
x90c_loaderFuncs[size_t(EScriptObjectType::OmegaPirate)] = ScriptLoader::LoadOmegaPirate;
@ -536,8 +537,8 @@ void CStateManager::BuildDynamicLightListForWorld() {
}
void CStateManager::DrawDebugStuff() const {
#ifndef NDEBUG
CGraphics::SetModelMatrix(zeus::CTransform());
#ifndef NDEBUG
for (CEntity* ent : GetActorObjectList()) {
if (const TCastToPtr<CPatterned> ai = ent) {
if (CPathFindSearch* path = ai->GetSearchPath()) {
@ -545,6 +546,11 @@ void CStateManager::DrawDebugStuff() const {
}
} else if (const TCastToPtr<CGameLight> light = ent) {
light->DebugDraw();
} else if (const TCastToPtr<CCollisionActor> colAct = ent) {
if (colAct->GetUniqueId() == x870_cameraManager->GetBallCamera()->GetCollisionActorId()) {
continue;
}
colAct->DebugDraw();
}
}
@ -556,6 +562,15 @@ void CStateManager::DrawDebugStuff() const {
xf70_currentMaze->DebugRender();
}
#endif
for (CEntity* ent : GetActorObjectList()) {
if (const TCastToPtr<CCollisionActor> colAct = ent) {
if (colAct->GetUniqueId() == x870_cameraManager->GetBallCamera()->GetCollisionActorId()) {
continue;
}
colAct->DebugDraw();
}
}
}
void CStateManager::RenderCamerasAndAreaLights() {
@ -1983,8 +1998,9 @@ bool CStateManager::ApplyDamage(TUniqueId damagerId, TUniqueId damageeId, TUniqu
}
if (alive && damager && info.GetKnockBackPower() > 0.f) {
const zeus::CVector3f delta =
zeus::CVector3f delta =
knockbackVec.isZero() ? (damagee->GetTranslation() - damager->GetTranslation()) : knockbackVec;
delta.z() = FLT_EPSILON;
ApplyKnockBack(*damagee, info, *dVuln, delta.normalized(), 0.f);
}
}

1
Runtime/Camera/CBallCamera.hpp
View File

@ -270,6 +270,7 @@ public:
void DoorClosing(TUniqueId doorId);
[[nodiscard]] const zeus::CVector3f& GetLookPosAhead() const { return x1c0_lookPosAhead; }
[[nodiscard]] const zeus::CVector3f& GetFixedLookPos() const { return x1cc_fixedLookPos; }
const TUniqueId GetCollisionActorId() const { return x46c_collisionActorId; }
static bool IsBallNearDoor(const zeus::CVector3f& pos, CStateManager& mgr);
};

31
Runtime/Collision/CCollisionActor.cpp
View File

@ -15,9 +15,9 @@ constexpr CMaterialList skDefaultCollisionActorMaterials =
CCollisionActor::CCollisionActor(TUniqueId uid, TAreaId areaId, TUniqueId owner, const zeus::CVector3f& extent,
const zeus::CVector3f& center, bool active, float mass, std::string_view name)
: CPhysicsActor(uid, active, "CollisionActor", CEntityInfo(areaId, CEntity::NullConnectionList),
zeus::CTransform(), CModelData::CModelDataNull(), skDefaultCollisionActorMaterials,
zeus::skNullBox, SMoverData(mass), CActorParameters::None(), 0.3f, 0.1f)
: CPhysicsActor(uid, active, "CollisionActor", CEntityInfo(areaId, CEntity::NullConnectionList), zeus::CTransform(),
CModelData::CModelDataNull(), skDefaultCollisionActorMaterials, zeus::skNullBox, SMoverData(mass),
CActorParameters::None(), 0.3f, 0.1f)
, x258_primitiveType(EPrimitiveType::OBBTreeGroup)
, x25c_owner(owner)
, x260_boxSize(extent)
@ -34,9 +34,9 @@ CCollisionActor::CCollisionActor(TUniqueId uid, TAreaId areaId, TUniqueId owner,
CCollisionActor::CCollisionActor(TUniqueId uid, TAreaId areaId, TUniqueId owner, const zeus::CVector3f& boxSize,
bool active, float mass, std::string_view name)
: CPhysicsActor(uid, active, "CollisionActor", CEntityInfo(areaId, CEntity::NullConnectionList),
zeus::CTransform(), CModelData::CModelDataNull(), skDefaultCollisionActorMaterials,
zeus::skNullBox, SMoverData(mass), CActorParameters::None(), 0.3f, 0.1f)
: CPhysicsActor(uid, active, "CollisionActor", CEntityInfo(areaId, CEntity::NullConnectionList), zeus::CTransform(),
CModelData::CModelDataNull(), skDefaultCollisionActorMaterials, zeus::skNullBox, SMoverData(mass),
CActorParameters::None(), 0.3f, 0.1f)
, x258_primitiveType(EPrimitiveType::AABox)
, x25c_owner(owner)
, x260_boxSize(boxSize)
@ -53,9 +53,9 @@ CCollisionActor::CCollisionActor(TUniqueId uid, TAreaId areaId, TUniqueId owner,
CCollisionActor::CCollisionActor(TUniqueId uid, TAreaId areaId, TUniqueId owner, bool active, float radius, float mass,
std::string_view name)
: CPhysicsActor(uid, active, "CollisionActor", CEntityInfo(areaId, CEntity::NullConnectionList),
zeus::CTransform(), CModelData::CModelDataNull(), skDefaultCollisionActorMaterials,
zeus::skNullBox, SMoverData(mass), CActorParameters::None(), 0.3f, 0.1f)
: CPhysicsActor(uid, active, "CollisionActor", CEntityInfo(areaId, CEntity::NullConnectionList), zeus::CTransform(),
CModelData::CModelDataNull(), skDefaultCollisionActorMaterials, zeus::skNullBox, SMoverData(mass),
CActorParameters::None(), 0.3f, 0.1f)
, x258_primitiveType(EPrimitiveType::Sphere)
, x25c_owner(owner)
, x284_spherePrimitive(std::make_unique<CCollidableSphere>(
@ -179,4 +179,17 @@ void CCollisionActor::SetSphereRadius(float radius) {
x288_sphereRadius = radius;
x284_spherePrimitive->SetSphereRadius(radius);
}
void CCollisionActor::DebugDraw() {
zeus::CAABox aabox;
if (x258_primitiveType == EPrimitiveType::OBBTreeGroup)
aabox = x27c_obbTreeGroupPrimitive->CalculateAABox(x34_transform);
else if (x258_primitiveType == EPrimitiveType::AABox)
aabox = x280_aaboxPrimitive->CalculateAABox(x34_transform);
else if (x258_primitiveType == EPrimitiveType::Sphere)
aabox = x284_spherePrimitive->CalculateAABox(x34_transform);
m_aabox.setAABB(aabox);
zeus::CColor col = !GetActive() ? zeus::skRed : zeus::skGreen;
col.a() = 0.5f;
m_aabox.draw(col);
}
} // namespace urde

3
Runtime/Collision/CCollisionActor.hpp
View File

@ -3,6 +3,7 @@
#include <memory>
#include <string_view>
#include "Runtime/Graphics/Shaders/CAABoxShader.hpp"
#include "Runtime/World/CDamageVulnerability.hpp"
#include "Runtime/World/CHealthInfo.hpp"
#include "Runtime/World/CPhysicsActor.hpp"
@ -32,6 +33,7 @@ class CCollisionActor : public CPhysicsActor {
EWeaponCollisionResponseTypes x300_responseType = EWeaponCollisionResponseTypes::EnemyNormal;
zeus::CVector3f x304_extendedTouchBounds = zeus::skZero3f;
CAABoxShader m_aabox;
public:
CCollisionActor(TUniqueId uid, TAreaId areaId, TUniqueId owner, const zeus::CVector3f& extent,
const zeus::CVector3f& center, bool active, float mass, std::string_view name);
@ -42,6 +44,7 @@ public:
void Accept(IVisitor& visitor) override;
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId sender, CStateManager& mgr) override;
void DebugDraw();
CHealthInfo* HealthInfo(CStateManager& mgr) override;
const CDamageVulnerability* GetDamageVulnerability() const override;
const CDamageVulnerability* GetDamageVulnerability(const zeus::CVector3f& vec1, const zeus::CVector3f& vec2,

17
Runtime/Collision/CGameCollision.cpp
View File

@ -682,6 +682,23 @@ bool CGameCollision::DetectDynamicCollisionMoving(const CCollisionPrimitive& pri
return ret;
}
bool CGameCollision::DetectCollision(const CStateManager& mgr, const CCollisionPrimitive& prim, const zeus::CTransform& xf,
const CMaterialFilter& filter, const rstl::reserved_vector<TUniqueId, 1024>& nearList,
TUniqueId& idOut, CCollisionInfoList& infoOut) {
bool ret = false;
CMaterialList exclude = filter.ExcludeList();
if (!exclude.HasMaterial(EMaterialTypes::Occluder) && DetectStaticCollision(mgr, prim, xf, filter, infoOut)) {
ret = true;
}
TUniqueId tmpId = kInvalidUniqueId;
if (DetectDynamicCollision(prim, xf, nearList, tmpId, infoOut, mgr)) {
ret = true;
idOut = tmpId;
}
return ret;
}
void CGameCollision::MakeCollisionCallbacks(CStateManager& mgr, CPhysicsActor& actor, TUniqueId id,
const CCollisionInfoList& list) {
actor.CollidedWith(id, list, mgr);

3
Runtime/Collision/CGameCollision.hpp
View File

@ -105,6 +105,9 @@ public:
const rstl::reserved_vector<TUniqueId, 1024>& nearList,
const zeus::CVector3f& vec, TUniqueId& idOut, CCollisionInfo& infoOut,
double& d, const CStateManager& mgr);
static bool DetectCollision(const CStateManager& mgr, const CCollisionPrimitive& prim, const zeus::CTransform& xf,
const CMaterialFilter& filter, const rstl::reserved_vector<TUniqueId, 1024>& nearList,
TUniqueId& idOut, CCollisionInfoList& infoOut);
static void MakeCollisionCallbacks(CStateManager& mgr, CPhysicsActor& actor, TUniqueId id,
const CCollisionInfoList& list);
static void SendScriptMessages(CStateManager& mgr, CActor& a0, CActor* a1, const CCollisionInfoList& list);

3
Runtime/Collision/CMaterialFilter.hpp
View File

@ -35,6 +35,9 @@ public:
constexpr const CMaterialList& GetExcludeList() const noexcept { return x8_exclude; }
constexpr CMaterialList& IncludeList() noexcept { return x0_include; }
constexpr CMaterialList& ExcludeList() noexcept { return x8_exclude; }
const CMaterialList& IncludeList() const noexcept { return x0_include; }
const CMaterialList& ExcludeList() const noexcept { return x8_exclude; }
constexpr bool Passes(const CMaterialList& list) const noexcept {
switch (x10_type) {

1
Runtime/MP1/World/CMakeLists.txt
View File

@ -32,6 +32,7 @@ set(MP1_WORLD_SOURCES
CMetroidPrimeExo.hpp CMetroidPrimeExo.cpp
CMetroidPrimeProjectile.hpp CMetroidPrimeProjectile.cpp
CMetroidPrimeRelay.hpp CMetroidPrimeRelay.cpp
CMetroidPrimeEssence.hpp CMetroidPrimeEssence.cpp
CNewIntroBoss.hpp CNewIntroBoss.cpp
COmegaPirate.hpp COmegaPirate.cpp
CParasite.hpp CParasite.cpp

724
Runtime/MP1/World/CMetroidPrimeEssence.cpp Normal file
View File

@ -0,0 +1,724 @@
#include "Runtime/MP1/World/CMetroidPrimeEssence.hpp"
#include "Runtime/CSimplePool.hpp"
#include "Runtime/CStateManager.hpp"
#include "Runtime/Collision/CCollisionActor.hpp"
#include "Runtime/Collision/CCollisionActorManager.hpp"
#include "Runtime/Collision/CGameCollision.hpp"
#include "Runtime/GameGlobalObjects.hpp"
#include "Runtime/Graphics/CBooRenderer.hpp"
#include "Runtime/Weapon/CGameProjectile.hpp"
#include "Runtime/World/CGameArea.hpp"
#include "Runtime/World/CPatternedInfo.hpp"
#include "Runtime/World/CPlayer.hpp"
#include "Runtime/World/CScriptWaypoint.hpp"
#include "Runtime/World/CWorld.hpp"
#include "DataSpec/DNAMP1/SFX/MetroidPrime.h"
#include "TCastTo.hpp" // Generated file, do not modify include path
namespace urde::MP1 {
namespace {
std::array<SSphereJointInfo, 1> skJointInfo{{
{"lockon_target_LCTR", 1.5f},
}};
std::array<u32, 4> skUnkInts1{{0, 1, 0, 2}};
std::array<u32, 3> skUnkInts2{{1, 2, 3}};
} // namespace
CMetroidPrimeEssence::CMetroidPrimeEssence(urde::TUniqueId uid, std::string_view name, const urde::CEntityInfo& info,
const zeus::CTransform& xf, urde::CModelData&& mData,
const urde::CPatternedInfo& pInfo, const urde::CActorParameters& actParms,
urde::CAssetId particle1, const urde::CDamageInfo& dInfo, float f1,
urde::CAssetId electric, u32 w1, urde::CAssetId particle2)
: CPatterned(ECharacter::MetroidPrimeEssence, uid, name, EFlavorType::Zero, info, xf, std::move(mData), pInfo,
EMovementType::Flyer, EColliderType::One, EBodyType::Flyer, actParms, EKnockBackVariant::Medium)
, x568_(g_SimplePool->GetObj({FOURCC('PART'), particle2}))
, x574_searchPath(nullptr, 3, pInfo.GetPathfindingIndex(), 1.f, 1.f)
, x660_(particle1)
, x664_(electric)
, x698_(dInfo)
, x6b4_(xf.origin)
, x70c_(CSfxManager::TranslateSFXID(w1)) {
CreateShadow(false);
MakeThermalColdAndHot();
}
void CMetroidPrimeEssence::Think(float dt, CStateManager& mgr) {
if (!GetActive()) {
return;
}
CPatterned::Think(dt, mgr);
if (IsAlive()) {
UpdatePhase(dt, mgr);
}
x450_bodyController->FaceDirection((mgr.GetPlayer().GetTranslation() - GetTranslation()).normalized(), dt);
x658_collisionManager->Update(dt, mgr, CCollisionActorManager::EUpdateOptions::ObjectSpace);
UpdateHealth(mgr);
CountListeningAi(mgr);
if (x70e_30_) {
x6d4_ = 2.f * dt + x6d4_;
if (x6d4_ >= 1.f) {
x6d4_ = 0.f;
}
sub8027ce5c(-4.f * x6d4_ * (x6d4_ - 1.f));
}
}
void CMetroidPrimeEssence::AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId other, CStateManager& mgr) {
CPatterned::AcceptScriptMsg(msg, other, mgr);
switch (msg) {
case EScriptObjectMessage::Activate:
x658_collisionManager->SetActive(mgr, true);
break;
case EScriptObjectMessage::Deactivate:
x658_collisionManager->SetActive(mgr, false);
break;
case EScriptObjectMessage::Start:
x70e_25_ = true;
break;
case EScriptObjectMessage::Stop:
x70e_25_ = false;
break;
case EScriptObjectMessage::Touched: {
if (TCastToPtr<CCollisionActor> colAct = mgr.ObjectById(other)) {
if (colAct->GetLastTouchedObject() == mgr.GetPlayer().GetUniqueId()) {
mgr.ApplyDamage(GetUniqueId(), mgr.GetPlayer().GetUniqueId(), GetUniqueId(), GetContactDamage(),
CMaterialFilter::MakeIncludeExclude({EMaterialTypes::Solid}, {}), zeus::skZero3f);
x420_curDamageRemTime = x424_damageWaitTime;
}
}
break;
}
case EScriptObjectMessage::Registered: {
SetupCollisionActorManager(mgr);
x658_collisionManager->SetActive(mgr, true);
x6cc_ = GetModelData()->GetScale().x();
x6d0_ = 0.9f * x6cc_ + x6cc_;
x55c_moveScale.splat(1.f / (0.625f * x6cc_));
const float hp = GetHealthInfo(mgr)->GetHP();
x6c0_ = 0.3f * hp;
if (hp > 0.f) {
x6c4_ = 1.f / hp;
}
x450_bodyController->Activate(mgr);
break;
}
case EScriptObjectMessage::Deleted: {
x658_collisionManager->Destroy(mgr);
mgr.SetBossParams(kInvalidUniqueId, 0.f, 0);
break;
}
case EScriptObjectMessage::InitializedInArea: {
x574_searchPath.SetArea(mgr.GetWorld()->GetArea(GetAreaIdAlways())->GetPostConstructed()->x10bc_pathArea);
x704_bossUtilityWaypointId = GetWaypointForState(mgr, EScriptObjectState::Play, EScriptObjectMessage::Activate);
break;
}
case EScriptObjectMessage::Damage: {
if (TCastToPtr<CCollisionActor> colAct = mgr.ObjectById(other)) {
if (TCastToConstPtr<CGameProjectile> proj = mgr.GetObjectById(colAct->GetLastTouchedObject())) {
if (proj->GetOwnerId() == mgr.GetPlayer().GetUniqueId()) {
if (colAct->GetDamageVulnerability()->WeaponHits(proj->GetDamageInfo().GetWeaponMode(), false) &&
proj->GetDamageInfo().GetWeaponMode().GetType() == EWeaponType::Phazon) {
sub8027cee0(mgr);
TakeDamage(zeus::skForward, 1.f);
if (!x70e_24_ && !x70e_26_) {
GetBodyController()->GetCommandMgr().DeliverCmd(
CBCKnockBackCmd{GetTransform().frontVector(), pas::ESeverity::One});
sub8027cce0(mgr);
}
}
}
}
} else if (TCastToConstPtr<CGameProjectile> proj = mgr.GetObjectById(other)) {
mgr.ApplyDamage(other, x706_lockOnTargetCollider, proj->GetOwnerId(), proj->GetDamageInfo(),
CMaterialFilter::MakeIncludeExclude({EMaterialTypes::Solid}, {}), zeus::skZero3f);
}
break;
}
default:
break;
}
}
void CMetroidPrimeEssence::PreRender(CStateManager& mgr, const zeus::CFrustum& frustum) {
CPatterned::PreRender(mgr, frustum);
}
void CMetroidPrimeEssence::AddToRenderer(const zeus::CFrustum& frustum, CStateManager& mgr) {
if (GetActive() && x65c_) {
g_Renderer->AddParticleGen(*x65c_);
}
CPatterned::AddToRenderer(frustum, mgr);
}
void CMetroidPrimeEssence::Render(CStateManager& mgr) {
if (x70e_27_) {
mgr.DrawSpaceWarp(x6b4_, 1.f);
}
CPatterned::Render(mgr);
}
zeus::CVector3f CMetroidPrimeEssence::GetAimPosition(const CStateManager& mgr, float dt) const {
if (TCastToConstPtr<CCollisionActor> colAct = mgr.GetObjectById(x706_lockOnTargetCollider)) {
return colAct->GetTranslation();
}
return CPatterned::GetAimPosition(mgr, dt);
}
void CMetroidPrimeEssence::DoUserAnimEvent(CStateManager& mgr, const CInt32POINode& node, EUserEventType type,
float dt) {
switch (type) {
case EUserEventType::EggLay: {
if (x70e_29_ && x6d8_ != 0 && x6e4_ < x6f8_) {
const float ang1 = zeus::degToRad(22.5f) * mgr.GetActiveRandom()->Range(-1, 1);
const float ang2 = zeus::degToRad(45.0f) * mgr.GetActiveRandom()->Range(-1, 1);
zeus::CVector3f pos =
x668_ * zeus::CVector3f{2.f * -std::sin(ang1), (2.f * (2.f * std::cos(ang1)) * std::sin(ang2)),
2.f * ((2.f * std::cos(ang1)) * std::cos(ang2))};
if (TCastToPtr<CScriptWaypoint> wp = mgr.ObjectById(x704_bossUtilityWaypointId)) {
wp->SetTransform(zeus::lookAt(pos, mgr.GetPlayer().GetAimPosition(mgr, 0.f)));
if (sub8027e870(wp->GetTransform(), mgr)) {
SendScriptMsgs(EScriptObjectState::Zero, mgr, EScriptObjectMessage::None);
x6b4_ = wp->GetTranslation();
}
}
}
return;
}
case EUserEventType::EventStart: {
if (!x70e_31_) {
SendScriptMsgs(EScriptObjectState::CameraTarget, mgr, EScriptObjectMessage::None);
x70e_31_ = true;
}
return;
}
case EUserEventType::BeginAction: {
SShockWaveData data(x660_, x698_, 2.f, x664_, x70c_);
// TODO: Need to fix CElementGen accessing null ParticleAccessParameters
// data.SetSpeedIncrease(180.f);
DropShockwave(mgr, data);
ShakeCamera(mgr, 1.f);
return;
}
case EUserEventType::Activate: {
sub8027d824(mgr);
return;
}
case EUserEventType::Deactivate:
x70e_27_ = false;
[[fallthrough]];
default:
break;
}
CPatterned::DoUserAnimEvent(mgr, node, type, dt);
}
void CMetroidPrimeEssence::Death(CStateManager& mgr, const zeus::CVector3f& direction, EScriptObjectState state) {
if (!IsAlive()) {
return;
}
KillAiInArea(mgr);
SetParticleEffectState(mgr, false);
if (TCastToPtr<CCollisionActor> colAct = mgr.ObjectById(x706_lockOnTargetCollider)) {
colAct->AddMaterial(EMaterialTypes::ProjectilePassthrough, mgr);
}
CPatterned::Death(mgr, direction, state);
}
void CMetroidPrimeEssence::Dead(CStateManager& mgr, EStateMsg msg, float dt) {
if (msg != EStateMsg::Update || GetModelData()->GetAnimationData()->IsAnimTimeRemaining(dt, "Whole Body"sv)) {
return;
}
DeathDelete(mgr);
}
void CMetroidPrimeEssence::PathFind(CStateManager& mgr, EStateMsg msg, float dt) {
CPatterned::PathFind(mgr, msg, dt);
if (msg == EStateMsg::Update) {
sub8027cb40(mgr.GetPlayer().GetTranslation());
}
}
void CMetroidPrimeEssence::Halt(CStateManager& mgr, EStateMsg msg, float dt) {
// Intentionally empty
}
void CMetroidPrimeEssence::Generate(CStateManager& mgr, EStateMsg msg, float dt) {
if (msg == EStateMsg::Activate) {
zeus::CVector3f lookPos = mgr.GetPlayer().GetTranslation();
lookPos.z() = GetTranslation().z();
zeus::CTransform xf = zeus::lookAt(GetTranslation(), lookPos);
xf.origin = GetTranslation();
SetTransform(xf);
} else if (msg == EStateMsg::Deactivate) {
mgr.SetBossParams(GetUniqueId(), GetHealthInfo(mgr)->GetHP(), 91);
SetParticleEffectState(mgr, true);
}
}
void CMetroidPrimeEssence::JumpBack(CStateManager& mgr, EStateMsg msg, float dt) {
if (msg == EStateMsg::Activate) {
x32c_animState = EAnimState::Ready;
x700_ = sub8027cfd4(mgr, true);
} else if (msg == EStateMsg::Update) {
TryCommand(mgr, pas::EAnimationState::Step, &CPatterned::TryStep, x700_);
} else if (msg == EStateMsg::Deactivate) {
x32c_animState = EAnimState::NotReady;
}
}
void CMetroidPrimeEssence::Skid(CStateManager& mgr, EStateMsg msg, float dt) {
if (msg == EStateMsg::Activate) {
x32c_animState = EAnimState::Ready;
} else if (msg == EStateMsg::Update) {
TryCommand(mgr, pas::EAnimationState::Step, &CPatterned::TryStep, 5);
} else if (msg == EStateMsg::Deactivate) {
x32c_animState = EAnimState::NotReady;
}
}
void CMetroidPrimeEssence::FadeIn(CStateManager& mgr, EStateMsg msg, float dt) {
if (msg == EStateMsg::Activate) {
x6f8_ = sub8027d428();
x32c_animState = EAnimState::Ready;
x70e_24_ = true;
} else if (msg == EStateMsg::Update) {
TryCommand(mgr, pas::EAnimationState::ProjectileAttack, &CPatterned::TryProjectileAttack, 0);
} else if (msg == EStateMsg::Deactivate) {
x70e_24_ = false;
x70e_27_ = false;
x70e_29_ = false;
x70e_30_ = false;
x32c_animState = EAnimState::NotReady;
}
}
void CMetroidPrimeEssence::FadeOut(CStateManager& mgr, EStateMsg msg, float dt) {
if (msg != EStateMsg::Activate) {
return;
}
DoPhaseTransition(mgr);
}
void CMetroidPrimeEssence::Taunt(CStateManager& mgr, EStateMsg msg, float dt) {
if (msg == EStateMsg::Activate) {
x32c_animState = EAnimState::Ready;
} else if (msg == EStateMsg::Update) {
TryCommand(mgr, pas::EAnimationState::Taunt, &CPatterned::TryTaunt, 2);
} else if (msg == EStateMsg::Deactivate) {
x32c_animState = EAnimState::NotReady;
}
}
void CMetroidPrimeEssence::TelegraphAttack(CStateManager& mgr, EStateMsg msg, float dt) {
if (msg == EStateMsg::Activate) {
x32c_animState = EAnimState::Ready;
x70e_30_ = true;
} else if (msg == EStateMsg::Update) {
if (!x70e_31_) {
TryCommand(mgr, pas::EAnimationState::MeleeAttack, &CPatterned::TryMeleeAttack, 2);
} else {
TryCommand(mgr, pas::EAnimationState::ProjectileAttack, &CPatterned::TryProjectileAttack, 5);
}
} else if (msg == EStateMsg::Deactivate) {
x32c_animState = EAnimState::NotReady;
x70e_30_ = false;
sub8027ce5c(dt);
}
}
void CMetroidPrimeEssence::Dodge(CStateManager& mgr, EStateMsg msg, float dt) {
if (msg == EStateMsg::Activate) {
x32c_animState = EAnimState::Ready;
x700_ = sub8027cfd4(mgr, false);
} else if (msg == EStateMsg::Update) {
TryCommand(mgr, pas::EAnimationState::Step, &CPatterned::TryStep, x700_);
} else if (msg == EStateMsg::Deactivate) {
x32c_animState = EAnimState::NotReady;
}
}
void CMetroidPrimeEssence::PathFindEx(CStateManager& mgr, EStateMsg msg, float dt) {
CPatterned::PathFind(mgr, msg, dt);
if (msg == EStateMsg::Activate) {
x70e_24_ = true;
} else if (msg == EStateMsg::Update) {
sub8027cb40(x2e0_destPos);
} else if (msg == EStateMsg::Deactivate) {
x70e_24_ = false;
}
}
bool CMetroidPrimeEssence::HasPatrolPath(CStateManager& mgr, float dt) {
return !x70e_31_ && CPatterned::HasPatrolPath(mgr, dt);
}
bool CMetroidPrimeEssence::ShouldAttack(CStateManager& mgr, float dt) {
if (x70e_31_) {
return x70e_25_;
}
return true;
}
bool CMetroidPrimeEssence::InPosition(CStateManager& mgr, float dt) {
return (GetTranslation().z() - mgr.GetPlayer().GetTranslation().z()) > 0.25f;
}
bool CMetroidPrimeEssence::CoverFind(CStateManager& mgr, float dt) {
return (x2e0_destPos - GetTranslation()).magSquared() < 90.f;
}
bool CMetroidPrimeEssence::ShouldTaunt(CStateManager& mgr, float dt) {
const CHealthInfo* info = GetHealthInfo(mgr);
if (!info || info->GetHP() <= x6c0_) {
return false;
}
return mgr.GetActiveRandom()->Next() % 100 < 50;
}
bool CMetroidPrimeEssence::ShouldCrouch(CStateManager& mgr, float dt) {
if (x6f0_ < x6f4_) {
++x6f0_;
return false;
}
x6f4_ = std::min(static_cast<u32>(3.f * (1.f - x6c4_ * GetHealthInfo(mgr)->GetHP())), x6ec_);
x6f0_ = 0;
return true;
}
bool CMetroidPrimeEssence::ShouldMove(CStateManager& mgr, float dt) { return x70e_31_; }
CPathFindSearch* CMetroidPrimeEssence::GetSearchPath() { return &x574_searchPath; }
void CMetroidPrimeEssence::sub8027cb40(const zeus::CVector3f& vec) {
pas::EStepDirection stepDir = GetStepDirection(GetBodyController()->GetCommandMgr().GetMoveVector());
GetBodyController()->GetCommandMgr().ClearLocomotionCmds();
if (stepDir == pas::EStepDirection::Forward &&
GetTransform().frontVector().normalized().dot((x2e0_destPos - GetTranslation()).normalized()) <
zeus::degToRad(-15.f)) {
stepDir = pas::EStepDirection::Backward;
}
GetBodyController()->GetCommandMgr().DeliverCmd(CBCStepCmd(stepDir, pas::EStepType::Normal));
GetBodyController()->GetCommandMgr().DeliverTargetVector(vec - GetTranslation());
}
void CMetroidPrimeEssence::sub8027cce0(CStateManager& mgr) {
if (CSfxManager::IsPlaying(x708_)) {
return;
}
CAudioSys::C3DEmitterParmData emitterData{zeus::skZero3f, zeus::skZero3f, 1000.f, 0.1f, 1, SFXsfx0B67, 1.f,
0.16f, false, 127};
emitterData.x0_pos = GetTargetTransform(mgr).origin;
x708_ = CSfxManager::AddEmitter(emitterData, true, 127, false, GetAreaIdAlways());
}
zeus::CTransform CMetroidPrimeEssence::GetTargetTransform(CStateManager& mgr) {
if (TCastToPtr<CCollisionActor> colAct = mgr.ObjectById(x706_lockOnTargetCollider)) {
return colAct->GetTransform();
}
return GetTransform();
}
void CMetroidPrimeEssence::sub8027ce5c(float dt) {
const auto matCount = static_cast<float>(GetModelData()->GetNumMaterialSets() - 2);
u32 iVar1 = matCount - (matCount * dt);
if (x6fc_ != iVar1) {
x6fc_ = iVar1;
}
}
void CMetroidPrimeEssence::sub8027cee0(CStateManager& mgr) {
const float hp = x6c4_ * GetHealthInfo(mgr)->GetHP();
if (hp <= 0.f) {
return;
}
bool sendMsg = false;
if (x6d8_ == 0 && hp < 0.75f) {
x6d8_ = 1;
} else if (x6d8_ == 1 && hp < 0.5f) {
sendMsg = true;
x6d8_ = 2;
} else if (x6d8_ == 2 && hp < 0.25f) {
sendMsg = true;
x6d8_ = 3;
}
if (sendMsg) {
SendScriptMsgs(EScriptObjectState::DeactivateState, mgr, EScriptObjectMessage::None);
}
}
u32 CMetroidPrimeEssence::sub8027cfd4(CStateManager& mgr, bool w1) {
auto startIndex = static_cast<size_t>(!w1);
zeus::CTransform xf = GetTargetTransform(mgr);
std::array<zeus::CVector3f, 3> directions;
directions[0] = -xf.frontVector();
directions[2] = xf.rightVector();
directions[1] = -directions[2];
u32 uVar5 = 1 << size_t(startIndex);
for (auto i = size_t(startIndex); i < 3; ++i) {
CRayCastResult res = mgr.RayStaticIntersection(xf.origin, directions[i], 20.f, CMaterialFilter::skPassEverything);
if (res.IsInvalid()) {
uVar5 |= 1 << i;
}
}
u32 uVar3 = 0;
if (uVar5 < 8) {
u32 numBits = zeus::PopCount(uVar5);
if (numBits == 2) {
u32 uVar1_ = mgr.GetActiveRandom()->Next();
if ((uVar1_ & 1) == false) {
uVar3 = (uVar5 & 1) ^ 1;
} else {
uVar3 = ((uVar5 >> 2) & 1) + 1;
}
} else if (numBits < 2) {
uVar3 = uVar5 >> 1;
} else if (numBits == 3) {
uVar3 = mgr.GetActiveRandom()->Range(startIndex, 2);
}
}
return skUnkInts2[uVar3];
}
void CMetroidPrimeEssence::DoPhaseTransition(CStateManager& mgr) {
x330_stateMachineState.SetDelay(2.f);
x70e_26_ = true;
x70e_27_ = true;
x6c8_ = 1.f;
x70e_29_ = false;
bool uVar3 = x6dc_ == skUnkInts1[size_t(mgr.GetPlayerState()->GetCurrentVisor())];
if (skUnkInts1[size_t(mgr.GetPlayerState()->GetCurrentVisor())] == x6dc_) {
x65c_ = std::make_unique<CElementGen>(x568_, CElementGen::EModelOrientationType::Normal,
CElementGen::EOptionalSystemFlags::One);
if (x65c_) {
zeus::CTransform xf = GetTargetTransform(mgr);
x65c_->SetGlobalScale(GetModelData()->GetScale());
x65c_->SetGlobalOrientation(xf.getRotation());
x65c_->SetGlobalTranslation(xf.origin);
}
}
CSfxManager::AddEmitter(SFXsfx0B7D + uVar3, GetTranslation(), zeus::skZero3f, true, false, 127, kInvalidAreaId);
x6e0_ = x6dc_;
++x6dc_;
if (x6dc_ > 2) {
x6dc_ = 0;
}
}
void CMetroidPrimeEssence::ShakeCamera(CStateManager& mgr, float f1) {
float mag = 0.5f - (0.01f * (GetTranslation() - mgr.GetPlayer().GetTranslation()).magnitude());
if (mag < 0.f || mgr.GetPlayer().GetSurfaceRestraint() == CPlayer::ESurfaceRestraints::Air) {
return;
}
mgr.GetCameraManager()->AddCameraShaker(CCameraShakeData(0.5f, mag), true);
}
void CMetroidPrimeEssence::DropShockwave(CStateManager& mgr, const SShockWaveData& shockWaveData) {
CRayCastResult res = RayStaticIntersection(mgr);
if (res.IsInvalid()) {
return;
}
mgr.AddObject(new CShockWave(mgr.AllocateUniqueId(), "Shockwave", CEntityInfo(GetAreaIdAlways(), NullConnectionList),
zeus::CTransform::Translate(res.GetPoint()), GetUniqueId(), shockWaveData, 1.5f, 0.5f));
}
CRayCastResult CMetroidPrimeEssence::RayStaticIntersection(CStateManager& mgr) {
return mgr.RayStaticIntersection(GetTranslation(), -zeus::skUp, 30.f, CMaterialFilter::skPassEverything);
}
void CMetroidPrimeEssence::SetParticleEffectState(CStateManager& mgr, bool active) {
GetModelData()->GetAnimationData()->SetParticleEffectState("Eyes"sv, active, mgr);
GetModelData()->GetAnimationData()->SetParticleEffectState("Head"sv, active, mgr);
}
void CMetroidPrimeEssence::sub8027d824(CStateManager& mgr) {
CRayCastResult res = RayStaticIntersection(mgr);
if (res.IsInvalid()) {
return;
}
x668_ = zeus::CTransform::Translate(res.GetPoint());
if (TCastToPtr<CScriptWaypoint> wp = mgr.ObjectById(x704_bossUtilityWaypointId)) {
wp->SetTransform(x668_);
SendScriptMsgs(EScriptObjectState::AboutToMassivelyDie, mgr, EScriptObjectMessage::None);
x70e_29_ = true;
}
}
bool CMetroidPrimeEssence::sub8027e870(const zeus::CTransform& xf, CStateManager& mgr) {
rstl::reserved_vector<TUniqueId, 1024> nearList;
mgr.BuildNearList(nearList, {xf.origin - 2.f, xf.origin + 2.f}, CMaterialFilter::MakeInclude(EMaterialTypes::AIBlock),
this);
CCollidableSphere sphere({zeus::skZero3f, 2.f}, CMaterialList(EMaterialTypes::Solid, EMaterialTypes::AIBlock));
CCollisionInfoList infoList;
TUniqueId tmpId = kInvalidUniqueId;
CGameCollision::DetectCollision(
mgr, sphere, xf,
CMaterialFilter::MakeIncludeExclude(
{EMaterialTypes ::Solid, EMaterialTypes ::Player, EMaterialTypes ::Character, EMaterialTypes ::AIBlock},
{EMaterialTypes ::ProjectilePassthrough}),
nearList, tmpId, infoList);
if (infoList.GetCount() >= 1) {
return false;
}
if (TCastToPtr<CCollisionActor> colAct = mgr.ObjectById(x706_lockOnTargetCollider)) {
zeus::CVector3f direction = (xf.origin - colAct->GetTranslation()).normalized();
CRayCastResult res =
mgr.RayStaticIntersection(colAct->GetTranslation(), direction, direction.magnitude(),
CMaterialFilter::MakeExclude({EMaterialTypes::ProjectilePassthrough}));
if (res.IsInvalid()) {
return true;
}
}
return false;
}
void CMetroidPrimeEssence::KillAiInArea(CStateManager& mgr) {
for (auto* ent : mgr.GetListeningAiObjectList()) {
if (TCastToPtr<CAi> ai = ent) {
if (ai != this && ai->GetActive() && ai->GetAreaIdAlways() == GetAreaIdAlways()) {
static_cast<CPatterned*>(ai.GetPtr())->MassiveDeath(mgr);
}
}
}
}
void CMetroidPrimeEssence::CountListeningAi(CStateManager& mgr) {
x6e0_ = 0;
for (auto* ent : mgr.GetListeningAiObjectList()) {
if (TCastToPtr<CAi> ai = ent) {
if (ai != this && ai->GetActive() && ai->GetAreaIdAlways() == GetAreaIdAlways()) {
++x6e4_;
}
}
}
}
void CMetroidPrimeEssence::UpdatePhase(float dt, CStateManager& mgr) {
if (skUnkInts1[size_t(mgr.GetPlayerState()->GetCurrentVisor())] == x6dc_) {
x42c_color.a() = 1.f - x6c8_;
GetModelData()->SetScale(zeus::CVector3f((x6cc_ - x6d0_) + x6d0_));
if (!x70e_28_) {
AddMaterial(EMaterialTypes::Orbit, EMaterialTypes::Target, mgr);
SetParticleEffectState(mgr, true);
x70e_28_ = true;
}
} else {
x42c_color.a() = skUnkInts1[size_t(mgr.GetPlayerState()->GetCurrentVisor())] == x6e0_ ? x6c8_ : 0.f;
GetModelData()->SetScale(zeus::CVector3f((x6cc_ - x6d0_) + x6d0_));
if (x70e_28_) {
RemoveMaterial(EMaterialTypes::Orbit, EMaterialTypes::Target, mgr);
SetParticleEffectState(mgr, false);
x70e_28_ = false;
}
}
zeus::CTransform xf = GetTargetTransform(mgr);
if (x70e_26_) {
x6c8_ -= 0.5f * dt;
x6b4_ = xf.origin;
if (x6c8_ < 0.f) {
x6c8_ = 0.f;
x70e_26_ = false;
x70e_27_ = false;
}
}
if (!x65c_) {
return;
}
if (!x65c_->IsSystemDeletable()) {
x65c_->SetGlobalOrientation(xf.getRotation());
x65c_->SetGlobalTranslation(xf.origin);
x65c_->Update(dt);
} else {
x65c_.reset();
}
}
void CMetroidPrimeEssence::UpdateHealth(CStateManager& mgr) {
if (!IsAlive()) {
return;
}
if (TCastToPtr<CCollisionActor> colAct = mgr.ObjectById(x706_lockOnTargetCollider)) {
colAct->SetDamageVulnerability(*GetDamageVulnerability());
HealthInfo(mgr)->SetHP(colAct->GetHealthInfo(mgr)->GetHP());
}
if (GetHealthInfo(mgr)->GetHP() <= 0.f) {
Death(mgr, zeus::skZero3f, EScriptObjectState::DeathRattle);
RemoveMaterial(EMaterialTypes::Orbit, EMaterialTypes::Target, mgr);
}
}
void CMetroidPrimeEssence::SetLockOnTargetHealthAndDamageVulns(CStateManager& mgr) {
if (TCastToPtr<CCollisionActor> colAct = mgr.ObjectById(x706_lockOnTargetCollider)) {
*colAct->HealthInfo(mgr) = *HealthInfo(mgr);
colAct->SetDamageVulnerability(*GetDamageVulnerability());
}
}
void CMetroidPrimeEssence::AddSphereCollisions(SSphereJointInfo* info, size_t count,
std::vector<CJointCollisionDescription>& vecOut) {
const CAnimData* animData = GetModelData()->GetAnimationData();
for (size_t i = 0; i < count; ++i) {
CSegId segId = animData->GetLocatorSegId(info[i].name);
if (segId.IsInvalid()) {
continue;
}
vecOut.push_back(CJointCollisionDescription::SphereCollision(segId, info[i].radius, info[i].name, 1000.f));
}
}
void CMetroidPrimeEssence::SetupCollisionActorManager(CStateManager& mgr) {
std::vector<CJointCollisionDescription> joints;
AddSphereCollisions(skJointInfo.data(), skJointInfo.size(), joints);
x658_collisionManager =
std::make_unique<CCollisionActorManager>(mgr, GetUniqueId(), GetAreaIdAlways(), joints, false);
for (size_t i = 0; i < x658_collisionManager->GetNumCollisionActors(); ++i) {
const auto& info = x658_collisionManager->GetCollisionDescFromIndex(i);
if (TCastToPtr<CCollisionActor> colAct = mgr.ObjectById(info.GetCollisionActorId())) {
if (info.GetName() == "lockon_target_LCTR"sv) {
x706_lockOnTargetCollider = info.GetCollisionActorId();
}
}
}
SetLockOnTargetHealthAndDamageVulns(mgr);
SetMaterialFilter(CMaterialFilter::MakeIncludeExclude(
{EMaterialTypes::Solid}, {EMaterialTypes::CollisionActor, EMaterialTypes::Player, EMaterialTypes::Character}));
AddMaterial(EMaterialTypes::ProjectilePassthrough, mgr);
}
} // namespace urde::MP1

111
Runtime/MP1/World/CMetroidPrimeEssence.hpp Normal file
View File

@ -0,0 +1,111 @@
#pragma once
#include "Runtime/Collision/CJointCollisionDescription.hpp"
#include "Runtime/MP1/World/CShockWave.hpp"
#include "Runtime/World/CPathFindSearch.hpp"
#include "Runtime/World/CPatterned.hpp"
namespace urde {
class CCollisionActorManager;
namespace MP1 {
class CMetroidPrimeEssence : public CPatterned {
TCachedToken<CGenDescription> x568_;
CPathFindSearch x574_searchPath;
std::unique_ptr<CCollisionActorManager> x658_collisionManager;
std::unique_ptr<CElementGen> x65c_;
CAssetId x660_;
CAssetId x664_;
zeus::CTransform x668_;
CDamageInfo x698_;
zeus::CVector3f x6b4_;
float x6c0_ = 0.f;
float x6c4_ = 0.f;
float x6c8_ = 0.f;
float x6cc_ = 4.f;
float x6d0_ = 0.9f * x6cc_ + x6cc_;
float x6d4_ = 0.f;
u32 x6d8_ = 0;
u32 x6dc_ = 0;
u32 x6e0_ = x6dc_;
u32 x6e4_ = 0;
u32 x6e8_ = 2;
u32 x6ec_ = 4;
u32 x6f0_ = 0;
u32 x6f4_ = x6e8_ - 1;
u32 x6f8_ = 2;
u32 x6fc_ = 0;
u32 x700_ = 1;
TUniqueId x704_bossUtilityWaypointId = kInvalidUniqueId;
TUniqueId x706_lockOnTargetCollider = kInvalidUniqueId;
CSfxHandle x708_;
s16 x70c_;
bool x70e_24_ : 1 = false;
bool x70e_25_ : 1 = true;
bool x70e_26_ : 1 = false;
bool x70e_27_ : 1 = false;
bool x70e_28_ : 1 = true;
bool x70e_29_ : 1 = false;
bool x70e_30_ : 1 = false;
bool x70e_31_ : 1 = false;
void sub8027cb40(const zeus::CVector3f& vec);
void sub8027cce0(CStateManager& mgr);
zeus::CTransform GetTargetTransform(CStateManager& mgr);
void sub8027ce5c(float f1);
void sub8027cee0(CStateManager& mgr);
u32 sub8027cfd4(CStateManager& mgr, bool w1);
void DoPhaseTransition(CStateManager& mgr);
u32 sub8027d428() { return 2; /* Decided by fair dice roll, guaranteed to be random */}
void ShakeCamera(CStateManager& mgr, float f1);
void DropShockwave(CStateManager& mgr, const SShockWaveData& shockWaveData);
CRayCastResult RayStaticIntersection(CStateManager& mgr);
void SetParticleEffectState(CStateManager& mgr, bool active);
void sub8027d824(CStateManager& mgr);
bool sub8027e870(const zeus::CTransform& xf, CStateManager& mgr);
void KillAiInArea(CStateManager& mgr);
void CountListeningAi(CStateManager& mgr);
void UpdatePhase(float dt, CStateManager& mgr);
void UpdateHealth(CStateManager& mgr);
void SetLockOnTargetHealthAndDamageVulns(CStateManager& mgr);
void AddSphereCollisions(SSphereJointInfo* info, size_t count, std::vector<CJointCollisionDescription>& vecOut);
void SetupCollisionActorManager(CStateManager& mgr);
public:
DEFINE_PATTERNED(MetroidPrimeEssence);
CMetroidPrimeEssence(TUniqueId uid, std::string_view name, const CEntityInfo& info, const zeus::CTransform& xf,
CModelData&& mData, const CPatternedInfo& pInfo, const CActorParameters& actParms,
CAssetId particle1, const CDamageInfo& dInfo, float f1, CAssetId electric, u32 w1,
CAssetId particle2);
void Think(float dt, CStateManager& mgr) override;
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId other, CStateManager& mgr) override;
void PreRender(CStateManager& mgr, const zeus::CFrustum& frustum) override;
void AddToRenderer(const zeus::CFrustum& frustum, CStateManager& mgr) override;
void Render(CStateManager& mgr) override;
zeus::CVector3f GetAimPosition(const CStateManager& mgr, float dt) 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 Dead(CStateManager& mgr, EStateMsg msg, float dt) override;
void PathFind(CStateManager& mgr, EStateMsg msg, float dt) override;
void Halt(CStateManager& mgr, EStateMsg msg, float dt) override;
void Generate(CStateManager& mgr, EStateMsg msg, float dt) override;
void JumpBack(CStateManager& mgr, EStateMsg msg, float dt) override;
void Skid(CStateManager& mgr, EStateMsg msg, float dt) override;
void FadeIn(CStateManager& mgr, EStateMsg msg, float dt) override;
void FadeOut(CStateManager& mgr, EStateMsg msg, float dt) override;
void Taunt(CStateManager& mgr, EStateMsg msg, float dt) override;
void TelegraphAttack(CStateManager& mgr, EStateMsg msg, float dt) override;
void Dodge(CStateManager& mgr, EStateMsg msg, float dt) override;
void PathFindEx(CStateManager& mgr, EStateMsg msg, float dt) override;
bool HasPatrolPath(CStateManager& mgr, float dt) override;
bool ShouldAttack(CStateManager& mgr, float dt) override;
bool InPosition(CStateManager& mgr, float dt) override;
bool CoverFind(CStateManager& mgr, float dt) override;
bool ShouldTaunt(CStateManager& mgr, float dt) override;
bool ShouldCrouch(CStateManager& mgr, float dt) override;
bool ShouldMove(CStateManager& mgr, float dt) override;
CPathFindSearch* GetSearchPath() override;
};
} // namespace MP1
} // namespace urde

1812
Runtime/MP1/World/CMetroidPrimeExo.cpp
View File

File diff suppressed because it is too large Load Diff

253
Runtime/MP1/World/CMetroidPrimeExo.hpp
View File

@ -1,17 +1,24 @@
#pragma once
#include "Runtime/rstl.hpp"
#include "Runtime/Camera/CCameraShakeData.hpp"
#include "Runtime/Character/CBoneTracking.hpp"
#include "Runtime/MP1/World/CMetroidPrimeProjectile.hpp"
#include "Runtime/Weapon/CBeamInfo.hpp"
#include "Runtime/Weapon/CPlasmaProjectile.hpp"
#include "Runtime/Weapon/CProjectileInfo.hpp"
#include "Runtime/World/CActorParameters.hpp"
#include "Runtime/World/CPatterned.hpp"
#include "Runtime/World/CPatternedInfo.hpp"
#include "Runtime/rstl.hpp"
#include <zeus/CColor.hpp>
namespace urde {
class CCameraShakeData;
class CCollisionActorManager;
class CGenDescription;
class CElementGen;
class CProjectedShadow;
namespace MP1 {
@ -29,24 +36,11 @@ struct SPrimeStruct2B {
explicit SPrimeStruct2B(CInputStream& in);
};
struct SPrimeStruct5 {
u32 x0_propertyCount;
CAssetId x4_;
u32 x8_;
CAssetId xc_;
CAssetId x10_;
u32 x14_;
u32 x18_;
u32 x1c_;
u32 x20_;
explicit SPrimeStruct5(CInputStream& in);
};
struct SPrimeStruct4 {
CBeamInfo x0_beamInfo;
u32 x44_;
CDamageInfo x48_dInfo1;
SPrimeStruct5 x64_struct5;
CPlasmaProjectile::PlayerEffectResources x64_struct5;
float x88_;
CDamageInfo x8c_dInfo2;
explicit SPrimeStruct4(CInputStream& in);
@ -56,8 +50,7 @@ struct SPrimeStruct6 {
u32 x0_propertyCount;
CDamageVulnerability x4_damageVulnerability;
zeus::CColor x6c_color;
u32 x70_;
u32 x74_;
std::array<u32, 2> x70_;
explicit SPrimeStruct6(CInputStream& in);
};
@ -92,9 +85,182 @@ struct SPrimeExoParameters {
struct SPrimeExoRoomParameters {
rstl::reserved_vector<float, 14> x0_;
explicit SPrimeExoRoomParameters(CInputStream& in);
float GetFloatValue(size_t idx) const { return x0_[idx]; }
};
class CMetroidPrimeExo : public CPatterned {
class CPhysicsDummy : public CPhysicsActor {
public:
CPhysicsDummy(TUniqueId uid, bool active, std::string_view name, const CEntityInfo& info)
: CPhysicsActor(uid, active, name, info, {}, CModelData::CModelDataNull(),
CMaterialList(EMaterialTypes::Target, EMaterialTypes::ExcludeFromRadar), zeus::CAABox{-1.f, 1.f},
SMoverData(1.f), CActorParameters::None(), 0.3f, 0.1f) {}
void Accept(IVisitor& visitor) override;
};
TUniqueId x568_relayId = kInvalidUniqueId;
std::unique_ptr<CCollisionActorManager> x56c_collisionManager;
s32 x570_ = 1;
u32 x574_ = 1;
u32 x578_ = 0;
u32 x57c_ = 0;
u32 x580_ = 0;
bool x584_ = false;
rstl::reserved_vector<SPrimeStruct6, 4> x588_;
rstl::reserved_vector<CBoneTracking, 6> x76c_;
CHealthInfo x8c0_ = CHealthInfo(150.f, 0.f);
float x8c8_ = 0.f;
TUniqueId x8cc_headColActor = kInvalidUniqueId;
u32 x8d0_ = 3;
u32 x8d4_ = 3;
zeus::CColor x8d8_ = zeus::skBlack;
zeus::CColor x8dc_ = zeus::skBlack;
zeus::CColor x8e0_ = zeus::skBlack;
float x8e4_ = 0.f;
s32 x8e8_headUpAdditiveBodyAnimIndex;
float x8ec_ = 0.f;
float x8f0_ = 0.f;
bool x8f4_24_ : 1 = false;
bool x8f4_25_ : 1 = false;
bool x8f4_26_ : 1 = false;
bool x8f4_27_ : 1 = false;
bool x8f4_28_ : 1 = false;
zeus::CAABox x8f8_;
float x910_ = 5.f;
bool x914_24_ : 1 = false;
s32 x918_ = -1;
s32 x91c_;
float x920_ = 0.f;
float x924_ = 4.f;
float x928_ = 5.f;
u32 x92c_ = 0;
SPrimeStruct2B x930_;
rstl::reserved_vector<CBeamInfo, 4> x96c_;
rstl::reserved_vector<CProjectileInfo, 4> xa80_;
rstl::reserved_vector<TUniqueId, 4> xb24_plasmaProjectileIds = {{kInvalidUniqueId, kInvalidUniqueId, kInvalidUniqueId,
kInvalidUniqueId}};
rstl::reserved_vector<CPlasmaProjectile::PlayerEffectResources, 4> xb30_;
rstl::reserved_vector<CDamageInfo, 4> xbc4_;
TLockedToken<CGenDescription> xc48_;
std::unique_ptr<CElementGen> xc50_;
s32 xc58_curPlasmaProjectile = -1;
float xc5c_ = 0.f;
zeus::CVector3f xc60_;
zeus::CVector3f xc6c_;
CProjectileInfo xc78_;
CCameraShakeData xca0_;
CProjectileInfo xd74_;
CCameraShakeData xd9c_;
SPrimeProjectileInfo xe70_;
TUniqueId xeac_ = kInvalidUniqueId;
u32 xeb0_ = 0;
CDamageInfo xeb4_;
CCameraShakeData xed0_;
TLockedToken<CElectricDescription> xfa4_;
std::unique_ptr<CParticleElectric> xfac_;
float xfb4_ = 0.f;
float xfb8_ = 0.f;
CSfxHandle xfbc_;
bool xfc0_ = false;
bool xfc1_ = false;
rstl::reserved_vector<TToken<CGenDescription>, 2> xfc4_;
rstl::reserved_vector<TToken<CSwooshDescription>, 2> xfd8_;
rstl::reserved_vector<std::unique_ptr<CElementGen>, 2> xfec_;
rstl::reserved_vector<std::unique_ptr<CParticleSwoosh>, 2> x1000_;
TToken<CGenDescription> x1014_;
TToken<CGenDescription> x101c_;
std::unique_ptr<CElementGen> x1024_;
rstl::reserved_vector<float, 2> x102c_;
rstl::reserved_vector<float, 2> x1038_;
TUniqueId x1044_billboardId = kInvalidUniqueId;
TUniqueId x1046_ = kInvalidUniqueId;
float x1048_ = 0.f;
float x104c_ = 75.f;
float x1050_ = 0.f;
bool x1054_24_ : 1 = false;
bool x1054_25_ : 1 = false;
bool x1054_26_ : 1 = false;
bool x1054_27_ : 1 = false;
rstl::reserved_vector<TUniqueId, 2> x106c_energyBallIds;
float x1074_ = 0.f;
s32 x1078_ = -1;
float x107c_ = 0.f;
float x1080_;
float x1084_ = 0.f;
float x1088_ = 0.f;
CCameraShakeData x108c_;
rstl::reserved_vector<SPrimeExoRoomParameters, 4> x1160_;
s32 x1254_ = -1;
rstl::reserved_vector<float, 14> x1258_;
CCameraShakeData x1294_;
CCameraShakeData x1368_;
std::unique_ptr<CProjectedShadow> x143c_;
s32 x1440_ = 0;
bool x1444_24_ : 1 = false;
bool x1444_25_ : 1 = false;
void sub802738d4(CStateManager& mgr);
void UpdateEnergyBalls(float dt, CStateManager& mgr);
u32 CountEnergyBalls(CStateManager& mgr);
void sub80273d38(CStateManager& mgr);
void UpdatePhysicsDummy(CStateManager& mgr);
void sub80274054(CStateManager& mgr);
void sub802740cc(CStateManager& mgr);
void CreatePhysicsDummy(CStateManager& mgr);
void SetBillboardEmission(CStateManager& mgr, bool emission);
void FreeBillboard(CStateManager& mgr);
zeus::CVector3f sub8027464c(CStateManager& mgr);
void CreateHUDBillBoard(CStateManager& mgr);
void sub802747b8(float f1, CStateManager& mgr, const zeus::CVector3f& vec);
void sub802749e8(float f1, float f2, float f3, const zeus::CVector3f& vec1, const zeus::CVector3f& vec2);
void sub80274e6c(float f1, CStateManager& mgr);
void sub802755ac(CStateManager& mgr, bool b1);
void EnableHeadOrbitAndTarget(CStateManager& mgr);
void DisableHeadOrbitAndTarget(CStateManager& mgr);
void UpdateTimers(float mgr);
void sub80275800(CStateManager& mgr);
void sub802759a8(CStateManager& mgr, u32 w1);
float sub80275b04(const SPrimeExoRoomParameters& roomParms, int w2);
void sub80275b68();
void sub80275c60(CStateManager& mgr, int w1);
bool sub80275d68(int w1);
pas::ELocomotionType sub80275e14(int w1);
u32 sub80275e34(int w1) const;
void sub80275e54(float f1, CStateManager& mgr);
void UpdateSfxEmitter(float f1, CStateManager& mgr);
void sub80276204(CStateManager& mgr, bool b1);
void sub8027639c(CStateManager& mgr, bool b1);
void SetActorAreaId(CStateManager& mgr, TUniqueId uid, TAreaId aid);
void UpdateAreaId(CStateManager& mgr);
void SendStateToRelay(EScriptObjectState state, CStateManager& mgr);
void sub80276754(CStateManager& mgr);
TUniqueId sub802769e0(CStateManager& mgr, bool b1);
TUniqueId sub80276b3c(CStateManager& mgr, EScriptObjectState state, EScriptObjectMessage msg);
void UpdateRelay(CStateManager& mgr, TAreaId areaId);
bool IsRelayValid(CStateManager& mgr, TAreaId w2);
bool sub80277224(float f1, CStateManager& mgr);
void FirePlasmaProjectile(CStateManager& mgr, bool b1);
void UpdatePlasmaProjectile(float dt, CStateManager& mgr);
zeus::CVector3f GetTargetVector(CStateManager& mgr);
void FreePlasmaProjectiles(CStateManager& mgr);
void CreatePlasmaProjectiles(CStateManager& mgr);
void UpdateContactDamage(CStateManager& mgr);
void UpdateColorChange(float f1, CStateManager& mgr);
void sub80278130(const zeus::CColor& col);
void UpdateHeadAnimation(float f1);
void sub8027827c(TUniqueId uid, CStateManager& mgr);
void sub80278508(CStateManager& mgr, int w1, bool b1);
void sub802786fc(CStateManager& mgr);
void SetEyesParticleEffectState(CStateManager& mgr, bool b);
void UpdateHeadHealthInfo(CStateManager& mgr);
void UpdateHealthInfo(CStateManager& mgr);
void SetBoneTrackingTarget(CStateManager& mgr, bool active);
void UpdateBoneTracking(float f1, CStateManager& mgr);
void DoContactDamage(TUniqueId uid, CStateManager& mgr);
void UpdateCollision(float dt, CStateManager& mgr);
void SetupBoneTracking();
void SetupCollisionActorManager(CStateManager& mgr);
public:
DEFINE_PATTERNED(MetroidPrimeExo);
CMetroidPrimeExo(TUniqueId uid, std::string_view name, const CEntityInfo& info, const zeus::CTransform& xf,
@ -106,6 +272,59 @@ public:
const CCameraShakeData& shakeData5, const SPrimeProjectileInfo& projectileInfo,
const CDamageInfo& dInfo3, const CCameraShakeData& shakeData6, CAssetId particle2, CAssetId swoosh,
CAssetId particle3, CAssetId particle4, const rstl::reserved_vector<SPrimeStruct6, 4>& struct6s);
void PreThink(float dt, CStateManager& mgr) override;
void Think(float dt, CStateManager& mgr) override;
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId other, CStateManager& mgr) override;
void PreRender(CStateManager& mgr, const zeus::CFrustum& frustum) override;
void AddToRenderer(const zeus::CFrustum& frustum, CStateManager& mgr) override;
void Render(CStateManager& mgr) override;
bool CanRenderUnsorted(const CStateManager& mgr) const override;
void Touch(CActor& act, CStateManager& mgr) override;
void DoUserAnimEvent(CStateManager& mgr, const CInt32POINode& node, EUserEventType type, float dt) override;
void SelectTarget(CStateManager& mgr, EStateMsg msg, float arg) override;
void Run(CStateManager& mgr, EStateMsg msg, float arg) override;
void Attack(CStateManager& mgr, EStateMsg msg, float arg) override;
void TurnAround(CStateManager& mgr, EStateMsg msg, float arg) override;
void Active(CStateManager& mgr, EStateMsg msg, float arg) override;
void InActive(CStateManager& mgr, EStateMsg msg, float arg) override;
void CoverAttack(CStateManager& mgr, EStateMsg msg, float arg) override;
void Crouch(CStateManager& mgr, EStateMsg msg, float arg) override;
void Taunt(CStateManager& mgr, EStateMsg msg, float arg) override;
void Suck(CStateManager& mgr, EStateMsg msg, float arg) override;
void ProjectileAttack(CStateManager& mgr, EStateMsg msg, float arg) override;
void Flinch(CStateManager& mgr, EStateMsg msg, float arg) override;
void Dodge(CStateManager& mgr, EStateMsg msg, float arg) override;
void Retreat(CStateManager& mgr, EStateMsg msg, float arg) override;
void Cover(CStateManager& mgr, EStateMsg msg, float arg) override;
void Approach(CStateManager& mgr, EStateMsg msg, float arg) override;
void Enraged(CStateManager& mgr, EStateMsg msg, float arg) override;
void SpecialAttack(CStateManager& mgr, EStateMsg msg, float arg) override;
void Growth(CStateManager& mgr, EStateMsg msg, float arg) override;
void Land(CStateManager& mgr, EStateMsg msg, float arg) override;
bool TooClose(CStateManager& mgr, float arg) override;
bool InMaxRange(CStateManager& mgr, float arg) override;
bool PlayerSpot(CStateManager& mgr, float arg) override;
bool ShouldAttack(CStateManager& mgr, float arg) override;
bool ShouldDoubleSnap(CStateManager& mgr, float arg) override;
bool InPosition(CStateManager& mgr, float arg) override;
bool ShouldTurn(CStateManager& mgr, float arg) override;
bool ShouldJumpBack(CStateManager& mgr, float arg) override { return x1254_ == 11; }
bool CoverCheck(CStateManager& mgr, float arg) override;
bool CoverFind(CStateManager& mgr, float arg) override;
bool CoveringFire(CStateManager& mgr, float arg) override;
bool AggressionCheck(CStateManager& mgr, float arg) override;
bool AttackOver(CStateManager& mgr, float arg) override;
bool ShouldFire(CStateManager& mgr, float arg) override;
bool ShouldFlinch(CStateManager& mgr, float arg) override;
bool ShouldRetreat(CStateManager& mgr, float arg) override;
bool ShouldCrouch(CStateManager& mgr, float arg) override;
bool ShouldMove(CStateManager& mgr, float arg) override;
bool AIStage(CStateManager& mgr, float arg) override;
bool StartAttack(CStateManager& mgr, float arg) override;
bool ShouldSpecialAttack(CStateManager& mgr, float arg) override;
bool CodeTrigger(CStateManager& mgr, float arg) override;
CProjectileInfo* GetProjectileInfo() override;
};
} // namespace MP1

41
Runtime/MP1/World/CMetroidPrimeRelay.cpp
View File

@ -1,5 +1,7 @@
#include "Runtime/MP1/World/CMetroidPrimeRelay.hpp"
#include "Runtime/MP1/World/CMetroidPrimeExo.hpp"
#include "Runtime/CStateManager.hpp"
#include "TCastTo.hpp" // Generated file, do not modify include path
namespace urde::MP1 {
@ -27,5 +29,44 @@ CMetroidPrimeRelay::CMetroidPrimeRelay(TUniqueId uid, std::string_view name, con
, xcb8_roomParms(std::move(roomParms)) {}
void CMetroidPrimeRelay::Accept(IVisitor& visitor) { visitor.Visit(this); }
void CMetroidPrimeRelay::AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId objId, CStateManager& mgr) {
if (x34_mpUid != objId) {
ForwardMessageToMetroidPrimeExo(msg, mgr);
}
if (msg == EScriptObjectMessage::InitializedInArea) {
GetOrBuildMetroidPrimeExo(mgr);
}
}
void CMetroidPrimeRelay::ForwardMessageToMetroidPrimeExo(EScriptObjectMessage msg, CStateManager& mgr) {
if (auto* exo = CPatterned::CastTo<CMetroidPrimeExo>(mgr.ObjectById(x34_mpUid))) {
mgr.SendScriptMsg(exo, GetUniqueId(), msg);
}
}
void CMetroidPrimeRelay::GetOrBuildMetroidPrimeExo(CStateManager& mgr) {
if (!GetActive()) {
return;
}
for (const auto& act : mgr.GetPhysicsActorObjectList()) {
if (CPatterned::CastTo<CMetroidPrimeExo>(act) != nullptr) {
return;
}
}
const auto& animParms = x74_parms.x4_patternedInfo.GetAnimationParameters();
CModelData mData(
CAnimRes(animParms.GetACSFile(), animParms.GetCharacter(), x68_scale, animParms.GetInitialAnimation(), true));
auto* exo = new CMetroidPrimeExo(
mgr.AllocateUniqueId(), "Metroid Prime! (Stage 1)"sv, CEntityInfo(GetAreaId(), NullConnectionList), x38_xf, std::move(mData),
x74_parms.x4_patternedInfo, x74_parms.x13c_actorParms, x74_parms.x1a4_, x74_parms.x1a8_, x74_parms.x27c_,
x74_parms.x350_, x74_parms.x424_, x74_parms.x460_particle1, x74_parms.x464_, x74_parms.x708_wpsc1,
x74_parms.x70c_dInfo1, x74_parms.x728_shakeData1, x74_parms.x7fc_wpsc2, x74_parms.x800_dInfo2,
x74_parms.x81c_shakeData2, x74_parms.x8f0_, x74_parms.x92c_, x74_parms.x948_, x74_parms.xa1c_particle2,
x74_parms.xa20_swoosh, x74_parms.xa24_particle3, x74_parms.xa28_particle4, x74_parms.xa2c_);
mgr.AddObject(exo);
mgr.SendScriptMsg(exo, kInvalidUniqueId, EScriptObjectMessage::InitializedInArea);
}
} // namespace urde::MP1

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

@ -28,13 +28,30 @@ class CMetroidPrimeRelay : public CEntity {
u32 xcb4_w5;
rstl::reserved_vector<SPrimeExoRoomParameters, 4> xcb8_roomParms;
void ForwardMessageToMetroidPrimeExo(EScriptObjectMessage msg, CStateManager& mgr);
void GetOrBuildMetroidPrimeExo(CStateManager& mgr);
public:
CMetroidPrimeRelay(TUniqueId uid, std::string_view name, const CEntityInfo& info, bool active,
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) override;
TUniqueId GetMetroidPrimeExoId() const { return x34_mpUid; }
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId objId, CStateManager &stateMgr) override;
[[nodiscard]] TUniqueId GetMetroidPrimeExoId() const { return x34_mpUid; }
void SetMetroidPrimeExoId(TUniqueId uid) { x34_mpUid = uid; }
float Get_xc84() const { return xc84_f1; }
float Get_xc88() const { return xc88_f2; }
float Get_xc8c() const { return xc8c_f3; }
u32 Get_xc90() const { return xc90_w1; }
bool Get_xc94() const { return xc94_b1; }
u32 Get_xc98() const { return xc98_w2; }
CHealthInfo GetHealthInfo1() const { return xc9c_hInfo1; }
CHealthInfo GetHealthInfo2() const { return xca4_hInfo2; }
u32 Get_xcac() const { return xcac_w3; }
u32 Get_xcb0() const { return xcb0_w4; }
u32 Get_xcb4() const { return xcb4_w5; }
rstl::reserved_vector<SPrimeExoRoomParameters, 4> GetRoomParameters() const { return xcb8_roomParms; }
};
} // namespace urde::MP1

2
Runtime/MP1/World/CRidley.cpp
View File

@ -869,7 +869,7 @@ void CRidley::FirePlasma(urde::CStateManager& mgr) {
xb64_plasmaProjectile = mgr.AllocateUniqueId();
mgr.AddObject(new CPlasmaProjectile(xb68_.Token(), ""sv, EWeaponType::AI, x568_data.x64_, {},
EMaterialTypes::Character, xb68_.GetDamage(), xb64_plasmaProjectile,
GetAreaIdAlways(), GetUniqueId(), CPlasmaProjectile::PlayerEffectResoures(),
GetAreaIdAlways(), GetUniqueId(), CPlasmaProjectile::PlayerEffectResources(),
false, EProjectileAttrib::KeepInCinematic));
}

3
Runtime/MP1/World/CShockWave.hpp
View File

@ -1,8 +1,8 @@
#pragma once
#include "Runtime/Particle/CElementGen.hpp"
#include "Runtime/World/CActor.hpp"
#include "Runtime/World/CDamageInfo.hpp"
#include "Runtime/Particle/CElementGen.hpp"
namespace urde::MP1 {
struct SShockWaveData {
@ -31,6 +31,7 @@ public:
[[nodiscard]] float GetWidthPercent() const { return x28_widthPercent; }
[[nodiscard]] float GetInitialExpansionSpeed() const { return x2c_initialExpansionSpeed; }
[[nodiscard]] float GetSpeedIncrease() const { return x30_speedIncrease; }
void SetSpeedIncrease(float speed) { x30_speedIncrease = speed; }
[[nodiscard]] CAssetId GetWeaponDescId() const { return x34_weaponDesc; }
[[nodiscard]] u16 GetElectrocuteSfx() const { return x38_electrocuteSfx; }
};

5
Runtime/Particle/CParticleSwoosh.hpp
View File

@ -215,9 +215,14 @@ public:
}
}
void ForceOneUpdate(float dt) {
x1d0_26_forceOneUpdate = true;
Update(dt);
}
std::vector<SSwooshData> const& GetSwooshes() const { return x15c_swooshes; }
std::vector<SSwooshData>& GetSwooshes() { return x15c_swooshes; }
u32 GetCurParticle() const { return x158_curParticle; }
static u32 GetAliveParticleSystemCount() { return g_ParticleSystemAliveCount; }
};
} // namespace urde

2
Runtime/Weapon/CPlasmaProjectile.cpp
View File

@ -28,7 +28,7 @@ CPlasmaProjectile::RenderObjects::RenderObjects(boo::IGraphicsDataFactory::Conte
CPlasmaProjectile::CPlasmaProjectile(const TToken<CWeaponDescription>& wDesc, std::string_view name, EWeaponType wType,
const CBeamInfo& bInfo, const zeus::CTransform& xf, EMaterialTypes matType,
const CDamageInfo& dInfo, TUniqueId uid, TAreaId aid, TUniqueId owner,
const PlayerEffectResoures& res, bool growingBeam, EProjectileAttrib attribs)
const PlayerEffectResources& res, bool growingBeam, EProjectileAttrib attribs)
: CBeamProjectile(wDesc, name, wType, xf, bInfo.GetLength(), bInfo.GetRadius(), bInfo.GetTravelSpeed(), matType, dInfo,
uid, aid, owner, attribs, growingBeam)
, x478_beamAttributes(bInfo.GetBeamAttributes())

21
Runtime/Weapon/CPlasmaProjectile.hpp
View File

@ -18,11 +18,23 @@
namespace urde {
class CPlasmaProjectile : public CBeamProjectile {
public:
struct PlayerEffectResoures : rstl::reserved_vector<CAssetId, 8> {
PlayerEffectResoures(CAssetId a = {}, CAssetId b = {}, CAssetId c = {}, CAssetId d = {},
struct PlayerEffectResources : rstl::reserved_vector<CAssetId, 8> {
PlayerEffectResources(CAssetId a = {}, CAssetId b = {}, CAssetId c = {}, CAssetId d = {},
CAssetId e = {}, CAssetId f = {}, CAssetId g = {}, CAssetId h = {})
: rstl::reserved_vector<CAssetId, 8>({a, b, c, d, e, f, g, h}) {}
};
static PlayerEffectResources LoadPlayerEffectResources(CInputStream& in) {
u32 propCount = in.readUint32();
CAssetId a{in};
CAssetId b{in};
CAssetId c{in};
CAssetId d{in};
CAssetId e{in};
CAssetId f{in};
CAssetId g{in};
CAssetId h{in};
return {a, b, c, d, e, f, g, h};
}
private:
std::vector<TUniqueId> x468_lights;
s32 x478_beamAttributes;
@ -107,7 +119,7 @@ public:
CPlasmaProjectile(const TToken<CWeaponDescription>& wDesc, std::string_view name, EWeaponType wType,
const CBeamInfo& bInfo, const zeus::CTransform& xf, EMaterialTypes matType,
const CDamageInfo& dInfo, TUniqueId uid, TAreaId aid, TUniqueId owner,
const PlayerEffectResoures& res, bool growingBeam, EProjectileAttrib attribs);
const PlayerEffectResources& res, bool growingBeam, EProjectileAttrib attribs);
void Accept(IVisitor& visitor) override;
void AcceptScriptMsg(EScriptObjectMessage msg, TUniqueId sender, CStateManager& mgr) override;
@ -118,5 +130,8 @@ public:
bool CanRenderUnsorted(const CStateManager& mgr) const override;
void AddToRenderer(const zeus::CFrustum& frustum, CStateManager& mgr) override;
void Render(CStateManager& mgr) override;
zeus::CColor GetInnerColor() const { return x490_innerColor; }
zeus::CColor GetOuterColor() const { return x494_outerColor; }
bool IsFiring() const { return x548_26_firing; }
};
} // namespace urde

2
Runtime/World/CMorphBall.hpp
View File

@ -180,7 +180,7 @@ public:
void GetBallContactMaterials() const {}
void GetWallBumpCounter() const {}
void GetBoostChargeTimer() const {}
bool IsBoosting() const { return false; }
bool IsBoosting() const { return x1de4_24_inBoost; }
float GetBallRadius() const;
float GetBallTouchRadius() const;
float ForwardInput(const CFinalInput& input) const;

6
Runtime/World/CPatterned.cpp
View File

@ -1014,6 +1014,10 @@ void CPatterned::TryStep(CStateManager& mgr, int arg) {
x450_bodyController->GetCommandMgr().DeliverCmd(CBCStepCmd(pas::EStepDirection(arg), pas::EStepType::Normal));
}
void CPatterned::TryScripted(CStateManager& mgr, int arg) {
x450_bodyController->GetCommandMgr().DeliverCmd(CBCScriptedCmd(arg, false, false, 0.f));
}
void CPatterned::BuildBodyController(EBodyType bodyType) {
if (x450_bodyController) {
return;
@ -1159,7 +1163,7 @@ CGameProjectile* CPatterned::LaunchProjectile(const zeus::CTransform& gunXf, CSt
const std::optional<TLockedToken<CGenDescription>>& visorParticle,
u16 visorSfx, bool sendCollideMsg, const zeus::CVector3f& scale) {
CProjectileInfo* pInfo = GetProjectileInfo();
if (pInfo->Token().IsLoaded()) {
if (pInfo && pInfo->Token().IsLoaded()) {
if (mgr.CanCreateProjectile(GetUniqueId(), EWeaponType::AI, maxAllowed)) {
TUniqueId homingId = playerHoming ? mgr.GetPlayer().GetUniqueId() : kInvalidUniqueId;
auto* newProjectile =

1
Runtime/World/CPatterned.hpp
View File

@ -338,6 +338,7 @@ public:
void TryKnockBack_Front(CStateManager& mgr, int arg);
void TryGenerateDeactivate(CStateManager& mgr, int arg);
void TryStep(CStateManager& mgr, int arg);
void TryScripted(CStateManager& mgr, int arg);
virtual bool KnockbackWhenFrozen() const { return true; }
virtual void MassiveDeath(CStateManager& mgr);

2
Runtime/World/CPlayer.hpp
View File

@ -605,6 +605,7 @@ public:
bool AttachActorToPlayer(TUniqueId id, bool disableGun);
TUniqueId GetAttachedActor() const { return x26c_attachedActor; }
float GetAttachedActorStruggle() const { return xa28_attachedActorStruggle; }
void SetFrozenTimeoutBias(float bias) { x758_frozenTimeoutBias = bias; }
float GetDistanceUnderWater() const { return x828_distanceUnderWater; }
TUniqueId GetRidingPlatformId() const { return x82e_ridingPlatform; }
const zeus::CVector3f& GetLastVelocity() const { return x794_lastVelocity; }
@ -620,5 +621,6 @@ public:
float GetAverageSpeed() const;
bool IsInWaterMovement() const { return x9c4_31_inWaterMovement; }
void SetNoDamageLoopSfx(bool val) { x9c7_24_noDamageLoopSfx = val; }
void SetAccelerationChangeTimer(float time) { x2d4_accelerationChangeTimer = time; }
};
} // namespace urde

1
Runtime/World/CProjectedShadow.hpp
View File

@ -28,5 +28,6 @@ public:
float, float);
void Unset_X80() { x80_ = false; }
void Set_x98(float f) { x98_ = f; }
};
} // namespace urde

4
Runtime/World/CScriptPlayerActor.cpp
View File

@ -428,8 +428,8 @@ void CScriptPlayerActor::Render(CStateManager& mgr) {
const float radius = zeus::clamp(0.25f, (6.f - vecFromCam.magnitude()) / 6.f, 2.f);
const float offsetX = std::sin(x34c_phazonOffsetAngle);
const float offsetY = std::sin(x34c_phazonOffsetAngle) * 0.5f;
g_Renderer->DrawPhazonSuitIndirectEffect(zeus::CColor(0.1f, 1.f), x338_phazonIndirectTexture, zeus::skWhite,
radius, 0.05f, offsetX, offsetY);
//g_Renderer->DrawPhazonSuitIndirectEffect(zeus::CColor(0.1f, 1.f), x338_phazonIndirectTexture, zeus::skWhite,
// radius, 0.05f, offsetX, offsetY);
}
}

31
Runtime/World/ScriptLoader.cpp
View File

@ -31,6 +31,7 @@
#include "Runtime/MP1/World/CDrone.hpp"
#include "Runtime/MP1/World/CMetroid.hpp"
#include "Runtime/MP1/World/CMetroidBeta.hpp"
#include "Runtime/MP1/World/CMetroidPrimeEssence.hpp"
#include "Runtime/MP1/World/CMetroidPrimeRelay.hpp"
#include "Runtime/MP1/World/CNewIntroBoss.hpp"
#include "Runtime/MP1/World/COmegaPirate.hpp"
@ -3693,10 +3694,32 @@ CEntity* ScriptLoader::LoadWorldLightFader(CStateManager& mgr, CInputStream& in,
0.f, zeus::skZero2f, false, active, 0.f, 0.f, f1, f2);
}
CEntity* ScriptLoader::LoadMetroidPrimeStage2(CStateManager& mgr, CInputStream& in, int propCount,
const CEntityInfo& info) {
return nullptr;
}
CEntity* ScriptLoader::LoadMetroidPrimeEssence(CStateManager& mgr, CInputStream& in, int propCount,
const CEntityInfo& info) {
if (!EnsurePropertyCount(propCount, 11, "MetroidPrimeEssence")) {
return nullptr;
}
SScaledActorHead aHead = LoadScaledActorHead(in, mgr);
auto [valid, pInfoPropCount] = CPatternedInfo::HasCorrectParameterCount(in);
if (!valid) {
return nullptr;
}
CPatternedInfo pInfo{in, pInfoPropCount};
CActorParameters actParms = LoadActorParameters(in);
CAssetId particle1{in};
CDamageInfo dInfo{in};
CAssetId electric{in};
u32 w3 = in.readUint32Big();
CAssetId particle2{in};
const CAnimationParameters& animParms = pInfo.GetAnimationParameters();
CModelData mData{CAnimRes(animParms.GetACSFile(), animParms.GetCharacter(), aHead.x40_scale,
animParms.GetInitialAnimation(), true)};
return new MP1::CMetroidPrimeEssence(mgr.AllocateUniqueId(), aHead.x0_name, info, aHead.x10_transform,
std::move(mData), pInfo, actParms, particle1, dInfo, aHead.x40_scale.y(),
electric, w3, particle2);
};
CEntity* ScriptLoader::LoadMetroidPrimeStage1(CStateManager& mgr, CInputStream& in, int propCount,
const CEntityInfo& info) {

2
Runtime/World/ScriptLoader.hpp
View File

@ -154,7 +154,7 @@ public:
static CEntity* LoadBurrower(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info);
static CEntity* LoadBeam(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info);
static CEntity* LoadWorldLightFader(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info);
static CEntity* LoadMetroidPrimeStage2(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info);
static CEntity* LoadMetroidPrimeEssence(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info);
static CEntity* LoadMetroidPrimeStage1(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info);
static CEntity* LoadMazeNode(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info);
static CEntity* LoadOmegaPirate(CStateManager& mgr, CInputStream& in, int propCount, const CEntityInfo& info);