HC-06: rutes d'assets de GameScene a Defaults::Pyramid + Config

Afegits `Defaults::Pyramid::{MAP_YAML, PLAYER_SPRITE, PLAYER_YAML,
MUSIC_TRACK}` a utils/defaults.hpp. `GameScene` exposa `Config` i
`defaultConfig()`; el ctor accepta Config (default = Defaults::Pyramid)
i usa els camps enlloc dels literals. `Player` passa a rebre el anim_key
per constructor en lloc de cablejar "player.yaml". Cache key = basename
(convenció preexistent). Cada piràmide futura serà un Config distint.

source/game/entities/player.cpp

@@ -45,8 +45,8 @@ void Player::loadFrom(const std::string& yaml_path) {
     collision_y_offset = (sprite_h - base_size) - collision_padding;
 }
 
-Player::Player(float x, float y, const Controls& controls)
-    : AnimatedSprite(Resource::Cache::get().getAnimationData("player.yaml")),
+Player::Player(const std::string& anim_key, float x, float y, const Controls& controls)
+    : AnimatedSprite(Resource::Cache::get().getAnimationData(anim_key)),
       controls_(controls) {
     setPos(x, y);
     setCurrentAnimation("stand");

source/game/entities/player.hpp

@@ -36,7 +36,7 @@ class Player : public AnimatedSprite {
     // Ha de cridar-se abans d'instanciar Player; GameScene ho fa al ctor.
     static void loadFrom(const std::string& yaml_path);
 
-    Player(float x, float y, const Controls& controls);
+    Player(const std::string& anim_key, float x, float y, const Controls& controls);
 
     void update(float delta_time) override;
 

source/game/scenes/game_scene.cpp

@@ -4,7 +4,9 @@
 
 #include <algorithm>
 #include <cstddef>
+#include <filesystem>
 #include <iterator>
+#include <utility>
 #include <vector>
 
 #include "core/audio/audio.hpp"
@@ -23,25 +25,39 @@
 namespace {
 
     // La geometria ha de quedar inicialitzada abans que Tilemap parsejar el
-    // mateix YAML i abans que el ctor de Player consulte Map::PLAYFIELD_*.
-    // Cridar-la des d'una expressió que retorne la ruta permet encadenar-ho
-    // a l'init list sense fer Tilemap default-constructible.
-    auto loadMapGeometry(const char* yaml_path) -> const char* {
+    // mateix YAML i abans que el ctor de Player consulte Map::playfield_*.
+    // Construïm el Tilemap via un helper que primer carrega la geometria
+    // i després retorna el Tilemap per valor (move-construït).
+    auto makeTilemap(const std::string& yaml_path) -> Tilemap {
         Map::loadFrom(yaml_path);
-        return yaml_path;
+        return Tilemap(yaml_path);
     }
 
 }  // namespace
 
-GameScene::GameScene()
-    : tilemap_(loadMapGeometry("data/maps/pyramid.yaml")) {
-    Resource::Cache::get().loadSurface("player.gif", "data/player/player.gif");
-    Resource::Cache::get().loadAnimation("player.yaml", "data/player/player.yaml");
+auto GameScene::defaultConfig() -> Config {
+    return {
+        .map_yaml = Defaults::Pyramid::MAP_YAML,
+        .player_sprite = Defaults::Pyramid::PLAYER_SPRITE,
+        .player_yaml = Defaults::Pyramid::PLAYER_YAML,
+        .music_track = Defaults::Pyramid::MUSIC_TRACK,
+    };
+}
+
+GameScene::GameScene(Config config)
+    : config_(std::move(config)),
+      tilemap_(makeTilemap(config_.map_yaml)) {
+    // Convenció: el Resource::Cache indexa per basename del fitxer, perquè
+    // la mateixa clau l'usa el parseador d'animació (YAML > tileSetFile).
+    const auto SPRITE_KEY = std::filesystem::path(config_.player_sprite).filename().string();
+    const auto ANIM_KEY = std::filesystem::path(config_.player_yaml).filename().string();
+    Resource::Cache::get().loadSurface(SPRITE_KEY, config_.player_sprite);
+    Resource::Cache::get().loadAnimation(ANIM_KEY, config_.player_yaml);
 
     // Geometria de col·lisió del jugador (caixa 16×16, base 12): carregada
     // del mateix YAML que l'animació. Ha d'estar feta abans d'instanciar
     // Player perquè el spawn consulta `collision_*`.
-    Player::loadFrom("data/player/player.yaml");
+    Player::loadFrom(config_.player_yaml);
 
     // Jugador 0: fletxes del teclat (Defaults::KeysGame). Instanciar-ne un
     // segon només requereix afegir una altra entrada amb uns Controls
@@ -61,13 +77,13 @@ GameScene::GameScene()
         static_cast<float>(Map::playfield_y) + (static_cast<float>(Map::outer_corridor) / 2.0F);
     const auto SPAWN_X = CORRIDOR_CENTER_X - (static_cast<float>(Player::sprite_w) / 2.0F);
     const auto SPAWN_Y = CORRIDOR_CENTER_Y - static_cast<float>(Player::collision_y_offset) - (static_cast<float>(Player::collision_size) / 2.0F);
-    players_.emplace_back(std::make_unique<Player>(SPAWN_X, SPAWN_Y, CONTROLS_P1));
+    players_.emplace_back(std::make_unique<Player>(ANIM_KEY, SPAWN_X, SPAWN_Y, CONTROLS_P1));
 
-    // Música de fons de la piràmide 1 en bucle infinit. El track ja està al
-    // Resource::Cache (preload al Director), així que playMusic només mou el
-    // punter cap a jail_audio i obri l'stream.
+    // Música de fons en bucle infinit. El track ja està al Resource::Cache
+    // (preload al Director), així que playMusic només mou el punter cap a
+    // jail_audio i obri l'stream.
     if (Audio::get() != nullptr) {
-        Audio::get()->playMusic("pyramid_1.ogg", -1);
+        Audio::get()->playMusic(config_.music_track, -1);
     }
 }
 

source/game/scenes/game_scene.hpp

@@ -1,6 +1,7 @@
 #pragma once
 
 #include <memory>
+#include <string>
 #include <vector>
 
 #include "core/scene/scene.hpp"
@@ -10,13 +11,26 @@ class Player;
 
 class GameScene : public Scene {
    public:
-    GameScene();
+    // Conjunt de rutes que defineixen una piràmide concreta (mapa + tilemap
+    // + sprites del jugador + música). Cada piràmide serà un Config distint;
+    // `defaultConfig()` retorna la primera (Defaults::Pyramid).
+    struct Config {
+        std::string map_yaml;
+        std::string player_sprite;
+        std::string player_yaml;
+        std::string music_track;
+    };
+
+    [[nodiscard]] static auto defaultConfig() -> Config;
+
+    explicit GameScene(Config config = defaultConfig());
     ~GameScene() override;
 
     void update(int delta_ms) override;
     void render() override;
 
    private:
+    Config config_;
     Tilemap tilemap_;
 
     // Vector des del principi: AEE suportarà multijugador local; cada Player