845 lines
23 KiB
C#
845 lines
23 KiB
C#
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
using System.Linq;
|
|
using RootMotion.FinalIK;
|
|
using UnityEngine;
|
|
using UnityStandardAssets.Characters.FirstPerson;
|
|
|
|
public class FullBodyAvatar : MonoBehaviour
|
|
{
|
|
public enum AnimatorLayers
|
|
{
|
|
Movement = 0,
|
|
ThirdPersonView = 1,
|
|
RightHand = 2,
|
|
PullUp = 3,
|
|
LeftHand = 4,
|
|
HandsRotationFish = 5,
|
|
HandsRotationFishVertical = 6,
|
|
RightHandFingers = 7
|
|
}
|
|
|
|
public enum FishOnRod
|
|
{
|
|
None = 0,
|
|
Hook = 1
|
|
}
|
|
|
|
public enum FingersRight
|
|
{
|
|
Idle = 0,
|
|
OnRodLoose = 1,
|
|
OnRodTight = 2
|
|
}
|
|
|
|
public enum FingersLeft
|
|
{
|
|
Idle = 0,
|
|
OnReelHandle = 1
|
|
}
|
|
|
|
public enum ThrowMethod
|
|
{
|
|
Far = 0,
|
|
Near = 1
|
|
}
|
|
|
|
public enum ArmLeft
|
|
{
|
|
Idle = 0,
|
|
IK = 1,
|
|
CastNear = 2,
|
|
Catch = 3,
|
|
CatchChwytak = 4
|
|
}
|
|
|
|
public enum TPPAnimation
|
|
{
|
|
Idle = 0,
|
|
MiddleFishView = 1,
|
|
BigFishView = 2,
|
|
ThrowFar = 3,
|
|
ThrowNear = 4,
|
|
RodJam = 5,
|
|
Take = 6,
|
|
PutDown = 7
|
|
}
|
|
|
|
[Serializable]
|
|
public struct AvatarSetup
|
|
{
|
|
public Avatar avatar;
|
|
|
|
public List<Renderer> renderers;
|
|
|
|
public Transform armatureBoneNeck;
|
|
|
|
public ArmIK leftArm_ArmIK;
|
|
|
|
public ArmIK leftArm_HandIK;
|
|
|
|
public ArmIK rightArm_ArmIK;
|
|
|
|
public ArmIK rightArm_HandIK;
|
|
|
|
public Transform cameraPoint;
|
|
|
|
public Transform rHandRodJoiner;
|
|
|
|
public Transform lHandLineJoiner;
|
|
|
|
public Transform lHandLineJoinerFish;
|
|
|
|
public Transform lHandChwytakJoiner;
|
|
|
|
public Transform fishInArmsPoint;
|
|
}
|
|
|
|
[SerializeField]
|
|
private Animator animator;
|
|
|
|
[SerializeField]
|
|
private AvatarSetup maleSetup;
|
|
|
|
[SerializeField]
|
|
private AvatarSetup femaleSetup;
|
|
|
|
[SerializeField]
|
|
[Tooltip("Adjusts the momentum of animator state transitions in the Movement layer; higher values result in faster changes, while lower values produce smoother movements")]
|
|
private float animatorMovementMomentum = 0.1f;
|
|
|
|
[SerializeField]
|
|
[Tooltip("Controls the speed at which hands are attached or detached from IK targets")]
|
|
private float IKWeightChangeSpeed = 2f;
|
|
|
|
private static FullBodyAvatar existingPlayerAvatar;
|
|
|
|
private static List<FullBodyAvatar> existingRemotePlayerAvatars;
|
|
|
|
private Dictionary<AnimatorLayers, float> originalLayerWeights;
|
|
|
|
private Coroutine layerWeightsChangeCoroutine;
|
|
|
|
private float forward;
|
|
|
|
private float right;
|
|
|
|
private float angular;
|
|
|
|
private Quaternion lastRotation;
|
|
|
|
private bool isJumping;
|
|
|
|
private Transform leftArm_IKTarget;
|
|
|
|
private Vector3 leftArm_IKTargetPos;
|
|
|
|
private Quaternion leftArm_IKTargetRot;
|
|
|
|
private float leftArm_Lerp;
|
|
|
|
private bool leftArm_IKWithRotation;
|
|
|
|
private bool leftArm_IKByHand;
|
|
|
|
private Transform rightArm_IKTarget;
|
|
|
|
private Vector3 rightArm_IKTargetPos;
|
|
|
|
private Quaternion rightArm_IKTargetRot;
|
|
|
|
private float rightArm_Lerp;
|
|
|
|
private bool rightArm_IKWithRotation;
|
|
|
|
private bool rightArm_IKByHand;
|
|
|
|
private int RightIdle_Rod;
|
|
|
|
private int FishingHandsUp;
|
|
|
|
public Transform CameraPoint => CurrentAvatarSetup.cameraPoint;
|
|
|
|
public Transform RodJoiner => CurrentAvatarSetup.rHandRodJoiner;
|
|
|
|
public Transform LineJoiner => CurrentAvatarSetup.lHandLineJoiner;
|
|
|
|
public Transform LineJoinerFish => CurrentAvatarSetup.lHandLineJoinerFish;
|
|
|
|
public Transform ChwytakJoiner => CurrentAvatarSetup.lHandChwytakJoiner;
|
|
|
|
public Transform FishInArms => CurrentAvatarSetup.fishInArmsPoint;
|
|
|
|
public bool IsThrowInProgress
|
|
{
|
|
get
|
|
{
|
|
if (!animator.GetBool("RightHand_ReelUnlock") && !animator.GetBool("RightHand_ThrowFar"))
|
|
{
|
|
return animator.GetBool("RightHand_ThrowNear");
|
|
}
|
|
return true;
|
|
}
|
|
}
|
|
|
|
public bool IsRodFishing
|
|
{
|
|
get
|
|
{
|
|
int shortNameHash = animator.GetCurrentAnimatorStateInfo(2).shortNameHash;
|
|
if (shortNameHash == RightIdle_Rod || shortNameHash == FishingHandsUp)
|
|
{
|
|
return animator.GetLayerWeight(6) > 0f;
|
|
}
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public bool IsJumping => isJumping;
|
|
|
|
public bool TPPMovement { get; set; }
|
|
|
|
public float AnimatorMovementMomentum
|
|
{
|
|
get
|
|
{
|
|
if (TPPMovement)
|
|
{
|
|
return animatorMovementMomentum * 3f;
|
|
}
|
|
return animatorMovementMomentum;
|
|
}
|
|
}
|
|
|
|
public FingersRight CurrentFingersRightState { get; private set; }
|
|
|
|
public FingersLeft CurrentFingersLeftState { get; private set; }
|
|
|
|
public ArmLeft CurrentArmLeftState { get; private set; }
|
|
|
|
public AvatarSetup CurrentAvatarSetup { get; private set; }
|
|
|
|
public TPPAnimation CurrentTPPAnimation { get; private set; }
|
|
|
|
public static FullBodyAvatar ExistingPlayerAvatar
|
|
{
|
|
get
|
|
{
|
|
return existingPlayerAvatar;
|
|
}
|
|
private set
|
|
{
|
|
existingPlayerAvatar = value;
|
|
}
|
|
}
|
|
|
|
public static List<FullBodyAvatar> ExistingRemotePlayerAvatars
|
|
{
|
|
get
|
|
{
|
|
if (existingRemotePlayerAvatars == null)
|
|
{
|
|
existingRemotePlayerAvatars = new List<FullBodyAvatar>();
|
|
}
|
|
existingRemotePlayerAvatars.RemoveAll((FullBodyAvatar element) => element == null);
|
|
return existingRemotePlayerAvatars;
|
|
}
|
|
}
|
|
|
|
public static FullBodyAvatar GetAvatar()
|
|
{
|
|
if (!ExistingPlayerAvatar)
|
|
{
|
|
ExistingPlayerAvatar = UnityEngine.Object.FindObjectsByType<FullBodyAvatar>(FindObjectsInactive.Exclude, FindObjectsSortMode.InstanceID).FirstOrDefault((FullBodyAvatar element) => !ExistingRemotePlayerAvatars.Contains(element));
|
|
if (ExistingPlayerAvatar == null)
|
|
{
|
|
ExistingPlayerAvatar = UnityEngine.Object.Instantiate(Resources.Load<GameObject>("FullBodyAvatar")).GetComponent<FullBodyAvatar>();
|
|
}
|
|
ExistingPlayerAvatar.animator.cullingMode = AnimatorCullingMode.AlwaysAnimate;
|
|
}
|
|
return ExistingPlayerAvatar;
|
|
}
|
|
|
|
public static FullBodyAvatar GetAvatarRemote()
|
|
{
|
|
GameObject gameObject = UnityEngine.Object.Instantiate(Resources.Load<GameObject>("FullBodyAvatar"));
|
|
ExistingRemotePlayerAvatars.Add(gameObject.GetComponent<FullBodyAvatar>());
|
|
ExistingRemotePlayerAvatars.Last().animator.cullingMode = AnimatorCullingMode.CullUpdateTransforms;
|
|
return ExistingRemotePlayerAvatars.Last();
|
|
}
|
|
|
|
public void SetGender(bool male = true)
|
|
{
|
|
DisableSetup(maleSetup);
|
|
DisableSetup(femaleSetup);
|
|
CurrentAvatarSetup = (male ? maleSetup : femaleSetup);
|
|
EnableSetup(CurrentAvatarSetup);
|
|
Vector3 zero = Vector3.zero;
|
|
if (!male)
|
|
{
|
|
zero.x = 3f;
|
|
}
|
|
animator.transform.localEulerAngles = zero;
|
|
static void DisableSetup(AvatarSetup avatarSetup)
|
|
{
|
|
avatarSetup.renderers.ForEach(delegate(Renderer element)
|
|
{
|
|
element.enabled = false;
|
|
});
|
|
avatarSetup.leftArm_ArmIK.gameObject.SetActive(value: false);
|
|
avatarSetup.rightArm_ArmIK.gameObject.SetActive(value: false);
|
|
}
|
|
void EnableSetup(AvatarSetup avatarSetup)
|
|
{
|
|
avatarSetup.renderers.ForEach(delegate(Renderer element)
|
|
{
|
|
element.enabled = true;
|
|
});
|
|
avatarSetup.leftArm_ArmIK.gameObject.SetActive(value: true);
|
|
avatarSetup.rightArm_ArmIK.gameObject.SetActive(value: true);
|
|
animator.avatar = avatarSetup.avatar;
|
|
}
|
|
}
|
|
|
|
public void ShowHead(bool toggle = true)
|
|
{
|
|
if (toggle)
|
|
{
|
|
CurrentAvatarSetup.armatureBoneNeck.localScale = Vector3.one;
|
|
}
|
|
else
|
|
{
|
|
CurrentAvatarSetup.armatureBoneNeck.localScale = new Vector3(1f, 0f, 0f);
|
|
}
|
|
}
|
|
|
|
public void MovementAnimation(FirstPersonController firstPersonController, Vector3 baselineVelocity)
|
|
{
|
|
MovementAnimation(firstPersonController.transform.forward, firstPersonController.transform.right, firstPersonController.m_CharacterController.velocity, baselineVelocity, firstPersonController.m_WalkSpeed, firstPersonController.m_RunSpeed);
|
|
}
|
|
|
|
public void MovementAnimation(Vector3 orientationForward, Vector3 orientationRight, Vector3 velocity, Vector3 baselineVelocity, float walkSpeed, float runSpeed)
|
|
{
|
|
velocity.y = 0f;
|
|
baselineVelocity.y = 0f;
|
|
velocity -= baselineVelocity;
|
|
float num = Vector3.Dot(velocity, orientationForward);
|
|
float num2 = Vector3.Dot(velocity, orientationRight);
|
|
num /= walkSpeed;
|
|
num2 /= walkSpeed;
|
|
forward = Mathf.Lerp(forward, num, AnimatorMovementMomentum);
|
|
right = Mathf.Lerp(right, num2, AnimatorMovementMomentum);
|
|
forward = Mathf.Clamp(forward, -1f, 1.3f);
|
|
right = Mathf.Clamp(right, -1f, 1f);
|
|
if (float.IsNaN(forward))
|
|
{
|
|
forward = 0f;
|
|
}
|
|
if (float.IsNaN(right))
|
|
{
|
|
right = 0f;
|
|
}
|
|
animator.SetFloat("Movement_PlayerWalk", (Mathf.Abs(forward) < 0.01f) ? 0f : forward);
|
|
animator.SetFloat("Movement_PlayerStrafe", (Mathf.Abs(right) < 0.01f) ? 0f : right);
|
|
Quaternion rotation = base.transform.rotation;
|
|
(Quaternion.Inverse(lastRotation) * rotation).ToAngleAxis(out var angle, out var axis);
|
|
angle = ((angle > 180f) ? (angle - 360f) : angle);
|
|
if (axis.y < 0f)
|
|
{
|
|
angle = 0f - angle;
|
|
}
|
|
if (Time.deltaTime > 0f)
|
|
{
|
|
angular = Mathf.Lerp(angular, angle / Time.deltaTime, AnimatorMovementMomentum);
|
|
}
|
|
lastRotation = rotation;
|
|
animator.SetFloat("Movement_PlayerRotate", angular);
|
|
bool num3 = velocity.magnitude > walkSpeed;
|
|
float num4 = 1f;
|
|
num4 = (num3 ? Mathf.Lerp(1.2f, 1.8f, velocity.magnitude / runSpeed) : ((!(velocity.magnitude > 0.001f)) ? 1f : Mathf.Lerp(0.7f, 1.2f, velocity.magnitude / runSpeed)));
|
|
if ((double)num4 < 0.1)
|
|
{
|
|
num4 = 0f;
|
|
}
|
|
animator.SetFloat("Movement_MultiplierVelocity", num4);
|
|
float num5 = Mathf.Clamp01(Mathf.Abs(angular) / 90f);
|
|
if ((double)num5 < 0.1)
|
|
{
|
|
num5 = 0f;
|
|
}
|
|
animator.SetFloat("Movement_MultiplierAngular", num5);
|
|
}
|
|
|
|
public void HandsIdle()
|
|
{
|
|
if (CurrentTPPAnimation == TPPAnimation.Idle)
|
|
{
|
|
RodPullUp(0f);
|
|
RodAngle();
|
|
RightArmIK();
|
|
LeftArmIK();
|
|
SetFingersRight(FingersRight.Idle);
|
|
SetFingersLeft(FingersLeft.Idle);
|
|
SetFishOnRod(FishOnRod.None);
|
|
ReelLockUnlockReset();
|
|
ThrowReset();
|
|
LeftArmControl(ArmLeft.Idle);
|
|
}
|
|
}
|
|
|
|
public void SetFishOnRod(FishOnRod fishOnRod)
|
|
{
|
|
switch (fishOnRod)
|
|
{
|
|
case FishOnRod.None:
|
|
animator.SetBool("RightHand_isCatch", value: false);
|
|
animator.SetBool("RightHand_isFish", value: false);
|
|
break;
|
|
case FishOnRod.Hook:
|
|
animator.SetBool("RightHand_isCatch", value: false);
|
|
animator.SetBool("RightHand_isFish", value: true);
|
|
break;
|
|
}
|
|
}
|
|
|
|
public void ShowRod(bool bySlot = true)
|
|
{
|
|
if (bySlot)
|
|
{
|
|
animator.SetTrigger("RightHand_ShowRodBySlot");
|
|
}
|
|
else
|
|
{
|
|
animator.SetTrigger("RightHand_GetRod");
|
|
}
|
|
}
|
|
|
|
public void HideRod(bool bySlot = true)
|
|
{
|
|
if (bySlot)
|
|
{
|
|
animator.SetTrigger("RightHand_HideRodToSlot");
|
|
}
|
|
else
|
|
{
|
|
animator.SetTrigger("RightHand_DropRod");
|
|
}
|
|
}
|
|
|
|
public void SetFingersRight(FingersRight fingers)
|
|
{
|
|
CurrentFingersRightState = fingers;
|
|
switch (fingers)
|
|
{
|
|
case FingersRight.Idle:
|
|
animator.SetBool("RightHandFingers_OnRod", value: false);
|
|
animator.SetBool("RightHandFingers_OnRodPowered", value: false);
|
|
break;
|
|
case FingersRight.OnRodLoose:
|
|
animator.SetBool("RightHandFingers_OnRod", value: true);
|
|
animator.SetBool("RightHandFingers_OnRodPowered", value: false);
|
|
break;
|
|
case FingersRight.OnRodTight:
|
|
animator.SetBool("RightHandFingers_OnRod", value: true);
|
|
animator.SetBool("RightHandFingers_OnRodPowered", value: true);
|
|
break;
|
|
}
|
|
}
|
|
|
|
public void SetFingersLeft(FingersLeft fingers)
|
|
{
|
|
CurrentFingersLeftState = fingers;
|
|
switch (fingers)
|
|
{
|
|
case FingersLeft.Idle:
|
|
animator.SetBool("LeftHand_OnReel", value: false);
|
|
break;
|
|
case FingersLeft.OnReelHandle:
|
|
animator.SetBool("LeftHand_OnReel", value: true);
|
|
break;
|
|
}
|
|
}
|
|
|
|
public void RodPullUp(float amount, float weight = 0f)
|
|
{
|
|
float layerWeight = animator.GetLayerWeight(3);
|
|
if (layerWeight != weight)
|
|
{
|
|
animator.SetLayerWeight(3, Mathf.MoveTowards(layerWeight, weight, Time.deltaTime * 4f));
|
|
}
|
|
float min = 0.02f;
|
|
amount = Mathf.Clamp(amount, min, 1f);
|
|
animator.Play("PullUpRodFishing", 3, amount);
|
|
}
|
|
|
|
public void RodAngle(float amountHorizontal = 0f, float amountVertical = 0f, float weightHorizontal = 0f, float weightVertical = 0f)
|
|
{
|
|
float layerWeight = animator.GetLayerWeight(5);
|
|
float layerWeight2 = animator.GetLayerWeight(6);
|
|
if (layerWeight != weightHorizontal || layerWeight2 != weightVertical)
|
|
{
|
|
animator.SetLayerWeight(5, Mathf.MoveTowards(layerWeight, weightHorizontal, Time.deltaTime * 4f));
|
|
animator.SetLayerWeight(6, Mathf.MoveTowards(layerWeight2, weightVertical, Time.deltaTime * 4f));
|
|
}
|
|
amountHorizontal = Mathf.Clamp(amountHorizontal, -1f, 1f);
|
|
amountVertical = Mathf.Clamp(amountVertical, -1f, 1f);
|
|
float num = 0.02f;
|
|
if (Mathf.Abs(amountVertical) < num)
|
|
{
|
|
amountVertical = ((!(amountVertical >= 0f)) ? (0f - num) : num);
|
|
}
|
|
if (amountHorizontal > 0f)
|
|
{
|
|
animator.Play("FishingHandsRightRot", 5, amountHorizontal);
|
|
}
|
|
else
|
|
{
|
|
animator.Play("FishingHandsLeftRot", 5, 0f - amountHorizontal);
|
|
}
|
|
if (amountVertical > 0f)
|
|
{
|
|
animator.Play("FishingHandsUpRot", 6, amountVertical);
|
|
}
|
|
else
|
|
{
|
|
animator.Play("FishingHandsDownRot", 6, 0f - amountVertical);
|
|
}
|
|
}
|
|
|
|
public void ReelLockUnlockReset()
|
|
{
|
|
animator.SetBool("RightHand_ReelLock", value: false);
|
|
animator.SetBool("RightHand_ReelUnlock", value: false);
|
|
}
|
|
|
|
public void ThrowReset()
|
|
{
|
|
animator.SetBool("RightHand_ThrowFar", value: false);
|
|
animator.SetBool("RightHand_ThrowNear", value: false);
|
|
}
|
|
|
|
public void Throw(ThrowMethod throwMethod)
|
|
{
|
|
ReelLockUnlockReset();
|
|
ThrowReset();
|
|
switch (throwMethod)
|
|
{
|
|
case ThrowMethod.Far:
|
|
animator.SetBool("RightHand_ReelUnlock", value: true);
|
|
animator.SetBool("RightHand_ThrowFar", value: true);
|
|
break;
|
|
case ThrowMethod.Near:
|
|
animator.SetBool("RightHand_ThrowNear", value: true);
|
|
break;
|
|
}
|
|
}
|
|
|
|
public void ReelControl(bool reelUnlock = false, bool reelLock = false)
|
|
{
|
|
animator.SetBool("RightHand_ReelUnlock", reelUnlock);
|
|
animator.SetBool("RightHand_ReelLock", reelLock);
|
|
}
|
|
|
|
public void LeftArmControl(ArmLeft armLeft, Transform ikTarget = null)
|
|
{
|
|
LeftArmIK();
|
|
switch (armLeft)
|
|
{
|
|
case ArmLeft.Idle:
|
|
animator.SetBool("LeftHand_PreCast", value: false);
|
|
animator.SetBool("LeftHand_GrabLineFish", value: false);
|
|
animator.SetBool("LeftHand_isFishChwytak", value: false);
|
|
break;
|
|
case ArmLeft.IK:
|
|
animator.SetBool("LeftHand_PreCast", value: false);
|
|
animator.SetBool("LeftHand_GrabLineFish", value: false);
|
|
animator.SetBool("LeftHand_isFishChwytak", value: false);
|
|
if (ikTarget != null)
|
|
{
|
|
LeftArmIK(ikTarget);
|
|
}
|
|
break;
|
|
case ArmLeft.CastNear:
|
|
animator.SetBool("LeftHand_PreCast", value: true);
|
|
animator.SetBool("LeftHand_GrabLineFish", value: false);
|
|
animator.SetBool("LeftHand_isFishChwytak", value: false);
|
|
break;
|
|
case ArmLeft.Catch:
|
|
animator.SetBool("LeftHand_PreCast", value: false);
|
|
animator.SetBool("LeftHand_GrabLineFish", value: true);
|
|
animator.SetBool("LeftHand_isFishChwytak", value: false);
|
|
break;
|
|
case ArmLeft.CatchChwytak:
|
|
animator.SetBool("LeftHand_PreCast", value: false);
|
|
animator.SetBool("LeftHand_GrabLineFish", value: false);
|
|
animator.SetBool("LeftHand_isFishChwytak", value: true);
|
|
break;
|
|
}
|
|
CurrentArmLeftState = armLeft;
|
|
}
|
|
|
|
public void LeftArmIK(Transform ikTarget = null, bool withRotation = false, bool byHand = false)
|
|
{
|
|
leftArm_IKTarget = ikTarget;
|
|
leftArm_Lerp = 0f;
|
|
leftArm_IKWithRotation = withRotation;
|
|
leftArm_IKByHand = byHand;
|
|
}
|
|
|
|
public void RightArmIK(Transform ikTarget = null, bool withRotation = false, bool byHand = false)
|
|
{
|
|
rightArm_IKTarget = ikTarget;
|
|
rightArm_Lerp = 0f;
|
|
rightArm_IKWithRotation = withRotation;
|
|
rightArm_IKByHand = byHand;
|
|
}
|
|
|
|
public void Jump()
|
|
{
|
|
if (!isJumping)
|
|
{
|
|
isJumping = true;
|
|
animator.SetBool("Movement_Jump", value: true);
|
|
}
|
|
}
|
|
|
|
public void Land()
|
|
{
|
|
if (isJumping)
|
|
{
|
|
isJumping = false;
|
|
animator.SetBool("Movement_Jump", value: false);
|
|
}
|
|
}
|
|
|
|
public void PlayTPPAnimation(TPPAnimation animation)
|
|
{
|
|
animator.SetBool("Movement_MFV", value: false);
|
|
animator.SetBool("Movement_BFV", value: false);
|
|
animator.SetBool("ThirdPersonView_ThrowFar", value: false);
|
|
animator.SetBool("ThirdPersonView_ThrowNear", value: false);
|
|
animator.SetBool("ThirdPersonView_ThrowRodJam", value: false);
|
|
animator.SetBool("ThirdPersonView_Take", value: false);
|
|
animator.SetBool("ThirdPersonView_PutDown", value: false);
|
|
CurrentTPPAnimation = animation;
|
|
switch (animation)
|
|
{
|
|
case TPPAnimation.Idle:
|
|
RestoreOriginalLayerWeights();
|
|
break;
|
|
case TPPAnimation.MiddleFishView:
|
|
animator.SetBool("Movement_MFV", value: true);
|
|
CullAllLayers(new List<AnimatorLayers> { AnimatorLayers.Movement });
|
|
break;
|
|
case TPPAnimation.BigFishView:
|
|
animator.SetBool("Movement_BFV", value: true);
|
|
CullAllLayers(new List<AnimatorLayers> { AnimatorLayers.Movement });
|
|
break;
|
|
case TPPAnimation.ThrowFar:
|
|
animator.SetBool("ThirdPersonView_ThrowFar", value: true);
|
|
CullAllLayers(new List<AnimatorLayers>
|
|
{
|
|
AnimatorLayers.Movement,
|
|
AnimatorLayers.ThirdPersonView,
|
|
AnimatorLayers.RightHandFingers
|
|
});
|
|
break;
|
|
case TPPAnimation.ThrowNear:
|
|
animator.SetBool("ThirdPersonView_ThrowNear", value: true);
|
|
CullAllLayers(new List<AnimatorLayers>
|
|
{
|
|
AnimatorLayers.Movement,
|
|
AnimatorLayers.ThirdPersonView,
|
|
AnimatorLayers.RightHandFingers
|
|
});
|
|
break;
|
|
case TPPAnimation.RodJam:
|
|
animator.SetBool("ThirdPersonView_ThrowRodJam", value: true);
|
|
CullAllLayers(new List<AnimatorLayers>
|
|
{
|
|
AnimatorLayers.Movement,
|
|
AnimatorLayers.ThirdPersonView,
|
|
AnimatorLayers.RightHandFingers
|
|
});
|
|
break;
|
|
case TPPAnimation.Take:
|
|
animator.SetBool("ThirdPersonView_Take", value: true);
|
|
CullAllLayers(new List<AnimatorLayers>
|
|
{
|
|
AnimatorLayers.Movement,
|
|
AnimatorLayers.ThirdPersonView
|
|
});
|
|
break;
|
|
case TPPAnimation.PutDown:
|
|
animator.SetBool("ThirdPersonView_PutDown", value: true);
|
|
CullAllLayers(new List<AnimatorLayers>
|
|
{
|
|
AnimatorLayers.Movement,
|
|
AnimatorLayers.ThirdPersonView
|
|
});
|
|
break;
|
|
}
|
|
}
|
|
|
|
public void LookAtFishInHand()
|
|
{
|
|
Vector3 eulerAngles = CurrentAvatarSetup.cameraPoint.eulerAngles;
|
|
eulerAngles.x = 20f;
|
|
CurrentAvatarSetup.cameraPoint.eulerAngles = eulerAngles;
|
|
}
|
|
|
|
public Transform GetBoneTransform(HumanBodyBones humanBodyBones)
|
|
{
|
|
return animator.GetBoneTransform(humanBodyBones);
|
|
}
|
|
|
|
private void Start()
|
|
{
|
|
originalLayerWeights = new Dictionary<AnimatorLayers, float>();
|
|
foreach (AnimatorLayers value in Enum.GetValues(typeof(AnimatorLayers)))
|
|
{
|
|
originalLayerWeights[value] = animator.GetLayerWeight((int)value);
|
|
}
|
|
lastRotation = base.transform.rotation;
|
|
RightIdle_Rod = Animator.StringToHash("RightIdle_Rod");
|
|
FishingHandsUp = Animator.StringToHash("FishingHandsUp");
|
|
}
|
|
|
|
private void Update()
|
|
{
|
|
SmoothIKUpdate();
|
|
}
|
|
|
|
private void SmoothIKUpdate()
|
|
{
|
|
if (CurrentAvatarSetup.leftArm_ArmIK == null)
|
|
{
|
|
return;
|
|
}
|
|
ArmIK armIK;
|
|
ArmIK armIK2;
|
|
if (leftArm_IKByHand)
|
|
{
|
|
armIK = CurrentAvatarSetup.leftArm_HandIK;
|
|
armIK2 = CurrentAvatarSetup.leftArm_ArmIK;
|
|
}
|
|
else
|
|
{
|
|
armIK = CurrentAvatarSetup.leftArm_ArmIK;
|
|
armIK2 = CurrentAvatarSetup.leftArm_HandIK;
|
|
}
|
|
armIK.gameObject.SetActive(value: true);
|
|
armIK2.gameObject.SetActive(value: false);
|
|
armIK2.solver.IKPositionWeight = 0f;
|
|
armIK2.solver.IKRotationWeight = 0f;
|
|
if (leftArm_IKTarget != null)
|
|
{
|
|
leftArm_Lerp = Mathf.MoveTowards(leftArm_Lerp, 1f, Time.deltaTime * IKWeightChangeSpeed);
|
|
leftArm_IKTargetPos = Vector3.Lerp(armIK.solver.IKPosition, leftArm_IKTarget.position, leftArm_Lerp);
|
|
leftArm_IKTargetRot = Quaternion.Lerp(armIK.solver.IKRotation, leftArm_IKTarget.rotation, leftArm_Lerp);
|
|
armIK.solver.IKPosition = leftArm_IKTargetPos;
|
|
armIK.solver.IKPositionWeight = Mathf.MoveTowards(armIK.solver.IKPositionWeight, 1f, Time.deltaTime * IKWeightChangeSpeed);
|
|
if (leftArm_IKWithRotation)
|
|
{
|
|
armIK.solver.IKRotation = leftArm_IKTargetRot;
|
|
armIK.solver.IKRotationWeight = Mathf.MoveTowards(armIK.solver.IKRotationWeight, 1f, Time.deltaTime * IKWeightChangeSpeed);
|
|
}
|
|
else
|
|
{
|
|
armIK.solver.IKRotationWeight = Mathf.MoveTowards(armIK.solver.IKRotationWeight, 0f, Time.deltaTime * IKWeightChangeSpeed);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
armIK.solver.IKPositionWeight = Mathf.MoveTowards(armIK.solver.IKPositionWeight, 0f, Time.deltaTime * IKWeightChangeSpeed);
|
|
armIK.solver.IKRotationWeight = Mathf.MoveTowards(armIK.solver.IKRotationWeight, 0f, Time.deltaTime * IKWeightChangeSpeed);
|
|
}
|
|
if (rightArm_IKByHand)
|
|
{
|
|
armIK = CurrentAvatarSetup.rightArm_HandIK;
|
|
armIK2 = CurrentAvatarSetup.rightArm_ArmIK;
|
|
}
|
|
else
|
|
{
|
|
armIK = CurrentAvatarSetup.rightArm_ArmIK;
|
|
armIK2 = CurrentAvatarSetup.rightArm_HandIK;
|
|
}
|
|
armIK.gameObject.SetActive(value: true);
|
|
armIK2.gameObject.SetActive(value: false);
|
|
armIK2.solver.IKPositionWeight = 0f;
|
|
armIK2.solver.IKRotationWeight = 0f;
|
|
if (rightArm_IKTarget != null)
|
|
{
|
|
rightArm_Lerp = Mathf.MoveTowards(rightArm_Lerp, 1f, Time.deltaTime * IKWeightChangeSpeed);
|
|
rightArm_IKTargetPos = Vector3.Lerp(armIK.solver.IKPosition, rightArm_IKTarget.position, rightArm_Lerp);
|
|
rightArm_IKTargetRot = Quaternion.Lerp(armIK.solver.IKRotation, rightArm_IKTarget.rotation, rightArm_Lerp);
|
|
armIK.solver.IKPosition = rightArm_IKTargetPos;
|
|
armIK.solver.IKPositionWeight = Mathf.MoveTowards(armIK.solver.IKPositionWeight, 1f, Time.deltaTime * IKWeightChangeSpeed);
|
|
if (rightArm_IKWithRotation)
|
|
{
|
|
armIK.solver.IKRotation = rightArm_IKTargetRot;
|
|
armIK.solver.IKRotationWeight = Mathf.MoveTowards(armIK.solver.IKRotationWeight, 1f, Time.deltaTime * IKWeightChangeSpeed);
|
|
}
|
|
else
|
|
{
|
|
armIK.solver.IKRotationWeight = Mathf.MoveTowards(armIK.solver.IKRotationWeight, 0f, Time.deltaTime * IKWeightChangeSpeed);
|
|
}
|
|
}
|
|
else
|
|
{
|
|
armIK.solver.IKPositionWeight = Mathf.MoveTowards(armIK.solver.IKPositionWeight, 0f, Time.deltaTime * IKWeightChangeSpeed);
|
|
armIK.solver.IKRotationWeight = Mathf.MoveTowards(armIK.solver.IKRotationWeight, 0f, Time.deltaTime * IKWeightChangeSpeed);
|
|
}
|
|
}
|
|
|
|
private void CullAllLayers(List<AnimatorLayers> except = null)
|
|
{
|
|
Dictionary<AnimatorLayers, float> dictionary = new Dictionary<AnimatorLayers, float>();
|
|
foreach (AnimatorLayers value in Enum.GetValues(typeof(AnimatorLayers)))
|
|
{
|
|
dictionary[value] = ((except != null && except.Contains(value)) ? 1f : 0f);
|
|
}
|
|
if (layerWeightsChangeCoroutine != null)
|
|
{
|
|
StopCoroutine(layerWeightsChangeCoroutine);
|
|
}
|
|
layerWeightsChangeCoroutine = StartCoroutine(LayerWeightsChangeCoroutine(dictionary));
|
|
}
|
|
|
|
private void RestoreOriginalLayerWeights()
|
|
{
|
|
if (layerWeightsChangeCoroutine != null)
|
|
{
|
|
StopCoroutine(layerWeightsChangeCoroutine);
|
|
}
|
|
layerWeightsChangeCoroutine = StartCoroutine(LayerWeightsChangeCoroutine(originalLayerWeights));
|
|
}
|
|
|
|
private IEnumerator LayerWeightsChangeCoroutine(Dictionary<AnimatorLayers, float> targetWeights)
|
|
{
|
|
Dictionary<AnimatorLayers, float> initialWeights = new Dictionary<AnimatorLayers, float>();
|
|
foreach (AnimatorLayers key in targetWeights.Keys)
|
|
{
|
|
initialWeights[key] = animator.GetLayerWeight((int)key);
|
|
}
|
|
float duration = 1f;
|
|
float time = 0f;
|
|
while (time < duration)
|
|
{
|
|
time += Time.deltaTime;
|
|
float t = time / duration;
|
|
foreach (AnimatorLayers key2 in targetWeights.Keys)
|
|
{
|
|
float weight = Mathf.Lerp(initialWeights[key2], targetWeights[key2], t);
|
|
animator.SetLayerWeight((int)key2, weight);
|
|
}
|
|
yield return null;
|
|
}
|
|
foreach (AnimatorLayers key3 in targetWeights.Keys)
|
|
{
|
|
animator.SetLayerWeight((int)key3, targetWeights[key3]);
|
|
}
|
|
}
|
|
}
|