/// <summary>
/// Raised when we release the lock on a target
/// </summary>
protected virtual void OnTargetUnlocked(Transform rTransform)
{
if (_UnlockCameraMode >= 0)
{
if (mMotionController != null && mMotionController.CameraRig != null)
{
mMotionController.CameraRig.Mode = _UnlockCameraMode;
}
}
if (TargetUnlocked != null)
{
TargetUnlocked(this, rTransform);
}
// Send the message
CombatMessage lMessage = CombatMessage.Allocate();
lMessage.ID = EnumMessageID.MSG_COMBAT_ATTACKER_TARGET_UNLOCKED;
lMessage.Attacker = gameObject;
lMessage.Defender = rTransform.gameObject;
if (TargetUnlockedEvent != null)
{
TargetUnlockedEvent.Invoke(lMessage);
}
#if USE_MESSAGE_DISPATCHER || OOTII_MD
MessageDispatcher.SendMessage(lMessage);
#endif
CombatMessage.Release(lMessage);
}
/// <summary>
/// Pulls an object from the pool.
/// </summary>
/// <returns></returns>
public static CombatMessage Allocate(CombatMessage rSource)
{
// Grab the next available object
CombatMessage lInstance = sPool.Allocate();
if (lInstance == null)
{
lInstance = new CombatMessage();
}
lInstance.Attacker = rSource.Attacker;
lInstance.Defender = rSource.Defender;
lInstance.Weapon = rSource.Weapon;
lInstance.StyleIndex = rSource.StyleIndex;
lInstance.CombatStyle = rSource.CombatStyle;
lInstance.Damage = rSource.Damage;
lInstance.DamageType = rSource.DamageType;
lInstance.ImpactPower = rSource.ImpactPower;
lInstance.HitVector = rSource.HitVector;
lInstance.HitTransform = rSource.HitTransform;
lInstance.HitPoint = rSource.HitPoint;
lInstance.HitDirection = rSource.HitDirection;
// Reset the sent flags. We do this so messages are flagged as 'completed'
// by default.
lInstance.IsSent = false;
lInstance.IsHandled = false;
// For this type, guarentee we have something
// to hand back tot he caller
return(lInstance);
}
/// <summary>
/// Notifies the defender that they are attacked.
/// </summary>
/// <param name="rRound"></param>
public virtual void OnAttacked(CombatMessage rMessage)
{
//com.ootii.Utilities.Debug.Log.FileWrite(_Transform.name + ".OnAttacked()");
if (Attacked != null)
{
Attacked(this, rMessage);
}
if (rMessage.ID != CombatMessage.MSG_DEFENDER_ATTACKED)
{
return;
}
ActorCore lDefenderCore = gameObject.GetComponent <ActorCore>();
if (lDefenderCore != null)
{
lDefenderCore.SendMessage(rMessage);
}
else
{
// Check if this defender is blocking, parrying, etc
if (mMotionController != null)
{
mMotionController.SendMessage(rMessage);
}
// Determine if we're continuing with the attack and apply damage
if (rMessage.ID == CombatMessage.MSG_DEFENDER_ATTACKED)
{
IDamageable lDamageable = gameObject.GetComponent <IDamageable>();
if (lDamageable != null)
{
lDamageable.OnDamaged(rMessage);
}
else
{
rMessage.ID = CombatMessage.MSG_DEFENDER_DAMAGED;
if (mMotionController != null)
{
mMotionController.SendMessage(rMessage);
}
}
}
// Disable this combatant
if (rMessage.ID == CombatMessage.MSG_DEFENDER_KILLED)
{
this.enabled = false;
}
}
}
/// <summary>
/// Occurs prior to the defender receiving the attack notification. This
/// allows the attacker to augment the attack if needed.
/// </summary>
/// <param name="rRound"></param>
public virtual void OnPreAttack(CombatMessage rMessage)
{
//com.ootii.Utilities.Debug.Log.FileWrite(_Transform.name + ".OnPreAttack()");
if (PreAttack != null)
{
PreAttack(this, rMessage);
}
if (mMotionController != null)
{
mMotionController.SendMessage(rMessage);
}
}
/// <summary>
/// Returns an element back to the pool.
/// </summary>
/// <param name="rEdge"></param>
public static void Release(CombatMessage rInstance)
{
if (rInstance == null)
{
return;
}
// Reset the sent flags. We do this so messages are flagged as 'completed'
// and removed by default.
rInstance.IsSent = true;
rInstance.IsHandled = true;
// Make it available to others.
sPool.Release(rInstance);
}
/// <summary>
/// Pulls an object from the pool.
/// </summary>
/// <returns></returns>
public static CombatMessage Allocate()
{
// Grab the next available object
CombatMessage lInstance = sPool.Allocate();
// Reset the sent flags. We do this so messages are flagged as 'completed'
// by default.
lInstance.IsSent = false;
lInstance.IsHandled = false;
// For this type, guarentee we have something
// to hand back tot he caller
if (lInstance == null)
{
lInstance = new CombatMessage();
}
return(lInstance);
}
/// <summary>
/// Returns an element back to the pool.
/// </summary>
/// <param name="rEdge"></param>
public static void Release(CombatMessage rInstance)
{
if (rInstance == null)
{
return;
}
// We should never release an instance unless we're
// sure we're done with it. So clearing here is fine
rInstance.Clear();
// Reset the sent flags. We do this so messages are flagged as 'completed'
// and removed by default.
rInstance.IsSent = true;
rInstance.IsHandled = true;
// Make it available to others.
sPool.Release(rInstance);
}
/// <summary>
/// Occurs after the defender receives the attack notification. This
/// allows the attacker to react to the defender if needed.
/// </summary>
/// <param name="rRound"></param>
public virtual void OnPostAttack(CombatMessage rMessage)
{
//com.ootii.Utilities.Debug.Log.FileWrite(_Transform.name + ".OnPostAttack()");
if (PostAttack != null)
{
PostAttack(this, rMessage);
}
if (mMotionController != null)
{
mMotionController.SendMessage(rMessage);
}
// If the defender was killed, release the target
if (_Target != null && rMessage.ID == CombatMessage.MSG_DEFENDER_KILLED)
{
IsTargetLocked = false;
OnTargetUnlocked(_Target);
}
}
