afegits diferents enemics

source/game/entities/enemic.cpp

@@ -21,25 +21,53 @@ Enemic::Enemic(SDL_Renderer* renderer)
       drotacio_(0.0f),
       rotacio_(0.0f),
       esta_(false),
-      brightness_(Defaults::Brightness::ENEMIC) {
-    // [NUEVO] Carregar forma compartida des de fitxer
-    forma_ = Graphics::ShapeLoader::load("enemy_pentagon.shp");
-
-    if (!forma_ || !forma_->es_valida()) {
-        std::cerr << "[Enemic] Error: no s'ha pogut carregar enemy_pentagon.shp"
-                  << std::endl;
-    }
+      brightness_(Defaults::Brightness::ENEMIC),
+      tipus_(TipusEnemic::PENTAGON),
+      tracking_timer_(0.0f),
+      ship_position_(nullptr) {
+    // [NUEVO] Forma es carrega a inicialitzar() segons el tipus
+    // Constructor no carrega forma per permetre tipus diferents
 }
 
-void Enemic::inicialitzar() {
-    // Inicialitzar enemic (pentàgon)
-    // Copiat de joc_asteroides.cpp línies 41-54
+void Enemic::inicialitzar(TipusEnemic tipus) {
+    // Guardar tipus
+    tipus_ = tipus;
 
-    // [NUEVO] Ja no cal crear_poligon_regular - la geometria es carrega del
-    // fitxer Només inicialitzem l'estat de la instància
+    // Carregar forma segons el tipus
+    const char* shape_file;
+    float drotacio_min, drotacio_max;
+
+    switch (tipus_) {
+        case TipusEnemic::PENTAGON:
+            shape_file = Defaults::Enemies::Pentagon::SHAPE_FILE;
+            velocitat_ = Defaults::Enemies::Pentagon::VELOCITAT;
+            drotacio_min = Defaults::Enemies::Pentagon::DROTACIO_MIN;
+            drotacio_max = Defaults::Enemies::Pentagon::DROTACIO_MAX;
+            break;
+
+        case TipusEnemic::QUADRAT:
+            shape_file = Defaults::Enemies::Quadrat::SHAPE_FILE;
+            velocitat_ = Defaults::Enemies::Quadrat::VELOCITAT;
+            drotacio_min = Defaults::Enemies::Quadrat::DROTACIO_MIN;
+            drotacio_max = Defaults::Enemies::Quadrat::DROTACIO_MAX;
+            tracking_timer_ = 0.0f;
+            break;
+
+        case TipusEnemic::MOLINILLO:
+            shape_file = Defaults::Enemies::Molinillo::SHAPE_FILE;
+            velocitat_ = Defaults::Enemies::Molinillo::VELOCITAT;
+            drotacio_min = Defaults::Enemies::Molinillo::DROTACIO_MIN;
+            drotacio_max = Defaults::Enemies::Molinillo::DROTACIO_MAX;
+            break;
+    }
+
+    // Carregar forma
+    forma_ = Graphics::ShapeLoader::load(shape_file);
+    if (!forma_ || !forma_->es_valida()) {
+        std::cerr << "[Enemic] Error: no s'ha pogut carregar " << shape_file << std::endl;
+    }
 
     // Posició aleatòria dins de l'àrea de joc
-    // Calcular rangs segurs amb radi de l'enemic
     float min_x, max_x, min_y, max_y;
     Constants::obtenir_limits_zona_segurs(Defaults::Entities::ENEMY_RADIUS,
         min_x,
@@ -47,7 +75,6 @@ void Enemic::inicialitzar() {
         min_y,
         max_y);
 
-    // Spawn aleatori dins dels límits segurs
     int range_x = static_cast<int>(max_x - min_x);
     int range_y = static_cast<int>(max_y - min_y);
     centre_.x = static_cast<float>((std::rand() % range_x) + static_cast<int>(min_x));
@@ -56,14 +83,17 @@ void Enemic::inicialitzar() {
     // Angle aleatori de moviment
     angle_ = (std::rand() % 360) * Constants::PI / 180.0f;
 
-    // Velocitat (2 px/frame original * 20 FPS = 40 px/s)
-    velocitat_ = 40.0f;
-
-    // Rotació visual aleatòria (rad/s)
-    // Original Pascal: random * 0.1 rad/frame * 20 FPS ≈ 2 rad/s
-    drotacio_ = (static_cast<float>(std::rand()) / RAND_MAX) * 2.0f;
+    // Rotació visual aleatòria (rad/s) dins del rang del tipus
+    float drotacio_range = drotacio_max - drotacio_min;
+    drotacio_ = drotacio_min + (static_cast<float>(std::rand()) / RAND_MAX) * drotacio_range;
     rotacio_ = 0.0f;
 
+    // Inicialitzar estat d'animació
+    animacio_ = AnimacioEnemic();  // Reset to defaults
+    animacio_.drotacio_base = drotacio_;
+    animacio_.drotacio_objetivo = drotacio_;
+    animacio_.drotacio_t = 1.0f;  // Start without interpolating
+
     // Activar
     esta_ = true;
 }
@@ -73,6 +103,9 @@ void Enemic::actualitzar(float delta_time) {
         // Moviment autònom
         mou(delta_time);
 
+        // Actualitzar animacions (palpitació, rotació accelerada)
+        actualitzar_animacio(delta_time);
+
         // Rotació visual (time-based: drotacio_ està en rad/s)
         rotacio_ += drotacio_ * delta_time;
     }
@@ -80,21 +113,31 @@ void Enemic::actualitzar(float delta_time) {
 
 void Enemic::dibuixar() const {
     if (esta_ && forma_) {
-        // [NUEVO] Usar render_shape en lloc de rota_pol
-        Rendering::render_shape(renderer_, forma_, centre_, rotacio_, 1.0f, true, 1.0f, brightness_);
+        // [NUEVO] Usar render_shape amb escala animada
+        float escala = calcular_escala_actual();
+        Rendering::render_shape(renderer_, forma_, centre_, rotacio_, escala, true, 1.0f, brightness_);
     }
 }
 
 void Enemic::mou(float delta_time) {
-    // Moviment autònom d'ORNI (enemic pentàgon)
-    // Basat EXACTAMENT en el codi Pascal original: ASTEROID.PAS lines 279-293
-    // Copiat EXACTAMENT de joc_asteroides.cpp línies 348-394
-    //
-    // IMPORTANT: El Pascal original NO té canvi aleatori continu!
-    // Només ajusta l'angle quan toca una paret.
+    // Dispatcher: crida el comportament específic segons el tipus
+    switch (tipus_) {
+        case TipusEnemic::PENTAGON:
+            comportament_pentagon(delta_time);
+            break;
+        case TipusEnemic::QUADRAT:
+            comportament_quadrat(delta_time);
+            break;
+        case TipusEnemic::MOLINILLO:
+            comportament_molinillo(delta_time);
+            break;
+    }
+}
+
+void Enemic::comportament_pentagon(float delta_time) {
+    // Pentagon: zigzag esquivador (frequent direction changes)
+    // Similar a comportament original però amb probabilitat més alta
 
-    // Calcular nova posició PROPUESTA (time-based, però lògica Pascal)
-    // velocitat_ ja està en px/s (40 px/s), multiplicar per delta_time
     float velocitat_efectiva = velocitat_ * delta_time;
 
     // Calcular desplaçament (angle-PI/2 perquè angle=0 apunta amunt)
@@ -104,41 +147,241 @@ void Enemic::mou(float delta_time) {
     float new_y = centre_.y + dy;
     float new_x = centre_.x + dx;
 
-    // Obtenir límits segurs compensant el radi de l'enemic
+    // Obtenir límits segurs
     float min_x, max_x, min_y, max_y;
     Constants::obtenir_limits_zona_segurs(Defaults::Entities::ENEMY_RADIUS,
-        min_x,
-        max_x,
-        min_y,
-        max_y);
+        min_x, max_x, min_y, max_y);
 
-    // Lògica Pascal: Actualitza Y si dins, sinó ajusta angle aleatòriament
-    // if (dy>marge_dalt) and (dy<marge_baix) then orni.centre.y:=round(Dy)
-    // else orni.angle:=orni.angle+(random(256)/512)*(random(3)-1);
-    // CORRECCIÓ: Usar inequalitats inclusives (>= i <=) per evitar fugides
+    // Zigzag: canvi d'angle més freqüent en tocar límits
     if (new_y >= min_y && new_y <= max_y) {
         centre_.y = new_y;
     } else {
-        // Pequeño ajuste aleatorio: (random(256)/512)*(random(3)-1)
-        // random(256) = 0..255, /512 = 0..0.498
-        // random(3) = 0,1,2, -1 = -1,0,1
-        // Resultado: ±0.5 rad aprox
-        float rand1 = (static_cast<float>(std::rand() % 256) / 512.0f);
-        int rand2 = (std::rand() % 3) - 1;  // -1, 0, o 1
-        angle_ += rand1 * static_cast<float>(rand2);
+        // Probabilitat més alta de canvi d'angle
+        if (static_cast<float>(std::rand()) / RAND_MAX < Defaults::Enemies::Pentagon::CANVI_ANGLE_PROB) {
+            float rand_angle = (static_cast<float>(std::rand()) / RAND_MAX) *
+                               Defaults::Enemies::Pentagon::CANVI_ANGLE_MAX;
+            angle_ += (std::rand() % 2 == 0) ? rand_angle : -rand_angle;
+        }
     }
 
-    // Lògica Pascal: Actualitza X si dins, sinó ajusta angle aleatòriament
-    // if (dx>marge_esq) and (dx<marge_dret) then orni.centre.x:=round(Dx)
-    // else orni.angle:=orni.angle+(random(256)/512)*(random(3)-1);
-    // CORRECCIÓ: Usar inequalitats inclusives (>= i <=) per evitar fugides
     if (new_x >= min_x && new_x <= max_x) {
         centre_.x = new_x;
     } else {
-        float rand1 = (static_cast<float>(std::rand() % 256) / 512.0f);
-        int rand2 = (std::rand() % 3) - 1;
-        angle_ += rand1 * static_cast<float>(rand2);
+        if (static_cast<float>(std::rand()) / RAND_MAX < Defaults::Enemies::Pentagon::CANVI_ANGLE_PROB) {
+            float rand_angle = (static_cast<float>(std::rand()) / RAND_MAX) *
+                               Defaults::Enemies::Pentagon::CANVI_ANGLE_MAX;
+            angle_ += (std::rand() % 2 == 0) ? rand_angle : -rand_angle;
+        }
+    }
+}
+
+void Enemic::comportament_quadrat(float delta_time) {
+    // Quadrat: perseguidor (tracks player position)
+
+    // Update tracking timer
+    tracking_timer_ += delta_time;
+
+    // Periodically update angle toward ship
+    if (tracking_timer_ >= Defaults::Enemies::Quadrat::TRACKING_INTERVAL) {
+        tracking_timer_ = 0.0f;
+
+        if (ship_position_) {
+            // Calculate angle to ship
+            float dx = ship_position_->x - centre_.x;
+            float dy = ship_position_->y - centre_.y;
+            float target_angle = std::atan2(dy, dx) + Constants::PI / 2.0f;
+
+            // Interpolate toward target angle
+            float angle_diff = target_angle - angle_;
+
+            // Normalize angle difference to [-π, π]
+            while (angle_diff > Constants::PI) angle_diff -= 2.0f * Constants::PI;
+            while (angle_diff < -Constants::PI) angle_diff += 2.0f * Constants::PI;
+
+            // Apply tracking strength
+            angle_ += angle_diff * Defaults::Enemies::Quadrat::TRACKING_STRENGTH;
+        }
     }
 
-    // Nota: La rotació visual (rotacio_ += drotacio_) ja es fa a actualitzar()
+    // Move in current direction
+    float velocitat_efectiva = velocitat_ * delta_time;
+    float dy = velocitat_efectiva * std::sin(angle_ - Constants::PI / 2.0f);
+    float dx = velocitat_efectiva * std::cos(angle_ - Constants::PI / 2.0f);
+
+    float new_y = centre_.y + dy;
+    float new_x = centre_.x + dx;
+
+    // Obtenir límits segurs
+    float min_x, max_x, min_y, max_y;
+    Constants::obtenir_limits_zona_segurs(Defaults::Entities::ENEMY_RADIUS,
+        min_x, max_x, min_y, max_y);
+
+    // Bounce on walls (simple reflection)
+    if (new_y >= min_y && new_y <= max_y) {
+        centre_.y = new_y;
+    } else {
+        angle_ = -angle_;  // Vertical reflection
+    }
+
+    if (new_x >= min_x && new_x <= max_x) {
+        centre_.x = new_x;
+    } else {
+        angle_ = Constants::PI - angle_;  // Horizontal reflection
+    }
+}
+
+void Enemic::comportament_molinillo(float delta_time) {
+    // Molinillo: agressiu (fast, straight lines, proximity spin-up)
+
+    // Check proximity to ship for spin-up effect
+    if (ship_position_) {
+        float dx = ship_position_->x - centre_.x;
+        float dy = ship_position_->y - centre_.y;
+        float distance = std::sqrt(dx * dx + dy * dy);
+
+        if (distance < Defaults::Enemies::Molinillo::PROXIMITY_DISTANCE) {
+            // Temporarily boost rotation speed when near ship
+            float boost = Defaults::Enemies::Molinillo::DROTACIO_PROXIMITY_MULTIPLIER;
+            drotacio_ = animacio_.drotacio_base * boost;
+        } else {
+            // Normal rotation speed
+            drotacio_ = animacio_.drotacio_base;
+        }
+    }
+
+    // Fast straight-line movement
+    float velocitat_efectiva = velocitat_ * delta_time;
+    float dy = velocitat_efectiva * std::sin(angle_ - Constants::PI / 2.0f);
+    float dx = velocitat_efectiva * std::cos(angle_ - Constants::PI / 2.0f);
+
+    float new_y = centre_.y + dy;
+    float new_x = centre_.x + dx;
+
+    // Obtenir límits segurs
+    float min_x, max_x, min_y, max_y;
+    Constants::obtenir_limits_zona_segurs(Defaults::Entities::ENEMY_RADIUS,
+        min_x, max_x, min_y, max_y);
+
+    // Rare angle changes on wall hits
+    if (new_y >= min_y && new_y <= max_y) {
+        centre_.y = new_y;
+    } else {
+        if (static_cast<float>(std::rand()) / RAND_MAX < Defaults::Enemies::Molinillo::CANVI_ANGLE_PROB) {
+            float rand_angle = (static_cast<float>(std::rand()) / RAND_MAX) *
+                               Defaults::Enemies::Molinillo::CANVI_ANGLE_MAX;
+            angle_ += (std::rand() % 2 == 0) ? rand_angle : -rand_angle;
+        }
+    }
+
+    if (new_x >= min_x && new_x <= max_x) {
+        centre_.x = new_x;
+    } else {
+        if (static_cast<float>(std::rand()) / RAND_MAX < Defaults::Enemies::Molinillo::CANVI_ANGLE_PROB) {
+            float rand_angle = (static_cast<float>(std::rand()) / RAND_MAX) *
+                               Defaults::Enemies::Molinillo::CANVI_ANGLE_MAX;
+            angle_ += (std::rand() % 2 == 0) ? rand_angle : -rand_angle;
+        }
+    }
+}
+
+void Enemic::actualitzar_animacio(float delta_time) {
+    actualitzar_palpitacio(delta_time);
+    actualitzar_rotacio_accelerada(delta_time);
+}
+
+void Enemic::actualitzar_palpitacio(float delta_time) {
+    if (animacio_.palpitacio_activa) {
+        // Advance phase (2π * frequency * dt)
+        animacio_.palpitacio_fase += 2.0f * Constants::PI * animacio_.palpitacio_frequencia * delta_time;
+
+        // Decrement timer
+        animacio_.palpitacio_temps_restant -= delta_time;
+
+        // Deactivate when timer expires
+        if (animacio_.palpitacio_temps_restant <= 0.0f) {
+            animacio_.palpitacio_activa = false;
+        }
+    } else {
+        // Random trigger (probability per second)
+        float rand_val = static_cast<float>(std::rand()) / RAND_MAX;
+        float trigger_prob = Defaults::Enemies::Animation::PALPITACIO_TRIGGER_PROB * delta_time;
+
+        if (rand_val < trigger_prob) {
+            // Activate palpitation
+            animacio_.palpitacio_activa = true;
+            animacio_.palpitacio_fase = 0.0f;
+
+            // Randomize parameters
+            float freq_range = Defaults::Enemies::Animation::PALPITACIO_FREQ_MAX -
+                               Defaults::Enemies::Animation::PALPITACIO_FREQ_MIN;
+            animacio_.palpitacio_frequencia = Defaults::Enemies::Animation::PALPITACIO_FREQ_MIN +
+                (static_cast<float>(std::rand()) / RAND_MAX) * freq_range;
+
+            float amp_range = Defaults::Enemies::Animation::PALPITACIO_AMPLITUD_MAX -
+                              Defaults::Enemies::Animation::PALPITACIO_AMPLITUD_MIN;
+            animacio_.palpitacio_amplitud = Defaults::Enemies::Animation::PALPITACIO_AMPLITUD_MIN +
+                (static_cast<float>(std::rand()) / RAND_MAX) * amp_range;
+
+            float dur_range = Defaults::Enemies::Animation::PALPITACIO_DURACIO_MAX -
+                              Defaults::Enemies::Animation::PALPITACIO_DURACIO_MIN;
+            animacio_.palpitacio_temps_restant = Defaults::Enemies::Animation::PALPITACIO_DURACIO_MIN +
+                (static_cast<float>(std::rand()) / RAND_MAX) * dur_range;
+        }
+    }
+}
+
+void Enemic::actualitzar_rotacio_accelerada(float delta_time) {
+    if (animacio_.drotacio_t < 1.0f) {
+        // Transitioning to new target
+        animacio_.drotacio_t += delta_time / animacio_.drotacio_duracio;
+
+        if (animacio_.drotacio_t >= 1.0f) {
+            animacio_.drotacio_t = 1.0f;
+            animacio_.drotacio_base = animacio_.drotacio_objetivo;  // Reached target
+            drotacio_ = animacio_.drotacio_base;
+        } else {
+            // Smoothstep interpolation: t² * (3 - 2t)
+            float t = animacio_.drotacio_t;
+            float smooth_t = t * t * (3.0f - 2.0f * t);
+
+            // Interpolate between base and target
+            float initial = animacio_.drotacio_base;
+            float target = animacio_.drotacio_objetivo;
+            drotacio_ = initial + (target - initial) * smooth_t;
+        }
+    } else {
+        // Random trigger for new acceleration
+        float rand_val = static_cast<float>(std::rand()) / RAND_MAX;
+        float trigger_prob = Defaults::Enemies::Animation::ROTACIO_ACCEL_TRIGGER_PROB * delta_time;
+
+        if (rand_val < trigger_prob) {
+            // Start new transition
+            animacio_.drotacio_t = 0.0f;
+
+            // Randomize target speed (multiplier * base)
+            float mult_range = Defaults::Enemies::Animation::ROTACIO_ACCEL_MULTIPLIER_MAX -
+                               Defaults::Enemies::Animation::ROTACIO_ACCEL_MULTIPLIER_MIN;
+            float multiplier = Defaults::Enemies::Animation::ROTACIO_ACCEL_MULTIPLIER_MIN +
+                (static_cast<float>(std::rand()) / RAND_MAX) * mult_range;
+
+            animacio_.drotacio_objetivo = animacio_.drotacio_base * multiplier;
+
+            // Randomize duration
+            float dur_range = Defaults::Enemies::Animation::ROTACIO_ACCEL_DURACIO_MAX -
+                              Defaults::Enemies::Animation::ROTACIO_ACCEL_DURACIO_MIN;
+            animacio_.drotacio_duracio = Defaults::Enemies::Animation::ROTACIO_ACCEL_DURACIO_MIN +
+                (static_cast<float>(std::rand()) / RAND_MAX) * dur_range;
+        }
+    }
+}
+
+float Enemic::calcular_escala_actual() const {
+    float escala = 1.0f;
+
+    if (animacio_.palpitacio_activa) {
+        // Add pulsating scale variation
+        escala += animacio_.palpitacio_amplitud * std::sin(animacio_.palpitacio_fase);
+    }
+
+    return escala;
 }

source/game/entities/enemic.hpp

@@ -10,13 +10,36 @@
 #include "core/graphics/shape.hpp"
 #include "core/types.hpp"
 
+// Tipus d'enemic
+enum class TipusEnemic : uint8_t {
+    PENTAGON = 0,   // Pentàgon esquivador (zigzag)
+    QUADRAT = 1,    // Quadrat perseguidor (tracks ship)
+    MOLINILLO = 2   // Molinillo agressiu (fast, spinning)
+};
+
+// Estat d'animació (palpitació i rotació accelerada)
+struct AnimacioEnemic {
+    // Palpitation (breathing effect)
+    bool palpitacio_activa = false;
+    float palpitacio_fase = 0.0f;         // Phase in cycle (0.0-2π)
+    float palpitacio_frequencia = 2.0f;   // Hz (cycles per second)
+    float palpitacio_amplitud = 0.15f;    // Scale variation (±15%)
+    float palpitacio_temps_restant = 0.0f;  // Time remaining (seconds)
+
+    // Rotation acceleration (long-term spin modulation)
+    float drotacio_base = 0.0f;           // Base rotation speed (rad/s)
+    float drotacio_objetivo = 0.0f;       // Target rotation speed (rad/s)
+    float drotacio_t = 0.0f;              // Interpolation progress (0.0-1.0)
+    float drotacio_duracio = 0.0f;        // Duration of transition (seconds)
+};
+
 class Enemic {
     public:
         Enemic()
             : renderer_(nullptr) {}
         Enemic(SDL_Renderer* renderer);
 
-        void inicialitzar();
+        void inicialitzar(TipusEnemic tipus = TipusEnemic::PENTAGON);
         void actualitzar(float delta_time);
         void dibuixar() const;
 
@@ -26,6 +49,9 @@ class Enemic {
         const std::shared_ptr<Graphics::Shape>& get_forma() const { return forma_; }
         void destruir() { esta_ = false; }
 
+        // Set ship position reference for tracking behavior
+        void set_ship_position(const Punt* ship_pos) { ship_position_ = ship_pos; }
+
     private:
         SDL_Renderer* renderer_;
 
@@ -41,5 +67,25 @@ class Enemic {
         bool esta_;
         float brightness_;  // Factor de brillantor (0.0-1.0)
 
+        // [NEW] Enemy type and configuration
+        TipusEnemic tipus_;
+
+        // [NEW] Animation state
+        AnimacioEnemic animacio_;
+
+        // [NEW] Behavior state (type-specific)
+        float tracking_timer_;           // For Quadrat: time since last angle update
+        const Punt* ship_position_;      // Pointer to ship position (for tracking)
+
+        // [EXISTING] Private methods
         void mou(float delta_time);
+
+        // [NEW] Private methods
+        void actualitzar_animacio(float delta_time);
+        void actualitzar_palpitacio(float delta_time);
+        void actualitzar_rotacio_accelerada(float delta_time);
+        void comportament_pentagon(float delta_time);
+        void comportament_quadrat(float delta_time);
+        void comportament_molinillo(float delta_time);
+        float calcular_escala_actual() const;  // Returns scale with palpitation applied
 };

source/game/escenes/escena_joc.cpp

@@ -119,9 +119,22 @@ void EscenaJoc::inicialitzar() {
     // Inicialitzar nau
     nau_.inicialitzar();
 
-    // Inicialitzar enemics (ORNIs)
+    // Inicialitzar enemics (ORNIs) amb tipus aleatoris
     for (auto& enemy : orni_) {
-        enemy.inicialitzar();
+        // Random type distribution: ~40% Pentagon, ~30% Quadrat, ~30% Molinillo
+        int rand_val = std::rand() % 10;
+        TipusEnemic tipus;
+
+        if (rand_val < 4) {
+            tipus = TipusEnemic::PENTAGON;
+        } else if (rand_val < 7) {
+            tipus = TipusEnemic::QUADRAT;
+        } else {
+            tipus = TipusEnemic::MOLINILLO;
+        }
+
+        enemy.inicialitzar(tipus);
+        enemy.set_ship_position(&nau_.get_centre());  // Set ship reference for tracking
     }
 
     // Inicialitzar bales