Enemy state machine

Scripts/Components/Actors/ActorAi.cs

@@ -1,4 +1,5 @@
 using Cirno.Scripts.Components.Actors;
+using Cirno.Scripts.Enums;
 using Godot;
 
 public partial class ActorAi : ActorModule 

Scripts/Components/Actors/EnemyNavigationMovement.cs

@@ -4,6 +4,7 @@ using Cirno.Scripts.Components;
 using System.Collections.Generic;
 using System.Linq;
 using Cirno.Scripts.Components.Actors;
+using Cirno.Scripts.Enums;
 
 public partial class EnemyNavigationMovement : MovementHandler
 {

Scripts/Components/Actors/EnemyTurretRotationMovement.cs

@@ -1,4 +1,5 @@
-using Godot;
+using Cirno.Scripts.Enums;
+using Godot;
 
 namespace Cirno.Scripts.Components.Actors;
 

Scripts/Components/Actors/GenericDamageReceiver.cs

@@ -16,6 +16,10 @@ public partial class GenericDamageReceiver : Area2D, IHittable
     [Export] public PackedScene Debris { get; set; }
     
     [Export] public Array<DamageResistance> DamageResistances { get; set; } = [];
+
+    [Export] public bool DeleteParentOnDeath { get; private set; } = true;
+    
+    //[Signal] public delegate void DeathEventHandler();
     
     private Node2D _parent;
     
@@ -69,6 +73,12 @@ public partial class GenericDamageReceiver : Area2D, IHittable
             _parent.CreateSibling<Node2D>(Debris);
         }
         
-        _parent.QueueFree();
+        // Not needed because the health provider is accessible
+        //EmitSignal(SignalName.Death);
+        
+        if (DeleteParentOnDeath)
+        {
+            _parent.QueueFree();
+        }
     }
 }

Scripts/Components/FSM/BaseState.cs

@@ -19,7 +19,7 @@ public abstract partial class BaseState<TKey, TType> : Node2D, IState<TKey, TTyp
     [Export]
     private Array<Node> _moduleNodes = [];
 
-    private readonly List<IModule<TKey, TType>> _modules = [];
+    protected readonly List<IModule<TKey, TType>> _modules = [];
     
     public virtual void Init(IStateMachine<TKey, TType> machine)
     {

Scripts/Components/FSM/Enemy/Alert.cs

@@ -0,0 +1,105 @@
+using Cirno.Scripts.Components.Actors;
+using Cirno.Scripts.Enums;
+using Godot;
+
+namespace Cirno.Scripts.Components.FSM.Enemy;
+
+public partial class Alert : EnemyStateBase
+{
+    public override EnemyState StateId => EnemyState.Alert;
+
+    [Export]
+    public EnemyStorageModule StorageModule { get; private set; }
+    
+    [Export]
+    public PlayerDetectionModule PlayerDetection { get; private set; }
+    
+    [Export]
+    public GenericDamageReceiver DamageReceiver { get; private set; }
+    
+    private bool _isPlayerInRange = false;
+    
+    public override void EnterState()
+    {
+        base.EnterState();
+        GD.Print("Entered Idle");
+        PlayerDetection.SetRange(StorageModule.Root.EnemyResource.PlayerDetectionRange);
+        
+        _isPlayerInRange = PlayerDetection.IsPlayerInRange(StorageModule.Root.EnemyResource.PlayerDetectionRange);
+        
+        PlayerDetection.PlayerInRange += PlayerDetectionOnPlayerInRange;
+        
+        PlayerDetection.PlayerOutOfRange += PlayerDetectionOnPlayerOutOfRange;
+
+        DamageReceiver.ChangeState(true);
+        
+        DamageReceiver.HealthProvider.ResourceDepleted += HealthProviderOnResourceDepleted;
+        
+    }
+
+
+    private void HealthProviderOnResourceDepleted()
+    {
+        ChangeState(EnemyState.Dead);
+    }
+
+    private void PlayerDetectionOnPlayerOutOfRange()
+    {
+        _isPlayerInRange = false;
+        GD.Print("Player out of range");
+    }
+
+    public override void ExitState()
+    {
+        base.ExitState();
+        GD.Print("Exited Idle");
+        PlayerDetection.PlayerInRange -= PlayerDetectionOnPlayerInRange;
+        
+        PlayerDetection.PlayerOutOfRange -= PlayerDetectionOnPlayerOutOfRange;
+        
+        DamageReceiver.HealthProvider.ResourceDepleted -= HealthProviderOnResourceDepleted;
+        DamageReceiver.ChangeState(false);
+        
+    }
+
+    private void PlayerDetectionOnPlayerInRange()
+    {
+        _isPlayerInRange = true;
+        GD.Print("Player In Range");
+    }
+
+    public override void PhysicsProcessState(double delta)
+    {
+        base.PhysicsProcessState(delta);
+        if (_isPlayerInRange && PlayerDetection.IsPlayerInSight())
+        {
+            StateMachine.SetState(EnemyState.Shooting);
+            return;
+        }
+        
+        // if player is outside disengage range, change to idle (later on, search)
+        if (this.GlobalPosition.DistanceTo(GameManager.Instance.PlayerPosition.Value) >=
+            StorageModule.Root.EnemyResource.PlayerDisengageRange)
+        {
+            StateMachine.SetState(EnemyState.Idle);
+        }
+        
+        // Move towards last known position
+        if (PlayerDetection.LastKnownPlayerPosition.HasValue)
+        {
+            MoveTowardsPosition(PlayerDetection.LastKnownPlayerPosition.Value);
+        }
+            
+        
+    }
+
+    private void MoveTowardsPosition(Vector2 position)
+    {
+        
+    }
+
+    public override void ProcessState(double delta)
+    {
+        base.ProcessState(delta);
+    }
+}

Scripts/Components/FSM/Enemy/Alert.cs.uid

@@ -0,0 +1 @@
+uid://dbmc3klko5x18

Scripts/Components/FSM/Enemy/EnemyDamageReceiver.cs

@@ -0,0 +1,15 @@
+using Cirno.Scripts.Components.Actors;
+using Godot;
+
+namespace Cirno.Scripts.Components.FSM.Enemy;
+
+public partial class EnemyDamageReceiver : Area2D, IHittable
+{
+    [Export]
+    public ActorResourceProvider HealthProvider { get; private set; }
+    
+    public void Hit(float damage, DamageType damageType = DamageType.Neutral)
+    {
+        
+    }
+}

Scripts/Components/FSM/Enemy/EnemyDamageReceiver.cs.uid

@@ -0,0 +1 @@
+uid://vkmg3pggt8h5

Scripts/Components/FSM/Enemy/EnemyFSMProxy.cs

@@ -0,0 +1,24 @@
+using Cirno.Scripts.Enums;
+using Cirno.Scripts.Resources;
+using Cirno.Scripts.Resources.Loot;
+using Godot;
+using Godot.Collections;
+
+namespace Cirno.Scripts.Components.FSM.Enemy;
+
+public partial class EnemyFSMProxy : CharacterBody2D
+{
+    [Export] public EnemyStateMachine EnemyFSM { get; private set; }
+    
+    [Export] public EnemyResource EnemyResource { get; private set; }
+    
+    [Export] public Array<LootDrop> ExtraLoot { get; private set; }
+    
+    [Export]
+    public AiState StartingAiState { get; private set; }
+    
+    [ExportCategory("Defeat Script")]
+    [Export] public Node2D DefeatScript { get; set; }
+
+    [Export] public ActivationType ActivationType { get; private set; } = ActivationType.Toggle;
+}

Scripts/Components/FSM/Enemy/EnemyFSMProxy.cs.uid

@@ -0,0 +1 @@
+uid://bi2edpdosngll

Scripts/Components/FSM/Enemy/EnemyStateBase.cs

@@ -0,0 +1,9 @@
+using Cirno.Scripts.Enums;
+using Godot;
+
+namespace Cirno.Scripts.Components.FSM.Enemy;
+
+public abstract partial class  EnemyStateBase : BaseState<EnemyState, CharacterBody2D>
+{
+    
+}

Scripts/Components/FSM/Enemy/EnemyStateBase.cs.uid

@@ -0,0 +1 @@
+uid://cljaa768xq70j

Scripts/Components/FSM/Enemy/EnemyStateMachine.cs

@@ -0,0 +1,10 @@
+using Cirno.Scripts.Enums;
+using Godot;
+
+namespace Cirno.Scripts.Components.FSM.Enemy;
+
+public partial class EnemyStateMachine : StateMachineBase<EnemyState, CharacterBody2D>
+{
+    [Export] public override EnemyState InitialState { get; protected set; } = EnemyState.Init;
+    
+}

Scripts/Components/FSM/Enemy/EnemyStateMachine.cs.uid

@@ -0,0 +1 @@
+uid://dn6dbog1s2818

Scripts/Components/FSM/Enemy/EnemyStorageModule.cs

@@ -0,0 +1,19 @@
+using Godot;
+
+namespace Cirno.Scripts.Components.FSM.Enemy;
+
+public partial class EnemyStorageModule : Node2D
+{
+    [Export]
+    public EnemyFSMProxy Root { get; private set; }
+    
+    public  Vector2 MovementDirection { get; set; }
+    public Vector2 FacingDirection { get; set; }
+
+    public float MovementSpeed => Root.EnemyResource.MovementSpeed;
+    
+    
+
+
+
+}

Scripts/Components/FSM/Enemy/EnemyStorageModule.cs.uid

@@ -0,0 +1 @@
+uid://bflvr26h52c55

Scripts/Components/FSM/Enemy/Idle.cs

@@ -0,0 +1,102 @@
+using Cirno.Scripts.Components.Actors;
+using Cirno.Scripts.Enums;
+using Godot;
+
+namespace Cirno.Scripts.Components.FSM.Enemy;
+
+public partial class Idle : EnemyStateBase
+{
+    public override EnemyState StateId => EnemyState.Idle;
+    
+    // Scan for player, move to alert if found
+    // Receive damage, move to alert if received
+    
+    [Export]
+    public EnemyStorageModule StorageModule { get; private set; }
+    
+    [Export]
+    public PlayerDetectionModule PlayerDetection { get; private set; }
+    
+    [Export]
+    public GenericDamageReceiver DamageReceiver { get; private set; }
+
+    // public override void Init(IStateMachine<EnemyState, CharacterBody2D> machine)
+    // {
+    //     base.Init(machine);
+    // } 
+    private bool _isPlayerInRange = false;
+    
+    public override void EnterState()
+    {
+        base.EnterState();
+        GD.Print("Entered Idle");
+        PlayerDetection.SetRange(StorageModule.Root.EnemyResource.PlayerDetectionRange);
+        
+        _isPlayerInRange = PlayerDetection.IsPlayerInRange(StorageModule.Root.EnemyResource.PlayerDetectionRange);
+        
+        PlayerDetection.PlayerInRange += PlayerDetectionOnPlayerInRange;
+        
+        PlayerDetection.PlayerOutOfRange += PlayerDetectionOnPlayerOutOfRange;
+
+        DamageReceiver.ChangeState(true);
+        
+        DamageReceiver.HealthProvider.ResourceDepleted += HealthProviderOnResourceDepleted;
+        
+        DamageReceiver.HealthProvider.ResourceDecreased += HealthProviderOnResourceDecreased;
+    }
+
+    private void HealthProviderOnResourceDecreased(float oldvalue, float newvalue, float maxvalue)
+    {
+        ChangeState(EnemyState.Alert);
+    }
+
+    private void HealthProviderOnResourceDepleted()
+    {
+        ChangeState(EnemyState.Dead);
+    }
+
+    private void PlayerDetectionOnPlayerOutOfRange()
+    {
+        _isPlayerInRange = false;
+        GD.Print("Player out of range");
+    }
+
+    public override void ExitState()
+    {
+        base.ExitState();
+        GD.Print("Exited Idle");
+        PlayerDetection.PlayerInRange -= PlayerDetectionOnPlayerInRange;
+        
+        PlayerDetection.PlayerOutOfRange -= PlayerDetectionOnPlayerOutOfRange;
+        
+        DamageReceiver.HealthProvider.ResourceDepleted -= HealthProviderOnResourceDepleted;
+        
+        DamageReceiver.HealthProvider.ResourceDecreased -= HealthProviderOnResourceDecreased;
+        DamageReceiver.ChangeState(false);
+        
+    }
+
+    private void PlayerDetectionOnPlayerInRange()
+    {
+        _isPlayerInRange = true;
+        GD.Print("Player In Range");
+    }
+
+    public override void PhysicsProcessState(double delta)
+    {
+        base.PhysicsProcessState(delta);
+        if (_isPlayerInRange)
+        {
+            if (PlayerDetection.IsPlayerInSight())
+            {
+                StateMachine.SetState(EnemyState.Alert);
+            }
+        }
+    }
+
+    public override void ProcessState(double delta)
+    {
+        base.ProcessState(delta);
+    }
+    
+}

Scripts/Components/FSM/Enemy/Idle.cs.uid

@@ -0,0 +1 @@
+uid://bjrh5q24nuoec

Scripts/Components/FSM/Enemy/Init.cs

@@ -0,0 +1,35 @@
+using Cirno.Scripts.Components.Actors;
+using Cirno.Scripts.Enums;
+using Godot;
+
+namespace Cirno.Scripts.Components.FSM.Enemy;
+
+public partial class Init : EnemyStateBase
+{
+    public override EnemyState StateId => EnemyState.Init;
+
+    [Export]
+    public GenericDamageReceiver DamageReceiver { get; private set; }
+    
+    [Export]
+    public EnemyStorageModule StorageModule { get; private set; }
+    
+    public override void EnterState()
+    {
+        GD.Print("Enemy init");
+        DamageReceiver.HealthProvider.MaxResource = StorageModule.Root.EnemyResource.MaxHealth;
+        
+        StateMachine.SetState(EnemyState.Idle);
+    }
+    
+    public override void PhysicsProcessState(double delta)
+    {
+
+    }
+
+    public override void ProcessState(double delta)
+    {
+
+    }
+    
+}

Scripts/Components/FSM/Enemy/Init.cs.uid

@@ -0,0 +1 @@
+uid://rrelumir3g6n

Scripts/Components/FSM/Enemy/PlayerDetectionModule.cs

@@ -0,0 +1,83 @@
+using Cirno.Scripts.Enums;
+using Godot;
+using Godot.Collections;
+
+namespace Cirno.Scripts.Components.FSM.Enemy;
+
+public partial class PlayerDetectionModule : Area2D
+{
+    [Signal]
+    public delegate void PlayerInRangeEventHandler();
+    
+    [Signal]
+    public delegate void PlayerOutOfRangeEventHandler();
+    
+    [Export(PropertyHint.Layers2DPhysics)]
+    public uint ObstaclesCollisionMask { get; private set; }
+    
+    public Vector2? LastKnownPlayerPosition { get; private set; }
+    
+    //public bool PlayerInActiveArea { get; private set; }
+    private CollisionShape2D _collisionShape2D;
+    public override void _Ready()
+    {
+        
+    }
+    
+    public void SetRange(float range)
+    {
+        _collisionShape2D ??= this.GetNode<CollisionShape2D>("CollisionShape2D");
+        if (_collisionShape2D.Shape is CircleShape2D shape2D)
+        {
+            shape2D.Radius = range;
+        }
+    }
+    
+    public bool IsPlayerInRange(float range)
+    {
+        if (!GameManager.Instance?.PlayerPosition.HasValue ?? false)
+        {
+            return false;
+        }
+        
+        return this.GlobalPosition.DistanceTo(GameManager.Instance.PlayerPosition.Value) < range;
+    }
+    
+    public bool IsPlayerInSight()
+    {
+        //if (_cachedPlayer == null) return false;
+        if (!GameManager.Instance?.PlayerPosition.HasValue ?? false) return false;
+        
+        var spaceState = GetWorld2D().DirectSpaceState;
+        
+        // It needs to use its own collision mask because it's detecting obstacles rather than the player
+        var query = PhysicsRayQueryParameters2D.Create(this.GlobalPosition, GameManager.Instance.PlayerPosition.Value, ObstaclesCollisionMask,
+            [GetRid()]);
+        //query.CollideWithBodies = true;
+        //query.CollideWithAreas = true;
+        // var query = PhysicsRayQueryParameters2D.Create(this.GlobalPosition, _cachedPlayer.GlobalPosition, CollisionMask, new Array<Rid> { GetRid() });
+        var result = spaceState.IntersectRay(query);
+
+        // If count is 0 then the player is in sight, otherwise there is level geometry in the way
+        var found = result.Count == 0;
+        if (found)
+        {
+            LastKnownPlayerPosition = GameManager.Instance.PlayerPosition;
+        }
+        return found;
+    }
+    
+    private void _on_area_entered(Area2D area)
+    {
+        if (area is not InteractionController player) return;
+        EmitSignal(SignalName.PlayerInRange);
+        //PlayerInActiveArea = true;
+    }
+
+    private void _on_area_exited(Area2D area)
+    {
+        if (area is not InteractionController player) return;
+        EmitSignal(SignalName.PlayerOutOfRange);
+        //PlayerInActiveArea = false;
+    }
+}

Scripts/Components/FSM/Enemy/PlayerDetectionModule.cs.uid

@@ -0,0 +1 @@
+uid://mb4ugq74a17c

Scripts/Components/FSM/EnemyFSMState.cs

@@ -1,4 +1,5 @@
-using Godot;
+using Cirno.Scripts.Enums;
+using Godot;
 
 namespace Cirno.Scripts.Components.FSM;
 

Scripts/Components/PlayerDetection.cs

@@ -8,6 +8,7 @@ public partial class PlayerDetection : Area2D
     public InteractionController CachedPlayer => _cachedPlayer;
 
     protected InteractionController _cachedPlayer;
+    
     public virtual bool IsPlayerInRange { get; set; }
 
     public virtual bool IsPlayerInSight(uint collisionMask)