popup menu refactor, player class refactor

2023-12-17 12:01:08 +02:00
parent 72191123c2
commit 19d57651c3
10 changed files with 261 additions and 194 deletions
@@ -0,0 +1,137 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.AI;
+
+public class BlockingAnimation : Attribute { }
+public abstract class BaseCharacter : MonoBehaviour
+{
+    [SerializeField]
+    public NavMeshAgent _navAgent;
+    [SerializeField]
+    public Animator _animator;
+
+    private const string WALK_VELOCITY = "WalkVelocity";
+    private readonly Queue<PlayerTasks> _tasks = new Queue<PlayerTasks>();
+    private PlayerTasks _currentTask;
+
+    private Action _OnAnimationFinish;
+    private AnimationStates _currentAnimation;
+
+    private void Update()
+    {
+        if (PlayerHelper.IsBlockingAnimation(_currentAnimation))
+        {
+            if (IsAnimationStatePlaying(0))
+            {
+                return;
+            }
+            else
+            {
+                _OnAnimationFinish?.Invoke();
+                _OnAnimationFinish = null;
+            }
+        }
+
+        if (_currentTask == null || _currentTask.Status == TaskStatus.Complete)
+        {
+            _tasks.TryDequeue(out _currentTask);
+        }
+        if (_currentTask != null)
+        {
+            if (_currentTask.Status == TaskStatus.Waiting)
+                Debug.Log($"Current task {_currentTask.Task}");
+            switch (_currentTask.Task)
+            {
+                case Tasks.Rotate:
+                    _currentTask.UpdateStatus(Rotate(_currentTask.TagretObject._interactionPoint.forward));
+                    break;
+                case Tasks.Move:
+                    if (_currentAnimation == AnimationStates.Sitting)
+                    {
+                        SetPlayerAnimation(AnimationStates.Standing);
+                        return;
+                    }
+                    _navAgent.SetDestination(_currentTask.TagretObject._interactionPoint.position);
+                    _currentTask.UpdateStatus(MoveToPoint());
+                    break;
+                case Tasks.Interact:
+                    _currentTask.UpdateStatus(_currentTask.TagretObject.Interact());
+                    break;
+            }
+        }
+    }
+    private TaskStatus MoveToPoint()
+    {
+        _navAgent.isStopped = false;
+        SetPlayerAnimation(AnimationStates.Walking);
+
+        _animator.SetFloat(WALK_VELOCITY, _navAgent.velocity.magnitude);
+        return IsPathComplete(_navAgent.destination) ? TaskStatus.Complete : TaskStatus.InProgress;
+    }
+
+    public bool IsPathComplete(Vector3 destination)
+    {
+        var dest = new Vector3(destination.x, 0, destination.z);
+        var pos = new Vector3(_navAgent.transform.position.x, 0, _navAgent.transform.position.z);
+
+        if (Vector3.Distance(dest, pos) <= _navAgent.radius)
+        {
+            transform.position = destination;
+            if (!_navAgent.hasPath || _navAgent.velocity.sqrMagnitude < 0.2f)
+            {
+                SetPlayerAnimation(AnimationStates.Idle);
+                _navAgent.isStopped = true;
+                return true;
+            }
+        }
+
+        return false;
+    }
+
+    public TaskStatus Rotate(Vector3 target)
+    {
+        var targetRot = Quaternion.LookRotation(target);
+        Quaternion rotation = Quaternion.Slerp(transform.rotation, Quaternion.LookRotation(target), 10 * Time.deltaTime);
+        rotation.x = 0;
+        transform.rotation = rotation;
+        if (IsApproximate(targetRot, transform.rotation, 0.000004f))
+        {
+            return TaskStatus.Complete;
+        }
+        return TaskStatus.InProgress;
+    }
+
+    protected void AddTask(PlayerTasks task)
+    {
+        _tasks.Enqueue(task);
+    }
+
+    public bool IsAnimationStatePlaying(int animLayer)
+    {
+        string stateName = PlayerHelper.GetEnumMemberValue(_currentAnimation);
+        var stateInfo = _animator.GetCurrentAnimatorStateInfo(animLayer);
+        return stateInfo.IsName(stateName) && stateInfo.normalizedTime < 1.0f;
+    }
+
+    public void SetPlayerAnimation(AnimationStates newState, Action onAnimationFinish)
+    {
+        _OnAnimationFinish = onAnimationFinish;
+        SetPlayerAnimation(newState);
+    }
+
+    public void SetPlayerAnimation(AnimationStates newState)
+    {
+        if (newState == _currentAnimation)
+        {
+            return;
+        }
+        _animator.Play(PlayerHelper.GetEnumMemberValue(newState));
+        _currentAnimation = newState;
+    }
+
+    private bool IsApproximate(Quaternion q1, Quaternion q2, float precision)
+    {
+        return Mathf.Abs(Quaternion.Dot(q1, q2)) >= 1 - precision;
+    }
+}
@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: ae6d3e3aea34ae447a6aa1914a953e8e
@@ -1,38 +1,23 @@
 using Assets.Scripts.Interfaces;
-using System;
 using System.Collections.Generic;
 using UnityEngine;
-using UnityEngine.AI;

-public class BlockingAnimation : Attribute { }
-
-public class Player : MonoBehaviour
+public class Player : BaseCharacter
 {
    public static Player Instance { get; private set; }
-
-    [SerializeField]
-    public NavMeshAgent _navAgent;
-    [SerializeField]
-    public Animator _animator;
-
+    
    [SerializeField]
    private Transform _holdPoint;

    private PlayerStates _currentActing;
-    private AnimationStates _currentAnimation;

    public Dictionary<StatsId, object> Stats;
    public JobPositions JobPosition { get; set; }

    public EducationSkill Education { get; set; }

-    private readonly Queue<PlayerTasks> _tasks = new Queue<PlayerTasks>();
-    private PlayerTasks _currentTask;
-
-    private const string WALK_VELOCITY = "WalkVelocity";
-
    private ContainerItem _containerItem;
-    private Action _OnAnimationFinish;
+    
    private string _locationName;

    private void Awake()
@@ -66,143 +51,33 @@ public class Player : MonoBehaviour
        GameManager.Instance.Time.OnMinuteChanged -= UpdateStatsByClock;
    }

-    private void Update()
-    {
-        if (PlayerHelper.IsBlockingAnimation(_currentAnimation))
-        {
-            if (IsAnimationStatePlaying(0))
-            {
-                return;
-            }
-            else
-            {
-                _OnAnimationFinish?.Invoke();
-                _OnAnimationFinish = null;
-            }
-        }
-
-        if (_currentTask == null || _currentTask.Status == TaskStatus.Complete)
-        {
-            _tasks.TryDequeue(out _currentTask);
-        }
-        if (_currentTask != null)
-        {
-            if (_currentTask.Status == TaskStatus.Waiting)
-                Debug.Log($"Current task {_currentTask.Task}");
-            switch (_currentTask.Task)
-            {
-                case Tasks.Rotate:
-                    _currentTask.UpdateStatus(Rotate(_currentTask.TagretObject._interactionPoint.forward));
-                    break;
-                case Tasks.Move:
-                    if (_currentAnimation == AnimationStates.Sitting)
-                    {
-                        SetPlayerAnimation(AnimationStates.Standing);
-                        return;
-                    }
-                    _navAgent.SetDestination(_currentTask.TagretObject._interactionPoint.position);
-                    _currentTask.UpdateStatus(MoveToPoint());
-                    break;
-                case Tasks.Interact:
-                    var result = _currentTask.TagretObject.Interact(this);
-                    switch (result)
-                    {
-                        case InteractionStatus.FarFromPlayer:
-                            AddTask(new PlayerTasks(Tasks.Move, _currentTask.TagretObject));
-                            AddTask(new PlayerTasks(Tasks.Rotate, _currentTask.TagretObject));
-                            AddTask(_currentTask);
-                            _currentTask = null;
-                            break;
-                        case InteractionStatus.Complete:
-                            _currentTask.UpdateStatus(TaskStatus.Complete);
-                            break;
-                        default:
-                            break;
-                    }
-                    break;
-            }
-        }
-    }
-
    public void SetPosition(Vector3 desiredPosition)
    {
        _navAgent.Warp(desiredPosition);
        _navAgent.updatePosition = false;
    }

-    private TaskStatus MoveToPoint()
+    public void GoToPoint(BaseInteractableObject point)
    {
-        _navAgent.isStopped = false;
-        SetPlayerAnimation(AnimationStates.Walking);
-
-        _animator.SetFloat(WALK_VELOCITY, _navAgent.velocity.magnitude);
-        return IsPathComplete(_navAgent.destination) ? TaskStatus.Complete : TaskStatus.InProgress;
+        AddTask(new PlayerTasks(Tasks.Move, point));
    }
-
-    public bool IsPathComplete(Vector3 destination)
+    public async void Interact(BaseInteractableObject interactionItem)
    {
-        var dest = new Vector3(destination.x, 0, destination.z);
-        var pos = new Vector3(_navAgent.transform.position.x, 0, _navAgent.transform.position.z);
-
-        if (Vector3.Distance(dest, pos) <= _navAgent.radius)
+        var result = await interactionItem.ShowPopupMenu(this);
+        if (result != InteractionStatus.Complete)
        {
-            transform.position = destination;
-            if (!_navAgent.hasPath || _navAgent.velocity.sqrMagnitude < 0.2f)
+            if (!IsPathComplete(interactionItem._interactionPoint.position))
            {
-                SetPlayerAnimation(AnimationStates.Idle);
-                _navAgent.isStopped = true;
-                return true;
+                AddTask(new PlayerTasks(Tasks.Move, interactionItem));
+                AddTask(new PlayerTasks(Tasks.Rotate, interactionItem));
+                AddTask(new PlayerTasks(Tasks.Interact, interactionItem));
+            }
+            else
+            {
+                AddTask(new PlayerTasks(Tasks.Interact, interactionItem));
            }
        }
-
-        return false;
-    }
-
-    public TaskStatus Rotate(Vector3 target)
-    {
-        var targetRot = Quaternion.LookRotation(target);
-        Quaternion rotation = Quaternion.Slerp(transform.rotation, Quaternion.LookRotation(target), 10 * Time.deltaTime);
-        rotation.x = 0;
-        transform.rotation = rotation;
-        if (IsApproximate(targetRot, transform.rotation, 0.000004f))
-        {
-            return TaskStatus.Complete;
-        }
-        return TaskStatus.InProgress;
-    }
-
-    private bool IsApproximate(Quaternion q1, Quaternion q2, float precision)
-    {
-        return Mathf.Abs(Quaternion.Dot(q1, q2)) >= 1 - precision;
-    }
-
-    public void SetPlayerAnimation(AnimationStates newState, Action onAnimationFinish)
-    {
-        _OnAnimationFinish = onAnimationFinish;
-        SetPlayerAnimation(newState);
-    }
-
-    public void SetPlayerAnimation(AnimationStates newState)
-    {
-        if (newState == _currentAnimation)
-        {
-            return;
-        }
-        _animator.Play(PlayerHelper.GetEnumMemberValue(newState));
-        _currentAnimation = newState;
-    }
-
-    public bool IsAnimationStatePlaying(int animLayer)
-    {
-        string stateName = PlayerHelper.GetEnumMemberValue(_currentAnimation);
-        var stateInfo = _animator.GetCurrentAnimatorStateInfo(animLayer);
-        return stateInfo.IsName(stateName) && stateInfo.normalizedTime < 1.0f;
-    }
-
-    public void AddTask(PlayerTasks task)
-    {
-        _tasks.Enqueue(task);
-    }
+    }   

    public void SetPlayerActing(PlayerStates state)
    {