feat(entities): andamiatge del sistema d'entitats (classes, factory, bus, YAML, placeholders, smoke tests)

source/game/entities/hazard.hpp

@@ -0,0 +1,90 @@
+#pragma once
+
+#include "game/entities/entity.hpp"
+
+// Base d'entitats perilloses: al contacte amb el jugador, apliquen dany.
+// De moment `Player` no té HP exposat; l'andamiatge deixa el hook llest
+// (`damage_` + `onPlayerContact` publicant un event `"player_hit"`) perquè
+// la lògica real de vides es cable-je quan s'integri al GameScene.
+class Hazard : public Entity {
+   public:
+    Hazard() { collides_ = true; }
+
+    [[nodiscard]] auto getDamage() const -> int { return damage_; }
+    void setDamage(int d) { damage_ = d; }
+
+   protected:
+    int damage_{1};
+};
+
+// Perill estàtic: sempre al mateix tile. Suport opcional de cicle
+// actiu/inactiu (trampes que oscil·len). Quan `active_=false`, el contacte
+// no fa dany (però la detecció de col·lisió es manté: pot bloquejar o no
+// segons la configuració).
+class StaticHazard : public Hazard {
+   public:
+    StaticHazard() = default;
+
+    void setCycle(float active_s, float inactive_s) {
+        active_duration_ = active_s;
+        inactive_duration_ = inactive_s;
+        has_cycle_ = (active_s > 0.0F) || (inactive_s > 0.0F);
+    }
+
+    void update(float delta_time) override {
+        Entity::update(delta_time);
+        if (!has_cycle_) { return; }
+
+        timer_ += delta_time;
+        const float PERIOD = active_ ? active_duration_ : inactive_duration_;
+        if (timer_ >= PERIOD) {
+            timer_ -= PERIOD;
+            active_ = !active_;
+        }
+    }
+
+    [[nodiscard]] auto isActive() const -> bool { return active_; }
+
+   protected:
+    bool has_cycle_{false};
+    bool active_{true};
+    float active_duration_{0.0F};
+    float inactive_duration_{0.0F};
+    float timer_{0.0F};
+};
+
+// Perill dinàmic: es mou. Velocitat expressada en píxels/segon i una
+// direcció (vec2). Les subclasses decideixen la política de moviment
+// (IA corridor_wanderer, línia recta, etc.) sobreescribint `step(dt)`.
+class DynamicHazard : public Hazard {
+   public:
+    DynamicHazard() = default;
+
+    void setSpeed(float px_per_s) { speed_ = px_per_s; }
+    [[nodiscard]] auto getSpeed() const -> float { return speed_; }
+
+    void setDirection(float dx, float dy) {
+        dir_x_ = dx;
+        dir_y_ = dy;
+    }
+    [[nodiscard]] auto getDirX() const -> float { return dir_x_; }
+    [[nodiscard]] auto getDirY() const -> float { return dir_y_; }
+
+    // Política de moviment per frame. La base desplaça el pixel_rect_
+    // proporcionalment a velocitat i direcció; les subclasses amb IA la
+    // sobreescriuen per triar nova direcció a les interseccions o rebotar.
+    virtual void step(float delta_time) {
+        pixel_rect_.x += dir_x_ * speed_ * delta_time;
+        pixel_rect_.y += dir_y_ * speed_ * delta_time;
+    }
+
+    void update(float delta_time) override {
+        Entity::update(delta_time);
+        step(delta_time);
+    }
+
+   protected:
+    float speed_{0.0F};
+    float dir_x_{0.0F};
+    float dir_y_{0.0F};
+};