diff options
Diffstat (limited to 'Client/Assets/Scripts/XMainClient/Skill/XSkillCore.cs')
| -rw-r--r-- | Client/Assets/Scripts/XMainClient/Skill/XSkillCore.cs | 1161 |
1 files changed, 1161 insertions, 0 deletions
diff --git a/Client/Assets/Scripts/XMainClient/Skill/XSkillCore.cs b/Client/Assets/Scripts/XMainClient/Skill/XSkillCore.cs new file mode 100644 index 00000000..8afcc57f --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Skill/XSkillCore.cs @@ -0,0 +1,1161 @@ +using System;
+using System.Collections.Generic;
+using System.Reflection;
+using KKSG;
+using UnityEngine;
+using XMainClient.UI;
+using XMainClient.UI.UICommon;
+using XUtliPoolLib;
+
+namespace XMainClient
+{
+ internal sealed class XSkillCore
+ {
+ public bool IsPvPVersion
+ {
+ get
+ {
+ return this._is_pvp_version;
+ }
+ }
+
+ public string TriggerToken
+ {
+ get
+ {
+ return this._trigger_token_string;
+ }
+ set
+ {
+ this._trigger_token_string = value;
+ }
+ }
+
+ public uint ID
+ {
+ get
+ {
+ return this._id;
+ }
+ }
+
+ public uint LongID
+ {
+ get
+ {
+ return this._long_id;
+ }
+ }
+
+ public uint Level
+ {
+ get
+ {
+ return this._skill_level;
+ }
+ }
+
+ public int CarrierID
+ {
+ get
+ {
+ return this._carrier_id;
+ }
+ }
+
+ public XSkill Carrier
+ {
+ get
+ {
+ return this._carrier;
+ }
+ }
+
+ public XEntity Firer
+ {
+ get
+ {
+ return this._firer;
+ }
+ }
+
+ public XSkillData Soul
+ {
+ get
+ {
+ return this._soul;
+ }
+ }
+
+ public bool EverFired
+ {
+ get
+ {
+ return this._ever_fired;
+ }
+ }
+
+ public bool HasInitCD
+ {
+ get
+ {
+ return this._init_cd > 0f;
+ }
+ }
+
+ public bool CooledDown
+ {
+ get
+ {
+ return !this._is_init_cooling && this._current_running_time > 0;
+ }
+ }
+
+ public bool Reloading
+ {
+ get
+ {
+ return this._is_init_cooling || this._current_running_time < this._totally_running_time;
+ }
+ }
+
+ public bool ShowRunningTime
+ {
+ get
+ {
+ return this._totally_running_time > 1;
+ }
+ }
+
+ public bool IsOnSyntonic
+ {
+ get
+ {
+ return this._is_on_syntonic;
+ }
+ }
+
+ public int LeftRunningTime
+ {
+ get
+ {
+ return this._current_running_time;
+ }
+ }
+
+ public float Offset
+ {
+ get
+ {
+ return this._offset;
+ }
+ }
+
+ public int PreservedStrength
+ {
+ get
+ {
+ return (int)((double)(this._preserved_strength * ((this._soul.Logical == null) ? 0 : this._soul.Logical.PreservedStrength)) * XSingleton<XSkillEffectMgr>.singleton.GetXULIPower(this._firer));
+ }
+ }
+
+ public float CastRangeUpper
+ {
+ get
+ {
+ return this._soul.Cast_Range_Upper;
+ }
+ }
+
+ public float CastRangeLower
+ {
+ get
+ {
+ return this._soul.Cast_Range_Rect ? 0f : this._soul.Cast_Range_Lower;
+ }
+ }
+
+ public float CastScope
+ {
+ get
+ {
+ return this._soul.Cast_Range_Rect ? this._soul.Cast_Scope : (this._soul.Cast_Scope * 0.5f);
+ }
+ }
+
+ private XSkillData _soul = null;
+
+ private XSkill _carrier = null;
+
+ private XEntity _firer = null;
+
+ private bool _is_pvp_version = false;
+
+ private bool _is_init_cooling = false;
+
+ private bool _is_on_syntonic = false;
+
+ private float _static_cd = 1f;
+
+ private float _init_cd = 1f;
+
+ private uint _skill_level = 0u;
+
+ private uint _id = 0u;
+
+ private uint _long_id = 0u;
+
+ private int _carrier_id = 0;
+
+ private int _totally_running_time = 1;
+
+ private int _current_running_time = 1;
+
+ private uint _cd_token = 0u;
+
+ private uint _timer_token_skill_notify = 0u;
+
+ private bool _ever_fired = false;
+
+ private float _last_lock_and_load_time = 0f;
+
+ private float _offset = 0f;
+
+ private float _notify_at = 0f;
+
+ private float _semi_dynamic_cd_ratio = 0f;
+
+ private float _last_dynamic_cd = 0f;
+
+ private float _dynamic_cd_delta = 0f;
+
+ private float _dynamic_cd_ratio = 1f;
+
+ private int _preserved_strength = 0;
+
+ private string _trigger_token_string = null;
+
+ private List<ulong> _hurt_target;
+
+ private Rect _rect;
+
+ private static Rect s_rect;
+
+ private Vector3 _vOffset = Vector3.zero;
+
+ private XTimerMgr.ElapsedEventHandler _OnReloaded = null;
+
+ public List<XSkillCore.XSkillWarningPackage>[] WarningPosAt = null;
+
+ public List<XSkillCore.XWarningRandomPackage>[] WarningRandomAt = null;
+
+ public static int maxHurtCount = 0;
+
+ public struct XSkillWarningPackage
+ {
+ public Vector3 WarningAt;
+
+ public ulong WarningTo;
+ }
+
+ public struct XWarningRandomPackage
+ {
+ public ulong ID;
+
+ public List<uint> Pos;
+ }
+
+ public XSkillCore(XEntity firer, XSkillData data, uint longid)
+ {
+ this._firer = firer;
+ this._long_id = longid;
+ this._id = XSingleton<XCommon>.singleton.XHash(data.Name);
+ this._carrier_id = XSingleton<XSkillFactory>.singleton.GetTypeHash(data.TypeToken);
+ this._hurt_target = ListPool<ulong>.Get();
+ this.SoulRefine(data, false);
+ }
+
+ public void SoulRefine(XSkillData newsoul, bool ispvp = false)
+ {
+ this._notify_at = 0f;
+ this._soul = newsoul;
+ this._is_pvp_version = ispvp;
+ bool flag = this._soul.Warning != null && this._soul.Warning.Count > 0;
+ if (flag)
+ {
+ bool flag2 = this.WarningPosAt == null || this.WarningPosAt.Length != this._soul.Warning.Count;
+ if (flag2)
+ {
+ this.WarningPosAt = new List<XSkillCore.XSkillWarningPackage>[this._soul.Warning.Count];
+ for (int i = 0; i < this._soul.Warning.Count; i++)
+ {
+ this.WarningPosAt[i] = new List<XSkillCore.XSkillWarningPackage>();
+ }
+ }
+ }
+ this._offset = 0f;
+ bool flag3 = !XSingleton<XGame>.singleton.SyncMode && this._soul.Charge.Count > 0;
+ if (flag3)
+ {
+ bool using_Curve = this._soul.Charge[0].Using_Curve;
+ if (using_Curve)
+ {
+ IXCurve curve = XSingleton<XResourceLoaderMgr>.singleton.GetCurve(this._soul.Charge[0].Curve_Forward);
+ this._offset = Mathf.Abs(curve.GetValue(curve.length - 1) - curve.GetValue(0));
+ }
+ else
+ {
+ this._offset = Mathf.Abs(this._soul.Charge[0].Offset);
+ }
+ }
+ bool flag4 = this._OnReloaded == null;
+ if (flag4)
+ {
+ this._OnReloaded = new XTimerMgr.ElapsedEventHandler(this.OnReloaded);
+ }
+ this.InitCoreData(true);
+ }
+
+ public void Clear()
+ {
+ this._soul = null;
+ }
+
+ public void Uninit()
+ {
+ bool flag = this._hurt_target != null;
+ if (flag)
+ {
+ ListPool<ulong>.Release(this._hurt_target);
+ this._hurt_target = null;
+ }
+ this.ClearWarningPos();
+ }
+
+ public void Recycle(XEntity firer)
+ {
+ this._firer = firer;
+ this._last_lock_and_load_time = 0f;
+ this._dynamic_cd_ratio = 1f;
+ this._dynamic_cd_delta = 0f;
+ this.InitCoreData(true);
+ this._current_running_time = this._totally_running_time;
+ this._hurt_target = ListPool<ulong>.Get();
+ this.ClearWarningPos();
+ }
+
+ public bool ExternalCanCast()
+ {
+ bool flag = this._soul.Script != null && !string.IsNullOrEmpty(this._soul.Script.Start_Name);
+ bool result;
+ if (flag)
+ {
+ Type type = Type.GetType("XMainClient." + this._soul.Name);
+ MethodInfo method = type.GetMethod("ExternalCanCast");
+ result = (method == null || (bool)method.Invoke(null, null));
+ }
+ else
+ {
+ result = true;
+ }
+ return result;
+ }
+
+ public void StartCameraPostEffect()
+ {
+ XSingleton<XPostEffectMgr>.singleton.MakeEffectEnable(XPostEffect.RadialBlur, true);
+ }
+
+ public void EndCameraPostEffect()
+ {
+ XSingleton<XPostEffectMgr>.singleton.MakeEffectEnable(XPostEffect.RadialBlur, false);
+ }
+
+ public void AddHurtTarget(ulong id, int triggerTime)
+ {
+ bool flag = !this.Soul.Result[triggerTime].Loop && !this.Soul.Result[triggerTime].LongAttackEffect;
+ if (flag)
+ {
+ bool flag2 = !this.IsHurtEntity(id, triggerTime);
+ if (flag2)
+ {
+ this._hurt_target.Add((ulong)((long)triggerTime));
+ this._hurt_target.Add(id);
+ }
+ }
+ bool flag3 = this._hurt_target.Count > XSkillCore.maxHurtCount;
+ if (flag3)
+ {
+ XSkillCore.maxHurtCount = this._hurt_target.Count;
+ }
+ }
+
+ public bool IsHurtEntity(ulong id, int triggerTime)
+ {
+ int i = 0;
+ int count = this._hurt_target.Count;
+ while (i < count)
+ {
+ ulong num = this._hurt_target[i];
+ ulong num2 = this._hurt_target[i + 1];
+ bool flag = (int)num == triggerTime && id == num2;
+ if (flag)
+ {
+ return true;
+ }
+ i += 2;
+ }
+ return false;
+ }
+
+ public bool Fire(XSkill carrier)
+ {
+ bool demonstrationMode = carrier.DemonstrationMode;
+ bool result;
+ if (demonstrationMode)
+ {
+ result = true;
+ }
+ else
+ {
+ bool flag = this._soul.OnceOnly && this._ever_fired;
+ if (flag)
+ {
+ result = false;
+ }
+ else
+ {
+ bool cooledDown = this.CooledDown;
+ if (cooledDown)
+ {
+ this._carrier = carrier;
+ this.OnCdCall(this._current_running_time - 1, false);
+ result = true;
+ }
+ else
+ {
+ bool syncMode = XSingleton<XGame>.singleton.SyncMode;
+ if (syncMode)
+ {
+ this._carrier = carrier;
+ this._ever_fired = true;
+ result = true;
+ }
+ else
+ {
+ result = false;
+ }
+ }
+ }
+ }
+ return result;
+ }
+
+ public void OnCdCall(int left_running_time, bool syntonic = false)
+ {
+ this._ever_fired = true;
+ bool flag = !this.Reloading;
+ this._current_running_time = left_running_time;
+ this.CheckRunningTime();
+ bool flag2 = flag || syntonic;
+ if (flag2)
+ {
+ this._last_lock_and_load_time = Time.time;
+ float coolDown = this.GetCoolDown();
+ XSingleton<XTimerMgr>.singleton.KillTimer(this._cd_token);
+ this._cd_token = XSingleton<XTimerMgr>.singleton.SetTimer(coolDown, this._OnReloaded, null);
+ bool flag3 = this._notify_at > 0f && this._notify_at < coolDown;
+ if (flag3)
+ {
+ XSingleton<XTimerMgr>.singleton.KillTimer(this._timer_token_skill_notify);
+ this._timer_token_skill_notify = XSingleton<XTimerMgr>.singleton.SetTimer(coolDown - this._notify_at, new XTimerMgr.ElapsedEventHandler(this.OnCastNotify), null);
+ }
+ bool flag4 = !XSingleton<XGame>.singleton.SyncMode && !string.IsNullOrEmpty(this.Soul.Logical.Syntonic_CoolDown_Skill);
+ if (flag4)
+ {
+ this._is_on_syntonic = true;
+ XSkillCore skill = this._firer.SkillMgr.GetSkill(XSingleton<XCommon>.singleton.XHash(this.Soul.Logical.Syntonic_CoolDown_Skill));
+ bool flag5 = skill != null && skill != this && !skill.IsOnSyntonic;
+ if (flag5)
+ {
+ skill.OnCdCall(0, true);
+ }
+ this._is_on_syntonic = false;
+ }
+ }
+ }
+
+ public void Execute(XSkill carrier)
+ {
+ this._carrier = carrier;
+ this.ClearHurtTarget();
+ this.ClearWarningPos();
+ }
+
+ public void BuildRandomWarningPos(List<WarningItemSet> set)
+ {
+ bool flag = this._soul.Warning != null && this._soul.Warning.Count > 0 && this._soul.Warning.Count == set.Count;
+ if (flag)
+ {
+ bool flag2 = this.WarningRandomAt == null || this.WarningRandomAt.Length != this._soul.Warning.Count;
+ if (flag2)
+ {
+ this.WarningRandomAt = new List<XSkillCore.XWarningRandomPackage>[this._soul.Warning.Count];
+ for (int i = 0; i < this._soul.Warning.Count; i++)
+ {
+ this.WarningRandomAt[i] = new List<XSkillCore.XWarningRandomPackage>();
+ }
+ }
+ for (int j = 0; j < set.Count; j++)
+ {
+ this.WarningRandomAt[j].Clear();
+ for (int k = 0; k < set[j].WarningItem.Count; k++)
+ {
+ XSkillCore.XWarningRandomPackage xwarningRandomPackage = default(XSkillCore.XWarningRandomPackage);
+ xwarningRandomPackage.ID = set[j].WarningItem[k].ID;
+ xwarningRandomPackage.Pos = new List<uint>();
+ for (int l = 0; l < set[j].WarningItem[k].WarningPos.Count; l++)
+ {
+ xwarningRandomPackage.Pos.Add(set[j].WarningItem[k].WarningPos[l]);
+ }
+ this.WarningRandomAt[j].Add(xwarningRandomPackage);
+ }
+ }
+ }
+ }
+
+ public void ClearHurtTarget()
+ {
+ this._hurt_target.Clear();
+ }
+
+ public void ClearWarningPos()
+ {
+ bool flag = this.WarningPosAt == null;
+ if (!flag)
+ {
+ for (int i = 0; i < this._soul.Warning.Count; i++)
+ {
+ this.WarningPosAt[i].Clear();
+ }
+ }
+ }
+
+ public void Halt()
+ {
+ this._carrier = null;
+ }
+
+ public float GetElapsedCD()
+ {
+ return this.Reloading ? (Time.time - this._last_lock_and_load_time) : this.GetCoolDown();
+ }
+
+ public float GetCoolDown()
+ {
+ return this.CheckDynamicCD(this.CheckStaticCD());
+ }
+
+ public void AccelerateCD(float delta, bool ratio)
+ {
+ bool reloading = this.Reloading;
+ if (reloading)
+ {
+ if (ratio)
+ {
+ this._dynamic_cd_delta += (this.GetCoolDown() - this.GetElapsedCD()) * delta;
+ }
+ else
+ {
+ this._dynamic_cd_delta += delta;
+ }
+ this.GetCoolDown();
+ }
+ else
+ {
+ this._dynamic_cd_delta = 0f;
+ }
+ }
+
+ public void ResetStaticCD()
+ {
+ this._static_cd = XSingleton<XSkillEffectMgr>.singleton.GetSkillCDStaticRatio(this.ID, this._skill_level, this._firer.SkillCasterTypeID, XSingleton<XScene>.singleton.IsPVPScene) * this._soul.CoolDown;
+ bool reloading = this.Reloading;
+ if (reloading)
+ {
+ this.GetCoolDown();
+ }
+ }
+
+ public void AccelerateStaticCD(float delta)
+ {
+ bool flag = delta < 0f || delta > 1f;
+ if (!flag)
+ {
+ this._static_cd = (1f - delta) * this._static_cd;
+ bool reloading = this.Reloading;
+ if (reloading)
+ {
+ this.GetCoolDown();
+ }
+ }
+ }
+
+ private float CheckStaticCD()
+ {
+ return this._is_init_cooling ? this._init_cd : this._static_cd;
+ }
+
+ private float CheckDynamicCD(float static_cd)
+ {
+ float num = static_cd * XSingleton<XSkillEffectMgr>.singleton.CalcDynamicRatio(1f, this._semi_dynamic_cd_ratio);
+ bool reloading = this.Reloading;
+ if (reloading)
+ {
+ float num2 = XSingleton<XSkillEffectMgr>.singleton.CalcDynamicRatio(XSingleton<XSkillEffectMgr>.singleton.CanChangeCD(this.ID, this._skill_level, this._firer.SkillCasterTypeID) ? XSingleton<XSkillEffectMgr>.singleton.GetSkillCDDynamicRatio(this._firer.Attributes) : 1f, this._semi_dynamic_cd_ratio);
+ float time = Time.time;
+ bool flag = this._dynamic_cd_ratio != num2;
+ if (flag)
+ {
+ float num3 = num2 / this._dynamic_cd_ratio;
+ this._last_lock_and_load_time = time - (time - this._last_lock_and_load_time) * num3;
+ this._dynamic_cd_ratio = num2;
+ }
+ num = static_cd * this._dynamic_cd_ratio - this._dynamic_cd_delta;
+ bool flag2 = this._last_dynamic_cd != num;
+ if (flag2)
+ {
+ float num4 = num - (time - this._last_lock_and_load_time);
+ XSingleton<XTimerMgr>.singleton.KillTimer(this._cd_token);
+ bool flag3 = num4 > 0f;
+ if (flag3)
+ {
+ this._cd_token = XSingleton<XTimerMgr>.singleton.SetTimer(num4, this._OnReloaded, null);
+ }
+ else
+ {
+ this.CoolDown();
+ }
+ }
+ }
+ this._last_dynamic_cd = num;
+ return num;
+ }
+
+ public float GetTimeScale()
+ {
+ return (float)XSingleton<XSkillEffectMgr>.singleton.GetAttackSpeedRatio(this._firer.Attributes);
+ }
+
+ public float GetRange(int id)
+ {
+ return this._soul.Result[id].Range;
+ }
+
+ public float GetRangeLow(int id)
+ {
+ return this._soul.Result[id].Low_Range;
+ }
+
+ public float GetScope(int id)
+ {
+ return this._soul.Result[id].Sector_Type ? (this._soul.Result[id].Scope * 0.5f) : this._soul.Result[id].Scope;
+ }
+
+ public void CoolDown()
+ {
+ XSingleton<XTimerMgr>.singleton.KillTimer(this._cd_token);
+ this._current_running_time = this._totally_running_time;
+ this.OnReloaded(null);
+ }
+
+ private void OnReloaded(object o)
+ {
+ bool is_init_cooling = this._is_init_cooling;
+ if (is_init_cooling)
+ {
+ this._current_running_time = this._totally_running_time;
+ }
+ this._is_init_cooling = false;
+ this._current_running_time++;
+ this.CheckRunningTime();
+ bool reloading = this.Reloading;
+ if (reloading)
+ {
+ this._last_lock_and_load_time = Time.time;
+ float coolDown = this.GetCoolDown();
+ XSingleton<XTimerMgr>.singleton.KillTimer(this._cd_token);
+ bool flag = coolDown > 0f;
+ if (flag)
+ {
+ this._cd_token = XSingleton<XTimerMgr>.singleton.SetTimer(coolDown, this._OnReloaded, null);
+ }
+ }
+ else
+ {
+ XSingleton<XTimerMgr>.singleton.KillTimer(this._timer_token_skill_notify);
+ this._dynamic_cd_delta = 0f;
+ this._dynamic_cd_ratio = 1f;
+ }
+ }
+
+ private void OnCastNotify(object o)
+ {
+ SkillList.RowData skillConfig = XSingleton<XSkillEffectMgr>.singleton.GetSkillConfig(this.ID, this._skill_level, this._firer.SkillCasterTypeID);
+ bool flag = skillConfig != null;
+ if (flag)
+ {
+ DlgBase<BattleMain, BattleMainBehaviour>.singleton.ShowSkillRemainingCD(skillConfig.ScriptName, this._notify_at);
+ }
+ }
+
+ public void InitCoreData(bool ctor = false)
+ {
+ XAttributes attributes = this._firer.Attributes;
+ bool flag = attributes == null;
+ if (!flag)
+ {
+ this._skill_level = attributes.SkillLevelInfo.GetSkillLevel(this.ID);
+ this._static_cd = XSingleton<XSkillEffectMgr>.singleton.GetSkillCDStaticRatio(this.ID, this._skill_level, this._firer.SkillCasterTypeID, XSingleton<XScene>.singleton.IsPVPScene) * this._soul.CoolDown;
+ this._init_cd = XSingleton<XSkillEffectMgr>.singleton.GetSkillInitCDRatio(this.ID, this._skill_level, this._firer.SkillCasterTypeID, XSingleton<XScene>.singleton.IsPVPScene, attributes) * this._soul.CoolDown;
+ this._semi_dynamic_cd_ratio = XSingleton<XSkillEffectMgr>.singleton.GetSkillCDSemiDynamicRatio(attributes, this.ID);
+ this._preserved_strength = XSingleton<XSkillEffectMgr>.singleton.GetStrengthValue(this.ID, this._skill_level, this._firer.SkillCasterTypeID);
+ this._notify_at = XSingleton<XSkillEffectMgr>.singleton.GetRemainingCDNotify(this.ID, this._skill_level, this._firer.SkillCasterTypeID);
+ this._totally_running_time = XSingleton<XSkillEffectMgr>.singleton.GetUsageCount(this.ID, this._skill_level, this._firer.SkillCasterTypeID);
+ bool flag2 = this._totally_running_time == 0;
+ if (flag2)
+ {
+ this._totally_running_time = 1;
+ }
+ if (ctor)
+ {
+ this._current_running_time = this._totally_running_time;
+ }
+ if (ctor)
+ {
+ this._ever_fired = false;
+ }
+ bool reloading = this.Reloading;
+ if (reloading)
+ {
+ this.GetCoolDown();
+ }
+ }
+ }
+
+ private void CheckRunningTime()
+ {
+ bool flag = this._current_running_time < 0;
+ if (flag)
+ {
+ this._current_running_time = 0;
+ }
+ else
+ {
+ bool flag2 = this._current_running_time > this._totally_running_time;
+ if (flag2)
+ {
+ this._current_running_time = this._totally_running_time;
+ }
+ }
+ }
+
+ public void MakeCoolDownAtLaunch()
+ {
+ bool hasInitCD = this.HasInitCD;
+ if (hasInitCD)
+ {
+ this._current_running_time = 0;
+ this._is_init_cooling = true;
+ this._last_lock_and_load_time = Time.time;
+ XSingleton<XTimerMgr>.singleton.KillTimer(this._cd_token);
+ XSingleton<XTimerMgr>.singleton.KillTimer(this._timer_token_skill_notify);
+ this._cd_token = XSingleton<XTimerMgr>.singleton.SetTimer(this._init_cd, this._OnReloaded, null);
+ bool flag = this._notify_at > 0f && this._notify_at < this._init_cd;
+ if (flag)
+ {
+ this._timer_token_skill_notify = XSingleton<XTimerMgr>.singleton.SetTimer(this._init_cd - this._notify_at, new XTimerMgr.ElapsedEventHandler(this.OnCastNotify), null);
+ }
+ }
+ }
+
+ public bool CanCast(long token)
+ {
+ bool flag = token > 0L && token == this._firer.Machine.ActionToken;
+ bool result;
+ if (flag)
+ {
+ result = true;
+ }
+ else
+ {
+ XStateDefine xstateDefine = this._firer.Machine.State.IsFinished ? this._firer.Machine.Default : this._firer.Machine.Current;
+ result = (xstateDefine == XStateDefine.XState_Idle || xstateDefine == XStateDefine.XState_Move || xstateDefine == XStateDefine.XState_Charge);
+ }
+ return result;
+ }
+
+ public bool CanAct(XStateDefine state)
+ {
+ bool flag = this._carrier == null;
+ bool result;
+ if (flag)
+ {
+ bool flag2 = this._soul != null;
+ if (flag2)
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog(this._firer.ToString(), " SkillCore error: without carrier for core name ", this._soul.Name, null, null, null);
+ }
+ result = true;
+ }
+ else
+ {
+ float timeElapsed = this._carrier.TimeElapsed;
+ Vector3 position = this._firer.EngineObject.Position;
+ bool flag3 = true;
+ if (state != XStateDefine.XState_Idle)
+ {
+ if (state == XStateDefine.XState_Move)
+ {
+ bool flag4 = XSingleton<XCommon>.singleton.IsLess(timeElapsed, this._soul.Logical.Not_Move_End) && XSingleton<XCommon>.singleton.IsEqualGreater(timeElapsed, this._soul.Logical.Not_Move_At);
+ if (flag4)
+ {
+ flag3 = false;
+ bool multipleAttackSupported = this._soul.MultipleAttackSupported;
+ if (multipleAttackSupported)
+ {
+ this._firer.Skill.TagTrigger();
+ bool flag5 = this._firer.IsPlayer && XSingleton<XVirtualTab>.singleton.Feeding;
+ if (flag5)
+ {
+ this._carrier.SkillTowardsTo = XSingleton<XVirtualTab>.singleton.Direction;
+ }
+ }
+ else
+ {
+ this._carrier.Firer.Net.ReportRotateAction((this._firer.IsPlayer && XSingleton<XVirtualTab>.singleton.Feeding) ? XSingleton<XVirtualTab>.singleton.Direction : this._firer.Rotate.GetMeaningfulFaceVector3(), (this._soul.Logical.Rotate_Speed > 0f) ? this._soul.Logical.Rotate_Speed : this._firer.Attributes.RotateSpeed, 0L);
+ }
+ }
+ }
+ }
+ else
+ {
+ flag3 = false;
+ }
+ bool flag6 = flag3;
+ if (flag6)
+ {
+ this._firer.Skill.EndSkill(false, true);
+ }
+ result = flag3;
+ }
+ return result;
+ }
+
+ public bool CanRotate()
+ {
+ return this._carrier == null || (XSingleton<XCommon>.singleton.IsLess(this._carrier.TimeElapsed, this._soul.Logical.Rotate_End) && XSingleton<XCommon>.singleton.IsEqualGreater(this._carrier.TimeElapsed, this._soul.Logical.Rotate_At));
+ }
+
+ public bool CanMove()
+ {
+ return this._carrier == null || XSingleton<XCommon>.singleton.IsEqualGreater(this._carrier.TimeElapsed, this._soul.Logical.Not_Move_End) || XSingleton<XCommon>.singleton.IsLess(this._carrier.TimeElapsed, this._soul.Logical.Not_Move_At);
+ }
+
+ private static Vector3 ResultPos(Vector3 result_pos, Vector3 logical, float radius)
+ {
+ Vector3 vector = logical - result_pos;
+ vector.y = 0f;
+ float num = vector.magnitude;
+ vector.Normalize();
+ num = ((num > radius) ? (num - radius) : 0f);
+ return result_pos + vector * num;
+ }
+
+ private bool InnerIsInAttckField(int triggerTime, Vector3 pos, Vector3 forward, Vector3 targetPos, int shift)
+ {
+ Vector3 vector = targetPos - pos;
+ vector.y = 0f;
+ float magnitude = vector.magnitude;
+ float range = this.GetRange(triggerTime);
+ float scope = this.GetScope(triggerTime);
+ bool sector_Type = this._soul.Result[triggerTime].Sector_Type;
+ bool result;
+ if (sector_Type)
+ {
+ float num = (magnitude == 0f) ? 0f : Vector3.Angle(forward, vector);
+ result = (magnitude < range && magnitude >= this.GetRangeLow(triggerTime) && num <= scope);
+ }
+ else
+ {
+ Quaternion rotation = XSingleton<XCommon>.singleton.VectorToQuaternion(XSingleton<XCommon>.singleton.HorizontalRotateVetor3(forward, (float)this._soul.Result[triggerTime].None_Sector_Angle_Shift, true));
+ bool flag = magnitude > 0f;
+ if (flag)
+ {
+ vector.Normalize();
+ }
+ float num2 = scope / 2f;
+ float num3 = range / 2f;
+ this._rect.xMin = -num2;
+ this._rect.xMax = num2;
+ this._rect.yMin = (this._soul.Result[triggerTime].Rect_HalfEffect ? 0f : (-num3));
+ this._rect.yMax = num3;
+ result = XSingleton<XCommon>.singleton.IsInRect(magnitude * vector, this._rect, Vector3.zero, rotation);
+ }
+ return result;
+ }
+
+ public bool IsInAttckField(int triggerTime, Vector3 pos, Vector3 forward, XEntity target)
+ {
+ bool flag = !XEntity.ValideEntity(target);
+ bool result;
+ if (flag)
+ {
+ result = false;
+ }
+ else
+ {
+ XEntity xentity = target.IsTransform ? target.Transformer : target;
+ this._vOffset.Set(this._soul.Result[triggerTime].Offset_X, 0f, this._soul.Result[triggerTime].Offset_Z);
+ pos += this._firer.EngineObject.Rotation * this._vOffset;
+ bool huge = xentity.Present.PresentLib.Huge;
+ if (huge)
+ {
+ SeqListRef<float> hugeMonsterColliders = xentity.Present.PresentLib.HugeMonsterColliders;
+ for (int i = 0; i < hugeMonsterColliders.Count; i++)
+ {
+ float radius = hugeMonsterColliders[i, 2] * xentity.Scale;
+ bool flag2 = this.InnerIsInAttckField(triggerTime, pos, forward, XSkillCore.ResultPos(pos, xentity.HugeMonsterColliderCenter(i), radius), this._soul.Result[triggerTime].None_Sector_Angle_Shift);
+ if (flag2)
+ {
+ return true;
+ }
+ }
+ result = false;
+ }
+ else
+ {
+ result = this.InnerIsInAttckField(triggerTime, pos, forward, XSkillCore.ResultPos(pos, xentity.RadiusCenter, xentity.Radius), this._soul.Result[triggerTime].None_Sector_Angle_Shift);
+ }
+ }
+ return result;
+ }
+
+ public bool IsInAttckField(Vector3 pos, Vector3 forward, XEntity target)
+ {
+ return XEntity.ValideEntity(target) && this.GetAttckWeights(pos, forward, target) > float.MinValue;
+ }
+
+ public static XEntity FindTargetAt(Vector3 pos, Vector3 forward, float range, float lower, float scope, XEntity firer, bool sector = true)
+ {
+ XEntity result = null;
+ float num = float.MinValue;
+ List<XEntity> opponent = XSingleton<XEntityMgr>.singleton.GetOpponent(firer);
+ for (int i = 0; i < opponent.Count; i++)
+ {
+ bool flag = !XEntity.ValideEntity(opponent[i]) || opponent[i].Present.IsShowUp;
+ if (!flag)
+ {
+ float attckWeights = XSkillCore.GetAttckWeights(pos, forward, opponent[i], range, lower, scope, 0, sector);
+ bool flag2 = attckWeights > num;
+ if (flag2)
+ {
+ num = attckWeights;
+ result = opponent[i];
+ }
+ }
+ }
+ return result;
+ }
+
+ public XEntity FindTargetAt(Vector3 pos, Vector3 forward)
+ {
+ pos.x += this._soul.Cast_Offset_X;
+ pos.z += this._soul.Cast_Offset_Z;
+ return XSkillCore.FindTargetAt(pos, forward, this.CastRangeUpper, this.CastRangeLower, (float)((int)this.CastScope), this._firer, !this._soul.Cast_Range_Rect);
+ }
+
+ public bool CanReplacedBy(XSkillCore skill)
+ {
+ bool flag = (this._soul.Logical.CanReplacedby & 1 << skill.Soul.TypeToken) != 0;
+ bool flag2 = !flag;
+ if (flag2)
+ {
+ flag = XSingleton<XCommon>.singleton.IsGreater(this._carrier.TimeElapsed, this._soul.Logical.CanCancelAt);
+ bool flag3 = !flag && this._soul.TypeToken == 0;
+ if (flag3)
+ {
+ bool flag4 = this._soul.Ja != null && this._soul.Ja.Count > 0;
+ if (flag4)
+ {
+ XJAComboSkill xjacomboSkill = this._carrier as XJAComboSkill;
+ bool flag5 = xjacomboSkill != null && xjacomboSkill.DuringJA;
+ if (flag5)
+ {
+ uint num = XSingleton<XCommon>.singleton.XHash(this._soul.Ja[0].Name);
+ flag = (skill.ID == num);
+ bool flag6 = !flag;
+ if (flag6)
+ {
+ XSkillCore skill2 = this._firer.SkillMgr.GetSkill(XSingleton<XCommon>.singleton.XHash(this._soul.Ja[0].Name));
+ bool flag7 = skill2 != null && skill2.Soul.Logical.Association;
+ if (flag7)
+ {
+ num = XSingleton<XCommon>.singleton.XHash(skill2.Soul.Logical.Association_Skill);
+ flag = (skill.ID == num);
+ }
+ }
+ }
+ }
+ }
+ }
+ return flag;
+ }
+
+ private static float GetAttckWeights(Vector3 pos, Vector3 forward, XEntity target, float upper, float lower, float scope, int scopeshift, bool sector)
+ {
+ forward = XSingleton<XCommon>.singleton.HorizontalRotateVetor3(forward, (float)scopeshift, true);
+ XEntity xentity = target.IsTransform ? target.Transformer : target;
+ bool huge = xentity.Present.PresentLib.Huge;
+ float result;
+ if (huge)
+ {
+ float num = float.MinValue;
+ SeqListRef<float> hugeMonsterColliders = xentity.Present.PresentLib.HugeMonsterColliders;
+ for (int i = 0; i < hugeMonsterColliders.Count; i++)
+ {
+ float radius = hugeMonsterColliders[i, 2] * xentity.Scale;
+ float num2 = XSkillCore.InnerGetAttckWeights(pos, forward, target, upper, lower, scope, XSkillCore.ResultPos(pos, xentity.HugeMonsterColliderCenter(i), radius), sector);
+ bool flag = num2 > num;
+ if (flag)
+ {
+ num = num2;
+ }
+ }
+ result = num;
+ }
+ else
+ {
+ result = XSkillCore.InnerGetAttckWeights(pos, forward, target, upper, lower, scope, XSkillCore.ResultPos(pos, xentity.RadiusCenter, xentity.Radius), sector);
+ }
+ return result;
+ }
+
+ private static float InnerGetAttckWeights(Vector3 pos, Vector3 forward, XEntity target, float upper, float lower, float scope, Vector3 logical, bool sector)
+ {
+ float num = float.MinValue;
+ Vector3 vector = logical - pos;
+ vector.y = 0f;
+ float magnitude = vector.magnitude;
+ vector.Normalize();
+ float num2 = (magnitude == 0f) ? 0f : Vector3.Angle(forward, vector);
+ bool flag;
+ if (sector)
+ {
+ flag = (XSingleton<XCommon>.singleton.IsLess(magnitude, upper) && XSingleton<XCommon>.singleton.IsEqualGreater(magnitude, lower) && num2 <= scope);
+ }
+ else
+ {
+ Quaternion rotation = XSingleton<XCommon>.singleton.VectorToQuaternion(forward);
+ bool flag2 = magnitude > 0f;
+ if (flag2)
+ {
+ vector.Normalize();
+ }
+ float num3 = scope / 2f;
+ float num4 = upper / 2f;
+ XSkillCore.s_rect.xMin = -num3;
+ XSkillCore.s_rect.xMax = num3;
+ XSkillCore.s_rect.yMin = -num4;
+ XSkillCore.s_rect.yMax = num4;
+ flag = XSingleton<XCommon>.singleton.IsInRect(magnitude * vector, XSkillCore.s_rect, Vector3.zero, rotation);
+ }
+ bool flag3 = flag && target.CanSelected;
+ if (flag3)
+ {
+ num = 0f;
+ float num5 = magnitude - lower;
+ float num6 = upper - lower;
+ float num7 = num6 / ((XSingleton<XOperationData>.singleton.WithinRange == 0f) ? 1f : XSingleton<XOperationData>.singleton.WithinRange);
+ int num8 = XSingleton<XCommon>.singleton.IsInteger(num7) ? Mathf.FloorToInt(num7 + 0.05f) : Mathf.CeilToInt(num7);
+ float num9 = (float)XSingleton<XOperationData>.singleton.RangeWeight / (float)num8;
+ num7 = (float)num8 * (1f - num5 / num6);
+ int num10 = XSingleton<XCommon>.singleton.IsInteger(num7) ? Mathf.FloorToInt(num7 + 0.05f) : Mathf.CeilToInt(num7);
+ num += (float)num10 * num9;
+ num += (1f - num2 / scope) * num9;
+ bool flag4 = !target.IsRole && target.Buffs != null && target.Buffs.IsBuffStateOn(XBuffType.XBuffType_Immortal);
+ if (flag4)
+ {
+ num += (float)XSingleton<XOperationData>.singleton.ImmortalWeight;
+ }
+ bool isBoss = target.IsBoss;
+ if (isBoss)
+ {
+ num += (float)XSingleton<XOperationData>.singleton.BossWeight;
+ }
+ else
+ {
+ bool isElite = target.IsElite;
+ if (isElite)
+ {
+ num += (float)XSingleton<XOperationData>.singleton.EliteWeight;
+ }
+ else
+ {
+ bool isPuppet = target.IsPuppet;
+ if (isPuppet)
+ {
+ num += (float)XSingleton<XOperationData>.singleton.PupetWeight;
+ }
+ else
+ {
+ bool isRole = target.IsRole;
+ if (isRole)
+ {
+ num += (float)XSingleton<XOperationData>.singleton.RoleWeight;
+ }
+ else
+ {
+ num += (float)XSingleton<XOperationData>.singleton.EnemyWeight;
+ }
+ }
+ }
+ }
+ }
+ return num;
+ }
+
+ private float GetAttckWeights(Vector3 pos, Vector3 forward, XEntity target)
+ {
+ pos.x += this._soul.Cast_Offset_X;
+ pos.z += this._soul.Cast_Offset_Z;
+ return XSkillCore.GetAttckWeights(pos, forward, target, this.CastRangeUpper, this.CastRangeLower, (float)((int)this.CastScope), (int)this._soul.Cast_Scope_Shift, !this._soul.Cast_Range_Rect);
+ }
+
+ public float GetMultipleDirectionFactor()
+ {
+ bool flag = !this._carrier.MainCore.Soul.MultipleAttackSupported;
+ float result;
+ if (flag)
+ {
+ result = 1f;
+ }
+ else
+ {
+ XEntity target = this._carrier.Target;
+ Vector3 vector = (target != null) ? XSingleton<XCommon>.singleton.Horizontal(target.EngineObject.Position - this._firer.EngineObject.Position) : this._firer.EngineObject.Forward;
+ Vector3 skillTowardsTo = this._carrier.SkillTowardsTo;
+ vector.y = 0f;
+ bool flag2 = vector.sqrMagnitude == 0f;
+ if (flag2)
+ {
+ vector = Vector3.forward;
+ }
+ float num = Vector3.Angle(vector, skillTowardsTo);
+ num = (XSingleton<XCommon>.singleton.Clockwise(vector, skillTowardsTo) ? num : (360f - num));
+ result = num / 360f;
+ }
+ return result;
+ }
+ }
+}
|