Stage ja carrega desde fitxer la informació de les fases

source/stage.cpp

@@ -1,12 +1,14 @@
 #include "stage.h"
 #include <algorithm>
+#include <fstream>
+#include <sstream>
 
-// ===== IMPLEMENTACIÓN DE StageData =====
+// Implementación de StageData
 StageData::StageData(int power_to_complete, int min_menace, int max_menace, const std::string& name)
     : power_to_complete_(power_to_complete), min_menace_(min_menace), 
       max_menace_(max_menace), name_(name), status_(StageStatus::LOCKED) {}
 
-// ===== IMPLEMENTACIÓN DE StageManager =====
+// Implementación de StageManager
 StageManager::StageManager()
     : current_power_(0), total_power_(0), current_stage_index_(0), 
       power_collection_state_(PowerCollectionState::ENABLED),
@@ -20,6 +22,17 @@ void StageManager::initialize() {
     reset();
 }
 
+void StageManager::initialize(const std::string& stages_file) {
+    stages_.clear();
+    
+    // Intentar cargar desde archivo, si falla usar valores predeterminados
+    if (!loadStagesFromFile(stages_file)) {
+        createDefaultStages();
+    }
+    
+    reset();
+}
+
 void StageManager::reset() {
     current_power_ = 0;
     total_power_ = 0;
@@ -29,7 +42,7 @@ void StageManager::reset() {
 }
 
 void StageManager::createDefaultStages() {
-    // Crear las 10 fases como en tu código original
+    // Crear las 10 fases predeterminadas con dificultad progresiva
     stages_.emplace_back(200, 7 + (4 * 1), 7 + (4 * 3), "Tutorial");
     stages_.emplace_back(300, 7 + (4 * 2), 7 + (4 * 4), "Primeros pasos");
     stages_.emplace_back(600, 7 + (4 * 3), 7 + (4 * 5), "Intensificación");
@@ -42,6 +55,69 @@ void StageManager::createDefaultStages() {
     stages_.emplace_back(950, 7 + (4 * 7), 7 + (4 * 10), "Maestría");
 }
 
+bool StageManager::loadStagesFromFile(const std::string& filename) {
+    std::ifstream file(filename);
+    if (!file.is_open()) {
+        return false; // No se pudo abrir el archivo
+    }
+    
+    std::string line;
+    int line_number = 0;
+    
+    while (std::getline(file, line)) {
+        line_number++;
+        
+        // Ignorar líneas vacías y comentarios (líneas que empiezan con #)
+        if (line.empty() || line[0] == '#') {
+            continue;
+        }
+        
+        // Parsear línea: power_to_complete,min_menace,max_menace,name
+        std::stringstream ss(line);
+        std::string token;
+        std::vector<std::string> tokens;
+        
+        // Dividir por comas
+        while (std::getline(ss, token, ',')) {
+            // Eliminar espacios en blanco al inicio y final
+            token.erase(0, token.find_first_not_of(" \t"));
+            token.erase(token.find_last_not_of(" \t") + 1);
+            tokens.push_back(token);
+        }
+        
+        // Verificar que tenemos exactamente 4 campos
+        if (tokens.size() != 4) {
+            // Error de formato, continuar con la siguiente línea
+            continue;
+        }
+        
+        try {
+            // Convertir a enteros los primeros tres campos
+            int power_to_complete = std::stoi(tokens[0]);
+            int min_menace = std::stoi(tokens[1]);
+            int max_menace = std::stoi(tokens[2]);
+            std::string name = tokens[3];
+            
+            // Validar valores
+            if (power_to_complete <= 0 || min_menace < 0 || max_menace < min_menace) {
+                continue; // Valores inválidos, saltar línea
+            }
+            
+            // Crear y añadir la fase
+            stages_.emplace_back(power_to_complete, min_menace, max_menace, name);
+            
+        } catch (const std::exception&) {
+            // Error de conversión, continuar con la siguiente línea
+            continue;
+        }
+    }
+    
+    file.close();
+    
+    // Verificar que se cargó al menos una fase
+    return !stages_.empty();
+}
+
 bool StageManager::advanceToNextStage() {
     if (!isCurrentStageCompleted() || current_stage_index_ >= stages_.size() - 1) {
         return false;
@@ -58,7 +134,7 @@ bool StageManager::jumpToStage(size_t target_stage_index) {
         return false;
     }
     
-    // Calcular el poder total acumulado hasta la fase objetivo
+    // Calcular el poder acumulado hasta la fase objetivo
     int accumulated_power = 0;
     for (size_t i = 0; i < target_stage_index; ++i) {
         accumulated_power += stages_[i].getPowerToComplete();
@@ -66,8 +142,8 @@ bool StageManager::jumpToStage(size_t target_stage_index) {
     
     // Actualizar estado
     current_stage_index_ = target_stage_index;
-    current_power_ = 0;  // Empezar la fase objetivo sin poder
-    total_power_ = accumulated_power;  // Poder total como si hubiéramos completado las anteriores
+    current_power_ = 0;  // Comenzar la fase objetivo sin poder
+    total_power_ = accumulated_power;  // Poder total como si se hubieran completado las anteriores
     
     updateStageStatuses();
     return true;
@@ -118,7 +194,7 @@ bool StageManager::isGameCompleted() const {
 double StageManager::getProgressPercentage() const {
     if (stages_.empty()) return 0.0;
     
-    int total_power_needed = getTotalPowerNeededToCompleteGame();  // ⬅️ Usar el nuevo método
+    int total_power_needed = getTotalPowerNeededToCompleteGame();
     if (total_power_needed == 0) return 100.0;
     
     return (static_cast<double>(total_power_) / total_power_needed) * 100.0;
@@ -139,7 +215,7 @@ double StageManager::getCurrentStageProgressFraction() const {
         return 1.0;
     }
     
-    // Retorna fracción entre 0.0 y 1.0
+    // Devuelve una fracción entre 0.0 y 1.0
     double fraction = static_cast<double>(current_power_) / power_needed;
     return std::min(fraction, 1.0);
 }
@@ -161,7 +237,7 @@ int StageManager::getTotalPowerNeededToCompleteGame() const {
     return total_power_needed;
 }
 
-// ===== IMPLEMENTACIÓN DE IStageInfo (lo que ven Player y Balloon) =====
+// Implementación de la interfaz IStageInfo
 bool StageManager::canCollectPower() const {
     return power_collection_state_ == PowerCollectionState::ENABLED;
 }
@@ -174,9 +250,10 @@ void StageManager::addPower(int amount) {
     current_power_ += amount;
     total_power_ += amount;
 
+    // Ejecutar callback si está registrado
     if (power_change_callback_) {
-    power_change_callback_(amount);
-}
+        power_change_callback_(amount);
+    }
     
     // Verificar si se completó la fase actual
     if (isCurrentStageCompleted()) {
@@ -198,12 +275,22 @@ int StageManager::getCurrentMenaceLevel() const {
     return current_stage->getMinMenace();
 }
 
-// ===== MÉTODOS PRIVADOS =====
+// Gestión de callbacks
+void StageManager::setPowerChangeCallback(PowerChangeCallback callback) {
+    power_change_callback_ = callback;
+}
+
+void StageManager::removePowerChangeCallback() {
+    power_change_callback_ = nullptr;
+}
+
+// Métodos privados
 bool StageManager::validateStageIndex(size_t index) const {
     return index < stages_.size();
 }
 
 void StageManager::updateStageStatuses() {
+    // Actualizar el estado de cada fase según su posición relativa a la actual
     for (size_t i = 0; i < stages_.size(); ++i) {
         if (i < current_stage_index_) {
             stages_[i].setStatus(StageStatus::COMPLETED);
@@ -213,12 +300,4 @@ void StageManager::updateStageStatuses() {
             stages_[i].setStatus(StageStatus::LOCKED);
         }
     }
-}
-
-void StageManager::setPowerChangeCallback(PowerChangeCallback callback) {
-    power_change_callback_ = callback;
-}
-
-void StageManager::removePowerChangeCallback() {
-    power_change_callback_ = nullptr;
 }