/// <summary>
/// Removes the motion from the list of motions being managed
/// </summary>
/// <param name="rMotion">Motion to remove</param>
public void RemoveMotion(MotionControllerMotion rMotion)
{
Motions.Remove(rMotion);
rMotion.MotionController = null;
rMotion.MotionLayer = null;
}
/// <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)
{
mIsEquipped = false;
// Tell the actor controller about our stance (in case the motion was forced)
mActorController.State.Stance = EnumControllerStance.SPELL_CASTING;
// If we already have equipment in hand, we don't need to run this motion
if (mInventorySource != null)
{
string lItemID = (_OverrideItemID != null && _OverrideItemID.Length > 0 ? _OverrideItemID : _ItemID);
string lSlotID = (_OverrideSlotID != null && _OverrideSlotID.Length > 0 ? _OverrideSlotID : _SlotID);
string lEquippedItemID = mInventorySource.GetItemID(lSlotID);
if (lEquippedItemID != null && lEquippedItemID.Length > 0)
{
if (lItemID != null && lItemID.Length > 0 && lItemID == lEquippedItemID)
{
return(false);
}
}
}
// Trigger the animation
mMotionController.SetAnimatorMotionPhase(mMotionLayer.AnimatorLayerIndex, PHASE_START, true);
return(base.Activate(rPrevMotion));
}
/// <summary>
/// Clear this instance.
/// </summary>
public override void Clear()
{
Motion = null;
Continue = false;
base.Clear();
}
/// <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)
{
mMotionController.SetAnimatorMotionPhase(mMotionLayer.AnimatorLayerIndex, PHASE_START, _Form, mParameter, true);
// Finalize 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)
{
mIdleTime = 0f;
mIsRotationLocked = false;
mInputX.Clear();
mInputY.Clear();
mInputMagnitude.Clear();
// Update the max speed based on our animation
mMotionController.MaxSpeed = 5.668f;
// Start the motion
mActiveForm = (_Form >= 0 ? _Form : mMotionController.CurrentForm);
mMotionController.SetAnimatorMotionPhase(mMotionLayer.AnimatorLayerIndex, PHASE_START, mActiveForm, 0, true);
// Register this motion with the camera
if (mMotionController.CameraRig is BaseCameraRig)
{
((BaseCameraRig)mMotionController.CameraRig).OnPostLateUpdate -= OnCameraUpdated;
((BaseCameraRig)mMotionController.CameraRig).OnPostLateUpdate += OnCameraUpdated;
}
// Finalize 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)
{
mStopTime = 0f;
mStopInput = Vector2.zero;
mLinkRotation = false;
// Helps with syncronizing from a motion like attack
float lRunFactor = (IsRunActive ? 1f : 0.5f);
mInputX.Clear(mMotionController.State.InputX * lRunFactor);
mInputY.Clear(mMotionController.State.InputY * lRunFactor);
// Update the max speed based on our animation
mMotionController.MaxSpeed = (_RunSpeed > 0f ? _RunSpeed : 3.2f);
// Determine how we'll start our animation
mMotionController.SetAnimatorMotionPhase(mMotionLayer.AnimatorLayerIndex, PHASE_START, true);
// Register this motion with the camera
if (_RotateWithCamera && mMotionController.CameraRig is BaseCameraRig)
{
((BaseCameraRig)mMotionController.CameraRig).OnPostLateUpdate -= OnCameraUpdated;
((BaseCameraRig)mMotionController.CameraRig).OnPostLateUpdate += OnCameraUpdated;
}
// Finalize the activation
return(base.Activate(rPrevMotion));
}
/// <summary>
/// New way to create sub-state machines without destroying what exists first.
/// </summary>
protected override void CreateStateMachine()
{
int rLayerIndex = mMotionLayer._AnimatorLayerIndex;
MotionController rMotionController = mMotionController;
UnityEditor.Animations.AnimatorController lController = null;
Animator lAnimator = rMotionController.Animator;
if (lAnimator == null)
{
lAnimator = rMotionController.gameObject.GetComponent <Animator>();
}
if (lAnimator != null)
{
lController = lAnimator.runtimeAnimatorController as UnityEditor.Animations.AnimatorController;
}
if (lController == null)
{
return;
}
while (lController.layers.Length <= rLayerIndex)
{
UnityEditor.Animations.AnimatorControllerLayer lNewLayer = new UnityEditor.Animations.AnimatorControllerLayer();
lNewLayer.name = "Layer " + (lController.layers.Length + 1);
lNewLayer.stateMachine = new UnityEditor.Animations.AnimatorStateMachine();
lController.AddLayer(lNewLayer);
}
UnityEditor.Animations.AnimatorControllerLayer lLayer = lController.layers[rLayerIndex];
UnityEditor.Animations.AnimatorStateMachine lLayerStateMachine = lLayer.stateMachine;
UnityEditor.Animations.AnimatorStateMachine lSSM_37928 = MotionControllerMotion.EditorFindSSM(lLayerStateMachine, "BasicEquipStore-SM");
if (lSSM_37928 == null)
{
lSSM_37928 = lLayerStateMachine.AddStateMachine("BasicEquipStore-SM", new Vector3(192, -1008, 0));
}
#if USE_ARCHERY_MP || OOTII_AYMP
ArcheryPackDefinition.ExtendBasicEquipStore(rMotionController, rLayerIndex);
#endif
#if USE_SWORD_SHIELD_MP || OOTII_SSMP
SwordShieldPackDefinition.ExtendBasicEquipStore(rMotionController, rLayerIndex);
#endif
#if USE_SPELL_CASTING_MP || OOTII_SCMP
SpellCastingPackDefinition.ExtendBasicEquipStore(rMotionController, rLayerIndex);
#endif
#if USE_SHOOTER_MP || OOTII_SHMP
ShooterPackDefinition.ExtendBasicEquipStore(rMotionController, rLayerIndex);
#endif
// Run any post processing after creating the state machine
OnStateMachineCreated();
}
private void OnIsAliveChanged(bool alive)
{
m_IsActive &= alive;
if (alive)
{
return;
}
CombatMessage message = CombatMessage.Allocate();
if (message != null)
{
message.ID = EnumMessageID.MSG_COMBAT_DEFENDER_KILLED;
message.StyleIndex = -1; // Random
message.Defender = m_MotionController.gameObject;
m_MotionController.SendMessage(message);
message.Release();
}
if (m_NavMeshAgent != null)
{
m_NavMeshAgent.isStopped = true;
}
if (message.IsHandled)
{
m_DeathMotion = message.Recipient as MotionControllerMotion;
}
}
/// <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)
{
mNoInputElapsed = 0f;
mLinkRotation = false;
// Force the stance
mSwimmerInfo.EnterWater();
if (rPrevMotion is Jump || rPrevMotion is Fall)
{
mSwimmerInfo.CreateSplash();
}
// Helps with syncronizing from a motion like attack
float lRunFactor = (IsRunActive ? 1f : 0.5f);
mInputX.Clear(mMotionController.State.InputX * lRunFactor);
mInputY.Clear(mMotionController.State.InputY * lRunFactor);
mInputMagnitude.Clear(Mathf.Sqrt((mInputX.Value * mInputX.Value) + (mInputY.Value * mInputY.Value)));
// Determine how we'll start our animation
mMotionController.ForcedInput = Vector3.zero;
mMotionController.SetAnimatorMotionPhase(mMotionLayer.AnimatorLayerIndex, PHASE_START, true);
// Register this motion with the camera
if (_RotateWithCamera && mMotionController.CameraRig is BaseCameraRig)
{
((BaseCameraRig)mMotionController.CameraRig).OnPostLateUpdate -= OnCameraUpdated;
((BaseCameraRig)mMotionController.CameraRig).OnPostLateUpdate += OnCameraUpdated;
}
// Finalize the activation
return(base.Activate(rPrevMotion));
}
/// <summary>
/// Equip all items in the weapon set
/// </summary>
/// <param name="rIndex">Index of the weapon set whose items will be stored</param>
protected virtual IEnumerator Internal_EquipWeaponsSet(int rIndex)
{
// First, find all the entries with no equip motions and spawn them first
for (int i = 0; i < WeaponSets[rIndex].Items.Count; i++)
{
BasicInventoryItem lItem = GetInventoryItem(WeaponSets[rIndex].Items[i].ItemID);
if (lItem != null && lItem.EquipMotion.Length == 0)
{
BasicInventorySlot lSlot = GetInventorySlot(WeaponSets[rIndex].Items[i].SlotID);
if (lSlot != null)
{
if (WeaponSets[rIndex].Items[i].Instantiate)
{
GameObject lInstance = EquipItem(lItem.ID, lSlot.ID);
if (lInstance != null)
{
lSlot.ItemID = lItem.ID;
}
}
else
{
lSlot.ItemID = lItem.ID;
}
}
}
}
// Now, find all the entries that do have an equip motion
for (int i = 0; i < WeaponSets[rIndex].Items.Count; i++)
{
BasicInventoryItem lItem = GetInventoryItem(WeaponSets[rIndex].Items[i].ItemID);
if (lItem != null && lItem.EquipMotion.Length > 0)
{
BasicInventorySlot lSlot = GetInventorySlot(WeaponSets[rIndex].Items[i].SlotID);
if (lSlot != null && lSlot.ItemID.Length == 0)
{
// If we have a motion to equip, activate it
MotionControllerMotion lMotion = mMotionController.GetMotion(lItem.EquipMotion);
if (lMotion != null)
{
IEquipStoreMotion lEquipStoreMotion = lMotion as IEquipStoreMotion;
if (lEquipStoreMotion != null)
{
lEquipStoreMotion.OverrideItemID = lItem.ID;
lEquipStoreMotion.OverrideSlotID = lSlot.ID;
}
mMotionController.ActivateMotion(lMotion);
while (lMotion.IsActive || lMotion.QueueActivation)
{
yield return(null);
}
// Set the item
lSlot.ItemID = lItem.ID;
}
}
}
}
}
/// <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)
{
mIdleTime = 0f;
mLinkRotation = false;
mInputX.Clear();
mInputY.Clear();
mInputMagnitude.Clear();
// Update the max speed based on our animation
mMotionController.MaxSpeed = 5.668f;
// Determine how we'll start our animation
mMotionController.SetAnimatorMotionPhase(mMotionLayer.AnimatorLayerIndex, PHASE_START, true);
// Register this motion with the camera
if (_RotateWithCamera && mMotionController.CameraRig is BaseCameraRig)
{
((BaseCameraRig)mMotionController.CameraRig).OnPostLateUpdate -= OnCameraUpdated;
((BaseCameraRig)mMotionController.CameraRig).OnPostLateUpdate += OnCameraUpdated;
}
// Finalize 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)
{
mHasLanded = false;
mHasLaunched = false;
// Ensure the AC allows us to levitate
mStoredIsGravityEnabled = mActorController.IsGravityEnabled;
mActorController.IsGravityEnabled = false;
mStoredIsOrientationEnabled = mActorController.OrientToGround;
mActorController.OrientToGround = false;
mActorController.FixGroundPenetration = false;
// Run the approapriate cast
mMotionController.SetAnimatorMotionPhase(mMotionLayer.AnimatorLayerIndex, PHASE_START, 0, true);
// Register this motion with the camera
if (_RotateWithCamera && mMotionController.CameraRig is BaseCameraRig)
{
((BaseCameraRig)mMotionController.CameraRig).OnPostLateUpdate -= OnCameraUpdated;
((BaseCameraRig)mMotionController.CameraRig).OnPostLateUpdate += OnCameraUpdated;
}
// Now, activate the motion
return(base.Activate(rPrevMotion));
}
/// <summary>
/// Activates the motion on the specified target
/// </summary>
/// <param name="rTarget">GameObject to activate the motion on</param>
/// <returns>Bool that determines if the motion was activated</returns>
public bool ActivateInstance(GameObject rTarget)
{
bool lIsActivated = false;
// Check if we have a motion controller and activate the motion
MotionController lMotionController = rTarget.GetComponent <MotionController>();
if (lMotionController != null)
{
mMotion = lMotionController.ActivateMotion(MotionName);
if (mMotion != null)
{
lIsActivated = true;
// Clear out any event first, then add our event
if (TargetTypeIndex == 0 || TargetTypeIndex == 1)
{
mMotion.OnDeactivatedEvent -= OnMotionDeactivated;
mMotion.OnDeactivatedEvent += OnMotionDeactivated;
}
}
// Grab the state as needed
if (ExitState.Length > 0)
{
mExitStateID = lMotionController.AddAnimatorName(ExitState);
}
}
return(lIsActivated);
}
/// <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)
{
mMotionController.SetAnimatorMotionPhase(mMotionLayer.AnimatorLayerIndex, PHASE_START, (IsRunActive ? 1 : 0), true);
// Flag this motion as active
return(base.Activate(rPrevMotion));
}
/// <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 override bool TestInterruption(MotionControllerMotion rMotion)
{
// Since we're dealing with a blend tree, keep the value until the transition completes
mMotionController.ForcedInput.x = mInputX.Average;
mMotionController.ForcedInput.y = mInputY.Average;
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)
{
mActiveForm = (_Form >= 0 ? _Form : mMotionController.CurrentForm);
mMotionController.SetAnimatorMotionPhase(mMotionLayer.AnimatorLayerIndex, PHASE_START, mActiveForm, 0, true);
// Finalize 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)
{
mIsEquipped = true;
// Trigger the animation
mMotionController.SetAnimatorMotionPhase(mMotionLayer.AnimatorLayerIndex, PHASE_START, true);
return(base.Activate(rPrevMotion));
}
/// <summary>
/// Store all items in the weapon set
/// </summary>
/// <param name="rIndex">Index of the weapon set whose items will be stored</param>
protected virtual IEnumerator Internal_StoreWeaponsSet(int rIndex)
{
mIsEquippingItem = true;
// First, find all the entries that do have a store motion
for (int i = 0; i < WeaponSets[rIndex].Items.Count; i++)
{
BasicInventorySlot lSlot = GetInventorySlot(WeaponSets[rIndex].Items[i].SlotID);
if (lSlot != null && lSlot.ItemID.Length > 0)
{
BasicInventoryItem lItem = GetInventoryItem(lSlot.ItemID);
if (lItem != null && lItem.StoreMotion.Length > 0)
{
// If we have a motion to unequip, activate it
MotionControllerMotion lMotion = mMotionController.GetMotion(lItem.StoreMotion);
if (lMotion != null)
{
// This is an extra test so we don't try to sheathe a weapons we just
// unsheathed... until we're totally done with the transitions
while (lMotion.MotionLayer._AnimatorTransitionID != 0)
{
yield return(null);
}
// Ensure we override the item and slot
IEquipStoreMotion lEquipStoreMotion = lMotion as IEquipStoreMotion;
if (lEquipStoreMotion != null)
{
lEquipStoreMotion.OverrideItemID = lItem.ID;
lEquipStoreMotion.OverrideSlotID = lSlot.ID;
}
// Now sheathe
mMotionController.ActivateMotion(lMotion);
while (lMotion.IsActive || lMotion.QueueActivation)
{
yield return(null);
}
// Clear the item
lSlot.ItemID = "";
}
}
}
}
// Second, find all the entries with no store motions destroy them
for (int i = 0; i < WeaponSets[rIndex].Items.Count; i++)
{
BasicInventorySlot lSlot = GetInventorySlot(WeaponSets[rIndex].Items[i].SlotID);
if (lSlot != null && lSlot.ItemID.Length > 0)
{
StoreItem(lSlot.ID);
}
}
mIsEquippingItem = false;
}
/// <summary>
/// Moves the agent to the link in a straight line
/// </summary>
/// <param name="speed">Speed at which we'll move</param>
protected IEnumerator ClimbUp(float rSpeed)
{
bool lStoredUpdatePosition = mNavMeshAgent.updatePosition;
bool lStoredUpdateRotation = mNavMeshAgent.updateRotation;
mNavMeshAgent.updatePosition = false;
mNavMeshAgent.updateRotation = false;
// First, move to the nav mesh start position
Vector3 lTargetPosition = mOffMeshLinkData.startPos + (Vector3.up * mNavMeshAgent.baseOffset);
while (mMotionController._Transform.position != lTargetPosition)
{
mMotionController._Transform.position = Vector3.MoveTowards(mMotionController._Transform.position, lTargetPosition, rSpeed * Time.deltaTime);
float lAngle = NumberHelper.GetHorizontalAngle(mMotionController._Transform.forward, (mOffMeshLinkData.endPos - mOffMeshLinkData.startPos).normalized, mMotionController._Transform.up);
mMotionController._Transform.rotation = mMotionController._Transform.rotation * Quaternion.AngleAxis(lAngle * 0.05f, Vector3.up);
yield return(null);
}
// Next, lets see if we can find a climb motion that will handle our movement
NavigationMessage lMessage = NavigationMessage.Allocate();
lMessage.ID = NavigationMessage.MSG_NAVIGATE_CLIMB;
mMotionController.SendMessage(lMessage);
if (lMessage.IsHandled)
{
// Wait for the climb to finish
mMotionController.ActorController.UseTransformPosition = false;
MotionControllerMotion lMotion = lMessage.Recipient as MotionControllerMotion;
while (lMotion != null && (lMotion.QueueActivation || lMotion.IsActive))
{
yield return(null);
}
mMotionController.ActorController.UseTransformPosition = true;
// Finally, move to the nav mesh end position
lTargetPosition = mOffMeshLinkData.endPos + (Vector3.up * mNavMeshAgent.baseOffset);
while (mMotionController._Transform.position != lTargetPosition)
{
mMotionController._Transform.position = Vector3.MoveTowards(mMotionController._Transform.position, lTargetPosition, rSpeed * Time.deltaTime);
yield return(null);
}
}
else
{
yield return(mMotionController.StartCoroutine(MoveParabola(mHeight, rSpeed)));
}
mNavMeshAgent.Warp(mMotionController._Transform.position);
mNavMeshAgent.updatePosition = lStoredUpdatePosition;
mNavMeshAgent.updateRotation = lStoredUpdateRotation;
}
/// <summary>
/// Coroutine to play the death animation and disable the actor after a couple of seconds
/// </summary>
/// <param name="rDamageValue">Amount of damage to take</param>
/// <param name="rDamageType">Damage type taken</param>
/// <param name="rAttackAngle">Angle that the damage came from releative to the actor's forward</param>
/// <param name="rBone">Transform that the damage it... if known</param>
/// <returns></returns>
protected virtual IEnumerator InternalDeath(IMessage rMessage)
{
ActorController lActorController = gameObject.GetComponent <ActorController>();
MotionController lMotionController = gameObject.GetComponent <MotionController>();
// Run the death animation if we can
if (rMessage != null && lMotionController != null)
{
// Send the message to the MC to let it activate
rMessage.ID = CombatMessage.MSG_DEFENDER_KILLED;
lMotionController.SendMessage(rMessage);
if (!rMessage.IsHandled && DeathMotion.Length > 0)
{
MotionControllerMotion lMotion = lMotionController.GetMotion(DeathMotion);
if (lMotion != null)
{
lMotionController.ActivateMotion(lMotion);
}
else
{
int lID = Animator.StringToHash(DeathMotion);
if (lID != 0)
{
Animator lAnimator = gameObject.GetComponent <Animator>();
if (lAnimator != null)
{
try
{
lAnimator.CrossFade(DeathMotion, 0.25f, 0);
}
catch { }
}
}
}
}
// Trigger the death animation
yield return(new WaitForSeconds(3.0f));
// Shut down the MC
lMotionController.enabled = false;
lMotionController.ActorController.enabled = false;
}
// Disable all colliders
Collider[] lColliders = gameObject.GetComponents <Collider>();
for (int i = 0; i < lColliders.Length; i++)
{
lColliders[i].enabled = false;
}
if (lActorController != null)
{
lActorController.RemoveBodyShapes();
}
}
/// <summary>
/// Registers a motion with the behavior
/// </summary>
/// <param name="rAnimator"></param>
/// <param name="rMotion"></param>
public virtual void AddMotion(MotionControllerMotion rMotion)
{
if (mMotions.IndexOf(rMotion) < 0)
{
mMotions.Add(rMotion);
}
mMotionCount = mMotions.Count;
}
/// <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 override bool TestInterruption(MotionControllerMotion rMotion)
{
// ********************************************************************************
// 16. If another motion with a higher priority wants to activate and deactivate
// your motion, you can prevent that from happening here. Simply return 'false'.
// ********************************************************************************
return(true);
}
/// <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 (!Motions.Contains(rMotion))
{
rMotion.MotionController = mMotionController;
rMotion.MotionLayer = this;
Motions.Add(rMotion);
}
}
/// <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)
{
// Trigger the transition
mActiveForm = (mActiveForm >= 0 ? mActiveForm : _Form);
mMotionController.SetAnimatorMotionPhase(mMotionLayer.AnimatorLayerIndex, PHASE_START, mActiveForm, mParameter, true);
// Finalize the activation
return(base.Activate(rPrevMotion));
}
/// <summary>
/// Example code on how to force which attack style to use.
/// </summary>
/// <param name="rCombatant">Combatant the event was fired for</param>
/// <param name="rMotion">Motion that represents the attack</param>
/// <returns></returns>
private bool OnAttackActivated(Combatant rCombatant, MotionControllerMotion rMotion)
{
BasicSpellCasting lAttacks = rMotion as BasicSpellCasting;
if (lAttacks != null)
{
lAttacks.SpellIndex = 0;
}
return(true);
}
/// <summary>
/// Allows the combatant a chance to modify the motion before it is fully activated.
/// </summary>
/// <param name="rMotion">Motion that is being activated</param>
/// <returns>Boolean used to determine if the motion should continue activation.</returns>
public virtual bool OnAttackActivated(MotionControllerMotion rMotion)
{
//com.ootii.Utilities.Debug.Log.FileWrite(_Transform.name + ".OnAttackActivated(" + rMotion.GetType().Name + ")");
if (AttackActivated != null)
{
return(AttackActivated(this, rMotion));
}
return(true);
}
/// <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 override bool TestInterruption(MotionControllerMotion rMotion)
{
if (rMotion is Fall)
{
if (mActorController.State.GroundSurfaceDistance < 2f)
{
return(false);
}
}
return(true);
}
/// <summary>
/// Deactivates the motion on the specified target
/// </summary>
/// <param name="rTarget">GameObject to activate the motion on</param>
/// <returns>Bool that determines if the motion was activated</returns>
public void ActivateInstance(GameObject rTarget)
{
MotionController lMotionController = rTarget.GetComponent <MotionController>();
if (lMotionController != null)
{
MotionControllerMotion lMotion = lMotionController.ActiveMotion;
if (lMotion != null && (lMotion.Name == _MotionName || lMotion.GetType().Name == _MotionName))
{
lMotion.Deactivate();
}
}
}
/// <summary>
/// Determines if this motion can be interrupted
/// </summary>
/// <param name="rMotion"></param>
/// <returns></returns>
public override bool TestInterruption(MotionControllerMotion rMotion)
{
// Don't allow the fall to kick in if we're close to the ground
if (rMotion is Fall)
{
if (mActorController.State.GroundSurfaceDistance < 1f)
{
return(false);
}
}
return(base.TestInterruption(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 override bool TestInterruption(MotionControllerMotion rMotion)
{
if (rMotion.Category != EnumMotionCategories.DEATH)
{
if (mIsEquipped)
{
mIsEquipped = false;
StoreItem();
}
}
return(base.TestInterruption(rMotion));
}
