Add FSM components for player and enemy state management, including initialization and module resolution

Scripts/Components/FSM/Enemy/3D/Idle.cs

@@ -7,15 +7,23 @@ public partial class Idle : EnemyStateBase3D
 {
     public override EnemyState StateId => EnemyState.Idle;
 
-    [Export] public EnemyStorage3D Storage { get; private set; }
-    [Export] public PlayerDetection3D PlayerDetection { get; private set; }
+    private EnemyStorage3D Storage { get; set; }
+    private PlayerDetection3D PlayerDetection { get; set; }
 
-    [Export] public GravityProvider GravityProvider { get; private set; }
+    private GravityProvider GravityProvider { get; set; }
 
     [Export] public bool DebugEnabled { get; set; } = false;
 
     private bool _isPlayerInRange = false;
 
+    public override void Init(IStateMachine<EnemyState, CharacterBody3D> machine)
+    {
+        base.Init(machine);
+        Storage ??= StateMachine.GetModule<EnemyStorage3D>();
+        PlayerDetection ??= StateMachine.GetModule<PlayerDetection3D>();
+        GravityProvider ??= StateMachine.GetModule<GravityProvider>();
+    }
+
     public override void EnterState()
     {
         base.EnterState();

Scripts/Components/FSM/Enemy/3D/Init.cs

@@ -1,32 +0,0 @@
-using Cirno.Scripts.Components.Actors;
-using Cirno.Scripts.Enums;
-using Godot;
-
-namespace Cirno.Scripts.Components.FSM.Enemy._3D;
-
-public partial class Init : EnemyStateBase3D
-{
-    public override EnemyState StateId => EnemyState.Init;
-    [Export] public EnemyStorage3D Storage {get; private set;}
-    
-    [Export] public PlayerDetection3D DetectionProvider { get; private set; }
-    
-    [Export] public ActorResourceProvider HealthProvider { get; private set; }
-    
-    public override void EnterState()
-    {
-        //DamageReceiver.HealthProvider.MaxResource = StorageModule.Root.EnemyResource.MaxHealth;
-        DetectionProvider.Initialize(MainObject);
-        Storage.AiState = Storage.Root.StartingAiState;
-        
-        Storage.HomePosition = MainObject.GlobalPosition;
-        // TODO: Hide wings
-        // TODO: Hide aiming reticule
-
-        HealthProvider.MaxResource = Storage.Root.EnemyResource.MaxHealth;
-        
-        HealthProvider.FillResource();
-        
-        StateMachine.SetState(EnemyState.Idle);
-    }
-}

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

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

Scripts/Components/FSM/Enemy/3D/InitState.cs

@@ -0,0 +1,72 @@
+using Cirno.Scripts.Components.Actors;
+using Cirno.Scripts.Enums;
+using Godot;
+
+namespace Cirno.Scripts.Components.FSM.Enemy._3D;
+
+public partial class InitState : EnemyStateBase3D
+{
+    public override EnemyState StateId => EnemyState.Init;
+    private EnemyStorage3D Storage { get; set; }
+    private PlayerDetection3D DetectionProvider { get; set; }
+    private ActorResourceProvider HealthProvider { get; set; }
+
+    private int _initRetryCount = 0;
+    private const int MaxInitRetries = 20;
+    private const float InitRetryDelaySeconds = 0.05f;
+
+    public override void Init(IStateMachine<EnemyState, CharacterBody3D> machine)
+    {
+        base.Init(machine);
+        // Try an initial resolve; EnterState will retry if necessary
+        Storage ??= StateMachine.GetModule<EnemyStorage3D>();
+        DetectionProvider ??= StateMachine.GetModule<PlayerDetection3D>();
+        HealthProvider ??= StateMachine.GetModule<ActorResourceProvider>();
+    }
+    
+
+    public override void EnterState()
+    {
+        // Attempt to complete initialization; if modules are missing, retry with a timer
+        TryCompleteInit();
+    }
+
+    private void TryCompleteInit()
+    {
+        // Attempt to resolve modules again in case they were attached after Init
+        Storage ??= StateMachine.GetModule<EnemyStorage3D>();
+        DetectionProvider ??= StateMachine.GetModule<PlayerDetection3D>();
+        HealthProvider ??= StateMachine.GetModule<ActorResourceProvider>();
+
+        if (Storage is null || DetectionProvider is null || HealthProvider is null)
+        {
+            _initRetryCount++;
+            if (_initRetryCount <= MaxInitRetries)
+            {
+                // Schedule a retry shortly to wait for other nodes to finish _Ready
+                var timer = GetTree().CreateTimer(InitRetryDelaySeconds);
+                timer.Timeout += TryCompleteInit;
+                return;
+            }
+
+            // Final failure: log detailed error and bail out to avoid throws
+            var actorName = MainObject?.Name ?? "<unknown>";
+            GD.PrintErr($"[InitState] Failed to resolve required modules on actor '{actorName}' after {_initRetryCount} attempts.\n" +
+                        $"  Storage: {(Storage is null ? "MISSING" : "OK")},\n" +
+                        $"  DetectionProvider: {(DetectionProvider is null ? "MISSING" : "OK")},\n" +
+                        $"  HealthProvider: {(HealthProvider is null ? "MISSING" : "OK")}");
+            return;
+        }
+
+        // All modules present, proceed with initialization
+        DetectionProvider.Initialize(MainObject);
+        Storage.AiState = Storage.Root.StartingAiState;
+        Storage.HomePosition = MainObject.GlobalPosition;
+
+        HealthProvider.MaxResource = Storage.Root.EnemyResource.MaxHealth;
+        HealthProvider.FillResource();
+
+        // Transition to the Idle state now that initialization is complete
+        StateMachine.SetState(EnemyState.Idle);
+    }
+}

Scripts/Components/FSM/Enemy/3D/InitState.cs.uid

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

Scripts/Components/FSM/Enemy/3D/Shooting.cs

@@ -9,20 +9,30 @@ public partial class Shooting : EnemyStateBase3D
 {
     public override EnemyState StateId => EnemyState.Shooting;
     
-    [Export] public EnemyStorage3D Storage  { get; private set; }
+    private EnemyStorage3D Storage { get; set; }
 
-    [Export] public PlayerDetection3D PlayerDetection { get; private set; }
+    private PlayerDetection3D PlayerDetection { get; set; }
 
     [Export] public Weapon3D EquippedWeapon;
-    [Export] public NavigationProvider3D NavigationModule { get; private set; }
+    private NavigationProvider3D NavigationModule { get; set; }
     
-    [Export] public GravityProvider GravityProvider { get; private set; }
+    private GravityProvider GravityProvider { get; set; }
     
-    private bool _isPlayerInRange = false;
-    private Vector3? _currentStrafeTarget = null;
-    private float _strafeSpeed => Storage.EnemyData.StrafeSpeed;
+    private bool _isPlayerInRange;
+    private Vector3? _currentStrafeTarget;
+    private float StrafeSpeed => Storage.EnemyData.StrafeSpeed;
+
+    private double _responseTimer;
+
+    public override void Init(IStateMachine<EnemyState, CharacterBody3D> machine)
+    {
+        base.Init(machine);
+        Storage ??= StateMachine.GetModule<EnemyStorage3D>();
+        PlayerDetection ??= StateMachine.GetModule<PlayerDetection3D>();
+        NavigationModule ??= StateMachine.GetModule<NavigationProvider3D>();
+        GravityProvider ??= StateMachine.GetModule<GravityProvider>();
+    }
 
-    private double _responseTimer = 0;
     public override void EnterState()
     {
         base.EnterState();
@@ -31,12 +41,13 @@ public partial class Shooting : EnemyStateBase3D
         
         PlayerDetection.PlayerOutOfRange += PlayerDetectionOnPlayerOutOfRange;
 
-        //DamageReceiver.ChangeState(true);
-        
-        //DamageReceiver.HealthProvider.ResourceDepleted += HealthProviderOnResourceDepleted;
+        if (Storage is null || PlayerDetection is null) return;
 
-        EquippedWeapon.WeaponData = Storage.Root.EnemyResource.Weapon;
-        EquippedWeapon.Init();
+        if (EquippedWeapon != null)
+        {
+            EquippedWeapon.WeaponData = Storage.Root.EnemyResource.Weapon;
+            EquippedWeapon.Init();
+        }
 
         _currentStrafeTarget = null;
         
@@ -56,24 +67,22 @@ public partial class Shooting : EnemyStateBase3D
         
         PlayerDetection.PlayerOutOfRange -= PlayerDetectionOnPlayerOutOfRange;
         
-        //DamageReceiver.HealthProvider.ResourceDepleted -= HealthProviderOnResourceDepleted;
-        
         _currentStrafeTarget = null;
-        
-        //DamageReceiver.ChangeState(false);
-        
     }
 
     public override void PhysicsProcessState(double delta)
     {
         base.PhysicsProcessState(delta);
         
+        if (Storage is null || PlayerDetection is null || NavigationModule is null || GravityProvider is null)
+            return;
+
         if (PlayerDetection.IsPlayerInRange(Storage.Root.EnemyResource.ViewRange) && PlayerDetection.IsPlayerInSight())
         {
             // SHOOT
             Shoot();
             
-            if (_strafeSpeed > 0)
+            if (StrafeSpeed > 0)
             {
                 // Check if a strafe position is needed
                 if (!_currentStrafeTarget.HasValue || NavigationModule.IsNavigationFinished())
@@ -100,7 +109,7 @@ public partial class Shooting : EnemyStateBase3D
         if (_currentStrafeTarget.HasValue)
         {
             NavigationModule.SetTarget(_currentStrafeTarget.Value);
-            NavigationModule.Move(_strafeSpeed);
+            NavigationModule.Move(StrafeSpeed);
         }
 
         // Calculate gravity
@@ -111,6 +120,8 @@ public partial class Shooting : EnemyStateBase3D
     
     private Vector3? CalculateStrafePosition()
     {
+        if (!PlayerDetection.LastKnownPlayerPosition.HasValue) return null;
+
         var playerPos = PlayerDetection.LastKnownPlayerPosition.Value;
         var enemyPos = MainObject.GlobalPosition;
       
@@ -149,16 +160,10 @@ public partial class Shooting : EnemyStateBase3D
 
     private Vector2 GetShootDirection()
     {
-        // if (Storage.EnemyData.PredictPlayer && PlayerDetection.LastKnowPlayerVelocity.HasValue)
-        // {
-        //     var predictedDirection = MathFunctions.PredictInterceptPosition(MainObject.GlobalPosition,
-        //         PlayerDetection.LastKnownPlayerPosition.Value, PlayerDetection.LastKnowPlayerVelocity.Value,
-        //         EquippedWeapon.WeaponData.BulletData.BulletSpeed);
-        //     if (predictedDirection.HasValue) return (predictedDirection.Value - MainObject.GlobalPosition).Normalized();
-        //     
-        // }
-        
-        return ( PlayerDetection.LastKnownPlayerPosition.Value - MainObject.GlobalPosition).ToVector2().Normalized();
+        if (!PlayerDetection.LastKnownPlayerPosition.HasValue)
+            return Vector2.Zero;
+
+        return (PlayerDetection.LastKnownPlayerPosition.Value - MainObject.GlobalPosition).ToVector2().Normalized();
     }
     
     private void Shoot()

Scripts/Components/FSM/Enemy/Alert.cs

@@ -8,16 +8,26 @@ public partial class Alert : EnemyStateBase
 {
     public override EnemyState StateId => EnemyState.Alert;
 
-    [Export] public EnemyStorageModule StorageModule { get; private set; }
+    private EnemyStorageModule StorageModule { get; set; }
 
-    [Export] public PlayerDetectionModule PlayerDetection { get; private set; }
+    private PlayerDetectionModule PlayerDetection { get; set; }
 
-    [Export] public GenericDamageReceiver DamageReceiver { get; private set; }
+    private GenericDamageReceiver DamageReceiver { get; set; }
 
-    [Export] public NavigationMovementModule NavigationModule { get; private set; }
+    private NavigationMovementModule NavigationModule { get; set; }
 
     private bool _isPlayerInRange = false;
 
+    public override void Init(IStateMachine<EnemyState, CharacterBody2D> machine)
+    {
+        base.Init(machine);
+        // Try to resolve modules via the state machine so the same modules can be reused without per-state exports
+        StorageModule ??= StateMachine.GetModule<EnemyStorageModule>();
+        PlayerDetection ??= StateMachine.GetModule<PlayerDetectionModule>();
+        DamageReceiver ??= StateMachine.GetModule<GenericDamageReceiver>();
+        NavigationModule ??= StateMachine.GetModule<NavigationMovementModule>();
+    }
+
     public override void EnterState()
     {
         base.EnterState();
@@ -25,8 +35,6 @@ public partial class Alert : EnemyStateBase
 
         PlayerDetection.SetRange(StorageModule.Root.EnemyResource.PlayerDetectionRange);
 
-        //_isPlayerInRange = PlayerDetection.IsPlayerInRange(StorageModule.Root.EnemyResource.ViewRange);
-        //GD.Print($"Player In Range: {_isPlayerInRange}");
 
         PlayerDetection.PlayerInRange += PlayerDetectionOnPlayerInRange;
 

Scripts/Components/FSM/Enemy/Controlled.cs

@@ -8,17 +8,14 @@ public partial class Controlled : EnemyStateBase
 {
     public override EnemyState StateId => EnemyState.Controlled;
 
-    [Export]
-    public EnemyStorageModule StorageModule { get; private set; }
+    private EnemyStorageModule StorageModule { get; set; }
     
-    [Export]
-    public GenericDamageReceiver DamageReceiver { get; private set; }
+    private GenericDamageReceiver DamageReceiver { get; set; }
     
     [Export]
     private InputProvider _inputProvider;
     
-    [Export]
-    public PlayerCrosshairProvider CrosshairProvider { get; private set; }
+    private PlayerCrosshairProvider CrosshairProvider { get; set; }
     
     [Export] public Weapon EquippedWeapon { get; private set; }
     
@@ -28,6 +25,14 @@ public partial class Controlled : EnemyStateBase
 
     private bool _isStrafing = false;
     
+    public override void Init(IStateMachine<EnemyState, CharacterBody2D> machine)
+    {
+        base.Init(machine);
+        StorageModule ??= StateMachine.GetModule<EnemyStorageModule>();
+        DamageReceiver ??= StateMachine.GetModule<GenericDamageReceiver>();
+        CrosshairProvider ??= StateMachine.GetModule<PlayerCrosshairProvider>();
+    }
+    
     public override void EnterState()
     {
         base.EnterState();
@@ -80,10 +85,6 @@ public partial class Controlled : EnemyStateBase
         
         if (Input.IsActionJustPressed(ControlEndAction))
         {
-            // if (GameManager.Instance.ToggleControlMode() is GameState.Playing)
-            // {
-            //     ResumeControl();
-            // }
             StateMachine.SetState(EnemyState.Idle);
         }
         
@@ -126,7 +127,6 @@ public partial class Controlled : EnemyStateBase
         
         // Shoot at the player's last known position
         EquippedWeapon.ShootDirection = direction;
-        //StorageModule.FacingDirection = direction;
         //StorageModule.FacingDirection = direction.SnapToCardinal().Normalized();
         
         EquippedWeapon.Shoot(BulletOwner.Player);

Scripts/Components/FSM/Enemy/Dead.cs

@@ -7,18 +7,16 @@ public partial class Dead : EnemyStateBase
 {
     public override EnemyState StateId => EnemyState.Dead;
 
-    [Export]
-    public EnemyStorageModule StorageModule { get; private set; }
+    private EnemyStorageModule StorageModule { get; set; }
     
-    [Export]
-    public EnemyDropsProvider DropsProvider { get; private set; }
+    private EnemyDropsProvider DropsProvider { get; set; }
 
-    // public override void Init(IStateMachine<EnemyState, CharacterBody2D> machine)
-    // {
-    //     base.Init(machine);
-    //
-    //
-    // }
+    public override void Init(IStateMachine<EnemyState, CharacterBody2D> machine)
+    {
+        base.Init(machine);
+        StorageModule ??= StateMachine.GetModule<EnemyStorageModule>();
+        DropsProvider ??= StateMachine.GetModule<EnemyDropsProvider>();
+    }
 
     public override void EnterState()
     {

Scripts/Components/FSM/Enemy/EnemyStorageModule.cs

@@ -3,16 +3,15 @@ using System.Linq;
 using Cirno.Scripts.Resources;
 using Cirno.Scripts.Resources.Loot;
 using Godot;
-using Godot.Collections;
 
 namespace Cirno.Scripts.Components.FSM.Enemy;
 
-public partial class EnemyStorageModule : Node2D, IFSMStorage
+public partial class EnemyStorageModule : Node2D, IFSMStorage, IActorStorage
 {
     [Export]
     public EnemyFSMProxy Root { get; private set; }
 
-    public Node2D RootAsNode => Root;
+    public Node RootAsNode => Root;
     
     public EnemyResource EnemyData => Root.EnemyResource;
     

Scripts/Components/FSM/Enemy/Idle.cs

@@ -11,21 +11,22 @@ public partial class Idle : EnemyStateBase
     // Scan for player, move to alert if found
     // Receive damage, move to alert if received
     
-    [Export]
-    public EnemyStorageModule StorageModule { get; private set; }
+    private EnemyStorageModule StorageModule { get; set; }
     
-    [Export]
-    public PlayerDetectionModule PlayerDetection { get; private set; }
+    private PlayerDetectionModule PlayerDetection { get; set; }
     
-    [Export]
-    public GenericDamageReceiver DamageReceiver { get; private set; }
+    private GenericDamageReceiver DamageReceiver { get; set; }
 
-    // public override void Init(IStateMachine<EnemyState, CharacterBody2D> machine)
-    // {
-    //     base.Init(machine);
-    // } 
     private bool _isPlayerInRange = false;
     
+    public override void Init(IStateMachine<EnemyState, CharacterBody2D> machine)
+    {
+        base.Init(machine);
+        StorageModule ??= StateMachine.GetModule<EnemyStorageModule>();
+        PlayerDetection ??= StateMachine.GetModule<PlayerDetectionModule>();
+        DamageReceiver ??= StateMachine.GetModule<GenericDamageReceiver>();
+    }
+    
     public override void EnterState()
     {
         base.EnterState();

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

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

Scripts/Components/FSM/Enemy/InitState.cs

@@ -4,15 +4,20 @@ using Godot;
 
 namespace Cirno.Scripts.Components.FSM.Enemy;
 
-public partial class Init : EnemyStateBase
+public partial class InitState : EnemyStateBase
 {
     public override EnemyState StateId => EnemyState.Init;
 
-    [Export]
-    public GenericDamageReceiver DamageReceiver { get; private set; }
+    private GenericDamageReceiver DamageReceiver { get; set; }
     
-    [Export]
-    public EnemyStorageModule StorageModule { get; private set; }
+    private EnemyStorageModule StorageModule { get; set; }
+    
+    public override void Init(IStateMachine<EnemyState, CharacterBody2D> machine)
+    {
+        base.Init(machine);
+        DamageReceiver ??= StateMachine.GetModule<GenericDamageReceiver>();
+        StorageModule ??= StateMachine.GetModule<EnemyStorageModule>();
+    }
     
     public override void EnterState()
     {

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

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

Scripts/Components/FSM/Enemy/Shooting.cs

@@ -9,17 +9,13 @@ public partial class Shooting : EnemyStateBase
 {
     public override EnemyState StateId => EnemyState.Shooting;
     
-    [Export]
-    public EnemyStorageModule StorageModule { get; private set; }
+    private EnemyStorageModule StorageModule { get; set; }
     
-    [Export]
-    public PlayerDetectionModule PlayerDetection { get; private set; }
+    private PlayerDetectionModule PlayerDetection { get; set; }
     
-    [Export]
-    public GenericDamageReceiver DamageReceiver { get; private set; }
+    private GenericDamageReceiver DamageReceiver { get; set; }
     
-    [Export]
-    public NavigationMovementModule NavigationModule { get; private set; }
+    private NavigationMovementModule NavigationModule { get; set; }
 
      // [Export] public float MaxStrafeDistance { get; private set; } = 64f;
      // [Export] public float MinStrafeDistance { get; private set; } = 16f;
@@ -34,6 +30,15 @@ public partial class Shooting : EnemyStateBase
 
     private double _responseTimer = 0;
     
+    public override void Init(IStateMachine<EnemyState, CharacterBody2D> machine)
+    {
+        base.Init(machine);
+        StorageModule ??= StateMachine.GetModule<EnemyStorageModule>();
+        PlayerDetection ??= StateMachine.GetModule<PlayerDetectionModule>();
+        DamageReceiver ??= StateMachine.GetModule<GenericDamageReceiver>();
+        NavigationModule ??= StateMachine.GetModule<NavigationMovementModule>();
+    }
+    
     public override void EnterState()
     {
         base.EnterState();