/// <summary>
/// Called to start the specific motion. If the motion
/// were something like 'jump', this would start the jumping process
/// </summary>
/// <param name="rPrevMotion">Motion that this motion is taking over from</param>
public override bool Activate(MotionControllerMotion rPrevMotion)
{
// When falling, we don't want to change the camera mode. However,
// the deactivate of the 'jump' will set it back. So we need to save the
// current mode.
if (mController.UseInput && mController.CameraRig != null)
{
mSavedCameraMode = mController.CameraRig.Mode;
}
// Flag the motion as active
mIsActive = true;
mIsActivatedFrame = true;
mIsStartable = false;
mLaunchForward = mController.transform.forward;
mPhase = Fall.PHASE_START_FALL;
mController.SetAnimatorMotionPhase(mAnimatorLayerIndex, Fall.PHASE_START_FALL, true);
// Remove any accumulated velocity so that gravity can start over
mController.AccumulatedVelocity = new Vector3(mController.AccumulatedVelocity.x, 0f, mController.AccumulatedVelocity.z);
// Set the ground velocity so that we can keep momentum going
ControllerState lState = mController.State;
lState.GroundLaunchVelocity = (mController.transform.rotation * mController.RootMotionVelocityAvg.Average);
// Set the controller state with the modified values
mController.State = lState;
// Report that we're good to enter the jump
return true;
}
/// <summary>
/// Called to start the specific motion. If the motion
/// were something like 'jump', this would start the jumping process
/// </summary>
/// <param name="rPrevMotion">Motion that this motion is taking over from</param>
public virtual bool Activate(MotionControllerMotion rPrevMotion)
{
// Flag the motion as active
mIsActive = true;
mIsActivatedFrame = true;
mIsStartable = false;
// Report that we're good enter the motion
return true;
}
/// <summary>
/// Called to start the specific motion. If the motion
/// were something like 'jump', this would start the jumping process
/// </summary>
/// <param name="rPrevMotion">Motion that this motion is taking over from</param>
public override bool Activate(MotionControllerMotion rPrevMotion)
{
// Ensure we have good collision info
if (sCollisionInfo.collider == null) { return false; }
// Flag the motion as active
mIsActive = true;
mIsActivatedFrame = true;
mIsStartable = false;
//mHasArrived = false;
//mArrivalLerp = 0.25f;
mController.AccumulatedVelocity = Vector3.zero;
// Set the control state
ControllerState lState = mController.State;
mPhase = ClimbMid.PHASE_START;
mController.SetAnimatorMotionPhase(mAnimatorLayerIndex, ClimbMid.PHASE_START, true);
mController.State = lState;
// Track the object we're trying to climb and store it
mClimbable = sCollisionInfo.collider.gameObject;
UnityEngine.Physics.IgnoreCollision(mController.CharController.collider, mClimbable.collider, true);
// Set the grab position we're anchoring on
mGrabPosition = sCollisionInfo.point;
mLocalGrabPosition = Quaternion.Inverse(mClimbable.transform.rotation) * (sCollisionInfo.point - mClimbable.transform.position);
// Set the grab normal coming out of the wall we're anchoring on
mGrabPositionNormal = sCollisionInfo.normal;
// Determine the target position given the grab info
mTargetPosition = DetermineTargetPositions(ref mGrabPosition, ref mGrabPositionNormal);
// Clear the avatar contact position so it can be reset
mAvatarContactPosition = Vector3.zero;
// Return
return true;
}
/// <summary>
/// Called to start the specific motion. If the motion
/// were something like 'jump', this would start the jumping process
/// </summary>
/// <param name="rPrevMotion">Motion that this motion is taking over from</param>
public override bool Activate(MotionControllerMotion rPrevMotion)
{
// Store the last camera mode and force it to a fixed view.
// We do this to always keep the camera behind the player
if (mController.UseInput && mController.CameraRig != null)
{
mSavedCameraMode = mController.CameraRig.Mode;
mController.CameraRig.TransitionToMode(EnumCameraMode.CRAWLING);
}
// Force the character's stance to change
mController.Stance = EnumControllerStance.SNEAK;
mLaunchForward = mController.transform.forward;
mController.SetColliderHeightAtBase(0.5f*mController.BaseColliderHeight);
// mController.SetColliderRadiusAtCenter(2f*mController.BaseColliderRadius);
// Trigger the change in the animator
mController.SetAnimatorMotionPhase(mMotionLayer.AnimatorLayerIndex, Sneak.PHASE_START, true);
// Allow the base to finish
return base.Activate(rPrevMotion);
}
/// <summary>
/// Called to start the specific motion. If the motion
/// were something like 'jump', this would start the jumping process
/// </summary>
/// <param name="rPrevMotion">Motion that this motion is taking over from</param>
public override bool Activate(MotionControllerMotion rPrevMotion)
{
mHasEnteredState = false;
// Force the character's stance to change
mController.Stance = EnumControllerStance.SNEAK;
// Trigger the change in the animator
mController.SetAnimatorMotionPhase(mMotionLayer.AnimatorLayerIndex, Sneak.PHASE_START, true);
// Allow the base to finish
return base.Activate(rPrevMotion);
}
/// <summary>
/// Called to start the specific motion. If the motion
/// were something like 'jump', this would start the jumping process
/// </summary>
/// <param name="rPrevMotion">Motion that this motion is taking over from</param>
public override bool Activate(MotionControllerMotion rPrevMotion)
{
// Force the camera so we can do side jumps
if (mController.UseInput && mController.CameraRig != null)
{
mSavedCameraMode = mController.CameraRig.Mode;
mController.CameraRig.TransitionToMode(EnumCameraMode.THIRD_PERSON_FIXED);
}
// Flag the motion as active
mIsActive = true;
mIsActivatedFrame = true;
mIsStartable = false;
mLaunchForward = mController.transform.forward;
// Initialize the jump
mPhase = Jump.PHASE_START_JUMP;
mController.SetAnimatorMotionPhase(mAnimatorLayerIndex, Jump.PHASE_START_JUMP, true);
// Remove any accumulated velocity so that gravity can start over
mController.AccumulatedVelocity = new Vector3(mController.AccumulatedVelocity.x, 0f, mController.AccumulatedVelocity.z);
// Set the ground velocity so that we can keep momentum going
ControllerState lState = mController.State;
lState.IsGrounded = false;
lState.GroundLaunchVelocity = (mController.transform.rotation * mController.RootMotionVelocityAvg.Average);
mController.State = lState;
// Create the total impulse (direction + magnitude)
Vector3 lImpulse = mController.transform.up * mImpulse;
mController.AddImpulse(lImpulse);
// Report that we're good to enter the jump
return true;
}
/// <summary>
/// Called to start the specific motion. If the motion
/// were something like 'jump', this would start the jumping process
/// </summary>
/// <param name="rPrevMotion">Motion that this motion is taking over from</param>
public override bool Activate(MotionControllerMotion rPrevMotion)
{
// Store the last camera mode and force it to a fixed view.
// We do this to always keep the camera behind the player
if (mController.UseInput && mController.CameraRig != null)
{
mController.CameraRig.TransitionToMode(EnumCameraMode.THIRD_PERSON_FOLLOW);
}
// It's possible we're activating from a small fall or other
// skip while already in this motion. If so, no need to restart it.
if (!IsInRunState)
{
// Trigger the change in the animator
mController.SetAnimatorMotionPhase(mMotionLayer.AnimatorLayerIndex, AdventureForward.PHASE_START, true);
}
return base.Activate(rPrevMotion);
}
/// <summary>
/// Activate the specified motion (on the next frame).
/// </summary>
/// <param name="rMotion">Motion to activate</param>
public void ActivateMotion(MotionControllerMotion rMotion)
{
if (rMotion != null)
{
rMotion.MotionLayer.QueueMotion(rMotion);
}
}
/// <summary>
/// Updates the motions tied to this layer at the variable
/// time step (ie Update() not FixedUpdate().
/// </summary>
public void UpdateMotions()
{
int lPriorityIndex = int.MinValue;
float lPriorityValue = float.MinValue;
// Track how long the motion has been playing
mActiveMotionDuration += Time.deltaTime;
// Clean up the active motion's flag
if (mActiveMotion != null) { mActiveMotion.IsActivatedFrame = false; }
// First, check if our current motion is interruptible.
// If it's not, we know we are simply running it.
if (mActiveMotion == null || mActiveMotion.IsInterruptible)
{
bool lIsQueued = false;
// Cycle through the motions to determine which ones were not
// active and should be. We'll take the motion with the highest priority
for (int i = 0; i < mMotions.Count; i++)
{
// Clean up the activation flag
mMotions[i].IsActivatedFrame = false;
// Don't test if the motion is not enabled
if (!mMotions[i].IsEnabled) { continue; }
// If we haven't gone past the reactivation delay, move one
if (mMotions[i].ReactivationDelay > 0 && mMotions[i].DeactivationTime + mMotions[i].ReactivationDelay > Time.time) { continue; }
// If we're to force the motion, don't check others
if (mMotions[i].QueueActivation)
{
lIsQueued = true;
lPriorityIndex = i;
lPriorityValue = mMotions[i].Priority;
mMotions[i].QueueActivation = false;
break;
}
// Check for activation
else if (mMotions[i].IsStartable && mMotions[i].TestActivate())
{
if (lPriorityValue < mMotions[i].Priority)
{
lPriorityIndex = i;
lPriorityValue = mMotions[i].Priority;
}
}
}
// If we have a newly chosen motion, we need to activate it
if (lPriorityIndex >= 0 && lPriorityIndex < mMotions.Count)
{
// Ensure the motion will allow the interruption and
// shuts down as needed. If not, we cancel the upcoming motion.
if (!lIsQueued && mActiveMotion != null)
{
if (mActiveMotion.Priority > lPriorityValue)
{
lPriorityIndex = int.MinValue;
}
else if (!mActiveMotion.OnInterruption(mMotions[lPriorityIndex]))
{
lPriorityIndex = int.MinValue;
}
}
// Look to start the new motion
if (lPriorityIndex >= 0)
{
mMotions[lPriorityIndex].Activate(mActiveMotion);
if (mActiveMotion != null && mActiveMotion != mMotions[lPriorityIndex]) { mActiveMotion.Deactivate(); }
mActiveMotion = mMotions[lPriorityIndex];
mActiveMotionDuration = 0f;
}
}
}
// Process any motions that are active. They will die out on thier own
for (int i = 0; i < mMotions.Count; i++)
{
if (mMotions[i].IsActive)
{
mMotions[i].UpdateMotion();
// As a safetly, test and set the active motion
if (mActiveMotion == null && mMotions[i].IsActive)
{
mActiveMotion = mMotions[i];
mActiveMotionDuration = 0f;
}
}
}
// Check if we've deactivated the current motion. If so, we
// need to remove our reference to it
if (mActiveMotion != null && !mActiveMotion.IsActive)
{
mActiveMotion = null;
mActiveMotionDuration = 0f;
}
// Calculate the velocities of the active motions
mAngularVelocity = Vector3.zero;
mVelocity = Vector3.zero;
for (int i = 0; i < mMotions.Count; i++)
{
if (mMotions[i].IsActive)
{
mAngularVelocity += mMotions[i].AngularVelocity;
mVelocity += mMotions[i].Velocity;
}
}
}
/// <summary>
/// Forces the motion to become active for the layer
/// </summary>
/// <param name="rLayerIndex">Layer to work with</param>
/// <param name="rMotion">Motion to activate</param>
/// <returns>Boolean used to determine if the motion was activated</returns>
public bool QueueMotion(int rLayerIndex, MotionControllerMotion rMotion)
{
if (rLayerIndex >= MotionLayers.Count) { return false; }
return MotionLayers[rLayerIndex].QueueMotion(rMotion);
}
/// <summary>
/// Attempt to activate the specified motion and make it the
/// active motion.
/// </summary>
/// <param name="rMotion">Motion to activate</param>
/// <returns>Determines if the motion was set as the active motion</returns>
public bool QueueMotion(MotionControllerMotion rMotion)
{
if (!mMotions.Contains(rMotion)) { return false; }
if (mActiveMotion == rMotion) { return false; }
rMotion.QueueActivation = true;
return true;
}
/// <summary>
/// Removes the motion from the list of motions being managed
/// </summary>
/// <param name="rMotion">Motion to remove</param>
public void RemoveMotion(MotionControllerMotion rMotion)
{
mMotions.Remove(rMotion);
rMotion.Controller = null;
rMotion.MotionLayer = null;
}
/// <summary>
/// Adds a motion to the list of motions being managed
/// </summary>
/// <param name="rMotion">Motion to add</param>
public void AddMotion(MotionControllerMotion rMotion)
{
if (!mMotions.Contains(rMotion))
{
rMotion.Controller = mController;
rMotion.MotionLayer = this;
mMotions.Add(rMotion);
}
}
/// <summary>
/// Raised when a motion is being interrupted by another motion
/// </summary>
/// <param name="rMotion">Motion doing the interruption</param>
/// <returns>Boolean determining if it can be interrupted</returns>
public virtual bool OnInterruption(MotionControllerMotion rMotion)
{
return true;
}
/// <summary>
/// Called to start the specific motion. If the motion
/// were something like 'jump', this would start the jumping process
/// </summary>
/// <param name="rPrevMotion">Motion that this motion is taking over from</param>
public override bool Activate(MotionControllerMotion rPrevMotion)
{
mYaw = 0f;
mController.SetAnimatorMotionPhase(mMotionLayer.AnimatorLayerIndex, CasualIdle.PHASE_START, true);
return base.Activate(rPrevMotion);
}
/// <summary>
/// Called to start the specific motion. If the motion
/// were something like 'jump', this would start the jumping process
/// </summary>
/// <param name="rPrevMotion">Motion that this motion is taking over from</param>
public override bool Activate(MotionControllerMotion rPrevMotion)
{
// Store the last camera mode and force it to a fixed view.
// We do this to always keep the camera behind the player
if (mController.UseInput && mController.CameraRig != null)
{
mSavedCameraMode = mController.CameraRig.Mode;
mController.CameraRig.TransitionToMode(EnumCameraMode.FIRST_PERSON);
}
// Force the character's stance to change
mSavedStance = mController.Stance;
mController.Stance = EnumControllerStance.COMBAT_RANGED;
// Trigger the change in the animator
mController.SetAnimatorMotionPhase(mAnimatorLayerIndex, Walk360.PHASE_START, true);
// Continue with the activation
return base.Activate(rPrevMotion);
}
/// <summary>
/// Called to start the specific motion. If the motion
/// were something like 'jump', this would start the jumping process
/// </summary>
/// <param name="rPrevMotion">Motion that this motion is taking over from</param>
public override bool Activate(MotionControllerMotion rPrevMotion)
{
// Ensure we have good collision info
if (sCollisionInfo.collider == null) { return false; }
// Flag the motion as active
mIsActive = true;
mIsActivatedFrame = true;
mIsStartable = false;
mHasArrived = false;
mArrivalLerp = 0.25f;
mController.AccumulatedVelocity = Vector3.zero;
// Set the control state
ControllerState lState = mController.State;
// Test if we're coming from a jump rise
if (mGrabMotion == 1)
{
mPhase = ClimbCrouch.PHASE_FROM_JUMP_RISE;
mController.SetAnimatorMotionPhase(mAnimatorLayerIndex, ClimbCrouch.PHASE_FROM_JUMP_RISE);
}
// Test if we're coming from the top of the jump
else if (mGrabMotion == 2)
{
mPhase = ClimbCrouch.PHASE_FROM_JUMP_TOP;
mController.SetAnimatorMotionPhase(mAnimatorLayerIndex, ClimbCrouch.PHASE_FROM_JUMP_TOP);
}
// Test if we're coming from a fall
else if (mGrabMotion == 3)
{
mPhase = ClimbCrouch.PHASE_FROM_JUMP_FALL;
mController.SetAnimatorMotionPhase(mAnimatorLayerIndex, ClimbCrouch.PHASE_FROM_JUMP_FALL);
}
mController.State = lState;
// Track the object we're trying to climb and store it
mClimbable = sCollisionInfo.collider.gameObject;
// Set the grab position we're anchoring on
mGrabPosition = sCollisionInfo.point;
mLocalGrabPosition = Quaternion.Inverse(mClimbable.transform.rotation) * (sCollisionInfo.point - mClimbable.transform.position);
// Set the grab normal coming out of the wall we're anchoring on
mGrabPositionNormal = sCollisionInfo.normal;
// Determine the target position given the grab info
mTargetPosition = DetermineTargetPositions(ref mGrabPosition, ref mGrabPositionNormal);
// Clear the avatar contact position so it can be reset
mAvatarContactPosition = Vector3.zero;
// Return
return true;
}
/// <summary>
/// Called to start the specific motion. If the motion
/// were something like 'jump', this would start the jumping process
/// </summary>
/// <param name="rPrevMotion">Motion that this motion is taking over from</param>
public override bool Activate(MotionControllerMotion rPrevMotion)
{
mController.SetAnimatorMotionPhase(mAnimatorLayerIndex, Slide.PHASE_START, true);
return base.Activate(rPrevMotion);
}
/// <summary>
/// Called to start the specific motion. If the motion
/// were something like 'jump', this would start the jumping process
/// </summary>
/// <param name="rPrevMotion">Motion that this motion is taking over from</param>
public override bool Activate(MotionControllerMotion rPrevMotion)
{
mYaw = 0f;
// Store the last camera mode and force it to a fixed view.
// We do this to always keep the camera behind the player
if (mController.UseInput && mController.CameraRig != null)
{
mController.CameraRig.TransitionToMode(EnumCameraMode.THIRD_PERSON_FIXED);
}
// Trigger the change in the animator
mController.SetAnimatorMotionPhase(mAnimatorLayerIndex, SimpleForward.PHASE_START, true);
// Continue with the activation
return base.Activate(rPrevMotion);
}