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 static void CalcImpactConfig(int emitImpact, int hitImpact, SkillInstance instance, TableConfig.Skill cfg, out Dictionary <string, object> result)
{
var variables = instance.Variables;
result = new Dictionary <string, object>(variables);
if (null != instance.EmitSkillInstances)
{
if (emitImpact <= 0)
{
emitImpact = SkillInstance.c_FirstInnerEmitSkillId;
}
TableConfig.Skill impactCfg = TableConfig.SkillProvider.Instance.GetSkill(emitImpact);
if (null != impactCfg)
{
if (impactCfg.type == (int)SkillOrImpactType.Buff)
{
emitImpact = SkillInstance.c_FirstInnerEmitSkillId;
}
}
SkillInstance val;
if (instance.EmitSkillInstances.TryGetValue(emitImpact, out val))
{
result["emitskill"] = val;
}
}
if (null != instance.HitSkillInstances)
{
if (hitImpact <= 0)
{
hitImpact = SkillInstance.c_FirstInnerHitSkillId;
}
TableConfig.Skill impactCfg = TableConfig.SkillProvider.Instance.GetSkill(hitImpact);;
if (null != impactCfg)
{
if (impactCfg.type == (int)SkillOrImpactType.Buff)
{
hitImpact = SkillInstance.c_FirstInnerHitSkillId;
}
}
SkillInstance val;
if (instance.HitSkillInstances.TryGetValue(hitImpact, out val))
{
result["hitskill"] = val;
}
}
string hitEffect = SkillParamUtility.RefixResourceVariable("hitEffect", instance, cfg.resources);
if (!string.IsNullOrEmpty(hitEffect))
{
result["hitEffect"] = hitEffect;
}
string hitEffect1 = SkillParamUtility.RefixResourceVariable("hitEffect1", instance, cfg.resources);
if (!string.IsNullOrEmpty(hitEffect1))
{
result["hitEffect1"] = hitEffect1;
}
string hitEffect2 = SkillParamUtility.RefixResourceVariable("hitEffect2", instance, cfg.resources);
if (!string.IsNullOrEmpty(hitEffect2))
{
result["hitEffect2"] = hitEffect2;
}
string hitEffect3 = SkillParamUtility.RefixResourceVariable("hitEffect3", instance, cfg.resources);
if (!string.IsNullOrEmpty(hitEffect3))
{
result["hitEffect3"] = hitEffect3;
}
string emitEffect = SkillParamUtility.RefixResourceVariable("emitEffect", instance, cfg.resources);
if (!string.IsNullOrEmpty(emitEffect))
{
result["emitEffect"] = emitEffect;
}
string emitEffect1 = SkillParamUtility.RefixResourceVariable("emitEffect1", instance, cfg.resources);
if (!string.IsNullOrEmpty(emitEffect1))
{
result["emitEffect1"] = emitEffect1;
}
string emitEffect2 = SkillParamUtility.RefixResourceVariable("emitEffect2", instance, cfg.resources);
if (!string.IsNullOrEmpty(emitEffect2))
{
result["emitEffect2"] = emitEffect2;
}
string emitEffect3 = SkillParamUtility.RefixResourceVariable("emitEffect3", instance, cfg.resources);
if (!string.IsNullOrEmpty(emitEffect3))
{
result["emitEffect3"] = emitEffect3;
}
string targetEffect = SkillParamUtility.RefixResourceVariable("targetEffect", instance, cfg.resources);
if (!string.IsNullOrEmpty(targetEffect))
{
result["targetEffect"] = targetEffect;
}
string targetEffect1 = SkillParamUtility.RefixResourceVariable("targetEffect1", instance, cfg.resources);
if (!string.IsNullOrEmpty(targetEffect1))
{
result["targetEffect1"] = targetEffect1;
}
string targetEffect2 = SkillParamUtility.RefixResourceVariable("targetEffect2", instance, cfg.resources);
if (!string.IsNullOrEmpty(targetEffect2))
{
result["targetEffect2"] = targetEffect2;
}
string targetEffect3 = SkillParamUtility.RefixResourceVariable("targetEffect3", instance, cfg.resources);
if (!string.IsNullOrEmpty(targetEffect3))
{
result["targetEffect3"] = targetEffect3;
}
string selfEffect = SkillParamUtility.RefixResourceVariable("selfEffect", instance, cfg.resources);
if (!string.IsNullOrEmpty(selfEffect))
{
result["selfEffect"] = selfEffect;
}
string selfEffect1 = SkillParamUtility.RefixResourceVariable("selfEffect1", instance, cfg.resources);
if (!string.IsNullOrEmpty(selfEffect1))
{
result["selfEffect1"] = selfEffect1;
}
string selfEffect2 = SkillParamUtility.RefixResourceVariable("selfEffect2", instance, cfg.resources);
if (!string.IsNullOrEmpty(selfEffect2))
{
result["selfEffect2"] = selfEffect2;
}
string selfEffect3 = SkillParamUtility.RefixResourceVariable("selfEffect3", instance, cfg.resources);
if (!string.IsNullOrEmpty(selfEffect3))
{
result["selfEffect3"] = selfEffect3;
}
}
private int TryGetTimeFromConfig(SkillInstance instance)
{
return SkillParamUtility.RefixNonStringVariable<int>(m_Type, instance);
}
public override bool Execute(object sender, SkillInstance instance, long delta, long curSectionTime)
{
GfxSkillSenderInfo senderObj = sender as GfxSkillSenderInfo;
if (null == senderObj)
{
return(false);
}
if (senderObj.ConfigData.type == (int)SkillOrImpactType.Skill)
{
return(false);//track只能在impact或buff里使用
}
GameObject obj = senderObj.GfxObj;
if (null != obj)
{
if (curSectionTime >= StartTime)
{
if (!m_IsStarted)
{
m_IsStarted = true;
Vector3 dest;
string trackBone = m_TrackBone.Get(instance);
m_BoneTransform = Utility.FindChildRecursive(obj.transform, trackBone);
if (null != m_BoneTransform)
{
dest = m_BoneTransform.position;
}
else
{
dest = obj.transform.position;
dest.y += 1.5f;
LogSystem.Warn("[skill:{0} dsl skill id:{1}] track bone {2} can't find.", senderObj.SkillId, instance.DslSkillId, trackBone);
}
m_StartPos = EntityController.Instance.GetImpactSenderPosition(senderObj.ObjId, senderObj.SkillId, senderObj.Seq);
dest = Utility.FrontOfTarget(m_StartPos, dest, 0.1f);
object speedObj;
if (instance.Variables.TryGetValue("emitSpeed", out speedObj))
{
m_Speed = (float)speedObj;
}
else
{
return(false);
}
float duration = m_Duration.Get(instance);
if (duration > Geometry.c_FloatPrecision)
{
float d = duration / 1000.0f;
m_Lifetime = d;
m_Speed = (dest - m_StartPos).magnitude / m_Lifetime;
}
else
{
m_Lifetime = 1.0f;
if (m_Speed > Geometry.c_FloatPrecision)
{
m_Lifetime = (dest - m_StartPos).magnitude / m_Speed;
}
}
long newSectionDuration = StartTime + (long)(m_Lifetime * 1000);
if (instance.CurSectionDuration < newSectionDuration)
{
instance.SetCurSectionDuration(newSectionDuration);
}
Quaternion dir;
object dirObj;
if (instance.Variables.TryGetValue("emitDir", out dirObj))
{
dir = (Quaternion)dirObj;
}
else
{
dir = Quaternion.identity;
}
Vector3 scale;
object scaleObj;
if (instance.Variables.TryGetValue("emitScale", out scaleObj))
{
scale = (Vector3)scaleObj;
}
else
{
scale = Vector3.one;
}
Vector3 lookDir = dest - m_StartPos;
Quaternion q = Quaternion.LookRotation(lookDir);
m_ControlPos = m_StartPos + Vector3.Scale(q * dir * Vector3.forward, scale * lookDir.magnitude * 0.5f);
string effectPath = SkillParamUtility.RefixResourceVariable("emitEffect", instance, senderObj.ConfigData.resources);
m_Effect = ResourceSystem.Instance.NewObject(effectPath, m_Lifetime) as GameObject;
if (null != m_Effect)
{
senderObj.TrackEffectObj = m_Effect;
TriggerUtil.SetObjVisible(m_Effect, true);
m_Effect.SetActive(false);
m_Effect.transform.position = m_StartPos;
m_Effect.transform.localRotation = q;
m_Effect.SetActive(true);
}
else
{
if (string.IsNullOrEmpty(effectPath))
{
LogSystem.Warn("[skill:{0} dsl skill id:{1}] track effect is empty.", senderObj.SkillId, instance.DslSkillId);
}
else
{
LogSystem.Warn("[skill:{0} dsl skill id:{1}] track effect {2} can't find.", senderObj.SkillId, instance.DslSkillId, effectPath);
}
}
}
else if (null != m_Effect)
{
if (!m_NotMove && !m_IsHit)
{
Vector3 dest;
if (null != m_BoneTransform)
{
dest = m_BoneTransform.position;
}
else
{
dest = obj.transform.position;
dest.y += 1.5f;
}
dest = Utility.FrontOfTarget(m_StartPos, dest, 0.1f);
//m_Effect.transform.position = Vector3.MoveTowards(m_Effect.transform.position, dest, m_RealSpeed * Time.deltaTime);
m_Effect.transform.position = Utility.GetBezierPoint(m_StartPos, m_ControlPos, dest, (curSectionTime - StartTime) / 1000.0f / m_Lifetime);
if ((dest - m_Effect.transform.position).sqrMagnitude <= 0.01f)
{
m_HitEffectRotation = Quaternion.LookRotation(m_StartPos - dest);
if (m_NoImpact)
{
instance.SetVariable("hitEffectRotation", m_HitEffectRotation);
}
else
{
int impactId = EntityController.Instance.GetTrackSendImpact(senderObj.ObjId, senderObj.Seq, instance.Variables);
Dictionary <string, object> args;
TriggerUtil.CalcImpactConfig(0, impactId, instance, senderObj.ConfigData, out args);
if (args.ContainsKey("hitEffectRotation"))
{
args["hitEffectRotation"] = m_HitEffectRotation;
}
else
{
args.Add("hitEffectRotation", m_HitEffectRotation);
}
EntityController.Instance.TrackSendImpact(senderObj.ObjId, senderObj.SkillId, senderObj.Seq, impactId, args);
int senderId, targetId;
EntityController.Instance.CalcSenderAndTarget(senderObj, out senderId, out targetId);
}
m_IsHit = true;
}
}
if (curSectionTime > StartTime + m_Lifetime * 1000)
{
m_Effect.SetActive(false);
ResourceSystem.Instance.RecycleObject(m_Effect);
m_Effect = null;
instance.StopCurSection();
return(false);
}
}
else
{
return(false);
}
//GameFramework.LogSystem.Debug("EmitEffectTriger:{0}", m_EffectPath);
return(true);
}
else
{
return(true);
}
}
else
{
instance.StopCurSection();
return(false);
}
}
public bool Execute(object sender, SkillInstance instance, long delta, long curSectionTime)
{
GfxSkillSenderInfo senderObj = sender as GfxSkillSenderInfo;
if (null == senderObj)
{
return(false);
}
if (senderObj.ConfigData.type == (int)SkillOrImpactType.Skill)
{
return(false);//track只能在impact或buff里使用
}
GameObject obj = senderObj.GfxObj;
if (null != obj)
{
if (curSectionTime >= m_TriggerProxy.StartTime)
{
if (!m_IsStarted)
{
m_IsStarted = true;
Vector3 dest;
string trackBone = m_TrackBone.Get(instance);
m_BoneTransform = Utility.FindChildRecursive(obj.transform, trackBone);
if (null != m_BoneTransform)
{
dest = m_BoneTransform.position;
}
else
{
dest = obj.transform.position;
dest.y += 1.5f;
LogSystem.Warn("[skill:{0} dsl skill id:{1}] trackbullet bone {2} can't find.", senderObj.SkillId, instance.DslSkillId, trackBone);
}
m_StartPos = EntityController.Instance.GetImpactSenderPosition(senderObj.ObjId, senderObj.SkillId, senderObj.Seq);
object speedObj;
if (instance.Variables.TryGetValue("emitSpeed", out speedObj))
{
m_Speed = (float)speedObj;
}
else
{
return(false);
}
long duration = m_Duration.Get(instance);
m_Lifetime = duration / 1000.0f;
if (Geometry.DistanceSquare(m_StartPos.x, m_StartPos.z, dest.x, dest.z) > 0.01f)
{
m_TargetPos = Utility.FrontOfTarget(dest, m_StartPos, m_Speed * m_Lifetime);
}
else
{
m_TargetPos = obj.transform.TransformPoint(0, 0, m_Speed * m_Lifetime);
}
long newSectionDuration = m_TriggerProxy.StartTime + (long)(m_Lifetime * 1000);
if (instance.CurSectionDuration < newSectionDuration)
{
instance.SetCurSectionDuration(newSectionDuration);
}
Quaternion dir;
object dirObj;
if (instance.Variables.TryGetValue("emitDir", out dirObj))
{
dir = (Quaternion)dirObj;
}
else
{
dir = Quaternion.identity;
}
Vector3 scale;
object scaleObj;
if (instance.Variables.TryGetValue("emitScale", out scaleObj))
{
scale = (Vector3)scaleObj;
}
else
{
scale = Vector3.one;
}
Vector3 lookDir = dest - m_StartPos;
Quaternion q = Quaternion.LookRotation(lookDir);
m_ControlPos = m_StartPos + Vector3.Scale(q * dir * Vector3.forward, scale * lookDir.magnitude * 0.5f);
string effectPath = SkillParamUtility.RefixResourceVariable("emitEffect", instance, senderObj.ConfigData.resources);
m_Effect = ResourceSystem.Instance.NewObject(effectPath, m_Lifetime) as GameObject;
if (null != m_Effect)
{
senderObj.TrackEffectObj = m_Effect;
TriggerUtil.SetObjVisible(m_Effect, true);
m_Effect.SetActive(false);
m_Effect.transform.position = m_StartPos;
m_Effect.transform.localRotation = q;
m_Effect.SetActive(true);
EffectManager em = instance.CustomDatas.GetData <EffectManager>();
if (em == null)
{
em = new EffectManager();
instance.CustomDatas.AddData <EffectManager>(em);
}
em.AddEffect(m_Effect);
em.SetParticleSpeed(instance.EffectScale);
}
else
{
if (string.IsNullOrEmpty(effectPath))
{
LogSystem.Warn("[skill:{0} dsl skill id:{1}] trackbullet effect is empty.", senderObj.SkillId, instance.DslSkillId);
}
else
{
LogSystem.Warn("[skill:{0} dsl skill id:{1}] trackbullet effect {2} can't find.", senderObj.SkillId, instance.DslSkillId, effectPath);
}
}
}
else if (null != m_Effect)
{
Vector3 dest;
if (null != m_BoneTransform)
{
dest = m_BoneTransform.position;
}
else
{
dest = obj.transform.position;
dest.y += 1.5f;
}
dest = Utility.FrontOfTarget(m_StartPos, dest, 0.1f);
//m_Effect.transform.position = Vector3.MoveTowards(m_Effect.transform.position, m_TargetPos, m_RealSpeed * Time.deltaTime);
m_Effect.transform.position = Utility.GetBezierPoint(m_StartPos, m_ControlPos, m_TargetPos, (curSectionTime - m_TriggerProxy.StartTime) / 1000.0f / m_Lifetime);
var pos = m_Effect.transform.position;
if (!m_IsHit)
{
float distSqr = float.MaxValue;
if (m_LastPos.sqrMagnitude > Geometry.c_FloatPrecision)
{
ScriptRuntime.Vector2 np;
ScriptRuntime.Vector2 targetPos = new ScriptRuntime.Vector2(dest.x, dest.z);
ScriptRuntime.Vector2 lastPos = new ScriptRuntime.Vector2(m_LastPos.x, m_LastPos.z);
distSqr = Geometry.PointToLineSegmentDistanceSquare(targetPos, lastPos, new ScriptRuntime.Vector2(pos.x, pos.z), out np);
}
else
{
distSqr = (dest - pos).sqrMagnitude;
}
m_LastPos = pos;
if (distSqr <= m_BulletRadiusSquare)
{
float curTime = Time.time;
float interval = m_DamageInterval.Get(instance) / 1000.0f;
if (m_LastTime + interval <= curTime)
{
m_LastTime = curTime;
m_HitEffectRotation = Quaternion.LookRotation(m_StartPos - dest);
int impactId = TriggerUtil.GetSkillImpactId(instance.Variables, senderObj.ConfigData);
Dictionary <string, object> args;
TriggerUtil.CalcImpactConfig(0, impactId, instance, senderObj.ConfigData, out args);
if (args.ContainsKey("hitEffectRotation"))
{
args["hitEffectRotation"] = m_HitEffectRotation;
}
else
{
args.Add("hitEffectRotation", m_HitEffectRotation);
}
EntityController.Instance.TrackSendImpact(senderObj.ObjId, senderObj.SkillId, senderObj.Seq, impactId, args);
//m_IsHit = true;
}
}
}
if (curSectionTime > m_TriggerProxy.StartTime + m_Lifetime * 1000)
{
m_Effect.SetActive(false);
ResourceSystem.Instance.RecycleObject(m_Effect);
m_Effect = null;
instance.StopCurSection();
return(false);
}
}
else
{
return(false);
}
return(true);
}
else
{
return(true);
}
}
else
{
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);
}
Scene scene = senderObj.Scene;
EntityInfo obj = senderObj.GfxObj;
if (null != obj)
{
if (curSectionTime >= StartTime)
{
int senderId;
int targetId;
scene.EntityController.CalcSenderAndTarget(senderObj, out senderId, out targetId);
string effectPath = SkillParamUtility.RefixResourceVariable(m_EffectPath, instance, senderObj.ConfigData.resources);
string emitBone = SkillParamUtility.RefixStringVariable(m_EmitBone, instance);
float emitSpeed = m_EmitSpeed;
if (!string.IsNullOrEmpty(effectPath))
{
EntityInfo target = scene.EntityController.GetGameObject(targetId);
if (null != target)
{
int emitImpact = m_EmitImpact;
if (!m_IsExternalImpact)
{
emitImpact = SkillInstance.GenInnerEmitSkillId(m_EmitImpact <= 0 ? 1 : m_EmitImpact);
}
int impactId = TriggerUtil.GetSkillImpactId(instance.Variables, senderObj.ConfigData);
Dictionary <string, object> args;
TriggerUtil.CalcImpactConfig(emitImpact, impactId, instance, senderObj.ConfigData, out args);
Dictionary <string, object> addArgs = new Dictionary <string, object>()
{
{ "emitEffect", effectPath }, { "emitSpeed", emitSpeed }, { "emitDir", m_Dir }, { "emitScale", m_Scale }
};
foreach (var pair in addArgs)
{
if (args.ContainsKey(pair.Key))
{
args[pair.Key] = pair.Value;
}
else
{
args.Add(pair.Key, pair.Value);
}
}
scene.EntityController.TrackImpact(senderObj.ConfigData, senderObj.Seq, senderObj.ActorId, senderId, targetId, emitBone, m_EmitImpact, m_Pos, args);
}
}
else
{
LogSystem.Warn("[skill:{0} dsl skill id:{1}] emit effect is empty.", 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);
}
Scene scene = senderObj.Scene;
EntityInfo obj = senderObj.GfxObj;
if (null != obj)
{
if (curSectionTime >= StartTime)
{
int targetType = scene.EntityController.GetTargetType(senderObj.ActorId, senderObj.ConfigData, senderObj.Seq);
int senderId = 0;
if (senderObj.ConfigData.type == (int)SkillOrImpactType.Skill)
{
senderId = senderObj.ActorId;
}
else
{
senderId = senderObj.TargetActorId;
}
string effectPath = SkillParamUtility.RefixResourceVariable(m_EffectPath, instance, senderObj.ConfigData.resources);
int emitImpact = m_EmitImpact;
if (!m_IsExternalImpact)
{
emitImpact = SkillInstance.GenInnerEmitSkillId(m_EmitImpact <= 0 ? 1 : m_EmitImpact);
}
int impactId = TriggerUtil.GetSkillImpactId(instance.Variables, senderObj.ConfigData);
string emitBone = SkillParamUtility.RefixStringVariable(m_EmitBone, instance);
float emitSpeed = m_EmitSpeed;
int ct = 0;
TriggerUtil.AoeQuery(senderObj, instance, senderId, targetType, m_RelativeCenter, m_RelativeToTarget, (float distSqr, int objId) => {
Dictionary <string, object> args;
TriggerUtil.CalcImpactConfig(emitImpact, impactId, instance, senderObj.ConfigData, out args);
Dictionary <string, object> addArgs = new Dictionary <string, object>()
{
{ "emitEffect", effectPath }, { "emitSpeed", emitSpeed }, { "emitDir", m_Dir }, { "emitScale", m_Scale }
};
foreach (var pair in addArgs)
{
if (args.ContainsKey(pair.Key))
{
args[pair.Key] = pair.Value;
}
else
{
args.Add(pair.Key, pair.Value);
}
}
scene.EntityController.TrackImpact(senderObj.ConfigData, senderObj.Seq, senderObj.ActorId, senderId, objId, emitBone, emitImpact, m_Pos, args);
++ct;
if (senderObj.ConfigData.maxAoeTargetCount <= 0 || ct < senderObj.ConfigData.maxAoeTargetCount)
{
return(true);
}
else
{
return(false);
}
});
//GameFramework.LogSystem.Debug("AoeEmitEffectTriger:{0}", m_EffectPath);
return(false);
}
else
{
return(true);
}
}
else
{
return(false);
}
}
