Organize custom scripts under Assets/Baba_yaga and merge Opsive folders to Assets root

Assets/Scripts/Character/Abilities/RestrictRotation.cs

@@ -0,0 +1,96 @@
+/// ---------------------------------------------
+/// Ultimate Character Controller
+/// Copyright (c) Opsive. All Rights Reserved.
+/// https://www.opsive.com
+/// ---------------------------------------------
+
+namespace Opsive.UltimateCharacterController.Character.Abilities
+{
+    using Opsive.Shared.Events;
+    using Opsive.UltimateCharacterController.Utility;
+    using UnityEngine;
+
+    /// <summary>
+    /// The RestrictPosition ability restricts the character to the specified rotation.
+    /// </summary>
+    [DefaultStartType(AbilityStartType.Automatic)]
+    [DefaultStopType(AbilityStopType.Manual)]
+    public class RestrictRotation : Ability
+    {
+        [Tooltip("The number of degrees that the character can rotate between.")]
+        [SerializeField] protected float m_Restriction = 45f;
+        [Tooltip("Any offset that should be applied to the local y rotation.")]
+        [SerializeField] protected float m_Offset;
+        [Tooltip("Should the local y rotation of the look source be applied to the rotation?")]
+        [SerializeField] protected bool m_RelativeLookSourceRotation;
+        [Tooltip("Any offset that should be applied to the look source y rotation.")]
+        [SerializeField] protected float m_LookSourceOffset;
+
+        public float Restriction { get { return m_Restriction; } set { m_Restriction = value; } }
+        public float Offset { get { return m_Offset; } set { m_Offset = value; } }
+        public bool RelativeLookSourceRotation { get { return m_RelativeLookSourceRotation; } set { m_RelativeLookSourceRotation = value; } }
+        public float LookSourceOffset { get { return m_LookSourceOffset; } set { m_LookSourceOffset = value; } }
+
+        private ILookSource m_LookSource;
+
+        public override bool IsConcurrent { get { return true; } }
+
+        /// <summary>
+        /// Initialize the default values.
+        /// </summary>
+        public override void Awake()
+        {
+            base.Awake();
+
+            // The look source may have already been assigned if the ability was added to the character after the look source was assigned.
+            m_LookSource = m_CharacterLocomotion.LookSource;
+            EventHandler.RegisterEvent<ILookSource>(m_GameObject, "OnCharacterAttachLookSource", OnAttachLookSource);
+        }
+
+        /// <summary>
+        /// A new ILookSource object has been attached to the character.
+        /// </summary>
+        /// <param name="lookSource">The ILookSource object attached to the character.</param>
+        private void OnAttachLookSource(ILookSource lookSource)
+        {
+            m_LookSource = lookSource;
+        }
+
+        /// <summary>
+        /// Verify the rotation values. Called immediately before the rotation is applied.
+        /// </summary>
+        public override void ApplyRotation()
+        {
+            var targetRotation = m_Transform.rotation * Quaternion.Euler(m_CharacterLocomotion.DeltaRotation);
+            var localTargetRotation = MathUtility.InverseTransformQuaternion(Quaternion.LookRotation(Vector3.forward, m_CharacterLocomotion.Up), targetRotation);
+
+            // Find the closest angle to the degree restriction.
+            var localEulerRotation = localTargetRotation.eulerAngles;
+            var offset = m_Offset;
+
+            // The rotation can be applied based on the look source angle.
+            if (m_RelativeLookSourceRotation) {
+                var localLookSourceRotation = MathUtility.InverseTransformQuaternion(Quaternion.LookRotation(Vector3.forward, m_CharacterLocomotion.Up), m_LookSource.Transform.rotation);
+                offset += (localLookSourceRotation.eulerAngles.y + m_LookSourceOffset);
+            }
+
+            // Set the restricted rotation.
+            localEulerRotation.y = MathUtility.ClampAngle(Mathf.Round((localEulerRotation.y - offset) / m_Restriction) * m_Restriction) + offset;
+
+            // Rotate towards the restricted angle.
+            targetRotation = MathUtility.TransformQuaternion(Quaternion.LookRotation(Vector3.forward, m_CharacterLocomotion.Up), Quaternion.Euler(localEulerRotation));
+            targetRotation = Quaternion.Slerp(m_Transform.rotation, targetRotation, m_CharacterLocomotion.MotorRotationSpeed * Time.deltaTime);
+            m_CharacterLocomotion.Torque = targetRotation * Quaternion.Inverse(m_Transform.rotation);
+        }
+
+        /// <summary>
+        /// The object has been destroyed.
+        /// </summary>
+        public override void OnDestroy()
+        {
+            base.OnDestroy();
+
+            EventHandler.UnregisterEvent<ILookSource>(m_GameObject, "OnCharacterAttachLookSource", OnAttachLookSource);
+        }
+    }
+}