mirror of https://github.com/AxioDL/metaforce.git
2419 lines
94 KiB
C++
2419 lines
94 KiB
C++
#include "CBodyState.hpp"
|
|
#include "CBodyController.hpp"
|
|
#include "World/CActor.hpp"
|
|
#include "CStateManager.hpp"
|
|
#include "TCastTo.hpp"
|
|
#include "CPASAnimParmData.hpp"
|
|
#include "World/CPatterned.hpp"
|
|
|
|
namespace urde
|
|
{
|
|
|
|
void CBSAttack::Start(CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
const CBCMeleeAttackCmd* cmd =
|
|
static_cast<const CBCMeleeAttackCmd*>(bc.GetCommandMgr().GetCmd(EBodyStateCmd::MeleeAttack));
|
|
const CPASDatabase& pasDatabase = bc.GetPASDatabase();
|
|
CPASAnimParmData parms(7, CPASAnimParm::FromEnum(s32(cmd->GetAttackSeverity())),
|
|
CPASAnimParm::FromEnum(s32(bc.GetLocomotionType())));
|
|
std::pair<float, s32> best = pasDatabase.FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
|
|
CAnimPlaybackParms playParms(best.second, -1, 1.f, true);
|
|
bc.SetCurrentAnimation(playParms, false, false);
|
|
if (cmd->HasAttackTargetPos())
|
|
{
|
|
x20_targetPos = cmd->GetAttackTargetPos();
|
|
|
|
CCharAnimTime evTime = bc.GetOwner().GetModelData()->GetAnimationData()->GetTimeOfUserEvent(
|
|
EUserEventType::AlignTargetPosStart, CCharAnimTime::Infinity());
|
|
x2c_alignTargetPosStartTime = (evTime != CCharAnimTime::Infinity()) ? evTime.GetSeconds() : 0.f;
|
|
|
|
evTime = bc.GetOwner().GetModelData()->GetAnimationData()->GetTimeOfUserEvent(
|
|
EUserEventType::AlignTargetPos, CCharAnimTime::Infinity());
|
|
x30_alignTargetPosTime = (evTime != CCharAnimTime::Infinity()) ?
|
|
evTime.GetSeconds() : bc.GetAnimTimeRemaining();
|
|
}
|
|
else
|
|
{
|
|
x20_targetPos = zeus::CVector3f::skZero;
|
|
x2c_alignTargetPosStartTime = -1.f;
|
|
x30_alignTargetPosTime = -1.f;
|
|
}
|
|
|
|
x4_nextState = pas::EAnimationState::Locomotion;
|
|
x34_curTime = 0.f;
|
|
}
|
|
|
|
pas::EAnimationState CBSAttack::GetBodyStateTransition(float dt, CBodyController& bc)
|
|
{
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Hurled))
|
|
return pas::EAnimationState::Hurled;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::KnockDown))
|
|
return pas::EAnimationState::Fall;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::LoopHitReaction))
|
|
return pas::EAnimationState::LoopReaction;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::KnockBack))
|
|
return pas::EAnimationState::KnockBack;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Locomotion))
|
|
return pas::EAnimationState::Locomotion;
|
|
if (const CBCSlideCmd* cmd = static_cast<const CBCSlideCmd*>(
|
|
bc.GetCommandMgr().GetCmd(EBodyStateCmd::Slide)))
|
|
{
|
|
x8_slide = *cmd;
|
|
x4_nextState = pas::EAnimationState::Slide;
|
|
}
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Generate))
|
|
return pas::EAnimationState::Generate;
|
|
if (bc.IsAnimationOver())
|
|
{
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::MeleeAttack))
|
|
return pas::EAnimationState::MeleeAttack;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::ProjectileAttack))
|
|
return pas::EAnimationState::ProjectileAttack;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::LoopAttack))
|
|
return pas::EAnimationState::LoopAttack;
|
|
return x4_nextState;
|
|
}
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::NextState))
|
|
return x4_nextState;
|
|
return pas::EAnimationState::Invalid;
|
|
}
|
|
|
|
void CBSAttack::UpdatePhysicsActor(CBodyController& bc, float dt)
|
|
{
|
|
if (x20_targetPos.isZero())
|
|
return;
|
|
if (x34_curTime >= x2c_alignTargetPosStartTime && x34_curTime <= x30_alignTargetPosTime)
|
|
{
|
|
if (TCastToPtr<CPhysicsActor> act = bc.GetOwner())
|
|
{
|
|
zeus::CVector3f delta = x20_targetPos - act->GetTranslation();
|
|
float td = x30_alignTargetPosTime - x2c_alignTargetPosStartTime;
|
|
if (dt > 0.f)
|
|
delta *= zeus::CVector3f(dt / td);
|
|
zeus::CVector3f localDelta = act->GetTransform().transposeRotate(delta);
|
|
act->ApplyImpulseWR(act->GetMoveToORImpulseWR(localDelta, dt), zeus::CAxisAngle::sIdentity);
|
|
}
|
|
}
|
|
}
|
|
|
|
pas::EAnimationState CBSAttack::UpdateBody(float dt, CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
x34_curTime += dt;
|
|
pas::EAnimationState st = GetBodyStateTransition(dt, bc);
|
|
if (st == pas::EAnimationState::Invalid)
|
|
{
|
|
if (!bc.GetCommandMgr().GetTargetVector().isZero())
|
|
bc.FaceDirection(bc.GetCommandMgr().GetTargetVector(), dt);
|
|
UpdatePhysicsActor(bc, dt);
|
|
}
|
|
else if (st == pas::EAnimationState::Slide)
|
|
{
|
|
bc.GetCommandMgr().DeliverCmd(x8_slide);
|
|
}
|
|
return st;
|
|
}
|
|
|
|
void CBSProjectileAttack::Start(CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
const CBCProjectileAttackCmd* cmd =
|
|
static_cast<const CBCProjectileAttackCmd*>(bc.GetCommandMgr().GetCmd(EBodyStateCmd::ProjectileAttack));
|
|
zeus::CVector3f localDelta =
|
|
bc.GetOwner().GetTransform().transposeRotate(cmd->GetTargetPosition() -
|
|
bc.GetOwner().GetTranslation());
|
|
zeus::CRelAngle angle = std::atan2(localDelta.y, localDelta.x);
|
|
float attackAngle = angle.asDegrees();
|
|
CPASAnimParmData parms(18, CPASAnimParm::FromEnum(s32(cmd->GetAttackSeverity())),
|
|
CPASAnimParm::FromReal32(angle.asDegrees()),
|
|
CPASAnimParm::FromEnum(s32(bc.GetLocomotionType())));
|
|
std::pair<float, s32> best1 = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
|
|
if (cmd->BlendTwoClosest())
|
|
{
|
|
std::pair<float, s32> best2 = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(),
|
|
best1.second);
|
|
const CPASAnimState* projAttackState = bc.GetPASDatabase().GetAnimState(18);
|
|
float angle1 = projAttackState->GetAnimParmData(best1.second, 1).GetReal32Value();
|
|
float angle2 = projAttackState->GetAnimParmData(best2.second, 1).GetReal32Value();
|
|
if (angle1 - angle2 > 180.f)
|
|
angle2 += 360.f;
|
|
else if (angle2 - angle1 > 180.f)
|
|
angle1 += 360.f;
|
|
CAnimPlaybackParms playParms(best1.second, best2.second,
|
|
(angle1 - attackAngle) / (angle1 - angle2), true);
|
|
bc.SetCurrentAnimation(playParms, false, false);
|
|
}
|
|
else
|
|
{
|
|
CAnimPlaybackParms playParms(best1.second, -1, 1.f, true);
|
|
bc.SetCurrentAnimation(playParms, false, false);
|
|
}
|
|
}
|
|
|
|
pas::EAnimationState CBSProjectileAttack::GetBodyStateTransition(float dt, CBodyController& bc)
|
|
{
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Hurled))
|
|
return pas::EAnimationState::Hurled;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::KnockDown))
|
|
return pas::EAnimationState::Fall;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::LoopHitReaction))
|
|
return pas::EAnimationState::LoopReaction;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::KnockBack))
|
|
return pas::EAnimationState::KnockBack;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Locomotion))
|
|
return pas::EAnimationState::Locomotion;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Generate))
|
|
return pas::EAnimationState::Generate;
|
|
if (bc.IsAnimationOver() || bc.GetCommandMgr().GetCmd(EBodyStateCmd::NextState))
|
|
return pas::EAnimationState::Locomotion;
|
|
return pas::EAnimationState::Invalid;
|
|
}
|
|
|
|
pas::EAnimationState CBSProjectileAttack::UpdateBody(float dt, CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
pas::EAnimationState st = GetBodyStateTransition(dt, bc);
|
|
if (st == pas::EAnimationState::Invalid)
|
|
if (!bc.GetCommandMgr().GetTargetVector().isZero())
|
|
bc.FaceDirection(bc.GetCommandMgr().GetTargetVector(), dt);
|
|
return st;
|
|
}
|
|
|
|
void CBSDie::Start(CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
bool shouldReset = true;
|
|
if (bc.ShouldPlayDeathAnims())
|
|
{
|
|
CPASAnimParmData parms(4, CPASAnimParm::FromEnum(s32(bc.GetFallState())));
|
|
std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
|
|
if (best.first > 0.f)
|
|
{
|
|
CAnimPlaybackParms playParms(best.second, -1, 1.f, true);
|
|
bc.SetCurrentAnimation(playParms, false, false);
|
|
x4_remTime = bc.GetAnimTimeRemaining();
|
|
shouldReset = false;
|
|
}
|
|
}
|
|
|
|
if (shouldReset)
|
|
{
|
|
bc.EnableAnimation(false);
|
|
x4_remTime = bc.ShouldPlayDeathAnims() ? 3.f : 4.f;
|
|
}
|
|
|
|
x8_isDead = false;
|
|
}
|
|
|
|
pas::EAnimationState CBSDie::UpdateBody(float dt, CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
x4_remTime -= dt;
|
|
if (x4_remTime <= 0.f)
|
|
{
|
|
bc.EnableAnimation(false);
|
|
x8_isDead = true;
|
|
}
|
|
return pas::EAnimationState::Invalid;
|
|
}
|
|
|
|
void CBSFall::Start(CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
const CBCKnockDownCmd* cmd =
|
|
static_cast<const CBCKnockDownCmd*>(bc.GetCommandMgr().GetCmd(EBodyStateCmd::KnockDown));
|
|
zeus::CVector3f localDir = bc.GetOwner().GetTransform().transposeRotate(cmd->GetHitDirection());
|
|
zeus::CRelAngle angle = std::atan2(localDir.y, localDir.z);
|
|
CPASAnimParmData parms(0, CPASAnimParm::FromReal32(angle.asDegrees()),
|
|
CPASAnimParm::FromEnum(s32(cmd->GetHitSeverity())));
|
|
std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
|
|
CAnimPlaybackParms playParms(best.second, -1, 1.f, true);
|
|
bc.SetCurrentAnimation(playParms, false, false);
|
|
const CPASAnimState* knockdownState = bc.GetPASDatabase().GetAnimState(0);
|
|
if (!knockdownState->GetAnimParmData(best.second, 2).GetBoolValue())
|
|
{
|
|
float animAngle = zeus::degToRad(knockdownState->GetAnimParmData(best.second, 0).GetReal32Value());
|
|
zeus::CRelAngle delta1 = angle - animAngle;
|
|
zeus::CRelAngle delta2 = animAngle - angle;
|
|
float minAngle = std::min(float(delta1), float(delta2));
|
|
x8_remTime = 0.15f * bc.GetAnimTimeRemaining();
|
|
float flippedAngle = (delta1 > M_PIF) ? -minAngle : minAngle;
|
|
x4_rotateSpeed = (x8_remTime > FLT_EPSILON) ? flippedAngle / x8_remTime : flippedAngle;
|
|
}
|
|
else
|
|
{
|
|
x8_remTime = 0.f;
|
|
x4_rotateSpeed = 0.f;
|
|
}
|
|
xc_fallState = pas::EFallState(knockdownState->GetAnimParmData(best.second, 3).GetEnumValue());
|
|
}
|
|
|
|
pas::EAnimationState CBSFall::GetBodyStateTransition(float dt, CBodyController& bc)
|
|
{
|
|
if (bc.IsAnimationOver())
|
|
return pas::EAnimationState::LieOnGround;
|
|
return pas::EAnimationState::Invalid;
|
|
}
|
|
|
|
pas::EAnimationState CBSFall::UpdateBody(float dt, CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
pas::EAnimationState st = GetBodyStateTransition(dt, bc);
|
|
if (st == pas::EAnimationState::Invalid && x8_remTime > 0.f)
|
|
{
|
|
zeus::CQuaternion quat;
|
|
quat.rotateZ(x4_rotateSpeed * dt);
|
|
bc.SetDeltaRotation(quat);
|
|
x8_remTime -= dt;
|
|
}
|
|
return st;
|
|
}
|
|
|
|
void CBSFall::Shutdown(CBodyController& bc)
|
|
{
|
|
bc.SetFallState(xc_fallState);
|
|
}
|
|
|
|
void CBSGetup::Start(CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
const CBCGetupCmd* cmd =
|
|
static_cast<const CBCGetupCmd*>(bc.GetCommandMgr().GetCmd(EBodyStateCmd::Getup));
|
|
CPASAnimParmData parms(1, CPASAnimParm::FromEnum(s32(bc.GetFallState())),
|
|
CPASAnimParm::FromEnum(s32(cmd->GetGetupType())));
|
|
std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
|
|
if (best.first > FLT_EPSILON)
|
|
{
|
|
if (best.second != bc.GetCurrentAnimId())
|
|
{
|
|
CAnimPlaybackParms playParms(best.second, -1, 1.f, true);
|
|
bc.SetCurrentAnimation(playParms, false, false);
|
|
}
|
|
x4_fallState =
|
|
pas::EFallState(bc.GetPASDatabase().GetAnimState(1)->GetAnimParmData(best.second, 2).GetEnumValue());
|
|
}
|
|
else
|
|
{
|
|
x4_fallState = pas::EFallState::Zero;
|
|
}
|
|
}
|
|
|
|
pas::EAnimationState CBSGetup::GetBodyStateTransition(float dt, CBodyController& bc)
|
|
{
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Hurled))
|
|
return pas::EAnimationState::Hurled;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::KnockDown))
|
|
return pas::EAnimationState::Fall;
|
|
if (bc.IsAnimationOver())
|
|
{
|
|
if (x4_fallState == pas::EFallState::Zero)
|
|
return pas::EAnimationState::Locomotion;
|
|
return pas::EAnimationState::Getup;
|
|
}
|
|
return pas::EAnimationState::Invalid;
|
|
}
|
|
|
|
pas::EAnimationState CBSGetup::UpdateBody(float dt, CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
return GetBodyStateTransition(dt, bc);
|
|
}
|
|
|
|
void CBSGetup::Shutdown(CBodyController& bc)
|
|
{
|
|
bc.SetFallState(x4_fallState);
|
|
}
|
|
|
|
void CBSKnockBack::Start(CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
const CBCKnockBackCmd* cmd =
|
|
static_cast<const CBCKnockBackCmd*>(bc.GetCommandMgr().GetCmd(EBodyStateCmd::KnockBack));
|
|
zeus::CVector3f localDir = bc.GetOwner().GetTransform().transposeRotate(cmd->GetHitDirection());
|
|
zeus::CRelAngle angle = std::atan2(localDir.y, localDir.x);
|
|
CPASAnimParmData parms(6, CPASAnimParm::FromReal32(angle.asDegrees()),
|
|
CPASAnimParm::FromEnum(s32(cmd->GetHitSeverity())));
|
|
std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
|
|
CAnimPlaybackParms playParms(best.second, -1, 1.f, true);
|
|
bc.SetCurrentAnimation(playParms, false, false);
|
|
const CPASAnimState* knockbackState = bc.GetPASDatabase().GetAnimState(6);
|
|
if (!knockbackState->GetAnimParmData(best.second, 2).GetBoolValue())
|
|
{
|
|
float animAngle = zeus::degToRad(knockbackState->GetAnimParmData(best.second, 0).GetReal32Value());
|
|
zeus::CRelAngle delta1 = angle - animAngle;
|
|
zeus::CRelAngle delta2 = animAngle - angle;
|
|
float minAngle = std::min(float(delta1), float(delta2));
|
|
float flippedAngle = (delta1 > M_PIF) ? -minAngle : minAngle;
|
|
xc_remTime = 0.15f * bc.GetAnimTimeRemaining();
|
|
x8_rotateSpeed = (xc_remTime > FLT_EPSILON) ? flippedAngle / xc_remTime : flippedAngle;
|
|
}
|
|
else
|
|
{
|
|
xc_remTime = 0.f;
|
|
x8_rotateSpeed = 0.f;
|
|
}
|
|
x4_curTime = 0.f;
|
|
}
|
|
|
|
pas::EAnimationState CBSKnockBack::GetBodyStateTransition(float dt, CBodyController& bc)
|
|
{
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Hurled))
|
|
return pas::EAnimationState::Hurled;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::KnockDown))
|
|
return pas::EAnimationState::Fall;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::LoopHitReaction))
|
|
return pas::EAnimationState::LoopReaction;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::KnockBack) && x4_curTime > 0.2f)
|
|
return pas::EAnimationState::KnockBack;
|
|
if (bc.IsAnimationOver())
|
|
return pas::EAnimationState::Locomotion;
|
|
return pas::EAnimationState::Invalid;
|
|
}
|
|
|
|
pas::EAnimationState CBSKnockBack::UpdateBody(float dt, CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
pas::EAnimationState st = GetBodyStateTransition(dt, bc);
|
|
if (st == pas::EAnimationState::Invalid)
|
|
{
|
|
x4_curTime += dt;
|
|
if (xc_remTime > 0.f)
|
|
{
|
|
zeus::CQuaternion quat;
|
|
quat.rotateZ(x8_rotateSpeed * dt);
|
|
bc.SetDeltaRotation(quat);
|
|
xc_remTime -= dt;
|
|
}
|
|
}
|
|
return st;
|
|
}
|
|
|
|
CBSLieOnGround::CBSLieOnGround(CActor& actor)
|
|
{
|
|
x4_24_hasGroundHit =
|
|
actor.GetModelData()->GetAnimationData()->GetCharacterInfo().GetPASDatabase().HasState(11);
|
|
}
|
|
|
|
void CBSLieOnGround::Start(CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
CPASAnimParmData parms(2, CPASAnimParm::FromEnum(s32(bc.GetFallState())));
|
|
std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
|
|
if (best.first > 0.f)
|
|
{
|
|
CAnimPlaybackParms playParms(best.second, -1, 1.f, true);
|
|
bc.SetCurrentAnimation(playParms, true, false);
|
|
}
|
|
else
|
|
{
|
|
bc.EnableAnimation(false);
|
|
}
|
|
}
|
|
|
|
pas::EAnimationState CBSLieOnGround::GetBodyStateTransition(float dt, CBodyController& bc)
|
|
{
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Die))
|
|
return pas::EAnimationState::Death;
|
|
if (x4_24_hasGroundHit && bc.GetCommandMgr().GetCmd(EBodyStateCmd::KnockBack))
|
|
return pas::EAnimationState::GroundHit;
|
|
if (!bc.GetCommandMgr().GetCmd(EBodyStateCmd::Locomotion) &&
|
|
bc.GetCommandMgr().GetCmd(EBodyStateCmd::Getup))
|
|
return pas::EAnimationState::Getup;
|
|
return pas::EAnimationState::Invalid;
|
|
}
|
|
|
|
pas::EAnimationState CBSLieOnGround::UpdateBody(float dt, CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
return GetBodyStateTransition(dt, bc);
|
|
}
|
|
|
|
void CBSLieOnGround::Shutdown(CBodyController& bc)
|
|
{
|
|
bc.EnableAnimation(true);
|
|
}
|
|
|
|
void CBSStep::Start(CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
const CBCStepCmd* cmd =
|
|
static_cast<const CBCStepCmd*>(bc.GetCommandMgr().GetCmd(EBodyStateCmd::Step));
|
|
CPASAnimParmData parms(3, CPASAnimParm::FromEnum(s32(cmd->GetStepDirection())),
|
|
CPASAnimParm::FromEnum(s32(cmd->GetStepType())));
|
|
bc.PlayBestAnimation(parms, *mgr.GetActiveRandom());
|
|
}
|
|
|
|
pas::EAnimationState CBSStep::GetBodyStateTransition(float dt, CBodyController& bc)
|
|
{
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Hurled))
|
|
return pas::EAnimationState::Hurled;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::KnockDown))
|
|
return pas::EAnimationState::Fall;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::LoopHitReaction))
|
|
return pas::EAnimationState::LoopReaction;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::KnockBack))
|
|
return pas::EAnimationState::KnockBack;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Locomotion))
|
|
return pas::EAnimationState::Locomotion;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Generate))
|
|
return pas::EAnimationState::Generate;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::MeleeAttack))
|
|
return pas::EAnimationState::MeleeAttack;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::ProjectileAttack))
|
|
return pas::EAnimationState::ProjectileAttack;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::LoopAttack))
|
|
return pas::EAnimationState::LoopAttack;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Jump))
|
|
return pas::EAnimationState::Jump;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::LoopReaction))
|
|
return pas::EAnimationState::LoopReaction;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Scripted))
|
|
return pas::EAnimationState::Scripted;
|
|
if (bc.IsAnimationOver() || bc.GetCommandMgr().GetCmd(EBodyStateCmd::NextState))
|
|
return pas::EAnimationState::Locomotion;
|
|
return pas::EAnimationState::Invalid;
|
|
}
|
|
|
|
pas::EAnimationState CBSStep::UpdateBody(float dt, CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
pas::EAnimationState st = GetBodyStateTransition(dt, bc);
|
|
if (st == pas::EAnimationState::Invalid && !bc.GetCommandMgr().GetTargetVector().isZero())
|
|
bc.FaceDirection(bc.GetCommandMgr().GetTargetVector(), dt);
|
|
return st;
|
|
}
|
|
|
|
void CBSTurn::Start(CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
const zeus::CVector3f& lookDir = bc.GetOwner().GetTransform().basis[1];
|
|
zeus::CVector2f lookDir2d(lookDir.x, lookDir.y);
|
|
x8_dest = zeus::CVector2f(bc.GetCommandMgr().GetFaceVector().x,
|
|
bc.GetCommandMgr().GetFaceVector().y);
|
|
float deltaAngle = zeus::radToDeg(zeus::CVector2f::getAngleDiff(lookDir2d, x8_dest));
|
|
x10_turnDir = pas::ETurnDirection(zeus::CVector2f(lookDir2d.y, -lookDir2d.x).dot(x8_dest) > 0.f);
|
|
CPASAnimParmData parms(8, CPASAnimParm::FromEnum(s32(x10_turnDir)),
|
|
CPASAnimParm::FromReal32(deltaAngle),
|
|
CPASAnimParm::FromEnum(s32(bc.GetLocomotionType())));
|
|
std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
|
|
CAnimPlaybackParms playParms(best.second, -1, 1.f, true);
|
|
bc.SetCurrentAnimation(playParms, false, false);
|
|
float animAngle = bc.GetPASDatabase().GetAnimState(8)->GetAnimParmData(best.second, 1).GetReal32Value();
|
|
x4_rotateSpeed = zeus::degToRad((x10_turnDir == pas::ETurnDirection::Left) ?
|
|
animAngle - deltaAngle : deltaAngle - animAngle);
|
|
float timeRem = bc.GetAnimTimeRemaining();
|
|
if (timeRem > 0.f)
|
|
x4_rotateSpeed /= timeRem;
|
|
}
|
|
|
|
bool CBSTurn::FacingDest(CBodyController& bc) const
|
|
{
|
|
const zeus::CVector3f& lookDir = bc.GetOwner().GetTransform().basis[1];
|
|
zeus::CVector2f lookDir2d(lookDir.x, lookDir.y);
|
|
zeus::CVector2f leftDir(lookDir2d.y, -lookDir2d.x);
|
|
if (x10_turnDir == pas::ETurnDirection::Left)
|
|
{
|
|
if (leftDir.dot(x8_dest) < 0.f)
|
|
return true;
|
|
}
|
|
else
|
|
{
|
|
if (leftDir.dot(x8_dest) > 0.f)
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
pas::EAnimationState CBSTurn::GetBodyStateTransition(float dt, CBodyController& bc)
|
|
{
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Hurled))
|
|
return pas::EAnimationState::Hurled;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::KnockDown))
|
|
return pas::EAnimationState::Fall;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::LoopHitReaction))
|
|
return pas::EAnimationState::LoopReaction;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::KnockBack))
|
|
return pas::EAnimationState::KnockBack;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Locomotion))
|
|
return pas::EAnimationState::Locomotion;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Generate))
|
|
return pas::EAnimationState::Generate;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::MeleeAttack))
|
|
return pas::EAnimationState::MeleeAttack;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::ProjectileAttack))
|
|
return pas::EAnimationState::ProjectileAttack;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::LoopAttack))
|
|
return pas::EAnimationState::LoopAttack;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::LoopReaction))
|
|
return pas::EAnimationState::LoopReaction;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Jump))
|
|
return pas::EAnimationState::Jump;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Step))
|
|
return pas::EAnimationState::Step;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Scripted))
|
|
return pas::EAnimationState::Scripted;
|
|
if (bc.IsAnimationOver() || FacingDest(bc) || !bc.GetCommandMgr().GetMoveVector().isZero())
|
|
return pas::EAnimationState::Locomotion;
|
|
return pas::EAnimationState::Invalid;
|
|
}
|
|
|
|
pas::EAnimationState CBSTurn::UpdateBody(float dt, CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
pas::EAnimationState st = GetBodyStateTransition(dt, bc);
|
|
if (st == pas::EAnimationState::Invalid)
|
|
{
|
|
zeus::CQuaternion quat;
|
|
quat.rotateZ(x4_rotateSpeed * dt);
|
|
bc.SetDeltaRotation(quat);
|
|
}
|
|
return st;
|
|
}
|
|
|
|
void CBSFlyerTurn::Start(CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
if (bc.GetPASDatabase().GetAnimState(8)->GetNumAnims())
|
|
{
|
|
CBSTurn::Start(bc, mgr);
|
|
}
|
|
else
|
|
{
|
|
x8_dest = zeus::CVector2f(bc.GetCommandMgr().GetFaceVector().x,
|
|
bc.GetCommandMgr().GetFaceVector().y);
|
|
const zeus::CVector3f& lookDir = bc.GetOwner().GetTransform().basis[1];
|
|
zeus::CVector2f lookDir2d(lookDir.x, lookDir.y);
|
|
x10_turnDir = pas::ETurnDirection(zeus::CVector2f(lookDir2d.y, -lookDir2d.x).dot(x8_dest) > 0.f);
|
|
CPASAnimParmData parms(5, CPASAnimParm::FromEnum(0),
|
|
CPASAnimParm::FromEnum(s32(bc.GetLocomotionType())));
|
|
std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
|
|
if (best.second != bc.GetCurrentAnimId())
|
|
{
|
|
CAnimPlaybackParms playParms(best.second, -1, 1.f, true);
|
|
bc.SetCurrentAnimation(playParms, true, false);
|
|
}
|
|
}
|
|
}
|
|
|
|
pas::EAnimationState CBSFlyerTurn::UpdateBody(float dt, CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
if (bc.GetPASDatabase().GetAnimState(8)->GetNumAnims())
|
|
{
|
|
return CBSTurn::UpdateBody(dt, bc, mgr);
|
|
}
|
|
else
|
|
{
|
|
pas::EAnimationState st = GetBodyStateTransition(dt, bc);
|
|
if (st == pas::EAnimationState::Invalid)
|
|
{
|
|
if (!bc.GetCommandMgr().GetFaceVector().isZero())
|
|
{
|
|
x8_dest = zeus::CVector2f(bc.GetCommandMgr().GetFaceVector().x,
|
|
bc.GetCommandMgr().GetFaceVector().y);
|
|
const zeus::CVector3f& lookDir = bc.GetOwner().GetTransform().basis[1];
|
|
zeus::CVector2f lookDir2d(lookDir.x, lookDir.y);
|
|
x10_turnDir = pas::ETurnDirection(zeus::CVector2f(lookDir2d.y, -lookDir2d.x).dot(x8_dest) > 0.f);
|
|
}
|
|
bc.FaceDirection(zeus::CVector3f(x8_dest.x, x8_dest.y, 0.f), dt);
|
|
}
|
|
return st;
|
|
}
|
|
}
|
|
|
|
void CBSLoopAttack::Start(CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
const CBCLoopAttackCmd* cmd =
|
|
static_cast<const CBCLoopAttackCmd*>(bc.GetCommandMgr().GetCmd(EBodyStateCmd::LoopAttack));
|
|
x8_loopAttackType = cmd->GetAttackType();
|
|
xc_24_waitForAnimOver = cmd->WaitForAnimOver();
|
|
xc_25_advance = false;
|
|
if (bc.GetLocomotionType() == pas::ELocomotionType::Crouch)
|
|
{
|
|
CPASAnimParmData parms(9, CPASAnimParm::FromEnum(s32(x4_state)),
|
|
CPASAnimParm::FromEnum(s32(x8_loopAttackType)));
|
|
bc.LoopBestAnimation(parms, *mgr.GetActiveRandom());
|
|
}
|
|
else
|
|
{
|
|
x4_state = pas::ELoopState::Begin;
|
|
CPASAnimParmData parms(9, CPASAnimParm::FromEnum(s32(x4_state)),
|
|
CPASAnimParm::FromEnum(s32(x8_loopAttackType)));
|
|
std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
|
|
if (best.first > FLT_EPSILON)
|
|
{
|
|
CAnimPlaybackParms playParms(best.second, -1, 1.f, true);
|
|
bc.SetCurrentAnimation(playParms, false, false);
|
|
}
|
|
else
|
|
{
|
|
x4_state = pas::ELoopState::Loop;
|
|
CPASAnimParmData parms(9, CPASAnimParm::FromEnum(s32(x4_state)),
|
|
CPASAnimParm::FromEnum(s32(x8_loopAttackType)));
|
|
bc.LoopBestAnimation(parms, *mgr.GetActiveRandom());
|
|
}
|
|
}
|
|
}
|
|
|
|
pas::EAnimationState CBSLoopAttack::GetBodyStateTransition(float dt, CBodyController& bc)
|
|
{
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Hurled))
|
|
return pas::EAnimationState::Hurled;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::KnockDown))
|
|
return pas::EAnimationState::Fall;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::LoopHitReaction))
|
|
return pas::EAnimationState::LoopReaction;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::KnockBack))
|
|
return pas::EAnimationState::KnockBack;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Locomotion))
|
|
return pas::EAnimationState::Locomotion;
|
|
if (x4_state == pas::ELoopState::End)
|
|
{
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::MeleeAttack))
|
|
return pas::EAnimationState::MeleeAttack;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::ProjectileAttack))
|
|
return pas::EAnimationState::ProjectileAttack;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::LoopAttack))
|
|
return pas::EAnimationState::LoopAttack;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Step))
|
|
return pas::EAnimationState::Step;
|
|
if (!bc.GetCommandMgr().GetMoveVector().isZero())
|
|
return pas::EAnimationState::Locomotion;
|
|
if (!bc.GetCommandMgr().GetFaceVector().isZero())
|
|
return pas::EAnimationState::Turn;
|
|
}
|
|
return pas::EAnimationState::Invalid;
|
|
}
|
|
|
|
pas::EAnimationState CBSLoopAttack::UpdateBody(float dt, CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
pas::EAnimationState st = GetBodyStateTransition(dt, bc);
|
|
if (st == pas::EAnimationState::Invalid)
|
|
{
|
|
xc_25_advance |= bc.GetCommandMgr().GetCmd(EBodyStateCmd::ExitState) != nullptr;
|
|
switch (x4_state)
|
|
{
|
|
case pas::ELoopState::Begin:
|
|
if (xc_25_advance && (!xc_24_waitForAnimOver || bc.IsAnimationOver()))
|
|
{
|
|
x4_state = pas::ELoopState::Invalid;
|
|
return pas::EAnimationState::Locomotion;
|
|
}
|
|
if (bc.IsAnimationOver())
|
|
{
|
|
CPASAnimParmData parms(9, CPASAnimParm::FromEnum(1),
|
|
CPASAnimParm::FromEnum(s32(x8_loopAttackType)));
|
|
bc.LoopBestAnimation(parms, *mgr.GetActiveRandom());
|
|
x4_state = pas::ELoopState::Loop;
|
|
}
|
|
else if (!bc.GetCommandMgr().GetTargetVector().isZero())
|
|
{
|
|
bc.FaceDirection(bc.GetCommandMgr().GetTargetVector(), dt);
|
|
}
|
|
break;
|
|
case pas::ELoopState::Loop:
|
|
if (xc_25_advance && (!xc_24_waitForAnimOver || bc.IsAnimationOver()))
|
|
{
|
|
if (bc.GetLocomotionType() != pas::ELocomotionType::Crouch)
|
|
{
|
|
CPASAnimParmData parms(9, CPASAnimParm::FromEnum(2),
|
|
CPASAnimParm::FromEnum(s32(x8_loopAttackType)));
|
|
bc.PlayBestAnimation(parms, *mgr.GetActiveRandom());
|
|
x4_state = pas::ELoopState::End;
|
|
}
|
|
else
|
|
{
|
|
x4_state = pas::ELoopState::Invalid;
|
|
return pas::EAnimationState::Locomotion;
|
|
}
|
|
}
|
|
break;
|
|
case pas::ELoopState::End:
|
|
if (bc.IsAnimationOver())
|
|
{
|
|
x4_state = pas::ELoopState::Invalid;
|
|
return pas::EAnimationState::Locomotion;
|
|
}
|
|
break;
|
|
default: break;
|
|
}
|
|
}
|
|
return st;
|
|
}
|
|
|
|
void CBSLoopReaction::Start(CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
if (const CBCLoopReactionCmd* cmd =
|
|
static_cast<const CBCLoopReactionCmd*>(bc.GetCommandMgr().GetCmd(EBodyStateCmd::LoopReaction)))
|
|
{
|
|
x8_reactionType = cmd->GetReactionType();
|
|
xc_24_loopHit = false;
|
|
}
|
|
else
|
|
{
|
|
const CBCLoopHitReactionCmd* hcmd =
|
|
static_cast<const CBCLoopHitReactionCmd*>(bc.GetCommandMgr().GetCmd(EBodyStateCmd::LoopHitReaction));
|
|
x8_reactionType = hcmd->GetReactionType();
|
|
xc_24_loopHit = true;
|
|
}
|
|
|
|
x4_state = pas::ELoopState::Begin;
|
|
CPASAnimParmData parms(10, CPASAnimParm::FromEnum(s32(x8_reactionType)),
|
|
CPASAnimParm::FromEnum(s32(x4_state)));
|
|
std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
|
|
if (best.first > FLT_EPSILON)
|
|
{
|
|
CAnimPlaybackParms playParms(best.second, -1, 1.f, true);
|
|
bc.SetCurrentAnimation(playParms, false, false);
|
|
}
|
|
else
|
|
{
|
|
x4_state = pas::ELoopState::Loop;
|
|
CPASAnimParmData parms(10, CPASAnimParm::FromEnum(s32(x8_reactionType)),
|
|
CPASAnimParm::FromEnum(s32(x4_state)));
|
|
bc.LoopBestAnimation(parms, *mgr.GetActiveRandom());
|
|
}
|
|
}
|
|
|
|
pas::EAnimationState CBSLoopReaction::GetBodyStateTransition(float dt, CBodyController& bc)
|
|
{
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Hurled))
|
|
return pas::EAnimationState::Hurled;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::KnockDown))
|
|
return pas::EAnimationState::Fall;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::KnockBack))
|
|
return pas::EAnimationState::KnockBack;
|
|
if (!xc_24_loopHit && bc.GetCommandMgr().GetCmd(EBodyStateCmd::Locomotion))
|
|
return pas::EAnimationState::Locomotion;
|
|
if (x4_state == pas::ELoopState::End)
|
|
{
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::MeleeAttack))
|
|
return pas::EAnimationState::MeleeAttack;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::ProjectileAttack))
|
|
return pas::EAnimationState::ProjectileAttack;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::LoopAttack))
|
|
return pas::EAnimationState::LoopAttack;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Step))
|
|
return pas::EAnimationState::Step;
|
|
if (!bc.GetCommandMgr().GetMoveVector().isZero())
|
|
return pas::EAnimationState::Locomotion;
|
|
if (!bc.GetCommandMgr().GetFaceVector().isZero())
|
|
return pas::EAnimationState::Turn;
|
|
}
|
|
return pas::EAnimationState::Invalid;
|
|
}
|
|
|
|
bool CBSLoopReaction::PlayExitAnimation(CBodyController& bc, CStateManager& mgr) const
|
|
{
|
|
CPASAnimParmData parms(10, CPASAnimParm::FromEnum(int(x8_reactionType)),
|
|
CPASAnimParm::FromEnum(2));
|
|
std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
|
|
if (best.first > 0.f)
|
|
{
|
|
CAnimPlaybackParms playParms(best.second, -1, 1.f, true);
|
|
bc.SetCurrentAnimation(playParms, false, false);
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
pas::EAnimationState CBSLoopReaction::UpdateBody(float dt, CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
pas::EAnimationState st = GetBodyStateTransition(dt, bc);
|
|
if (st == pas::EAnimationState::Invalid)
|
|
{
|
|
switch (x4_state)
|
|
{
|
|
case pas::ELoopState::Begin:
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::ExitState))
|
|
{
|
|
if (PlayExitAnimation(bc, mgr))
|
|
{
|
|
x4_state = pas::ELoopState::End;
|
|
}
|
|
else
|
|
{
|
|
x4_state = pas::ELoopState::Invalid;
|
|
return pas::EAnimationState::Locomotion;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
if (bc.IsAnimationOver())
|
|
{
|
|
CPASAnimParmData parms(10, CPASAnimParm::FromEnum(s32(x8_reactionType)),
|
|
CPASAnimParm::FromEnum(1));
|
|
bc.LoopBestAnimation(parms, *mgr.GetActiveRandom());
|
|
x4_state = pas::ELoopState::Loop;
|
|
}
|
|
else if (!bc.GetCommandMgr().GetTargetVector().isZero())
|
|
{
|
|
bc.FaceDirection(bc.GetCommandMgr().GetTargetVector(), dt);
|
|
}
|
|
}
|
|
break;
|
|
case pas::ELoopState::Loop:
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::ExitState))
|
|
{
|
|
if (PlayExitAnimation(bc, mgr))
|
|
{
|
|
x4_state = pas::ELoopState::End;
|
|
}
|
|
else
|
|
{
|
|
x4_state = pas::ELoopState::Invalid;
|
|
return pas::EAnimationState::Locomotion;
|
|
}
|
|
}
|
|
else if (!bc.GetCommandMgr().GetTargetVector().isZero())
|
|
{
|
|
bc.FaceDirection(bc.GetCommandMgr().GetTargetVector(), dt);
|
|
}
|
|
break;
|
|
case pas::ELoopState::End:
|
|
if (bc.IsAnimationOver())
|
|
{
|
|
x4_state = pas::ELoopState::Invalid;
|
|
return pas::EAnimationState::Locomotion;
|
|
}
|
|
break;
|
|
default: break;
|
|
}
|
|
}
|
|
return st;
|
|
}
|
|
|
|
void CBSGroundHit::Start(CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
const CBCKnockBackCmd* cmd =
|
|
static_cast<const CBCKnockBackCmd*>(bc.GetCommandMgr().GetCmd(EBodyStateCmd::KnockBack));
|
|
zeus::CVector3f localDir = bc.GetOwner().GetTransform().transposeRotate(cmd->GetHitDirection());
|
|
zeus::CRelAngle angle = std::atan2(localDir.y, localDir.x);
|
|
CPASAnimParmData parms(11, CPASAnimParm::FromEnum(s32(bc.GetFallState())),
|
|
CPASAnimParm::FromReal32(angle.asDegrees()));
|
|
std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
|
|
CAnimPlaybackParms playParms(best.second, -1, 1.f, true);
|
|
bc.SetCurrentAnimation(playParms, false, false);
|
|
const CPASAnimState* groundHitState = bc.GetPASDatabase().GetAnimState(11);
|
|
if (!groundHitState->GetAnimParmData(best.second, 2).GetBoolValue())
|
|
{
|
|
float animAngle = zeus::degToRad(groundHitState->GetAnimParmData(best.second, 1).GetReal32Value());
|
|
zeus::CRelAngle delta1 = angle - animAngle;
|
|
zeus::CRelAngle delta2 = animAngle - angle;
|
|
float minAngle = std::min(float(delta1), float(delta2));
|
|
float flippedAngle = (delta1 > M_PIF) ? -minAngle : minAngle;
|
|
x8_remTime = 0.15f * bc.GetAnimTimeRemaining();
|
|
x4_rotateSpeed = (x8_remTime > FLT_EPSILON) ? flippedAngle / x8_remTime : flippedAngle;
|
|
}
|
|
else
|
|
{
|
|
x8_remTime = 0.f;
|
|
x4_rotateSpeed = 0.f;
|
|
}
|
|
xc_fallState = pas::EFallState(groundHitState->GetAnimParmData(best.second, 3).GetEnumValue());
|
|
}
|
|
|
|
pas::EAnimationState CBSGroundHit::GetBodyStateTransition(float dt, CBodyController& bc)
|
|
{
|
|
if (bc.IsAnimationOver())
|
|
{
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Die))
|
|
return pas::EAnimationState::Death;
|
|
return pas::EAnimationState::LieOnGround;
|
|
}
|
|
return pas::EAnimationState::Invalid;
|
|
}
|
|
|
|
pas::EAnimationState CBSGroundHit::UpdateBody(float dt, CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
pas::EAnimationState st = GetBodyStateTransition(dt, bc);
|
|
if (st == pas::EAnimationState::Invalid && x8_remTime > 0.f)
|
|
{
|
|
zeus::CQuaternion quat;
|
|
quat.rotateZ(x4_rotateSpeed * dt);
|
|
bc.SetDeltaRotation(quat);
|
|
x8_remTime -= dt;
|
|
}
|
|
return st;
|
|
}
|
|
|
|
void CBSGroundHit::Shutdown(CBodyController& bc)
|
|
{
|
|
bc.SetFallState(xc_fallState);
|
|
}
|
|
|
|
void CBSGenerate::Start(CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
const CBCGenerateCmd* cmd =
|
|
static_cast<const CBCGenerateCmd*>(bc.GetCommandMgr().GetCmd(EBodyStateCmd::Generate));
|
|
s32 anim;
|
|
if (!cmd->UseSpecialAnimId())
|
|
{
|
|
CPASAnimParmData parms(12, CPASAnimParm::FromEnum(s32(cmd->GetGenerateType())));
|
|
std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
|
|
anim = best.second;
|
|
}
|
|
else
|
|
{
|
|
anim = cmd->GetSpecialAnimId();
|
|
}
|
|
|
|
if (cmd->HasExitTargetPos())
|
|
{
|
|
CAnimPlaybackParms playParms(anim, nullptr, &cmd->GetExitTargetPos(), &bc.GetOwner().GetTransform(),
|
|
&bc.GetOwner().GetModelData()->GetScale(), false);
|
|
bc.SetCurrentAnimation(playParms, false, false);
|
|
}
|
|
else
|
|
{
|
|
CAnimPlaybackParms playParms(anim, -1, 1.f, true);
|
|
bc.SetCurrentAnimation(playParms, false, false);
|
|
}
|
|
}
|
|
|
|
pas::EAnimationState CBSGenerate::GetBodyStateTransition(float dt, CBodyController& bc)
|
|
{
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Hurled))
|
|
return pas::EAnimationState::Hurled;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::KnockDown))
|
|
return pas::EAnimationState::Fall;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Generate))
|
|
return pas::EAnimationState::Generate;
|
|
if (bc.IsAnimationOver() || bc.GetCommandMgr().GetCmd(EBodyStateCmd::NextState))
|
|
return pas::EAnimationState::Locomotion;
|
|
return pas::EAnimationState::Invalid;
|
|
}
|
|
|
|
pas::EAnimationState CBSGenerate::UpdateBody(float dt, CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
pas::EAnimationState st = GetBodyStateTransition(dt, bc);
|
|
if (st == pas::EAnimationState::Invalid)
|
|
if (!bc.GetCommandMgr().GetTargetVector().isZero())
|
|
bc.FaceDirection(bc.GetCommandMgr().GetTargetVector(), dt);
|
|
return st;
|
|
}
|
|
|
|
void CBSJump::Start(CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
const CBCJumpCmd* cmd =
|
|
static_cast<const CBCJumpCmd*>(bc.GetCommandMgr().GetCmd(EBodyStateCmd::Jump));
|
|
x8_jumpType = cmd->GetJumpType();
|
|
xc_waypoint1 = cmd->GetJumpTarget();
|
|
x24_waypoint2 = cmd->GetSecondJumpTarget();
|
|
x30_25_wallJump = cmd->IsWallJump();
|
|
x30_28_startInJumpLoop = cmd->StartInJumpLoop();
|
|
x30_24_bodyForceSet = false;
|
|
x30_27_wallBounceComplete = false;
|
|
if (x30_25_wallJump)
|
|
x30_26_wallBounceRight =
|
|
(xc_waypoint1 - bc.GetOwner().GetTranslation()).cross(zeus::CVector3f::skUp).
|
|
dot(x24_waypoint2 - xc_waypoint1) < 0.f;
|
|
if (!cmd->StartInJumpLoop())
|
|
{
|
|
x4_state = pas::EJumpState::IntoJump;
|
|
CPASAnimParmData parms(13, CPASAnimParm::FromEnum(s32(x4_state)),
|
|
CPASAnimParm::FromEnum(s32(x8_jumpType)));
|
|
bc.PlayBestAnimation(parms, *mgr.GetActiveRandom());
|
|
}
|
|
else
|
|
{
|
|
PlayJumpLoop(mgr, bc);
|
|
}
|
|
}
|
|
|
|
pas::EAnimationState CBSJump::GetBodyStateTransition(float dt, CBodyController& bc)
|
|
{
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Hurled))
|
|
return pas::EAnimationState::Hurled;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::KnockDown))
|
|
return pas::EAnimationState::Fall;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Jump) &&
|
|
bc.GetBodyType() == EBodyType::WallWalker)
|
|
return pas::EAnimationState::Jump;
|
|
return pas::EAnimationState::Invalid;
|
|
}
|
|
|
|
bool CBSJump::CheckForWallJump(CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
if (x30_25_wallJump && !x30_27_wallBounceComplete)
|
|
{
|
|
if (TCastToPtr<CPatterned> act = bc.GetOwner())
|
|
{
|
|
float distToWall = (xc_waypoint1 - act->GetTranslation()).magnitude();
|
|
zeus::CAABox aabb = act->GetBoundingBox();
|
|
float xExtent = (aabb.max.x - aabb.min.x) * 0.5f;
|
|
if (distToWall < 1.414f * xExtent || (act->CanLongJump() && distToWall < 3.f * xExtent))
|
|
{
|
|
x4_state = x30_26_wallBounceRight ? pas::EJumpState::WallBounceRight : pas::EJumpState::WallBounceLeft;
|
|
CPASAnimParmData parms(13, CPASAnimParm::FromEnum(s32(x4_state)),
|
|
CPASAnimParm::FromEnum(s32(x8_jumpType)));
|
|
bc.PlayBestAnimation(parms, *mgr.GetActiveRandom());
|
|
mgr.SendScriptMsg(act.GetPtr(), kInvalidUniqueId, EScriptObjectMessage::OnFloor);
|
|
return true;
|
|
}
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void CBSJump::CheckForLand(CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
if (TCastToPtr<CPatterned> act = bc.GetOwner())
|
|
{
|
|
if (act->CanLongJump() || act->IsOnGround())
|
|
{
|
|
x4_state = pas::EJumpState::OutOfJump;
|
|
CPASAnimParmData parms(13, CPASAnimParm::FromEnum(s32(x4_state)),
|
|
CPASAnimParm::FromEnum(s32(x8_jumpType)));
|
|
bc.PlayBestAnimation(parms, *mgr.GetActiveRandom());
|
|
mgr.SendScriptMsg(act.GetPtr(), kInvalidUniqueId, EScriptObjectMessage::OnFloor);
|
|
}
|
|
}
|
|
}
|
|
|
|
void CBSJump::PlayJumpLoop(CStateManager& mgr, CBodyController& bc)
|
|
{
|
|
CPASAnimParmData parms(13, CPASAnimParm::FromEnum(1),
|
|
CPASAnimParm::FromEnum(s32(x8_jumpType)));
|
|
std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
|
|
if (best.first > 99.f)
|
|
{
|
|
x4_state = pas::EJumpState::AmbushJump;
|
|
CAnimPlaybackParms playParms(best.second, -1, 1.f, true);
|
|
bc.SetCurrentAnimation(playParms, false, false);
|
|
}
|
|
else
|
|
{
|
|
x4_state = pas::EJumpState::Loop;
|
|
CPASAnimParmData parms(13, CPASAnimParm::FromEnum(s32(x4_state)),
|
|
CPASAnimParm::FromEnum(s32(x8_jumpType)));
|
|
bc.LoopBestAnimation(parms, *mgr.GetActiveRandom());
|
|
}
|
|
|
|
if (TCastToPtr<CPhysicsActor> act = bc.GetOwner())
|
|
{
|
|
mgr.SendScriptMsg(act.GetPtr(), kInvalidUniqueId, EScriptObjectMessage::Falling);
|
|
mgr.SendScriptMsg(act.GetPtr(), kInvalidUniqueId, EScriptObjectMessage::Jumped);
|
|
x30_24_bodyForceSet = false;
|
|
x18_velocity = act->GetVelocity();
|
|
}
|
|
}
|
|
|
|
pas::EAnimationState CBSJump::UpdateBody(float dt, CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
pas::EAnimationState st = GetBodyStateTransition(dt, bc);
|
|
if (st == pas::EAnimationState::Invalid)
|
|
{
|
|
switch (x4_state)
|
|
{
|
|
case pas::EJumpState::IntoJump:
|
|
if (bc.IsAnimationOver())
|
|
PlayJumpLoop(mgr, bc);
|
|
break;
|
|
case pas::EJumpState::AmbushJump:
|
|
if (!x30_24_bodyForceSet)
|
|
{
|
|
if (TCastToPtr<CPhysicsActor> act = bc.GetOwner())
|
|
act->SetConstantForce(act->GetMass() * x18_velocity);
|
|
x30_24_bodyForceSet = true;
|
|
}
|
|
if (!bc.GetCommandMgr().GetTargetVector().isZero())
|
|
bc.FaceDirection(bc.GetCommandMgr().GetTargetVector(), dt);
|
|
if (bc.IsAnimationOver())
|
|
{
|
|
x4_state = pas::EJumpState::Loop;
|
|
CPASAnimParmData parms(13, CPASAnimParm::FromEnum(s32(x4_state)),
|
|
CPASAnimParm::FromEnum(s32(x8_jumpType)));
|
|
bc.LoopBestAnimation(parms, *mgr.GetActiveRandom());
|
|
}
|
|
else
|
|
{
|
|
if (!CheckForWallJump(bc, mgr))
|
|
CheckForLand(bc, mgr);
|
|
}
|
|
break;
|
|
case pas::EJumpState::Loop:
|
|
if (!x30_24_bodyForceSet)
|
|
{
|
|
if (TCastToPtr<CPhysicsActor> act = bc.GetOwner())
|
|
act->SetConstantForce(act->GetMass() * x18_velocity);
|
|
x30_24_bodyForceSet = true;
|
|
}
|
|
if (!bc.GetCommandMgr().GetTargetVector().isZero())
|
|
bc.FaceDirection(bc.GetCommandMgr().GetTargetVector(), dt);
|
|
if (!CheckForWallJump(bc, mgr))
|
|
CheckForLand(bc, mgr);
|
|
break;
|
|
case pas::EJumpState::WallBounceLeft:
|
|
case pas::EJumpState::WallBounceRight:
|
|
if (TCastToPtr<CPhysicsActor> act = bc.GetOwner())
|
|
{
|
|
act->Stop();
|
|
act->SetMomentumWR(zeus::CVector3f::skZero);
|
|
}
|
|
if (bc.IsAnimationOver())
|
|
{
|
|
mgr.SendScriptMsg(&bc.GetOwner(), kInvalidUniqueId, EScriptObjectMessage::Falling);
|
|
x4_state = pas::EJumpState::Loop;
|
|
CPASAnimParmData parms(13, CPASAnimParm::FromEnum(s32(x4_state)),
|
|
CPASAnimParm::FromEnum(s32(x8_jumpType)));
|
|
bc.LoopBestAnimation(parms, *mgr.GetActiveRandom());
|
|
x30_27_wallBounceComplete = true;
|
|
if (TCastToPtr<CPatterned> act = bc.GetOwner())
|
|
{
|
|
zeus::CVector3f toFinal = x24_waypoint2 - act->GetTranslation();
|
|
float tmp = std::sqrt(act->GetGravityConstant() / (2.f * toFinal.z));
|
|
act->SetVelocityWR(zeus::CVector3f(tmp * toFinal.x, tmp * toFinal.y, 0.f));
|
|
}
|
|
}
|
|
break;
|
|
case pas::EJumpState::OutOfJump:
|
|
if (bc.IsAnimationOver())
|
|
{
|
|
x4_state = pas::EJumpState::Invalid;
|
|
return pas::EAnimationState::Locomotion;
|
|
}
|
|
break;
|
|
default: break;
|
|
}
|
|
}
|
|
return st;
|
|
}
|
|
|
|
bool CBSJump::ApplyAnimationDeltas() const
|
|
{
|
|
if (x4_state == pas::EJumpState::AmbushJump || x4_state == pas::EJumpState::Loop)
|
|
return false;
|
|
return true;
|
|
}
|
|
|
|
bool CBSJump::IsInAir(const CBodyController& bc) const
|
|
{
|
|
return x4_state == pas::EJumpState::AmbushJump || x4_state == pas::EJumpState::Loop;
|
|
}
|
|
|
|
bool CBSJump::CanShoot() const
|
|
{
|
|
return x4_state == pas::EJumpState::AmbushJump || x4_state == pas::EJumpState::Loop;
|
|
}
|
|
|
|
void CBSHurled::Start(CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
const CBCHurledCmd* cmd =
|
|
static_cast<const CBCHurledCmd*>(bc.GetCommandMgr().GetCmd(EBodyStateCmd::Hurled));
|
|
x4_state = pas::EHurledState(cmd->GetSkipLaunchState());
|
|
zeus::CVector3f localDir = bc.GetOwner().GetTransform().transposeRotate(cmd->GetHitDirection());
|
|
zeus::CRelAngle angle = std::atan2(localDir.y, localDir.x);
|
|
x8_knockAngle = angle.asDegrees();
|
|
CPASAnimParmData parms(14, CPASAnimParm::FromInt32(-1),
|
|
CPASAnimParm::FromReal32(x8_knockAngle),
|
|
CPASAnimParm::FromEnum(s32(x4_state)));
|
|
std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
|
|
CAnimPlaybackParms playParms(best.second, -1, 1.f, true);
|
|
bc.SetCurrentAnimation(playParms, false, false);
|
|
const CPASAnimState* hurledState = bc.GetPASDatabase().GetAnimState(14);
|
|
xc_animSeries = hurledState->GetAnimParmData(best.second, 0).GetInt32Value();
|
|
mgr.SendScriptMsg(&bc.GetOwner(), kInvalidUniqueId, EScriptObjectMessage::Falling);
|
|
mgr.SendScriptMsg(&bc.GetOwner(), kInvalidUniqueId, EScriptObjectMessage::Jumped);
|
|
if (!zeus::close_enough(cmd->GetLaunchVelocity(), zeus::CVector3f::skZero, 0.0001f))
|
|
if (TCastToPtr<CPhysicsActor> act = bc.GetOwner())
|
|
act->SetConstantForce(act->GetMass() * cmd->GetLaunchVelocity());
|
|
float animAngle = zeus::degToRad(hurledState->GetAnimParmData(best.second, 1).GetReal32Value());
|
|
zeus::CRelAngle delta1 = angle - animAngle;
|
|
zeus::CRelAngle delta2 = animAngle - angle;
|
|
float minAngle = std::min(float(delta1), float(delta2));
|
|
x14_remTime = 0.15f * bc.GetAnimTimeRemaining();
|
|
float flippedAngle = (delta1 > M_PIF) ? -minAngle : minAngle;
|
|
x10_rotateSpeed = (x14_remTime > FLT_EPSILON) ? flippedAngle / x14_remTime : flippedAngle;
|
|
x18_curTime = 0.f;
|
|
x2c_24_needsRecover = false;
|
|
}
|
|
|
|
pas::EAnimationState CBSHurled::GetBodyStateTransition(float dt, CBodyController& bc)
|
|
{
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::NextState))
|
|
return pas::EAnimationState::LieOnGround;
|
|
if (x18_curTime > 0.25f)
|
|
{
|
|
if (const CBCHurledCmd* cmd =
|
|
static_cast<const CBCHurledCmd*>(bc.GetCommandMgr().GetCmd(EBodyStateCmd::Hurled)))
|
|
{
|
|
const_cast<CBCHurledCmd*>(cmd)->SetSkipLaunchState(true);
|
|
return pas::EAnimationState::Hurled;
|
|
}
|
|
}
|
|
return pas::EAnimationState::Invalid;
|
|
}
|
|
|
|
void CBSHurled::Recover(CStateManager& mgr, CBodyController& bc, pas::EHurledState state)
|
|
{
|
|
CPASAnimParmData parms(14, CPASAnimParm::FromInt32(xc_animSeries),
|
|
CPASAnimParm::FromReal32(x8_knockAngle),
|
|
CPASAnimParm::FromEnum(s32(state)));
|
|
std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
|
|
if (best.first > FLT_EPSILON)
|
|
{
|
|
CAnimPlaybackParms playParms(best.second, -1, 1.f, true);
|
|
bc.SetCurrentAnimation(playParms, false, false);
|
|
x4_state = state;
|
|
if (TCastToPtr<CPhysicsActor> act = bc.GetOwner())
|
|
act->SetMomentumWR(zeus::CVector3f::skZero);
|
|
}
|
|
x2c_24_needsRecover = false;
|
|
}
|
|
|
|
void CBSHurled::PlayStrikeWallAnimation(CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
CPASAnimParmData parms(14, CPASAnimParm::FromInt32(xc_animSeries),
|
|
CPASAnimParm::FromReal32(x8_knockAngle),
|
|
CPASAnimParm::FromEnum(3));
|
|
std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
|
|
if (best.first > FLT_EPSILON)
|
|
{
|
|
CAnimPlaybackParms playParms(best.second, -1, 1.f, true);
|
|
bc.SetCurrentAnimation(playParms, false, false);
|
|
x4_state = pas::EHurledState::StrikeWall;
|
|
}
|
|
}
|
|
|
|
void CBSHurled::PlayLandAnimation(CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
CPASAnimParmData parms(14, CPASAnimParm::FromInt32(xc_animSeries),
|
|
CPASAnimParm::FromReal32(x8_knockAngle),
|
|
CPASAnimParm::FromEnum(s32(x4_state)));
|
|
std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
|
|
CAnimPlaybackParms playParms(best.second, -1, 1.f, true);
|
|
bc.SetCurrentAnimation(playParms, false, false);
|
|
const CPASAnimState* hurledState = bc.GetPASDatabase().GetAnimState(14);
|
|
bc.SetFallState(pas::EFallState(hurledState->GetAnimParmData(best.second, 3).GetEnumValue()));
|
|
if (TCastToPtr<CPhysicsActor> act = bc.GetOwner())
|
|
mgr.SendScriptMsg(act.GetPtr(), kInvalidUniqueId, EScriptObjectMessage::OnFloor);
|
|
}
|
|
|
|
bool CBSHurled::ShouldStartStrikeWall(CBodyController& bc) const
|
|
{
|
|
if (TCastToPtr<CPatterned> ai = bc.GetOwner())
|
|
{
|
|
if (ai->CanLongJump())
|
|
if (!ai->IsOnGround())
|
|
return true;
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CBSHurled::ShouldStartLand(float dt, CBodyController& bc) const
|
|
{
|
|
bool ret = true;
|
|
if (TCastToPtr<CPatterned> ai = bc.GetOwner())
|
|
{
|
|
ret = false;
|
|
if (ai->IsOnGround())
|
|
return true;
|
|
if (zeus::close_enough(ai->GetTranslation(), x1c_lastTranslation, 0.0001f) &&
|
|
ai->GetVelocity().z < 0.f)
|
|
{
|
|
x28_landedDur += dt;
|
|
if (x28_landedDur >= 0.25f)
|
|
ret = true;
|
|
}
|
|
else
|
|
{
|
|
x28_landedDur = 0.f;
|
|
}
|
|
x1c_lastTranslation = ai->GetTranslation();
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
pas::EAnimationState CBSHurled::UpdateBody(float dt, CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
pas::EAnimationState st = GetBodyStateTransition(dt, bc);
|
|
if (st == pas::EAnimationState::Invalid)
|
|
{
|
|
x18_curTime += dt;
|
|
if (x14_remTime > 0.f)
|
|
{
|
|
zeus::CQuaternion quat;
|
|
quat.rotateZ(x10_rotateSpeed * dt);
|
|
bc.SetDeltaRotation(quat);
|
|
x14_remTime -= dt;
|
|
}
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::ExitState))
|
|
x2c_24_needsRecover = true;
|
|
switch (x4_state)
|
|
{
|
|
case pas::EHurledState::KnockIntoAir:
|
|
{
|
|
if (bc.IsAnimationOver())
|
|
{
|
|
CPASAnimParmData parms(14, CPASAnimParm::FromInt32(xc_animSeries),
|
|
CPASAnimParm::FromReal32(x8_knockAngle),
|
|
CPASAnimParm::FromEnum(1));
|
|
bc.LoopBestAnimation(parms, *mgr.GetActiveRandom());
|
|
x4_state = pas::EHurledState::KnockLoop;
|
|
x28_landedDur = 0.f;
|
|
}
|
|
break;
|
|
}
|
|
case pas::EHurledState::KnockLoop:
|
|
if (ShouldStartLand(dt, bc))
|
|
{
|
|
x4_state = pas::EHurledState::KnockDown;
|
|
PlayLandAnimation(bc, mgr);
|
|
}
|
|
else if (ShouldStartStrikeWall(bc))
|
|
{
|
|
PlayStrikeWallAnimation(bc, mgr);
|
|
if (TCastToPtr<CPatterned> ai = bc.GetOwner())
|
|
ai->SetVelocityWR(zeus::CVector3f::skDown * (2.f * dt * ai->GetGravityConstant()));
|
|
}
|
|
else if (x2c_24_needsRecover)
|
|
{
|
|
Recover(mgr, bc, pas::EHurledState::Six);
|
|
}
|
|
break;
|
|
case pas::EHurledState::StrikeWall:
|
|
if (bc.IsAnimationOver())
|
|
{
|
|
x4_state = pas::EHurledState::StrikeWallFallLoop;
|
|
CPASAnimParmData parms(14, CPASAnimParm::FromInt32(xc_animSeries),
|
|
CPASAnimParm::FromReal32(x8_knockAngle),
|
|
CPASAnimParm::FromEnum(s32(x4_state)));
|
|
bc.LoopBestAnimation(parms, *mgr.GetActiveRandom());
|
|
x28_landedDur = 0.f;
|
|
}
|
|
break;
|
|
case pas::EHurledState::StrikeWallFallLoop:
|
|
if (ShouldStartLand(dt, bc))
|
|
{
|
|
x4_state = pas::EHurledState::OutOfStrikeWall;
|
|
PlayLandAnimation(bc, mgr);
|
|
}
|
|
else if (x2c_24_needsRecover)
|
|
{
|
|
Recover(mgr, bc, pas::EHurledState::Seven);
|
|
}
|
|
break;
|
|
case pas::EHurledState::Six:
|
|
case pas::EHurledState::Seven:
|
|
if (TCastToPtr<CPhysicsActor> act = bc.GetOwner())
|
|
act->SetVelocityWR(act->GetVelocity() * std::pow(0.9, 60.0 * dt));
|
|
if (bc.IsAnimationOver())
|
|
{
|
|
x4_state = pas::EHurledState::Invalid;
|
|
return pas::EAnimationState::Locomotion;
|
|
}
|
|
break;
|
|
case pas::EHurledState::KnockDown:
|
|
case pas::EHurledState::OutOfStrikeWall:
|
|
if (bc.IsAnimationOver())
|
|
{
|
|
x4_state = pas::EHurledState::Invalid;
|
|
if (bc.GetFallState() == pas::EFallState::Zero)
|
|
return pas::EAnimationState::Locomotion;
|
|
return pas::EAnimationState::LieOnGround;
|
|
}
|
|
break;
|
|
default: break;
|
|
}
|
|
}
|
|
return st;
|
|
}
|
|
|
|
void CBSSlide::Start(CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
const CBCSlideCmd* cmd =
|
|
static_cast<const CBCSlideCmd*>(bc.GetCommandMgr().GetCmd(EBodyStateCmd::Slide));
|
|
zeus::CVector3f localDir = bc.GetOwner().GetTransform().transposeRotate(cmd->GetSlideDirection());
|
|
float angle = std::atan2(localDir.y, localDir.x);
|
|
CPASAnimParmData parms(15, CPASAnimParm::FromEnum(s32(cmd->GetSlideType())),
|
|
CPASAnimParm::FromReal32(zeus::radToDeg(angle)));
|
|
std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
|
|
CAnimPlaybackParms playParms(best.second, -1, 1.f, true);
|
|
bc.SetCurrentAnimation(playParms, false, false);
|
|
float timeRem = bc.GetAnimTimeRemaining();
|
|
if (timeRem > FLT_EPSILON)
|
|
{
|
|
const CPASAnimState* slideState = bc.GetPASDatabase().GetAnimState(15);
|
|
float animAngle = zeus::degToRad(slideState->GetAnimParmData(best.second, 1).GetReal32Value());
|
|
float delta1 = zeus::CRelAngle(angle - animAngle);
|
|
float flippedAngle = (delta1 > M_PIF) ? delta1 - 2.f * M_PIF : delta1;
|
|
x4_rotateSpeed = flippedAngle / timeRem;
|
|
}
|
|
else
|
|
{
|
|
x4_rotateSpeed = 0.f;
|
|
}
|
|
}
|
|
|
|
pas::EAnimationState CBSSlide::GetBodyStateTransition(float dt, CBodyController& bc)
|
|
{
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Hurled))
|
|
return pas::EAnimationState::Hurled;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::KnockDown))
|
|
return pas::EAnimationState::Fall;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::LoopHitReaction))
|
|
return pas::EAnimationState::LoopReaction;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::KnockBack))
|
|
return pas::EAnimationState::KnockBack;
|
|
if (bc.IsAnimationOver())
|
|
return pas::EAnimationState::Locomotion;
|
|
return pas::EAnimationState::Invalid;
|
|
}
|
|
|
|
pas::EAnimationState CBSSlide::UpdateBody(float dt, CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
pas::EAnimationState st = GetBodyStateTransition(dt, bc);
|
|
if (st == pas::EAnimationState::Invalid && x4_rotateSpeed != 0.f)
|
|
{
|
|
zeus::CQuaternion quat;
|
|
quat.rotateZ(x4_rotateSpeed * dt);
|
|
bc.SetDeltaRotation(quat);
|
|
}
|
|
return st;
|
|
}
|
|
|
|
void CBSTaunt::Start(CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
const CBCTauntCmd* cmd =
|
|
static_cast<const CBCTauntCmd*>(bc.GetCommandMgr().GetCmd(EBodyStateCmd::Taunt));
|
|
CPASAnimParmData parms(16, CPASAnimParm::FromEnum(s32(cmd->GetTauntType())));
|
|
bc.PlayBestAnimation(parms, *mgr.GetActiveRandom());
|
|
}
|
|
|
|
pas::EAnimationState CBSTaunt::GetBodyStateTransition(float dt, CBodyController& bc)
|
|
{
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Hurled))
|
|
return pas::EAnimationState::Hurled;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::KnockDown))
|
|
return pas::EAnimationState::Fall;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::LoopHitReaction))
|
|
return pas::EAnimationState::LoopReaction;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::KnockBack))
|
|
return pas::EAnimationState::KnockBack;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Locomotion))
|
|
return pas::EAnimationState::Locomotion;
|
|
if (bc.IsAnimationOver())
|
|
return pas::EAnimationState::Locomotion;
|
|
return pas::EAnimationState::Invalid;
|
|
}
|
|
|
|
pas::EAnimationState CBSTaunt::UpdateBody(float dt, CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
pas::EAnimationState st = GetBodyStateTransition(dt, bc);
|
|
if (st == pas::EAnimationState::Invalid && !bc.GetCommandMgr().GetTargetVector().isZero())
|
|
bc.FaceDirection(bc.GetCommandMgr().GetTargetVector(), dt);
|
|
return st;
|
|
}
|
|
|
|
void CBSScripted::Start(CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
const CBCScriptedCmd* cmd =
|
|
static_cast<const CBCScriptedCmd*>(bc.GetCommandMgr().GetCmd(EBodyStateCmd::Scripted));
|
|
x4_24_loopAnim = cmd->IsLooped();
|
|
x4_25_timedLoop = cmd->GetUseLoopDuration();
|
|
x8_remTime = cmd->GetLoopDuration();
|
|
CAnimPlaybackParms playParms(cmd->GetAnimId(), -1, 1.f, true);
|
|
bc.SetCurrentAnimation(playParms, cmd->IsLooped(), false);
|
|
}
|
|
|
|
pas::EAnimationState CBSScripted::GetBodyStateTransition(float dt, CBodyController& bc)
|
|
{
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Hurled))
|
|
return pas::EAnimationState::Hurled;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::KnockDown))
|
|
return pas::EAnimationState::Fall;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::LoopHitReaction))
|
|
return pas::EAnimationState::LoopReaction;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::KnockBack))
|
|
return pas::EAnimationState::KnockBack;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Scripted))
|
|
return pas::EAnimationState::Scripted;
|
|
if (x4_24_loopAnim && bc.GetCommandMgr().GetCmd(EBodyStateCmd::ExitState))
|
|
return pas::EAnimationState::Locomotion;
|
|
if (bc.IsAnimationOver())
|
|
return pas::EAnimationState::Locomotion;
|
|
return pas::EAnimationState::Invalid;
|
|
}
|
|
|
|
pas::EAnimationState CBSScripted::UpdateBody(float dt, CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
pas::EAnimationState st = GetBodyStateTransition(dt, bc);
|
|
if (st == pas::EAnimationState::Invalid)
|
|
{
|
|
if (!bc.GetCommandMgr().GetTargetVector().isZero())
|
|
bc.FaceDirection(bc.GetCommandMgr().GetTargetVector(), dt);
|
|
if (x4_24_loopAnim && x4_25_timedLoop)
|
|
{
|
|
x8_remTime -= dt;
|
|
if (x8_remTime <= 0.f)
|
|
return pas::EAnimationState::Locomotion;
|
|
}
|
|
}
|
|
return st;
|
|
}
|
|
|
|
void CBSCover::Start(CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
const CBCCoverCmd* cmd =
|
|
static_cast<const CBCCoverCmd*>(bc.GetCommandMgr().GetCmd(EBodyStateCmd::Cover));
|
|
x8_coverDirection = cmd->GetDirection();
|
|
x4_state = pas::ECoverState::IntoCover;
|
|
CPASAnimParmData parms(19, CPASAnimParm::FromEnum(s32(x4_state)),
|
|
CPASAnimParm::FromEnum(s32(x8_coverDirection)));
|
|
std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
|
|
zeus::CQuaternion orientDelta =
|
|
zeus::CQuaternion::lookAt(zeus::CVector3f::skForward, cmd->GetAlignDirection(), 2.f * M_PIF);
|
|
CAnimPlaybackParms playParms(best.second, &orientDelta, &cmd->GetTarget(), &bc.GetOwner().GetTransform(),
|
|
&bc.GetOwner().GetModelData()->GetScale(), false);
|
|
bc.SetCurrentAnimation(playParms, false, false);
|
|
xc_needsExit = false;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::ExitState))
|
|
xc_needsExit = true;
|
|
}
|
|
|
|
pas::EAnimationState CBSCover::GetBodyStateTransition(float dt, CBodyController& bc)
|
|
{
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Hurled))
|
|
return pas::EAnimationState::Hurled;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::KnockDown))
|
|
return pas::EAnimationState::Fall;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::LoopHitReaction))
|
|
return pas::EAnimationState::LoopReaction;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::KnockBack))
|
|
return pas::EAnimationState::KnockBack;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Locomotion))
|
|
return pas::EAnimationState::Locomotion;
|
|
return pas::EAnimationState::Invalid;
|
|
}
|
|
|
|
pas::EAnimationState CBSCover::UpdateBody(float dt, CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
pas::EAnimationState st = GetBodyStateTransition(dt, bc);
|
|
if (st == pas::EAnimationState::Invalid)
|
|
{
|
|
switch (x4_state)
|
|
{
|
|
case pas::ECoverState::Lean:
|
|
case pas::ECoverState::IntoCover:
|
|
if (bc.IsAnimationOver())
|
|
{
|
|
x4_state = pas::ECoverState::Cover;
|
|
CPASAnimParmData parms(19, CPASAnimParm::FromEnum(s32(x4_state)),
|
|
CPASAnimParm::FromEnum(s32(x8_coverDirection)));
|
|
bc.LoopBestAnimation(parms, *mgr.GetActiveRandom());
|
|
}
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::ExitState))
|
|
xc_needsExit = true;
|
|
break;
|
|
case pas::ECoverState::Cover:
|
|
if (!bc.GetCommandMgr().GetTargetVector().isZero())
|
|
bc.FaceDirection(bc.GetCommandMgr().GetTargetVector(), dt);
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::ExitState) || xc_needsExit)
|
|
{
|
|
xc_needsExit = false;
|
|
x4_state = pas::ECoverState::OutOfCover;
|
|
CPASAnimParmData parms(19, CPASAnimParm::FromEnum(s32(x4_state)),
|
|
CPASAnimParm::FromEnum(s32(x8_coverDirection)));
|
|
bc.PlayBestAnimation(parms, *mgr.GetActiveRandom());
|
|
}
|
|
else if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::LeanFromCover))
|
|
{
|
|
x4_state = pas::ECoverState::Lean;
|
|
CPASAnimParmData parms(19, CPASAnimParm::FromEnum(s32(x4_state)),
|
|
CPASAnimParm::FromEnum(s32(x8_coverDirection)));
|
|
bc.PlayBestAnimation(parms, *mgr.GetActiveRandom());
|
|
}
|
|
break;
|
|
case pas::ECoverState::OutOfCover:
|
|
if (bc.IsAnimationOver())
|
|
{
|
|
x4_state = pas::ECoverState::Invalid;
|
|
return pas::EAnimationState::Locomotion;
|
|
}
|
|
break;
|
|
default: break;
|
|
}
|
|
}
|
|
return st;
|
|
}
|
|
|
|
void CBSWallHang::Start(CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
const CBCWallHangCmd* cmd =
|
|
static_cast<const CBCWallHangCmd*>(bc.GetCommandMgr().GetCmd(EBodyStateCmd::WallHang));
|
|
x4_state = pas::EWallHangState::IntoJump;
|
|
x8_wpId = cmd->GetTarget();
|
|
x18_25_needsExit = false;
|
|
CPASAnimParmData parms(20, CPASAnimParm::FromEnum(s32(x4_state)));
|
|
bc.PlayBestAnimation(parms, *mgr.GetActiveRandom());
|
|
}
|
|
|
|
pas::EAnimationState CBSWallHang::GetBodyStateTransition(float dt, CBodyController& bc)
|
|
{
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Hurled))
|
|
return pas::EAnimationState::Hurled;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::KnockDown))
|
|
return pas::EAnimationState::Fall;
|
|
return pas::EAnimationState::Invalid;
|
|
}
|
|
|
|
void CBSWallHang::FixInPlace(CBodyController& bc)
|
|
{
|
|
if (TCastToPtr<CAi> ai = bc.GetOwner())
|
|
{
|
|
ai->SetConstantForce(zeus::CVector3f::skZero);
|
|
ai->SetVelocityWR(zeus::CVector3f::skZero);
|
|
}
|
|
}
|
|
|
|
bool CBSWallHang::CheckForLand(CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
if (TCastToPtr<CPatterned> ai = bc.GetOwner())
|
|
{
|
|
if (ai->CanLongJump() || ai->IsOnGround())
|
|
{
|
|
x4_state = pas::EWallHangState::DetachOutOfJump;
|
|
CPASAnimParmData parms(20, CPASAnimParm::FromEnum(s32(x4_state)));
|
|
bc.PlayBestAnimation(parms, *mgr.GetActiveRandom());
|
|
mgr.SendScriptMsg(ai.GetPtr(), kInvalidUniqueId, EScriptObjectMessage::OnFloor);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
bool CBSWallHang::CheckForWall(CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
if (TCastToPtr<CPatterned> ai = bc.GetOwner())
|
|
{
|
|
float magSq = 10.f;
|
|
TCastToPtr<CActor> wp = mgr.ObjectById(x8_wpId);
|
|
if (wp)
|
|
magSq = (wp->GetTranslation() - ai->GetTranslation()).magSquared();
|
|
|
|
if (magSq < 1.f || ai->CanLongJump())
|
|
{
|
|
x4_state = pas::EWallHangState::IntoWallHang;
|
|
CPASAnimParmData parms(20, CPASAnimParm::FromEnum(s32(x4_state)));
|
|
std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
|
|
const zeus::CVector3f& target = wp ? wp->GetTranslation() : ai->GetTranslation();
|
|
CAnimPlaybackParms playParms(best.second, nullptr, &target, &bc.GetOwner().GetTransform(),
|
|
&bc.GetOwner().GetModelData()->GetScale(), false);
|
|
bc.SetCurrentAnimation(playParms, false, false);
|
|
ai->SetVelocityWR(zeus::CVector3f::skZero);
|
|
ai->SetMomentumWR(zeus::CVector3f::skZero);
|
|
mgr.SendScriptMsg(ai.GetPtr(), kInvalidUniqueId, EScriptObjectMessage::OnFloor);
|
|
return true;
|
|
}
|
|
}
|
|
return false;
|
|
}
|
|
|
|
void CBSWallHang::SetLaunchVelocity(CBodyController& bc)
|
|
{
|
|
if (!x18_24_launched)
|
|
{
|
|
if (TCastToPtr<CPhysicsActor> act = bc.GetOwner())
|
|
{
|
|
act->SetVelocityWR(xc_launchVel);
|
|
act->SetConstantForce(xc_launchVel * act->GetMass());
|
|
}
|
|
x18_24_launched = true;
|
|
}
|
|
}
|
|
|
|
pas::EAnimationState CBSWallHang::UpdateBody(float dt, CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
pas::EAnimationState st = GetBodyStateTransition(dt, bc);
|
|
if (st == pas::EAnimationState::Invalid)
|
|
{
|
|
switch (x4_state)
|
|
{
|
|
case pas::EWallHangState::IntoJump:
|
|
{
|
|
CPASAnimParmData parms(20, CPASAnimParm::FromEnum(1));
|
|
std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
|
|
if (best.first > 0.f)
|
|
{
|
|
x4_state = pas::EWallHangState::JumpArc;
|
|
CAnimPlaybackParms playParms(best.second, -1, 1.f, true);
|
|
bc.SetCurrentAnimation(playParms, false, false);
|
|
}
|
|
else
|
|
{
|
|
x4_state = pas::EWallHangState::JumpAirLoop;
|
|
CPASAnimParmData parms(20, CPASAnimParm::FromEnum(s32(x4_state)));
|
|
bc.LoopBestAnimation(parms, *mgr.GetActiveRandom());
|
|
}
|
|
if (TCastToPtr<CPhysicsActor> act = bc.GetOwner())
|
|
{
|
|
mgr.SendScriptMsg(act.GetPtr(), kInvalidUniqueId, EScriptObjectMessage::Jumped);
|
|
if (TCastToPtr<CActor> wp = mgr.ObjectById(x8_wpId))
|
|
{
|
|
zeus::CVector3f toWp = wp->GetTranslation() - act->GetTranslation();
|
|
if (toWp.z > 0.f)
|
|
{
|
|
float tmp = -act->GetMomentum().z / act->GetMass();
|
|
float tmp2 = std::sqrt(tmp * 2.f * toWp.z);
|
|
tmp = 1.f / (tmp2 / tmp);
|
|
xc_launchVel = zeus::CVector3f(tmp * toWp.x, tmp * toWp.y, tmp2);
|
|
x18_24_launched = false;
|
|
}
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case pas::EWallHangState::JumpArc:
|
|
{
|
|
SetLaunchVelocity(bc);
|
|
if (bc.IsAnimationOver())
|
|
{
|
|
x4_state = pas::EWallHangState::JumpAirLoop;
|
|
CPASAnimParmData parms(20, CPASAnimParm::FromEnum(s32(x4_state)));
|
|
bc.LoopBestAnimation(parms, *mgr.GetActiveRandom());
|
|
}
|
|
else
|
|
{
|
|
CheckForWall(bc, mgr);
|
|
}
|
|
break;
|
|
}
|
|
case pas::EWallHangState::JumpAirLoop:
|
|
{
|
|
SetLaunchVelocity(bc);
|
|
if (!CheckForWall(bc, mgr))
|
|
CheckForLand(bc, mgr);
|
|
break;
|
|
}
|
|
case pas::EWallHangState::IntoWallHang:
|
|
{
|
|
if (bc.IsAnimationOver())
|
|
{
|
|
x4_state = pas::EWallHangState::WallHang;
|
|
CPASAnimParmData parms(20, CPASAnimParm::FromEnum(s32(x4_state)));
|
|
bc.LoopBestAnimation(parms, *mgr.GetActiveRandom());
|
|
}
|
|
else if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::ExitState))
|
|
{
|
|
x18_25_needsExit = true;
|
|
}
|
|
break;
|
|
}
|
|
case pas::EWallHangState::WallHang:
|
|
{
|
|
if (!bc.GetCommandMgr().GetTargetVector().isZero())
|
|
{
|
|
if (TCastToPtr<CActor> wp = mgr.ObjectById(x8_wpId))
|
|
{
|
|
if (TCastToPtr<CActor> act = bc.GetOwner())
|
|
{
|
|
zeus::CVector3f lookDir = bc.GetCommandMgr().GetTargetVector().normalized();
|
|
float actorDotWp = act->GetTransform().basis[1].dot(wp->GetTransform().basis[1]);
|
|
float lookDotWp = lookDir.dot(wp->GetTransform().basis[1]);
|
|
if (actorDotWp < -0.5f || lookDotWp > 0.5f)
|
|
bc.FaceDirection(lookDir, dt);
|
|
}
|
|
}
|
|
}
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::ExitState) || x18_25_needsExit)
|
|
{
|
|
x4_state = pas::EWallHangState::OutOfWallHang;
|
|
CPASAnimParmData parms(20, CPASAnimParm::FromEnum(s32(x4_state)));
|
|
bc.PlayBestAnimation(parms, *mgr.GetActiveRandom());
|
|
}
|
|
FixInPlace(bc);
|
|
break;
|
|
}
|
|
case pas::EWallHangState::Five:
|
|
{
|
|
if (bc.IsAnimationOver())
|
|
{
|
|
x4_state = pas::EWallHangState::WallHang;
|
|
CPASAnimParmData parms(20, CPASAnimParm::FromEnum(s32(x4_state)));
|
|
bc.LoopBestAnimation(parms, *mgr.GetActiveRandom());
|
|
}
|
|
FixInPlace(bc);
|
|
break;
|
|
}
|
|
case pas::EWallHangState::OutOfWallHang:
|
|
{
|
|
if (bc.IsAnimationOver())
|
|
{
|
|
CPASAnimParmData parms(20, CPASAnimParm::FromEnum(7));
|
|
std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
|
|
if (best.first > 0.f)
|
|
{
|
|
x4_state = pas::EWallHangState::OutOfWallHangTurn;
|
|
CAnimPlaybackParms playParms(best.second, -1, 1.f, true);
|
|
bc.SetCurrentAnimation(playParms, false, false);
|
|
}
|
|
else
|
|
{
|
|
x4_state = pas::EWallHangState::DetachJumpLoop;
|
|
CPASAnimParmData parms(20, CPASAnimParm::FromEnum(s32(x4_state)));
|
|
bc.LoopBestAnimation(parms, *mgr.GetActiveRandom());
|
|
}
|
|
if (TCastToPtr<CPhysicsActor> act = bc.GetOwner())
|
|
{
|
|
mgr.SendScriptMsg(act.GetPtr(), kInvalidUniqueId, EScriptObjectMessage::Jumped);
|
|
x18_24_launched = false;
|
|
if (TCastToPtr<CActor> wp = mgr.ObjectById(x8_wpId))
|
|
{
|
|
xc_launchVel = 15.f * wp->GetTransform().basis[1];
|
|
xc_launchVel.z = 5.f;
|
|
}
|
|
else
|
|
{
|
|
xc_launchVel = -15.f * act->GetTransform().basis[1];
|
|
}
|
|
act->SetAngularMomentum(zeus::CAxisAngle::sIdentity);
|
|
}
|
|
}
|
|
break;
|
|
}
|
|
case pas::EWallHangState::OutOfWallHangTurn:
|
|
{
|
|
SetLaunchVelocity(bc);
|
|
if (bc.IsAnimationOver())
|
|
{
|
|
x4_state = pas::EWallHangState::DetachJumpLoop;
|
|
CPASAnimParmData parms(20, CPASAnimParm::FromEnum(s32(x4_state)));
|
|
bc.LoopBestAnimation(parms, *mgr.GetActiveRandom());
|
|
}
|
|
else
|
|
{
|
|
CheckForLand(bc, mgr);
|
|
}
|
|
break;
|
|
}
|
|
case pas::EWallHangState::DetachJumpLoop:
|
|
{
|
|
SetLaunchVelocity(bc);
|
|
CheckForLand(bc, mgr);
|
|
break;
|
|
}
|
|
case pas::EWallHangState::DetachOutOfJump:
|
|
{
|
|
if (bc.IsAnimationOver())
|
|
{
|
|
x4_state = pas::EWallHangState::Invalid;
|
|
return pas::EAnimationState::Locomotion;
|
|
}
|
|
break;
|
|
}
|
|
default: break;
|
|
}
|
|
}
|
|
return st;
|
|
}
|
|
|
|
bool CBSWallHang::IsInAir(const CBodyController& bc) const
|
|
{
|
|
switch (x4_state)
|
|
{
|
|
case pas::EWallHangState::JumpArc:
|
|
case pas::EWallHangState::JumpAirLoop:
|
|
case pas::EWallHangState::OutOfWallHangTurn:
|
|
case pas::EWallHangState::DetachJumpLoop:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool CBSWallHang::ApplyAnimationDeltas() const
|
|
{
|
|
switch (x4_state)
|
|
{
|
|
case pas::EWallHangState::IntoJump:
|
|
case pas::EWallHangState::IntoWallHang:
|
|
case pas::EWallHangState::WallHang:
|
|
case pas::EWallHangState::Five:
|
|
case pas::EWallHangState::OutOfWallHang:
|
|
case pas::EWallHangState::DetachOutOfJump:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool CBSWallHang::ApplyHeadTracking() const
|
|
{
|
|
switch (x4_state)
|
|
{
|
|
case pas::EWallHangState::WallHang:
|
|
case pas::EWallHangState::Five:
|
|
return true;
|
|
default:
|
|
return false;
|
|
}
|
|
}
|
|
|
|
bool CBSWallHang::ApplyGravity() const
|
|
{
|
|
switch (x4_state)
|
|
{
|
|
case pas::EWallHangState::WallHang:
|
|
case pas::EWallHangState::IntoWallHang:
|
|
case pas::EWallHangState::OutOfWallHang:
|
|
return false;
|
|
default:
|
|
return true;
|
|
}
|
|
}
|
|
|
|
float CBSLocomotion::GetStartVelocityMagnitude(CBodyController& bc)
|
|
{
|
|
if (TCastToPtr<CPhysicsActor> act = bc.GetOwner())
|
|
{
|
|
float maxSpeed = bc.GetBodyStateInfo().GetMaxSpeed();
|
|
float ret = 0.f;
|
|
if (maxSpeed > 0.f)
|
|
ret = act->GetVelocity().magnitude() / maxSpeed;
|
|
return std::min(1.f, ret);
|
|
}
|
|
return 0.f;
|
|
}
|
|
|
|
void CBSLocomotion::ReStartBodyState(CBodyController& bc, bool b)
|
|
{
|
|
UpdateLocomotionAnimation(0.f, b ? GetStartVelocityMagnitude(bc) : 0.f, bc, true);
|
|
}
|
|
|
|
float CBSLocomotion::ComputeWeightPercentage(const std::pair<s32, float>& a,
|
|
const std::pair<s32, float>& b, float f) const
|
|
{
|
|
float range = b.second - a.second;
|
|
if (range > FLT_EPSILON)
|
|
return std::max(0.f, std::min(1.f, (f - a.second) / range));
|
|
return 0.f;
|
|
}
|
|
|
|
void CBSLocomotion::Start(CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
x4_locomotionType = bc.GetLocomotionType();
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Thirteen))
|
|
ReStartBodyState(bc, true);
|
|
else
|
|
ReStartBodyState(bc, false);
|
|
}
|
|
|
|
pas::EAnimationState CBSLocomotion::UpdateBody(float dt, CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
pas::EAnimationState st = GetBodyStateTransition(dt, bc);
|
|
if (st == pas::EAnimationState::Invalid)
|
|
UpdateLocomotionAnimation(dt, ApplyLocomotionPhysics(dt, bc), bc, false);
|
|
return st;
|
|
}
|
|
|
|
void CBSLocomotion::Shutdown(CBodyController& bc)
|
|
{
|
|
bc.MultiplyPlaybackRate(1.f);
|
|
}
|
|
|
|
float CBSLocomotion::ApplyLocomotionPhysics(float dt, CBodyController& bc)
|
|
{
|
|
if (TCastToPtr<CPhysicsActor> act = bc.GetOwner())
|
|
{
|
|
zeus::CVector3f vec =
|
|
(zeus::close_enough(bc.GetCommandMgr().GetFaceVector(), zeus::CVector3f::skZero, 0.0001f)) ?
|
|
bc.GetCommandMgr().GetMoveVector() : bc.GetCommandMgr().GetFaceVector();
|
|
if (vec.canBeNormalized())
|
|
{
|
|
if (IsPitchable())
|
|
{
|
|
zeus::CVector3f tmp = vec;
|
|
tmp.z = 0.f;
|
|
zeus::CVector3f lookVec = act->GetTransform().basis[1];
|
|
lookVec.z = 0.f;
|
|
lookVec.normalize();
|
|
bc.FaceDirection3D(tmp, lookVec, dt);
|
|
zeus::CVector3f lookVec2 = act->GetTransform().basis[1];
|
|
lookVec2.z = vec.z;
|
|
lookVec2.normalize();
|
|
if (!zeus::close_enough(lookVec, lookVec2, 0.0001f))
|
|
{
|
|
zeus::CRelAngle pitchAngle = std::min(bc.GetBodyStateInfo().GetMaximumPitch(),
|
|
zeus::CVector3f::getAngleDiff(vec, tmp));
|
|
lookVec2 = zeus::CVector3f::slerp(lookVec, lookVec2, pitchAngle);
|
|
}
|
|
bc.FaceDirection3D(lookVec2, act->GetTransform().basis[1], dt);
|
|
zeus::CVector3f lookVec3 = act->GetTransform().basis[1];
|
|
lookVec3.z = 0.f;
|
|
bc.FaceDirection3D(lookVec3, act->GetTransform().basis[1], dt);
|
|
}
|
|
else
|
|
{
|
|
bc.FaceDirection(vec.normalized(), dt);
|
|
}
|
|
}
|
|
return std::min(1.f, bc.GetCommandMgr().GetMoveVector().magnitude());
|
|
}
|
|
return 0.f;
|
|
}
|
|
|
|
pas::EAnimationState CBSLocomotion::GetBodyStateTransition(float, CBodyController& bc)
|
|
{
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Hurled))
|
|
return pas::EAnimationState::Hurled;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::KnockDown))
|
|
return pas::EAnimationState::Fall;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::LoopHitReaction))
|
|
return pas::EAnimationState::LoopReaction;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::KnockBack))
|
|
return pas::EAnimationState::KnockBack;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Locomotion))
|
|
{
|
|
bc.GetCommandMgr().ClearLocomotionCmds();
|
|
return pas::EAnimationState::Invalid;
|
|
}
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Slide))
|
|
return pas::EAnimationState::Slide;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Generate))
|
|
return pas::EAnimationState::Generate;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::MeleeAttack))
|
|
return pas::EAnimationState::MeleeAttack;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::ProjectileAttack))
|
|
return pas::EAnimationState::ProjectileAttack;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::LoopAttack))
|
|
return pas::EAnimationState::LoopAttack;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::LoopReaction))
|
|
return pas::EAnimationState::LoopReaction;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Jump))
|
|
return pas::EAnimationState::Jump;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Taunt))
|
|
return pas::EAnimationState::Taunt;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Step))
|
|
return pas::EAnimationState::Step;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Cover))
|
|
return pas::EAnimationState::Cover;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::WallHang))
|
|
return pas::EAnimationState::WallHang;
|
|
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::Scripted))
|
|
return pas::EAnimationState::Scripted;
|
|
if (bc.GetCommandMgr().GetMoveVector().isZero())
|
|
{
|
|
if (!bc.GetCommandMgr().GetFaceVector().isZero())
|
|
if (!IsMoving())
|
|
return pas::EAnimationState::Turn;
|
|
}
|
|
if (x4_locomotionType != bc.GetLocomotionType())
|
|
return pas::EAnimationState::Locomotion;
|
|
return pas::EAnimationState::Invalid;
|
|
}
|
|
|
|
CBSBiPedLocomotion::CBSBiPedLocomotion(CActor& actor)
|
|
{
|
|
const CPASDatabase& pasDatabase =
|
|
actor.GetModelData()->GetAnimationData()->GetCharacterInfo().GetPASDatabase();
|
|
for (int i=0 ; i<14 ; ++i)
|
|
{
|
|
x8_anims.emplace_back();
|
|
rstl::reserved_vector<std::pair<s32, float>, 8>& innerVec = x8_anims.back();
|
|
for (int j=0 ; j<8 ; ++j)
|
|
{
|
|
CPASAnimParmData parms(5, CPASAnimParm::FromEnum(j), CPASAnimParm::FromEnum(i));
|
|
std::pair<float, s32> best = pasDatabase.FindBestAnimation(parms, -1);
|
|
float avgVel = 0.f;
|
|
if (best.second != -1)
|
|
{
|
|
avgVel = actor.GetAverageAnimVelocity(best.second);
|
|
if (j == 0)
|
|
avgVel = 0.f;
|
|
}
|
|
innerVec.push_back({best.second, avgVel});
|
|
}
|
|
}
|
|
}
|
|
|
|
void CBSBiPedLocomotion::Start(CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
x3c8_primeTime = 0.f;
|
|
CBSLocomotion::Start(bc, mgr);
|
|
}
|
|
|
|
pas::EAnimationState CBSBiPedLocomotion::UpdateBody(float dt, CBodyController& bc, CStateManager& mgr)
|
|
{
|
|
if (x3c8_primeTime < 0.2f)
|
|
x3c8_primeTime += dt;
|
|
return CBSLocomotion::UpdateBody(dt, bc, mgr);
|
|
}
|
|
|
|
float CBSBiPedLocomotion::GetLocomotionSpeed(pas::ELocomotionType type, pas::ELocomotionAnim anim) const
|
|
{
|
|
return GetLocoAnimation(type, anim).second;
|
|
}
|
|
|
|
float CBSBiPedLocomotion::UpdateRun(float vel, CBodyController& bc, pas::ELocomotionAnim anim)
|
|
{
|
|
const std::pair<s32, float>& walk = GetLocoAnimation(x4_locomotionType, pas::ELocomotionAnim::Walk);
|
|
const std::pair<s32, float>& run = GetLocoAnimation(x4_locomotionType, pas::ELocomotionAnim::Run);
|
|
float perc = ComputeWeightPercentage(walk, run, vel);
|
|
|
|
if (perc < 0.4f)
|
|
{
|
|
float rate = walk.second > 0.f ? vel / walk.second : 1.f;
|
|
if (anim != pas::ELocomotionAnim::Walk && bc.GetCurrentAnimId() != walk.first)
|
|
{
|
|
CAnimPlaybackParms playParms(walk.first, -1, 1.f, true);
|
|
bc.SetCurrentAnimation(playParms, true, false);
|
|
x3c8_primeTime = 0.f;
|
|
}
|
|
bc.MultiplyPlaybackRate(rate);
|
|
x3c4_anim = pas::ELocomotionAnim::Walk;
|
|
return rate;
|
|
}
|
|
else
|
|
{
|
|
float rate = std::min(1.f, vel / run.second);
|
|
if (anim != pas::ELocomotionAnim::Run && bc.GetCurrentAnimId() != run.first)
|
|
{
|
|
CAnimPlaybackParms playParms(run.first, -1, 1.f, true);
|
|
bc.SetCurrentAnimation(playParms, true, false);
|
|
x3c8_primeTime = 0.f;
|
|
}
|
|
bc.MultiplyPlaybackRate(rate);
|
|
x3c4_anim = pas::ELocomotionAnim::Run;
|
|
return rate;
|
|
}
|
|
}
|
|
|
|
float CBSBiPedLocomotion::UpdateWalk(float vel, CBodyController& bc, pas::ELocomotionAnim anim)
|
|
{
|
|
if (anim != pas::ELocomotionAnim::Walk)
|
|
{
|
|
const std::pair<s32, float>& walk = GetLocoAnimation(x4_locomotionType, pas::ELocomotionAnim::Walk);
|
|
if (bc.GetCurrentAnimId() != walk.first)
|
|
{
|
|
CAnimPlaybackParms playParms(walk.first, -1, 1.f, true);
|
|
bc.SetCurrentAnimation(playParms, true, false);
|
|
x3c8_primeTime = 0.f;
|
|
}
|
|
x3c4_anim = pas::ELocomotionAnim::Walk;
|
|
}
|
|
|
|
const std::pair<s32, float>& idle = GetLocoAnimation(x4_locomotionType, pas::ELocomotionAnim::Idle);
|
|
const std::pair<s32, float>& walk = GetLocoAnimation(x4_locomotionType, pas::ELocomotionAnim::Walk);
|
|
float perc = std::max(0.5f, ComputeWeightPercentage(idle, walk, vel));
|
|
bc.MultiplyPlaybackRate(perc);
|
|
return perc;
|
|
}
|
|
|
|
static const pas::ELocomotionAnim Strafes[] =
|
|
{
|
|
pas::ELocomotionAnim::StrafeRight,
|
|
pas::ELocomotionAnim::StrafeLeft,
|
|
pas::ELocomotionAnim::Walk,
|
|
pas::ELocomotionAnim::BackUp,
|
|
pas::ELocomotionAnim::StrafeUp,
|
|
pas::ELocomotionAnim::StrafeDown
|
|
};
|
|
|
|
float CBSBiPedLocomotion::UpdateStrafe(float vel, CBodyController& bc, pas::ELocomotionAnim anim)
|
|
{
|
|
if (TCastToPtr<CPhysicsActor> act = bc.GetOwner())
|
|
{
|
|
zeus::CVector3f localVec = act->GetTransform().transposeRotate(bc.GetCommandMgr().GetMoveVector());
|
|
zeus::CVector3f localVecSq = localVec * localVec;
|
|
int maxComp = 0;
|
|
for (int i=0 ; i<3 ; ++i)
|
|
if (localVecSq[i] >= localVecSq[maxComp])
|
|
maxComp = i;
|
|
int strafeKey = maxComp * 2 + localVec[maxComp] > 0.f ? 0 : 1;
|
|
pas::ELocomotionAnim strafeType = Strafes[strafeKey];
|
|
float rate = vel * GetLocomotionSpeed(x4_locomotionType, strafeType);
|
|
if (anim != strafeType)
|
|
{
|
|
const std::pair<s32, float>& strafe =
|
|
GetLocoAnimation(x4_locomotionType, strafeType);
|
|
if (bc.GetCurrentAnimId() != strafe.first)
|
|
{
|
|
CAnimPlaybackParms playParms(strafe.first, -1, 1.f, true);
|
|
bc.SetCurrentAnimation(playParms, true, false);
|
|
x3c8_primeTime = 0.f;
|
|
}
|
|
x3c4_anim = strafeType;
|
|
}
|
|
const std::pair<s32, float>& idle = GetLocoAnimation(x4_locomotionType, pas::ELocomotionAnim::Idle);
|
|
const std::pair<s32, float>& strafe = GetLocoAnimation(x4_locomotionType, strafeType);
|
|
float perc = std::max(0.5f, ComputeWeightPercentage(idle, strafe, rate));
|
|
bc.MultiplyPlaybackRate(perc);
|
|
}
|
|
return 1.f;
|
|
}
|
|
|
|
float CBSBiPedLocomotion::UpdateLocomotionAnimation(float dt, float velMag,
|
|
CBodyController& bc, bool init)
|
|
{
|
|
float ret = 1.f;
|
|
if (init || x3c8_primeTime >= 0.2f)
|
|
{
|
|
pas::ELocomotionAnim anim = init ? pas::ELocomotionAnim::Invalid : x3c4_anim;
|
|
float maxSpeed = velMag * GetLocomotionSpeed(x4_locomotionType, pas::ELocomotionAnim::Run);
|
|
if (IsStrafing(bc) && velMag >= 0.01f)
|
|
return UpdateStrafe(velMag, bc, anim);
|
|
|
|
if (maxSpeed < 0.01f)
|
|
{
|
|
if (anim != pas::ELocomotionAnim::Idle || init)
|
|
{
|
|
if (!bc.GetBodyStateInfo().GetLocoAnimChangeAtEndOfAnimOnly() ||
|
|
bc.GetAnimTimeRemaining() <= dt || init)
|
|
{
|
|
const std::pair<s32, float>& best =
|
|
GetLocoAnimation(x4_locomotionType, pas::ELocomotionAnim::Idle);
|
|
if (bc.GetCurrentAnimId() != best.first)
|
|
{
|
|
CAnimPlaybackParms playParms(best.first, -1, 1.f, true);
|
|
bc.SetCurrentAnimation(playParms, true, false);
|
|
x3c8_primeTime = 0.f;
|
|
}
|
|
x3c4_anim = pas::ELocomotionAnim::Idle;
|
|
}
|
|
}
|
|
}
|
|
else
|
|
{
|
|
const std::pair<s32, float>& best =
|
|
GetLocoAnimation(x4_locomotionType, pas::ELocomotionAnim::Walk);
|
|
if (maxSpeed < best.second)
|
|
return UpdateWalk(maxSpeed, bc, anim);
|
|
return UpdateRun(maxSpeed, bc, anim);
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
bool CBSBiPedLocomotion::IsStrafing(const CBodyController& bc) const
|
|
{
|
|
if (!zeus::close_enough(bc.GetCommandMgr().GetMoveVector(), zeus::CVector3f::skZero, 0.0001f))
|
|
if (!zeus::close_enough(bc.GetCommandMgr().GetFaceVector(), zeus::CVector3f::skZero, 0.0001f))
|
|
return true;
|
|
return false;
|
|
}
|
|
|
|
CBSFlyerLocomotion::CBSFlyerLocomotion(CActor& actor, bool pitchable)
|
|
: CBSBiPedLocomotion(actor), x3cc_pitchable(pitchable)
|
|
{}
|
|
|
|
float CBSFlyerLocomotion::ApplyLocomotionPhysics(float dt, CBodyController& bc)
|
|
{
|
|
float ret = CBSLocomotion::ApplyLocomotionPhysics(dt, bc);
|
|
if (TCastToPtr<CPhysicsActor> act = bc.GetOwner())
|
|
{
|
|
if (std::fabs(bc.GetCommandMgr().GetMoveVector().z) > 0.01f &&
|
|
(!x3cc_pitchable || bc.GetBodyStateInfo().GetMaximumPitch() < 0.17453292f))
|
|
{
|
|
zeus::CVector3f dir;
|
|
dir.z = dt * bc.GetBodyStateInfo().GetMaxSpeed() * bc.GetCommandMgr().GetMoveVector().z;
|
|
act->ApplyImpulseWR(act->GetMoveToORImpulseWR(dir, dt), zeus::CAxisAngle::sIdentity);
|
|
}
|
|
}
|
|
return ret;
|
|
}
|
|
|
|
CBSWallWalkerLocomotion::CBSWallWalkerLocomotion(CActor& actor)
|
|
: CBSBiPedLocomotion(actor)
|
|
{}
|
|
|
|
float CBSWallWalkerLocomotion::ApplyLocomotionPhysics(float dt, CBodyController& bc)
|
|
{
|
|
if (TCastToPtr<CPhysicsActor> act = bc.GetOwner())
|
|
{
|
|
float maxSpeed = bc.GetBodyStateInfo().GetMaxSpeed();
|
|
zeus::CVector3f x40 = bc.GetCommandMgr().GetMoveVector() * maxSpeed;
|
|
if ((zeus::CVector3f::getAngleDiff(bc.GetCommandMgr().GetFaceVector(), x40) < (M_PIF / 2.f) ?
|
|
x40 : bc.GetCommandMgr().GetFaceVector()).canBeNormalized())
|
|
bc.FaceDirection3D(x40.normalized(), act->GetTransform().basis[1], dt);
|
|
zeus::CVector3f impulse =
|
|
act->GetMoveToORImpulseWR(act->GetTransform().transposeRotate(x40 * dt), dt);
|
|
impulse = act->GetMass() > FLT_EPSILON ? impulse / act->GetMass() :
|
|
zeus::CVector3f(0.f, act->GetVelocity().magnitude(), 0.f);
|
|
if (maxSpeed > FLT_EPSILON)
|
|
return std::min(1.f, impulse.magnitude() / maxSpeed);
|
|
}
|
|
return 0.f;
|
|
}
|
|
|
|
CBSNewFlyerLocomotion::CBSNewFlyerLocomotion(CActor& actor)
|
|
: CBSBiPedLocomotion(actor)
|
|
{}
|
|
|
|
float CBSNewFlyerLocomotion::ApplyLocomotionPhysics(float dt, CBodyController& bc)
|
|
{
|
|
if (TCastToPtr<CPhysicsActor>(bc.GetOwner()))
|
|
bc.FaceDirection(bc.GetCommandMgr().GetFaceVector(), dt);
|
|
return 0.f;
|
|
}
|
|
|
|
static const pas::ELocomotionAnim RunStrafes[] =
|
|
{
|
|
pas::ELocomotionAnim::StrafeRight,
|
|
pas::ELocomotionAnim::StrafeLeft,
|
|
pas::ELocomotionAnim::Run,
|
|
pas::ELocomotionAnim::BackUp,
|
|
pas::ELocomotionAnim::StrafeUp,
|
|
pas::ELocomotionAnim::StrafeDown
|
|
};
|
|
|
|
float CBSNewFlyerLocomotion::UpdateLocomotionAnimation(float dt, float velMag,
|
|
CBodyController& bc, bool init)
|
|
{
|
|
if (TCastToPtr<CPhysicsActor> act = bc.GetOwner())
|
|
{
|
|
pas::ELocomotionAnim strafeType = pas::ELocomotionAnim::Idle;
|
|
if (bc.GetCommandMgr().GetMoveVector().canBeNormalized())
|
|
{
|
|
zeus::CVector3f localVec = act->GetTransform().transposeRotate(bc.GetCommandMgr().GetMoveVector());
|
|
zeus::CVector3f localVecSq = localVec * localVec;
|
|
int maxComp = 0;
|
|
for (int i=0 ; i<3 ; ++i)
|
|
if (localVecSq[i] >= localVecSq[maxComp])
|
|
maxComp = i;
|
|
int strafeKey = maxComp * 2 + localVec[maxComp] > 0.f ? 0 : 1;
|
|
strafeType = RunStrafes[strafeKey];
|
|
}
|
|
|
|
if (init || strafeType != x3c4_anim)
|
|
{
|
|
const std::pair<s32, float>& strafe = GetLocoAnimation(x4_locomotionType, strafeType);
|
|
if (init || bc.GetCurrentAnimId() != strafe.first)
|
|
{
|
|
CAnimPlaybackParms playParms(strafe.first, -1, 1.f, true);
|
|
bc.SetCurrentAnimation(playParms, true, false);
|
|
}
|
|
x3c4_anim = strafeType;
|
|
}
|
|
}
|
|
return 1.f;
|
|
}
|
|
|
|
CBSRestrictedLocomotion::CBSRestrictedLocomotion(CActor& actor)
|
|
{
|
|
const CPASDatabase& pasDatabase =
|
|
actor.GetModelData()->GetAnimationData()->GetCharacterInfo().GetPASDatabase();
|
|
for (int i=0 ; i<14 ; ++i)
|
|
{
|
|
CPASAnimParmData parms(5, CPASAnimParm::FromEnum(0), CPASAnimParm::FromEnum(i));
|
|
std::pair<float, s32> best = pasDatabase.FindBestAnimation(parms, -1);
|
|
x8_anims.push_back(best.second);
|
|
}
|
|
}
|
|
|
|
float CBSRestrictedLocomotion::UpdateLocomotionAnimation(float dt, float velMag,
|
|
CBodyController& bc, bool init)
|
|
{
|
|
pas::ELocomotionAnim anim = init ? pas::ELocomotionAnim::Invalid : x44_anim;
|
|
if (anim != pas::ELocomotionAnim::Idle)
|
|
{
|
|
s32 newAnim = x8_anims[int(x4_locomotionType)];
|
|
if (newAnim != bc.GetCurrentAnimId())
|
|
{
|
|
CAnimPlaybackParms playParms(newAnim, -1, 1.f, true);
|
|
bc.SetCurrentAnimation(playParms, true, false);
|
|
}
|
|
x44_anim = pas::ELocomotionAnim::Idle;
|
|
}
|
|
return 1.f;
|
|
}
|
|
|
|
CBSRestrictedFlyerLocomotion::CBSRestrictedFlyerLocomotion(CActor& actor)
|
|
: CBSRestrictedLocomotion(actor)
|
|
{}
|
|
|
|
float CBSRestrictedFlyerLocomotion::ApplyLocomotionPhysics(float dt, CBodyController& bc)
|
|
{
|
|
if (TCastToPtr<CPhysicsActor> act = bc.GetOwner())
|
|
{
|
|
bc.FaceDirection(bc.GetCommandMgr().GetFaceVector(), dt);
|
|
act->ApplyImpulseWR(bc.GetCommandMgr().GetMoveVector() *
|
|
bc.GetRestrictedFlyerMoveSpeed() * act->GetMass(),
|
|
zeus::CAxisAngle::sIdentity);
|
|
}
|
|
return 0.f;
|
|
}
|
|
|
|
}
|