public override bool Execute(object sender, SkillInstance instance, long delta, long curSectionTime)
{
GfxSkillSenderInfo senderObj = sender as GfxSkillSenderInfo;
if (null == senderObj)
{
return(false);
}
Scene scene = senderObj.Scene;
EntityInfo obj = senderObj.GfxObj;
if (curSectionTime < StartTime)
{
return(true);
}
if (m_RemainTime > 0 && curSectionTime > (StartTime + m_RemainTime))
{
return(false);
}
if (senderObj.ConfigData.type == (int)SkillOrImpactType.Skill)
{
scene.EntityController.KeepTarget(senderObj.TargetActorId);
}
else
{
scene.EntityController.KeepTarget(senderObj.ActorId);
}
return(true);
}
public override bool Execute(object sender, SkillInstance instance, long delta, long curSectionTime)
{
GfxSkillSenderInfo senderObj = sender as GfxSkillSenderInfo;
if (null == senderObj)
{
return(false);
}
EntityInfo obj = senderObj.GfxObj;
if (obj == null)
{
return(false);
}
if (curSectionTime < StartTime)
{
return(true);
}
if (StartTime + m_DurationTime < curSectionTime)
{
return(false);
}
EntityInfo targetObj = senderObj.TargetGfxObj;
if (null != targetObj)
{
Vector3 srcPos = targetObj.GetMovementStateInfo().GetPosition3D();
float dir = targetObj.GetMovementStateInfo().GetFaceDir();
Vector3 pos = Geometry.TransformPoint(srcPos, m_RelativeOffset, dir);
TriggerUtil.MoveObjTo(obj, pos);
}
return(true);
}
public override bool Execute(object sender, SkillInstance instance, long delta, long curSectionTime)
{
GfxSkillSenderInfo senderObj = sender as GfxSkillSenderInfo;
if (null == senderObj)
{
return(false);
}
GameObject obj = senderObj.GfxObj;
if (null == obj)
{
return(false);
}
if (null != senderObj.TrackEffectObj)
{
obj = senderObj.TrackEffectObj;
}
if (curSectionTime < StartTime)
{
return(true);
}
Vector3 old_pos = instance.CustomDatas.GetData <Vector3>();
if (old_pos.sqrMagnitude > Geometry.c_FloatPrecision)
{
obj.transform.position = old_pos;
}
return(false);
}
public override bool Execute(object sender, SkillInstance instance, long delta, long curSectionTime)
{
GfxSkillSenderInfo senderObj = sender as GfxSkillSenderInfo;
if (null == senderObj)
{
return(false);
}
GameObject obj = senderObj.GfxObj;
if (null == obj)
{
return(false);
}
if (curSectionTime < StartTime)
{
return(true);
}
EffectManager em = instance.CustomDatas.GetData <EffectManager>();
if (em == null)
{
return(false);
}
em.StopEffects();
return(false);
}
public override bool Execute(object sender, SkillInstance instance, long delta, long curSectionTime)
{
GfxSkillSenderInfo senderObj = sender as GfxSkillSenderInfo;
if (null == senderObj)
{
return(false);
}
GameObject obj = senderObj.GfxObj;
if (obj == null)
{
return(false);
}
if (curSectionTime < StartTime)
{
return(true);
}
TargetManager mgr = instance.CustomDatas.GetData <TargetManager>();
if (null != mgr)
{
mgr.Clear();
}
return(false);
}
public override bool Execute(object sender, SkillInstance instance, long delta, long curSectionTime)
{
GfxSkillSenderInfo senderObj = sender as GfxSkillSenderInfo;
if (null == senderObj)
{
return(false);
}
GameObject obj = senderObj.GfxObj;
if (null == obj)
{
return(false);
}
if (curSectionTime >= StartTime)
{
if (senderObj.ConfigData.type != (int)SkillOrImpactType.Skill)
{
EntityController.Instance.ImpactDamage(senderObj.TargetActorId, senderObj.ActorId, senderObj.SkillId, senderObj.Seq, IsFinal);
}
return(false);
}
else
{
return(true);
}
}
public override bool Execute(object sender, SkillInstance instance, long delta, long curSectionTime)
{
GfxSkillSenderInfo senderObj = sender as GfxSkillSenderInfo;
if (null == senderObj)
{
return(false);
}
GameObject obj = senderObj.GfxObj;
if (null == obj)
{
return(false);
}
if (null != senderObj.TrackEffectObj)
{
obj = senderObj.TrackEffectObj;
}
if (curSectionTime < StartTime)
{
return(true);
}
if (curSectionTime > StartTime + m_RemainTime)
{
return(false);
}
obj.transform.Rotate(m_RotateSpeed * TriggerUtil.ConvertToSecond(delta));
return(true);
}
public override bool Execute(object sender, SkillInstance instance, long delta, long curSectionTime)
{
GfxSkillSenderInfo senderObj = sender as GfxSkillSenderInfo;
if (null == senderObj)
{
return(false);
}
GameObject obj = senderObj.GfxObj;
if (null == obj)
{
EntityController.Instance.RemoveState(senderObj.ActorId, m_State);
return(false);
}
if (curSectionTime >= StartTime)
{
EntityController.Instance.AddState(senderObj.ActorId, m_State);
return(false);
}
else
{
return(true);
}
}
public override bool Execute(object sender, SkillInstance instance, long delta, long curSectionTime)
{
GfxSkillSenderInfo senderObj = sender as GfxSkillSenderInfo;
if (null == senderObj)
{
return(false);
}
GameObject obj = senderObj.GfxObj;
if (null == obj)
{
return(false);
}
if (curSectionTime < StartTime)
{
return(true);
}
if (m_LastKeepTime <= 0 || m_LastKeepTime + m_Interval >= curSectionTime)
{
m_LastKeepTime = curSectionTime;
int time = EntityController.Instance.GetImpactDuration(senderObj.ObjId, senderObj.SkillId, senderObj.Seq);
if (time > 0)
{
instance.SetCurSectionDuration((long)time + m_DeltaTime);
}
else
{
LogSystem.Warn("adjustsectionduration impact duration is 0, skill id:{0} dsl skill id:{1}", senderObj.SkillId, instance.DslSkillId);
}
}
return(true);
}
public override bool Execute(object sender, SkillInstance instance, long delta, long curSectionTime)
{
GfxSkillSenderInfo senderObj = sender as GfxSkillSenderInfo;
if (null == senderObj)
{
return(false);
}
EntityInfo obj = senderObj.GfxObj;
if (null == obj)
{
return(false);
}
if (curSectionTime < StartTime)
{
return(true);
}
Vector3 old_pos = instance.CustomDatas.GetData <Vector3>();
if (old_pos != null)
{
obj.GetMovementStateInfo().SetPosition(old_pos);
}
return(false);
}
public override bool Execute(object sender, SkillInstance instance, long delta, long curSectionTime)
{
GfxSkillSenderInfo senderObj = sender as GfxSkillSenderInfo;
if (null == senderObj)
{
return(false);
}
GameObject obj = senderObj.GfxObj;
if (null == obj)
{
return(false);
}
if (curSectionTime < StartTime)
{
return(true);
}
List <object> args = new List <object>();
args.Add(senderObj);
for (int i = 0; i < m_Args.Count; ++i)
{
args.Add(m_Args[i]);
}
if (m_IsConcurrent)
{
GfxStorySystem.Instance.SendConcurrentMessage(m_Msg, args.ToArray());
}
else
{
GfxStorySystem.Instance.SendMessage(m_Msg, args.ToArray());
}
return(false);
}
public override bool Execute(object sender, SkillInstance instance, long delta, long curSectionTime)
{
GfxSkillSenderInfo senderObj = sender as GfxSkillSenderInfo;
if (null == senderObj) return false;
GameObject obj = senderObj.GfxObj;
if (null == obj) return false;
if (curSectionTime < StartTime) {
return true;
}
if (m_HaveIsContinue) {
if (0 == m_Type.CompareTo("shield")) {
if (EntityController.Instance.HaveShield(senderObj.ObjId))
return true;
} else {
if (EntityController.Instance.HaveState(senderObj.ObjId, m_Type))
return true;
}
} else {
if (0 == m_Type.CompareTo("shield")) {
if (!EntityController.Instance.HaveShield(senderObj.ObjId))
return true;
} else {
if (!EntityController.Instance.HaveState(senderObj.ObjId, m_Type))
return true;
}
}
instance.StopCurSection();
return false;
}
public override bool Execute(object sender, SkillInstance instance, long delta, long curSectionTime)
{
GfxSkillSenderInfo senderObj = sender as GfxSkillSenderInfo;
if (null == senderObj)
{
return(false);
}
GameObject obj = senderObj.GfxObj;
if (null == obj)
{
return(false);
}
if (curSectionTime < StartTime)
{
return(true);
}
List <object> arglist = new List <object>();
arglist.Add(senderObj);
for (int i = 0; i < m_Args.Count; ++i)
{
arglist.Add(m_Args[i]);
}
object[] args = arglist.ToArray();
Utility.EventSystem.Publish(m_Event, m_Group, args);
return(false);
}
public override bool Execute(object sender, SkillInstance instance, long delta, long curSectionTime)
{
GfxSkillSenderInfo senderObj = sender as GfxSkillSenderInfo;
if (null == senderObj)
{
return(false);
}
GameObject obj = senderObj.GfxObj;
if (null == obj)
{
return(false);
}
if (curSectionTime < StartTime)
{
return(true);
}
GameObject receiver = null;
switch (m_Type)
{
case 0:
receiver = obj;
break;
case 1:
receiver = senderObj.TargetGfxObj;
break;
case 2:
receiver = senderObj.TrackEffectObj;
break;
}
if (null == receiver)
{
return(false);
}
List <object> arglist = new List <object>();
arglist.Add(senderObj);
for (int i = 0; i < m_Args.Count; ++i)
{
arglist.Add(m_Args[i]);
}
object[] args = arglist.ToArray();
if (args.Length == 0)
{
receiver.SendMessage(m_Msg, UnityEngine.SendMessageOptions.DontRequireReceiver);
}
else if (args.Length == 1)
{
receiver.SendMessage(m_Msg, args[0], UnityEngine.SendMessageOptions.DontRequireReceiver);
}
else
{
receiver.SendMessage(m_Msg, args, UnityEngine.SendMessageOptions.DontRequireReceiver);
}
return(false);
}
public override bool Execute(object sender, SkillInstance instance, long delta, long curSectionTime)
{
GfxSkillSenderInfo senderObj = sender as GfxSkillSenderInfo;
if (null == senderObj)
{
return(false);
}
GameObject obj = senderObj.GfxObj;
if (null == obj)
{
return(false);
}
GameObject target = senderObj.TargetGfxObj;
if (null != senderObj.TrackEffectObj)
{
obj = senderObj.TrackEffectObj;
target = senderObj.GfxObj;
}
if (curSectionTime < StartTime)
{
return(true);
}
Vector3 pos = obj.transform.position;
instance.CustomDatas.AddData <Vector3>(pos);
return(false);
}
public override bool Execute(object sender, SkillInstance instance, long delta, long curSectionTime)
{
GfxSkillSenderInfo senderObj = sender as GfxSkillSenderInfo;
if (null == senderObj)
{
return(false);
}
EntityInfo obj = senderObj.GfxObj;
if (null == obj)
{
return(false);
}
if (curSectionTime < StartTime)
{
return(true);
}
instance.SetVariable("hitEffect", SkillParamUtility.RefixResourceVariable(m_HitEffect, instance, senderObj.ConfigData.resources));
instance.SetVariable("hitEffectBone", m_HitEffectBone);
instance.SetVariable("hitEffectStartTime", m_HitEffectStartTime);
instance.SetVariable("hitEffectDeleteTime", m_HitEffectDeleteTime);
instance.SetVariable("hitAnim", m_HitAnim);
instance.SetVariable("hitAnimTime", m_HitAnimTime);
instance.SetVariable("hitDelayTime", m_HitDelayTime);
return(false);
}
public override bool Execute(object sender, SkillInstance instance, long delta, long curSectionTime)
{
GfxSkillSenderInfo senderObj = sender as GfxSkillSenderInfo;
if (null == senderObj)
{
return(false);
}
Scene scene = senderObj.Scene;
EntityInfo obj = senderObj.GfxObj;
if (null == obj)
{
scene.EntityController.RemoveShield(senderObj.ActorId, senderObj.ConfigData, senderObj.Seq);
return(false);
}
if (curSectionTime >= StartTime)
{
scene.EntityController.RemoveShield(senderObj.ActorId, senderObj.ConfigData, senderObj.Seq);
return(false);
}
else
{
return(true);
}
}
public override bool Execute(object sender, SkillInstance instance, long delta, long curSectionTime)
{
GfxSkillSenderInfo senderObj = sender as GfxSkillSenderInfo;
if (null == senderObj)
{
return(false);
}
Scene scene = senderObj.Scene;
EntityInfo obj = senderObj.GfxObj;
if (null == obj)
{
return(false);
}
if (curSectionTime < StartTime)
{
return(true);
}
foreach (var pair in m_Params)
{
instance.SetVariable(pair.Key, pair.Value);
}
return(false);
}
public override bool Execute(object sender, SkillInstance instance, long delta, long curSectionTime)
{
GfxSkillSenderInfo senderObj = sender as GfxSkillSenderInfo;
if (null == senderObj)
{
return(false);
}
EntityInfo obj = senderObj.GfxObj;
if (null == obj)
{
return(false);
}
if (curSectionTime < StartTime)
{
return(true);
}
if (curSectionTime > StartTime + m_RemainTime)
{
return(false);
}
float dir = obj.GetMovementStateInfo().GetFaceDir();
dir = (dir + Geometry.DegreeToRadian(m_RotateSpeed.Y) * TriggerUtil.ConvertToSecond(delta)) % (float)(2 * Math.PI);
obj.GetMovementStateInfo().SetFaceDir(dir);
return(true);
}
public override bool Execute(object sender, SkillInstance instance, long delta, long curSectionTime)
{
GfxSkillSenderInfo senderObj = sender as GfxSkillSenderInfo;
if (null == senderObj)
{
return(false);
}
GameObject obj = senderObj.GfxObj;
if (obj == null)
{
return(false);
}
long durationTime = m_DurationTime.Get(instance);
long intervalTime = m_IntervalTime.Get(instance);
if (durationTime <= 0)
{
durationTime = senderObj.ConfigData.duration;
}
if (intervalTime <= 0)
{
intervalTime = senderObj.ConfigData.interval;
}
if (curSectionTime < StartTime)
{
return(true);
}
if (curSectionTime > StartTime + durationTime)
{
return(false);
}
if (m_LastTime + intervalTime < curSectionTime)
{
m_LastTime = curSectionTime;
int targetType = EntityController.Instance.GetTargetType(senderObj.ActorId, senderObj.ConfigData, senderObj.Seq);
int impactId = TriggerUtil.GetSkillImpactId(instance.Variables, senderObj.ConfigData);
int senderId;
int targetId;
EntityController.Instance.CalcSenderAndTarget(senderObj, out senderId, out targetId);
if (senderObj.ConfigData.aoeType != (int)SkillAoeType.Unknown)
{
float minDistSqr = float.MaxValue;
TriggerUtil.AoeQuery(senderObj, instance, senderId, targetType, m_RelativeCenter, m_RelativeToTarget, (float distSqr, int objId) => {
if (distSqr < minDistSqr)
{
minDistSqr = distSqr;
targetId = objId;
}
return(true);
});
}
Dictionary <string, object> args;
TriggerUtil.CalcImpactConfig(0, impactId, instance, senderObj.ConfigData, out args);
EntityController.Instance.SendImpact(senderObj.ConfigData, senderObj.Seq, senderObj.ActorId, senderId, targetId, impactId, IsFinal, args);
}
return(true);
}
public override bool Execute(object sender, SkillInstance instance, long delta, long curSectionTime)
{
GfxSkillSenderInfo senderObj = sender as GfxSkillSenderInfo;
if (null == senderObj)
{
return(false);
}
GameObject obj = senderObj.GfxObj;
if (null != obj)
{
if (null != senderObj.TrackEffectObj)
{
obj = senderObj.TrackEffectObj;
}
if (curSectionTime >= StartTime)
{
Animator animator = obj.GetComponentInChildren <Animator>();
if (null != animator)
{
string anim = m_AnimName.Get(instance);
if (!string.IsNullOrEmpty(anim))
{
try {
if (m_PlayMode == 0)
{
animator.Play(anim, -1, m_NormalizedAnimStartTime.Get(instance));
}
else
{
animator.CrossFade(anim, m_CrossFadeTime / 1000.0f, -1, m_NormalizedAnimStartTime.Get(instance));
}
animator.speed = m_Speed;
if (m_IsEffectSkillTime)
{
instance.TimeScale = m_Speed;
}
} catch (Exception ex) {
LogSystem.Error("[skill:{0} dsl skill id:{1}] play animation {2} throw exception:{3}.", senderObj.SkillId, instance.DslSkillId, anim, ex.Message);
}
}
else
{
LogSystem.Warn("[skill:{0} dsl skill id:{1}] animation is null.", senderObj.SkillId, instance.DslSkillId);
}
}
return(false);
}
else
{
return(true);
}
}
else
{
return(false);
}
}
public override bool Execute(object sender, SkillInstance instance, long delta, long curSectionTime)
{
GfxSkillSenderInfo senderObj = sender as GfxSkillSenderInfo;
if (null == senderObj)
{
return(false);
}
GameObject obj = senderObj.GfxObj;
if (obj == null)
{
return(false);
}
if (curSectionTime < StartTime)
{
return(true);
}
long duration = m_DurationTime.Get(instance);
long interval = m_IntervalTime.Get(instance);
if (curSectionTime > StartTime + duration)
{
return(false);
}
if (m_LastTime + interval < curSectionTime)
{
m_LastTime = curSectionTime;
int targetType = EntityController.Instance.GetTargetType(senderObj.ObjId, senderObj.ConfigData, senderObj.Seq);
int impactId = TriggerUtil.GetSkillImpactId(instance.Variables, senderObj.ConfigData);
int senderId = 0;
if (senderObj.ConfigData.type == (int)SkillOrImpactType.Skill)
{
senderId = senderObj.ObjId;
}
else
{
senderId = senderObj.TargetObjId;
}
int ct = 0;
List <int> targetIds = new List <int>();
TriggerUtil.AoeQuery(senderObj, instance, senderId, targetType, m_RelativeCenter, m_RelativeToTarget, (float distSqr, int objId) => {
Dictionary <string, object> args;
TriggerUtil.CalcImpactConfig(0, impactId, instance, senderObj.ConfigData, out args);
EntityController.Instance.SendImpact(senderObj.ConfigData, senderObj.Seq, senderObj.ObjId, senderId, objId, impactId, IsFinal, args);
targetIds.Add(objId);
++ct;
if (senderObj.ConfigData.maxAoeTargetCount <= 0 || ct < senderObj.ConfigData.maxAoeTargetCount)
{
return(true);
}
else
{
return(false);
}
});
}
return(true);
}
public override bool Execute(object sender, SkillInstance instance, long delta, long curSectionTime)
{
GfxSkillSenderInfo senderObj = sender as GfxSkillSenderInfo;
if (null == senderObj)
{
return(false);
}
GameObject obj = senderObj.GfxObj;
if (obj == null)
{
return(false);
}
GameObject targetObj = senderObj.TargetGfxObj;
if (null != senderObj.TrackEffectObj)
{
obj = senderObj.TrackEffectObj;
targetObj = senderObj.GfxObj;
}
if (curSectionTime < StartTime)
{
return(true);
}
if (m_IsForRoundMove)
{
Vector3 srcPos = obj.transform.position;
Vector3 targetPos = Vector3.zero;
if (null != targetObj)
{
targetPos = targetObj.transform.position;
}
TriggerUtil.GetSkillStartPosition(srcPos, senderObj.ConfigData, instance, senderObj.ActorId, senderObj.TargetActorId, ref targetPos);
if (targetPos.sqrMagnitude > Geometry.c_FloatPrecision)
{
float angle = Geometry.GetYRadian(new ScriptRuntime.Vector2(srcPos.x, srcPos.z), new ScriptRuntime.Vector2(targetPos.x, targetPos.z));
ScriptRuntime.Vector2 newPos = new ScriptRuntime.Vector2(targetPos.x, targetPos.z) + Geometry.GetRotate(new ScriptRuntime.Vector2(m_RelativeOffset.x, m_RelativeOffset.z), angle);
targetPos = new Vector3(newPos.X, srcPos.y + m_RelativeOffset.y, newPos.Y);
TriggerUtil.MoveObjTo(obj, targetPos);
}
}
else if (null != targetObj)
{
//Vector3 pos = targetObj.transform.TransformPoint(m_RelativeOffset);
Vector3 srcPos = obj.transform.position;
Vector3 pos = Vector3.zero;
if (null != targetObj)
{
pos = targetObj.transform.position;
}
TriggerUtil.GetSkillStartPosition(srcPos, senderObj.ConfigData, instance, senderObj.ActorId, senderObj.TargetActorId, ref pos);
pos.y = srcPos.y;
TriggerUtil.MoveObjTo(obj, pos);
}
return(false);
}
public override bool Execute(object sender, SkillInstance instance, long delta, long curSectionTime)
{
GfxSkillSenderInfo senderObj = sender as GfxSkillSenderInfo;
if (null == senderObj)
{
return(false);
}
Scene scene = senderObj.Scene;
EntityInfo obj = senderObj.GfxObj;
if (null == obj)
{
return(false);
}
if (curSectionTime < StartTime)
{
return(true);
}
if (m_HaveIsContinue)
{
if (0 == m_Type.CompareTo("shield"))
{
if (scene.EntityController.HaveShield(senderObj.ActorId))
{
return(true);
}
}
else
{
if (scene.EntityController.HaveState(senderObj.ActorId, m_Type))
{
return(true);
}
}
}
else
{
if (0 == m_Type.CompareTo("shield"))
{
if (!scene.EntityController.HaveShield(senderObj.ActorId))
{
return(true);
}
}
else
{
if (!scene.EntityController.HaveState(senderObj.ActorId, m_Type))
{
return(true);
}
}
}
instance.StopCurSection();
return(false);
}
public override bool Execute(object sender, SkillInstance instance, long delta, long curSectionTime)
{
GfxSkillSenderInfo senderObj = sender as GfxSkillSenderInfo;
if (null == senderObj)
{
return(false);
}
m_Myself = senderObj.GfxObj;
if (null == m_Myself)
{
return(false);
}
if (curSectionTime < StartTime)
{
return(true);
}
if (m_IsExecuted && curSectionTime > (StartTime + m_RemainTime))
{
return(false);
}
Vector3 pos = m_Myself.transform.position;
m_Target = senderObj.TargetGfxObj;
if (!m_IsExecuted && (null == m_Target && !string.IsNullOrEmpty(m_SelectTargetType)))
{
TargetManager mgr = instance.CustomDatas.GetData <TargetManager>();
if (null == mgr)
{
mgr = new TargetManager();
instance.CustomDatas.AddData(mgr);
}
int targetId = EntityController.Instance.SelectTargetForSkill(m_SelectTargetType, senderObj.ObjId, senderObj.ConfigData, senderObj.Seq, mgr.Targets);
if (targetId > 0)
{
mgr.Add(targetId);
m_Target = EntityController.Instance.GetGameObject(targetId);
senderObj.TargetObjId = targetId;
senderObj.TargetGfxObj = m_Target;
}
}
if (null != m_Target)
{
m_IsExecuted = true;
if (!m_IsHaveRotateSpeed || m_RotateSpeed.y == 0)
{
TriggerUtil.Lookat(m_Myself, m_Target.transform.position);
}
else
{
float maxRotateDelta = m_RotateSpeed.y * TriggerUtil.ConvertToSecond(delta);
TriggerUtil.Lookat(m_Myself, m_Target.transform.position, maxRotateDelta);
}
}
return(true);
}
public override bool Execute(object sender, SkillInstance instance, long delta, long curSectionTime)
{
GfxSkillSenderInfo senderObj = sender as GfxSkillSenderInfo;
if (null == senderObj)
{
return(false);
}
if (curSectionTime < StartTime)
{
return(true);
}
if (m_RemainTime > 0 && curSectionTime > (StartTime + m_RemainTime))
{
return(false);
}
if (senderObj.ConfigData.aoeType != (int)SkillAoeType.Unknown)
{
int targetType = EntityController.Instance.GetTargetType(senderObj.ObjId, senderObj.ConfigData, senderObj.Seq);
int senderId = 0;
if (senderObj.ConfigData.type == (int)SkillOrImpactType.Skill)
{
senderId = senderObj.ObjId;
}
else
{
senderId = senderObj.TargetObjId;
}
int ct = 0;
TriggerUtil.AoeQuery(senderObj, instance, senderId, targetType, m_RelativeCenter, m_RelativeToTarget, (float distSqr, int objId) => {
++ct;
if (senderObj.ConfigData.maxAoeTargetCount <= 0 || ct < senderObj.ConfigData.maxAoeTargetCount)
{
EntityController.Instance.KeepTarget(objId);
return(true);
}
else
{
return(false);
}
});
}
else
{
if (senderObj.ConfigData.type == (int)SkillOrImpactType.Skill)
{
EntityController.Instance.KeepTarget(senderObj.TargetObjId);
}
else
{
EntityController.Instance.KeepTarget(senderObj.ObjId);
}
}
return(true);
}
private void ShowHideForSkill(object[] args)
{
if (null != args && args.Length >= 2)
{
GfxSkillSenderInfo info = args[0] as GfxSkillSenderInfo;
string v = args[1] as string;
if (null != info && null != v && null != info.GfxObj)
{
info.GfxObj.SetActive(v != "0");
}
}
}
public override bool Execute(object sender, SkillInstance instance, long delta, long curSectionTime)
{
GfxSkillSenderInfo senderObj = sender as GfxSkillSenderInfo;
if (null == senderObj)
{
return(false);
}
GameObject obj = senderObj.GfxObj;
if (null == obj)
{
return(false);
}
if (null != senderObj.TrackEffectObj)
{
obj = senderObj.TrackEffectObj;
}
if (!m_IsResourcePreloaded)
{
PreloadResource(obj, instance);
}
if (curSectionTime < StartTime)
{
return(true);
}
if (m_IsNeedCollide)
{
}
string random_audio = GetRandomAudio();
AudioClip clip = ResourceSystem.Instance.GetSharedResource(random_audio) as AudioClip;
if (null == clip)
{
return(false);
}
if (m_AudioSource != null)
{
if (m_AudioSource.loop)
{
m_AudioSource.clip = clip;
m_AudioSource.Play();
}
else
{
m_AudioSource.PlayOneShot(clip);
}
m_AudioSource.volume = m_volume;
m_AudioSource.dopplerLevel = 0f;
}
return(false);
}
private void CameraShakeForSkill(object[] args)
{
if (null != args && args.Length >= 4)
{
GfxSkillSenderInfo info = args[0] as GfxSkillSenderInfo;
if (null != info)
{
if (PluginFramework.Instance.IsLocalSkillEffect(info))
{
m_CameraController.Shake(float.Parse(args[1] as string), float.Parse(args[2] as string), float.Parse(args[3] as string));
}
}
}
}
public override bool Execute(object sender, SkillInstance instance, long delta, long curSectionTime)
{
GfxSkillSenderInfo senderObj = sender as GfxSkillSenderInfo;
if (null == senderObj)
{
return(false);
}
Scene scene = senderObj.Scene;
EntityInfo obj = senderObj.GfxObj;
if (null == obj)
{
return(false);
}
if (curSectionTime >= StartTime)
{
int targetType = scene.EntityController.GetTargetType(senderObj.ActorId, senderObj.ConfigData, senderObj.Seq);
int impactId = TriggerUtil.GetSkillImpactId(instance.Variables, senderObj.ConfigData);
int senderId = 0;
if (senderObj.ConfigData.type == (int)SkillOrImpactType.Skill)
{
senderId = senderObj.ActorId;
}
else
{
senderId = senderObj.TargetActorId;
}
int ct = 0;
TriggerUtil.AoeQuery(senderObj, instance, senderId, targetType, m_RelativeCenter, m_RelativeToTarget, (float distSqr, int objId) => {
Dictionary <string, object> args;
TriggerUtil.CalcImpactConfig(0, impactId, instance, senderObj.ConfigData, out args);
scene.EntityController.SendImpact(senderObj.ConfigData, senderObj.Seq, senderObj.ActorId, senderId, objId, impactId, args);
++ct;
if (senderObj.ConfigData.maxAoeTargetCount <= 0 || ct < senderObj.ConfigData.maxAoeTargetCount)
{
return(true);
}
else
{
return(false);
}
});
return(false);
}
else
{
return(true);
}
}
public static void AoeQuery(GfxSkillSenderInfo senderObj, SkillInstance instance, int senderId, int targetType, Vector3 relativeCenter, bool relativeToTarget, MyFunc<float, int, bool> callback)
{
GameObject srcObj = senderObj.GfxObj;
if (null != senderObj.TrackEffectObj)
srcObj = senderObj.TrackEffectObj;
GameObject targetObj = senderObj.TargetGfxObj;
int aoeType = 0;
float range = 0;
float angleOrLength = 0;
TableConfig.Skill cfg = senderObj.ConfigData;
if (null != cfg) {
aoeType = cfg.aoeType;
range = cfg.aoeSize;
angleOrLength = cfg.aoeAngleOrLength;
}
AoeQuery(srcObj, targetObj, aoeType, range, angleOrLength, instance, senderId, targetType, relativeCenter, relativeToTarget, callback);
}
internal SkillInstance FindActiveSkillInstance(int actorId, int skillId, int seq, out GfxSkillSenderInfo sender)
{
SkillLogicInfo logicInfo = m_SkillLogicInfos.Find(info => info.ActorId == actorId && info.SkillId == skillId && info.Seq == seq);
if (null != logicInfo) {
sender = logicInfo.Sender;
return logicInfo.SkillInst;
}
sender = null;
return null;
}
internal SkillInstance FindInnerSkillInstanceForSkillViewer(int skillId, SkillInstance innerInstance, out GfxSkillSenderInfo sender)
{
SkillInstance ret = null;
SkillLogicInfo logicInfo = m_SkillLogicInfos.Find(info => info.SkillId == skillId && info.SkillInst.InnerDslSkillId == innerInstance.InnerDslSkillId && info.SkillInst.OuterDslSkillId == innerInstance.OuterDslSkillId);
if (null != logicInfo) {
sender = logicInfo.Sender;
ret = logicInfo.SkillInst;
} else {
int newSkillId = CalcUniqueInnerSkillId(skillId, innerInstance);
sender = null;
var instInfo = GetUnusedSkillInstanceInfoFromPool(newSkillId);
if (null != instInfo) {
ret = instInfo.m_SkillInstance;
}
}
return ret;
}
internal SkillInstance FindSkillInstanceForSkillViewer(int skillId, out GfxSkillSenderInfo sender)
{
SkillInstance ret = null;
SkillLogicInfo logicInfo = m_SkillLogicInfos.Find(info => info.SkillId == skillId);
if (null != logicInfo) {
sender = logicInfo.Sender;
ret = logicInfo.SkillInst;
} else {
sender = null;
var instInfo = GetUnusedSkillInstanceInfoFromPool(skillId);
if (null != instInfo) {
ret = instInfo.m_SkillInstance;
}
}
return ret;
}
public bool IsLocalSkillEffect(GfxSkillSenderInfo info)
{
if (info.ActorId == m_leaderID || info.TargetActorId == m_leaderID) {
return true;
}
EntityInfo sender = GetEntityById(info.ActorId);
if (null != sender && !sender.IsServerEntity) {
return true;
}
EntityInfo target = GetEntityById(info.TargetActorId);
if (null != target && !target.IsServerEntity) {
return true;
}
return false;
}
internal SkillInstance GetActiveSkillInfo(int index, out GfxSkillSenderInfo sender)
{
int ct = m_SkillLogicInfos.Count;
if (index >= 0 && index < ct) {
var info = m_SkillLogicInfos[index];
sender = info.Sender;
return info.SkillInst;
} else {
sender = null;
return null;
}
}
internal SkillLogicInfo(GfxSkillSenderInfo sender, SkillInstanceInfo info)
{
m_Sender = sender;
m_SkillInfo = info;
}
private void CalNewSpeedWithTarget(GfxSkillSenderInfo senderObj, SkillInstance instance)
{
GameObject obj = senderObj.GfxObj;
GameObject target = senderObj.TargetGfxObj;
if (null == obj)
return;
Vector3 srcPos = obj.transform.position;
Vector3 targetPos = Vector3.zero;
if (null != target) {
targetPos = target.transform.position;
}
if (m_IsForRoundMove) {
TriggerUtil.GetSkillStartPosition(srcPos, senderObj.ConfigData, instance, senderObj.ActorId, senderObj.TargetActorId, ref targetPos);
m_TargetPos = targetPos;
} else if (null == target) {
return;
}
float cur_distance_z = 0;
for (int i = 0; i < m_SectionListCopy.Count; i++) {
cur_distance_z += (m_SectionListCopy[i].speedVect.z * m_SectionListCopy[i].moveTime +
m_SectionListCopy[i].accelVect.z * m_SectionListCopy[i].moveTime * m_SectionListCopy[i].moveTime / 2.0f);
}
Vector3 target_motion = (targetPos - obj.transform.position);
target_motion.y = 0;
float target_distance_z = target_motion.magnitude;
float speed_ratio = 1;
if (cur_distance_z != 0) {
speed_ratio = target_distance_z / cur_distance_z;
}
for (int i = 0; i < m_SectionListCopy.Count; i++) {
m_SectionListCopy[i].speedVect.z *= speed_ratio;
m_SectionListCopy[i].accelVect.z *= speed_ratio;
}
}
internal void CalcSenderAndTarget(GfxSkillSenderInfo senderObj, out int senderId, out int targetId)
{
senderId = 0;
targetId = 0;
int targetType = GetTargetType(senderObj.ActorId, senderObj.ConfigData, senderObj.Seq);
if (senderObj.ConfigData.type == (int)SkillOrImpactType.Skill) {
senderId = senderObj.ActorId;
targetId = senderObj.TargetActorId;
if (targetType == (int)SkillTargetType.RandEnemy) {
targetId = GetRandEnemyId(GetCampId(senderId));
} else if (targetType == (int)SkillTargetType.RandFriend) {
targetId = GetRandFriendId(GetCampId(senderId));
} else if (targetType == (int)SkillTargetType.Friend) {
targetId = senderObj.ActorId;
} else if (targetType == (int)SkillTargetType.Self) {
targetId = senderObj.ActorId;
}
} else {
senderId = senderObj.TargetActorId;
targetId = senderObj.ActorId;
if (targetType == (int)SkillTargetType.RandEnemy) {
targetId = GetRandEnemyId(GetCampId(senderId));
} else if (targetType == (int)SkillTargetType.RandFriend) {
targetId = GetRandFriendId(GetCampId(senderId));
} else if (targetType == (int)SkillTargetType.Friend) {
targetId = senderObj.TargetActorId;
} else if (targetType == (int)SkillTargetType.Self) {
targetId = senderObj.TargetActorId;
}
}
}
internal GfxSkillSenderInfo BuildSkillInfo(int objId, TableConfig.Skill configData, int seq)
{
GfxSkillSenderInfo ret = null;
EntityViewModel view = GetEntityViewById(objId);
if (null != view && null != view.Actor && null != view.Entity && null != configData) {
EntityInfo entity = view.Entity;
int targetId = 0;
if (configData.type == (int)SkillOrImpactType.Skill) {
targetId = entity.GetAiStateInfo().Target;
} else {
ImpactInfo impactInfo = entity.GetSkillStateInfo().GetImpactInfoBySeq(seq);
if (null != impactInfo) {
targetId = impactInfo.ImpactSenderId;
}
}
UnityEngine.GameObject targetObj = GetGameObject(targetId);
if (null != targetObj) {
ret = new GfxSkillSenderInfo(configData, seq, objId, view.Actor, targetId, targetObj);
} else {
ret = new GfxSkillSenderInfo(configData, seq, objId, view.Actor);
}
}
return ret;
}
internal GfxSkillSenderInfo BuildSkillInfo(int objId, TableConfig.Skill configData, int seq, Scene scene)
{
GfxSkillSenderInfo ret = null;
EntityInfo entity = m_Scene.EntityManager.GetEntityInfo(objId);
if (null != entity && null != configData) {
int targetId = 0;
if (configData.type == (int)SkillOrImpactType.Skill) {
targetId = entity.GetAiStateInfo().Target;
} else {
ImpactInfo impactInfo = entity.GetSkillStateInfo().GetImpactInfoBySeq(seq);
if (null != impactInfo) {
targetId = impactInfo.ImpactSenderId;
}
}
EntityInfo targetObj = m_Scene.EntityManager.GetEntityInfo(targetId);
if (null != targetObj) {
ret = new GfxSkillSenderInfo(configData, seq, objId, entity, targetId, targetObj, scene);
} else {
ret = new GfxSkillSenderInfo(configData, seq, objId, entity, scene);
}
}
return ret;
}
private void Init(GfxSkillSenderInfo senderObj, SkillInstance instance)
{
CopySectionList();
CalNewSpeedWithTarget(senderObj, instance);
m_Now = instance.CurTime / 1000.0f;
m_SectionListCopy[0].startTime = m_Now;
m_SectionListCopy[0].lastUpdateTime = m_Now;
m_SectionListCopy[0].curSpeedVect = m_SectionListCopy[0].speedVect;
m_StartTransform = new GameObject();
if (null != senderObj.TrackEffectObj) {
m_StartTransform.transform.position = senderObj.TrackEffectObj.transform.position;
m_StartTransform.transform.rotation = senderObj.TrackEffectObj.transform.rotation;
} else {
m_StartTransform.transform.position = senderObj.GfxObj.transform.position;
m_StartTransform.transform.rotation = senderObj.GfxObj.transform.rotation;
}
m_IsInited = true;
}
