add documentation

09de87fa · alsunj · cb7803e0 · 09de87fa · 09de87fa · 09de87fa
Commit 09de87fa authored May 15, 2025 by alsunj
Showing with 761 additions and 122 deletions
Assets/_Game/Code/Systems/Combat/ApplyDamageSystem.cs
Assets/_Game/Code/Systems/Combat/CalculateFrameDamageSystem.cs
Assets/_Game/Code/Systems/Combat/DamageOnTriggerSystem.cs
Assets/_Game/Code/Systems/Combat/HealthBarSystem.cs
Assets/_Game/Code/Systems/Combat/MoveAbilitySystem.cs
Assets/_Game/Code/Systems/Combat/MoveSlimeSystem.cs
Assets/_Game/Code/Systems/Combat/MoveSlimeSystem.cs.meta
Assets/_Game/Code/Systems/Combat/RogueAttackSystem.cs
Assets/_Game/Code/Systems/Combat/SetTargetSlimeSystem.cs
Assets/_Game/Code/Systems/Combat/SetTargetSlimeSystem.cs.meta
Assets/_Game/Code/Systems/Combat/TargetingSystem.cs
Assets/_Game/Code/Systems/Connection/ClientRequestGameEntrySystem.cs
Assets/_Game/Code/Systems/Connection/ClientStartGameSystem.cs
Assets/_Game/Code/Systems/Connection/CountDownToGameStartSystem.cs
Assets/_Game/Code/Systems/Connection/GoInGameServerSystem.cs
Assets/_Game/Code/Systems/Destroy/DestroyEntitySystem.cs
Assets/_Game/Code/Systems/Destroy/DestroyOnTimerSystem.cs
Assets/_Game/Code/Systems/Destroy/InitializeDestroyOnTimerSystem.cs
Assets/_Game/Code/Systems/Destroy/RespawnPlayerSystem.cs
Assets/_Game/Code/Systems/Enemy/EnemySpawnerAspect.cs
--- a/Assets/_Game/Code/Systems/Combat/ApplyDamageSystem.cs
+++ b/Assets/_Game/Code/Systems/Combat/ApplyDamageSystem.cs
@@ -3,37 +3,56 @@ using Unity.Collections;
 using Unity.Entities;
 using Unity.NetCode;
 [UpdateInGroup(typeof(PredictedSimulationSystemGroup), OrderLast = true)]
 [UpdateAfter(typeof(CalculateFrameDamageSystem))]
 public partial struct ApplyDamageSystem : ISystem
 {
+    /// <summary>
+    /// Called when the system is created. Ensures the system only updates when
+    /// the required components (NetworkTime and GamePlayingTag) are present.
+    /// </summary>
+    /// <param name="state">The system state.</param>
    public void OnCreate(ref SystemState state)
    {
        state.RequireForUpdate<NetworkTime>();
        state.RequireForUpdate<GamePlayingTag>();
    }
+    /// <summary>
+    /// Called every frame to update the system. Processes damage for entities
+    /// with a DamageThisTick buffer and applies it to their CurrentHitPoints.
+    /// If an entity's hit points drop to zero or below, it is marked for destruction.
+    /// </summary>
+    /// <param name="state">The system state.</param>
    [BurstCompile]
    public void OnUpdate(ref SystemState state)
    {
+        // Get the current server tick from the NetworkTime singleton.
        var currentTick = SystemAPI.GetSingleton<NetworkTime>().ServerTick;
+        // Create a temporary EntityCommandBuffer to queue entity modifications.
        var ecb = new EntityCommandBuffer(Allocator.Temp);
+        // Query entities with CurrentHitPoints, DamageThisTick buffer, and Simulate tag.
        foreach (var (currentHitPoints, damageThisTickBuffer, entity) in SystemAPI
                     .Query<RefRW<CurrentHitPoints>, DynamicBuffer<DamageThisTick>>().WithAll<Simulate>()
                     .WithEntityAccess())
        {
+            // Skip if no damage data exists for the current tick.
            if (!damageThisTickBuffer.GetDataAtTick(currentTick, out var damageThisTick)) continue;
            if (damageThisTick.Tick != currentTick) continue;
+            // Apply the damage to the entity's current hit points.
            currentHitPoints.ValueRW.Value -= damageThisTick.Value;
+            // If hit points drop to zero or below, mark the entity for destruction.
            if (currentHitPoints.ValueRO.Value <= 0)
            {
                ecb.AddComponent<DestroyEntityTag>(entity);
            }
        }
+        // Apply all queued entity modifications.
        ecb.Playback(state.EntityManager);
    }
 }
\ No newline at end of file
--- a/Assets/_Game/Code/Systems/Combat/CalculateFrameDamageSystem.cs
+++ b/Assets/_Game/Code/Systems/Combat/CalculateFrameDamageSystem.cs
@@ -2,9 +2,18 @@ using Unity.Burst;
 using Unity.Entities;
 using Unity.NetCode;
+/// <summary>
+/// System responsible for calculating the total damage for the current frame.
+/// This system runs in the PredictedSimulationSystemGroup and executes last in the group.
+/// </summary>
 [UpdateInGroup(typeof(PredictedSimulationSystemGroup), OrderLast = true)]
 public partial struct CalculateFrameDamageSystem : ISystem
 {
+    /// <summary>
+    /// Called when the system is created. Ensures the system only updates when
+    /// the required components (NetworkTime, GamePlayingTag, and DamageBufferElement) are present.
+    /// </summary>
+    /// <param name="state">The system state.</param>
    public void OnCreate(ref SystemState state)
    {
        state.RequireForUpdate<NetworkTime>();
@@ -12,32 +21,44 @@ public partial struct CalculateFrameDamageSystem : ISystem
        state.RequireForUpdate<DamageBufferElement>();
    }
+    /// <summary>
+    /// Called every frame to update the system. Aggregates damage from the DamageBufferElement
+    /// and stores the total damage for the current tick in the DamageThisTick buffer.
+    /// Clears the damage buffer after processing.
+    /// </summary>
+    /// <param name="state">The system state.</param>
    [BurstCompile]
    public void OnUpdate(ref SystemState state)
    {
+        // Retrieve the current server tick from the NetworkTime singleton.
        var currentTick = SystemAPI.GetSingleton<NetworkTime>().ServerTick;
+        // Iterate over entities with DamageBufferElement and DamageThisTick buffers, and the Simulate tag.
        foreach (var (damageBuffer, damageThisTickBuffer) in SystemAPI
                     .Query<DynamicBuffer<DamageBufferElement>, DynamicBuffer<DamageThisTick>>()
                     .WithAll<Simulate>())
        {
+            // If the damage buffer is empty, add a zero-damage entry for the current tick.
            if (damageBuffer.IsEmpty)
            {
                damageThisTickBuffer.AddCommandData(new DamageThisTick { Tick = currentTick, Value = 0 });
            }
            else
            {
+                // Calculate the total damage for the current tick.
                var totalDamage = 0;
                if (damageThisTickBuffer.GetDataAtTick(currentTick, out var damageThisTick))
                {
                    totalDamage = damageThisTick.Value;
                }
+                // Add up all damage values from the damage buffer.
                foreach (var damage in damageBuffer)
                {
                    totalDamage += damage.Value;
                }
+                // Store the total damage in the DamageThisTick buffer and clear the damage buffer.
                damageThisTickBuffer.AddCommandData(new DamageThisTick { Tick = currentTick, Value = totalDamage });
                damageBuffer.Clear();
            }

--- a/Assets/_Game/Code/Systems/Combat/DamageOnTriggerSystem.cs
+++ b/Assets/_Game/Code/Systems/Combat/DamageOnTriggerSystem.cs
@@ -4,10 +4,20 @@ using Unity.Entities;
 using Unity.Physics;
 using Unity.Physics.Systems;
+/// <summary>
+/// System responsible for handling damage when trigger events occur between entities, applies the damage on DamageBufferElement buffer.
+/// This system runs within the PhysicsSystemGroup and executes after the PhysicsSimulationGroup.
+/// </summary>
 [UpdateInGroup(typeof(PhysicsSystemGroup))]
 [UpdateAfter(typeof(PhysicsSimulationGroup))]
 public partial struct DamageOnTriggerSystem : ISystem
 {
+    /// <summary>
+    /// Initializes the system by specifying the required components for it to update.
+    /// Ensures that the system only runs when the SimulationSingleton, EndSimulationEntityCommandBufferSystem.Singleton,
+    /// and GamePlayingTag components are present.
+    /// </summary>
+    /// <param name="state">The current state of the system.</param>
    public void OnCreate(ref SystemState state)
    {
        state.RequireForUpdate<SimulationSingleton>();
@@ -15,11 +25,19 @@ public partial struct DamageOnTriggerSystem : ISystem
        state.RequireForUpdate<GamePlayingTag>();
    }
+    /// <summary>
+    /// Executes the system logic every frame. Schedules the DamageOnTriggerJob to process trigger events
+    /// and apply damage to entities based on their interactions.
+    /// </summary>
+    /// <param name="state">The current state of the system.</param>
    [BurstCompile]
    public void OnUpdate(ref SystemState state)
    {
+        // Retrieve the singleton for the EndSimulationEntityCommandBufferSystem.
        var ecbSingleton = SystemAPI.GetSingleton<EndSimulationEntityCommandBufferSystem.Singleton>();
-        var damageOnCollisionJob = new DamageOnTriggerJob
+        // Create and configure the DamageOnTriggerJob.
+        var damageOnTriggerJob = new DamageOnTriggerJob
        {
            DamageOnTriggerLookup = SystemAPI.GetComponentLookup<DamageOnTrigger>(true),
            AlreadyDamagedLookup = SystemAPI.GetBufferLookup<AlreadyDamagedEntity>(true),
@@ -27,21 +45,42 @@ public partial struct DamageOnTriggerSystem : ISystem
            ECB = ecbSingleton.CreateCommandBuffer(state.WorldUnmanaged)
        };
+        // Retrieve the SimulationSingleton and schedule the job.
        var simulationSingleton = SystemAPI.GetSingleton<SimulationSingleton>();
-        state.Dependency = damageOnCollisionJob.Schedule(simulationSingleton, state.Dependency);
+        state.Dependency = damageOnTriggerJob.Schedule(simulationSingleton, state.Dependency);
    }
 }
+/// <summary>
-//team lookup is no more necessary as the enemy only collides with player now.
+/// Job that processes trigger events and applies damage to entities based on their interactions.
+/// </summary>
 public struct DamageOnTriggerJob : ITriggerEventsJob
 {
+    /// <summary>
+    /// Read-only lookup for DamageOnTrigger components to determine damage-dealing entities.
+    /// </summary>
    [ReadOnly] public ComponentLookup<DamageOnTrigger> DamageOnTriggerLookup;
+    /// <summary>
+    /// Lookup for AlreadyDamagedEntity buffers to track entities that have already been damaged.
+    /// </summary>
    public BufferLookup<AlreadyDamagedEntity> AlreadyDamagedLookup;
+    /// <summary>
+    /// Lookup for DamageBufferElement buffers to store damage values for entities.
+    /// </summary>
    public BufferLookup<DamageBufferElement> DamageBufferLookup;
+    /// <summary>
+    /// EntityCommandBuffer used to queue entity modifications during the job execution.
+    /// </summary>
    public EntityCommandBuffer ECB;
+    /// <summary>
+    /// Executes the job for each trigger event. Determines the damage-dealing and damage-receiving entities,
+    /// applies damage, and marks entities for destruction if necessary.
+    /// </summary>
+    /// <param name="triggerEvent">The trigger event containing the interacting entities.</param>
    public void Execute(TriggerEvent triggerEvent)
    {
        Entity entityA = triggerEvent.EntityA;
@@ -49,6 +88,7 @@ public struct DamageOnTriggerJob : ITriggerEventsJob
        Entity damageDealingEntity = Entity.Null;
        Entity damageReceivingEntity = Entity.Null;
+        // Determine which entity is dealing damage and which is receiving damage.
        if (DamageBufferLookup.HasBuffer(entityA) &&
            DamageOnTriggerLookup.HasComponent(entityB))
        {
@@ -66,6 +106,7 @@ public struct DamageOnTriggerJob : ITriggerEventsJob
            return;
        }
+        // Check if the damage-dealing entity has already damaged the receiving entity.
        if (AlreadyDamagedLookup.HasBuffer(damageDealingEntity))
        {
            var alreadyDamagedBuffer = AlreadyDamagedLookup[damageDealingEntity];
@@ -76,9 +117,11 @@ public struct DamageOnTriggerJob : ITriggerEventsJob
        }
        else
        {
+            // Add a buffer to track already damaged entities if it doesn't exist.
            ECB.AddBuffer<AlreadyDamagedEntity>(damageDealingEntity);
        }
+        // Apply damage and mark the damage-dealing entity for destruction if applicable.
        if (DamageOnTriggerLookup.TryGetComponent(damageDealingEntity, out var damageOnTrigger))
        {
            ECB.AddComponent<DestroyEntityTag>(damageDealingEntity);

--- a/Assets/_Game/Code/Systems/Combat/HealthBarSystem.cs
+++ b/Assets/_Game/Code/Systems/Combat/HealthBarSystem.cs
@@ -3,54 +3,87 @@ using Unity.Transforms;
 using UnityEngine;
 using UnityEngine.UI;
+/// <summary>
+/// System responsible for managing health bars in the game. This includes spawning health bars for entities,
+/// updating their positions and values, and cleaning up health bars when their associated entities are destroyed.
+/// Does not have a requirement for GamePlayingTag, so player health can be seen when the players are spawned and the game has not started yet
+/// </summary>
 [UpdateAfter(typeof(TransformSystemGroup))]
 [WorldSystemFilter(WorldSystemFilterFlags.ClientSimulation)]
 public partial struct HealthBarSystem : ISystem
 {
+    /// <summary>
+    /// Called when the system is created. Ensures the system only updates when the required components
+    /// (EndSimulationEntityCommandBufferSystem.Singleton and UIPrefabs) are present.
+    /// </summary>
+    /// <param name="state">The current state of the system.</param>
    public void OnCreate(ref SystemState state)
    {
        state.RequireForUpdate<EndSimulationEntityCommandBufferSystem.Singleton>();
        state.RequireForUpdate<UIPrefabs>();
-        state.RequireForUpdate<GamePlayingTag>();
    }
+    /// <summary>
+    /// Called every frame to update the system. Handles the creation, updating, and cleanup of health bars.
+    /// </summary>
+    /// <param name="state">The current state of the system.</param>
    public void OnUpdate(ref SystemState state)
    {
+        // Retrieve the EntityCommandBuffer for queuing entity modifications.
        var ecbSingleton = SystemAPI.GetSingleton<EndSimulationEntityCommandBufferSystem.Singleton>();
        var ecb = ecbSingleton.CreateCommandBuffer(state.WorldUnmanaged);
+        // Spawn health bars for entities that do not already have one.
        foreach (var (transform, healthBarOffset, maxHitPoints, entity) in SystemAPI
                     .Query<LocalTransform, HealthBarOffset, MaxHitPoints>().WithNone<HealthBarUIReference>()
                     .WithEntityAccess())
        {
+            // Instantiate a new health bar at the entity's position plus the offset.
            var healthBarPrefab = SystemAPI.ManagedAPI.GetSingleton<UIPrefabs>().PlayerHealthUIEntity;
            var spawnPosition = transform.Position + healthBarOffset.Value;
            var newHealthBar = Object.Instantiate(healthBarPrefab, spawnPosition, Quaternion.identity);
+            // Initialize the health bar with the entity's maximum hit points.
            SetHealthBar(newHealthBar, maxHitPoints.Value, maxHitPoints.Value);
+            // Add a reference to the health bar in the entity's components.
            ecb.AddComponent(entity, new HealthBarUIReference { Value = newHealthBar });
        }
-        // Update position and values of health bar
+        // Update the position and values of existing health bars.
        foreach (var (transform, healthBarOffset, currentHitPoints, maxHitPoints, healthBarUI) in SystemAPI
                     .Query<LocalTransform, HealthBarOffset, CurrentHitPoints, MaxHitPoints, HealthBarUIReference>())
        {
+            // Update the health bar's position to match the entity's position plus the offset.
            var healthBarPosition = transform.Position + healthBarOffset.Value;
            healthBarUI.Value.transform.position = healthBarPosition;
+            // Update the health bar's slider values to reflect the entity's current and maximum hit points.
            SetHealthBar(healthBarUI.Value, currentHitPoints.Value, maxHitPoints.Value);
        }
-        // Cleanup health bar once associated entity is destroyed
+        // Cleanup health bars for entities that no longer exist.
        foreach (var (healthBarUI, entity) in SystemAPI.Query<HealthBarUIReference>().WithNone<LocalTransform>()
                     .WithEntityAccess())
        {
+            // Destroy the health bar GameObject and remove the reference component from the entity.
            Object.Destroy(healthBarUI.Value);
            ecb.RemoveComponent<HealthBarUIReference>(entity);
        }
    }
+    /// <summary>
+    /// Configures the health bar's slider to display the current and maximum hit points.
+    /// </summary>
+    /// <param name="healthBarCanvasObject">The GameObject representing the health bar.</param>
+    /// <param name="curHitPoints">The current hit points of the entity.</param>
+    /// <param name="maxHitPoints">The maximum hit points of the entity.</param>
    private void SetHealthBar(GameObject healthBarCanvasObject, int curHitPoints, int maxHitPoints)
    {
+        // Retrieve the Slider component from the health bar GameObject.
        var healthBarSlider = healthBarCanvasObject.GetComponentInChildren<Slider>();
+        // Set the slider's minimum, maximum, and current values.
        healthBarSlider.minValue = 0;
        healthBarSlider.maxValue = maxHitPoints;
        healthBarSlider.value = curHitPoints;

--- a/Assets/_Game/Code/Systems/Combat/MoveAbilitySystem.cs
+++ b/Assets/_Game/Code/Systems/Combat/MoveAbilitySystem.cs
@@ -4,15 +4,28 @@ using Unity.Physics;
 using Unity.Transforms;
 using Unity.NetCode;
+/// <summary>
+/// System responsible for handling movement abilities of entities. 
+/// Updates the velocity of entities based on their movement speed and direction.
+/// </summary>
 [UpdateInGroup(typeof(PredictedSimulationSystemGroup))]
 public partial struct MoveAbilitySystem : ISystem
 {
+    /// <summary>
+    /// Called when the system is created. Ensures the system only updates when the required components
+    /// (GamePlayingTag and AbilityMoveSpeed) are present.
+    /// </summary>
+    /// <param name="state">The current state of the system.</param>
    public void OnCreate(ref SystemState state)
    {
-        state.RequireForUpdate<GamePlayingTag>(); 
+        state.RequireForUpdate<GamePlayingTag>();
        state.RequireForUpdate<AbilityMoveSpeed>();
    }
+    /// <summary>
+    /// Called every frame to update the system. Schedules the MoveAbilityJob to process entity movement in parallel.
+    /// </summary>
+    /// <param name="state">The current state of the system.</param>
    public void OnUpdate(ref SystemState state)
    {
        state.Dependency = new MoveAbilityJob()
@@ -20,10 +33,21 @@ public partial struct MoveAbilitySystem : ISystem
    }
 }
+/// <summary>
+/// Job that processes entity movement by updating their velocity based on their forward direction
+/// and movement speed. Excludes entities with the SlimeTag component.
+/// </summary>
 [BurstCompile]
 [WithNone(typeof(SlimeTag))]
 public partial struct MoveAbilityJob : IJobEntity
 {
+    /// <summary>
+    /// Executes the job for each entity. Calculates the linear velocity of the entity
+    /// based on its forward direction and movement speed.
+    /// </summary>
+    /// <param name="velocity">The physics velocity of the entity.</param>
+    /// <param name="transform">The local transform of the entity.</param>
+    /// <param name="moveSpeed">The movement speed of the entity.</param>
    [BurstCompile]
    private void Execute(
        ref PhysicsVelocity velocity,

--- a/Assets/_Game/Code/Systems/Combat/MoveSlimeSystem.cs
+++ b/Assets/_Game/Code/Systems/Combat/MoveSlimeSystem.cs
+using Unity.Burst;
+using Unity.Collections;
+using Unity.Entities;
+using Unity.Mathematics;
+using Unity.NetCode;
+using Unity.Physics;
+using Unity.Transforms;
+/// <summary>
+/// System responsible for moving slime entities towards their target positions.
+/// This system runs in the PredictedSimulationSystemGroup and executes last in the group.
+/// </summary>
+[UpdateInGroup(typeof(PredictedSimulationSystemGroup), OrderLast = true)]
+public partial struct MoveSlimeSystem : ISystem
+{
+    /// <summary>
+    /// Called when the system is created. Ensures the system only updates when
+    /// entities with the required components (SlimeTag and GamePlayingTag) exist.
+    /// </summary>
+    /// <param name="state">The system state.</param>
+    public void OnCreate(ref SystemState state)
+    {
+        state.RequireForUpdate<SlimeTag>();
+        state.RequireForUpdate<GamePlayingTag>();
+    }
+    /// <summary>
+    /// Called every frame to update the system. Schedules a job to move slime entities
+    /// towards their target positions based on their move speed and target entity.
+    /// </summary>
+    /// <param name="state">The system state.</param>
+    [BurstCompile]
+    public void OnUpdate(ref SystemState state)
+    {
+        // Lookup for LocalTransform components, used to get the position of target entities.
+        var transformLookup = SystemAPI.GetComponentLookup<LocalTransform>(true);
+        // Schedule the SlimeMoveDirectJob to run in parallel.
+        state.Dependency = new SlimeMoveDirectJob
+        {
+            TransformLookup = transformLookup
+        }.ScheduleParallel(state.Dependency);
+    }
+    /// <summary>
+    /// Job that handles the movement of slime entities towards their target positions.
+    /// </summary>
+    [BurstCompile]
+    public partial struct SlimeMoveDirectJob : IJobEntity
+    {
+        /// <summary>
+        /// Read-only lookup for LocalTransform components to access target entity positions.
+        /// </summary>
+        [ReadOnly] public ComponentLookup<LocalTransform> TransformLookup;
+        /// <summary>
+        /// Executes the job for each entity. Updates the entity's velocity to move it
+        /// towards its target position, or stops it if no valid target exists.
+        /// </summary>
+        /// <param name="velocity">The entity's current velocity.</param>
+        /// <param name="transform">The entity's current transform.</param>
+        /// <param name="moveSpeed">The entity's movement speed.</param>
+        /// <param name="targetEntity">The target entity the slime is moving towards.</param>
+        [BurstCompile]
+        private void Execute(
+            ref PhysicsVelocity velocity,
+            in LocalTransform transform,
+            in AbilityMoveSpeed moveSpeed,
+            in NpcTargetEntity targetEntity)
+        {
+            // If the target entity is null or does not have a LocalTransform, stop the entity.
+            if (targetEntity.Value == Entity.Null || !TransformLookup.HasComponent(targetEntity.Value))
+            {
+                velocity.Linear = float3.zero;
+                return;
+            }
+            // Calculate the direction towards the target and update the velocity.
+            var targetPosition = TransformLookup[targetEntity.Value].Position;
+            var direction = math.normalize(targetPosition - transform.Position);
+            velocity.Linear = direction * moveSpeed.Value;
+        }
+    }
+}
\ No newline at end of file
--- a/Assets/_Game/Code/Systems/Combat/MoveSlimeSystem.cs.meta
+++ b/Assets/_Game/Code/Systems/Combat/MoveSlimeSystem.cs.meta
 fileFormatVersion: 2
-guid: 3783f791f48f7b047a3354bfe6fc88c9
+guid: 86f8c4a7fca9c2244981a82be26b0c7d
\ No newline at end of file
--- a/Assets/_Game/Code/Systems/Combat/RogueAttackSystem.cs
+++ b/Assets/_Game/Code/Systems/Combat/RogueAttackSystem.cs
@@ -5,9 +5,18 @@ using Unity.Mathematics;
 using Unity.NetCode;
 using Unity.Transforms;
+/// <summary>
+/// System responsible for handling rogue NPC attacks. This system ensures that NPCs can attack their targets
+/// based on cooldowns and attack properties, and updates their transformations accordingly.
+/// </summary>
 [UpdateInGroup(typeof(PredictedSimulationSystemGroup))]
 public partial struct RogueAttackSystem : ISystem
 {
+    /// <summary>
+    /// Called when the system is created. Ensures the system only updates when the required components
+    /// (NetworkTime, BeginSimulationEntityCommandBufferSystem.Singleton, and GamePlayingTag) are present.
+    /// </summary>
+    /// <param name="state">The current state of the system.</param>
    public void OnCreate(ref SystemState state)
    {
        state.RequireForUpdate<NetworkTime>();
@@ -15,11 +24,17 @@ public partial struct RogueAttackSystem : ISystem
        state.RequireForUpdate<GamePlayingTag>();
    }
+    /// <summary>
+    /// Called every frame to update the system. Schedules the NpcAttackJob to process NPC attacks in parallel.
+    /// </summary>
+    /// <param name="state">The current state of the system.</param>
    public void OnUpdate(ref SystemState state)
    {
+        // Retrieve the EntityCommandBuffer singleton and the current network time.
        var ecbSingleton = SystemAPI.GetSingleton<BeginSimulationEntityCommandBufferSystem.Singleton>();
        var networkTime = SystemAPI.GetSingleton<NetworkTime>();
+        // Schedule the NpcAttackJob to handle NPC attack logic.
        state.Dependency = new NpcAttackJob
        {
            CurrentTick = networkTime.ServerTick,
@@ -29,51 +44,85 @@ public partial struct RogueAttackSystem : ISystem
    }
 }
+/// <summary>
+/// Job that processes NPC attack logic. Handles attack cooldowns, target rotation, and attack instantiation.
+/// Excludes entities with the SlimeTag component.
+/// </summary>
 [BurstCompile]
 [WithAll(typeof(Simulate))]
 [WithNone(typeof(SlimeTag))]
 public partial struct NpcAttackJob : IJobEntity
 {
+    /// <summary>
+    /// The current server tick used to determine attack cooldowns.
+    /// </summary>
    [ReadOnly] public NetworkTick CurrentTick;
+    /// <summary>
+    /// Read-only lookup for LocalTransform components to access entity positions and rotations.
+    /// </summary>
    [ReadOnly] public ComponentLookup<LocalTransform> TransformLookup;
+    /// <summary>
+    /// Parallel writer for queuing entity modifications during the job execution.
+    /// </summary>
    public EntityCommandBuffer.ParallelWriter ECB;
+    /// <summary>
+    /// Executes the job for each entity. Handles attack cooldowns, rotates the NPC towards its target,
+    /// and spawns attack entities with the appropriate transformations.
+    /// </summary>
+    /// <param name="attackCooldown">The buffer storing attack cooldown data for the NPC.</param>
+    /// <param name="attackProperties">The properties defining the NPC's attack behavior.</param>
+    /// <param name="targetEntity">The target entity the NPC is attacking.</param>
+    /// <param name="enemyEntity">The NPC entity performing the attack.</param>
+    /// <param name="team">The team type of the NPC.</param>
+    /// <param name="sortKey">The chunk index used for parallel execution.</param>
    [BurstCompile]
-    private void Execute(ref DynamicBuffer<NpcAttackCooldown> attackCooldown, in NpcAttackProperties attackProperties,
+    private void Execute(
-        in NpcTargetEntity targetEntity, Entity enemyEntity, TeamTypes team, [ChunkIndexInQuery] int sortKey)
+        ref DynamicBuffer<NpcAttackCooldown> attackCooldown,
+        in NpcAttackProperties attackProperties,
+        in NpcTargetEntity targetEntity,
+        Entity enemyEntity,
+        TeamTypes team,
+        [ChunkIndexInQuery] int sortKey)
    {
+        // Ensure the target entity has a LocalTransform component.
        if (!TransformLookup.HasComponent(targetEntity.Value)) return;
+        // Retrieve or initialize the cooldown expiration tick.
        if (!attackCooldown.GetDataAtTick(CurrentTick, out var cooldownExpirationTick))
        {
            cooldownExpirationTick.Value = NetworkTick.Invalid;
        }
+        // Check if the NPC can attack based on the cooldown.
        var canAttack = !cooldownExpirationTick.Value.IsValid ||
                        CurrentTick.IsNewerThan(cooldownExpirationTick.Value);
        if (!canAttack) return;
+        // Retrieve the enemy's and target's transformations.
        var enemyTransform = TransformLookup[enemyEntity];
-        var spawnPosition = enemyTransform.Position;
        var targetPosition = TransformLookup[targetEntity.Value].Position;
-        // Get the vector from the enemy to the player
+        // Calculate the direction and rotation towards the target.
-        var direction = math.normalize(targetPosition - spawnPosition);
+        var direction = math.normalize(targetPosition - enemyTransform.Position);
        var targetRotation = quaternion.LookRotationSafe(direction, math.up());
-        // Rotate the enemy towards player
+        // Rotate the NPC towards the target.
        enemyTransform.Rotation = targetRotation;
        ECB.SetComponent(sortKey, enemyEntity, enemyTransform);
+        // Spawn the attack entity at the appropriate position and rotation.
        var newAttack = ECB.Instantiate(sortKey, attackProperties.AttackPrefab);
-        var newAttackTransform = LocalTransform.FromPositionRotation(spawnPosition + attackProperties.FirePointOffset,
+        var newAttackTransform = LocalTransform.FromPositionRotation(
-            quaternion.LookRotationSafe(targetPosition - spawnPosition, math.up()));
+            enemyTransform.Position + attackProperties.FirePointOffset,
+            quaternion.LookRotationSafe(targetPosition - enemyTransform.Position, math.up()));
        ECB.SetComponent(sortKey, newAttack, newAttackTransform);
        ECB.SetComponent(sortKey, newAttack, team);
+        // Update the attack cooldown.
        var newCooldownTick = CurrentTick;
        newCooldownTick.Add(attackProperties.CooldownTickCount);
        attackCooldown.AddCommandData(new NpcAttackCooldown { Tick = CurrentTick, Value = newCooldownTick });

--- a/Assets/_Game/Code/Systems/Combat/SetTargetSlimeSystem.cs
+++ b/Assets/_Game/Code/Systems/Combat/SetTargetSlimeSystem.cs
-using Unity.Burst;
-using Unity.Collections;
-using Unity.Entities;
-using Unity.Mathematics;
-using Unity.NetCode;
-using Unity.Physics;
-using Unity.Transforms;
-[UpdateInGroup(typeof(PredictedSimulationSystemGroup), OrderLast = true)]
-public partial struct MoveSlimeSystem : ISystem
-{
-    public void OnCreate(ref SystemState state)
-    {
-        state.RequireForUpdate<BeginSimulationEntityCommandBufferSystem.Singleton>();
-        state.RequireForUpdate<SlimeTag>();
-        state.RequireForUpdate<GamePlayingTag>();
-    }
-    [BurstCompile]
-    public void OnUpdate(ref SystemState state)
-    {
-        var transformLookup = SystemAPI.GetComponentLookup<LocalTransform>(true);
-        state.Dependency = new SlimeMoveDirectJob
-        {
-            TransformLookup = transformLookup
-        }.ScheduleParallel(state.Dependency);
-    }
-    [BurstCompile]
-    public partial struct SlimeMoveDirectJob : IJobEntity
-    {
-        [ReadOnly] public ComponentLookup<LocalTransform> TransformLookup;
-        [BurstCompile]
-        private void Execute(
-            ref PhysicsVelocity velocity,
-            in LocalTransform transform,
-            in AbilityMoveSpeed moveSpeed,
-            in NpcTargetEntity targetEntity)
-        {
-            if (targetEntity.Value == Entity.Null || !TransformLookup.HasComponent(targetEntity.Value))
-            {
-                velocity.Linear = float3.zero;
-                return;
-            }
-            var targetPosition = TransformLookup[targetEntity.Value].Position;
-            var direction = math.normalize(targetPosition - transform.Position);
-            velocity.Linear = direction * moveSpeed.Value;
-        }
-    }
-}
\ No newline at end of file
--- a/Assets/_Game/Code/Systems/Combat/SetTargetSlimeSystem.cs.meta
+++ b/Assets/_Game/Code/Systems/Combat/SetTargetSlimeSystem.cs.meta
-fileFormatVersion: 2
-guid: 86f8c4a7fca9c2244981a82be26b0c7d
\ No newline at end of file
--- a/Assets/_Game/Code/Systems/Combat/TargetingSystem.cs
+++ b/Assets/_Game/Code/Systems/Combat/TargetingSystem.cs
@@ -5,13 +5,25 @@ using Unity.Physics;
 using Unity.Physics.Systems;
 using Unity.Transforms;
+/// <summary>
+/// System responsible for targeting logic for NPCs. This system determines the closest valid target
+/// within a specified radius for each NPC and updates the target entity accordingly.
+/// </summary>
 [UpdateInGroup(typeof(PhysicsSystemGroup))]
 [UpdateAfter(typeof(PhysicsSimulationGroup))]
 [UpdateBefore(typeof(ExportPhysicsWorld))]
 public partial struct TargetingSystem : ISystem
 {
+    /// <summary>
+    /// Collision filter used to define which layers the NPCs can target.
+    /// </summary>
    private CollisionFilter _npcAttackFilter;
+    /// <summary>
+    /// Called when the system is created. Ensures the system only updates when the required components
+    /// (PhysicsWorldSingleton and GamePlayingTag) are present. Initializes the collision filter for NPC targeting.
+    /// </summary>
+    /// <param name="state">The current state of the system.</param>
    [BurstCompile]
    public void OnCreate(ref SystemState state)
    {
@@ -19,12 +31,15 @@ public partial struct TargetingSystem : ISystem
        state.RequireForUpdate<GamePlayingTag>();
        _npcAttackFilter = new CollisionFilter
        {
-            BelongsTo = 1 << 6, //Target Cast
+            BelongsTo = 1 << 6, // Target Cast
-            CollidesWith = 1 << 1  //Player
+            CollidesWith = 1 << 1  // Player
        };
    }
+    /// <summary>
+    /// Called every frame to update the system. Schedules the NpcTargetingJob to process NPC targeting logic in parallel.
+    /// </summary>
+    /// <param name="state">The current state of the system.</param>
    [BurstCompile]
    public void OnUpdate(ref SystemState state)
    {
@@ -36,26 +51,51 @@ public partial struct TargetingSystem : ISystem
        }.ScheduleParallel(state.Dependency);
    }
+    /// <summary>
+    /// Job that processes NPC targeting logic. Identifies the closest valid target within the NPC's targeting radius
+    /// and updates the target entity component.
+    /// </summary>
    [BurstCompile]
    [WithAll(typeof(Simulate))]
    public partial struct NpcTargetingJob : IJobEntity
    {
+        /// <summary>
+        /// The collision world used to perform overlap sphere queries for detecting potential targets.
+        /// </summary>
        [ReadOnly] public CollisionWorld CollisionWorld;
+        /// <summary>
+        /// The collision filter defining the layers that NPCs can target.
+        /// </summary>
        [ReadOnly] public CollisionFilter CollisionFilter;
+        /// <summary>
+        /// Read-only lookup for TeamTypes components to ensure NPCs do not target entities on the same team.
+        /// </summary>
        [ReadOnly] public ComponentLookup<TeamTypes> TeamTypeLookup;
+        /// <summary>
+        /// Executes the job for each NPC entity. Finds the closest valid target within the targeting radius
+        /// and updates the NpcTargetEntity component with the target entity.
+        /// </summary>
+        /// <param name="enemyEntity">The NPC entity performing the targeting.</param>
+        /// <param name="targetEntity">The component storing the current target entity for the NPC.</param>
+        /// <param name="transform">The local transform of the NPC entity.</param>
+        /// <param name="targetRadius">The targeting radius of the NPC.</param>
        [BurstCompile]
        private void Execute(Entity enemyEntity, ref NpcTargetEntity targetEntity, in LocalTransform transform,
            in NpcTargetRadius targetRadius)
        {
+            // Temporary list to store potential target hits.
            var hits = new NativeList<DistanceHit>(Allocator.TempJob);
+            // Perform an overlap sphere query to find potential targets within the targeting radius.
            if (CollisionWorld.OverlapSphere(transform.Position, targetRadius.Value, ref hits, CollisionFilter))
            {
                var closestDistance = float.MaxValue;
                var closestEntity = Entity.Null;
+                // Iterate through the hits to find the closest valid target.
                foreach (var hit in hits)
                {
                    if (!TeamTypeLookup.TryGetComponent(hit.Entity, out var teamTypes)) continue;
@@ -67,13 +107,16 @@ public partial struct TargetingSystem : ISystem
                    }
                }
+                // Update the target entity with the closest valid target.
                targetEntity.Value = closestEntity;
            }
            else
            {
+                // If no valid targets are found, set the target entity to null.
                targetEntity.Value = Entity.Null;
            }
+            // Dispose of the temporary hits list.
            hits.Dispose();
        }
    }

--- a/Assets/_Game/Code/Systems/Connection/ClientRequestGameEntrySystem.cs
+++ b/Assets/_Game/Code/Systems/Connection/ClientRequestGameEntrySystem.cs
@@ -4,9 +4,19 @@ using Unity.NetCode;
 using UnityEngine;
+/// <summary>
+/// System responsible for handling game entry requests from client players.
+/// This system ensures that clients are marked as "in-game" and initializes their game-related components,
+/// such as creating a camera and associating it with the player.
+/// </summary>
 [WorldSystemFilter(WorldSystemFilterFlags.ClientSimulation)]
 public partial struct ClientRequestGameEntrySystem : ISystem
 {
+    /// <summary>
+    /// Called when the system is created. Ensures the system only updates when there are entities
+    /// with a `NetworkId` component but without a `NetworkStreamInGame` component.
+    /// </summary>
+    /// <param name="state">The current state of the system.</param>
    public void OnCreate(ref SystemState state)
    {
        EntityQueryBuilder entityQueryBuilder = new EntityQueryBuilder(Allocator.Temp)
@@ -16,35 +26,56 @@ public partial struct ClientRequestGameEntrySystem : ISystem
        entityQueryBuilder.Dispose();
    }
+    /// <summary>
+    /// Called every frame to process game entry requests. Marks clients as "in-game",
+    /// creates a camera for each client, and sends an RPC request to notify the server.
+    /// </summary>
+    /// <param name="state">The current state of the system.</param>
    public void OnUpdate(ref SystemState state)
    {
        EntityCommandBuffer entityCommandBuffer = new EntityCommandBuffer(Unity.Collections.Allocator.Temp);
+        // Iterate through all entities with a `NetworkId` component but without a `NetworkStreamInGame` component.
        foreach ((
                     RefRO<NetworkId> networkId,
                     Entity entity)
                 in SystemAPI.Query
                     <RefRO<NetworkId>>().WithNone<NetworkStreamInGame>().WithEntityAccess())
        {
+            // Add the `NetworkStreamInGame` component to mark the client as "in-game".
            entityCommandBuffer.AddComponent<NetworkStreamInGame>(entity);
+            // Create a new entity for the game entry request.
            var requestGameConnection = entityCommandBuffer.CreateEntity();
+            // Create a new camera GameObject for the client and associate it with the player.
            GameObject playerCameraGO = new GameObject($"Camera{networkId.ValueRO.Value}");
            playerCameraGO.AddComponent<Camera>();
            FollowPlayer followScript = playerCameraGO.AddComponent<FollowPlayer>();
            followScript.networkId = networkId.ValueRO.Value;
+            // Add components to the request entity to send an RPC to the server.
            entityCommandBuffer.AddComponent<GoInGameRequestRpc>(requestGameConnection);
            entityCommandBuffer.AddComponent<SendRpcCommandRequest>(requestGameConnection);
        }
+        // Apply all queued entity modifications.
        entityCommandBuffer.Playback(state.EntityManager);
    }
 }
+/// <summary>
+/// System responsible for handling game entry requests from thin clients.
+/// This system ensures that thin clients are marked as "in-game" and sends an RPC request to notify the server.
+/// </summary>
 [WorldSystemFilter(WorldSystemFilterFlags.ThinClientSimulation)]
 public partial struct ThinClientRequestGameEntrySystem : ISystem
 {
+    /// <summary>
+    /// Called when the system is created. Ensures the system only updates when there are entities
+    /// with a `NetworkId` component but without a `NetworkStreamInGame` component.
+    /// </summary>
+    /// <param name="state">The current state of the system.</param>
    public void OnCreate(ref SystemState state)
    {
        EntityQueryBuilder entityQueryBuilder = new EntityQueryBuilder(Allocator.Temp)
@@ -54,24 +85,34 @@ public partial struct ThinClientRequestGameEntrySystem : ISystem
        entityQueryBuilder.Dispose();
    }
+    /// <summary>
+    /// Called every frame to process game entry requests. Marks thin clients as "in-game"
+    /// and sends an RPC request to notify the server.
+    /// </summary>
+    /// <param name="state">The current state of the system.</param>
    public void OnUpdate(ref SystemState state)
    {
        EntityCommandBuffer entityCommandBuffer = new EntityCommandBuffer(Unity.Collections.Allocator.Temp);
+        // Iterate through all entities with a `NetworkId` component but without a `NetworkStreamInGame` component.
        foreach ((
                     RefRO<NetworkId> networkId,
                     Entity entity)
                 in SystemAPI.Query
                     <RefRO<NetworkId>>().WithNone<NetworkStreamInGame>().WithEntityAccess())
        {
+            // Add the `NetworkStreamInGame` component to mark the thin client as "in-game".
            entityCommandBuffer.AddComponent<NetworkStreamInGame>(entity);
+            // Create a new entity for the game entry request.
            var requestGameConnection = entityCommandBuffer.CreateEntity();
+            // Add components to the request entity to send an RPC to the server.
            entityCommandBuffer.AddComponent<GoInGameRequestRpc>(requestGameConnection);
            entityCommandBuffer.AddComponent<SendRpcCommandRequest>(requestGameConnection);
        }
+        // Apply all queued entity modifications.
        entityCommandBuffer.Playback(state.EntityManager);
    }
 }
\ No newline at end of file
--- a/Assets/_Game/Code/Systems/Connection/ClientStartGameSystem.cs
+++ b/Assets/_Game/Code/Systems/Connection/ClientStartGameSystem.cs
@@ -4,38 +4,65 @@ using Unity.Collections;
 using Unity.Entities;
 using Unity.NetCode;
+/// <summary>
+/// System responsible for handling client-side game start logic. This system processes RPCs related to the 
+/// number of players remaining to start the game and the game start tick, triggering appropriate actions 
+/// and updating the game state on the client.
+/// </summary>
 [WorldSystemFilter(WorldSystemFilterFlags.ClientSimulation)]
 public partial class ClientStartGameSystem : SystemBase
 {
+    /// <summary>
+    /// Action invoked when the number of players remaining to start the game is updated.
+    /// </summary>
    public Action<int> OnUpdatePlayersRemainingToStart;
+    /// <summary>
+    /// Action invoked when the game start countdown begins.
+    /// </summary>
    public Action OnStartGameCountdown;
+    /// <summary>
+    /// Called every frame to process game start-related RPCs. Handles the destruction of RPC entities, 
+    /// updates the number of players remaining to start, and initializes the game start tick on the client.
+    /// </summary>
    protected override void OnUpdate()
    {
+        // Create a temporary EntityCommandBuffer to queue entity modifications.
        var ecb = new EntityCommandBuffer(Allocator.Temp);
+        // Process RPCs for updating the number of players remaining to start the game.
        foreach (var (playersRemainingToStart, entity) in SystemAPI.Query<PlayersRemainingToStart>()
                     .WithAll<ReceiveRpcCommandRequest>().WithEntityAccess())
        {
+            // Destroy the RPC entity after processing.
            ecb.DestroyEntity(entity);
+            // Invoke the action to update the number of players remaining to start.
            OnUpdatePlayersRemainingToStart?.Invoke(playersRemainingToStart.Value);
        }
+        // Process RPCs for the game start tick.
        foreach (var (gameStartTick, entity) in SystemAPI.Query<GameStartTickRpc>()
                     .WithAll<ReceiveRpcCommandRequest>().WithEntityAccess())
        {
+            // Destroy the RPC entity after processing.
            ecb.DestroyEntity(entity);
+            // Invoke the action to start the game countdown.
            OnStartGameCountdown?.Invoke();
+            // Create a new entity to store the game start tick on the client side.
            var gameStartEntity = ecb.CreateEntity();
-            //creates the entity about when the game has started on client side
+            // Add the GameStartTick component to the new entity with the received tick value.
            ecb.AddComponent(gameStartEntity, new GameStartTick
            {
                Value = gameStartTick.Value
            });
        }
+        // Apply all queued entity modifications.
        ecb.Playback(EntityManager);
    }
 }
\ No newline at end of file
--- a/Assets/_Game/Code/Systems/Connection/CountDownToGameStartSystem.cs
+++ b/Assets/_Game/Code/Systems/Connection/CountDownToGameStartSystem.cs
@@ -5,46 +5,79 @@ using Unity.Entities;
 using Unity.Mathematics;
 using Unity.NetCode;
 [UpdateInGroup(typeof(PredictedSimulationSystemGroup))]
 public partial class CountdownToGameStartSystem : SystemBase
 {
+    /// <summary>
+    /// Action invoked to update the countdown text with the number of seconds remaining until the game starts.
+    /// </summary>
    public Action<int> OnUpdateCountdownText;
+    /// <summary>
+    /// Action invoked when the countdown ends and the game starts.
+    /// </summary>
    public Action OnCountdownEnd;
+    /// <summary>
+    /// Called when the system is created. Ensures the system only updates when a `NetworkTime` component is present.
+    /// </summary>
    protected override void OnCreate()
    {
        RequireForUpdate<NetworkTime>();
    }
+    /// <summary>
+    /// Called every frame to process the countdown to the game start. Updates the countdown text or triggers
+    /// the game start logic when the countdown ends.
+    /// </summary>
    protected override void OnUpdate()
    {
+        // Retrieve the current network time.
        var networkTime = SystemAPI.GetSingleton<NetworkTime>();
+        // Skip processing if this is not the first time fully predicting the current tick.
        if (!networkTime.IsFirstTimeFullyPredictingTick) return;
+        // Get the current server tick.
        var currentTick = networkTime.ServerTick;
+        // Create a temporary EntityCommandBuffer to queue entity modifications.
        var ecb = new EntityCommandBuffer(Allocator.Temp);
+        // Iterate through all entities with a `GameStartTick` component and a `Simulate` tag.
        foreach (var (gameStartTick, entity) in SystemAPI.Query<GameStartTick>().WithAll<Simulate>().WithEntityAccess())
        {
+            // Check if the current tick is equal to or newer than the game start tick.
            if (currentTick.Equals(gameStartTick.Value) || currentTick.IsNewerThan(gameStartTick.Value))
            {
+                // Create a new entity to represent the game playing state.
                var gamePlayingEntity = ecb.CreateEntity();
                ecb.SetName(gamePlayingEntity, "GamePlayingEntity");
                ecb.AddComponent<GamePlayingTag>(gamePlayingEntity);
+                // Destroy the `GameStartTick` entity as the countdown has ended.
                ecb.DestroyEntity(entity);
+                // Invoke the action to signal the end of the countdown.
                OnCountdownEnd?.Invoke();
            }
            else
            {
+                // Calculate the number of ticks remaining until the game starts.
                var ticksToStart = gameStartTick.Value.TickIndexForValidTick - currentTick.TickIndexForValidTick;
+                // Retrieve the simulation tick rate.
                var simulationTickRate = NetCodeConfig.Global.ClientServerTickRate.SimulationTickRate;
+                // Calculate the number of seconds remaining until the game starts.
                var secondsToStart = (int)math.ceil((float)ticksToStart / simulationTickRate);
+                // Invoke the action to update the countdown text.
                OnUpdateCountdownText?.Invoke(secondsToStart);
            }
        }
+        // Apply all queued entity modifications.
        ecb.Playback(EntityManager);
    }
 }
\ No newline at end of file
--- a/Assets/_Game/Code/Systems/Connection/GoInGameServerSystem.cs
+++ b/Assets/_Game/Code/Systems/Connection/GoInGameServerSystem.cs
@@ -8,6 +8,11 @@ using UnityEngine;
 [WorldSystemFilter(WorldSystemFilterFlags.ServerSimulation)]
 partial struct GoInGameServerSystem : ISystem
 {
+    /// <summary>
+    /// Called when the system is created. Ensures the system only updates when the required components
+    /// and entities are present in the world.
+    /// </summary>
+    /// <param name="state">The current state of the system.</param>
    [BurstCompile]
    public void OnCreate(ref SystemState state)
    {
@@ -19,63 +24,81 @@ partial struct GoInGameServerSystem : ISystem
        state.RequireForUpdate<GoInGameRequestRpc>();
    }
+    /// <summary>
+    /// Called every frame to process incoming game entry requests from clients. Handles player instantiation,
+    /// updates the player counter, and sends RPCs to clients about the game start or remaining players.
+    /// </summary>
+    /// <param name="state">The current state of the system.</param>
    public void OnUpdate(ref SystemState state)
    {
+        // Create a temporary command buffer to queue entity modifications.
        EntityCommandBuffer entityCommandBuffer = new EntityCommandBuffer(Unity.Collections.Allocator.Temp);
+        // Retrieve singleton components and entities required for processing.
        EntititesReferences entititesReferences = SystemAPI.GetSingleton<EntititesReferences>();
        Entity gameStartPropertiesEntity = SystemAPI.GetSingletonEntity<GameStartProperties>();
        PlayerCounter playerCounter = SystemAPI.GetComponent<PlayerCounter>(gameStartPropertiesEntity);
        GameStartProperties gameStartProperties =
            SystemAPI.GetComponent<GameStartProperties>(gameStartPropertiesEntity);
+        // Iterate through all entities with a `ReceiveRpcCommandRequest` and `GoInGameRequestRpc` component.
        foreach ((
                     RefRO<ReceiveRpcCommandRequest> receiveRpcCommandRequest,
                     Entity entity) in
                 SystemAPI.Query
                     <RefRO<ReceiveRpcCommandRequest>>().WithAll<GoInGameRequestRpc>().WithEntityAccess())
        {
+            // Get the source connection entity from the RPC request.
            Entity sourceConnection =
-                receiveRpcCommandRequest.ValueRO.SourceConnection; // Get the source connection entity
+                receiveRpcCommandRequest.ValueRO.SourceConnection;
+            // Mark the client as "in-game" by adding the `NetworkStreamInGame` component.
            entityCommandBuffer.AddComponent<NetworkStreamInGame>(sourceConnection);
            Debug.Log("Client Connected to Server");
-            entityCommandBuffer.DestroyEntity(entity);
+            // Destroy the RPC entity after processing.
+            entityCommandBuffer.DestroyEntity(entity);
-            // Instantiate player entity and place randomly on the x axis -+10
+            // Instantiate a player entity and set its position randomly along the x-axis.
            Entity playerEntity = entityCommandBuffer.Instantiate(entititesReferences.PlayerPrefabEntity);
            entityCommandBuffer.SetComponent(playerEntity, LocalTransform.FromPosition(new float3(
                UnityEngine.Random.Range(-10, +10), 0, 0)));
-            NetworkId networkId = SystemAPI.GetComponent<NetworkId>(sourceConnection); // use sourceConnection
+            // Retrieve the `NetworkId` component from the source connection and assign it to the player entity.
+            NetworkId networkId = SystemAPI.GetComponent<NetworkId>(sourceConnection);
            entityCommandBuffer.AddComponent(playerEntity, new GhostOwner
            {
                NetworkId = networkId.Value
            });
            entityCommandBuffer.AddComponent(playerEntity, new NetworkEntityReference { Value = sourceConnection });
-            entityCommandBuffer.AppendToBuffer(sourceConnection, new LinkedEntityGroup // use sourceConnection
+            // Link the player entity to the source connection using a `LinkedEntityGroup` buffer.
+            entityCommandBuffer.AppendToBuffer(sourceConnection, new LinkedEntityGroup
            {
                Value = playerEntity
            });
+            // Update the player counter and calculate the number of players remaining to start the game.
            playerCounter.Value++;
            int playersRemainingToStart = gameStartProperties.PlayerAmount - playerCounter.Value;
+            // Create an RPC entity to notify clients about the game start or remaining players.
            var gameStartRpc = entityCommandBuffer.CreateEntity();
            if (playersRemainingToStart <= 0 && !SystemAPI.HasSingleton<GamePlayingTag>())
            {
+                // Calculate the tick at which the game should start.
                var simulationTickRate = NetCodeConfig.Global.ClientServerTickRate.SimulationTickRate;
                var ticksUntilStart = (uint)(simulationTickRate * gameStartProperties.CountdownTime);
                var gameStartTick = SystemAPI.GetSingleton<NetworkTime>().ServerTick;
                gameStartTick.Add(ticksUntilStart);
-                // sends data to client about on what tick the game should start.
+                // Add a `GameStartTickRpc` component to the RPC entity with the calculated start tick.
                entityCommandBuffer.AddComponent(gameStartRpc, new GameStartTickRpc
                {
                    Value = gameStartTick
                });
-                //creates the entity about when the game has started on server side
+                // Create a server-side entity to track the game start tick.
                var gameStartEntity = entityCommandBuffer.CreateEntity();
                entityCommandBuffer.AddComponent(gameStartEntity, new GameStartTick
                {
@@ -84,14 +107,19 @@ partial struct GoInGameServerSystem : ISystem
            }
            else
            {
+                // Add a `PlayersRemainingToStart` component to the RPC entity with the remaining player count.
                entityCommandBuffer.AddComponent(gameStartRpc,
                    new PlayersRemainingToStart { Value = playersRemainingToStart });
            }
+            // Add a `SendRpcCommandRequest` component to the RPC entity to send it to clients.
            entityCommandBuffer.AddComponent<SendRpcCommandRequest>(gameStartRpc);
        }
+        // Apply all queued entity modifications.
        entityCommandBuffer.Playback(state.EntityManager);
+        // Update the singleton `PlayerCounter` component with the new value.
        SystemAPI.SetSingleton(playerCounter);
    }
 }
\ No newline at end of file
--- a/Assets/_Game/Code/Systems/Destroy/DestroyEntitySystem.cs
+++ b/Assets/_Game/Code/Systems/Destroy/DestroyEntitySystem.cs
@@ -5,12 +5,17 @@ using Unity.NetCode;
 using Unity.Transforms;
 using UnityEngine;
 [UpdateInGroup(typeof(PredictedSimulationSystemGroup), OrderLast = true)]
 public partial struct DestroyEntitySystem : ISystem
 {
+    /// <summary>
+    /// Called when the system is created. Ensures the system only updates when the required components
+    /// and entities are present in the world.
+    /// </summary>
+    /// <param name="state">The current state of the system.</param>
    public void OnCreate(ref SystemState state)
    {
+        // Require specific components and entities for the system to update.
        state.RequireForUpdate<RespawnEntityTag>();
        state.RequireForUpdate<BeginSimulationEntityCommandBufferSystem.Singleton>();
        state.RequireForUpdate<NetworkTime>();
@@ -18,35 +23,49 @@ public partial struct DestroyEntitySystem : ISystem
        state.RequireForUpdate<DestroyEntityTag>();
    }
+    /// <summary>
+    /// Called every frame to process entities marked for destruction. Handles player-specific logic
+    /// such as respawn scheduling and destroys non-player entities directly.
+    /// </summary>
+    /// <param name="state">The current state of the system.</param>
    public void OnUpdate(ref SystemState state)
    {
+        // Retrieve the current network time.
        var networkTime = SystemAPI.GetSingleton<NetworkTime>();
+        // Skip processing if this is not the first time fully predicting the current tick.
        if (!networkTime.IsFirstTimeFullyPredictingTick) return;
+        // Get the current server tick.
        var currentTick = networkTime.ServerTick;
+        // Retrieve the EntityCommandBuffer for queuing entity modifications.
        var ecbSingleton = SystemAPI.GetSingleton<BeginSimulationEntityCommandBufferSystem.Singleton>();
        var ecb = ecbSingleton.CreateCommandBuffer(state.WorldUnmanaged);
+        // Iterate through all entities with a LocalTransform component, DestroyEntityTag, and Simulate tag.
        foreach (var (transform, entity) in SystemAPI.Query<RefRW<LocalTransform>>()
                     .WithAll<DestroyEntityTag, Simulate>().WithEntityAccess())
        {
+            // Check if the current world is the server.
            if (state.World.IsServer())
            {
+                // Handle player entities.
                if (SystemAPI.HasComponent<PlayerTag>(entity))
                {
+                    // Retrieve the network entity and respawn-related components.
                    var networkEntity = SystemAPI.GetComponent<NetworkEntityReference>(entity).Value;
                    var respawnEntity = SystemAPI.GetSingletonEntity<RespawnEntityTag>();
                    var respawnTickCount = SystemAPI.GetComponent<RespawnTickCount>(respawnEntity).Value;
+                    // Calculate the tick at which the player should respawn.
                    var respawnTick = currentTick;
                    respawnTick.Add(respawnTickCount);
-                    // Store NetworkId BEFORE destroying entity or networkEntity
+                    // Store the NetworkId before destroying the entity.
                    int networkIdValue = SystemAPI.GetComponent<NetworkId>(networkEntity).Value;
+                    // Append the player to the respawn buffer with the calculated respawn tick.
                    ecb.AppendToBuffer(respawnEntity, new RespawnBufferElement
                    {
                        NetworkEntity = networkEntity,
@@ -54,11 +73,13 @@ public partial struct DestroyEntitySystem : ISystem
                        NetworkId = networkIdValue
                    });
+                    // Destroy the player entity.
                    ecb.DestroyEntity(entity);
                }
                else
                {
-                    ecb.DestroyEntity(entity); // Destroy non-player entities
+                    // Destroy non-player entities directly.
+                    ecb.DestroyEntity(entity);
                }
            }
        }

--- a/Assets/_Game/Code/Systems/Destroy/DestroyOnTimerSystem.cs
+++ b/Assets/_Game/Code/Systems/Destroy/DestroyOnTimerSystem.cs
@@ -5,27 +5,44 @@ using Unity.NetCode;
 [UpdateInGroup(typeof(PredictedSimulationSystemGroup))]
 public partial struct DestroyOnTimerSystem : ISystem
 {
+    /// <summary>
+    /// Called when the system is created. Ensures the system only updates when the required components
+    /// and entities are present in the world.
+    /// </summary>
+    /// <param name="state">The current state of the system.</param>
    public void OnCreate(ref SystemState state)
    {
+        // Require specific components and entities for the system to update.
        state.RequireForUpdate<NetworkTime>();
        state.RequireForUpdate<EndSimulationEntityCommandBufferSystem.Singleton>();
        state.RequireForUpdate<DestroyAtTick>();
        state.RequireForUpdate<GamePlayingTag>();
    }
+    /// <summary>
+    /// Called every frame to process entities with a `DestroyAtTick` component. Adds a `DestroyEntityTag`
+    /// to entities whose destruction tick has been reached or passed.
+    /// </summary>
+    /// <param name="state">The current state of the system.</param>
    [BurstCompile]
    public void OnUpdate(ref SystemState state)
    {
+        // Retrieve the EntityCommandBuffer for queuing entity modifications.
        var ecbSingleton = SystemAPI.GetSingleton<EndSimulationEntityCommandBufferSystem.Singleton>();
        var ecb = ecbSingleton.CreateCommandBuffer(state.WorldUnmanaged);
+        // Get the current server tick.
        var currentTick = SystemAPI.GetSingleton<NetworkTime>().ServerTick;
+        // Iterate through all entities with a `DestroyAtTick` component and a `Simulate` tag,
+        // but without a `DestroyEntityTag`.
        foreach (var (destroyAtTick, entity) in SystemAPI.Query<RefRW<DestroyAtTick>>().WithAll<Simulate>()
                     .WithNone<DestroyEntityTag>().WithEntityAccess())
        {
+            // Check if the current tick is equal to or newer than the destruction tick.
            if (currentTick.Equals(destroyAtTick.ValueRW.Value) || currentTick.IsNewerThan(destroyAtTick.ValueRW.Value))
            {
+                // Add the `DestroyEntityTag` to mark the entity for destruction.
                ecb.AddComponent<DestroyEntityTag>(entity);
            }
        }

--- a/Assets/_Game/Code/Systems/Destroy/InitializeDestroyOnTimerSystem.cs
+++ b/Assets/_Game/Code/Systems/Destroy/InitializeDestroyOnTimerSystem.cs
@@ -2,30 +2,56 @@ using Unity.Collections;
 using Unity.Entities;
 using Unity.NetCode;
+/// <summary>
+/// System responsible for initializing the destruction timer for entities. 
+/// This system calculates the tick at which entities should be destroyed based on their lifetime
+/// and adds a `DestroyAtTick` component to mark the destruction time.
+/// </summary>
 public partial struct InitializeDestroyOnTimerSystem : ISystem
 {
+    /// <summary>
+    /// Called when the system is created. Ensures the system only updates when the required components
+    /// and entities are present in the world.
+    /// </summary>
+    /// <param name="state">The current state of the system.</param>
    public void OnCreate(ref SystemState state)
    {
+        // Require specific components and entities for the system to update.
        state.RequireForUpdate<NetworkTime>();
        state.RequireForUpdate<DestroyOnTimer>();
        state.RequireForUpdate<GamePlayingTag>();
    }
+    /// <summary>
+    /// Called every frame to process entities with a `DestroyOnTimer` component. Calculates the destruction tick
+    /// based on the entity's lifetime and adds a `DestroyAtTick` component to schedule its destruction.
+    /// </summary>
+    /// <param name="state">The current state of the system.</param>
    public void OnUpdate(ref SystemState state)
    {
+        // Create a temporary EntityCommandBuffer to queue entity modifications.
        var ecb = new EntityCommandBuffer(Allocator.Temp);
+        // Retrieve the simulation tick rate and the current server tick.
        var simulationTickRate = NetCodeConfig.Global.ClientServerTickRate.SimulationTickRate;
        var currentTick = SystemAPI.GetSingleton<NetworkTime>().ServerTick;
+        // Iterate through all entities with a `DestroyOnTimer` component but without a `DestroyAtTick` component.
        foreach (var (destroyOnTimer, entity) in SystemAPI.Query<RefRW<DestroyOnTimer>>().WithNone<DestroyAtTick>()
                     .WithEntityAccess())
        {
+            // Calculate the lifetime in ticks based on the entity's lifetime in seconds.
            var lifetimeInTicks = (uint)(destroyOnTimer.ValueRW.Value * simulationTickRate);
+            // Calculate the target tick at which the entity should be destroyed.
            var targetTick = currentTick;
            targetTick.Add(lifetimeInTicks);
+            // Add the `DestroyAtTick` component to the entity with the calculated destruction tick.
            ecb.AddComponent(entity, new DestroyAtTick { Value = targetTick });
        }
+        // Apply all queued entity modifications.
        ecb.Playback(state.EntityManager);
    }
 }
\ No newline at end of file
--- a/Assets/_Game/Code/Systems/Destroy/RespawnPlayerSystem.cs
+++ b/Assets/_Game/Code/Systems/Destroy/RespawnPlayerSystem.cs
@@ -10,9 +10,20 @@ using UnityEngine;
 [UpdateInGroup(typeof(PredictedSimulationSystemGroup))]
 public partial class RespawnPlayerSystem : SystemBase
 {
+    /// <summary>
+    /// Action invoked to update the respawn countdown with the number of seconds remaining until the player respawns.
+    /// </summary>
    public Action<int> OnUpdateRespawnCountdown;
+    /// <summary>
+    /// Action invoked when the player respawns.
+    /// </summary>
    public Action OnRespawn;
+    /// <summary>
+    /// Called when the system is created. Ensures the system only updates when the required components
+    /// and entities are present in the world.
+    /// </summary>
    protected override void OnCreate()
    {
        RequireForUpdate<NetworkTime>();
@@ -20,6 +31,9 @@ public partial class RespawnPlayerSystem : SystemBase
        RequireForUpdate<GamePlayingTag>();
    }
+    /// <summary>
+    /// Called when the system starts running. Instantiates the respawn entity if it does not already exist.
+    /// </summary>
    protected override void OnStartRunning()
    {
        if (SystemAPI.HasSingleton<RespawnEntityTag>()) return;
@@ -27,6 +41,10 @@ public partial class RespawnPlayerSystem : SystemBase
        EntityManager.Instantiate(respawnPrefab);
    }
+    /// <summary>
+    /// Called every frame to process player respawn logic. Handles server-side player instantiation
+    /// and client-side countdown updates.
+    /// </summary>
    protected override void OnUpdate()
    {
        var networkTime = SystemAPI.GetSingleton<NetworkTime>();
@@ -37,6 +55,7 @@ public partial class RespawnPlayerSystem : SystemBase
        var ecb = new EntityCommandBuffer(Allocator.Temp);
+        // Iterate through all entities with a RespawnBufferElement buffer.
        foreach (var respawnBuffer in SystemAPI.Query<DynamicBuffer<RespawnBufferElement>>()
                     .WithAll<RespawnTickCount, Simulate>())
        {
@@ -46,10 +65,12 @@ public partial class RespawnPlayerSystem : SystemBase
            {
                var curRespawn = respawnBuffer[i];
+                // Check if the current tick matches or exceeds the respawn tick.
                if (currentTick.Equals(curRespawn.RespawnTick) || currentTick.IsNewerThan(curRespawn.RespawnTick))
                {
                    if (isServer)
                    {
+                        // Server-side logic: Instantiate a new player entity and set its components.
                        int networkId = SystemAPI.GetComponent<NetworkId>(curRespawn.NetworkEntity).Value;
                        Entity playerPrefab = SystemAPI.GetSingleton<EntititesReferences>().PlayerPrefabEntity;
@@ -65,6 +86,7 @@ public partial class RespawnPlayerSystem : SystemBase
                    }
                    else
                    {
+                        // Client-side logic: Invoke the respawn action and create a camera for the new player.
                        OnRespawn?.Invoke();
                        if (SystemAPI.TryGetSingleton<NetworkId>(out var clientNetworkId) &&
                            curRespawn.NetworkId == clientNetworkId.Value)
@@ -75,6 +97,7 @@ public partial class RespawnPlayerSystem : SystemBase
                }
                else if (!isServer)
                {
+                    // Client-side logic: Update the respawn countdown.
                    if (SystemAPI.TryGetSingleton<NetworkId>(out var networkId))
                    {
                        if (networkId.Value == curRespawn.NetworkId)
@@ -89,15 +112,21 @@ public partial class RespawnPlayerSystem : SystemBase
                }
            }
+            // Remove processed respawn entries from the buffer.
            foreach (var respawnIndex in respawnsToCleanup)
            {
                respawnBuffer.RemoveAt(respawnIndex);
            }
        }
+        // Apply all queued entity modifications.
        ecb.Playback(EntityManager);
    }
+    /// <summary>
+    /// Creates a camera for the newly respawned player.
+    /// </summary>
+    /// <param name="networkId">The network ID of the player.</param>
    private void CreateCameraForNewPlayer(int networkId)
    {
        GameObject playerCameraGO = new GameObject($"Camera{networkId}");

--- a/Assets/_Game/Code/Systems/Enemy/EnemySpawnerAspect.cs
+++ b/Assets/_Game/Code/Systems/Enemy/EnemySpawnerAspect.cs
@@ -2,55 +2,100 @@ using Unity.Entities;
 using Unity.Entities.UniversalDelegates;
 using UnityEngine;
+/// <summary>
+/// Represents an aspect for managing enemy spawning logic, including spawn timers,
+/// spawn counters, and cooldowns for different enemy types.
+/// </summary>
 public readonly partial struct EnemySpawnerAspect : IAspect
 {
+    // Reference to the enemy spawn timer component.
    private readonly RefRW<EnemySpawnTimer> _enemySpawnTimer;
+    // Reference to the game start properties component.
    private readonly RefRO<GameStartProperties> _gameStartProperties;
+    // Reference to the spawnable enemies counter component.
    private readonly RefRW<SpawnableEnemiesCounter> _spawnableEnemiesCounter;
+    /// <summary>
+    /// Gets or sets the time remaining for the next slime enemy spawn.
+    /// </summary>
    public float TimeForNextSlimeSpawn
    {
        get => _enemySpawnTimer.ValueRO.SlimeSpawnTimer;
        set => _enemySpawnTimer.ValueRW.SlimeSpawnTimer = value;
    }
+    /// <summary>
+    /// Gets or sets the time remaining for the next rogue enemy spawn.
+    /// </summary>
    public float TimeForNextRogueSpawn
    {
        get => _enemySpawnTimer.ValueRO.RogueSpawnTimer;
        set => _enemySpawnTimer.ValueRW.RogueSpawnTimer = value;
    }
+    /// <summary>
+    /// Gets or sets the random spawn offset used to vary spawn timings.
+    /// </summary>
    public float RandomSpawnOffset
    {
        get => _enemySpawnTimer.ValueRO.RandomSpawnOffset;
        set => _enemySpawnTimer.ValueRW.RandomSpawnOffset = value;
    }
+    /// <summary>
+    /// Gets the total number of rogue enemies to spawn, as defined in the game start properties.
+    /// </summary>
    public int RogueSpawnAmount => _gameStartProperties.ValueRO.RogueEnemyAmount;
+    /// <summary>
+    /// Gets the total number of slime enemies to spawn, as defined in the game start properties.
+    /// </summary>
    public int SlimeSpawnAmount => _gameStartProperties.ValueRO.SlimeEnemyAmount;
+    /// <summary>
+    /// Gets or sets the current count of spawned rogue enemies.
+    /// </summary>
    public int RogueEnemyCounter
    {
        get => _spawnableEnemiesCounter.ValueRO.RogueEnemyCounter;
        set => _spawnableEnemiesCounter.ValueRW.RogueEnemyCounter = value;
    }
+    /// <summary>
+    /// Gets or sets the current count of spawned slime enemies.
+    /// </summary>
    public int SlimeEnemyCounter
    {
        get => _spawnableEnemiesCounter.ValueRO.SlimeEnemyCounter;
        set => _spawnableEnemiesCounter.ValueRW.SlimeEnemyCounter = value;
    }
+    /// <summary>
+    /// Gets the cooldown duration for spawning slime enemies.
+    /// </summary>
    public float SlimeSpawnCoolDown => _enemySpawnTimer.ValueRO.SlimeSpawnCooldown;
+    /// <summary>
+    /// Gets the cooldown duration for spawning rogue enemies.
+    /// </summary>
    public float RogueSpawnCoolDown => _enemySpawnTimer.ValueRO.RogueSpawnCooldown;
+    /// <summary>
+    /// Determines whether a slime enemy can spawn based on the timer and spawn limits.
+    /// </summary>
    public bool CanEnemySlimeSpawn => TimeForNextSlimeSpawn <= 0 && SlimeSpawnAmount > SlimeEnemyCounter;
-    public bool CanEnemyRogueSpawn => TimeForNextRogueSpawn <= 0 && RogueSpawnAmount > RogueEnemyCounter;
+    /// <summary>
+    /// Determines whether a rogue enemy can spawn based on the timer and spawn limits.
+    /// </summary>
+    public bool CanEnemyRogueSpawn => TimeForNextRogueSpawn <= 0 && RogueSpawnAmount > RogueEnemyCounter;
+    /// <summary>
+    /// Decrements the spawn timers and adjusts the random spawn offset over time.
+    /// </summary>
+    /// <param name="deltaTime">The time elapsed since the last update.</param>
    public void DecrementTimers(float deltaTime)
    {
        TimeForNextSlimeSpawn -= deltaTime;
@@ -61,21 +106,33 @@ public readonly partial struct EnemySpawnerAspect : IAspect
            RandomSpawnOffset = 5f;
    }
+    /// <summary>
+    /// Increments the counter for spawned slime enemies.
+    /// </summary>
    public void IncreaseSlimeCounter()
    {
        SlimeEnemyCounter++;
    }
+    /// <summary>
+    /// Increments the counter for spawned rogue enemies.
+    /// </summary>
    public void IncreaseRogueCounter()
    {
        RogueEnemyCounter++;
    }
+    /// <summary>
+    /// Resets the timer for spawning rogue enemies to the cooldown duration.
+    /// </summary>
    public void ResetRoqueTimer()
    {
        TimeForNextRogueSpawn = RogueSpawnCoolDown;
    }
+    /// <summary>
+    /// Resets the timer for spawning slime enemies to the cooldown duration.
+    /// </summary>
    public void ResetSlimeTimer()
    {
        TimeForNextSlimeSpawn = SlimeSpawnCoolDown;

--- a/Assets/_Game/Code/Systems/Enemy/EnemySpawnerSystem.cs
+++ b/Assets/_Game/Code/Systems/Enemy/EnemySpawnerSystem.cs
@@ -5,11 +5,22 @@ using Unity.Physics;
 using Unity.Transforms;
 using UnityEngine;
+/// <summary>
+/// System responsible for spawning enemies during the game. 
+/// Handles the logic for decrementing spawn timers, checking spawn conditions, 
+/// and instantiating enemies at designated spawn points.
+/// </summary>
 [WorldSystemFilter(WorldSystemFilterFlags.ServerSimulation)]
 partial struct EnemySpawnerSystem : ISystem
 {
+    /// <summary>
+    /// Called when the system is created. Ensures the system only updates when the required components
+    /// and entities are present in the world.
+    /// </summary>
+    /// <param name="state">The current state of the system.</param>
    public void OnCreate(ref SystemState state)
    {
+        // Require specific components and entities for the system to update.
        state.RequireForUpdate<GamePlayingTag>();
        state.RequireForUpdate<EnemySpawnPoints>();
        state.RequireForUpdate<EnemySpawnTimer>();
@@ -17,17 +28,27 @@ partial struct EnemySpawnerSystem : ISystem
        state.RequireForUpdate<BeginSimulationEntityCommandBufferSystem.Singleton>();
    }
+    /// <summary>
+    /// Called every frame to process enemy spawning logic. 
+    /// Decrements spawn timers, checks if enemies can spawn, and spawns them at designated positions.
+    /// </summary>
+    /// <param name="state">The current state of the system.</param>
    [BurstCompile]
    public void OnUpdate(ref SystemState state)
    {
+        // Retrieve the time elapsed since the last frame.
        var deltaTime = SystemAPI.Time.DeltaTime;
+        // Iterate through all entities with the EnemySpawnerAspect.
        foreach (EnemySpawnerAspect aspect in SystemAPI.Query<EnemySpawnerAspect>())
        {
+            // Decrement spawn timers for the current aspect.
            aspect.DecrementTimers(deltaTime);
+            // Check if a slime enemy can spawn.
            if (aspect.CanEnemySlimeSpawn)
            {
+                // Retrieve spawn points and the command buffer for entity modifications.
                Entity enemyPropertiesEntity = SystemAPI.GetSingletonEntity<EnemySpawnPoints>();
                DynamicBuffer<EnemySpawnPoints> spawnPoints =
                    SystemAPI.GetBuffer<EnemySpawnPoints>(enemyPropertiesEntity);
@@ -35,17 +56,22 @@ partial struct EnemySpawnerSystem : ISystem
                var ecb = ecbSingleton.CreateCommandBuffer(state.WorldUnmanaged);
                Entity enemySlimeEntity = SystemAPI.GetSingleton<EntititesReferences>().SlimeEnemyEntity;
+                // Calculate the spawn position for the slime enemy.
                int slimeSpawnIndex = aspect.SlimeEnemyCounter % spawnPoints.Length;
                float randomValue = aspect.RandomSpawnOffset;
                float3 spawnPosition =
                    spawnPoints[slimeSpawnIndex].SpawnPoint + new float3(randomValue, 0, -randomValue);
+                // Spawn the slime enemy and update the aspect's counters and timers.
                SpawnEnemy(ecb, enemySlimeEntity, spawnPosition);
                aspect.IncreaseSlimeCounter();
                aspect.ResetSlimeTimer();
            }
+            // Check if a rogue enemy can spawn.
            if (aspect.CanEnemyRogueSpawn)
            {
+                // Retrieve spawn points and the command buffer for entity modifications.
                Entity enemyPropertiesEntity = SystemAPI.GetSingletonEntity<EnemySpawnPoints>();
                DynamicBuffer<EnemySpawnPoints> spawnPoints =
                    SystemAPI.GetBuffer<EnemySpawnPoints>(enemyPropertiesEntity);
@@ -53,10 +79,13 @@ partial struct EnemySpawnerSystem : ISystem
                var ecb = ecbSingleton.CreateCommandBuffer(state.WorldUnmanaged);
                Entity enemyRogueEntity = SystemAPI.GetSingleton<EntititesReferences>().RougeEnemyEntity;
+                // Calculate the spawn position for the rogue enemy.
                int rogueSpawnIndex = aspect.RogueEnemyCounter % spawnPoints.Length;
                float randomValue = aspect.RandomSpawnOffset;
                float3 spawnPosition =
                    spawnPoints[rogueSpawnIndex].SpawnPoint + new float3(randomValue, 0, -randomValue);
+                // Spawn the rogue enemy and update the aspect's counters and timers.
                SpawnEnemy(ecb, enemyRogueEntity, spawnPosition);
                aspect.IncreaseRogueCounter();
                aspect.ResetRoqueTimer();
@@ -64,10 +93,16 @@ partial struct EnemySpawnerSystem : ISystem
        }
    }
+    /// <summary>
+    /// Spawns an enemy entity at the specified position.
+    /// </summary>
+    /// <param name="ecb">The EntityCommandBuffer used to queue entity modifications.</param>
+    /// <param name="spawnableEntity">The entity prefab to spawn.</param>
+    /// <param name="position">The position where the entity should be spawned.</param>
    void SpawnEnemy(EntityCommandBuffer ecb, Entity spawnableEntity, float3 position)
    {
+        // Instantiate the enemy entity and set its position.
        Entity newEnemy = ecb.Instantiate(spawnableEntity);
-        ecb.SetComponent(newEnemy,
+        ecb.SetComponent(newEnemy, LocalTransform.FromPosition(position));
-            LocalTransform.FromPosition(position));
    }
 }
\ No newline at end of file
--- a/Assets/_Game/Code/Systems/Input/NetcodePlayerInputSystem.cs
+++ b/Assets/_Game/Code/Systems/Input/NetcodePlayerInputSystem.cs
@@ -5,32 +5,46 @@ using Unity.Mathematics;
 using Unity.NetCode;
 using UnityEngine;
 [UpdateInGroup(typeof(GhostInputSystemGroup))]
 public partial class NetcodePlayerInputSystem : SystemBase
 {
    private InputSystem_Actions _inputActions;
+    /// <summary>
+    /// Called when the system is created. Initializes the input actions and ensures the system
+    /// only updates when the required components and entities are present in the world.
+    /// </summary>
    protected override void OnCreate()
    {
+        // Initialize and enable the input actions.
        _inputActions = new InputSystem_Actions();
        _inputActions.Enable();
+        // Require specific components and entities for the system to update.
        RequireForUpdate<NetworkStreamInGame>();
        RequireForUpdate<GamePlayingTag>();
        RequireForUpdate<NetcodePlayerInput>();
    }
+    /// <summary>
+    /// Called every frame to process player input. Updates the `NetcodePlayerInput` component
+    /// with the player's movement vector and sprinting state.
+    /// </summary>
    protected override void OnUpdate()
    {
+        // Iterate through all entities with a `NetcodePlayerInput` component and a `GhostOwnerIsLocal` tag.
        foreach (RefRW<NetcodePlayerInput> netcodePlayerInput in SystemAPI.Query<RefRW<NetcodePlayerInput>>()
                     .WithAll<GhostOwnerIsLocal>())
        {
+            // Update the input vector and sprinting state from the input actions.
            netcodePlayerInput.ValueRW.inputVector = _inputActions.Player.Move.ReadValue<Vector2>();
            netcodePlayerInput.ValueRW.isSprinting = _inputActions.Player.Sprint.IsPressed();
        }
    }
+    /// <summary>
+    /// Called when the system is destroyed. Disables the input actions to clean up resources.
+    /// </summary>
    protected override void OnDestroy()
    {
        base.OnDestroy();

--- a/Assets/_Game/Code/Systems/Input/NetcodePlayerMovementSystem.cs
+++ b/Assets/_Game/Code/Systems/Input/NetcodePlayerMovementSystem.cs
@@ -6,12 +6,23 @@ using Unity.Physics;
 using Unity.Transforms;
 using UnityEngine;
+/// <summary>
+/// System responsible for handling player movement in a netcode environment.
+/// This system processes player input, updates physics velocity, and adjusts player rotation
+/// based on movement direction and sprinting state.
+/// </summary>
 [UpdateInGroup(typeof(PredictedSimulationSystemGroup))]
 partial struct NetcodePlayerMovementSystem : ISystem
 {
+    /// <summary>
+    /// Called when the system is created. Ensures the system only updates when the required components
+    /// and entities are present in the world.
+    /// </summary>
+    /// <param name="state">The current state of the system.</param>
    [BurstCompile]
    public void OnCreate(ref SystemState state)
    {
+        // Require specific components and entities for the system to update.
        state.RequireForUpdate<NetcodePlayerInput>();
        state.RequireForUpdate<PhysicsVelocity>();
        state.RequireForUpdate<LocalTransform>();
@@ -19,11 +30,18 @@ partial struct NetcodePlayerMovementSystem : ISystem
        state.RequireForUpdate<GamePlayingTag>();
    }
+    /// <summary>
+    /// Called every frame to process player movement logic.
+    /// Updates the player's velocity and rotation based on input and sprinting state.
+    /// </summary>
+    /// <param name="state">The current state of the system.</param>
    [BurstCompile]
    public void OnUpdate(ref SystemState state)
    {
+        // Retrieve the time elapsed since the last frame.
        float deltaTime = SystemAPI.Time.DeltaTime;
+        // Iterate through all entities with the required components.
        foreach ((RefRO<NetcodePlayerInput> netcodePlayerInput, RefRW<PhysicsVelocity> physicsVelocity,
                     RefRW<LocalTransform> localTransform, RefRW<PlayerSprintData> sprintData)
                 in SystemAPI
@@ -31,13 +49,17 @@ partial struct NetcodePlayerMovementSystem : ISystem
                         RefRW<PlayerSprintData>>()
                     .WithAll<Simulate>())
        {
+            // Calculate the movement vector based on player input.
            float3 moveVector = new float3(netcodePlayerInput.ValueRO.inputVector.x, 0,
                netcodePlayerInput.ValueRO.inputVector.y);
+            // Set the default movement speed to walking speed.
            float moveSpeed = sprintData.ValueRO.walkSpeed;
+            // Check if the player is sprinting.
            if (netcodePlayerInput.ValueRO.isSprinting)
            {
+                // Handle sprinting logic and cooldowns.
                if (!sprintData.ValueRO.isSprintCooldown)
                {
                    sprintData.ValueRW.sprintRemaining -= deltaTime;
@@ -53,6 +75,7 @@ partial struct NetcodePlayerMovementSystem : ISystem
                }
            }
+            // Handle sprint cooldown logic.
            if (sprintData.ValueRO.isSprintCooldown)
            {
                sprintData.ValueRW.sprintCooldown -= deltaTime;
@@ -62,10 +85,11 @@ partial struct NetcodePlayerMovementSystem : ISystem
                }
            }
+            // Smoothly update the player's velocity based on the movement vector and speed.
            physicsVelocity.ValueRW.Linear =
                math.lerp(physicsVelocity.ValueRO.Linear, moveVector * moveSpeed, deltaTime * 10);
+            // Update the player's rotation to face the movement direction if moving.
            if (!math.all(moveVector == float3.zero))
            {
                quaternion targetRotation = quaternion.LookRotationSafe(moveVector, math.up());

--- a/Assets/_Game/Prefabs/Enemies/Arrow.prefab
+++ b/Assets/_Game/Prefabs/Enemies/Arrow.prefab
@@ -222,7 +222,7 @@ MonoBehaviour:
  m_Script: {fileID: 11500000, guid: 7e19d579a4586dd40805276eb2d1a684, type: 3}
  m_Name: 
  m_EditorClassIdentifier: 
-  DestroyOnTimer: 2
+  DestroyOnTimer: 3
 --- !u!114 &1149029900162062154
 MonoBehaviour:
  m_ObjectHideFlags: 0
@@ -298,7 +298,7 @@ MonoBehaviour:
  m_Script: {fileID: 11500000, guid: 2de495c310a322143be08aa7819a1a33, type: 3}
  m_Name: 
  m_EditorClassIdentifier: 
-  DamageOnTrigger: 0
+  DamageOnTrigger: 20
 --- !u!1001 &7309850180045348080
 PrefabInstance:
  m_ObjectHideFlags: 0

--- a/Assets/_Game/Prefabs/Enemies/Cube.prefab
+++ b/Assets/_Game/Prefabs/Enemies/Cube.prefab
@@ -103,7 +103,7 @@ MonoBehaviour:
  m_Script: {fileID: 11500000, guid: 2de495c310a322143be08aa7819a1a33, type: 3}
  m_Name: 
  m_EditorClassIdentifier: 
-  DamageOnTrigger: 50
+  DamageOnTrigger: 10
 --- !u!114 &-8527907258641966621
 MonoBehaviour:
  m_ObjectHideFlags: 0
@@ -129,7 +129,7 @@ MonoBehaviour:
  m_Script: {fileID: 11500000, guid: d8b4a5cfe7236db4dba833c5751c2665, type: 3}
  m_Name: 
  m_EditorClassIdentifier: 
-  NpcTargetRadius: 80
+  NpcTargetRadius: 10
 --- !u!114 &-274669407858188047
 MonoBehaviour:
  m_ObjectHideFlags: 0

--- a/Assets/_Game/Prefabs/Enemies/RogueEnemy.prefab
+++ b/Assets/_Game/Prefabs/Enemies/RogueEnemy.prefab
@@ -100,7 +100,7 @@ MonoBehaviour:
  m_Script: {fileID: 11500000, guid: 8194ce63a01ea9044a8c5a6ebd0e2829, type: 3}
  m_Name: 
  m_EditorClassIdentifier: 
-  NpcTargetRadius: 80
+  NpcTargetRadius: 13
  AttackCooldownTime: 2
  FirePointOffset: {x: 0, y: 1.5, z: 0}
  AttackPrefab: {fileID: 357967689053387235, guid: 19127a4c1ac11844db4373b9e147918b, type: 3}

--- a/Assets/_Game/Prefabs/Player/Player.prefab
+++ b/Assets/_Game/Prefabs/Player/Player.prefab
@@ -149,8 +149,8 @@ MonoBehaviour:
  m_EditorClassIdentifier: 
  sprintRemaining: 5
  sprintDuration: 5
-  sprintSpeed: 12
+  sprintSpeed: 7
-  walkSpeed: 8
+  walkSpeed: 5
  sprintCooldownReset: 1
 --- !u!114 &3955402020692204287
 MonoBehaviour:
@@ -320,7 +320,7 @@ MonoBehaviour:
  m_Script: {fileID: 11500000, guid: 8e73c985659b81d408f4e99cb152349d, type: 3}
  m_Name: 
  m_EditorClassIdentifier: 
-  MaxHitPoints: 1000
+  MaxHitPoints: 200
  HealthBarOffset: {x: 0, y: 2.5, z: 0}
 --- !u!1001 &6975352639711469968
 PrefabInstance:

--- a/Assets/_Game/Prefabs/Player/RespawnEntity.prefab
+++ b/Assets/_Game/Prefabs/Player/RespawnEntity.prefab
@@ -63,7 +63,7 @@ MonoBehaviour:
  OptimizationMode: 0
  Importance: 10
  MaxSendRate: 0
-  prefabId: 
+  prefabId: b3cdfc2eac1a20f4fa01943b331adf7e
  HasOwner: 0
  SupportAutoCommandTarget: 1
  TrackInterpolationDelay: 0
@@ -84,4 +84,4 @@ MonoBehaviour:
  m_Name: 
  m_EditorClassIdentifier: 
  RespawnTime: 10
-  NetCodeConfig: {fileID: 11400000, guid: cd69de227738309429193c9089949c16, type: 2}
+  NetCodeConfig: {fileID: 11400000, guid: edda5bd0f33a95e4a98f780e0e3ae9e8, type: 2}
--- a/Assets/_Game/Scenes/ConnectionScene.unity
+++ b/Assets/_Game/Scenes/ConnectionScene.unity
@@ -489,9 +489,9 @@ MonoBehaviour:
  RangerAmountContainer: {fileID: 7438304585132253662}
  SlimeAmountContainer: {fileID: 7438304585132253661}
  _connectButton: {fileID: 661734915}
-  _gameStartCountDownTime: 2
+  _gameStartCountDownTime: 10
-  _slimeSpawnCooldownTime: 0.01
+  _slimeSpawnCooldownTime: 1
-  _rogueSpawnCooldownTime: 0.1
+  _rogueSpawnCooldownTime: 2
 --- !u!114 &1734898360 stripped
 MonoBehaviour:
  m_CorrespondingSourceObject: {fileID: 8650075725555599494, guid: 72327351aa28fbe4fb4c16c3d17e4de5, type: 3}

--- a/Assets/_Game/Scenes/GameScene.unity
+++ b/Assets/_Game/Scenes/GameScene.unity
@@ -336,6 +336,26 @@ PrefabInstance:
      propertyPath: m_LocalEulerAnglesHint.z
      value: 0
      objectReference: {fileID: 0}
+    - target: {fileID: 4973084550295746815, guid: dc695439125c44a4190bdc008aa5a0fc, type: 3}
+      propertyPath: m_IsActive
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 5689824232254750683, guid: dc695439125c44a4190bdc008aa5a0fc, type: 3}
+      propertyPath: m_text
+      value: 10
+      objectReference: {fileID: 0}
+    - target: {fileID: 5823419856895464815, guid: dc695439125c44a4190bdc008aa5a0fc, type: 3}
+      propertyPath: m_text
+      value: 10
+      objectReference: {fileID: 0}
+    - target: {fileID: 5823419856895464815, guid: dc695439125c44a4190bdc008aa5a0fc, type: 3}
+      propertyPath: 'm_ActiveFontFeatures.Array.data[0]'
+      value: 1801810542
+      objectReference: {fileID: 0}
+    - target: {fileID: 8914969948828194284, guid: dc695439125c44a4190bdc008aa5a0fc, type: 3}
+      propertyPath: m_IsActive
+      value: 0
+      objectReference: {fileID: 0}
    m_RemovedComponents: []
    m_RemovedGameObjects: []
    m_AddedGameObjects: []

--- a/ProjectSettings/EditorBuildSettings.asset
+++ b/ProjectSettings/EditorBuildSettings.asset
@@ -9,11 +9,11 @@ EditorBuildSettings:
    path: Assets/_Game/Scenes/ConnectionScene.unity
    guid: 5652506fc72e4fa42a51d693df592812
  - enabled: 1
-    path: Assets/_Game/Scenes/TestGameScene.unity
-    guid: a3178e3c90053df499a40c2abd214157
-  - enabled: 1
    path: Assets/_Game/Scenes/GameScene.unity
    guid: 99c9720ab356a0642a771bea13969a05
+  - enabled: 1
+    path: Assets/_Game/Scenes/TestGameScene.unity
+    guid: a3178e3c90053df499a40c2abd214157
  m_configObjects:
    com.unity.input.settings.actions: {fileID: -944628639613478452, guid: 14b037eabac02c946b6a54f5e7289a64, type: 3}
  m_UseUCBPForAssetBundles: 0