tash list

diff --git a/include/Personajes.hpp b/include/Personajes.hpp
new file mode 100644
index 0000000..40c90a7
--- /dev/null
+++ b/include/Personajes.hpp
@@ -0,0 +1,40 @@
+//
+// Created by Rocco on 27/3/2025.
+//
+
+#ifndef PERSONAJES_H
+#define PERSONAJES_H
+
+#include "entidadGenerica.hpp"
+#include "wrapperVector.hpp"
+#include <iostream>
+#include <string>
+#include <utility>
+#include "list.hpp"
+
+/**
+ * @class Personaje
+ * @brief Representa un personaje
+ *
+ *
+ *
+ */
+class Personaje : public EntidadGenerica{
+protected :
+    float m_health;   //defino atributos genericos de personajes
+    float m_strength;
+    float m_energy;
+public:
+    /**
+     * @brief Constructor de personaje
+     *
+     * @param name Nombre del personaje
+     * @param strength Nivel de fuerza inicial del personaje
+     * @param energy energia inicial del personaje
+     */
+    Personaje(const std::string& name, float strength, float energy);
+    void showInfo() const override;
+    void doAction() const override;
+};
+
+#endif //PERSONAJES_H
diff --git a/include/dataStructures/list.hpp b/include/dataStructures/list.hpp
index ee9ad7f..802c8d6 100644
--- a/include/dataStructures/list.hpp
+++ b/include/dataStructures/list.hpp
@@ -40,7 +40,12 @@ public:
 
     ~LinkedList()
     {
-        throw std::runtime_error("Not implemented yet");
+        while(head != nullptr)
+        {
+            auto temporalNode = head;
+            head = head->next;
+            delete temporalNode;
+        }
     }
 
     /**
@@ -50,7 +55,14 @@ public:
      */
     void push_front(const TData& value)
     {
-        throw std::runtime_error("Not implemented yet");
+        auto node = new ListNode<TData>(value);
+        if (head == nullptr)
+        {
+            node->next = head;
+            head = node;
+        }
+        head = head->next;
+        head = node;
     }
 
     /**
@@ -60,7 +72,29 @@ public:
     */
     void remove_at(size_t position)
     {
-        throw std::runtime_error("Not implemented yet");
+        if (head == nullptr){return;} //si esta vacia no hace nada
+        int contador = 0;
+        if (position == 0) //caso de posicion 0
+        {
+            auto temporalNode = head;
+            head = head->next;
+            delete temporalNode;
+            return;
+        }
+        auto current = head;
+        ListNode<TData> previous = nullptr;
+        while (current != nullptr && contador < position)
+        {
+            previous = current;
+            current = current->next;
+            contador++;
+        }
+        if (current)
+        {
+            previous->next = current->next;
+            delete current;
+        }
+
     }
 
     /**
@@ -69,7 +103,45 @@ public:
     */
     ListNode<TData>* take(size_t startPosition, size_t nElements)
     {
-        throw std::runtime_error("Not implemented yet");
+        if (head == nullptr) return nullptr;
+        if (startPosition + nElements > size()){return nullptr;}
+        auto current = head;
+        int contador=0;
+        while (contador < startPosition)
+        {
+            current = current->next;
+            contador++;
+        }
+        auto nuevo = new LinkedList<TData>;
+        //punteros controladores
+        ListNode<TData> newhead = nullptr, newtail = nullptr;
+        for (size_t i = 0; i < nElements; i++)
+        {
+            auto copia = new ListNode(current->data);
+            if (newhead == nullptr) //primer nodo
+            {
+                newhead = copia;
+                newtail = copia;
+            } else //lo mandamos al final de la lista
+            {
+                newtail->next = copia;
+                newtail = copia;
+            }
+            current = current->next; //avanzamos al siguiente nodo
+        }
+        nuevo->head = newhead; //enlazamos el head de la nueva al primer nodo
+        return nuevo;
+    }
+
+    // Devuelve el tamaño de la lista
+    size_t size() const {
+        size_t count = 0;
+        auto current = head;
+        while (current) {
+            count++;
+            current = current->next;
+        }
+        return count;
     }
 
     /**
@@ -151,7 +223,12 @@ public:
      */
     void push_front(const TData& value)
     {
-        throw std::runtime_error("Not implemented yet");
+        auto node = new ListNode<TData>(value);
+        if (head == nullptr)
+        {
+            node->next = head;
+            head = node;
+        }
     }
 
     /**
diff --git a/include/dataStructures/wrapperVector.hpp b/include/dataStructures/wrapperVector.hpp
index c864053..137d899 100644
--- a/include/dataStructures/wrapperVector.hpp
+++ b/include/dataStructures/wrapperVector.hpp
@@ -5,9 +5,11 @@
 #ifndef WRAPPERVECTOR_HPP
 #define WRAPPERVECTOR_HPP
 
+#include <algorithm>
 #include <cstddef>
+#include <iostream>
+#include <ostream>
 #include <utility>
-#include <algorithm>
 
 auto constexpr INIT_CAPACITY {100}; //< Capacidad inicial del vector
 
@@ -113,6 +115,10 @@ public:
      */
     TData& operator[](size_t index)
     {
+        if (index >= m_size)
+        {
+            std::cout << "Indice fuera de limites" << std::endl;
+        }
         return m_data[index];
     }
 
@@ -121,6 +127,10 @@ public:
      */
     const TData& at(size_t index) const
     {
+        if (index >= m_size)
+        {
+            std::cout << "Indice fuera de limites" << std::endl;
+        }
         return m_data[index];
     }
 
diff --git a/include/inventarioRefugio.hpp b/include/inventarioRefugio.hpp
new file mode 100644
index 0000000..d385d79
--- /dev/null
+++ b/include/inventarioRefugio.hpp
@@ -0,0 +1,147 @@
+/*
+ * Inventario del Refugio 33
+ * Copyright (C) 2025, AyED COM-VIRTUAL
+ * Marzo 13, 2025.
+ */
+
+#ifndef _INVENTARIO_REFUGIO_HPP
+#define _INVENTARIO_REFUGIO_HPP
+
+#include <iostream>
+#include <string>
+
+/**
+ * @brief Clase que representa un objeto de tipo WrapperVectorInventario. Una implementación de un vector para el
+ * inventario del refugio.
+ */
+class WrapperVectorInventario
+{
+private:
+    std::string* m_data; //< Puntero a un string que representa el inventario del refugio.
+    size_t m_size;       //< Tamaño del inventario del refugio.
+    size_t m_capacity;   //< Capacidad del inventario del refugio.
+
+    /**
+     * @brief Método que se encarga de redimensionar el inventario del refugio.
+     */
+    void resize(){ //es como el metodo expandir
+      m_capacity = (m_capacity == 0) ? 100 : m_capacity * 2;
+      auto* nuevo_data = new std::string[m_capacity];
+      for (std::string* ptr = m_data; ptr < m_data + m_size; ++ptr) {
+       nuevo_data[ptr - m_data] = *ptr;
+      }
+      delete[] m_data;
+      m_data = nuevo_data;
+    };
+
+public:
+    /**
+     * @brief Constructor de la clase WrapperVectorInventario.
+     */
+    WrapperVectorInventario()
+        : m_data(nullptr)
+        , m_size(0)
+        , m_capacity(0) {};
+
+    /**
+     * @brief Destructor de la clase WrapperVectorInventario.
+     */
+    ~WrapperVectorInventario()
+    {
+        delete[] m_data;
+    }
+
+    /**
+     * @brief Método que se encarga de agregar un elemento al inventario del refugio.
+     *
+     * @param item Elemento a agregar al inventario del refugio.
+     */
+    void pushBack(const std::string& item)
+    {
+        if (m_size == m_capacity)
+        {
+            resize();
+        }
+        m_data[m_size++] = item;
+    }
+
+    /**
+     * @brief Método que se encarga de obtener un elemento del inventario del refugio.
+     */
+    std::string& getAt(size_t index) //el metodo devuelve una referencia a un string, no devuelve una copia
+                                     //devuelve un acceso directo al objeto guardado en m_data
+    {
+        return m_data[index];      //con el podemos modificar directamente el objeto dentro
+    }                                //por ej: getAt(2) = "nuevo valor";
+    //la funcion getAt que toma como parametro un indice size_t(entero sin signo) que se usa para representar
+    // tamaños o indices en contenedores estandar
+    /**
+     * @brief Método que se encarga de obtener el tamaño del inventario del refugio.
+     */
+    size_t size() const{
+      return m_size;
+    };
+
+    /**
+     * @brief Método que se encarga de obtener la capacidad del inventario del refugio.
+     */
+    size_t capacity() const{
+      return m_capacity;
+    };
+
+    /**
+     * @brief Método que se encarga de imprimir el inventario del refugio.
+     */
+    void print() const{
+      if (m_size == 0){
+        std::cout<<"Inventario sin elementos"<<std::endl;
+        return;
+      }
+      std::cout << "===Inventario del refugio==== " << std::endl;
+      for (auto* ptr = begin(); ptr < end(); ++ptr) {
+        std::cout << *ptr << std::endl;
+      }
+    };
+
+    /**
+     * @brief Método que se encarga de eliminar el último elemento del inventario del refugio.
+     */
+    void popBack(){
+      if (m_size == 0){
+        std::cout<<"Inventario sin elementos, no se puede eliminar elemento"<<std::endl;
+        return;
+      }
+      std::destroy_at(&m_data[m_size - 1]); // Destruimos el último elemento
+      --m_size;
+    };
+
+    /**
+     * @brief Iterador final del inventario del refugio.
+     */
+    std::string* end() const
+    {
+        return m_data + m_size;
+    }
+
+    /**
+     * @brief Iterador comienzo del inventario del refugio.
+     */
+    std::string* begin() const{
+      return m_data;
+    };
+
+    /**
+     * @brief Intercambiar dos WrapperVectorInventario. (Swap)
+     */
+    void swap(WrapperVectorInventario& other){
+      /*auto* ptr = m_data;
+      m_data = other.m_data;
+      m_size = other.m_size;
+      other.m_data = ptr;
+      other.m_size = m_size;*/
+      std::swap(m_data, other.m_data);
+      std::swap(m_size, other.m_size);
+      std::swap(m_capacity, other.m_capacity); //swap implementado por c++ mas seguro y eficiente
+    };
+};
+#endif // _INVENTARIO_REFUGIO_HPP
\ No newline at end of file
diff --git a/src/refugio.cpp b/src/refugio.cpp
index 9d94711..09a55a0 100644
--- a/src/refugio.cpp
+++ b/src/refugio.cpp
@@ -1,5 +1,7 @@
 #include "refugio.hpp"
 
+#include <utility>
+
 Refugio::Refugio(const std::string& name, float defense, float attack)
     : EntidadGenerica(name)
     , m_defense(defense)
@@ -28,24 +30,43 @@ void Refugio::doAction() const
 
 void Refugio::addRefugee(const std::string& refugee)
 {
-    throw std::runtime_error("Not implemented yet");
+    m_refugees.push_back(refugee);
+    std::cout<< "se ha añadido el morador" << refugee << "al refugio 33" <<std::endl;
 }
 
 void Refugio::addResource(const std::string& resource, float amount)
 {
-    throw std::runtime_error("Not implemented yet");
+    m_resources.push_back(std::pair(resource,amount));
 }
 
 bool Refugio::consumeResource(const std::string& resource, float amount)
 {
-    throw std::runtime_error("Not implemented yet");
-    return false;
+    for (auto it=m_resources.begin(); it < m_resources.end(); ++it )
+    {
+        if (it->first == resource)
+        {
+            if (it->second >= amount)
+            {
+                it->second -= amount;
+                std::cout << "Se ha consumido "<<amount<<" de "<<resource<<std::endl;
+                return true;
+            }
+            else
+            {
+                std::cout << "No hay suficiente recurso" << std::endl;
+                return false;
+            }
+        }
+        else{std::cout << "No hay recurso con ese nombre" << std::endl; return false;}
+    }
 }
 
 void Refugio::registerVisitant(const std::string& nombre, const std::string& faccion)
 {
+    Visitante visitante{nombre, faccion};
     // if (!isSafeFaction(faccion)) {
-    throw std::runtime_error("Not implemented yet");
+    if (m_visitants == nullptr){m_visitants= new DoublyLinkedList<Visitante>();}
+    m_visitants->push_front(visitante);
     // }
 }
 
@@ -69,5 +90,11 @@ void Refugio::printRecursive(DoublyListNode<Visitante>* mNode)
 
 bool Refugio::hasFactionVisited(const std::string& faccion) const
 {
-    throw std::runtime_error("Not implemented yet");
+    auto it=m_visitants->get_head();
+    while (it != nullptr)
+    {
+        if (it->data.faccion == faccion){return true;}
+        if (it == nullptr){return false;}
+        it = it->next;
+    }
 }