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;
}
if (m_IsForRoundMove) {
Vector3 srcPos = obj.transform.position;
Vector3 targetPos = Vector3.zero;
if (null != target) {
targetPos = target.transform.position;
}
TriggerUtil.GetSkillStartPosition(srcPos, senderObj.ConfigData, instance, senderObj.ActorId, senderObj.TargetActorId, ref targetPos);
if (targetPos.sqrMagnitude > Geometry.c_FloatPrecision) {
instance.CustomDatas.AddData<Vector3>(targetPos);
}
} else {
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;
}
GameObject obj = senderObj.GfxObj;
if (obj == null) {
return false;
}
if (null != senderObj.TrackEffectObj)
obj = senderObj.TrackEffectObj;
if (curSectionTime < StartTime) {
return true;
}
Animator animator = obj.GetComponentInChildren<Animator>();
if (animator != null) {
float passed_ms = curSectionTime - StartTime;
if (passed_ms > 0) {
float old_speed = animator.speed;
float time = animator.playbackTime;
time -= old_speed * passed_ms / 1000.0f;
time += m_Speed * passed_ms / 1000.0f;
if (time < 0) {
time = 0;
}
animator.playbackTime = time;
}
animator.speed = m_Speed;
if (m_IsEffectSkillTime) {
instance.TimeScale = m_Speed;
}
}
return false;
}
private string m_Type = "anim"; //anim/impact
#endregion Fields
#region Methods
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 (0 == m_Type.CompareTo("anim")) {
} else if (0 == m_Type.CompareTo("impact")) {
int time = scene.EntityController.GetImpactDuration(senderObj.ActorId, 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);
}
} else {
int time = TryGetTimeFromConfig(instance);
if (time > 0) {
instance.SetCurSectionDuration((long)time + m_DeltaTime);
} else {
LogSystem.Warn("adjustsectionduration variable time is 0, skill id:{0} dsl skill id:{1}", senderObj.SkillId, instance.DslSkillId);
}
}
return false;
}
public ISkillTriger CreateTriger(Dsl.ISyntaxComponent trigerConfig, SkillInstance instance)
{
ISkillTriger triger = null;
string type = trigerConfig.GetId();
ISkillTrigerFactory factory = GetFactory(type);
if (null != factory) {
try {
triger = factory.Create();
triger.Init(trigerConfig, instance);
} catch (Exception ex) {
GameFramework.LogSystem.Error("triger:{0} line:{1} failed.", trigerConfig.ToScriptString(), trigerConfig.GetLine());
throw ex;
}
} else {
#if !DEBUG
GameFramework.LogSystem.Error("CreateTriger failed, type:{0}", type);
#endif
}
if (null != triger) {
GameFramework.LogSystem.Debug("CreateTriger, type:{0} triger:{1}", type, triger.GetType().Name);
} else {
#if !DEBUG
GameFramework.LogSystem.Error("CreateTriger failed, type:{0}", type);
#endif
}
return triger;
}
static public int AddImpactForInit(IntPtr l)
{
try {
int argc = LuaDLL.lua_gettop(l);
if (argc == 2)
{
SkillSystem.SkillInstance self = (SkillSystem.SkillInstance)checkSelf(l);
SkillSystem.ISkillTriger a1;
checkType(l, 2, out a1);
self.AddImpactForInit(a1);
pushValue(l, true);
return(1);
}
else if (argc == 4)
{
SkillSystem.SkillInstance self = (SkillSystem.SkillInstance)checkSelf(l);
SkillSystem.ISkillTriger a1;
checkType(l, 2, out a1);
System.Int32 a2;
checkType(l, 3, out a2);
System.Boolean a3;
checkType(l, 4, out a3);
self.AddImpactForInit(a1, a2, a3);
pushValue(l, true);
return(1);
}
pushValue(l, false);
LuaDLL.lua_pushstring(l, "No matched override function to call");
return(2);
}
catch (Exception e) {
return(error(l, e));
}
}
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;
}
static public int Init(IntPtr l)
{
try {
int argc = LuaDLL.lua_gettop(l);
if (matchType(l, argc, 2, typeof(Dsl.FunctionData)))
{
SkillSystem.SkillInstance self = (SkillSystem.SkillInstance)checkSelf(l);
Dsl.FunctionData a1;
checkType(l, 2, out a1);
var ret = self.Init(a1);
pushValue(l, true);
pushValue(l, ret);
return(2);
}
else if (matchType(l, argc, 2, typeof(Dsl.DslInfo)))
{
SkillSystem.SkillInstance self = (SkillSystem.SkillInstance)checkSelf(l);
Dsl.DslInfo a1;
checkType(l, 2, out a1);
var ret = self.Init(a1);
pushValue(l, true);
pushValue(l, ret);
return(2);
}
pushValue(l, false);
LuaDLL.lua_pushstring(l, "No matched override function to call");
return(2);
}
catch (Exception e) {
return(error(l, e));
}
}
public static void AoeQuery(GameObject srcObj, GameObject targetObj, int aoeType, float range, float angleOrLength, SkillInstance instance, int senderId, int targetType, Vector3 relativeCenter, bool relativeToTarget, MyFunc<float, int, bool> callback)
{
float radian;
Vector3 center;
if (null != targetObj && relativeToTarget) {
Vector3 srcPos = srcObj.transform.position;
Vector3 targetPos = targetObj.transform.position;
radian = Geometry.GetYRadian(new ScriptRuntime.Vector2(srcPos.x, srcPos.z), new ScriptRuntime.Vector2(targetPos.x, targetPos.z));
ScriptRuntime.Vector2 newOffset = Geometry.GetRotate(new ScriptRuntime.Vector2(relativeCenter.x, relativeCenter.z), radian);
center = targetPos + new Vector3(newOffset.X, relativeCenter.y, newOffset.Y);
} else {
radian = Geometry.DegreeToRadian(srcObj.transform.localRotation.eulerAngles.y);
center = srcObj.transform.TransformPoint(relativeCenter);
}
if (aoeType == (int)SkillAoeType.Circle || aoeType == (int)SkillAoeType.Sector) {
angleOrLength = Geometry.DegreeToRadian(angleOrLength);
ClientModule.Instance.KdTree.Query(center.x, center.y, center.z, range, (float distSqr, KdTreeObject kdTreeObj) => {
int targetId = kdTreeObj.Object.GetId();
if (targetType == (int)SkillTargetType.Enemy && CharacterRelation.RELATION_ENEMY == EntityController.Instance.GetRelation(senderId, targetId) ||
targetType == (int)SkillTargetType.Friend && CharacterRelation.RELATION_FRIEND == EntityController.Instance.GetRelation(senderId, targetId)) {
bool isMatch = false;
if (aoeType == (int)SkillAoeType.Circle) {
isMatch = true;
} else {
ScriptRuntime.Vector2 u = Geometry.GetRotate(new ScriptRuntime.Vector2(0, 1), radian);
isMatch = Geometry.IsSectorDiskIntersect(new ScriptRuntime.Vector2(center.x, center.z), u, angleOrLength / 2, range, new ScriptRuntime.Vector2(kdTreeObj.Position.X, kdTreeObj.Position.Z), kdTreeObj.Radius);
}
if (isMatch) {
if (!callback(distSqr, kdTreeObj.Object.GetId())) {
return false;
}
}
}
return true;
});
} else {
ScriptRuntime.Vector2 angleu = Geometry.GetRotate(new ScriptRuntime.Vector2(0, angleOrLength), radian);
ScriptRuntime.Vector2 c = new ScriptRuntime.Vector2(center.x, center.z) + angleu / 2;
GameFramework.ClientModule.Instance.KdTree.Query(c.X, 0, c.Y, range + angleOrLength / 2, (float distSqr, GameFramework.KdTreeObject kdTreeObj) => {
int targetId = kdTreeObj.Object.GetId();
if (targetType == (int)SkillTargetType.Enemy && CharacterRelation.RELATION_ENEMY == EntityController.Instance.GetRelation(senderId, targetId) ||
targetType == (int)SkillTargetType.Friend && CharacterRelation.RELATION_FRIEND == EntityController.Instance.GetRelation(senderId, targetId)) {
bool isMatch = false;
if (aoeType == (int)SkillAoeType.Capsule) {
isMatch = Geometry.IsCapsuleDiskIntersect(new ScriptRuntime.Vector2(center.x, center.z), angleu, range, new ScriptRuntime.Vector2(kdTreeObj.Position.X, kdTreeObj.Position.Z), kdTreeObj.Radius);
} else {
ScriptRuntime.Vector2 half = new ScriptRuntime.Vector2(range / 2, angleOrLength / 2);
isMatch = Geometry.IsObbDiskIntersect(c, half, radian, new ScriptRuntime.Vector2(kdTreeObj.Position.X, kdTreeObj.Position.Z), kdTreeObj.Radius);
}
if (isMatch) {
if (!callback(distSqr, kdTreeObj.Object.GetId())) {
return false;
}
}
}
return true;
});
}
}
protected override void Load(Dsl.CallData callData, SkillInstance instance)
{
if (callData.GetParamNum() >= 3) {
StartTime = long.Parse(callData.GetParamId(0));
m_RemainTime = long.Parse(callData.GetParamId(1));
m_RotateSpeed = DslUtility.CalcVector3(callData.GetParam(2) as Dsl.CallData);
}
}
protected override void Load(Dsl.CallData callData, SkillInstance instance)
{
int num = callData.GetParamNum();
if (num > 0) {
StartTime = long.Parse(callData.GetParamId(0));
} else {
StartTime = 0;
}
}
protected override void Load(Dsl.CallData callData, SkillInstance instance)
{
int num = callData.GetParamNum();
if (num >= 1) {
StartTime = long.Parse(callData.GetParamId(0));
}
if (num >= 2) {
m_RemainTime = long.Parse(callData.GetParamId(1));
}
}
protected override void Load(Dsl.CallData callData, SkillInstance instance)
{
int num = callData.GetParamNum();
if (num >= 4) {
StartTime = long.Parse(callData.GetParamId(0));
m_RelativeOffset.X = float.Parse(callData.GetParamId(1));
m_RelativeOffset.Y = float.Parse(callData.GetParamId(2));
m_RelativeOffset.Z = float.Parse(callData.GetParamId(3));
}
}
protected override void Load(Dsl.CallData callData, SkillInstance instance )
{
int num = callData.GetParamNum();
if (num >= 2) {
StartTime = long.Parse(callData.GetParamId(0));
m_Speed = float.Parse(callData.GetParamId(1));
}
if (num >= 3) {
m_IsEffectSkillTime = bool.Parse(callData.GetParamId(2));
}
}
static public int StopCurSection(IntPtr l)
{
try {
SkillSystem.SkillInstance self = (SkillSystem.SkillInstance)checkSelf(l);
self.StopCurSection();
pushValue(l, true);
return(1);
}
catch (Exception e) {
return(error(l, e));
}
}
protected override void Load(Dsl.CallData callData, SkillInstance instance)
{
if (callData.GetParamNum() > 0) {
m_Type = callData.GetParamId(0);
}
if (callData.GetParamNum() > 1) {
StartTime = long.Parse(callData.GetParamId(1));
}
if (callData.GetParamNum() > 2) {
m_DeltaTime = long.Parse(callData.GetParamId(2));
}
}
static public int get_IsInterrupted(IntPtr l)
{
try {
SkillSystem.SkillInstance self = (SkillSystem.SkillInstance)checkSelf(l);
pushValue(l, true);
pushValue(l, self.IsInterrupted);
return(2);
}
catch (Exception e) {
return(error(l, e));
}
}
static public int get_DamageCount(IntPtr l)
{
try {
SkillSystem.SkillInstance self = (SkillSystem.SkillInstance)checkSelf(l);
pushValue(l, true);
pushValue(l, self.DamageCount);
return(2);
}
catch (Exception e) {
return(error(l, e));
}
}
static public int get_CustomDatas(IntPtr l)
{
try {
SkillSystem.SkillInstance self = (SkillSystem.SkillInstance)checkSelf(l);
pushValue(l, true);
pushValue(l, self.CustomDatas);
return(2);
}
catch (Exception e) {
return(error(l, e));
}
}
static public int get_OriginalDelta(IntPtr l)
{
try {
SkillSystem.SkillInstance self = (SkillSystem.SkillInstance)checkSelf(l);
pushValue(l, true);
pushValue(l, self.OriginalDelta);
return(2);
}
catch (Exception e) {
return(error(l, e));
}
}
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;
}
}
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 pos = obj.GetMovementStateInfo().GetPosition3D();
instance.CustomDatas.AddData<Vector3>(pos);
return false;
}
static public int ToScriptString(IntPtr l)
{
try {
SkillSystem.SkillInstance self = (SkillSystem.SkillInstance)checkSelf(l);
var ret = self.ToScriptString();
pushValue(l, true);
pushValue(l, ret);
return(2);
}
catch (Exception e) {
return(error(l, e));
}
}
protected override void Load(Dsl.CallData callData, SkillInstance instance)
{
int num = callData.GetParamNum();
if (num >= 4) {
StartTime = long.Parse(callData.GetParamId(0));
m_RelativeOffset.x = float.Parse(callData.GetParamId(1));
m_RelativeOffset.y = float.Parse(callData.GetParamId(2));
m_RelativeOffset.z = float.Parse(callData.GetParamId(3));
}
if (num >= 5) {
m_IsForRoundMove = callData.GetParamId(4) == "true";
}
}
static public int constructor(IntPtr l)
{
try {
SkillSystem.SkillInstance o;
o = new SkillSystem.SkillInstance();
pushValue(l, true);
pushValue(l, o);
return(2);
}
catch (Exception e) {
return(error(l, e));
}
}
static public int IsMessageDone(IntPtr l)
{
try {
SkillSystem.SkillInstance self = (SkillSystem.SkillInstance)checkSelf(l);
var ret = self.IsMessageDone();
pushValue(l, true);
pushValue(l, ret);
return(2);
}
catch (Exception e) {
return(error(l, e));
}
}
static public int CollectProperties(IntPtr l)
{
try {
SkillSystem.SkillInstance self = (SkillSystem.SkillInstance)checkSelf(l);
var ret = self.CollectProperties();
pushValue(l, true);
pushValue(l, ret);
return(2);
}
catch (Exception e) {
return(error(l, e));
}
}
static public int SendMessage(IntPtr l)
{
try {
SkillSystem.SkillInstance self = (SkillSystem.SkillInstance)checkSelf(l);
System.String a1;
checkType(l, 2, out a1);
self.SendMessage(a1);
pushValue(l, true);
return(1);
}
catch (Exception e) {
return(error(l, e));
}
}
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_IsExecuted && curSectionTime > (StartTime + m_RemainTime)) {
return false;
}
Vector3 pos = obj.GetMovementStateInfo().GetPosition3D();
EntityInfo target = senderObj.TargetGfxObj;
if (!m_IsExecuted && (null == target || !string.IsNullOrEmpty(m_SelectTargetType))) {
if (string.IsNullOrEmpty(m_SelectTargetType)) {
int targetType = scene.EntityController.GetTargetType(senderObj.ActorId, senderObj.ConfigData, senderObj.Seq);
if (targetType == (int)SkillTargetType.Friend || targetType == (int)SkillTargetType.RandFriend)
m_RealSelectTargetType = "randfriend";
else
m_RealSelectTargetType = "randenemy";
}
TargetManager mgr = instance.CustomDatas.GetData<TargetManager>();
if (null == mgr) {
mgr = new TargetManager();
instance.CustomDatas.AddData(mgr);
}
int targetId = scene.EntityController.SelectTargetForSkill(m_RealSelectTargetType, senderObj.ActorId, senderObj.ConfigData, senderObj.Seq, mgr.Targets);
if (targetId > 0) {
mgr.Add(targetId);
target = scene.EntityController.GetGameObject(targetId);
senderObj.TargetActorId = targetId;
senderObj.TargetGfxObj = target;
}
}
if (null != target) {
m_IsExecuted = true;
if (!m_IsHaveRotateSpeed || m_RotateSpeed.Y == 0) {
TriggerUtil.Lookat(scene, obj, target.GetMovementStateInfo().GetPosition3D());
} else {
float maxRotateDelta = m_RotateSpeed.Y * TriggerUtil.ConvertToSecond(delta);
TriggerUtil.Lookat(scene, obj, target.GetMovementStateInfo().GetPosition3D(), maxRotateDelta);
}
}
return true;
}
static public int OnSkillStop(IntPtr l)
{
try {
SkillSystem.SkillInstance self = (SkillSystem.SkillInstance)checkSelf(l);
System.Object a1;
checkType(l, 2, out a1);
self.OnSkillStop(a1);
pushValue(l, true);
return(1);
}
catch (Exception e) {
return(error(l, e));
}
}
static public int set_IsFinished(IntPtr l)
{
try {
SkillSystem.SkillInstance self = (SkillSystem.SkillInstance)checkSelf(l);
bool v;
checkType(l, 2, out v);
self.IsFinished = v;
pushValue(l, true);
return(1);
}
catch (Exception e) {
return(error(l, e));
}
}
static public int set_MoveScale(IntPtr l)
{
try {
SkillSystem.SkillInstance self = (SkillSystem.SkillInstance)checkSelf(l);
float v;
checkType(l, 2, out v);
self.MoveScale = v;
pushValue(l, true);
return(1);
}
catch (Exception e) {
return(error(l, e));
}
}
static public int AdjustCurSectionDuration(IntPtr l)
{
try {
SkillSystem.SkillInstance self = (SkillSystem.SkillInstance)checkSelf(l);
System.Int64 a1;
checkType(l, 2, out a1);
self.AdjustCurSectionDuration(a1);
pushValue(l, true);
return(1);
}
catch (Exception e) {
return(error(l, e));
}
}
static public int AddDamageForInit(IntPtr l)
{
try {
SkillSystem.SkillInstance self = (SkillSystem.SkillInstance)checkSelf(l);
SkillSystem.ISkillTriger a1;
checkType(l, 2, out a1);
self.AddDamageForInit(a1);
pushValue(l, true);
return(1);
}
catch (Exception e) {
return(error(l, e));
}
}
static public int set_GoToSection(IntPtr l)
{
try {
SkillSystem.SkillInstance self = (SkillSystem.SkillInstance)checkSelf(l);
int v;
checkType(l, 2, out v);
self.GoToSection = v;
pushValue(l, true);
return(1);
}
catch (Exception e) {
return(error(l, e));
}
}
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 (obj == null) {
return false;
}
if (curSectionTime < StartTime) {
return true;
}
int senderId = senderObj.ActorId;
if (senderObj.ConfigData.type != (int)SkillOrImpactType.Skill) {
senderId = senderObj.TargetActorId;
}
int impactId = senderObj.ConfigData.impacttoself;
if (senderObj.ConfigData.type != (int)SkillOrImpactType.Skill) {
if (impactId <= 0) {
int skillId = scene.EntityController.GetImpactSkillId(senderObj.ActorId, senderObj.SkillId, senderObj.Seq);
TableConfig.Skill cfg = TableConfig.SkillProvider.Instance.GetSkill(skillId);
if (null != cfg) {
impactId = cfg.impacttoself;
}
}
}
if (m_Radius <= Geometry.c_FloatPrecision) {
Dictionary<string, object> args;
TriggerUtil.CalcImpactConfig(0, impactId, instance, senderObj.ConfigData, out args);
scene.EntityController.SendImpact(senderObj.ConfigData, senderObj.Seq, senderObj.ActorId, senderId, senderId, impactId, args);
} else {
EntityInfo targetObj = senderObj.TargetGfxObj;
int ct = 0;
List<int> targetIds = new List<int>();
TriggerUtil.AoeQuery(scene, obj, targetObj, m_AoeType, m_Radius, m_AngleOrLength, instance, senderId, (int)SkillTargetType.Friend, 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);
targetIds.Add(objId);
++ct;
if (m_MaxCount <= 0 || ct < m_MaxCount) {
return true;
} else {
return false;
}
});
}
return false;
}
static public int Init(IntPtr l)
{
try {
SkillSystem.SkillInstance self = (SkillSystem.SkillInstance)checkSelf(l);
Dsl.DslInfo a1;
checkType(l, 2, out a1);
var ret = self.Init(a1);
pushValue(l, true);
pushValue(l, ret);
return(2);
}
catch (Exception e) {
return(error(l, e));
}
}
protected override void Load(Dsl.CallData callData, SkillInstance instance)
{
int num = callData.GetParamNum();
if (num >= 6) {
StartTime = long.Parse(callData.GetParamId(0));
m_RemainTime = long.Parse(callData.GetParamId(1));
m_GoPath = callData.GetParamId(2);
m_ShaderName = callData.GetParamId(3);
m_StartColor = DslUtility.CalcColor(callData.GetParam(4) as Dsl.CallData);
m_ChangeColor = DslUtility.CalcColor(callData.GetParam(5) as Dsl.CallData);
}
if (num >= 7) {
m_ChangeTime = long.Parse(callData.GetParamId(6));
}
}
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;
bool isTower = !EntityController.Instance.IsMovableEntity(obj);
if (isTower)
return false;
if (curSectionTime < StartTime) {
return true;
}
if (!m_IsCurveMoving) {
if (m_IsForRoundMove && m_TargetPos.sqrMagnitude > Geometry.c_FloatPrecision) {
obj.transform.position = m_TargetPos;
}
return false;
}
if (!m_IsInited) {
Init(senderObj, instance);
}
if (m_SectionListCopy.Count == 0) {
m_IsCurveMoving = false;
return false;
}
m_Now += TriggerUtil.ConvertToSecond((long)(instance.OriginalDelta * instance.MoveScale));
MoveSectionInfo cur_section = m_SectionListCopy[0];
if (m_Now - cur_section.startTime > cur_section.moveTime) {
float end_time = cur_section.startTime + cur_section.moveTime;
float used_time = end_time - cur_section.lastUpdateTime;
cur_section.curSpeedVect = Move(obj, cur_section.curSpeedVect, cur_section.accelVect, used_time);
m_SectionListCopy.RemoveAt(0);
if (m_SectionListCopy.Count > 0) {
cur_section = m_SectionListCopy[0];
cur_section.startTime = end_time;
cur_section.lastUpdateTime = end_time;
cur_section.curSpeedVect = cur_section.speedVect;
} else {
m_IsCurveMoving = false;
}
} else {
cur_section.curSpeedVect = Move(obj, cur_section.curSpeedVect, cur_section.accelVect, m_Now - cur_section.lastUpdateTime);
cur_section.lastUpdateTime = m_Now;
}
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;
}
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 (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;
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.AddShield(senderObj.ActorId, senderObj.ConfigData, senderObj.Seq);
return false;
} else {
return true;
}
}
protected override void Load(Dsl.CallData callData, SkillInstance instance)
{
int num = callData.GetParamNum();
if (num >= 1) {
StartTime = long.Parse(callData.GetParamId(0));
}
if (num >= 9) {
m_RelativeCenter.X = float.Parse(callData.GetParamId(1));
m_RelativeCenter.Y = float.Parse(callData.GetParamId(2));
m_RelativeCenter.Z = float.Parse(callData.GetParamId(3));
m_Radius = float.Parse(callData.GetParamId(4));
m_AngleOrLength = float.Parse(callData.GetParamId(5));
m_AoeType = int.Parse(callData.GetParamId(6));
m_MaxCount = int.Parse(callData.GetParamId(7));
m_RelativeToTarget = callData.GetParamId(8) == "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;
}
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 (null != senderObj.TrackEffectObj) {
obj = senderObj.TrackEffectObj;
}
if (curSectionTime < StartTime) {
return true;
}
if (curSectionTime > StartTime + m_RemainTime) {
return false;
}
if (m_material == null) {
Transform tf = obj.transform.Find(m_GoPath);
if (tf != null) {
SkinnedMeshRenderer smr = tf.GetComponent<SkinnedMeshRenderer>();
if (smr != null) {
int count = smr.materials.Length;
Material material = null;
for (int i = 0; i < count; ++i) {
material = smr.materials[i];
if (material != null && material.shader != null) {
if (material.shader.name.CompareTo(m_ShaderName) == 0) {
m_material = material;
break;
}
}
}
}
}
}
if (m_material != null) {
if (curSectionTime > StartTime + m_ChangeTime) {
if (!m_IsFinalColor) {
m_IsFinalColor = true;
m_material.color = m_StartColor + m_ChangeColor;
}
} else {
m_material.color = m_StartColor + m_ChangeColor * ((curSectionTime - StartTime) / (m_ChangeTime * 1.0f));
}
}
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;
}
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 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);
}
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;
bool isTower = scene.EntityController.GetEntityType(senderObj.GfxObj) == (int)EntityTypeEnum.Tower;
if (isTower)
return false;
if (curSectionTime < StartTime){
return true;
}
if (!m_IsCurveMoving){
return false;
}
if (!m_IsInited){
Init(obj, senderObj.TargetGfxObj, instance);
}
if (m_SectionListCopy.Count == 0) {
m_IsCurveMoving = false;
return false;
}
m_Now += TriggerUtil.ConvertToSecond((long)(instance.OriginalDelta * instance.MoveScale));
MoveSectionInfo cur_section = m_SectionListCopy[0];
if (m_Now - cur_section.startTime > cur_section.moveTime) {
float end_time = cur_section.startTime + cur_section.moveTime;
float used_time = end_time - cur_section.lastUpdateTime;
cur_section.curSpeedVect = Move(obj, cur_section.curSpeedVect, cur_section.accelVect, used_time);
m_SectionListCopy.RemoveAt(0);
if (m_SectionListCopy.Count > 0) {
cur_section = m_SectionListCopy[0];
cur_section.startTime = end_time;
cur_section.lastUpdateTime = end_time;
cur_section.curSpeedVect = cur_section.speedVect;
} else {
m_IsCurveMoving = false;
}
} else {
cur_section.curSpeedVect = Move(obj, cur_section.curSpeedVect, cur_section.accelVect, m_Now - cur_section.lastUpdateTime);
cur_section.lastUpdateTime = m_Now;
}
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;
Scene scene = senderObj.Scene;
EntityInfo 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]);
}
scene.StorySystem.SendMessage(m_Msg, args.ToArray());
return false;
}
static public int AddUseImpactForInit(IntPtr l)
{
try {
SkillSystem.SkillInstance self = (SkillSystem.SkillInstance)checkSelf(l);
SkillSystem.ISkillTriger a1;
checkType(l, 2, out a1);
System.Int32 a2;
checkType(l, 3, out a2);
System.Boolean a3;
checkType(l, 4, out a3);
self.AddUseImpactForInit(a1, a2, a3);
pushValue(l, true);
return(1);
}
catch (Exception e) {
return(error(l, e));
}
}
public virtual bool Execute(object sender, SkillInstance instance, long delta, long curSectionTime)
{
return(false);
}
protected virtual void Load(Dsl.CallData callData, SkillInstance instance)
{
}
protected virtual void Load(Dsl.FunctionData funcData, SkillInstance instance)
{
}
protected virtual void Load(Dsl.StatementData statementData, SkillInstance instance)
{
}
public string Get(SkillInstance instance)
{
return(SkillParamUtility.RefixStringVariable(m_KeyOrValue, instance));
}
public string Get(SkillInstance instance, Dictionary <string, string> resources)
{
return(SkillParamUtility.RefixResourceVariable(m_KeyOrValue, instance, resources));
}
