chore: cleanup

Game/Target/Target.cs

@@ -8,14 +8,14 @@ namespace GodotHostTest.Game.Target;
 public partial class Target : Node2D, ITarget
 {
     private readonly Subject<Unit> _hit = new();
-
     private readonly Subject<Unit> _timedOut = new();
+
     [Export] public required Area2D CollisionArea;
     [Export] public required Sprite2D Image;
     [Export] public required Timer TimeOutTimer;
     [Export] private PackedScene _explosionPackedScene = null!;
-    [Inject] private ILevel _level = null!;
 
+    [Inject] private ILevel _level = null!;
     [Inject] private ITargetCollector _targetCollector = null!;
 
     public Observable<Unit> TimedOut => _timedOut.AsObservable();
@@ -30,26 +30,30 @@ public partial class Target : Node2D, ITarget
         TimeOutTimer.Start(_level.SpawnDuration.TotalSeconds);
     }
 
+    private void Disable()
+    {
+        Image.Visible = false;
+        // can't set monitoring/monitorable when inside collision code, like during OnHit, so let's call them deferred
+        CollisionArea.SetDeferred(Area2D.PropertyName.Monitoring, false);
+        CollisionArea.SetDeferred(Area2D.PropertyName.Monitorable, false);
+        TimeOutTimer.Stop();
+    }
+
     public override void _Ready()
     {
         _targetCollector.NewTarget(this);
     }
 
-    public override void _ExitTree()
+    protected override void Dispose(bool disposing)
     {
+        base.Dispose(disposing);
         _timedOut.Dispose();
         _hit.Dispose();
     }
 
     private void OnAreaEntered(Area2D _)
-    {
-        OnHit();
-    }
-
-    private void OnHit()
     {
         Disable();
-        TimeOutTimer.Stop();
         _hit.OnNext(Unit.Default);
 
         var explosion = (GpuParticles2D)_explosionPackedScene.Instantiate();
@@ -58,14 +62,6 @@ public partial class Target : Node2D, ITarget
         GetTree().CurrentScene.AddChild(explosion);
     }
 
-    private void Disable()
-    {
-        Image.Visible = false;
-        // can't se monitoring/monitorable when inside the collision code, like during OnHit
-        CollisionArea.SetDeferred(Area2D.PropertyName.Monitoring, false);
-        CollisionArea.SetDeferred(Area2D.PropertyName.Monitorable, false);
-    }
-
     private void OnTimeout()
     {
         Disable();

Game/Target/TargetSpawner.cs

@@ -10,31 +10,36 @@ namespace GodotHostTest.Game.Target;
 public partial class TargetSpawner : Node2D, ITargetCollector, ITargetSpawner
 {
     private readonly List<ITarget> _availableTargets = [];
-
     private readonly Subject<ITarget> _targetSpawned = new();
+
     [Export] public required Timer Timer;
 
     [Inject] private ILevel _level = null!;
     [Inject] private ITargetEventBus _targetEventBus = null!;
 
+    /// <inheritdoc />
     public void NewTarget(ITarget target)
     {
+        // record the target as available
         _availableTargets.Add(target);
-        target.Hit.Merge(target.TimedOut).Select(_ => target).Subscribe(MakeTargetAvailable).AddTo(this);
+
+        // whenever the target gets disabled, mark it as available again
+        target.Hit.Merge(target.TimedOut)
+            .Select(_ => target)
+            .Subscribe(_availableTargets.Add)
+            .AddTo(this);
     }
 
     public Observable<ITarget> TargetSpawned => _targetSpawned.AsObservable();
 
     public override void _Ready()
     {
+        // inform the target event bus that there's a new target spawner
         _targetEventBus.NewTargetSpawner(this);
-        Spawn();
-        Timer.Start(_level.TimeBetweenSpawns.TotalSeconds);
-    }
 
-    private void MakeTargetAvailable(ITarget target)
-    {
-        _availableTargets.Add(target);
+        // spawn every total seconds (and immediately spawn something at ready)
+        Timer.Start(_level.TimeBetweenSpawns.TotalSeconds);
+        Spawn();
     }
 
     private void OnTimer()