CPASDatabase imps

Runtime/Character/CCharacterInfo.hpp

@@ -41,6 +41,7 @@ private:
 public:
     CCharacterInfo(CInputStream& in);
 
+    const std::string& GetCharacterName() const { return x4_name; }
     ResId GetModelId() const {return x14_cmdl;}
     ResId GetSkinRulesId() const {return x18_cskr;}
     ResId GetCharLayoutInfoId() const {return x1c_cinf;}

Runtime/Character/CPASAnimParm.hpp

@@ -32,6 +32,7 @@ private:
 public:
     CPASAnimParm(UParmValue val, EParmType tp) : x4_type(tp), x0_value(val) {}
 
+    EParmType GetParameterType() const { return x4_type; }
     s32 GetEnumValue() const {return x0_value.m_int;}
     bool GetBoolValue() const {return x0_value.m_bool;}
     float GetReal32Value() const {return x0_value.m_float;}

Runtime/Character/CPASAnimParmData.cpp

@@ -23,7 +23,7 @@ s32 CPASAnimParmData::GetStateId()
     return x0_stateId;
 }
 
-const std::vector<CPASAnimParm>& CPASAnimParmData::GetAnimParmData() const
+const rstl::reserved_vector<CPASAnimParm, 8>& CPASAnimParmData::GetAnimParmData() const
 {
     return x4_parms;
 }

Runtime/Character/CPASAnimParmData.hpp

@@ -14,11 +14,11 @@ public:
     {};
 
     CPASAnimParmData(s32 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);
+                     const CPASAnimParm& parm4, const CPASAnimParm& parm5, const CPASAnimParm& parm6,
+                     const CPASAnimParm& parm7, const CPASAnimParm& parm8);
 
     s32 GetStateId();
-    const std::vector<CPASAnimParm>& GetAnimParmData() const;
+    const rstl::reserved_vector<CPASAnimParm,8>& GetAnimParmData() const;
 };
 }
 

Runtime/Character/CPASAnimState.cpp

@@ -1,5 +1,10 @@
 #include "CPASAnimState.hpp"
 #include "CPASAnimParmData.hpp"
+#include "CRandom16.hpp"
+#include "zeus/Math.hpp"
+#include <math.h>
+#include <float.h>
+
 namespace urde
 {
 
@@ -11,7 +16,7 @@ CPASAnimState::CPASAnimState(CInputStream& in)
 
     x4_parms.reserve(parmCount);
     x14_anims.reserve(animCount);
-    x24_.reserve(animCount);
+    x24_selectionCache.reserve(animCount);
 
     for (u32 i=0 ; i<parmCount ; ++i)
         x4_parms.emplace_back(in);
@@ -23,7 +28,7 @@ CPASAnimState::CPASAnimState(CInputStream& in)
         for (const CPASParmInfo& parm : x4_parms)
         {
             CPASAnimParm::UParmValue val = {};
-            switch (parm.GetType())
+            switch (parm.GetParameterType())
             {
             case CPASAnimParm::EParmType::Int32:
                 val.m_int = in.readInt32Big();
@@ -51,14 +56,194 @@ CPASAnimState::CPASAnimState(CInputStream& in)
     }
 }
 
-const CPASAnimParmData& CPASAnimState::GetAnimParmData(s32, u32) const
+CPASAnimParm CPASAnimState::GetAnimParmData(s32 idx, u32 id) const
 {
-    static const CPASAnimParmData badData;
-    return badData;
+    auto search = std::lower_bound(x14_anims.begin(), x14_anims.end(), id,
+                                   [](const CPASAnimInfo& item, const u32& testId) ->
+                                   bool {return item.GetAnimId() < testId;});
+    if (search == x14_anims.end())
+        return CPASAnimParm::NoParameter();
+
+    CPASParmInfo parm = x4_parms.at(idx);
+    return (*search).GetAnimParmData(idx, parm.GetParameterType());
 }
 
-std::pair<float, s32> CPASAnimState::FindBestAnimation(const rstl::reserved_vector<CPASAnimParm, 8>&, CRandom16&, s32) const
+s32 CPASAnimState::PickRandomAnimation(CRandom16& rand) const
 {
-    return {};
+    if (x24_selectionCache.size() == 1)
+        return x24_selectionCache[0];
+
+    if (x24_selectionCache.size() > 1)
+    {
+        u32 idx = u32(floor(rand.Float()));
+        if (idx == x24_selectionCache.size())
+            idx--;
+
+        return x24_selectionCache[idx];
+    }
+
+    return -1;
+}
+
+std::pair<float, s32> CPASAnimState::FindBestAnimation(const rstl::reserved_vector<CPASAnimParm, 8>& parms,
+                                                       CRandom16& rand, s32 anim) const
+{
+    const_cast<std::vector<s32>*>(&x24_selectionCache)->clear();
+    float weight = -1.f;
+
+    if (x14_anims.size() != 0)
+    {
+        for (const CPASAnimInfo& info : x14_anims)
+        {
+            float calcWeight = 1.f;
+            if (x4_parms.size() > 0)
+                calcWeight = 0.f;
+
+            u32 r23 = 0 ;
+            u32 i = 0;
+
+            for (; i<x4_parms.size() ; ++i)
+            {
+                CPASAnimParm::UParmValue val = info.GetAnimParmValue(i);
+                const CPASParmInfo& parmInfo = x4_parms[i];
+                float parmWeight = parmInfo.GetParameterWeight();
+
+                float computedWeight;
+                if (parmInfo.GetWeightFunction() == CPASParmInfo::EWeightFunction::AngularPercent)
+                    computedWeight = ComputeAngularPercentErrorWeight(i, parms[i], val);
+                else if (parmInfo.GetWeightFunction() == CPASParmInfo::EWeightFunction::ExactMatch)
+                    computedWeight = ComputeExactMatchWeight(i, parms[i], val);
+                else if (parmInfo.GetWeightFunction() == CPASParmInfo::EWeightFunction::PercentError)
+                    computedWeight = ComputePercentErrorWeight(i, parms[i], val);
+                else if (parmInfo.GetWeightFunction() == CPASParmInfo::EWeightFunction::Three)
+                    r23++;
+
+                calcWeight = parmWeight * calcWeight + computedWeight;
+            }
+
+            if (r23 == x4_parms.size())
+                calcWeight = 1.0f;
+
+            if (calcWeight < weight)
+                continue;
+
+            auto search = std::find(x24_selectionCache.cbegin(), x24_selectionCache.cend(),
+                                    info.GetAnimId());
+
+            if (search == x24_selectionCache.cend())
+                const_cast<std::vector<s32>*>(&x24_selectionCache)->push_back(info.GetAnimId());
+        }
+    }
+    return {weight, PickRandomAnimation(rand)};
+}
+
+float CPASAnimState::ComputeExactMatchWeight(u32, const CPASAnimParm& parm, CPASAnimParm::UParmValue parmVal) const
+{
+    if (parm.GetParameterType() == CPASAnimParm::EParmType::Int32)
+    {
+        return (parm.GetInt32Value() == parmVal.m_int ? 1.f : 0.f);
+    }
+    else if (parm.GetParameterType() == CPASAnimParm::EParmType::UInt32)
+    {
+        return (parm.GetUint32Value() == parmVal.m_uint ? 1.f : 0.f);
+    }
+    else if (parm.GetParameterType() == CPASAnimParm::EParmType::Float)
+    {
+        return ((parmVal.m_float - parm.GetReal32Value()) < FLT_EPSILON ? 1.f : 0.f);
+    }
+    else if (parm.GetParameterType() == CPASAnimParm::EParmType::Bool)
+    {
+        return (parm.GetBoolValue() == parmVal.m_bool ? 1.f : 0.f);
+    }
+    else if (parm.GetParameterType() == CPASAnimParm::EParmType::Enum)
+    {
+        return (parm.GetEnumValue() == parmVal.m_int ? 1.f : 0.f);
+    }
+
+    return 0.f;
+}
+
+float CPASAnimState::ComputePercentErrorWeight(u32 idx, const CPASAnimParm& parm, CPASAnimParm::UParmValue parmVal) const
+{
+    float range = 0.f;
+    float val = 0.f;
+
+    if (parm.GetParameterType() == CPASAnimParm::EParmType::Int32)
+    {
+        const CPASParmInfo& info = x4_parms[idx];
+        range = float(info.GetWeightMinValue().m_int - info.GetWeightMaxValue().m_int);
+        val = float(fabs(parmVal.m_int - parm.GetInt32Value()));
+    }
+    else if (parm.GetParameterType() == CPASAnimParm::EParmType::UInt32)
+    {
+        const CPASParmInfo& info = x4_parms[idx];
+        range = float(info.GetWeightMinValue().m_uint - info.GetWeightMaxValue().m_uint);
+        val = float(fabs(parmVal.m_uint - parm.GetUint32Value()));
+    }
+    else if (parm.GetParameterType() == CPASAnimParm::EParmType::Float)
+    {
+        const CPASParmInfo& info = x4_parms[idx];
+        range = float(info.GetWeightMinValue().m_float - info.GetWeightMaxValue().m_float);
+        val = float(fabs(parmVal.m_float - parm.GetReal32Value()));
+    }
+    else if (parm.GetParameterType() == CPASAnimParm::EParmType::Bool)
+    {
+        val = parm.GetBoolValue() ? 1.f : 0.f;
+    }
+    else if (parm.GetParameterType() == CPASAnimParm::EParmType::Enum)
+    {
+        const CPASParmInfo& info = x4_parms[idx];
+        range = float(info.GetWeightMinValue().m_float - info.GetWeightMaxValue().m_float);
+        val = float(fabs(parmVal.m_float - parm.GetReal32Value()));
+    }
+
+    if (range > FLT_EPSILON)
+        return (val / range) - 1.0f;
+
+    return (val < FLT_EPSILON ? 1.f : 0.f);
+}
+
+float CPASAnimState::ComputeAngularPercentErrorWeight(u32 idx, const CPASAnimParm& parm, CPASAnimParm::UParmValue parmVal) const
+{
+    float range = 0.f;
+    float val = 0.f;
+
+    if (parm.GetParameterType() == CPASAnimParm::EParmType::Int32)
+    {
+        const CPASParmInfo& info = x4_parms[idx];
+        range = float(info.GetWeightMinValue().m_int - info.GetWeightMaxValue().m_int);
+        val = float(fabs(parmVal.m_int - parm.GetInt32Value()));
+    }
+    else if (parm.GetParameterType() == CPASAnimParm::EParmType::UInt32)
+    {
+        const CPASParmInfo& info = x4_parms[idx];
+        range = float(info.GetWeightMinValue().m_uint - info.GetWeightMaxValue().m_uint);
+        val = float(fabs(parmVal.m_uint - parm.GetUint32Value()));
+    }
+    else if (parm.GetParameterType() == CPASAnimParm::EParmType::Float)
+    {
+        const CPASParmInfo& info = x4_parms[idx];
+        range = float(info.GetWeightMinValue().m_float - info.GetWeightMaxValue().m_float);
+        val = float(fabs(parmVal.m_float - parm.GetReal32Value()));
+    }
+    else if (parm.GetParameterType() == CPASAnimParm::EParmType::Bool)
+    {
+        val = parm.GetBoolValue() ? 1.f : 0.f;
+    }
+    else if (parm.GetParameterType() == CPASAnimParm::EParmType::Enum)
+    {
+        const CPASParmInfo& info = x4_parms[idx];
+        range = float(info.GetWeightMinValue().m_float - info.GetWeightMaxValue().m_float);
+        val = float(fabs(parmVal.m_float - parm.GetReal32Value()));
+    }
+
+    if (range > FLT_EPSILON)
+    {
+        float mid = 0.5f * range;
+        float offset = 1.f - ((val > mid ? range - val : val) / mid);
+        return zeus::clamp(0.f, offset, 1.f);
+    }
+
+    return (val >= FLT_EPSILON ? 0.f : 1.f);
 }
 }

Runtime/Character/CPASAnimState.hpp

@@ -14,12 +14,13 @@ class CPASAnimState
     s32 x0_id;
     std::vector<CPASParmInfo> x4_parms;
     std::vector<CPASAnimInfo> x14_anims;
-    std::vector<u32> x24_;
+    std::vector<s32> x24_selectionCache;
 public:
     CPASAnimState(CInputStream& in);
     s32 GetStateId() const {return x0_id;}
     s32 GetNumAnims() const { return x14_anims.size(); }
-    const CPASAnimParmData& GetAnimParmData(s32, u32) const;
+    CPASAnimParm GetAnimParmData(s32, u32) const;
+    s32 PickRandomAnimation(CRandom16 &rand) const;
     std::pair<float,s32> FindBestAnimation(const rstl::reserved_vector<CPASAnimParm,8>&, CRandom16&, s32) const;
     float ComputeExactMatchWeight(u32, const CPASAnimParm&, CPASAnimParm::UParmValue) const;
     float ComputePercentErrorWeight(u32, const CPASAnimParm&, CPASAnimParm::UParmValue) const;

Runtime/Character/CPASDatabase.cpp

@@ -1,4 +1,6 @@
 #include "CPASDatabase.hpp"
+#include "CPASAnimParmData.hpp"
+#include "CRandom16.hpp"
 
 namespace urde
 {
@@ -27,4 +29,21 @@ CPASDatabase::CPASDatabase(CInputStream& in)
         SetDefaultState(defaultState);
 }
 
+std::pair<float, s32> CPASDatabase::FindBestAnimation(const CPASAnimParmData& data, s32 id) const
+{
+    CRandom16 rnd(4660);
+    return FindBestAnimation(data, rnd, id);
+}
+
+std::pair<float, s32> CPASDatabase::FindBestAnimation(const CPASAnimParmData& data, CRandom16& rand, s32 id) const
+{
+    auto it = std::lower_bound(x0_states.cbegin(), x0_states.cend(), id,
+    [](const CPASAnimState& item, const int& test) -> bool {return item.GetStateId() < test;});
+
+    if (it == x0_states.cend())
+        return {0.f, -1};
+
+    return (*it).FindBestAnimation(data.GetAnimParmData(), rand, id);
+}
+
 }

Runtime/Character/CPASDatabase.hpp

@@ -18,8 +18,8 @@ class CPASDatabase
 public:
     CPASDatabase(CInputStream& in);
 
-    void FindBestAnimation(const CPASAnimParmData&, int) const;
-    void FindBestAnimation(const CPASAnimParmData&, CRandom16&, int) const;
+    std::pair<float,s32> FindBestAnimation(const CPASAnimParmData&, s32) const;
+    std::pair<float,s32> FindBestAnimation(const CPASAnimParmData&, CRandom16&, s32) const;
     s32 GetDefaultState() const { return x10_defaultState; }
     s32 GetNumAnimStates() const { return x0_states.size(); }
     const CPASAnimState* GetAnimState(s32 id) const

Runtime/Character/CPASParmInfo.cpp

@@ -5,33 +5,33 @@ namespace urde
 
 CPASParmInfo::CPASParmInfo(CInputStream& in)
 {
-    xc_val1.m_int = 0;
-    x10_val2.m_int = 0;
+    xc_min.m_int = 0;
+    x10_max.m_int = 0;
     x0_type = CPASAnimParm::EParmType(in.readUint32Big());
-    x4_unk1 = in.readUint32Big();
-    x8_unk2 = in.readFloatBig();
+    x4_weightFunction = EWeightFunction(in.readUint32Big());
+    x8_weight = in.readFloatBig();
 
     switch (x0_type)
     {
     case CPASAnimParm::EParmType::Int32:
-        xc_val1.m_int = in.readInt32Big();
-        x10_val2.m_int = in.readInt32Big();
+        xc_min.m_int = in.readInt32Big();
+        x10_max.m_int = in.readInt32Big();
         break;
     case CPASAnimParm::EParmType::UInt32:
-        xc_val1.m_uint = in.readUint32Big();
-        x10_val2.m_uint = in.readUint32Big();
+        xc_min.m_uint = in.readUint32Big();
+        x10_max.m_uint = in.readUint32Big();
         break;
     case CPASAnimParm::EParmType::Float:
-        xc_val1.m_float = in.readFloatBig();
-        x10_val2.m_float = in.readFloatBig();
+        xc_min.m_float = in.readFloatBig();
+        x10_max.m_float = in.readFloatBig();
         break;
     case CPASAnimParm::EParmType::Bool:
-        xc_val1.m_bool = in.readBool();
-        x10_val2.m_bool = in.readBool();
+        xc_min.m_bool = in.readBool();
+        x10_max.m_bool = in.readBool();
         break;
     case CPASAnimParm::EParmType::Enum:
-        xc_val1.m_int = in.readInt32Big();
-        x10_val2.m_int = in.readInt32Big();
+        xc_min.m_int = in.readInt32Big();
+        x10_max.m_int = in.readInt32Big();
         break;
     default: break;
     }

Runtime/Character/CPASParmInfo.hpp

@@ -9,14 +9,27 @@ namespace urde
 
 class CPASParmInfo
 {
+public:
+    enum class EWeightFunction
+    {
+        ExactMatch,
+        PercentError,
+        AngularPercent,
+        Three
+    };
+
     CPASAnimParm::EParmType x0_type;
-    u32 x4_unk1;
-    float x8_unk2;
-    CPASAnimParm::UParmValue xc_val1;
-    CPASAnimParm::UParmValue x10_val2;
+    EWeightFunction x4_weightFunction;
+    float x8_weight;
+    CPASAnimParm::UParmValue xc_min;
+    CPASAnimParm::UParmValue x10_max;
 public:
     CPASParmInfo(CInputStream& in);
-    CPASAnimParm::EParmType GetType() const {return x0_type;}
+    CPASAnimParm::EParmType GetParameterType() const {return x0_type;}
+    EWeightFunction GetWeightFunction() const { return x4_weightFunction; }
+    float GetParameterWeight() const { return x8_weight; }
+    CPASAnimParm::UParmValue GetWeightMinValue() const { return xc_min; }
+    CPASAnimParm::UParmValue GetWeightMaxValue() const { return x10_max; }
 };
 
 }

Runtime/Character/CharacterCommon.hpp

@@ -17,8 +17,73 @@ enum class EAnimationState
 {
 };
 
+enum class EHurledType
+{
+
+};
+
 enum class EFallState
 {
+};
+
+enum class EReactionType
+{
+
+};
+
+enum class EAdditiveReactionType
+{
+
+};
+
+enum class EJumpType
+{
+
+};
+
+enum class EStepDirection
+{
+
+};
+
+enum class EStepType
+{
+
+};
+
+enum class ESeverity
+{
+
+};
+
+enum class EGetupType
+{
+
+};
+
+enum class ELoopAttackType
+{
+
+};
+
+enum class EGenerateType
+{
+
+};
+
+enum class ESlideType
+{
+
+};
+
+enum class ETauntType
+{
+
+};
+
+enum class ECoverDirection
+{
+
 };
 }
 
@@ -32,6 +97,7 @@ enum class EBodyStateCmd
 {
 
 };
+
 }
 
 #endif // __URDE_PASTYPES_HPP__