Fight happening base setup

2025-09-21 14:54:55 +02:00
parent fd0e631b1f
commit f27dd199b8
38 changed files with 1022 additions and 681 deletions
@@ -0,0 +1,34 @@
+using Godot;
+using System;
+using Babushka.scripts.CSharp.Common.Fight;
+
+public partial class AllFightersVisual : Node
+{
+    [Export] private Node2D _allyFighters;
+    [Export] private Node2D _enemyFighters;
+
+    [Export] private PackedScene _blobFighterVisual;
+    [Export] private PackedScene _bigBlobFighterVisual;
+    [Export] private PackedScene _mavkaFighterVisual;
+    [Export] private PackedScene _yourMomFighterVisual;
+    [Export] private PackedScene _vesnaFighterVisual;
+    
+    public void EnterFighter(FightWorld.Fighter fighter, bool isEnemy)
+    {
+        var parent = isEnemy ? _enemyFighters : _allyFighters;
+
+        var packedScene = fighter.type switch
+        {
+            FightWorld.Fighter.Type.Blob => _blobFighterVisual,
+            FightWorld.Fighter.Type.BigBlob => _bigBlobFighterVisual,
+            FightWorld.Fighter.Type.Mavka => _mavkaFighterVisual,
+            FightWorld.Fighter.Type.YourMom => _yourMomFighterVisual,
+            FightWorld.Fighter.Type.Vesna => _vesnaFighterVisual,
+            _ => throw new ArgumentOutOfRangeException()
+        };
+
+        var fighterVisual = packedScene.Instantiate<FighterVisual>();
+        fighterVisual.Initialize(fighter);
+        parent.AddChild(fighterVisual);
+    }
+}
@@ -0,0 +1 @@
+uid://dwsqst8fhhqlc
@@ -0,0 +1,320 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Runtime.ExceptionServices;
+using System.Threading.Tasks;
+using Babushka.scripts.CSharp.Common.Util;
+using Godot;
+
+namespace Babushka.scripts.CSharp.Common.Fight;
+
+public class FightHappening
+{
+    /*
+    To get a visual overview of the FightHappening state machine, refer to the graph on miro:
+    https://miro.com/app/board/uXjVK8YEprM=/?moveToWidget=3458764640805655262&cot=14
+    */
+
+    #region Internal Types
+
+    public enum FightState
+    {
+        None,
+        FightStartAnim,
+        FightersEnter,
+        FightersEnterAnim,
+        NextFighter,
+        StateCheck,
+        InputActionSelect,
+        ActionCheckDetails,
+        InputActionDetail,
+        ActionExecute,
+        ActionAnim,
+        EnemyActionSelect,
+        PlayerWin,
+        EnemyWin,
+    }
+
+    private class FightersEnterStaging
+    {
+        public required List<FightWorld.Fighter> enteringAllyFighters;
+        public required List<FightWorld.Fighter> enteringEnemyFighters;
+
+        public bool HasAnyToExecute()
+        {
+            return enteringAllyFighters.Count != 0 || enteringEnemyFighters.Count != 0;
+        }
+    }
+
+    #endregion
+
+    #region Settings
+
+    private const float StartAnimationTime = 1;
+    private const float FightersEnterAnimationTime = 1;
+
+    #endregion
+
+    #region ShortCuts
+
+    private static FightWorld.FightHappeningData HappeningData =>
+        FightWorld.Instance.fightHappeningData ?? throw new NoFightHappeningException();
+
+    private static FightWorld.Fighter CurrentFighter => HappeningData.fighterStack.Current;
+
+    #endregion
+
+    #region Events
+
+    public event Action<FightState>? transitionFromState;
+    public event Action<FightState, FightState>? transitionState;
+    public event Action<FightState>? transitionToState;
+
+    #endregion
+
+    #region Staging
+
+    private FightersEnterStaging? _fightersEnterStaging;
+    private FighterAction? _actionStaging;
+
+    #endregion
+
+    #region Public Methods
+
+    public void StartFight()
+    {
+        RequireState(FightState.None);
+        ChangeState(FightState.FightStartAnim);
+    }
+
+    #endregion
+
+    #region State Machine
+
+    private void ChangeState(FightState nextState)
+    {
+        TransitionFromState();
+        var lastState = HappeningData.fightState;
+        HappeningData.fightState = nextState;
+        TransitionFromToState(nextState, lastState);
+        TransitionToState(nextState);
+    }
+
+    private void TransitionFromState()
+    {
+        // fixed behaviour
+        switch (HappeningData.fightState)
+        {
+            default: break;
+        }
+
+        // notify everyone else
+        transitionFromState?.Invoke(HappeningData.fightState);
+    }
+
+    private void TransitionFromToState(FightState nextState, FightState lastState)
+    {
+        transitionState?.Invoke(lastState, nextState);
+    }
+
+    private void TransitionToState(FightState nextState)
+    {
+        // notify everyone else
+        transitionToState?.Invoke(nextState);
+
+        // fixed behaviour
+        switch (HappeningData.fightState)
+        {
+            case FightState.FightStartAnim:
+                AdvanceToStateInSeconds(FightState.FightersEnter, StartAnimationTime);
+                break;
+            case FightState.FightersEnter:
+                _fightersEnterStaging = StageFightersEnter();
+                if (_fightersEnterStaging.HasAnyToExecute())
+                {
+                    ExecuteFightersEnter();
+                    ChangeState(FightState.FightersEnterAnim);
+                }
+                else
+                {
+                    ChangeState(FightState.NextFighter);
+                }
+
+                break;
+            case FightState.FightersEnterAnim:
+                AdvanceToStateInSeconds(FightState.NextFighter, FightersEnterAnimationTime);
+                break;
+            case FightState.NextFighter:
+                ExecuteNextFighter();
+                ChangeState(FightState.StateCheck);
+                break;
+            case FightState.StateCheck:
+                // restest action staging
+                _actionStaging = null;
+
+                if ( /*TODO: are all allys dead*/ false)
+                {
+                    ChangeState(FightState.EnemyWin);
+                }
+                else if (HappeningData.enemyGroup.AreAllDead())
+                {
+                    ChangeState(FightState.PlayerWin);
+                }
+                else if (CurrentFighter.actionsLeft <= 0)
+                {
+                    ChangeState(FightState.FightersEnter);
+                }
+                else if (CurrentFighter.isEnemy)
+                {
+                    ChangeState(FightState.EnemyActionSelect);
+                }
+                else
+                {
+                    ChangeState(FightState.InputActionSelect);
+                }
+
+                break;
+            case FightState.InputActionSelect:
+                // wait for player input
+                break;
+            case FightState.ActionCheckDetails:
+                if (ActionAbort())
+                    ChangeState(FightState.InputActionSelect);
+                else if (ActionNeededDetail() != null)
+                    ChangeState(FightState.InputActionDetail);
+                else
+                    ChangeState(FightState.ActionExecute);
+                break;
+            case FightState.InputActionDetail:
+                // wait for player input
+                break;
+            case FightState.EnemyActionSelect:
+                _actionStaging = CurrentFighter.AutoSelectAction();
+                ChangeState(FightState.ActionExecute);
+                break;
+            case FightState.ActionExecute:
+                ExecuteAction();
+                ChangeState(FightState.ActionAnim);
+                break;
+            case FightState.ActionAnim:
+                var actionTime = GetActionAnimationEnd();
+                if (actionTime.IsType<float>())
+                {
+                    AdvanceToStateInSeconds(FightState.StateCheck, actionTime);
+                }
+                else
+                {
+                    _ = AdvanceToStateWhenDone(FightState.StateCheck, actionTime);
+                }
+
+                break;
+            default: break;
+        }
+    }
+
+    #endregion
+
+    #region Game Logic
+
+    private FightersEnterStaging StageFightersEnter()
+    {
+        // ally
+        var enteringAllyFighters = new List<FightWorld.Fighter>();
+        //TODO
+
+        // enemy
+        const int totalEnemySpace = 3;
+        var enemySpaceLeft = totalEnemySpace - HappeningData.enemyGroup.GetEnteredAmount();
+        var enterEnemyFighters = new List<FightWorld.Fighter>();
+
+        for (var i = 0; i < enemySpaceLeft; i++)
+        {
+            if (HappeningData.enemyGroup.TryGetFirstUnenteredFighter(out var fighter))
+            {
+                enterEnemyFighters.Add(fighter);
+            }
+        }
+
+        return new FightersEnterStaging
+        {
+            enteringAllyFighters = enteringAllyFighters,
+            enteringEnemyFighters = enterEnemyFighters
+        };
+    }
+
+    private void ExecuteFightersEnter()
+    {
+        Debug.Assert(_fightersEnterStaging != null);
+        foreach (var fighter in _fightersEnterStaging.enteringAllyFighters)
+        {
+            fighter.entered = true;
+            HappeningData.fighterStack.AddAsLast(fighter);
+        }
+
+        foreach (var fighter in _fightersEnterStaging.enteringEnemyFighters)
+        {
+            fighter.entered = true;
+            HappeningData.fighterStack.AddAsLast(fighter);
+        }
+    }
+
+    private void ExecuteNextFighter()
+    {
+        HappeningData.fighterStack.Next();
+    }
+
+    private void ExecuteAction()
+    {
+        Debug.Assert(_actionStaging != null);
+        _actionStaging.ExecuteAction();
+    }
+
+    private Variant<float, Func<bool>> GetActionAnimationEnd()
+    {
+        Debug.Assert(_actionStaging != null);
+        return _actionStaging.GetAnimationEnd();
+    }
+
+    private bool ActionAbort()
+    {
+        Debug.Assert(_actionStaging != null);
+        return _actionStaging.MarkedForAbort();
+    }
+
+    private FighterAction.FighterActionDetail? ActionNeededDetail()
+    {
+        Debug.Assert(_actionStaging != null);
+        return _actionStaging.NeededDetail();
+    }
+
+    #endregion // Game Logic
+
+    #region Utility
+
+    private void RequireState(params FightState[] states)
+    {
+        if (states.Contains(HappeningData.fightState))
+            return;
+
+        throw new Exception(
+            $"Can not call this Method while in state {HappeningData.fightState}. Only available in {string.Join(" ,", states)}");
+    }
+
+    private void AdvanceToStateInSeconds(FightState nextState, float seconds)
+    {
+        FightWorld.Instance.GetTree().CreateTimer(seconds).Timeout += () => ChangeState(nextState);
+    }
+
+    private async Task AdvanceToStateWhenDone(FightState nextState, Func<bool> isDone)
+    {
+        while (!isDone())
+        {
+            await FightWorld.Instance.ToSignal(FightWorld.Instance.GetTree(), SceneTree.SignalName.ProcessFrame);
+        }
+
+        ChangeState(nextState);
+    }
+
+    #endregion
+}
@@ -0,0 +1 @@
+uid://c76mhhqyk4lgh
@@ -0,0 +1,15 @@
+using Godot;
+using System;
+using System.Diagnostics;
+using Babushka.scripts.CSharp.Common.Fight;
+
+public partial class FightHappeningSceneSetup : Node2D
+{
+    public override void _Ready()
+    {
+        var fightHappening = FightWorld.Instance.fightHappeningData;
+        Debug.Assert(fightHappening != null, "Fight happening scene loaded, without a fight happening");
+        
+        
+    }
+}
@@ -0,0 +1 @@
+uid://cnhpnn8o0gybd
@@ -2,7 +2,7 @@ using Godot;

 namespace Babushka.scripts.CSharp.Common.Fight;

-public partial class FightSceneSetup : Node
+public partial class FightRoomSceneSetup : Node
 {
    [Export] private Label debugLabel;
    public override void _Ready()
@@ -9,15 +9,15 @@ public partial class FightSceneSwitcher : Node
 {
    [Export] private Node sceneRoot;
    [Export] private string fightRoomScenePath;
-    [Export] private string fightingGroupScene;
+    [Export] private string fightHappeningScene;

    private void LoadNext()
    {
        var nextRoom = FightWorld.Instance.currentRoom;
        Debug.Assert(nextRoom != null, "nextRoom!=null");
-        var nextEnemyGroup = FightWorld.Instance.inFightWith;
-        SceneTransitionThreaded.Instance.ChangeSceneToFile(nextEnemyGroup != null
-            ? fightingGroupScene
+        var nextFightHappening = FightWorld.Instance.fightHappeningData;
+        SceneTransitionThreaded.Instance.ChangeSceneToFile(nextFightHappening != null
+            ? fightHappeningScene
            : fightRoomScenePath);
        UnloadAfterDelay();
    }
@@ -0,0 +1,45 @@
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Babushka.scripts.CSharp.Common.Fight;
+
+public static class FightUtils
+{
+    public static int GetEnteredAmount(this FightWorld.EnemyGroup self)
+    {
+        return self.enemies.Count(e => e.IsAlive() && e.entered);
+    }
+
+    public static bool TryGetFirstUnenteredFighter(this FightWorld.EnemyGroup self, out FightWorld.Fighter fighter)
+    {
+        foreach (var f in self.enemies.Where(e=>!e.entered && e.IsAlive()))
+        {
+            fighter = f;
+            return true;
+        }
+
+        fighter = null!;
+        return false;
+    }
+
+    public static bool IsAlive(this FightWorld.Fighter self)
+    {
+        return self.GetHealth() >= 0;
+    }
+    
+    public static bool IsDead(this FightWorld.Fighter self)
+    {
+        return !self.IsAlive();
+    }
+    
+    public static int GetHealth(this FightWorld.Fighter self)
+    {
+        return self.health ?? self.maxHealth;
+    }
+
+    public static bool AreAllDead(this FightWorld.EnemyGroup self)
+    {
+        return self.enemies.All(e => e.IsDead());
+    }
+    
+}
@@ -0,0 +1 @@
+uid://beuhpltb84pf
@@ -1,4 +1,5 @@
 using System.Collections.Generic;
+using Babushka.scripts.CSharp.Common.Util;
 using Godot;

 namespace Babushka.scripts.CSharp.Common.Fight;
@@ -18,21 +19,39 @@ public partial class FightWorld : Node

    public class EnemyGroup
    {
-        public required List<Enemy> enemies;
+        public required List<Fighter> enemies;
    }

-    public class Enemy
+    public class FightHappeningData
+    {
+        public FightHappening.FightState fightState = FightHappening.FightState.None;
+        public FighterStack fighterStack = new();
+        public required EnemyGroup enemyGroup;
+    }
+
+    public class Fighter
    {
        public enum Type
        {
            Blob,
            BigBlob,
            Mavka,
-            YourMom
+            YourMom,
+            Vesna
        }

        public required Type type;
-        public required int? health = null; // null => initialize to full health on spawn
+        public required int maxHealth;
+        public required bool isEnemy;
+        public required List<FighterAction> availableActions;
+        public int? health = null; // null => initialize to full health on spawn
+        public bool entered = false;
+        public int actionsLeft;
+
+        public FighterAction AutoSelectAction()
+        {
+            return availableActions.Random() ?? new FighterAction.Skip();
+        }
    }

    #region AutoLoad ( Contains _EnterTree() )
@@ -46,10 +65,10 @@ public partial class FightWorld : Node
    }

    #endregion
-    
+
    public World? world = null;
    public Room? currentRoom = null;
-    public EnemyGroup? inFightWith = null;
+    public FightHappeningData? fightHappeningData = null;

    public void MyEnterTree()
    {
@@ -135,22 +154,27 @@ public partial class FightWorld : Node
            return enemyGroup;
        }

-        private Enemy GenerateSingleEnemy()
+        private Fighter GenerateSingleEnemy()
        {
            var typeRoll = GD.RandRange(0, 99);

            var type = typeRoll switch
            {
-                < 50 => Enemy.Type.Blob,
-                < 75 => Enemy.Type.BigBlob,
-                < 90 => Enemy.Type.Mavka,
-                _ => Enemy.Type.YourMom
+                < 50 => Fighter.Type.Blob,
+                < 75 => Fighter.Type.BigBlob,
+                < 90 => Fighter.Type.Mavka,
+                _ => Fighter.Type.YourMom
            };

-            var enemy = new Enemy
+            var enemy = new Fighter
            {
                type = type,
-                health = null
+                health = null,
+                isEnemy = true,
+                maxHealth = 12,
+                availableActions = [
+                    new FighterAction.Skip()
+                ]
            };

            return enemy;
@@ -0,0 +1,80 @@
+using System;
+using System.Threading.Tasks;
+using Babushka.scripts.CSharp.Common.Util;
+using Godot;
+
+namespace Babushka.scripts.CSharp.Common.Fight;
+
+public abstract class FighterAction
+{
+    public class TargetSelection
+    {
+        // ReSharper disable once MemberHidesStaticFromOuterClass
+        public static readonly TargetSelection Skip = new() { skipTargetSelection = () => true };
+        public Func<bool> skipTargetSelection = () => false;
+    }
+    
+    public abstract class FighterActionDetail
+    {
+        public abstract bool DetailComplete();
+    }
+
+    private bool _abort = false;
+
+    #region Shortcuts
+
+    protected static FightWorld.FightHappeningData HappeningData =>
+        FightWorld.Instance.fightHappeningData ?? throw new NoFightHappeningException();
+
+    #endregion
+
+    /// <summary>
+    /// Executes the data modification for the action. This must happen instantly and not via a coroutines or callbacks.
+    /// To get a multiple hit effect for one action, use appropriate Visual Manipulation functions in AnimateAction.
+    /// </summary>
+    public virtual void ExecuteAction()
+    {
+    }
+
+    /// <summary>
+    /// Returns a way to determine, when an action animation is done
+    /// </summary>
+    /// <returns>
+    /// A variant that can be <c>float</c> or <c>Func&lt;bool&gt;</c>.<br/>
+    /// When the return type is <c>float</c>, the animation will take the return value amount of seconds.<br/>
+    /// When the return type is <c>Func&lt;bool&gt;</c>, the animation will be done, when the function returns true.
+    /// </returns>
+    public abstract Variant<float, Func<bool>> GetAnimationEnd();
+
+    /// <summary>
+    /// Animates the action.
+    /// </summary>
+    public virtual async Task AnimateAction()
+    {
+    }
+
+    public void MarkAbort()
+    {
+        _abort = true;
+    }
+
+    public bool MarkedForAbort()
+    {
+        return _abort;
+    }
+
+    public abstract FighterActionDetail? NeededDetail();
+
+    public class Skip : FighterAction
+    {
+        public override Variant<float, Func<bool>> GetAnimationEnd()
+        {
+            return 0f;
+        }
+
+        public override FighterActionDetail? NeededDetail()
+        {
+            return null;
+        }
+    }
+}
@@ -0,0 +1,95 @@
+using System.Collections.Generic;
+using Godot.NativeInterop;
+
+namespace Babushka.scripts.CSharp.Common.Fight;
+
+public class FighterStack
+{
+    private class Node
+    {
+        public Node next;
+        public FightWorld.Fighter fighter;
+    }
+
+    private Node? currentNode;
+
+    public FightWorld.Fighter Current => currentNode.fighter;
+
+    public void Next()
+    {
+        currentNode = currentNode.next;
+    }
+
+    public FightWorld.Fighter PeekNext()
+    {
+        return currentNode.next.fighter;
+    }
+
+    public void AddAsLast(FightWorld.Fighter value)
+    {
+        // if first node
+        if (currentNode == null)
+        {
+            currentNode = new Node { fighter = value };
+            currentNode.next = currentNode;
+            return;
+        }
+
+        var newNode = new Node { fighter = value, next = currentNode };
+        var node = currentNode;
+        while (node.next != currentNode)
+        {
+            node = node.next;
+        }
+
+        node.next = newNode;
+    }
+
+    public void AddAsNext(FightWorld.Fighter value)
+    {
+        // if first node
+        if (currentNode == null)
+        {
+            AddAsLast(value);
+            return;
+        }
+
+        var newNode = new Node { fighter = value, next = currentNode.next };
+        currentNode.next = newNode;
+    }
+
+    public bool Remove(FightWorld.Fighter value)
+    {
+        if (currentNode == null) return false;
+
+        // if only one node
+        if (currentNode.next == currentNode)
+        {
+            if (currentNode.fighter == value)
+            {
+                currentNode = null;
+                return true;
+            }
+
+            return false;
+        }
+
+        var node = currentNode;
+        do
+        {
+            // next is the fighter to remove
+            if (node.next.fighter == value)
+            {
+                // if removing current, keep current
+                // it will be implicitly deleted on the next Next() call
+                
+                node.next = node.next.next;
+                return true;
+            }
+
+            node = node.next;
+        } while (node != currentNode);
+
+        return false;
+    }
+}
@@ -0,0 +1,157 @@
+using Godot;
+namespace Babushka.scripts.CSharp.Common.Fight;
+
+public partial class FighterVisual : Node2D
+{
+    //[Export] public string name;
+    //[Export] public int maxHealth;
+    //[Export] public int attackStrength;
+    //[Export] public int maxActions = 1;
+    [Export] public FightWorld.Fighter.Type type;
+
+    [ExportCategory("References")]
+    [Export] private Node2D _attackButtons;
+    [Export] private Node2D _targetButtons;
+    [Export] private Node2D _targetMarker;
+    [Export] private Label _healthText;
+    [Export] private Node2D _visualSprite;
+
+    [Signal] public delegate void DamageTakenEventHandler();
+    [Signal] public delegate void AttackingEventHandler();
+    [Signal] public delegate void DyingEventHandler();
+    [Signal] public delegate void HealedEventHandler();
+
+
+    private FightWorld.Fighter _boundFighter;
+
+    //private void Die()
+    //{
+    //    _visualSprite.Scale = new Vector2(1, 0.3f);
+    //    EmitSignalDying();
+    //}
+
+    //public override void _Ready()
+    //{
+    //    UpdateHealthVisual();
+    //    ResetActions();
+    //}
+
+    public void Initialize(FightWorld.Fighter fighter)
+    {
+        _boundFighter = fighter;
+        UpdateHealthVisual();
+    }
+
+    public void Attack()
+    {
+        //FightHappening.SelectAttack(this);
+    }
+
+    public void HideAttackButton()
+    {
+        _attackButtons.Hide();
+    }
+
+    public void ShowAttackButton()
+    {
+        _attackButtons.Show();
+    }
+
+    public void HideTargetButtons()
+    {
+        _targetButtons.Hide();
+    }
+
+    public void ShowTargetButtons()
+    {
+        _targetButtons.Show();
+    }
+
+    public void TargetMouseEvent(Node viewport, InputEvent inputEvent, int shapeIdx)
+    {
+        if (inputEvent.IsPressed())
+            ClickedTarget();
+    }
+
+    public void AttackMouseEvent(Node viewport, InputEvent inputEvent, int shapeIdx)
+    {
+        if (inputEvent.IsPressed())
+            ClickedAttack();
+    }
+    
+    public void HealMouseEvent(Node viewport, InputEvent inputEvent, int shapeIdx)
+    {
+        if (inputEvent.IsPressed())
+            ClickedHeal();
+    }
+
+    private void ClickedAttack()
+    {
+        //FightHappening.SelectAttack(this);
+    }
+
+    private void ClickedHeal()
+    {
+        //FightHappening.SelectHeal(this);
+    }
+
+    private void ClickedTarget()
+    {
+        //FightHappening.SelectTargetAndAttack(this);
+    }
+
+    public void StartHoverTarget()
+    {
+        _targetMarker.Visible = true;
+    }
+
+    public void EndHoverTarget()
+    {
+        _targetMarker.Visible = false;
+    }
+
+    public void UpdateHealthVisual()
+    {
+        _healthText.Text = $"{_boundFighter.health}";
+    }
+
+    public bool IsDead()
+    {
+        //return Health <= 0;
+        return true;
+    }
+
+    public void ResetActions()
+    {
+        //_actions = maxActions;
+    }
+
+    public void AttackAnimation(FightAttack attack)
+    {
+        EmitSignalAttacking();
+        var tween = GetTree().CreateTween();
+        tween.TweenProperty(this, "global_position", attack.target.GlobalPosition, 0.15);
+        tween.TweenCallback(Callable.From(() => attack.target?.HitAnimation(attack)));
+        tween.TweenProperty(this, "position", new Vector2(0, 0), 0.7)
+            .SetTrans(Tween.TransitionType.Cubic).SetEase(Tween.EaseType.Out);
+
+    }
+
+    private void HitAnimation(FightAttack attack)
+    {
+        EmitSignalDamageTaken();
+        var tween = GetTree().CreateTween();
+        tween.TweenProperty(this, "scale", new Vector2(1.4f, 0.6f), 0.15);
+        tween.TweenProperty(this, "scale", new Vector2(1, 1), 0.4)
+            .SetTrans(Tween.TransitionType.Cubic).SetEase(Tween.EaseType.Out);
+    }
+
+    public void HealAnimation()
+    {
+        EmitSignalHealed();
+        var tween = GetTree().CreateTween();
+        tween.TweenProperty(this, "scale", new Vector2(0.6f, 1.4f), 0.15);
+        tween.TweenProperty(this, "scale", new Vector2(1, 1), 0.4)
+            .SetTrans(Tween.TransitionType.Cubic).SetEase(Tween.EaseType.Out);
+    }
+}
@@ -0,0 +1 @@
+uid://by88f32fou7lh
@@ -0,0 +1,7 @@
+using System;
+
+namespace Babushka.scripts.CSharp.Common.Fight;
+
+public class NoFightHappeningException() : Exception("No fight happening right now")
+{
+}