move bunch of things to depricated folder

.DepricatedMods/AlternateIKSystem/IK/IKHandlers/IKHandler.cs

@@ -0,0 +1,170 @@
+using ABI.CCK.Components;
+using NAK.AlternateIKSystem.VRIKHelpers;
+using RootMotion.FinalIK;
+using UnityEngine;
+
+namespace NAK.AlternateIKSystem.IK.IKHandlers;
+
+internal abstract class IKHandler
+{
+    #region Variables
+
+    internal VRIK _vrik;
+    internal IKSolverVR _solver;
+
+    internal bool shouldTrackAll = true;
+    internal bool shouldTrackHead = true;
+    internal bool shouldTrackLeftArm = true;
+    internal bool shouldTrackRightArm = true;
+    internal bool shouldTrackLeftLeg = true;
+    internal bool shouldTrackRightLeg = true;
+    internal bool shouldTrackPelvis = true;
+    internal bool shouldTrackLocomotion = true;
+
+    // VRIK Calibration Info
+    internal VRIKLocomotionData _locomotionData;
+
+    // Last Movement Parent Info
+    internal Vector3 _movementPosition;
+    internal Quaternion _movementRotation;
+    internal CVRMovementParent _movementParent;
+
+    // Solver Info
+    internal float _scaleDifference = 1f;
+    internal float _locomotionWeight = 1f;
+    internal float _ikSimulatedRootAngle;
+    internal bool _wasTrackingLocomotion;
+
+    #endregion
+
+    #region Virtual Game Methods
+
+    public virtual void OnInitializeIk() { }
+
+    public virtual void OnPlayerScaled(float scaleDifference)
+    {
+        VRIKUtils.ApplyScaleToVRIK
+        (
+            _vrik,
+            _locomotionData,
+            _scaleDifference = scaleDifference
+        );
+    }
+
+    public virtual void OnPlayerHandleMovementParent(CVRMovementParent currentParent, Vector3 platformPivot)
+    {
+        Vector3 currentPosition = currentParent._referencePoint.position;
+        Quaternion currentRotation = Quaternion.Euler(0f, currentParent.transform.rotation.eulerAngles.y, 0f);
+
+        Vector3 deltaPosition = currentPosition - _movementPosition;
+        Quaternion deltaRotation = Quaternion.Inverse(_movementRotation) * currentRotation;
+
+        if (_movementParent == currentParent)
+        {
+            _solver.AddPlatformMotion(deltaPosition, deltaRotation, platformPivot);
+            _ikSimulatedRootAngle = Mathf.Repeat(_ikSimulatedRootAngle + deltaRotation.eulerAngles.y, 360f);
+        }
+
+        _movementParent = currentParent;
+        _movementPosition = currentPosition;
+        _movementRotation = currentRotation;
+    }
+
+    #endregion
+
+    #region Virtual IK Weights
+
+    public virtual void UpdateWeights()
+    {
+        if (!shouldTrackAll)
+            return;
+
+        if (shouldTrackHead)
+            Update_HeadWeight();
+
+        if (shouldTrackLeftArm)
+            Update_LeftArmWeight();
+
+        if (shouldTrackRightArm)
+            Update_RightArmWeight();
+
+        if (shouldTrackLeftLeg)
+            Update_LeftLegWeight();
+
+        if (shouldTrackRightLeg)
+            Update_RightLegWeight();
+
+        if (shouldTrackPelvis)
+            Update_PelvisWeight();
+
+        if (shouldTrackLocomotion)
+        {
+            Update_LocomotionWeight();
+            ResetSolverIfNeeded();
+        }
+
+        Update_IKPositionWeight();
+    }
+
+    protected virtual void Update_HeadWeight()
+    {
+        float targetWeight = GetTargetWeight(BodyControl.TrackingHead, true);
+    }
+
+    protected virtual void Update_LeftArmWeight()
+    {
+        float leftArmWeight = GetTargetWeight(BodyControl.TrackingLeftArm, _solver.leftArm.target != null);
+    }
+
+    protected virtual void Update_RightArmWeight()
+    {
+        float rightArmWeight = GetTargetWeight(BodyControl.TrackingRightArm, _solver.rightArm.target != null);
+    }
+
+    protected virtual void Update_LeftLegWeight()
+    {
+        float leftLegWeight = GetTargetWeight(BodyControl.TrackingLeftLeg, _solver.leftLeg.target != null);
+    }
+
+    protected virtual void Update_RightLegWeight()
+    {
+        float rightLegWeight = GetTargetWeight(BodyControl.TrackingRightLeg, _solver.rightLeg.target != null);
+    }
+
+    protected virtual void Update_PelvisWeight()
+    {
+        float pelvisWeight = GetTargetWeight(BodyControl.TrackingPelvis, _solver.spine.pelvisTarget != null);
+    }
+
+    protected virtual void Update_LocomotionWeight()
+    {
+        _locomotionWeight = Mathf.Lerp(_locomotionWeight, BodyControl.TrackingLocomotion ? 1f : 0f,
+            Time.deltaTime * ModSettings.EntryIKLerpSpeed.Value * 2f);
+    }
+
+    protected virtual void Update_IKPositionWeight()
+    {
+        float ikPositionWeight = BodyControl.TrackingAll ? BodyControl.TrackingIKPositionWeight : 0f;
+    }
+
+    protected virtual float GetTargetWeight(bool isTracking, bool hasTarget)
+    {
+        return isTracking && hasTarget ? 1f : 0f;
+    }
+
+    #endregion
+
+    #region Private Methods
+
+    private void ResetSolverIfNeeded()
+    {
+        if (_wasTrackingLocomotion == BodyControl.TrackingLocomotion)
+            return;
+
+        _wasTrackingLocomotion = BodyControl.TrackingLocomotion;
+        VRIKUtils.ResetToInitialFootsteps(_vrik, _locomotionData, _scaleDifference);
+        _solver.Reset();
+    }
+
+    #endregion
+}

.DepricatedMods/AlternateIKSystem/IK/IKHandlers/IKHandlerDesktop.cs

@@ -0,0 +1,80 @@
+using NAK.AlternateIKSystem.IK.WeightManipulators;
+using RootMotion.FinalIK;
+using UnityEngine;
+
+namespace NAK.AlternateIKSystem.IK.IKHandlers;
+
+internal class IKHandlerDesktop : IKHandler
+{
+    public IKHandlerDesktop(VRIK vrik)
+    {
+        _vrik = vrik;
+        _solver = vrik.solver;
+    }
+
+    #region Game Overrides
+
+    public override void OnInitializeIk()
+    {
+        _vrik.onPreSolverUpdate.AddListener(OnPreSolverUpdateDesktop);
+    }
+
+    #endregion
+
+    #region Weight Overrides
+
+    public override void UpdateWeights()
+    {
+        // Reset avatar local position
+        _vrik.transform.localPosition = Vector3.zero;
+        _vrik.transform.localRotation = Quaternion.identity;
+    }
+
+    #endregion
+
+    #region VRIK Solver Events
+
+    private void OnPreSolverUpdateDesktop()
+    {
+        _solver.plantFeet = ModSettings.EntryPlantFeet.Value;
+
+        // Emulate old VRChat hip movement
+        if (ModSettings.EntryBodyLeanWeight.Value > 0)
+        {
+            float weightedAngle = ModSettings.EntryProneThrusting.Value ? 1f : ModSettings.EntryBodyLeanWeight.Value * _solver.locomotion.weight;
+            float angle = IKManager.Instance._desktopCamera.localEulerAngles.x;
+            angle = angle > 180 ? angle - 360 : angle;
+            Quaternion rotation = Quaternion.AngleAxis(angle * weightedAngle, _vrik.transform.right);
+            _solver.spine.headRotationOffset *= rotation;
+        }
+
+        // Make root heading follow within a set limit
+        if (ModSettings.EntryBodyHeadingLimit.Value > 0)
+        {
+            float weightedAngleLimit = ModSettings.EntryBodyHeadingLimit.Value * _solver.locomotion.weight;
+            float deltaAngleRoot = Mathf.DeltaAngle(IKManager.Instance.transform.eulerAngles.y, _ikSimulatedRootAngle);
+            float absDeltaAngleRoot = Mathf.Abs(deltaAngleRoot);
+
+            if (absDeltaAngleRoot > weightedAngleLimit)
+            {
+                deltaAngleRoot = Mathf.Sign(deltaAngleRoot) * weightedAngleLimit;
+                _ikSimulatedRootAngle = Mathf.MoveTowardsAngle(_ikSimulatedRootAngle, IKManager.Instance.transform.eulerAngles.y, absDeltaAngleRoot - weightedAngleLimit);
+            }
+
+            _solver.spine.rootHeadingOffset = deltaAngleRoot;
+
+            if (ModSettings.EntryPelvisHeadingWeight.Value > 0)
+            {
+                _solver.spine.pelvisRotationOffset *= Quaternion.Euler(0f, deltaAngleRoot * ModSettings.EntryPelvisHeadingWeight.Value, 0f);
+                _solver.spine.chestRotationOffset *= Quaternion.Euler(0f, -deltaAngleRoot * ModSettings.EntryPelvisHeadingWeight.Value, 0f);
+            }
+
+            if (ModSettings.EntryChestHeadingWeight.Value > 0)
+            {
+                _solver.spine.chestRotationOffset *= Quaternion.Euler(0f, deltaAngleRoot * ModSettings.EntryChestHeadingWeight.Value, 0f);
+            }
+        }
+    }
+
+    #endregion
+}

.DepricatedMods/AlternateIKSystem/IK/IKHandlers/IKHandlerHalfBody.cs

@@ -0,0 +1,48 @@
+using NAK.AlternateIKSystem.IK.WeightManipulators;
+using RootMotion.FinalIK;
+using UnityEngine;
+
+namespace NAK.AlternateIKSystem.IK.IKHandlers;
+
+internal class IKHandlerHalfBody : IKHandler
+{
+    public IKHandlerHalfBody(VRIK vrik)
+    {
+        _vrik = vrik;
+        _solver = vrik.solver;
+    }
+
+    #region Game Overrides
+
+    public override void OnInitializeIk()
+    {
+        _vrik.onPreSolverUpdate.AddListener(OnPreSolverUpdateHalfBody);
+    }
+
+    #endregion
+
+    #region VRIK Solver Events
+
+    private void OnPreSolverUpdateHalfBody()
+    {
+        _solver.plantFeet = ModSettings.EntryPlantFeet.Value;
+
+        // Make root heading follow within a set limit
+        if (ModSettings.EntryBodyHeadingLimit.Value > 0)
+        {
+            float weightedAngleLimit = ModSettings.EntryBodyHeadingLimit.Value * _solver.locomotion.weight;
+            float currentRotation = IKManager.Instance.GetPlayerRotation().y;
+            float deltaAngleRoot = Mathf.DeltaAngle(currentRotation, _ikSimulatedRootAngle);
+
+            if (Mathf.Abs(deltaAngleRoot) > weightedAngleLimit)
+            {
+                deltaAngleRoot = Mathf.Sign(deltaAngleRoot) * weightedAngleLimit;
+                _ikSimulatedRootAngle = Mathf.MoveTowardsAngle(_ikSimulatedRootAngle, currentRotation, Mathf.Abs(deltaAngleRoot) - weightedAngleLimit);
+            }
+
+            _solver.spine.rootHeadingOffset = deltaAngleRoot;
+        }
+    }
+
+    #endregion
+}