mirror of https://github.com/AxioDL/metaforce.git
281 lines
9.6 KiB
C++
281 lines
9.6 KiB
C++
#include "CBodyController.hpp"
|
|
#include "World/CActor.hpp"
|
|
#include "TCastTo.hpp"
|
|
#include "World/CPhysicsActor.hpp"
|
|
#include "World/CActorModelParticles.hpp"
|
|
#include "Character/CPASAnimParm.hpp"
|
|
#include "Character/CPASAnimParmData.hpp"
|
|
#include "CStateManager.hpp"
|
|
|
|
namespace urde {
|
|
|
|
CBodyController::CBodyController(CActor& actor, float turnSpeed, EBodyType bodyType)
|
|
: x0_actor(actor), x2a4_bodyStateInfo(actor, bodyType), x2f4_bodyType(bodyType), x2fc_turnSpeed(turnSpeed) {
|
|
x300_28_playDeathAnims = true;
|
|
x2a4_bodyStateInfo.x18_bodyController = this;
|
|
}
|
|
|
|
void CBodyController::EnableAnimation(bool e) { x0_actor.ModelData()->AnimationData()->EnableAnimation(e); }
|
|
|
|
void CBodyController::Activate(CStateManager& mgr) {
|
|
x300_25_active = true;
|
|
x2a4_bodyStateInfo.SetState(pas::EAnimationState(GetPASDatabase().GetDefaultState()));
|
|
x2a4_bodyStateInfo.GetCurrentState()->Start(*this, mgr);
|
|
x2a4_bodyStateInfo.GetCurrentAdditiveState()->Start(*this, mgr);
|
|
}
|
|
|
|
void CBodyController::UpdateBody(float dt, CStateManager& mgr) {
|
|
UpdateFrozenInfo(dt, mgr);
|
|
if (x320_fireDur > 0.f) {
|
|
if (x328_timeOnFire > x320_fireDur) {
|
|
x328_timeOnFire = 0.f;
|
|
x320_fireDur = 0.f;
|
|
} else {
|
|
x328_timeOnFire += dt;
|
|
}
|
|
} else if (x324_electrocutionDur > 0.f) {
|
|
if (x32c_timeElectrocuting > x324_electrocutionDur) {
|
|
x32c_timeElectrocuting = 0.f;
|
|
x324_electrocutionDur = 0.f;
|
|
} else {
|
|
x32c_timeElectrocuting += dt;
|
|
}
|
|
}
|
|
|
|
if (GetPercentageFrozen() < 1.f && x300_28_playDeathAnims) {
|
|
pas::EAnimationState nextState = x2a4_bodyStateInfo.GetCurrentState()->UpdateBody(dt, *this, mgr);
|
|
if (nextState != pas::EAnimationState::Invalid) {
|
|
x2a4_bodyStateInfo.GetCurrentState()->Shutdown(*this);
|
|
x2a4_bodyStateInfo.SetState(nextState);
|
|
x2a4_bodyStateInfo.GetCurrentState()->Start(*this, mgr);
|
|
}
|
|
|
|
nextState = x2a4_bodyStateInfo.GetCurrentAdditiveState()->UpdateBody(dt, *this, mgr);
|
|
if (nextState != pas::EAnimationState::Invalid) {
|
|
x2a4_bodyStateInfo.GetCurrentAdditiveState()->Shutdown(*this);
|
|
x2a4_bodyStateInfo.SetAdditiveState(nextState);
|
|
x2a4_bodyStateInfo.GetCurrentAdditiveState()->Start(*this, mgr);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CBodyController::SetTurnSpeed(float s) { x2fc_turnSpeed = std::max(0.f, s); }
|
|
|
|
void CBodyController::Update(float dt, CStateManager& mgr) {
|
|
SetPlaybackRate(1.f);
|
|
if (x300_25_active) {
|
|
x300_24_animationOver = !x0_actor.GetModelData()->GetAnimationData()->IsAnimTimeRemaining(dt, "Whole Body"sv);
|
|
x4_cmdMgr.BlendSteeringCmds();
|
|
x2dc_rot = zeus::CQuaternion();
|
|
UpdateBody(dt, mgr);
|
|
if (TCastToPtr<CPhysicsActor> act = x0_actor)
|
|
act->RotateInOneFrameOR(x2dc_rot, dt);
|
|
x4_cmdMgr.Reset();
|
|
}
|
|
}
|
|
|
|
bool CBodyController::HasBodyState(pas::EAnimationState s) const { return GetPASDatabase().HasState(s32(s)); }
|
|
|
|
void CBodyController::SetCurrentAnimation(const CAnimPlaybackParms& parms, bool loop, bool noTrans) {
|
|
x0_actor.ModelData()->AnimationData()->SetAnimation(parms, noTrans);
|
|
x0_actor.ModelData()->EnableLooping(loop);
|
|
x2f8_curAnim = parms.GetAnimationId();
|
|
}
|
|
|
|
float CBodyController::GetAnimTimeRemaining() const {
|
|
return x0_actor.GetModelData()->GetAnimationData()->GetAnimTimeRemaining("Whole Body");
|
|
}
|
|
|
|
void CBodyController::SetPlaybackRate(float r) { x0_actor.ModelData()->AnimationData()->SetPlaybackRate(r); }
|
|
|
|
const CPASDatabase& CBodyController::GetPASDatabase() const {
|
|
return x0_actor.GetModelData()->GetAnimationData()->GetCharacterInfo().GetPASDatabase();
|
|
}
|
|
|
|
void CBodyController::MultiplyPlaybackRate(float r) { x0_actor.ModelData()->AnimationData()->MultiplyPlaybackRate(r); }
|
|
|
|
void CBodyController::FaceDirection(const zeus::CVector3f& v0, float dt) {
|
|
if (x300_26_frozen)
|
|
return;
|
|
zeus::CVector3f noZ = v0;
|
|
noZ.z() = 0.f;
|
|
if (noZ.canBeNormalized()) {
|
|
if (TCastToPtr<CPhysicsActor> act = x0_actor) {
|
|
zeus::CQuaternion rot = zeus::CQuaternion::lookAt(act->GetTransform().basis[1], noZ.normalized(),
|
|
zeus::degToRad(dt * x2fc_turnSpeed));
|
|
rot.setImaginary(act->GetTransform().transposeRotate(rot.getImaginary()));
|
|
act->RotateInOneFrameOR(rot, dt);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CBodyController::FaceDirection3D(const zeus::CVector3f& v0, const zeus::CVector3f& v1, float dt) {
|
|
if (x300_26_frozen)
|
|
return;
|
|
if (v0.canBeNormalized() && v1.canBeNormalized()) {
|
|
if (TCastToPtr<CPhysicsActor> act = x0_actor) {
|
|
zeus::CUnitVector3f uv0 = v0;
|
|
zeus::CUnitVector3f uv1 = v1;
|
|
float dot = uv0.dot(uv1);
|
|
if (std::fabs(dot - 1.f) >= 0.00001f) {
|
|
if (dot < -0.9999f) {
|
|
zeus::CQuaternion rot =
|
|
zeus::CQuaternion::fromAxisAngle(act->GetTransform().basis[2], zeus::degToRad(dt * x2fc_turnSpeed));
|
|
rot.setImaginary(act->GetTransform().transposeRotate(rot.getImaginary()));
|
|
act->RotateInOneFrameOR(rot, dt);
|
|
} else {
|
|
zeus::CQuaternion rot = zeus::CQuaternion::clampedRotateTo(uv1, uv0, zeus::degToRad(dt * x2fc_turnSpeed));
|
|
rot.setImaginary(x0_actor.GetTransform().transposeRotate(rot.getImaginary()));
|
|
act->RotateInOneFrameOR(rot, dt);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool CBodyController::HasBodyInfo(CActor& act) {
|
|
return act.GetModelData()->GetAnimationData()->GetCharacterInfo().GetPASDatabase().GetNumAnimStates() != 0;
|
|
}
|
|
|
|
void CBodyController::PlayBestAnimation(const CPASAnimParmData& parms, CRandom16& r) {
|
|
std::pair<float, s32> best = GetPASDatabase().FindBestAnimation(parms, r, -1);
|
|
CAnimPlaybackParms playParms(best.second, -1, 1.f, true);
|
|
SetCurrentAnimation(playParms, false, false);
|
|
}
|
|
|
|
void CBodyController::LoopBestAnimation(const CPASAnimParmData& parms, CRandom16& r) {
|
|
std::pair<float, s32> best = GetPASDatabase().FindBestAnimation(parms, r, -1);
|
|
CAnimPlaybackParms playParms(best.second, -1, 1.f, true);
|
|
SetCurrentAnimation(playParms, true, false);
|
|
}
|
|
|
|
void CBodyController::Freeze(float intoFreezeDur, float frozenDur, float breakoutDur) {
|
|
x304_intoFreezeDur = intoFreezeDur;
|
|
x308_frozenDur = frozenDur;
|
|
x30c_breakoutDur = breakoutDur;
|
|
x300_26_frozen = true;
|
|
x300_27_hasBeenFrozen = true;
|
|
|
|
if (TCastToPtr<CPhysicsActor> act = x0_actor) {
|
|
x314_backedUpForce = act->GetConstantForce();
|
|
act->SetConstantForce(zeus::skZero3f);
|
|
act->SetMomentumWR(zeus::skZero3f);
|
|
}
|
|
|
|
x320_fireDur = 0.f;
|
|
x328_timeOnFire = 0.f;
|
|
x310_timeFrozen = 0.f;
|
|
}
|
|
|
|
void CBodyController::UnFreeze() {
|
|
SetPlaybackRate(1.f);
|
|
x300_26_frozen = false;
|
|
x304_intoFreezeDur = 0.f;
|
|
x308_frozenDur = 0.f;
|
|
x30c_breakoutDur = 0.f;
|
|
x310_timeFrozen = 0.f;
|
|
x0_actor.SetVolume(1.f);
|
|
|
|
if (TCastToPtr<CPhysicsActor> act = x0_actor) {
|
|
act->SetConstantForce(x314_backedUpForce);
|
|
act->SetVelocityWR(x314_backedUpForce * (1.f / act->GetMass()));
|
|
}
|
|
}
|
|
|
|
float CBodyController::GetPercentageFrozen() const {
|
|
float sum = x304_intoFreezeDur + x308_frozenDur + x30c_breakoutDur;
|
|
if (x310_timeFrozen == 0.f || sum == 0.f)
|
|
return 0.f;
|
|
|
|
if (x310_timeFrozen <= x304_intoFreezeDur && x304_intoFreezeDur > 0.f)
|
|
return x310_timeFrozen / x304_intoFreezeDur;
|
|
|
|
if (x310_timeFrozen < sum - x30c_breakoutDur)
|
|
return 1.f;
|
|
if (x30c_breakoutDur <= 0.f)
|
|
return 1.f;
|
|
|
|
return 1.f - (x310_timeFrozen - (x308_frozenDur + x304_intoFreezeDur)) / x30c_breakoutDur;
|
|
}
|
|
|
|
void CBodyController::SetOnFire(float dur) {
|
|
x320_fireDur = dur;
|
|
x328_timeOnFire = 0.f;
|
|
if (IsFrozen())
|
|
UnFreeze();
|
|
}
|
|
|
|
void CBodyController::DouseFlames() {
|
|
if (x320_fireDur <= 0.f)
|
|
return;
|
|
x320_fireDur = 0.f;
|
|
x328_timeOnFire = 0.f;
|
|
}
|
|
|
|
void CBodyController::SetElectrocuting(float dur) {
|
|
if (!IsElectrocuting()) {
|
|
CBCAdditiveReactionCmd reaction(pas::EAdditiveReactionType::Electrocution, 1.f, true);
|
|
x4_cmdMgr.DeliverCmd(reaction);
|
|
}
|
|
x324_electrocutionDur = dur;
|
|
x32c_timeElectrocuting = 0.f;
|
|
if (IsFrozen())
|
|
UnFreeze();
|
|
else if (IsOnFire())
|
|
DouseFlames();
|
|
}
|
|
|
|
void CBodyController::DouseElectrocuting() {
|
|
x324_electrocutionDur = 0.f;
|
|
x32c_timeElectrocuting = 0.f;
|
|
CBodyStateCmd cmd(EBodyStateCmd::StopReaction);
|
|
x4_cmdMgr.DeliverCmd(cmd);
|
|
}
|
|
|
|
void CBodyController::UpdateFrozenInfo(float dt, CStateManager& mgr) {
|
|
if (x300_26_frozen) {
|
|
float totalTime = x304_intoFreezeDur + x308_frozenDur + x30c_breakoutDur;
|
|
if (x310_timeFrozen > totalTime &&
|
|
x2a4_bodyStateInfo.GetCurrentAdditiveStateId() != pas::EAnimationState::AdditiveReaction) {
|
|
UnFreeze();
|
|
x0_actor.SendScriptMsgs(EScriptObjectState::UnFrozen, mgr, EScriptObjectMessage::None);
|
|
mgr.GetActorModelParticles()->StartIce(x0_actor);
|
|
return;
|
|
}
|
|
if (x310_timeFrozen <= totalTime) {
|
|
float percUnfrozen = 1.f;
|
|
if (x310_timeFrozen < totalTime - x30c_breakoutDur)
|
|
percUnfrozen = 1.f - GetPercentageFrozen();
|
|
MultiplyPlaybackRate(percUnfrozen);
|
|
x310_timeFrozen += dt;
|
|
x0_actor.SetVolume(percUnfrozen);
|
|
if (x310_timeFrozen > totalTime && HasIceBreakoutState()) {
|
|
CBCAdditiveReactionCmd cmd(pas::EAdditiveReactionType::IceBreakout, 1.f, false);
|
|
x4_cmdMgr.DeliverCmd(cmd);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
bool CBodyController::HasIceBreakoutState() const {
|
|
CPASAnimParmData parms(24, CPASAnimParm::FromEnum(3));
|
|
std::pair<float, s32> best = GetPASDatabase().FindBestAnimation(parms, -1);
|
|
return best.first > 0.f;
|
|
}
|
|
|
|
void CBodyController::StopElectrocution() {
|
|
x324_electrocutionDur = 0.f;
|
|
x32c_timeElectrocuting = 0.f;
|
|
x4_cmdMgr.DeliverCmd(CBodyStateCmd(EBodyStateCmd::StopReaction));
|
|
}
|
|
|
|
void CBodyController::FrozenBreakout() {
|
|
if (x300_26_frozen) {
|
|
float timeToBreakout = x304_intoFreezeDur + x308_frozenDur;
|
|
if (x310_timeFrozen < timeToBreakout)
|
|
x310_timeFrozen = timeToBreakout;
|
|
}
|
|
}
|
|
|
|
} // namespace urde
|