readme

Hitbox.h

@@ -0,0 +1,61 @@
+#ifndef HITBOX_CLASS
+#define HITBOX_CLASS
+
+#include <functional>
+#include <unordered_map>
+#include <vector>
+
+#include "t.h"
+
+class Character;
+class Animation;
+struct Ability;
+struct HitboxDebugLine;
+
+// A box that hurts whatever character it touches, for the frame it's added in. Attacks put these out
+// while they can connect, HitboxSystem works out what they hit.
+struct Hitbox {
+    Character* owner = nullptr;      // never hits whoever put it out
+    unsigned int swing = 0;          // hitboxes sharing a nonzero swing hit each character once between them, over every frame
+    t box;                           // in the world, its scale is its size
+    float damage = 0.0f;
+    float knockback = 0.0f;          // m/s away from the owner
+    float knockbackUp = 0.0f;        // m/s upward
+    float stun = 0.0f;               // real seconds whoever it hits can't do anything
+    float knockdown = 0.0f;          // real seconds whoever it hits is knocked down for, 0 doesn't
+    bool hitsKnockedDown = false;    // can hit characters that are knocked down, which nothing else can
+    Animation* killAnimation = nullptr;   // played on whoever it kills, its Camera bone filming it, see Ability
+    const Ability* killAbility = nullptr; // the ability it's from, for the sounds that go with killAnimation
+    std::function<void(Character& target)> onHit;   // called on top of the damage for each character it hits, if set
+};
+
+// Every hitbox in the game goes through here. Each frame they're added, checked against every character's
+// body (its hurtbox), and cleared. It also draws them all for the hitbox debug view.
+class HitboxSystem {
+public:
+    using HitHandler = std::function<void(const Hitbox& hitbox, Character& target)>;
+
+    // For this frame only
+    void Add(const Hitbox& hitbox) { pending.push_back(hitbox); }
+
+    // Checks this frame's hitboxes against every living character, calling onHit for each new hit, then clears them.
+    // dt is real time, for how long the debug view keeps showing them.
+    void Resolve(const std::vector<Character*>& characters, const HitHandler& onHit, float dt);
+
+    // Hurtboxes in green, hitboxes in red, the ones that hit something in yellow. Hitboxes linger a moment
+    // after they're gone, dimming, so ones that only last a few frames can still be seen.
+    void AppendDebugLines(const std::vector<Character*>& characters, std::vector<HitboxDebugLine>& lines) const;
+
+private:
+    struct Shown {
+        t box;
+        bool landed = false;
+        float timeLeft = 0.0f;
+    };
+
+    std::vector<Hitbox> pending;
+    std::unordered_map<unsigned int, std::vector<const Character*>> hitBySwing;   // swings still going, and who they've hit
+    std::vector<Shown> shown;
+};
+
+#endif