void FindFriend(Actor target)
{
if (m_target != null)
{
return;
}
if (target.IsDead)
{
return;
}
if (ActorTargetManager.IsFriendly(m_self, target))
{
float d = ActorTargetManager.GetTargetDistance(m_self.MainPos, target.MainPos);
float attackRange = 0;
if (m_self.Type == ActorType.enNPC)
{
attackRange = (m_self as NPC).CurrentTableInfo.AttackRange;
}
else
{
attackRange = (m_self as Player).CurrentTableInfo.AttackRange;
}
if (d < attackRange)
{//攻击范围内
m_target = target;
}
}
}
static public bool IsFriendly(Actor self, Actor target)
{
if (self == target)
{
return(false);
}
ENCamp selfCamp = (ENCamp)self.Camp;
if (selfCamp != self.TempCamp)
{
selfCamp = self.TempCamp;
}
ActorType selfType = self.Type;
if (selfType != self.TempType)
{
selfType = self.TempType;
}
return(ActorTargetManager.IsFriendly(selfCamp, selfType, target));
}
//战斗托管时组建targetList
void CheckAutoBattleTarget(ENTargetType type, Actor target)
{
if (target.Type == ActorType.enNPC)
{
NPC npc = target as NPC;
if (npc.GetNpcType() == ENNpcType.enBlockNPC ||
npc.GetNpcType() == ENNpcType.enFunctionNPC)
{
return;
}
}
else if (target.Type == ActorType.enMain)
{
if (target.IsActorExit)
{
return;
}
}
if (target.IsDead)
{
return;
}
switch (type)
{
case ENTargetType.enEnemy:
{
if (!ActorTargetManager.IsEnemy(Owner, target))
{
return;
}
}
break;
case ENTargetType.enFriendly:
{
if (!ActorTargetManager.IsFriendly(Owner, target))
{
return;
}
}
break;
case ENTargetType.enSelf:
{
if (Owner != target)
{
return;
}
}
break;
case ENTargetType.enNullTarget:
break;
case ENTargetType.enFriendlyAndSelf:
{
if (!ActorTargetManager.IsFriendly(Owner, target) && Owner != target)
{
return;
}
}
break;
default:
break;
}
float distance = ActorTargetManager.GetTargetDistance(Owner.RealPos, target.RealPos);
if (distance < m_minDistance)
{
m_minDistance = distance;
m_minActor = target;
}
m_targetIDList.Add(target.ID);
}
void CheckActorDistance(Actor target, BuffResultInfo info)
{
if (target.Type == ActorType.enNPC)
{
NPC npc = target as NPC;
if (npc.GetNpcType() == ENNpcType.enBlockNPC ||
npc.GetNpcType() == ENNpcType.enFunctionNPC)
{
return;
}
}
else if (target.Type == ActorType.enMain)
{
if (target.IsActorExit)
{
return;
}
}
if (target.IsDead)
{
return;
}
switch ((ENTargetType)info.ParamList[2])//判断技能目标类型
{
case ENTargetType.enEnemy:
{
if (!ActorTargetManager.IsEnemy(m_selfActor, target))
{
return;
}
}
break;
case ENTargetType.enFriendly:
{
if (!ActorTargetManager.IsFriendly(m_selfActor, target))
{
return;
}
}
break;
case ENTargetType.enSelf:
{
if (m_selfActor != target)
{
return;
}
}
break;
case ENTargetType.enNullTarget:
break;
case ENTargetType.enFriendlyAndSelf:
{
if (!ActorTargetManager.IsFriendly(m_selfActor, target) && m_selfActor != target)
{
return;
}
}
break;
default:
break;
}
float distance = ActorTargetManager.GetTargetDistance(m_selfActor.RealPos, target.RealPos);
bool tmpFlag = true;
if (distance <= info.ParamList[1])//判断光环半径
{
foreach (Buff tmpBuf in target.MyBuffControl.BuffList)
{
if (tmpBuf.BuffID == (int)info.ParamList[2])
{
tmpFlag = false;
}
}
if (tmpFlag)
{
IResult addBuffResult = BattleFactory.Singleton.CreateResult(ENResult.AddBuff, m_selfActor.ID, target.ID, 0, 0, new float[1] {
info.ParamList[3]
});
if (addBuffResult != null)
{
addBuffResult.ResultExpr(new float[1] {
info.ParamList[3]
}); //添加技能ID
BattleFactory.Singleton.DispatchResult(addBuffResult);
}
}
}
else
{
tmpFlag = false;
foreach (Buff tmpBuf in target.MyBuffControl.BuffList)
{
if (tmpBuf.BuffID == info.ParamList[2])
{
tmpFlag = true;
}
}
if (tmpFlag)
{
IResult rbResult = BattleFactory.Singleton.CreateResult(ENResult.RemoveBuff, m_selfActor.ID, target.ID, 0, 0, new float[2] {
(float)ResultRemoveBuff.ENRemoveBuffType.enBuffID, info.ParamList[3]
});
if (rbResult != null)
{
rbResult.ResultExpr(new float[2] {
(float)ResultRemoveBuff.ENRemoveBuffType.enBuffID, info.ParamList[3]
});
BattleFactory.Singleton.DispatchResult(rbResult);
}
}
}
}
void CheckTarget(Actor target)
{
if (target == null || target.IsDead)
{
return;
}
Vector3 d = target.RealPos - Self.RealPos;
d.y = 0;
float distance = d.magnitude;
foreach (var item in Self.SkillBag)
{
if (item.IsSilence)
{
continue;
}
if (item.MinComboRequir > Self.Combo.TotalComboNumber)
{//combo值不足，不能释放技能
continue;
}
if (Self.CurrentRage < item.SkillTableInfo.CostRagePoint)
{//怒气值不足
continue;
}
if (distance < item.SkillTableInfo.LeastAttackDistance)
{//最小攻击距离内
continue;
}
float attackRange = Self.CurrentTableInfo.AttackRange;
if (!Self.CurrentTargetIsDead)
{
attackRange = item.SkillTableInfo.AttackDistance > attackRange ? item.SkillTableInfo.AttackDistance : attackRange;
}
if (distance < attackRange)
{//攻击距离内
switch ((ENTargetType)item.SkillTableInfo.TargetType)
{
case ENTargetType.enEnemy:
if (!ActorTargetManager.IsEnemy(Self, target))
{
continue;
}
break;
case ENTargetType.enFriendly:
if (!ActorTargetManager.IsFriendly(Self, target))
{
continue;
}
break;
case ENTargetType.enSelf:
if (Self != target)
{
continue;
}
break;
case ENTargetType.enNullTarget:
break;
case ENTargetType.enFriendlyAndSelf:
{
if (!ActorTargetManager.IsFriendly(Self, target) && Self != target)
{
continue;
}
}
break;
default:
continue;
//break;
}
if (!m_newSkillIDListForFire.Contains(item.SkillTableInfo.ID))
{
if (Self.NormalSkillList.Contains(item.SkillTableInfo.ID))
{
m_newSkillIDListForFire.AddRange(Self.NormalSkillList);
}
else
{
m_newSkillIDListForFire.Add(item.SkillTableInfo.ID);
}
}
if (!SkillIDListForFire.Contains(item.SkillTableInfo.ID))
{
m_isSkillUpdateForFire = true;
}
if (item.SkillTableInfo.SkillType == (int)ENSkillType.enSkill)
{//skill
FireSkillIDListWithoutNormal.Add(item.SkillTableInfo.ID);
}
}
}
}
bool LookupTarget(SkillInfo info, out Actor skillTarget, out float closestDistance)
{
skillTarget = null;
closestDistance = float.MaxValue;
//if (info.SkillTableInfo.SkillEffectType == (int)ENSkillEffectType.enRestore)
//{
// return false;
//}
if (info.TargetType == (int)ENTargetType.enNullTarget)
{//不需要目标就能释放的技能
return(true);
}
//首先查看是否可对当前目标释放
Actor curTarget = ActorManager.Singleton.Lookup(m_curTargetID);
if (curTarget != null && !curTarget.IsDead)
{
float distance = ActorTargetManager.GetTargetDistance(Owner.MainPos, curTarget.MainPos);
if (distance >= info.LeastAttackDistance)
{//最小攻击距离外
switch ((ENTargetType)info.TargetType)
{
case ENTargetType.enEnemy:
{
if (ActorTargetManager.IsEnemy(Owner, curTarget))
{
skillTarget = curTarget;
return(true);
}
}
break;
case ENTargetType.enFriendly:
{
if (ActorTargetManager.IsFriendly(Owner, curTarget))
{
skillTarget = curTarget;
return(true);
}
}
break;
case ENTargetType.enSelf:
{
if (Owner == curTarget)
{
skillTarget = curTarget;
return(true);
}
}
break;
case ENTargetType.enNullTarget:
break;
case ENTargetType.enFriendlyAndSelf:
{
if (ActorTargetManager.IsFriendly(Owner, curTarget) && Owner != curTarget)
{
skillTarget = curTarget;
return(true);
}
}
break;
default:
break;
}
}
}
//不可以对当前目标释放，查找距离自己最近的
for (int i = 0; i < m_targetIDList.Count; ++i)
{
Actor target = ActorManager.Singleton.Lookup(m_targetIDList[i]);
if (target == null)
{
continue;
}
if (target.IsDead)
{
continue;
}
float distance = ActorTargetManager.GetTargetDistance(Owner.MainPos, target.MainPos);
if (distance < info.LeastAttackDistance)
{//最小攻击距离内
continue;
}
switch ((ENTargetType)info.TargetType)
{
case ENTargetType.enEnemy:
{
if (!ActorTargetManager.IsEnemy(Owner, target))
{
continue;
}
}
break;
case ENTargetType.enFriendly:
{
if (!ActorTargetManager.IsFriendly(Owner, target))
{
continue;
}
}
break;
case ENTargetType.enSelf:
{
if (Owner != target)
{
continue;
}
}
break;
case ENTargetType.enNullTarget:
break;
case ENTargetType.enFriendlyAndSelf:
{
if (!ActorTargetManager.IsFriendly(Owner, target) && Owner != target)
{
continue;
}
}
break;
default:
break;
}
if (m_firstTargetType != ActorType.enNone)
{ //优先选择目标条件成立
if (target.Type == m_firstTargetType)
{ //是优先选择的目标类型
if (skillTarget == null)
{
skillTarget = target;
closestDistance = distance;
}
else
{
if (skillTarget.Type == m_firstTargetType)
{//已有优先目标，进行比较，取近的
if (distance < closestDistance)
{
skillTarget = target;
closestDistance = distance;
}
}
else
{
skillTarget = target;
closestDistance = distance;
}
}
}
else
{
if (skillTarget == null)
{
skillTarget = target;
closestDistance = distance;
}
else
{
if (skillTarget.Type != m_firstTargetType)
{
if (distance < closestDistance)
{
skillTarget = target;
closestDistance = distance;
}
}
}
}
}
else
{
if (distance < info.AttackDistance)
{
skillTarget = target;
break;
}
else
{
if (distance < closestDistance)
{
skillTarget = target;
closestDistance = distance;
}
}
}
}
return(skillTarget != null);
}
void CheckTarget(Actor target)
{
if (target.Type == ActorType.enNPC)
{
NPC npc = target as NPC;
if (npc.GetNpcType() == ENNpcType.enBlockNPC ||
npc.GetNpcType() == ENNpcType.enFunctionNPC)
{
return;
}
}
else if (target.Type == ActorType.enMain)
{
if (target.IsActorExit)
{
return;
}
}
if (target.IsDead)
{
return;
}
switch (m_searchTargetType)
{
case ENTargetType.enEnemy:
{
if (!ActorTargetManager.IsEnemy(Owner, target))
{
return;
}
}
break;
case ENTargetType.enFriendly:
{
if (!ActorTargetManager.IsFriendly(Owner, target))
{
return;
}
}
break;
case ENTargetType.enSelf:
{
if (Owner != target)
{
return;
}
}
break;
case ENTargetType.enNullTarget:
break;
case ENTargetType.enFriendlyAndSelf:
{
if (!ActorTargetManager.IsFriendly(Owner, target) && Owner != target)
{
return;
}
}
break;
default:
break;
}
float range = 0;
if (Owner.Type == ActorType.enMain || Owner.Type == ActorType.enSwitch || Owner.Type == ActorType.enFollow)
{
Player self = Owner as Player;
range = self.CurrentTableInfo.AttackRange;
if (range <= 0)
{
return;
}
range = m_searchTargetRange != 0 ? m_searchTargetRange : range;
}
else if (Owner.Type == ActorType.enNPC)
{
NPC npc = Owner as NPC;
if (npc.AttackRange <= 0)
{
return;
}
range = m_searchTargetRange != 0 ? m_searchTargetRange : npc.AttackRange;
}
float distance = ActorTargetManager.GetTargetDistance(Owner.RealPos, target.RealPos);
if (range >= distance)
{
if (distance < m_minDistance)
{
m_minDistance = distance;
m_minActor = target;
}
m_targetIDList.Add(target.ID);
}
}
public void OnTriggerEnter(GameObject selfObj, Collider other)
{
if (other.isTrigger)
{
//Debug.LogWarning("OnTriggerEnter other.isTrigger is true");
return;
}
Actor target = null;
Transform targetObj = other.transform;
while (null != targetObj && targetObj.name != "body")
{
targetObj = targetObj.parent;
}
if (null == targetObj)
{
//Debug.LogWarning("OnTriggerEnter target obj is null");
return;
}
ActorProp prop = targetObj.parent.GetComponent <ActorProp>();
target = prop.ActorLogicObj;
if (null == target)
{
Debug.LogWarning("OnTriggerEnter target is null");
return;
}
if (target.IsDead)
{
//Debug.LogWarning("OnTriggerEnter target is deaded");
return;
}
//Debug.LogWarning("OnTriggerEnter target id is " +target.ID.ToString());
SkillResultInfo info = GameTable.SkillResultTableAsset.Lookup(SkillResultID);
if (info == null)
{
Debug.LogError("SkillResultID is null, actor ID:" + CurrentActor.ID + "SkillResultID:," + SkillResultID + ",skillID:" + m_skillID + ",index:" + m_skillResultIDIndex);
DebugLog.Singleton.OnShowLog("SkillResultID is null, actor ID:" + CurrentActor.ID + "SkillResultID:" + SkillResultID + ",skillID:" + m_skillID + ",index:" + m_skillResultIDIndex);
return;
}
ActorProp selfProp = selfObj.transform.parent.GetComponent <ActorProp>();
Actor self = selfProp.ActorLogicObj;
switch ((ENResultTargetType)info.ResultTargetType)
{
case ENResultTargetType.enEnemySingle:
{ //只作用于第一个enemy
if (m_skillTarget != null)
{
if (m_skillTarget != target)
{
return;
}
}
else
{
if (m_firstTarget != null)
{
return;
}
if (!ActorTargetManager.IsEnemy(self, target))
{
return;
}
m_firstTarget = target;
}
}
break;
case ENResultTargetType.enEnemyAll:
{ //作用于所有enemy
if (!ActorTargetManager.IsEnemy(self, target))
{
return;
}
}
break;
case ENResultTargetType.enFriendlySingle:
{ //只作用于第一个friendly
if (m_skillTarget != null)
{
if (m_skillTarget != target)
{
return;
}
}
else
{
if (m_firstTarget != null)
{
return;
}
if (!ActorTargetManager.IsFriendly(self, target))
{
return;
}
m_firstTarget = target;
}
}
break;
case ENResultTargetType.enFriendlyAll:
{ //作用于所有friendly
if (!ActorTargetManager.IsFriendly(self, target))
{
return;
}
}
break;
case ENResultTargetType.enEveryone:
break;
case ENResultTargetType.enSelf:
{
if (self != target)
{
return;
}
}
break;
case ENResultTargetType.enFriendlyAllAndSelf:
{
if (!ActorTargetManager.IsFriendly(self, target) && self != target)
{
return;
}
}
break;
case ENResultTargetType.enFriendlySingleAndSelf:
{
if (!ActorTargetManager.IsFriendly(self, target) && self != target)
{
return;
}
if (m_firstTarget != null)
{
return;
}
m_firstTarget = target;
}
break;
default:
return;
}
if (ClientNet.Singleton.IsConnected)
{
IResult r = BattleFactory.Singleton.CreateResult(ENResult.Skill, self.ID, target.ID,
SkillResultID, m_skillInfo != null ? m_skillInfo.ID : 0);
if (r != null)
{
target.SetBlastPos(self.RealPos, self.GetBodyObject().transform.forward);
r.ResultExpr(null);
BattleFactory.Singleton.GetBattleContext().CreateResultControl().DispatchResult(r);
}
}
else
{
IResult r = BattleFactory.Singleton.CreateResult(ENResult.Skill, self.ID, target.ID,
SkillResultID, m_skillInfo != null ? m_skillInfo.ID : 0);
if (r != null)
{
target.SetBlastPos(self.RealPos, self.GetBodyObject().transform.forward);
r.ResultExpr(null);
BattleFactory.Singleton.GetBattleContext().CreateResultControl().DispatchResult(r);
}
}
if (!string.IsNullOrEmpty(info.SoundList))
{//播放击中声音
string[] param = info.SoundList.Split(new char[1] {
','
});
string sound = param[0];
if (!string.IsNullOrEmpty(sound))
{
#if UNITY_IPHONE || UNITY_ANDRIOD
#else
AudioClip aClip = PoolManager.Singleton.LoadSound(sound);
if (aClip != null)
{
AudioSource.PlayClipAtPoint(aClip, selfObj.transform.position);
}
#endif
}
else
{
Debug.LogWarning("sound string is null");
}
}
m_isTriggerSucced = true;
m_isMissing = false;
}
public bool CreateSkillResult()
{
SkillResultInfo info = GameTable.SkillResultTableAsset.Lookup(SkillResultID);
if (info == null)
{
Debug.LogError("SkillResultID is null, SkillResultID:" + SkillResultID + ",skillID:" + m_skillID + ",index:" + m_skillResultIDIndex);
return(false);
}
CurrentActor.SelfAI.GetRangeTargetList(ENTargetType.enNone, info.InstantRange);
List <int> resultActorIDList = new List <int>();
float minDistance = float.MaxValue;
int tempActorID = 0;
foreach (var targetID in CurrentActor.SelfAI.m_targetIDList)
{
Actor target = ActorManager.Singleton.Lookup(targetID);
if (target == null || target.IsDead)
{
continue;
}
switch ((ENResultTargetType)info.ResultTargetType)
{
case ENResultTargetType.enEnemySingle:
{ //作用于单个enemy
if (m_skillTarget != null && ActorTargetManager.IsEnemy(CurrentActor, m_skillTarget))
{ //有技能目标,技能目标是enemy
if (m_skillTarget == target)
{
tempActorID = m_skillTarget.ID;
}
}
else
{
if (ActorTargetManager.IsEnemy(CurrentActor, target))
{
Vector3 temp = target.RealPos - CurrentActor.MainPos;
temp.y = 0;
if (temp.magnitude < minDistance)
{
minDistance = temp.magnitude;
tempActorID = target.ID;
}
}
}
}
break;
case ENResultTargetType.enEnemyAll:
{ //作用于所有enemy
if (ActorTargetManager.IsEnemy(CurrentActor, target))
{
resultActorIDList.Add(target.ID);
}
}
break;
case ENResultTargetType.enFriendlySingle:
{ //作用于单个friendly
if (m_skillTarget != null && ActorTargetManager.IsFriendly(CurrentActor, m_skillTarget))
{ //有技能目标,技能目标是friend
if (m_skillTarget == target)
{
tempActorID = m_skillTarget.ID;
}
}
else
{
if (ActorTargetManager.IsFriendly(CurrentActor, target))
{
Vector3 temp = target.RealPos - CurrentActor.MainPos;
temp.y = 0;
if (temp.magnitude < minDistance)
{
minDistance = temp.magnitude;
tempActorID = target.ID;
}
}
}
}
break;
case ENResultTargetType.enFriendlyAll:
{ //作用于所有friendly
if (ActorTargetManager.IsFriendly(CurrentActor, target))
{
resultActorIDList.Add(target.ID);
}
}
break;
case ENResultTargetType.enEveryone:
{
resultActorIDList.Add(target.ID);
}
break;
case ENResultTargetType.enSelf:
{
if (CurrentActor == target)
{
tempActorID = target.ID;
}
}
break;
case ENResultTargetType.enFriendlyAllAndSelf:
{
if (ActorTargetManager.IsFriendly(CurrentActor, target) || CurrentActor == target)
{
resultActorIDList.Add(target.ID);
}
}
break;
case ENResultTargetType.enFriendlySingleAndSelf:
{
if (m_skillTarget != null &&
(ActorTargetManager.IsFriendly(CurrentActor, m_skillTarget) || m_skillTarget == CurrentActor))
{
tempActorID = m_skillTarget.ID;
}
else
{ //自己
if (CurrentActor == target)
{
tempActorID = target.ID;
}
}
}
break;
default:
break;
}
}
if (tempActorID != 0)
{
resultActorIDList.Add(tempActorID);
}
//if (ClientNet.Singleton.IsConnected)
//{
//}
//else
{
foreach (var targetID in resultActorIDList)
{
IResult r = BattleFactory.Singleton.CreateResult(ENResult.Skill, CurrentActor.ID, targetID,
SkillResultID, m_skillInfo != null ? m_skillInfo.ID : 0);
if (r != null)
{
Actor targetActor = ActorManager.Singleton.Lookup(targetID);
targetActor.SetBlastPos(CurrentActor.RealPos, CurrentActor.GetBodyObject().transform.forward);
r.ResultExpr(null);
BattleFactory.Singleton.GetBattleContext().CreateResultControl().DispatchResult(r);
}
}
}
return(true);
}
void CheckTarget(Actor target)
{
if (SkillTargetIDList.Contains(target.ID))
{
return;
}
if (target.IsDead)
{
return;
}
float d = ActorTargetManager.GetTargetDistance(CurrentActor.RealPos, target.RealPos);
if (m_skillInfo.AttackDistance >= d)
{
switch ((ENTargetType)m_skillInfo.TargetType)
{
case ENTargetType.enEnemy:
{
if (!ActorTargetManager.IsEnemy(CurrentActor, target))
{
return;
}
}
break;
case ENTargetType.enFriendly:
{
if (!ActorTargetManager.IsFriendly(CurrentActor, target))
{
return;
}
}
break;
case ENTargetType.enSelf:
{
if (CurrentActor != target)
{
return;
}
}
break;
case ENTargetType.enNullTarget:
break;
case ENTargetType.enInteraction:
{
if (!ActorTargetManager.IsInteractionally(CurrentActor, target))
{
return;
}
}
break;
case ENTargetType.enFriendlyAndSelf:
{
if (!ActorTargetManager.IsFriendly(CurrentActor, target) && CurrentActor != target)
{
return;
}
}
break;
default:
return;
}
if (d < m_closestDistance)
{
m_closestTargetID = target.ID;
}
}
}
//paramList
//0:resultID
//1:resultRange
//2:resultTargetType
//3:skillID
void CheckTarget(Actor target, float[] paramList)
{
if (isReturn)
{
return;
}
if (target.IsDead)
{
return;
}
float range = paramList[1];
float d = ActorTargetManager.GetTargetDistance(m_self.RealPos, target.RealPos);
if (d > range)
{
return;
}
ENResultTargetType type = (ENResultTargetType)paramList[2];
switch ((ENResultTargetType)type)
{
case ENResultTargetType.enEnemySingle:
{
if (ActorTargetManager.IsEnemy(m_self, target))
{
CreateResult_Skill((int)paramList[0], target, (int)paramList[3], paramList);
isReturn = true;
}
}
break;
case ENResultTargetType.enEnemyAll:
{
if (ActorTargetManager.IsEnemy(m_self, target))
{
CreateResult_Skill((int)paramList[0], target, (int)paramList[3], paramList);
}
}
break;
case ENResultTargetType.enFriendlySingle:
{
if (ActorTargetManager.IsFriendly(m_self, target))
{
CreateResult_Skill((int)paramList[0], target, (int)paramList[3], paramList);
isReturn = true;
}
}
break;
case ENResultTargetType.enFriendlyAll:
{
if (ActorTargetManager.IsFriendly(m_self, target))
{
CreateResult_Skill((int)paramList[0], target, (int)paramList[3], paramList);
isReturn = true;
}
}
break;
case ENResultTargetType.enEveryone:
{
CreateResult_Skill((int)paramList[0], target, (int)paramList[3], paramList);
}
break;
case ENResultTargetType.enFriendlyAllAndSelf:
{
if (ActorTargetManager.IsFriendly(m_self, target) || m_self == target)
{
CreateResult_Skill((int)paramList[0], target, (int)paramList[3], paramList);
}
}
break;
}
}
//通过skillResultID产生技能result
public bool CreateSkillResult(int sourceID, int skillResultID, int targetID = 0, int skillID = 0, float[] param = null)
{
m_self = ActorManager.Singleton.Lookup(sourceID);
if (m_self == null)
{
Debug.LogWarning("self is null, id is " + sourceID);
return(false);
}
Actor target = ActorManager.Singleton.Lookup(targetID);
SkillResultInfo info = GameTable.SkillResultTableAsset.Lookup(skillResultID);
if (info == null)
{
if (skillResultID != 0)
{
Debug.LogWarning("result id is error, id is " + skillResultID);
}
return(false);
}
float range = float.MinValue;
if (info.InstantRange != 0)
{
range = info.InstantRange;
}
//优先判断当前目标和自己
switch ((ENResultTargetType)info.ResultTargetType)
{
case ENResultTargetType.enEnemySingle:
{
if (target != null && !target.IsDead)
{
if (ActorTargetManager.IsEnemy(m_self, target))
{
float d = ActorTargetManager.GetTargetDistance(m_self.RealPos, target.RealPos);
if (d <= range)
{ //给当前技能目标加skillresult
CreateResult_Skill(info.ID, target, skillID, param);
return(true);
}
}
}
}
break;
case ENResultTargetType.enFriendlySingle:
{
if (target != null && !target.IsDead)
{
if (ActorTargetManager.IsFriendly(m_self, target))
{
float d = ActorTargetManager.GetTargetDistance(m_self.RealPos, target.RealPos);
if (d <= range)
{ //给当前技能目标加skillresult
CreateResult_Skill(info.ID, target, skillID, param);
return(true);
}
}
}
}
break;
case ENResultTargetType.enSelf:
case ENResultTargetType.enFriendlySingleAndSelf:
{ //给自己加skillresult
CreateResult_Skill(info.ID, m_self, skillID, param);
return(true);
}
//break;
}
ActorManager.Singleton.ForEach_result(CheckTarget, new float[4] {
info.ID, range, info.ResultTargetType, skillID
});
return(true);
}
void CheckTarget(Actor target)
{
if (target.Type == ActorType.enNPC)
{
NPC npc = target as NPC;
if (npc.GetNpcType() == ENNpcType.enBlockNPC ||
npc.GetNpcType() == ENNpcType.enFunctionNPC)
{
return;
}
}
if (target.IsDead)
{
return;
}
switch (m_searchTargetType)
{
case ENTargetType.enEnemy:
{
if (!ActorTargetManager.IsEnemy(m_selfCamp, m_selfActorType, target))
{
return;
}
}
break;
case ENTargetType.enFriendly:
{
if (!ActorTargetManager.IsFriendly(m_selfCamp, m_selfActorType, target))
{
return;
}
}
break;
case ENTargetType.enSelf:
{
if (m_selfActorType != target.Type)
{
return;
}
}
break;
case ENTargetType.enNullTarget:
break;
case ENTargetType.enFriendlyAndSelf:
{
if (!ActorTargetManager.IsFriendly(m_selfCamp, m_selfActorType, target) && m_selfActorType != target.Type)
{
return;
}
}
break;
default:
break;
}
Vector3 distance = target.RealPos - m_selfPos;
distance.y = 0;
if (m_searchTargetRange >= distance.magnitude)
{
m_targetIDList.Add(target.ID);
}
}
void OnTriggerEnter(Collider other)
{
if (!ActorTargetManager.IsTrigger(other))
{
return;
}
try
{
if (m_info.m_isNeedRemove)
{
return;
}
Transform targetObj = other.transform;
while (null != targetObj && targetObj.name != "body")
{
targetObj = targetObj.parent;
}
if (null == targetObj)
{
return;
}
ActorProp actorProp = targetObj.parent.GetComponent <ActorProp>();
if (null == actorProp)
{
Debug.LogWarning("trigger return, actorProp get failed");
return;
}
Actor target = actorProp.ActorLogicObj;
if (target == null || target.IsDead)
{
return;
}
if (m_info.m_itemInfo.IsOnlyForChosenTarget)
{ //只对选中目标生效
if (target != m_info.m_dstActor)
{ //不是选中目标
return;
}
}
if (m_info.m_bouncyTargetIDList != null)
{ //反弹中
if (target != m_info.m_dstActor)
{ //不是选中目标
return;
}
}
SkillResultInfo info = GameTable.SkillResultTableAsset.Lookup(m_info.m_itemInfo.Item_ResultID);
if (info == null)
{
//Debug.LogWarning("trigger return, SkillResultInfo is null, result id is " + m_info.m_itemInfo.Item_ResultID);
return;
}
switch ((ENResultTargetType)info.ResultTargetType)
{
case ENResultTargetType.enEnemySingle:
case ENResultTargetType.enEnemyAll:
{ //作用于enemy
if (!ActorTargetManager.IsEnemy(m_info.m_actorCamp, m_info.m_actorType, target))
{
return;
}
}
break;
case ENResultTargetType.enFriendlySingle:
case ENResultTargetType.enFriendlyAll:
{ //作用于friendly
if (!ActorTargetManager.IsFriendly(m_info.m_actorCamp, m_info.m_actorType, target))
{
return;
}
}
break;
case ENResultTargetType.enEveryone:
break;
case ENResultTargetType.enSelf:
if (m_info.m_actorType != target.Type)
{
return;
}
break;
case ENResultTargetType.enFriendlyAllAndSelf:
case ENResultTargetType.enFriendlySingleAndSelf:
{
if (!ActorTargetManager.IsFriendly(m_info.m_actorCamp, m_info.m_actorType, target) && m_info.m_actorType != target.Type)
{
return;
}
}
break;
default:
return;
}
if (m_targetIDList.Contains(target.ID))
{
if (!m_info.m_itemInfo.IsMultiResult)
{//不对目标多次生效
return;
}
}
else
{
m_targetIDList.Add(target.ID);
}
GlobalEnvironment.Singleton.IsInCallbackOrTrigger = true;
IResult r = BattleFactory.Singleton.CreateResult(ENResult.Skill, m_info.m_srcActor.ID, target.ID,
m_info.m_itemInfo.Item_ResultID, m_info.m_skillID);
if (r != null)
{
target.SetBlastPos(m_info.m_itemObj.transform.position, m_info.m_itemObj.transform.forward);
r.ResultExpr(null);
BattleFactory.Singleton.GetBattleContext().CreateResultControl().DispatchResult(r);
}
if (m_info.m_itemInfo.IsRemoveAfterResult)
{
m_info.m_isNeedRemove = true;
}
//播放击中声音
if (!string.IsNullOrEmpty(info.SoundList))
{
string[] param = info.SoundList.Split(new char[1] {
','
});
string sound = param[0];
if (!string.IsNullOrEmpty(sound))
{
#if UNITY_IPHONE || UNITY_ANDRIOD
#else
AudioClip aClip = PoolManager.Singleton.LoadSound(sound);
if (aClip != null)
{
AudioSource.PlayClipAtPoint(aClip, gameObject.transform.position);
}
#endif
}
else
{
Debug.LogWarning("sound string is null");
}
}
RemoteAttackManager.Singleton.StartBouncy(m_info, target.MainPos);
}
catch (Exception e)
{
Debug.LogError("Error On OnTriggerEnter" + e.Message + ",,,,Stack:" + e.StackTrace.ToString());
}
GlobalEnvironment.Singleton.IsInCallbackOrTrigger = false;
}
