Інтерфейс IDamagable

using System;
using Godot;

public partial class EnemyCrab : CharacterBody2D, IDamagable
{
    public float Gravity = 980f;

    [Export] public float Speed = 60f;
    [Export] public int Damage = 1;
    [Export] public int Health = 1;

    private string WalkAnimName = "Walk";
    private string AttackAnimName = "Attack";
    private string DeathAnimName = "Death";

    private int Direction = 1;
    private Area2D Area;
    private AnimatedSprite2D AnimSprite;

    private bool Dying = false;
    private bool PauseMovement = false;

    public bool IsDead { get; private set; }

    public event Action<DamageInfo> Damaged;
    public event Action Died;

    public override void _Ready()
    {
        Area = GetNode<Area2D>("Area2D");
        Area.BodyEntered += OnBodyEntered;

        AnimSprite = GetNode<AnimatedSprite2D>("AnimatedSprite2D");

        AnimSprite.AnimationFinished += OnAnimationFinished;
    }

    public override void _PhysicsProcess(double delta)
    {
        if (IsDead || Dying) return;

        Vector2 velocity = Velocity;

        if (!IsOnFloor())
        {
            velocity.Y += Gravity * (float)delta;
        }

        if (PauseMovement)
        {
            velocity.X = 0;
        }
        else
        {
            velocity.X = Direction * Speed;
        }

        Velocity = velocity;
        MoveAndSlide();

        if (IsOnWall())
        {
            Direction *= -1;
            AnimSprite.FlipH = !AnimSprite.FlipH;
        }
    }

    private void OnBodyEntered(Node2D body)
    {
        if (IsDead || Dying) return;
        if (body is not Player player) return;

        bool playerAbove = (GlobalPosition.Y - player.GlobalPosition.Y) > 10;

        if (playerAbove)
        {
            // Раніше тут напряму виставлялась швидкість гравця (vel.Y = -800f) - тепер це те саме
            // "відскакування атакуючого", яке DamageInfo/TakeDamage вміють робити для будь-кого,
            // хто реалізує IDamagable, а не лише для цього конкретного випадку.
            TakeDamage(new DamageInfo(
                player.StompDamage,
                player,
                new Vector2(player.Velocity.X, player.StompBounceVelocity)));
        }
        else
        {
            HurtPlayer(player);
        }
    }

    /// <summary>Реалізація IDamagable.TakeDamage - той самий метод, який гравець викликає на нас, коли стрибає нам на голову.</summary>
    public void TakeDamage(DamageInfo info)
    {
        Health -= info.Amount;
        info.ApplyBounceToSource();
        Damaged?.Invoke(info);

        if (Health <= 0 && !Dying)
        {
            IsDead = true;
            Died?.Invoke();
            StartDying();
        }
    }

    private void StartDying()
    {
        Dying = true;

        AnimSprite.Play(DeathAnimName);
    }

    private void OnAnimationFinished()
    {
        string currentAnim = AnimSprite.Animation;

        if (currentAnim == DeathAnimName && Dying)
        {
            Cleanup();
        }

        if (currentAnim == AttackAnimName)
        {
            PauseMovement = false;
            AnimSprite.Play(WalkAnimName);
        }
    }

    private void Cleanup()
    {
        // IsDead уже true - виставлено синхронно з Died у TakeDamage(), а не тут.
        SetPhysicsProcess(false);

        Area.Monitoring = false;

        foreach (var child in FindChildren("", "CollisionShape2D"))
        {
            if (child is CollisionShape2D shape)
            {
                shape.Disabled = true;
            }
        }
    }

    private void HurtPlayer(Player player)
    {
        GD.Print("Player hurt!");

        PauseMovement = true;
        AnimSprite.Play(AttackAnimName);

        // Раніше тут викликався GameManager.DamagePlayer(Damage, player) - конкретний метод для
        // конкретного типу Player. Тепер це просто TakeDamage() з інтерфейсу IDamagable: той самий
        // виклик спрацював би для будь-якого IDamagable, а не лише для Player.
        player.TakeDamage(new DamageInfo(Damage, this));
    }
}

using Godot;
using System;
using System.Collections.Generic;

// Клас PlayerCharacterBody2d успадковує CharacterBody2D, що дозволяє йому мати фізичні властивості, такі як маса, прискорення, колізії.
public partial class Player : CharacterBody2D, ISavable, IDamagable
{
    // Константи для фізичних параметрів гравця
    private const float Acceleration = 300.0f;         // Прискорення при русі
    private const float JumpAcceleration = 700f;       // Сила стрибка
    private const float MaxSpeed = 350;                // Максимальна швидкість руху
    private const float AnimationMaxFPS = 20;          // Максимальна швидкість анимації для ходьби
    private const float PushForce = 1000;              // Сила відштовхування при колізії з іншими об'єктами

    // Вектор гравітації (вниз)
    private Vector2 Gravity = new Vector2(0, 50f);

    // Посилання на AnimatedSprite2D для відображення анімації
    public AnimatedSprite2D AnimatedSprite2D { private set; get; }

    [Export]
    public int HP { get; set; } = 3;

    // Раніше -800f було захардкоджено прямо у EnemyCrab.StartDying(). Тепер це налаштовується
    // тут, на самому Player-і, і передається як SourceBounceVelocity у DamageInfo, коли Player
    // когось топче.
    [Export] public int StompDamage = 1;
    [Export] public float StompBounceVelocity = -800f;

    public bool IsDead { get; private set; }

    public event Action<DamageInfo> Damaged;
    public event Action Died;

    // Метод викликається один раз під час ініціалізації об'єкта
    public override void _Ready()
    {
        // Отримуємо посилання на AnimatedSprite2D з сцени
        AnimatedSprite2D = GetNode<AnimatedSprite2D>("AnimatedSprite2D");

        // Реєструємось у GameManager один раз, щоб він міг підписатись на Damaged/Died.
        GetNode<GameManager>("/root/GameManager").RegisterPlayer(this);
    }

    // Основний метод фізичного процесу, викликається кожен кадр
    public override void _PhysicsProcess(double delta)
    {
        // Отримуємо напрямок руху з методу GetDirection()
        Vector2 direction = GetDirection();
        Vector2 velocity = Velocity;

        // Додаємо прискорення в напрямку руху
        velocity += direction * Acceleration * (float)delta;
        // Додаємо гравітацію
        velocity += Gravity;

        // Обмежуємо швидкість по X, щоб не перевищувала MaxSpeed
        velocity.X = Mathf.Clamp(velocity.X, -MaxSpeed, MaxSpeed);

        // Якщо гравець рухається по X
        if (velocity.X != 0)
        {
            // Якщо рух відбувається вправо
            if (velocity.X > 0)
            {
                AnimatedSprite2D.FlipH = true; // Перевертаємо спрайт вправо
            }
            // Якщо рух відбувається вліво
            else if (velocity.X < 0)
            {
                AnimatedSprite2D.FlipH = false; // Перевертаємо спрайт вліво
            }

            // Встановлюємо анімацію ходьби
            AnimatedSprite2D.Animation = "walk";

            // Змінюємо швидкість анімації залежно від швидкості руху
            AnimatedSprite2D.SpriteFrames.SetAnimationSpeed("walk", AnimationMaxFPS * (Math.Abs(velocity.X) / MaxSpeed));
        }
        else
        {
            // Якщо гравець не рухається по X, встановлюємо анімацію "idle"
            AnimatedSprite2D.Animation = "idle";
        }

        // Запускаємо анімацію
        AnimatedSprite2D.Play();

        // Реалізуємо інерцію при зміні напрямку руху
        if (direction.X == 1 && velocity.X < 0 || direction.X == -1 && velocity.X > 0)
        {
            velocity.X *= 0.90f; // Зменшуємо швидкість по X
        }
        else if (direction.X == 0)
        {
            velocity.X *= 0.90f; // Зменшуємо швидкість по X при відсутності напрямку
        }

        // Якщо натиснута клавіша пробіл і гравець на землі, робимо стрибок
        if (Input.IsPhysicalKeyPressed(Key.Space) && IsOnFloor())
        {
            velocity.Y -= JumpAcceleration; // Змінюємо швидкість по Y вгору
        }

        // Встановлюємо нову швидкість гравця
        Velocity = velocity;

        // Виконуємо фізичний рух об'єкта
        if (MoveAndSlide())
        {
            // Отримуємо кількість колізій
            int collisionCount = GetSlideCollisionCount();

            // Перебираємо всі колізії
            for (int i = 0; i < collisionCount; i++)
            {
                KinematicCollision2D collision = GetSlideCollision(i);

                // Якщо колізія відбувається з RigidBody2D
                if (collision.GetCollider() is RigidBody2D collider)
                {
                    // Застосовуємо силу відштовхування в напрямку нормалі колізії
                    collider.ApplyForce(collision.GetNormal() * -PushForce);
                }
            }
        }
    }

    // Метод для визначення напрямку руху гравця
    public Vector2 GetDirection()
    {
        Vector2 direction = new Vector2(); // Створюємо вектор напрямку

        // Якщо натиснута клавіша W — рух вгору
        if (Input.IsPhysicalKeyPressed(Key.W))
        {
            direction.Y += -1;
        }

        // Якщо натиснута клавіша S — рух вниз
        if (Input.IsPhysicalKeyPressed(Key.S))
        {
            direction.Y += 1;
        }

        // Якщо натиснута клавіша A — рух вліво
        if (Input.IsPhysicalKeyPressed(Key.A))
        {
            direction.X += -1;
        }

        // Якщо натиснута клавіша D — рух вправо
        if (Input.IsPhysicalKeyPressed(Key.D))
        {
            direction.X += 1;
        }

        return direction; // Повертаємо напрямок руху
    }

    /// <summary>Реалізація IDamagable.TakeDamage.</summary>
    public void TakeDamage(DamageInfo info)
    {
        HP -= info.Amount;
        info.ApplyBounceToSource();
        Damaged?.Invoke(info);

        if (HP <= 0 && !IsDead)
        {
            IsDead = true;
            Died?.Invoke();
        }
    }

    public bool Save(Dictionary<string, object> data)
    {
        Red.RedGodot.SaveData(this, data, "Position", Position);
        Red.RedGodot.SaveData(this, data, "Velocity", Velocity);

        return true;
    }

    public bool Load(Dictionary<string, object> data)
    {
        Position = Red.RedGodot.LoadData<Vector2>(this, data, "Position");
        Velocity = Red.RedGodot.LoadData<Vector2>(this, data, "Velocity");

        return true;
    }
}

using Godot;

public partial class GameManager : Node
{
    private PackedScene PauseMenuScene { get; set; }
    private PackedScene DeathMenuScene { get; set; }

    private Node PauseMenuInstance { get; set; }
    private Node DeathMenuInstance { get; set; }

    private HUDMenu HUDMenu { get; set; } = null;

    private Player player;

    public override void _Ready()
    {
        PauseMenuScene = GD.Load<PackedScene>("res://Scenes/Menus/PauseMenu/PauseMenu.tscn");
        DeathMenuScene = GD.Load<PackedScene>("res://Scenes/Menus/DeathMenu/DeathMenu.tscn");

        // КРИТИЧНО: Встановлюємо ProcessMode в Always, щоб цей Node продовжував 
        // обробляти ввід та працювати, навіть коли GetTree().Paused = true
        ProcessMode = ProcessModeEnum.Always;
    }

    public override void _UnhandledInput(InputEvent @event)
    {
        // Перевіряємо, чи було натиснуто дію "ui_cancel" (за замовчуванням це клавіша ESC)
        if (@event.IsActionPressed("ui_cancel"))
        {
            TogglePause();
            // Позначаємо подію як оброблену, щоб вона не передавалася далі іншим об'єктам
            GetViewport().SetInputAsHandled();
        }
    }

    private void TogglePause()
    {
        // Визначаємо новий стан паузи (інвертуємо поточний стан GetTree().Paused)
        bool willBePaused = !GetTree().Paused;
        // Встановлюємо стан паузи для всього дерева сцени
        GetTree().Paused = willBePaused;

        if (willBePaused)
        {
            // Якщо гра стає на паузу: створюємо екземпляр меню паузи та додаємо його в корінь сцени
            PauseMenuInstance = PauseMenuScene.Instantiate<Node>();
            GetTree().Root.AddChild(PauseMenuInstance);
        }
        else
        {
            // Якщо гра виходить з паузи: перевіряємо існування меню та видаляємо його з пам'яті
            if (PauseMenuInstance != null && IsInstanceValid(PauseMenuInstance))
            {
                PauseMenuInstance.QueueFree();
                PauseMenuInstance = null;
            }
        }
    }

    // Публічний метод для примусового виходу з режиму паузи (наприклад, при натисканні кнопки "Resume")
    public void Unpause()
    {
        if (GetTree().Paused)
            TogglePause();
    }

    public void ShowDeathMenu()
    {
        GetTree().Paused = true;
        DeathMenuInstance = DeathMenuScene.Instantiate<Node>();
        GetTree().Root.AddChild(DeathMenuInstance);
    }

    public void RegisterPlayer(Player p)
    {
        player = p;
        player.Damaged += OnPlayerDamaged;
        player.Died += OnPlayerDied;
    }

    private void OnPlayerDamaged(DamageInfo info)
    {
        // GameManager - autoload, тому переживає перезавантаження рівня/сцени, а HUDMenu - ні:
        // після ChangeSceneToPacked/ChangeSceneToFile стара HUDMenu звільняється, і кешоване тут
        // посилання лишається вказувати на вже видалений (freed) нод. ??= саме через це не годиться -
        // він побачить, що поле вже не null, і залишить стале посилання як є. IsInstanceValid()
        // перевіряє саме це - чи ще живий той нод, на який ми посилаємось - і лише тоді шукає HUDMenu
        // заново.
        if (HUDMenu == null || !IsInstanceValid(HUDMenu))
        {
            HUDMenu = GetTree().GetFirstNodeInGroup("HUDMenu") as HUDMenu;
        }
        HUDMenu?.UpdateHealth(player.HP);
    }

    private void OnPlayerDied() => ShowDeathMenu();
}