AxioDL
/
metaforce
mirror of https://github.com/AxioDL/metaforce.git
2
0
Fork 0
Code Issues Projects Releases Wiki Activity

Use pas::EAnimationState in CPAS*

This commit is contained in:
Luke Street 2020-04-22 05:08:02 -04:00
parent 535717fbd8
commit 14c92e85ce
26 changed files with 337 additions and 310 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

8
Runtime/Character/CAdditiveBodyState.cpp
View File

@ -11,11 +11,11 @@ namespace urde {
void CABSAim::Start(CBodyController& bc, CStateManager& mgr) {
// const CBCAdditiveAimCmd* cmd =
// static_cast<const CBCAdditiveAimCmd*>(bc.GetCommandMgr().GetCmd(EBodyStateCmd::AdditiveAim));
const CPASAnimState* aimState = bc.GetPASDatabase().GetAnimState(22);
const CPASAnimState* aimState = bc.GetPASDatabase().GetAnimState(pas::EAnimationState::AdditiveAim);
// Left, Right, Up, Down
for (size_t i = 0; i < x8_anims.size(); ++i) {
const CPASAnimParmData parms(22, CPASAnimParm::FromEnum(s32(i)));
const CPASAnimParmData parms(pas::EAnimationState::AdditiveAim, CPASAnimParm::FromEnum(s32(i)));
const std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
x8_anims[i] = best.second;
x18_angles[i] = zeus::degToRad(aimState->GetAnimParmData(x8_anims[i], 1).GetReal32Value());
@ -99,7 +99,7 @@ void CABSFlinch::Start(CBodyController& bc, CStateManager& mgr) {
static_cast<const CBCAdditiveFlinchCmd*>(bc.GetCommandMgr().GetCmd(EBodyStateCmd::AdditiveFlinch));
x4_weight = cmd->GetWeight();
CPASAnimParmData parms(23);
CPASAnimParmData parms(pas::EAnimationState::AdditiveFlinch);
std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
x8_anim = best.second;
@ -145,7 +145,7 @@ void CABSReaction::Start(CBodyController& bc, CStateManager& mgr) {
xc_type = cmd->GetType();
x10_active = cmd->GetIsActive();
CPASAnimParmData parms(24, CPASAnimParm::FromEnum(s32(xc_type)));
CPASAnimParmData parms(pas::EAnimationState::AdditiveReaction, CPASAnimParm::FromEnum(s32(xc_type)));
std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
x8_anim = best.second;

5
Runtime/Character/CBodyController.cpp
View File

@ -80,7 +80,7 @@ void CBodyController::Update(float dt, CStateManager& mgr) {
}
}
bool CBodyController::HasBodyState(pas::EAnimationState state) const { return GetPASDatabase().HasState(s32(state)); }
bool CBodyController::HasBodyState(pas::EAnimationState state) const { return GetPASDatabase().HasState(state); }
void CBodyController::SetCurrentAnimation(const CAnimPlaybackParms& parms, bool loop, bool noTrans) {
x0_actor.GetModelData()->GetAnimationData()->SetAnimation(parms, noTrans);
@ -269,7 +269,8 @@ void CBodyController::UpdateFrozenInfo(float dt, CStateManager& mgr) {
}
bool CBodyController::HasIceBreakoutState() const {
CPASAnimParmData parms(24, CPASAnimParm::FromEnum(3));
CPASAnimParmData parms(pas::EAnimationState::AdditiveReaction,
CPASAnimParm::FromEnum(static_cast<s32>(pas::EAdditiveReactionType::IceBreakout)));
std::pair<float, s32> best = GetPASDatabase().FindBestAnimation(parms, -1);
return best.first > 0.f;
}

168
Runtime/Character/CBodyState.cpp
View File

@ -13,7 +13,7 @@ namespace urde {
void CBSAttack::Start(CBodyController& bc, CStateManager& mgr) {
const auto* cmd = static_cast<const CBCMeleeAttackCmd*>(bc.GetCommandMgr().GetCmd(EBodyStateCmd::MeleeAttack));
const CPASDatabase& pasDatabase = bc.GetPASDatabase();
const CPASAnimParmData parms(7, CPASAnimParm::FromEnum(s32(cmd->GetAttackSeverity())),
const CPASAnimParmData parms(pas::EAnimationState::MeleeAttack, CPASAnimParm::FromEnum(s32(cmd->GetAttackSeverity())),
CPASAnimParm::FromEnum(s32(bc.GetLocomotionType())));
const std::pair<float, s32> best = pasDatabase.FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
const CAnimPlaybackParms playParms(best.second, -1, 1.f, true);
@ -121,13 +121,14 @@ void CBSProjectileAttack::Start(CBodyController& bc, CStateManager& mgr) {
zeus::CRelAngle angle = std::atan2(localDelta.y(), localDelta.x());
angle.makeRel();
const float attackAngle = angle.asDegrees();
const CPASAnimParmData parms(18, CPASAnimParm::FromEnum(s32(cmd->GetAttackSeverity())),
CPASAnimParm::FromReal32(angle.asDegrees()),
CPASAnimParm::FromEnum(s32(bc.GetLocomotionType())));
const CPASAnimParmData parms(
pas::EAnimationState::ProjectileAttack, CPASAnimParm::FromEnum(s32(cmd->GetAttackSeverity())),
CPASAnimParm::FromReal32(angle.asDegrees()), CPASAnimParm::FromEnum(s32(bc.GetLocomotionType())));
const std::pair<float, s32> best1 = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
if (cmd->BlendTwoClosest()) {
const std::pair<float, s32> best2 = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), best1.second);
const CPASAnimState* projAttackState = bc.GetPASDatabase().GetAnimState(18);
const std::pair<float, s32> best2 =
bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), best1.second);
const CPASAnimState* projAttackState = bc.GetPASDatabase().GetAnimState(pas::EAnimationState::ProjectileAttack);
float angle1 = projAttackState->GetAnimParmData(best1.second, 1).GetReal32Value();
float angle2 = projAttackState->GetAnimParmData(best2.second, 1).GetReal32Value();
if (angle1 - angle2 > 180.f) {
@ -178,7 +179,7 @@ pas::EAnimationState CBSProjectileAttack::UpdateBody(float dt, CBodyController&
void CBSDie::Start(CBodyController& bc, CStateManager& mgr) {
bool shouldReset = true;
if (bc.ShouldPlayDeathAnims()) {
const CPASAnimParmData parms(4, CPASAnimParm::FromEnum(s32(bc.GetFallState())));
const CPASAnimParmData parms(pas::EAnimationState::Death, CPASAnimParm::FromEnum(s32(bc.GetFallState())));
const std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
if (best.first > 0.f) {
const CAnimPlaybackParms playParms(best.second, -1, 1.f, true);
@ -210,12 +211,12 @@ void CBSFall::Start(CBodyController& bc, CStateManager& mgr) {
zeus::CVector3f localDir = bc.GetOwner().GetTransform().transposeRotate(cmd->GetHitDirection());
zeus::CRelAngle angle = std::atan2(localDir.y(), localDir.z());
angle.makeRel();
const CPASAnimParmData parms(0, CPASAnimParm::FromReal32(angle.asDegrees()),
const CPASAnimParmData parms(pas::EAnimationState::Fall, CPASAnimParm::FromReal32(angle.asDegrees()),
CPASAnimParm::FromEnum(s32(cmd->GetHitSeverity())));
const std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
const CAnimPlaybackParms playParms(best.second, -1, 1.f, true);
bc.SetCurrentAnimation(playParms, false, false);
const CPASAnimState* knockdownState = bc.GetPASDatabase().GetAnimState(0);
const CPASAnimState* knockdownState = bc.GetPASDatabase().GetAnimState(pas::EAnimationState::Fall);
if (!knockdownState->GetAnimParmData(best.second, 2).GetBoolValue()) {
const float animAngle = zeus::degToRad(knockdownState->GetAnimParmData(best.second, 0).GetReal32Value());
zeus::CRelAngle delta1 = angle - animAngle;
@ -255,7 +256,7 @@ void CBSFall::Shutdown(CBodyController& bc) { bc.SetFallState(xc_fallState); }
void CBSGetup::Start(CBodyController& bc, CStateManager& mgr) {
const auto* cmd = static_cast<const CBCGetupCmd*>(bc.GetCommandMgr().GetCmd(EBodyStateCmd::Getup));
const CPASAnimParmData parms(1, CPASAnimParm::FromEnum(s32(bc.GetFallState())),
const CPASAnimParmData parms(pas::EAnimationState::Getup, CPASAnimParm::FromEnum(s32(bc.GetFallState())),
CPASAnimParm::FromEnum(s32(cmd->GetGetupType())));
const std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
if (best.first > FLT_EPSILON) {
@ -263,7 +264,8 @@ void CBSGetup::Start(CBodyController& bc, CStateManager& mgr) {
const 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());
x4_fallState = pas::EFallState(
bc.GetPASDatabase().GetAnimState(pas::EAnimationState::Getup)->GetAnimParmData(best.second, 2).GetEnumValue());
} else {
x4_fallState = pas::EFallState::Zero;
}
@ -296,12 +298,12 @@ void CBSKnockBack::Start(CBodyController& bc, CStateManager& mgr) {
const zeus::CVector3f localDir = bc.GetOwner().GetTransform().transposeRotate(cmd->GetHitDirection());
zeus::CRelAngle angle = std::atan2(localDir.y(), localDir.x());
angle.makeRel();
const CPASAnimParmData parms(6, CPASAnimParm::FromReal32(angle.asDegrees()),
const CPASAnimParmData parms(pas::EAnimationState::KnockBack, CPASAnimParm::FromReal32(angle.asDegrees()),
CPASAnimParm::FromEnum(s32(cmd->GetHitSeverity())));
const std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
const CAnimPlaybackParms playParms(best.second, -1, 1.f, true);
bc.SetCurrentAnimation(playParms, false, false);
const CPASAnimState* knockbackState = bc.GetPASDatabase().GetAnimState(6);
const CPASAnimState* knockbackState = bc.GetPASDatabase().GetAnimState(pas::EAnimationState::KnockBack);
if (!knockbackState->GetAnimParmData(best.second, 2).GetBoolValue()) {
const float animAngle = zeus::degToRad(knockbackState->GetAnimParmData(best.second, 0).GetReal32Value());
zeus::CRelAngle delta1 = angle - animAngle;
@ -353,11 +355,12 @@ pas::EAnimationState CBSKnockBack::UpdateBody(float dt, CBodyController& bc, CSt
}
CBSLieOnGround::CBSLieOnGround(CActor& actor) {
x4_24_hasGroundHit = actor.GetModelData()->GetAnimationData()->GetCharacterInfo().GetPASDatabase().HasState(11);
x4_24_hasGroundHit = actor.GetModelData()->GetAnimationData()->GetCharacterInfo().GetPASDatabase().HasState(
pas::EAnimationState::GroundHit);
}
void CBSLieOnGround::Start(CBodyController& bc, CStateManager& mgr) {
const CPASAnimParmData parms(2, CPASAnimParm::FromEnum(s32(bc.GetFallState())));
const CPASAnimParmData parms(pas::EAnimationState::LieOnGround, CPASAnimParm::FromEnum(s32(bc.GetFallState())));
const std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
if (best.first > 0.f) {
const CAnimPlaybackParms playParms(best.second, -1, 1.f, true);
@ -388,7 +391,7 @@ void CBSLieOnGround::Shutdown(CBodyController& bc) { bc.EnableAnimation(true); }
void CBSStep::Start(CBodyController& bc, CStateManager& mgr) {
const auto* cmd = static_cast<const CBCStepCmd*>(bc.GetCommandMgr().GetCmd(EBodyStateCmd::Step));
const CPASAnimParmData parms(3, CPASAnimParm::FromEnum(s32(cmd->GetStepDirection())),
const CPASAnimParmData parms(pas::EAnimationState::Step, CPASAnimParm::FromEnum(s32(cmd->GetStepDirection())),
CPASAnimParm::FromEnum(s32(cmd->GetStepType())));
bc.PlayBestAnimation(parms, *mgr.GetActiveRandom());
}
@ -450,12 +453,14 @@ void CBSTurn::Start(CBodyController& bc, CStateManager& mgr) {
x8_dest = zeus::CVector2f(bc.GetCommandMgr().GetFaceVector().toVec2f());
const 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);
const CPASAnimParmData parms(8, CPASAnimParm::FromEnum(s32(x10_turnDir)), CPASAnimParm::FromReal32(deltaAngle),
const CPASAnimParmData parms(pas::EAnimationState::Turn, CPASAnimParm::FromEnum(s32(x10_turnDir)),
CPASAnimParm::FromReal32(deltaAngle),
CPASAnimParm::FromEnum(s32(bc.GetLocomotionType())));
const std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
const CAnimPlaybackParms playParms(best.second, -1, 1.f, true);
bc.SetCurrentAnimation(playParms, false, false);
const float animAngle = bc.GetPASDatabase().GetAnimState(8)->GetAnimParmData(best.second, 1).GetReal32Value();
const float animAngle =
bc.GetPASDatabase().GetAnimState(pas::EAnimationState::Turn)->GetAnimParmData(best.second, 1).GetReal32Value();
x4_rotateSpeed =
zeus::degToRad((x10_turnDir == pas::ETurnDirection::Left) ? animAngle - deltaAngle : deltaAngle - animAngle);
const float timeRem = bc.GetAnimTimeRemaining();
@ -539,14 +544,15 @@ pas::EAnimationState CBSTurn::UpdateBody(float dt, CBodyController& bc, CStateMa
}
void CBSFlyerTurn::Start(CBodyController& bc, CStateManager& mgr) {
if (bc.GetPASDatabase().GetAnimState(8)->HasAnims()) {
if (bc.GetPASDatabase().GetAnimState(pas::EAnimationState::Turn)->HasAnims()) {
CBSTurn::Start(bc, mgr);
} else {
x8_dest = zeus::CVector2f(bc.GetCommandMgr().GetFaceVector().toVec2f());
const zeus::CVector3f& lookDir = bc.GetOwner().GetTransform().basis[1];
const zeus::CVector2f lookDir2d(lookDir.toVec2f());
x10_turnDir = pas::ETurnDirection(zeus::CVector2f(lookDir2d.y(), -lookDir2d.x()).dot(x8_dest) > 0.f);
const CPASAnimParmData parms(5, CPASAnimParm::FromEnum(0), CPASAnimParm::FromEnum(s32(bc.GetLocomotionType())));
const CPASAnimParmData parms(pas::EAnimationState::Locomotion, CPASAnimParm::FromEnum(0),
CPASAnimParm::FromEnum(s32(bc.GetLocomotionType())));
const std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
if (best.second != bc.GetCurrentAnimId()) {
const CAnimPlaybackParms playParms(best.second, -1, 1.f, true);
@ -556,7 +562,7 @@ void CBSFlyerTurn::Start(CBodyController& bc, CStateManager& mgr) {
}
pas::EAnimationState CBSFlyerTurn::UpdateBody(float dt, CBodyController& bc, CStateManager& mgr) {
if (bc.GetPASDatabase().GetAnimState(8)->HasAnims()) {
if (bc.GetPASDatabase().GetAnimState(pas::EAnimationState::Turn)->HasAnims()) {
return CBSTurn::UpdateBody(dt, bc, mgr);
}
@ -580,12 +586,12 @@ void CBSLoopAttack::Start(CBodyController& bc, CStateManager& mgr) {
xc_25_advance = false;
if (bc.GetLocomotionType() == pas::ELocomotionType::Crouch) {
const CPASAnimParmData parms(9, CPASAnimParm::FromEnum(s32(x4_state)),
const CPASAnimParmData parms(pas::EAnimationState::LoopAttack, CPASAnimParm::FromEnum(s32(x4_state)),
CPASAnimParm::FromEnum(s32(x8_loopAttackType)));
bc.LoopBestAnimation(parms, *mgr.GetActiveRandom());
} else {
x4_state = pas::ELoopState::Begin;
const CPASAnimParmData parms(9, CPASAnimParm::FromEnum(s32(x4_state)),
const CPASAnimParmData parms(pas::EAnimationState::LoopAttack, CPASAnimParm::FromEnum(s32(x4_state)),
CPASAnimParm::FromEnum(s32(x8_loopAttackType)));
const std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
if (best.first > FLT_EPSILON) {
@ -593,7 +599,7 @@ void CBSLoopAttack::Start(CBodyController& bc, CStateManager& mgr) {
bc.SetCurrentAnimation(playParms, false, false);
} else {
x4_state = pas::ELoopState::Loop;
const CPASAnimParmData loopParms(9, CPASAnimParm::FromEnum(s32(x4_state)),
const CPASAnimParmData loopParms(pas::EAnimationState::LoopAttack, CPASAnimParm::FromEnum(s32(x4_state)),
CPASAnimParm::FromEnum(s32(x8_loopAttackType)));
bc.LoopBestAnimation(loopParms, *mgr.GetActiveRandom());
}
@ -652,7 +658,8 @@ pas::EAnimationState CBSLoopAttack::UpdateBody(float dt, CBodyController& bc, CS
return pas::EAnimationState::Locomotion;
}
if (bc.IsAnimationOver()) {
const CPASAnimParmData parms(9, CPASAnimParm::FromEnum(1), CPASAnimParm::FromEnum(s32(x8_loopAttackType)));
const CPASAnimParmData parms(pas::EAnimationState::LoopAttack, CPASAnimParm::FromEnum(1),
CPASAnimParm::FromEnum(s32(x8_loopAttackType)));
bc.LoopBestAnimation(parms, *mgr.GetActiveRandom());
x4_state = pas::ELoopState::Loop;
} else if (!bc.GetCommandMgr().GetTargetVector().isZero()) {
@ -662,7 +669,8 @@ pas::EAnimationState CBSLoopAttack::UpdateBody(float dt, CBodyController& bc, CS
case pas::ELoopState::Loop:
if (xc_25_advance && (!xc_24_waitForAnimOver || bc.IsAnimationOver())) {
if (bc.GetLocomotionType() != pas::ELocomotionType::Crouch) {
const CPASAnimParmData parms(9, CPASAnimParm::FromEnum(2), CPASAnimParm::FromEnum(s32(x8_loopAttackType)));
const CPASAnimParmData parms(pas::EAnimationState::LoopAttack, CPASAnimParm::FromEnum(2),
CPASAnimParm::FromEnum(s32(x8_loopAttackType)));
bc.PlayBestAnimation(parms, *mgr.GetActiveRandom());
x4_state = pas::ELoopState::End;
} else {
@ -697,14 +705,15 @@ void CBSLoopReaction::Start(CBodyController& bc, CStateManager& mgr) {
}
x4_state = pas::ELoopState::Begin;
const CPASAnimParmData parms(10, CPASAnimParm::FromEnum(s32(x8_reactionType)), CPASAnimParm::FromEnum(s32(x4_state)));
const CPASAnimParmData parms(pas::EAnimationState::LoopReaction, CPASAnimParm::FromEnum(s32(x8_reactionType)),
CPASAnimParm::FromEnum(s32(x4_state)));
const std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
if (best.first > FLT_EPSILON) {
const CAnimPlaybackParms playParms(best.second, -1, 1.f, true);
bc.SetCurrentAnimation(playParms, false, false);
} else {
x4_state = pas::ELoopState::Loop;
const CPASAnimParmData loopParms(10, CPASAnimParm::FromEnum(s32(x8_reactionType)),
const CPASAnimParmData loopParms(pas::EAnimationState::LoopReaction, CPASAnimParm::FromEnum(s32(x8_reactionType)),
CPASAnimParm::FromEnum(s32(x4_state)));
bc.LoopBestAnimation(loopParms, *mgr.GetActiveRandom());
}
@ -748,7 +757,8 @@ pas::EAnimationState CBSLoopReaction::GetBodyStateTransition(float dt, const CBo
}
bool CBSLoopReaction::PlayExitAnimation(CBodyController& bc, CStateManager& mgr) const {
const CPASAnimParmData parms(10, CPASAnimParm::FromEnum(int(x8_reactionType)), CPASAnimParm::FromEnum(2));
const CPASAnimParmData parms(pas::EAnimationState::LoopReaction, CPASAnimParm::FromEnum(int(x8_reactionType)),
CPASAnimParm::FromEnum(2));
const std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
if (best.first > 0.f) {
const CAnimPlaybackParms playParms(best.second, -1, 1.f, true);
@ -772,7 +782,8 @@ pas::EAnimationState CBSLoopReaction::UpdateBody(float dt, CBodyController& bc,
}
} else {
if (bc.IsAnimationOver()) {
const CPASAnimParmData parms(10, CPASAnimParm::FromEnum(s32(x8_reactionType)), CPASAnimParm::FromEnum(1));
const CPASAnimParmData parms(pas::EAnimationState::LoopReaction, CPASAnimParm::FromEnum(s32(x8_reactionType)),
CPASAnimParm::FromEnum(1));
bc.LoopBestAnimation(parms, *mgr.GetActiveRandom());
x4_state = pas::ELoopState::Loop;
} else if (!bc.GetCommandMgr().GetTargetVector().isZero()) {
@ -810,12 +821,12 @@ void CBSGroundHit::Start(CBodyController& bc, CStateManager& mgr) {
const zeus::CVector3f localDir = bc.GetOwner().GetTransform().transposeRotate(cmd->GetHitDirection());
zeus::CRelAngle angle = std::atan2(localDir.y(), localDir.x());
angle.makeRel();
const CPASAnimParmData parms(11, CPASAnimParm::FromEnum(s32(bc.GetFallState())),
const CPASAnimParmData parms(pas::EAnimationState::GroundHit, CPASAnimParm::FromEnum(s32(bc.GetFallState())),
CPASAnimParm::FromReal32(angle.asDegrees()));
const std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
const CAnimPlaybackParms playParms(best.second, -1, 1.f, true);
bc.SetCurrentAnimation(playParms, false, false);
const CPASAnimState* groundHitState = bc.GetPASDatabase().GetAnimState(11);
const CPASAnimState* groundHitState = bc.GetPASDatabase().GetAnimState(pas::EAnimationState::GroundHit);
if (!groundHitState->GetAnimParmData(best.second, 2).GetBoolValue()) {
const float animAngle = zeus::degToRad(groundHitState->GetAnimParmData(best.second, 1).GetReal32Value());
zeus::CRelAngle delta1 = angle - animAngle;
@ -860,7 +871,7 @@ void CBSGenerate::Start(CBodyController& bc, CStateManager& mgr) {
const auto* cmd = static_cast<const CBCGenerateCmd*>(bc.GetCommandMgr().GetCmd(EBodyStateCmd::Generate));
s32 anim;
if (!cmd->UseSpecialAnimId()) {
const CPASAnimParmData parms(12, CPASAnimParm::FromEnum(s32(cmd->GetGenerateType())));
const CPASAnimParmData parms(pas::EAnimationState::Generate, CPASAnimParm::FromEnum(s32(cmd->GetGenerateType())));
const std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
anim = best.second;
} else {
@ -918,7 +929,8 @@ void CBSJump::Start(CBodyController& bc, CStateManager& mgr) {
}
if (!cmd->StartInJumpLoop()) {
x4_state = pas::EJumpState::IntoJump;
const CPASAnimParmData parms(13, CPASAnimParm::FromEnum(s32(x4_state)), CPASAnimParm::FromEnum(s32(x8_jumpType)));
const CPASAnimParmData parms(pas::EAnimationState::Jump, CPASAnimParm::FromEnum(s32(x4_state)),
CPASAnimParm::FromEnum(s32(x8_jumpType)));
bc.PlayBestAnimation(parms, *mgr.GetActiveRandom());
} else {
PlayJumpLoop(mgr, bc);
@ -949,7 +961,8 @@ bool CBSJump::CheckForWallJump(CBodyController& bc, CStateManager& mgr) {
const float xExtent = (aabb.max.x() - aabb.min.x()) * 0.5f;
if (distToWall < 1.414f * xExtent || (act->MadeSolidCollision() && distToWall < 3.f * xExtent)) {
x4_state = x30_26_wallBounceRight ? pas::EJumpState::WallBounceRight : pas::EJumpState::WallBounceLeft;
const CPASAnimParmData parms(13, CPASAnimParm::FromEnum(s32(x4_state)), CPASAnimParm::FromEnum(s32(x8_jumpType)));
const CPASAnimParmData parms(pas::EAnimationState::Jump, CPASAnimParm::FromEnum(s32(x4_state)),
CPASAnimParm::FromEnum(s32(x8_jumpType)));
bc.PlayBestAnimation(parms, *mgr.GetActiveRandom());
mgr.SendScriptMsg(act.GetPtr(), kInvalidUniqueId, EScriptObjectMessage::OnFloor);
return true;
@ -963,7 +976,8 @@ void CBSJump::CheckForLand(CBodyController& bc, CStateManager& mgr) {
if (const TCastToPtr<CPatterned> act = bc.GetOwner()) {
if (act->MadeSolidCollision() || act->IsOnGround()) {
x4_state = pas::EJumpState::OutOfJump;
const CPASAnimParmData parms(13, CPASAnimParm::FromEnum(s32(x4_state)), CPASAnimParm::FromEnum(s32(x8_jumpType)));
const CPASAnimParmData parms(pas::EAnimationState::Jump, CPASAnimParm::FromEnum(s32(x4_state)),
CPASAnimParm::FromEnum(s32(x8_jumpType)));
bc.PlayBestAnimation(parms, *mgr.GetActiveRandom());
mgr.SendScriptMsg(act.GetPtr(), kInvalidUniqueId, EScriptObjectMessage::OnFloor);
}
@ -971,7 +985,8 @@ void CBSJump::CheckForLand(CBodyController& bc, CStateManager& mgr) {
}
void CBSJump::PlayJumpLoop(CStateManager& mgr, CBodyController& bc) {
const CPASAnimParmData parms(13, CPASAnimParm::FromEnum(1), CPASAnimParm::FromEnum(s32(x8_jumpType)));
const CPASAnimParmData parms(pas::EAnimationState::Jump, CPASAnimParm::FromEnum(1),
CPASAnimParm::FromEnum(s32(x8_jumpType)));
const std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
if (best.first > 99.f) {
x4_state = pas::EJumpState::AmbushJump;
@ -979,7 +994,7 @@ void CBSJump::PlayJumpLoop(CStateManager& mgr, CBodyController& bc) {
bc.SetCurrentAnimation(playParms, false, false);
} else {
x4_state = pas::EJumpState::Loop;
const CPASAnimParmData loopParms(13, CPASAnimParm::FromEnum(s32(x4_state)),
const CPASAnimParmData loopParms(pas::EAnimationState::Jump, CPASAnimParm::FromEnum(s32(x4_state)),
CPASAnimParm::FromEnum(s32(x8_jumpType)));
bc.LoopBestAnimation(loopParms, *mgr.GetActiveRandom());
}
@ -1013,7 +1028,7 @@ pas::EAnimationState CBSJump::UpdateBody(float dt, CBodyController& bc, CStateMa
}
if (bc.IsAnimationOver()) {
x4_state = pas::EJumpState::Loop;
const CPASAnimParmData parms(13, CPASAnimParm::FromEnum(s32(x4_state)),
const CPASAnimParmData parms(pas::EAnimationState::Jump, CPASAnimParm::FromEnum(s32(x4_state)),
CPASAnimParm::FromEnum(s32(x8_jumpType)));
bc.LoopBestAnimation(parms, *mgr.GetActiveRandom());
} else {
@ -1045,7 +1060,7 @@ pas::EAnimationState CBSJump::UpdateBody(float dt, CBodyController& bc, CStateMa
if (bc.IsAnimationOver()) {
mgr.SendScriptMsg(&bc.GetOwner(), kInvalidUniqueId, EScriptObjectMessage::Falling);
x4_state = pas::EJumpState::Loop;
const CPASAnimParmData parms(13, CPASAnimParm::FromEnum(s32(x4_state)),
const CPASAnimParmData parms(pas::EAnimationState::Jump, CPASAnimParm::FromEnum(s32(x4_state)),
CPASAnimParm::FromEnum(s32(x8_jumpType)));
bc.LoopBestAnimation(parms, *mgr.GetActiveRandom());
x30_27_wallBounceComplete = true;
@ -1070,10 +1085,7 @@ pas::EAnimationState CBSJump::UpdateBody(float dt, CBodyController& bc, CStateMa
}
bool CBSJump::ApplyAnimationDeltas() const {
if (x4_state == pas::EJumpState::AmbushJump || x4_state == pas::EJumpState::Loop) {
return false;
}
return true;
return !(x4_state == pas::EJumpState::AmbushJump || x4_state == pas::EJumpState::Loop);
}
bool CBSJump::IsInAir(const CBodyController& bc) const {
@ -1089,12 +1101,12 @@ void CBSHurled::Start(CBodyController& bc, CStateManager& mgr) {
zeus::CRelAngle angle = std::atan2(localDir.y(), localDir.x());
angle.makeRel();
x8_knockAngle = angle.asDegrees();
const CPASAnimParmData parms(14, CPASAnimParm::FromInt32(-1), CPASAnimParm::FromReal32(x8_knockAngle),
CPASAnimParm::FromEnum(s32(x4_state)));
const CPASAnimParmData parms(pas::EAnimationState::Hurled, CPASAnimParm::FromInt32(-1),
CPASAnimParm::FromReal32(x8_knockAngle), CPASAnimParm::FromEnum(s32(x4_state)));
const std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
const CAnimPlaybackParms playParms(best.second, -1, 1.f, true);
bc.SetCurrentAnimation(playParms, false, false);
const CPASAnimState* hurledState = bc.GetPASDatabase().GetAnimState(14);
const CPASAnimState* hurledState = bc.GetPASDatabase().GetAnimState(pas::EAnimationState::Hurled);
xc_animSeries = hurledState->GetAnimParmData(best.second, 0).GetInt32Value();
mgr.SendScriptMsg(&bc.GetOwner(), kInvalidUniqueId, EScriptObjectMessage::Falling);
mgr.SendScriptMsg(&bc.GetOwner(), kInvalidUniqueId, EScriptObjectMessage::Jumped);
@ -1132,8 +1144,8 @@ pas::EAnimationState CBSHurled::GetBodyStateTransition(float dt, CBodyController
}
void CBSHurled::Recover(CStateManager& mgr, CBodyController& bc, pas::EHurledState state) {
const CPASAnimParmData parms(14, CPASAnimParm::FromInt32(xc_animSeries), CPASAnimParm::FromReal32(x8_knockAngle),
CPASAnimParm::FromEnum(s32(state)));
const CPASAnimParmData parms(pas::EAnimationState::Hurled, CPASAnimParm::FromInt32(xc_animSeries),
CPASAnimParm::FromReal32(x8_knockAngle), CPASAnimParm::FromEnum(s32(state)));
const std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
if (best.first > FLT_EPSILON) {
const CAnimPlaybackParms playParms(best.second, -1, 1.f, true);
@ -1147,8 +1159,8 @@ void CBSHurled::Recover(CStateManager& mgr, CBodyController& bc, pas::EHurledSta
}
void CBSHurled::PlayStrikeWallAnimation(CBodyController& bc, CStateManager& mgr) {
const CPASAnimParmData parms(14, CPASAnimParm::FromInt32(xc_animSeries), CPASAnimParm::FromReal32(x8_knockAngle),
CPASAnimParm::FromEnum(3));
const CPASAnimParmData parms(pas::EAnimationState::Hurled, CPASAnimParm::FromInt32(xc_animSeries),
CPASAnimParm::FromReal32(x8_knockAngle), CPASAnimParm::FromEnum(3));
const std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
if (best.first <= FLT_EPSILON) {
@ -1161,12 +1173,12 @@ void CBSHurled::PlayStrikeWallAnimation(CBodyController& bc, CStateManager& mgr)
}
void CBSHurled::PlayLandAnimation(CBodyController& bc, CStateManager& mgr) {
const CPASAnimParmData parms(14, CPASAnimParm::FromInt32(xc_animSeries), CPASAnimParm::FromReal32(x8_knockAngle),
CPASAnimParm::FromEnum(s32(x4_state)));
const CPASAnimParmData parms(pas::EAnimationState::Hurled, CPASAnimParm::FromInt32(xc_animSeries),
CPASAnimParm::FromReal32(x8_knockAngle), CPASAnimParm::FromEnum(s32(x4_state)));
const std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
const CAnimPlaybackParms playParms(best.second, -1, 1.f, true);
bc.SetCurrentAnimation(playParms, false, false);
const CPASAnimState* hurledState = bc.GetPASDatabase().GetAnimState(14);
const CPASAnimState* hurledState = bc.GetPASDatabase().GetAnimState(pas::EAnimationState::Hurled);
bc.SetFallState(pas::EFallState(hurledState->GetAnimParmData(best.second, 3).GetEnumValue()));
if (const TCastToPtr<CPhysicsActor> act = bc.GetOwner()) {
mgr.SendScriptMsg(act.GetPtr(), kInvalidUniqueId, EScriptObjectMessage::OnFloor);
@ -1220,7 +1232,7 @@ pas::EAnimationState CBSHurled::UpdateBody(float dt, CBodyController& bc, CState
switch (x4_state) {
case pas::EHurledState::KnockIntoAir: {
if (bc.IsAnimationOver()) {
const CPASAnimParmData parms(14, CPASAnimParm::FromInt32(xc_animSeries),
const CPASAnimParmData parms(pas::EAnimationState::Hurled, CPASAnimParm::FromInt32(xc_animSeries),
CPASAnimParm::FromReal32(x8_knockAngle), CPASAnimParm::FromEnum(1));
bc.LoopBestAnimation(parms, *mgr.GetActiveRandom());
x4_state = pas::EHurledState::KnockLoop;
@ -1244,7 +1256,7 @@ pas::EAnimationState CBSHurled::UpdateBody(float dt, CBodyController& bc, CState
case pas::EHurledState::StrikeWall:
if (bc.IsAnimationOver()) {
x4_state = pas::EHurledState::StrikeWallFallLoop;
const CPASAnimParmData parms(14, CPASAnimParm::FromInt32(xc_animSeries),
const CPASAnimParmData parms(pas::EAnimationState::Hurled, CPASAnimParm::FromInt32(xc_animSeries),
CPASAnimParm::FromReal32(x8_knockAngle), CPASAnimParm::FromEnum(s32(x4_state)));
bc.LoopBestAnimation(parms, *mgr.GetActiveRandom());
x28_landedDur = 0.f;
@ -1289,14 +1301,14 @@ void CBSSlide::Start(CBodyController& bc, CStateManager& mgr) {
const auto* cmd = static_cast<const CBCSlideCmd*>(bc.GetCommandMgr().GetCmd(EBodyStateCmd::Slide));
const zeus::CVector3f localDir = bc.GetOwner().GetTransform().transposeRotate(cmd->GetSlideDirection());
const float angle = std::atan2(localDir.y(), localDir.x());
const CPASAnimParmData parms(15, CPASAnimParm::FromEnum(s32(cmd->GetSlideType())),
const CPASAnimParmData parms(pas::EAnimationState::Slide, CPASAnimParm::FromEnum(s32(cmd->GetSlideType())),
CPASAnimParm::FromReal32(zeus::radToDeg(angle)));
const std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
const CAnimPlaybackParms playParms(best.second, -1, 1.f, true);
bc.SetCurrentAnimation(playParms, false, false);
const float timeRem = bc.GetAnimTimeRemaining();
if (timeRem > FLT_EPSILON) {
const CPASAnimState* slideState = bc.GetPASDatabase().GetAnimState(15);
const CPASAnimState* slideState = bc.GetPASDatabase().GetAnimState(pas::EAnimationState::Slide);
const float animAngle = zeus::degToRad(slideState->GetAnimParmData(best.second, 1).GetReal32Value());
const float delta1 = zeus::CRelAngle(angle - animAngle).asRel();
const float flippedAngle = (delta1 > M_PIF) ? delta1 - 2.f * M_PIF : delta1;
@ -1337,7 +1349,7 @@ pas::EAnimationState CBSSlide::UpdateBody(float dt, CBodyController& bc, CStateM
void CBSTaunt::Start(CBodyController& bc, CStateManager& mgr) {
const auto* cmd = static_cast<const CBCTauntCmd*>(bc.GetCommandMgr().GetCmd(EBodyStateCmd::Taunt));
const CPASAnimParmData parms(16, CPASAnimParm::FromEnum(s32(cmd->GetTauntType())));
const CPASAnimParmData parms(pas::EAnimationState::Taunt, CPASAnimParm::FromEnum(s32(cmd->GetTauntType())));
bc.PlayBestAnimation(parms, *mgr.GetActiveRandom());
}
@ -1425,7 +1437,7 @@ void CBSCover::Start(CBodyController& bc, CStateManager& mgr) {
const auto* cmd = static_cast<const CBCCoverCmd*>(bc.GetCommandMgr().GetCmd(EBodyStateCmd::Cover));
x8_coverDirection = cmd->GetDirection();
x4_state = pas::ECoverState::IntoCover;
const CPASAnimParmData parms(19, CPASAnimParm::FromEnum(s32(x4_state)),
const CPASAnimParmData parms(pas::EAnimationState::Cover, CPASAnimParm::FromEnum(s32(x4_state)),
CPASAnimParm::FromEnum(s32(x8_coverDirection)));
const std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
const zeus::CQuaternion orientDelta =
@ -1466,7 +1478,7 @@ pas::EAnimationState CBSCover::UpdateBody(float dt, CBodyController& bc, CStateM
case pas::ECoverState::IntoCover:
if (bc.IsAnimationOver()) {
x4_state = pas::ECoverState::Cover;
const CPASAnimParmData parms(19, CPASAnimParm::FromEnum(s32(x4_state)),
const CPASAnimParmData parms(pas::EAnimationState::Cover, CPASAnimParm::FromEnum(s32(x4_state)),
CPASAnimParm::FromEnum(s32(x8_coverDirection)));
bc.LoopBestAnimation(parms, *mgr.GetActiveRandom());
}
@ -1481,12 +1493,12 @@ pas::EAnimationState CBSCover::UpdateBody(float dt, CBodyController& bc, CStateM
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::ExitState) || xc_needsExit) {
xc_needsExit = false;
x4_state = pas::ECoverState::OutOfCover;
const CPASAnimParmData parms(19, CPASAnimParm::FromEnum(s32(x4_state)),
const CPASAnimParmData parms(pas::EAnimationState::Cover, 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;
const CPASAnimParmData parms(19, CPASAnimParm::FromEnum(s32(x4_state)),
const CPASAnimParmData parms(pas::EAnimationState::Cover, CPASAnimParm::FromEnum(s32(x4_state)),
CPASAnimParm::FromEnum(s32(x8_coverDirection)));
bc.PlayBestAnimation(parms, *mgr.GetActiveRandom());
}
@ -1509,7 +1521,7 @@ void CBSWallHang::Start(CBodyController& bc, CStateManager& mgr) {
x4_state = pas::EWallHangState::IntoJump;
x8_wpId = cmd->GetTarget();
x18_25_needsExit = false;
const CPASAnimParmData parms(20, CPASAnimParm::FromEnum(s32(x4_state)));
const CPASAnimParmData parms(pas::EAnimationState::WallHang, CPASAnimParm::FromEnum(s32(x4_state)));
bc.PlayBestAnimation(parms, *mgr.GetActiveRandom());
}
@ -1534,7 +1546,7 @@ bool CBSWallHang::CheckForLand(CBodyController& bc, CStateManager& mgr) {
if (const TCastToPtr<CPatterned> ai = bc.GetOwner()) {
if (ai->MadeSolidCollision() || ai->IsOnGround()) {
x4_state = pas::EWallHangState::DetachOutOfJump;
const CPASAnimParmData parms(20, CPASAnimParm::FromEnum(s32(x4_state)));
const CPASAnimParmData parms(pas::EAnimationState::WallHang, CPASAnimParm::FromEnum(s32(x4_state)));
bc.PlayBestAnimation(parms, *mgr.GetActiveRandom());
mgr.SendScriptMsg(ai.GetPtr(), kInvalidUniqueId, EScriptObjectMessage::OnFloor);
return true;
@ -1553,7 +1565,7 @@ bool CBSWallHang::CheckForWall(CBodyController& bc, CStateManager& mgr) {
if (magSq < 1.f || ai->MadeSolidCollision()) {
x4_state = pas::EWallHangState::IntoWallHang;
const CPASAnimParmData parms(20, CPASAnimParm::FromEnum(s32(x4_state)));
const CPASAnimParmData parms(pas::EAnimationState::WallHang, CPASAnimParm::FromEnum(s32(x4_state)));
const std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
const zeus::CVector3f& target = wp ? wp->GetTranslation() : ai->GetTranslation();
const CAnimPlaybackParms playParms(best.second, nullptr, &target, &bc.GetOwner().GetTransform(),
@ -1586,7 +1598,7 @@ pas::EAnimationState CBSWallHang::UpdateBody(float dt, CBodyController& bc, CSta
if (st == pas::EAnimationState::Invalid) {
switch (x4_state) {
case pas::EWallHangState::IntoJump: {
const CPASAnimParmData parms(20, CPASAnimParm::FromEnum(1));
const CPASAnimParmData parms(pas::EAnimationState::WallHang, CPASAnimParm::FromEnum(1));
const std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
if (best.first > 0.f) {
x4_state = pas::EWallHangState::JumpArc;
@ -1594,7 +1606,7 @@ pas::EAnimationState CBSWallHang::UpdateBody(float dt, CBodyController& bc, CSta
bc.SetCurrentAnimation(playParms, false, false);
} else {
x4_state = pas::EWallHangState::JumpAirLoop;
const CPASAnimParmData loopParms(20, CPASAnimParm::FromEnum(s32(x4_state)));
const CPASAnimParmData loopParms(pas::EAnimationState::WallHang, CPASAnimParm::FromEnum(s32(x4_state)));
bc.LoopBestAnimation(loopParms, *mgr.GetActiveRandom());
}
if (const TCastToPtr<CPhysicsActor> act = bc.GetOwner()) {
@ -1616,7 +1628,7 @@ pas::EAnimationState CBSWallHang::UpdateBody(float dt, CBodyController& bc, CSta
SetLaunchVelocity(bc);
if (bc.IsAnimationOver()) {
x4_state = pas::EWallHangState::JumpAirLoop;
const CPASAnimParmData parms(20, CPASAnimParm::FromEnum(s32(x4_state)));
const CPASAnimParmData parms(pas::EAnimationState::WallHang, CPASAnimParm::FromEnum(s32(x4_state)));
bc.LoopBestAnimation(parms, *mgr.GetActiveRandom());
} else {
CheckForWall(bc, mgr);
@ -1633,7 +1645,7 @@ pas::EAnimationState CBSWallHang::UpdateBody(float dt, CBodyController& bc, CSta
case pas::EWallHangState::IntoWallHang: {
if (bc.IsAnimationOver()) {
x4_state = pas::EWallHangState::WallHang;
const CPASAnimParmData parms(20, CPASAnimParm::FromEnum(s32(x4_state)));
const CPASAnimParmData parms(pas::EAnimationState::WallHang, CPASAnimParm::FromEnum(s32(x4_state)));
bc.LoopBestAnimation(parms, *mgr.GetActiveRandom());
} else if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::ExitState)) {
x18_25_needsExit = true;
@ -1655,7 +1667,7 @@ pas::EAnimationState CBSWallHang::UpdateBody(float dt, CBodyController& bc, CSta
}
if (bc.GetCommandMgr().GetCmd(EBodyStateCmd::ExitState) || x18_25_needsExit) {
x4_state = pas::EWallHangState::OutOfWallHang;
const CPASAnimParmData parms(20, CPASAnimParm::FromEnum(s32(x4_state)));
const CPASAnimParmData parms(pas::EAnimationState::WallHang, CPASAnimParm::FromEnum(s32(x4_state)));
bc.PlayBestAnimation(parms, *mgr.GetActiveRandom());
}
FixInPlace(bc);
@ -1664,7 +1676,7 @@ pas::EAnimationState CBSWallHang::UpdateBody(float dt, CBodyController& bc, CSta
case pas::EWallHangState::Five: {
if (bc.IsAnimationOver()) {
x4_state = pas::EWallHangState::WallHang;
const CPASAnimParmData parms(20, CPASAnimParm::FromEnum(s32(x4_state)));
const CPASAnimParmData parms(pas::EAnimationState::WallHang, CPASAnimParm::FromEnum(s32(x4_state)));
bc.LoopBestAnimation(parms, *mgr.GetActiveRandom());
}
FixInPlace(bc);
@ -1672,7 +1684,7 @@ pas::EAnimationState CBSWallHang::UpdateBody(float dt, CBodyController& bc, CSta
}
case pas::EWallHangState::OutOfWallHang: {
if (bc.IsAnimationOver()) {
const CPASAnimParmData parms(20, CPASAnimParm::FromEnum(7));
const CPASAnimParmData parms(pas::EAnimationState::WallHang, CPASAnimParm::FromEnum(7));
const std::pair<float, s32> best = bc.GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
if (best.first > 0.f) {
x4_state = pas::EWallHangState::OutOfWallHangTurn;
@ -1680,7 +1692,7 @@ pas::EAnimationState CBSWallHang::UpdateBody(float dt, CBodyController& bc, CSta
bc.SetCurrentAnimation(playParms, false, false);
} else {
x4_state = pas::EWallHangState::DetachJumpLoop;
const CPASAnimParmData loopParms(20, CPASAnimParm::FromEnum(s32(x4_state)));
const CPASAnimParmData loopParms(pas::EAnimationState::WallHang, CPASAnimParm::FromEnum(s32(x4_state)));
bc.LoopBestAnimation(loopParms, *mgr.GetActiveRandom());
}
if (const TCastToPtr<CPhysicsActor> act = bc.GetOwner()) {
@ -1701,7 +1713,7 @@ pas::EAnimationState CBSWallHang::UpdateBody(float dt, CBodyController& bc, CSta
SetLaunchVelocity(bc);
if (bc.IsAnimationOver()) {
x4_state = pas::EWallHangState::DetachJumpLoop;
const CPASAnimParmData parms(20, CPASAnimParm::FromEnum(s32(x4_state)));
const CPASAnimParmData parms(pas::EAnimationState::WallHang, CPASAnimParm::FromEnum(s32(x4_state)));
bc.LoopBestAnimation(parms, *mgr.GetActiveRandom());
} else {
CheckForLand(bc, mgr);
@ -1923,7 +1935,8 @@ CBSBiPedLocomotion::CBSBiPedLocomotion(CActor& actor) {
for (int i = 0; i < 14; ++i) {
rstl::reserved_vector<std::pair<s32, float>, 8>& innerVec = x8_anims.emplace_back();
for (int j = 0; j < 8; ++j) {
const CPASAnimParmData parms(5, CPASAnimParm::FromEnum(j), CPASAnimParm::FromEnum(i));
const CPASAnimParmData parms(pas::EAnimationState::WallHang, CPASAnimParm::FromEnum(j),
CPASAnimParm::FromEnum(i));
const std::pair<float, s32> best = pasDatabase.FindBestAnimation(parms, -1);
float avgVel = 0.f;
if (best.second != -1) {
@ -2159,7 +2172,8 @@ float CBSNewFlyerLocomotion::UpdateLocomotionAnimation(float dt, float velMag, C
CBSRestrictedLocomotion::CBSRestrictedLocomotion(CActor& actor) {
const CPASDatabase& pasDatabase = actor.GetModelData()->GetAnimationData()->GetCharacterInfo().GetPASDatabase();
for (int i = 0; i < 14; ++i) {
const CPASAnimParmData parms(5, CPASAnimParm::FromEnum(0), CPASAnimParm::FromEnum(i));
const CPASAnimParmData parms(pas::EAnimationState::Locomotion, CPASAnimParm::FromEnum(0),
CPASAnimParm::FromEnum(i));
const std::pair<float, s32> best = pasDatabase.FindBestAnimation(parms, -1);
x8_anims.push_back(best.second);
}

286
Runtime/Character/CBodyStateInfo.cpp
View File

@ -48,321 +48,321 @@ CBodyStateInfo::CBodyStateInfo(CActor& actor, EBodyType type) {
x1c_additiveStates.emplace_back(pas::EAnimationState::AdditiveReaction, std::make_unique<CABSReaction>());
}
std::unique_ptr<CBodyState> CBodyStateInfo::SetupRestrictedFlyerBodyStates(int stateId, CActor& actor) const {
std::unique_ptr<CBodyState> CBodyStateInfo::SetupRestrictedFlyerBodyStates(pas::EAnimationState stateId, CActor& actor) const {
switch (stateId) {
case 0:
case pas::EAnimationState::Fall:
return std::make_unique<CBSFall>();
case 1:
case pas::EAnimationState::Getup:
return std::make_unique<CBSGetup>();
case 2:
case pas::EAnimationState::LieOnGround:
return std::make_unique<CBSLieOnGround>(actor);
case 3:
case pas::EAnimationState::Step:
return std::make_unique<CBSStep>();
case 4:
case pas::EAnimationState::Death:
return std::make_unique<CBSDie>();
case 5:
case pas::EAnimationState::Locomotion:
return std::make_unique<CBSRestrictedFlyerLocomotion>(actor);
case 6:
case pas::EAnimationState::KnockBack:
return std::make_unique<CBSKnockBack>();
case 7:
case pas::EAnimationState::MeleeAttack:
return std::make_unique<CBSAttack>();
case 18:
case pas::EAnimationState::ProjectileAttack:
return std::make_unique<CBSProjectileAttack>();
case 9:
case pas::EAnimationState::LoopAttack:
return std::make_unique<CBSLoopAttack>();
case 8:
case pas::EAnimationState::Turn:
return std::make_unique<CBSTurn>();
case 10:
case pas::EAnimationState::LoopReaction:
return std::make_unique<CBSLoopReaction>();
case 11:
case pas::EAnimationState::GroundHit:
return std::make_unique<CBSGroundHit>();
case 12:
case pas::EAnimationState::Generate:
return std::make_unique<CBSGenerate>();
case 13:
case pas::EAnimationState::Jump:
return std::make_unique<CBSJump>();
case 14:
case pas::EAnimationState::Hurled:
return std::make_unique<CBSHurled>();
case 15:
case pas::EAnimationState::Slide:
return std::make_unique<CBSSlide>();
case 16:
case pas::EAnimationState::Taunt:
return std::make_unique<CBSTaunt>();
case 17:
case pas::EAnimationState::Scripted:
return std::make_unique<CBSScripted>();
default:
return {};
}
}
std::unique_ptr<CBodyState> CBodyStateInfo::SetupNewFlyerBodyStates(int stateId, CActor& actor) const {
std::unique_ptr<CBodyState> CBodyStateInfo::SetupNewFlyerBodyStates(pas::EAnimationState stateId, CActor& actor) const {
switch (stateId) {
case 0:
case pas::EAnimationState::Fall:
return std::make_unique<CBSFall>();
case 1:
case pas::EAnimationState::Getup:
return std::make_unique<CBSGetup>();
case 2:
case pas::EAnimationState::LieOnGround:
return std::make_unique<CBSLieOnGround>(actor);
case 3:
case pas::EAnimationState::Step:
return std::make_unique<CBSStep>();
case 4:
case pas::EAnimationState::Death:
return std::make_unique<CBSDie>();
case 5:
case pas::EAnimationState::Locomotion:
return std::make_unique<CBSNewFlyerLocomotion>(actor);
case 6:
case pas::EAnimationState::KnockBack:
return std::make_unique<CBSKnockBack>();
case 7:
case pas::EAnimationState::MeleeAttack:
return std::make_unique<CBSAttack>();
case 18:
case pas::EAnimationState::ProjectileAttack:
return std::make_unique<CBSProjectileAttack>();
case 9:
case pas::EAnimationState::LoopAttack:
return std::make_unique<CBSLoopAttack>();
case 8:
case pas::EAnimationState::Turn:
return std::make_unique<CBSTurn>();
case 10:
case pas::EAnimationState::LoopReaction:
return std::make_unique<CBSLoopReaction>();
case 11:
case pas::EAnimationState::GroundHit:
return std::make_unique<CBSGroundHit>();
case 12:
case pas::EAnimationState::Generate:
return std::make_unique<CBSGenerate>();
case 13:
case pas::EAnimationState::Jump:
return std::make_unique<CBSJump>();
case 14:
case pas::EAnimationState::Hurled:
return std::make_unique<CBSHurled>();
case 15:
case pas::EAnimationState::Slide:
return std::make_unique<CBSSlide>();
case 16:
case pas::EAnimationState::Taunt:
return std::make_unique<CBSTaunt>();
case 17:
case pas::EAnimationState::Scripted:
return std::make_unique<CBSScripted>();
default:
return {};
}
}
std::unique_ptr<CBodyState> CBodyStateInfo::SetupWallWalkerBodyStates(int stateId, CActor& actor) const {
std::unique_ptr<CBodyState> CBodyStateInfo::SetupWallWalkerBodyStates(pas::EAnimationState stateId, CActor& actor) const {
switch (stateId) {
case 0:
case pas::EAnimationState::Fall:
return std::make_unique<CBSFall>();
case 1:
case pas::EAnimationState::Getup:
return std::make_unique<CBSGetup>();
case 2:
case pas::EAnimationState::LieOnGround:
return std::make_unique<CBSLieOnGround>(actor);
case 3:
case pas::EAnimationState::Step:
return std::make_unique<CBSStep>();
case 4:
case pas::EAnimationState::Death:
return std::make_unique<CBSDie>();
case 5:
case pas::EAnimationState::Locomotion:
return std::make_unique<CBSWallWalkerLocomotion>(actor);
case 6:
case pas::EAnimationState::KnockBack:
return std::make_unique<CBSKnockBack>();
case 7:
case pas::EAnimationState::MeleeAttack:
return std::make_unique<CBSAttack>();
case 18:
case pas::EAnimationState::ProjectileAttack:
return std::make_unique<CBSProjectileAttack>();
case 9:
case pas::EAnimationState::LoopAttack:
return std::make_unique<CBSLoopAttack>();
case 8:
case pas::EAnimationState::Turn:
return std::make_unique<CBSFlyerTurn>();
case 10:
case pas::EAnimationState::LoopReaction:
return std::make_unique<CBSLoopReaction>();
case 11:
case pas::EAnimationState::GroundHit:
return std::make_unique<CBSGroundHit>();
case 12:
case pas::EAnimationState::Generate:
return std::make_unique<CBSGenerate>();
case 13:
case pas::EAnimationState::Jump:
return std::make_unique<CBSJump>();
case 14:
case pas::EAnimationState::Hurled:
return std::make_unique<CBSHurled>();
case 15:
case pas::EAnimationState::Slide:
return std::make_unique<CBSSlide>();
case 16:
case pas::EAnimationState::Taunt:
return std::make_unique<CBSTaunt>();
case 17:
case pas::EAnimationState::Scripted:
return std::make_unique<CBSScripted>();
default:
return {};
}
}
std::unique_ptr<CBodyState> CBodyStateInfo::SetupPitchableBodyStates(int stateId, CActor& actor) const {
std::unique_ptr<CBodyState> CBodyStateInfo::SetupPitchableBodyStates(pas::EAnimationState stateId, CActor& actor) const {
switch (stateId) {
case 0:
case pas::EAnimationState::Fall:
return std::make_unique<CBSFall>();
case 1:
case pas::EAnimationState::Getup:
return std::make_unique<CBSGetup>();
case 2:
case pas::EAnimationState::LieOnGround:
return std::make_unique<CBSLieOnGround>(actor);
case 3:
case pas::EAnimationState::Step:
return std::make_unique<CBSStep>();
case 4:
case pas::EAnimationState::Death:
return std::make_unique<CBSDie>();
case 5:
case pas::EAnimationState::Locomotion:
return std::make_unique<CBSFlyerLocomotion>(actor, true);
case 6:
case pas::EAnimationState::KnockBack:
return std::make_unique<CBSKnockBack>();
case 7:
case pas::EAnimationState::MeleeAttack:
return std::make_unique<CBSAttack>();
case 18:
case pas::EAnimationState::ProjectileAttack:
return std::make_unique<CBSProjectileAttack>();
case 9:
case pas::EAnimationState::LoopAttack:
return std::make_unique<CBSLoopAttack>();
case 8:
case pas::EAnimationState::Turn:
return std::make_unique<CBSFlyerTurn>();
case 10:
case pas::EAnimationState::LoopReaction:
return std::make_unique<CBSLoopReaction>();
case 11:
case pas::EAnimationState::GroundHit:
return std::make_unique<CBSGroundHit>();
case 12:
case pas::EAnimationState::Generate:
return std::make_unique<CBSGenerate>();
case 13:
case pas::EAnimationState::Jump:
return std::make_unique<CBSJump>();
case 14:
case pas::EAnimationState::Hurled:
return std::make_unique<CBSHurled>();
case 15:
case pas::EAnimationState::Slide:
return std::make_unique<CBSSlide>();
case 16:
case pas::EAnimationState::Taunt:
return std::make_unique<CBSTaunt>();
case 17:
case pas::EAnimationState::Scripted:
return std::make_unique<CBSScripted>();
default:
return {};
}
}
std::unique_ptr<CBodyState> CBodyStateInfo::SetupFlyerBodyStates(int stateId, CActor& actor) const {
std::unique_ptr<CBodyState> CBodyStateInfo::SetupFlyerBodyStates(pas::EAnimationState stateId, CActor& actor) const {
switch (stateId) {
case 0:
case pas::EAnimationState::Fall:
return std::make_unique<CBSFall>();
case 1:
case pas::EAnimationState::Getup:
return std::make_unique<CBSGetup>();
case 2:
case pas::EAnimationState::LieOnGround:
return std::make_unique<CBSLieOnGround>(actor);
case 3:
case pas::EAnimationState::Step:
return std::make_unique<CBSStep>();
case 4:
case pas::EAnimationState::Death:
return std::make_unique<CBSDie>();
case 5:
case pas::EAnimationState::Locomotion:
return std::make_unique<CBSFlyerLocomotion>(actor, false);
case 6:
case pas::EAnimationState::KnockBack:
return std::make_unique<CBSKnockBack>();
case 7:
case pas::EAnimationState::MeleeAttack:
return std::make_unique<CBSAttack>();
case 18:
case pas::EAnimationState::ProjectileAttack:
return std::make_unique<CBSProjectileAttack>();
case 9:
case pas::EAnimationState::LoopAttack:
return std::make_unique<CBSLoopAttack>();
case 8:
case pas::EAnimationState::Turn:
return std::make_unique<CBSFlyerTurn>();
case 10:
case pas::EAnimationState::LoopReaction:
return std::make_unique<CBSLoopReaction>();
case 11:
case pas::EAnimationState::GroundHit:
return std::make_unique<CBSGroundHit>();
case 12:
case pas::EAnimationState::Generate:
return std::make_unique<CBSGenerate>();
case 13:
case pas::EAnimationState::Jump:
return std::make_unique<CBSJump>();
case 14:
case pas::EAnimationState::Hurled:
return std::make_unique<CBSHurled>();
case 15:
case pas::EAnimationState::Slide:
return std::make_unique<CBSSlide>();
case 16:
case pas::EAnimationState::Taunt:
return std::make_unique<CBSTaunt>();
case 17:
case pas::EAnimationState::Scripted:
return std::make_unique<CBSScripted>();
default:
return {};
}
}
std::unique_ptr<CBodyState> CBodyStateInfo::SetupRestrictedBodyStates(int stateId, CActor& actor) const {
std::unique_ptr<CBodyState> CBodyStateInfo::SetupRestrictedBodyStates(pas::EAnimationState stateId, CActor& actor) const {
switch (stateId) {
case 0:
case pas::EAnimationState::Fall:
return std::make_unique<CBSFall>();
case 1:
case pas::EAnimationState::Getup:
return std::make_unique<CBSGetup>();
case 2:
case pas::EAnimationState::LieOnGround:
return std::make_unique<CBSLieOnGround>(actor);
case 3:
case pas::EAnimationState::Step:
return std::make_unique<CBSStep>();
case 4:
case pas::EAnimationState::Death:
return std::make_unique<CBSDie>();
case 5:
case pas::EAnimationState::Locomotion:
return std::make_unique<CBSRestrictedLocomotion>(actor);
case 6:
case pas::EAnimationState::KnockBack:
return std::make_unique<CBSKnockBack>();
case 7:
case pas::EAnimationState::MeleeAttack:
return std::make_unique<CBSAttack>();
case 18:
case pas::EAnimationState::ProjectileAttack:
return std::make_unique<CBSProjectileAttack>();
case 9:
case pas::EAnimationState::LoopAttack:
return std::make_unique<CBSLoopAttack>();
case 8:
case pas::EAnimationState::Turn:
return std::make_unique<CBSTurn>();
case 10:
case pas::EAnimationState::LoopReaction:
return std::make_unique<CBSLoopReaction>();
case 11:
case pas::EAnimationState::GroundHit:
return std::make_unique<CBSGroundHit>();
case 12:
case pas::EAnimationState::Generate:
return std::make_unique<CBSGenerate>();
case 13:
case pas::EAnimationState::Jump:
return std::make_unique<CBSJump>();
case 14:
case pas::EAnimationState::Hurled:
return std::make_unique<CBSHurled>();
case 15:
case pas::EAnimationState::Slide:
return std::make_unique<CBSSlide>();
case 16:
case pas::EAnimationState::Taunt:
return std::make_unique<CBSTaunt>();
case 17:
case pas::EAnimationState::Scripted:
return std::make_unique<CBSScripted>();
case 19:
case pas::EAnimationState::Cover:
return std::make_unique<CBSCover>();
default:
return {};
}
}
std::unique_ptr<CBodyState> CBodyStateInfo::SetupBiPedalBodyStates(int stateId, CActor& actor) const {
std::unique_ptr<CBodyState> CBodyStateInfo::SetupBiPedalBodyStates(pas::EAnimationState stateId, CActor& actor) const {
switch (stateId) {
case 0:
case pas::EAnimationState::Fall:
return std::make_unique<CBSFall>();
case 1:
case pas::EAnimationState::Getup:
return std::make_unique<CBSGetup>();
case 2:
case pas::EAnimationState::LieOnGround:
return std::make_unique<CBSLieOnGround>(actor);
case 3:
case pas::EAnimationState::Step:
return std::make_unique<CBSStep>();
case 4:
case pas::EAnimationState::Death:
return std::make_unique<CBSDie>();
case 5:
case pas::EAnimationState::Locomotion:
return std::make_unique<CBSBiPedLocomotion>(actor);
case 6:
case pas::EAnimationState::KnockBack:
return std::make_unique<CBSKnockBack>();
case 7:
case pas::EAnimationState::MeleeAttack:
return std::make_unique<CBSAttack>();
case 18:
case pas::EAnimationState::ProjectileAttack:
return std::make_unique<CBSProjectileAttack>();
case 9:
case pas::EAnimationState::LoopAttack:
return std::make_unique<CBSLoopAttack>();
case 8:
case pas::EAnimationState::Turn:
return std::make_unique<CBSTurn>();
case 10:
case pas::EAnimationState::LoopReaction:
return std::make_unique<CBSLoopReaction>();
case 11:
case pas::EAnimationState::GroundHit:
return std::make_unique<CBSGroundHit>();
case 12:
case pas::EAnimationState::Generate:
return std::make_unique<CBSGenerate>();
case 13:
case pas::EAnimationState::Jump:
return std::make_unique<CBSJump>();
case 14:
case pas::EAnimationState::Hurled:
return std::make_unique<CBSHurled>();
case 15:
case pas::EAnimationState::Slide:
return std::make_unique<CBSSlide>();
case 16:
case pas::EAnimationState::Taunt:
return std::make_unique<CBSTaunt>();
case 17:
case pas::EAnimationState::Scripted:
return std::make_unique<CBSScripted>();
case 19:
case pas::EAnimationState::Cover:
return std::make_unique<CBSCover>();
case 20:
case pas::EAnimationState::WallHang:
return std::make_unique<CBSWallHang>();
default:
return {};

14
Runtime/Character/CBodyStateInfo.hpp
View File

@ -22,13 +22,13 @@ class CBodyStateInfo {
pas::EAnimationState x2c_additiveState = pas::EAnimationState::AdditiveIdle;
float x30_maxPitch = 0.f;
bool x34_24_changeLocoAtEndOfAnimOnly;
std::unique_ptr<CBodyState> SetupRestrictedFlyerBodyStates(int stateId, CActor& actor) const;
std::unique_ptr<CBodyState> SetupNewFlyerBodyStates(int stateId, CActor& actor) const;
std::unique_ptr<CBodyState> SetupWallWalkerBodyStates(int stateId, CActor& actor) const;
std::unique_ptr<CBodyState> SetupPitchableBodyStates(int stateId, CActor& actor) const;
std::unique_ptr<CBodyState> SetupFlyerBodyStates(int stateId, CActor& actor) const;
std::unique_ptr<CBodyState> SetupRestrictedBodyStates(int stateId, CActor& actor) const;
std::unique_ptr<CBodyState> SetupBiPedalBodyStates(int stateId, CActor& actor) const;
std::unique_ptr<CBodyState> SetupRestrictedFlyerBodyStates(pas::EAnimationState stateId, CActor& actor) const;
std::unique_ptr<CBodyState> SetupNewFlyerBodyStates(pas::EAnimationState stateId, CActor& actor) const;
std::unique_ptr<CBodyState> SetupWallWalkerBodyStates(pas::EAnimationState stateId, CActor& actor) const;
std::unique_ptr<CBodyState> SetupPitchableBodyStates(pas::EAnimationState stateId, CActor& actor) const;
std::unique_ptr<CBodyState> SetupFlyerBodyStates(pas::EAnimationState stateId, CActor& actor) const;
std::unique_ptr<CBodyState> SetupRestrictedBodyStates(pas::EAnimationState stateId, CActor& actor) const;
std::unique_ptr<CBodyState> SetupBiPedalBodyStates(pas::EAnimationState stateId, CActor& actor) const;
public:
CBodyStateInfo(CActor& actor, EBodyType type);

2
Runtime/Character/CPASAnimParmData.cpp
View File

@ -2,7 +2,7 @@
namespace urde {
CPASAnimParmData::CPASAnimParmData(s32 stateId, const CPASAnimParm& parm1, const CPASAnimParm& parm2,
CPASAnimParmData::CPASAnimParmData(pas::EAnimationState stateId, const CPASAnimParm& parm1, const CPASAnimParm& parm2,
const CPASAnimParm& parm3, const CPASAnimParm& parm4, const CPASAnimParm& parm5,
const CPASAnimParm& parm6, const CPASAnimParm& parm7, const CPASAnimParm& parm8)
: x0_stateId(stateId) {

9
Runtime/Character/CPASAnimParmData.hpp
View File

@ -2,17 +2,18 @@
#include "Runtime/RetroTypes.hpp"
#include "Runtime/rstl.hpp"
#include "Runtime/Character/CharacterCommon.hpp"
#include "Runtime/Character/CPASAnimParm.hpp"
namespace urde {
class CPASAnimParmData {
s32 x0_stateId;
pas::EAnimationState x0_stateId;
rstl::reserved_vector<CPASAnimParm, 8> x4_parms;
public:
CPASAnimParmData() = default;
explicit CPASAnimParmData(s32 stateId, const CPASAnimParm& parm1 = CPASAnimParm::NoParameter(),
explicit CPASAnimParmData(pas::EAnimationState stateId, const CPASAnimParm& parm1 = CPASAnimParm::NoParameter(),
const CPASAnimParm& parm2 = CPASAnimParm::NoParameter(),
const CPASAnimParm& parm3 = CPASAnimParm::NoParameter(),
const CPASAnimParm& parm4 = CPASAnimParm::NoParameter(),
@ -21,9 +22,9 @@ public:
const CPASAnimParm& parm7 = CPASAnimParm::NoParameter(),
const CPASAnimParm& parm8 = CPASAnimParm::NoParameter());
s32 GetStateId() const { return x0_stateId; }
pas::EAnimationState GetStateId() const { return x0_stateId; }
const rstl::reserved_vector<CPASAnimParm, 8>& GetAnimParmData() const { return x4_parms; }
static auto NoParameters(s32 stateId) { return CPASAnimParmData(stateId); }
static auto NoParameters(pas::EAnimationState stateId) { return CPASAnimParmData(stateId); }
};
} // namespace urde

5
Runtime/Character/CPASAnimState.cpp
View File

@ -2,6 +2,7 @@
#include "Runtime/CRandom16.hpp"
#include "Runtime/rstl.hpp"
#include "Runtime/Character/CharacterCommon.hpp"
#include "Runtime/Character/CPASAnimParmData.hpp"
#include <algorithm>
@ -13,7 +14,7 @@
namespace urde {
CPASAnimState::CPASAnimState(CInputStream& in) {
x0_id = in.readUint32Big();
x0_id = static_cast<pas::EAnimationState>(in.readUint32Big());
u32 parmCount = in.readUint32Big();
u32 animCount = in.readUint32Big();
@ -58,7 +59,7 @@ CPASAnimState::CPASAnimState(CInputStream& in) {
}
}
CPASAnimState::CPASAnimState(int stateId) : x0_id(stateId) {}
CPASAnimState::CPASAnimState(pas::EAnimationState stateId) : x0_id(stateId) {}
CPASAnimParm CPASAnimState::GetAnimParmData(s32 animId, size_t parmIdx) const {
const auto search = rstl::binary_find(x14_anims.cbegin(), x14_anims.cend(), animId,

7
Runtime/Character/CPASAnimState.hpp
View File

@ -4,6 +4,7 @@
#include <vector>
#include "Runtime/IOStreams.hpp"
#include "Runtime/Character/CharacterCommon.hpp"
#include "Runtime/Character/CPASAnimInfo.hpp"
#include "Runtime/Character/CPASParmInfo.hpp"
@ -11,7 +12,7 @@ namespace urde {
class CRandom16;
class CPASAnimParmData;
class CPASAnimState {
s32 x0_id;
pas::EAnimationState x0_id;
std::vector<CPASParmInfo> x4_parms;
std::vector<CPASAnimInfo> x14_anims;
mutable std::vector<s32> x24_selectionCache;
@ -24,8 +25,8 @@ class CPASAnimState {
public:
explicit CPASAnimState(CInputStream& in);
explicit CPASAnimState(int stateId);
s32 GetStateId() const { return x0_id; }
explicit CPASAnimState(pas::EAnimationState stateId);
pas::EAnimationState GetStateId() const { return x0_id; }
size_t GetNumAnims() const { return x14_anims.size(); }
bool HasAnims() const { return !x14_anims.empty(); }
CPASAnimParm GetAnimParmData(s32 animId, size_t parmIdx) const;

4
Runtime/Character/CPASDatabase.hpp
View File

@ -24,7 +24,7 @@ public:
std::pair<float, s32> FindBestAnimation(const CPASAnimParmData& data, CRandom16& rand, s32 ignoreAnim) const;
s32 GetDefaultState() const { return x10_defaultState; }
size_t GetNumAnimStates() const { return x0_states.size(); }
const CPASAnimState* GetAnimState(s32 id) const {
const CPASAnimState* GetAnimState(pas::EAnimationState id) const {
for (const CPASAnimState& state : x0_states)
if (id == state.GetStateId())
return &state;
@ -39,7 +39,7 @@ public:
return &x0_states[index];
}
bool HasState(s32 id) const {
bool HasState(pas::EAnimationState id) const {
const auto& st = std::find_if(x0_states.begin(), x0_states.end(),
[&id](const CPASAnimState& other) -> bool { return other.GetStateId() == id; });
return st != x0_states.end();

52
Runtime/Character/CharacterCommon.hpp
View File

@ -25,31 +25,31 @@ enum class ELocomotionAnim { Invalid = -1, Idle, Walk, Run, BackUp, StrafeLeft,
enum class EAnimationState {
Invalid = -1,
Fall,
Getup,
LieOnGround,
Step,
Death,
Locomotion,
KnockBack,
MeleeAttack,
Turn,
LoopAttack,
LoopReaction,
GroundHit,
Generate,
Jump,
Hurled,
Slide,
Taunt,
Scripted,
ProjectileAttack,
Cover,
WallHang,
AdditiveIdle,
AdditiveAim,
AdditiveFlinch,
AdditiveReaction
Fall = 0,
Getup = 1,
LieOnGround = 2,
Step = 3,
Death = 4,
Locomotion = 5,
KnockBack = 6,
MeleeAttack = 7,
Turn = 8,
LoopAttack = 9,
LoopReaction = 10,
GroundHit = 11,
Generate = 12,
Jump = 13,
Hurled = 14,
Slide = 15,
Taunt = 16,
Scripted = 17,
ProjectileAttack = 18,
Cover = 19,
WallHang = 20,
AdditiveIdle = 21,
AdditiveAim = 22,
AdditiveFlinch = 23,
AdditiveReaction = 24
};
enum class EHurledState {
@ -64,7 +64,7 @@ enum class EHurledState {
Seven
};
enum class EFallState { Invalid = -1, Zero, One , Two};
enum class EFallState { Invalid = -1, Zero, One, Two };
enum class EReactionType { Invalid = -1, Zero, One, Two, Three };

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

@ -97,7 +97,7 @@ CBabygoth::CBabygoth(TUniqueId uid, std::string_view name, const CEntityInfo& in
x460_knockBackController.SetEnableShock(true);
x460_knockBackController.SetEnableExplodeDeath(true);
x8d4_stepBackwardDist =
GetAnimationDistance(CPASAnimParmData(3, CPASAnimParm::FromEnum(1), CPASAnimParm::FromEnum(0))) *
GetAnimationDistance(CPASAnimParmData(pas::EAnimationState::Step, CPASAnimParm::FromEnum(1), CPASAnimParm::FromEnum(0))) *
GetModelData()->GetScale().y(); // B_backward_sheegoth
xa08_noShellModel->SetLayoutInfo(GetModelData()->GetAnimationData()->GetModelData()->GetLayoutInfo());
MakeThermalColdAndHot();

4
Runtime/MP1/World/CBeetle.cpp
View File

@ -32,10 +32,10 @@ CBeetle::CBeetle(TUniqueId uid, std::string_view name, const CEntityInfo& info,
, x7ac_tailVuln(tailVuln)
, x814_attackDelayTimer(initialAttackDelay)
, x834_retreatTime(retreatTime) {
x5a0_headbuttDist = GetAnimationDistance(CPASAnimParmData(7, CPASAnimParm::FromEnum(0), CPASAnimParm::FromEnum(1)));
x5a0_headbuttDist = GetAnimationDistance(CPASAnimParmData(pas::EAnimationState::MeleeAttack, CPASAnimParm::FromEnum(0), CPASAnimParm::FromEnum(1)));
x5a4_jumpBackwardDist =
x64_modelData->GetScale().y() *
GetAnimationDistance(CPASAnimParmData(3, CPASAnimParm::FromEnum(1), CPASAnimParm::FromEnum(0)));
GetAnimationDistance(CPASAnimParmData(pas::EAnimationState::Step, CPASAnimParm::FromEnum(1), CPASAnimParm::FromEnum(0)));
MakeThermalColdAndHot();
if (x3fc_flavor == EFlavorType::One)
x460_knockBackController.SetLocomotionDuringElectrocution(true);

6
Runtime/MP1/World/CChozoGhost.cpp
View File

@ -105,11 +105,11 @@ CChozoGhost::CChozoGhost(TUniqueId uid, std::string_view name, const CEntityInfo
x578_.Token().Lock();
x5a0_.Token().Lock();
x668_ = GetModelData()->GetScale().z() *
GetAnimationDistance(CPASAnimParmData(13, CPASAnimParm::FromEnum(3), CPASAnimParm::FromEnum(0)));
GetAnimationDistance(CPASAnimParmData(pas::EAnimationState::Jump, CPASAnimParm::FromEnum(3), CPASAnimParm::FromEnum(0)));
x66c_ = GetModelData()->GetScale().z() *
GetAnimationDistance(CPASAnimParmData(15, CPASAnimParm::FromEnum(1), CPASAnimParm::FromReal32(90.f)));
GetAnimationDistance(CPASAnimParmData(pas::EAnimationState::Slide, CPASAnimParm::FromEnum(1), CPASAnimParm::FromReal32(90.f)));
x670_ = GetModelData()->GetScale().z() *
GetAnimationDistance(CPASAnimParmData(7, CPASAnimParm::FromEnum(2), CPASAnimParm::FromEnum(1)));
GetAnimationDistance(CPASAnimParmData(pas::EAnimationState::MeleeAttack, CPASAnimParm::FromEnum(2), CPASAnimParm::FromEnum(1)));
if (projectileVisorEffect.IsValid())
x640_projectileVisor = g_SimplePool->GetObj({SBIG('PART'), projectileVisorEffect});

4
Runtime/MP1/World/CFlyingPirate.cpp
View File

@ -322,7 +322,7 @@ CFlyingPirate::CFlyingPirate(TUniqueId uid, std::string_view name, const CEntity
x864_missileSegments.push_back(animData->GetLocatorSegId("L_Missile_LCTR"sv));
x864_missileSegments.push_back(animData->GetLocatorSegId("R_Missile_LCTR"sv));
x850_height = modelData->GetScale().x() *
GetAnimationDistance(CPASAnimParmData{3, CPASAnimParm::FromEnum(3), CPASAnimParm::FromEnum(1)});
GetAnimationDistance(CPASAnimParmData{pas::EAnimationState::Step, CPASAnimParm::FromEnum(3), CPASAnimParm::FromEnum(1)});
if (x568_data.xd8_particleGen1.IsValid() && x568_data.xdc_particleGen2.IsValid() &&
x568_data.xe0_particleGen3.IsValid()) {
x65c_particleGenDescs.push_back(g_SimplePool->GetObj({SBIG('PART'), x568_data.xd8_particleGen1}));
@ -747,7 +747,7 @@ void CFlyingPirate::FireProjectile(CStateManager& mgr, float dt) {
}
if (projectileFired) {
const std::pair<float, s32>& anim = x450_bodyController->GetPASDatabase().FindBestAnimation(
CPASAnimParmData{24, CPASAnimParm::FromEnum(2)}, *mgr.GetActiveRandom(), -1);
CPASAnimParmData{pas::EAnimationState::AdditiveReaction, CPASAnimParm::FromEnum(2)}, *mgr.GetActiveRandom(), -1);
if (anim.first > 0.f) {
GetModelData()->GetAnimationData()->AddAdditiveAnimation(anim.second, 1.f, false, true);
}

10
Runtime/MP1/World/CGrenadeLauncher.cpp
View File

@ -32,7 +32,8 @@ CGrenadeLauncher::CGrenadeLauncher(TUniqueId uid, std::string_view name, const C
GetModelData()->EnableLooping(true);
const CPASDatabase& pasDatabase = GetModelData()->GetAnimationData()->GetCharacterInfo().GetPASDatabase();
for (size_t i = 0; i < x3c8_animIds.size(); ++i) {
const auto result = pasDatabase.FindBestAnimation(CPASAnimParmData{22, CPASAnimParm::FromEnum(int(i))}, -1);
const auto result = pasDatabase.FindBestAnimation(
CPASAnimParmData{pas::EAnimationState::AdditiveAim, CPASAnimParm::FromEnum(int(i))}, -1);
x3c8_animIds[i] = result.second;
}
}
@ -285,7 +286,9 @@ void CGrenadeLauncher::sub_80230438() {
constexpr std::array arr{0, 3};
const auto anim = animData->GetCharacterInfo().GetPASDatabase().FindBestAnimation(
CPASAnimParmData{5, CPASAnimParm::FromEnum(0), CPASAnimParm::FromEnum(arr[x258_started])}, -1);
CPASAnimParmData{pas::EAnimationState::Locomotion, CPASAnimParm::FromEnum(0),
CPASAnimParm::FromEnum(arr[x258_started])},
-1);
if (anim.first > 0.f) {
animData->SetAnimation({anim.second, -1, 1.f, true}, false);
modelData->EnableLooping(true);
@ -299,7 +302,8 @@ void CGrenadeLauncher::LaunchGrenade(CStateManager& mgr) {
return;
}
const auto& anim = animData->GetCharacterInfo().GetPASDatabase().FindBestAnimation(CPASAnimParmData{23}, -1);
const auto& anim = animData->GetCharacterInfo().GetPASDatabase().FindBestAnimation(
CPASAnimParmData{pas::EAnimationState::AdditiveFlinch}, -1);
if (anim.first > 0.f) {
animData->AddAdditiveAnimation(anim.second, 1.f, false, true);
const zeus::CVector3f origin =

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

@ -298,7 +298,8 @@ CRidley::CRidley(TUniqueId uid, std::string_view name, const CEntityInfo& info,
}
xae4_ = GetModelData()->GetScale().x() *
GetAnimationDistance(CPASAnimParmData(7, CPASAnimParm::FromEnum(4), CPASAnimParm::FromEnum(3)));
GetAnimationDistance(CPASAnimParmData(pas::EAnimationState::MeleeAttack, CPASAnimParm::FromEnum(4),
CPASAnimParm::FromEnum(3)));
x460_knockBackController.SetAnimationStateRange(EKnockBackAnimationState::Flinch, EKnockBackAnimationState::Flinch);
x460_knockBackController.SetEnableBurn(false);
x460_knockBackController.SetEnableFreeze(false);

10
Runtime/MP1/World/CSpacePirate.cpp
View File

@ -416,10 +416,10 @@ CSpacePirate::CSpacePirate(TUniqueId uid, std::string_view name, const CEntityIn
if (!x634_29_onlyAttackInRange) {
x7a4_intoJumpDist =
GetAnimationDistance(CPASAnimParmData(13, CPASAnimParm::FromEnum(0), CPASAnimParm::FromEnum(0)));
x848_dodgeDist = GetAnimationDistance(CPASAnimParmData(3, CPASAnimParm::FromEnum(3), CPASAnimParm::FromEnum(1)));
GetAnimationDistance(CPASAnimParmData(pas::EAnimationState::Jump, CPASAnimParm::FromEnum(0), CPASAnimParm::FromEnum(0)));
x848_dodgeDist = GetAnimationDistance(CPASAnimParmData(pas::EAnimationState::Step, CPASAnimParm::FromEnum(3), CPASAnimParm::FromEnum(1)));
x84c_breakDodgeDist =
GetAnimationDistance(CPASAnimParmData(3, CPASAnimParm::FromEnum(3), CPASAnimParm::FromEnum(2)));
GetAnimationDistance(CPASAnimParmData(pas::EAnimationState::Step, CPASAnimParm::FromEnum(3), CPASAnimParm::FromEnum(2)));
} else {
x450_bodyController->BodyStateInfo().SetLocoAnimChangeAtEndOfAnimOnly(true);
}
@ -588,7 +588,7 @@ bool CSpacePirate::FireProjectile(float dt, CStateManager& mgr) {
}
if (ret) {
const auto bestAnim = x450_bodyController->GetPASDatabase().FindBestAnimation(
CPASAnimParmData{24, CPASAnimParm::FromEnum(2)}, *mgr.GetActiveRandom(), -1);
CPASAnimParmData{pas::EAnimationState::AdditiveReaction, CPASAnimParm::FromEnum(2)}, *mgr.GetActiveRandom(), -1);
if (bestAnim.first > 0.f) {
x64_modelData->GetAnimationData()->AddAdditiveAnimation(bestAnim.second, 1.f, false, true);
}
@ -1847,7 +1847,7 @@ void CSpacePirate::Taunt(CStateManager& mgr, EStateMsg msg, float dt) {
bool withOtherPirate = true;
if (x634_27_melee) {
const auto bestAnim = x450_bodyController->GetPASDatabase().FindBestAnimation(
CPASAnimParmData{16, CPASAnimParm::FromEnum(2)}, *mgr.GetActiveRandom(), -1);
CPASAnimParmData{pas::EAnimationState::Taunt, CPASAnimParm::FromEnum(2)}, *mgr.GetActiveRandom(), -1);
if (bestAnim.first > 0.f) {
withOtherPirate = false;
x760_taunt = pas::ETauntType::Two;

3
Runtime/Weapon/CGSComboFire.cpp
View File

@ -46,7 +46,8 @@ s32 CGSComboFire::SetAnim(CAnimData& data, s32 gunId, s32 loopState, CStateManag
useLoopState = loopState;
x10_25_idle = false;
const CPASDatabase& pas = data.GetCharacterInfo().GetPASDatabase();
CPASAnimParmData parms(4, CPASAnimParm::FromInt32(gunId), CPASAnimParm::FromEnum(useLoopState));
CPASAnimParmData parms(pas::EAnimationState::Death, CPASAnimParm::FromInt32(gunId),
CPASAnimParm::FromEnum(useLoopState));
auto anim = pas.FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
x10_24_over = false;
xc_gunId = gunId;

6
Runtime/Weapon/CGSFidget.cpp
View File

@ -12,10 +12,10 @@ bool CGSFidget::Update(CAnimData& data, float dt, CStateManager& mgr) {
s32 CGSFidget::SetAnim(CAnimData& data, s32 type, s32 gunId, s32 animSet, CStateManager& mgr) {
const CPASDatabase& pas = data.GetCharacterInfo().GetPASDatabase();
CPASAnimParmData parms(1, CPASAnimParm::FromEnum(type), CPASAnimParm::FromInt32(gunId),
CPASAnimParmData parms(pas::EAnimationState::Getup, CPASAnimParm::FromEnum(type), CPASAnimParm::FromInt32(gunId),
CPASAnimParm::FromInt32(animSet));
auto anim = pas.FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
bool loop = pas.GetAnimState(1)->GetAnimParmData(anim.second, 3).GetBoolValue();
bool loop = pas.GetAnimState(pas::EAnimationState::Getup)->GetAnimParmData(anim.second, 3).GetBoolValue();
x14_gunId = gunId;
x18_animSet = animSet;
if (anim.second != -1) {
@ -28,7 +28,7 @@ s32 CGSFidget::SetAnim(CAnimData& data, s32 type, s32 gunId, s32 animSet, CState
}
void CGSFidget::LoadAnimAsync(CAnimData& data, s32 type, s32 gunId, s32 animSet, CStateManager& mgr) {
CPASAnimParmData parms(1, CPASAnimParm::FromEnum(type), CPASAnimParm::FromInt32(gunId),
CPASAnimParmData parms(pas::EAnimationState::Getup, CPASAnimParm::FromEnum(type), CPASAnimParm::FromInt32(gunId),
CPASAnimParm::FromInt32(animSet));
auto anim = data.GetCharacterInfo().GetPASDatabase().FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
if (anim.second != -1)

4
Runtime/Weapon/CGSFreeLook.cpp
View File

@ -36,11 +36,11 @@ s32 CGSFreeLook::SetAnim(CAnimData& data, s32 gunId, s32 setId, s32 loopState, C
useLoopState = loopState;
x14_idle = false;
const CPASDatabase& pas = data.GetCharacterInfo().GetPASDatabase();
CPASAnimParmData parms(3, CPASAnimParm::FromInt32(gunId), CPASAnimParm::FromInt32(setId),
CPASAnimParmData parms(pas::EAnimationState::Step, CPASAnimParm::FromInt32(gunId), CPASAnimParm::FromInt32(setId),
CPASAnimParm::FromEnum(useLoopState));
auto anim = pas.FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
xc_gunId = gunId;
x10_setId = pas.GetAnimState(3)->GetAnimParmData(anim.second, 1).GetInt32Value();
x10_setId = pas.GetAnimState(pas::EAnimationState::Step)->GetAnimParmData(anim.second, 1).GetInt32Value();
x8_loopState = useLoopState;
if (delay != 0.f) {
x0_delay = delay;

10
Runtime/Weapon/CGunController.cpp
View File

@ -48,8 +48,9 @@ void CGunController::EnterStruck(CStateManager& mgr, float angle, bool bigStrike
}
const CPASDatabase& pasDatabase = x0_modelData.GetAnimationData()->GetCharacterInfo().GetPASDatabase();
CPASAnimParmData parms(2, CPASAnimParm::FromInt32(x4_freeLook.GetGunId()), CPASAnimParm::FromReal32(angle),
CPASAnimParm::FromBool(bigStrike), CPASAnimParm::FromBool(b2));
CPASAnimParmData parms(pas::EAnimationState::LieOnGround, CPASAnimParm::FromInt32(x4_freeLook.GetGunId()),
CPASAnimParm::FromReal32(angle), CPASAnimParm::FromBool(bigStrike),
CPASAnimParm::FromBool(b2));
std::pair<float, s32> anim = pasDatabase.FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
x0_modelData.GetAnimationData()->EnableLooping(false);
CAnimPlaybackParms aparms(anim.second, -1, 1.f, true);
@ -75,7 +76,7 @@ void CGunController::EnterIdle(CStateManager& mgr) {
}
const CPASDatabase& pasDatabase = x0_modelData.GetAnimationData()->GetCharacterInfo().GetPASDatabase();
CPASAnimParmData parms(5, parm);
CPASAnimParmData parms(pas::EAnimationState::Locomotion, parm);
std::pair<float, s32> anim = pasDatabase.FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
x0_modelData.GetAnimationData()->EnableLooping(false);
CAnimPlaybackParms aparms(anim.second, -1, 1.f, true);
@ -161,7 +162,8 @@ void CGunController::ReturnToDefault(CStateManager& mgr, float dt, bool setState
void CGunController::ReturnToBasePosition(CStateManager& mgr, float) {
const CPASDatabase& pasDatabase = x0_modelData.GetAnimationData()->GetCharacterInfo().GetPASDatabase();
std::pair<float, s32> anim = pasDatabase.FindBestAnimation(CPASAnimParmData(6), *mgr.GetActiveRandom(), -1);
std::pair<float, s32> anim =
pasDatabase.FindBestAnimation(CPASAnimParmData(pas::EAnimationState::KnockBack), *mgr.GetActiveRandom(), -1);
x0_modelData.GetAnimationData()->EnableLooping(false);
CAnimPlaybackParms parms(anim.second, -1, 1.f, true);
x0_modelData.GetAnimationData()->SetAnimation(parms, false);

6
Runtime/Weapon/CGunMotion.cpp
View File

@ -22,19 +22,19 @@ bool CGunMotion::PlayPasAnim(SamusGun::EAnimationState state, CStateManager& mgr
bool loop = true;
switch (state) {
case SamusGun::EAnimationState::Wander: {
CPASAnimParmData parms((s32(state)));
CPASAnimParmData parms((pas::EAnimationState(state)));
auto anim = pas.FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
animId = anim.second;
break;
}
case SamusGun::EAnimationState::Idle: {
CPASAnimParmData parms(s32(state), CPASAnimParm::FromEnum(0));
CPASAnimParmData parms(pas::EAnimationState(state), CPASAnimParm::FromEnum(0));
auto anim = pas.FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
animId = anim.second;
break;
}
case SamusGun::EAnimationState::Struck: {
CPASAnimParmData parms(s32(state), CPASAnimParm::FromInt32(0), CPASAnimParm::FromReal32(angle),
CPASAnimParmData parms(pas::EAnimationState(state), CPASAnimParm::FromInt32(0), CPASAnimParm::FromReal32(angle),
CPASAnimParm::FromBool(bigStrike), CPASAnimParm::FromBool(false));
auto anim = pas.FindBestAnimation(parms, *mgr.GetActiveRandom(), -1);
animId = anim.second;

4
Runtime/World/CKnockBackController.cpp
View File

@ -498,8 +498,8 @@ void CKnockBackController::DoKnockBackAnimation(const zeus::CVector3f& backVec,
break;
}
case EKnockBackAnimationState::Flinch: {
const std::pair<float, s32> bestAnim =
parent.GetBodyController()->GetPASDatabase().FindBestAnimation(CPASAnimParmData(23), *mgr.GetActiveRandom(), -1);
const std::pair<float, s32> bestAnim = parent.GetBodyController()->GetPASDatabase().FindBestAnimation(
CPASAnimParmData(pas::EAnimationState::AdditiveFlinch), *mgr.GetActiveRandom(), -1);
if (bestAnim.first > 0.f) {
parent.GetModelData()->GetAnimationData()->AddAdditiveAnimation(bestAnim.second, 1.f, false, true);
x64_flinchRemTime =

4
Runtime/World/CPatterned.cpp
View File

@ -954,8 +954,8 @@ void CPatterned::BuildBodyController(EBodyType bodyType) {
return;
x450_bodyController = std::make_unique<CBodyController>(*this, x3b8_turnSpeed, bodyType);
auto anim =
x450_bodyController->GetPASDatabase().FindBestAnimation(CPASAnimParmData(24, CPASAnimParm::FromEnum(0)), -1);
auto anim = x450_bodyController->GetPASDatabase().FindBestAnimation(
CPASAnimParmData(pas::EAnimationState::AdditiveReaction, CPASAnimParm::FromEnum(0)), -1);
x460_knockBackController.x81_26_enableShock = anim.first > 0.f;
}

11
Runtime/World/CScriptGunTurret.cpp
View File

@ -422,8 +422,9 @@ void CScriptGunTurret::LaunchProjectile(CStateManager& mgr) {
mgr.AddObject(proj);
auto pair =
x64_modelData->GetAnimationData()->GetCharacterInfo().GetPASDatabase().FindBestAnimation(
CPASAnimParmData(18, CPASAnimParm::FromEnum(1), CPASAnimParm::FromReal32(90.f),
CPASAnimParm::FromEnum(skStateToLocoTypeLookup[size_t(x520_state)])), -1);
CPASAnimParmData(pas::EAnimationState::ProjectileAttack, CPASAnimParm::FromEnum(1),
CPASAnimParm::FromReal32(90.f),
CPASAnimParm::FromEnum(skStateToLocoTypeLookup[size_t(x520_state)])), -1);
if (pair.first > 0.f) {
x64_modelData->EnableLooping(false);
x64_modelData->GetAnimationData()->SetAnimation(CAnimPlaybackParms(pair.second, -1, 1.f, true), false);
@ -433,7 +434,7 @@ void CScriptGunTurret::LaunchProjectile(CStateManager& mgr) {
void CScriptGunTurret::PlayAdditiveFlinchAnimation(CStateManager& mgr) {
auto pair = GetModelData()->GetAnimationData()->GetCharacterInfo().GetPASDatabase().FindBestAnimation(
CPASAnimParmData(23), *mgr.GetActiveRandom(), -1);
CPASAnimParmData(pas::EAnimationState::AdditiveFlinch), *mgr.GetActiveRandom(), -1);
if (pair.first > 0.f)
GetModelData()->GetAnimationData()->AddAdditiveAnimation(pair.second, 1.f, false, true);
}
@ -695,7 +696,7 @@ void CScriptGunTurret::UpdateTurretAnimation() {
return;
}
const auto parmData = CPASAnimParmData(5, CPASAnimParm::FromEnum(0),
const auto parmData = CPASAnimParmData(pas::EAnimationState::Locomotion, CPASAnimParm::FromEnum(0),
CPASAnimParm::FromEnum(skStateToLocoTypeLookup[size_t(x520_state)]));
const auto pair =
GetModelData()->GetAnimationData()->GetCharacterInfo().GetPASDatabase().FindBestAnimation(parmData, -1);
@ -1150,7 +1151,7 @@ void CScriptGunTurret::PlayAdditiveChargingAnimation(CStateManager& mgr) {
return;
auto pair = GetModelData()->GetAnimationData()->GetCharacterInfo().GetPASDatabase().FindBestAnimation(
CPASAnimParmData(24, CPASAnimParm::FromEnum(2)), *mgr.GetActiveRandom(), -1);
CPASAnimParmData(pas::EAnimationState::AdditiveReaction, CPASAnimParm::FromEnum(2)), *mgr.GetActiveRandom(), -1);
if (pair.first > 0.f) {
x55c_additiveChargeAnim = pair.second;
GetModelData()->GetAnimationData()->AddAdditiveAnimation(pair.second, 1.f, true, false);