Añade gestión pausas

src/nivel.cpp

@@ -108,9 +108,11 @@ void Nivel::procesa_cambio_de_fase(
     switch (nueva_fase) {
         case FaseNivel::Activa:
             assert(fase_previa == FaseNivel::MostrandoInstrucciones);
+            GestorTiempoJuego::activar();
             break;
         case FaseNivel::EsperaAntesDeResultado:
             assert(fase_previa == FaseNivel::Activa);
+            GestorTiempoJuego::pausar();
             timer_espera_antes_de_resultado.start(
                 tiempos::RETARDO_ANTES_DE_RESULTADO
             );
@@ -146,6 +148,8 @@ AccionGeneral Nivel::ejecutar() {
     Timer timer_fin_nivel;
     sf::Sound sound;
 
+    GestorTiempoJuego::reiniciar();
+
     assert(!contadores.empty());
     // std::cout << "Empezando ciclo de juego en nivel()" << std::endl;
     while (globales.window.isOpen()) {

src/tiempo.cpp

@@ -3,6 +3,11 @@
 #include <cassert>
 #include <chrono>
 
+// Asignacion miembros estaticos
+TiempoJuego GestorTiempoJuego::previo = TiempoJuego_CERO;
+Tiempo GestorTiempoJuego::ultima_activacion = Tiempo::CERO;
+bool GestorTiempoJuego::en_pausa = true;
+
 std::string pad_with_zeroes(int n) {
     assert(n >= 0);
     if (n > 59) {
@@ -19,7 +24,7 @@ std::string pad_with_zeroes(int n) {
 // Tiempo
 //////////////////////////////////////////
 
-bool Tiempo::operator<(const Tiempo &otro) const { // fmt
+bool Tiempo::operator<(const Tiempo &otro) const { //
     return _ms < otro._ms;
 }
 
@@ -125,30 +130,29 @@ const TiempoJuego TiempoJuego::operator-(const TiempoJuego &otro) const {
 // GestorTiempoJuego
 //////////////////////////////////////////
 
-void GestorTiempoJuego::contabilizar() {
-    const auto actual = obtener_tiempo_actual();
-    const auto transcurrido = actual - ultima_contabilizacion;
-    contabilizado = TiempoJuego::desde_milisegundos(
-        contabilizado.obtener_milisegundos() +
-        transcurrido.obtener_milisegundos()
-    );
-}
-
 TiempoJuego GestorTiempoJuego::obtener_tiempo_juego() {
-    // TODO: implementar con pausas
-    return TiempoJuego::desde_milisegundos(
-        obtener_tiempo_actual().obtener_milisegundos()
-    );
+    if (en_pausa) {
+        return previo;
+    }
+    const auto transcurrido = obtener_tiempo_actual() - ultima_activacion;
+    return previo +
+           TiempoJuego::desde_milisegundos(transcurrido.obtener_milisegundos());
 }
 
 void GestorTiempoJuego::activar() {
     assert(en_pausa);
+    ultima_activacion = obtener_tiempo_actual();
     en_pausa = false;
 }
 void GestorTiempoJuego::pausar() {
     assert(!en_pausa);
+    previo = obtener_tiempo_juego();
+    en_pausa = true;
+}
+void GestorTiempoJuego::reiniciar() {
     en_pausa = true;
+    previo = TiempoJuego_CERO;
+    ultima_activacion = Tiempo::CERO;
 }
-TiempoJuego GestorTiempoJuego::obtener_transcurrido() { return contabilizado; }
 
 const Tiempo Tiempo::CERO = Tiempo::desde_milisegundos(0);

src/tiempo.h

@@ -82,19 +82,18 @@ struct TiempoPreparacion {
 // GestorTiempoJuego
 //////////////////////////////////////////
 
-/* Provisional. Debe poder activarse y pausarse */
 struct GestorTiempoJuego {
 
   private:
-    TiempoJuego contabilizado = TiempoJuego_CERO;
-    Tiempo ultima_contabilizacion = Tiempo::CERO;
-    bool en_pausa = true;
-    void contabilizar();
+    // Tiempo de juego contabilizado previamente
+    static TiempoJuego previo;
+    static Tiempo ultima_activacion;
+    static bool en_pausa;
 
   public:
-    GestorTiempoJuego() {}
+    GestorTiempoJuego() = delete;
     static TiempoJuego obtener_tiempo_juego();
-    void activar();
-    void pausar();
-    TiempoJuego obtener_transcurrido();
+    static void activar();
+    static void pausar();
+    static void reiniciar();
 };