treballant en Background i Stage

source/stage.cpp

@@ -1,14 +1,16 @@
 #include "stage.h"
-
 #include <algorithm>
 
 // ===== 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) {}
+    : power_to_complete_(power_to_complete), min_menace_(min_menace), 
+      max_menace_(max_menace), name_(name), status_(StageStatus::LOCKED) {}
 
 // ===== IMPLEMENTACIÓN DE StageManager =====
 StageManager::StageManager()
-    : current_power_(0), total_power_(0), current_stage_index_(0), power_collection_state_(PowerCollectionState::ENABLED) {
+    : current_power_(0), total_power_(0), current_stage_index_(0), 
+      power_collection_state_(PowerCollectionState::ENABLED),
+      power_change_callback_(nullptr) {
     initialize();
 }
 
@@ -44,9 +46,9 @@ bool StageManager::advanceToNextStage() {
     if (!isCurrentStageCompleted() || current_stage_index_ >= stages_.size() - 1) {
         return false;
     }
-
+    
     current_stage_index_++;
-    current_power_ = 0;  // Reiniciar poder para la nueva fase
+    current_power_ = 0; // Reiniciar poder para la nueva fase
     updateStageStatuses();
     return true;
 }
@@ -55,18 +57,18 @@ bool StageManager::jumpToStage(size_t target_stage_index) {
     if (!validateStageIndex(target_stage_index)) {
         return false;
     }
-
+    
     // Calcular el poder total acumulado hasta la fase objetivo
     int accumulated_power = 0;
     for (size_t i = 0; i < target_stage_index; ++i) {
         accumulated_power += stages_[i].getPowerToComplete();
     }
-
+    
     // Actualizar estado
     current_stage_index_ = target_stage_index;
-    current_power_ = 0;                // Empezar la fase objetivo sin poder
+    current_power_ = 0;  // Empezar la fase objetivo sin poder
     total_power_ = accumulated_power;  // Poder total como si hubiéramos completado las anteriores
-
+    
     updateStageStatuses();
     return true;
 }
@@ -75,7 +77,7 @@ bool StageManager::subtractPower(int amount) {
     if (amount <= 0 || current_power_ < amount) {
         return false;
     }
-
+    
     current_power_ -= amount;
     updateStageStatuses();
     return true;
@@ -105,7 +107,7 @@ bool StageManager::isCurrentStageCompleted() const {
     if (!current_stage.has_value()) {
         return false;
     }
-
+    
     return current_power_ >= current_stage->getPowerToComplete();
 }
 
@@ -115,10 +117,10 @@ bool StageManager::isGameCompleted() const {
 
 double StageManager::getProgressPercentage() const {
     if (stages_.empty()) return 0.0;
-
-    int total_power_needed = getTotalPowerNeededToCompleteGame();
+    
+    int total_power_needed = getTotalPowerNeededToCompleteGame();  // ⬅️ Usar el nuevo método
     if (total_power_needed == 0) return 100.0;
-
+    
     return (static_cast<double>(total_power_) / total_power_needed) * 100.0;
 }
 
@@ -131,12 +133,12 @@ double StageManager::getCurrentStageProgressFraction() const {
     if (!current_stage.has_value()) {
         return 0.0;
     }
-
+    
     int power_needed = current_stage->getPowerToComplete();
     if (power_needed == 0) {
         return 1.0;
     }
-
+    
     // Retorna fracción entre 0.0 y 1.0
     double fraction = static_cast<double>(current_power_) / power_needed;
     return std::min(fraction, 1.0);
@@ -147,7 +149,7 @@ int StageManager::getPowerNeededForCurrentStage() const {
     if (!current_stage.has_value()) {
         return 0;
     }
-
+    
     return std::max(0, current_stage->getPowerToComplete() - current_power_);
 }
 
@@ -168,10 +170,14 @@ void StageManager::addPower(int amount) {
     if (amount <= 0 || !canCollectPower()) {
         return;
     }
-
+    
     current_power_ += amount;
     total_power_ += amount;
 
+    if (power_change_callback_) {
+    power_change_callback_(amount);
+}
+    
     // Verificar si se completó la fase actual
     if (isCurrentStageCompleted()) {
         auto current_stage = getCurrentStage();
@@ -179,7 +185,7 @@ void StageManager::addPower(int amount) {
             stages_[current_stage_index_].setStatus(StageStatus::COMPLETED);
         }
     }
-
+    
     updateStageStatuses();
 }
 
@@ -188,7 +194,7 @@ int StageManager::getCurrentMenaceLevel() const {
     if (!current_stage.has_value()) {
         return 0;
     }
-
+    
     return current_stage->getMinMenace();
 }
 
@@ -207,4 +213,12 @@ void StageManager::updateStageStatuses() {
             stages_[i].setStatus(StageStatus::LOCKED);
         }
     }
+}
+
+void StageManager::setPowerChangeCallback(PowerChangeCallback callback) {
+    power_change_callback_ = callback;
+}
+
+void StageManager::removePowerChangeCallback() {
+    power_change_callback_ = nullptr;
 }