Merge pull request #9 from jacuzzicoding/feature/crafting

Feature/crafting

Author: jacuzzicoding

Source/Crafting/CraftingSystem.cs

@@ -0,0 +1,129 @@
+using System;
+using System.Collections.Generic;
+using MyIslandGame.Crafting;
+
+namespace MyIslandGame.ECS.Components
+{
+    /// <summary>
+    /// Component that allows an entity to perform crafting operations.
+    /// </summary>
+    public class CraftingComponent : Component
+    {
+        /// <summary>
+        /// Gets the highest level crafting station available to this entity.
+        /// </summary>
+        public CraftingStationType HighestStationType { get; private set; }
+        
+        /// <summary>
+        /// Gets a list of unlocked recipe IDs.
+        /// </summary>
+        public HashSet<string> UnlockedRecipes { get; private set; }
+        
+        /// <summary>
+        /// Gets a value indicating whether the entity is currently crafting.
+        /// </summary>
+        public bool IsCrafting { get; private set; }
+        
+        /// <summary>
+        /// Event raised when a recipe is unlocked.
+        /// </summary>
+        public event EventHandler<RecipeUnlockedEventArgs> RecipeUnlocked;
+        
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CraftingComponent"/> class.
+        /// </summary>
+        /// <param name="stationType">The highest crafting station type available.</param>
+        public CraftingComponent(CraftingStationType stationType = CraftingStationType.None)
+        {
+            HighestStationType = stationType;
+            UnlockedRecipes = new HashSet<string>();
+            IsCrafting = false;
+        }
+        
+        /// <summary>
+        /// Sets the crafting state.
+        /// </summary>
+        /// <param name="isCrafting">Whether the entity is crafting.</param>
+        public void SetCraftingState(bool isCrafting)
+        {
+            IsCrafting = isCrafting;
+        }
+        
+        /// <summary>
+        /// Upgrades the crafting station type.
+        /// </summary>
+        /// <param name="stationType">The new station type.</param>
+        /// <returns>True if the station was upgraded, false if downgraded or unchanged.</returns>
+        public bool UpgradeStation(CraftingStationType stationType)
+        {
+            if (stationType > HighestStationType)
+            {
+                HighestStationType = stationType;
+                return true;
+            }
+            
+            return false;
+        }
+        
+        /// <summary>
+        /// Unlocks a recipe for crafting.
+        /// </summary>
+        /// <param name="recipeId">The ID of the recipe to unlock.</param>
+        /// <returns>True if the recipe was newly unlocked, false if already unlocked.</returns>
+        public bool UnlockRecipe(string recipeId)
+        {
+            if (string.IsNullOrEmpty(recipeId))
+                return false;
+            
+            if (UnlockedRecipes.Add(recipeId))
+            {
+                OnRecipeUnlocked(recipeId);
+                return true;
+            }
+            
+            return false;
+        }
+        
+        /// <summary>
+        /// Checks if a recipe is unlocked.
+        /// </summary>
+        /// <param name="recipeId">The ID of the recipe to check.</param>
+        /// <returns>True if the recipe is unlocked, otherwise false.</returns>
+        public bool IsRecipeUnlocked(string recipeId)
+        {
+            if (string.IsNullOrEmpty(recipeId))
+                return false;
+            
+            return UnlockedRecipes.Contains(recipeId);
+        }
+        
+        /// <summary>
+        /// Raises the RecipeUnlocked event.
+        /// </summary>
+        /// <param name="recipeId">The ID of the recipe that was unlocked.</param>
+        protected virtual void OnRecipeUnlocked(string recipeId)
+        {
+            RecipeUnlocked?.Invoke(this, new RecipeUnlockedEventArgs(recipeId));
+        }
+    }
+    
+    /// <summary>
+    /// Event arguments for recipe unlocked events.
+    /// </summary>
+    public class RecipeUnlockedEventArgs : EventArgs
+    {
+        /// <summary>
+        /// Gets the ID of the recipe that was unlocked.
+        /// </summary>
+        public string RecipeId { get; }
+        
+        /// <summary>
+        /// Initializes a new instance of the <see cref="RecipeUnlockedEventArgs"/> class.
+        /// </summary>
+        /// <param name="recipeId">The ID of the recipe that was unlocked.</param>
+        public RecipeUnlockedEventArgs(string recipeId)
+        {
+            RecipeId = recipeId;
+        }
+    }
+}

Source/Crafting/Recipe.cs

@@ -0,0 +1,128 @@
+using System;
+using Microsoft.Xna.Framework;
+using MyIslandGame.Crafting;
+
+namespace MyIslandGame.ECS.Components
+{
+    /// <summary>
+    /// Component for entities that function as crafting stations.
+    /// </summary>
+    public class CraftingStationComponent : Component
+    {
+        /// <summary>
+        /// Gets the type of crafting station.
+        /// </summary>
+        public CraftingStationType StationType { get; }
+        
+        /// <summary>
+        /// Gets the interaction range for this crafting station.
+        /// </summary>
+        public float InteractionRange { get; }
+        
+        /// <summary>
+        /// Gets or sets the entity that is currently using this crafting station.
+        /// </summary>
+        public Entity CurrentUser { get; private set; }
+        
+        /// <summary>
+        /// Gets a value indicating whether the station is currently in use.
+        /// </summary>
+        public bool InUse => CurrentUser != null;
+        
+        /// <summary>
+        /// Event raised when the station is used.
+        /// </summary>
+        public event EventHandler<StationUsedEventArgs> StationUsed;
+        
+        /// <summary>
+        /// Initializes a new instance of the <see cref="CraftingStationComponent"/> class.
+        /// </summary>
+        /// <param name="stationType">The type of crafting station.</param>
+        /// <param name="interactionRange">The interaction range for this station.</param>
+        public CraftingStationComponent(CraftingStationType stationType, float interactionRange = 100f)
+        {
+            if (stationType == CraftingStationType.None)
+                throw new ArgumentException("Crafting station type cannot be None", nameof(stationType));
+            
+            StationType = stationType;
+            InteractionRange = interactionRange;
+            CurrentUser = null;
+        }
+        
+        /// <summary>
+        /// Sets the current user of this crafting station.
+        /// </summary>
+        /// <param name="user">The entity using the station, or null to clear.</param>
+        /// <returns>True if the user was set or cleared successfully, false if already in use.</returns>
+        public bool SetUser(Entity user)
+        {
+            // If we're clearing the user, always allow it
+            if (user == null)
+            {
+                CurrentUser = null;
+                return true;
+            }
+            
+            // Don't allow if already in use by someone else
+            if (InUse && CurrentUser != user)
+                return false;
+            
+            // Set the user
+            CurrentUser = user;
+            OnStationUsed(user);
+            return true;
+        }
+        
+        /// <summary>
+        /// Checks if an entity is within range to use this station.
+        /// </summary>
+        /// <param name="entity">The entity to check.</param>
+        /// <returns>True if the entity is within range, otherwise false.</returns>
+        public bool IsEntityInRange(Entity entity)
+        {
+            if (entity == null || Owner == null)
+                return false;
+            
+            // Both entities need transform components
+            if (!entity.HasComponent<TransformComponent>() || !Owner.HasComponent<TransformComponent>())
+                return false;
+            
+            var entityTransform = entity.GetComponent<TransformComponent>();
+            var stationTransform = Owner.GetComponent<TransformComponent>();
+            
+            // Calculate distance
+            float distance = Vector2.Distance(entityTransform.Position, stationTransform.Position);
+            
+            return distance <= InteractionRange;
+        }
+        
+        /// <summary>
+        /// Raises the StationUsed event.
+        /// </summary>
+        /// <param name="user">The entity using the station.</param>
+        protected virtual void OnStationUsed(Entity user)
+        {
+            StationUsed?.Invoke(this, new StationUsedEventArgs(user));
+        }
+    }
+    
+    /// <summary>
+    /// Event arguments for station used events.
+    /// </summary>
+    public class StationUsedEventArgs : EventArgs
+    {
+        /// <summary>
+        /// Gets the entity using the station.
+        /// </summary>
+        public Entity User { get; }
+        
+        /// <summary>
+        /// Initializes a new instance of the <see cref="StationUsedEventArgs"/> class.
+        /// </summary>
+        /// <param name="user">The entity using the station.</param>
+        public StationUsedEventArgs(Entity user)
+        {
+            User = user;
+        }
+    }
+}

Source/Crafting/RecipeManager.cs

@@ -0,0 +1,139 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using Microsoft.Xna.Framework;
+
+namespace MyIslandGame.ECS
+{
+    /// <summary>
+    /// Manages all entities and systems in the game.
+    /// </summary>
+    public class EntityManager
+    {
+        private readonly List<Entity> _entities = new();
+        private readonly List<Entity> _entitiesToAdd = new();
+        private readonly List<Entity> _entitiesToRemove = new();
+        
+        private readonly List<System> _systems = new();
+        private readonly List<System> _systemsToAdd = new();
+        private readonly List<System> _systemsToRemove = new();
+        
+        private readonly Dictionary<Type, List<Entity>> _componentEntityMap = new();
+        
+        /// <summary>
+        /// Event raised when a component is added to an entity.
+        /// </summary>
+        public event Action<Entity, Component> ComponentAdded;
+        
+        /// <summary>
+        /// Event raised when a component is removed from an entity.
+        /// </summary>
+        public event Action<Entity, Component> ComponentRemoved;
+        
+        /// <summary>
+        /// Event raised when an entity is added.
+        /// </summary>
+        public event Action<Entity> EntityAdded;
+        
+        /// <summary>
+        /// Event raised when an entity is removed.
+        /// </summary>
+        public event Action<Entity> EntityRemoved;
+        
+        /// <summary>
+        /// Creates a new entity.
+        /// </summary>
+        /// <returns>The created entity.</returns>
+        public Entity CreateEntity()
+        {
+            var entity = new Entity();
+            entity.EntityManager = this;
+            _entitiesToAdd.Add(entity);
+            return entity;
+        }
+        
+        /// <summary>
+        /// Adds an existing entity to the manager.
+        /// </summary>
+        /// <param name="entity">The entity to add.</param>
+        /// <exception cref="ArgumentException">Thrown if the entity is already managed by another manager.</exception>
+        public void AddEntity(Entity entity)
+        {
+            if (entity.EntityManager != null && entity.EntityManager != this)
+            {
+                throw new ArgumentException("Entity is already managed by another EntityManager", nameof(entity));
+            }
+            
+            entity.EntityManager = this;
+            _entitiesToAdd.Add(entity);
+        }
+        
+        /// <summary>
+        /// Gets an entity by its unique identifier.
+        /// </summary>
+        /// <param name="id">The entity identifier.</param>
+        /// <returns>The entity if found, otherwise null.</returns>
+        public Entity GetEntityById(Guid id)
+        {
+            return _entities.FirstOrDefault(e => e.Id == id);
+        }
+        
+        /// <summary>
+        /// Destroys an entity, removing it from management.
+        /// </summary>
+        /// <param name="entity">The entity to destroy.</param>
+        public void DestroyEntity(Entity entity)
+        {
+            if (entity.EntityManager == this)
+            {
+                entity.Destroy();
+                _entitiesToRemove.Add(entity);
+            }
+        }
+        
+        /// <summary>
+        /// Adds a system to the manager.
+        /// </summary>
+        /// <param name="system">The system to add.</param>
+        public void AddSystem(System system)
+        {
+            _systemsToAdd.Add(system);
+        }
+        
+        /// <summary>
+        /// Removes a system from the manager.
+        /// </summary>
+        /// <param name="system">The system to remove.</param>
+        public void RemoveSystem(System system)
+        {
+            _systemsToRemove.Add(system);
+        }
+        
+        /// <summary>
+        /// Gets all entities managed by this manager.
+        /// </summary>
+        /// <returns>An enumerable collection of entities.</returns>
+        public IEnumerable<Entity> GetEntities()
+        {
+            return _entities;
+        }
+        
+        /// <summary>
+        /// Gets entities that have all of the specified component types.
+        /// </summary>
+        /// <param name="componentTypes">The component types to filter by.</param>
+        /// <returns>An enumerable collection of entities.</returns>
+        public IEnumerable<Entity> GetEntitiesWithComponents(params Type[] componentTypes)
+        {
+            if (componentTypes.Length == 0)
+            {
+                return _entities;
+            }
+            
+            IEnumerable<Entity> result = null;
+            
+            foreach (var type in componentTypes)
+            {
+                if (_componentEntityMap.TryGetValue(type, out var entities))
+                {
+                    if (result ==