Babushka/scripts/CSharp/Common/Farming/FarmingControls2D.cs

using Godot;
using Godot.Collections;

namespace Babushka.scripts.CSharp.Common.Farming;

[GlobalClass]
public partial class FarmingControls2D : Node2D
{
    [Export] private PackedScene _fieldPrefab;
    [Export] private Node2D _movingPlayer;
    [Export] private Camera2D _camera;

    public FieldService2D FieldService;

    private int _toolId = -1;
    private bool _wateringCanFilled = false;
    private int _currentWateringCanStep = 0;
    private int _wateringCanCapacity = 3;
    
    [Signal] public delegate void WateringFieldEventHandler();
    
    #region Tools
    
    /// <summary>
    /// If no tool has been set, then set the current tool to the incoming tool id.
    /// </summary>
    /// <param name="toolId">The id of the tool to activate if possible</param>
    /// <returns>If the tool in question was activated.</returns>
    public bool TryActivateTool(int toolId)
    {
        bool activate;
        
        //if our hands are empty, activate
        if (toolId == -1)
        {
            activate = false;
        }
        else
        {
            activate = true;
        }

        _toolId = activate ? toolId : -1;
        return activate;
    }
    
    #endregion

    public override void _Input(InputEvent @event)
    {
        Vector2 mousePosition = _camera.GetGlobalMousePosition();
        Vector2I mousePositionInteger = (Vector2I) mousePosition;
        Vector2I adjustedPosition = AdjustValue(mousePositionInteger, new Vector2I(735, 651));

        if (@event.IsActionPressed("click") && _toolId == 0)
        {
            MakeField(adjustedPosition);
        }

        if (@event.IsActionPressed("click") && _toolId == 1 && _wateringCanFilled)
        {
            WaterTheField(adjustedPosition);
        }
    }

    public void FillWateringCan(bool fillUp)
    {
        if (_toolId == 1 )
        {
            _wateringCanFilled = fillUp;
        }
    }
    
    private void WaterTheField(Vector2I fieldPosition)
    {
        FieldBehaviour2D field = FieldService.Get(fieldPosition);
        if (field == null || field.FieldState == FieldState.Watered)
            return;
        
        field.Water();
        EmitSignal(SignalName.WateringField);
        
        if (_currentWateringCanStep < _wateringCanCapacity)
        {
            _currentWateringCanStep++;
        }
        else
        {
            _currentWateringCanStep = 0;
            FillWateringCan(false);
        }
        
    }

    private void MakeField(Vector2I fieldPosition)
    {
        if(FieldService == null || _fieldPrefab == null) 
            return;
        
        // only try to instantiate a field if you're in the allowed area
        if (!FieldService.FieldAllowed())
            return;
        
        // only instantiate a field if there isn't one already.
        if(FieldService.Get(fieldPosition) == null)
        {
            Node fieldInstance = _fieldPrefab.Instantiate();
            if (fieldInstance is Node2D field2d)
            {
                // add dictionary entry for the field
                Array<Node> fields = field2d.FindChildren("*", nameof(FieldBehaviour2D));
                if (fields.Count > 0)
                    FieldService.TryAddEntry(fieldPosition, fields[0] as FieldBehaviour2D);
                
                // reposition and reparent the instance
                field2d.Position = new Vector2(fieldPosition.X, fieldPosition.Y);;
                FieldService.AddChild(fieldInstance);
            }
        }
    }

    private int AdjustValue(float value)
    {
        float adjustedValue = value / 500;
        adjustedValue = Mathf.RoundToInt(adjustedValue);
        adjustedValue *= 500;
        return (int)adjustedValue;
    }

    private Vector2I AdjustValue(Vector2I input, Vector2I step)
    {
        return input.Snapped(step);
    }
}