v1 implementacion pila_cola

include/characters/artefactoUnico.hpp

@@ -83,6 +83,11 @@ class ArtefactoUnico : public EntidadGenerica
     {
         return m_durability <= 0.0;
     }
+
+    std::string nombre() const
+    {
+        return this->m_name;
+    }
 };
 
 #endif // ARTEFACTOUNICO_HPP

include/characters/caravana.hpp

@@ -0,0 +1,50 @@
+#ifndef CARAVAN_HPP
+#define CARAVAN_HPP
+
+#include "artefactoUnico.hpp"
+#include "entidadGenerica.hpp"
+#include <iostream>
+#include <memory>
+#include <vector>
+
+/**
+ * @class Caravana
+ * @brief Representa a los comerciantes itinerantes de artefactos únicos.
+ *
+ * La caravana viaja por el yermo ofreciendo artículos extremadamente raros a precios elevados.
+ */
+class Caravana : public EntidadGenerica
+{
+private:
+    std::vector<std::shared_ptr<ArtefactoUnico>> m_stock; ///< Lista de artefactos únicos disponibles
+    bool m_confia;                                        ///< Confianza en el refugio
+
+public:
+    /**
+     * @brief Constructor
+     * @param nombre Nombre de la caravana
+     * @param confia Indica si la caravana está dispuesta a comerciar
+     */
+    Caravana(const std::string& nombre, bool confia);
+    /**
+     * @brief Muestra el inventario de la caravana
+     */
+    void showInfo() const override;
+
+    /**
+     * @brief Intenta comprar un artefacto
+     * @param nombre Nombre del artefacto
+     * @return Puntero al artefacto si se realizó la transacción, nullptr en caso contrario
+     */
+    std::shared_ptr<ArtefactoUnico> comprarArtefacto(const std::string& nombre);
+
+    /**
+     * @brief Simula una evaluación de confianza futura
+     */
+    void evaluarConfianza();
+
+private:
+    void inicializarStock();
+};
+
+#endif // CARAVAN_HPP

include/characters/chracterVisitant.hpp

@@ -0,0 +1,51 @@
+//
+// Created by gvalenzuela on 3/30/25.
+//
+
+#ifndef CHRACTERVISITANT_HPP
+#define CHRACTERVISITANT_HPP
+
+#include "characters/artefactoUnico.hpp"
+#include "characters/asaltante.hpp"
+#include "characters/caravana.hpp"
+#include "characters/enclave.hpp"
+#include "characters/ghoul.hpp"
+#include "characters/hermanosDeAcero.hpp"
+#include "characters/mercader.hpp"
+#include "characters/mercaderAgua.hpp"
+#include "characters/mutantes.hpp"
+#include "characters/refugiado.hpp"
+#include "characters/refugio.hpp"
+#include "characters/saqueador.hpp"
+
+using VisitanteVariant = std::variant<
+Refugiado,
+Mercader,
+MercaderAgua,
+Saqueador,
+HermanoAcero,
+Enclave,
+Mutante,
+Asaltante,
+Ghoul,
+Caravana
+>;
+
+namespace NPC {
+    enum class VisitantCategory
+    {
+        REFUGEE,
+        BROTHER,
+        ENEMY,
+        MERCHANT,
+        CARAVAN
+    };
+
+    struct VisitantChance
+    {
+        VisitantCategory type;
+        double weight;
+    };
+};
+
+#endif //CHRACTERVISITANT_HPP

include/characters/enclave.hpp

@@ -24,78 +24,41 @@ class Enclave : public EntidadGenerica
      * @brief Constructor
      * @param nombre Nombre del escuadrón
      */
-    explicit Enclave(const std::string& nombre)
-        : EntidadGenerica(nombre)
-        , m_fuerza(generarFuerza())
-        , m_potencia(generarPotencia())
-        , m_detectado(false)
-    {
-    }
+    explicit Enclave(const std::string& nombre);
 
     /**
      * @brief Muestra información de la escuadra ENCLAVE
      */
-    void showInfo() const override
-    {
-        std::cout << "💂🏻 ENCLAVE - Escuadrón: " << m_name << "\n"
-                  << " - Soldados: " << m_fuerza << "\n"
-                  << " - Potencia táctica: " << m_potencia << "\n"
-                  << " - ¿Han detectado el refugio?: " << (m_detectado ? "Sí" : "No") << "\n";
-    }
+    void showInfo() const override;
 
     /**
      * @brief Simula la detección del refugio
      */
-    void detectarRefugio()
-    {
-        m_detectado = true;
-        std::cout << "💬 " << m_name << " >>> Objetivo confirmado. Preparando ofensiva." << std::endl;
-    }
+    void detectarRefugio();
 
     /**
      * @brief Devuelve si la escuadra ya ha detectado el refugio
      */
-    bool haDetectado() const
-    {
-        return m_detectado;
-    }
+    bool haDetectado() const;
 
     /**
      * @brief Devuelve la fuerza de combate
      */
-    int fuerza() const
-    {
-        return m_fuerza;
-    }
-
+    int fuerza() const;
     /**
      * @brief Devuelve la potencia de ataque
      */
-    double potencia() const
-    {
-        return m_potencia;
-    }
+    double potencia() const;
 
 private:
     /**
      * @brief Genera aleatoriamente una cantidad de soldados entre 10 y 50
      */
-    int generarFuerza() const
-    {
-        static std::mt19937 rng(std::random_device {}());
-        std::uniform_int_distribution<int> dist(10, 50);
-        return dist(rng);
-    }
-
+    int generarFuerza();
     /**
      * @brief Genera aleatoriamente un valor de potencia entre 2.5 y 5.0
      */
-    double generarPotencia() const
-    {
-        static std::mt19937 rng(std::random_device {}());
-        std::uniform_real_distribution<double> dist(2.5, 5.0);
-        return dist(rng);
-    }
+    double generarPotencia() const;
 };
 
 #endif // ENCLAVE_HPP

include/characters/hermanosDeAcero.hpp

@@ -0,0 +1,94 @@
+#ifndef HERMANO_ACERO_HPP
+#define HERMANO_ACERO_HPP
+
+#include "entidadGenerica.hpp"
+#include <iostream>
+
+/**
+ * @class HermanoAcero
+ * @brief Representa a un miembro de la Hermandad del Acero.
+ *
+ * Poseen entrenamiento militar avanzado y pueden usar artefactos únicos.
+ * Requieren muchos recursos y son estrictos con su permanencia en un refugio.
+ */
+class HermanoAcero : public EntidadGenerica
+{
+private:
+    int m_entrenamiento; ///< Nivel de entrenamiento (impacta en defensa del refugio)
+    double m_suministros;   ///< Recursos necesarios para mantenerlo
+    bool m_enRefugio;    ///< Si actualmente vive en un refugio
+    int m_consumoMinimo; ///< Cuántos recursos necesita por turno
+
+public:
+    /**
+     * @brief Constructor
+     * @param nombre Nombre del miembro
+     * @param entrenamiento Nivel de habilidad (100 por defecto)
+     */
+    HermanoAcero(const std::string& nombre, int entrenamiento = 100)
+        : EntidadGenerica(nombre)
+        , m_entrenamiento(entrenamiento)
+        , m_suministros(0.20f) // 20% de los suministros del refugio
+        , m_enRefugio(false)
+        , m_consumoMinimo(20) // el doble de lo estándar
+    {
+    }
+
+    /**
+     * @brief Muestra información del hermano del acero
+     */
+    void showInfo() const override
+    {
+        std::cout << "⚙️ Hermano del Acero: " << m_name << "\n"
+                  << " - Nivel de entrenamiento: " << m_entrenamiento << "\n"
+                  << " - Suministros actuales: " << m_suministros << "\n"
+                  << " - En refugio: " << (m_enRefugio ? "Sí" : "No") << "\n";
+    }
+
+    /**
+     * @brief Intenta ingresar al refugio
+     * @param recursosDisponibles Recursos disponibles del refugio
+     * @return Recursos consumidos, o 0 si no fue aceptado
+     */
+    int solicitarIngreso(int recursosDisponibles)
+    {
+        if (recursosDisponibles >= m_consumoMinimo)
+        {
+            m_enRefugio = true;
+            std::cout << "💬" << m_name << " >>> Por la tecnología, serviré a este refugio." << std::endl;
+            return m_consumoMinimo;
+        }
+        else
+        {
+            std::cout << "💬" << m_name << " >>> Sus recursos no están a la altura de la Hermandad." << std::endl;
+            return 0;
+        }
+    }
+
+    /**
+     * @brief Consume recursos cada ciclo, si no hay suficientes abandona el refugio
+     */
+    void consumir()
+    {
+        if (m_suministros >= m_consumoMinimo)
+        {
+            m_suministros -= m_consumoMinimo;
+            std::cout << "💬" << m_name << " >>> Reabastecido. Listo para defender." << std::endl;
+        }
+        else
+        {
+            m_enRefugio = false;
+            std::cout << "💬" << m_name << " >>> Sin suministros. Este refugio no merece protección." << std::endl;
+        }
+    }
+
+    /**
+     * @brief Saber si está aún en el refugio
+     */
+    bool estaEnRefugio() const
+    {
+        return m_enRefugio;
+    }
+};
+
+#endif // HERMANO_ACERO_HPP

include/dataStructures/queue.hpp

@@ -0,0 +1,88 @@
+#ifndef QUEUE_HPP
+#define QUEUE_HPP
+
+#include <stdexcept>
+
+
+/**
+ * @brief Estructura de datos tipo Cola (FIFO - First In, First Out)
+ *
+ * @tparam TData Tipo de dato almacenado en la cola
+ */
+template<typename TData>
+class Queue
+{
+private:
+    /**
+     * @brief Nodo de la cola
+     */
+    struct Node
+    {
+        TData data;     ///< Dato almacenado
+        Node* next; ///< Puntero al siguiente nodo
+
+        explicit Node(const TData& value)
+            : data(value)
+            , next(nullptr)
+        {
+        }
+    };
+
+    Node* m_front; ///< Puntero al primer elemento
+    Node* m_rear;  ///< Puntero al último elemento
+    size_t m_size; ///< Cantidad de elementos en la cola
+
+public:
+    /**
+     * @brief Constructor por defecto
+     */
+    Queue();
+
+    /**
+     * @brief Destructor: libera todos los nodos de la cola
+     */
+    ~Queue();
+
+    /**
+     * @brief Inserta un elemento al final de la cola
+     *
+     * @param value Valor a insertar
+     */
+    void enqueue(const TData& value);
+    /**
+     * @brief Elimina el primer elemento de la cola
+     *
+     * @throws std::underflow_error si la cola está vacía
+     */
+    void dequeue();
+
+    /**
+     * @brief Devuelve el primer elemento sin eliminarlo
+     *
+     * @return TData Primer valor en la cola
+     * @throws std::underflow_error si la cola está vacía
+     */
+    TData front() const;
+
+    /**
+     * @brief Verifica si la cola está vacía
+     *
+     * @return true si no hay elementos
+     * @return false si hay al menos un elemento
+     */
+    bool isEmpty() const;
+    /**
+     * @brief Devuelve la cantidad de elementos en la cola
+     *
+     * @return size_t tamaño de la cola
+     */
+    size_t getSize() const;
+
+    void print_all();
+
+    void printHead();
+
+    void clear();                     
+};
+
+#endif // QUEUE_HPP