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/XCombinedSkill.cs | |
+scripts
Diffstat (limited to 'Client/Assets/Scripts/XMainClient/XCombinedSkill.cs')
| -rw-r--r-- | Client/Assets/Scripts/XMainClient/XCombinedSkill.cs | 534 |
1 files changed, 534 insertions, 0 deletions
diff --git a/Client/Assets/Scripts/XMainClient/XCombinedSkill.cs b/Client/Assets/Scripts/XMainClient/XCombinedSkill.cs new file mode 100644 index 00000000..c69ce4b4 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/XCombinedSkill.cs @@ -0,0 +1,534 @@ +using System;
+using XUtliPoolLib;
+
+namespace XMainClient
+{
+ internal sealed class XCombinedSkill : XArtsSkill
+ {
+ public override int SkillType
+ {
+ get
+ {
+ return 3;
+ }
+ }
+
+ public override XSkillCore MainCore
+ {
+ get
+ {
+ return this._main_core;
+ }
+ }
+
+ private XSkillCore _main_core = null;
+
+ private int _combined_id = 0;
+
+ private uint _combine_token = 0u;
+
+ private int _result_time = 0;
+
+ private bool _shut_down = false;
+
+ private float _shut_down_elapsed = 0f;
+
+ private SmallBuffer<uint> _combined_token;
+
+ private enum ECombinedSkillTimerCb
+ {
+ ECombined = 25,
+ ECombinedSkillNum
+ }
+
+ public override void Initialize(XEntity firer)
+ {
+ base.Initialize(firer);
+ this._combined_token.debugName = "XCombinedSkill._combined_token";
+ XSingleton<BufferPoolMgr>.singleton.GetSmallBuffer(ref this._combined_token, 16, 0);
+ }
+
+ public override void Uninitialize()
+ {
+ base.Uninitialize();
+ XSingleton<BufferPoolMgr>.singleton.ReturnSmallBuffer(ref this._combined_token);
+ }
+
+ protected override bool InnerProcessTimer(object param, int id)
+ {
+ bool flag = !base.InnerProcessTimer(param, id);
+ if (flag)
+ {
+ bool flag2 = id == 25;
+ if (flag2)
+ {
+ this.Combined(param);
+ return true;
+ }
+ }
+ return false;
+ }
+
+ public override uint GetCombinedId()
+ {
+ return (uint)this._combined_id;
+ }
+
+ public override void TriggerAnim()
+ {
+ bool flag = this._firer.Ator != null;
+ if (flag)
+ {
+ float normalizedTime = this.MainCore.Soul.Combined[this._combined_id].At / base.Core.Soul.Time;
+ this._firer.Ator.Play(XSkillData.CombinedOverrideMap[this._combined_id], 1, normalizedTime);
+ }
+ }
+
+ public void ShutDown()
+ {
+ this._shut_down = true;
+ }
+
+ protected override void FireEvents()
+ {
+ float at = this.MainCore.Soul.Combined[this._combined_id].At;
+ bool flag = this._data.Result != null;
+ if (flag)
+ {
+ for (int i = 0; i < this._data.Result.Count; i++)
+ {
+ bool flag2 = this._data.Result[i].LongAttackEffect || !XSingleton<XGame>.singleton.SyncMode || !this._demonstration;
+ if (flag2)
+ {
+ XResultData xresultData = this._data.Result[i];
+ int result_time = this._result_time;
+ this._result_time = result_time + 1;
+ xresultData.Token = result_time;
+ bool flag3 = this._data.Result[i].At >= at;
+ if (flag3)
+ {
+ float num = this._data.Result[i].At - at;
+ base.AddedTimerToken(XSingleton<XTimerMgr>.singleton.SetTimer<XArtsSkill.EArtsSkillTimerCb>(num * this._time_scale, this._TimerCallback, this._data.Result[i], XArtsSkill.EArtsSkillTimerCb.EOnResult), true);
+ }
+ }
+ }
+ }
+ bool flag4 = this._data.Charge != null;
+ if (flag4)
+ {
+ for (int j = 0; j < this._data.Charge.Count; j++)
+ {
+ float num2 = this._data.Charge[j].Using_Curve ? 0f : this._data.Charge[j].At;
+ bool flag5 = num2 >= at;
+ if (flag5)
+ {
+ base.AddedTimerToken(XSingleton<XTimerMgr>.singleton.SetTimer<XArtsSkill.EArtsSkillTimerCb>((num2 - at) * this._time_scale, this._TimerCallback, this._data.Charge[j], XArtsSkill.EArtsSkillTimerCb.ECharge), true);
+ }
+ else
+ {
+ int o = (int)((at - num2) * 1000f) << 16 | j;
+ base.ChargeTo(o);
+ }
+ }
+ }
+ bool flag6 = !XSingleton<XGame>.singleton.SyncMode || this._demonstration;
+ if (flag6)
+ {
+ bool flag7 = !this._demonstration;
+ if (flag7)
+ {
+ bool flag8 = this._data.Manipulation != null;
+ if (flag8)
+ {
+ for (int k = 0; k < this._data.Manipulation.Count; k++)
+ {
+ bool flag9 = this._data.Manipulation[k].At >= at;
+ if (flag9)
+ {
+ base.AddedTimerToken(XSingleton<XTimerMgr>.singleton.SetTimer<XArtsSkill.EArtsSkillTimerCb>(this._data.Manipulation[k].At * this._time_scale, this._TimerCallback, this._data.Manipulation[k], XArtsSkill.EArtsSkillTimerCb.EManipulate), true);
+ }
+ }
+ }
+ }
+ bool flag10 = this._data.Mob != null;
+ if (flag10)
+ {
+ for (int l = 0; l < this._data.Mob.Count; l++)
+ {
+ bool flag11 = this._data.Mob[l].TemplateID > 0 && this._data.Mob[l].At >= at;
+ if (flag11)
+ {
+ base.AddedTimerToken(XSingleton<XTimerMgr>.singleton.SetTimer<XArtsSkill.EArtsSkillTimerCb>(this._data.Mob[l].At * this._time_scale, this._TimerCallback, this._data.Mob[l], XArtsSkill.EArtsSkillTimerCb.EMob), true);
+ }
+ }
+ }
+ }
+ bool override_Presentation = this.MainCore.Soul.Combined[this._combined_id].Override_Presentation;
+ if (override_Presentation)
+ {
+ bool flag12 = this._data.Fx != null && !this._firer.MobShield;
+ if (flag12)
+ {
+ for (int m = 0; m < this._data.Fx.Count; m++)
+ {
+ bool flag13 = !this._data.Fx[m].Shield || !XSingleton<XInput>.singleton.FxShield(this._firer);
+ if (flag13)
+ {
+ bool flag14 = this._data.Fx[m].At >= at;
+ if (flag14)
+ {
+ base.AddedTimerToken(XSingleton<XTimerMgr>.singleton.SetTimer<XArtsSkill.EArtsSkillTimerCb>((this._data.Fx[m].At - at) * this._time_scale, this._TimerCallback, this._data.Fx[m], XArtsSkill.EArtsSkillTimerCb.EFx), false);
+ }
+ }
+ }
+ }
+ bool flag15 = this._data.Audio != null && this._firer.IsVisible && !this._firer.MobShield;
+ if (flag15)
+ {
+ for (int n = 0; n < this._data.Audio.Count; n++)
+ {
+ bool flag16 = this._data.Audio[n].At >= at;
+ if (flag16)
+ {
+ base.AddedTimerToken(XSingleton<XTimerMgr>.singleton.SetTimer<XArtsSkill.EArtsSkillTimerCb>((this._data.Audio[n].At - at) * this._time_scale, this._TimerCallback, this._data.Audio[n], XArtsSkill.EArtsSkillTimerCb.EAudio), false);
+ }
+ }
+ }
+ bool flag17 = this._demonstration || this._firer.IsPlayer || this._firer.IsBoss;
+ if (flag17)
+ {
+ bool flag18 = this._data.CameraEffect != null;
+ if (flag18)
+ {
+ for (int num3 = 0; num3 < this._data.CameraEffect.Count; num3++)
+ {
+ bool flag19 = this._data.CameraEffect[num3].At >= at;
+ if (flag19)
+ {
+ base.AddedTimerToken(XSingleton<XTimerMgr>.singleton.SetTimer<XArtsSkill.EArtsSkillTimerCb>((this._data.CameraEffect[num3].At - at) * this._time_scale, this._TimerCallback, this._data.CameraEffect[num3], XArtsSkill.EArtsSkillTimerCb.EShake), false);
+ }
+ }
+ }
+ bool flag20 = this._demonstration || this._firer.IsPlayer;
+ if (flag20)
+ {
+ bool flag21 = this._data.CameraMotion != null && !string.IsNullOrEmpty(this._data.CameraMotion.Motion3D);
+ if (flag21)
+ {
+ bool flag22 = this._data.CameraMotion.At >= at;
+ if (flag22)
+ {
+ base.AddedTimerToken(XSingleton<XTimerMgr>.singleton.SetTimer<XArtsSkill.EArtsSkillTimerCb>((this._data.CameraMotion.At - at) * this._time_scale, this._TimerCallback, this._core, XArtsSkill.EArtsSkillTimerCb.ECameraMotion), false);
+ }
+ }
+ bool flag23 = this._data.CameraPostEffect != null;
+ if (flag23)
+ {
+ bool flag24 = !this._demonstration && !string.IsNullOrEmpty(this._data.CameraPostEffect.Effect);
+ if (flag24)
+ {
+ bool flag25 = this._data.CameraPostEffect.At >= at;
+ if (flag25)
+ {
+ base.AddedTimerToken(XSingleton<XTimerMgr>.singleton.SetTimer<XArtsSkill.EArtsSkillTimerCb>((this._data.CameraPostEffect.At - at) * this._time_scale, this._TimerCallback, this._core, XArtsSkill.EArtsSkillTimerCb.ECameraPostEffect), false);
+ base.AddedTimerToken(XSingleton<XTimerMgr>.singleton.SetTimer<XArtsSkill.EArtsSkillTimerCb>((this._data.CameraPostEffect.End - at) * this._time_scale, this._TimerCallback, this._core, XArtsSkill.EArtsSkillTimerCb.EEndCameraPostEffect), false);
+ }
+ }
+ }
+ }
+ }
+ }
+ bool flag26 = this._data.Warning != null;
+ if (flag26)
+ {
+ for (int num4 = 0; num4 < this._data.Warning.Count; num4++)
+ {
+ bool flag27 = this._data.Warning[num4].At >= at;
+ if (flag27)
+ {
+ base.AddedTimerToken(XSingleton<XTimerMgr>.singleton.SetTimer<XArtsSkill.EArtsSkillTimerCb>((this._data.Warning[num4].At - at) * this._time_scale, this._TimerCallback, this._data.Warning[num4], XArtsSkill.EArtsSkillTimerCb.EWarning), false);
+ }
+ }
+ }
+ }
+
+ protected override bool Present()
+ {
+ bool shut_down = this._shut_down;
+ bool result;
+ if (shut_down)
+ {
+ result = !XSingleton<XCommon>.singleton.IsGreater(this._timeElapsed, this._shut_down_elapsed * this._time_scale);
+ }
+ else
+ {
+ result = base.Present();
+ }
+ return result;
+ }
+
+ public void CombinedStop(bool cleanUp)
+ {
+ bool combined_set_camera_effect = this._combined_set_camera_effect;
+ if (combined_set_camera_effect)
+ {
+ XCameraMotionEndEventArgs @event = XEventPool<XCameraMotionEndEventArgs>.GetEvent();
+ @event.Target = this._firer;
+ @event.Firer = this._affect_camera;
+ XSingleton<XEventMgr>.singleton.FireEvent(@event);
+ this._affect_camera.Ator.speed = 1f;
+ bool flag = this._firer.IsPlayer && this._end_solo_effect;
+ if (flag)
+ {
+ XSingleton<XScene>.singleton.GameCamera.TrySolo();
+ }
+ }
+ this._end_solo_effect = false;
+ this._combined_set_camera_effect = false;
+ bool combined_set_camera_shake = this._combined_set_camera_shake;
+ if (combined_set_camera_shake)
+ {
+ XCameraShakeEventArgs event2 = XEventPool<XCameraShakeEventArgs>.GetEvent();
+ event2.Effect = null;
+ event2.Firer = this._affect_camera;
+ XSingleton<XEventMgr>.singleton.FireEvent(event2);
+ }
+ this._combined_set_camera_shake = false;
+ bool demonstration = this._demonstration;
+ if (demonstration)
+ {
+ XAttackShowEndArgs event3 = XEventPool<XAttackShowEndArgs>.GetEvent();
+ event3.ForceQuit = false;
+ event3.Firer = this._firer;
+ XSingleton<XEventMgr>.singleton.FireEvent(event3);
+ }
+ for (int i = 0; i < this._combined_fx.Count; i++)
+ {
+ XFx fx = this._combined_fx[i] as XFx;
+ XSingleton<XFxMgr>.singleton.DestroyFx(fx, cleanUp);
+ }
+ XSingleton<XAudioMgr>.singleton.StopSound(this._firer, AudioChannel.SkillCombine);
+ bool flag2 = this.MainCore.Soul.Logical != null;
+ if (flag2)
+ {
+ bool flag3 = this.MainCore.PreservedStrength > 0;
+ if (flag3)
+ {
+ base.PreservedSEnd(null);
+ }
+ bool flag4 = this.MainCore.Soul.Logical.QTEData != null && this.MainCore.Soul.Logical.QTEData.Count != 0;
+ if (flag4)
+ {
+ base.QTEOff(null);
+ }
+ }
+ XSingleton<XTimerMgr>.singleton.KillTimer(this._combine_token);
+ this._combined_fx.Clear();
+ bool flag5 = this.MainCore.Soul.CameraPostEffect != null;
+ if (flag5)
+ {
+ bool flag6 = !this._demonstration && !string.IsNullOrEmpty(this.MainCore.Soul.CameraPostEffect.Effect);
+ if (flag6)
+ {
+ this.MainCore.EndCameraPostEffect();
+ }
+ bool flag7 = !this._demonstration && this.MainCore.Soul.CameraPostEffect.SolidBlack;
+ if (flag7)
+ {
+ this._affect_camera.SolidCancel();
+ }
+ }
+ bool combined_set_not_selected = this._combined_set_not_selected;
+ if (combined_set_not_selected)
+ {
+ this._firer.CanSelected = true;
+ }
+ this._combined_set_not_selected = false;
+ }
+
+ private void MainCoreStart()
+ {
+ this._result_time = 0;
+ this._shut_down = false;
+ this._combined_set_camera_effect = false;
+ this._combined_set_camera_shake = false;
+ this._combined_set_not_selected = false;
+ bool flag = this.MainCore.Soul.Logical != null && this.MainCore.Soul.Logical.QTEData != null;
+ if (flag)
+ {
+ for (int i = 0; i < this.MainCore.Soul.Logical.QTEData.Count; i++)
+ {
+ bool flag2 = this._firer.QTE != null && this.MainCore.Soul.Logical.QTEData[i].QTE != 0;
+ if (flag2)
+ {
+ this.AddedCombinedTimerToken(XSingleton<XTimerMgr>.singleton.SetTimer<XArtsSkill.EArtsSkillTimerCb>(this.MainCore.Soul.Logical.QTEData[i].At * this._time_scale, this._TimerCallback, this.MainCore.Soul.Logical.QTEData[i].QTE, XArtsSkill.EArtsSkillTimerCb.EQTEOn));
+ this.AddedCombinedTimerToken(XSingleton<XTimerMgr>.singleton.SetTimer<XArtsSkill.EArtsSkillTimerCb>(this.MainCore.Soul.Logical.QTEData[i].End * this._time_scale, this._TimerCallback, this.MainCore.Soul.Logical.QTEData[i].QTE, XArtsSkill.EArtsSkillTimerCb.EQTEOff));
+ }
+ }
+ }
+ bool flag3 = this.MainCore.Soul.Logical != null;
+ if (flag3)
+ {
+ bool flag4 = this.MainCore.Soul.Logical != null && this.MainCore.Soul.Logical.Not_Selected_End > 0f;
+ if (flag4)
+ {
+ this.AddedCombinedTimerToken(XSingleton<XTimerMgr>.singleton.SetTimer<XArtsSkill.EArtsSkillTimerCb>(this.MainCore.Soul.Logical.Not_Selected_At * this._time_scale, this._TimerCallback, this.MainCore, XArtsSkill.EArtsSkillTimerCb.ENotSelected));
+ this.AddedCombinedTimerToken(XSingleton<XTimerMgr>.singleton.SetTimer<XArtsSkill.EArtsSkillTimerCb>(this.MainCore.Soul.Logical.Not_Selected_End * this._time_scale, this._TimerCallback, null, XArtsSkill.EArtsSkillTimerCb.ENotSelected));
+ }
+ bool flag5 = this.MainCore.PreservedStrength > 0;
+ if (flag5)
+ {
+ this.AddedCombinedTimerToken(XSingleton<XTimerMgr>.singleton.SetTimer<XArtsSkill.EArtsSkillTimerCb>(this.MainCore.Soul.Logical.PreservedAt * this._time_scale, this._TimerCallback, this.MainCore.PreservedStrength, XArtsSkill.EArtsSkillTimerCb.EPreservedSAt));
+ this.AddedCombinedTimerToken(XSingleton<XTimerMgr>.singleton.SetTimer<XArtsSkill.EArtsSkillTimerCb>(this.MainCore.Soul.Logical.PreservedEndAt * this._time_scale, this._TimerCallback, null, XArtsSkill.EArtsSkillTimerCb.EPreservedSEnd));
+ }
+ bool flag6 = !XSingleton<XGame>.singleton.SyncMode && !string.IsNullOrEmpty(this.MainCore.Soul.Logical.Exstring);
+ if (flag6)
+ {
+ this.AddedCombinedTimerToken(XSingleton<XTimerMgr>.singleton.SetTimer<XArtsSkill.EArtsSkillTimerCb>(this.MainCore.Soul.Logical.Exstring_At * this._time_scale, this._TimerCallback, this.MainCore.Soul.Logical.Exstring, XArtsSkill.EArtsSkillTimerCb.EExString));
+ }
+ }
+ bool flag7 = this.MainCore.Soul.Fx != null && this._firer.IsVisible && !this._firer.MobShield;
+ if (flag7)
+ {
+ for (int j = 0; j < this.MainCore.Soul.Fx.Count; j++)
+ {
+ bool flag8 = !this.MainCore.Soul.Fx[j].Shield || !XSingleton<XInput>.singleton.FxShield(this._firer);
+ if (flag8)
+ {
+ this.AddedCombinedTimerToken(XSingleton<XTimerMgr>.singleton.SetTimer<XArtsSkill.EArtsSkillTimerCb>(this.MainCore.Soul.Fx[j].At * this._time_scale, this._TimerCallback, this.MainCore.Soul.Fx[j], XArtsSkill.EArtsSkillTimerCb.EFx));
+ }
+ }
+ }
+ bool flag9 = this.MainCore.Soul.Audio != null && !this._firer.MobShield;
+ if (flag9)
+ {
+ for (int k = 0; k < this.MainCore.Soul.Audio.Count; k++)
+ {
+ this.AddedCombinedTimerToken(XSingleton<XTimerMgr>.singleton.SetTimer<XArtsSkill.EArtsSkillTimerCb>(this.MainCore.Soul.Audio[k].At * this._time_scale, this._TimerCallback, this.MainCore.Soul.Audio[k], XArtsSkill.EArtsSkillTimerCb.EAudio));
+ }
+ }
+ bool flag10 = this._firer.IsPlayer || this._firer.IsBoss;
+ if (flag10)
+ {
+ bool flag11 = this.MainCore.Soul.CameraEffect != null;
+ if (flag11)
+ {
+ for (int l = 0; l < this.MainCore.Soul.CameraEffect.Count; l++)
+ {
+ this.AddedCombinedTimerToken(XSingleton<XTimerMgr>.singleton.SetTimer<XArtsSkill.EArtsSkillTimerCb>(this.MainCore.Soul.CameraEffect[l].At * this._time_scale, this._TimerCallback, this.MainCore.Soul.CameraEffect[l], XArtsSkill.EArtsSkillTimerCb.EShake));
+ }
+ }
+ bool isPlayer = this._firer.IsPlayer;
+ if (isPlayer)
+ {
+ bool flag12 = this.MainCore.Soul.CameraMotion != null && !string.IsNullOrEmpty(this.MainCore.Soul.CameraMotion.Motion);
+ if (flag12)
+ {
+ this.AddedCombinedTimerToken(XSingleton<XTimerMgr>.singleton.SetTimer<XArtsSkill.EArtsSkillTimerCb>(this.MainCore.Soul.CameraMotion.At * this._time_scale, this._TimerCallback, this.MainCore, XArtsSkill.EArtsSkillTimerCb.ECameraMotion));
+ }
+ bool flag13 = this.MainCore.Soul.CameraPostEffect != null;
+ if (flag13)
+ {
+ bool flag14 = !this._demonstration && !string.IsNullOrEmpty(this.MainCore.Soul.CameraPostEffect.Effect);
+ if (flag14)
+ {
+ this.AddedCombinedTimerToken(XSingleton<XTimerMgr>.singleton.SetTimer<XArtsSkill.EArtsSkillTimerCb>(this.MainCore.Soul.CameraPostEffect.At * this._time_scale, this._TimerCallback, this.MainCore, XArtsSkill.EArtsSkillTimerCb.ECameraPostEffect));
+ this.AddedCombinedTimerToken(XSingleton<XTimerMgr>.singleton.SetTimer<XArtsSkill.EArtsSkillTimerCb>(this.MainCore.Soul.CameraPostEffect.End * this._time_scale, this._TimerCallback, this.MainCore, XArtsSkill.EArtsSkillTimerCb.EEndCameraPostEffect));
+ }
+ bool flag15 = !this._demonstration && this.MainCore.Soul.CameraPostEffect.SolidBlack;
+ if (flag15)
+ {
+ this.AddedCombinedTimerToken(XSingleton<XTimerMgr>.singleton.SetTimer<XArtsSkill.EArtsSkillTimerCb>(this.MainCore.Soul.CameraPostEffect.Solid_At * this._time_scale, this._TimerCallback, this.MainCore, XArtsSkill.EArtsSkillTimerCb.ESolidBlack));
+ this.AddedCombinedTimerToken(XSingleton<XTimerMgr>.singleton.SetTimer<XArtsSkill.EArtsSkillTimerCb>(this.MainCore.Soul.CameraPostEffect.Solid_End * this._time_scale, this._TimerCallback, null, XArtsSkill.EArtsSkillTimerCb.ESolidBlack));
+ }
+ }
+ }
+ }
+ bool suppressPlayer = this.MainCore.Soul.Logical.SuppressPlayer;
+ if (suppressPlayer)
+ {
+ XSingleton<XEntityMgr>.singleton.DummilizePlayer(true);
+ }
+ }
+
+ protected override bool Launch(XSkillCore core)
+ {
+ bool flag = core.Soul.Combined.Count > 0;
+ bool result;
+ if (flag)
+ {
+ this._main_core = core;
+ this.MainCore.Execute(this);
+ this.MainCoreStart();
+ this.Combined(0);
+ result = true;
+ }
+ else
+ {
+ result = false;
+ }
+ return result;
+ }
+
+ public void CombinedKillTimerAll()
+ {
+ for (int i = 0; i < this._combined_token.Count; i++)
+ {
+ XSingleton<XTimerMgr>.singleton.KillTimer(this._combined_token[i]);
+ }
+ this._combined_token.Clear();
+ }
+
+ private void Combined(object param)
+ {
+ this._combined_id = (int)param;
+ XSkillCore skill = this._skillmgr.GetSkill(XSingleton<XCommon>.singleton.XHash(this.MainCore.Soul.Combined[this._combined_id].Name));
+ bool flag = skill != null;
+ if (flag)
+ {
+ bool flag2 = this._combined_id > 0;
+ if (flag2)
+ {
+ bool flag3 = this._stop_method != null;
+ if (flag3)
+ {
+ this._stop_method(this);
+ }
+ bool shut_down = this._shut_down;
+ if (shut_down)
+ {
+ this._shut_down_elapsed = 0f;
+ for (int i = 0; i < this._combined_id; i++)
+ {
+ XSkillCore skill2 = this._skillmgr.GetSkill(XSingleton<XCommon>.singleton.XHash(this.MainCore.Soul.Combined[i].Name));
+ this._shut_down_elapsed += ((skill2 != null) ? skill2.Soul.Time : 0f);
+ }
+ return;
+ }
+ XEntity target = this._demonstration ? null : base.Target;
+ base.Puppetize(false);
+ this._target = target;
+ this._firer.Skill.TagTrigger();
+ bool flag4 = this._firer.Ator != null;
+ if (flag4)
+ {
+ this._firer.Ator.speed = 0f;
+ }
+ base.AnimInit = false;
+ }
+ this._core = skill;
+ this._data = this._core.Soul;
+ bool flag5 = this._combined_id + 1 < this.MainCore.Soul.Combined.Count;
+ if (flag5)
+ {
+ this._combine_token = XSingleton<XTimerMgr>.singleton.SetTimer<XCombinedSkill.ECombinedSkillTimerCb>((this.MainCore.Soul.Combined[this._combined_id].End - this.MainCore.Soul.Combined[this._combined_id].At) * this._time_scale, this._TimerCallback, this._combined_id + 1, XCombinedSkill.ECombinedSkillTimerCb.ECombined);
+ }
+ }
+ }
+
+ public void AddedCombinedTimerToken(uint token)
+ {
+ this._combined_token.Add(token);
+ }
+ }
+}
|