From 6eb915c129fc90c6f4c82ae097dd6ffad5239efc Mon Sep 17 00:00:00 2001 From: chai Date: Mon, 25 Jan 2021 14:28:30 +0800 Subject: +scripts --- Client/Assets/Scripts/XMainClient/Skill/XSkill.cs | 1028 ++++++++++++++++ .../Scripts/XMainClient/Skill/XSkill.cs.meta | 12 + .../Scripts/XMainClient/Skill/XSkillComponent.cs | 1070 ++++++++++++++++ .../XMainClient/Skill/XSkillComponent.cs.meta | 12 + .../Assets/Scripts/XMainClient/Skill/XSkillCore.cs | 1161 ++++++++++++++++++ .../Scripts/XMainClient/Skill/XSkillCore.cs.meta | 12 + .../Scripts/XMainClient/Skill/XSkillEffectMgr.cs | 937 ++++++++++++++ .../XMainClient/Skill/XSkillEffectMgr.cs.meta | 12 + .../XMainClient/Skill/XSkillExternalArgs.cs | 23 + .../XMainClient/Skill/XSkillExternalArgs.cs.meta | 12 + .../XMainClient/Skill/XSkillExternalBuffArgs.cs | 25 + .../Skill/XSkillExternalBuffArgs.cs.meta | 12 + .../Scripts/XMainClient/Skill/XSkillFactory.cs | 294 +++++ .../XMainClient/Skill/XSkillFactory.cs.meta | 12 + .../Scripts/XMainClient/Skill/XSkillFlags.cs | 45 + .../Scripts/XMainClient/Skill/XSkillFlags.cs.meta | 12 + .../XMainClient/Skill/XSkillJAPassedEventArgs.cs | 21 + .../Skill/XSkillJAPassedEventArgs.cs.meta | 12 + .../XMainClient/Skill/XSkillLevelInfoMgr.cs | 284 +++++ .../XMainClient/Skill/XSkillLevelInfoMgr.cs.meta | 12 + .../Assets/Scripts/XMainClient/Skill/XSkillMgr.cs | 598 +++++++++ .../Scripts/XMainClient/Skill/XSkillMgr.cs.meta | 12 + .../Scripts/XMainClient/Skill/XSkillPreViewMgr.cs | 100 ++ .../XMainClient/Skill/XSkillPreViewMgr.cs.meta | 12 + .../XMainClient/Skill/XSkillQTEEventArgs.cs | 24 + .../XMainClient/Skill/XSkillQTEEventArgs.cs.meta | 12 + .../XMainClient/Skill/XSkillTreeBehaviour.cs | 161 +++ .../XMainClient/Skill/XSkillTreeBehaviour.cs.meta | 12 + .../XMainClient/Skill/XSkillTreeDocument.cs | 1295 ++++++++++++++++++++ .../XMainClient/Skill/XSkillTreeDocument.cs.meta | 12 + .../Scripts/XMainClient/Skill/XSkillTreeView.cs | 1063 ++++++++++++++++ .../XMainClient/Skill/XSkillTreeView.cs.meta | 12 + 32 files changed, 8321 insertions(+) create mode 100644 Client/Assets/Scripts/XMainClient/Skill/XSkill.cs create mode 100644 Client/Assets/Scripts/XMainClient/Skill/XSkill.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/Skill/XSkillComponent.cs create mode 100644 Client/Assets/Scripts/XMainClient/Skill/XSkillComponent.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/Skill/XSkillCore.cs create mode 100644 Client/Assets/Scripts/XMainClient/Skill/XSkillCore.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/Skill/XSkillEffectMgr.cs create mode 100644 Client/Assets/Scripts/XMainClient/Skill/XSkillEffectMgr.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/Skill/XSkillExternalArgs.cs create mode 100644 Client/Assets/Scripts/XMainClient/Skill/XSkillExternalArgs.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/Skill/XSkillExternalBuffArgs.cs create mode 100644 Client/Assets/Scripts/XMainClient/Skill/XSkillExternalBuffArgs.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/Skill/XSkillFactory.cs create mode 100644 Client/Assets/Scripts/XMainClient/Skill/XSkillFactory.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/Skill/XSkillFlags.cs create mode 100644 Client/Assets/Scripts/XMainClient/Skill/XSkillFlags.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/Skill/XSkillJAPassedEventArgs.cs create mode 100644 Client/Assets/Scripts/XMainClient/Skill/XSkillJAPassedEventArgs.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/Skill/XSkillLevelInfoMgr.cs create mode 100644 Client/Assets/Scripts/XMainClient/Skill/XSkillLevelInfoMgr.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/Skill/XSkillMgr.cs create mode 100644 Client/Assets/Scripts/XMainClient/Skill/XSkillMgr.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/Skill/XSkillPreViewMgr.cs create mode 100644 Client/Assets/Scripts/XMainClient/Skill/XSkillPreViewMgr.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/Skill/XSkillQTEEventArgs.cs create mode 100644 Client/Assets/Scripts/XMainClient/Skill/XSkillQTEEventArgs.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/Skill/XSkillTreeBehaviour.cs create mode 100644 Client/Assets/Scripts/XMainClient/Skill/XSkillTreeBehaviour.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/Skill/XSkillTreeDocument.cs create mode 100644 Client/Assets/Scripts/XMainClient/Skill/XSkillTreeDocument.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/Skill/XSkillTreeView.cs create mode 100644 Client/Assets/Scripts/XMainClient/Skill/XSkillTreeView.cs.meta (limited to 'Client/Assets/Scripts/XMainClient/Skill') diff --git a/Client/Assets/Scripts/XMainClient/Skill/XSkill.cs b/Client/Assets/Scripts/XMainClient/Skill/XSkill.cs new file mode 100644 index 00000000..8f60c688 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Skill/XSkill.cs @@ -0,0 +1,1028 @@ +using System; +using System.Collections.Generic; +using UnityEngine; +using XUtliPoolLib; + +namespace XMainClient +{ + internal abstract class XSkill + { + public virtual int SkillType + { + get + { + return -1; + } + } + + public long Token + { + get + { + return this._token; + } + } + + public bool AnimInit { get; set; } + + public bool DemonstrationMode + { + get + { + return this._demonstration; + } + } + + public float MultipleDirectionFactorByServer + { + get + { + return this._multiple_direction_factor; + } + set + { + this._multiple_direction_factor = value; + } + } + + public Vector3 SkillTowardsTo + { + get + { + return this._skill_forward; + } + set + { + this._skill_forward = value; + } + } + + public XSkillCore Core + { + get + { + return this._core; + } + } + + public virtual XSkillCore MainCore + { + get + { + return this._core; + } + } + + public abstract string AnimClipName { get; } + + public XEntity Firer + { + get + { + return this._firer; + } + } + + public XEntity Target + { + get + { + return this.HasValidTarget() ? this._target : null; + } + } + + public int SlotPos + { + get + { + return this._slot_pos; + } + } + + public bool Casting + { + get + { + return this._casting; + } + } + + public float TimeElapsed + { + get + { + return this._timeElapsed / this._time_scale; + } + } + + public float TimeScale + { + get + { + return 1f / this._time_scale; + } + } + + public static readonly int XJAComboSkillHash = 0; + + public static readonly int XArtsSkillHash = 1; + + public static readonly int XUltraSkillHash = 2; + + public static readonly int XCombinedSkillHash = 3; + + private string _last_anim_token = null; + + private bool _casting = false; + + private bool _execute = false; + + protected float _time_scale = 1f; + + protected float _multiple_direction_factor = 1f; + + protected bool _demonstration = false; + + protected XCameraEx _affect_camera = null; + + protected SmallBuffer _logical_token; + + protected SmallBuffer _present_token; + + protected SkillDo _start_method = null; + + protected SkillDo _update_method = null; + + protected SkillDo _result_method = null; + + protected SkillDo _stop_method = null; + + protected XEntity _target = null; + + protected XEntity _firer = null; + + protected XSkillMgr _skillmgr = null; + + protected long _token = 0L; + + protected int _slot_pos = -1; + + protected float _timeElapsed = 0f; + + protected XSkillCore _core = null; + + protected XSkillData _data = null; + + private Vector3 _skill_forward = Vector3.forward; + + protected XTimerMgr.ElapsedIDEventHandler _TimerCallback = null; + + protected enum ESkillTimerCb + { + EExternalExecute = 1, + ESkillNum + } + + public XSkill() + { + this._TimerCallback = new XTimerMgr.ElapsedIDEventHandler(this.ProcessTimer); + } + + public virtual void Initialize(XEntity firer) + { + this._firer = firer; + this._skillmgr = this._firer.SkillMgr; + this._logical_token.debugName = "XSkill._logical_token"; + this._present_token.debugName = "XSkill._present_token"; + XSingleton.singleton.GetSmallBuffer(ref this._logical_token, 16, 0); + XSingleton.singleton.GetSmallBuffer(ref this._present_token, 16, 0); + } + + public virtual void Uninitialize() + { + this._firer = null; + this._target = null; + this._skillmgr = null; + bool flag = this._logical_token.Count != 0 || this._present_token.Count != 0; + if (flag) + { + XSingleton.singleton.AddErrorLog("skill token not null", null, null, null, null, null); + } + XSingleton.singleton.ReturnSmallBuffer(ref this._logical_token); + XSingleton.singleton.ReturnSmallBuffer(ref this._present_token); + } + + public virtual void TriggerAnim() + { + bool flag = this._firer.Ator != null; + if (flag) + { + string triggerToken = this.Core.TriggerToken; + bool multipleAttackSupported = this.MainCore.Soul.MultipleAttackSupported; + if (multipleAttackSupported) + { + bool flag2 = triggerToken != this._last_anim_token; + if (flag2) + { + this._firer.Ator.SetTrigger(triggerToken); + } + this._firer.Ator.SetFloat("MultipleDirFactor", XSingleton.singleton.SyncMode ? this._multiple_direction_factor : this.MainCore.GetMultipleDirectionFactor()); + this._last_anim_token = triggerToken; + } + else + { + this._firer.Ator.SetTrigger(triggerToken); + this._last_anim_token = null; + } + } + } + + protected virtual bool InnerProcessTimer(object param, int id) + { + bool flag = id == 1; + bool result; + if (flag) + { + this.ExternalExecute(param); + result = true; + } + else + { + result = false; + } + return result; + } + + private void ProcessTimer(object param, int id) + { + this.InnerProcessTimer(param, id); + } + + public void UpdateCollisionLayer(float velocity) + { + this._firer.SetCollisionLayer((this.MainCore.Soul.IgnoreCollision || (!this._firer.IsRole && this._core.Offset > 1.5f && velocity > this._firer.Attributes.RunSpeed)) ? 14 : this._firer.DefaultLayer); + } + + protected void CalcForward() + { + bool flag = !this.MainCore.Soul.MultipleAttackSupported; + if (flag) + { + this._skill_forward = ((this._firer.Rotate == null) ? this._firer.EngineObject.Forward : this._firer.Rotate.GetMeaningfulFaceVector3()); + } + } + + protected abstract void Result(XResultData data); + + protected void OnResult(object o) + { + bool flag = true; + bool flag2 = this._result_method != null; + if (flag2) + { + flag = this._result_method(this); + } + bool flag3 = flag; + if (flag3) + { + bool flag4 = this._firer.Attributes != null; + if (flag4) + { + this._firer.Attributes.CombatAppendTime(); + } + this.Result(o as XResultData); + } + } + + protected void AddedTimerToken(uint token, bool logical) + { + if (logical) + { + this._logical_token.Add(token); + } + else + { + this._present_token.Add(token); + } + } + + protected abstract bool Present(); + + protected virtual void Start() + { + this.Reflection(); + } + + protected virtual bool Launch(XSkillCore core) + { + return true; + } + + protected virtual void Stop(bool cleanUp) + { + } + + protected virtual void KillTimerAll() + { + for (int i = 0; i < this._present_token.Count; i++) + { + uint token = this._present_token[i]; + XSingleton.singleton.KillTimer(token); + } + for (int j = 0; j < this._logical_token.Count; j++) + { + uint token2 = this._logical_token[j]; + XSingleton.singleton.KillTimer(token2); + } + this._present_token.Clear(); + this._logical_token.Clear(); + } + + public virtual uint GetCombinedId() + { + return 0u; + } + + public bool Update(float fDeltaT) + { + bool flag = this._casting; + bool flag2 = this._casting && this._execute; + if (flag2) + { + bool flag3 = !XSingleton.singleton.SyncMode; + if (flag3) + { + this.CalcForward(); + } + this._timeElapsed += fDeltaT; + flag = this.Present(); + bool flag4 = flag; + if (flag4) + { + bool flag5 = this._update_method != null; + if (flag5) + { + this._update_method(this); + } + } + } + bool animInit = this.AnimInit; + if (animInit) + { + this.Execute(); + } + this.AnimInit = false; + return flag; + } + + public void Execute() + { + bool flag = this._casting && !this._execute; + if (flag) + { + bool flag2 = this._core.ID == this._skillmgr.GetAppearIdentity(); + if (flag2) + { + XSingleton.singleton.Puppets(this._firer, false, false); + bool flag3 = this._firer.Ator != null; + if (flag3) + { + this._firer.Ator.cullingMode = 0; + } + } + this._execute = true; + this.CalcForward(); + this._core.Execute(this); + bool flag4 = this._firer.Ator != null; + if (flag4) + { + this._firer.Ator.speed = this.TimeScale; + } + this.Start(); + bool flag5 = this._start_method != null; + if (flag5) + { + this._start_method(this); + } + } + } + + public bool Fire(XEntity target, XSkillCore core, XAttackEventArgs args) + { + bool flag = !this._casting || !this._execute; + bool result; + if (flag) + { + this._demonstration = args.Demonstration; + bool flag2 = core == null || !core.Fire(this); + if (flag2) + { + result = false; + } + else + { + this._affect_camera = args.AffectCamera; + this._time_scale = 1f / args.TimeScale; + this._target = target; + this._token = ((args.SyncSequence == 0u) ? XSingleton.singleton.UniqueToken : ((long)((ulong)args.SyncSequence))); + bool flag3 = core.Soul.TypeToken == 3; + if (flag3) + { + bool flag4 = !this.Launch(core); + if (flag4) + { + return false; + } + } + else + { + this._core = core; + this._data = this._core.Soul; + } + bool flag5 = this._firer.Attributes != null; + if (flag5) + { + this._firer.Attributes.CombatMarkTimeBaseLine(); + } + this._timeElapsed = 0f; + this._slot_pos = args.Slot; + bool flag6 = !this.MainCore.Soul.Logical.Association || !this.MainCore.Soul.Logical.MoveType; + if (flag6) + { + this._firer.Machine.ForceToDefaultState(false); + } + this._casting = true; + this._execute = false; + this.AnimInit = false; + this._last_anim_token = null; + this._multiple_direction_factor = 1f; + this.FocusTarget(this.Target); + bool isPlayer = this._firer.IsPlayer; + if (isPlayer) + { + this.Manual(); + } + bool flag7 = !this._demonstration; + if (flag7) + { + XSkill.ProcessStart(this._token, this.MainCore.ID, this._firer, this.Target, new SkillExternalCallback(this.ExternalCallback)); + bool flag8 = this.Casting && (this._firer.IsPlayer || this._firer.IsEnemy); + if (flag8) + { + XSecuritySkillInfo xsecuritySkillInfo = XSecuritySkillInfo.TryGetStatistics(this._firer); + bool flag9 = xsecuritySkillInfo != null; + if (flag9) + { + xsecuritySkillInfo.OnCast(this.MainCore.ID); + } + } + } + else + { + XSkill.ProcessDemonstrationStart(this._token, this.MainCore.ID, this._firer, this.Casting ? this.Target : null, new SkillExternalCallback(this.ExternalCallback)); + } + result = this.Casting; + } + } + else + { + result = false; + } + return result; + } + + public void Puppetize(bool cleanUp = false) + { + bool flag = this._core != null; + if (flag) + { + bool flag2 = this._core.ID == this._skillmgr.GetAppearIdentity(); + if (flag2) + { + this._firer.Present.OnReadyFight(null); + bool flag3 = this._firer.Ator != null; + if (flag3) + { + this._firer.Ator.cullingMode =(AnimatorCullingMode) 1; + } + } + } + bool execute = this._execute; + if (execute) + { + this._execute = false; + this.KillTimerAll(); + this.Stop(cleanUp); + bool flag4 = this._firer.Ator != null; + if (flag4) + { + this._firer.Ator.speed = 1f; + } + bool flag5 = this._update_method != null; + if (flag5) + { + this._update_method(this); + } + bool flag6 = this._stop_method != null && this.MainCore.Soul.TypeToken != 3; + if (flag6) + { + this._stop_method(this); + } + this._core.Halt(); + bool flag7 = this._target != null; + if (flag7) + { + this._target = null; + } + } + } + + public void Cease(bool cleanUp = false) + { + bool casting = this._casting; + if (casting) + { + this._casting = false; + this.Puppetize(cleanUp); + XCombinedSkill xcombinedSkill = this as XCombinedSkill; + bool flag = xcombinedSkill != null; + if (flag) + { + xcombinedSkill.CombinedKillTimerAll(); + xcombinedSkill.CombinedStop(cleanUp); + } + bool flag2 = this._firer.Attributes != null && this.MainCore.Soul.Result.Count > 0; + if (flag2) + { + this._firer.Attributes.CombatMarkTimEndLine(); + } + this.MainCore.Halt(); + bool flag3 = this._firer.Machine.ActionToken == this._token; + if (flag3) + { + bool flag4 = !this.MainCore.Soul.Logical.Association || !this.MainCore.Soul.Logical.MoveType; + if (flag4) + { + this._firer.Machine.ForceToDefaultState(false); + } + } + this._timeElapsed = 0f; + this._time_scale = 1f; + this._affect_camera = null; + bool flag5 = !this._demonstration; + if (flag5) + { + XSkill.ProcessEnd(this._token, this.MainCore.ID, this._firer, this.Target); + } + } + bool flag6 = this._target != null; + if (flag6) + { + this._target = null; + } + this._core = null; + this._start_method = null; + this._update_method = null; + this._result_method = null; + this._stop_method = null; + } + + public virtual bool CanPerformAction(XStateDefine state, long token) + { + bool flag = !this._casting; + bool result; + if (flag) + { + result = true; + } + else + { + bool flag2 = token > 0L && this._token == token; + if (flag2) + { + result = true; + } + else + { + bool flag3 = XStateDefine.XState_Death == state; + if (flag3) + { + this.Cease(false); + result = true; + } + else + { + result = (this.MainCore == null || this.MainCore.CanAct(state)); + } + } + } + return result; + } + + public void FocusTarget(XEntity target) + { + bool flag = !XEntity.ValideEntity(target) || XSingleton.singleton.SyncMode; + if (!flag) + { + this._firer.Net.ReportRotateAction(XSingleton.singleton.Horizontal(target.RadiusCenter - this._firer.EngineObject.Position), this._firer.Attributes.AutoRotateSpeed, this._token); + } + } + + public bool HasValidTarget() + { + return this.MainCore != null && this.MainCore.Soul.NeedTarget && XEntity.ValideEntity(this._target); + } + + public bool ExternalCallback(XSkillExternalArgs args) + { + bool flag = this is XCombinedSkill; + if (flag) + { + (this as XCombinedSkill).AddedCombinedTimerToken(XSingleton.singleton.SetTimer(args.delay, this._TimerCallback, args, XSkill.ESkillTimerCb.EExternalExecute)); + } + else + { + this.AddedTimerToken(XSingleton.singleton.SetTimer(args.delay, this._TimerCallback, args, XSkill.ESkillTimerCb.EExternalExecute), true); + } + return true; + } + + protected void Manual() + { + bool flag = XSingleton.singleton.SyncMode || this.MainCore.Soul.MultipleAttackSupported; + if (!flag) + { + bool feeding = XSingleton.singleton.Feeding; + if (feeding) + { + this._firer.Net.ReportRotateAction(XSingleton.singleton.Direction, this._firer.Attributes.AutoRotateSpeed, 0L); + } + else + { + bool flag2 = this.MainCore.ID == this._skillmgr.GetDashIdentity(); + if (flag2) + { + this._firer.Net.ReportRotateAction(-this._firer.Rotate.GetMeaningfulFaceVector3(), this._firer.Attributes.AutoRotateSpeed, 0L); + } + } + } + } + + private void Reflection() + { + this._start_method = null; + this._update_method = null; + this._result_method = null; + this._stop_method = null; + bool flag = this._data != null && this._data.Script != null; + if (flag) + { + bool flag2 = !string.IsNullOrEmpty(this._data.Script.Start_Name); + if (flag2) + { + XSingleton.singleton.GetSkillDo(this._data.Name + this._data.Script.Start_Name, out this._start_method); + } + bool flag3 = !string.IsNullOrEmpty(this._data.Script.Update_Name); + if (flag3) + { + XSingleton.singleton.GetSkillDo(this._data.Name + this._data.Script.Update_Name, out this._update_method); + } + bool flag4 = !string.IsNullOrEmpty(this._data.Script.Result_Name); + if (flag4) + { + XSingleton.singleton.GetSkillDo(this._data.Name + this._data.Script.Result_Name, out this._result_method); + } + bool flag5 = !string.IsNullOrEmpty(this._data.Script.Stop_Name); + if (flag5) + { + XSingleton.singleton.GetSkillDo(this._data.Name + this._data.Script.Stop_Name, out this._stop_method); + } + } + } + + private void ExternalExecute(object o) + { + XSkillExternalArgs xskillExternalArgs = o as XSkillExternalArgs; + xskillExternalArgs.callback(xskillExternalArgs); + } + + public static void SkillResult(long token, XEntity firer, XSkillCore core, XBullet bullet, int triggerTime, uint resultID, int resultTime, Vector3 hitdir, XEntity target) + { + bool flag = (bullet == null) ? core.IsHurtEntity(target.ID, triggerTime) : bullet.IsHurtEntity(target.ID); + if (!flag) + { + bool isShowUp = target.Present.IsShowUp; + if (!isShowUp) + { + XStrickenResponse xstrickenResponse = target.Skill.IsCasting() ? target.Skill.CurrentSkill.MainCore.Soul.Logical.StrickenMask : XStrickenResponse.Cease; + bool flag2 = xstrickenResponse == XStrickenResponse.Cease || core.CarrierID == XSkill.XUltraSkillHash || (xstrickenResponse == XStrickenResponse.Half_Endure && target.Skill.IsOverResults()); + if (flag2) + { + xstrickenResponse = XStrickenResponse.Cease; + } + bool flag3 = xstrickenResponse == XStrickenResponse.Invincible; + if (!flag3) + { + bool flag4 = !core.Soul.Logical.AttackOnHitDown && target.Machine.Current == XStateDefine.XState_BeHit && target.BeHit.LaidOnGround(); + if (!flag4) + { + ProjectDamageResult dResult = XSkill.ProcessHurt(token, resultID, firer, target, resultTime); + bool flag5 = triggerTime >= core.Soul.Hit.Count; + if (flag5) + { + XSingleton.singleton.AddErrorLog("skill ", core.Soul.Name, "'s hit point is not matched with results.", null, null, null); + } + else + { + XSkill.SkillResult_TakeEffect(firer, target, dResult, core.Soul.Hit[triggerTime], hitdir, xstrickenResponse, target.StandOn, (float)(1.0 + (firer.Attributes.ParalyzeAttribute - target.Attributes.ParalyzeDefenseAttribute)), Vector3.zero); + bool flag6 = bullet == null; + if (flag6) + { + core.AddHurtTarget(target.ID, triggerTime); + } + else + { + bullet.OnResult(target); + } + } + } + } + } + } + } + + public static void SkillResult(XBullet bullet, Vector3 forward, Vector3 position, bool bulletcycle) + { + bool syncMode = XSingleton.singleton.SyncMode; + if (!syncMode) + { + XBulletCore bulletCore = bullet.BulletCore; + List opponent = XSingleton.singleton.GetOpponent(bulletCore.Firer); + for (int i = 0; i < opponent.Count; i++) + { + XEntity xentity = opponent[i]; + bool flag = !XEntity.ValideEntity(xentity) || (bulletCore.SkillCore.Soul.Result[bulletCore.Sequnce].Attack_Only_Target && xentity != bulletCore.Target); + if (!flag) + { + bool flag2 = bulletCore.SkillCore.IsInAttckField(bulletCore.Sequnce, position, forward, xentity); + if (flag2) + { + Vector3 hitdir = (bulletCore.SkillCore.Soul.Result[bulletCore.Sequnce].Affect_Direction == XResultAffectDirection.AttackDir) ? (xentity.EngineObject.Position - position) : bulletCore.Firer.Rotate.GetMeaningfulFaceVector3(); + hitdir.y = 0f; + hitdir.Normalize(); + bool syncMode2 = XSingleton.singleton.SyncMode; + if (!syncMode2) + { + XSkill.SkillResult(bulletCore.Token, bulletCore.Firer, bulletCore.SkillCore, bulletcycle ? bullet : null, bulletCore.Sequnce, bulletCore.ResultID, bulletCore.ResultTime, hitdir, xentity); + } + } + } + } + } + } + + public static void SkillResult(long token, XEntity firer, XSkillCore core, int triggerTime, uint resultID, int resultTime, Vector3 forward, Vector3 position) + { + bool syncMode = XSingleton.singleton.SyncMode; + if (!syncMode) + { + List opponent = XSingleton.singleton.GetOpponent(firer); + for (int i = 0; i < opponent.Count; i++) + { + XEntity xentity = opponent[i]; + bool flag = !XEntity.ValideEntity(xentity) || (core.Soul.Result[triggerTime].Attack_Only_Target && xentity != core.Carrier.Target); + if (!flag) + { + bool flag2 = core.IsInAttckField(triggerTime, position, forward, xentity); + if (flag2) + { + Vector3 hitdir = (core.Soul.Result[triggerTime].Affect_Direction == XResultAffectDirection.AttackDir) ? (xentity.EngineObject.Position - position) : firer.Rotate.GetMeaningfulFaceVector3(); + hitdir.y = 0f; + hitdir.Normalize(); + bool syncMode2 = XSingleton.singleton.SyncMode; + if (!syncMode2) + { + XSkill.SkillResult(token, firer, core, null, triggerTime, resultID, resultTime, hitdir, xentity); + } + } + } + } + } + } + + public static void SkillResult_TakeEffect(XEntity firer, XEntity target, ProjectDamageResult dResult, XHitData data, Vector3 hurtDiretion, XStrickenResponse rps, bool standOn, float paralyzeFactor, Vector3 error) + { + bool accept = dResult.Accept; + if (accept) + { + bool flag = firer != null; + if (flag) + { + bool isPlayer = firer.IsPlayer; + if (isPlayer) + { + bool syncMode = XSingleton.singleton.SyncMode; + if (syncMode) + { + XSingleton.singleton.OnHitEnemy(dResult.ComboCount); + } + else + { + XSingleton.singleton.OnHitEnemy(-1); + } + } + else + { + XSingleton.singleton.OnEnemyHitEnemy(firer); + } + } + bool isPlayer2 = target.IsPlayer; + if (isPlayer2) + { + XSingleton.singleton.OnPlayerBeHit(); + } + bool flag2 = rps == XStrickenResponse.Half_Endure || rps == XStrickenResponse.Full_Endure; + if (flag2) + { + XEndureEventArgs @event = XEventPool.GetEvent(); + @event.Firer = target; + @event.Fx = ((data.State == XBeHitState.Hit_Freezed) ? null : data.Fx); + @event.Dir = hurtDiretion; + @event.HitFrom = firer; + XSingleton.singleton.FireEvent(@event); + XHitEventArgs event2 = XEventPool.GetEvent(); + event2.Firer = target; + XSingleton.singleton.FireEvent(event2); + } + else + { + bool flag3 = !dResult.IsTargetDead; + if (flag3) + { + switch (dResult.Result) + { + case ProjectResultType.PJRES_BATI: + { + XEndureEventArgs event3 = XEventPool.GetEvent(); + event3.Firer = target; + event3.Fx = ((data.State == XBeHitState.Hit_Freezed) ? null : data.Fx); + event3.Dir = hurtDiretion; + event3.HitFrom = firer; + XSingleton.singleton.FireEvent(event3); + XRenderComponent.OnHit(target); + break; + } + case ProjectResultType.PJRES_STUN: + { + bool flag4 = !XSingleton.singleton.SyncMode; + if (flag4) + { + XFreezeEventArgs event4 = XEventPool.GetEvent(); + event4.HitData = null; + event4.Dir = hurtDiretion; + event4.Duration = XSingleton.singleton.StunTime; + event4.Firer = target; + XSingleton.singleton.FireEvent(event4); + } + break; + } + case ProjectResultType.PJRES_BEHIT: + { + bool flag5 = !XSingleton.singleton.SyncMode; + if (flag5) + { + bool flag6 = rps == XStrickenResponse.Cease; + if (flag6) + { + target.Skill.EndSkill(true, false); + } + bool flag7 = data.State != XBeHitState.Hit_Free; + if (flag7) + { + bool flag8 = data.State == XBeHitState.Hit_Freezed; + if (flag8) + { + XFreezeEventArgs event5 = XEventPool.GetEvent(); + event5.HitData = data; + event5.Dir = hurtDiretion; + event5.Firer = target; + XSingleton.singleton.FireEvent(event5); + } + else + { + bool flag9 = target.CurState == XStateDefine.XState_Freeze; + if (flag9) + { + XEndureEventArgs event6 = XEventPool.GetEvent(); + event6.Firer = target; + event6.Fx = data.Fx; + event6.Dir = hurtDiretion; + event6.HitFrom = firer; + XSingleton.singleton.FireEvent(event6); + } + else + { + XBeHitEventArgs event7 = XEventPool.GetEvent(); + event7.DepracatedPass = true; + event7.HitDirection = hurtDiretion; + event7.HitData = data; + event7.Firer = target; + event7.HitFrom = firer; + event7.Paralyze = paralyzeFactor; + event7.ForceToFlyHit = ((data.State == XBeHitState.Hit_Back || data.State == XBeHitState.Hit_Roll) && !standOn); + XSingleton.singleton.FireEvent(event7); + } + } + } + } + break; + } + } + } + } + bool flag10 = dResult.Value != 0.0 || dResult.Result == ProjectResultType.PJRES_IMMORTAL || dResult.Result == ProjectResultType.PJRES_MISS || dResult.AbsorbDamage != 0.0; + if (flag10) + { + XHUDAddEventArgs event8 = XEventPool.GetEvent(); + event8.DepracatedPass = true; + event8.damageResult = dResult; + event8.caster = firer; + event8.Firer = target; + XSingleton.singleton.FireEvent(event8); + } + XProjectDamageEventArgs event9 = XEventPool.GetEvent(); + event9.Damage = dResult; + event9.Receiver = target; + event9.Firer = XSingleton.singleton.Doc; + XSingleton.singleton.FireEvent(event9); + } + dResult.Recycle(); + } + + public static void ProcessDemonstrationStart(long token, uint skillId, XEntity firer, XEntity target, SkillExternalCallback callback) + { + HurtInfo data = XDataPool.GetData(); + data.Caster = firer; + data.Target = target; + data.SkillID = skillId; + data.SkillToken = token; + data.Callback = callback; + XSingleton.singleton.ProjectDemonstrationStart(data); + data.Recycle(); + } + + public static void ProcessStart(long token, uint skillId, XEntity firer, XEntity target, SkillExternalCallback callback) + { + bool syncMode = XSingleton.singleton.SyncMode; + if (!syncMode) + { + HurtInfo data = XDataPool.GetData(); + data.Caster = firer; + data.Target = target; + data.SkillID = skillId; + data.SkillToken = token; + data.Callback = callback; + XSingleton.singleton.ProjectStart(data); + data.Recycle(); + } + } + + public static ProjectDamageResult ProcessHurt(long token, uint skillId, XEntity firer, XEntity target, int hitCount) + { + bool syncMode = XSingleton.singleton.SyncMode; + ProjectDamageResult result; + if (syncMode) + { + result = null; + } + else + { + HurtInfo data = XDataPool.GetData(); + data.Caster = firer; + data.Target = target; + data.HitPoint = hitCount; + data.SkillID = skillId; + data.SkillToken = token; + ProjectDamageResult projectDamageResult = XSingleton.singleton.ProjectDamage(data); + data.Recycle(); + result = projectDamageResult; + } + return result; + } + + public static void ProcessEnd(long token, uint skillId, XEntity firer, XEntity target) + { + bool syncMode = XSingleton.singleton.SyncMode; + if (!syncMode) + { + HurtInfo data = XDataPool.GetData(); + data.Caster = firer; + data.Target = target; + data.SkillID = skillId; + data.SkillToken = token; + XSingleton.singleton.ProjectEnd(data); + data.Recycle(); + } + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/Skill/XSkill.cs.meta b/Client/Assets/Scripts/XMainClient/Skill/XSkill.cs.meta new file mode 100644 index 00000000..1467e576 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Skill/XSkill.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: cda8976665b7a0948932946452f44c44 +timeCreated: 1611404556 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/Skill/XSkillComponent.cs b/Client/Assets/Scripts/XMainClient/Skill/XSkillComponent.cs new file mode 100644 index 00000000..8553d0d4 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Skill/XSkillComponent.cs @@ -0,0 +1,1070 @@ +using System; +using System.Collections.Generic; +using KKSG; +using UnityEngine; +using XMainClient.UI; +using XMainClient.UI.UICommon; +using XUtliPoolLib; + +namespace XMainClient +{ + internal class XSkillComponent : XComponent + { + public override uint ID + { + get + { + return XSkillComponent.uuID; + } + } + + public bool IsSkillReplaced + { + get + { + return this._skill_replaced_by_typeid > 0u; + } + } + + public uint ReplacedByTypeID + { + get + { + return this._skill_replaced_by_typeid; + } + } + + public XSkillMgr SkillMgr + { + get + { + return this._skill_mgr; + } + } + + public uint[] ReplacedSlot + { + get + { + return this._replaced_skill_slot; + } + } + + public List SkillMobs + { + get + { + return this._skill_mobs; + } + } + + public bool HasSkillReplaced + { + get + { + return this._skills_replace_dic != null && this._skills_replace_dic.Count != 0; + } + } + + public XSkill CurrentSkill + { + get + { + return this._skill; + } + } + + public new static readonly uint uuID = XSingleton.singleton.XHash("Skill"); + + public static readonly string TriggerTag = ""; + + private XSkill _skill = null; + + private XSkillMgr _skill_mgr = null; + + private uint _timer_token = 0u; + + private uint _skill_replaced_by_typeid = 0u; + + private XLocateTargetComponent _locate = null; + + private XQuickTimeEventComponent _qte = null; + + private string _trigger = null; + + private uint[] _replaced_skill_slot = null; + + private List _skill_mobs = null; + + private Dictionary _skills_replace_dic = null; + + public XSkillCore TryGetSkillReplace(uint skillID, XSkillCore soul) + { + bool flag = this._skills_replace_dic == null; + XSkillCore result; + if (flag) + { + result = soul; + } + else + { + uint id; + bool flag2 = this._skills_replace_dic.TryGetValue(skillID, out id); + if (flag2) + { + XSkillCore skill = this._entity.SkillMgr.GetSkill(id); + bool flag3 = skill != null; + if (flag3) + { + return skill; + } + } + result = soul; + } + return result; + } + + public void SetSkillReplace(uint from, uint to) + { + bool flag = to == 0u; + if (flag) + { + bool flag2 = this._skills_replace_dic != null; + if (flag2) + { + this._skills_replace_dic.Remove(from); + } + } + else + { + bool flag3 = this._skills_replace_dic == null; + if (flag3) + { + this._skills_replace_dic = DictionaryPool.Get(); + } + this._skills_replace_dic[from] = to; + } + } + + public bool AddSkillMob(XEntity e) + { + bool result = false; + bool flag = this._skill_mobs == null; + if (flag) + { + this._skill_mobs = ListPool.Get(); + } + bool flag2 = e != null && !this._skill_mobs.Contains(e); + if (flag2) + { + this._skill_mobs.Add(e); + bool syncMode = XSingleton.singleton.SyncMode; + if (syncMode) + { + result = true; + } + else + { + XOthersAttributes xothersAttributes = e.Attributes as XOthersAttributes; + bool flag3 = xothersAttributes != null && xothersAttributes.SummonGroup > 0 && xothersAttributes.SummonGroup < XSingleton.singleton.EntitySummonGroupLimit.Length; + if (flag3) + { + int num = XSingleton.singleton.EntitySummonGroupLimit[xothersAttributes.SummonGroup]; + int num2 = 0; + XEntity xentity = null; + for (int i = 0; i < this._skill_mobs.Count; i++) + { + bool flag4 = !XEntity.ValideEntity(this._skill_mobs[i]); + if (!flag4) + { + XOthersAttributes xothersAttributes2 = this._skill_mobs[i].Attributes as XOthersAttributes; + bool flag5 = xothersAttributes2 != null && xothersAttributes2.SummonGroup == xothersAttributes.SummonGroup; + if (flag5) + { + bool flag6 = num2 == 0; + if (flag6) + { + xentity = this._skill_mobs[i]; + } + num2++; + } + } + } + bool flag7 = num2 > num; + if (flag7) + { + result = (e != xentity); + XSingleton.singleton.DestroyEntity(xentity); + } + else + { + result = true; + } + } + else + { + result = true; + } + } + } + return result; + } + + public void RemoveSkillMob(XEntity e) + { + bool flag = this._skill_mobs != null; + if (flag) + { + this._skill_mobs.Remove(e); + } + } + + public override void Update(float fDeltaT) + { + bool flag = this._skill == null; + if (!flag) + { + bool flag2 = !this._skill.Update(fDeltaT); + if (flag2) + { + this.EndSkill(false, false); + } + } + } + + public override void PostUpdate(float fDeltaT) + { + bool flag = this._trigger != null; + if (flag) + { + bool flag2 = this._trigger != "EndSkill"; + if (flag2) + { + bool flag3 = this.IsCasting(); + if (flag3) + { + this._skill.AnimInit = true; + bool flag4 = this._entity.Ator != null; + if (flag4) + { + this._entity.Ator.speed = 1f; + } + this._skill.TriggerAnim(); + } + } + else + { + bool flag5 = this._entity.Ator != null; + if (flag5) + { + this._entity.Ator.SetTrigger(this._trigger); + } + } + this._trigger = null; + } + } + + public void TagTrigger() + { + this._trigger = XSkillComponent.TriggerTag; + } + + public bool CanPerformAction(XStateDefine state, XActionArgs e) + { + bool flag = this.CurrentSkill == null; + return flag || this.CurrentSkill.CanPerformAction(state, e.Token); + } + + protected override void EventSubscribe() + { + base.RegisterEvent(XEventDefine.XEvent_Attack, new XComponent.XEventHandler(this.OnAttack)); + base.RegisterEvent(XEventDefine.XEvent_StrengthPresevedOff, new XComponent.XEventHandler(this.OnPresevedStrengthStop)); + base.RegisterEvent(XEventDefine.XEvent_RealDead, new XComponent.XEventHandler(this.OnRealDead)); + base.RegisterEvent(XEventDefine.XEvent_Move_Mob, new XComponent.XEventHandler(this.OnMoveMob)); + } + + public override void OnAttachToHost(XObject host) + { + base.OnAttachToHost(host); + this._skill_mgr = XSingleton.singleton.CreateSkillMgr(this._entity); + } + + public override void Attached() + { + bool flag = XSingleton.singleton.CurrentStage.Stage != EXStage.Hall; + if (flag) + { + this._qte = (this._entity.GetXComponent(XQuickTimeEventComponent.uuID) as XQuickTimeEventComponent); + bool flag2 = !XSingleton.singleton.IsMustTransform || (this._entity.IsEnemy && this._entity.Transformee == null); + if (flag2) + { + this._locate = (this._entity.IsPlayer ? (this._entity.GetXComponent(XLocateTargetComponent.uuID) as XLocateTargetComponent) : null); + bool flag3 = XEntity.ValideEntity(this._entity.MobbedBy) && this._entity.Attributes.SkillLevelInfo != null; + if (flag3) + { + this._entity.Attributes.SkillLevelInfo.RefreshMobLinkedLevels(this._entity, this._entity.MobbedBy); + } + this.AttachSkill(); + } + } + } + + public override void OnDetachFromHost() + { + this.EndSkill(true, true); + bool flag = this._skill_mgr != null; + if (flag) + { + XSingleton.singleton.ReturnSkillMgr(this._skill_mgr); + this._skill_mgr = null; + } + this._skill = null; + XSingleton.singleton.KillTimer(this._timer_token); + this._timer_token = 0u; + this._locate = null; + this._qte = null; + this._trigger = null; + bool flag2 = this._skill_mobs != null; + if (flag2) + { + ListPool.Release(this._skill_mobs); + this._skill_mobs = null; + } + bool flag3 = this._skills_replace_dic != null; + if (flag3) + { + DictionaryPool.Release(this._skills_replace_dic); + this._skills_replace_dic = null; + } + base.OnDetachFromHost(); + } + + public bool IsCasting() + { + return this._skill != null && this._skill.Casting; + } + + public bool IsOverResults() + { + bool flag = this.IsCasting(); + bool result2; + if (flag) + { + List result = this._skill.Core.Soul.Result; + result2 = (result != null && result.Count > 0 && result[result.Count - 1].At < this.CurrentSkill.TimeElapsed); + } + else + { + result2 = true; + } + return result2; + } + + protected bool OnPresevedStrengthStop(XEventArgs e) + { + bool flag = this.IsCasting() && this.CurrentSkill.MainCore.PreservedStrength > 0 && this.CurrentSkill.TimeElapsed < this.CurrentSkill.MainCore.Soul.Logical.PreservedEndAt; + if (flag) + { + this.EndSkill(true, false); + XStrengthPresevationOffArgs @event = XEventPool.GetEvent(); + @event.Host = this._entity; + @event.Firer = XSingleton.singleton.Doc; + XSingleton.singleton.FireEvent(@event); + } + return true; + } + + protected virtual bool OnAttack(XEventArgs e) + { + XAttackEventArgs xattackEventArgs = e as XAttackEventArgs; + uint identify = xattackEventArgs.Identify; + XSkillCore xskillCore = this._entity.SkillMgr.GetSkill(identify); + bool flag = xskillCore == null; + bool result; + if (flag) + { + result = false; + } + else + { + bool flag2 = !XSingleton.singleton.SyncMode; + if (flag2) + { + xskillCore = this.PhysicalAttackAdaptor(xskillCore); + } + bool flag3 = xskillCore == null; + if (flag3) + { + XSingleton.singleton.AddErrorLog("Skill ", identify.ToString(), " Physical-Adapter error.", null, null, null); + result = false; + } + else + { + bool flag4 = !XSingleton.singleton.SyncMode; + if (flag4) + { + xskillCore = this.TryGetSkillReplace(xskillCore.ID, xskillCore); + } + XEntity target = this.SelectedTarget(xattackEventArgs, xskillCore); + bool flag5 = this._entity.QTE != null && this._entity.QTE.QTEList.Contains(xskillCore.ID); + bool flag6 = false; + bool flag7 = xskillCore != null && (xattackEventArgs.Demonstration || XSingleton.singleton.SyncMode || (xskillCore.CooledDown && (flag5 || (xskillCore.CanCast(e.Token) && (this._skill == null || !this._skill.Casting || this._skill.MainCore.CanReplacedBy(xskillCore)))))); + if (flag7) + { + XSkill carrier = this._entity.SkillMgr.GetCarrier(xskillCore.CarrierID); + bool flag8 = this.FireSkill(carrier, target, xskillCore, xattackEventArgs); + if (flag8) + { + flag6 = true; + } + } + bool flag9 = flag5 || xskillCore.Soul.TypeToken == 0; + if (flag9) + { + bool flag10 = this._qte != null; + if (flag10) + { + this._qte.OnSkillCasted(xskillCore.ID, xattackEventArgs.Slot, flag6); + } + } + result = flag6; + } + } + return result; + } + + protected virtual bool OnRealDead(XEventArgs e) + { + this.EndSkill(false, true); + return true; + } + + protected virtual bool FireSkill(XSkill newOne, XEntity target, XSkillCore core, XAttackEventArgs args) + { + bool flag = this._skill != null; + if (flag) + { + this.EndSkill(false, false); + } + this._skill = newOne; + bool flag2 = this._skill != null && this._skill.Fire(target, core, args); + bool result; + if (flag2) + { + this.TagTrigger(); + bool multipleAttackSupported = this._skill.MainCore.Soul.MultipleAttackSupported; + if (multipleAttackSupported) + { + this._entity.OverrideAnimClip(XSkillData.MultipleAttackOverrideMap[0], this._skill.MainCore.Soul.ClipName, false, false); + this._entity.OverrideAnimClip(XSkillData.MultipleAttackOverrideMap[1], this._skill.MainCore.Soul.ClipName + "_right_forward", false, false); + this._entity.OverrideAnimClip(XSkillData.MultipleAttackOverrideMap[2], this._skill.MainCore.Soul.ClipName + "_right", false, false); + this._entity.OverrideAnimClip(XSkillData.MultipleAttackOverrideMap[3], this._skill.MainCore.Soul.ClipName + "_right_back", false, false); + this._entity.OverrideAnimClip(XSkillData.MultipleAttackOverrideMap[4], this._skill.MainCore.Soul.ClipName + "_left_forward", false, false); + this._entity.OverrideAnimClip(XSkillData.MultipleAttackOverrideMap[5], this._skill.MainCore.Soul.ClipName + "_left", false, false); + this._entity.OverrideAnimClip(XSkillData.MultipleAttackOverrideMap[6], this._skill.MainCore.Soul.ClipName + "_left_back", false, false); + this._entity.OverrideAnimClip(XSkillData.MultipleAttackOverrideMap[7], this._skill.MainCore.Soul.ClipName + "_back", false, false); + } + else + { + switch (this._skill.MainCore.Soul.TypeToken) + { + case 0: + this._entity.OverrideAnimClip(XSkillData.JaOverrideMap[core.Soul.SkillPosition], this._skill.MainCore.Soul.ClipName, false, false); + break; + case 1: + this._entity.OverrideAnimClip("Art", this._skill.AnimClipName, false, false); + break; + case 3: + for (int i = 0; i < this._skill.MainCore.Soul.Combined.Count; i++) + { + XSkillCore skill = this._entity.SkillMgr.GetSkill(XSingleton.singleton.XHash(this._skill.MainCore.Soul.Combined[i].Name)); + this._entity.OverrideAnimClip(XSkillData.CombinedOverrideMap[i], skill.Soul.ClipName, false, false); + } + break; + } + } + result = true; + } + else + { + bool flag3 = this._skill != null && this._skill.Casting; + if (!flag3) + { + this._skill = null; + } + result = false; + } + return result; + } + + private bool OnMoveMob(XEventArgs e) + { + bool flag = this._skill_mobs != null && this._host.EngineObject != null; + if (flag) + { + for (int i = 0; i < this._skill_mobs.Count; i++) + { + bool flag2 = this._skill_mobs[i].Skill != null; + if (flag2) + { + this._skill_mobs[i].Skill.EndSkill(false, false); + } + Vector3 vector = this._host.EngineObject.Rotation * ((XSingleton.singleton.MobMovePos.Length > i) ? XSingleton.singleton.MobMovePos[i] : Vector3.zero); + bool flag3 = this._skill_mobs[i].Net != null && this._skill_mobs[i].Machine != null && this._skill_mobs[i].Machine.Current == XStateDefine.XState_Move; + if (flag3) + { + this._skill_mobs[i].Net.ReportMoveAction(Vector3.zero, 0.0); + } + this._skill_mobs[i].CorrectMe(this._host.EngineObject.Position + vector, this._host.EngineObject.Forward, false, false); + } + } + return true; + } + + public void ReAttachSkill(XEntityPresentation.RowData template, uint typeid) + { + XSingleton.singleton.ClearBullets(this._entity.ID); + bool flag = this._skill_mgr != null; + if (flag) + { + this._skill_mgr.Uninitialize(); + } + this._skill_mgr.Initialize(this._entity); + bool flag2 = template == null; + if (flag2) + { + bool isSkillReplaced = this.IsSkillReplaced; + if (isSkillReplaced) + { + bool flag3 = !XSingleton.singleton.IsMustTransform; + if (flag3) + { + this.AttachSkill(); + } + } + } + else + { + this._skill_replaced_by_typeid = typeid; + string skillprefix = "SkillPackage/" + template.SkillLocation; + bool flag4 = !string.IsNullOrEmpty(template.A); + if (flag4) + { + this._entity.SkillMgr.AttachPhysicalSkill(XSingleton.singleton.Build(skillprefix, template.A, this._entity)); + } + bool flag5 = !string.IsNullOrEmpty(template.AA); + if (flag5) + { + this._entity.SkillMgr.AttachSkill(XSingleton.singleton.Build(skillprefix, template.AA, this._entity), false); + } + bool flag6 = !string.IsNullOrEmpty(template.AAA); + if (flag6) + { + this._entity.SkillMgr.AttachSkill(XSingleton.singleton.Build(skillprefix, template.AAA, this._entity), false); + } + bool flag7 = !string.IsNullOrEmpty(template.AAAA); + if (flag7) + { + this._entity.SkillMgr.AttachSkill(XSingleton.singleton.Build(skillprefix, template.AAAA, this._entity), false); + } + bool flag8 = !string.IsNullOrEmpty(template.AAAAA); + if (flag8) + { + this._entity.SkillMgr.AttachSkill(XSingleton.singleton.Build(skillprefix, template.AAAAA, this._entity), false); + } + bool flag9 = !string.IsNullOrEmpty(template.Ultra); + if (flag9) + { + this._entity.SkillMgr.AttachUltraSkill(XSingleton.singleton.Build(skillprefix, template.Ultra, this._entity)); + } + bool flag10 = !string.IsNullOrEmpty(template.Appear); + if (flag10) + { + this._entity.SkillMgr.AttachAppearSkill(XSingleton.singleton.Build(skillprefix, template.Appear, this._entity)); + } + bool flag11 = !string.IsNullOrEmpty(template.Disappear); + if (flag11) + { + this._entity.SkillMgr.AttachDisappearSkill(XSingleton.singleton.Build(skillprefix, template.Disappear, this._entity)); + } + bool flag12 = !string.IsNullOrEmpty(template.Dash); + if (flag12) + { + this._entity.SkillMgr.AttachDashSkill(XSingleton.singleton.Build(skillprefix, template.Dash, this._entity)); + } + bool flag13 = !string.IsNullOrEmpty(template.SuperArmorRecoverySkill); + if (flag13) + { + this._entity.SkillMgr.AttachRecoverySkill(XSingleton.singleton.Build(skillprefix, template.SuperArmorRecoverySkill, this._entity)); + } + bool flag14 = !string.IsNullOrEmpty(template.ArmorBroken); + if (flag14) + { + this._entity.SkillMgr.AttachBrokenSkill(XSingleton.singleton.Build(skillprefix, template.ArmorBroken, this._entity)); + } + bool flag15 = template.OtherSkills != null && template.OtherSkills.Length != 0; + if (flag15) + { + int i = 0; + int num = template.OtherSkills.Length; + while (i < num) + { + bool flag16 = !string.IsNullOrEmpty(template.OtherSkills[i]) && template.OtherSkills[i] != "E"; + if (flag16) + { + this._entity.SkillMgr.AttachSkill(XSingleton.singleton.Build(skillprefix, template.OtherSkills[i], this._entity), true); + } + i++; + } + } + else + { + bool isRole = this._entity.IsRole; + if (isRole) + { + for (int j = 0; j < this._entity.Attributes.skillSlot.Length; j++) + { + bool flag17 = this._entity.Attributes.skillSlot[j] == 0u; + if (!flag17) + { + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(this._entity.Attributes.skillSlot[j], 0u); + bool flag18 = skillConfig == null; + if (flag18) + { + XSingleton.singleton.AddErrorLog("Skill: ", this._entity.Attributes.skillSlot[j].ToString(), " is not found in SkillList", null, null, null); + } + else + { + this.OtherAttachFilter(skillConfig, this._entity.Attributes.skillSlot[j]); + } + } + } + Dictionary.Enumerator enumerator = this._entity.Attributes.SkillLevelInfo.LearnedSkills.GetEnumerator(); + while (enumerator.MoveNext()) + { + XSkillEffectMgr singleton = XSingleton.singleton; + KeyValuePair keyValuePair = enumerator.Current; + SkillList.RowData skillConfig2 = singleton.GetSkillConfig(keyValuePair.Key, 0u); + bool flag19 = skillConfig2 == null; + if (flag19) + { + XDebug singleton2 = XSingleton.singleton; + string log = "Skill: "; + keyValuePair = enumerator.Current; + singleton2.AddErrorLog(log, keyValuePair.Key.ToString(), " is not found in SkillList", null, null, null); + } + else + { + bool flag20 = (int)skillConfig2.SkillType == XFastEnumIntEqualityComparer.ToInt(SkillTypeEnum.Skill_Help) || skillConfig2.IsBasicSkill > 0; + if (flag20) + { + SkillList.RowData data = skillConfig2; + keyValuePair = enumerator.Current; + this.OtherAttachFilter(data, keyValuePair.Key); + } + } + } + } + } + this._entity.SkillMgr.StatisticsPhysicalSkill(); + bool isPlayer = this._entity.IsPlayer; + if (isPlayer) + { + List list = ListPool.Get(); + list.Add(this._entity.SkillMgr.GetPhysicalIdentity()); + list.Add(this._entity.SkillMgr.GetDashIdentity()); + bool flag21 = template.OtherSkills != null && template.OtherSkills.Length != 0; + if (flag21) + { + int num2 = template.OtherSkills.Length; + int num3 = 2; + while ((long)num3 < (long)((ulong)XBattleSkillDocument.Total_skill_slot)) + { + bool flag22 = num3 - 2 < num2 && !string.IsNullOrEmpty(template.OtherSkills[num3 - 2]) && template.OtherSkills[num3 - 2] != "E"; + if (flag22) + { + list.Add(XSingleton.singleton.XHash(template.OtherSkills[num3 - 2])); + } + else + { + list.Add(0u); + } + num3++; + } + } + else + { + int num4 = 2; + while ((long)num4 < (long)((ulong)XBattleSkillDocument.Total_skill_slot)) + { + list.Add(this._entity.Attributes.skillSlot[num4]); + num4++; + } + } + this._replaced_skill_slot = list.ToArray(); + ListPool.Release(list); + bool flag23 = DlgBase.singleton.SkillHandler != null; + if (flag23) + { + DlgBase.singleton.SkillHandler.SetButtonNum((int)template.SkillNum); + } + } + } + } + + public void AttachSkill() + { + this._skill_replaced_by_typeid = 0u; + this._replaced_skill_slot = null; + bool isRole = this._entity.IsRole; + if (isRole) + { + for (int i = 0; i < this._entity.Attributes.skillSlot.Length; i++) + { + bool flag = this._entity.Attributes.skillSlot[i] == 0u; + if (!flag) + { + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(this._entity.Attributes.skillSlot[i], 0u); + bool flag2 = skillConfig == null; + if (flag2) + { + XSingleton.singleton.AddErrorLog("Skill: ", this._entity.Attributes.skillSlot[i].ToString(), " is not found in SkillList", null, null, null); + } + else + { + this.AttachFilter(skillConfig, this._entity.Attributes.skillSlot[i]); + } + } + } + Dictionary.Enumerator enumerator = this._entity.Attributes.SkillLevelInfo.LearnedSkills.GetEnumerator(); + while (enumerator.MoveNext()) + { + XSkillEffectMgr singleton = XSingleton.singleton; + KeyValuePair keyValuePair = enumerator.Current; + SkillList.RowData skillConfig2 = singleton.GetSkillConfig(keyValuePair.Key, 0u); + bool flag3 = skillConfig2 == null; + if (flag3) + { + XDebug singleton2 = XSingleton.singleton; + string log = "Skill: "; + keyValuePair = enumerator.Current; + singleton2.AddErrorLog(log, keyValuePair.Key.ToString(), " is not found in SkillList", null, null, null); + } + else + { + bool flag4 = (int)skillConfig2.SkillType == XFastEnumIntEqualityComparer.ToInt(SkillTypeEnum.Skill_Help) || skillConfig2.IsBasicSkill > 0; + if (flag4) + { + SkillList.RowData data = skillConfig2; + keyValuePair = enumerator.Current; + this.AttachFilter(data, keyValuePair.Key); + } + } + } + } + else + { + bool flag5 = !string.IsNullOrEmpty(this._entity.Present.PresentLib.A); + if (flag5) + { + this._entity.SkillMgr.AttachPhysicalSkill(XSingleton.singleton.Build(this._entity.Present.SkillPrefix, this._entity.Present.PresentLib.A, this._entity)); + } + bool flag6 = !string.IsNullOrEmpty(this._entity.Present.PresentLib.AA); + if (flag6) + { + this._entity.SkillMgr.AttachSkill(XSingleton.singleton.Build(this._entity.Present.SkillPrefix, this._entity.Present.PresentLib.AA, this._entity), false); + } + bool flag7 = !string.IsNullOrEmpty(this._entity.Present.PresentLib.AAA); + if (flag7) + { + this._entity.SkillMgr.AttachSkill(XSingleton.singleton.Build(this._entity.Present.SkillPrefix, this._entity.Present.PresentLib.AAA, this._entity), false); + } + bool flag8 = !string.IsNullOrEmpty(this._entity.Present.PresentLib.AAAA); + if (flag8) + { + this._entity.SkillMgr.AttachSkill(XSingleton.singleton.Build(this._entity.Present.SkillPrefix, this._entity.Present.PresentLib.AAAA, this._entity), false); + } + bool flag9 = !string.IsNullOrEmpty(this._entity.Present.PresentLib.AAAAA); + if (flag9) + { + this._entity.SkillMgr.AttachSkill(XSingleton.singleton.Build(this._entity.Present.SkillPrefix, this._entity.Present.PresentLib.AAAAA, this._entity), false); + } + bool flag10 = !string.IsNullOrEmpty(this._entity.Present.PresentLib.Ultra); + if (flag10) + { + this._entity.SkillMgr.AttachUltraSkill(XSingleton.singleton.Build(this._entity.Present.SkillPrefix, this._entity.Present.PresentLib.Ultra, this._entity)); + } + bool flag11 = !string.IsNullOrEmpty(this._entity.Present.PresentLib.Appear); + if (flag11) + { + this._entity.SkillMgr.AttachAppearSkill(XSingleton.singleton.Build(this._entity.Present.SkillPrefix, this._entity.Present.PresentLib.Appear, this._entity)); + } + bool flag12 = !string.IsNullOrEmpty(this._entity.Present.PresentLib.Disappear); + if (flag12) + { + this._entity.SkillMgr.AttachDisappearSkill(XSingleton.singleton.Build(this._entity.Present.SkillPrefix, this._entity.Present.PresentLib.Disappear, this._entity)); + } + bool flag13 = !string.IsNullOrEmpty(this._entity.Present.PresentLib.Dash); + if (flag13) + { + this._entity.SkillMgr.AttachDashSkill(XSingleton.singleton.Build(this._entity.Present.SkillPrefix, this._entity.Present.PresentLib.Dash, this._entity)); + } + bool flag14 = !string.IsNullOrEmpty(this._entity.Present.PresentLib.SuperArmorRecoverySkill); + if (flag14) + { + this._entity.SkillMgr.AttachRecoverySkill(XSingleton.singleton.Build(this._entity.Present.SkillPrefix, this._entity.Present.PresentLib.SuperArmorRecoverySkill, this._entity)); + } + bool flag15 = !string.IsNullOrEmpty(this._entity.Present.PresentLib.ArmorBroken); + if (flag15) + { + this._entity.SkillMgr.AttachBrokenSkill(XSingleton.singleton.Build(this._entity.Present.SkillPrefix, this._entity.Present.PresentLib.ArmorBroken, this._entity)); + } + bool flag16 = this._entity.Present.PresentLib.OtherSkills != null; + if (flag16) + { + int j = 0; + int num = this._entity.Present.PresentLib.OtherSkills.Length; + while (j < num) + { + bool flag17 = !string.IsNullOrEmpty(this._entity.Present.PresentLib.OtherSkills[j]) && this._entity.Present.PresentLib.OtherSkills[j] != "E"; + if (flag17) + { + this._entity.SkillMgr.AttachSkill(XSingleton.singleton.Build(this._entity.Present.SkillPrefix, this._entity.Present.PresentLib.OtherSkills[j], this._entity), true); + } + j++; + } + } + } + this._entity.SkillMgr.StatisticsPhysicalSkill(); + bool isPlayer = this._entity.IsPlayer; + if (isPlayer) + { + } + } + + public void EndSkill(bool cleanUp = false, bool force = false) + { + bool syncMode = XSingleton.singleton.SyncMode; + if (syncMode) + { + bool isPlayer = this._entity.IsPlayer; + if (isPlayer) + { + this._entity.Net.LastReqSkill = 0u; + } + bool flag = !force && this._skill != null && !this._skill.DemonstrationMode; + if (flag) + { + return; + } + } + this.InnerEnd(cleanUp); + } + + private void InnerEnd(bool cleanUp) + { + bool flag = this._skill != null; + if (flag) + { + this._skill.Cease(cleanUp); + this._skill = null; + this._trigger = "EndSkill"; + } + } + + private XEntity SelectedTarget(XAttackEventArgs args, XSkillCore soul) + { + bool syncMode = XSingleton.singleton.SyncMode; + XEntity result; + if (syncMode) + { + result = args.Target; + } + else + { + bool flag = args.Target == null; + if (flag) + { + result = ((this._locate == null) ? null : this._locate.Locate(this._entity.EngineObject.Forward, this._entity.EngineObject.Position, false)); + } + else + { + result = args.Target; + } + } + return result; + } + + private XSkillCore PhysicalAttackAdaptor(XSkillCore soul) + { + bool flag = this._entity.IsPlayer && soul.Soul.Logical.Association; + if (flag) + { + bool feeding = XSingleton.singleton.Feeding; + if (feeding) + { + bool flag2 = !soul.Soul.Logical.MoveType; + if (flag2) + { + soul = this._entity.SkillMgr.GetSkill(XSingleton.singleton.XHash(soul.Soul.Logical.Association_Skill)); + } + } + else + { + bool moveType = soul.Soul.Logical.MoveType; + if (moveType) + { + soul = this._entity.SkillMgr.GetSkill(XSingleton.singleton.XHash(soul.Soul.Logical.Association_Skill)); + } + } + } + return soul; + } + + private void AttachFilter(SkillList.RowData data, uint id) + { + XSkillCore core = XSingleton.singleton.Build(this._entity.Present.SkillPrefix, data.SkillScript, this._entity); + XSkillData.PreLoad = (this._entity.IsPlayer && !XSingleton.singleton.IsMustTransform); + bool flag = this._entity.SkillMgr.GetPhysicalIdentity() == 0u && XSingleton.singleton.XHash(this._entity.Present.PresentLib.A) == id; + if (flag) + { + this._entity.SkillMgr.AttachPhysicalSkill(core); + } + else + { + bool flag2 = this._entity.SkillMgr.GetUltraIdentity() == 0u && XSingleton.singleton.XHash(this._entity.Present.PresentLib.Ultra) == id; + if (flag2) + { + this._entity.SkillMgr.AttachUltraSkill(core); + } + else + { + bool flag3 = this._entity.SkillMgr.GetAppearIdentity() == 0u && XSingleton.singleton.XHash(this._entity.Present.PresentLib.Appear) == id; + if (flag3) + { + this._entity.SkillMgr.AttachAppearSkill(core); + } + else + { + bool flag4 = this._entity.SkillMgr.GetDisappearIdentity() == 0u && XSingleton.singleton.XHash(this._entity.Present.PresentLib.Disappear) == id; + if (flag4) + { + this._entity.SkillMgr.AttachDisappearSkill(core); + } + else + { + bool flag5 = this._entity.SkillMgr.GetDashIdentity() == 0u && XSingleton.singleton.XHash(this._entity.Present.PresentLib.Dash) == id; + if (flag5) + { + this._entity.SkillMgr.AttachDashSkill(core); + } + else + { + bool flag6 = this._entity.SkillMgr.GetRecoveryIdentity() == 0u && XSingleton.singleton.XHash(this._entity.Present.PresentLib.SuperArmorRecoverySkill) == id; + if (flag6) + { + this._entity.SkillMgr.AttachRecoverySkill(core); + } + else + { + bool flag7 = this._entity.SkillMgr.GetBrokenIdentity() == 0u && XSingleton.singleton.XHash(this._entity.Present.PresentLib.ArmorBroken) == id; + if (flag7) + { + this._entity.SkillMgr.AttachRecoverySkill(core); + } + else + { + bool flag8 = XSingleton.singleton.XHash(this._entity.Present.PresentLib.AA) == id; + if (flag8) + { + this._entity.SkillMgr.AttachSkill(core, false); + } + else + { + bool flag9 = XSingleton.singleton.XHash(this._entity.Present.PresentLib.AAA) == id; + if (flag9) + { + this._entity.SkillMgr.AttachSkill(core, false); + } + else + { + bool flag10 = XSingleton.singleton.XHash(this._entity.Present.PresentLib.AAAA) == id; + if (flag10) + { + this._entity.SkillMgr.AttachSkill(core, false); + } + else + { + bool flag11 = XSingleton.singleton.XHash(this._entity.Present.PresentLib.AAAAA) == id; + if (flag11) + { + this._entity.SkillMgr.AttachSkill(core, false); + } + else + { + this._entity.SkillMgr.AttachSkill(core, true); + } + } + } + } + } + } + } + } + } + } + } + XSkillData.PreLoad = false; + } + + private void OtherAttachFilter(SkillList.RowData data, uint id) + { + bool flag = XSingleton.singleton.XHash(this._entity.Present.PresentLib.A) == id; + if (!flag) + { + bool flag2 = XSingleton.singleton.XHash(this._entity.Present.PresentLib.Ultra) == id; + if (!flag2) + { + bool flag3 = XSingleton.singleton.XHash(this._entity.Present.PresentLib.Appear) == id; + if (!flag3) + { + bool flag4 = XSingleton.singleton.XHash(this._entity.Present.PresentLib.Disappear) == id; + if (!flag4) + { + bool flag5 = XSingleton.singleton.XHash(this._entity.Present.PresentLib.Dash) == id; + if (!flag5) + { + bool flag6 = XSingleton.singleton.XHash(this._entity.Present.PresentLib.SuperArmorRecoverySkill) == id; + if (!flag6) + { + bool flag7 = XSingleton.singleton.XHash(this._entity.Present.PresentLib.ArmorBroken) == id; + if (!flag7) + { + bool flag8 = XSingleton.singleton.XHash(this._entity.Present.PresentLib.AA) == id; + if (!flag8) + { + bool flag9 = XSingleton.singleton.XHash(this._entity.Present.PresentLib.AAA) == id; + if (!flag9) + { + bool flag10 = XSingleton.singleton.XHash(this._entity.Present.PresentLib.AAAA) == id; + if (!flag10) + { + bool flag11 = XSingleton.singleton.XHash(this._entity.Present.PresentLib.AAAAA) == id; + if (!flag11) + { + XSkillCore core = XSingleton.singleton.Build(this._entity.Present.SkillPrefix, data.SkillScript, this._entity); + this._entity.SkillMgr.AttachSkill(core, true); + } + } + } + } + } + } + } + } + } + } + } + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/Skill/XSkillComponent.cs.meta b/Client/Assets/Scripts/XMainClient/Skill/XSkillComponent.cs.meta new file mode 100644 index 00000000..4b31a55c --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Skill/XSkillComponent.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 0bce6fc3050c86a418204a6a1d27f002 +timeCreated: 1611403170 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: 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.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 _hurt_target; + + private Rect _rect; + + private static Rect s_rect; + + private Vector3 _vOffset = Vector3.zero; + + private XTimerMgr.ElapsedEventHandler _OnReloaded = null; + + public List[] WarningPosAt = null; + + public List[] WarningRandomAt = null; + + public static int maxHurtCount = 0; + + public struct XSkillWarningPackage + { + public Vector3 WarningAt; + + public ulong WarningTo; + } + + public struct XWarningRandomPackage + { + public ulong ID; + + public List Pos; + } + + public XSkillCore(XEntity firer, XSkillData data, uint longid) + { + this._firer = firer; + this._long_id = longid; + this._id = XSingleton.singleton.XHash(data.Name); + this._carrier_id = XSingleton.singleton.GetTypeHash(data.TypeToken); + this._hurt_target = ListPool.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[this._soul.Warning.Count]; + for (int i = 0; i < this._soul.Warning.Count; i++) + { + this.WarningPosAt[i] = new List(); + } + } + } + this._offset = 0f; + bool flag3 = !XSingleton.singleton.SyncMode && this._soul.Charge.Count > 0; + if (flag3) + { + bool using_Curve = this._soul.Charge[0].Using_Curve; + if (using_Curve) + { + IXCurve curve = XSingleton.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.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.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.singleton.MakeEffectEnable(XPostEffect.RadialBlur, true); + } + + public void EndCameraPostEffect() + { + XSingleton.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.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.singleton.KillTimer(this._cd_token); + this._cd_token = XSingleton.singleton.SetTimer(coolDown, this._OnReloaded, null); + bool flag3 = this._notify_at > 0f && this._notify_at < coolDown; + if (flag3) + { + XSingleton.singleton.KillTimer(this._timer_token_skill_notify); + this._timer_token_skill_notify = XSingleton.singleton.SetTimer(coolDown - this._notify_at, new XTimerMgr.ElapsedEventHandler(this.OnCastNotify), null); + } + bool flag4 = !XSingleton.singleton.SyncMode && !string.IsNullOrEmpty(this.Soul.Logical.Syntonic_CoolDown_Skill); + if (flag4) + { + this._is_on_syntonic = true; + XSkillCore skill = this._firer.SkillMgr.GetSkill(XSingleton.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 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[this._soul.Warning.Count]; + for (int i = 0; i < this._soul.Warning.Count; i++) + { + this.WarningRandomAt[i] = new List(); + } + } + 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(); + 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.singleton.GetSkillCDStaticRatio(this.ID, this._skill_level, this._firer.SkillCasterTypeID, XSingleton.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.singleton.CalcDynamicRatio(1f, this._semi_dynamic_cd_ratio); + bool reloading = this.Reloading; + if (reloading) + { + float num2 = XSingleton.singleton.CalcDynamicRatio(XSingleton.singleton.CanChangeCD(this.ID, this._skill_level, this._firer.SkillCasterTypeID) ? XSingleton.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.singleton.KillTimer(this._cd_token); + bool flag3 = num4 > 0f; + if (flag3) + { + this._cd_token = XSingleton.singleton.SetTimer(num4, this._OnReloaded, null); + } + else + { + this.CoolDown(); + } + } + } + this._last_dynamic_cd = num; + return num; + } + + public float GetTimeScale() + { + return (float)XSingleton.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.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.singleton.KillTimer(this._cd_token); + bool flag = coolDown > 0f; + if (flag) + { + this._cd_token = XSingleton.singleton.SetTimer(coolDown, this._OnReloaded, null); + } + } + else + { + XSingleton.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.singleton.GetSkillConfig(this.ID, this._skill_level, this._firer.SkillCasterTypeID); + bool flag = skillConfig != null; + if (flag) + { + DlgBase.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.singleton.GetSkillCDStaticRatio(this.ID, this._skill_level, this._firer.SkillCasterTypeID, XSingleton.singleton.IsPVPScene) * this._soul.CoolDown; + this._init_cd = XSingleton.singleton.GetSkillInitCDRatio(this.ID, this._skill_level, this._firer.SkillCasterTypeID, XSingleton.singleton.IsPVPScene, attributes) * this._soul.CoolDown; + this._semi_dynamic_cd_ratio = XSingleton.singleton.GetSkillCDSemiDynamicRatio(attributes, this.ID); + this._preserved_strength = XSingleton.singleton.GetStrengthValue(this.ID, this._skill_level, this._firer.SkillCasterTypeID); + this._notify_at = XSingleton.singleton.GetRemainingCDNotify(this.ID, this._skill_level, this._firer.SkillCasterTypeID); + this._totally_running_time = XSingleton.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.singleton.KillTimer(this._cd_token); + XSingleton.singleton.KillTimer(this._timer_token_skill_notify); + this._cd_token = XSingleton.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.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.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.singleton.IsLess(timeElapsed, this._soul.Logical.Not_Move_End) && XSingleton.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.singleton.Feeding; + if (flag5) + { + this._carrier.SkillTowardsTo = XSingleton.singleton.Direction; + } + } + else + { + this._carrier.Firer.Net.ReportRotateAction((this._firer.IsPlayer && XSingleton.singleton.Feeding) ? XSingleton.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.singleton.IsLess(this._carrier.TimeElapsed, this._soul.Logical.Rotate_End) && XSingleton.singleton.IsEqualGreater(this._carrier.TimeElapsed, this._soul.Logical.Rotate_At)); + } + + public bool CanMove() + { + return this._carrier == null || XSingleton.singleton.IsEqualGreater(this._carrier.TimeElapsed, this._soul.Logical.Not_Move_End) || XSingleton.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.singleton.VectorToQuaternion(XSingleton.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.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 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 opponent = XSingleton.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.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.singleton.XHash(this._soul.Ja[0].Name); + flag = (skill.ID == num); + bool flag6 = !flag; + if (flag6) + { + XSkillCore skill2 = this._firer.SkillMgr.GetSkill(XSingleton.singleton.XHash(this._soul.Ja[0].Name)); + bool flag7 = skill2 != null && skill2.Soul.Logical.Association; + if (flag7) + { + num = XSingleton.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.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 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.singleton.IsLess(magnitude, upper) && XSingleton.singleton.IsEqualGreater(magnitude, lower) && num2 <= scope); + } + else + { + Quaternion rotation = XSingleton.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.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.singleton.WithinRange == 0f) ? 1f : XSingleton.singleton.WithinRange); + int num8 = XSingleton.singleton.IsInteger(num7) ? Mathf.FloorToInt(num7 + 0.05f) : Mathf.CeilToInt(num7); + float num9 = (float)XSingleton.singleton.RangeWeight / (float)num8; + num7 = (float)num8 * (1f - num5 / num6); + int num10 = XSingleton.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.singleton.ImmortalWeight; + } + bool isBoss = target.IsBoss; + if (isBoss) + { + num += (float)XSingleton.singleton.BossWeight; + } + else + { + bool isElite = target.IsElite; + if (isElite) + { + num += (float)XSingleton.singleton.EliteWeight; + } + else + { + bool isPuppet = target.IsPuppet; + if (isPuppet) + { + num += (float)XSingleton.singleton.PupetWeight; + } + else + { + bool isRole = target.IsRole; + if (isRole) + { + num += (float)XSingleton.singleton.RoleWeight; + } + else + { + num += (float)XSingleton.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.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.singleton.Clockwise(vector, skillTowardsTo) ? num : (360f - num)); + result = num / 360f; + } + return result; + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/Skill/XSkillCore.cs.meta b/Client/Assets/Scripts/XMainClient/Skill/XSkillCore.cs.meta new file mode 100644 index 00000000..e59f830f --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Skill/XSkillCore.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 235579c69d7832c45b6b25a9a12e92d8 +timeCreated: 1611403450 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/Skill/XSkillEffectMgr.cs b/Client/Assets/Scripts/XMainClient/Skill/XSkillEffectMgr.cs new file mode 100644 index 00000000..798f1385 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Skill/XSkillEffectMgr.cs @@ -0,0 +1,937 @@ +using System; +using System.Collections.Generic; +using UnityEngine; +using XUtliPoolLib; + +namespace XMainClient +{ + internal class XSkillEffectMgr : XSingleton + { + private XTableAsyncLoader _async_loader = null; + + private SkillList _skillTable = new SkillList(); + + public Dictionary PreSkillDict = new Dictionary(200); + + private Dictionary _specialEnemyPreSkillDict = new Dictionary(); + + public uint EmptySkillHash = XSingleton.singleton.XHash("E"); + + private static CVSReader.RowDataCompare comp = new CVSReader.RowDataCompare(XSkillEffectMgr.SkillDataCompare); + + private SkillLevelupRequest req = null; + + private SkillEffect m_SkillEffect = new SkillEffect(); + + private List ret = null; + + private HashSet repeatHash = null; + + public void TestSkillTable() + { + for (int i = 0; i < this._skillTable.Table.Length; i++) + { + SkillList.RowData rowData = this._skillTable.Table[i]; + bool flag = this.GetSkillConfig(XSingleton.singleton.XHash(rowData.SkillScript), 0u, rowData.XEntityStatisticsID) == null; + if (flag) + { + XSingleton.singleton.AddErrorLog2("skill not found:{0}", new object[] + { + rowData.SkillScript + }); + } + } + } + + public override bool Init() + { + bool flag = this._async_loader == null; + if (flag) + { + this._async_loader = new XTableAsyncLoader(); + this._async_loader.AddTask("Table/SkillList", this._skillTable, false); + this._async_loader.Execute(null); + } + bool flag2 = !this._async_loader.IsDone; + bool result; + if (flag2) + { + result = false; + } + else + { + for (int i = 0; i < this._skillTable.Table.Length; i++) + { + SkillList.RowData rowData = this._skillTable.Table[i]; + bool flag3 = !string.IsNullOrEmpty(rowData.SkillScript) && !string.IsNullOrEmpty(rowData.ExSkillScript); + if (flag3) + { + bool flag4 = rowData.XEntityStatisticsID > 0u; + if (flag4) + { + ulong key = (ulong)XSingleton.singleton.XHash(rowData.ExSkillScript) << 32 | (ulong)rowData.XEntityStatisticsID; + this._specialEnemyPreSkillDict[key] = rowData.SkillScriptHash; + } + else + { + this.PreSkillDict[XSingleton.singleton.XHash(rowData.ExSkillScript)] = rowData.SkillScriptHash; + } + } + } + result = true; + } + return result; + } + + public override void Uninit() + { + this._async_loader = null; + } + + public SkillList.RowData GetSkillConfig(uint skillHash, uint skillLevel, uint entityTempID) + { + bool flag = entityTempID == 0u; + SkillList.RowData result; + if (flag) + { + result = this.GetSkillConfig(skillHash, skillLevel); + } + else + { + result = this.GetEnemySpecialSkillConfig(skillHash, skillLevel, entityTempID); + } + return result; + } + + public SkillList.RowData GetEnemySpecialSkillConfig(uint skillHash, uint skillLevel, uint entityTempID) + { + bool flag = this.EmptySkillHash == skillHash; + SkillList.RowData result; + if (flag) + { + result = null; + } + else + { + int num = -1; + int num2 = -1; + CVSReader.GetRowDataListByField(this._skillTable.Table, skillHash, out num, out num2, XSkillEffectMgr.comp); + bool flag2 = num >= 0 && num <= num2; + if (flag2) + { + for (int i = num; i <= num2; i++) + { + SkillList.RowData rowData = this._skillTable.Table[i]; + bool flag3 = rowData.XEntityStatisticsID == entityTempID && skillLevel <= (uint)rowData.SkillLevel; + if (flag3) + { + return rowData; + } + } + bool flag4 = num == num2; + if (flag4) + { + result = this._skillTable.Table[num]; + } + else + { + for (int j = num; j <= num2; j++) + { + SkillList.RowData rowData2 = this._skillTable.Table[j]; + bool flag5 = rowData2.XEntityStatisticsID == 0u && skillLevel <= (uint)rowData2.SkillLevel; + if (flag5) + { + return rowData2; + } + } + result = this._skillTable.Table[num2]; + } + } + else + { + result = null; + } + } + return result; + } + + private static int SkillDataCompare(SkillList.RowData rowData, uint skillHash) + { + return skillHash.CompareTo(rowData.SkillScriptHash); + } + + public SkillList.RowData GetSkillConfig(uint skillHash, uint skillLevel) + { + bool flag = this.EmptySkillHash == skillHash; + SkillList.RowData result; + if (flag) + { + result = null; + } + else + { + int num = -1; + int num2 = -1; + CVSReader.GetRowDataListByField(this._skillTable.Table, skillHash, out num, out num2, XSkillEffectMgr.comp); + bool flag2 = num >= 0 && num <= num2; + if (flag2) + { + bool flag3 = num == num2; + if (flag3) + { + result = this._skillTable.Table[num]; + } + else + { + for (int i = num; i <= num2; i++) + { + SkillList.RowData rowData = this._skillTable.Table[i]; + bool flag4 = rowData.XEntityStatisticsID == 0u && skillLevel <= (uint)rowData.SkillLevel; + if (flag4) + { + return rowData; + } + } + result = this._skillTable.Table[num2]; + } + } + else + { + result = null; + } + } + return result; + } + + public int GetSkillMaxLevel(uint skillHash, uint entityTempID = 0u) + { + bool flag = this.EmptySkillHash == skillHash; + int result; + if (flag) + { + result = 0; + } + else + { + int num = -1; + int num2 = -1; + CVSReader.GetRowDataListByField(this._skillTable.Table, skillHash, out num, out num2, XSkillEffectMgr.comp); + bool flag2 = num >= 0 && num <= num2; + if (flag2) + { + bool flag3 = entityTempID > 0u; + SkillList.RowData rowData; + if (flag3) + { + for (int i = num2; i >= num; i--) + { + rowData = this._skillTable.Table[i]; + bool flag4 = rowData.XEntityStatisticsID == entityTempID; + if (flag4) + { + return (int)rowData.SkillLevel; + } + } + } + rowData = this._skillTable.Table[0]; + uint preSkill = this.GetPreSkill(skillHash, 0u); + bool flag5 = preSkill > 0u; + if (flag5) + { + result = 1; + } + else + { + for (int j = num2; j >= num; j--) + { + rowData = this._skillTable.Table[j]; + bool flag6 = rowData.XEntityStatisticsID == 0u; + if (flag6) + { + return (int)rowData.SkillLevel; + } + } + result = 0; + } + } + else + { + result = 0; + } + } + return result; + } + + public int GetSkillHpMaxLimit(string skillName, uint level, uint entityTempID) + { + uint skillHash = XSingleton.singleton.XHash(skillName); + SkillList.RowData skillConfig = this.GetSkillConfig(skillHash, level, entityTempID); + bool flag = skillConfig == null; + int result; + if (flag) + { + result = 0; + } + else + { + result = (int)skillConfig.HpMaxLimit; + } + return result; + } + + public int GetSkillHpMinLimit(string skillName, uint level, uint entityTempID) + { + uint skillHash = XSingleton.singleton.XHash(skillName); + SkillList.RowData skillConfig = this.GetSkillConfig(skillHash, level, entityTempID); + bool flag = skillConfig == null; + int result; + if (flag) + { + result = 0; + } + else + { + result = (int)skillConfig.HpMinLimit; + } + return result; + } + + public bool GetSkillDescriptValue(uint skillhash, uint level, XBodyBag EmblemBag, out float Ratio, out float Fixed) + { + float num = 0f; + float num2 = 0f; + Ratio = 0f; + Fixed = 0f; + SkillList.RowData skillConfig = this.GetSkillConfig(skillhash, level); + bool flag = skillConfig == null; + bool result; + if (flag) + { + result = false; + } + else + { + for (int i = 0; i < skillConfig.TipsRatio.Count; i++) + { + Ratio += skillConfig.TipsRatio[i, 0]; + num += skillConfig.TipsRatio[i, 1]; + } + Ratio += num * level; + for (int i = 0; i < skillConfig.TipsFixed.Count; i++) + { + Fixed += skillConfig.TipsFixed[i, 0]; + num2 += skillConfig.TipsFixed[i, 1]; + } + Fixed += num2 * level; + float num3 = 0f; + CombatEffectHelper data = XDataPool.GetData(); + data.Set(skillhash, XSingleton.singleton.Player); + data.GetSkillDamage(out num3); + num3 += XEmblemDocument.GetSkillDamageRatio(EmblemBag, skillhash); + Ratio *= 1f + num3; + data.Recycle(); + result = true; + } + return result; + } + + public SkillLevelupRequest GetLevelupRequest(uint skillHash, uint level) + { + SkillList.RowData skillConfig = this.GetSkillConfig(skillHash, level); + bool flag = skillConfig == null; + SkillLevelupRequest result; + if (flag) + { + result = null; + } + else + { + bool flag2 = this.req == null; + if (flag2) + { + this.req = new SkillLevelupRequest(); + } + bool flag3 = skillConfig.UpReqRoleLevel == null || skillConfig.UpReqRoleLevel.Length == 0; + if (flag3) + { + this.req.Level = 0; + } + else + { + bool flag4 = (ulong)level < (ulong)((long)skillConfig.UpReqRoleLevel.Length); + if (flag4) + { + this.req.Level = (int)skillConfig.UpReqRoleLevel[(int)level]; + } + else + { + this.req.Level = (int)skillConfig.UpReqRoleLevel[skillConfig.UpReqRoleLevel.Length - 1]; + } + } + bool flag5 = this.req.Items == null; + if (flag5) + { + this.req.Items = new List(); + } + else + { + this.req.Items.Clear(); + } + ItemDesc item = default(ItemDesc); + item.ItemID = 5; + bool flag6 = skillConfig.LevelupCost == null || skillConfig.LevelupCost.Length == 0; + if (flag6) + { + item.ItemCount = 0; + } + else + { + bool flag7 = (ulong)level < (ulong)((long)skillConfig.LevelupCost.Length); + if (flag7) + { + item.ItemCount = (int)skillConfig.LevelupCost[(int)level]; + } + else + { + item.ItemCount = (int)skillConfig.LevelupCost[skillConfig.LevelupCost.Length - 1]; + } + } + this.req.Items.Add(item); + result = this.req; + } + return result; + } + + public double GetAttackSpeedRatio(XAttributes attr) + { + return (double)attr.AttackSpeed; + } + + public float GetSkillInitCDRatio(uint skillHash, uint level, uint entityTempID, bool IsPVP, XAttributes attr) + { + SkillList.RowData skillConfig = this.GetSkillConfig(skillHash, level, entityTempID); + bool flag = skillConfig == null; + float result; + if (flag) + { + result = 0f; + } + else + { + float num = 0f; + CombatEffectHelper data = XDataPool.GetData(); + data.Set(skillHash, attr.Entity); + data.GetSkillCD(out num); + data.Recycle(); + bool isPlayer = attr.Entity.IsPlayer; + if (isPlayer) + { + num += XEmblemDocument.GetSkillCDRatio(attr.EmblemBag, skillHash); + } + num += 1f; + if (IsPVP) + { + result = skillConfig.PvPInitCD * num; + } + else + { + result = skillConfig.InitCD * num; + } + } + return result; + } + + public float GetSkillCDDynamicRatio(XAttributes attr) + { + return (float)(attr.GetAttr(XAttributeDefine.XATTR_SKILL_CD_Total) / XSingleton.singleton.GeneralCombatParam); + } + + public float GetSkillCDDynamicRatio(XAttributes attr, uint skillHash) + { + return this.CalcDynamicRatio(this.GetSkillCDDynamicRatio(attr), this.GetSkillCDSemiDynamicRatio(attr, skillHash)); + } + + public float GetSkillCDSemiDynamicRatio(XAttributes attr, uint skillHash) + { + float num = 0f; + CombatEffectHelper data = XDataPool.GetData(); + data.Set(skillHash, attr.Entity); + data.GetSkillCD(out num); + data.Recycle(); + bool isPlayer = attr.Entity.IsPlayer; + if (isPlayer) + { + num += XEmblemDocument.GetSkillCDRatio(attr.EmblemBag, skillHash); + } + return num; + } + + public double GetXULIPower(XEntity entity) + { + bool flag = entity == null || entity.Attributes == null; + double result; + if (flag) + { + result = 1.0; + } + else + { + result = entity.Attributes.GetAttr(XAttributeDefine.XAttr_XULI_Total) / XSingleton.singleton.GeneralCombatParam; + } + return result; + } + + public float CalcDynamicRatio(float dynamicCDRatio, float semiDynamicCDRatio) + { + float num = dynamicCDRatio + semiDynamicCDRatio; + return Mathf.Clamp(num, XSingleton.singleton.CDChangeLowerBound, XSingleton.singleton.CDChangeUpperBound); + } + + public float GetSkillCDStaticRatio(uint skillHash, uint level, uint entityTempID, bool IsPVP) + { + SkillList.RowData skillConfig = this.GetSkillConfig(skillHash, level, entityTempID); + bool flag = skillConfig == null; + float result; + if (flag) + { + result = 1f; + } + else if (IsPVP) + { + bool flag2 = skillConfig.PvPCDRatio[0] == 0f && skillConfig.PvPCDRatio[1] == 0f; + if (flag2) + { + result = 1f; + } + else + { + result = skillConfig.PvPCDRatio[0] + skillConfig.PvPCDRatio[1] * level; + } + } + else + { + bool flag3 = skillConfig.CDRatio[0] == 0f && skillConfig.CDRatio[1] == 0f; + if (flag3) + { + result = 1f; + } + else + { + result = skillConfig.CDRatio[0] + skillConfig.CDRatio[1] * level; + } + } + return result; + } + + public float GetSkillCostMP(uint skillHash, uint level, uint entityTempID) + { + SkillList.RowData skillConfig = this.GetSkillConfig(skillHash, level, entityTempID); + bool flag = skillConfig == null; + float result; + if (flag) + { + result = 0f; + } + else + { + result = skillConfig.CostMP[0] + skillConfig.CostMP[1] * level; + } + return result; + } + + public float GetSkillCostMP(string skillName, uint level, uint entityTempID) + { + uint skillHash = XSingleton.singleton.XHash(skillName); + return this.GetSkillCostMP(skillHash, level, entityTempID); + } + + public SkillStartEffect GetSkillStartEffect(uint skillHash, uint level, XSkillFlags skillFlags, uint entityTempID, bool IsPVP) + { + SkillStartEffect skillStartEffect = default(SkillStartEffect); + skillStartEffect.IncSuperArmor = 0; + skillStartEffect.MpCost = 0.0; + skillStartEffect.Buffs = null; + SkillList.RowData skillConfig = this.GetSkillConfig(skillHash, level, entityTempID); + bool flag = skillConfig == null; + SkillStartEffect result; + if (flag) + { + result = skillStartEffect; + } + else + { + if (IsPVP) + { + skillStartEffect.IncSuperArmor = skillConfig.PvPIncreaseSuperArmor; + } + else + { + skillStartEffect.IncSuperArmor = skillConfig.IncreaseSuperArmor; + } + for (int i = 0; i < skillConfig.StartBuffID.Count; i++) + { + bool flag2 = skillConfig.StartBuffID[i, 0] != 0f && (skillFlags == null || skillFlags.IsFlagSet((uint)skillConfig.StartBuffID[i, 3])); + if (flag2) + { + BuffDesc item; + item.BuffID = (int)skillConfig.StartBuffID[i, 0]; + item.BuffLevel = (int)(((int)skillConfig.StartBuffID[i, 1] == 0) ? level : ((uint)((int)skillConfig.StartBuffID[i, 1]))); + item.DelayTime = skillConfig.StartBuffID[i, 2]; + item.CasterID = 0UL; + item.EffectTime = BuffDesc.DEFAULT_TIME; + bool flag3 = skillStartEffect.Buffs == null; + if (flag3) + { + skillStartEffect.Buffs = new List(); + } + item.SkillID = skillHash; + skillStartEffect.Buffs.Add(item); + } + } + skillStartEffect.MpCost = (double)(skillConfig.CostMP[0] + skillConfig.CostMP[1] * level); + result = skillStartEffect; + } + return result; + } + + public SkillEffect GetSkillEffect(uint skillHash, int hitpoint, uint level, XSkillFlags skillFlags, uint entityTempID, bool IsPVP) + { + SkillEffect skillEffect = this.m_SkillEffect; + skillEffect.DamageElementType = DamageElement.DE_NONE; + skillEffect.PhyRatio = 1.0; + skillEffect.PhyFixed = 0.0; + skillEffect.MagRatio = 1.0; + skillEffect.MagFixed = 0.0; + skillEffect.DecSuperArmor = 0f; + bool flag = skillEffect.Buffs != null; + if (flag) + { + skillEffect.Buffs.Clear(); + } + SkillList.RowData skillConfig = this.GetSkillConfig(skillHash, level, entityTempID); + bool flag2 = skillConfig == null; + SkillEffect result; + if (flag2) + { + result = skillEffect; + } + else + { + skillEffect.DamageElementType = (DamageElement)skillConfig.Element; + if (IsPVP) + { + bool flag3 = hitpoint >= skillConfig.PvPRatio.Count || hitpoint >= skillConfig.PvPFixed.Count || hitpoint >= skillConfig.PvPMagicRatio.Count || hitpoint >= skillConfig.PvPMagicFixed.Count || hitpoint >= skillConfig.PercentDamage.Count; + if (flag3) + { + XSingleton.singleton.AddErrorLog("Error: skill ", skillConfig.SkillScript, " hitpoint ", hitpoint.ToString(), " out of range", null); + return skillEffect; + } + skillEffect.PhyRatio = (double)(skillConfig.PvPRatio[hitpoint, 0] + skillConfig.PvPRatio[hitpoint, 1] * level); + skillEffect.PhyFixed = (double)(skillConfig.PvPFixed[hitpoint, 0] + skillConfig.PvPFixed[hitpoint, 1] * level); + skillEffect.MagRatio = (double)(skillConfig.PvPMagicRatio[hitpoint, 0] + skillConfig.PvPMagicRatio[hitpoint, 1] * level); + skillEffect.MagFixed = (double)(skillConfig.PvPMagicFixed[hitpoint, 0] + skillConfig.PvPMagicFixed[hitpoint, 1] * level); + skillEffect.PercentDamage = (double)(skillConfig.PercentDamage[hitpoint, 0] + skillConfig.PercentDamage[hitpoint, 1] * level); + bool flag4 = skillConfig.PvPDecreaseSuperArmor != null && hitpoint < skillConfig.PvPDecreaseSuperArmor.Length; + if (flag4) + { + skillEffect.DecSuperArmor = skillConfig.PvPDecreaseSuperArmor[hitpoint]; + } + } + else + { + bool flag5 = hitpoint >= skillConfig.PhysicalRatio.Count || hitpoint >= skillConfig.PhysicalFixed.Count || hitpoint >= skillConfig.MagicRatio.Count || hitpoint >= skillConfig.MagicFixed.Count || hitpoint >= skillConfig.PercentDamage.Count; + if (flag5) + { + XSingleton.singleton.AddErrorLog("Error: skill ", skillConfig.SkillScript, " hitpoint ", hitpoint.ToString(), " out of range", null); + return skillEffect; + } + skillEffect.PhyRatio = (double)(skillConfig.PhysicalRatio[hitpoint, 0] + skillConfig.PhysicalRatio[hitpoint, 1] * level); + skillEffect.PhyFixed = (double)(skillConfig.PhysicalFixed[hitpoint, 0] + skillConfig.PhysicalFixed[hitpoint, 1] * level); + skillEffect.MagRatio = (double)(skillConfig.MagicRatio[hitpoint, 0] + skillConfig.MagicRatio[hitpoint, 1] * level); + skillEffect.MagFixed = (double)(skillConfig.MagicFixed[hitpoint, 0] + skillConfig.MagicFixed[hitpoint, 1] * level); + skillEffect.PercentDamage = (double)(skillConfig.PercentDamage[hitpoint, 0] + skillConfig.PercentDamage[hitpoint, 1] * level); + bool flag6 = skillConfig.DecreaseSuperArmor != null && hitpoint < skillConfig.DecreaseSuperArmor.Length; + if (flag6) + { + skillEffect.DecSuperArmor = (float)skillConfig.DecreaseSuperArmor[hitpoint]; + } + } + bool flag7 = skillConfig.AddBuffPoint != null; + if (flag7) + { + for (int i = 0; i < skillConfig.AddBuffPoint.Length; i++) + { + bool flag8 = (int)skillConfig.AddBuffPoint[i] == hitpoint; + if (flag8) + { + bool flag9 = i < skillConfig.BuffID.Count && (skillFlags == null || skillFlags.IsFlagSet((uint)skillConfig.BuffID[i, 2])); + if (flag9) + { + bool flag10 = skillEffect.Buffs == null; + if (flag10) + { + skillEffect.Buffs = new List(); + } + BuffDesc item; + item.BuffID = skillConfig.BuffID[i, 0]; + item.BuffLevel = (int)((skillConfig.BuffID[i, 1] == 0) ? level : ((uint)skillConfig.BuffID[i, 1])); + item.CasterID = 0UL; + item.DelayTime = 0f; + item.EffectTime = BuffDesc.DEFAULT_TIME; + item.SkillID = skillHash; + skillEffect.Buffs.Add(item); + } + else + { + XSingleton.singleton.AddLog("Error: skill ", skillConfig.SkillScript, " index ", i.ToString(), " buff out of range ", skillConfig.BuffID.Count.ToString(), XDebugColor.XDebug_None); + } + } + } + } + skillEffect.ExclusiveMask = 0u; + bool flag11 = skillConfig.ExclusiveMask != null; + if (flag11) + { + for (int j = 0; j < skillConfig.ExclusiveMask.Length; j++) + { + skillEffect.ExclusiveMask |= 1u << (int)skillConfig.ExclusiveMask[j]; + } + } + result = skillEffect; + } + return result; + } + + public List GetProfSkillID(int profID) + { + bool flag = this.ret == null; + if (flag) + { + this.ret = new List(); + } + bool flag2 = this.repeatHash == null; + if (flag2) + { + this.repeatHash = new HashSet(); + } + this.ret.Clear(); + this.repeatHash.Clear(); + for (int i = 0; i < this._skillTable.Table.Length; i++) + { + SkillList.RowData rowData = this._skillTable.Table[i]; + bool flag3 = rowData != null && rowData.Profession == profID && rowData.IsBasicSkill == 0; + if (flag3) + { + bool flag4 = !this.repeatHash.Contains(rowData.SkillScriptHash); + if (flag4) + { + this.ret.Add(rowData.SkillScriptHash); + this.repeatHash.Add(rowData.SkillScriptHash); + } + } + } + return this.ret; + } + + public int GetSkillType(uint skillID) + { + SkillList.RowData skillConfig = this.GetSkillConfig(skillID, 0u); + bool flag = skillConfig != null; + int result; + if (flag) + { + result = (int)skillConfig.SkillType; + } + else + { + result = 0; + } + return result; + } + + public uint GetSkillID(string skillName, uint statisticsID = 0u) + { + uint num = XSingleton.singleton.XHash(skillName); + SkillList.RowData skillConfig = this.GetSkillConfig(num, 0u, statisticsID); + bool flag = skillConfig == null; + uint result; + if (flag) + { + result = 0u; + } + else + { + result = num; + } + return result; + } + + public void SetMobProperty(XEntity mobEntity, XEntity caster, uint skillID) + { + bool flag = mobEntity == null || caster == null || mobEntity.Attributes == null || caster.Attributes == null; + if (!flag) + { + XAttributes attributes = mobEntity.Attributes; + XAttributes attributes2 = caster.Attributes; + attributes.Level = attributes2.Level; + attributes.SetAttr(XAttributeDefine.XAttr_MaxHP_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_MaxHP_Basic)); + attributes.SetAttr(XAttributeDefine.XAttr_CurrentHP_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_MaxHP_Basic)); + attributes.SetAttr(XAttributeDefine.XAttr_PhysicalAtk_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_PhysicalAtk_Basic)); + attributes.SetAttr(XAttributeDefine.XAttr_MagicAtk_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_MagicAtk_Basic)); + attributes.SetAttr(XAttributeDefine.XAttr_PhysicalAtkMod_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_PhysicalAtkMod_Basic)); + attributes.SetAttr(XAttributeDefine.XAttr_MagicAtkMod_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_MagicAtkMod_Basic)); + attributes.SetAttr(XAttributeDefine.XAttr_PhysicalDefMod_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_PhysicalDefMod_Basic)); + attributes.SetAttr(XAttributeDefine.XAttr_MagicDefMod_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_MagicDefMod_Basic)); + attributes.SetAttr(XAttributeDefine.XAttr_Critical_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_Critical_Basic)); + attributes.SetAttr(XAttributeDefine.XAttr_CritDamage_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_CritDamage_Basic)); + attributes.SetAttr(XAttributeDefine.XAttr_CritResist_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_CritResist_Basic)); + attributes.SetAttr(XAttributeDefine.XAttr_FireAtk_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_FireAtk_Basic)); + attributes.SetAttr(XAttributeDefine.XAttr_WaterAtk_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_WaterAtk_Basic)); + attributes.SetAttr(XAttributeDefine.XAttr_LightAtk_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_LightAtk_Basic)); + attributes.SetAttr(XAttributeDefine.XAttr_DarkAtk_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_DarkAtk_Basic)); + attributes.SetAttr(XAttributeDefine.XAttr_FireDef_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_FireDef_Basic)); + attributes.SetAttr(XAttributeDefine.XAttr_WaterDef_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_WaterDef_Basic)); + attributes.SetAttr(XAttributeDefine.XAttr_LightDef_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_LightDef_Basic)); + attributes.SetAttr(XAttributeDefine.XAttr_DarkDef_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_DarkDef_Basic)); + attributes.SetAttr(XAttributeDefine.XAttr_Strength_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_Strength_Basic)); + attributes.SetAttr(XAttributeDefine.XAttr_Agility_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_Agility_Basic)); + attributes.SetAttr(XAttributeDefine.XAttr_Intelligence_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_Intelligence_Basic)); + attributes.SetAttr(XAttributeDefine.XAttr_Vitality_Basic, attributes2.GetAttr(XAttributeDefine.XAttr_Vitality_Basic)); + attributes.SetHost(caster); + uint skillLevel = attributes2.SkillLevelInfo.GetSkillLevel(skillID); + SkillList.RowData skillConfig = this.GetSkillConfig(skillID, skillLevel, caster.SkillCasterTypeID); + bool flag2 = skillConfig == null; + if (!flag2) + { + CombatEffectHelper data = XDataPool.GetData(); + data.Set(skillID, caster); + bool flag3 = (skillConfig == null || skillConfig.MobBuffs == null) && !data.bHasEffect(CombatEffectType.CET_Skill_AddMobBuff); + if (flag3) + { + data.Recycle(); + } + else + { + List list = ListPool.Get(); + bool flag4 = data != null; + if (flag4) + { + data.GetSkillAddMobBuff((int)skillLevel, list); + } + bool flag5 = skillConfig.MobBuffs != null; + if (flag5) + { + for (int i = 0; i < skillConfig.MobBuffs.Length; i++) + { + list.Add(new BuffDesc + { + BuffID = (int)skillConfig.MobBuffs[i], + BuffLevel = (int)skillLevel, + EffectTime = BuffDesc.DEFAULT_TIME + }); + } + } + for (int j = 0; j < list.Count; j++) + { + XBuffAddEventArgs @event = XEventPool.GetEvent(); + @event.xBuffDesc = list[j]; + @event.xBuffDesc.CasterID = mobEntity.ID; + @event.Firer = mobEntity; + XSingleton.singleton.FireEvent(@event); + } + ListPool.Release(list); + data.Recycle(); + } + } + } + } + + public uint GetPreSkill(uint skillID, uint entityTempID) + { + uint num = 0u; + bool flag = entityTempID > 0u; + if (flag) + { + ulong key = (ulong)skillID << 32 | (ulong)entityTempID; + bool flag2 = this._specialEnemyPreSkillDict.TryGetValue(key, out num); + if (flag2) + { + return num; + } + } + bool flag3 = this.PreSkillDict.TryGetValue(skillID, out num); + uint result; + if (flag3) + { + result = num; + } + else + { + result = 0u; + } + return result; + } + + public bool CanChangeCD(uint skillHash, uint skillLevel, uint entityTempID) + { + SkillList.RowData skillConfig = this.GetSkillConfig(skillHash, skillLevel, entityTempID); + bool flag = skillConfig == null; + return !flag && skillConfig.UnchangableCD == 0; + } + + public bool AICantCast(uint skillHash, uint skillLevel, uint entityTempID) + { + SkillList.RowData skillConfig = this.GetSkillConfig(skillHash, skillLevel, entityTempID); + bool flag = skillConfig == null; + return !flag && skillConfig.LinkType == 1; + } + + public float GetRemainingCDNotify(uint skillHash, uint skillLevel, uint entityTempID) + { + SkillList.RowData skillConfig = this.GetSkillConfig(skillHash, skillLevel, entityTempID); + bool flag = skillConfig == null; + float result; + if (flag) + { + result = 0f; + } + else + { + result = skillConfig.RemainingCDNotify; + } + return result; + } + + public int GetStrengthValue(uint skillHash, uint skillLevel, uint entityTempID) + { + SkillList.RowData skillConfig = this.GetSkillConfig(skillHash, skillLevel, entityTempID); + bool flag = skillConfig == null; + int result; + if (flag) + { + result = 0; + } + else + { + result = skillConfig.StrengthValue; + } + return result; + } + + public int GetUsageCount(uint skillHash, uint skillLevel, uint entityTempID) + { + SkillList.RowData skillConfig = this.GetSkillConfig(skillHash, skillLevel, entityTempID); + bool flag = skillConfig == null; + int result; + if (flag) + { + result = 0; + } + else + { + result = (int)skillConfig.UsageCount; + } + return result; + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/Skill/XSkillEffectMgr.cs.meta b/Client/Assets/Scripts/XMainClient/Skill/XSkillEffectMgr.cs.meta new file mode 100644 index 00000000..c73dffcb --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Skill/XSkillEffectMgr.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: c52f8df9c5d21e84eb95592e156c7449 +timeCreated: 1611404505 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/Skill/XSkillExternalArgs.cs b/Client/Assets/Scripts/XMainClient/Skill/XSkillExternalArgs.cs new file mode 100644 index 00000000..f2381522 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Skill/XSkillExternalArgs.cs @@ -0,0 +1,23 @@ +using System; + +namespace XMainClient +{ + internal abstract class XSkillExternalArgs : XEventArgs + { + public SkillExternalCallback callback = null; + + public float delay = 0f; + + public XSkillExternalArgs() + { + this._eDefine = XEventDefine.XEvent_SkillExternal; + } + + public override void Recycle() + { + this.callback = null; + this.delay = 0f; + base.Recycle(); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/Skill/XSkillExternalArgs.cs.meta b/Client/Assets/Scripts/XMainClient/Skill/XSkillExternalArgs.cs.meta new file mode 100644 index 00000000..914c103e --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Skill/XSkillExternalArgs.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: c650231bd2ab189458fb732d68f7a140 +timeCreated: 1611404508 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/Skill/XSkillExternalBuffArgs.cs b/Client/Assets/Scripts/XMainClient/Skill/XSkillExternalBuffArgs.cs new file mode 100644 index 00000000..e1698ce0 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Skill/XSkillExternalBuffArgs.cs @@ -0,0 +1,25 @@ +using System; + +namespace XMainClient +{ + internal class XSkillExternalBuffArgs : XSkillExternalArgs + { + public BuffDesc xBuffDesc = default(BuffDesc); + + public XEntity xTarget; + + public XSkillExternalBuffArgs() + { + this.xBuffDesc.Reset(); + this.xTarget = null; + } + + public override void Recycle() + { + this.xBuffDesc.Reset(); + this.xTarget = null; + base.Recycle(); + XEventPool.Recycle(this); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/Skill/XSkillExternalBuffArgs.cs.meta b/Client/Assets/Scripts/XMainClient/Skill/XSkillExternalBuffArgs.cs.meta new file mode 100644 index 00000000..46c6d485 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Skill/XSkillExternalBuffArgs.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 8476a07a64530f7418e53bd086b80547 +timeCreated: 1611404048 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/Skill/XSkillFactory.cs b/Client/Assets/Scripts/XMainClient/Skill/XSkillFactory.cs new file mode 100644 index 00000000..071f6616 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Skill/XSkillFactory.cs @@ -0,0 +1,294 @@ +using System; +using XUtliPoolLib; + +namespace XMainClient +{ + internal class XSkillFactory : XSingleton + { + private SmallBuffer _skillData; + + private SmallBuffer _skillCache; + + private SmallBuffer _skillMgrCache; + + public void OnSceneLoaded() + { + this._skillData.debugName = "XSkillCorePool._skillData"; + this._skillCache.debugName = "XSkillCorePool._skillCache"; + XSingleton.singleton.GetSmallBuffer(ref this._skillData, 256, 0); + XSingleton.singleton.GetSmallBuffer(ref this._skillCache, 256, 0); + XSingleton.singleton.GetSmallBuffer(ref this._skillMgrCache, 256, 0); + XSingleton.singleton.OnEnterScene(); + } + + public void OnLeaveScene() + { + bool isInit = this._skillData.IsInit; + if (isInit) + { + int i = 0; + int count = this._skillData.Count; + while (i < count) + { + XSkillCore xskillCore = this._skillData[i] as XSkillCore; + bool flag = xskillCore != null; + if (flag) + { + xskillCore.Clear(); + } + i++; + } + } + XSingleton.singleton.ReturnSmallBuffer(ref this._skillData); + XSingleton.singleton.ReturnSmallBuffer(ref this._skillCache); + XSingleton.singleton.ReturnSmallBuffer(ref this._skillMgrCache); + XSingleton.singleton.OnLeaveScene(); + } + + public XSkillCore Build(string skillprefix, string name, XEntity firer) + { + string text = skillprefix + name; + uint num = XSingleton.singleton.XHash(text); + XSkillCore xskillCore = firer.SkillMgr.GetSkill(XSingleton.singleton.XHash(name)); + bool flag = xskillCore != null; + XSkillCore result; + if (flag) + { + result = xskillCore; + } + else + { + int i = 0; + int count = this._skillData.Count; + while (i < count) + { + XSkillCore xskillCore2 = this._skillData[i] as XSkillCore; + bool flag2 = xskillCore2 != null && num == xskillCore2.LongID; + if (flag2) + { + xskillCore2.Recycle(firer); + this._skillData[i] = null; + bool flag3 = XSingleton.singleton.IsPVPScene && !xskillCore2.IsPvPVersion; + if (flag3) + { + bool flag4 = !string.IsNullOrEmpty(xskillCore2.Soul.PVP_Script_Name); + if (flag4) + { + XSkillData data = XSingleton.singleton.GetData(skillprefix + xskillCore2.Soul.PVP_Script_Name, ".txt"); + data.Prefix = skillprefix; + data.Name = xskillCore2.Soul.Name; + xskillCore2.SoulRefine(data, true); + } + } + else + { + bool flag5 = !XSingleton.singleton.IsPVPScene && xskillCore2.IsPvPVersion; + if (flag5) + { + XSkillData data2 = XSingleton.singleton.GetData(skillprefix + xskillCore2.Soul.Name, ".txt"); + data2.Prefix = skillprefix; + xskillCore2.SoulRefine(data2, false); + } + } + return xskillCore2; + } + i++; + } + XSkillData data3 = XSingleton.singleton.GetData(text, ".txt"); + data3.Prefix = skillprefix; + xskillCore = new XSkillCore(firer, data3, num); + bool flag6 = XSingleton.singleton.IsPVPScene && !string.IsNullOrEmpty(xskillCore.Soul.PVP_Script_Name); + if (flag6) + { + XSkillData data4 = XSingleton.singleton.GetData(skillprefix + xskillCore.Soul.PVP_Script_Name, ".txt"); + data4.Prefix = skillprefix; + data4.Name = xskillCore.Soul.Name; + xskillCore.SoulRefine(data4, true); + } + switch (xskillCore.Soul.TypeToken) + { + case 0: + xskillCore.TriggerToken = XSkillData.JA_Command[xskillCore.Soul.SkillPosition]; + break; + case 1: + xskillCore.TriggerToken = "ToArtSkill"; + xskillCore.Soul.Ja = null; + break; + case 2: + xskillCore.TriggerToken = "ToUltraShow"; + xskillCore.Soul.Ja = null; + break; + case 3: + xskillCore.TriggerToken = "ToPhase"; + xskillCore.Soul.Ja = null; + break; + } + bool multipleAttackSupported = xskillCore.Soul.MultipleAttackSupported; + if (multipleAttackSupported) + { + xskillCore.TriggerToken = "ToMultipleDirAttack"; + } + result = xskillCore; + } + return result; + } + + public void Release(XSkillCore core) + { + core.CoolDown(); + core.Uninit(); + int i = 0; + int count = this._skillData.Count; + while (i < count) + { + bool flag = this._skillData[i] == null; + if (flag) + { + this._skillData[i] = core; + return; + } + i++; + } + this._skillData.Add(core); + } + + public void Print() + { + XSingleton.singleton.AddLog("skill core count:", this._skillData.Count.ToString(), null, null, null, null, XDebugColor.XDebug_None); + } + + public string GetTypeName(int token) + { + bool flag = token < XSkillData.Skills.Length; + string result; + if (flag) + { + result = XSkillData.Skills[token]; + } + else + { + result = null; + } + return result; + } + + public int GetTypeHash(int token) + { + int result; + switch (token) + { + case 0: + result = XSkill.XJAComboSkillHash; + break; + case 1: + result = XSkill.XArtsSkillHash; + break; + case 2: + result = XSkill.XUltraSkillHash; + break; + case 3: + result = XSkill.XCombinedSkillHash; + break; + default: + throw new ArgumentException(); + } + return result; + } + + public XSkill CreateSkill(XEntity firer, int token) + { + int i = 0; + int count = this._skillCache.Count; + while (i < count) + { + XSkill xskill = this._skillCache[i] as XSkill; + bool flag = xskill != null && xskill.SkillType == token; + if (flag) + { + this._skillCache[i] = null; + xskill.Initialize(firer); + return xskill; + } + i++; + } + XSkill xskill2; + switch (token) + { + case 0: + xskill2 = new XJAComboSkill(); + break; + case 1: + xskill2 = new XArtsSkill(); + break; + case 2: + xskill2 = new XUltraSkill(); + break; + case 3: + xskill2 = new XCombinedSkill(); + break; + default: + return null; + } + xskill2.Initialize(firer); + return xskill2; + } + + public void ReturnSkill(XSkill skill) + { + int i = 0; + int count = this._skillCache.Count; + while (i < count) + { + bool flag = this._skillCache[i] == null; + if (flag) + { + this._skillCache[i] = skill; + return; + } + i++; + } + this._skillCache.Add(skill); + } + + public XSkillMgr CreateSkillMgr(XEntity entity) + { + int i = 0; + int count = this._skillMgrCache.Count; + while (i < count) + { + XSkillMgr xskillMgr = this._skillMgrCache[i] as XSkillMgr; + bool flag = xskillMgr != null; + if (flag) + { + this._skillMgrCache[i] = null; + xskillMgr.Initialize(entity); + return xskillMgr; + } + i++; + } + return new XSkillMgr(entity); + } + + public void ReturnSkillMgr(XSkillMgr skillMgr) + { + bool flag = skillMgr != null; + if (flag) + { + skillMgr.Uninitialize(); + int i = 0; + int count = this._skillMgrCache.Count; + while (i < count) + { + bool flag2 = this._skillMgrCache[i] == null; + if (flag2) + { + this._skillCache[i] = skillMgr; + return; + } + i++; + } + this._skillMgrCache.Add(skillMgr); + } + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/Skill/XSkillFactory.cs.meta b/Client/Assets/Scripts/XMainClient/Skill/XSkillFactory.cs.meta new file mode 100644 index 00000000..913841ad --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Skill/XSkillFactory.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 9c52eb7e872c5c740b07ea982a8dab8f +timeCreated: 1611404231 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/Skill/XSkillFlags.cs b/Client/Assets/Scripts/XMainClient/Skill/XSkillFlags.cs new file mode 100644 index 00000000..74fb31a2 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Skill/XSkillFlags.cs @@ -0,0 +1,45 @@ +using System; +using System.Collections.Generic; + +namespace XMainClient +{ + internal class XSkillFlags + { + private ulong m_Flag = 1UL; + + public bool IsFlagSet(uint flag) + { + return (this.m_Flag & 1UL << (int)flag) > 0UL; + } + + public void SetFlag(List flags) + { + for (int i = 0; i < flags.Count; i++) + { + this.SetFlag(flags[i]); + } + } + + public void SetFlag(short[] flags) + { + bool flag = flags != null; + if (flag) + { + for (int i = 0; i < flags.Length; i++) + { + this.SetFlag((uint)flags[i]); + } + } + } + + public void SetFlag(uint flag) + { + this.m_Flag |= 1UL << (int)flag; + } + + public void Reset() + { + this.m_Flag = 1UL; + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/Skill/XSkillFlags.cs.meta b/Client/Assets/Scripts/XMainClient/Skill/XSkillFlags.cs.meta new file mode 100644 index 00000000..e11b1287 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Skill/XSkillFlags.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 563bc6c9c0a6b484594d531b186cc494 +timeCreated: 1611403743 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/Skill/XSkillJAPassedEventArgs.cs b/Client/Assets/Scripts/XMainClient/Skill/XSkillJAPassedEventArgs.cs new file mode 100644 index 00000000..aed26dd0 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Skill/XSkillJAPassedEventArgs.cs @@ -0,0 +1,21 @@ +using System; + +namespace XMainClient +{ + internal class XSkillJAPassedEventArgs : XEventArgs + { + public int Slot = -1; + + public XSkillJAPassedEventArgs() + { + this._eDefine = XEventDefine.XEvent_OnJAPassed; + } + + public override void Recycle() + { + this.Slot = -1; + base.Recycle(); + XEventPool.Recycle(this); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/Skill/XSkillJAPassedEventArgs.cs.meta b/Client/Assets/Scripts/XMainClient/Skill/XSkillJAPassedEventArgs.cs.meta new file mode 100644 index 00000000..cf413add --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Skill/XSkillJAPassedEventArgs.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 88ba3167c707a3d458e3f06bf263bd85 +timeCreated: 1611404085 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/Skill/XSkillLevelInfoMgr.cs b/Client/Assets/Scripts/XMainClient/Skill/XSkillLevelInfoMgr.cs new file mode 100644 index 00000000..bb8aa2e4 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Skill/XSkillLevelInfoMgr.cs @@ -0,0 +1,284 @@ +using System; +using System.Collections.Generic; +using KKSG; +using XUtliPoolLib; + +namespace XMainClient +{ + internal class XSkillLevelInfoMgr + { + public XSkillFlags Flags + { + get + { + return this._Flags; + } + } + + public Dictionary LearnedSkills + { + get + { + return this._SkillDicts; + } + } + + public static int AuraSkillType = 4; + + private Dictionary _SkillDicts = new Dictionary(); + + private Dictionary _LinkedLevels = new Dictionary(); + + private uint _DefaultLevel = 1u; + + private XEntity _entity = null; + + private XSkillFlags _Flags = new XSkillFlags(); + + private static List g_SkillsHavingEx = new List(); + + public void SetDefaultLevel(uint level) + { + this._DefaultLevel = level; + } + + public void RemoveSkill(uint skillHash) + { + this._SkillDicts.Remove(skillHash); + } + + public uint GetSkillLevel(uint skillHash) + { + uint num = 0u; + bool flag = XEntity.ValideEntity(this._entity) && this._entity.IsTransform; + uint result; + if (flag) + { + bool canlevelrans = XBattleSkillDocument.m_canlevelrans; + if (canlevelrans) + { + bool flag2 = XBattleSkillDocument.SkillLevelDict.TryGetValue(skillHash, out num); + if (flag2) + { + result = num; + } + else + { + result = 1u; + } + } + else + { + result = 1u; + } + } + else + { + bool flag3 = this._LinkedLevels.TryGetValue(skillHash, out num); + if (flag3) + { + result = num; + } + else + { + result = this.GetSkillOriginalLevel(skillHash); + } + } + return result; + } + + public uint GetSkillOriginalLevel(uint skillHash) + { + uint defaultLevel = this._DefaultLevel; + bool flag = this._SkillDicts.TryGetValue(skillHash, out defaultLevel); + uint result; + if (flag) + { + result = defaultLevel; + } + else + { + result = this._DefaultLevel; + } + return result; + } + + public void SetSkillLevel(uint skillHash, uint skillLevel) + { + bool flag = this._SkillDicts.ContainsKey(skillHash); + if (flag) + { + this._SkillDicts[skillHash] = skillLevel; + } + else + { + this._SkillDicts.Add(skillHash, skillLevel); + } + } + + public void RefreshSkillFlags() + { + this._Flags.Reset(); + foreach (KeyValuePair keyValuePair in this._SkillDicts) + { + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(keyValuePair.Key, keyValuePair.Value); + bool flag = skillConfig != null; + if (flag) + { + this._Flags.SetFlag(skillConfig.Flag); + } + } + } + + public void Init(List skills) + { + this._SkillDicts.Clear(); + for (int i = 0; i < skills.Count; i++) + { + this.SetSkillLevel(skills[i].skillHash, skills[i].skillLevel); + } + this.RefreshSkillFlags(); + } + + public void CaskAuraSkills(XEntity entity) + { + Dictionary.Enumerator enumerator = this._SkillDicts.GetEnumerator(); + while (enumerator.MoveNext()) + { + XSkillEffectMgr singleton = XSingleton.singleton; + KeyValuePair keyValuePair = enumerator.Current; + uint key = keyValuePair.Key; + keyValuePair = enumerator.Current; + SkillList.RowData skillConfig = singleton.GetSkillConfig(key, keyValuePair.Value, entity.SkillCasterTypeID); + bool flag = skillConfig != null && (int)skillConfig.SkillType == XSkillLevelInfoMgr.AuraSkillType; + if (flag) + { + XBuffAddEventArgs @event = XEventPool.GetEvent(); + @event.xBuffDesc.BuffID = skillConfig.AuraBuffID[0]; + XBuffAddEventArgs xbuffAddEventArgs = @event; + int buffLevel; + if (skillConfig.AuraBuffID[1] != 0) + { + buffLevel = skillConfig.AuraBuffID[1]; + } + else + { + keyValuePair = enumerator.Current; + buffLevel = (int)keyValuePair.Value; + } + xbuffAddEventArgs.xBuffDesc.BuffLevel = buffLevel; + @event.Firer = entity; + @event.xBuffDesc.CasterID = entity.ID; + XBuffAddEventArgs xbuffAddEventArgs2 = @event; + keyValuePair = enumerator.Current; + xbuffAddEventArgs2.xBuffDesc.SkillID = keyValuePair.Key; + XSingleton.singleton.FireEvent(@event); + } + } + } + + public void RefreshSelfLinkedLevels(XEntity entity) + { + this._entity = entity; + this._LinkedLevels.Clear(); + bool flag = entity == null || entity.Attributes == null || this._entity.Attributes.skillSlot == null; + if (!flag) + { + foreach (uint num in this._SkillDicts.Keys) + { + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(num, 1u, entity.SkillCasterTypeID); + bool flag2 = skillConfig != null && !string.IsNullOrEmpty(skillConfig.LinkedSkill); + if (flag2) + { + uint skillOriginalLevel = this.GetSkillOriginalLevel(XSingleton.singleton.XHash(skillConfig.LinkedSkill)); + bool flag3 = skillOriginalLevel > 0u; + if (flag3) + { + this._LinkedLevels[num] = skillOriginalLevel; + } + } + } + } + } + + public void RefreshMobLinkedLevels(XEntity entity, XEntity hoster) + { + this._entity = entity; + this._LinkedLevels.Clear(); + bool flag = entity == null || entity.SkillMgr == null || hoster == null || hoster.Attributes == null || hoster.Attributes.SkillLevelInfo == null; + if (!flag) + { + XSkillMgr skillMgr = entity.SkillMgr; + XSkillLevelInfoMgr skillLevelInfo = hoster.Attributes.SkillLevelInfo; + XEntityPresentation.RowData byPresentID = XSingleton.singleton.EntityInfo.GetByPresentID(entity.PresentID); + bool flag2 = byPresentID == null || byPresentID.OtherSkills == null; + if (!flag2) + { + XSkillLevelInfoMgr.g_SkillsHavingEx.Clear(); + for (int i = 0; i < byPresentID.OtherSkills.Length; i++) + { + bool flag3 = string.IsNullOrEmpty(byPresentID.OtherSkills[i]) || byPresentID.OtherSkills[i] == "E"; + if (!flag3) + { + uint num = XSingleton.singleton.XHash(byPresentID.OtherSkills[i]); + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(num, 1u, entity.SkillCasterTypeID); + bool flag4 = skillConfig == null; + if (!flag4) + { + bool flag5 = !string.IsNullOrEmpty(skillConfig.ExSkillScript); + if (flag5) + { + XSkillLevelInfoMgr.g_SkillsHavingEx.Add(skillConfig); + } + else + { + this.SetLinkedLevel(num, skillConfig, skillLevelInfo, entity.SkillCasterTypeID); + } + } + } + } + for (int j = 0; j < XSkillLevelInfoMgr.g_SkillsHavingEx.Count; j++) + { + SkillList.RowData rowData = XSkillLevelInfoMgr.g_SkillsHavingEx[j]; + uint num2 = XSingleton.singleton.XHash(rowData.SkillScript); + bool flag6 = this.GetSkillLevel(XSingleton.singleton.XHash(rowData.ExSkillScript)) > 0u; + if (flag6) + { + this._LinkedLevels[num2] = 0u; + } + else + { + this.SetLinkedLevel(num2, rowData, skillLevelInfo, entity.SkillCasterTypeID); + } + } + } + } + } + + private void SetLinkedLevel(uint skillID, SkillList.RowData rowData, XSkillLevelInfoMgr hosterSkillLevelMgr, uint enemyTempID) + { + bool flag = rowData == null || hosterSkillLevelMgr == null || string.IsNullOrEmpty(rowData.LinkedSkill); + if (!flag) + { + uint skillHash = XSingleton.singleton.XHash(rowData.LinkedSkill); + uint skillLevel = hosterSkillLevelMgr.GetSkillLevel(skillHash); + bool flag2 = skillLevel == 0u; + if (flag2) + { + this._LinkedLevels[skillID] = 0u; + } + else + { + uint val = skillLevel; + uint preSkill = XSingleton.singleton.GetPreSkill(XSingleton.singleton.XHash(rowData.LinkedSkill), enemyTempID); + bool flag3 = preSkill > 0u; + if (flag3) + { + val = hosterSkillLevelMgr.GetSkillLevel(preSkill); + } + this._LinkedLevels[skillID] = Math.Min((uint)rowData.SkillLevel, val); + } + } + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/Skill/XSkillLevelInfoMgr.cs.meta b/Client/Assets/Scripts/XMainClient/Skill/XSkillLevelInfoMgr.cs.meta new file mode 100644 index 00000000..1f1b99e6 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Skill/XSkillLevelInfoMgr.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 4c9cc22e72dd4694f8f5bff066bd614a +timeCreated: 1611403691 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/Skill/XSkillMgr.cs b/Client/Assets/Scripts/XMainClient/Skill/XSkillMgr.cs new file mode 100644 index 00000000..ad8dcde8 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Skill/XSkillMgr.cs @@ -0,0 +1,598 @@ +using System; +using System.Collections.Generic; +using XUtliPoolLib; + +namespace XMainClient +{ + internal sealed class XSkillMgr + { + public int SkillCount + { + get + { + return this._core.Count; + } + } + + public static XSkillMgr.XQTEInfo[] QTEBuffer; + + public static int MaxQTECount = 4; + + private XEntity _host = null; + + private SmallBuffer _physicals; + + private SmallBuffer _carriers; + + private SmallBuffer _core; + + private Dictionary _coreDic = new Dictionary(); + + public SmallBuffer SkillOrder; + + private uint _physical = 0u; + + private uint _ultra = 0u; + + private uint _appear = 0u; + + private uint _disappear = 0u; + + private uint _dash = 0u; + + private uint _recovery = 0u; + + private uint _broken = 0u; + + internal struct XQTEInfo + { + public int key; + + public uint skill; + + public XQTEInfo(int rkey, uint rskill) + { + this.key = rkey; + this.skill = rskill; + } + + public void Empty() + { + this.key = 0; + this.skill = 0u; + } + } + + public XSkillMgr(XEntity entity) + { + this.Initialize(entity); + } + + public XSkillCore GetSkillCore(int index) + { + return this._core[index] as XSkillCore; + } + + private bool TryGetSkillCore(uint id, out XSkillCore s) + { + return this._coreDic.TryGetValue(id, out s); + } + + private bool ContainSkillCore(uint id) + { + return this._coreDic.ContainsKey(id); + } + + public void Initialize(XEntity entity) + { + this._host = entity; + this._physicals.debugName = "XSkillMgr._physicals"; + this._carriers.debugName = "XSkillMgr._carriers"; + this.SkillOrder.debugName = "XSkillMgr.SkillOrder"; + XSingleton.singleton.GetSmallBuffer(ref this._physicals, 16, 0); + XSingleton.singleton.GetSmallBuffer(ref this._carriers, 4, 0); + int i = 0; + int num = XSkillData.Skills.Length; + while (i < num) + { + this._carriers.Add(null); + i++; + } + XSingleton.singleton.GetSmallBuffer(ref this._core, 16, 0); + XSingleton.singleton.GetSmallBuffer(ref this.SkillOrder, 16, 0); + } + + public void Uninitialize() + { + XSingleton.singleton.ReturnSmallBuffer(ref this._physicals); + XSingleton.singleton.ReturnSmallBuffer(ref this.SkillOrder); + int i = 0; + int count = this._carriers.Count; + while (i < count) + { + XSkill xskill = this._carriers[i] as XSkill; + bool flag = xskill != null; + if (flag) + { + xskill.Uninitialize(); + XSingleton.singleton.ReturnSkill(xskill); + } + i++; + } + this._carriers.Clear(); + int j = 0; + int count2 = this._core.Count; + while (j < count2) + { + XSkillCore xskillCore = this._core[j] as XSkillCore; + bool flag2 = xskillCore != null; + if (flag2) + { + XSingleton.singleton.Release(xskillCore); + } + j++; + } + this._core.Clear(); + this._coreDic.Clear(); + this._physical = 0u; + this._ultra = 0u; + this._appear = 0u; + this._disappear = 0u; + this._dash = 0u; + this._recovery = 0u; + this._broken = 0u; + } + + public void AttachPhysicalSkill(XSkillCore core) + { + this._physical = core.ID; + this.AttachSkill(core, true); + } + + public void AttachAppearSkill(XSkillCore core) + { + this._appear = core.ID; + this.AttachSkill(core, false); + } + + public void AttachDisappearSkill(XSkillCore core) + { + this._disappear = core.ID; + this.AttachSkill(core, false); + } + + public void AttachUltraSkill(XSkillCore core) + { + this._ultra = core.ID; + this.AttachSkill(core, true); + } + + public void AttachRecoverySkill(XSkillCore core) + { + this._recovery = core.ID; + this.AttachSkill(core, false); + } + + public void AttachBrokenSkill(XSkillCore core) + { + this._broken = core.ID; + this.AttachSkill(core, false); + } + + public void AttachDashSkill(XSkillCore core) + { + this._dash = core.ID; + this.AttachSkill(core, true); + } + + public void AttachSkill(XSkillCore core, bool inorder = true) + { + bool flag = !this.ContainSkillCore(core.ID); + if (flag) + { + bool flag2 = this._host.Attributes != null; + if (flag2) + { + bool flag3 = core.Level > 0u; + if (flag3) + { + this.SkillBuildIn(core, inorder); + } + else + { + bool preLoad = XSkillData.PreLoad; + XSkillData.PreLoad = false; + bool isSkillReplaced = this._host.Skill.IsSkillReplaced; + if (isSkillReplaced) + { + this.SkillBuildIn(core, inorder); + } + XSkillData.PreLoad = preLoad; + } + } + else + { + this._core.Add(core); + this._coreDic.Add(core.ID, core); + bool flag4 = core.Soul.TypeToken == 3; + if (flag4) + { + for (int i = 0; i < core.Soul.Combined.Count; i++) + { + XSkillCore xskillCore = XSingleton.singleton.Build(this._host.IsTransform ? this._host.Transformer.Present.SkillPrefix : this._host.Present.SkillPrefix, core.Soul.Combined[i].Name, this._host); + bool flag5 = !this.ContainSkillCore(xskillCore.ID); + if (flag5) + { + this._core.Add(xskillCore); + this._coreDic.Add(xskillCore.ID, xskillCore); + } + } + } + bool flag6 = core.Soul.TypeToken < this._carriers.Count; + if (flag6) + { + bool flag7 = this._carriers[core.Soul.TypeToken] == null; + if (flag7) + { + this._carriers[core.Soul.TypeToken] = XSingleton.singleton.CreateSkill(this._host, core.Soul.TypeToken); + } + } + } + } + } + + public void DetachSkill(uint id) + { + XSkillCore item = null; + bool flag = this.TryGetSkillCore(id, out item); + if (flag) + { + bool flag2 = id == this._physical; + if (flag2) + { + this._physical = 0u; + } + bool flag3 = id == this._ultra; + if (flag3) + { + this._ultra = 0u; + } + bool flag4 = id == this._appear; + if (flag4) + { + this._appear = 0u; + } + bool flag5 = id == this._disappear; + if (flag5) + { + this._disappear = 0u; + } + this.SkillOrder.Remove(item); + this._core.Remove(id); + this._coreDic.Remove(id); + this._physicals.Remove(id); + } + } + + public XSkill GetCarrier(int id) + { + XSkill xskill = null; + bool flag = id < this._carriers.Count; + if (flag) + { + xskill = (this._carriers[id] as XSkill); + bool flag2 = xskill == null; + if (flag2) + { + xskill = XSingleton.singleton.CreateSkill(this._host, id); + this._carriers[id] = xskill; + } + } + bool flag3 = xskill == null; + if (flag3) + { + XSingleton.singleton.AddErrorLog("Invalid carrier id: ", id.ToString(), null, null, null, null); + } + return xskill; + } + + public XSkillCore GetPhysicalSkill() + { + return this.GetSkill(this._physical); + } + + public XSkillCore GetDashSkill() + { + return this.GetSkill(this._dash); + } + + public XSkillCore GetSkill(uint id) + { + XSkillCore result = null; + this.TryGetSkillCore(id, out result); + return result; + } + + public uint GetPhysicalIdentity() + { + return this._physical; + } + + public bool IsPhysicalAttack(uint id) + { + return this._physicals.Contains(id); + } + + public uint GetUltraIdentity() + { + return this._ultra; + } + + public uint GetAppearIdentity() + { + return this._appear; + } + + public uint GetDisappearIdentity() + { + return this._disappear; + } + + public uint GetDashIdentity() + { + return this._dash; + } + + public uint GetRecoveryIdentity() + { + return this._recovery; + } + + public uint GetBrokenIdentity() + { + return this._broken; + } + + public bool IsCooledDown(XSkillCore skill) + { + return skill.CooledDown; + } + + public bool IsCooledDown(uint id) + { + return this.IsCooledDown(this.GetSkill(id)); + } + + public bool IsQTESkill(uint id) + { + XSkillCore skill = this.GetSkill(id); + return skill != null && skill.Soul.Logical.CanCastAt_QTE > 0; + } + + public float GetCD(uint id) + { + XSkillCore skill = this.GetSkill(id); + return (skill != null) ? skill.GetCoolDown() : 0f; + } + + public static float GetCD(XEntity entity, string name, uint skillLevel = 0u) + { + XSkillData data = XSingleton.singleton.GetData(XSingleton.singleton.StringCombine(entity.Present.SkillPrefix, name), ".txt"); + data.Prefix = entity.Present.SkillPrefix; + uint skillHash = XSingleton.singleton.XHash(data.Name); + bool flag = skillLevel == 0u; + if (flag) + { + skillLevel = ((entity.Attributes == null) ? 1u : entity.Attributes.SkillLevelInfo.GetSkillLevel(XSingleton.singleton.XHash(data.Name))); + bool flag2 = skillLevel == 0u; + if (flag2) + { + skillLevel = 1u; + } + } + float num = (data != null) ? (XSingleton.singleton.GetSkillCDStaticRatio(skillHash, skillLevel, entity.SkillCasterTypeID, XSingleton.singleton.IsPVPScene) * data.CoolDown) : 0f; + return entity.IsPlayer ? (num * XSingleton.singleton.GetSkillCDDynamicRatio(entity.Attributes, skillHash)) : num; + } + + public void CoolDown(uint id) + { + XSkillCore skill = this.GetSkill(id); + bool flag = skill != null; + if (flag) + { + skill.CoolDown(); + } + } + + public void ResetStaticCD(uint id) + { + XSkillCore skill = this.GetSkill(id); + bool flag = skill != null; + if (flag) + { + skill.ResetStaticCD(); + } + } + + public void AccelerateStaticCD(uint id, float delta) + { + XSkillCore skill = this.GetSkill(id); + bool flag = skill != null; + if (flag) + { + skill.AccelerateStaticCD(delta); + } + } + + public void Accelerate(uint id, float delta, bool ratio) + { + XSkillCore skill = this.GetSkill(id); + bool flag = skill != null; + if (flag) + { + skill.AccelerateCD(delta, ratio); + } + } + + public float GetCastRangeUpper(uint id) + { + XSkillCore skill = this.GetSkill(id); + return skill.CastRangeUpper; + } + + public float GetCastRangeLower(uint id) + { + XSkillCore skill = this.GetSkill(id); + return skill.CastRangeLower; + } + + public float GetCastScope(uint id) + { + XSkillCore skill = this.GetSkill(id); + return skill.CastScope; + } + + public float GetElapsedCD(uint id) + { + XSkillCore skill = this.GetSkill(id); + bool flag = skill == null; + float result; + if (flag) + { + result = 0f; + } + else + { + result = skill.GetElapsedCD(); + } + return result; + } + + public float GetMPCost(uint id) + { + float result = float.PositiveInfinity; + bool flag = this.GetSkill(id) != null; + if (flag) + { + XAttributes attributes = this._host.Attributes; + uint skillLevel = attributes.SkillLevelInfo.GetSkillLevel(id); + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(id, skillLevel, this._host.SkillCasterTypeID); + bool flag2 = skillConfig != null; + if (flag2) + { + result = skillConfig.CostMP[0] + skillConfig.CostMP[1] * skillLevel; + } + } + return result; + } + + public void StatisticsPhysicalSkill() + { + this._physicals.Clear(); + XSkillCore xskillCore = this.GetPhysicalSkill(); + while (xskillCore != null) + { + this._physicals.Add(xskillCore.ID); + bool flag = xskillCore.Soul.Logical.Association && !string.IsNullOrEmpty(xskillCore.Soul.Logical.Association_Skill); + if (flag) + { + this._physicals.Add(XSingleton.singleton.XHash(xskillCore.Soul.Logical.Association_Skill)); + } + bool flag2 = xskillCore.Soul.Ja != null && xskillCore.Soul.Ja.Count > 0; + if (flag2) + { + uint num = XSingleton.singleton.XHash(xskillCore.Soul.Ja[0].Name); + bool flag3 = num > 0u; + if (flag3) + { + this._physicals.Add(num); + } + xskillCore = this.GetSkill(num); + } + else + { + xskillCore = null; + } + } + } + + public int GetQTE(uint id, out XSkillMgr.XQTEInfo[] qteList) + { + bool flag = XSkillMgr.QTEBuffer == null; + if (flag) + { + XSkillMgr.QTEBuffer = new XSkillMgr.XQTEInfo[XSkillMgr.MaxQTECount]; + } + qteList = XSkillMgr.QTEBuffer; + int num = 0; + int i = 0; + int count = this._core.Count; + while (i < count) + { + XSkillCore xskillCore = this._core[i] as XSkillCore; + bool flag2 = xskillCore != null && (1 << (int)id & xskillCore.Soul.Logical.CanCastAt_QTE) > 0; + if (flag2) + { + XSkillMgr.XQTEInfo xqteinfo = default(XSkillMgr.XQTEInfo); + xqteinfo.skill = xskillCore.ID; + xqteinfo.key = xskillCore.Soul.Logical.QTE_Key; + qteList[num++] = xqteinfo; + bool flag3 = num == 4; + if (flag3) + { + return num; + } + } + i++; + } + return num; + } + + private void SkillBuildIn(XSkillCore core, bool inorder) + { + bool preLoad = XSkillData.PreLoad; + if (preLoad) + { + XSkillData.PreLoadSkillRes(core.Soul, 1); + } + this._core.Add(core); + this._coreDic.Add(core.ID, core); + if (inorder) + { + bool flag = core.ID != this._physical; + if (flag) + { + this.SkillOrder.Add(core); + } + } + bool flag2 = core.Soul.TypeToken == 3; + if (flag2) + { + for (int i = 0; i < core.Soul.Combined.Count; i++) + { + XSkillCore xskillCore = XSingleton.singleton.Build(core.Soul.Prefix, core.Soul.Combined[i].Name, this._host); + bool flag3 = !this.ContainSkillCore(xskillCore.ID); + if (flag3) + { + bool preLoad2 = XSkillData.PreLoad; + if (preLoad2) + { + XSkillData.PreLoadSkillRes(xskillCore.Soul, 1); + } + this._core.Add(xskillCore); + this._coreDic.Add(xskillCore.ID, xskillCore); + } + } + } + bool flag4 = core.Soul.TypeToken < this._carriers.Count; + if (flag4) + { + bool flag5 = this._carriers[core.Soul.TypeToken] == null; + if (flag5) + { + this._carriers[core.Soul.TypeToken] = XSingleton.singleton.CreateSkill(this._host, core.Soul.TypeToken); + } + } + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/Skill/XSkillMgr.cs.meta b/Client/Assets/Scripts/XMainClient/Skill/XSkillMgr.cs.meta new file mode 100644 index 00000000..dd15b0ab --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Skill/XSkillMgr.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 0266b2121816ed049b83a1ea5699344c +timeCreated: 1611402956 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/Skill/XSkillPreViewMgr.cs b/Client/Assets/Scripts/XMainClient/Skill/XSkillPreViewMgr.cs new file mode 100644 index 00000000..770210d0 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Skill/XSkillPreViewMgr.cs @@ -0,0 +1,100 @@ +using System; +using UnityEngine; +using XUtliPoolLib; + +namespace XMainClient +{ + internal class XSkillPreViewMgr : XSingleton + { + public Camera BlackHouseCamera; + + public GameObject BlackHouse; + + public void GetSkillBlackHouse(ref GameObject blackHouse, ref Camera blackHouseCamera) + { + bool flag = this.BlackHouse == null; + if (flag) + { + this.BlackHouse = (XSingleton.singleton.CreateFromPrefab("Common/SkillBlackHouse", true, false) as GameObject); + this.BlackHouseCamera = this.BlackHouse.transform.Find("BasePoint/Camera").GetComponent(); + this.BlackHouseCamera.enabled = false; + } + blackHouse = this.BlackHouse; + blackHouseCamera = this.BlackHouseCamera; + } + + public void ResetDummyPos(XDummy dummy) + { + bool flag = dummy == null; + if (!flag) + { + Transform transform = this.BlackHouse.transform.Find(string.Format("BasePoint", new object[0])); + bool flag2 = transform != null; + if (flag2) + { + bool flag3 = dummy.EngineObject == null; + if (flag3) + { + XSingleton.singleton.AddErrorLog("Dummy is null!!!", null, null, null, null, null); + return; + } + dummy.EngineObject.Position = transform.position; + dummy.EngineObject.SetParentTrans(transform.transform); + dummy.EngineObject.SetLocalPRS(Vector3.zero, true, Quaternion.identity, true, Vector3.one, true); + } + bool flag4 = dummy.Buffs == null; + if (flag4) + { + XSingleton.singleton.AddErrorLog("Dummy Buffs is null!!!", null, null, null, null, null); + } + else + { + dummy.Buffs.ClearBuff(); + dummy.Buffs.ClearBuffFx(); + } + } + } + + public void ShowSkill(XDummy dummy, uint skillID, uint statisticsID = 0u) + { + this.ResetDummyPos(dummy); + bool flag = dummy.Audio != null; + if (flag) + { + dummy.Audio.Set3DPos(XSingleton.singleton.GameCamera.CameraTrans.position); + } + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(skillID, 0u, statisticsID); + string name = (skillConfig.PreviewScript == "") ? skillConfig.SkillScript : skillConfig.PreviewScript; + XAttackShowArgs @event = XEventPool.GetEvent(); + @event.name = name; + @event.Firer = dummy; + XSingleton.singleton.FireEvent(@event); + } + + public void SkillShowBegin(XDummy dummy, Camera camera) + { + bool flag = dummy == null; + if (!flag) + { + this.ResetDummyPos(dummy); + bool flag2 = dummy.Audio != null; + if (flag2) + { + dummy.Audio.Set3DPos(XSingleton.singleton.GameCamera.CameraTrans.position); + } + XAttackShowBeginArgs @event = XEventPool.GetEvent(); + @event.Firer = dummy; + @event.XCamera = camera.transform.gameObject; + XSingleton.singleton.FireEvent(@event); + } + } + + public void SkillShowEnd(XDummy dummy) + { + XAttackShowEndArgs @event = XEventPool.GetEvent(); + @event.ForceQuit = true; + @event.Firer = dummy; + XSingleton.singleton.FireEvent(@event); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/Skill/XSkillPreViewMgr.cs.meta b/Client/Assets/Scripts/XMainClient/Skill/XSkillPreViewMgr.cs.meta new file mode 100644 index 00000000..65b33015 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Skill/XSkillPreViewMgr.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 3084c89d83932d740b04117e56ce0872 +timeCreated: 1611403522 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/Skill/XSkillQTEEventArgs.cs b/Client/Assets/Scripts/XMainClient/Skill/XSkillQTEEventArgs.cs new file mode 100644 index 00000000..58f735b3 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Skill/XSkillQTEEventArgs.cs @@ -0,0 +1,24 @@ +using System; + +namespace XMainClient +{ + internal class XSkillQTEEventArgs : XEventArgs + { + public uint State = 0u; + + public bool On = false; + + public XSkillQTEEventArgs() + { + this._eDefine = XEventDefine.XEvent_QTE; + } + + public override void Recycle() + { + base.Recycle(); + this.State = 0u; + this.On = false; + XEventPool.Recycle(this); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/Skill/XSkillQTEEventArgs.cs.meta b/Client/Assets/Scripts/XMainClient/Skill/XSkillQTEEventArgs.cs.meta new file mode 100644 index 00000000..dd4d8234 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Skill/XSkillQTEEventArgs.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: acb7dc4513050ee4ebf92a88cf97c652 +timeCreated: 1611404332 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/Skill/XSkillTreeBehaviour.cs b/Client/Assets/Scripts/XMainClient/Skill/XSkillTreeBehaviour.cs new file mode 100644 index 00000000..0b2bba3e --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Skill/XSkillTreeBehaviour.cs @@ -0,0 +1,161 @@ +using System; +using UILib; +using UnityEngine; +using XMainClient.UI.UICommon; +using XUtliPoolLib; + +namespace XMainClient +{ + internal class XSkillTreeBehaviour : DlgBehaviourBase + { + public IXUIButton m_Close; + + public GameObject m_TransferFrame; + + public GameObject m_SkillTreeFrame; + + public IXUISprite m_ResetProBtn; + + public IXUISprite m_ResetSkillBtn; + + public IXUISprite m_SwitchSkillPageBtn; + + public IXUILabel m_SkillPageText; + + public IXUILabel m_UseSkillPoint; + + public IXUILabel m_UseAwakeSkillPoint; + + public IXUILabel m_LeftSkillPoint; + + public IXUILabel m_FreeResetSkillTip; + + public IXUIScrollView m_SkillTreeScrollView; + + public XUIPool m_SkillPool = new XUIPool(XSingleton.singleton.m_uiTool); + + public XUIPool m_ArrowPool = new XUIPool(XSingleton.singleton.m_uiTool); + + public GameObject m_LevelUpFx; + + public IXUITweenTool m_CatchFrameTween; + + public IXUITweenTool m_DetailFrameTween; + + public IXUIButton m_CatchBackBtn; + + public IXUIButton m_ChooseBtn; + + public IXUIButton m_LearnBtn; + + public IXUISprite m_SkillPlayBtn; + + public GameObject m_SkillLearnRedPoint; + + public GameObject m_NonPreView; + + public IXUITexture m_Snapshot; + + public IXUISprite[] m_SkillSlotList = new IXUISprite[XSkillTreeDocument.SkillSlotCount]; + + public IXUIScrollView m_SkillDetailScrollView; + + public Transform DetailSkillFrame; + + public IXUILabel m_SkillName_L; + + public IXUILabel m_SkillType_L; + + public IXUILabel m_SkillAttrText; + + public IXUILabel m_SkillCostText; + + public IXUILabel m_SkillCDText; + + public IXUILabel m_SkillDetail_L; + + public IXUILabel m_SkillCurrDesc; + + public IXUILabel m_SkillPreSkillPointTips; + + public IXUILabel m_SkillNextDesc; + + public IXUILabel m_SkillNextReq; + + public IXUILabel m_SuperIndureAttack; + + public IXUILabel m_SuperIndureDenfense; + + public IXUILabel m_SkillName_S; + + public IXUILabel m_SkillType_S; + + public IXUILabel m_SkillDetail_S; + + public IXUIScrollView m_SkillDetailScrollView_S; + + public IXUILabel m_ChooseTips; + + public Transform m_FxFirework; + + public XUIPool m_Tabs = new XUIPool(XSingleton.singleton.m_uiTool); + + private void Awake() + { + this.m_Close = (base.transform.Find("Bg/Close").GetComponent("XUIButton") as IXUIButton); + this.m_TransferFrame = base.transform.Find("Bg/TransferFrame").gameObject; + this.m_SkillTreeFrame = base.transform.Find("Bg/SkillTreeFrame").gameObject; + this.m_FreeResetSkillTip = (this.m_SkillTreeFrame.transform.Find("Other/ResetTip").GetComponent("XUILabel") as IXUILabel); + this.m_UseSkillPoint = (this.m_SkillTreeFrame.transform.Find("Other/UsePoint").GetComponent("XUILabel") as IXUILabel); + this.m_UseAwakeSkillPoint = (this.m_SkillTreeFrame.transform.Find("Other/UseAwakePoint").GetComponent("XUILabel") as IXUILabel); + this.m_LeftSkillPoint = (this.m_SkillTreeFrame.transform.Find("Other/LeftPoint").GetComponent("XUILabel") as IXUILabel); + this.m_ResetProBtn = (this.m_SkillTreeFrame.transform.Find("Other/ResetProf").GetComponent("XUISprite") as IXUISprite); + this.m_ResetSkillBtn = (this.m_SkillTreeFrame.transform.Find("Other/ResetSkillPoint").GetComponent("XUISprite") as IXUISprite); + this.m_SwitchSkillPageBtn = (this.m_SkillTreeFrame.transform.Find("Other/SwitchSkillPage").GetComponent("XUISprite") as IXUISprite); + this.m_SkillPageText = (this.m_SkillTreeFrame.transform.Find("Other/SwitchSkillPage/Text").GetComponent("XUILabel") as IXUILabel); + Transform transform = base.transform.Find("Bg/Tabs/Tpl"); + this.m_Tabs.SetupPool(transform.parent.gameObject, transform.gameObject, 3u, false); + transform = this.m_SkillTreeFrame.transform.Find("SkillTree/Skill/SkillTpl"); + this.m_SkillPool.SetupPool(transform.parent.gameObject, transform.gameObject, 16u, false); + transform = this.m_SkillTreeFrame.transform.Find("SkillTree/Arrow/ArrowTpl"); + this.m_ArrowPool.SetupPool(transform.parent.gameObject, transform.gameObject, 16u, false); + this.m_SkillTreeScrollView = (this.m_SkillTreeFrame.transform.Find("SkillTree").GetComponent("XUIScrollView") as IXUIScrollView); + this.m_LevelUpFx = this.m_SkillTreeFrame.transform.Find("SkillTree/effect").gameObject; + this.m_LevelUpFx.SetActive(false); + this.m_CatchFrameTween = (this.m_SkillTreeFrame.transform.Find("CatchWindow").GetComponent("XUIPlayTween") as IXUITweenTool); + this.m_DetailFrameTween = (this.m_SkillTreeFrame.transform.Find("DetailWindow").GetComponent("XUIPlayTween") as IXUITweenTool); + this.m_ChooseBtn = (this.m_SkillTreeFrame.transform.Find("DetailWindow/DetailSkillBg/CatchButton").GetComponent("XUIButton") as IXUIButton); + this.m_LearnBtn = (this.m_SkillTreeFrame.transform.Find("DetailWindow/DetailSkillBg/LearnButton").GetComponent("XUIButton") as IXUIButton); + this.m_CatchBackBtn = (this.m_SkillTreeFrame.transform.Find("CatchWindow/BackButton").GetComponent("XUIButton") as IXUIButton); + this.m_SkillPlayBtn = (this.m_SkillTreeFrame.transform.Find("DetailWindow/DetailSkillBg/Snapshot/Play").GetComponent("XUISprite") as IXUISprite); + this.m_SkillLearnRedPoint = this.m_LearnBtn.gameObject.transform.Find("RedPoint").gameObject; + this.m_NonPreView = this.m_SkillTreeFrame.transform.Find("DetailWindow/DetailSkillBg/NonPreView").gameObject; + this.m_Snapshot = (this.m_SkillTreeFrame.transform.Find("DetailWindow/DetailSkillBg/Snapshot").GetComponent("XUITexture") as IXUITexture); + for (int i = 0; i < XSkillTreeDocument.SkillSlotCount; i++) + { + this.m_SkillSlotList[i] = (this.m_SkillTreeFrame.transform.Find(string.Format("CatchWindow/BaseSkill/Skill{0}", i)).GetComponent("XUISprite") as IXUISprite); + this.m_SkillSlotList[i].ID = (ulong)((long)i); + } + this.DetailSkillFrame = this.m_SkillTreeFrame.transform.Find("DetailWindow/DetailSkillBg"); + this.m_SkillDetailScrollView = (this.DetailSkillFrame.Find("DetailSkill").GetComponent("XUIScrollView") as IXUIScrollView); + this.m_SkillName_L = (this.DetailSkillFrame.Find("Name").GetComponent("XUILabel") as IXUILabel); + this.m_SkillType_L = (this.DetailSkillFrame.Find("Name/Type").GetComponent("XUILabel") as IXUILabel); + this.m_SkillAttrText = (this.DetailSkillFrame.Find("Attr/AttrT").GetComponent("XUILabel") as IXUILabel); + this.m_SkillCostText = (this.DetailSkillFrame.Find("Attr/CostT").GetComponent("XUILabel") as IXUILabel); + this.m_SkillCDText = (this.DetailSkillFrame.Find("Attr/CDT").GetComponent("XUILabel") as IXUILabel); + this.m_SkillDetail_L = (this.DetailSkillFrame.Find("DetailSkill/Detail/SkillDetail").GetComponent("XUILabel") as IXUILabel); + this.m_SkillCurrDesc = (this.DetailSkillFrame.Find("DetailSkill/Current/CurDesc").GetComponent("XUILabel") as IXUILabel); + this.m_SkillPreSkillPointTips = (this.DetailSkillFrame.Find("DetailSkill/Current/UnLearn").GetComponent("XUILabel") as IXUILabel); + this.m_SkillNextDesc = (this.DetailSkillFrame.Find("DetailSkill/Next/NextDesc").GetComponent("XUILabel") as IXUILabel); + this.m_SkillNextReq = (this.DetailSkillFrame.Find("DetailSkill/Next/RequieLevel").GetComponent("XUILabel") as IXUILabel); + this.m_SuperIndureAttack = (this.DetailSkillFrame.Find("DetailSkill/Indure/Attack/T").GetComponent("XUILabel") as IXUILabel); + this.m_SuperIndureDenfense = (this.DetailSkillFrame.Find("DetailSkill/Indure/Defense/T").GetComponent("XUILabel") as IXUILabel); + this.m_SkillName_S = (this.m_SkillTreeFrame.transform.Find("CatchWindow/Name").GetComponent("XUILabel") as IXUILabel); + this.m_SkillType_S = (this.m_SkillTreeFrame.transform.Find("CatchWindow/Name/Type").GetComponent("XUILabel") as IXUILabel); + this.m_SkillDetailScrollView_S = (this.m_SkillTreeFrame.transform.Find("CatchWindow/DragBox/ScrollView").GetComponent("XUIScrollView") as IXUIScrollView); + this.m_SkillDetail_S = (this.m_SkillTreeFrame.transform.Find("CatchWindow/DragBox/ScrollView/SkillDetail").GetComponent("XUILabel") as IXUILabel); + this.m_ChooseTips = (this.m_SkillTreeFrame.transform.Find("CatchWindow/Tips").GetComponent("XUILabel") as IXUILabel); + this.m_FxFirework = base.transform.Find("Bg/FxFirework"); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/Skill/XSkillTreeBehaviour.cs.meta b/Client/Assets/Scripts/XMainClient/Skill/XSkillTreeBehaviour.cs.meta new file mode 100644 index 00000000..abbcbfc6 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Skill/XSkillTreeBehaviour.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 23cca7004a4429c4e8e7cefd6523af59 +timeCreated: 1611403457 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/Skill/XSkillTreeDocument.cs b/Client/Assets/Scripts/XMainClient/Skill/XSkillTreeDocument.cs new file mode 100644 index 00000000..cf51d34f --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Skill/XSkillTreeDocument.cs @@ -0,0 +1,1295 @@ +using System; +using System.Collections.Generic; +using KKSG; +using UnityEngine; +using XMainClient.UI; +using XMainClient.UI.UICommon; +using XUtliPoolLib; + +namespace XMainClient +{ + internal class XSkillTreeDocument : XDocComponent + { + public override uint ID + { + get + { + return XSkillTreeDocument.uuID; + } + } + + public XDummy Dummy { get; set; } + + public static int SkillSlotCount + { + get + { + return 11; + } + } + + public XPlayer Player { get; set; } + + public uint CurrentSkillID { get; set; } + + public int TotalSkillPoint { get; set; } + + public int TotalAwakeSkillPoint { get; set; } + + public bool RedPoint { get; set; } + + public bool IsAwakeSkillSlotOpen + { + get + { + return 1 == XSingleton.singleton.GetInt("AwakeSkillSlotOpen"); + } + } + + public bool IsSelfAwaked + { + get + { + return XSingleton.singleton.XPlayerData.TypeID / 1000u > 0u; + } + } + + public static int AwakeSkillSlot + { + get + { + return XFastEnumIntEqualityComparer.ToInt(XSkillSlot.Awake_Attack); + } + } + + public new static readonly uint uuID = XSingleton.singleton.XHash("SkillTreeDocument"); + + public static XTableAsyncLoader AsyncLoader = new XTableAsyncLoader(); + + private static SkillTreeConfigTable _skillTreeConfig = new SkillTreeConfigTable(); + + public Camera BlackHouseCamera; + + public GameObject BlackHouse; + + public readonly uint UNSELECT = 0u; + + public Dictionary NewSkillDic = new Dictionary(); + + private List _slot_unlock_level = new List(); + + public List TransferLimit = new List(); + + public readonly int TRANSFERNUM = 4; + + private RenderTexture skillPreView; + + public List TurnProTaskIDList = new List(); + + public List NpcID = new List(); + + public int SkillPageOpenLevel; + + public override void OnAttachToHost(XObject host) + { + base.OnAttachToHost(host); + this.NewSkillDic.Clear(); + this.GetSlotUnLockLevel(); + this.GetSkillInfo(); + } + + public static void Execute(OnLoadedCallback callback = null) + { + XSkillTreeDocument.AsyncLoader.AddTask("Table/SkillTreeConfig", XSkillTreeDocument._skillTreeConfig, false); + XSkillTreeDocument.AsyncLoader.Execute(callback); + } + + protected override void EventSubscribe() + { + base.EventSubscribe(); + base.RegisterEvent(XEventDefine.XEvent_AttackShowEnd, new XComponent.XEventHandler(this.SkillPlayFinished)); + base.RegisterEvent(XEventDefine.XEvent_VirtualItemChanged, new XComponent.XEventHandler(this.SkillPointChanged)); + base.RegisterEvent(XEventDefine.XEvent_TaskStateChange, new XComponent.XEventHandler(this.IsTurnProTaskFinish)); + base.RegisterEvent(XEventDefine.XEvent_PlayerLevelChange, new XComponent.XEventHandler(this.OnPlayerLevelChange)); + } + + public override void OnEnterSceneFinally() + { + base.OnEnterScene(); + this.Player = XSingleton.singleton.Player; + uint sceneID = XSingleton.singleton.SceneID; + this.Dummy = null; + bool flag = XSingleton.singleton.CurrentStage.Stage == EXStage.Hall; + if (flag) + { + this.CalSkillPointTotalCount(); + this.RefreshRedPoint(); + } + } + + private void GetSlotUnLockLevel() + { + string[] array = XSingleton.singleton.GetValue("SkillSlotUnlockLevel").Split(XGlobalConfig.ListSeparator); + for (int i = 0; i < array.Length; i++) + { + this._slot_unlock_level.Add(uint.Parse(array[i])); + } + } + + private void GetSkillInfo() + { + this.TransferLimit.Add(0u); + for (int i = 1; i < this.TRANSFERNUM; i++) + { + this.TransferLimit.Add((uint)XSingleton.singleton.GetInt(string.Format("Promote{0}", i))); + } + this.TurnProTaskIDList = XSingleton.singleton.GetIntList("ChangeProTaskIds"); + this.NpcID = XSingleton.singleton.GetIntList("ChangeProNpc"); + this.SkillPageOpenLevel = XSingleton.singleton.GetInt("SkillPageNewOpen"); + } + + public uint GetSkillSlotUnLockLevel(int slotid) + { + bool flag = slotid >= this._slot_unlock_level.Count; + uint result; + if (flag) + { + result = 0u; + } + else + { + result = this._slot_unlock_level[slotid]; + } + return result; + } + + public SkillTypeEnum GetSkillSlotType(int slotid) + { + bool flag = (2 <= slotid && 6 >= slotid) || 10 == slotid; + SkillTypeEnum result; + if (flag) + { + result = SkillTypeEnum.Skill_Normal; + } + else + { + bool flag2 = 9 == slotid; + if (flag2) + { + result = SkillTypeEnum.Skill_Big; + } + else + { + bool flag3 = 7 <= slotid && 8 >= slotid; + if (flag3) + { + result = SkillTypeEnum.Skill_Buff; + } + else + { + result = SkillTypeEnum.Skill_None; + } + } + } + return result; + } + + public void SetNewSkillDic() + { + int num = XFastEnumIntEqualityComparer.ToInt(XSingleton.singleton.XPlayerData.Profession); + int num2 = num % 10; + int num3 = (num > 10) ? (num % 100) : 0; + int num4 = (num > 100) ? (num % 1000) : 0; + bool flag = num2 > 0; + if (flag) + { + List profSkillID = XSingleton.singleton.GetProfSkillID(num2); + for (int i = 0; i < profSkillID.Count; i++) + { + uint skillOriginalLevel = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(profSkillID[i]); + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(profSkillID[i], skillOriginalLevel); + bool flag2 = this.CheckRedPoint(profSkillID[i]); + if (flag2) + { + bool flag3 = !this.NewSkillDic.ContainsKey(profSkillID[i]); + if (flag3) + { + this.NewSkillDic.Add(profSkillID[i], false); + } + } + bool flag4 = this.CheckNew(profSkillID[i]); + if (flag4) + { + bool flag5 = !this.NewSkillDic.ContainsKey(profSkillID[i]); + if (flag5) + { + this.NewSkillDic.Add(profSkillID[i], false); + } + } + } + } + bool flag6 = num3 > 0; + if (flag6) + { + List profSkillID2 = XSingleton.singleton.GetProfSkillID(num3); + for (int j = 0; j < profSkillID2.Count; j++) + { + uint skillOriginalLevel2 = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(profSkillID2[j]); + SkillList.RowData skillConfig2 = XSingleton.singleton.GetSkillConfig(profSkillID2[j], skillOriginalLevel2); + bool flag7 = this.CheckRedPoint(profSkillID2[j]); + if (flag7) + { + bool flag8 = !this.NewSkillDic.ContainsKey(profSkillID2[j]); + if (flag8) + { + this.NewSkillDic.Add(profSkillID2[j], false); + } + } + bool flag9 = this.CheckNew(profSkillID2[j]); + if (flag9) + { + bool flag10 = !this.NewSkillDic.ContainsKey(profSkillID2[j]); + if (flag10) + { + this.NewSkillDic.Add(profSkillID2[j], false); + } + } + } + } + bool flag11 = num4 > 0; + if (flag11) + { + List profSkillID3 = XSingleton.singleton.GetProfSkillID(num4); + for (int k = 0; k < profSkillID3.Count; k++) + { + uint skillOriginalLevel3 = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(profSkillID3[k]); + SkillList.RowData skillConfig3 = XSingleton.singleton.GetSkillConfig(profSkillID3[k], skillOriginalLevel3); + bool flag12 = this.CheckRedPoint(profSkillID3[k]); + if (flag12) + { + bool flag13 = !this.NewSkillDic.ContainsKey(profSkillID3[k]); + if (flag13) + { + this.NewSkillDic.Add(profSkillID3[k], false); + } + } + bool flag14 = this.CheckNew(profSkillID3[k]); + if (flag14) + { + bool flag15 = !this.NewSkillDic.ContainsKey(profSkillID3[k]); + if (flag15) + { + this.NewSkillDic.Add(profSkillID3[k], false); + } + } + } + } + } + + public bool CanSkillLevelUp(uint skillID, uint skillLevel, int addLevel = 0) + { + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(skillID, 0u); + bool flag = skillLevel != 0u && XSingleton.singleton.GetPreSkill(skillID, 0u) > 0u; + bool result; + if (flag) + { + result = false; + } + else + { + SkillLevelupRequest levelupRequest = XSingleton.singleton.GetLevelupRequest(skillID, skillLevel + (uint)addLevel); + bool flag2 = (ulong)skillLevel >= (ulong)((long)XSingleton.singleton.GetSkillMaxLevel(skillID, 0u)); + if (flag2) + { + result = false; + } + else + { + bool flag3 = (ulong)XSingleton.singleton.XPlayerData.Level < (ulong)((long)levelupRequest.Level); + result = !flag3; + } + } + return result; + } + + public bool SkillIsEquip(uint skillID) + { + uint num = skillID; + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(skillID, 0u); + bool flag = skillConfig.ExSkillScript != "" && XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(skillID) > 0u; + if (flag) + { + num = XSingleton.singleton.GetSkillID(skillConfig.ExSkillScript, 0u); + } + for (int i = 0; i < XSingleton.singleton.XPlayerData.skillSlot.Length; i++) + { + bool flag2 = XSingleton.singleton.XPlayerData.skillSlot[i] == skillID || XSingleton.singleton.XPlayerData.skillSlot[i] == num; + if (flag2) + { + return true; + } + } + return false; + } + + public void SendResetSkill() + { + RpcC2G_ResetSkill rpcC2G_ResetSkill = new RpcC2G_ResetSkill(); + rpcC2G_ResetSkill.oArg.resetType = ResetType.RESET_SKILL; + XSingleton.singleton.Send(rpcC2G_ResetSkill); + } + + public void SendSkillLevelup() + { + RpcC2G_SkillLevelup rpcC2G_SkillLevelup = new RpcC2G_SkillLevelup(); + rpcC2G_SkillLevelup.oArg.skillHash = this.CurrentSkillID; + XSingleton.singleton.Send(rpcC2G_SkillLevelup); + } + + public void SendResetProf() + { + RpcC2G_ResetSkill rpcC2G_ResetSkill = new RpcC2G_ResetSkill(); + rpcC2G_ResetSkill.oArg.resetType = ResetType.RESET_PROFESSION; + XSingleton.singleton.Send(rpcC2G_ResetSkill); + } + + public void SendBindSkill(uint skillID, uint slot) + { + RpcC2G_BindSkill rpcC2G_BindSkill = new RpcC2G_BindSkill(); + rpcC2G_BindSkill.oArg.skillhash = skillID; + rpcC2G_BindSkill.oArg.slot = (int)slot; + XSingleton.singleton.Send(rpcC2G_BindSkill); + } + + public void QuerySwitchSkillPage() + { + RpcC2G_ChangeSkillSet rpcC2G_ChangeSkillSet = new RpcC2G_ChangeSkillSet(); + rpcC2G_ChangeSkillSet.oArg.index = 1u - XSingleton.singleton.XPlayerData.SkillPageIndex; + XSingleton.singleton.Send(rpcC2G_ChangeSkillSet); + } + + public void OnSwitchSkillPageSuccess(uint index, SkillRecord data) + { + XSingleton.singleton.ShowSystemTip(XStringDefineProxy.GetString("SwitchSkillPageSuccess"), "fece00"); + XSingleton.singleton.XPlayerData.SkillPageIndex = index; + XSingleton.singleton.XPlayerData.skillSlot = ((index == 0u) ? data.SkillSlot.ToArray() : data.SkillSlotTwo.ToArray()); + XSingleton.singleton.XPlayerData.SkillLevelInfo.Init((index == 0u) ? data.Skills : data.SkillsTwo); + this.CalSkillPointTotalCount(); + this.SkillRefresh(false, true); + } + + public bool SkillPlayFinished(XEventArgs args) + { + bool flag = !DlgBase.singleton.IsVisible(); + bool result; + if (flag) + { + result = false; + } + else + { + DlgBase.singleton.uiBehaviour.m_SkillPlayBtn.SetVisible(true); + bool flag2 = DlgBase.singleton._skillDlgPromoteHandler.IsVisible(); + if (flag2) + { + DlgBase.singleton._skillDlgPromoteHandler.m_PlayBtn.SetVisible(true); + } + result = true; + } + return result; + } + + public bool SkillPointChanged(XEventArgs args) + { + bool flag = XSingleton.singleton.XPlayerData == null; + bool result; + if (flag) + { + result = false; + } + else + { + XVirtualItemChangedEventArgs xvirtualItemChangedEventArgs = args as XVirtualItemChangedEventArgs; + ItemEnum itemID = (ItemEnum)xvirtualItemChangedEventArgs.itemID; + bool flag2 = XSingleton.singleton.XPlayerData.SkillPageIndex == 0u; + if (flag2) + { + bool flag3 = itemID != ItemEnum.SKILL_POINT && itemID != ItemEnum.AWAKE_SKILL_POINT; + if (flag3) + { + return true; + } + } + else + { + bool flag4 = itemID != ItemEnum.SKILL_POINT_TWO && itemID != ItemEnum.AWAKE_SKILL_POINT_TWO; + if (flag4) + { + return true; + } + } + this.RefreshRedPoint(); + this.CalSkillPointTotalCount(); + bool flag5 = DlgBase.singleton.IsVisible(); + if (flag5) + { + DlgBase.singleton.CalAllTabRedPoint(); + } + result = true; + } + return result; + } + + public bool IsTurnProTaskFinish(XEventArgs args) + { + bool flag = XSingleton.singleton.CurrentStage.Stage != EXStage.Hall; + bool result; + if (flag) + { + result = false; + } + else + { + XTaskStatusChangeArgs xtaskStatusChangeArgs = args as XTaskStatusChangeArgs; + bool flag2 = xtaskStatusChangeArgs.status != TaskStatus.TaskStatus_Over; + if (flag2) + { + result = false; + } + else + { + for (int i = 0; i < this.TurnProTaskIDList.Count; i++) + { + bool flag3 = xtaskStatusChangeArgs.id == (uint)this.TurnProTaskIDList[i]; + if (flag3) + { + uint num = XSingleton.singleton.XPlayerData.TypeID; + for (int j = 0; j < 5; j++) + { + num /= 10u; + bool flag4 = num == 0u; + if (flag4) + { + DlgBase.singleton.LastSelectPromote = j + 1; + bool flag5 = j + 1 == XSkillTreeView.AwakeIndex; + if (flag5) + { + this.AwakeTaskFinish(); + } + else + { + DlgBase.singleton.SetVisibleWithAnimation(true, null); + } + return true; + } + } + } + } + result = false; + } + } + return result; + } + + private void AwakeTaskFinish() + { + XSingleton.singleton.CreateAndPlay("Effects/FX_Particle/Roles/Lzg_Ty/Ty_juexing", XSingleton.singleton.Player.EngineObject, Vector3.zero, Vector3.one, 1f, false, 3f, true); + uint num = 1u; + for (int i = 0; i < XSkillTreeView.AwakeIndex; i++) + { + num *= 10u; + } + uint key = num + XSingleton.singleton.XPlayerData.TypeID; + ProfessionTable.RowData byProfID = XSingleton.singleton.RoleInfo.GetByProfID(key); + bool flag = byProfID == null; + if (flag) + { + XSingleton.singleton.AddErrorLog("ProfessionTable config not found: profID = ", key.ToString(), null, null, null, null); + } + else + { + uint awakeHair = byProfID.AwakeHair; + XFashionStorageDocument specificDocument = XDocuments.GetSpecificDocument(XFashionStorageDocument.uuID); + bool flag2 = XFashionDocument.IsTargetPart((int)awakeHair, FashionPosition.Hair); + if (flag2) + { + specificDocument.CheckMutuexHair((int)awakeHair); + RpcC2G_UseItem rpcC2G_UseItem = new RpcC2G_UseItem(); + rpcC2G_UseItem.oArg.OpType = ItemUseMgr.GetItemUseValue(ItemUse.FashionDisplayWear); + rpcC2G_UseItem.oArg.itemID = awakeHair; + XSingleton.singleton.Send(rpcC2G_UseItem); + } + } + } + + public static bool IsAvengerTaskDone(int prof) + { + XTaskDocument specificDocument = XDocuments.GetSpecificDocument(XTaskDocument.uuID); + uint avengerTaskID = XSkillTreeDocument.GetAvengerTaskID(prof); + return specificDocument.TaskRecord.IsTaskFinished(avengerTaskID); + } + + private static uint GetAvengerTaskID(int prof) + { + List intList = XSingleton.singleton.GetIntList("AvengerProTaskIds"); + bool flag = intList != null && intList.Count > 0; + uint result; + if (flag) + { + int num = 0; + bool flag2 = prof / 100 > 0; + if (flag2) + { + num = 1; + } + bool flag3 = prof / 1000 > 0; + if (flag3) + { + num = 2; + } + uint num2 = (uint)((num < intList.Count) ? intList[num] : 0); + result = num2; + } + else + { + result = 0u; + } + return result; + } + + private bool OnPlayerLevelChange(XEventArgs args) + { + this.RefreshRedPoint(); + return true; + } + + public void SkillRefresh(bool resetTabs = false, bool resetPosition = true) + { + this.RefreshRedPoint(); + bool flag = !DlgBase.singleton.IsVisible(); + if (!flag) + { + bool isPromoteHandlerShow = DlgBase.singleton.IsPromoteHandlerShow; + if (isPromoteHandlerShow) + { + DlgBase.singleton._skillDlgPromoteHandler.SetVisible(false); + DlgBase.singleton.IsPromoteHandlerShow = false; + } + if (resetTabs) + { + DlgBase.singleton.SetupTabs(); + } + DlgBase.singleton.Refresh(DlgBase.singleton.LastSelectPromote, resetTabs, resetPosition); + DlgBase.singleton.CalAllTabRedPoint(); + } + } + + public void OnSkillLevelUp(uint skillID) + { + bool flag = !DlgBase.singleton.IsVisible(); + if (!flag) + { + uint skillOriginalLevel = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(skillID); + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(skillID, 0u); + DlgBase.singleton.OnSkillLevelUp((int)skillConfig.XPostion, (int)skillConfig.YPostion); + bool flag2 = skillOriginalLevel == 1u && skillConfig.SkillType == 2; + if (flag2) + { + int num = XFastEnumIntEqualityComparer.ToInt(XSkillSlot.Ultra_Attack); + bool flag3 = XSingleton.singleton.XPlayerData.skillSlot[num] == 0u; + if (flag3) + { + this.SendBindSkill(this.CurrentSkillID, (uint)num); + } + } + } + } + + public int CheckPreSkillLevel(uint skillID) + { + uint skillOriginalLevel = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(skillID); + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(skillID, skillOriginalLevel); + uint skillID2 = XSingleton.singleton.GetSkillID(skillConfig.PreSkill, 0u); + uint skillOriginalLevel2 = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(skillID2); + bool flag = skillID2 == 0u; + int result; + if (flag) + { + result = -1; + } + else + { + result = (int)skillOriginalLevel2; + } + return result; + } + + public bool CheckFx(uint skillID) + { + uint skillOriginalLevel = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(skillID); + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(skillID, skillOriginalLevel); + uint skillID2 = XSingleton.singleton.GetSkillID(skillConfig.PreSkill, 0u); + uint skillOriginalLevel2 = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(skillID2); + bool flag = skillOriginalLevel >= (uint)skillConfig.SkillLevel; + bool result; + if (flag) + { + result = false; + } + else + { + bool flag2 = !this.CanSkillLevelUp(skillID, skillOriginalLevel, 0); + if (flag2) + { + result = false; + } + else + { + bool isAwake = skillConfig.IsAwake; + int num = (int)skillConfig.LevelupCost[(int)Math.Min((long)((ulong)skillOriginalLevel), (long)(skillConfig.LevelupCost.Length - 1))]; + bool flag3 = num > (int)XSingleton.singleton.Doc.XBagDoc.GetSkillPointCount(isAwake); + if (flag3) + { + result = false; + } + else + { + bool flag4 = skillID2 != 0u && skillOriginalLevel2 == 0u; + if (flag4) + { + result = false; + } + else + { + int num2 = (isAwake ? this.TotalAwakeSkillPoint : this.TotalSkillPoint) - (int)XSingleton.singleton.Doc.XBagDoc.GetSkillPointCount(isAwake); + bool flag5 = num2 < (int)skillConfig.PreSkillPoint; + result = !flag5; + } + } + } + } + return result; + } + + public bool CheckNew(uint skillID) + { + uint skillOriginalLevel = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(skillID); + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(skillID, skillOriginalLevel); + uint skillID2 = XSingleton.singleton.GetSkillID(skillConfig.PreSkill, 0u); + uint skillOriginalLevel2 = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(skillID2); + bool flag = skillOriginalLevel > 0u; + bool result; + if (flag) + { + result = false; + } + else + { + bool flag2 = this.NewSkillDic.ContainsKey(skillID); + if (flag2) + { + result = this.NewSkillDic[skillID]; + } + else + { + bool flag3 = !this.CanSkillLevelUp(skillID, skillOriginalLevel, 0); + if (flag3) + { + result = false; + } + else + { + bool flag4 = skillID2 != 0u && skillOriginalLevel2 == 0u; + if (flag4) + { + result = false; + } + else + { + bool isAwake = skillConfig.IsAwake; + int num = (isAwake ? this.TotalAwakeSkillPoint : this.TotalSkillPoint) - (int)XSingleton.singleton.Doc.XBagDoc.GetSkillPointCount(isAwake); + bool flag5 = num < (int)skillConfig.PreSkillPoint; + result = !flag5; + } + } + } + } + return result; + } + + public bool CheckLevelUpButton() + { + return this.CheckLevelUpButton(this.CurrentSkillID); + } + + public bool CheckLevelUpButton(uint skillID) + { + uint skillOriginalLevel = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(skillID); + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(skillID, skillOriginalLevel); + uint skillID2 = XSingleton.singleton.GetSkillID(skillConfig.PreSkill, 0u); + uint skillOriginalLevel2 = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(skillID2); + bool flag = !this.CanSkillLevelUp(skillID, skillOriginalLevel, 0); + bool result; + if (flag) + { + result = false; + } + else + { + bool isAwake = skillConfig.IsAwake; + int num = (int)skillConfig.LevelupCost[(int)Math.Min((long)((ulong)skillOriginalLevel), (long)(skillConfig.LevelupCost.Length - 1))]; + bool flag2 = num > (int)XSingleton.singleton.Doc.XBagDoc.GetSkillPointCount(isAwake); + if (flag2) + { + result = false; + } + else + { + bool flag3 = skillID2 != 0u && skillOriginalLevel2 == 0u; + if (flag3) + { + result = false; + } + else + { + int num2 = (isAwake ? this.TotalAwakeSkillPoint : this.TotalSkillPoint) - (int)XSingleton.singleton.Doc.XBagDoc.GetSkillPointCount(isAwake); + bool flag4 = num2 < (int)skillConfig.PreSkillPoint; + result = !flag4; + } + } + } + return result; + } + + public bool CheckRedPoint(uint skillID) + { + SkillTreeConfigTable.RowData byLevel = XSkillTreeDocument._skillTreeConfig.GetByLevel(XSingleton.singleton.XPlayerData.Level); + bool flag = byLevel == null; + bool result; + if (flag) + { + XSingleton.singleton.AddErrorLog("Can't find skill tree show redpoint num level config from SkillTreeConfigTable, level = ", XSingleton.singleton.XPlayerData.Level.ToString(), null, null, null, null); + result = false; + } + else + { + uint skillOriginalLevel = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(skillID); + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(skillID, skillOriginalLevel); + bool isAwake = skillConfig.IsAwake; + bool flag2 = XSingleton.singleton.Doc.XBagDoc.GetSkillPointCount(isAwake) < (ulong)byLevel.RedPointShowNum; + if (flag2) + { + result = false; + } + else + { + uint skillID2 = XSingleton.singleton.GetSkillID(skillConfig.PreSkill, 0u); + uint skillOriginalLevel2 = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(skillID2); + bool flag3 = skillOriginalLevel >= (uint)skillConfig.SkillLevel; + if (flag3) + { + result = false; + } + else + { + SkillTypeEnum skillType = (SkillTypeEnum)skillConfig.SkillType; + bool flag4 = !this.IsExSkill(skillConfig); + if (flag4) + { + bool flag5 = skillOriginalLevel != 0u && (skillType == SkillTypeEnum.Skill_Normal || skillType == SkillTypeEnum.Skill_Big || skillType == SkillTypeEnum.Skill_Buff) && !this.SkillIsEquip(skillID); + if (flag5) + { + return false; + } + } + bool flag6 = !this.CanSkillLevelUp(skillID, skillOriginalLevel, 0); + if (flag6) + { + result = false; + } + else + { + int num = (int)skillConfig.LevelupCost[(int)Math.Min((long)((ulong)skillOriginalLevel), (long)(skillConfig.LevelupCost.Length - 1))]; + bool flag7 = num > (int)XSingleton.singleton.Doc.XBagDoc.GetSkillPointCount(isAwake); + if (flag7) + { + result = false; + } + else + { + bool flag8 = skillID2 != 0u && skillOriginalLevel2 == 0u; + if (flag8) + { + result = false; + } + else + { + int num2 = (isAwake ? this.TotalAwakeSkillPoint : this.TotalSkillPoint) - (int)XSingleton.singleton.Doc.XBagDoc.GetSkillPointCount(isAwake); + bool flag9 = num2 < (int)skillConfig.PreSkillPoint; + result = !flag9; + } + } + } + } + } + } + return result; + } + + public void RefreshRedPoint() + { + int num = XFastEnumIntEqualityComparer.ToInt(XSingleton.singleton.XPlayerData.Profession); + int num2 = num % 10; + int num3 = (num > 10) ? (num % 100) : 0; + int num4 = (num > 100) ? (num % 1000) : 0; + int num5 = (num > 1000) ? (num % 10000) : 0; + this.RedPoint = false; + bool flag = num2 > 0; + if (flag) + { + List profSkillID = XSingleton.singleton.GetProfSkillID(num2); + for (int i = 0; i < profSkillID.Count; i++) + { + uint skillOriginalLevel = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(profSkillID[i]); + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(profSkillID[i], skillOriginalLevel); + bool flag2 = this.CheckRedPoint(profSkillID[i]); + if (flag2) + { + this.RedPoint = true; + break; + } + } + } + bool flag3 = num3 > 0 && !this.RedPoint; + if (flag3) + { + List profSkillID2 = XSingleton.singleton.GetProfSkillID(num3); + for (int j = 0; j < profSkillID2.Count; j++) + { + uint skillOriginalLevel2 = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(profSkillID2[j]); + SkillList.RowData skillConfig2 = XSingleton.singleton.GetSkillConfig(profSkillID2[j], skillOriginalLevel2); + bool flag4 = this.CheckRedPoint(profSkillID2[j]); + if (flag4) + { + this.RedPoint = true; + break; + } + } + } + bool flag5 = num4 > 0 && !this.RedPoint; + if (flag5) + { + List profSkillID3 = XSingleton.singleton.GetProfSkillID(num4); + for (int k = 0; k < profSkillID3.Count; k++) + { + uint skillOriginalLevel3 = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(profSkillID3[k]); + SkillList.RowData skillConfig3 = XSingleton.singleton.GetSkillConfig(profSkillID3[k], skillOriginalLevel3); + bool flag6 = this.CheckRedPoint(profSkillID3[k]); + if (flag6) + { + this.RedPoint = true; + break; + } + } + } + bool flag7 = num5 > 0 && !this.RedPoint; + if (flag7) + { + List profSkillID4 = XSingleton.singleton.GetProfSkillID(num5); + for (int l = 0; l < profSkillID4.Count; l++) + { + uint skillOriginalLevel4 = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(profSkillID4[l]); + SkillList.RowData skillConfig4 = XSingleton.singleton.GetSkillConfig(profSkillID4[l], skillOriginalLevel4); + bool flag8 = this.CheckRedPoint(profSkillID4[l]); + if (flag8) + { + this.RedPoint = true; + break; + } + } + } + XSingleton.singleton.RecalculateRedPointState(XSysDefine.XSys_Skill, true); + } + + public void CalSkillPointTotalCount() + { + int num = XFastEnumIntEqualityComparer.ToInt(XSingleton.singleton.XPlayerData.Profession); + int num2 = num % 10; + int num3 = (num > 10) ? (num % 100) : 0; + int num4 = (num > 100) ? (num % 1000) : 0; + int num5 = (num > 1000) ? (num % 10000) : 0; + this.TotalSkillPoint = (int)XSingleton.singleton.Doc.XBagDoc.GetSkillPointCount(false); + this.TotalAwakeSkillPoint = (int)XSingleton.singleton.Doc.XBagDoc.GetSkillPointCount(true); + bool flag = num2 > 0; + if (flag) + { + List profSkillID = XSingleton.singleton.GetProfSkillID(num2); + for (int i = 0; i < profSkillID.Count; i++) + { + uint skillOriginalLevel = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(profSkillID[i]); + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(profSkillID[i], skillOriginalLevel); + int num6 = 0; + while ((long)num6 < (long)((ulong)skillOriginalLevel)) + { + this.TotalSkillPoint += (int)skillConfig.LevelupCost[Math.Min(num6, skillConfig.LevelupCost.Length - 1)]; + num6++; + } + } + } + bool flag2 = num3 > 0; + if (flag2) + { + List profSkillID2 = XSingleton.singleton.GetProfSkillID(num3); + for (int j = 0; j < profSkillID2.Count; j++) + { + uint skillOriginalLevel2 = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(profSkillID2[j]); + SkillList.RowData skillConfig2 = XSingleton.singleton.GetSkillConfig(profSkillID2[j], skillOriginalLevel2); + int num7 = 0; + while ((long)num7 < (long)((ulong)skillOriginalLevel2)) + { + this.TotalSkillPoint += (int)skillConfig2.LevelupCost[Math.Min(num7, skillConfig2.LevelupCost.Length - 1)]; + num7++; + } + } + } + bool flag3 = num4 > 0; + if (flag3) + { + List profSkillID3 = XSingleton.singleton.GetProfSkillID(num4); + for (int k = 0; k < profSkillID3.Count; k++) + { + uint skillOriginalLevel3 = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(profSkillID3[k]); + SkillList.RowData skillConfig3 = XSingleton.singleton.GetSkillConfig(profSkillID3[k], skillOriginalLevel3); + int num8 = 0; + while ((long)num8 < (long)((ulong)skillOriginalLevel3)) + { + this.TotalSkillPoint += (int)skillConfig3.LevelupCost[Math.Min(num8, skillConfig3.LevelupCost.Length - 1)]; + num8++; + } + } + } + bool flag4 = num5 > 0; + if (flag4) + { + List profSkillID4 = XSingleton.singleton.GetProfSkillID(num5); + for (int l = 0; l < profSkillID4.Count; l++) + { + uint skillOriginalLevel4 = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(profSkillID4[l]); + SkillList.RowData skillConfig4 = XSingleton.singleton.GetSkillConfig(profSkillID4[l], skillOriginalLevel4); + int num9 = 0; + while ((long)num9 < (long)((ulong)skillOriginalLevel4)) + { + bool isAwake = skillConfig4.IsAwake; + if (isAwake) + { + this.TotalAwakeSkillPoint += (int)skillConfig4.LevelupCost[Math.Min(num9, skillConfig4.LevelupCost.Length - 1)]; + } + else + { + this.TotalSkillPoint += (int)skillConfig4.LevelupCost[Math.Min(num9, skillConfig4.LevelupCost.Length - 1)]; + } + num9++; + } + } + } + } + + protected override void OnReconnected(XReconnectedEventArgs arg) + { + this.SkillRefresh(false, true); + } + + public void CreateSkillBlackHouse() + { + bool flag = this.BlackHouse == null; + if (flag) + { + XSingleton.singleton.GetSkillBlackHouse(ref this.BlackHouse, ref this.BlackHouseCamera); + this.BlackHouseCamera.enabled = false; + } + bool flag2 = this.Dummy == null || this.Dummy.Deprecated; + if (flag2) + { + this.CreateDummy(); + } + } + + private void CreateDummy() + { + XOutlookData outlook = XSingleton.singleton.XPlayerData.Outlook; + this.Dummy = XSingleton.singleton.CreateDummy(XSingleton.singleton.XPlayerData.PresentID, XSingleton.singleton.XPlayerData.TypeID, outlook, true, true, true); + bool flag = this.Dummy == null; + if (flag) + { + XSingleton.singleton.AddErrorLog("Dummy Creat Fail.", null, null, null, null, null); + } + else + { + this.Dummy.OverrideAnimClip("Idle", XSingleton.singleton.Player.Present.PresentLib.AttackIdle, true, false); + XSingleton.singleton.ResetDummyPos(this.Dummy); + } + } + + public void DelDummy() + { + bool flag = this.Dummy != null; + if (flag) + { + XSingleton.singleton.SkillShowEnd(this.Dummy); + XSingleton.singleton.DestroyEntity(this.Dummy); + } + } + + public void SetSkillPreviewTexture(RenderTexture rt) + { + this.skillPreView = rt; + bool flag = this.BlackHouseCamera != null; + if (flag) + { + this.BlackHouseCamera.targetTexture = rt; + } + } + + public void CreateAndPlayFxFxFirework() + { + bool flag = DlgBase.singleton.IsVisible(); + if (flag) + { + DlgBase.singleton.CreateAndPlayFxFxFirework(); + } + } + + public bool IsExSkill(SkillList.RowData data) + { + return XSingleton.singleton.GetPreSkill(XSingleton.singleton.XHash(data.SkillScript), 0u) > 0u; + } + + public bool isTutorialNeed(int promote, int index) + { + int[] array = new int[] + { + 1, + 10, + 100, + 1000 + }; + int profID = (int)(XSingleton.singleton.XPlayerData.TypeID % (uint)array[promote + 1]); + List profSkillID = XSingleton.singleton.GetProfSkillID(profID); + List list = new List(); + for (int i = 0; i < profSkillID.Count; i++) + { + SkillTreeSortItem skillTreeSortItem = new SkillTreeSortItem(); + skillTreeSortItem.skillID = profSkillID[i]; + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(profSkillID[i], 0u); + skillTreeSortItem.x = (int)skillConfig.XPostion; + skillTreeSortItem.y = (int)skillConfig.YPostion; + list.Add(skillTreeSortItem); + } + list.Sort(new Comparison(this.Compare)); + return XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(list[index - 1].skillID) == 0u; + } + + private int Compare(SkillTreeSortItem x, SkillTreeSortItem y) + { + bool flag = x.skillID == y.skillID; + int result; + if (flag) + { + result = 0; + } + else + { + bool flag2 = x.y != y.y; + if (flag2) + { + result = y.y - x.y; + } + else + { + result = x.x - y.x; + } + } + return result; + } + + public static string GetSkillAttrStr(int element) + { + string @string; + switch (element) + { + case 0: + @string = XStringDefineProxy.GetString("Void"); + break; + case 1: + @string = XStringDefineProxy.GetString("Fire"); + break; + case 2: + @string = XStringDefineProxy.GetString("Water"); + break; + case 3: + @string = XStringDefineProxy.GetString("Light"); + break; + case 4: + @string = XStringDefineProxy.GetString("Dark"); + break; + default: + @string = XStringDefineProxy.GetString("Void"); + break; + } + return @string; + } + + public bool IsEquipThisSkill(List skillNames) + { + for (int i = 0; i < skillNames.Count; i++) + { + bool flag = skillNames[i] == string.Empty; + if (!flag) + { + uint skillID = XSingleton.singleton.GetSkillID(skillNames[i], 0u); + bool flag2 = skillID > 0u; + if (flag2) + { + bool flag3 = this.IsEquipThisSkill(skillID); + if (flag3) + { + return true; + } + } + } + } + return false; + } + + public void ShowEmblemTips(List hashList) + { + bool flag = hashList.Count == 0; + if (!flag) + { + List skillRow = new List(); + XEmblemDocument specificDocument = XDocuments.GetSpecificDocument(XEmblemDocument.uuID); + for (int i = 0; i < hashList.Count; i++) + { + uint num = XSingleton.singleton.XPlayerData.skillSlot[hashList[i]]; + bool flag2 = num > 0u; + if (flag2) + { + bool flag3 = specificDocument.IsEquipThisSkillEmblem(num, ref skillRow); + bool flag4 = flag3; + if (flag4) + { + this.ShowTips(skillRow, false); + } + } + } + } + } + + public void ShowEmblemTips(ulong skillHash, int slot) + { + bool flag = skillHash == 0UL; + if (!flag) + { + uint num = XSingleton.singleton.XPlayerData.skillSlot[slot]; + bool flag2 = (ulong)num == skillHash; + if (!flag2) + { + List skillRow = new List(); + XEmblemDocument specificDocument = XDocuments.GetSpecificDocument(XEmblemDocument.uuID); + bool flag3 = this.IsEquipThisSkill((uint)skillHash); + bool flag4 = num == 0u && skillHash > 0UL; + if (flag4) + { + bool flag5 = !flag3; + if (flag5) + { + bool flag6 = specificDocument.IsEquipThisSkillEmblem((uint)skillHash, ref skillRow); + bool flag7 = flag6; + if (flag7) + { + this.ShowTips(skillRow, true); + } + } + } + else + { + bool flag8 = !flag3; + if (flag8) + { + bool flag6 = specificDocument.IsEquipThisSkillEmblem((uint)skillHash, ref skillRow); + bool flag9 = flag6; + if (flag9) + { + this.ShowTips(skillRow, true); + } + flag6 = specificDocument.IsEquipThisSkillEmblem(num, ref skillRow); + bool flag10 = flag6; + if (flag10) + { + this.ShowTips(skillRow, false); + } + } + } + } + } + } + + public void ShowTips(List skillRow, bool isUp) + { + bool flag = skillRow.Count == 0; + if (!flag) + { + for (int i = 0; i < skillRow.Count; i++) + { + ItemList.RowData itemConf = XBagDocument.GetItemConf((int)skillRow[i].EmblemID); + bool flag2 = itemConf == null; + if (flag2) + { + break; + } + if (isUp) + { + XSingleton.singleton.ShowSystemTip(string.Format(XStringDefineProxy.GetString("Active_Emblem"), itemConf.ItemName[0], skillRow[i].SkillPPT), "fece00"); + } + else + { + XSingleton.singleton.ShowSystemTip(string.Format(XStringDefineProxy.GetString("Deactive_Emblem"), itemConf.ItemName[0], skillRow[i].SkillPPT), "fece00"); + } + } + } + } + + private bool IsEquipThisSkill(uint skillHash) + { + bool flag = this.IsPassiveSkill(skillHash); + bool flag2 = !flag; + bool result; + if (flag2) + { + for (int i = 0; i < XSingleton.singleton.XPlayerData.skillSlot.Length; i++) + { + uint num = XSingleton.singleton.XPlayerData.skillSlot[i]; + bool flag3 = num > 0u && skillHash == num; + if (flag3) + { + return true; + } + } + result = false; + } + else + { + uint skillOriginalLevel = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(skillHash); + bool flag4 = skillOriginalLevel > 0u; + result = flag4; + } + return result; + } + + public bool IsPassiveSkill(uint skillHash) + { + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(skillHash, 0u); + return skillConfig != null && skillConfig.SkillType == 5; + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/Skill/XSkillTreeDocument.cs.meta b/Client/Assets/Scripts/XMainClient/Skill/XSkillTreeDocument.cs.meta new file mode 100644 index 00000000..b701e5ef --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Skill/XSkillTreeDocument.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 172d0cd8e5557514f9887e765a841929 +timeCreated: 1611403292 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/Skill/XSkillTreeView.cs b/Client/Assets/Scripts/XMainClient/Skill/XSkillTreeView.cs new file mode 100644 index 00000000..d614f958 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Skill/XSkillTreeView.cs @@ -0,0 +1,1063 @@ +using System; +using System.Collections.Generic; +using KKSG; +using UILib; +using UnityEngine; +using XMainClient.UI; +using XMainClient.UI.GameSystem; +using XMainClient.UI.UICommon; +using XUtliPoolLib; + +namespace XMainClient +{ + internal class XSkillTreeView : DlgBase + { + public override string fileName + { + get + { + return "GameSystem/SkillTree"; + } + } + + public override int layer + { + get + { + return 1; + } + } + + public override bool pushstack + { + get + { + return true; + } + } + + public override bool fullscreenui + { + get + { + return true; + } + } + + public override bool hideMainMenu + { + get + { + return true; + } + } + + public override bool autoload + { + get + { + return true; + } + } + + public SkillDlgPromoteHandler _skillDlgPromoteHandler; + + private GameObject _LastSelect = null; + + private GameObject _CurrentSkillSprite = null; + + private List _TabRedPointList = new List(); + + private bool _SwitchFrameState = true; + + public bool IsPromoteHandlerShow = false; + + public int LastSelectPromote; + + private XSkillTreeDocument _doc = null; + + private List _icbList = new List(); + + public RenderTexture skillPreView; + + private float _skillPageSwitchSignTime = 0f; + + private XFx _FxFirework; + + private int[] MI = new int[] + { + 1, + 10, + 100, + 1000, + 10000 + }; + + public static readonly int AwakeIndex = 3; + + protected override void Init() + { + base.Init(); + this._doc = XDocuments.GetSpecificDocument(XSkillTreeDocument.uuID); + this._doc.CurrentSkillID = this._doc.UNSELECT; + this._SwitchFrameState = true; + this.SetupTabs(); + base.uiBehaviour.m_FreeResetSkillTip.SetText(string.Format(XStringDefineProxy.GetString("SKILL_RESETFREE_TIPS"), XSingleton.singleton.GetInt("FreeResetSkillLevel"))); + this._skillDlgPromoteHandler = DlgHandlerBase.EnsureCreate(ref this._skillDlgPromoteHandler, base.uiBehaviour.m_TransferFrame, null, false); + } + + public override void RegisterEvent() + { + base.RegisterEvent(); + base.uiBehaviour.m_Close.RegisterClickEventHandler(new ButtonClickEventHandler(this.OnCloseClicked)); + base.uiBehaviour.m_ResetSkillBtn.RegisterSpriteClickEventHandler(new SpriteClickEventHandler(this.OnResetSkillPointClicked)); + base.uiBehaviour.m_ResetProBtn.RegisterSpriteClickEventHandler(new SpriteClickEventHandler(this.OnResetProfClicked)); + base.uiBehaviour.m_SwitchSkillPageBtn.RegisterSpriteClickEventHandler(new SpriteClickEventHandler(this.OnSwitchSkillPageBtnClick)); + base.uiBehaviour.m_CatchBackBtn.RegisterClickEventHandler(new ButtonClickEventHandler(this.TurnSwitchFrameState)); + base.uiBehaviour.m_ChooseBtn.RegisterClickEventHandler(new ButtonClickEventHandler(this.TurnSwitchFrameState)); + base.uiBehaviour.m_SkillPlayBtn.RegisterSpriteClickEventHandler(new SpriteClickEventHandler(this.OnPlaySkillClicked)); + base.uiBehaviour.m_LearnBtn.RegisterClickEventHandler(new ButtonClickEventHandler(this.OnSkillLevelUpClicked)); + for (int i = 0; i < XSkillTreeDocument.SkillSlotCount; i++) + { + base.uiBehaviour.m_SkillSlotList[i].RegisterSpriteClickEventHandler(new SpriteClickEventHandler(this.OnSetupSkillClicked)); + } + } + + public void SetupTabs() + { + uint num = XSingleton.singleton.XPlayerData.TypeID; + uint level = XSingleton.singleton.XPlayerData.Level; + base.uiBehaviour.m_Tabs.ReturnAll(false); + Vector3 tplPos = base.uiBehaviour.m_Tabs.TplPos; + bool flag = true; + this._icbList.Clear(); + this._TabRedPointList.Clear(); + for (int i = 0; i < this._doc.TRANSFERNUM; i++) + { + uint num2 = num % 10u; + num /= 10u; + bool flag2 = num2 == 0u; + string inputText; + if (flag2) + { + bool flag3 = i == XSkillTreeView.AwakeIndex; + if (flag3) + { + inputText = XStringDefineProxy.GetString("SKILL_TREE_TAB_AWAKE"); + } + else + { + string arg = (i == 1) ? XStringDefineProxy.GetString("ONE") : XStringDefineProxy.GetString("TWO"); + string arg2 = (level >= this._doc.TransferLimit[i]) ? "" : XLabelSymbolHelper.FormatImage("common/Lcommon", "l_lock_00"); + inputText = string.Format(XStringDefineProxy.GetString("SKILL_TREE_TAB"), arg2, this._doc.TransferLimit[i], arg); + } + } + else + { + int profID = (int)(XSingleton.singleton.XPlayerData.TypeID % (uint)this.MI[i + 1]); + inputText = XSingleton.singleton.GetProfName(profID); + } + GameObject gameObject = base.uiBehaviour.m_Tabs.FetchGameObject(false); + gameObject.transform.localPosition = new Vector3(tplPos.x, tplPos.y - (float)(base.uiBehaviour.m_Tabs.TplHeight * i)); + this._TabRedPointList.Add(gameObject.transform.Find("RedPoint").gameObject); + IXUILabelSymbol ixuilabelSymbol = gameObject.transform.Find("TextLabel").GetComponent("XUILabelSymbol") as IXUILabelSymbol; + ixuilabelSymbol.InputText = inputText; + IXUILabelSymbol ixuilabelSymbol2 = gameObject.transform.Find("SelectedTextLabel").GetComponent("XUILabelSymbol") as IXUILabelSymbol; + ixuilabelSymbol2.InputText = inputText; + IXUICheckBox ixuicheckBox = gameObject.GetComponent("XUICheckBox") as IXUICheckBox; + IXUISprite ixuisprite = gameObject.transform.Find("Lock").GetComponent("XUISprite") as IXUISprite; + this._icbList.Add(ixuicheckBox); + ixuicheckBox.ID = (ulong)((long)i); + bool flag4 = flag; + if (flag4) + { + gameObject.GetComponent().enabled = true; + ixuicheckBox.RegisterOnCheckEventHandler(new CheckBoxOnCheckEventHandler(this.OnTabClick)); + ixuisprite.RegisterSpriteClickEventHandler(null); + } + else + { + gameObject.GetComponent().enabled = false; + ixuicheckBox.RegisterOnCheckEventHandler(null); + ixuisprite.ID = (ulong)this._doc.TransferLimit[i - 1]; + ixuisprite.RegisterSpriteClickEventHandler(new SpriteClickEventHandler(this.OnUnableCheckBoxClick)); + } + bool flag5 = num2 == 0u; + if (flag5) + { + flag = false; + } + } + } + + protected override void OnShow() + { + base.OnShow(); + XSingleton.singleton.ArrangeEffectData(); + this._doc.CreateSkillBlackHouse(); + bool flag = this.skillPreView == null; + if (flag) + { + this.skillPreView = new RenderTexture(369, 208, 1, 0, 0); + this.skillPreView.name = "SkillPreview"; + this.skillPreView.autoGenerateMips = false; + this.skillPreView.Create(); + } + base.uiBehaviour.m_Snapshot.SetRuntimeTex(this.skillPreView, true); + this._doc.SetSkillPreviewTexture(this.skillPreView); + this.SetUVRectangle(); + this._icbList[this.LastSelectPromote].bChecked = true; + this.OnTabClick(this._icbList[this.LastSelectPromote]); + bool flag2 = !this._SwitchFrameState; + if (flag2) + { + this.TurnSwitchFrameState(null); + } + this.CalAllTabRedPoint(); + } + + protected override void OnHide() + { + this._doc.DelDummy(); + bool flag = this._doc.BlackHouseCamera != null; + if (flag) + { + this._doc.BlackHouseCamera.enabled = false; + } + this.LastSelectPromote = 0; + this._skillDlgPromoteHandler.SetVisible(false); + this._doc.SetSkillPreviewTexture(null); + bool flag2 = this.skillPreView != null; + if (flag2) + { + base.uiBehaviour.m_Snapshot.SetRuntimeTex(null, true); + this.skillPreView = null; + } + this.DestroyFx(this._FxFirework); + this._FxFirework = null; + base.uiBehaviour.m_LevelUpFx.SetActive(false); + base.OnHide(); + } + + public override void LeaveStackTop() + { + base.LeaveStackTop(); + base.uiBehaviour.m_LevelUpFx.SetActive(false); + } + + protected override void OnUnload() + { + XSingleton.singleton.SkillShowEnd(this._doc.Dummy); + bool flag = this._doc.BlackHouseCamera != null; + if (flag) + { + this._doc.BlackHouseCamera.enabled = false; + } + this._doc.SetSkillPreviewTexture(null); + bool flag2 = this.skillPreView != null; + if (flag2) + { + this.skillPreView.Release(); + this.skillPreView = null; + } + this.LastSelectPromote = 0; + this._LastSelect = null; + DlgHandlerBase.EnsureUnload(ref this._skillDlgPromoteHandler); + this.DestroyFx(this._FxFirework); + this._FxFirework = null; + base.OnUnload(); + } + + public void CalAllTabRedPoint() + { + for (int i = 0; i < this._doc.TRANSFERNUM; i++) + { + this.CalTabRedPoint(i); + } + } + + private void CalTabRedPoint(int Promote) + { + bool flag = XSingleton.singleton.XPlayerData.TypeID / (uint)this.MI[Promote] == 0u; + if (flag) + { + this._TabRedPointList[Promote].SetActive(false); + } + else + { + int profID = (int)(XSingleton.singleton.XPlayerData.TypeID % (uint)this.MI[Promote + 1]); + List profSkillID = XSingleton.singleton.GetProfSkillID(profID); + for (int i = 0; i < profSkillID.Count; i++) + { + uint skillOriginalLevel = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(profSkillID[i]); + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(profSkillID[i], skillOriginalLevel); + bool flag2 = this._doc.CheckRedPoint(profSkillID[i]); + if (flag2) + { + this._TabRedPointList[Promote].SetActive(true); + return; + } + } + this._TabRedPointList[Promote].SetActive(false); + } + } + + private bool OnTabClick(IXUICheckBox icb) + { + bool flag = !icb.bChecked; + bool result; + if (flag) + { + result = true; + } + else + { + bool flag2 = this._LastSelect != null; + if (flag2) + { + this._LastSelect.SetActive(false); + } + this.Refresh((int)icb.ID, true, true); + result = true; + } + return result; + } + + private bool OnCloseClicked(IXUIButton button) + { + this.SetVisibleWithAnimation(false, null); + return true; + } + + public void Refresh(int Promote, bool resetCurrentSkill = false, bool resetPosition = true) + { + this.LastSelectPromote = Promote; + this._icbList[Promote].bChecked = true; + int typeID = (int)XSingleton.singleton.XPlayerData.TypeID; + int num = typeID / this.MI[Promote] % 10; + bool flag = num != 0; + if (flag) + { + if (resetCurrentSkill) + { + this._doc.CurrentSkillID = this._doc.UNSELECT; + } + this.ShowSkillTreeFrame(Promote); + } + else + { + this.ShowTransferFrame(Promote); + } + this.SetOtherInfo(Promote == XSkillTreeView.AwakeIndex); + if (resetPosition) + { + base.uiBehaviour.m_SkillTreeScrollView.ResetPosition(); + } + } + + public void ShowSkillTreeFrame(int Promote) + { + this.IsPromoteHandlerShow = false; + this._skillDlgPromoteHandler.SetVisible(false); + this.SetupSkillFrame(Promote); + } + + private void ShowTransferFrame(int Promote) + { + this.IsPromoteHandlerShow = true; + this._skillDlgPromoteHandler.IsShowAwake = (Promote == XSkillTreeView.AwakeIndex); + this._skillDlgPromoteHandler.CurrStage = Promote; + this._skillDlgPromoteHandler.SetVisible(true); + } + + private void OnPlaySkillClicked(IXUISprite sp) + { + base.uiBehaviour.m_SkillPlayBtn.SetVisible(false); + XSingleton.singleton.ShowSkill(this._doc.Dummy, this._doc.CurrentSkillID, 0u); + } + + private bool OnSkillLevelUpClicked(IXUIButton button) + { + this._doc.SendSkillLevelup(); + return true; + } + + public void SetupSkillFrame(int Promote) + { + bool flag = !base.IsVisible(); + if (!flag) + { + int profID = (int)(XSingleton.singleton.XPlayerData.TypeID % (uint)this.MI[Promote + 1]); + base.uiBehaviour.m_SkillPool.ReturnAll(false); + base.uiBehaviour.m_ArrowPool.ReturnAll(false); + List profSkillID = XSingleton.singleton.GetProfSkillID(profID); + List list = new List(); + for (int i = 0; i < profSkillID.Count; i++) + { + SkillTreeSortItem skillTreeSortItem = new SkillTreeSortItem(); + skillTreeSortItem.skillID = profSkillID[i]; + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(profSkillID[i], 0u); + skillTreeSortItem.x = (int)skillConfig.XPostion; + skillTreeSortItem.y = (int)skillConfig.YPostion; + list.Add(skillTreeSortItem); + } + list.Sort(new Comparison(this.Compare)); + int num = 0; + for (int j = 0; j < list.Count; j++) + { + GameObject gameObject = base.uiBehaviour.m_SkillPool.FetchGameObject(false); + gameObject.name = string.Format("Skill{0}", ++num); + this.SetupSkill(gameObject, list[j].skillID); + } + } + } + + private void SetOtherInfo(bool isAwake = false) + { + base.uiBehaviour.m_FreeResetSkillTip.SetVisible((ulong)XSingleton.singleton.XPlayerData.Level < (ulong)((long)XSingleton.singleton.GetInt("FreeResetSkillLevel"))); + int num = (int)XSingleton.singleton.Doc.XBagDoc.GetSkillPointCount(false); + base.uiBehaviour.m_UseSkillPoint.SetText(string.Format("{0}/{1}", num, this._doc.TotalSkillPoint)); + base.uiBehaviour.m_UseAwakeSkillPoint.SetText(string.Format("{0}/{1}", (int)XSingleton.singleton.Doc.XBagDoc.GetSkillPointCount(true), this._doc.TotalAwakeSkillPoint)); + base.uiBehaviour.m_LeftSkillPoint.SetText(num.ToString()); + base.uiBehaviour.m_ResetProBtn.SetEnabled(XSingleton.singleton.XPlayerData.TypeID > 10u); + base.uiBehaviour.m_ResetSkillBtn.SetEnabled((isAwake ? this._doc.TotalAwakeSkillPoint : this._doc.TotalSkillPoint) - (int)XSingleton.singleton.Doc.XBagDoc.GetSkillPointCount(isAwake) != 1); + base.uiBehaviour.m_SwitchSkillPageBtn.SetGrey((ulong)XSingleton.singleton.XPlayerData.Level >= (ulong)((long)this._doc.SkillPageOpenLevel)); + base.uiBehaviour.m_SkillPageText.SetEnabled((ulong)XSingleton.singleton.XPlayerData.Level >= (ulong)((long)this._doc.SkillPageOpenLevel)); + base.uiBehaviour.m_SkillPageText.SetText(XStringDefineProxy.GetString(string.Format("SkillPage{0}", 1u - XSingleton.singleton.XPlayerData.SkillPageIndex))); + } + + protected void SetupSkill(GameObject go, uint skillID) + { + uint skillOriginalLevel = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(skillID); + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(skillID, skillOriginalLevel); + SkillList.RowData rowData = null; + bool flag = skillConfig.PreSkill != null && skillConfig.PreSkill != ""; + if (flag) + { + uint skillID2 = XSingleton.singleton.GetSkillID(skillConfig.PreSkill, 0u); + rowData = XSingleton.singleton.GetSkillConfig(skillID2, 0u); + } + int skillMaxLevel = XSingleton.singleton.GetSkillMaxLevel(skillID, 0u); + SkillTypeEnum skillType = (SkillTypeEnum)skillConfig.SkillType; + IXUISprite ixuisprite = go.GetComponent("XUISprite") as IXUISprite; + IXUISprite ixuisprite2 = go.transform.Find("Icon").GetComponent("XUISprite") as IXUISprite; + IXUISprite ixuisprite3 = go.transform.Find("Icon/P").GetComponent("XUISprite") as IXUISprite; + IXUILabel ixuilabel = go.transform.Find("Text").GetComponent("XUILabel") as IXUILabel; + IXUISprite ixuisprite4 = go.transform.Find("Tip").GetComponent("XUISprite") as IXUISprite; + IXUILabel ixuilabel2 = go.transform.Find("LockTip").GetComponent("XUILabel") as IXUILabel; + IXUISprite ixuisprite5 = go.transform.Find("Lock").GetComponent("XUISprite") as IXUISprite; + GameObject gameObject = go.transform.Find("Select").gameObject; + ixuisprite.ID = (ulong)skillID; + ixuisprite.RegisterSpriteClickEventHandler(new SpriteClickEventHandler(this.OnSkillClicked)); + bool flag2 = this._doc.CurrentSkillID == this._doc.UNSELECT || this._doc.CurrentSkillID == skillID; + if (flag2) + { + gameObject.SetActive(true); + this._doc.CurrentSkillID = skillID; + this.OnSkillClicked(ixuisprite); + this._LastSelect = gameObject; + } + else + { + gameObject.SetActive(false); + } + Transform transform = go.transform.Find("CanLearn"); + Transform transform2 = go.transform.Find("RedPoint"); + transform.gameObject.SetActive(false); + transform2.gameObject.SetActive(false); + bool flag3 = (skillType == SkillTypeEnum.Skill_Normal || skillType == SkillTypeEnum.Skill_Big || skillType == SkillTypeEnum.Skill_Buff) && this._doc.SkillIsEquip(skillID); + if (flag3) + { + ixuisprite4.SetVisible(true); + } + else + { + ixuisprite4.SetVisible(false); + } + go.transform.localPosition = new Vector3(base.uiBehaviour.m_SkillPool.TplPos.x + (float)((int)(skillConfig.XPostion - 1) * base.uiBehaviour.m_SkillPool.TplWidth), (float)skillConfig.YPostion); + ixuisprite2.SetSprite(skillConfig.Icon, skillConfig.Atlas, false); + ixuilabel2.SetVisible(this._doc.CheckPreSkillLevel(skillID) != 0 && !this._doc.CanSkillLevelUp(skillID, skillOriginalLevel, 0) && skillOriginalLevel == 0u); + ixuilabel.SetVisible((this._doc.CheckPreSkillLevel(skillID) != 0 && this._doc.CanSkillLevelUp(skillID, skillOriginalLevel, 0)) || skillOriginalLevel > 0u); + ixuilabel.SetText(skillOriginalLevel + "/" + skillMaxLevel); + bool flag4 = skillOriginalLevel == 0u && !this._doc.CanSkillLevelUp(skillID, skillOriginalLevel, 0); + if (flag4) + { + ixuilabel2.SetText(string.Format(XStringDefineProxy.GetString(XStringDefine.SKILL_LEARN), skillConfig.UpReqRoleLevel[0])); + } + else + { + bool flag5 = this._doc.CheckFx(skillID); + bool flag6 = this._doc.CheckRedPoint(skillID); + bool flag7 = this._doc.CheckNew(skillID); + IXUISprite ixuisprite6 = transform2.transform.Find("Fx").GetComponent("XUISprite") as IXUISprite; + IXUISprite ixuisprite7 = transform2.transform.Find("Fx1").GetComponent("XUISprite") as IXUISprite; + ixuisprite6.SetVisible(false); + ixuisprite7.SetVisible(false); + bool flag8 = flag7; + if (flag8) + { + transform2.gameObject.SetActive(true); + ixuisprite6.SetVisible(true); + } + bool flag9 = flag5 && !flag6; + if (flag9) + { + transform.gameObject.SetActive(true); + } + bool flag10 = flag6; + if (flag10) + { + transform2.gameObject.SetActive(true); + ixuisprite7.SetVisible(true); + } + } + SkillTypeEnum skillTypeEnum = skillType; + if (skillTypeEnum != SkillTypeEnum.Skill_Big) + { + if (skillTypeEnum != SkillTypeEnum.Skill_Buff) + { + ixuisprite3.SetSprite("JN_dk"); + } + else + { + ixuisprite3.SetSprite("JN_dk_buff"); + } + } + else + { + ixuisprite3.SetSprite("JN_dk_0"); + } + bool flag11 = rowData != null; + if (flag11) + { + Vector3 localPosition = go.transform.localPosition; + Vector3 vector; + vector= new Vector3(base.uiBehaviour.m_SkillPool.TplPos.x + (float)((int)(rowData.XPostion - 1) * base.uiBehaviour.m_SkillPool.TplWidth), (float)rowData.YPostion); + Vector3 vector2 = (localPosition + vector) / 2f; + GameObject gameObject2 = base.uiBehaviour.m_ArrowPool.FetchGameObject(false); + IXUISprite ixuisprite8 = gameObject2.GetComponent("XUISprite") as IXUISprite; + bool flag12 = skillConfig.XPostion == rowData.XPostion || skillConfig.YPostion == rowData.YPostion; + if (flag12) + { + bool flag13 = skillConfig.XPostion == rowData.XPostion; + if (flag13) + { + ixuisprite8.SetSprite("SkillTree_3"); + ixuisprite8.spriteHeight = (int)((float)(rowData.YPostion - skillConfig.YPostion) - (float)ixuisprite2.spriteHeight * 1.5f); + ixuisprite8.spriteWidth = base.uiBehaviour.m_ArrowPool.TplWidth; + gameObject2.transform.localPosition = vector2; + gameObject2.transform.localScale = new Vector3(1f, 1f); + gameObject2.transform.localRotation = Quaternion.identity; + } + else + { + ixuisprite8.SetSprite("SkillTree_3"); + int num = (skillConfig.XPostion < rowData.XPostion) ? 1 : -1; + ixuisprite8.spriteHeight = (int)((float)((int)(rowData.XPostion - skillConfig.XPostion) * (num * base.uiBehaviour.m_SkillPool.TplWidth)) - (float)ixuisprite2.spriteWidth * 1.5f); + ixuisprite8.spriteWidth = base.uiBehaviour.m_ArrowPool.TplWidth; + gameObject2.transform.localPosition = vector2; + gameObject2.transform.localScale = new Vector3(1f, 1f); + gameObject2.transform.localRotation = Quaternion.Euler(0f, 0f, (float)(-(float)num * 90)); + } + } + else + { + ixuisprite8.SetSprite("SkillTree_4"); + ixuisprite8.spriteHeight = (int)Math.Abs(localPosition.y - vector.y) - ixuisprite2.spriteHeight / 2; + ixuisprite8.spriteWidth = (int)Math.Abs(localPosition.x - vector.x) - ixuisprite2.spriteWidth / 2; + int num2 = (skillConfig.XPostion < rowData.XPostion) ? 1 : -1; + gameObject2.transform.localPosition = vector2 + new Vector3((float)(ixuisprite2.spriteWidth / 2 * -(float)num2), (float)(ixuisprite2.spriteHeight / 2)); + gameObject2.transform.localScale = new Vector3((float)num2, 1f); + gameObject2.transform.localRotation = Quaternion.identity; + } + } + ixuisprite2.SetEnabled(skillOriginalLevel > 0u); + ixuisprite3.SetEnabled(skillOriginalLevel > 0u); + ixuisprite5.SetVisible(skillOriginalLevel == 0u); + ixuisprite5.SetEnabled(skillOriginalLevel > 0u); + ixuisprite2.ID = (ulong)skillID; + } + + private void OnSkillClicked(IXUISprite sp) + { + this._doc.CurrentSkillID = (uint)sp.ID; + bool flag = this._LastSelect != null; + if (flag) + { + this._LastSelect.SetActive(false); + } + this._LastSelect = sp.gameObject.transform.Find("Select").gameObject; + this._LastSelect.SetActive(true); + this._CurrentSkillSprite = sp.gameObject.transform.Find("RedPoint").gameObject; + this.SetupDetail(true); + } + + private void OnSetupSkillClicked(IXUISprite sp) + { + uint currentSkillID = this._doc.CurrentSkillID; + uint slot = (uint)sp.ID; + uint skillSlotUnLockLevel = this._doc.GetSkillSlotUnLockLevel((int)sp.ID); + bool flag = skillSlotUnLockLevel > XSingleton.singleton.XPlayerData.Level; + if (flag) + { + XSingleton.singleton.ShowSystemTip(XStringDefineProxy.GetString("OpenSkillAtLevel", new object[] + { + skillSlotUnLockLevel + }), "fece00"); + this.SetupBaseSkill(); + } + else + { + this._doc.SendBindSkill(currentSkillID, slot); + } + } + + private bool TurnSwitchFrameState(IXUIButton btn) + { + this._SwitchFrameState = !this._SwitchFrameState; + this.SetupDetail(true); + int num = this._SwitchFrameState ? 1 : 0; + base.uiBehaviour.m_DetailFrameTween.StopTweenByGroup(1 - num); + base.uiBehaviour.m_CatchFrameTween.StopTweenByGroup(1 - num); + base.uiBehaviour.m_DetailFrameTween.SetTweenGroup(num); + base.uiBehaviour.m_CatchFrameTween.SetTweenGroup(num); + base.uiBehaviour.m_DetailFrameTween.PlayTween(true, -1f); + base.uiBehaviour.m_CatchFrameTween.PlayTween(true, -1f); + return true; + } + + public void SetupDetail(bool resetSnap = true) + { + uint skillOriginalLevel = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(this._doc.CurrentSkillID); + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(this._doc.CurrentSkillID, skillOriginalLevel); + bool flag = skillConfig == null; + if (flag) + { + XSingleton.singleton.AddErrorLog("Can't find Current Skill, SkillID = ", this._doc.CurrentSkillID.ToString(), null, null, null, null); + } + else + { + SkillTypeEnum skillType = (SkillTypeEnum)skillConfig.SkillType; + bool flag2 = false; + bool flag3 = false; + bool flag4 = (ulong)skillOriginalLevel < (ulong)((long)XSingleton.singleton.GetSkillMaxLevel(this._doc.CurrentSkillID, 0u)); + bool flag5 = skillType == SkillTypeEnum.Skill_Normal || skillType == SkillTypeEnum.Skill_Big || skillType == SkillTypeEnum.Skill_Help || skillType == SkillTypeEnum.Skill_Buff; + if (flag5) + { + flag2 = true; + } + bool flag6 = skillOriginalLevel > 0u; + if (flag6) + { + bool flag7 = !this._doc.IsExSkill(skillConfig); + if (flag7) + { + bool flag8 = skillType == SkillTypeEnum.Skill_Normal || skillType == SkillTypeEnum.Skill_Big || skillType == SkillTypeEnum.Skill_Buff; + if (flag8) + { + flag3 = true; + } + } + } + bool flag9 = this._doc.CurrentSkillID != this._doc.UNSELECT; + if (flag9) + { + base.uiBehaviour.m_SkillLearnRedPoint.gameObject.SetActive(this._doc.CheckRedPoint(this._doc.CurrentSkillID)); + } + else + { + base.uiBehaviour.m_SkillLearnRedPoint.gameObject.SetActive(false); + } + if (resetSnap) + { + XSingleton.singleton.SkillShowEnd(this._doc.Dummy); + XSingleton.singleton.SkillShowBegin(this._doc.Dummy, this._doc.BlackHouseCamera); + } + base.uiBehaviour.m_NonPreView.SetActive(!flag2); + base.uiBehaviour.m_Snapshot.SetVisible(flag2); + base.uiBehaviour.m_SkillPlayBtn.SetVisible(flag2); + base.uiBehaviour.m_ChooseBtn.SetVisible(flag3); + bool flag10 = flag3; + if (flag10) + { + Vector3 localPosition = base.uiBehaviour.m_ChooseBtn.gameObject.transform.localPosition; + bool flag11 = flag4; + if (flag11) + { + base.uiBehaviour.m_ChooseBtn.gameObject.transform.localPosition = new Vector3(96f, localPosition.y); + } + else + { + base.uiBehaviour.m_ChooseBtn.gameObject.transform.localPosition = new Vector3(0f, localPosition.y); + } + } + bool flag12 = !flag3 && !this._SwitchFrameState; + if (flag12) + { + this.TurnSwitchFrameState(null); + } + base.uiBehaviour.m_LearnBtn.SetVisible(flag4); + bool flag13 = flag4; + if (flag13) + { + Vector3 localPosition2 = base.uiBehaviour.m_LearnBtn.gameObject.transform.localPosition; + bool flag14 = flag3; + if (flag14) + { + base.uiBehaviour.m_LearnBtn.gameObject.transform.localPosition = new Vector3(-96f, localPosition2.y); + } + else + { + base.uiBehaviour.m_LearnBtn.gameObject.transform.localPosition = new Vector3(0f, localPosition2.y); + } + } + IXUISprite ixuisprite = base.uiBehaviour.m_LearnBtn.gameObject.transform.Find("Icon").GetComponent("XUISprite") as IXUISprite; + ItemList.RowData itemConf = XBagDocument.GetItemConf(skillConfig.IsAwake ? XFastEnumIntEqualityComparer.ToInt(ItemEnum.AWAKE_SKILL_POINT) : XFastEnumIntEqualityComparer.ToInt(ItemEnum.SKILL_POINT)); + bool flag15 = itemConf != null && itemConf.ItemAtlas1.Length != 0 && itemConf.ItemIcon1.Length != 0; + if (flag15) + { + ixuisprite.SetSprite(itemConf.ItemIcon1[0], itemConf.ItemAtlas1[0], false); + } + IXUILabel ixuilabel = base.uiBehaviour.m_LearnBtn.gameObject.transform.Find("Text").GetComponent("XUILabel") as IXUILabel; + ixuilabel.SetText(XStringDefineProxy.GetString((skillOriginalLevel == 0u) ? "LEARN" : "UPGRADE")); + IXUILabel ixuilabel2 = base.uiBehaviour.m_LearnBtn.gameObject.transform.Find("Cost").GetComponent("XUILabel") as IXUILabel; + bool flag16 = skillConfig.LevelupCost == null; + if (flag16) + { + ixuilabel2.SetText("0"); + } + else + { + bool flag17 = (ulong)skillOriginalLevel < (ulong)((long)skillConfig.LevelupCost.Length); + if (flag17) + { + ixuilabel2.SetText(skillConfig.LevelupCost[(int)skillOriginalLevel].ToString()); + } + else + { + ixuilabel2.SetText(skillConfig.LevelupCost[skillConfig.LevelupCost.Length - 1].ToString()); + } + } + base.uiBehaviour.m_LearnBtn.SetGrey(this._doc.CheckLevelUpButton(this._doc.CurrentSkillID)); + this.SetupDetailMsg(this._doc.CurrentSkillID, skillOriginalLevel, skillConfig); + this.SetupBaseSkill(); + } + } + + private void SetupBaseSkill() + { + SkillList.RowData skillConfig = XSingleton.singleton.GetSkillConfig(this._doc.CurrentSkillID, 0u); + SkillTypeEnum skillType = (SkillTypeEnum)skillConfig.SkillType; + bool isAwake = skillConfig.IsAwake; + for (int i = 0; i < XSkillTreeDocument.SkillSlotCount; i++) + { + bool flag = i == 0 || i == 1; + if (!flag) + { + bool flag2 = i == XSkillTreeDocument.AwakeSkillSlot; + if (flag2) + { + base.uiBehaviour.m_SkillSlotList[i].gameObject.SetActive(this._doc.IsAwakeSkillSlotOpen && this._doc.IsSelfAwaked); + } + uint num = 0u; + bool flag3 = i < XSingleton.singleton.XPlayerData.skillSlot.Length; + if (flag3) + { + num = XSingleton.singleton.XPlayerData.skillSlot[i]; + } + SkillTypeEnum skillSlotType = this._doc.GetSkillSlotType(i); + IXUISprite ixuisprite = base.uiBehaviour.m_SkillSlotList[i].gameObject.transform.Find("Light").GetComponent("XUISprite") as IXUISprite; + IXUISprite ixuisprite2 = base.uiBehaviour.m_SkillSlotList[i].gameObject.transform.Find("Icon").GetComponent("XUISprite") as IXUISprite; + IXUISprite ixuisprite3 = base.uiBehaviour.m_SkillSlotList[i].gameObject.transform.Find("Lock").GetComponent("XUISprite") as IXUISprite; + BoxCollider boxCollider = base.uiBehaviour.m_SkillSlotList[i].gameObject.GetComponent("BoxCollider") as BoxCollider; + bool flag4 = skillConfig.ExSkillScript == ""; + if (flag4) + { + ixuisprite.SetVisible(num == this._doc.CurrentSkillID); + } + else + { + uint skillID = XSingleton.singleton.GetSkillID(skillConfig.ExSkillScript, 0u); + ixuisprite.SetVisible(num == this._doc.CurrentSkillID || num == skillID); + } + bool flag5 = skillSlotType == skillType; + if (flag5) + { + base.uiBehaviour.m_SkillSlotList[i].SetAlpha(1f); + boxCollider.enabled = true; + } + else + { + base.uiBehaviour.m_SkillSlotList[i].SetAlpha(0.5f); + boxCollider.enabled = false; + } + ixuisprite3.SetAlpha((this._doc.GetSkillSlotUnLockLevel(i) > XSingleton.singleton.XPlayerData.Level) ? 1f : 0f); + bool flag6 = skillSlotType == SkillTypeEnum.Skill_Buff && this._doc.GetSkillSlotUnLockLevel(XFastEnumIntEqualityComparer.ToInt(XSkillSlot.Skill_1_Buff)) > XSingleton.singleton.XPlayerData.Level; + if (flag6) + { + base.uiBehaviour.m_SkillSlotList[i].SetAlpha(0f); + } + bool flag7 = num > 0u; + if (flag7) + { + uint skillOriginalLevel = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(num); + SkillList.RowData skillConfig2 = XSingleton.singleton.GetSkillConfig(num, skillOriginalLevel); + ixuisprite2.SetSprite(skillConfig2.Icon, skillConfig2.Atlas, false); + } + else + { + ixuisprite2.spriteName = "EmptySkill"; + } + } + } + } + + private void SetupDetailMsg(uint skillID, uint skillLevel, SkillList.RowData data) + { + SkillTypeEnum skillType = (SkillTypeEnum)data.SkillType; + string text = string.Format("{0}({1}/{2})", data.ScriptName, skillLevel, XSingleton.singleton.GetSkillMaxLevel(skillID, 0u)); + base.uiBehaviour.m_SkillName_L.SetText(text); + base.uiBehaviour.m_SkillName_S.SetText(text); + string @string; + switch (skillType) + { + case SkillTypeEnum.Skill_Big: + @string = XStringDefineProxy.GetString("SPECIAL_SKILL"); + goto IL_CE; + case SkillTypeEnum.Skill_SceneBuff: + @string = XStringDefineProxy.GetString("SCENEBUFF_SKILL"); + goto IL_CE; + case SkillTypeEnum.Skill_Help: + @string = XStringDefineProxy.GetString("SUPPORT_SKILL"); + goto IL_CE; + case SkillTypeEnum.Skill_Buff: + @string = XStringDefineProxy.GetString("BUFF_SKILL"); + goto IL_CE; + case SkillTypeEnum.Skill_Awake: + @string = XStringDefineProxy.GetString("AWAKE_SKILL"); + goto IL_CE; + } + @string = XStringDefineProxy.GetString("NORMAL_SKILL"); + IL_CE: + base.uiBehaviour.m_SkillType_L.SetText(@string); + base.uiBehaviour.m_SkillType_S.SetText(@string); + base.uiBehaviour.m_ChooseTips.SetText(string.Format(XStringDefineProxy.GetString("SKILL_CHOOSE_TIPS"), @string)); + base.uiBehaviour.m_SkillCostText.SetText((data.CostMP[0] + data.CostMP[1] * skillLevel).ToString()); + base.uiBehaviour.m_SkillAttrText.SetText(XSkillTreeDocument.GetSkillAttrStr((int)data.Element)); + bool flag = skillType != SkillTypeEnum.Skill_SceneBuff; + if (flag) + { + base.uiBehaviour.m_SkillCDText.SetText(string.Format("{0}s", Math.Round((double)XSkillMgr.GetCD(this._doc.Player, data.SkillScript, 0u) + 0.01, 1))); + } + else + { + base.uiBehaviour.m_SkillCDText.SetText(XStringDefineProxy.GetString("NONE")); + } + base.uiBehaviour.m_SkillDetail_L.SetText(data.CurrentLevelDescription); + base.uiBehaviour.m_SkillDetail_S.SetText(data.CurrentLevelDescription); + base.uiBehaviour.m_SkillDetailScrollView_S.SetPosition(0f); + uint preSkill = XSingleton.singleton.GetPreSkill(skillID, 0u); + uint num = 0u; + bool flag2 = preSkill > 0u; + if (flag2) + { + num = XSingleton.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(preSkill); + } + float num2; + float num3; + XSingleton.singleton.GetSkillDescriptValue(skillID, (preSkill == 0u) ? skillLevel : num, XSingleton.singleton.Doc.XBagDoc.EmblemBag, out num2, out num3); + base.uiBehaviour.m_SkillCurrDesc.SetText(string.Format(XSingleton.singleton.ReplaceReturn(data.NextLevelDescription), Math.Round((double)(num2 * 100f) + 0.01, 1), Math.Round((double)num3 + 0.01, 1))); + base.uiBehaviour.m_SkillPreSkillPointTips.SetVisible(false); + bool flag3 = num == 0u; + if (flag3) + { + num += 1u; + } + XSingleton.singleton.GetSkillDescriptValue(skillID, (preSkill == 0u) ? (skillLevel + 1u) : num, XSingleton.singleton.Doc.XBagDoc.EmblemBag, out num2, out num3); + base.uiBehaviour.m_SkillNextDesc.SetText(string.Format(XSingleton.singleton.ReplaceReturn(data.NextLevelDescription), Math.Round((double)(num2 * 100f) + 0.01, 1), Math.Round((double)num3 + 0.01, 1))); + bool flag4 = this._doc.CanSkillLevelUp(skillID, skillLevel, 0); + if (flag4) + { + base.uiBehaviour.m_SkillNextReq.SetText(""); + } + else + { + SkillLevelupRequest levelupRequest = XSingleton.singleton.GetLevelupRequest(skillID, skillLevel); + base.uiBehaviour.m_SkillNextReq.SetText(string.Format("{0}({1})", string.Format(XStringDefineProxy.GetString(XStringDefine.ITEM_REQUIRE_LEVEL), levelupRequest.Level), string.Format(XStringDefineProxy.GetString("LEFT_LEVEL"), (long)levelupRequest.Level - (long)((ulong)XSingleton.singleton.XPlayerData.Level)))); + } + base.uiBehaviour.m_SuperIndureAttack.SetText(data.SuperIndureAttack); + base.uiBehaviour.m_SuperIndureDenfense.SetText(data.SuperIndureDefense); + bool flag5 = skillLevel == 0u; + if (flag5) + { + base.uiBehaviour.m_SkillCurrDesc.SetText(XStringDefineProxy.GetString("NOT_LEARN")); + bool isAwake = data.IsAwake; + int num4 = (isAwake ? this._doc.TotalAwakeSkillPoint : this._doc.TotalSkillPoint) - (int)XSingleton.singleton.Doc.XBagDoc.GetSkillPointCount(isAwake); + bool flag6 = num4 < (int)data.PreSkillPoint; + if (flag6) + { + base.uiBehaviour.m_SkillPreSkillPointTips.SetVisible(true); + base.uiBehaviour.m_SkillPreSkillPointTips.SetText(string.Format(XStringDefineProxy.GetString("SKILLTREE_PRESKILLPOINT_TIPS"), data.PreSkillPoint)); + } + else + { + base.uiBehaviour.m_SkillPreSkillPointTips.SetVisible(false); + } + } + else + { + bool flag7 = (ulong)skillLevel == (ulong)((long)XSingleton.singleton.GetSkillMaxLevel(skillID, 0u)); + if (flag7) + { + base.uiBehaviour.m_SkillNextDesc.SetText(XStringDefineProxy.GetString("SkillLevelMaxTips")); + base.uiBehaviour.m_SkillNextReq.SetText(""); + } + } + base.uiBehaviour.m_SkillDetailScrollView.ResetPosition(); + } + + private void OnResetSkillPointClicked(IXUISprite sp) + { + DlgBase.singleton._bHasGrey = false; + DlgBase.singleton.SetVisible(false, true); + DlgBase.singleton.SetSingleButtonMode(false); + int num = XSingleton.singleton.GetInt("SkillResetCost"); + bool flag = (ulong)XSingleton.singleton.XPlayerData.Level < (ulong)((long)XSingleton.singleton.GetInt("FreeResetSkillLevel")); + if (flag) + { + num = 0; + } + bool flag2 = num != 0; + if (flag2) + { + DlgBase.singleton.SetLabelsWithSymbols(string.Format(XSingleton.singleton.ReplaceReturn(XStringDefineProxy.GetString(XStringDefine.SKILL_RESET_SP)), num, XLabelSymbolHelper.FormatSmallIcon(7)), XStringDefineProxy.GetString(XStringDefine.COMMON_OK), XStringDefineProxy.GetString(XStringDefine.COMMON_CANCEL)); + } + else + { + DlgBase.singleton.SetLabelsWithSymbols(string.Format(XStringDefineProxy.GetString("FREE_RESET_SKILL_POINT"), XSingleton.singleton.GetInt("FreeResetSkillLevel")), XStringDefineProxy.GetString(XStringDefine.COMMON_OK), XStringDefineProxy.GetString(XStringDefine.COMMON_CANCEL)); + } + DlgBase.singleton.SetModalCallback(new ButtonClickEventHandler(this.OnResetSpConfirmed), null); + DlgBase.singleton.SetTweenTargetAndPlay(DlgBase.singleton.uiBehaviour.gameObject); + } + + private bool OnResetSpConfirmed(IXUIButton go) + { + this._doc.SendResetSkill(); + DlgBase.singleton.SetVisible(false, true); + return true; + } + + private void OnResetProfClicked(IXUISprite sp) + { + DlgBase.singleton._bHasGrey = false; + DlgBase.singleton.SetVisible(false, true); + DlgBase.singleton.SetSingleButtonMode(false); + DlgBase.singleton.SetLabelsWithSymbols(string.Format("{0}{1}", string.Format(XStringDefineProxy.GetString(XStringDefine.SKILL_RESET_PROF), XSingleton.singleton.GetInt("SkillResetProfession")), XLabelSymbolHelper.FormatSmallIcon(7)), XStringDefineProxy.GetString(XStringDefine.COMMON_OK), XStringDefineProxy.GetString(XStringDefine.COMMON_CANCEL)); + DlgBase.singleton.SetModalCallback(new ButtonClickEventHandler(this.OnResetProfConfirmed), null); + DlgBase.singleton.SetTweenTargetAndPlay(DlgBase.singleton.uiBehaviour.gameObject); + } + + private bool OnResetProfConfirmed(IXUIButton go) + { + this._doc.SendResetProf(); + DlgBase.singleton.SetVisible(false, true); + return true; + } + + private void OnSwitchSkillPageBtnClick(IXUISprite iSp) + { + bool flag = (ulong)XSingleton.singleton.XPlayerData.Level < (ulong)((long)this._doc.SkillPageOpenLevel); + if (flag) + { + XSingleton.singleton.ShowSystemTip(XStringDefineProxy.GetString("SkillPageOpenTips"), "fece00"); + } + else + { + bool flag2 = Time.time - this._skillPageSwitchSignTime < 2f; + if (flag2) + { + XSingleton.singleton.ShowSystemTip(XStringDefineProxy.GetString("SkillPageSwitchTooOften"), "fece00"); + } + else + { + this._skillPageSwitchSignTime = Time.time; + this._doc.QuerySwitchSkillPage(); + } + } + } + + public void OnSkillLevelUp(int x, int y) + { + bool flag = !base.IsVisible(); + if (!flag) + { + base.uiBehaviour.m_LevelUpFx.gameObject.transform.localPosition = new Vector3(base.uiBehaviour.m_SkillPool.TplPos.x + (float)((x - 1) * base.uiBehaviour.m_SkillPool.TplWidth), (float)y); + base.uiBehaviour.m_LevelUpFx.SetActive(false); + base.uiBehaviour.m_LevelUpFx.SetActive(true); + } + } + + public void SetLearnSkillButtonState(bool state) + { + bool flag = !DlgBase.singleton.IsVisible(); + if (!flag) + { + base.uiBehaviour.m_LearnBtn.SetEnable(state, false); + } + } + + public void CreateAndPlayFxFxFirework() + { + XSingleton.singleton.PlayUISound("Audio/UI/zhuanzhi", true, AudioChannel.Action); + this.DestroyFx(this._FxFirework); + this._FxFirework = null; + this._FxFirework = XSingleton.singleton.CreateFx("Effects/FX_Particle/UIfx/UI_zzcg", null, true); + this._FxFirework.Play(base.uiBehaviour.m_FxFirework, Vector3.zero, Vector3.one, 1f, true, false); + } + + public void DestroyFx(XFx fx) + { + bool flag = fx == null; + if (!flag) + { + XSingleton.singleton.DestroyFx(fx, true); + } + } + + private void OnUnableCheckBoxClick(IXUISprite iSp) + { + XSingleton.singleton.ShowSystemTip(string.Format(XStringDefineProxy.GetString("CHANGEPROF_PRETIPS"), iSp.ID), "fece00"); + } + + private int Compare(SkillTreeSortItem x, SkillTreeSortItem y) + { + bool flag = x.skillID == y.skillID; + int result; + if (flag) + { + result = 0; + } + else + { + bool flag2 = x.y != y.y; + if (flag2) + { + result = y.y - x.y; + } + else + { + result = x.x - y.x; + } + } + return result; + } + + public void SetUVRectangle() + { + Rect rect = this._doc.BlackHouseCamera.rect; + rect.y = (rect.y * 208f + 1f) / 208f; + rect.height = (rect.height * 208f - 2f) / 208f; + base.uiBehaviour.m_Snapshot.SetUVRect(rect); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/Skill/XSkillTreeView.cs.meta b/Client/Assets/Scripts/XMainClient/Skill/XSkillTreeView.cs.meta new file mode 100644 index 00000000..9073678a --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Skill/XSkillTreeView.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: d64c78e9edc986c4e9c9cb12e21ca0c5 +timeCreated: 1611404630 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: -- cgit v1.1-26-g67d0