GodotComponentTest/entities/Player.cs

using System.Collections.Generic;
using System.Diagnostics;
using Godot;
using GodotComponentTest.components;
using GodotComponentTest.entities;
using GodotComponentTest.utils;

public class Player : Entity, IInteractionInterface
{
    // public members
    [Export] public NodePath WorldNode;

    public int GoldCount;
    public TaskQueueComponent TaskQueueComponent;
    public NavigationComponent NavigationComponent { get; private set; }
    public InteractionComponent InteractionComponent { get; set; }

    [Signal]
    private delegate void GoldCountChanged(int goldCount);

    // private members
    private WorldInfoComponent _worldInfo;
    private readonly List<Node> _attractedItemList = new();
    private AnimationTree _animationTree;
    private DebugGeometry _debugGeometry;
    private GroundMotionComponent _groundMotion;
    private Area _itemAttractorArea;
    private Area _itemPickupArea;
    private AnimationPlayer _playerAnimationPlayer;
    private BoneAttachment _toolAttachement;

    // Called when the node enters the scene tree for the first time.
    public override void _Ready()
    {
        _groundMotion = new GroundMotionComponent();
        _worldInfo = (WorldInfoComponent)FindNode("WorldInfo", false);
        NavigationComponent = (NavigationComponent)FindNode("Navigation", false);
        NavigationComponent.World = GetNode<World>(WorldNode);
        TaskQueueComponent = new TaskQueueComponent();

        _itemAttractorArea = (Area)FindNode("ItemAttractorArea", false);
        if (_itemAttractorArea == null)
        {
            GD.PushWarning("No ItemAttractorArea node found for " + GetClass());
        }
        else
        {
            _itemAttractorArea.Connect("body_entered", this, nameof(OnItemAttractorBodyEntered));
            _itemAttractorArea.Connect("body_exited", this, nameof(OnItemAttractorBodyExited));
        }

        _itemPickupArea = (Area)FindNode("ItemPickupArea", false);
        if (_itemPickupArea == null)
            GD.PushWarning("No ItemPickupArea node found for " + GetClass());
        else
            _itemPickupArea.Connect("body_entered", this, nameof(OnItemPickupAreaBodyEntered));

        _playerAnimationPlayer = GetNode<AnimationPlayer>("Geometry/AnimationPlayer");
        Debug.Assert(_playerAnimationPlayer != null);
        _animationTree = GetNode<AnimationTree>("Geometry/AnimationTree");
        Debug.Assert(_animationTree != null);
        var stateMachine =
            (AnimationNodeStateMachinePlayback)_animationTree.Get("parameters/playback");
        stateMachine.Start("Idle");

        _toolAttachement = (BoneAttachment)FindNode("ToolAttachement");
        if (_toolAttachement == null)
        {
            GD.PushWarning("No ToolAttachement found!");
        }

        _debugGeometry = (DebugGeometry)FindNode("DebugGeometry");
    }


    public override void _PhysicsProcess(float delta)
    {
        base._PhysicsProcess(delta);

        if (NavigationComponent == null)
        {
            return;
        }

        if (TaskQueueComponent != null && TaskQueueComponent.Queue.Count > 0)
        {
            TaskQueueComponent.Process(this, delta);

            if (TaskQueueComponent.Queue.Count > 0)
            {
                var currentTask = TaskQueueComponent.Queue.Peek();
                TaskQueueComponent.NavigationTask navigationTask = currentTask as TaskQueueComponent.NavigationTask;
                if (navigationTask != null && navigationTask.PlanningComplete == false)
                {
                    // _navigationComponent.PlanGridPath(this, GlobalTransform, navigationTask.NavigationPoint);
                    NavigationComponent.PlanSmoothedPath(this, GlobalTransform, navigationTask.NavigationPoint);

                    NavigationComponent.ActivatePlannedPath();
                    navigationTask.PlanningComplete = true;
                }

                NavigationComponent.UpdateCurrentGoal(GlobalTransform);
                _groundMotion.PhysicsProcess(delta, this, NavigationComponent.CurrentGoalPositionWorld,
                    NavigationComponent.CurrentGoalAngleWorld, _worldInfo.World);

                if (NavigationComponent.IsGoalReached())
                    navigationTask.NavigationPoint = new NavigationPoint(GlobalTransform);
            }
        }
    }


    public override void _Process(float delta)
    {
        if (NavigationComponent != null)
        {
            NavigationComponent.UpdateCurrentGoal(GlobalTransform);
        }

        foreach (Node node in _attractedItemList)
        {
            if (node is GoldBar)
            {
                GoldBar bar = (GoldBar)node;
                bar.SetTarget(GlobalTransform.origin);
            }
        }

        UpdateDebugGeometry();
    }

    public void UpdateDebugGeometry()
    {
        if (_debugGeometry == null || _debugGeometry.Visible == false)
        {
            return;
        }

        _debugGeometry.Clear();
        _debugGeometry.GlobalTransform = Transform.Identity;

        if (NavigationComponent != null)
        {
            NavigationComponent.DebugDraw(this, _debugGeometry);
        }
    }

    public void OnItemAttractorBodyEntered(Node node)
    {
        _attractedItemList.Add(node);
    }

    public void OnItemAttractorBodyExited(Node node)
    {
        if (node is GoldBar)
        {
            GoldBar bar = (GoldBar)node;
            bar.UnsetTarget();
        }

        _attractedItemList.Remove(node);
    }

    public void OnItemPickupAreaBodyEntered(Node body)
    {
        GD.Print("Picking up item: " + body.Name);

        if (body is Axe)
        {
            SetActiveTool("Axe");
        }

        if (body is GoldBar)
        {
            GoldCount++;
            EmitSignal("GoldCountChanged", GoldCount);
        }

        body.QueueFree();
    }

    public void SetActiveTool(string toolName)
    {
        Debug.Assert(_toolAttachement != null);
        if (toolName == "Axe")
        {
            _toolAttachement.Visible = true;
        }
        else if (toolName == "")
        {
            _toolAttachement.Visible = false;
        }
    }

    public void OnInteractionStart()
    {
        AnimationNodeStateMachinePlayback stateMachine =
            (AnimationNodeStateMachinePlayback)_animationTree.Get("parameters/playback");
        Debug.Assert(stateMachine != null);

        if (InteractionComponent.TargetEntity is Chest)
        {
            GD.Print("Player Opening Box");
            stateMachine.Travel("Interaction");
        }
        else if (InteractionComponent.TargetEntity is Tree)
        {
            GD.Print("Player Chopping Tree");
            stateMachine.Travel("Hit");
        }
    }

    public void OnInteractionEnd()
    {
        GD.Print("Player Stopping Interaction");
        AnimationNodeStateMachinePlayback stateMachine =
            (AnimationNodeStateMachinePlayback)_animationTree.Get("parameters/playback");
        Debug.Assert(stateMachine != null);
        stateMachine.Travel("Idle");
    }
}