added the readme

Character.h

@@ -0,0 +1,128 @@
+#ifndef CHARACTER_CLASS
+#define CHARACTER_CLASS
+#include <vector>
+#include <string>
+#include <functional>
+#include <algorithm>
+#include "t.h"
+#include "Rig.h"
+#include "Object.h"
+#include "Animator.h"
+
+class CharacterBody;
+class BodyComponent;
+
+class Action {
+public:
+    std::string Name;
+    std::function<void(CharacterBody*, BodyComponent*)> FunctionPointer;
+};
+
+class InputAction {
+public:
+    std::string BodyComponentName;
+    std::string ActionName;
+};
+
+class BodyComponent {
+public:
+    std::string    name;
+    BodyComponent* ParentComponent = nullptr;
+    std::vector<Action*> Actions;
+};
+
+class CharacterBody : public t_package {
+public:
+    int  Health = 100;
+    Rig* rig = nullptr;
+
+    std::vector<Animator*> animators;
+    Animator* animator = nullptr;  // back-compat: base animator at weight 0
+
+    std::vector<BodyComponent*> components;
+    BodyComponent* RootComponent = nullptr;
+
+    CharacterBody() {
+        animator = AddAnimator(0);
+        animator->blendWeight = 1.0f;  // base always fully visible
+    }
+
+    Animator* AddAnimator(int weight) {
+        Animator* a = new Animator();
+        a->weight = weight;
+        if (rig) a->SetRig(rig);
+        animators.push_back(a);
+        std::sort(animators.begin(), animators.end(),
+            [](Animator* a, Animator* b) { return a->weight < b->weight; });
+        return a;
+    }
+
+    // Returns weighted blend of all playing animators.
+    // Base (weight 0) is always the foundation; higher-weight animators
+    // blend in on top based on their blendWeight (0?1).
+    std::vector<glm::mat4> GetBlendedBoneMatrices() const {
+        // Start from the base animator
+        std::vector<glm::mat4> result = animator->GetFinalBoneMatrices();
+        const int count = (int)result.size();
+
+        // Blend each higher-priority playing animator on top
+        for (int i = 1; i < (int)animators.size(); i++) {
+            Animator* a = animators[i];
+            if (!a->isPlaying || !a->m_CurrentAnimation || a->blendWeight <= 0.0f) continue;
+            const auto& matrices = a->GetFinalBoneMatrices();
+            for (int j = 0; j < count && j < (int)matrices.size(); j++)
+                result[j] = glm::mix(result[j], matrices[j], a->blendWeight);
+        }
+        return result;
+    }
+
+    // Returns the highest-weight playing animator (for back-compat)
+    Animator* GetActiveAnimator() const {
+        for (int i = (int)animators.size() - 1; i >= 0; i--)
+            if (animators[i]->isPlaying && animators[i]->m_CurrentAnimation)
+                return animators[i];
+        return animator;
+    }
+
+    void SetRig(Rig* r) {
+        rig = r;
+        for (Animator* a : animators)
+            a->SetRig(r);
+    }
+
+    void SetAnimation(Animation* anim) {
+        animator->SetAnimation(anim);
+        animator->PlayAnimation();
+        animator->blendWeight = 1.0f;  // base never blends — always instant
+    }
+
+    void LoadAnimation(Animation* anim) { SetAnimation(anim); }
+
+    void Step(float dt) {
+        for (Animator* a : animators)
+            a->Step(dt);
+    }
+
+    BodyComponent* GetComponentOfName(std::string name);
+    void ExecuteAction(InputAction* action);
+};
+
+class CharacterMind {
+public:
+    InputAction* ProduceAction();
+};
+
+class Character : public Object, public Renderable {
+public:
+    CharacterMind* mind = nullptr;
+    CharacterBody* body = nullptr;
+
+    Character();
+    void Render(Shader& shader) override;
+
+    void Step(float dt) {
+        body->Step(dt);
+    }
+};
+
+#endif