Enhanced ClimbHandController functionality with improved and robust animation handling.

Assets/Scripts/Interact/ClimbHandController.cs

@@ -4,43 +4,56 @@ using UnityEngine;
 /// <summary>
 /// Drives visibility, position, and animation of the FPS climb hand.
 ///
-/// Default state: hidden, snapped to <see cref="handRestPos"/>, Animator on the Idle state.
+/// Default state: hidden, PARENTED to <see cref="handRestPos"/> (local identity), Animator on Idle.
 ///
 /// Flow (all driven by events from <see cref="PlayerMovement"/>, no polling):
 ///   1. Climb prompt appears (player looks at a climbable wall while airborne)
-///      -> hand becomes visible at handRestPos, tweens to fpsHandPos over <see cref="moveDuration"/>.
+///      -> hand becomes visible, unparents, tweens handRestPos -> fpsHandPos over moveDuration,
+///         then re-parents to fpsHandPos (so it stays locked to it, e.g. if it sways with the camera).
 ///   2. Player actually sticks to the wall (ClimbKey pressed & leap completes)
-///      -> crossfade to the stick animation, play once, freeze on its last frame.
+///      -> hand unparents and is positioned at the wall hit point (+ a small right-hand offset),
+///         crossfades to the stick animation, plays once, freezes on the last frame.
 ///   3. Wall stick ends (timer ran out, key toggled off, wall jump, grounded, etc.)
-///      -> crossfade back to Idle, tween hand from fpsHandPos back to handRestPos, then hide.
+///      -> crossfade back to Idle, tween wall-position -> handRestPos, then re-parent + hide.
 ///   4. Climb prompt disappears without ever sticking (player looked away)
-///      -> tween back to handRestPos and hide, same as above.
+///      -> tween back to handRestPos, re-parent, hide. Same as #3 minus the animation swap.
 /// </summary>
 public class ClimbHandController : MonoBehaviour
 {
     [Header("References")]
     [Tooltip("The PlayerMovement script driving climb state. Auto-found on parent/scene if left empty.")]
     [SerializeField] private PlayerMovement playerMovement;
-    [Tooltip("Renderers to toggle for visibility (e.g. the hand's SkinnedMeshRenderer). All are found in children automatically if left empty.")]
+    [Tooltip("Renderers to toggle for visibility. Auto-found in children if left empty.")]
     [SerializeField] private Renderer[] handRenderers;
-    [Tooltip("Animator on the hand prefab (Idle R Hand = default state).")]
+    [Tooltip("Animator component ON THE HAND PREFAB (drag the hand GameObject itself, not the Controller asset - the Controller asset must already be assigned inside that Animator's own Controller slot).")]
     [SerializeField] private Animator handAnimator;
-    [Tooltip("Empty transform: where the hand sits/hides when not climbing.")]
+    [Tooltip("Empty transform: where the hand parents/hides when not climbing.")]
     [SerializeField] private Transform handRestPos;
-    [Tooltip("Empty transform: where the hand moves to while showing/climbing.")]
+    [Tooltip("Empty transform: where the hand parents while the climb prompt is shown / before sticking.")]
     [SerializeField] private Transform fpsHandPos;
 
+    [Header("Wall Stick Offset")]
+    [Tooltip("Local offset applied at the wall-stick position, along the player's right vector (positive = right). Since this is currently a right-hand-only prefab.")]
+    [SerializeField] private float rightHandOffset = 0.15f;
+    [Tooltip("Additional offset along the wall normal (positive = away from the wall, prevents clipping).")]
+    [SerializeField] private float wallNormalOffset = 0.05f;
+
     [Header("Animator State Names")]
+    [Tooltip("Must exactly match the state name in the Animator Controller's Base Layer (index 0).")]
     [SerializeField] private string idleStateName = "Idle R Hand";
     [SerializeField] private string stickStateName = "stckHandR 1";
+    [SerializeField] private int animatorLayer = 0;
 
     [Header("Timing")]
     [Tooltip("How long the hand takes to move between rest and FPS position.")]
     [SerializeField] private float moveDuration = 0.7f;
-    [SerializeField] private float animCrossfadeDuration = 0.15f;
+    [SerializeField] private float animCrossfadeDuration = 0.1f;
+
+    [Header("Debug")]
+    [SerializeField] private bool debugLogging = false;
 
     private Coroutine moveRoutine;
-    private Coroutine stickWatchRoutine;
+    private Coroutine stickAnimRoutine;
     private bool isVisible;
 
     private void Reset()
@@ -56,6 +69,11 @@ public class ClimbHandController : MonoBehaviour
         if (playerMovement == null) playerMovement = FindObjectOfType<PlayerMovement>();
         if (handAnimator == null) handAnimator = GetComponentInChildren<Animator>();
         if (handRenderers == null || handRenderers.Length == 0) handRenderers = GetComponentsInChildren<Renderer>();
+
+        if (handAnimator == null)
+            Debug.LogWarning("[ClimbHandController] No Animator found/assigned. Animations will not play.");
+        else if (handAnimator.runtimeAnimatorController == null)
+            Debug.LogWarning("[ClimbHandController] The assigned Animator has no Controller asset plugged into it. Assign the Animator Controller on the Animator component itself (not on this script).");
     }
 
     private void OnEnable()
@@ -84,88 +102,83 @@ public class ClimbHandController : MonoBehaviour
         }
 
         if (moveRoutine != null) StopCoroutine(moveRoutine);
-        if (stickWatchRoutine != null) StopCoroutine(stickWatchRoutine);
+        if (stickAnimRoutine != null) StopCoroutine(stickAnimRoutine);
     }
 
     // --- Event Handlers -----------------------------------------------------
 
     private void HandleClimbPromptChanged(bool shown)
     {
-        // If we're already mid-stick, the prompt hiding/showing doesn't matter - the stick events own the hand.
-        if (playerMovement.IsWallSticking) return;
+        if (playerMovement.IsWallSticking) return; // stick events own the hand while sticking
 
-        if (shown)
-        {
-            ShowAndMoveToFPS();
-        }
-        else
-        {
-            MoveToRestThenHide();
-        }
+        if (shown) ShowAndMoveToFPS();
+        else MoveToRestThenHide();
     }
 
-    private void HandleWallStickStarted()
+    private void HandleWallStickStarted(Vector3 wallHitPoint, Vector3 wallNormal)
     {
-        // Make sure we're visible and at the FPS position (in case events raced), then play the stick anim.
+        Log("Wall stick started - positioning at wall hit point.");
+
+        if (moveRoutine != null) { StopCoroutine(moveRoutine); moveRoutine = null; }
+
         SetVisible(true);
-        if (moveRoutine != null) StopCoroutine(moveRoutine);
-        transform.position = fpsHandPos.position;
-        transform.rotation = fpsHandPos.rotation;
+        transform.SetParent(null, true);
 
-        PlayStickAnimationAndFreeze();
+        // Position at the wall hit point, pushed slightly off the surface, offset to the player's right
+        // so a right-hand-only prefab reads correctly on the wall.
+        Vector3 rightAxis = playerMovement.Orient != null ? playerMovement.Orient.right : transform.right;
+        Vector3 targetPos = wallHitPoint + wallNormal * wallNormalOffset + rightAxis * rightHandOffset;
+        Quaternion targetRot = Quaternion.LookRotation(-wallNormal, rightAxis);
 
-        // Watch the countdown so the hand releases the instant the timer hits zero,
-        // even if PlayerMovement ends the stick for a different reason too (both paths call EndWallStick).
-        if (stickWatchRoutine != null) StopCoroutine(stickWatchRoutine);
-        stickWatchRoutine = StartCoroutine(WatchStickTimer());
+        transform.position = targetPos;
+        transform.rotation = targetRot;
+
+        PlayStickAnimationAndFreeze();
     }
 
     private void HandleWallStickEnded()
     {
-        if (stickWatchRoutine != null)
-        {
-            StopCoroutine(stickWatchRoutine);
-            stickWatchRoutine = null;
-        }
+        Log("Wall stick ended - returning to idle and rest position.");
+
+        if (stickAnimRoutine != null) { StopCoroutine(stickAnimRoutine); stickAnimRoutine = null; }
 
         ReturnToIdleAnimation();
         MoveToRestThenHide();
     }
 
-    private IEnumerator WatchStickTimer()
-    {
-        // Purely observational - PlayerMovement owns the authoritative timer and calls EndWallStick()
-        // itself when it hits zero, which triggers HandleWallStickEnded() above. This coroutine exists
-        // only in case you want per-frame hand feedback (e.g. shake) later; it does not end the stick itself.
-        while (playerMovement.IsWallSticking)
-        {
-            yield return null;
-        }
-    }
-
-    // --- Movement / Visibility -----------------------------------------------
+    // --- Movement / Parenting -----------------------------------------------
 
     private void ShowAndMoveToFPS()
     {
         SetVisible(true);
-        StartMove(handRestPos, fpsHandPos, () => { });
+        transform.SetParent(null, true); // unparent from rest so we can tween in world space
+        StartMove(transform.position, transform.rotation, fpsHandPos, () =>
+        {
+            // Lock to fpsHandPos so it tracks it (e.g. if it sways with camera bob).
+            transform.SetParent(fpsHandPos, true);
+            transform.localPosition = Vector3.zero;
+            transform.localRotation = Quaternion.identity;
+        });
     }
 
     private void MoveToRestThenHide()
     {
-        // If already hidden, nothing to do.
         if (!isVisible) return;
 
-        StartMove(transform, handRestPos, () =>
+        transform.SetParent(null, true);
+        StartMove(transform.position, transform.rotation, handRestPos, () =>
         {
+            transform.SetParent(handRestPos, true);
+            transform.localPosition = Vector3.zero;
+            transform.localRotation = Quaternion.identity;
             SetVisible(false);
         });
     }
 
-    private void StartMove(Transform from, Transform to, System.Action onComplete)
+    private void StartMove(Vector3 fromPos, Quaternion fromRot, Transform target, System.Action onComplete)
     {
         if (moveRoutine != null) StopCoroutine(moveRoutine);
-        moveRoutine = StartCoroutine(MoveRoutine(from.position, from.rotation, to, onComplete));
+        moveRoutine = StartCoroutine(MoveRoutine(fromPos, fromRot, target, onComplete));
     }
 
     private IEnumerator MoveRoutine(Vector3 startPos, Quaternion startRot, Transform target, System.Action onComplete)
@@ -202,12 +215,13 @@ public class ClimbHandController : MonoBehaviour
 
     private void SnapToRestAndHide()
     {
-        if (moveRoutine != null) StopCoroutine(moveRoutine);
+        if (moveRoutine != null) { StopCoroutine(moveRoutine); moveRoutine = null; }
 
         if (handRestPos != null)
         {
-            transform.position = handRestPos.position;
-            transform.rotation = handRestPos.rotation;
+            transform.SetParent(handRestPos, true);
+            transform.localPosition = Vector3.zero;
+            transform.localRotation = Quaternion.identity;
         }
 
         SetVisible(false);
@@ -218,30 +232,54 @@ public class ClimbHandController : MonoBehaviour
 
     private void PlayStickAnimationAndFreeze()
     {
-        if (handAnimator == null) return;
-        StopAllCoroutines_AnimOnly();
-        StartCoroutine(PlayStickRoutine());
+        if (handAnimator == null)
+        {
+            Log("Cannot play stick animation - no Animator assigned/found.");
+            return;
+        }
+
+        if (stickAnimRoutine != null) StopCoroutine(stickAnimRoutine);
+        stickAnimRoutine = StartCoroutine(PlayStickRoutine());
     }
 
     private IEnumerator PlayStickRoutine()
     {
-        handAnimator.CrossFadeInFixedTime(stickStateName, animCrossfadeDuration);
+        handAnimator.speed = 1f;
+        handAnimator.CrossFadeInFixedTime(stickStateName, animCrossfadeDuration, animatorLayer);
 
-        // Wait a frame so the crossfade actually starts and state info updates.
-        yield return null;
-        yield return null;
+        // Wait for the crossfade to finish and confirm we actually landed on the target state.
+        // (During the crossfade itself, GetCurrentAnimatorStateInfo may still report the previous state.)
+        float safetyTimer = 0f;
+        const float safetyLimit = 2f;
 
-        AnimatorStateInfo state = handAnimator.GetCurrentAnimatorStateInfo(0);
+        while (!handAnimator.GetCurrentAnimatorStateInfo(animatorLayer).IsName(stickStateName))
+        {
+            safetyTimer += Time.deltaTime;
+            if (safetyTimer > safetyLimit)
+            {
+                Debug.LogWarning($"[ClimbHandController] Timed out waiting to enter state '{stickStateName}'. " +
+                                  "Check that the Animator state name matches EXACTLY (case-sensitive) and lives on layer " + animatorLayer + ".");
+                yield break;
+            }
+            yield return null;
+        }
 
-        // Wait until the clip has played through once (normalizedTime >= 1), then freeze it there.
-        while (state.normalizedTime < 1f && handAnimator.GetCurrentAnimatorStateInfo(0).IsName(stickStateName))
+        Log($"Entered '{stickStateName}', playing until it completes.");
+
+        // Play forward until the clip completes once.
+        AnimatorStateInfo state = handAnimator.GetCurrentAnimatorStateInfo(animatorLayer);
+        while (state.normalizedTime < 1f)
         {
-            state = handAnimator.GetCurrentAnimatorStateInfo(0);
             yield return null;
+            state = handAnimator.GetCurrentAnimatorStateInfo(animatorLayer);
+
+            // If something transitioned us away (e.g. Any State override), bail safely.
+            if (!state.IsName(stickStateName)) yield break;
         }
 
-        // Freeze on the last frame by stopping playback (speed 0) once it has reached the end.
+        // Freeze on the last frame.
         handAnimator.speed = 0f;
+        Log($"'{stickStateName}' finished - frozen on last frame.");
     }
 
     private void ReturnToIdleAnimation(bool instant = false)
@@ -252,17 +290,16 @@ public class ClimbHandController : MonoBehaviour
 
         if (instant)
         {
-            handAnimator.Play(idleStateName, 0, 0f);
+            handAnimator.Play(idleStateName, animatorLayer, 0f);
         }
         else
         {
-            handAnimator.CrossFadeInFixedTime(idleStateName, animCrossfadeDuration);
+            handAnimator.CrossFadeInFixedTime(idleStateName, animCrossfadeDuration, animatorLayer);
         }
     }
 
-    private void StopAllCoroutines_AnimOnly()
+    private void Log(string msg)
     {
-        // Placeholder hook kept separate from movement coroutines in case anim playback
-        // needs independent cancellation later without touching position tweening.
+        if (debugLogging) Debug.Log($"[ClimbHandController] {msg}");
     }
 }

Assets/Scripts/PlayerMovement.cs

@@ -12,12 +12,14 @@ public class PlayerMovement : MonoBehaviour
     // Fired when the climb prompt becomes visible/hidden (i.e. player is looking at a climbable wall while airborne).
     public event Action<bool> OnClimbPromptChanged;
     // Fired the moment the player actually sticks to the wall (after the leap finishes).
-    public event Action OnWallStickStarted;
+    // Passes the wall hit point and wall normal so external systems (e.g. hand IK) can position themselves.
+    public event Action<Vector3, Vector3> OnWallStickStarted;
     // Fired the moment wall sticking ends, for ANY reason (grounded, key toggle, wall jump, or timer running out).
     public event Action OnWallStickEnded;
     // Current normalized stick time remaining (1 = full, 0 = about to fall). Read-only for consumers.
     public float StickTimeRemaining01 => maxStickTime > 0f ? Mathf.Clamp01(stickTimer / maxStickTime) : 0f;
     public bool IsWallSticking => isWallSticking;
+    public Transform Orient => orient;
 
     [Header("Movement")]
     public float baseMoveSpeed = 8f;
@@ -380,7 +382,7 @@ public class PlayerMovement : MonoBehaviour
             wallTimerFillImage.color = normalTimerColor;
         }
 
-        OnWallStickStarted?.Invoke();
+        OnWallStickStarted?.Invoke(wallHitPoint, wallNormal);
     }
 
     private void EndWallStick()