diff options
| author | chai <chaifix@163.com> | 2021-01-25 14:28:30 +0800 |
|---|---|---|
| committer | chai <chaifix@163.com> | 2021-01-25 14:28:30 +0800 |
| commit | 6eb915c129fc90c6f4c82ae097dd6ffad5239efc (patch) | |
| tree | 7dd2be50edf41f36b60fac84696e731c13afe617 /Client/Assets/Scripts/XMainClient/Skill | |
+scripts
Diffstat (limited to 'Client/Assets/Scripts/XMainClient/Skill')
32 files changed, 8321 insertions, 0 deletions
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<uint> _logical_token;
+
+ protected SmallBuffer<uint> _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<BufferPoolMgr>.singleton.GetSmallBuffer(ref this._logical_token, 16, 0);
+ XSingleton<BufferPoolMgr>.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<XDebug>.singleton.AddErrorLog("skill token not null", null, null, null, null, null);
+ }
+ XSingleton<BufferPoolMgr>.singleton.ReturnSmallBuffer(ref this._logical_token);
+ XSingleton<BufferPoolMgr>.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<XGame>.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<XTimerMgr>.singleton.KillTimer(token);
+ }
+ for (int j = 0; j < this._logical_token.Count; j++)
+ {
+ uint token2 = this._logical_token[j];
+ XSingleton<XTimerMgr>.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<XGame>.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<XEntityMgr>.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<XCommon>.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<XGame>.singleton.SyncMode;
+ if (!flag)
+ {
+ this._firer.Net.ReportRotateAction(XSingleton<XCommon>.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<XTimerMgr>.singleton.SetTimer<XSkill.ESkillTimerCb>(args.delay, this._TimerCallback, args, XSkill.ESkillTimerCb.EExternalExecute));
+ }
+ else
+ {
+ this.AddedTimerToken(XSingleton<XTimerMgr>.singleton.SetTimer<XSkill.ESkillTimerCb>(args.delay, this._TimerCallback, args, XSkill.ESkillTimerCb.EExternalExecute), true);
+ }
+ return true;
+ }
+
+ protected void Manual()
+ {
+ bool flag = XSingleton<XGame>.singleton.SyncMode || this.MainCore.Soul.MultipleAttackSupported;
+ if (!flag)
+ {
+ bool feeding = XSingleton<XVirtualTab>.singleton.Feeding;
+ if (feeding)
+ {
+ this._firer.Net.ReportRotateAction(XSingleton<XVirtualTab>.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<ScriptCode>.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<ScriptCode>.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<ScriptCode>.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<ScriptCode>.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<XDebug>.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<XGame>.singleton.SyncMode;
+ if (!syncMode)
+ {
+ XBulletCore bulletCore = bullet.BulletCore;
+ List<XEntity> opponent = XSingleton<XEntityMgr>.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<XGame>.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<XGame>.singleton.SyncMode;
+ if (!syncMode)
+ {
+ List<XEntity> opponent = XSingleton<XEntityMgr>.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<XGame>.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<XGame>.singleton.SyncMode;
+ if (syncMode)
+ {
+ XSingleton<XLevelStatistics>.singleton.OnHitEnemy(dResult.ComboCount);
+ }
+ else
+ {
+ XSingleton<XLevelStatistics>.singleton.OnHitEnemy(-1);
+ }
+ }
+ else
+ {
+ XSingleton<XLevelStatistics>.singleton.OnEnemyHitEnemy(firer);
+ }
+ }
+ bool isPlayer2 = target.IsPlayer;
+ if (isPlayer2)
+ {
+ XSingleton<XLevelStatistics>.singleton.OnPlayerBeHit();
+ }
+ bool flag2 = rps == XStrickenResponse.Half_Endure || rps == XStrickenResponse.Full_Endure;
+ if (flag2)
+ {
+ XEndureEventArgs @event = XEventPool<XEndureEventArgs>.GetEvent();
+ @event.Firer = target;
+ @event.Fx = ((data.State == XBeHitState.Hit_Freezed) ? null : data.Fx);
+ @event.Dir = hurtDiretion;
+ @event.HitFrom = firer;
+ XSingleton<XEventMgr>.singleton.FireEvent(@event);
+ XHitEventArgs event2 = XEventPool<XHitEventArgs>.GetEvent();
+ event2.Firer = target;
+ XSingleton<XEventMgr>.singleton.FireEvent(event2);
+ }
+ else
+ {
+ bool flag3 = !dResult.IsTargetDead;
+ if (flag3)
+ {
+ switch (dResult.Result)
+ {
+ case ProjectResultType.PJRES_BATI:
+ {
+ XEndureEventArgs event3 = XEventPool<XEndureEventArgs>.GetEvent();
+ event3.Firer = target;
+ event3.Fx = ((data.State == XBeHitState.Hit_Freezed) ? null : data.Fx);
+ event3.Dir = hurtDiretion;
+ event3.HitFrom = firer;
+ XSingleton<XEventMgr>.singleton.FireEvent(event3);
+ XRenderComponent.OnHit(target);
+ break;
+ }
+ case ProjectResultType.PJRES_STUN:
+ {
+ bool flag4 = !XSingleton<XGame>.singleton.SyncMode;
+ if (flag4)
+ {
+ XFreezeEventArgs event4 = XEventPool<XFreezeEventArgs>.GetEvent();
+ event4.HitData = null;
+ event4.Dir = hurtDiretion;
+ event4.Duration = XSingleton<XGlobalConfig>.singleton.StunTime;
+ event4.Firer = target;
+ XSingleton<XEventMgr>.singleton.FireEvent(event4);
+ }
+ break;
+ }
+ case ProjectResultType.PJRES_BEHIT:
+ {
+ bool flag5 = !XSingleton<XGame>.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<XFreezeEventArgs>.GetEvent();
+ event5.HitData = data;
+ event5.Dir = hurtDiretion;
+ event5.Firer = target;
+ XSingleton<XEventMgr>.singleton.FireEvent(event5);
+ }
+ else
+ {
+ bool flag9 = target.CurState == XStateDefine.XState_Freeze;
+ if (flag9)
+ {
+ XEndureEventArgs event6 = XEventPool<XEndureEventArgs>.GetEvent();
+ event6.Firer = target;
+ event6.Fx = data.Fx;
+ event6.Dir = hurtDiretion;
+ event6.HitFrom = firer;
+ XSingleton<XEventMgr>.singleton.FireEvent(event6);
+ }
+ else
+ {
+ XBeHitEventArgs event7 = XEventPool<XBeHitEventArgs>.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<XEventMgr>.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<XHUDAddEventArgs>.GetEvent();
+ event8.DepracatedPass = true;
+ event8.damageResult = dResult;
+ event8.caster = firer;
+ event8.Firer = target;
+ XSingleton<XEventMgr>.singleton.FireEvent(event8);
+ }
+ XProjectDamageEventArgs event9 = XEventPool<XProjectDamageEventArgs>.GetEvent();
+ event9.Damage = dResult;
+ event9.Receiver = target;
+ event9.Firer = XSingleton<XGame>.singleton.Doc;
+ XSingleton<XEventMgr>.singleton.FireEvent(event9);
+ }
+ dResult.Recycle();
+ }
+
+ public static void ProcessDemonstrationStart(long token, uint skillId, XEntity firer, XEntity target, SkillExternalCallback callback)
+ {
+ HurtInfo data = XDataPool<HurtInfo>.GetData();
+ data.Caster = firer;
+ data.Target = target;
+ data.SkillID = skillId;
+ data.SkillToken = token;
+ data.Callback = callback;
+ XSingleton<XCombat>.singleton.ProjectDemonstrationStart(data);
+ data.Recycle();
+ }
+
+ public static void ProcessStart(long token, uint skillId, XEntity firer, XEntity target, SkillExternalCallback callback)
+ {
+ bool syncMode = XSingleton<XGame>.singleton.SyncMode;
+ if (!syncMode)
+ {
+ HurtInfo data = XDataPool<HurtInfo>.GetData();
+ data.Caster = firer;
+ data.Target = target;
+ data.SkillID = skillId;
+ data.SkillToken = token;
+ data.Callback = callback;
+ XSingleton<XCombat>.singleton.ProjectStart(data);
+ data.Recycle();
+ }
+ }
+
+ public static ProjectDamageResult ProcessHurt(long token, uint skillId, XEntity firer, XEntity target, int hitCount)
+ {
+ bool syncMode = XSingleton<XGame>.singleton.SyncMode;
+ ProjectDamageResult result;
+ if (syncMode)
+ {
+ result = null;
+ }
+ else
+ {
+ HurtInfo data = XDataPool<HurtInfo>.GetData();
+ data.Caster = firer;
+ data.Target = target;
+ data.HitPoint = hitCount;
+ data.SkillID = skillId;
+ data.SkillToken = token;
+ ProjectDamageResult projectDamageResult = XSingleton<XCombat>.singleton.ProjectDamage(data);
+ data.Recycle();
+ result = projectDamageResult;
+ }
+ return result;
+ }
+
+ public static void ProcessEnd(long token, uint skillId, XEntity firer, XEntity target)
+ {
+ bool syncMode = XSingleton<XGame>.singleton.SyncMode;
+ if (!syncMode)
+ {
+ HurtInfo data = XDataPool<HurtInfo>.GetData();
+ data.Caster = firer;
+ data.Target = target;
+ data.SkillID = skillId;
+ data.SkillToken = token;
+ XSingleton<XCombat>.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<XEntity> 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<XCommon>.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<XEntity> _skill_mobs = null;
+
+ private Dictionary<uint, uint> _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<uint, uint>.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<XEntity>.Get();
+ }
+ bool flag2 = e != null && !this._skill_mobs.Contains(e);
+ if (flag2)
+ {
+ this._skill_mobs.Add(e);
+ bool syncMode = XSingleton<XGame>.singleton.SyncMode;
+ if (syncMode)
+ {
+ result = true;
+ }
+ else
+ {
+ XOthersAttributes xothersAttributes = e.Attributes as XOthersAttributes;
+ bool flag3 = xothersAttributes != null && xothersAttributes.SummonGroup > 0 && xothersAttributes.SummonGroup < XSingleton<XGlobalConfig>.singleton.EntitySummonGroupLimit.Length;
+ if (flag3)
+ {
+ int num = XSingleton<XGlobalConfig>.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<XEntityMgr>.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<XSkillFactory>.singleton.CreateSkillMgr(this._entity);
+ }
+
+ public override void Attached()
+ {
+ bool flag = XSingleton<XGame>.singleton.CurrentStage.Stage != EXStage.Hall;
+ if (flag)
+ {
+ this._qte = (this._entity.GetXComponent(XQuickTimeEventComponent.uuID) as XQuickTimeEventComponent);
+ bool flag2 = !XSingleton<XScene>.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<XSkillFactory>.singleton.ReturnSkillMgr(this._skill_mgr);
+ this._skill_mgr = null;
+ }
+ this._skill = null;
+ XSingleton<XTimerMgr>.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<XEntity>.Release(this._skill_mobs);
+ this._skill_mobs = null;
+ }
+ bool flag3 = this._skills_replace_dic != null;
+ if (flag3)
+ {
+ DictionaryPool<uint, uint>.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<XResultData> 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<XStrengthPresevationOffArgs>.GetEvent();
+ @event.Host = this._entity;
+ @event.Firer = XSingleton<XGame>.singleton.Doc;
+ XSingleton<XEventMgr>.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<XGame>.singleton.SyncMode;
+ if (flag2)
+ {
+ xskillCore = this.PhysicalAttackAdaptor(xskillCore);
+ }
+ bool flag3 = xskillCore == null;
+ if (flag3)
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog("Skill ", identify.ToString(), " Physical-Adapter error.", null, null, null);
+ result = false;
+ }
+ else
+ {
+ bool flag4 = !XSingleton<XGame>.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<XGame>.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<XCommon>.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<XGlobalConfig>.singleton.MobMovePos.Length > i) ? XSingleton<XGlobalConfig>.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<XBulletMgr>.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<XScene>.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<XSkillFactory>.singleton.Build(skillprefix, template.A, this._entity));
+ }
+ bool flag5 = !string.IsNullOrEmpty(template.AA);
+ if (flag5)
+ {
+ this._entity.SkillMgr.AttachSkill(XSingleton<XSkillFactory>.singleton.Build(skillprefix, template.AA, this._entity), false);
+ }
+ bool flag6 = !string.IsNullOrEmpty(template.AAA);
+ if (flag6)
+ {
+ this._entity.SkillMgr.AttachSkill(XSingleton<XSkillFactory>.singleton.Build(skillprefix, template.AAA, this._entity), false);
+ }
+ bool flag7 = !string.IsNullOrEmpty(template.AAAA);
+ if (flag7)
+ {
+ this._entity.SkillMgr.AttachSkill(XSingleton<XSkillFactory>.singleton.Build(skillprefix, template.AAAA, this._entity), false);
+ }
+ bool flag8 = !string.IsNullOrEmpty(template.AAAAA);
+ if (flag8)
+ {
+ this._entity.SkillMgr.AttachSkill(XSingleton<XSkillFactory>.singleton.Build(skillprefix, template.AAAAA, this._entity), false);
+ }
+ bool flag9 = !string.IsNullOrEmpty(template.Ultra);
+ if (flag9)
+ {
+ this._entity.SkillMgr.AttachUltraSkill(XSingleton<XSkillFactory>.singleton.Build(skillprefix, template.Ultra, this._entity));
+ }
+ bool flag10 = !string.IsNullOrEmpty(template.Appear);
+ if (flag10)
+ {
+ this._entity.SkillMgr.AttachAppearSkill(XSingleton<XSkillFactory>.singleton.Build(skillprefix, template.Appear, this._entity));
+ }
+ bool flag11 = !string.IsNullOrEmpty(template.Disappear);
+ if (flag11)
+ {
+ this._entity.SkillMgr.AttachDisappearSkill(XSingleton<XSkillFactory>.singleton.Build(skillprefix, template.Disappear, this._entity));
+ }
+ bool flag12 = !string.IsNullOrEmpty(template.Dash);
+ if (flag12)
+ {
+ this._entity.SkillMgr.AttachDashSkill(XSingleton<XSkillFactory>.singleton.Build(skillprefix, template.Dash, this._entity));
+ }
+ bool flag13 = !string.IsNullOrEmpty(template.SuperArmorRecoverySkill);
+ if (flag13)
+ {
+ this._entity.SkillMgr.AttachRecoverySkill(XSingleton<XSkillFactory>.singleton.Build(skillprefix, template.SuperArmorRecoverySkill, this._entity));
+ }
+ bool flag14 = !string.IsNullOrEmpty(template.ArmorBroken);
+ if (flag14)
+ {
+ this._entity.SkillMgr.AttachBrokenSkill(XSingleton<XSkillFactory>.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<XSkillFactory>.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<XSkillEffectMgr>.singleton.GetSkillConfig(this._entity.Attributes.skillSlot[j], 0u);
+ bool flag18 = skillConfig == null;
+ if (flag18)
+ {
+ XSingleton<XDebug>.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<uint, uint>.Enumerator enumerator = this._entity.Attributes.SkillLevelInfo.LearnedSkills.GetEnumerator();
+ while (enumerator.MoveNext())
+ {
+ XSkillEffectMgr singleton = XSingleton<XSkillEffectMgr>.singleton;
+ KeyValuePair<uint, uint> keyValuePair = enumerator.Current;
+ SkillList.RowData skillConfig2 = singleton.GetSkillConfig(keyValuePair.Key, 0u);
+ bool flag19 = skillConfig2 == null;
+ if (flag19)
+ {
+ XDebug singleton2 = XSingleton<XDebug>.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<SkillTypeEnum>.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<uint> list = ListPool<uint>.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<XCommon>.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<uint>.Release(list);
+ bool flag23 = DlgBase<BattleMain, BattleMainBehaviour>.singleton.SkillHandler != null;
+ if (flag23)
+ {
+ DlgBase<BattleMain, BattleMainBehaviour>.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<XSkillEffectMgr>.singleton.GetSkillConfig(this._entity.Attributes.skillSlot[i], 0u);
+ bool flag2 = skillConfig == null;
+ if (flag2)
+ {
+ XSingleton<XDebug>.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<uint, uint>.Enumerator enumerator = this._entity.Attributes.SkillLevelInfo.LearnedSkills.GetEnumerator();
+ while (enumerator.MoveNext())
+ {
+ XSkillEffectMgr singleton = XSingleton<XSkillEffectMgr>.singleton;
+ KeyValuePair<uint, uint> keyValuePair = enumerator.Current;
+ SkillList.RowData skillConfig2 = singleton.GetSkillConfig(keyValuePair.Key, 0u);
+ bool flag3 = skillConfig2 == null;
+ if (flag3)
+ {
+ XDebug singleton2 = XSingleton<XDebug>.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<SkillTypeEnum>.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<XSkillFactory>.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<XSkillFactory>.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<XSkillFactory>.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<XSkillFactory>.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<XSkillFactory>.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<XSkillFactory>.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<XSkillFactory>.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<XSkillFactory>.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<XSkillFactory>.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<XSkillFactory>.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<XSkillFactory>.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<XSkillFactory>.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<XGame>.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<XGame>.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<XVirtualTab>.singleton.Feeding;
+ if (feeding)
+ {
+ bool flag2 = !soul.Soul.Logical.MoveType;
+ if (flag2)
+ {
+ soul = this._entity.SkillMgr.GetSkill(XSingleton<XCommon>.singleton.XHash(soul.Soul.Logical.Association_Skill));
+ }
+ }
+ else
+ {
+ bool moveType = soul.Soul.Logical.MoveType;
+ if (moveType)
+ {
+ soul = this._entity.SkillMgr.GetSkill(XSingleton<XCommon>.singleton.XHash(soul.Soul.Logical.Association_Skill));
+ }
+ }
+ }
+ return soul;
+ }
+
+ private void AttachFilter(SkillList.RowData data, uint id)
+ {
+ XSkillCore core = XSingleton<XSkillFactory>.singleton.Build(this._entity.Present.SkillPrefix, data.SkillScript, this._entity);
+ XSkillData.PreLoad = (this._entity.IsPlayer && !XSingleton<XScene>.singleton.IsMustTransform);
+ bool flag = this._entity.SkillMgr.GetPhysicalIdentity() == 0u && XSingleton<XCommon>.singleton.XHash(this._entity.Present.PresentLib.A) == id;
+ if (flag)
+ {
+ this._entity.SkillMgr.AttachPhysicalSkill(core);
+ }
+ else
+ {
+ bool flag2 = this._entity.SkillMgr.GetUltraIdentity() == 0u && XSingleton<XCommon>.singleton.XHash(this._entity.Present.PresentLib.Ultra) == id;
+ if (flag2)
+ {
+ this._entity.SkillMgr.AttachUltraSkill(core);
+ }
+ else
+ {
+ bool flag3 = this._entity.SkillMgr.GetAppearIdentity() == 0u && XSingleton<XCommon>.singleton.XHash(this._entity.Present.PresentLib.Appear) == id;
+ if (flag3)
+ {
+ this._entity.SkillMgr.AttachAppearSkill(core);
+ }
+ else
+ {
+ bool flag4 = this._entity.SkillMgr.GetDisappearIdentity() == 0u && XSingleton<XCommon>.singleton.XHash(this._entity.Present.PresentLib.Disappear) == id;
+ if (flag4)
+ {
+ this._entity.SkillMgr.AttachDisappearSkill(core);
+ }
+ else
+ {
+ bool flag5 = this._entity.SkillMgr.GetDashIdentity() == 0u && XSingleton<XCommon>.singleton.XHash(this._entity.Present.PresentLib.Dash) == id;
+ if (flag5)
+ {
+ this._entity.SkillMgr.AttachDashSkill(core);
+ }
+ else
+ {
+ bool flag6 = this._entity.SkillMgr.GetRecoveryIdentity() == 0u && XSingleton<XCommon>.singleton.XHash(this._entity.Present.PresentLib.SuperArmorRecoverySkill) == id;
+ if (flag6)
+ {
+ this._entity.SkillMgr.AttachRecoverySkill(core);
+ }
+ else
+ {
+ bool flag7 = this._entity.SkillMgr.GetBrokenIdentity() == 0u && XSingleton<XCommon>.singleton.XHash(this._entity.Present.PresentLib.ArmorBroken) == id;
+ if (flag7)
+ {
+ this._entity.SkillMgr.AttachRecoverySkill(core);
+ }
+ else
+ {
+ bool flag8 = XSingleton<XCommon>.singleton.XHash(this._entity.Present.PresentLib.AA) == id;
+ if (flag8)
+ {
+ this._entity.SkillMgr.AttachSkill(core, false);
+ }
+ else
+ {
+ bool flag9 = XSingleton<XCommon>.singleton.XHash(this._entity.Present.PresentLib.AAA) == id;
+ if (flag9)
+ {
+ this._entity.SkillMgr.AttachSkill(core, false);
+ }
+ else
+ {
+ bool flag10 = XSingleton<XCommon>.singleton.XHash(this._entity.Present.PresentLib.AAAA) == id;
+ if (flag10)
+ {
+ this._entity.SkillMgr.AttachSkill(core, false);
+ }
+ else
+ {
+ bool flag11 = XSingleton<XCommon>.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<XCommon>.singleton.XHash(this._entity.Present.PresentLib.A) == id;
+ if (!flag)
+ {
+ bool flag2 = XSingleton<XCommon>.singleton.XHash(this._entity.Present.PresentLib.Ultra) == id;
+ if (!flag2)
+ {
+ bool flag3 = XSingleton<XCommon>.singleton.XHash(this._entity.Present.PresentLib.Appear) == id;
+ if (!flag3)
+ {
+ bool flag4 = XSingleton<XCommon>.singleton.XHash(this._entity.Present.PresentLib.Disappear) == id;
+ if (!flag4)
+ {
+ bool flag5 = XSingleton<XCommon>.singleton.XHash(this._entity.Present.PresentLib.Dash) == id;
+ if (!flag5)
+ {
+ bool flag6 = XSingleton<XCommon>.singleton.XHash(this._entity.Present.PresentLib.SuperArmorRecoverySkill) == id;
+ if (!flag6)
+ {
+ bool flag7 = XSingleton<XCommon>.singleton.XHash(this._entity.Present.PresentLib.ArmorBroken) == id;
+ if (!flag7)
+ {
+ bool flag8 = XSingleton<XCommon>.singleton.XHash(this._entity.Present.PresentLib.AA) == id;
+ if (!flag8)
+ {
+ bool flag9 = XSingleton<XCommon>.singleton.XHash(this._entity.Present.PresentLib.AAA) == id;
+ if (!flag9)
+ {
+ bool flag10 = XSingleton<XCommon>.singleton.XHash(this._entity.Present.PresentLib.AAAA) == id;
+ if (!flag10)
+ {
+ bool flag11 = XSingleton<XCommon>.singleton.XHash(this._entity.Present.PresentLib.AAAAA) == id;
+ if (!flag11)
+ {
+ XSkillCore core = XSingleton<XSkillFactory>.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<XSkillEffectMgr>.singleton.GetXULIPower(this._firer));
+ }
+ }
+
+ public float CastRangeUpper
+ {
+ get
+ {
+ return this._soul.Cast_Range_Upper;
+ }
+ }
+
+ public float CastRangeLower
+ {
+ get
+ {
+ return this._soul.Cast_Range_Rect ? 0f : this._soul.Cast_Range_Lower;
+ }
+ }
+
+ public float CastScope
+ {
+ get
+ {
+ return this._soul.Cast_Range_Rect ? this._soul.Cast_Scope : (this._soul.Cast_Scope * 0.5f);
+ }
+ }
+
+ private XSkillData _soul = null;
+
+ private XSkill _carrier = null;
+
+ private XEntity _firer = null;
+
+ private bool _is_pvp_version = false;
+
+ private bool _is_init_cooling = false;
+
+ private bool _is_on_syntonic = false;
+
+ private float _static_cd = 1f;
+
+ private float _init_cd = 1f;
+
+ private uint _skill_level = 0u;
+
+ private uint _id = 0u;
+
+ private uint _long_id = 0u;
+
+ private int _carrier_id = 0;
+
+ private int _totally_running_time = 1;
+
+ private int _current_running_time = 1;
+
+ private uint _cd_token = 0u;
+
+ private uint _timer_token_skill_notify = 0u;
+
+ private bool _ever_fired = false;
+
+ private float _last_lock_and_load_time = 0f;
+
+ private float _offset = 0f;
+
+ private float _notify_at = 0f;
+
+ private float _semi_dynamic_cd_ratio = 0f;
+
+ private float _last_dynamic_cd = 0f;
+
+ private float _dynamic_cd_delta = 0f;
+
+ private float _dynamic_cd_ratio = 1f;
+
+ private int _preserved_strength = 0;
+
+ private string _trigger_token_string = null;
+
+ private List<ulong> _hurt_target;
+
+ private Rect _rect;
+
+ private static Rect s_rect;
+
+ private Vector3 _vOffset = Vector3.zero;
+
+ private XTimerMgr.ElapsedEventHandler _OnReloaded = null;
+
+ public List<XSkillCore.XSkillWarningPackage>[] WarningPosAt = null;
+
+ public List<XSkillCore.XWarningRandomPackage>[] WarningRandomAt = null;
+
+ public static int maxHurtCount = 0;
+
+ public struct XSkillWarningPackage
+ {
+ public Vector3 WarningAt;
+
+ public ulong WarningTo;
+ }
+
+ public struct XWarningRandomPackage
+ {
+ public ulong ID;
+
+ public List<uint> Pos;
+ }
+
+ public XSkillCore(XEntity firer, XSkillData data, uint longid)
+ {
+ this._firer = firer;
+ this._long_id = longid;
+ this._id = XSingleton<XCommon>.singleton.XHash(data.Name);
+ this._carrier_id = XSingleton<XSkillFactory>.singleton.GetTypeHash(data.TypeToken);
+ this._hurt_target = ListPool<ulong>.Get();
+ this.SoulRefine(data, false);
+ }
+
+ public void SoulRefine(XSkillData newsoul, bool ispvp = false)
+ {
+ this._notify_at = 0f;
+ this._soul = newsoul;
+ this._is_pvp_version = ispvp;
+ bool flag = this._soul.Warning != null && this._soul.Warning.Count > 0;
+ if (flag)
+ {
+ bool flag2 = this.WarningPosAt == null || this.WarningPosAt.Length != this._soul.Warning.Count;
+ if (flag2)
+ {
+ this.WarningPosAt = new List<XSkillCore.XSkillWarningPackage>[this._soul.Warning.Count];
+ for (int i = 0; i < this._soul.Warning.Count; i++)
+ {
+ this.WarningPosAt[i] = new List<XSkillCore.XSkillWarningPackage>();
+ }
+ }
+ }
+ this._offset = 0f;
+ bool flag3 = !XSingleton<XGame>.singleton.SyncMode && this._soul.Charge.Count > 0;
+ if (flag3)
+ {
+ bool using_Curve = this._soul.Charge[0].Using_Curve;
+ if (using_Curve)
+ {
+ IXCurve curve = XSingleton<XResourceLoaderMgr>.singleton.GetCurve(this._soul.Charge[0].Curve_Forward);
+ this._offset = Mathf.Abs(curve.GetValue(curve.length - 1) - curve.GetValue(0));
+ }
+ else
+ {
+ this._offset = Mathf.Abs(this._soul.Charge[0].Offset);
+ }
+ }
+ bool flag4 = this._OnReloaded == null;
+ if (flag4)
+ {
+ this._OnReloaded = new XTimerMgr.ElapsedEventHandler(this.OnReloaded);
+ }
+ this.InitCoreData(true);
+ }
+
+ public void Clear()
+ {
+ this._soul = null;
+ }
+
+ public void Uninit()
+ {
+ bool flag = this._hurt_target != null;
+ if (flag)
+ {
+ ListPool<ulong>.Release(this._hurt_target);
+ this._hurt_target = null;
+ }
+ this.ClearWarningPos();
+ }
+
+ public void Recycle(XEntity firer)
+ {
+ this._firer = firer;
+ this._last_lock_and_load_time = 0f;
+ this._dynamic_cd_ratio = 1f;
+ this._dynamic_cd_delta = 0f;
+ this.InitCoreData(true);
+ this._current_running_time = this._totally_running_time;
+ this._hurt_target = ListPool<ulong>.Get();
+ this.ClearWarningPos();
+ }
+
+ public bool ExternalCanCast()
+ {
+ bool flag = this._soul.Script != null && !string.IsNullOrEmpty(this._soul.Script.Start_Name);
+ bool result;
+ if (flag)
+ {
+ Type type = Type.GetType("XMainClient." + this._soul.Name);
+ MethodInfo method = type.GetMethod("ExternalCanCast");
+ result = (method == null || (bool)method.Invoke(null, null));
+ }
+ else
+ {
+ result = true;
+ }
+ return result;
+ }
+
+ public void StartCameraPostEffect()
+ {
+ XSingleton<XPostEffectMgr>.singleton.MakeEffectEnable(XPostEffect.RadialBlur, true);
+ }
+
+ public void EndCameraPostEffect()
+ {
+ XSingleton<XPostEffectMgr>.singleton.MakeEffectEnable(XPostEffect.RadialBlur, false);
+ }
+
+ public void AddHurtTarget(ulong id, int triggerTime)
+ {
+ bool flag = !this.Soul.Result[triggerTime].Loop && !this.Soul.Result[triggerTime].LongAttackEffect;
+ if (flag)
+ {
+ bool flag2 = !this.IsHurtEntity(id, triggerTime);
+ if (flag2)
+ {
+ this._hurt_target.Add((ulong)((long)triggerTime));
+ this._hurt_target.Add(id);
+ }
+ }
+ bool flag3 = this._hurt_target.Count > XSkillCore.maxHurtCount;
+ if (flag3)
+ {
+ XSkillCore.maxHurtCount = this._hurt_target.Count;
+ }
+ }
+
+ public bool IsHurtEntity(ulong id, int triggerTime)
+ {
+ int i = 0;
+ int count = this._hurt_target.Count;
+ while (i < count)
+ {
+ ulong num = this._hurt_target[i];
+ ulong num2 = this._hurt_target[i + 1];
+ bool flag = (int)num == triggerTime && id == num2;
+ if (flag)
+ {
+ return true;
+ }
+ i += 2;
+ }
+ return false;
+ }
+
+ public bool Fire(XSkill carrier)
+ {
+ bool demonstrationMode = carrier.DemonstrationMode;
+ bool result;
+ if (demonstrationMode)
+ {
+ result = true;
+ }
+ else
+ {
+ bool flag = this._soul.OnceOnly && this._ever_fired;
+ if (flag)
+ {
+ result = false;
+ }
+ else
+ {
+ bool cooledDown = this.CooledDown;
+ if (cooledDown)
+ {
+ this._carrier = carrier;
+ this.OnCdCall(this._current_running_time - 1, false);
+ result = true;
+ }
+ else
+ {
+ bool syncMode = XSingleton<XGame>.singleton.SyncMode;
+ if (syncMode)
+ {
+ this._carrier = carrier;
+ this._ever_fired = true;
+ result = true;
+ }
+ else
+ {
+ result = false;
+ }
+ }
+ }
+ }
+ return result;
+ }
+
+ public void OnCdCall(int left_running_time, bool syntonic = false)
+ {
+ this._ever_fired = true;
+ bool flag = !this.Reloading;
+ this._current_running_time = left_running_time;
+ this.CheckRunningTime();
+ bool flag2 = flag || syntonic;
+ if (flag2)
+ {
+ this._last_lock_and_load_time = Time.time;
+ float coolDown = this.GetCoolDown();
+ XSingleton<XTimerMgr>.singleton.KillTimer(this._cd_token);
+ this._cd_token = XSingleton<XTimerMgr>.singleton.SetTimer(coolDown, this._OnReloaded, null);
+ bool flag3 = this._notify_at > 0f && this._notify_at < coolDown;
+ if (flag3)
+ {
+ XSingleton<XTimerMgr>.singleton.KillTimer(this._timer_token_skill_notify);
+ this._timer_token_skill_notify = XSingleton<XTimerMgr>.singleton.SetTimer(coolDown - this._notify_at, new XTimerMgr.ElapsedEventHandler(this.OnCastNotify), null);
+ }
+ bool flag4 = !XSingleton<XGame>.singleton.SyncMode && !string.IsNullOrEmpty(this.Soul.Logical.Syntonic_CoolDown_Skill);
+ if (flag4)
+ {
+ this._is_on_syntonic = true;
+ XSkillCore skill = this._firer.SkillMgr.GetSkill(XSingleton<XCommon>.singleton.XHash(this.Soul.Logical.Syntonic_CoolDown_Skill));
+ bool flag5 = skill != null && skill != this && !skill.IsOnSyntonic;
+ if (flag5)
+ {
+ skill.OnCdCall(0, true);
+ }
+ this._is_on_syntonic = false;
+ }
+ }
+ }
+
+ public void Execute(XSkill carrier)
+ {
+ this._carrier = carrier;
+ this.ClearHurtTarget();
+ this.ClearWarningPos();
+ }
+
+ public void BuildRandomWarningPos(List<WarningItemSet> set)
+ {
+ bool flag = this._soul.Warning != null && this._soul.Warning.Count > 0 && this._soul.Warning.Count == set.Count;
+ if (flag)
+ {
+ bool flag2 = this.WarningRandomAt == null || this.WarningRandomAt.Length != this._soul.Warning.Count;
+ if (flag2)
+ {
+ this.WarningRandomAt = new List<XSkillCore.XWarningRandomPackage>[this._soul.Warning.Count];
+ for (int i = 0; i < this._soul.Warning.Count; i++)
+ {
+ this.WarningRandomAt[i] = new List<XSkillCore.XWarningRandomPackage>();
+ }
+ }
+ for (int j = 0; j < set.Count; j++)
+ {
+ this.WarningRandomAt[j].Clear();
+ for (int k = 0; k < set[j].WarningItem.Count; k++)
+ {
+ XSkillCore.XWarningRandomPackage xwarningRandomPackage = default(XSkillCore.XWarningRandomPackage);
+ xwarningRandomPackage.ID = set[j].WarningItem[k].ID;
+ xwarningRandomPackage.Pos = new List<uint>();
+ for (int l = 0; l < set[j].WarningItem[k].WarningPos.Count; l++)
+ {
+ xwarningRandomPackage.Pos.Add(set[j].WarningItem[k].WarningPos[l]);
+ }
+ this.WarningRandomAt[j].Add(xwarningRandomPackage);
+ }
+ }
+ }
+ }
+
+ public void ClearHurtTarget()
+ {
+ this._hurt_target.Clear();
+ }
+
+ public void ClearWarningPos()
+ {
+ bool flag = this.WarningPosAt == null;
+ if (!flag)
+ {
+ for (int i = 0; i < this._soul.Warning.Count; i++)
+ {
+ this.WarningPosAt[i].Clear();
+ }
+ }
+ }
+
+ public void Halt()
+ {
+ this._carrier = null;
+ }
+
+ public float GetElapsedCD()
+ {
+ return this.Reloading ? (Time.time - this._last_lock_and_load_time) : this.GetCoolDown();
+ }
+
+ public float GetCoolDown()
+ {
+ return this.CheckDynamicCD(this.CheckStaticCD());
+ }
+
+ public void AccelerateCD(float delta, bool ratio)
+ {
+ bool reloading = this.Reloading;
+ if (reloading)
+ {
+ if (ratio)
+ {
+ this._dynamic_cd_delta += (this.GetCoolDown() - this.GetElapsedCD()) * delta;
+ }
+ else
+ {
+ this._dynamic_cd_delta += delta;
+ }
+ this.GetCoolDown();
+ }
+ else
+ {
+ this._dynamic_cd_delta = 0f;
+ }
+ }
+
+ public void ResetStaticCD()
+ {
+ this._static_cd = XSingleton<XSkillEffectMgr>.singleton.GetSkillCDStaticRatio(this.ID, this._skill_level, this._firer.SkillCasterTypeID, XSingleton<XScene>.singleton.IsPVPScene) * this._soul.CoolDown;
+ bool reloading = this.Reloading;
+ if (reloading)
+ {
+ this.GetCoolDown();
+ }
+ }
+
+ public void AccelerateStaticCD(float delta)
+ {
+ bool flag = delta < 0f || delta > 1f;
+ if (!flag)
+ {
+ this._static_cd = (1f - delta) * this._static_cd;
+ bool reloading = this.Reloading;
+ if (reloading)
+ {
+ this.GetCoolDown();
+ }
+ }
+ }
+
+ private float CheckStaticCD()
+ {
+ return this._is_init_cooling ? this._init_cd : this._static_cd;
+ }
+
+ private float CheckDynamicCD(float static_cd)
+ {
+ float num = static_cd * XSingleton<XSkillEffectMgr>.singleton.CalcDynamicRatio(1f, this._semi_dynamic_cd_ratio);
+ bool reloading = this.Reloading;
+ if (reloading)
+ {
+ float num2 = XSingleton<XSkillEffectMgr>.singleton.CalcDynamicRatio(XSingleton<XSkillEffectMgr>.singleton.CanChangeCD(this.ID, this._skill_level, this._firer.SkillCasterTypeID) ? XSingleton<XSkillEffectMgr>.singleton.GetSkillCDDynamicRatio(this._firer.Attributes) : 1f, this._semi_dynamic_cd_ratio);
+ float time = Time.time;
+ bool flag = this._dynamic_cd_ratio != num2;
+ if (flag)
+ {
+ float num3 = num2 / this._dynamic_cd_ratio;
+ this._last_lock_and_load_time = time - (time - this._last_lock_and_load_time) * num3;
+ this._dynamic_cd_ratio = num2;
+ }
+ num = static_cd * this._dynamic_cd_ratio - this._dynamic_cd_delta;
+ bool flag2 = this._last_dynamic_cd != num;
+ if (flag2)
+ {
+ float num4 = num - (time - this._last_lock_and_load_time);
+ XSingleton<XTimerMgr>.singleton.KillTimer(this._cd_token);
+ bool flag3 = num4 > 0f;
+ if (flag3)
+ {
+ this._cd_token = XSingleton<XTimerMgr>.singleton.SetTimer(num4, this._OnReloaded, null);
+ }
+ else
+ {
+ this.CoolDown();
+ }
+ }
+ }
+ this._last_dynamic_cd = num;
+ return num;
+ }
+
+ public float GetTimeScale()
+ {
+ return (float)XSingleton<XSkillEffectMgr>.singleton.GetAttackSpeedRatio(this._firer.Attributes);
+ }
+
+ public float GetRange(int id)
+ {
+ return this._soul.Result[id].Range;
+ }
+
+ public float GetRangeLow(int id)
+ {
+ return this._soul.Result[id].Low_Range;
+ }
+
+ public float GetScope(int id)
+ {
+ return this._soul.Result[id].Sector_Type ? (this._soul.Result[id].Scope * 0.5f) : this._soul.Result[id].Scope;
+ }
+
+ public void CoolDown()
+ {
+ XSingleton<XTimerMgr>.singleton.KillTimer(this._cd_token);
+ this._current_running_time = this._totally_running_time;
+ this.OnReloaded(null);
+ }
+
+ private void OnReloaded(object o)
+ {
+ bool is_init_cooling = this._is_init_cooling;
+ if (is_init_cooling)
+ {
+ this._current_running_time = this._totally_running_time;
+ }
+ this._is_init_cooling = false;
+ this._current_running_time++;
+ this.CheckRunningTime();
+ bool reloading = this.Reloading;
+ if (reloading)
+ {
+ this._last_lock_and_load_time = Time.time;
+ float coolDown = this.GetCoolDown();
+ XSingleton<XTimerMgr>.singleton.KillTimer(this._cd_token);
+ bool flag = coolDown > 0f;
+ if (flag)
+ {
+ this._cd_token = XSingleton<XTimerMgr>.singleton.SetTimer(coolDown, this._OnReloaded, null);
+ }
+ }
+ else
+ {
+ XSingleton<XTimerMgr>.singleton.KillTimer(this._timer_token_skill_notify);
+ this._dynamic_cd_delta = 0f;
+ this._dynamic_cd_ratio = 1f;
+ }
+ }
+
+ private void OnCastNotify(object o)
+ {
+ SkillList.RowData skillConfig = XSingleton<XSkillEffectMgr>.singleton.GetSkillConfig(this.ID, this._skill_level, this._firer.SkillCasterTypeID);
+ bool flag = skillConfig != null;
+ if (flag)
+ {
+ DlgBase<BattleMain, BattleMainBehaviour>.singleton.ShowSkillRemainingCD(skillConfig.ScriptName, this._notify_at);
+ }
+ }
+
+ public void InitCoreData(bool ctor = false)
+ {
+ XAttributes attributes = this._firer.Attributes;
+ bool flag = attributes == null;
+ if (!flag)
+ {
+ this._skill_level = attributes.SkillLevelInfo.GetSkillLevel(this.ID);
+ this._static_cd = XSingleton<XSkillEffectMgr>.singleton.GetSkillCDStaticRatio(this.ID, this._skill_level, this._firer.SkillCasterTypeID, XSingleton<XScene>.singleton.IsPVPScene) * this._soul.CoolDown;
+ this._init_cd = XSingleton<XSkillEffectMgr>.singleton.GetSkillInitCDRatio(this.ID, this._skill_level, this._firer.SkillCasterTypeID, XSingleton<XScene>.singleton.IsPVPScene, attributes) * this._soul.CoolDown;
+ this._semi_dynamic_cd_ratio = XSingleton<XSkillEffectMgr>.singleton.GetSkillCDSemiDynamicRatio(attributes, this.ID);
+ this._preserved_strength = XSingleton<XSkillEffectMgr>.singleton.GetStrengthValue(this.ID, this._skill_level, this._firer.SkillCasterTypeID);
+ this._notify_at = XSingleton<XSkillEffectMgr>.singleton.GetRemainingCDNotify(this.ID, this._skill_level, this._firer.SkillCasterTypeID);
+ this._totally_running_time = XSingleton<XSkillEffectMgr>.singleton.GetUsageCount(this.ID, this._skill_level, this._firer.SkillCasterTypeID);
+ bool flag2 = this._totally_running_time == 0;
+ if (flag2)
+ {
+ this._totally_running_time = 1;
+ }
+ if (ctor)
+ {
+ this._current_running_time = this._totally_running_time;
+ }
+ if (ctor)
+ {
+ this._ever_fired = false;
+ }
+ bool reloading = this.Reloading;
+ if (reloading)
+ {
+ this.GetCoolDown();
+ }
+ }
+ }
+
+ private void CheckRunningTime()
+ {
+ bool flag = this._current_running_time < 0;
+ if (flag)
+ {
+ this._current_running_time = 0;
+ }
+ else
+ {
+ bool flag2 = this._current_running_time > this._totally_running_time;
+ if (flag2)
+ {
+ this._current_running_time = this._totally_running_time;
+ }
+ }
+ }
+
+ public void MakeCoolDownAtLaunch()
+ {
+ bool hasInitCD = this.HasInitCD;
+ if (hasInitCD)
+ {
+ this._current_running_time = 0;
+ this._is_init_cooling = true;
+ this._last_lock_and_load_time = Time.time;
+ XSingleton<XTimerMgr>.singleton.KillTimer(this._cd_token);
+ XSingleton<XTimerMgr>.singleton.KillTimer(this._timer_token_skill_notify);
+ this._cd_token = XSingleton<XTimerMgr>.singleton.SetTimer(this._init_cd, this._OnReloaded, null);
+ bool flag = this._notify_at > 0f && this._notify_at < this._init_cd;
+ if (flag)
+ {
+ this._timer_token_skill_notify = XSingleton<XTimerMgr>.singleton.SetTimer(this._init_cd - this._notify_at, new XTimerMgr.ElapsedEventHandler(this.OnCastNotify), null);
+ }
+ }
+ }
+
+ public bool CanCast(long token)
+ {
+ bool flag = token > 0L && token == this._firer.Machine.ActionToken;
+ bool result;
+ if (flag)
+ {
+ result = true;
+ }
+ else
+ {
+ XStateDefine xstateDefine = this._firer.Machine.State.IsFinished ? this._firer.Machine.Default : this._firer.Machine.Current;
+ result = (xstateDefine == XStateDefine.XState_Idle || xstateDefine == XStateDefine.XState_Move || xstateDefine == XStateDefine.XState_Charge);
+ }
+ return result;
+ }
+
+ public bool CanAct(XStateDefine state)
+ {
+ bool flag = this._carrier == null;
+ bool result;
+ if (flag)
+ {
+ bool flag2 = this._soul != null;
+ if (flag2)
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog(this._firer.ToString(), " SkillCore error: without carrier for core name ", this._soul.Name, null, null, null);
+ }
+ result = true;
+ }
+ else
+ {
+ float timeElapsed = this._carrier.TimeElapsed;
+ Vector3 position = this._firer.EngineObject.Position;
+ bool flag3 = true;
+ if (state != XStateDefine.XState_Idle)
+ {
+ if (state == XStateDefine.XState_Move)
+ {
+ bool flag4 = XSingleton<XCommon>.singleton.IsLess(timeElapsed, this._soul.Logical.Not_Move_End) && XSingleton<XCommon>.singleton.IsEqualGreater(timeElapsed, this._soul.Logical.Not_Move_At);
+ if (flag4)
+ {
+ flag3 = false;
+ bool multipleAttackSupported = this._soul.MultipleAttackSupported;
+ if (multipleAttackSupported)
+ {
+ this._firer.Skill.TagTrigger();
+ bool flag5 = this._firer.IsPlayer && XSingleton<XVirtualTab>.singleton.Feeding;
+ if (flag5)
+ {
+ this._carrier.SkillTowardsTo = XSingleton<XVirtualTab>.singleton.Direction;
+ }
+ }
+ else
+ {
+ this._carrier.Firer.Net.ReportRotateAction((this._firer.IsPlayer && XSingleton<XVirtualTab>.singleton.Feeding) ? XSingleton<XVirtualTab>.singleton.Direction : this._firer.Rotate.GetMeaningfulFaceVector3(), (this._soul.Logical.Rotate_Speed > 0f) ? this._soul.Logical.Rotate_Speed : this._firer.Attributes.RotateSpeed, 0L);
+ }
+ }
+ }
+ }
+ else
+ {
+ flag3 = false;
+ }
+ bool flag6 = flag3;
+ if (flag6)
+ {
+ this._firer.Skill.EndSkill(false, true);
+ }
+ result = flag3;
+ }
+ return result;
+ }
+
+ public bool CanRotate()
+ {
+ return this._carrier == null || (XSingleton<XCommon>.singleton.IsLess(this._carrier.TimeElapsed, this._soul.Logical.Rotate_End) && XSingleton<XCommon>.singleton.IsEqualGreater(this._carrier.TimeElapsed, this._soul.Logical.Rotate_At));
+ }
+
+ public bool CanMove()
+ {
+ return this._carrier == null || XSingleton<XCommon>.singleton.IsEqualGreater(this._carrier.TimeElapsed, this._soul.Logical.Not_Move_End) || XSingleton<XCommon>.singleton.IsLess(this._carrier.TimeElapsed, this._soul.Logical.Not_Move_At);
+ }
+
+ private static Vector3 ResultPos(Vector3 result_pos, Vector3 logical, float radius)
+ {
+ Vector3 vector = logical - result_pos;
+ vector.y = 0f;
+ float num = vector.magnitude;
+ vector.Normalize();
+ num = ((num > radius) ? (num - radius) : 0f);
+ return result_pos + vector * num;
+ }
+
+ private bool InnerIsInAttckField(int triggerTime, Vector3 pos, Vector3 forward, Vector3 targetPos, int shift)
+ {
+ Vector3 vector = targetPos - pos;
+ vector.y = 0f;
+ float magnitude = vector.magnitude;
+ float range = this.GetRange(triggerTime);
+ float scope = this.GetScope(triggerTime);
+ bool sector_Type = this._soul.Result[triggerTime].Sector_Type;
+ bool result;
+ if (sector_Type)
+ {
+ float num = (magnitude == 0f) ? 0f : Vector3.Angle(forward, vector);
+ result = (magnitude < range && magnitude >= this.GetRangeLow(triggerTime) && num <= scope);
+ }
+ else
+ {
+ Quaternion rotation = XSingleton<XCommon>.singleton.VectorToQuaternion(XSingleton<XCommon>.singleton.HorizontalRotateVetor3(forward, (float)this._soul.Result[triggerTime].None_Sector_Angle_Shift, true));
+ bool flag = magnitude > 0f;
+ if (flag)
+ {
+ vector.Normalize();
+ }
+ float num2 = scope / 2f;
+ float num3 = range / 2f;
+ this._rect.xMin = -num2;
+ this._rect.xMax = num2;
+ this._rect.yMin = (this._soul.Result[triggerTime].Rect_HalfEffect ? 0f : (-num3));
+ this._rect.yMax = num3;
+ result = XSingleton<XCommon>.singleton.IsInRect(magnitude * vector, this._rect, Vector3.zero, rotation);
+ }
+ return result;
+ }
+
+ public bool IsInAttckField(int triggerTime, Vector3 pos, Vector3 forward, XEntity target)
+ {
+ bool flag = !XEntity.ValideEntity(target);
+ bool result;
+ if (flag)
+ {
+ result = false;
+ }
+ else
+ {
+ XEntity xentity = target.IsTransform ? target.Transformer : target;
+ this._vOffset.Set(this._soul.Result[triggerTime].Offset_X, 0f, this._soul.Result[triggerTime].Offset_Z);
+ pos += this._firer.EngineObject.Rotation * this._vOffset;
+ bool huge = xentity.Present.PresentLib.Huge;
+ if (huge)
+ {
+ SeqListRef<float> hugeMonsterColliders = xentity.Present.PresentLib.HugeMonsterColliders;
+ for (int i = 0; i < hugeMonsterColliders.Count; i++)
+ {
+ float radius = hugeMonsterColliders[i, 2] * xentity.Scale;
+ bool flag2 = this.InnerIsInAttckField(triggerTime, pos, forward, XSkillCore.ResultPos(pos, xentity.HugeMonsterColliderCenter(i), radius), this._soul.Result[triggerTime].None_Sector_Angle_Shift);
+ if (flag2)
+ {
+ return true;
+ }
+ }
+ result = false;
+ }
+ else
+ {
+ result = this.InnerIsInAttckField(triggerTime, pos, forward, XSkillCore.ResultPos(pos, xentity.RadiusCenter, xentity.Radius), this._soul.Result[triggerTime].None_Sector_Angle_Shift);
+ }
+ }
+ return result;
+ }
+
+ public bool IsInAttckField(Vector3 pos, Vector3 forward, XEntity target)
+ {
+ return XEntity.ValideEntity(target) && this.GetAttckWeights(pos, forward, target) > float.MinValue;
+ }
+
+ public static XEntity FindTargetAt(Vector3 pos, Vector3 forward, float range, float lower, float scope, XEntity firer, bool sector = true)
+ {
+ XEntity result = null;
+ float num = float.MinValue;
+ List<XEntity> opponent = XSingleton<XEntityMgr>.singleton.GetOpponent(firer);
+ for (int i = 0; i < opponent.Count; i++)
+ {
+ bool flag = !XEntity.ValideEntity(opponent[i]) || opponent[i].Present.IsShowUp;
+ if (!flag)
+ {
+ float attckWeights = XSkillCore.GetAttckWeights(pos, forward, opponent[i], range, lower, scope, 0, sector);
+ bool flag2 = attckWeights > num;
+ if (flag2)
+ {
+ num = attckWeights;
+ result = opponent[i];
+ }
+ }
+ }
+ return result;
+ }
+
+ public XEntity FindTargetAt(Vector3 pos, Vector3 forward)
+ {
+ pos.x += this._soul.Cast_Offset_X;
+ pos.z += this._soul.Cast_Offset_Z;
+ return XSkillCore.FindTargetAt(pos, forward, this.CastRangeUpper, this.CastRangeLower, (float)((int)this.CastScope), this._firer, !this._soul.Cast_Range_Rect);
+ }
+
+ public bool CanReplacedBy(XSkillCore skill)
+ {
+ bool flag = (this._soul.Logical.CanReplacedby & 1 << skill.Soul.TypeToken) != 0;
+ bool flag2 = !flag;
+ if (flag2)
+ {
+ flag = XSingleton<XCommon>.singleton.IsGreater(this._carrier.TimeElapsed, this._soul.Logical.CanCancelAt);
+ bool flag3 = !flag && this._soul.TypeToken == 0;
+ if (flag3)
+ {
+ bool flag4 = this._soul.Ja != null && this._soul.Ja.Count > 0;
+ if (flag4)
+ {
+ XJAComboSkill xjacomboSkill = this._carrier as XJAComboSkill;
+ bool flag5 = xjacomboSkill != null && xjacomboSkill.DuringJA;
+ if (flag5)
+ {
+ uint num = XSingleton<XCommon>.singleton.XHash(this._soul.Ja[0].Name);
+ flag = (skill.ID == num);
+ bool flag6 = !flag;
+ if (flag6)
+ {
+ XSkillCore skill2 = this._firer.SkillMgr.GetSkill(XSingleton<XCommon>.singleton.XHash(this._soul.Ja[0].Name));
+ bool flag7 = skill2 != null && skill2.Soul.Logical.Association;
+ if (flag7)
+ {
+ num = XSingleton<XCommon>.singleton.XHash(skill2.Soul.Logical.Association_Skill);
+ flag = (skill.ID == num);
+ }
+ }
+ }
+ }
+ }
+ }
+ return flag;
+ }
+
+ private static float GetAttckWeights(Vector3 pos, Vector3 forward, XEntity target, float upper, float lower, float scope, int scopeshift, bool sector)
+ {
+ forward = XSingleton<XCommon>.singleton.HorizontalRotateVetor3(forward, (float)scopeshift, true);
+ XEntity xentity = target.IsTransform ? target.Transformer : target;
+ bool huge = xentity.Present.PresentLib.Huge;
+ float result;
+ if (huge)
+ {
+ float num = float.MinValue;
+ SeqListRef<float> hugeMonsterColliders = xentity.Present.PresentLib.HugeMonsterColliders;
+ for (int i = 0; i < hugeMonsterColliders.Count; i++)
+ {
+ float radius = hugeMonsterColliders[i, 2] * xentity.Scale;
+ float num2 = XSkillCore.InnerGetAttckWeights(pos, forward, target, upper, lower, scope, XSkillCore.ResultPos(pos, xentity.HugeMonsterColliderCenter(i), radius), sector);
+ bool flag = num2 > num;
+ if (flag)
+ {
+ num = num2;
+ }
+ }
+ result = num;
+ }
+ else
+ {
+ result = XSkillCore.InnerGetAttckWeights(pos, forward, target, upper, lower, scope, XSkillCore.ResultPos(pos, xentity.RadiusCenter, xentity.Radius), sector);
+ }
+ return result;
+ }
+
+ private static float InnerGetAttckWeights(Vector3 pos, Vector3 forward, XEntity target, float upper, float lower, float scope, Vector3 logical, bool sector)
+ {
+ float num = float.MinValue;
+ Vector3 vector = logical - pos;
+ vector.y = 0f;
+ float magnitude = vector.magnitude;
+ vector.Normalize();
+ float num2 = (magnitude == 0f) ? 0f : Vector3.Angle(forward, vector);
+ bool flag;
+ if (sector)
+ {
+ flag = (XSingleton<XCommon>.singleton.IsLess(magnitude, upper) && XSingleton<XCommon>.singleton.IsEqualGreater(magnitude, lower) && num2 <= scope);
+ }
+ else
+ {
+ Quaternion rotation = XSingleton<XCommon>.singleton.VectorToQuaternion(forward);
+ bool flag2 = magnitude > 0f;
+ if (flag2)
+ {
+ vector.Normalize();
+ }
+ float num3 = scope / 2f;
+ float num4 = upper / 2f;
+ XSkillCore.s_rect.xMin = -num3;
+ XSkillCore.s_rect.xMax = num3;
+ XSkillCore.s_rect.yMin = -num4;
+ XSkillCore.s_rect.yMax = num4;
+ flag = XSingleton<XCommon>.singleton.IsInRect(magnitude * vector, XSkillCore.s_rect, Vector3.zero, rotation);
+ }
+ bool flag3 = flag && target.CanSelected;
+ if (flag3)
+ {
+ num = 0f;
+ float num5 = magnitude - lower;
+ float num6 = upper - lower;
+ float num7 = num6 / ((XSingleton<XOperationData>.singleton.WithinRange == 0f) ? 1f : XSingleton<XOperationData>.singleton.WithinRange);
+ int num8 = XSingleton<XCommon>.singleton.IsInteger(num7) ? Mathf.FloorToInt(num7 + 0.05f) : Mathf.CeilToInt(num7);
+ float num9 = (float)XSingleton<XOperationData>.singleton.RangeWeight / (float)num8;
+ num7 = (float)num8 * (1f - num5 / num6);
+ int num10 = XSingleton<XCommon>.singleton.IsInteger(num7) ? Mathf.FloorToInt(num7 + 0.05f) : Mathf.CeilToInt(num7);
+ num += (float)num10 * num9;
+ num += (1f - num2 / scope) * num9;
+ bool flag4 = !target.IsRole && target.Buffs != null && target.Buffs.IsBuffStateOn(XBuffType.XBuffType_Immortal);
+ if (flag4)
+ {
+ num += (float)XSingleton<XOperationData>.singleton.ImmortalWeight;
+ }
+ bool isBoss = target.IsBoss;
+ if (isBoss)
+ {
+ num += (float)XSingleton<XOperationData>.singleton.BossWeight;
+ }
+ else
+ {
+ bool isElite = target.IsElite;
+ if (isElite)
+ {
+ num += (float)XSingleton<XOperationData>.singleton.EliteWeight;
+ }
+ else
+ {
+ bool isPuppet = target.IsPuppet;
+ if (isPuppet)
+ {
+ num += (float)XSingleton<XOperationData>.singleton.PupetWeight;
+ }
+ else
+ {
+ bool isRole = target.IsRole;
+ if (isRole)
+ {
+ num += (float)XSingleton<XOperationData>.singleton.RoleWeight;
+ }
+ else
+ {
+ num += (float)XSingleton<XOperationData>.singleton.EnemyWeight;
+ }
+ }
+ }
+ }
+ }
+ return num;
+ }
+
+ private float GetAttckWeights(Vector3 pos, Vector3 forward, XEntity target)
+ {
+ pos.x += this._soul.Cast_Offset_X;
+ pos.z += this._soul.Cast_Offset_Z;
+ return XSkillCore.GetAttckWeights(pos, forward, target, this.CastRangeUpper, this.CastRangeLower, (float)((int)this.CastScope), (int)this._soul.Cast_Scope_Shift, !this._soul.Cast_Range_Rect);
+ }
+
+ public float GetMultipleDirectionFactor()
+ {
+ bool flag = !this._carrier.MainCore.Soul.MultipleAttackSupported;
+ float result;
+ if (flag)
+ {
+ result = 1f;
+ }
+ else
+ {
+ XEntity target = this._carrier.Target;
+ Vector3 vector = (target != null) ? XSingleton<XCommon>.singleton.Horizontal(target.EngineObject.Position - this._firer.EngineObject.Position) : this._firer.EngineObject.Forward;
+ Vector3 skillTowardsTo = this._carrier.SkillTowardsTo;
+ vector.y = 0f;
+ bool flag2 = vector.sqrMagnitude == 0f;
+ if (flag2)
+ {
+ vector = Vector3.forward;
+ }
+ float num = Vector3.Angle(vector, skillTowardsTo);
+ num = (XSingleton<XCommon>.singleton.Clockwise(vector, skillTowardsTo) ? num : (360f - num));
+ result = num / 360f;
+ }
+ return result;
+ }
+ }
+}
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<XSkillEffectMgr>
+ {
+ private XTableAsyncLoader _async_loader = null;
+
+ private SkillList _skillTable = new SkillList();
+
+ public Dictionary<uint, uint> PreSkillDict = new Dictionary<uint, uint>(200);
+
+ private Dictionary<ulong, uint> _specialEnemyPreSkillDict = new Dictionary<ulong, uint>();
+
+ public uint EmptySkillHash = XSingleton<XCommon>.singleton.XHash("E");
+
+ private static CVSReader.RowDataCompare<SkillList.RowData, uint> comp = new CVSReader.RowDataCompare<SkillList.RowData, uint>(XSkillEffectMgr.SkillDataCompare);
+
+ private SkillLevelupRequest req = null;
+
+ private SkillEffect m_SkillEffect = new SkillEffect();
+
+ private List<uint> ret = null;
+
+ private HashSet<uint> 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<XCommon>.singleton.XHash(rowData.SkillScript), 0u, rowData.XEntityStatisticsID) == null;
+ if (flag)
+ {
+ XSingleton<XDebug>.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<XCommon>.singleton.XHash(rowData.ExSkillScript) << 32 | (ulong)rowData.XEntityStatisticsID;
+ this._specialEnemyPreSkillDict[key] = rowData.SkillScriptHash;
+ }
+ else
+ {
+ this.PreSkillDict[XSingleton<XCommon>.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<SkillList.RowData, uint>(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<SkillList.RowData, uint>(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<SkillList.RowData, uint>(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<XCommon>.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<XCommon>.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<CombatEffectHelper>.GetData();
+ data.Set(skillhash, XSingleton<XEntityMgr>.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<ItemDesc>();
+ }
+ 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<CombatEffectHelper>.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<XGlobalConfig>.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<CombatEffectHelper>.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<XGlobalConfig>.singleton.GeneralCombatParam;
+ }
+ return result;
+ }
+
+ public float CalcDynamicRatio(float dynamicCDRatio, float semiDynamicCDRatio)
+ {
+ float num = dynamicCDRatio + semiDynamicCDRatio;
+ return Mathf.Clamp(num, XSingleton<XGlobalConfig>.singleton.CDChangeLowerBound, XSingleton<XGlobalConfig>.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<XCommon>.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<BuffDesc>();
+ }
+ 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<XDebug>.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<XDebug>.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>();
+ }
+ 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<XDebug>.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<uint> GetProfSkillID(int profID)
+ {
+ bool flag = this.ret == null;
+ if (flag)
+ {
+ this.ret = new List<uint>();
+ }
+ bool flag2 = this.repeatHash == null;
+ if (flag2)
+ {
+ this.repeatHash = new HashSet<uint>();
+ }
+ 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<XCommon>.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<CombatEffectHelper>.GetData();
+ data.Set(skillID, caster);
+ bool flag3 = (skillConfig == null || skillConfig.MobBuffs == null) && !data.bHasEffect(CombatEffectType.CET_Skill_AddMobBuff);
+ if (flag3)
+ {
+ data.Recycle();
+ }
+ else
+ {
+ List<BuffDesc> list = ListPool<BuffDesc>.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<XBuffAddEventArgs>.GetEvent();
+ @event.xBuffDesc = list[j];
+ @event.xBuffDesc.CasterID = mobEntity.ID;
+ @event.Firer = mobEntity;
+ XSingleton<XEventMgr>.singleton.FireEvent(@event);
+ }
+ ListPool<BuffDesc>.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<XSkillExternalBuffArgs>.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<XSkillFactory>
+ {
+ private SmallBuffer<object> _skillData;
+
+ private SmallBuffer<object> _skillCache;
+
+ private SmallBuffer<object> _skillMgrCache;
+
+ public void OnSceneLoaded()
+ {
+ this._skillData.debugName = "XSkillCorePool._skillData";
+ this._skillCache.debugName = "XSkillCorePool._skillCache";
+ XSingleton<BufferPoolMgr>.singleton.GetSmallBuffer(ref this._skillData, 256, 0);
+ XSingleton<BufferPoolMgr>.singleton.GetSmallBuffer(ref this._skillCache, 256, 0);
+ XSingleton<BufferPoolMgr>.singleton.GetSmallBuffer(ref this._skillMgrCache, 256, 0);
+ XSingleton<XBulletMgr>.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<BufferPoolMgr>.singleton.ReturnSmallBuffer(ref this._skillData);
+ XSingleton<BufferPoolMgr>.singleton.ReturnSmallBuffer(ref this._skillCache);
+ XSingleton<BufferPoolMgr>.singleton.ReturnSmallBuffer(ref this._skillMgrCache);
+ XSingleton<XBulletMgr>.singleton.OnLeaveScene();
+ }
+
+ public XSkillCore Build(string skillprefix, string name, XEntity firer)
+ {
+ string text = skillprefix + name;
+ uint num = XSingleton<XCommon>.singleton.XHash(text);
+ XSkillCore xskillCore = firer.SkillMgr.GetSkill(XSingleton<XCommon>.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<XScene>.singleton.IsPVPScene && !xskillCore2.IsPvPVersion;
+ if (flag3)
+ {
+ bool flag4 = !string.IsNullOrEmpty(xskillCore2.Soul.PVP_Script_Name);
+ if (flag4)
+ {
+ XSkillData data = XSingleton<XResourceLoaderMgr>.singleton.GetData<XSkillData>(skillprefix + xskillCore2.Soul.PVP_Script_Name, ".txt");
+ data.Prefix = skillprefix;
+ data.Name = xskillCore2.Soul.Name;
+ xskillCore2.SoulRefine(data, true);
+ }
+ }
+ else
+ {
+ bool flag5 = !XSingleton<XScene>.singleton.IsPVPScene && xskillCore2.IsPvPVersion;
+ if (flag5)
+ {
+ XSkillData data2 = XSingleton<XResourceLoaderMgr>.singleton.GetData<XSkillData>(skillprefix + xskillCore2.Soul.Name, ".txt");
+ data2.Prefix = skillprefix;
+ xskillCore2.SoulRefine(data2, false);
+ }
+ }
+ return xskillCore2;
+ }
+ i++;
+ }
+ XSkillData data3 = XSingleton<XResourceLoaderMgr>.singleton.GetData<XSkillData>(text, ".txt");
+ data3.Prefix = skillprefix;
+ xskillCore = new XSkillCore(firer, data3, num);
+ bool flag6 = XSingleton<XScene>.singleton.IsPVPScene && !string.IsNullOrEmpty(xskillCore.Soul.PVP_Script_Name);
+ if (flag6)
+ {
+ XSkillData data4 = XSingleton<XResourceLoaderMgr>.singleton.GetData<XSkillData>(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<XDebug>.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<uint> 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<XSkillJAPassedEventArgs>.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<uint, uint> LearnedSkills
+ {
+ get
+ {
+ return this._SkillDicts;
+ }
+ }
+
+ public static int AuraSkillType = 4;
+
+ private Dictionary<uint, uint> _SkillDicts = new Dictionary<uint, uint>();
+
+ private Dictionary<uint, uint> _LinkedLevels = new Dictionary<uint, uint>();
+
+ private uint _DefaultLevel = 1u;
+
+ private XEntity _entity = null;
+
+ private XSkillFlags _Flags = new XSkillFlags();
+
+ private static List<SkillList.RowData> g_SkillsHavingEx = new List<SkillList.RowData>();
+
+ 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<uint, uint> keyValuePair in this._SkillDicts)
+ {
+ SkillList.RowData skillConfig = XSingleton<XSkillEffectMgr>.singleton.GetSkillConfig(keyValuePair.Key, keyValuePair.Value);
+ bool flag = skillConfig != null;
+ if (flag)
+ {
+ this._Flags.SetFlag(skillConfig.Flag);
+ }
+ }
+ }
+
+ public void Init(List<SkillInfo> 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<uint, uint>.Enumerator enumerator = this._SkillDicts.GetEnumerator();
+ while (enumerator.MoveNext())
+ {
+ XSkillEffectMgr singleton = XSingleton<XSkillEffectMgr>.singleton;
+ KeyValuePair<uint, uint> 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<XBuffAddEventArgs>.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<XEventMgr>.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<XSkillEffectMgr>.singleton.GetSkillConfig(num, 1u, entity.SkillCasterTypeID);
+ bool flag2 = skillConfig != null && !string.IsNullOrEmpty(skillConfig.LinkedSkill);
+ if (flag2)
+ {
+ uint skillOriginalLevel = this.GetSkillOriginalLevel(XSingleton<XCommon>.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<XEntityMgr>.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<XCommon>.singleton.XHash(byPresentID.OtherSkills[i]);
+ SkillList.RowData skillConfig = XSingleton<XSkillEffectMgr>.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<XCommon>.singleton.XHash(rowData.SkillScript);
+ bool flag6 = this.GetSkillLevel(XSingleton<XCommon>.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<XCommon>.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<XSkillEffectMgr>.singleton.GetPreSkill(XSingleton<XCommon>.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<uint> _physicals;
+
+ private SmallBuffer<object> _carriers;
+
+ private SmallBuffer<object> _core;
+
+ private Dictionary<uint, XSkillCore> _coreDic = new Dictionary<uint, XSkillCore>();
+
+ public SmallBuffer<object> 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<BufferPoolMgr>.singleton.GetSmallBuffer(ref this._physicals, 16, 0);
+ XSingleton<BufferPoolMgr>.singleton.GetSmallBuffer(ref this._carriers, 4, 0);
+ int i = 0;
+ int num = XSkillData.Skills.Length;
+ while (i < num)
+ {
+ this._carriers.Add(null);
+ i++;
+ }
+ XSingleton<BufferPoolMgr>.singleton.GetSmallBuffer(ref this._core, 16, 0);
+ XSingleton<BufferPoolMgr>.singleton.GetSmallBuffer(ref this.SkillOrder, 16, 0);
+ }
+
+ public void Uninitialize()
+ {
+ XSingleton<BufferPoolMgr>.singleton.ReturnSmallBuffer(ref this._physicals);
+ XSingleton<BufferPoolMgr>.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<XSkillFactory>.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<XSkillFactory>.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<XSkillFactory>.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<XSkillFactory>.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<XSkillFactory>.singleton.CreateSkill(this._host, id);
+ this._carriers[id] = xskill;
+ }
+ }
+ bool flag3 = xskill == null;
+ if (flag3)
+ {
+ XSingleton<XDebug>.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<XResourceLoaderMgr>.singleton.GetData<XSkillData>(XSingleton<XCommon>.singleton.StringCombine(entity.Present.SkillPrefix, name), ".txt");
+ data.Prefix = entity.Present.SkillPrefix;
+ uint skillHash = XSingleton<XCommon>.singleton.XHash(data.Name);
+ bool flag = skillLevel == 0u;
+ if (flag)
+ {
+ skillLevel = ((entity.Attributes == null) ? 1u : entity.Attributes.SkillLevelInfo.GetSkillLevel(XSingleton<XCommon>.singleton.XHash(data.Name)));
+ bool flag2 = skillLevel == 0u;
+ if (flag2)
+ {
+ skillLevel = 1u;
+ }
+ }
+ float num = (data != null) ? (XSingleton<XSkillEffectMgr>.singleton.GetSkillCDStaticRatio(skillHash, skillLevel, entity.SkillCasterTypeID, XSingleton<XScene>.singleton.IsPVPScene) * data.CoolDown) : 0f;
+ return entity.IsPlayer ? (num * XSingleton<XSkillEffectMgr>.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<XSkillEffectMgr>.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<XCommon>.singleton.XHash(xskillCore.Soul.Logical.Association_Skill));
+ }
+ bool flag2 = xskillCore.Soul.Ja != null && xskillCore.Soul.Ja.Count > 0;
+ if (flag2)
+ {
+ uint num = XSingleton<XCommon>.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<XSkillFactory>.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<XSkillFactory>.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<XSkillPreViewMgr>
+ {
+ 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<XResourceLoaderMgr>.singleton.CreateFromPrefab("Common/SkillBlackHouse", true, false) as GameObject);
+ this.BlackHouseCamera = this.BlackHouse.transform.Find("BasePoint/Camera").GetComponent<Camera>();
+ 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<XDebug>.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<XDebug>.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<XScene>.singleton.GameCamera.CameraTrans.position);
+ }
+ SkillList.RowData skillConfig = XSingleton<XSkillEffectMgr>.singleton.GetSkillConfig(skillID, 0u, statisticsID);
+ string name = (skillConfig.PreviewScript == "") ? skillConfig.SkillScript : skillConfig.PreviewScript;
+ XAttackShowArgs @event = XEventPool<XAttackShowArgs>.GetEvent();
+ @event.name = name;
+ @event.Firer = dummy;
+ XSingleton<XEventMgr>.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<XScene>.singleton.GameCamera.CameraTrans.position);
+ }
+ XAttackShowBeginArgs @event = XEventPool<XAttackShowBeginArgs>.GetEvent();
+ @event.Firer = dummy;
+ @event.XCamera = camera.transform.gameObject;
+ XSingleton<XEventMgr>.singleton.FireEvent(@event);
+ }
+ }
+
+ public void SkillShowEnd(XDummy dummy)
+ {
+ XAttackShowEndArgs @event = XEventPool<XAttackShowEndArgs>.GetEvent();
+ @event.ForceQuit = true;
+ @event.Firer = dummy;
+ XSingleton<XEventMgr>.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<XSkillQTEEventArgs>.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<XGameUI>.singleton.m_uiTool);
+
+ public XUIPool m_ArrowPool = new XUIPool(XSingleton<XGameUI>.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<XGameUI>.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<XGlobalConfig>.singleton.GetInt("AwakeSkillSlotOpen");
+ }
+ }
+
+ public bool IsSelfAwaked
+ {
+ get
+ {
+ return XSingleton<XAttributeMgr>.singleton.XPlayerData.TypeID / 1000u > 0u;
+ }
+ }
+
+ public static int AwakeSkillSlot
+ {
+ get
+ {
+ return XFastEnumIntEqualityComparer<XSkillSlot>.ToInt(XSkillSlot.Awake_Attack);
+ }
+ }
+
+ public new static readonly uint uuID = XSingleton<XCommon>.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<uint, bool> NewSkillDic = new Dictionary<uint, bool>();
+
+ private List<uint> _slot_unlock_level = new List<uint>();
+
+ public List<uint> TransferLimit = new List<uint>();
+
+ public readonly int TRANSFERNUM = 4;
+
+ private RenderTexture skillPreView;
+
+ public List<int> TurnProTaskIDList = new List<int>();
+
+ public List<int> NpcID = new List<int>();
+
+ 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<XEntityMgr>.singleton.Player;
+ uint sceneID = XSingleton<XScene>.singleton.SceneID;
+ this.Dummy = null;
+ bool flag = XSingleton<XGame>.singleton.CurrentStage.Stage == EXStage.Hall;
+ if (flag)
+ {
+ this.CalSkillPointTotalCount();
+ this.RefreshRedPoint();
+ }
+ }
+
+ private void GetSlotUnLockLevel()
+ {
+ string[] array = XSingleton<XGlobalConfig>.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<XGlobalConfig>.singleton.GetInt(string.Format("Promote{0}", i)));
+ }
+ this.TurnProTaskIDList = XSingleton<XGlobalConfig>.singleton.GetIntList("ChangeProTaskIds");
+ this.NpcID = XSingleton<XGlobalConfig>.singleton.GetIntList("ChangeProNpc");
+ this.SkillPageOpenLevel = XSingleton<XGlobalConfig>.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<RoleType>.ToInt(XSingleton<XAttributeMgr>.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<uint> profSkillID = XSingleton<XSkillEffectMgr>.singleton.GetProfSkillID(num2);
+ for (int i = 0; i < profSkillID.Count; i++)
+ {
+ uint skillOriginalLevel = XSingleton<XAttributeMgr>.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(profSkillID[i]);
+ SkillList.RowData skillConfig = XSingleton<XSkillEffectMgr>.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<uint> profSkillID2 = XSingleton<XSkillEffectMgr>.singleton.GetProfSkillID(num3);
+ for (int j = 0; j < profSkillID2.Count; j++)
+ {
+ uint skillOriginalLevel2 = XSingleton<XAttributeMgr>.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(profSkillID2[j]);
+ SkillList.RowData skillConfig2 = XSingleton<XSkillEffectMgr>.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<uint> profSkillID3 = XSingleton<XSkillEffectMgr>.singleton.GetProfSkillID(num4);
+ for (int k = 0; k < profSkillID3.Count; k++)
+ {
+ uint skillOriginalLevel3 = XSingleton<XAttributeMgr>.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(profSkillID3[k]);
+ SkillList.RowData skillConfig3 = XSingleton<XSkillEffectMgr>.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<XSkillEffectMgr>.singleton.GetSkillConfig(skillID, 0u);
+ bool flag = skillLevel != 0u && XSingleton<XSkillEffectMgr>.singleton.GetPreSkill(skillID, 0u) > 0u;
+ bool result;
+ if (flag)
+ {
+ result = false;
+ }
+ else
+ {
+ SkillLevelupRequest levelupRequest = XSingleton<XSkillEffectMgr>.singleton.GetLevelupRequest(skillID, skillLevel + (uint)addLevel);
+ bool flag2 = (ulong)skillLevel >= (ulong)((long)XSingleton<XSkillEffectMgr>.singleton.GetSkillMaxLevel(skillID, 0u));
+ if (flag2)
+ {
+ result = false;
+ }
+ else
+ {
+ bool flag3 = (ulong)XSingleton<XAttributeMgr>.singleton.XPlayerData.Level < (ulong)((long)levelupRequest.Level);
+ result = !flag3;
+ }
+ }
+ return result;
+ }
+
+ public bool SkillIsEquip(uint skillID)
+ {
+ uint num = skillID;
+ SkillList.RowData skillConfig = XSingleton<XSkillEffectMgr>.singleton.GetSkillConfig(skillID, 0u);
+ bool flag = skillConfig.ExSkillScript != "" && XSingleton<XAttributeMgr>.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(skillID) > 0u;
+ if (flag)
+ {
+ num = XSingleton<XSkillEffectMgr>.singleton.GetSkillID(skillConfig.ExSkillScript, 0u);
+ }
+ for (int i = 0; i < XSingleton<XAttributeMgr>.singleton.XPlayerData.skillSlot.Length; i++)
+ {
+ bool flag2 = XSingleton<XAttributeMgr>.singleton.XPlayerData.skillSlot[i] == skillID || XSingleton<XAttributeMgr>.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<XClientNetwork>.singleton.Send(rpcC2G_ResetSkill);
+ }
+
+ public void SendSkillLevelup()
+ {
+ RpcC2G_SkillLevelup rpcC2G_SkillLevelup = new RpcC2G_SkillLevelup();
+ rpcC2G_SkillLevelup.oArg.skillHash = this.CurrentSkillID;
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2G_SkillLevelup);
+ }
+
+ public void SendResetProf()
+ {
+ RpcC2G_ResetSkill rpcC2G_ResetSkill = new RpcC2G_ResetSkill();
+ rpcC2G_ResetSkill.oArg.resetType = ResetType.RESET_PROFESSION;
+ XSingleton<XClientNetwork>.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<XClientNetwork>.singleton.Send(rpcC2G_BindSkill);
+ }
+
+ public void QuerySwitchSkillPage()
+ {
+ RpcC2G_ChangeSkillSet rpcC2G_ChangeSkillSet = new RpcC2G_ChangeSkillSet();
+ rpcC2G_ChangeSkillSet.oArg.index = 1u - XSingleton<XAttributeMgr>.singleton.XPlayerData.SkillPageIndex;
+ XSingleton<XClientNetwork>.singleton.Send(rpcC2G_ChangeSkillSet);
+ }
+
+ public void OnSwitchSkillPageSuccess(uint index, SkillRecord data)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("SwitchSkillPageSuccess"), "fece00");
+ XSingleton<XAttributeMgr>.singleton.XPlayerData.SkillPageIndex = index;
+ XSingleton<XAttributeMgr>.singleton.XPlayerData.skillSlot = ((index == 0u) ? data.SkillSlot.ToArray() : data.SkillSlotTwo.ToArray());
+ XSingleton<XAttributeMgr>.singleton.XPlayerData.SkillLevelInfo.Init((index == 0u) ? data.Skills : data.SkillsTwo);
+ this.CalSkillPointTotalCount();
+ this.SkillRefresh(false, true);
+ }
+
+ public bool SkillPlayFinished(XEventArgs args)
+ {
+ bool flag = !DlgBase<XSkillTreeView, XSkillTreeBehaviour>.singleton.IsVisible();
+ bool result;
+ if (flag)
+ {
+ result = false;
+ }
+ else
+ {
+ DlgBase<XSkillTreeView, XSkillTreeBehaviour>.singleton.uiBehaviour.m_SkillPlayBtn.SetVisible(true);
+ bool flag2 = DlgBase<XSkillTreeView, XSkillTreeBehaviour>.singleton._skillDlgPromoteHandler.IsVisible();
+ if (flag2)
+ {
+ DlgBase<XSkillTreeView, XSkillTreeBehaviour>.singleton._skillDlgPromoteHandler.m_PlayBtn.SetVisible(true);
+ }
+ result = true;
+ }
+ return result;
+ }
+
+ public bool SkillPointChanged(XEventArgs args)
+ {
+ bool flag = XSingleton<XAttributeMgr>.singleton.XPlayerData == null;
+ bool result;
+ if (flag)
+ {
+ result = false;
+ }
+ else
+ {
+ XVirtualItemChangedEventArgs xvirtualItemChangedEventArgs = args as XVirtualItemChangedEventArgs;
+ ItemEnum itemID = (ItemEnum)xvirtualItemChangedEventArgs.itemID;
+ bool flag2 = XSingleton<XAttributeMgr>.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<XSkillTreeView, XSkillTreeBehaviour>.singleton.IsVisible();
+ if (flag5)
+ {
+ DlgBase<XSkillTreeView, XSkillTreeBehaviour>.singleton.CalAllTabRedPoint();
+ }
+ result = true;
+ }
+ return result;
+ }
+
+ public bool IsTurnProTaskFinish(XEventArgs args)
+ {
+ bool flag = XSingleton<XGame>.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<XAttributeMgr>.singleton.XPlayerData.TypeID;
+ for (int j = 0; j < 5; j++)
+ {
+ num /= 10u;
+ bool flag4 = num == 0u;
+ if (flag4)
+ {
+ DlgBase<XSkillTreeView, XSkillTreeBehaviour>.singleton.LastSelectPromote = j + 1;
+ bool flag5 = j + 1 == XSkillTreeView.AwakeIndex;
+ if (flag5)
+ {
+ this.AwakeTaskFinish();
+ }
+ else
+ {
+ DlgBase<XSkillTreeView, XSkillTreeBehaviour>.singleton.SetVisibleWithAnimation(true, null);
+ }
+ return true;
+ }
+ }
+ }
+ }
+ result = false;
+ }
+ }
+ return result;
+ }
+
+ private void AwakeTaskFinish()
+ {
+ XSingleton<XFxMgr>.singleton.CreateAndPlay("Effects/FX_Particle/Roles/Lzg_Ty/Ty_juexing", XSingleton<XEntityMgr>.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<XAttributeMgr>.singleton.XPlayerData.TypeID;
+ ProfessionTable.RowData byProfID = XSingleton<XEntityMgr>.singleton.RoleInfo.GetByProfID(key);
+ bool flag = byProfID == null;
+ if (flag)
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog("ProfessionTable config not found: profID = ", key.ToString(), null, null, null, null);
+ }
+ else
+ {
+ uint awakeHair = byProfID.AwakeHair;
+ XFashionStorageDocument specificDocument = XDocuments.GetSpecificDocument<XFashionStorageDocument>(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<XClientNetwork>.singleton.Send(rpcC2G_UseItem);
+ }
+ }
+ }
+
+ public static bool IsAvengerTaskDone(int prof)
+ {
+ XTaskDocument specificDocument = XDocuments.GetSpecificDocument<XTaskDocument>(XTaskDocument.uuID);
+ uint avengerTaskID = XSkillTreeDocument.GetAvengerTaskID(prof);
+ return specificDocument.TaskRecord.IsTaskFinished(avengerTaskID);
+ }
+
+ private static uint GetAvengerTaskID(int prof)
+ {
+ List<int> intList = XSingleton<XGlobalConfig>.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<XSkillTreeView, XSkillTreeBehaviour>.singleton.IsVisible();
+ if (!flag)
+ {
+ bool isPromoteHandlerShow = DlgBase<XSkillTreeView, XSkillTreeBehaviour>.singleton.IsPromoteHandlerShow;
+ if (isPromoteHandlerShow)
+ {
+ DlgBase<XSkillTreeView, XSkillTreeBehaviour>.singleton._skillDlgPromoteHandler.SetVisible(false);
+ DlgBase<XSkillTreeView, XSkillTreeBehaviour>.singleton.IsPromoteHandlerShow = false;
+ }
+ if (resetTabs)
+ {
+ DlgBase<XSkillTreeView, XSkillTreeBehaviour>.singleton.SetupTabs();
+ }
+ DlgBase<XSkillTreeView, XSkillTreeBehaviour>.singleton.Refresh(DlgBase<XSkillTreeView, XSkillTreeBehaviour>.singleton.LastSelectPromote, resetTabs, resetPosition);
+ DlgBase<XSkillTreeView, XSkillTreeBehaviour>.singleton.CalAllTabRedPoint();
+ }
+ }
+
+ public void OnSkillLevelUp(uint skillID)
+ {
+ bool flag = !DlgBase<XSkillTreeView, XSkillTreeBehaviour>.singleton.IsVisible();
+ if (!flag)
+ {
+ uint skillOriginalLevel = XSingleton<XAttributeMgr>.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(skillID);
+ SkillList.RowData skillConfig = XSingleton<XSkillEffectMgr>.singleton.GetSkillConfig(skillID, 0u);
+ DlgBase<XSkillTreeView, XSkillTreeBehaviour>.singleton.OnSkillLevelUp((int)skillConfig.XPostion, (int)skillConfig.YPostion);
+ bool flag2 = skillOriginalLevel == 1u && skillConfig.SkillType == 2;
+ if (flag2)
+ {
+ int num = XFastEnumIntEqualityComparer<XSkillSlot>.ToInt(XSkillSlot.Ultra_Attack);
+ bool flag3 = XSingleton<XAttributeMgr>.singleton.XPlayerData.skillSlot[num] == 0u;
+ if (flag3)
+ {
+ this.SendBindSkill(this.CurrentSkillID, (uint)num);
+ }
+ }
+ }
+ }
+
+ public int CheckPreSkillLevel(uint skillID)
+ {
+ uint skillOriginalLevel = XSingleton<XAttributeMgr>.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(skillID);
+ SkillList.RowData skillConfig = XSingleton<XSkillEffectMgr>.singleton.GetSkillConfig(skillID, skillOriginalLevel);
+ uint skillID2 = XSingleton<XSkillEffectMgr>.singleton.GetSkillID(skillConfig.PreSkill, 0u);
+ uint skillOriginalLevel2 = XSingleton<XAttributeMgr>.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<XAttributeMgr>.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(skillID);
+ SkillList.RowData skillConfig = XSingleton<XSkillEffectMgr>.singleton.GetSkillConfig(skillID, skillOriginalLevel);
+ uint skillID2 = XSingleton<XSkillEffectMgr>.singleton.GetSkillID(skillConfig.PreSkill, 0u);
+ uint skillOriginalLevel2 = XSingleton<XAttributeMgr>.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<XGame>.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<XGame>.singleton.Doc.XBagDoc.GetSkillPointCount(isAwake);
+ bool flag5 = num2 < (int)skillConfig.PreSkillPoint;
+ result = !flag5;
+ }
+ }
+ }
+ }
+ return result;
+ }
+
+ public bool CheckNew(uint skillID)
+ {
+ uint skillOriginalLevel = XSingleton<XAttributeMgr>.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(skillID);
+ SkillList.RowData skillConfig = XSingleton<XSkillEffectMgr>.singleton.GetSkillConfig(skillID, skillOriginalLevel);
+ uint skillID2 = XSingleton<XSkillEffectMgr>.singleton.GetSkillID(skillConfig.PreSkill, 0u);
+ uint skillOriginalLevel2 = XSingleton<XAttributeMgr>.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<XGame>.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<XAttributeMgr>.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(skillID);
+ SkillList.RowData skillConfig = XSingleton<XSkillEffectMgr>.singleton.GetSkillConfig(skillID, skillOriginalLevel);
+ uint skillID2 = XSingleton<XSkillEffectMgr>.singleton.GetSkillID(skillConfig.PreSkill, 0u);
+ uint skillOriginalLevel2 = XSingleton<XAttributeMgr>.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<XGame>.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<XGame>.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<XAttributeMgr>.singleton.XPlayerData.Level);
+ bool flag = byLevel == null;
+ bool result;
+ if (flag)
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog("Can't find skill tree show redpoint num level config from SkillTreeConfigTable, level = ", XSingleton<XAttributeMgr>.singleton.XPlayerData.Level.ToString(), null, null, null, null);
+ result = false;
+ }
+ else
+ {
+ uint skillOriginalLevel = XSingleton<XAttributeMgr>.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(skillID);
+ SkillList.RowData skillConfig = XSingleton<XSkillEffectMgr>.singleton.GetSkillConfig(skillID, skillOriginalLevel);
+ bool isAwake = skillConfig.IsAwake;
+ bool flag2 = XSingleton<XGame>.singleton.Doc.XBagDoc.GetSkillPointCount(isAwake) < (ulong)byLevel.RedPointShowNum;
+ if (flag2)
+ {
+ result = false;
+ }
+ else
+ {
+ uint skillID2 = XSingleton<XSkillEffectMgr>.singleton.GetSkillID(skillConfig.PreSkill, 0u);
+ uint skillOriginalLevel2 = XSingleton<XAttributeMgr>.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<XGame>.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<XGame>.singleton.Doc.XBagDoc.GetSkillPointCount(isAwake);
+ bool flag9 = num2 < (int)skillConfig.PreSkillPoint;
+ result = !flag9;
+ }
+ }
+ }
+ }
+ }
+ }
+ return result;
+ }
+
+ public void RefreshRedPoint()
+ {
+ int num = XFastEnumIntEqualityComparer<RoleType>.ToInt(XSingleton<XAttributeMgr>.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<uint> profSkillID = XSingleton<XSkillEffectMgr>.singleton.GetProfSkillID(num2);
+ for (int i = 0; i < profSkillID.Count; i++)
+ {
+ uint skillOriginalLevel = XSingleton<XAttributeMgr>.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(profSkillID[i]);
+ SkillList.RowData skillConfig = XSingleton<XSkillEffectMgr>.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<uint> profSkillID2 = XSingleton<XSkillEffectMgr>.singleton.GetProfSkillID(num3);
+ for (int j = 0; j < profSkillID2.Count; j++)
+ {
+ uint skillOriginalLevel2 = XSingleton<XAttributeMgr>.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(profSkillID2[j]);
+ SkillList.RowData skillConfig2 = XSingleton<XSkillEffectMgr>.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<uint> profSkillID3 = XSingleton<XSkillEffectMgr>.singleton.GetProfSkillID(num4);
+ for (int k = 0; k < profSkillID3.Count; k++)
+ {
+ uint skillOriginalLevel3 = XSingleton<XAttributeMgr>.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(profSkillID3[k]);
+ SkillList.RowData skillConfig3 = XSingleton<XSkillEffectMgr>.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<uint> profSkillID4 = XSingleton<XSkillEffectMgr>.singleton.GetProfSkillID(num5);
+ for (int l = 0; l < profSkillID4.Count; l++)
+ {
+ uint skillOriginalLevel4 = XSingleton<XAttributeMgr>.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(profSkillID4[l]);
+ SkillList.RowData skillConfig4 = XSingleton<XSkillEffectMgr>.singleton.GetSkillConfig(profSkillID4[l], skillOriginalLevel4);
+ bool flag8 = this.CheckRedPoint(profSkillID4[l]);
+ if (flag8)
+ {
+ this.RedPoint = true;
+ break;
+ }
+ }
+ }
+ XSingleton<XGameSysMgr>.singleton.RecalculateRedPointState(XSysDefine.XSys_Skill, true);
+ }
+
+ public void CalSkillPointTotalCount()
+ {
+ int num = XFastEnumIntEqualityComparer<RoleType>.ToInt(XSingleton<XAttributeMgr>.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<XGame>.singleton.Doc.XBagDoc.GetSkillPointCount(false);
+ this.TotalAwakeSkillPoint = (int)XSingleton<XGame>.singleton.Doc.XBagDoc.GetSkillPointCount(true);
+ bool flag = num2 > 0;
+ if (flag)
+ {
+ List<uint> profSkillID = XSingleton<XSkillEffectMgr>.singleton.GetProfSkillID(num2);
+ for (int i = 0; i < profSkillID.Count; i++)
+ {
+ uint skillOriginalLevel = XSingleton<XAttributeMgr>.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(profSkillID[i]);
+ SkillList.RowData skillConfig = XSingleton<XSkillEffectMgr>.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<uint> profSkillID2 = XSingleton<XSkillEffectMgr>.singleton.GetProfSkillID(num3);
+ for (int j = 0; j < profSkillID2.Count; j++)
+ {
+ uint skillOriginalLevel2 = XSingleton<XAttributeMgr>.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(profSkillID2[j]);
+ SkillList.RowData skillConfig2 = XSingleton<XSkillEffectMgr>.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<uint> profSkillID3 = XSingleton<XSkillEffectMgr>.singleton.GetProfSkillID(num4);
+ for (int k = 0; k < profSkillID3.Count; k++)
+ {
+ uint skillOriginalLevel3 = XSingleton<XAttributeMgr>.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(profSkillID3[k]);
+ SkillList.RowData skillConfig3 = XSingleton<XSkillEffectMgr>.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<uint> profSkillID4 = XSingleton<XSkillEffectMgr>.singleton.GetProfSkillID(num5);
+ for (int l = 0; l < profSkillID4.Count; l++)
+ {
+ uint skillOriginalLevel4 = XSingleton<XAttributeMgr>.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(profSkillID4[l]);
+ SkillList.RowData skillConfig4 = XSingleton<XSkillEffectMgr>.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<XSkillPreViewMgr>.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<XAttributeMgr>.singleton.XPlayerData.Outlook;
+ this.Dummy = XSingleton<XEntityMgr>.singleton.CreateDummy(XSingleton<XAttributeMgr>.singleton.XPlayerData.PresentID, XSingleton<XAttributeMgr>.singleton.XPlayerData.TypeID, outlook, true, true, true);
+ bool flag = this.Dummy == null;
+ if (flag)
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog("Dummy Creat Fail.", null, null, null, null, null);
+ }
+ else
+ {
+ this.Dummy.OverrideAnimClip("Idle", XSingleton<XEntityMgr>.singleton.Player.Present.PresentLib.AttackIdle, true, false);
+ XSingleton<XSkillPreViewMgr>.singleton.ResetDummyPos(this.Dummy);
+ }
+ }
+
+ public void DelDummy()
+ {
+ bool flag = this.Dummy != null;
+ if (flag)
+ {
+ XSingleton<XSkillPreViewMgr>.singleton.SkillShowEnd(this.Dummy);
+ XSingleton<XEntityMgr>.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<XSkillTreeView, XSkillTreeBehaviour>.singleton.IsVisible();
+ if (flag)
+ {
+ DlgBase<XSkillTreeView, XSkillTreeBehaviour>.singleton.CreateAndPlayFxFxFirework();
+ }
+ }
+
+ public bool IsExSkill(SkillList.RowData data)
+ {
+ return XSingleton<XSkillEffectMgr>.singleton.GetPreSkill(XSingleton<XCommon>.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<XAttributeMgr>.singleton.XPlayerData.TypeID % (uint)array[promote + 1]);
+ List<uint> profSkillID = XSingleton<XSkillEffectMgr>.singleton.GetProfSkillID(profID);
+ List<SkillTreeSortItem> list = new List<SkillTreeSortItem>();
+ for (int i = 0; i < profSkillID.Count; i++)
+ {
+ SkillTreeSortItem skillTreeSortItem = new SkillTreeSortItem();
+ skillTreeSortItem.skillID = profSkillID[i];
+ SkillList.RowData skillConfig = XSingleton<XSkillEffectMgr>.singleton.GetSkillConfig(profSkillID[i], 0u);
+ skillTreeSortItem.x = (int)skillConfig.XPostion;
+ skillTreeSortItem.y = (int)skillConfig.YPostion;
+ list.Add(skillTreeSortItem);
+ }
+ list.Sort(new Comparison<SkillTreeSortItem>(this.Compare));
+ return XSingleton<XAttributeMgr>.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<string> skillNames)
+ {
+ for (int i = 0; i < skillNames.Count; i++)
+ {
+ bool flag = skillNames[i] == string.Empty;
+ if (!flag)
+ {
+ uint skillID = XSingleton<XSkillEffectMgr>.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<int> hashList)
+ {
+ bool flag = hashList.Count == 0;
+ if (!flag)
+ {
+ List<SkillEmblem.RowData> skillRow = new List<SkillEmblem.RowData>();
+ XEmblemDocument specificDocument = XDocuments.GetSpecificDocument<XEmblemDocument>(XEmblemDocument.uuID);
+ for (int i = 0; i < hashList.Count; i++)
+ {
+ uint num = XSingleton<XAttributeMgr>.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<XAttributeMgr>.singleton.XPlayerData.skillSlot[slot];
+ bool flag2 = (ulong)num == skillHash;
+ if (!flag2)
+ {
+ List<SkillEmblem.RowData> skillRow = new List<SkillEmblem.RowData>();
+ XEmblemDocument specificDocument = XDocuments.GetSpecificDocument<XEmblemDocument>(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<SkillEmblem.RowData> 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<UiUtility>.singleton.ShowSystemTip(string.Format(XStringDefineProxy.GetString("Active_Emblem"), itemConf.ItemName[0], skillRow[i].SkillPPT), "fece00");
+ }
+ else
+ {
+ XSingleton<UiUtility>.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<XAttributeMgr>.singleton.XPlayerData.skillSlot.Length; i++)
+ {
+ uint num = XSingleton<XAttributeMgr>.singleton.XPlayerData.skillSlot[i];
+ bool flag3 = num > 0u && skillHash == num;
+ if (flag3)
+ {
+ return true;
+ }
+ }
+ result = false;
+ }
+ else
+ {
+ uint skillOriginalLevel = XSingleton<XAttributeMgr>.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(skillHash);
+ bool flag4 = skillOriginalLevel > 0u;
+ result = flag4;
+ }
+ return result;
+ }
+
+ public bool IsPassiveSkill(uint skillHash)
+ {
+ SkillList.RowData skillConfig = XSingleton<XSkillEffectMgr>.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<XSkillTreeView, XSkillTreeBehaviour>
+ {
+ 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<GameObject> _TabRedPointList = new List<GameObject>();
+
+ private bool _SwitchFrameState = true;
+
+ public bool IsPromoteHandlerShow = false;
+
+ public int LastSelectPromote;
+
+ private XSkillTreeDocument _doc = null;
+
+ private List<IXUICheckBox> _icbList = new List<IXUICheckBox>();
+
+ 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>(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<XGlobalConfig>.singleton.GetInt("FreeResetSkillLevel")));
+ this._skillDlgPromoteHandler = DlgHandlerBase.EnsureCreate<SkillDlgPromoteHandler>(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<XAttributeMgr>.singleton.XPlayerData.TypeID;
+ uint level = XSingleton<XAttributeMgr>.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<XAttributeMgr>.singleton.XPlayerData.TypeID % (uint)this.MI[i + 1]);
+ inputText = XSingleton<XProfessionSkillMgr>.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<BoxCollider>().enabled = true;
+ ixuicheckBox.RegisterOnCheckEventHandler(new CheckBoxOnCheckEventHandler(this.OnTabClick));
+ ixuisprite.RegisterSpriteClickEventHandler(null);
+ }
+ else
+ {
+ gameObject.GetComponent<BoxCollider>().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<XCombatEffectManager>.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<XSkillPreViewMgr>.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<SkillDlgPromoteHandler>(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<XAttributeMgr>.singleton.XPlayerData.TypeID / (uint)this.MI[Promote] == 0u;
+ if (flag)
+ {
+ this._TabRedPointList[Promote].SetActive(false);
+ }
+ else
+ {
+ int profID = (int)(XSingleton<XAttributeMgr>.singleton.XPlayerData.TypeID % (uint)this.MI[Promote + 1]);
+ List<uint> profSkillID = XSingleton<XSkillEffectMgr>.singleton.GetProfSkillID(profID);
+ for (int i = 0; i < profSkillID.Count; i++)
+ {
+ uint skillOriginalLevel = XSingleton<XAttributeMgr>.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(profSkillID[i]);
+ SkillList.RowData skillConfig = XSingleton<XSkillEffectMgr>.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<XAttributeMgr>.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<XSkillPreViewMgr>.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<XAttributeMgr>.singleton.XPlayerData.TypeID % (uint)this.MI[Promote + 1]);
+ base.uiBehaviour.m_SkillPool.ReturnAll(false);
+ base.uiBehaviour.m_ArrowPool.ReturnAll(false);
+ List<uint> profSkillID = XSingleton<XSkillEffectMgr>.singleton.GetProfSkillID(profID);
+ List<SkillTreeSortItem> list = new List<SkillTreeSortItem>();
+ for (int i = 0; i < profSkillID.Count; i++)
+ {
+ SkillTreeSortItem skillTreeSortItem = new SkillTreeSortItem();
+ skillTreeSortItem.skillID = profSkillID[i];
+ SkillList.RowData skillConfig = XSingleton<XSkillEffectMgr>.singleton.GetSkillConfig(profSkillID[i], 0u);
+ skillTreeSortItem.x = (int)skillConfig.XPostion;
+ skillTreeSortItem.y = (int)skillConfig.YPostion;
+ list.Add(skillTreeSortItem);
+ }
+ list.Sort(new Comparison<SkillTreeSortItem>(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<XAttributeMgr>.singleton.XPlayerData.Level < (ulong)((long)XSingleton<XGlobalConfig>.singleton.GetInt("FreeResetSkillLevel")));
+ int num = (int)XSingleton<XGame>.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<XGame>.singleton.Doc.XBagDoc.GetSkillPointCount(true), this._doc.TotalAwakeSkillPoint));
+ base.uiBehaviour.m_LeftSkillPoint.SetText(num.ToString());
+ base.uiBehaviour.m_ResetProBtn.SetEnabled(XSingleton<XAttributeMgr>.singleton.XPlayerData.TypeID > 10u);
+ base.uiBehaviour.m_ResetSkillBtn.SetEnabled((isAwake ? this._doc.TotalAwakeSkillPoint : this._doc.TotalSkillPoint) - (int)XSingleton<XGame>.singleton.Doc.XBagDoc.GetSkillPointCount(isAwake) != 1);
+ base.uiBehaviour.m_SwitchSkillPageBtn.SetGrey((ulong)XSingleton<XAttributeMgr>.singleton.XPlayerData.Level >= (ulong)((long)this._doc.SkillPageOpenLevel));
+ base.uiBehaviour.m_SkillPageText.SetEnabled((ulong)XSingleton<XAttributeMgr>.singleton.XPlayerData.Level >= (ulong)((long)this._doc.SkillPageOpenLevel));
+ base.uiBehaviour.m_SkillPageText.SetText(XStringDefineProxy.GetString(string.Format("SkillPage{0}", 1u - XSingleton<XAttributeMgr>.singleton.XPlayerData.SkillPageIndex)));
+ }
+
+ protected void SetupSkill(GameObject go, uint skillID)
+ {
+ uint skillOriginalLevel = XSingleton<XAttributeMgr>.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(skillID);
+ SkillList.RowData skillConfig = XSingleton<XSkillEffectMgr>.singleton.GetSkillConfig(skillID, skillOriginalLevel);
+ SkillList.RowData rowData = null;
+ bool flag = skillConfig.PreSkill != null && skillConfig.PreSkill != "";
+ if (flag)
+ {
+ uint skillID2 = XSingleton<XSkillEffectMgr>.singleton.GetSkillID(skillConfig.PreSkill, 0u);
+ rowData = XSingleton<XSkillEffectMgr>.singleton.GetSkillConfig(skillID2, 0u);
+ }
+ int skillMaxLevel = XSingleton<XSkillEffectMgr>.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<XAttributeMgr>.singleton.XPlayerData.Level;
+ if (flag)
+ {
+ XSingleton<UiUtility>.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<XAttributeMgr>.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(this._doc.CurrentSkillID);
+ SkillList.RowData skillConfig = XSingleton<XSkillEffectMgr>.singleton.GetSkillConfig(this._doc.CurrentSkillID, skillOriginalLevel);
+ bool flag = skillConfig == null;
+ if (flag)
+ {
+ XSingleton<XDebug>.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<XSkillEffectMgr>.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<XSkillPreViewMgr>.singleton.SkillShowEnd(this._doc.Dummy);
+ XSingleton<XSkillPreViewMgr>.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<ItemEnum>.ToInt(ItemEnum.AWAKE_SKILL_POINT) : XFastEnumIntEqualityComparer<ItemEnum>.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<XSkillEffectMgr>.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<XAttributeMgr>.singleton.XPlayerData.skillSlot.Length;
+ if (flag3)
+ {
+ num = XSingleton<XAttributeMgr>.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<XSkillEffectMgr>.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<XAttributeMgr>.singleton.XPlayerData.Level) ? 1f : 0f);
+ bool flag6 = skillSlotType == SkillTypeEnum.Skill_Buff && this._doc.GetSkillSlotUnLockLevel(XFastEnumIntEqualityComparer<XSkillSlot>.ToInt(XSkillSlot.Skill_1_Buff)) > XSingleton<XAttributeMgr>.singleton.XPlayerData.Level;
+ if (flag6)
+ {
+ base.uiBehaviour.m_SkillSlotList[i].SetAlpha(0f);
+ }
+ bool flag7 = num > 0u;
+ if (flag7)
+ {
+ uint skillOriginalLevel = XSingleton<XAttributeMgr>.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(num);
+ SkillList.RowData skillConfig2 = XSingleton<XSkillEffectMgr>.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<XSkillEffectMgr>.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<XSkillEffectMgr>.singleton.GetPreSkill(skillID, 0u);
+ uint num = 0u;
+ bool flag2 = preSkill > 0u;
+ if (flag2)
+ {
+ num = XSingleton<XAttributeMgr>.singleton.XPlayerData.SkillLevelInfo.GetSkillOriginalLevel(preSkill);
+ }
+ float num2;
+ float num3;
+ XSingleton<XSkillEffectMgr>.singleton.GetSkillDescriptValue(skillID, (preSkill == 0u) ? skillLevel : num, XSingleton<XGame>.singleton.Doc.XBagDoc.EmblemBag, out num2, out num3);
+ base.uiBehaviour.m_SkillCurrDesc.SetText(string.Format(XSingleton<UiUtility>.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<XSkillEffectMgr>.singleton.GetSkillDescriptValue(skillID, (preSkill == 0u) ? (skillLevel + 1u) : num, XSingleton<XGame>.singleton.Doc.XBagDoc.EmblemBag, out num2, out num3);
+ base.uiBehaviour.m_SkillNextDesc.SetText(string.Format(XSingleton<UiUtility>.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<XSkillEffectMgr>.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<XAttributeMgr>.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<XGame>.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<XSkillEffectMgr>.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<ModalDlg, ModalDlgBehaviour>.singleton._bHasGrey = false;
+ DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetVisible(false, true);
+ DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetSingleButtonMode(false);
+ int num = XSingleton<XGlobalConfig>.singleton.GetInt("SkillResetCost");
+ bool flag = (ulong)XSingleton<XAttributeMgr>.singleton.XPlayerData.Level < (ulong)((long)XSingleton<XGlobalConfig>.singleton.GetInt("FreeResetSkillLevel"));
+ if (flag)
+ {
+ num = 0;
+ }
+ bool flag2 = num != 0;
+ if (flag2)
+ {
+ DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetLabelsWithSymbols(string.Format(XSingleton<UiUtility>.singleton.ReplaceReturn(XStringDefineProxy.GetString(XStringDefine.SKILL_RESET_SP)), num, XLabelSymbolHelper.FormatSmallIcon(7)), XStringDefineProxy.GetString(XStringDefine.COMMON_OK), XStringDefineProxy.GetString(XStringDefine.COMMON_CANCEL));
+ }
+ else
+ {
+ DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetLabelsWithSymbols(string.Format(XStringDefineProxy.GetString("FREE_RESET_SKILL_POINT"), XSingleton<XGlobalConfig>.singleton.GetInt("FreeResetSkillLevel")), XStringDefineProxy.GetString(XStringDefine.COMMON_OK), XStringDefineProxy.GetString(XStringDefine.COMMON_CANCEL));
+ }
+ DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetModalCallback(new ButtonClickEventHandler(this.OnResetSpConfirmed), null);
+ DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetTweenTargetAndPlay(DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.uiBehaviour.gameObject);
+ }
+
+ private bool OnResetSpConfirmed(IXUIButton go)
+ {
+ this._doc.SendResetSkill();
+ DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetVisible(false, true);
+ return true;
+ }
+
+ private void OnResetProfClicked(IXUISprite sp)
+ {
+ DlgBase<ModalDlg, ModalDlgBehaviour>.singleton._bHasGrey = false;
+ DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetVisible(false, true);
+ DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetSingleButtonMode(false);
+ DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetLabelsWithSymbols(string.Format("{0}{1}", string.Format(XStringDefineProxy.GetString(XStringDefine.SKILL_RESET_PROF), XSingleton<XGlobalConfig>.singleton.GetInt("SkillResetProfession")), XLabelSymbolHelper.FormatSmallIcon(7)), XStringDefineProxy.GetString(XStringDefine.COMMON_OK), XStringDefineProxy.GetString(XStringDefine.COMMON_CANCEL));
+ DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetModalCallback(new ButtonClickEventHandler(this.OnResetProfConfirmed), null);
+ DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetTweenTargetAndPlay(DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.uiBehaviour.gameObject);
+ }
+
+ private bool OnResetProfConfirmed(IXUIButton go)
+ {
+ this._doc.SendResetProf();
+ DlgBase<ModalDlg, ModalDlgBehaviour>.singleton.SetVisible(false, true);
+ return true;
+ }
+
+ private void OnSwitchSkillPageBtnClick(IXUISprite iSp)
+ {
+ bool flag = (ulong)XSingleton<XAttributeMgr>.singleton.XPlayerData.Level < (ulong)((long)this._doc.SkillPageOpenLevel);
+ if (flag)
+ {
+ XSingleton<UiUtility>.singleton.ShowSystemTip(XStringDefineProxy.GetString("SkillPageOpenTips"), "fece00");
+ }
+ else
+ {
+ bool flag2 = Time.time - this._skillPageSwitchSignTime < 2f;
+ if (flag2)
+ {
+ XSingleton<UiUtility>.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<XSkillTreeView, XSkillTreeBehaviour>.singleton.IsVisible();
+ if (!flag)
+ {
+ base.uiBehaviour.m_LearnBtn.SetEnable(state, false);
+ }
+ }
+
+ public void CreateAndPlayFxFxFirework()
+ {
+ XSingleton<XAudioMgr>.singleton.PlayUISound("Audio/UI/zhuanzhi", true, AudioChannel.Action);
+ this.DestroyFx(this._FxFirework);
+ this._FxFirework = null;
+ this._FxFirework = XSingleton<XFxMgr>.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<XFxMgr>.singleton.DestroyFx(fx, true);
+ }
+ }
+
+ private void OnUnableCheckBoxClick(IXUISprite iSp)
+ {
+ XSingleton<UiUtility>.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: |