2203 lines
82 KiB
C#
2203 lines
82 KiB
C#
using UnityEngine;
|
|
using System;
|
|
using System.Collections;
|
|
using System.Collections.Generic;
|
|
|
|
public class IKSystem : MonoBehaviour
|
|
{
|
|
[Header ("Main Setting")]
|
|
[Space]
|
|
|
|
public LayerMask layer;
|
|
[Range (1, 10)] public float IKSpeed;
|
|
|
|
public string rightHandGrabbingIDName = "Right Hand Grabbing ID";
|
|
public string leftHandGrabbingIDName = "Left Hand Grabbing ID";
|
|
|
|
[Space]
|
|
[Header ("IK Body Info State List")]
|
|
[Space]
|
|
|
|
public List<IKBodyInfoState> IKBodyInfoStateList = new List<IKBodyInfoState> ();
|
|
|
|
[Space]
|
|
[Header ("Fire Weapons IK Settings")]
|
|
[Space]
|
|
|
|
public float fireWeaponsHeadWeight = 1;
|
|
public float fireWeaponsBodyWeight = 0;
|
|
|
|
[Space]
|
|
[Header ("Debug")]
|
|
[Space]
|
|
|
|
public bool showDebugPrint;
|
|
|
|
public aimMode currentAimMode;
|
|
|
|
public bool usingHands;
|
|
|
|
public bool usingWeapons;
|
|
public bool usingDualWeapon;
|
|
public bool disablingDualWeapons;
|
|
|
|
public bool usingArms;
|
|
public bool driving;
|
|
public bool usingZipline;
|
|
|
|
public bool disableWeapons;
|
|
public bool IKBodyInfoActive;
|
|
|
|
public bool disablingIKBodyInfoActive;
|
|
public bool objectGrabbed;
|
|
public bool IKSystemEnabledToGrab;
|
|
|
|
public bool isThirdPersonView;
|
|
|
|
public float currentHeadWeight;
|
|
public float headWeightTarget;
|
|
|
|
public bool IKBodyPaused;
|
|
|
|
public OnAnimatorIKComponent temporalOnAnimatorIKComponent;
|
|
|
|
public bool temporalOnAnimatorIKComponentAssigned;
|
|
|
|
public bool fullBodyAwarenessActive;
|
|
|
|
[Space]
|
|
[Header ("Gizmo Settings")]
|
|
[Space]
|
|
|
|
public bool showGizmo;
|
|
|
|
[Space]
|
|
[Header ("Mount Points Settings")]
|
|
[Space]
|
|
|
|
public Transform rightHandMountPoint;
|
|
public Transform leftHandMountPoint;
|
|
|
|
public Transform rightLowerArmMountPoint;
|
|
public Transform leftLowerArmMountPoint;
|
|
|
|
[Space]
|
|
[Header ("On Animator IK Components")]
|
|
[Space]
|
|
|
|
public OnAnimatorIKComponent handsOnSurfaceIKComponent;
|
|
public OnAnimatorIKComponent IKFootSystemComponent;
|
|
public OnAnimatorIKComponent headTrackIKComponent;
|
|
public OnAnimatorIKComponent bulletTimeIKComponent;
|
|
|
|
|
|
[Space]
|
|
[Header ("Components")]
|
|
[Space]
|
|
|
|
public Transform rightHandIKPos;
|
|
public Transform leftHandIKPos;
|
|
public Transform currentHandIKPos;
|
|
|
|
public Transform rightElbowIKPos;
|
|
public Transform leftElbowIKPos;
|
|
public Transform currentElbowIKPos;
|
|
public Transform IKBodyCOM;
|
|
|
|
public Animator animator;
|
|
public playerController playerControllerManager;
|
|
public playerWeaponsManager weaponsManager;
|
|
public otherPowers powersManager;
|
|
|
|
List<IKBodyInfo> currentIKBodyInfoList = new List<IKBodyInfo> ();
|
|
|
|
IKBodyInfoState currentIKBodyInfoState;
|
|
|
|
IKBodyInfo currentIKBodyInfo;
|
|
Vector2 playerInputAxis;
|
|
|
|
public IKSettings settings;
|
|
|
|
public enum aimMode
|
|
{
|
|
hands,
|
|
weapons
|
|
}
|
|
|
|
IKDrivingSystem.IKDrivingInformation IKDrivingSettings;
|
|
IKDrivingSystem.IKDrivingPositions currentIKDrivingPositions;
|
|
IKDrivingSystem.IKDrivingKneePositions currentIKDrivingKneePositions;
|
|
float currentDriveIkWeightValue;
|
|
|
|
zipline.IKZiplineInfo IKZiplineSettings;
|
|
zipline.IKGoalsZiplinePositions currentIKGoalsZiplinePositions;
|
|
zipline.IKHintsZiplinePositions currentIKHintsZiplinePositions;
|
|
|
|
IKWeaponInfo IKWeaponsSettings;
|
|
|
|
IKWeaponInfo IKWeaponsRightHandSettings;
|
|
IKWeaponInfo IKWeaponsLeftHandSettings;
|
|
|
|
AvatarIKGoal currentHand;
|
|
|
|
float IKWeight;
|
|
float IKWeightTargetValue;
|
|
float originalDist;
|
|
float hitDist;
|
|
float currentDist;
|
|
AvatarIKHint currenElbow;
|
|
|
|
RaycastHit hit;
|
|
|
|
Coroutine powerHandRecoil;
|
|
float originalCurrentDist;
|
|
int handsDisabled;
|
|
|
|
Transform playerHead;
|
|
|
|
bool playerHeadLocated;
|
|
|
|
List<grabObjects.handInfo> handInfoList = new List<grabObjects.handInfo> ();
|
|
grabObjects.handInfo currentHandInfo;
|
|
|
|
float currentWeightLerpSpeed;
|
|
|
|
bool resetIKCOMRotationChecked;
|
|
|
|
Vector3 targetRotation;
|
|
|
|
bool headLookStateEnabled;
|
|
bool disableHeadLookState;
|
|
float headLookSpeed;
|
|
Transform headLookTarget;
|
|
|
|
Vector3 drivingBodyRotation;
|
|
|
|
IKWeaponsPosition currentIKWeaponsPosition;
|
|
|
|
bool IKBodyInfoStateListOriginalPositionAssigned;
|
|
|
|
AvatarIKGoal currentIKGoal;
|
|
AvatarIKHint currentIKHint;
|
|
|
|
bool handsOnSurfaceIKComponentLocated;
|
|
bool IKFootSystemComponentLocated;
|
|
bool headTrackIKComponentLocated;
|
|
bool bulletTimeIKComponentLocated;
|
|
|
|
bool componentEnabled = true;
|
|
|
|
|
|
void Start ()
|
|
{
|
|
setIKBodyInfoListOriginalPosition ();
|
|
|
|
handsOnSurfaceIKComponentLocated = handsOnSurfaceIKComponent != null;
|
|
|
|
IKFootSystemComponentLocated = IKFootSystemComponent != null;
|
|
|
|
headTrackIKComponentLocated = headTrackIKComponent != null;
|
|
|
|
bulletTimeIKComponentLocated = bulletTimeIKComponent != null;
|
|
|
|
setIsThirdPersonViewState (!playerControllerManager.isPlayerOnFirstPerson ());
|
|
}
|
|
|
|
void Update ()
|
|
{
|
|
|
|
}
|
|
|
|
void LateUpdate ()
|
|
{
|
|
if (driving) {
|
|
if (IKDrivingSettings.useIKOnVehicle && IKDrivingSettings.useHeadLookDirection) {
|
|
if (IKDrivingSettings.headLookDirection != null) {
|
|
if (playerHeadLocated) {
|
|
Quaternion headRotation = Quaternion.FromToRotation (playerHead.transform.InverseTransformDirection (IKDrivingSettings.headLookDirection.forward),
|
|
IKDrivingSettings.headLookDirection.InverseTransformDirection (IKDrivingSettings.headLookDirection.forward));
|
|
|
|
Vector3 headDirection = headRotation.eulerAngles;
|
|
|
|
playerHead.transform.localEulerAngles = -headDirection;
|
|
|
|
} else {
|
|
playerHead = animator.GetBoneTransform (HumanBodyBones.Head);
|
|
|
|
playerHeadLocated = playerHead != null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
void OnAnimatorIK (int layerIndex)
|
|
{
|
|
if (usingWeapons || usingArms || driving || usingZipline || objectGrabbed) {
|
|
usingHands = true;
|
|
} else {
|
|
usingHands = false;
|
|
}
|
|
|
|
if (!driving && usingArms) {
|
|
//change the current weight of the ik
|
|
if (IKWeight != IKWeightTargetValue) {
|
|
IKWeight = Mathf.MoveTowards (IKWeight, IKWeightTargetValue, Time.deltaTime * IKSpeed);
|
|
}
|
|
|
|
if (IKWeight > 0) {
|
|
//if the raycast detects a surface, get the distance to it
|
|
if (Physics.Raycast (currentHandIKPos.position, transform.forward, out hit, 3, layer)) {
|
|
if (!hit.collider.isTrigger) {
|
|
if (hit.distance < originalDist) {
|
|
hitDist = hit.distance;
|
|
} else {
|
|
hitDist = originalDist;
|
|
}
|
|
}
|
|
}
|
|
//else, set the original distance
|
|
else {
|
|
hitDist = originalDist;
|
|
}
|
|
|
|
hitDist = Mathf.Clamp (hitDist, 0.1f, originalDist);
|
|
|
|
//set the correct position of the current hand to avoid cross any collider with it
|
|
currentDist = Mathf.Lerp (currentDist, hitDist, Time.deltaTime * IKSpeed);
|
|
|
|
currentHandIKPos.localPosition = new Vector3 (currentHandIKPos.localPosition.x, currentDist, currentHandIKPos.localPosition.z);
|
|
}
|
|
|
|
if (IKWeight == 0) {
|
|
usingArms = false;
|
|
}
|
|
}
|
|
|
|
if (usingWeapons) {
|
|
if (disableWeapons || disablingDualWeapons) {
|
|
handsDisabled = 0;
|
|
}
|
|
|
|
float currentDeltaTime = Time.deltaTime;
|
|
|
|
if (usingDualWeapon) {
|
|
if (IKWeaponsRightHandSettings != null && IKWeaponsRightHandSettings.dualWeaponActive) {
|
|
currentIKWeaponsPosition = IKWeaponsRightHandSettings.rightHandDualWeaopnInfo.handsInfo [0];
|
|
|
|
if (currentIKWeaponsPosition.HandIKWeight != currentIKWeaponsPosition.targetValue) {
|
|
|
|
currentIKWeaponsPosition.HandIKWeight =
|
|
Mathf.MoveTowards (currentIKWeaponsPosition.HandIKWeight,
|
|
currentIKWeaponsPosition.targetValue,
|
|
currentDeltaTime * currentIKWeaponsPosition.IKSpeed);
|
|
}
|
|
|
|
bool checkElbowIKWeightResult = false;
|
|
|
|
if (currentIKWeaponsPosition.elbowInfo.elbowIKWeight != currentIKWeaponsPosition.elbowInfo.targetValue) {
|
|
checkElbowIKWeightResult = true;
|
|
}
|
|
|
|
if (fullBodyAwarenessActive) {
|
|
checkElbowIKWeightResult = true;
|
|
}
|
|
|
|
if (checkElbowIKWeightResult) {
|
|
float elbowIKTargetValue = currentIKWeaponsPosition.elbowInfo.targetValue;
|
|
|
|
if (fullBodyAwarenessActive && IKWeaponsSettings.ignoreIKElbowsOnFBA) {
|
|
elbowIKTargetValue = 0;
|
|
}
|
|
|
|
currentIKWeaponsPosition.elbowInfo.elbowIKWeight =
|
|
Mathf.MoveTowards (currentIKWeaponsPosition.elbowInfo.elbowIKWeight,
|
|
elbowIKTargetValue,
|
|
currentDeltaTime * currentIKWeaponsPosition.IKSpeed);
|
|
}
|
|
|
|
if (disablingDualWeapons) {
|
|
if (currentIKWeaponsPosition.HandIKWeight == 0) {
|
|
handsDisabled++;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (IKWeaponsLeftHandSettings != null && IKWeaponsLeftHandSettings.dualWeaponActive) {
|
|
currentIKWeaponsPosition = IKWeaponsLeftHandSettings.leftHandDualWeaponInfo.handsInfo [0];
|
|
|
|
if (currentIKWeaponsPosition.HandIKWeight != currentIKWeaponsPosition.targetValue) {
|
|
|
|
currentIKWeaponsPosition.HandIKWeight =
|
|
Mathf.MoveTowards (currentIKWeaponsPosition.HandIKWeight,
|
|
currentIKWeaponsPosition.targetValue,
|
|
currentDeltaTime * currentIKWeaponsPosition.IKSpeed);
|
|
}
|
|
|
|
bool checkElbowIKWeightResult = false;
|
|
|
|
if (currentIKWeaponsPosition.elbowInfo.elbowIKWeight != currentIKWeaponsPosition.elbowInfo.targetValue) {
|
|
checkElbowIKWeightResult = true;
|
|
}
|
|
|
|
if (fullBodyAwarenessActive) {
|
|
checkElbowIKWeightResult = true;
|
|
}
|
|
|
|
if (checkElbowIKWeightResult) {
|
|
float elbowIKTargetValue = currentIKWeaponsPosition.elbowInfo.targetValue;
|
|
|
|
if (fullBodyAwarenessActive && IKWeaponsSettings.ignoreIKElbowsOnFBA) {
|
|
elbowIKTargetValue = 0;
|
|
}
|
|
|
|
currentIKWeaponsPosition.elbowInfo.elbowIKWeight =
|
|
Mathf.MoveTowards (currentIKWeaponsPosition.elbowInfo.elbowIKWeight,
|
|
elbowIKTargetValue,
|
|
currentDeltaTime * currentIKWeaponsPosition.IKSpeed);
|
|
}
|
|
|
|
if (disablingDualWeapons) {
|
|
if (currentIKWeaponsPosition.HandIKWeight == 0) {
|
|
handsDisabled++;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
int handsInfoCount = IKWeaponsSettings.handsInfo.Count;
|
|
|
|
for (int j = 0; j < handsInfoCount; j++) {
|
|
currentIKWeaponsPosition = IKWeaponsSettings.handsInfo [j];
|
|
|
|
if (currentIKWeaponsPosition.HandIKWeight != currentIKWeaponsPosition.targetValue &&
|
|
(!currentIKWeaponsPosition.ignoreIKWeight || currentIKWeaponsPosition.targetValue == 0)) {
|
|
|
|
currentIKWeaponsPosition.HandIKWeight =
|
|
Mathf.MoveTowards (currentIKWeaponsPosition.HandIKWeight,
|
|
currentIKWeaponsPosition.targetValue,
|
|
currentDeltaTime * currentIKWeaponsPosition.IKSpeed);
|
|
}
|
|
|
|
bool checkElbowIKWeightResult = false;
|
|
|
|
if (currentIKWeaponsPosition.elbowInfo.elbowIKWeight != currentIKWeaponsPosition.elbowInfo.targetValue &&
|
|
(!currentIKWeaponsPosition.ignoreIKWeight || currentIKWeaponsPosition.elbowInfo.targetValue == 0)) {
|
|
checkElbowIKWeightResult = true;
|
|
}
|
|
|
|
if (fullBodyAwarenessActive) {
|
|
checkElbowIKWeightResult = true;
|
|
}
|
|
|
|
if (checkElbowIKWeightResult) {
|
|
|
|
float elbowIKTargetValue = currentIKWeaponsPosition.elbowInfo.targetValue;
|
|
|
|
if (fullBodyAwarenessActive && IKWeaponsSettings.ignoreIKElbowsOnFBA) {
|
|
elbowIKTargetValue = 0;
|
|
}
|
|
|
|
currentIKWeaponsPosition.elbowInfo.elbowIKWeight =
|
|
Mathf.MoveTowards (currentIKWeaponsPosition.elbowInfo.elbowIKWeight,
|
|
elbowIKTargetValue,
|
|
currentDeltaTime * currentIKWeaponsPosition.IKSpeed);
|
|
}
|
|
|
|
if (disableWeapons) {
|
|
if (currentIKWeaponsPosition.HandIKWeight == 0) {
|
|
handsDisabled++;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (disableWeapons || disablingDualWeapons) {
|
|
if (handsDisabled == 2) {
|
|
setDisableWeaponsState (false);
|
|
|
|
handsDisabled = 0;
|
|
|
|
usingDualWeapon = false;
|
|
|
|
setUsingWeaponsState (false);
|
|
|
|
checkHandsInPosition (false);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (usingZipline) {
|
|
if (IKWeight != IKWeightTargetValue) {
|
|
IKWeight = Mathf.MoveTowards (IKWeight, IKWeightTargetValue, Time.deltaTime * IKSpeed);
|
|
}
|
|
}
|
|
|
|
if (IKBodyInfoActive && !isThirdPersonView && resetIKCOMRotationChecked) {
|
|
IKBodyCOM.localRotation = Quaternion.identity;
|
|
resetIKCOMRotationChecked = false;
|
|
}
|
|
|
|
if (!driving && !usingWeapons && IKWeight > 0 && usingArms) {
|
|
//set the current hand target position and rotation
|
|
animator.SetIKPositionWeight (currentHand, IKWeight);
|
|
animator.SetIKRotationWeight (currentHand, IKWeight);
|
|
|
|
animator.SetIKPosition (currentHand, currentHandIKPos.position);
|
|
animator.SetIKRotation (currentHand, currentHandIKPos.rotation);
|
|
|
|
animator.SetIKHintPositionWeight (currenElbow, IKWeight);
|
|
animator.SetIKHintPosition (currenElbow, currentElbowIKPos.position);
|
|
}
|
|
|
|
//if the player is driving, set all the position and rotations of every player's limb
|
|
if (driving) {
|
|
if (IKDrivingSettings.disableIKOnPassengerSmoothly) {
|
|
IKDrivingSettings.currentDriveIkWeightValue = Mathf.Lerp (IKDrivingSettings.currentDriveIkWeightValue, 0, Time.deltaTime * 2);
|
|
} else {
|
|
if (IKDrivingSettings.currentDriveIkWeightValue != 1) {
|
|
IKDrivingSettings.currentDriveIkWeightValue = Mathf.Lerp (IKDrivingSettings.currentDriveIkWeightValue, 1, Time.deltaTime * 2);
|
|
}
|
|
}
|
|
|
|
currentDriveIkWeightValue = IKDrivingSettings.currentDriveIkWeightValue;
|
|
|
|
if (IKDrivingSettings.useIKOnVehicle) {
|
|
int IKDrivingPosCount = IKDrivingSettings.IKDrivingPos.Count;
|
|
|
|
for (int i = 0; i < IKDrivingPosCount; i++) {
|
|
//hands and foots
|
|
currentIKDrivingPositions = IKDrivingSettings.IKDrivingPos [i];
|
|
|
|
currentIKGoal = currentIKDrivingPositions.limb;
|
|
|
|
animator.SetIKPositionWeight (currentIKGoal, currentDriveIkWeightValue);
|
|
animator.SetIKRotationWeight (currentIKGoal, currentDriveIkWeightValue);
|
|
|
|
animator.SetIKPosition (currentIKGoal, currentIKDrivingPositions.position.position);
|
|
animator.SetIKRotation (currentIKGoal, currentIKDrivingPositions.position.rotation);
|
|
}
|
|
|
|
//knees and elbows
|
|
|
|
int IKDrivingKneePosCount = IKDrivingSettings.IKDrivingKneePos.Count;
|
|
|
|
for (int i = 0; i < IKDrivingKneePosCount; i++) {
|
|
currentIKDrivingKneePositions = IKDrivingSettings.IKDrivingKneePos [i];
|
|
|
|
animator.SetIKHintPositionWeight (currentIKDrivingKneePositions.knee, currentDriveIkWeightValue);
|
|
|
|
animator.SetIKHintPosition (currentIKDrivingKneePositions.knee, currentIKDrivingKneePositions.position.position);
|
|
}
|
|
}
|
|
|
|
if (IKDrivingSettings.adjustPassengerPositionActive) {
|
|
//comment/discomment these two lines to edit correctly the body position of the player ingame.
|
|
transform.position = IKDrivingSettings.vehicleSeatInfo.seatTransform.position;
|
|
transform.rotation = IKDrivingSettings.vehicleSeatInfo.seatTransform.rotation;
|
|
}
|
|
|
|
//set the rotation of the upper body of the player according to the steering direction
|
|
if (IKDrivingSettings.useIKOnVehicle) {
|
|
if (IKDrivingSettings.useSteerDirection) {
|
|
if (IKDrivingSettings.steerDirecion != null) {
|
|
Vector3 lookDirection = IKDrivingSettings.steerDirecion.transform.forward + IKDrivingSettings.steerDirecion.transform.position;
|
|
animator.SetLookAtPosition (lookDirection);
|
|
|
|
animator.SetLookAtWeight (settings.weight, settings.bodyWeight, settings.headWeight, settings.eyesWeight, settings.clampWeight);
|
|
}
|
|
}
|
|
|
|
if (IKDrivingSettings.shakePlayerBodyOnCollision) {
|
|
IKDrivingSettings.currentSeatShake = Vector3.Lerp (IKDrivingSettings.currentSeatShake, Vector3.zero, Time.deltaTime * IKDrivingSettings.shakeFadeSpeed);
|
|
|
|
drivingBodyRotation = IKDrivingSettings.currentAngularDirection;
|
|
|
|
drivingBodyRotation = Vector3.Scale (drivingBodyRotation, IKDrivingSettings.forceDirection);
|
|
|
|
drivingBodyRotation.x += ((Mathf.Cos (Time.time * IKDrivingSettings.shakeSpeed)) / 2) * IKDrivingSettings.currentSeatShake.x;
|
|
drivingBodyRotation.y -= (Mathf.Cos (Time.time * IKDrivingSettings.shakeSpeed)) * IKDrivingSettings.currentSeatShake.y;
|
|
drivingBodyRotation.z -= ((Mathf.Sin (Time.time * IKDrivingSettings.shakeSpeed)) / 2) * IKDrivingSettings.currentSeatShake.z;
|
|
|
|
drivingBodyRotation.x = Mathf.Clamp (drivingBodyRotation.x, IKDrivingSettings.shakeForceDirectionMinClamp.z, IKDrivingSettings.shakeForceDirectionMaxClamp.z);
|
|
drivingBodyRotation.y = Mathf.Clamp (drivingBodyRotation.y, IKDrivingSettings.shakeForceDirectionMinClamp.y, IKDrivingSettings.shakeForceDirectionMaxClamp.y);
|
|
drivingBodyRotation.z = Mathf.Clamp (drivingBodyRotation.z, IKDrivingSettings.shakeForceDirectionMinClamp.x, IKDrivingSettings.shakeForceDirectionMaxClamp.x);
|
|
|
|
IKDrivingSettings.currentSeatUpRotation = drivingBodyRotation;
|
|
|
|
IKDrivingSettings.playerBodyParent.localRotation =
|
|
Quaternion.Lerp (IKDrivingSettings.playerBodyParent.localRotation, Quaternion.Euler (IKDrivingSettings.currentSeatUpRotation), Time.deltaTime * IKDrivingSettings.stabilitySpeed);
|
|
}
|
|
|
|
if (IKDrivingSettings.useHeadLookPosition) {
|
|
if (IKDrivingSettings.headLookPosition != null) {
|
|
animator.SetLookAtWeight (1, 0, 1);
|
|
animator.SetLookAtPosition (IKDrivingSettings.headLookPosition.position);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (IKDrivingSettings.setSteeringWheelAnimationFromInput) {
|
|
if (IKDrivingSettings.horizontalAnimatorID == -1) {
|
|
IKDrivingSettings.horizontalAnimatorID = Animator.StringToHash (IKDrivingSettings.horizontalAnimatorName);
|
|
} else {
|
|
animator.SetFloat (IKDrivingSettings.horizontalAnimatorID, IKDrivingSettings.currentSteeringWheelInputValue, 0.1f, Time.fixedDeltaTime);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (fullBodyAwarenessActive) {
|
|
if (headTrackIKComponentLocated) {
|
|
if (headTrackIKComponent.isUpdateIKEnabled ()) {
|
|
headTrackIKComponent.updateOnAnimatorIKState ();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!driving && usingWeapons) {
|
|
if (usingDualWeapon) {
|
|
if (IKWeaponsRightHandSettings != null && IKWeaponsRightHandSettings.dualWeaponActive) {
|
|
currentIKWeaponsPosition = IKWeaponsRightHandSettings.rightHandDualWeaopnInfo.handsInfo [0];
|
|
|
|
currentIKGoal = currentIKWeaponsPosition.limb;
|
|
|
|
animator.SetIKPositionWeight (currentIKGoal, currentIKWeaponsPosition.HandIKWeight);
|
|
animator.SetIKRotationWeight (currentIKGoal, currentIKWeaponsPosition.HandIKWeight);
|
|
|
|
if (currentIKWeaponsPosition.transformFollowByHand != null) {
|
|
animator.SetIKPosition (currentIKGoal, currentIKWeaponsPosition.transformFollowByHand.position);
|
|
animator.SetIKRotation (currentIKGoal, currentIKWeaponsPosition.transformFollowByHand.rotation);
|
|
}
|
|
|
|
currentIKHint = currentIKWeaponsPosition.elbowInfo.elbow;
|
|
|
|
animator.SetIKHintPositionWeight (currentIKHint, currentIKWeaponsPosition.elbowInfo.elbowIKWeight);
|
|
animator.SetIKHintPosition (currentIKHint, currentIKWeaponsPosition.elbowInfo.position.position);
|
|
}
|
|
|
|
if (IKWeaponsLeftHandSettings != null && IKWeaponsLeftHandSettings.dualWeaponActive) {
|
|
currentIKWeaponsPosition = IKWeaponsLeftHandSettings.leftHandDualWeaponInfo.handsInfo [0];
|
|
|
|
currentIKGoal = currentIKWeaponsPosition.limb;
|
|
|
|
animator.SetIKPositionWeight (currentIKGoal, currentIKWeaponsPosition.HandIKWeight);
|
|
animator.SetIKRotationWeight (currentIKGoal, currentIKWeaponsPosition.HandIKWeight);
|
|
|
|
if (currentIKWeaponsPosition.transformFollowByHand != null) {
|
|
animator.SetIKPosition (currentIKGoal, currentIKWeaponsPosition.transformFollowByHand.position);
|
|
animator.SetIKRotation (currentIKGoal, currentIKWeaponsPosition.transformFollowByHand.rotation);
|
|
}
|
|
|
|
currentIKHint = currentIKWeaponsPosition.elbowInfo.elbow;
|
|
|
|
animator.SetIKHintPositionWeight (currentIKHint, currentIKWeaponsPosition.elbowInfo.elbowIKWeight);
|
|
animator.SetIKHintPosition (currentIKHint, currentIKWeaponsPosition.elbowInfo.position.position);
|
|
}
|
|
} else {
|
|
int handsInfoCount = IKWeaponsSettings.handsInfo.Count;
|
|
|
|
for (int i = 0; i < handsInfoCount; i++) {
|
|
currentIKWeaponsPosition = IKWeaponsSettings.handsInfo [i];
|
|
|
|
if (currentIKWeaponsPosition.handUsedInWeapon) {
|
|
currentIKGoal = currentIKWeaponsPosition.limb;
|
|
|
|
animator.SetIKPositionWeight (currentIKGoal, currentIKWeaponsPosition.HandIKWeight);
|
|
animator.SetIKRotationWeight (currentIKGoal, currentIKWeaponsPosition.HandIKWeight);
|
|
|
|
if (currentIKWeaponsPosition.transformFollowByHand != null) {
|
|
animator.SetIKPosition (currentIKGoal, currentIKWeaponsPosition.transformFollowByHand.position);
|
|
animator.SetIKRotation (currentIKGoal, currentIKWeaponsPosition.transformFollowByHand.rotation);
|
|
}
|
|
|
|
currentIKHint = currentIKWeaponsPosition.elbowInfo.elbow;
|
|
|
|
animator.SetIKHintPositionWeight (currentIKHint, currentIKWeaponsPosition.elbowInfo.elbowIKWeight);
|
|
|
|
animator.SetIKHintPosition (currentIKHint, currentIKWeaponsPosition.elbowInfo.position.position);
|
|
}
|
|
}
|
|
}
|
|
|
|
if (weaponsManager.currentWeaponUsesHeadLookWhenAiming () && !fullBodyAwarenessActive) {
|
|
if (weaponsManager.isAimingInThirdPerson () && !weaponsManager.isReloadingWithAnimationActive ()) {
|
|
headWeightTarget = 1;
|
|
} else {
|
|
headWeightTarget = 0;
|
|
}
|
|
|
|
if (currentHeadWeight != headWeightTarget) {
|
|
currentHeadWeight = Mathf.MoveTowards (currentHeadWeight, headWeightTarget, Time.deltaTime * weaponsManager.getCurrentWeaponHeadLookSpeed ());
|
|
}
|
|
|
|
animator.SetLookAtWeight (fireWeaponsHeadWeight, fireWeaponsBodyWeight, currentHeadWeight);
|
|
animator.SetLookAtPosition (weaponsManager.getCurrentHeadLookTargetPosition ());
|
|
}
|
|
}
|
|
|
|
if (!driving) {
|
|
if (headLookStateEnabled) {
|
|
|
|
if (disableHeadLookState) {
|
|
if (headWeightTarget == 0 && currentHeadWeight == 0) {
|
|
headLookStateEnabled = false;
|
|
}
|
|
} else {
|
|
if (powersManager.aimingInThirdPerson) {
|
|
headWeightTarget = 1;
|
|
} else {
|
|
headWeightTarget = 0;
|
|
}
|
|
}
|
|
|
|
if (currentHeadWeight != headWeightTarget) {
|
|
currentHeadWeight = Mathf.MoveTowards (currentHeadWeight, headWeightTarget, Time.deltaTime * headLookSpeed);
|
|
}
|
|
|
|
animator.SetLookAtWeight (1, 0, currentHeadWeight);
|
|
animator.SetLookAtPosition (headLookTarget.position);
|
|
}
|
|
}
|
|
|
|
if (usingZipline) {
|
|
int IKZiplineSettingsIKGoalsCount = IKZiplineSettings.IKGoals.Count;
|
|
|
|
for (int i = 0; i < IKZiplineSettingsIKGoalsCount; i++) {
|
|
currentIKGoalsZiplinePositions = IKZiplineSettings.IKGoals [i];
|
|
|
|
currentIKGoal = currentIKGoalsZiplinePositions.limb;
|
|
|
|
animator.SetIKPositionWeight (currentIKGoal, IKWeight);
|
|
animator.SetIKRotationWeight (currentIKGoal, IKWeight);
|
|
|
|
animator.SetIKPosition (currentIKGoal, currentIKGoalsZiplinePositions.position.position);
|
|
animator.SetIKRotation (currentIKGoal, currentIKGoalsZiplinePositions.position.rotation);
|
|
}
|
|
|
|
int IKZiplineSettingsIKHintsCount = IKZiplineSettings.IKHints.Count;
|
|
|
|
for (int i = 0; i < IKZiplineSettingsIKHintsCount; i++) {
|
|
currentIKHintsZiplinePositions = IKZiplineSettings.IKHints [i];
|
|
|
|
currentIKHint = currentIKHintsZiplinePositions.limb;
|
|
|
|
animator.SetIKHintPositionWeight (currentIKHint, IKWeight);
|
|
animator.SetIKHintPosition (currentIKHint, currentIKHintsZiplinePositions.position.position);
|
|
}
|
|
|
|
transform.position = IKZiplineSettings.bodyPosition.position;
|
|
transform.rotation = IKZiplineSettings.bodyPosition.rotation;
|
|
}
|
|
|
|
if (isThirdPersonView && objectGrabbed) {
|
|
|
|
if (IKSystemEnabledToGrab) {
|
|
int handInfoListCount = handInfoList.Count;
|
|
|
|
for (int j = 0; j < handInfoListCount; j++) {
|
|
|
|
currentHandInfo = handInfoList [j];
|
|
|
|
if (currentHandInfo.useHand) {
|
|
|
|
if (currentHandInfo.handTransform != null) {
|
|
currentHandInfo.handPosition = currentHandInfo.handTransform.position;
|
|
currentHandInfo.handRotation = currentHandInfo.handTransform.rotation;
|
|
}
|
|
|
|
currentHandInfo.currentHandWeight = 1;
|
|
|
|
currentIKGoal = currentHandInfo.IKGoal;
|
|
|
|
animator.SetIKRotationWeight (currentIKGoal, currentHandInfo.currentHandWeight);
|
|
animator.SetIKPositionWeight (currentIKGoal, currentHandInfo.currentHandWeight);
|
|
|
|
animator.SetIKPosition (currentIKGoal, currentHandInfo.handPosition);
|
|
animator.SetIKRotation (currentIKGoal, currentHandInfo.handRotation);
|
|
|
|
if (currentHandInfo.useElbow) {
|
|
|
|
if (currentHandInfo.elbowTransform != null) {
|
|
currentHandInfo.elbowPosition = currentHandInfo.elbowTransform.position;
|
|
}
|
|
|
|
currentIKHint = currentHandInfo.IKHint;
|
|
|
|
animator.SetIKHintPositionWeight (currentIKHint, currentHandInfo.currentHandWeight);
|
|
|
|
animator.SetIKHintPosition (currentIKHint, currentHandInfo.elbowPosition);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (isThirdPersonView && IKBodyInfoActive) {
|
|
if (!playerControllerManager.isPlayerOnGround () || disablingIKBodyInfoActive) {
|
|
resetIKCOMRotationChecked = true;
|
|
|
|
playerInputAxis = playerControllerManager.getAxisValues ();
|
|
|
|
int numberOfLimbsActive = 0;
|
|
|
|
int currentIKBodyInfoListCount = currentIKBodyInfoList.Count;
|
|
|
|
bool isActionActive = playerControllerManager.isActionActive ();
|
|
|
|
for (int j = 0; j < currentIKBodyInfoListCount; j++) {
|
|
|
|
currentIKBodyInfo = currentIKBodyInfoList [j];
|
|
|
|
if (currentIKBodyInfo.IKBodyPartEnabled) {
|
|
|
|
if (IKBodyPaused || isActionActive) {
|
|
if (!currentIKBodyInfo.bodyPartBusy) {
|
|
currentIKBodyInfo.bodyPartBusy = true;
|
|
currentIKBodyInfo.IKBodyWeigthTarget = 0;
|
|
}
|
|
} else {
|
|
if (currentIKBodyInfo.isHand) {
|
|
if (!usingHands) {
|
|
if (currentIKBodyInfo.bodyPartBusy) {
|
|
currentIKBodyInfo.bodyPartBusy = false;
|
|
currentIKBodyInfo.IKBodyWeigthTarget = 1;
|
|
}
|
|
} else {
|
|
if (!currentIKBodyInfo.bodyPartBusy) {
|
|
currentIKBodyInfo.bodyPartBusy = true;
|
|
currentIKBodyInfo.IKBodyWeigthTarget = 0;
|
|
}
|
|
}
|
|
} else {
|
|
if (!isActionActive) {
|
|
if (currentIKBodyInfo.bodyPartBusy) {
|
|
currentIKBodyInfo.bodyPartBusy = false;
|
|
currentIKBodyInfo.IKBodyWeigthTarget = 1;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (currentIKBodyInfo.currentIKWeight != currentIKBodyInfo.IKBodyWeigthTarget) {
|
|
|
|
if (currentIKBodyInfo.bodyPartBusy) {
|
|
currentWeightLerpSpeed = currentIKBodyInfoState.busyBodyPartWeightLerpSpeed;
|
|
} else {
|
|
currentWeightLerpSpeed = currentIKBodyInfo.weightLerpSpeed;
|
|
}
|
|
|
|
currentIKBodyInfo.currentIKWeight = Mathf.MoveTowards (currentIKBodyInfo.currentIKWeight,
|
|
currentIKBodyInfo.IKBodyWeigthTarget, Time.deltaTime * currentWeightLerpSpeed);
|
|
} else {
|
|
|
|
if (currentIKBodyInfo.currentIKWeight == 0 && currentIKBodyInfo.IKBodyWeigthTarget == 0) {
|
|
numberOfLimbsActive++;
|
|
}
|
|
|
|
if (numberOfLimbsActive == currentIKBodyInfoList.Count && disablingIKBodyInfoActive) {
|
|
IKBodyInfoActive = false;
|
|
disablingIKBodyInfoActive = false;
|
|
|
|
return;
|
|
}
|
|
}
|
|
|
|
bool applyIKToBodyPart = false;
|
|
|
|
if (!currentIKBodyInfo.bodyPartBusy) {
|
|
if (playerInputAxis == Vector2.zero) {
|
|
currentIKBodyInfo.currentLimbVerticalMovementSpeed = currentIKBodyInfo.limbVerticalMovementSpeed;
|
|
} else {
|
|
currentIKBodyInfo.currentLimbVerticalMovementSpeed = currentIKBodyInfo.slowLimbVerticalMovementSpeed;
|
|
}
|
|
|
|
if (Time.time > lastTimeIkBodyStateActive + currentIKBodyInfoState.delayForVerticalMovement) {
|
|
if (currentIKBodyInfo.useSin) {
|
|
currentIKBodyInfo.posTargetY = Mathf.Sin (Time.time * currentIKBodyInfo.currentLimbVerticalMovementSpeed) * currentIKBodyInfo.limbMovementAmount;
|
|
} else {
|
|
currentIKBodyInfo.posTargetY = Mathf.Cos (Time.time * currentIKBodyInfo.currentLimbVerticalMovementSpeed) * currentIKBodyInfo.limbMovementAmount;
|
|
}
|
|
} else {
|
|
currentIKBodyInfo.posTargetY = Mathf.Lerp (currentIKBodyInfo.posTargetY, 0, Time.deltaTime / currentIKBodyInfoState.verticalMovementTransitionSpeed);
|
|
}
|
|
|
|
if (playerControllerManager.isPlayerMovingOn3dWorld ()) {
|
|
currentIKBodyInfo.newPosition = new Vector3 (-playerInputAxis.x, currentIKBodyInfo.posTargetY, -playerInputAxis.y);
|
|
} else {
|
|
currentIKBodyInfo.newPosition = new Vector3 (0, currentIKBodyInfo.posTargetY - (playerInputAxis.y / 8), -Mathf.Abs (playerInputAxis.x));
|
|
}
|
|
|
|
currentIKBodyInfo.newPosition.x = Mathf.Clamp (currentIKBodyInfo.newPosition.x, currentIKBodyInfo.minClampPosition.x, currentIKBodyInfo.maxClampPosition.x);
|
|
|
|
currentIKBodyInfo.newPosition.z = Mathf.Clamp (currentIKBodyInfo.newPosition.z, currentIKBodyInfo.minClampPosition.y, currentIKBodyInfo.maxClampPosition.y);
|
|
|
|
currentIKBodyInfo.newPosition += currentIKBodyInfo.originalPosition;
|
|
|
|
|
|
currentIKBodyInfo.targetToFollow.localPosition = Vector3.Slerp (currentIKBodyInfo.targetToFollow.localPosition,
|
|
currentIKBodyInfo.newPosition, Time.deltaTime * currentIKBodyInfo.limbsMovementSpeed);
|
|
|
|
|
|
currentIKBodyInfo.IKGoalPosition = currentIKBodyInfo.targetToFollow.position;
|
|
currentIKBodyInfo.IKGoalRotation = currentIKBodyInfo.targetToFollow.rotation;
|
|
|
|
applyIKToBodyPart = true;
|
|
|
|
} else if (currentIKBodyInfo.currentIKWeight != currentIKBodyInfo.IKBodyWeigthTarget) {
|
|
applyIKToBodyPart = true;
|
|
}
|
|
|
|
if (applyIKToBodyPart) {
|
|
if (currentIKBodyInfo.useIKHint) {
|
|
|
|
currentIKHint = currentIKBodyInfo.IKHint;
|
|
|
|
animator.SetIKHintPositionWeight (currentIKHint, currentIKBodyInfo.currentIKWeight);
|
|
animator.SetIKHintPosition (currentIKHint, currentIKBodyInfo.IKGoalPosition);
|
|
} else {
|
|
currentIKGoal = currentIKBodyInfo.IKGoal;
|
|
|
|
animator.SetIKRotationWeight (currentIKGoal, currentIKBodyInfo.currentIKWeight);
|
|
animator.SetIKPositionWeight (currentIKGoal, currentIKBodyInfo.currentIKWeight);
|
|
animator.SetIKPosition (currentIKGoal, currentIKBodyInfo.IKGoalPosition);
|
|
animator.SetIKRotation (currentIKGoal, currentIKBodyInfo.IKGoalRotation);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!disablingIKBodyInfoActive) {
|
|
if (weaponsManager.isUsingWeapons ()) {
|
|
targetRotation = Vector3.zero;
|
|
} else {
|
|
|
|
if (currentIKBodyInfoState.increaseRotationAmountWhenHigherSpeed && playerControllerManager.isMovementSpeedIncreased ()) {
|
|
currentIKBodyInfoState.currentIKBodyCOMRotationAmountX = currentIKBodyInfoState.increasedIKBodyCOMRotationAmountX;
|
|
currentIKBodyInfoState.currentIKBodyCOMRotationAmountY = currentIKBodyInfoState.increasedIKBodyComRotationAmountY;
|
|
|
|
currentIKBodyInfoState.currentIKBodyCOMRotationSpeed = currentIKBodyInfoState.increasedIKBodyCOMRotationSpeed;
|
|
|
|
} else {
|
|
currentIKBodyInfoState.currentIKBodyCOMRotationAmountX = currentIKBodyInfoState.IKBodyCOMRotationAmountX;
|
|
currentIKBodyInfoState.currentIKBodyCOMRotationAmountY = currentIKBodyInfoState.IKBodyComRotationAmountY;
|
|
|
|
currentIKBodyInfoState.currentIKBodyCOMRotationSpeed = currentIKBodyInfoState.IKBodyCOMRotationSpeed;
|
|
}
|
|
|
|
if (playerControllerManager.isPlayerMovingOn3dWorld ()) {
|
|
targetRotation = new Vector3 (playerInputAxis.y * currentIKBodyInfoState.currentIKBodyCOMRotationAmountY,
|
|
0, playerInputAxis.x * currentIKBodyInfoState.currentIKBodyCOMRotationAmountX);
|
|
} else {
|
|
targetRotation = new Vector3 (currentIKBodyInfoState.currentIKBodyCOMRotationAmountX * (-(Math.Abs (playerInputAxis.x) - playerInputAxis.y)), 0, 0);
|
|
}
|
|
}
|
|
|
|
IKBodyCOM.localRotation = Quaternion.Lerp (IKBodyCOM.localRotation, Quaternion.Euler (targetRotation), Time.deltaTime * currentIKBodyInfoState.currentIKBodyCOMRotationSpeed);
|
|
}
|
|
} else if (playerControllerManager.isPlayerOnGround ()) {
|
|
IKBodyCOM.localRotation = Quaternion.Lerp (IKBodyCOM.localRotation, Quaternion.identity, Time.deltaTime * currentIKBodyInfoState.currentIKBodyCOMRotationSpeed);
|
|
}
|
|
}
|
|
|
|
if (handsOnSurfaceIKComponentLocated) {
|
|
handsOnSurfaceIKComponent.updateOnAnimatorIKState ();
|
|
}
|
|
|
|
if (IKFootSystemComponentLocated) {
|
|
IKFootSystemComponent.updateOnAnimatorIKState ();
|
|
}
|
|
|
|
if (!fullBodyAwarenessActive) {
|
|
if (headTrackIKComponentLocated) {
|
|
if (headTrackIKComponent.isUpdateIKEnabled ()) {
|
|
headTrackIKComponent.updateOnAnimatorIKState ();
|
|
}
|
|
}
|
|
}
|
|
|
|
if (bulletTimeIKComponentLocated) {
|
|
if (bulletTimeIKComponent.isUpdateIKEnabled ()) {
|
|
bulletTimeIKComponent.updateOnAnimatorIKState ();
|
|
}
|
|
}
|
|
|
|
if (temporalOnAnimatorIKComponentAssigned) {
|
|
if (temporalOnAnimatorIKComponent.isUpdateIKEnabled ()) {
|
|
temporalOnAnimatorIKComponent.updateOnAnimatorIKState ();
|
|
}
|
|
}
|
|
}
|
|
|
|
public bool isFullBodyAwarenessActive ()
|
|
{
|
|
return fullBodyAwarenessActive;
|
|
}
|
|
|
|
public void setFullBodyAwarenessActiveState (bool state)
|
|
{
|
|
fullBodyAwarenessActive = state;
|
|
}
|
|
|
|
public void setHeadLookState (bool state, float newHeadLookSpeed, Transform newHeadLookTarget)
|
|
{
|
|
if (state) {
|
|
headLookStateEnabled = state;
|
|
headWeightTarget = 1;
|
|
} else {
|
|
headWeightTarget = 0;
|
|
}
|
|
|
|
disableHeadLookState = !state;
|
|
|
|
headLookSpeed = newHeadLookSpeed;
|
|
headLookTarget = newHeadLookTarget;
|
|
}
|
|
|
|
|
|
public bool getUsingHands ()
|
|
{
|
|
return usingHands;
|
|
}
|
|
|
|
public bool isObjectGrabbed ()
|
|
{
|
|
return objectGrabbed;
|
|
}
|
|
|
|
public float getHeadWeight ()
|
|
{
|
|
return currentHeadWeight;
|
|
}
|
|
|
|
public bool isUsingWeapons ()
|
|
{
|
|
return usingWeapons;
|
|
}
|
|
|
|
//change the ik weight in the current arm
|
|
public void changeArmState (float value)
|
|
{
|
|
if (currentAimMode == aimMode.weapons) {
|
|
usingArms = false;
|
|
} else {
|
|
usingArms = true;
|
|
}
|
|
|
|
IKWeightTargetValue = value;
|
|
|
|
if (usingZipline) {
|
|
IKWeightTargetValue = 1;
|
|
}
|
|
}
|
|
|
|
public void disableArmsState ()
|
|
{
|
|
usingArms = false;
|
|
IKWeightTargetValue = 0;
|
|
IKWeight = 0;
|
|
}
|
|
|
|
//change current arm to aim
|
|
public void changeArmSide (bool value)
|
|
{
|
|
if (value) {
|
|
//set the right arm as the current ik position
|
|
currentHandIKPos.position = rightHandIKPos.position;
|
|
currentHandIKPos.rotation = rightHandIKPos.rotation;
|
|
currentHand = AvatarIKGoal.RightHand;
|
|
|
|
currentElbowIKPos.position = rightElbowIKPos.position;
|
|
currenElbow = AvatarIKHint.RightElbow;
|
|
} else {
|
|
//set the left arm as the current ik position
|
|
currentHandIKPos.position = leftHandIKPos.position;
|
|
currentHandIKPos.rotation = leftHandIKPos.rotation;
|
|
currentHand = AvatarIKGoal.LeftHand;
|
|
|
|
currentElbowIKPos.position = leftElbowIKPos.position;
|
|
currenElbow = AvatarIKHint.LeftElbow;
|
|
}
|
|
|
|
originalDist = currentHandIKPos.localPosition.y;
|
|
currentDist = originalDist;
|
|
hitDist = originalDist;
|
|
}
|
|
|
|
//set if the player is driving or not, getting the current positions to every player's limb
|
|
public void setDrivingState (bool state, IKDrivingSystem.IKDrivingInformation IKPositions)
|
|
{
|
|
driving = state;
|
|
|
|
if (driving) {
|
|
IKDrivingSettings = IKPositions;
|
|
|
|
if (IKDrivingSettings != null && IKDrivingSettings.vehicleSeatInfo.useGrabbingHandID) {
|
|
setGrabbingHandState (IKDrivingSettings.vehicleSeatInfo.rightGrabbingHandID, true);
|
|
setGrabbingHandState (IKDrivingSettings.vehicleSeatInfo.leftGrabbingHandID, false);
|
|
}
|
|
} else {
|
|
if (IKDrivingSettings != null && IKDrivingSettings.vehicleSeatInfo.useGrabbingHandID) {
|
|
setGrabbingHandState (0, true);
|
|
setGrabbingHandState (0, false);
|
|
}
|
|
|
|
if (IKDrivingSettings != null) {
|
|
if (IKDrivingSettings.setSteeringWheelAnimationFromInput) {
|
|
if (IKDrivingSettings.horizontalAnimatorID != -1) {
|
|
animator.SetFloat (IKDrivingSettings.horizontalAnimatorID, 0);
|
|
|
|
IKDrivingSettings.horizontalAnimatorID = -1;
|
|
}
|
|
}
|
|
}
|
|
|
|
IKDrivingSettings = null;
|
|
}
|
|
}
|
|
|
|
public bool checkIfDeactivateIKIfNotAimingActive (IKWeaponInfo IKPositions)
|
|
{
|
|
if (fullBodyAwarenessActive) {
|
|
return false;
|
|
}
|
|
|
|
if (playerControllerManager.isCrouching ()) {
|
|
return true;
|
|
}
|
|
|
|
if (usingDualWeapon) {
|
|
if (IKWeaponsSettings.usedOnRightHand) {
|
|
if (IKPositions.rightHandDualWeaopnInfo.deactivateIKIfNotAiming) {
|
|
return true;
|
|
}
|
|
} else {
|
|
if (IKPositions.leftHandDualWeaponInfo.deactivateIKIfNotAiming) {
|
|
return true;
|
|
}
|
|
}
|
|
} else {
|
|
if (IKPositions.deactivateIKIfNotAiming) {
|
|
return true;
|
|
}
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
public void setIKWeaponState (bool state, IKWeaponInfo IKPositions, bool useHandToDrawWeapon, string weaponName)
|
|
{
|
|
//move hands through the waypoints to grab the weapon
|
|
IKWeaponsSettings = IKPositions;
|
|
|
|
// print ("SET IK WEAPON STATE " + state + " " + useHandToDrawWeapon + " " + weaponName);
|
|
|
|
bool useDrawKeepWeaponAnimation = weaponsManager.isUseDrawKeepWeaponAnimationActiveOnCurrentWeapon () &&
|
|
!weaponsManager.isIgnoreUseDrawKeepWeaponAnimationActive () &&
|
|
!weaponsManager.isUsingDualWeapons ();
|
|
|
|
if (useDrawKeepWeaponAnimation) {
|
|
if (state) {
|
|
weaponsManager.weaponReadyToMove ();
|
|
}
|
|
} else {
|
|
//the player is drawing a weapon
|
|
if (state) {
|
|
setUsingWeaponsState (state);
|
|
|
|
bool deactivateIKIfNotAiming = checkIfDeactivateIKIfNotAimingActive (IKPositions);
|
|
|
|
if (deactivateIKIfNotAiming) {
|
|
setDisableSingleWeaponState (false);
|
|
}
|
|
|
|
if (usingDualWeapon) {
|
|
if (IKWeaponsSettings.usedOnRightHand) {
|
|
currentIKWeaponsPosition = IKWeaponsSettings.rightHandDualWeaopnInfo.handsInfo [0];
|
|
} else {
|
|
currentIKWeaponsPosition = IKWeaponsSettings.leftHandDualWeaponInfo.handsInfo [0];
|
|
}
|
|
|
|
stopIKWeaponHandMovementCoroutine (currentIKWeaponsPosition);
|
|
|
|
setIKHandTargetValue (currentIKWeaponsPosition, 1);
|
|
|
|
currentIKWeaponsPosition.handMovementCoroutine =
|
|
StartCoroutine (moveThroughWaypoints (currentIKWeaponsPosition, false, deactivateIKIfNotAiming, IKWeaponsSettings.usedOnRightHand,
|
|
IKWeaponsSettings.useQuickDrawKeepWeapon, weaponName));
|
|
|
|
} else {
|
|
int handsInfoCount = IKWeaponsSettings.handsInfo.Count;
|
|
|
|
for (int i = 0; i < handsInfoCount; i++) {
|
|
currentIKWeaponsPosition = IKWeaponsSettings.handsInfo [i];
|
|
|
|
if ((currentIKWeaponsPosition.usedToDrawWeapon && useHandToDrawWeapon) || (!currentIKWeaponsPosition.usedToDrawWeapon && !useHandToDrawWeapon)) {
|
|
stopIKWeaponHandMovementCoroutine (currentIKWeaponsPosition);
|
|
|
|
setIKHandTargetValue (currentIKWeaponsPosition, 1);
|
|
|
|
currentIKWeaponsPosition.handMovementCoroutine =
|
|
StartCoroutine (moveThroughWaypoints (currentIKWeaponsPosition, false, IKPositions.deactivateIKIfNotAiming,
|
|
IKWeaponsSettings.usedOnRightHand, IKWeaponsSettings.useQuickDrawKeepWeapon, weaponName));
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
//the player is keeping a weapon
|
|
if (!usingDualWeapon) {
|
|
int handsInfoCount = IKWeaponsSettings.handsInfo.Count;
|
|
|
|
for (int i = 0; i < handsInfoCount; i++) {
|
|
currentIKWeaponsPosition = IKWeaponsSettings.handsInfo [i];
|
|
|
|
if (!currentIKWeaponsPosition.usedToDrawWeapon) {
|
|
stopIKWeaponHandMovementCoroutine (currentIKWeaponsPosition);
|
|
|
|
currentIKWeaponsPosition.handMovementCoroutine =
|
|
StartCoroutine (moveThroughWaypoints (currentIKWeaponsPosition, true, IKPositions.deactivateIKIfNotAiming,
|
|
IKWeaponsSettings.usedOnRightHand, IKWeaponsSettings.useQuickDrawKeepWeapon, weaponName));
|
|
} else {
|
|
if (!currentIKWeaponsPosition.handInPositionToAim) {
|
|
stopIKWeaponHandMovementCoroutine (currentIKWeaponsPosition);
|
|
|
|
setIKHandTargetValue (currentIKWeaponsPosition, 0);
|
|
|
|
setDisableSingleWeaponState (true);
|
|
}
|
|
|
|
checkGrabbingHandsState (false, currentIKWeaponsPosition.useGrabbingHandID,
|
|
currentIKWeaponsPosition.grabbingHandID, currentIKWeaponsPosition.limb == AvatarIKGoal.RightHand);
|
|
}
|
|
}
|
|
|
|
IKWeaponsSettings.handsInPosition = false;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
IEnumerator moveThroughWaypoints (IKWeaponsPosition IKWeapon, bool keepingWeapon, bool deactivateIKIfNotAiming,
|
|
bool isUsedOnDualRightHand, bool useQuickDrawKeepWeapon, string weaponName)
|
|
{
|
|
bool playerIsCrouching = playerControllerManager.isCrouching () && !fullBodyAwarenessActive;
|
|
|
|
deactivateIKIfNotAiming = deactivateIKIfNotAiming || playerIsCrouching;
|
|
|
|
if (fullBodyAwarenessActive) {
|
|
deactivateIKIfNotAiming = false;
|
|
}
|
|
|
|
if (IKWeapon.handUsedInWeapon) {
|
|
Transform follower = IKWeapon.waypointFollower;
|
|
List<Transform> wayPoints = new List<Transform> (IKWeapon.wayPoints);
|
|
|
|
if (keepingWeapon) {
|
|
wayPoints.Reverse ();
|
|
wayPoints.RemoveAt (0);
|
|
}
|
|
|
|
follower.position = IKWeapon.handTransform.position;
|
|
follower.rotation = IKWeapon.handTransform.rotation;
|
|
IKWeapon.transformFollowByHand = follower;
|
|
|
|
if (!useQuickDrawKeepWeapon || !IKWeapon.usedToDrawWeapon) {
|
|
if (!deactivateIKIfNotAiming || IKWeapon.usedToDrawWeapon) {
|
|
|
|
bool targetReached = false;
|
|
|
|
float angleDifference = 0;
|
|
|
|
float movementTimer = 0;
|
|
|
|
int wayPointsCount = wayPoints.Count;
|
|
|
|
for (int i = 0; i < wayPointsCount; i++) {
|
|
|
|
Transform transformPath = wayPoints [i];
|
|
|
|
// find the distance to travel
|
|
float dist = GKC_Utils.distance (follower.position, transformPath.position);
|
|
|
|
// calculate the movement duration
|
|
float duration = dist / IKWeapon.handMovementSpeed;
|
|
float t = 0;
|
|
|
|
targetReached = false;
|
|
|
|
angleDifference = 0;
|
|
|
|
movementTimer = 0;
|
|
|
|
float handDistance = 0;
|
|
|
|
while (!targetReached) {
|
|
t += Time.deltaTime / duration;
|
|
follower.position = Vector3.Lerp (follower.position, transformPath.position, t);
|
|
follower.rotation = Quaternion.Slerp (follower.rotation, transformPath.rotation, t);
|
|
|
|
angleDifference = Quaternion.Angle (follower.rotation, transformPath.rotation);
|
|
|
|
movementTimer += Time.deltaTime;
|
|
|
|
dist = GKC_Utils.distance (transformPath.position, IKWeapon.handTransform.position);
|
|
|
|
handDistance = GKC_Utils.distance (transformPath.position, IKWeapon.handTransform.position);
|
|
|
|
if ((dist < 0.02f && angleDifference < 0.02f && handDistance < 0.02f) || movementTimer > (duration + 0.5f)) {
|
|
// print ("reached");
|
|
targetReached = true;
|
|
} else {
|
|
// print ("moving " + handDistance + " " + dist + " " + angleDifference + " " + movementTimer);
|
|
}
|
|
|
|
yield return null;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (keepingWeapon) {
|
|
IKWeapon.handInPositionToAim = false;
|
|
|
|
setIKHandTargetValue (IKWeapon, 0);
|
|
|
|
bool usingCurrentWeapon = weaponsManager.isPlayerUsingWeapon (weaponName);
|
|
|
|
if (usingCurrentWeapon || weaponsManager.isUsingDualWeapons ()) {
|
|
setDisableSingleWeaponState (true);
|
|
|
|
// print ("player is using " + weaponName + "setting keep state");
|
|
} else {
|
|
// print ("player is not using " + weaponName + " avoiding to disable weapons");
|
|
}
|
|
|
|
IKWeapon.elbowInfo.targetValue = 0;
|
|
} else {
|
|
IKWeapon.handInPositionToAim = true;
|
|
IKWeapon.transformFollowByHand = IKWeapon.position;
|
|
|
|
if (IKWeapon.usedToDrawWeapon) {
|
|
if (usingDualWeapon) {
|
|
if (useQuickDrawKeepWeapon) {
|
|
weaponsManager.dualWeaponReadyToMoveDirectlyOnDrawHand (isUsedOnDualRightHand);
|
|
} else {
|
|
weaponsManager.dualWeaponReadyToMove (isUsedOnDualRightHand);
|
|
}
|
|
} else {
|
|
if (useQuickDrawKeepWeapon) {
|
|
weaponsManager.weaponReadyToMoveDirectlyOnDrawHand ();
|
|
} else {
|
|
weaponsManager.weaponReadyToMove ();
|
|
}
|
|
}
|
|
} else {
|
|
IKWeapon.elbowInfo.targetValue = 1;
|
|
}
|
|
|
|
if (deactivateIKIfNotAiming && !IKWeapon.usedToDrawWeapon) {
|
|
|
|
setIKHandTargetValue (IKWeapon, 0);
|
|
|
|
IKWeapon.elbowInfo.targetValue = 0;
|
|
}
|
|
|
|
if (!deactivateIKIfNotAiming && !IKWeapon.usedToDrawWeapon) {
|
|
setDisableSingleWeaponState (false);
|
|
}
|
|
|
|
checkHandsInPosition (true);
|
|
}
|
|
|
|
checkGrabbingHandsState (!keepingWeapon, IKWeapon.useGrabbingHandID, IKWeapon.grabbingHandID, IKWeapon.limb == AvatarIKGoal.RightHand);
|
|
} else {
|
|
if (keepingWeapon) {
|
|
IKWeapon.handInPositionToAim = false;
|
|
|
|
setDisableSingleWeaponState (true);
|
|
} else {
|
|
IKWeapon.handInPositionToAim = true;
|
|
|
|
if (IKWeapon.usedToDrawWeapon) {
|
|
|
|
if (usingDualWeapon) {
|
|
weaponsManager.dualWeaponReadyToMove (isUsedOnDualRightHand);
|
|
} else {
|
|
weaponsManager.weaponReadyToMove ();
|
|
}
|
|
}
|
|
|
|
checkHandsInPosition (true);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void checkGrabbingHandsState (bool drawingWeapon, bool useGrabbingHandID, int grabbingHandID, bool isRightHand)
|
|
{
|
|
if (useGrabbingHandID) {
|
|
int currentGrabbingHandID = 0;
|
|
|
|
if (drawingWeapon) {
|
|
currentGrabbingHandID = grabbingHandID;
|
|
}
|
|
|
|
setGrabbingHandState (currentGrabbingHandID, isRightHand);
|
|
}
|
|
}
|
|
|
|
public void setGrabbingHandState (int grabbingHandID, bool isRightHand)
|
|
{
|
|
if (!componentEnabled) {
|
|
return;
|
|
}
|
|
|
|
if (showDebugPrint) {
|
|
print ("setting grabbing hand id state " + grabbingHandID + " " + isRightHand);
|
|
}
|
|
|
|
if (isRightHand) {
|
|
animator.SetInteger (rightHandGrabbingIDName, grabbingHandID);
|
|
} else {
|
|
animator.SetInteger (leftHandGrabbingIDName, grabbingHandID);
|
|
}
|
|
}
|
|
|
|
public void checkHandsInPosition (bool drawingWeapon)
|
|
{
|
|
if (usingDualWeapon) {
|
|
if (IKWeaponsRightHandSettings != null && IKWeaponsRightHandSettings.rightHandDualWeaopnInfo.handsInfo.Count > 0) {
|
|
|
|
currentIKWeaponsPosition = IKWeaponsRightHandSettings.rightHandDualWeaopnInfo.handsInfo [0];
|
|
if (currentIKWeaponsPosition.handInPositionToAim == drawingWeapon) {
|
|
IKWeaponsRightHandSettings.rightHandDualWeaopnInfo.handsInPosition = drawingWeapon;
|
|
}
|
|
}
|
|
|
|
if (IKWeaponsLeftHandSettings != null && IKWeaponsLeftHandSettings.leftHandDualWeaponInfo.handsInfo.Count > 0) {
|
|
|
|
currentIKWeaponsPosition = IKWeaponsLeftHandSettings.leftHandDualWeaponInfo.handsInfo [0];
|
|
if (currentIKWeaponsPosition.handInPositionToAim == drawingWeapon) {
|
|
IKWeaponsLeftHandSettings.leftHandDualWeaponInfo.handsInPosition = drawingWeapon;
|
|
}
|
|
}
|
|
} else {
|
|
int numberOfHandsInPosition = 0;
|
|
|
|
for (int i = 0; i < IKWeaponsSettings.handsInfo.Count; i++) {
|
|
if (IKWeaponsSettings.handsInfo [i].handInPositionToAim == drawingWeapon) {
|
|
numberOfHandsInPosition++;
|
|
}
|
|
}
|
|
|
|
if (numberOfHandsInPosition == 2) {
|
|
IKWeaponsSettings.handsInPosition = drawingWeapon;
|
|
}
|
|
|
|
bool useDrawKeepWeaponAnimation = weaponsManager.isUseDrawKeepWeaponAnimationActiveOnCurrentWeapon () &&
|
|
!weaponsManager.isIgnoreUseDrawKeepWeaponAnimationActive () &&
|
|
!weaponsManager.isUsingDualWeapons ();
|
|
|
|
if (useDrawKeepWeaponAnimation) {
|
|
bool handsInPosition = (numberOfHandsInPosition == 2);
|
|
|
|
for (int i = 0; i < IKWeaponsSettings.handsInfo.Count; i++) {
|
|
currentIKWeaponsPosition = IKWeaponsSettings.handsInfo [i];
|
|
|
|
if (currentIKWeaponsPosition.handUsedInWeapon) {
|
|
|
|
if (!drawingWeapon) {
|
|
handsInPosition = false;
|
|
}
|
|
|
|
checkGrabbingHandsState (handsInPosition,
|
|
currentIKWeaponsPosition.useGrabbingHandID,
|
|
currentIKWeaponsPosition.grabbingHandID,
|
|
currentIKWeaponsPosition.limb == AvatarIKGoal.RightHand);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setGrabbingHandStateOnSingleHand (bool carryingWeapon, bool isRightHand, bool handInPosition)
|
|
{
|
|
for (int i = 0; i < IKWeaponsSettings.handsInfo.Count; i++) {
|
|
currentIKWeaponsPosition = IKWeaponsSettings.handsInfo [i];
|
|
|
|
bool handLocated = false;
|
|
|
|
if (currentIKWeaponsPosition.handUsedInWeapon) {
|
|
if (isRightHand) {
|
|
if (currentIKWeaponsPosition.limb == AvatarIKGoal.RightHand) {
|
|
handLocated = true;
|
|
}
|
|
} else {
|
|
if (currentIKWeaponsPosition.limb == AvatarIKGoal.LeftHand) {
|
|
handLocated = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
if (handLocated) {
|
|
|
|
if (!carryingWeapon) {
|
|
handInPosition = false;
|
|
}
|
|
|
|
checkGrabbingHandsState (handInPosition,
|
|
currentIKWeaponsPosition.useGrabbingHandID,
|
|
currentIKWeaponsPosition.grabbingHandID,
|
|
currentIKWeaponsPosition.limb == AvatarIKGoal.RightHand);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void stopIKWeaponsActions ()
|
|
{
|
|
if (usingDualWeapon) {
|
|
if (IKWeaponsRightHandSettings != null && IKWeaponsRightHandSettings.rightHandDualWeaopnInfo.handsInfo.Count > 0) {
|
|
currentIKWeaponsPosition = IKWeaponsRightHandSettings.rightHandDualWeaopnInfo.handsInfo [0];
|
|
|
|
stopIKWeaponHandMovementCoroutine (currentIKWeaponsPosition);
|
|
}
|
|
|
|
if (IKWeaponsLeftHandSettings != null && IKWeaponsLeftHandSettings.leftHandDualWeaponInfo.handsInfo.Count > 0) {
|
|
currentIKWeaponsPosition = IKWeaponsLeftHandSettings.leftHandDualWeaponInfo.handsInfo [0];
|
|
|
|
stopIKWeaponHandMovementCoroutine (currentIKWeaponsPosition);
|
|
}
|
|
} else {
|
|
if (IKWeaponsSettings != null) {
|
|
for (int i = 0; i < IKWeaponsSettings.handsInfo.Count; i++) {
|
|
currentIKWeaponsPosition = IKWeaponsSettings.handsInfo [i];
|
|
|
|
stopIKWeaponHandMovementCoroutine (currentIKWeaponsPosition);
|
|
}
|
|
}
|
|
}
|
|
|
|
setUsingWeaponsState (false);
|
|
|
|
usingDualWeapon = false;
|
|
|
|
setDisableWeaponsState (false);
|
|
}
|
|
|
|
public void quickDrawWeaponState (IKWeaponInfo IKPositions)
|
|
{
|
|
IKWeaponsSettings = IKPositions;
|
|
|
|
if (usingDualWeapon) {
|
|
if (IKWeaponsRightHandSettings != null && IKWeaponsRightHandSettings.rightHandDualWeaopnInfo.handsInfo.Count > 0) {
|
|
currentIKWeaponsPosition = IKWeaponsRightHandSettings.rightHandDualWeaopnInfo.handsInfo [0];
|
|
|
|
stopIKWeaponHandMovementCoroutine (currentIKWeaponsPosition);
|
|
}
|
|
|
|
if (IKWeaponsLeftHandSettings != null && IKWeaponsLeftHandSettings.leftHandDualWeaponInfo.handsInfo.Count > 0) {
|
|
currentIKWeaponsPosition = IKWeaponsLeftHandSettings.leftHandDualWeaponInfo.handsInfo [0];
|
|
|
|
stopIKWeaponHandMovementCoroutine (currentIKWeaponsPosition);
|
|
}
|
|
} else {
|
|
if (IKWeaponsSettings != null) {
|
|
for (int i = 0; i < IKWeaponsSettings.handsInfo.Count; i++) {
|
|
currentIKWeaponsPosition = IKWeaponsSettings.handsInfo [i];
|
|
|
|
stopIKWeaponHandMovementCoroutine (currentIKWeaponsPosition);
|
|
}
|
|
}
|
|
}
|
|
|
|
setUsingWeaponsState (true);
|
|
|
|
if (usingDualWeapon) {
|
|
if (IKWeaponsSettings.usedOnRightHand) {
|
|
currentIKWeaponsPosition = IKWeaponsSettings.rightHandDualWeaopnInfo.handsInfo [0];
|
|
} else {
|
|
currentIKWeaponsPosition = IKWeaponsSettings.leftHandDualWeaponInfo.handsInfo [0];
|
|
}
|
|
|
|
bool deactivateIKIfNotAiming = checkIfDeactivateIKIfNotAimingActive (IKPositions);
|
|
|
|
float targetValue = 1;
|
|
if (deactivateIKIfNotAiming) {
|
|
targetValue = 0;
|
|
}
|
|
|
|
setIKHandTargetValue (currentIKWeaponsPosition, targetValue);
|
|
|
|
currentIKWeaponsPosition.HandIKWeight = targetValue;
|
|
currentIKWeaponsPosition.elbowInfo.targetValue = targetValue;
|
|
currentIKWeaponsPosition.elbowInfo.elbowIKWeight = targetValue;
|
|
|
|
currentIKWeaponsPosition.handInPositionToAim = true;
|
|
currentIKWeaponsPosition.transformFollowByHand = currentIKWeaponsPosition.position;
|
|
} else {
|
|
for (int i = 0; i < IKWeaponsSettings.handsInfo.Count; i++) {
|
|
|
|
currentIKWeaponsPosition = IKWeaponsSettings.handsInfo [i];
|
|
|
|
float targetValue = 1;
|
|
|
|
if (!fullBodyAwarenessActive) {
|
|
if (IKWeaponsSettings.deactivateIKIfNotAiming || playerControllerManager.isCrouching ()) {
|
|
targetValue = 0;
|
|
}
|
|
}
|
|
|
|
if (IKWeaponsSettings.usingWeaponAsOneHandWield && !currentIKWeaponsPosition.usedToDrawWeapon) {
|
|
targetValue = 0;
|
|
}
|
|
|
|
setIKHandTargetValue (currentIKWeaponsPosition, targetValue);
|
|
|
|
currentIKWeaponsPosition.HandIKWeight = targetValue;
|
|
currentIKWeaponsPosition.elbowInfo.targetValue = targetValue;
|
|
currentIKWeaponsPosition.elbowInfo.elbowIKWeight = targetValue;
|
|
|
|
currentIKWeaponsPosition.handInPositionToAim = true;
|
|
currentIKWeaponsPosition.transformFollowByHand = currentIKWeaponsPosition.position;
|
|
}
|
|
}
|
|
|
|
checkHandsInPosition (true);
|
|
}
|
|
|
|
public void quickDrawWeaponStateDualWeapon (IKWeaponInfo IKPositions, bool isRigthWeapon)
|
|
{
|
|
IKWeaponsSettings = IKPositions;
|
|
|
|
if (isRigthWeapon) {
|
|
if (IKWeaponsRightHandSettings != null && IKWeaponsRightHandSettings.rightHandDualWeaopnInfo.handsInfo.Count > 0) {
|
|
currentIKWeaponsPosition = IKWeaponsRightHandSettings.rightHandDualWeaopnInfo.handsInfo [0];
|
|
|
|
stopIKWeaponHandMovementCoroutine (currentIKWeaponsPosition);
|
|
}
|
|
} else {
|
|
|
|
if (IKWeaponsLeftHandSettings != null && IKWeaponsLeftHandSettings.leftHandDualWeaponInfo.handsInfo.Count > 0) {
|
|
currentIKWeaponsPosition = IKWeaponsLeftHandSettings.leftHandDualWeaponInfo.handsInfo [0];
|
|
|
|
stopIKWeaponHandMovementCoroutine (currentIKWeaponsPosition);
|
|
}
|
|
}
|
|
|
|
setUsingWeaponsState (true);
|
|
|
|
if (IKWeaponsSettings.usedOnRightHand) {
|
|
currentIKWeaponsPosition = IKWeaponsSettings.rightHandDualWeaopnInfo.handsInfo [0];
|
|
} else {
|
|
currentIKWeaponsPosition = IKWeaponsSettings.leftHandDualWeaponInfo.handsInfo [0];
|
|
}
|
|
|
|
bool deactivateIKIfNotAiming = checkIfDeactivateIKIfNotAimingActive (IKPositions);
|
|
|
|
float targetValue = 1;
|
|
if (deactivateIKIfNotAiming) {
|
|
targetValue = 0;
|
|
}
|
|
|
|
setIKHandTargetValue (currentIKWeaponsPosition, targetValue);
|
|
|
|
currentIKWeaponsPosition.HandIKWeight = targetValue;
|
|
currentIKWeaponsPosition.elbowInfo.targetValue = targetValue;
|
|
currentIKWeaponsPosition.elbowInfo.elbowIKWeight = targetValue;
|
|
|
|
currentIKWeaponsPosition.handInPositionToAim = true;
|
|
currentIKWeaponsPosition.transformFollowByHand = currentIKWeaponsPosition.position;
|
|
|
|
checkHandsInPosition (true);
|
|
}
|
|
|
|
public void resetWeaponHandIKWeight ()
|
|
{
|
|
if (IKWeaponsSettings != null) {
|
|
for (int i = 0; i < IKWeaponsSettings.handsInfo.Count; i++) {
|
|
IKWeaponsSettings.handsInfo [i].HandIKWeight = 0;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void stopIKWeaponHandMovementCoroutine (IKWeaponsPosition IKWeaponPositionToCheck)
|
|
{
|
|
if (IKWeaponPositionToCheck.handMovementCoroutine != null) {
|
|
StopCoroutine (IKWeaponPositionToCheck.handMovementCoroutine);
|
|
}
|
|
}
|
|
|
|
public void quickKeepWeaponState ()
|
|
{
|
|
setDisableWeaponsState (true);
|
|
}
|
|
|
|
public void setDisableWeaponsState (bool state)
|
|
{
|
|
setDisableSingleWeaponState (state);
|
|
|
|
setDisableDualWeaponsState (state);
|
|
}
|
|
|
|
public void setDisableSingleWeaponState (bool state)
|
|
{
|
|
disableWeapons = state;
|
|
}
|
|
|
|
public void setDisableDualWeaponsState (bool state)
|
|
{
|
|
disablingDualWeapons = state;
|
|
}
|
|
|
|
public void disableIKWeight ()
|
|
{
|
|
headWeightTarget = 0;
|
|
currentHeadWeight = 0;
|
|
}
|
|
|
|
public void setUsingWeaponsState (bool state)
|
|
{
|
|
usingWeapons = state;
|
|
}
|
|
|
|
public void setUsingDualWeaponState (bool state)
|
|
{
|
|
if (state) {
|
|
usingDualWeapon = state;
|
|
} else {
|
|
setDisableDualWeaponsState (true);
|
|
}
|
|
}
|
|
|
|
public void disableUsingDualWeaponState ()
|
|
{
|
|
usingDualWeapon = false;
|
|
|
|
setDisableDualWeaponsState (false);
|
|
}
|
|
|
|
public void setIKWeaponsRightHandSettings (IKWeaponInfo IKPositions)
|
|
{
|
|
IKWeaponsRightHandSettings = IKPositions;
|
|
}
|
|
|
|
public void setIKWeaponsLeftHandSettings (IKWeaponInfo IKPositions)
|
|
{
|
|
IKWeaponsLeftHandSettings = IKPositions;
|
|
}
|
|
|
|
public void startRecoil (float recoilSpeed, float recoilAmount)
|
|
{
|
|
if (powerHandRecoil != null) {
|
|
StopCoroutine (powerHandRecoil);
|
|
}
|
|
|
|
powerHandRecoil = StartCoroutine (recoilMovementBack (recoilSpeed, recoilAmount));
|
|
}
|
|
|
|
IEnumerator recoilMovementBack (float recoilSpeed, float recoilAmount)
|
|
{
|
|
originalCurrentDist = currentDist;
|
|
float newDist = currentDist - recoilAmount;
|
|
|
|
for (float t = 0; t < 1;) {
|
|
t += Time.deltaTime * recoilSpeed;
|
|
|
|
currentDist = Mathf.Lerp (currentDist, newDist, t);
|
|
|
|
yield return null;
|
|
}
|
|
|
|
powerHandRecoil = StartCoroutine (recoilMovementForward (recoilSpeed));
|
|
}
|
|
|
|
IEnumerator recoilMovementForward (float recoilSpeed)
|
|
{
|
|
for (float t = 0; t < 1;) {
|
|
t += Time.deltaTime * recoilSpeed;
|
|
|
|
currentDist = Mathf.Lerp (currentDist, originalCurrentDist, t);
|
|
|
|
yield return null;
|
|
}
|
|
}
|
|
|
|
public void setElbowsIKTargetValue (float leftValue, float rightValue)
|
|
{
|
|
for (int i = 0; i < IKWeaponsSettings.handsInfo.Count; i++) {
|
|
currentIKWeaponsPosition = IKWeaponsSettings.handsInfo [i];
|
|
|
|
if (currentIKWeaponsPosition.limb == AvatarIKGoal.LeftHand) {
|
|
currentIKWeaponsPosition.elbowInfo.targetValue = leftValue;
|
|
}
|
|
|
|
if (currentIKWeaponsPosition.limb == AvatarIKGoal.RightHand) {
|
|
currentIKWeaponsPosition.elbowInfo.targetValue = rightValue;
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setIKHandTargetValue (IKWeaponsPosition IKWeaponPositionToCheck, float newTargetValue)
|
|
{
|
|
IKWeaponPositionToCheck.targetValue = newTargetValue;
|
|
|
|
// print ((IKWeaponPositionToCheck.limb == AvatarIKGoal.RightHand) + " " + newTargetValue);
|
|
}
|
|
|
|
public void ziplineState (bool state, zipline.IKZiplineInfo IKPositions)
|
|
{
|
|
usingZipline = state;
|
|
|
|
if (usingZipline) {
|
|
IKWeightTargetValue = 1;
|
|
IKZiplineSettings = IKPositions;
|
|
} else {
|
|
IKWeightTargetValue = 0;
|
|
IKZiplineSettings = null;
|
|
}
|
|
}
|
|
|
|
public void setGrabedObjectState (bool state, bool IKSystemEnabledToGrabState, List<grabObjects.handInfo> handInfo)
|
|
{
|
|
objectGrabbed = state;
|
|
|
|
IKSystemEnabledToGrab = IKSystemEnabledToGrabState;
|
|
|
|
if (objectGrabbed) {
|
|
handInfoList = handInfo;
|
|
|
|
for (int i = 0; i < handInfoList.Count; i++) {
|
|
if (handInfoList [i].useAnimationGrabbingHand) {
|
|
if (handInfoList [i].IKGoal == AvatarIKGoal.RightHand) {
|
|
setGrabbingHandState (handInfoList [i].grabbingHandID, true);
|
|
} else {
|
|
setGrabbingHandState (handInfoList [i].grabbingHandID, false);
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
setGrabbingHandState (0, true);
|
|
setGrabbingHandState (0, false);
|
|
}
|
|
}
|
|
|
|
public void setIKBodyInfoListOriginalPosition ()
|
|
{
|
|
if (!IKBodyInfoStateListOriginalPositionAssigned) {
|
|
IKBodyInfoStateListOriginalPositionAssigned = true;
|
|
|
|
for (int i = 0; i < IKBodyInfoStateList.Count; i++) {
|
|
for (int j = 0; j < IKBodyInfoStateList [i].IKBodyInfoList.Count; j++) {
|
|
IKBodyInfoStateList [i].IKBodyInfoList [j].originalPosition = IKBodyInfoStateList [i].IKBodyInfoList [j].targetToFollow.localPosition;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
public void setIKBodyPausedState (bool state)
|
|
{
|
|
IKBodyPaused = state;
|
|
}
|
|
|
|
public bool isIKBodyPaused ()
|
|
{
|
|
return IKBodyPaused;
|
|
}
|
|
|
|
public void setIKBodyState (bool state, string IKBodyStateName)
|
|
{
|
|
setIKBodyInfoListOriginalPosition ();
|
|
|
|
for (int j = 0; j < IKBodyInfoStateList.Count; j++) {
|
|
if (IKBodyInfoStateList [j].Name.Equals (IKBodyStateName)) {
|
|
currentIKBodyInfoState = IKBodyInfoStateList [j];
|
|
currentIKBodyInfoList = currentIKBodyInfoState.IKBodyInfoList;
|
|
|
|
currentIKBodyInfoState.currentlyActive = state;
|
|
}
|
|
}
|
|
|
|
if (state) {
|
|
for (int j = 0; j < currentIKBodyInfoList.Count; j++) {
|
|
currentIKBodyInfoList [j].targetToFollow.localPosition = currentIKBodyInfoList [j].originalPosition +
|
|
(currentIKBodyInfoState.extraVerticalPositionAtStartMultiplier * Vector3.up);
|
|
|
|
currentIKBodyInfoList [j].posTargetY = currentIKBodyInfoState.extraVerticalPositionAtStart;
|
|
}
|
|
}
|
|
|
|
if (state) {
|
|
IKBodyInfoActive = true;
|
|
disablingIKBodyInfoActive = false;
|
|
} else {
|
|
disablingIKBodyInfoActive = true;
|
|
}
|
|
|
|
for (int j = 0; j < currentIKBodyInfoList.Count; j++) {
|
|
if (state) {
|
|
currentIKBodyInfoList [j].IKBodyWeigthTarget = 1;
|
|
|
|
if (currentIKBodyInfoList [j].isHand) {
|
|
if (usingHands) {
|
|
if (!currentIKBodyInfoList [j].bodyPartBusy) {
|
|
currentIKBodyInfoList [j].bodyPartBusy = true;
|
|
currentIKBodyInfoList [j].IKBodyWeigthTarget = 0;
|
|
}
|
|
}
|
|
}
|
|
} else {
|
|
currentIKBodyInfoList [j].IKBodyWeigthTarget = 0;
|
|
|
|
if (currentIKBodyInfoList [j].isHand) {
|
|
if (usingHands) {
|
|
if (!currentIKBodyInfoList [j].bodyPartBusy) {
|
|
currentIKBodyInfoList [j].bodyPartBusy = true;
|
|
currentIKBodyInfoList [j].IKBodyWeigthTarget = 0;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
if (!state) {
|
|
resetBodyRotation ();
|
|
}
|
|
|
|
lastTimeIkBodyStateActive = Time.time;
|
|
}
|
|
|
|
float lastTimeIkBodyStateActive;
|
|
|
|
Coroutine bodyRotationCoroutine;
|
|
|
|
public void resetBodyRotation ()
|
|
{
|
|
if (bodyRotationCoroutine != null) {
|
|
StopCoroutine (bodyRotationCoroutine);
|
|
}
|
|
|
|
if (currentIKBodyInfoState == null) {
|
|
return;
|
|
}
|
|
|
|
bodyRotationCoroutine = StartCoroutine (resetBodyRotationCoroutine ());
|
|
}
|
|
|
|
IEnumerator resetBodyRotationCoroutine ()
|
|
{
|
|
targetRotation = Vector3.zero;
|
|
|
|
for (float t = 0; t < 1;) {
|
|
t += Time.deltaTime * currentIKBodyInfoState.IKBodyCOMRotationSpeed;
|
|
|
|
IKBodyCOM.localRotation = Quaternion.Lerp (IKBodyCOM.localRotation, Quaternion.Euler (targetRotation), t);
|
|
|
|
yield return null;
|
|
}
|
|
}
|
|
|
|
public Transform getIKBodyCOM ()
|
|
{
|
|
return IKBodyCOM;
|
|
}
|
|
|
|
public Transform getRightHandMountPoint ()
|
|
{
|
|
return rightHandMountPoint;
|
|
}
|
|
|
|
public Transform getLeftHandMountPoint ()
|
|
{
|
|
return leftHandMountPoint;
|
|
}
|
|
|
|
public Transform getRightLowerArmMountPoint ()
|
|
{
|
|
return rightLowerArmMountPoint;
|
|
}
|
|
|
|
public Transform getLeftLowerArmMountPoint ()
|
|
{
|
|
return leftLowerArmMountPoint;
|
|
}
|
|
|
|
public void setCurrentAimModeType (string newAimModeTypeName)
|
|
{
|
|
if (newAimModeTypeName.Equals ("Weapons")) {
|
|
currentAimMode = aimMode.weapons;
|
|
}
|
|
|
|
if (newAimModeTypeName.Equals ("Powers")) {
|
|
currentAimMode = aimMode.hands;
|
|
}
|
|
}
|
|
|
|
public void stopAllMovementCoroutines ()
|
|
{
|
|
if (powerHandRecoil != null) {
|
|
StopCoroutine (powerHandRecoil);
|
|
}
|
|
|
|
if (bodyRotationCoroutine != null) {
|
|
StopCoroutine (bodyRotationCoroutine);
|
|
}
|
|
|
|
if (IKWeaponsSettings != null) {
|
|
for (int i = 0; i < IKWeaponsSettings.handsInfo.Count; i++) {
|
|
currentIKWeaponsPosition = IKWeaponsSettings.handsInfo [i];
|
|
|
|
stopIKWeaponHandMovementCoroutine (currentIKWeaponsPosition);
|
|
}
|
|
}
|
|
}
|
|
|
|
public void enableOrDisableIKSystemManagerState (bool state)
|
|
{
|
|
if (!state) {
|
|
disableAllIKStates ();
|
|
}
|
|
|
|
enabled = state;
|
|
|
|
componentEnabled = state;
|
|
}
|
|
|
|
public void disableAllIKStates ()
|
|
{
|
|
if (currentIKWeaponsPosition != null) {
|
|
stopIKWeaponHandMovementCoroutine (currentIKWeaponsPosition);
|
|
}
|
|
|
|
disableArmsState ();
|
|
|
|
usingHands = false;
|
|
|
|
stopIKWeaponsActions ();
|
|
|
|
resetIKCOMRotationChecked = false;
|
|
|
|
headLookStateEnabled = false;
|
|
|
|
IKBodyInfoActive = false;
|
|
|
|
disablingIKBodyInfoActive = false;
|
|
|
|
headWeightTarget = 0;
|
|
|
|
if (driving) {
|
|
if (currentIKDrivingPositions != null) {
|
|
setDrivingState (false, IKDrivingSettings);
|
|
}
|
|
}
|
|
|
|
if (usingZipline) {
|
|
if (IKZiplineSettings != null) {
|
|
ziplineState (false, IKZiplineSettings);
|
|
}
|
|
}
|
|
|
|
objectGrabbed = false;
|
|
|
|
IKSystemEnabledToGrab = false;
|
|
}
|
|
|
|
public void setTemporalOnAnimatorIKComponentActive (OnAnimatorIKComponent newTemporalOnAnimatorIKComponent)
|
|
{
|
|
setTemporalOnAnimatorIKComponent (newTemporalOnAnimatorIKComponent, true);
|
|
}
|
|
|
|
public void setTemporalOnAnimatorIKComponentDeactivate (OnAnimatorIKComponent newTemporalOnAnimatorIKComponent)
|
|
{
|
|
setTemporalOnAnimatorIKComponent (newTemporalOnAnimatorIKComponent, false);
|
|
}
|
|
|
|
public void setTemporalOnAnimatorIKComponentActiveIfNotInUse (OnAnimatorIKComponent newTemporalOnAnimatorIKComponent)
|
|
{
|
|
if (!temporalOnAnimatorIKComponentAssigned || newTemporalOnAnimatorIKComponent == temporalOnAnimatorIKComponent) {
|
|
setTemporalOnAnimatorIKComponent (newTemporalOnAnimatorIKComponent, true);
|
|
}
|
|
}
|
|
|
|
public void removeThisTemporalOnAnimatorIKComponentIfIsCurrent (OnAnimatorIKComponent newTemporalOnAnimatorIKComponent)
|
|
{
|
|
if (newTemporalOnAnimatorIKComponent == temporalOnAnimatorIKComponent) {
|
|
setTemporalOnAnimatorIKComponent (newTemporalOnAnimatorIKComponent, false);
|
|
}
|
|
}
|
|
|
|
public void setTemporalOnAnimatorIKComponent (OnAnimatorIKComponent newTemporalOnAnimatorIKComponent, bool state)
|
|
{
|
|
temporalOnAnimatorIKComponent = newTemporalOnAnimatorIKComponent;
|
|
|
|
if (temporalOnAnimatorIKComponent != null) {
|
|
temporalOnAnimatorIKComponent.setActiveState (state);
|
|
}
|
|
|
|
temporalOnAnimatorIKComponentAssigned = temporalOnAnimatorIKComponent != null && state;
|
|
}
|
|
|
|
public bool checkIfTemporalOnAnimatorIKComponentIfIsCurrent (OnAnimatorIKComponent newTemporalOnAnimatorIKComponent)
|
|
{
|
|
return newTemporalOnAnimatorIKComponent == temporalOnAnimatorIKComponent;
|
|
}
|
|
|
|
public void setIsThirdPersonViewState (bool state)
|
|
{
|
|
isThirdPersonView = state;
|
|
}
|
|
|
|
public void setFireWeaponsHeadWeight (float newValue)
|
|
{
|
|
fireWeaponsHeadWeight = newValue;
|
|
}
|
|
|
|
void updateComponent ()
|
|
{
|
|
GKC_Utils.updateComponent (this);
|
|
}
|
|
|
|
#if UNITY_EDITOR
|
|
void OnDrawGizmos ()
|
|
{
|
|
if (!showGizmo) {
|
|
return;
|
|
}
|
|
|
|
if (GKC_Utils.isCurrentSelectionActiveGameObject (gameObject)) {
|
|
DrawGizmos ();
|
|
}
|
|
}
|
|
|
|
void OnDrawGizmosSelected ()
|
|
{
|
|
DrawGizmos ();
|
|
}
|
|
|
|
//draw the pivot and the final positions of every door
|
|
void DrawGizmos ()
|
|
{
|
|
if (showGizmo && !Application.isPlaying) {
|
|
Gizmos.color = Color.yellow;
|
|
Gizmos.DrawCube (leftHandIKPos.transform.position, Vector3.one / 10);
|
|
Gizmos.DrawCube (rightHandIKPos.transform.position, Vector3.one / 10);
|
|
}
|
|
}
|
|
#endif
|
|
|
|
[System.Serializable]
|
|
public class IKSettings
|
|
{
|
|
public float weight;
|
|
public float bodyWeight;
|
|
public float headWeight;
|
|
public float eyesWeight;
|
|
public float clampWeight;
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class IKBodyInfoState
|
|
{
|
|
[Header ("Main Setting")]
|
|
[Space]
|
|
|
|
public string Name;
|
|
public List<IKBodyInfo> IKBodyInfoList = new List<IKBodyInfo> ();
|
|
|
|
[Space]
|
|
[Header ("Speed Movement Settings")]
|
|
[Space]
|
|
|
|
public float IKBodyCOMRotationAmountX = 20;
|
|
public float IKBodyComRotationAmountY = 20;
|
|
public float IKBodyCOMRotationSpeed = 2;
|
|
|
|
public bool increaseRotationAmountWhenHigherSpeed;
|
|
public float increasedIKBodyCOMRotationAmountX = 20;
|
|
public float increasedIKBodyComRotationAmountY = 20;
|
|
public float increasedIKBodyCOMRotationSpeed = 2;
|
|
|
|
public float busyBodyPartWeightLerpSpeed = 3;
|
|
|
|
[Space]
|
|
[Header ("Other Settings")]
|
|
[Space]
|
|
|
|
public float delayForVerticalMovement = 1;
|
|
|
|
public float verticalMovementTransitionSpeed = 5;
|
|
|
|
public float extraVerticalPositionAtStart = 0.5f;
|
|
public float extraVerticalPositionAtStartMultiplier = 0.5f;
|
|
|
|
[Space]
|
|
[Header ("Debug")]
|
|
[Space]
|
|
|
|
public bool currentlyActive;
|
|
|
|
[HideInInspector] public float currentIKBodyCOMRotationAmountX;
|
|
[HideInInspector] public float currentIKBodyCOMRotationAmountY;
|
|
|
|
[HideInInspector] public float currentIKBodyCOMRotationSpeed = 2;
|
|
}
|
|
|
|
[System.Serializable]
|
|
public class IKBodyInfo
|
|
{
|
|
[Header ("Main Settings")]
|
|
[Space]
|
|
|
|
public string Name;
|
|
public bool IKBodyPartEnabled = true;
|
|
|
|
public Transform targetToFollow;
|
|
|
|
[Space]
|
|
[Header ("IK Settings")]
|
|
[Space]
|
|
|
|
public AvatarIKGoal IKGoal;
|
|
public bool isHand;
|
|
|
|
public bool useIKHint;
|
|
public AvatarIKHint IKHint;
|
|
|
|
[Space]
|
|
[Header ("Debug")]
|
|
[Space]
|
|
|
|
public bool bodyPartBusy;
|
|
|
|
public float currentIKWeight;
|
|
public float IKBodyWeigthTarget;
|
|
|
|
public float posTargetY;
|
|
|
|
[Space]
|
|
[Header ("Movement Settings")]
|
|
[Space]
|
|
|
|
public float weightLerpSpeed;
|
|
|
|
[HideInInspector] public Vector3 newPosition;
|
|
|
|
public bool useSin = true;
|
|
|
|
[HideInInspector] public Vector3 IKGoalPosition;
|
|
[HideInInspector] public Quaternion IKGoalRotation;
|
|
|
|
public float limbsMovementSpeed;
|
|
public float limbMovementAmount;
|
|
public float limbVerticalMovementSpeed;
|
|
|
|
public float slowLimbVerticalMovementSpeed = 0.2f;
|
|
|
|
[HideInInspector] public float currentLimbVerticalMovementSpeed;
|
|
|
|
[Space]
|
|
[Header ("Clamp Settings")]
|
|
[Space]
|
|
|
|
public Vector2 minClampPosition;
|
|
public Vector2 maxClampPosition;
|
|
public Vector3 originalPosition;
|
|
|
|
}
|
|
} |