v0.10.0

Author: MatiasVME

AGENTS.md

@@ -7,13 +7,14 @@
 
 
 ## Dev environment tips
+
 - Godot Engine documentation: https://docs.godotengine.org/en/stable/
 - Godot Engine GDScript style guide: https://docs.godotengine.org/en/stable/tutorials/scripting/gdscript/gdscript_styleguide.html
 - Use properties instead of setter and getter methods
+- Comments in english
 
 
 ## Testing instructions
 
 - Use GUT to unitary tests https://github.com/bitwes/Gut
 - Tests are located in the `tests/unit` directory.
-

README.md

@@ -15,24 +15,30 @@ For example:
 
 ## Project Status
 
-The project is usable, though some nodes are still incomplete.  
+The project is production-ready with comprehensive inventory management, character systems, and robust testing coverage.  
 Unit tests are written with [GUT](https://github.com/bitwes/Gut/).
 
-![](addons/rpg_nodes/icons/RPGCharacter.png) **RPGCharacter:** Very usable – tested with unit tests (GUT)!!
+### Production Ready Features
+
+![](addons/rpg_nodes/icons/RPGCharacter.png) **RPGCharacter:** Production-ready – tested with unit tests (GUT) and enhanced with serialization support!
 
 ![](addons/rpg_nodes/icons/RPGDialog.png) **RPGDialog:** Usable – tested in a scene within the project.
 
-![](addons/rpg_nodes/icons/RPGWeightItem.png) **RPGWeightItem:** Very usable and tested together with `RPGWeightInventory` using unit tests (GUT).
+![](addons/rpg_nodes/icons/RPGWeightItem.png) **RPGWeightItem:** Production-ready and tested together with `RPGWeightInventory` using unit tests (GUT).
+
+![](addons/rpg_nodes/icons/RPGWeightInventory.png) **RPGWeightInventory:** Production-ready and tested with unit tests (GUT).
+
+![](addons/rpg_nodes/icons/RPGSlotInventory.png) **RPGSlotInventory:** Production-ready – complete grid-based inventory system with comprehensive tests (GUT)!
 
-![](addons/rpg_nodes/icons/RPGWeightInventory.png) **RPGWeightInventory:** Very usable and tested with unit tests (GUT).
+![](addons/rpg_nodes/icons/RPGStats.png) **RPGStats:** Production-ready – full character stat management with allocation system and extensive tests (GUT)!
 
-### TODO or not usable
+### Supporting Classes
 
-![](addons/rpg_nodes/icons/RPGSlotInventory.png) **RPGSlotInventory:** TODO or not usable.
+**RPGSlotItem** Functional companion for slot-based inventories.
 
-**RPGSlotItem** Todo or not usable.
+**RPGActor** Abstract base class for actor-like entities.
 
-![](addons/rpg_nodes/icons/RPGStats.png) **RPGStats:** TODO or not usable.
+**RPGEnemy** Specific implementation for enemy characters.
 
 
 ## Installation & Usage
@@ -55,6 +61,32 @@ Using the plugin requires the following steps:
 3. Open Godot’s editor and enable the plugin under  
    **Project → Project Settings → Plugins**
 
+## What's New in v0.10.0
+
+This major release transforms RPGNodes from a promising toolkit into a production-ready RPG framework:
+
+* **Complete Dual Inventory Systems**: Choose between weight-based or Diablo-style slot-based inventories
+* **Production-Ready Stats System**: Full character stat management with point allocation
+* **Enhanced Architecture**: Better inheritance with proper base classes (RPGActor, RPGNode)
+* **Comprehensive Testing**: Extensive unit test coverage for all new features
+* **Serialization Support**: Save/load functionality for critical systems
+
+## Choosing the Right Inventory System
+
+RPGNodes now offers two complete inventory solutions:
+
+### Weight-Based Inventory (`RPGWeightInventory` + `RPGWeightItem`)
+* **Best for**: Realistic games with carrying capacity limits
+* **Features**: Items have weight, total weight capacity management
+* **Use cases**: Survival games, realistic RPGs, resource management games
+
+### Slot-Based Inventory (`RPGSlotInventory` + `RPGSlotItem`)
+* **Best for**: Classic RPGs with grid-based inventories
+* **Features**: Grid layout (width × height), items take up multiple slots, auto-positioning
+* **Use cases**: Diablo-style games, tactical RPGs, games with visual inventory management
+
+Both systems are fully tested and production-ready. Choose based on your game's design requirements.
+
 ## Custom Nodes
 
 Below is a brief description of each custom node.  
@@ -194,6 +226,119 @@ This class inherits all properties, signals, and functionality from RPGItem, add
 
 ---
 
+## RPGSlotInventory.gd
+
+A grid-based inventory system similar to Diablo-style games where items occupy specific slots in a grid layout.
+
+### Properties
+
+- `width: int` - Grid width in slots (default: 10)
+- `height: int` - Grid height in slots (default: 10)
+- `_slot_inventory: Array[RPGSlotItem]` - Array of items in the inventory
+- `_grid: Array` - 2D grid representing occupied slots
+
+### Signals
+
+- `slot_item_added(item)` - Emitted when an item is added to the inventory
+- `slot_item_removed(item)` - Emitted when an item is removed from the inventory
+- `slot_item_moved(item, old_position, new_position)` - Emitted when an item changes position
+- `inventory_resized(old_size, new_size)` - Emitted when grid dimensions change
+
+### Functions
+
+- `add_item(item, position)` - Adds an item at specific position or finds available spot
+- `remove_item(uuid)` - Removes an item by UUID
+- `move_item(uuid, new_position)` - Moves an item to a new position
+- `get_available_space(position, item_width, item_height)` - Checks if space is available
+- `find_available_position(item_width, item_height)` - Finds first available position
+- `is_position_valid(position, item_width, item_height)` - Validates position boundaries
+
+---
+
+## RPGSlotItem.gd
+
+Extended RPGItem class that adds spatial properties for grid-based inventory systems.
+
+### Properties
+
+- `width: int` - Item width in inventory grid slots (default: 1, minimum: 1)
+- `height: int` - Item height in inventory grid slots (default: 1, minimum: 1)
+- `position: Vector2i` - Current position in inventory grid (default: Vector2i.ZERO)
+
+### Signals
+
+- `dimensions_changed(old_size, new_size)` - Emitted when width or height changes
+- `position_changed(old_position, new_position)` - Emitted when position changes
+
+### Functions
+
+- `get_occupied_cells()` - Returns array of grid cells occupied by this item
+- `is_position_valid(inventory_width, inventory_height)` - Checks if current position is valid
+- `would_fit_at(position, inventory_width, inventory_height)` - Checks if item would fit at position
+
+This class inherits all properties, signals, and functionality from RPGItem, adding spatial management for grid-based inventory systems.
+
+---
+
+## RPGStats.gd
+
+Comprehensive character stat management system with dynamic stat addition and point allocation.
+
+### Properties
+
+- `stat_points: int` - Available stat points for allocation (default: 0)
+- `_stats: Dictionary` - Dictionary storing all stats with name-value pairs
+- `_base_stats: Dictionary` - Dictionary storing base stat values
+
+### Signals
+
+- `stat_points_changed(old_points, new_points)` - Emitted when stat points change
+- `stat_added(stat_name, value)` - Emitted when a new stat is added
+- `stat_changed(stat_name, old_value, new_value)` - Emitted when a stat value changes
+- `stat_points_allocated(stat_name, points)` - Emitted when points are allocated to a stat
+
+### Functions
+
+- `add_stat(stat_name, base_value, current_value)` - Adds a new stat to the character
+- `get_stat(stat_name)` - Gets current value of a stat
+- `get_base_stat(stat_name)` - Gets base value of a stat
+- `set_stat(stat_name, value)` - Sets current value of a stat
+- `allocate_stat_points(stat_name, points)` - Allocates stat points to increase a stat
+- `add_stat_points(points)` - Adds available stat points
+- `to_dict()` - Serializes stats to dictionary for saving
+- `from_dict(data)` - Loads stats from dictionary
+
+---
+
+## RPGActor.gd
+
+Abstract base class for all actor-like entities in the RPG system.
+
+### Properties
+
+- `character_name: String` - Name of the actor (default: "Actor")
+
+### Signals
+
+- `character_name_changed(old_name, new_name)` - Emitted when actor name changes
+
+This class serves as the foundation for all character and enemy classes, providing common actor functionality and naming capabilities.
+
+---
+
+## RPGEnemy.gd
+
+Specific implementation for enemy characters inheriting from RPGActor.
+
+### Properties
+
+- Inherits all properties from RPGActor
+- Additional enemy-specific properties can be added as needed
+
+This class provides a starting point for enemy character implementation with all base actor functionality inherited from RPGActor.
+
+---
+
 ## RPGPotion.gd
 
 Consumable item that applies an effect over time or instantly.

README_ES.md

@@ -15,24 +15,30 @@ Por ejemplo:
 
 ## Estado del Proyecto
 
-El proyecto es usable, aunque algunos nodos están incompletos.
+El proyecto está listo para producción con gestión de inventarios completa, sistemas de personajes y cobertura de pruebas robusta.
 Las pruebas unitarias están escritas con [GUT](https://github.com/bitwes/Gut/).
 
-![](addons/rpg_nodes/icons/RPGCharacter.png) **RPGCharacter:** ¡Muy usable y probado con tests unitarios (GUT)!
+### Características Listas para Producción
+
+![](addons/rpg_nodes/icons/RPGCharacter.png) **RPGCharacter:** ¡Listo para producción – probado con tests unitarios (GUT) y mejorado con soporte de serialización!
 
 ![](addons/rpg_nodes/icons/RPGDialog.png) **RPGDialog:** Usable – probado en una escena dentro del proyecto.
 
-![](addons/rpg_nodes/icons/RPGWeightItem.png) **RPGWeightItem:** Muy usable y probado junto con `RPGWeightInventory` usando tests unitarios (GUT).
+![](addons/rpg_nodes/icons/RPGWeightItem.png) **RPGWeightItem:** Listo para producción y probado junto con `RPGWeightInventory` usando tests unitarios (GUT).
+
+![](addons/rpg_nodes/icons/RPGWeightInventory.png) **RPGWeightInventory:** Listo para producción y probado con tests unitarios (GUT).
+
+![](addons/rpg_nodes/icons/RPGSlotInventory.png) **RPGSlotInventory:** ¡Listo para producción – sistema completo de inventario en cuadrícula con pruebas exhaustivas (GUT)!
 
-![](addons/rpg_nodes/icons/RPGWeightInventory.png) **RPGWeightInventory:** Muy usable y probado con tests unitarios (GUT).
+![](addons/rpg_nodes/icons/RPGStats.png) **RPGStats:** ¡Listo para producción – sistema completo de gestión de estadísticas de personaje con sistema de asignación y pruebas extensas (GUT)!
 
-### TODO o no usable
+### Clases de Soporte
 
-![](addons/rpg_nodes/icons/RPGSlotInventory.png) **RPGSlotInventory:** TODO o no usable.
+**RPGSlotItem** Clase funcional para inventarios basados en ranuras.
 
-**RPGSlotItem** Todo o no usable.
+**RPGActor** Clase base abstracta para entidades tipo actor.
 
-![](addons/rpg_nodes/icons/RPGStats.png) **RPGStats:** TODO o no usable.
+**RPGEnemy** Implementación específica para personajes enemigos.
 
 
 ## Instalación y Uso
@@ -55,6 +61,32 @@ Usar el plugin requiere los siguientes pasos:
 3. Abre el editor de Godot y activa el plugin en
    **Proyecto → Ajustes del Proyecto → Plugins**
 
+## Novedades en v0.10.0
+
+Esta versión principal transforma RPGNodes de un kit de herramientas prometedor a un framework RPG listo para producción:
+
+* **Sistemas Doble de Inventario Completos**: Elige entre inventarios basados en peso o estilo Diablo basados en ranuras
+* **Sistema de Estadísticas Listo para Producción**: Gestión completa de estadísticas de personaje con asignación de puntos
+* **Arquitectura Mejorada**: Mejor herencia con clases base apropiadas (RPGActor, RPGNode)
+* **Pruebas Exhaustivas**: Cobertura extensiva de pruebas unitarias para todas las nuevas características
+* **Soporte de Serialización**: Funcionalidad guardar/cargar para sistemas críticos
+
+## Elegir el Sistema de Inventario Adecuado
+
+RPGNodes ahora ofrece dos soluciones completas de inventario:
+
+### Inventario Basado en Peso (`RPGWeightInventory` + `RPGWeightItem`)
+* **Ideal para**: Juegos realistas con límites de capacidad de carga
+* **Características**: Los ítems tienen peso, gestión de capacidad de peso total
+* **Casos de uso**: Juegos de supervivencia, RPGs realistas, juegos de gestión de recursos
+
+### Inventario Basado en Ranuras (`RPGSlotInventory` + `RPGSlotItem`)
+* **Ideal para**: RPGs clásicos con inventarios basados en cuadrícula
+* **Características**: Diseño en cuadrícula (ancho × alto), los ítems ocupan múltiples ranuras, posicionamiento automático
+* **Casos de uso**: Juegos estilo Diablo, RPGs tácticos, juegos con gestión visual de inventario
+
+Ambos sistemas están completamente probados y listos para producción. Elige según los requisitos de diseño de tu juego.
+
 ## Nodos Personalizados
 
 A continuación hay una breve descripción de cada nodo personalizado.
@@ -194,6 +226,119 @@ Esta clase hereda todas las propiedades, señales y funcionalidades de RPGItem,
 
 ---
 
+## RPGSlotInventory.gd
+
+Sistema de inventario basado en cuadrícula similar a juegos estilo Diablo donde los ítems ocupan ranuras específicas en un diseño de cuadrícula.
+
+### Propiedades
+
+- `width: int` - Ancho de la cuadrícula en ranuras (por defecto: 10)
+- `height: int` - Alto de la cuadrícula en ranuras (por defecto: 10)
+- `_slot_inventory: Array[RPGSlotItem]` - Array de ítems en el inventario
+- `_grid: Array` - Cuadrícula 2D representando ranuras ocupadas
+
+### Señales
+
+- `slot_item_added(item)` - Emitida cuando se añade un ítem al inventario
+- `slot_item_removed(item)` - Emitida cuando se elimina un ítem del inventario
+- `slot_item_moved(item, old_position, new_position)` - Emitida cuando un ítem cambia de posición
+- `inventory_resized(old_size, new_size)` - Emitida cuando cambian las dimensiones de la cuadrícula
+
+### Funciones
+
+- `add_item(item, position)` - Añade un ítem en posición específica o encuentra espacio disponible
+- `remove_item(uuid)` - Elimina un ítem por UUID
+- `move_item(uuid, new_position)` - Mueve un ítem a una nueva posición
+- `get_available_space(position, item_width, item_height)` - Verifica si hay espacio disponible
+- `find_available_position(item_width, item_height)` - Encuentra la primera posición disponible
+- `is_position_valid(position, item_width, item_height)` - Valida los límites de la posición
+
+---
+
+## RPGSlotItem.gd
+
+Clase RPGItem extendida que añade propiedades espaciales para sistemas de inventario basados en cuadrícula.
+
+### Propiedades
+
+- `width: int` - Ancho del ítem en ranuras de cuadrícula (por defecto: 1, mínimo: 1)
+- `height: int` - Alto del ítem en ranuras de cuadrícula (por defecto: 1, mínimo: 1)
+- `position: Vector2i` - Posición actual en la cuadrícula del inventario (por defecto: Vector2i.ZERO)
+
+### Señales
+
+- `dimensions_changed(old_size, new_size)` - Emitida cuando cambia el ancho o alto
+- `position_changed(old_position, new_position)` - Emitida cuando cambia la posición
+
+### Funciones
+
+- `get_occupied_cells()` - Devuelve array de celdas de cuadrícula ocupadas por este ítem
+- `is_position_valid(inventory_width, inventory_height)` - Verifica si la posición actual es válida
+- `would_fit_at(position, inventory_width, inventory_height)` - Verifica si el ítem cabría en la posición
+
+Esta clase hereda todas las propiedades, señales y funcionalidades de RPGItem, añadiendo gestión espacial para sistemas de inventario basados en cuadrícula.
+
+---
+
+## RPGStats.gd
+
+Sistema comprehensivo de gestión de estadísticas de personaje con adición dinámica de estadísticas y asignación de puntos.
+
+### Propiedades
+
+- `stat_points: int` - Puntos de estadística disponibles para asignación (por defecto: 0)
+- `_stats: Dictionary` - Diccionario almacenando todas las estadísticas con pares nombre-valor
+- `_base_stats: Dictionary` - Diccionario almacenando valores base de estadísticas
+
+### Señales
+
+- `stat_points_changed(old_points, new_points)` - Emitida cuando cambian los puntos de estadística
+- `stat_added(stat_name, value)` - Emitida cuando se añade una nueva estadística
+- `stat_changed(stat_name, old_value, new_value)` - Emitida cuando cambia el valor de una estadística
+- `stat_points_allocated(stat_name, points)` - Emitida cuando se asignan puntos a una estadística
+
+### Funciones
+
+- `add_stat(stat_name, base_value, current_value)` - Añade una nueva estadística al personaje
+- `get_stat(stat_name)` - Obtiene el valor actual de una estadística
+- `get_base_stat(stat_name)` - Obtiene el valor base de una estadística
+- `set_stat(stat_name, value)` - Establece el valor actual de una estadística
+- `allocate_stat_points(stat_name, points)` - Asigna puntos de estadística para aumentar una estadística
+- `add_stat_points(points)` - Añade puntos de estadística disponibles
+- `to_dict()` - Serializa estadísticas a diccionario para guardar
+- `from_dict(data)` - Carga estadísticas desde diccionario
+
+---
+
+## RPGActor.gd
+
+Clase base abstracta para todas las entidades tipo actor en el sistema RPG.
+
+### Propiedades
+
+- `character_name: String` - Nombre del actor (por defecto: "Actor")
+
+### Señales
+
+- `character_name_changed(old_name, new_name)` - Emitida cuando cambia el nombre del actor
+
+Esta clase sirve como fundación para todas las clases de personaje y enemigo, proporcionando funcionalidad común de actor y capacidades de nomenclatura.
+
+---
+
+## RPGEnemy.gd
+
+Implementación específica para personajes enemigos heredando de RPGActor.
+
+### Propiedades
+
+- Hereda todas las propiedades de RPGActor
+- Se pueden añadir propiedades adicionales específicas de enemigos según sea necesario
+
+Esta clase proporciona un punto de partida para la implementación de personajes enemigos con toda la funcionalidad base de actor heredada de RPGActor.
+
+---
+
 ## RPGPotion.gd
 
 Ítem consumible que aplica un efecto a lo largo del tiempo o instantáneamente.