[WIP] Animation system

Assets/Content/WorldObjects/DummyAnimationTestsObjects/CircleSinusoidalMotion.cs

@@ -0,0 +1,26 @@
+using UnityEngine;
+
+public class CircleSinusoidalMotion : MonoBehaviour
+{
+    public float radius = 5f;        // Radius of the circular motion
+    public float speed = 1f;         // Speed of the motion
+    public float minHeight = 1f;     // Minimum height of the sinusoidal motion
+    public float maxHeight = 3f;     // Maximum height of the sinusoidal motion
+    public float waveFrequency = 4f; // Frequency of the sinusoidal motion
+
+    private float angle = 0f;
+
+    void Update()
+    {
+        // Increment angle based on speed
+        angle += speed * Time.deltaTime;
+
+        // Calculate position using sine and cosine functions
+        float x = Mathf.Cos(angle) * radius;
+        float y = Mathf.Lerp(minHeight, maxHeight, Mathf.Sin(angle * waveFrequency) * 0.5f + 0.5f); // Dynamically adjust height
+        float z = Mathf.Sin(angle) * radius;
+
+        // Update the position of the GameObject
+        transform.position = new Vector3(x, y, z);
+    }
+}

Assets/Content/WorldObjects/DummyAnimationTestsObjects/CoroutineHelper.cs

@@ -0,0 +1,57 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+
+public static class CoroutineHelper
+{
+
+
+    public static IEnumerator ModifyValueOverTime(Action<float> value,
+        float startValue, float endValue, float time)
+    {
+        float elapsedTime = 0f;
+
+        while (elapsedTime < time)
+        {
+            value(startValue + (endValue-startValue)*(elapsedTime/time));
+            elapsedTime += Time.deltaTime;
+            yield return null;
+        }
+
+        // Ensure the value reaches the target value exactly
+        value(endValue);
+    }
+
+    public static IEnumerator ModifyVector3OverTime(Action<Vector3> value,
+        Vector3 startValue, Vector3 endValue, float time)
+    {
+        float elapsedTime = 0f;
+
+        while (elapsedTime < time)
+        {
+            value(startValue + (endValue-startValue)*(elapsedTime/time));
+            elapsedTime += Time.deltaTime;
+            yield return null;
+        }
+
+        // Ensure the value reaches the target value exactly
+        value(endValue);
+    }
+
+    public static IEnumerator ModifyQuaternionOverTime(Action<Quaternion> value,
+        Quaternion startValue, Quaternion endValue, float time)
+    {
+        float elapsedTime = 0f;
+
+        while (elapsedTime < time)
+        {
+            value(Quaternion.Slerp(startValue, endValue, elapsedTime/time));
+            elapsedTime += Time.deltaTime;
+            yield return null;
+        }
+
+        // Ensure the value reaches the target value exactly
+        value(endValue);
+    }
+}

Assets/Content/WorldObjects/DummyAnimationTestsObjects/DummyAim.cs

@@ -0,0 +1,119 @@
+using Coimbra;
+using System;
+using UnityEngine;
+using UnityEngine.Animations.Rigging;
+
+namespace DummyStuff
+{
+    public sealed class DummyAim : MonoBehaviour
+    {
+
+        public Transform aimTarget;
+
+        public DummyHands hands;
+
+        public IntentController intents;
+
+        public HoldController holdController;
+
+        public Rig bodyAimRig;
+
+        public float rotationSpeed = 5f;
+
+        public bool canAim;
+
+        public bool isAiming;
+
+        public event EventHandler<bool> OnAim; 
+
+        [SerializeField]
+        private DummyMovement movementController;
+
+
+        private void Update()
+        {
+            UpdateAimAbility(hands.SelectedHand);
+
+            if (canAim && Input.GetMouseButton(1))
+            {
+                UpdateAimTargetPosition();
+
+                if (!isAiming)
+                {
+                    Aim(hands.SelectedHand, hands.SelectedHand.Item.GameObject.GetComponent<DummyGun>());
+                    isAiming = true;
+                }
+
+                if (GetComponent<DummyPositionController>().Position != PositionType.Sitting)
+                {
+                    movementController.RotatePlayerTowardTarget();
+                }
+            }
+            else if (isAiming && (!canAim || !Input.GetMouseButton(1)))
+            {
+                StopAiming(hands.SelectedHand);
+            }
+
+
+
+            if (Input.GetKey(KeyCode.E) && hands.SelectedHand.Full 
+                && isAiming && hands.SelectedHand.Item.GameObject.TryGetComponent(out DummyGun gun))
+            {
+                gun.GetComponent<DummyFire>().Fire();
+            }
+
+        }
+
+        private void Aim(DummyHand hand, DummyGun gun)
+        {
+            bodyAimRig.weight = 0.3f;
+            gun.transform.parent = hands.SelectedHand.shoulderWeaponPivot;
+
+            // position correctly the gun on the shoulder, assuming the rifle butt transform is defined correctly
+            gun.transform.localPosition = -gun.rifleButt.localPosition;
+            gun.transform.localRotation = Quaternion.identity;
+            OnAim?.Invoke(this, true);
+        }
+
+        private void StopAiming(DummyHand hand)
+        {
+            isAiming = false;
+            bodyAimRig.weight = 0f;
+
+            if (!hand.Full)
+                return;
+
+            hand.Item.GameObject.transform.parent = hand.itemPositionTargetLocker;
+            holdController.UpdateItemPositionConstraintAndRotation(hand, hand.Item,
+                true, 0.25f, false);
+            hand.Item.GameObject.transform.localPosition = Vector3.zero;
+            hand.Item.GameObject.transform.localRotation = Quaternion.identity;
+            OnAim?.Invoke(this, false);
+        }
+
+        private void UpdateAimAbility(DummyHand selectedHand)
+        {
+            if (intents.Intent == Intent.Harm && selectedHand.Full
+                && selectedHand.Item.GameObject.HasComponent<DummyGun>())
+            {
+                canAim = true;
+            }
+            else
+            {
+                canAim = false;
+            }
+        }
+
+        private void UpdateAimTargetPosition()
+        {
+            // Cast a ray from the mouse position into the scene
+            Ray ray = Camera.main.ScreenPointToRay(Input.mousePosition);
+
+            // Check if the ray hits any collider
+            if (Physics.Raycast(ray, out RaycastHit hit))
+            {
+                aimTarget.position = hit.point;
+            }
+        }
+    }
+}