migrat a sistema de shapes

CMakeLists.txt

@@ -40,6 +40,9 @@ set(APP_SOURCES
     source/core/rendering/color_oscillator.cpp
     source/core/rendering/polygon_renderer.cpp
     source/core/rendering/primitives.cpp
+    source/core/rendering/shape_renderer.cpp
+    source/core/graphics/shape.cpp
+    source/core/graphics/shape_loader.cpp
     source/game/options.cpp
     source/game/joc_asteroides.cpp
     source/game/entities/nau.cpp

Makefile

@@ -40,6 +40,9 @@ APP_SOURCES := \
     source/core/rendering/color_oscillator.cpp \
     source/core/rendering/polygon_renderer.cpp \
     source/core/rendering/primitives.cpp \
+    source/core/rendering/shape_renderer.cpp \
+    source/core/graphics/shape.cpp \
+    source/core/graphics/shape_loader.cpp \
     source/game/options.cpp \
     source/game/joc_asteroides.cpp \
     source/game/entities/nau.cpp \

data/shapes/bullet.shp

@@ -0,0 +1,19 @@
+# bullet.shp - Projectil (petit pentàgon)
+# © 1999 Visente i Sergi (versió Pascal)
+# © 2025 Port a C++20 amb SDL3
+
+name: bullet
+scale: 1.0
+center: 0, 0
+
+# Pentàgon petit radi=5 (1/4 del enemic)
+# Pentàgon regular amb 72° entre punts
+#
+# Conversió polar→cartesià (radi=5, SDL: Y creix cap avall):
+#   angle=-90°: (0.00, -5.00)
+#   angle=-18°: (4.76, -1.55)
+#   angle=54°:  (2.94, 4.05)
+#   angle=126°: (-2.94, 4.05)
+#   angle=198°: (-4.76, -1.55)
+
+polyline: 0,-5  4.76,-1.55  2.94,4.05  -2.94,4.05  -4.76,-1.55  0,-5

data/shapes/enemy_pentagon.shp

@@ -0,0 +1,21 @@
+# enemy_pentagon.shp - ORNI enemic (pentàgon regular)
+# © 1999 Visente i Sergi (versió Pascal)
+# © 2025 Port a C++20 amb SDL3
+
+name: enemy_pentagon
+scale: 1.0
+center: 0, 0
+
+# Pentàgon regular radi=20
+# 5 punts equidistants al voltant d'un cercle (72° entre ells)
+# Començant a angle=-90° (amunt), rotant sentit antihorari
+#
+# Angles: -90°, -18°, 54°, 126°, 198°
+# Conversió polar→cartesià (SDL: Y creix cap avall):
+#   angle=-90°: (0.00, -20.00)
+#   angle=-18°: (19.02, -6.18)
+#   angle=54°:  (11.76, 16.18)
+#   angle=126°: (-11.76, 16.18)
+#   angle=198°: (-19.02, -6.18)
+
+polyline: 0,-20  19.02,-6.18  11.76,16.18  -11.76,16.18  -19.02,-6.18  0,-20

data/shapes/ship.shp

@@ -0,0 +1,20 @@
+# ship.shp - Nau del jugador (triangle)
+# © 1999 Visente i Sergi (versió Pascal)
+# © 2025 Port a C++20 amb SDL3
+
+name: ship
+scale: 1.0
+center: 0, 0
+
+# Triangle: punta amunt, base avall
+# Punts originals (polar):
+#   p1: r=12, angle=270° (3π/2) → punta amunt
+#   p2: r=12, angle=45° (π/4) → base dreta-darrere
+#   p3: r=12, angle=135° (3π/4) → base esquerra-darrere
+#
+# Conversió polar→cartesià (angle-90° perquè origen visual és amunt):
+#   p1: (0, -12)
+#   p2: (8.49, 8.49)
+#   p3: (-8.49, 8.49)
+
+polyline: 0,-12  8.49,8.49  -8.49,8.49  0,-12

source/game/entities/bala.cpp

@@ -3,23 +3,30 @@
 // © 2025 Port a C++20 amb SDL3
 
 #include "game/entities/bala.hpp"
-#include "core/rendering/polygon_renderer.hpp"
+#include "core/graphics/shape_loader.hpp"
-#include "core/rendering/primitives.hpp"
+#include "core/rendering/shape_renderer.hpp"
 #include "game/constants.hpp"
 #include <cmath>
+#include <iostream>
 
-Bala::Bala(SDL_Renderer *renderer) : renderer_(renderer) {}
+Bala::Bala(SDL_Renderer *renderer)
+    : renderer_(renderer), centre_({0.0f, 0.0f}), angle_(0.0f),
+      velocitat_(0.0f), esta_(false) {
+
+  // [NUEVO] Carregar forma compartida des de fitxer
+  forma_ = Graphics::ShapeLoader::load("bullet.shp");
+
+  if (!forma_ || !forma_->es_valida()) {
+    std::cerr << "[Bala] Error: no s'ha pogut carregar bullet.shp" << std::endl;
+  }
+}
 
 void Bala::inicialitzar() {
-  // Inicialitzar bala com a pentàgon petit
-  // Basat en el codi Pascal original: inicialment inactiva
-  // Copiat de joc_asteroides.cpp línies 58-64
-
-  // Crear pentàgon petit (5 costats, radi 5)
-  crear_poligon_regular(dades_, 5, 5.0f);
-
   // Inicialment inactiva
-  dades_.esta = false;
+  esta_ = false;
+  centre_ = {0.0f, 0.0f};
+  angle_ = 0.0f;
+  velocitat_ = 0.0f;
 }
 
 void Bala::disparar(const Punt &posicio, float angle) {
@@ -27,30 +34,31 @@ void Bala::disparar(const Punt &posicio, float angle) {
   // Basat en joc_asteroides.cpp línies 188-200
 
   // Activar bala
-  dades_.esta = true;
+  esta_ = true;
 
   // Posició inicial = centre de la nau
-  dades_.centre.x = posicio.x;
+  centre_.x = posicio.x;
-  dades_.centre.y = posicio.y;
+  centre_.y = posicio.y;
 
   // Angle = angle de la nau (dispara en la direcció que apunta)
-  dades_.angle = angle;
+  angle_ = angle;
 
   // Velocitat alta (el joc Pascal original usava 7 px/frame)
   // 7 px/frame × 20 FPS = 140 px/s
-  dades_.velocitat = 140.0f;
+  velocitat_ = 140.0f;
 }
 
 void Bala::actualitzar(float delta_time) {
-  if (dades_.esta) {
+  if (esta_) {
     mou(delta_time);
   }
 }
 
 void Bala::dibuixar() const {
-  if (dades_.esta) {
+  if (esta_ && forma_) {
-    // Dibuixar com a pentàgon petit, sense rotació visual
+    // [NUEVO] Usar render_shape en lloc de rota_pol
-    Rendering::rota_pol(renderer_, dades_, 0.0f, true);
+    // Les bales no roten visualment (angle sempre 0.0f)
+    Rendering::render_shape(renderer_, forma_, centre_, 0.0f, 1.0f, true);
   }
 }
 
@@ -61,23 +69,19 @@ void Bala::mou(float delta_time) {
 
   // Calcular nova posició (moviment polar time-based)
   // velocitat ja està en px/s (140 px/s), només cal multiplicar per delta_time
-  float velocitat_efectiva = dades_.velocitat * delta_time;
+  float velocitat_efectiva = velocitat_ * delta_time;
 
   // Calcular desplaçament (angle-PI/2 perquè angle=0 apunta amunt)
-  float dy =
+  float dy = velocitat_efectiva * std::sin(angle_ - Constants::PI / 2.0f);
-      velocitat_efectiva * std::sin(dades_.angle - Constants::PI / 2.0f);
+  float dx = velocitat_efectiva * std::cos(angle_ - Constants::PI / 2.0f);
-  float dx =
-      velocitat_efectiva * std::cos(dades_.angle - Constants::PI / 2.0f);
 
   // Acumulació directa amb precisió subpíxel
-  dades_.centre.y += dy;
+  centre_.y += dy;
-  dades_.centre.x += dx;
+  centre_.x += dx;
 
   // Desactivar si surt dels marges (no rebota com els ORNIs)
-  if (dades_.centre.x < Constants::MARGE_ESQ ||
+  if (centre_.x < Constants::MARGE_ESQ || centre_.x > Constants::MARGE_DRET ||
-      dades_.centre.x > Constants::MARGE_DRET ||
+      centre_.y < Constants::MARGE_DALT || centre_.y > Constants::MARGE_BAIX) {
-      dades_.centre.y < Constants::MARGE_DALT ||
+    esta_ = false;
-      dades_.centre.y > Constants::MARGE_BAIX) {
-    dades_.esta = false;
   }
 }

source/game/entities/bala.hpp

@@ -3,8 +3,10 @@
 // © 2025 Port a C++20 amb SDL3
 
 #pragma once
+#include "core/graphics/shape.hpp"
 #include "core/types.hpp"
 #include <SDL3/SDL.h>
+#include <memory>
 
 class Bala {
 public:
@@ -16,13 +18,22 @@ public:
   void actualitzar(float delta_time);
   void dibuixar() const;
 
-  // Getters
+  // Getters (API pública sense canvis)
-  bool esta_activa() const { return dades_.esta; }
+  bool esta_activa() const { return esta_; }
-  const Punt &get_centre() const { return dades_.centre; }
+  const Punt &get_centre() const { return centre_; }
-  void desactivar() { dades_.esta = false; }
+  void desactivar() { esta_ = false; }
 
 private:
   SDL_Renderer *renderer_;
-  Poligon dades_;
+
+  // [NUEVO] Forma vectorial (compartida entre totes les bales)
+  std::shared_ptr<Graphics::Shape> forma_;
+
+  // [NUEVO] Estat de la instància (separat de la geometria)
+  Punt centre_;
+  float angle_;
+  float velocitat_;
+  bool esta_;
+
   void mou(float delta_time);
 };

source/game/entities/enemic.cpp

@@ -3,45 +3,66 @@
 // © 2025 Port a C++20 amb SDL3
 
 #include "game/entities/enemic.hpp"
-#include "core/rendering/polygon_renderer.hpp"
+#include "core/graphics/shape_loader.hpp"
-#include "core/rendering/primitives.hpp"
+#include "core/rendering/shape_renderer.hpp"
 #include "game/constants.hpp"
 #include <cmath>
 #include <cstdlib>
+#include <iostream>
 
-Enemic::Enemic(SDL_Renderer *renderer) : renderer_(renderer) {}
+Enemic::Enemic(SDL_Renderer *renderer)
+    : renderer_(renderer), centre_({0.0f, 0.0f}), angle_(0.0f),
+      velocitat_(0.0f), drotacio_(0.0f), rotacio_(0.0f), esta_(false) {
+
+  // [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;
+  }
+}
 
 void Enemic::inicialitzar() {
-  // Inicialitzar enemic com a pentàgon
+  // Inicialitzar enemic (pentàgon)
   // Copiat de joc_asteroides.cpp línies 41-54
 
-  // Crear pentàgon regular (5 costats, radi 20)
+  // [NUEVO] Ja no cal crear_poligon_regular - la geometria es carrega del fitxer
-  crear_poligon_regular(dades_, 5, 20.0f);
+  // Només inicialitzem l'estat de la instància
 
   // Posició aleatòria dins de l'àrea de joc
-  dades_.centre.x = static_cast<float>((std::rand() % 580) + 30); // 30-610
+  centre_.x = static_cast<float>((std::rand() % 580) + 30); // 30-610
-  dades_.centre.y = static_cast<float>((std::rand() % 420) + 30); // 30-450
+  centre_.y = static_cast<float>((std::rand() % 420) + 30); // 30-450
 
-  // Angle aleatori
+  // Angle aleatori de moviment
-  dades_.angle = (std::rand() % 360) * Constants::PI / 180.0f;
+  angle_ = (std::rand() % 360) * Constants::PI / 180.0f;
 
-  // Està actiu
+  // Velocitat (2 px/frame original * 20 FPS = 40 px/s)
-  dades_.esta = true;
+  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;
+  rotacio_ = 0.0f;
+
+  // Activar
+  esta_ = true;
 }
 
 void Enemic::actualitzar(float delta_time) {
-  if (dades_.esta) {
+  if (esta_) {
     // Moviment autònom
     mou(delta_time);
 
-    // Rotació visual (time-based: drotacio està en rad/s)
+    // Rotació visual (time-based: drotacio_ està en rad/s)
-    dades_.rotacio += dades_.drotacio * delta_time;
+    rotacio_ += drotacio_ * delta_time;
   }
 }
 
 void Enemic::dibuixar() const {
-  if (dades_.esta) {
+  if (esta_ && forma_) {
-    Rendering::rota_pol(renderer_, dades_, dades_.rotacio, true);
+    // [NUEVO] Usar render_shape en lloc de rota_pol
+    Rendering::render_shape(renderer_, forma_, centre_, rotacio_, 1.0f, true);
   }
 }
 
@@ -54,23 +75,21 @@ void Enemic::mou(float delta_time) {
   // Només ajusta l'angle quan toca una paret.
 
   // Calcular nova posició PROPUESTA (time-based, però lògica Pascal)
-  // velocitat ja està en px/s (40 px/s), multiplicar per delta_time
+  // velocitat_ ja està en px/s (40 px/s), multiplicar per delta_time
-  float velocitat_efectiva = dades_.velocitat * delta_time;
+  float velocitat_efectiva = velocitat_ * delta_time;
 
   // Calcular desplaçament (angle-PI/2 perquè angle=0 apunta amunt)
-  float dy =
+  float dy = velocitat_efectiva * std::sin(angle_ - Constants::PI / 2.0f);
-      velocitat_efectiva * std::sin(dades_.angle - Constants::PI / 2.0f);
+  float dx = velocitat_efectiva * std::cos(angle_ - Constants::PI / 2.0f);
-  float dx =
-      velocitat_efectiva * std::cos(dades_.angle - Constants::PI / 2.0f);
 
-  float new_y = dades_.centre.y + dy;
+  float new_y = centre_.y + dy;
-  float new_x = dades_.centre.x + dx;
+  float new_x = centre_.x + dx;
 
   // 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);
   if (new_y > Constants::MARGE_DALT && new_y < Constants::MARGE_BAIX) {
-    dades_.centre.y = new_y;
+    centre_.y = new_y;
   } else {
     // Pequeño ajuste aleatorio: (random(256)/512)*(random(3)-1)
     // random(256) = 0..255, /512 = 0..0.498
@@ -78,20 +97,19 @@ void Enemic::mou(float delta_time) {
     // 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
-    dades_.angle += rand1 * static_cast<float>(rand2);
+    angle_ += rand1 * static_cast<float>(rand2);
   }
 
   // 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);
   if (new_x > Constants::MARGE_ESQ && new_x < Constants::MARGE_DRET) {
-    dades_.centre.x = new_x;
+    centre_.x = new_x;
   } else {
     float rand1 = (static_cast<float>(std::rand() % 256) / 512.0f);
     int rand2 = (std::rand() % 3) - 1;
-    dades_.angle += rand1 * static_cast<float>(rand2);
+    angle_ += rand1 * static_cast<float>(rand2);
   }
 
-  // Nota: La rotació visual (dades_.rotacio += dades_.drotacio) ja es fa a
+  // Nota: La rotació visual (rotacio_ += drotacio_) ja es fa a actualitzar()
-  // actualitzar()
 }

source/game/entities/enemic.hpp

@@ -3,8 +3,10 @@
 // © 2025 Port a C++20 amb SDL3
 
 #pragma once
+#include "core/graphics/shape.hpp"
 #include "core/types.hpp"
 #include <SDL3/SDL.h>
+#include <memory>
 
 class Enemic {
 public:
@@ -15,13 +17,24 @@ public:
   void actualitzar(float delta_time);
   void dibuixar() const;
 
-  // Getters
+  // Getters (API pública sense canvis)
-  bool esta_actiu() const { return dades_.esta; }
+  bool esta_actiu() const { return esta_; }
-  const Punt &get_centre() const { return dades_.centre; }
+  const Punt &get_centre() const { return centre_; }
-  void destruir() { dades_.esta = false; }
+  void destruir() { esta_ = false; }
 
 private:
   SDL_Renderer *renderer_;
-  Poligon dades_;
+
+  // [NUEVO] Forma vectorial (compartida entre tots els enemics)
+  std::shared_ptr<Graphics::Shape> forma_;
+
+  // [NUEVO] Estat de la instància (separat de la geometria)
+  Punt centre_;
+  float angle_;      // Angle de moviment
+  float velocitat_;
+  float drotacio_;   // Delta rotació visual (rad/s)
+  float rotacio_;    // Rotació visual acumulada
+  bool esta_;
+
   void mou(float delta_time);
 };

source/game/entities/nau.cpp

@@ -4,36 +4,40 @@
 
 #include "game/entities/nau.hpp"
 #include "core/defaults.hpp"
-#include "core/rendering/polygon_renderer.hpp"
+#include "core/graphics/shape_loader.hpp"
+#include "core/rendering/shape_renderer.hpp"
 #include "game/constants.hpp"
 #include <SDL3/SDL.h>
 #include <cmath>
+#include <iostream>
 
 Nau::Nau(SDL_Renderer *renderer)
-    : renderer_(renderer), esta_tocada_(false) {}
+    : renderer_(renderer), centre_({0.0f, 0.0f}), angle_(0.0f),
+      velocitat_(0.0f), esta_tocada_(false) {
+
+  // [NUEVO] Carregar forma compartida des de fitxer
+  forma_ = Graphics::ShapeLoader::load("ship.shp");
+
+  if (!forma_ || !forma_->es_valida()) {
+    std::cerr << "[Nau] Error: no s'ha pogut carregar ship.shp" << std::endl;
+  }
+}
 
 void Nau::inicialitzar() {
   // Inicialització de la nau (triangle)
   // Basat en el codi Pascal original: lines 380-384
   // Copiat de joc_asteroides.cpp línies 30-44
 
-  // Configurar triangle amb 3 punts polars
+  // [NUEVO] Ja no cal configurar punts polars - la geometria es carrega del fitxer
-  dades_.p1.r = 12.0f;
+  // Només inicialitzem l'estat de la instància
-  dades_.p1.angle = 3.0f * Constants::PI / 2.0f; // Apunta amunt (270°)
-
-  dades_.p2.r = 12.0f;
-  dades_.p2.angle = Constants::PI / 4.0f; // 45°
-
-  dades_.p3.r = 12.0f;
-  dades_.p3.angle = (3.0f * Constants::PI) / 4.0f; // 135°
 
   // Posició inicial al centre de la pantalla
-  dades_.centre.x = 320.0f;
+  centre_.x = 320.0f;
-  dades_.centre.y = 240.0f;
+  centre_.y = 240.0f;
 
   // Estat inicial
-  dades_.angle = 0.0f;
+  angle_ = 0.0f;
-  dades_.velocitat = 0.0f;
+  velocitat_ = 0.0f;
   esta_tocada_ = false;
 }
 
@@ -49,19 +53,19 @@ void Nau::processar_input(float delta_time) {
 
   // Rotació
   if (keyboard_state[SDL_SCANCODE_RIGHT]) {
-    dades_.angle += Defaults::Physics::ROTATION_SPEED * delta_time;
+    angle_ += Defaults::Physics::ROTATION_SPEED * delta_time;
   }
 
   if (keyboard_state[SDL_SCANCODE_LEFT]) {
-    dades_.angle -= Defaults::Physics::ROTATION_SPEED * delta_time;
+    angle_ -= Defaults::Physics::ROTATION_SPEED * delta_time;
   }
 
   // Acceleració
   if (keyboard_state[SDL_SCANCODE_UP]) {
-    if (dades_.velocitat < Defaults::Physics::MAX_VELOCITY) {
+    if (velocitat_ < Defaults::Physics::MAX_VELOCITY) {
-      dades_.velocitat += Defaults::Physics::ACCELERATION * delta_time;
+      velocitat_ += Defaults::Physics::ACCELERATION * delta_time;
-      if (dades_.velocitat > Defaults::Physics::MAX_VELOCITY) {
+      if (velocitat_ > Defaults::Physics::MAX_VELOCITY) {
-        dades_.velocitat = Defaults::Physics::MAX_VELOCITY;
+        velocitat_ = Defaults::Physics::MAX_VELOCITY;
       }
     }
   }
@@ -81,13 +85,21 @@ void Nau::dibuixar() const {
   if (esta_tocada_)
     return;
 
+  if (!forma_)
+    return;
+
   // Escalar velocitat per l'efecte visual (200 px/s → ~6 px d'efecte)
   // El codi Pascal original sumava velocitat (0-6) al radi per donar
   // sensació de "empenta". Ara velocitat està en px/s (0-200).
   // Basat en joc_asteroides.cpp línies 127-134
-  float velocitat_visual = dades_.velocitat / 33.33f;
+  //
+  // [NUEVO] Convertir suma de velocitat_visual a escala multiplicativa
+  // Radio base del ship = 12 px
+  // velocitat_visual = 0-6 → r = 12-18 → escala = 1.0-1.5
+  float velocitat_visual = velocitat_ / 33.33f;
+  float escala = 1.0f + (velocitat_visual / 12.0f);
 
-  Rendering::rota_tri(renderer_, dades_, dades_.angle, velocitat_visual, true);
+  Rendering::render_shape(renderer_, forma_, centre_, angle_, escala, true);
 }
 
 void Nau::aplicar_fisica(float delta_time) {
@@ -96,29 +108,29 @@ void Nau::aplicar_fisica(float delta_time) {
 
   // Calcular nova posició basada en velocitat i angle
   // S'usa (angle - PI/2) perquè angle=0 apunta cap amunt, no cap a la dreta
-  // velocitat està en px/s, així que multipliquem per delta_time
+  // velocitat_ està en px/s, així que multipliquem per delta_time
-  float dy = (dades_.velocitat * delta_time) *
+  float dy =
-                 std::sin(dades_.angle - Constants::PI / 2.0f) +
+      (velocitat_ * delta_time) * std::sin(angle_ - Constants::PI / 2.0f) +
-             dades_.centre.y;
+      centre_.y;
-  float dx = (dades_.velocitat * delta_time) *
+  float dx =
-                 std::cos(dades_.angle - Constants::PI / 2.0f) +
+      (velocitat_ * delta_time) * std::cos(angle_ - Constants::PI / 2.0f) +
-             dades_.centre.x;
+      centre_.x;
 
   // Boundary checking - només actualitzar si dins dels marges
   // Acumulació directa amb precisió subpíxel
   if (dy > Constants::MARGE_DALT && dy < Constants::MARGE_BAIX) {
-    dades_.centre.y = dy;
+    centre_.y = dy;
   }
 
   if (dx > Constants::MARGE_ESQ && dx < Constants::MARGE_DRET) {
-    dades_.centre.x = dx;
+    centre_.x = dx;
   }
 
   // Fricció - desacceleració gradual (time-based)
-  if (dades_.velocitat > 0.1f) {
+  if (velocitat_ > 0.1f) {
-    dades_.velocitat -= Defaults::Physics::FRICTION * delta_time;
+    velocitat_ -= Defaults::Physics::FRICTION * delta_time;
-    if (dades_.velocitat < 0.0f) {
+    if (velocitat_ < 0.0f) {
-      dades_.velocitat = 0.0f;
+      velocitat_ = 0.0f;
     }
   }
 }

source/game/entities/nau.hpp

@@ -3,8 +3,10 @@
 // © 2025 Port a C++20 amb SDL3
 
 #pragma once
+#include "core/graphics/shape.hpp"
 #include "core/types.hpp"
 #include <SDL3/SDL.h>
+#include <memory>
 
 class Nau {
 public:
@@ -16,9 +18,9 @@ public:
   void actualitzar(float delta_time);
   void dibuixar() const;
 
-  // Getters
+  // Getters (API pública sense canvis)
-  const Punt &get_centre() const { return dades_.centre; }
+  const Punt &get_centre() const { return centre_; }
-  float get_angle() const { return dades_.angle; }
+  float get_angle() const { return angle_; }
   bool esta_viva() const { return !esta_tocada_; }
 
   // Col·lisions (Fase 10)
@@ -26,7 +28,14 @@ public:
 
 private:
   SDL_Renderer *renderer_;
-  Triangle dades_;
+
+  // [NUEVO] Forma vectorial (compartida, només 1 instància de Nau però preparat per reutilització)
+  std::shared_ptr<Graphics::Shape> forma_;
+
+  // [NUEVO] Estat de la instància (separat de la geometria)
+  Punt centre_;
+  float angle_;      // Angle d'orientació
+  float velocitat_;  // Velocitat (px/s)
   bool esta_tocada_;
 
   void aplicar_fisica(float delta_time);

source/game/joc_asteroides.cpp

@@ -3,7 +3,6 @@
 // © 2025 Port a C++20 amb SDL3
 
 #include "joc_asteroides.hpp"
-#include "core/rendering/primitives.hpp"
 #include <cmath>
 #include <cstdlib>
 #include <ctime>

source/game/joc_asteroides.hpp

@@ -5,7 +5,6 @@
 #ifndef JOC_ASTEROIDES_HPP
 #define JOC_ASTEROIDES_HPP
 
-#include "core/rendering/polygon_renderer.hpp"
 #include "core/types.hpp"
 #include "game/constants.hpp"
 #include "game/entities/bala.hpp"