From 6eb915c129fc90c6f4c82ae097dd6ffad5239efc Mon Sep 17 00:00:00 2001 From: chai Date: Mon, 25 Jan 2021 14:28:30 +0800 Subject: +scripts --- .../XMainClient/Components/ActionStates.meta | 9 + .../ActionStates/XActionStateComponent.cs | 253 ++++++ .../ActionStates/XActionStateComponent.cs.meta | 12 + .../Components/ActionStates/XBeHitComponent.cs | 895 +++++++++++++++++++++ .../ActionStates/XBeHitComponent.cs.meta | 12 + .../Components/ActionStates/XBeHitEventArgs.cs | 35 + .../ActionStates/XBeHitEventArgs.cs.meta | 12 + .../Components/ActionStates/XChargeComponent.cs | 422 ++++++++++ .../ActionStates/XChargeComponent.cs.meta | 12 + .../Components/ActionStates/XChargeEventArgs.cs | 39 + .../ActionStates/XChargeEventArgs.cs.meta | 12 + .../Components/ActionStates/XDeathComponent.cs | 335 ++++++++ .../ActionStates/XDeathComponent.cs.meta | 12 + .../Components/ActionStates/XFallComponent.cs | 109 +++ .../Components/ActionStates/XFallComponent.cs.meta | 12 + .../Components/ActionStates/XFallEventArgs.cs | 24 + .../Components/ActionStates/XFallEventArgs.cs.meta | 12 + .../Components/ActionStates/XFreezeComponent.cs | 229 ++++++ .../ActionStates/XFreezeComponent.cs.meta | 12 + .../Components/ActionStates/XFreezeEventArgs.cs | 32 + .../ActionStates/XFreezeEventArgs.cs.meta | 12 + .../Components/ActionStates/XIdleComponent.cs | 122 +++ .../Components/ActionStates/XIdleComponent.cs.meta | 12 + .../Components/ActionStates/XIdleEventArgs.cs | 18 + .../Components/ActionStates/XIdleEventArgs.cs.meta | 12 + .../Components/ActionStates/XJumpComponent.cs | 130 +++ .../Components/ActionStates/XJumpComponent.cs.meta | 12 + .../Components/ActionStates/XJumpEventArgs.cs | 27 + .../Components/ActionStates/XJumpEventArgs.cs.meta | 12 + .../Components/ActionStates/XMoveComponent.cs | 548 +++++++++++++ .../Components/ActionStates/XMoveComponent.cs.meta | 12 + .../Components/ActionStates/XMoveEventArgs.cs | 34 + .../Components/ActionStates/XMoveEventArgs.cs.meta | 12 + .../Components/ActionStates/XMoveMobEventArgs.cs | 18 + .../ActionStates/XMoveMobEventArgs.cs.meta | 12 + 35 files changed, 3483 insertions(+) create mode 100644 Client/Assets/Scripts/XMainClient/Components/ActionStates.meta create mode 100644 Client/Assets/Scripts/XMainClient/Components/ActionStates/XActionStateComponent.cs create mode 100644 Client/Assets/Scripts/XMainClient/Components/ActionStates/XActionStateComponent.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/Components/ActionStates/XBeHitComponent.cs create mode 100644 Client/Assets/Scripts/XMainClient/Components/ActionStates/XBeHitComponent.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/Components/ActionStates/XBeHitEventArgs.cs create mode 100644 Client/Assets/Scripts/XMainClient/Components/ActionStates/XBeHitEventArgs.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/Components/ActionStates/XChargeComponent.cs create mode 100644 Client/Assets/Scripts/XMainClient/Components/ActionStates/XChargeComponent.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/Components/ActionStates/XChargeEventArgs.cs create mode 100644 Client/Assets/Scripts/XMainClient/Components/ActionStates/XChargeEventArgs.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/Components/ActionStates/XDeathComponent.cs create mode 100644 Client/Assets/Scripts/XMainClient/Components/ActionStates/XDeathComponent.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/Components/ActionStates/XFallComponent.cs create mode 100644 Client/Assets/Scripts/XMainClient/Components/ActionStates/XFallComponent.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/Components/ActionStates/XFallEventArgs.cs create mode 100644 Client/Assets/Scripts/XMainClient/Components/ActionStates/XFallEventArgs.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/Components/ActionStates/XFreezeComponent.cs create mode 100644 Client/Assets/Scripts/XMainClient/Components/ActionStates/XFreezeComponent.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/Components/ActionStates/XFreezeEventArgs.cs create mode 100644 Client/Assets/Scripts/XMainClient/Components/ActionStates/XFreezeEventArgs.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/Components/ActionStates/XIdleComponent.cs create mode 100644 Client/Assets/Scripts/XMainClient/Components/ActionStates/XIdleComponent.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/Components/ActionStates/XIdleEventArgs.cs create mode 100644 Client/Assets/Scripts/XMainClient/Components/ActionStates/XIdleEventArgs.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/Components/ActionStates/XJumpComponent.cs create mode 100644 Client/Assets/Scripts/XMainClient/Components/ActionStates/XJumpComponent.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/Components/ActionStates/XJumpEventArgs.cs create mode 100644 Client/Assets/Scripts/XMainClient/Components/ActionStates/XJumpEventArgs.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/Components/ActionStates/XMoveComponent.cs create mode 100644 Client/Assets/Scripts/XMainClient/Components/ActionStates/XMoveComponent.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/Components/ActionStates/XMoveEventArgs.cs create mode 100644 Client/Assets/Scripts/XMainClient/Components/ActionStates/XMoveEventArgs.cs.meta create mode 100644 Client/Assets/Scripts/XMainClient/Components/ActionStates/XMoveMobEventArgs.cs create mode 100644 Client/Assets/Scripts/XMainClient/Components/ActionStates/XMoveMobEventArgs.cs.meta (limited to 'Client/Assets/Scripts/XMainClient/Components') diff --git a/Client/Assets/Scripts/XMainClient/Components/ActionStates.meta b/Client/Assets/Scripts/XMainClient/Components/ActionStates.meta new file mode 100644 index 00000000..6481944d --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Components/ActionStates.meta @@ -0,0 +1,9 @@ +fileFormatVersion: 2 +guid: 1e1486c08e098c44f8895d9f1115554c +folderAsset: yes +timeCreated: 1611554257 +licenseType: Free +DefaultImporter: + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/Components/ActionStates/XActionStateComponent.cs b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XActionStateComponent.cs new file mode 100644 index 00000000..89a214fe --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XActionStateComponent.cs @@ -0,0 +1,253 @@ +using System; +using XUtliPoolLib; + +namespace XMainClient +{ + internal abstract class XActionStateComponent : XComponent, IXStateTransform, IXInterface where T : XActionArgs + { + public virtual bool SyncPredicted + { + get + { + return !XSingleton.singleton.SyncMode; + } + } + + public virtual float Speed + { + get + { + throw new NotImplementedException(); + } + } + + public XStateDefine SelfState + { + get + { + return this._selfState; + } + } + + public bool IsStopped + { + get + { + return this._bStopped; + } + } + + public bool IsFinished + { + get + { + return this._bFinished || this._bStopped; + } + } + + public virtual bool ShouldBePresent + { + get + { + return true; + } + } + + public long Token + { + get + { + return this._stateToken; + } + } + + protected long SelfToken + { + get + { + return this._selfToken; + } + } + + public virtual int CollisionLayer + { + get + { + return this._entity.DefaultLayer; + } + } + + public abstract string PresentCommand { get; } + + public abstract string PresentName { get; } + + public bool Deprecated { get; set; } + + public abstract bool IsUsingCurve { get; } + + protected XStateDefine _selfState = XStateDefine.XState_Idle; + + private bool _bFinished = true; + + private bool _bStopped = false; + + private long _stateToken = 0L; + + private long _selfToken = 0L; + + public override void OnDetachFromHost() + { + bool flag = this.SelfState != XStateDefine.XState_Idle && this._entity.Machine.Current == this.SelfState; + if (flag) + { + this._entity.Machine.ForceToDefaultState(true); + } + base.OnDetachFromHost(); + } + + public bool IsPermitted(XStateDefine state) + { + bool flag = this.IsFinished && this._selfState != XStateDefine.XState_Move; + return flag || this.InnerPermitted(state); + } + + public virtual void OnRejected(XStateDefine current) + { + } + + public void StateUpdate(float deltaTime) + { + bool flag = this.SelfState != this._entity.Machine.Default && this.IsFinished; + if (flag) + { + this.Finish(); + } + else + { + this.ActionUpdate(deltaTime); + } + } + + private void Start() + { + this.Begin(); + } + + public void Stop(XStateDefine next) + { + bool flag = !this._bStopped; + if (flag) + { + this._bStopped = true; + this.Finish(); + this.Cancel(next); + } + } + + public virtual void OnGetPermission() + { + this._bStopped = false; + this._bFinished = false; + } + + public virtual string TriggerAnim(string pre) + { + string presentCommand = this.PresentCommand; + bool flag = pre != presentCommand; + if (flag) + { + bool flag2 = this._entity.Ator != null; + if (flag2) + { + this._entity.Ator.SetTrigger(presentCommand); + } + } + return presentCommand; + } + + protected void Finish() + { + bool flag = !this._bFinished; + if (flag) + { + this._bFinished = true; + this.Cease(); + } + } + + protected virtual void Cease() + { + } + + protected virtual void Begin() + { + } + + protected virtual void Cancel(XStateDefine next) + { + } + + protected virtual void OnMount(XMount mount) + { + } + + protected virtual bool SelfCheck(T args) + { + return true; + } + + protected bool GetPermission(T e) + { + bool flag = (this._entity.Skill == null || this._entity.Skill.CanPerformAction(this.SelfState, e)) && (this._entity.Machine == null || this._entity.Machine.TryTransferToState(this)); + bool flag2 = flag; + if (flag2) + { + this._stateToken = e.Token; + this._selfToken = XSingleton.singleton.UniqueToken; + } + return flag; + } + + protected virtual bool InnerPermitted(XStateDefine state) + { + return this._entity.Machine.StatePermitted(this._selfState, state); + } + + protected bool OnActionEvent(XEventArgs e) + { + T e2 = e as T; + XStateDefine last = this._entity.Machine.Current; + bool permission = this.GetPermission(e2); + if (permission) + { + this.OnGetEvent(e2, last); + this.Start(); + } + return true; + } + + protected bool OnMountEvent(XEventArgs e) + { + bool flag = e is XOnMountedEventArgs; + if (flag) + { + this.OnMount(this._entity.Mount); + } + else + { + bool flag2 = e is XOnUnMountedEventArgs; + if (flag2) + { + this.OnMount(null); + } + } + return true; + } + + protected abstract bool OnGetEvent(T e, XStateDefine last); + + protected virtual void ActionUpdate(float deltaTime) + { + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/Components/ActionStates/XActionStateComponent.cs.meta b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XActionStateComponent.cs.meta new file mode 100644 index 00000000..737bc520 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XActionStateComponent.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: ebd48e1350ad3394790e65a17900c872 +timeCreated: 1611404784 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/Components/ActionStates/XBeHitComponent.cs b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XBeHitComponent.cs new file mode 100644 index 00000000..7b52c9f9 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XBeHitComponent.cs @@ -0,0 +1,895 @@ +using System; +using KKSG; +using UnityEngine; +using XUtliPoolLib; + +namespace XMainClient +{ + internal sealed class XBeHitComponent : XActionStateComponent + { + public override uint ID + { + get + { + return XBeHitComponent.uuID; + } + } + + public override bool IsUsingCurve + { + get + { + return !base.IsFinished && this._hit_data.CurveUsing; + } + } + + public float TimeSpan + { + get + { + return this._total_time; + } + } + + public XBeHitState CurrentStateinLogical + { + get + { + return this._current_default_state; + } + } + + public bool HasFlyPresent + { + get + { + return this._bHasFlyPresent; + } + } + + public bool HasRollPresent + { + get + { + return this._bHasRollPresent; + } + } + + public override int CollisionLayer + { + get + { + XEntity xentity = this._entity.IsTransform ? this._entity.Transformer : this._entity; + return (xentity.IsPlayer || xentity.IsBoss) ? xentity.DefaultLayer : 14; + } + } + + public override bool ShouldBePresent + { + get + { + return false; + } + } + + public override string PresentCommand + { + get + { + return "ToBeHit"; + } + } + + public override string PresentName + { + get + { + string result; + switch (this._phase) + { + case XBeHitPhase.Hit_Present: + result = "Present"; + break; + case XBeHitPhase.Hit_Landing: + result = "HitLanding"; + break; + case XBeHitPhase.Hit_Hard: + result = "Hard"; + break; + case XBeHitPhase.Hit_GetUp: + result = "GetUp"; + break; + default: + result = "BeHit"; + break; + } + return result; + } + } + + public new static readonly uint uuID = XSingleton.singleton.XHash("BeHit_Presentation"); + + private int _start_idx = 0; + + private Vector2 _pos = Vector2.zero; + + private Vector2 _des = Vector2.zero; + + private XBeHitState _current_default_state = XBeHitState.Hit_Back; + + private XBeHitPhase _phase = XBeHitPhase.Hit_Present; + + private KKSG.XQTEState _last_set_qte = KKSG.XQTEState.QTE_None; + + private float _last_offset = 0f; + + private float _last_height = 0f; + + private float _delta_x = 0f; + + private float _delta_y = 0f; + + private float _delta_z = 0f; + + private float _deltaH = 0f; + + private float _land_time = 0f; + + private float _bounce_time = 0f; + + private float _getup_time = 0f; + + private float _hart_time = 0f; + + private float _gravity = 0f; + + private float _rticalV = 0f; + + private float _factor = 0f; + + private float _elapsed = 0f; + + private bool _bChange_to_fly = false; + + private bool _bHit_Down = false; + + private bool _bHit_Bounce = false; + + private bool _bLoop_Hard = false; + + private bool _bHasFlyPresent = false; + + private bool _bHasRollPresent = false; + + private bool _landing_overrided = false; + + private float _total_time = 0f; + + private float _present_straight = 1f; + + private float _hard_straight = 1f; + + private float _height = 0f; + + private float _offset = 0f; + + private string[] _clips = null; + + private float _clip0Length = 0f; + + private XFx _hit_fx = null; + + private XFx _hit_hit_fx = null; + + private XFx _hit_land_fx = null; + + private IXCurve _curve_h = null; + + private IXCurve _curve_v = null; + + private float _curve_height_scale = 1f; + + private float _curve_offset_scale = 1f; + + private float _curve_height_time_scale = 1f; + + private float _curve_offset_time_scale = 1f; + + private float _hard_time_factor = 1f; + + private XHitData _hit_data = null; + + private Vector3 _hit_direction = Vector3.forward; + + private XEntity _hit_from = null; + + public override string TriggerAnim(string pre) + { + XEntity xentity = this._entity.IsTransform ? this._entity.Transformer : this._entity; + bool flag = this._hit_data != null && !string.IsNullOrEmpty(this._hit_data.Fx); + if (flag) + { + this.PlayHitFx(this._hit_data.Fx, this._hit_data.Fx_Follow, this._hit_data.Fx_StickToGround, ref this._hit_fx); + } + bool flag2 = !string.IsNullOrEmpty(xentity.Present.PresentLib.HitFx); + if (flag2) + { + this.PlayHitFx(xentity.Present.PresentLib.HitFx, true, false, ref this._hit_hit_fx); + } + bool flag3 = xentity.Ator != null; + if (flag3) + { + xentity.Ator.Play("Present", 0); + } + return "ToBeHit"; + } + + public override void OnAttachToHost(XObject host) + { + base.OnAttachToHost(host); + this._selfState = XStateDefine.XState_BeHit; + this._clips = new string[16]; + this._landing_overrided = false; + } + + public override void OnDetachFromHost() + { + this.DestroyFx(ref this._hit_fx); + this.DestroyFx(ref this._hit_hit_fx); + this.DestroyFx(ref this._hit_land_fx); + bool flag = this._clips != null; + if (flag) + { + this._clips = null; + } + base.OnDetachFromHost(); + } + + public override void Attached() + { + this._bHasFlyPresent = (this._entity.Present.PresentLib.HitFly != null && this._entity.Present.PresentLib.HitFly.Length != 0); + this._bHasRollPresent = (this._entity.Present.PresentLib.Hit_Roll != null && this._entity.Present.PresentLib.Hit_Roll.Length != 0); + } + + protected override void EventSubscribe() + { + base.RegisterEvent(XEventDefine.XEvent_BeHit, new XComponent.XEventHandler(base.OnActionEvent)); + } + + protected override void ActionUpdate(float deltaTime) + { + XEntity xentity = this._entity.IsTransform ? this._entity.Transformer : this._entity; + bool flag = base.IsFinished || xentity.Ator == null; + if (!flag) + { + float elapsed = this._elapsed; + this._elapsed += deltaTime; + switch (this._phase) + { + case XBeHitPhase.Hit_Present: + { + bool flag2 = (this._bChange_to_fly || this._current_default_state == XBeHitState.Hit_Fly) && xentity.BeHit.HasFlyPresent; + bool flag3 = flag2 && !this._landing_overrided; + if (flag3) + { + xentity.OverrideAnimClip("HitLanding", xentity.BeHit.SaveGetClip(12), false, false); + this._landing_overrided = true; + } + bool flag4 = this._elapsed > this._present_straight; + if (flag4) + { + this._elapsed = this._present_straight; + bool flag5 = flag2; + if (flag5) + { + xentity.Ator.SetTrigger("ToBeHit_Landing"); + this._phase = XBeHitPhase.Hit_Landing; + this._bHit_Down = true; + this._bHit_Bounce = false; + bool flag6 = xentity.EngineObject.Position.y < XSingleton.singleton.TerrainY(xentity.EngineObject.Position) + 0.25f; + if (flag6) + { + this.PlayHitFx("Effects/FX_Particle/Roles/Lzg_Ty/Ty_dd", true, true, ref this._hit_land_fx); + } + xentity.Ator.speed = 1f; + } + else + { + xentity.Ator.SetTrigger("ToBeHit_Hard"); + this._phase = XBeHitPhase.Hit_Hard; + xentity.Ator.speed = (this._bLoop_Hard ? 1f : (this._hart_time / this._hard_straight)); + } + this.TrytoTirggerQTE(false); + } + this.CalcDeltaPos(Time.deltaTime, elapsed); + float num = -(this._deltaH / this._present_straight) * Time.deltaTime; + bool flag7 = this._offset < 0f && XEntity.ValideEntity(this._hit_from); + if (flag7) + { + float num2 = Mathf.Sqrt(this._delta_x * this._delta_x + this._delta_z * this._delta_z); + float magnitude = (this._hit_from.EngineObject.Position - xentity.EngineObject.Position).magnitude; + bool flag8 = (double)num2 > (double)magnitude - 0.5; + if (flag8) + { + this._delta_x = 0f; + this._delta_z = 0f; + } + } + this._entity.ApplyMove(this._delta_x, this._delta_y + num, this._delta_z); + bool flag9 = flag2; + if (flag9) + { + this._entity.DisableGravity(); + } + break; + } + case XBeHitPhase.Hit_Landing: + { + bool flag10 = !this._bHit_Bounce; + if (flag10) + { + bool flag11 = this._elapsed > this._present_straight + this._land_time; + if (flag11) + { + this._bHit_Bounce = true; + bool flag12 = this._elapsed <= this._present_straight + this._land_time + this._bounce_time; + if (flag12) + { + this.TrytoTirggerQTE(false); + } + } + } + bool bHit_Bounce = this._bHit_Bounce; + if (bHit_Bounce) + { + bool flag13 = this._elapsed > this._present_straight + this._land_time + this._bounce_time; + if (flag13) + { + xentity.Ator.SetTrigger("ToBeHit_Hard"); + this._phase = XBeHitPhase.Hit_Hard; + xentity.Ator.speed = (this._bLoop_Hard ? 1f : (this._hart_time / this._hard_straight)); + this._bHit_Bounce = false; + this.TrytoTirggerQTE(false); + } + } + break; + } + case XBeHitPhase.Hit_Hard: + { + bool flag14 = this._elapsed > this._present_straight + this._land_time + this._bounce_time + this._hard_straight; + if (flag14) + { + xentity.Ator.SetTrigger("ToBeHit_GetUp"); + this._phase = XBeHitPhase.Hit_GetUp; + xentity.Ator.speed = 1f; + this.TrytoTirggerQTE(false); + } + break; + } + case XBeHitPhase.Hit_GetUp: + { + bool flag15 = this._elapsed > this._total_time - this._getup_time * 0.7f; + if (flag15) + { + this._bHit_Down = false; + } + bool flag16 = this._elapsed > this._total_time; + if (flag16) + { + xentity.Ator.speed = 1f; + base.Finish(); + } + break; + } + } + } + } + + public bool LaidOnGround() + { + XEntity xentity = this._entity.IsTransform ? this._entity.Transformer : this._entity; + return xentity.Machine.Current == this._selfState && this._bHit_Down; + } + + protected override void Cancel(XStateDefine next) + { + XEntity xentity = this._entity.IsTransform ? this._entity.Transformer : this._entity; + this._elapsed = 0f; + this._rticalV = 0f; + this._gravity = 0f; + this._deltaH = 0f; + bool flag = xentity.Ator != null; + if (flag) + { + xentity.Ator.speed = 1f; + } + this._curve_h = null; + this._curve_v = null; + this._hit_data = null; + this._hit_from = null; + this.DestroyFx(ref this._hit_fx); + this.DestroyFx(ref this._hit_hit_fx); + this.DestroyFx(ref this._hit_land_fx); + this.TrytoTirggerQTE(true); + } + + protected override bool OnGetEvent(XBeHitEventArgs e, XStateDefine last) + { + this._bHit_Down = false; + this._bHit_Bounce = false; + this._hit_data = e.HitData; + this._hit_from = e.HitFrom; + this._hit_direction = XSingleton.singleton.Horizontal(e.HitDirection); + this._bChange_to_fly = e.ForceToFlyHit; + this._hard_time_factor = ((e.Paralyze > 0f) ? e.Paralyze : 1f); + return true; + } + + public string SaveGetClip(int idx) + { + bool flag = this._clips[idx] == null; + if (flag) + { + switch (idx) + { + case 0: + case 1: + case 2: + this._clips[idx] = this._entity.Present.ActionPrefix + this._entity.Present.PresentLib.Hit_f[idx]; + break; + case 3: + case 4: + case 5: + this._clips[idx] = this._entity.Present.ActionPrefix + this._entity.Present.PresentLib.Hit_l[idx % 3]; + break; + case 6: + case 7: + case 8: + this._clips[idx] = this._entity.Present.ActionPrefix + this._entity.Present.PresentLib.Hit_r[idx % 3]; + break; + case 9: + case 10: + case 11: + this._clips[idx] = this._entity.Present.ActionPrefix + this._entity.Present.PresentLib.Hit_Roll[idx % 3]; + break; + case 12: + this._clips[idx] = this._entity.Present.ActionPrefix + this._entity.Present.PresentLib.HitFly[XFastEnumIntEqualityComparer.ToInt(XBeHitPhase.Hit_Landing)]; + break; + case 13: + this._clips[idx] = this._entity.Present.ActionPrefix + this._entity.Present.PresentLib.HitFly[XFastEnumIntEqualityComparer.ToInt(XBeHitPhase.Hit_Present)]; + break; + case 14: + this._clips[idx] = this._entity.Present.ActionPrefix + this._entity.Present.PresentLib.HitFly[XFastEnumIntEqualityComparer.ToInt(XBeHitPhase.Hit_Hard)]; + break; + case 15: + this._clips[idx] = this._entity.Present.ActionPrefix + this._entity.Present.PresentLib.HitFly[XFastEnumIntEqualityComparer.ToInt(XBeHitPhase.Hit_GetUp)]; + break; + } + } + return this._clips[idx]; + } + + private void Prepare() + { + this._start_idx = 0; + XEntity xentity = this._entity.IsTransform ? this._entity.Transformer : this._entity; + switch (this._current_default_state) + { + case XBeHitState.Hit_Back: + { + bool bChange_to_fly = this._bChange_to_fly; + if (bChange_to_fly) + { + bool flag = !xentity.BeHit.HasFlyPresent; + if (flag) + { + this._start_idx = 3; + } + else + { + this._start_idx = 13; + } + } + else + { + switch (this._hit_data.State_Animation) + { + case XBeHitState_Animation.Hit_Back_Front: + this._start_idx = 0; + break; + case XBeHitState_Animation.Hit_Back_Left: + this._start_idx = 3; + break; + case XBeHitState_Animation.Hit_Back_Right: + this._start_idx = 6; + break; + } + } + break; + } + case XBeHitState.Hit_Fly: + { + bool flag2 = !xentity.BeHit.HasFlyPresent; + if (flag2) + { + this._start_idx = 3; + } + else + { + this._start_idx = 13; + } + break; + } + case XBeHitState.Hit_Roll: + { + bool bChange_to_fly2 = this._bChange_to_fly; + if (bChange_to_fly2) + { + bool flag3 = !xentity.BeHit.HasFlyPresent; + if (flag3) + { + this._start_idx = 3; + } + else + { + this._start_idx = 13; + } + } + else + { + bool flag4 = !xentity.BeHit.HasRollPresent; + if (flag4) + { + this._start_idx = 3; + } + else + { + this._start_idx = 9; + } + } + break; + } + } + XAnimationClip xanimationClip; + xentity.OverrideAnimClipGetClip("PresentStraight", xentity.BeHit.SaveGetClip(this._start_idx), false, true, out xanimationClip); + XAnimationClip xanimationClip2; + xentity.OverrideAnimClipGetClip("HardStraight", xentity.BeHit.SaveGetClip(this._start_idx + 1), false, false, out xanimationClip2); + xentity.OverrideAnimClip("GetUp", xentity.BeHit.SaveGetClip(this._start_idx + 2), false, false); + this._land_time = (((this._bChange_to_fly || this._current_default_state == XBeHitState.Hit_Fly) && xentity.BeHit.HasFlyPresent) ? xentity.Present.PresentLib.HitFly_Bounce_GetUp[0] : 0f); + this._bounce_time = (((this._bChange_to_fly || this._current_default_state == XBeHitState.Hit_Fly) && xentity.BeHit.HasFlyPresent) ? xentity.Present.PresentLib.HitFly_Bounce_GetUp[1] : 0f); + this._getup_time = (((this._bChange_to_fly || this._current_default_state == XBeHitState.Hit_Fly) && xentity.BeHit.HasFlyPresent) ? xentity.Present.PresentLib.HitFly_Bounce_GetUp[2] : ((this._current_default_state == XBeHitState.Hit_Roll && xentity.BeHit.HasRollPresent) ? xentity.Present.PresentLib.HitRoll_Recover : xentity.Present.PresentLib.HitBack_Recover[0])); + bool flag5 = xanimationClip2 != null; + if (flag5) + { + this._hart_time = xanimationClip2.length; + this._bLoop_Hard = ((int)xanimationClip2.clip.wrapMode == 2); + } + bool flag6 = xanimationClip != null; + if (flag6) + { + this._clip0Length = xanimationClip.length; + } + bool flag7 = this._hit_data.CurveUsing && xentity.Present.PresentLib.HitCurves != null; + if (flag7) + { + IXCurve ixcurve = ((this._bChange_to_fly || this._current_default_state == XBeHitState.Hit_Fly) && xentity.BeHit.HasFlyPresent) ? XSingleton.singleton.GetCurve(xentity.Present.CurvePrefix + xentity.Present.PresentLib.HitCurves[4]) : null; + IXCurve ixcurve2 = ((this._bChange_to_fly || this._current_default_state == XBeHitState.Hit_Fly) && xentity.BeHit.HasFlyPresent) ? XSingleton.singleton.GetCurve(xentity.Present.CurvePrefix + xentity.Present.PresentLib.HitCurves[3]) : ((this._current_default_state == XBeHitState.Hit_Roll && xentity.BeHit.HasRollPresent) ? XSingleton.singleton.GetCurve(xentity.Present.CurvePrefix + xentity.Present.PresentLib.HitCurves[5]) : ((this._current_default_state == XBeHitState.Hit_Back) ? XSingleton.singleton.GetCurve(xentity.Present.CurvePrefix + xentity.Present.PresentLib.HitCurves[XFastEnumIntEqualityComparer.ToInt(this._hit_data.State_Animation)]) : XSingleton.singleton.GetCurve(xentity.Present.CurvePrefix + xentity.Present.PresentLib.HitCurves[0]))); + this._curve_h = ((ixcurve != null) ? ixcurve : null); + this._curve_v = ixcurve2; + this._curve_height_scale = ((ixcurve == null || ixcurve.GetMaxValue() == 0f) ? 1f : (this._height / ixcurve.GetMaxValue())); + this._curve_offset_scale = ((ixcurve2.GetMaxValue() == 0f) ? 1f : (this._offset / ixcurve2.GetMaxValue())); + } + } + + protected override void Begin() + { + XEntity xentity = this._entity.IsTransform ? this._entity.Transformer : this._entity; + this._current_default_state = this._hit_data.State; + this._present_straight = (this._bChange_to_fly ? (this._hit_data.Additional_Using_Default ? XSingleton.singleton.Hit_PresentStraight : this._hit_data.Additional_Hit_Time_Present_Straight) : this._hit_data.Time_Present_Straight); + this._hard_straight = (this._bChange_to_fly ? (this._hit_data.Additional_Using_Default ? XSingleton.singleton.Hit_HardStraight : this._hit_data.Additional_Hit_Time_Hard_Straight) : this._hit_data.Time_Hard_Straight); + this._offset = (this._bChange_to_fly ? (this._hit_data.Additional_Using_Default ? XSingleton.singleton.Hit_Offset : this._hit_data.Additional_Hit_Offset) : this._hit_data.Offset); + this._height = (this._bChange_to_fly ? (this._hit_data.Additional_Using_Default ? XSingleton.singleton.Hit_Height : this._hit_data.Additional_Hit_Height) : this._hit_data.Height); + this._present_straight = (XSingleton.singleton.SyncMode ? this._present_straight : XSingleton.singleton.GetFloatingValue(this._present_straight, this._hit_data.Random_Range)); + this._offset = (XSingleton.singleton.SyncMode ? this._offset : XSingleton.singleton.GetFloatingValue(this._offset, this._hit_data.Random_Range)); + this._height = (XSingleton.singleton.SyncMode ? this._height : XSingleton.singleton.GetFloatingValue(this._height, this._hit_data.Random_Range)); + float num = 1f; + float num2 = 1f; + float num3 = 1f; + float num4 = 1f; + switch (this._current_default_state) + { + case XBeHitState.Hit_Back: + { + bool bChange_to_fly = this._bChange_to_fly; + if (bChange_to_fly) + { + bool flag = xentity.Present.PresentLib.HitFlyOffsetTimeScale != null; + if (flag) + { + num = ((xentity.Present.PresentLib.HitFlyOffsetTimeScale[0] == 0f) ? 1f : xentity.Present.PresentLib.HitFlyOffsetTimeScale[0]); + num2 = ((xentity.Present.PresentLib.HitFlyOffsetTimeScale[1] == 0f) ? 1f : xentity.Present.PresentLib.HitFlyOffsetTimeScale[1]); + num3 = ((xentity.Present.PresentLib.HitFlyOffsetTimeScale[2] == 0f) ? 1f : xentity.Present.PresentLib.HitFlyOffsetTimeScale[2]); + num4 = ((xentity.Present.PresentLib.HitFlyOffsetTimeScale[3] == 0f) ? 1f : xentity.Present.PresentLib.HitFlyOffsetTimeScale[3]); + } + } + else + { + bool flag2 = xentity.Present.PresentLib.HitBackOffsetTimeScale != null; + if (flag2) + { + num = ((xentity.Present.PresentLib.HitBackOffsetTimeScale[0] == 0f) ? 1f : xentity.Present.PresentLib.HitBackOffsetTimeScale[0]); + num3 = ((xentity.Present.PresentLib.HitBackOffsetTimeScale[1] == 0f) ? 1f : xentity.Present.PresentLib.HitBackOffsetTimeScale[1]); + num4 = ((xentity.Present.PresentLib.HitBackOffsetTimeScale[2] == 0f) ? 1f : xentity.Present.PresentLib.HitBackOffsetTimeScale[2]); + } + } + break; + } + case XBeHitState.Hit_Fly: + { + bool flag3 = xentity.Present.PresentLib.HitFlyOffsetTimeScale != null; + if (flag3) + { + num = ((xentity.Present.PresentLib.HitFlyOffsetTimeScale[0] == 0f) ? 1f : xentity.Present.PresentLib.HitFlyOffsetTimeScale[0]); + num2 = ((xentity.Present.PresentLib.HitFlyOffsetTimeScale[1] == 0f) ? 1f : xentity.Present.PresentLib.HitFlyOffsetTimeScale[1]); + num3 = ((xentity.Present.PresentLib.HitFlyOffsetTimeScale[2] == 0f) ? 1f : xentity.Present.PresentLib.HitFlyOffsetTimeScale[2]); + num4 = ((xentity.Present.PresentLib.HitFlyOffsetTimeScale[3] == 0f) ? 1f : xentity.Present.PresentLib.HitFlyOffsetTimeScale[3]); + } + break; + } + case XBeHitState.Hit_Roll: + { + bool bChange_to_fly2 = this._bChange_to_fly; + if (bChange_to_fly2) + { + bool flag4 = xentity.Present.PresentLib.HitFlyOffsetTimeScale != null; + if (flag4) + { + num = ((xentity.Present.PresentLib.HitFlyOffsetTimeScale[0] == 0f) ? 1f : xentity.Present.PresentLib.HitFlyOffsetTimeScale[0]); + num2 = ((xentity.Present.PresentLib.HitFlyOffsetTimeScale[1] == 0f) ? 1f : xentity.Present.PresentLib.HitFlyOffsetTimeScale[1]); + num3 = ((xentity.Present.PresentLib.HitFlyOffsetTimeScale[2] == 0f) ? 1f : xentity.Present.PresentLib.HitFlyOffsetTimeScale[2]); + num4 = ((xentity.Present.PresentLib.HitFlyOffsetTimeScale[3] == 0f) ? 1f : xentity.Present.PresentLib.HitFlyOffsetTimeScale[3]); + } + } + else + { + bool flag5 = xentity.Present.PresentLib.HitRollOffsetTimeScale != null; + if (flag5) + { + num = ((xentity.Present.PresentLib.HitRollOffsetTimeScale[0] == 0f) ? 1f : xentity.Present.PresentLib.HitRollOffsetTimeScale[0]); + num3 = ((xentity.Present.PresentLib.HitRollOffsetTimeScale[1] == 0f) ? 1f : xentity.Present.PresentLib.HitRollOffsetTimeScale[1]); + num4 = ((xentity.Present.PresentLib.HitRollOffsetTimeScale[2] == 0f) ? 1f : xentity.Present.PresentLib.HitRollOffsetTimeScale[2]); + } + } + break; + } + } + this._present_straight *= num3; + this._hard_straight = this._hard_straight * num4 * this._hard_time_factor; + bool flag6 = this._bChange_to_fly || this._current_default_state == XBeHitState.Hit_Fly; + if (flag6) + { + this._height *= num2; + } + this._offset *= num; + this.Prepare(); + this._total_time = this._present_straight + this._land_time + this._bounce_time + this._hard_straight + this._getup_time; + this._pos.x = xentity.EngineObject.Position.x; + this._pos.y = xentity.EngineObject.Position.z; + Vector3 vector = xentity.EngineObject.Position + this._hit_direction * this._offset; + float num5 = 0f; + bool flag7 = XSingleton.singleton.TryGetTerrainY(vector, out num5); + if (flag7) + { + this._deltaH = xentity.EngineObject.Position.y - ((xentity.Fly != null) ? (num5 + xentity.Fly.CurrentHeight) : num5); + } + else + { + this._deltaH = 0f; + } + bool flag8 = this._deltaH < 0f; + if (flag8) + { + this._deltaH = 0f; + } + this._des.x = vector.x; + this._des.y = vector.z; + bool curveUsing = this._hit_data.CurveUsing; + if (curveUsing) + { + this._curve_height_time_scale = ((this._curve_h == null) ? 1f : (this._present_straight / this._curve_h.GetTime(this._curve_h.length - 1))); + this._curve_offset_time_scale = this._present_straight / this._curve_v.GetTime(this._curve_v.length - 1); + this._last_offset = 0f; + this._last_height = 0f; + } + else + { + this._factor = XSingleton.singleton.GetSmoothFactor((this._pos - this._des).magnitude, this._present_straight, 0.01f); + this._rticalV = ((this._bChange_to_fly || this._current_default_state == XBeHitState.Hit_Fly) ? (this._height * 4f / this._present_straight) : 0f); + this._gravity = this._rticalV / this._present_straight * 2f; + } + XSingleton.singleton.PlaySound(xentity, AudioChannel.Behit, XAudioStateDefine.XState_Audio_BeHit, false, (this._hit_from == null) ? null : new XAudioExParam(this._hit_from)); + this._elapsed = 0f; + this._phase = XBeHitPhase.Hit_Present; + this.TrytoTirggerQTE(false); + bool flag9 = xentity.Ator != null; + if (flag9) + { + xentity.Ator.speed = this._clip0Length / this._present_straight; + } + this._entity.Machine.TriggerPresent(); + } + + private void PlayHitFx(string fx, bool follow, bool sticky, ref XFx xfx) + { + bool mobShield = this._entity.MobShield; + if (!mobShield) + { + XEntity xentity = this._entity.IsTransform ? this._entity.Transformer : this._entity; + bool flag = !xentity.IsRole && XQualitySetting.GetQuality(EFun.ELowEffect); + if (!flag) + { + bool flag2 = xfx != null && xfx.FxName != fx; + if (flag2) + { + this.DestroyFx(ref xfx); + } + bool flag3 = XEntity.FilterFx(this._entity, XFxMgr.FilterFxDis0); + if (!flag3) + { + bool flag4 = Time.realtimeSinceStartup - XFxMgr.lastBehitFxTime < XFxMgr.minBehitFxTime || XFxMgr.currentBeHitFx >= XFxMgr.maxBehitFx; + if (!flag4) + { + bool flag5 = xfx == null; + if (flag5) + { + xfx = XSingleton.singleton.CreateFx(fx, null, true); + } + XFxMgr.lastBehitFxTime = Time.realtimeSinceStartup; + XFxMgr.currentBeHitFx++; + Vector3 offset = sticky ? Vector3.zero : (Vector3.up * (xentity.Height * 0.5f)); + xfx.Play(xentity.EngineObject, offset, Vector3.one, 1f, follow, sticky, "", 0f); + } + } + } + } + } + + private void DestroyFx(ref XFx xfx) + { + bool flag = xfx != null; + if (flag) + { + XFxMgr.currentBeHitFx--; + bool flag2 = XFxMgr.currentBeHitFx < 0; + if (flag2) + { + XFxMgr.currentBeHitFx = 0; + } + XSingleton.singleton.DestroyFx(xfx, true); + xfx = null; + } + } + + private void CalcDeltaPos(float deltaTime, float last_elapsed) + { + Vector2 vector = Vector2.zero; + bool curveUsing = this._hit_data.CurveUsing; + float delta_y; + if (curveUsing) + { + float time = this._elapsed / this._curve_offset_time_scale; + float time2 = this._elapsed / this._curve_height_time_scale; + float num = this._curve_v.Evaluate(time) * this._curve_offset_scale; + float num2 = (this._curve_h == null) ? 0f : (this._curve_h.Evaluate(time2) * this._curve_height_scale); + Vector3 vector2 = this._hit_direction * (num - this._last_offset); + vector.x = vector2.x; + vector.y = vector2.z; + delta_y = num2 - this._last_height; + this._last_height = num2; + this._last_offset = num; + } + else + { + XEntity xentity = this._entity.IsTransform ? this._entity.Transformer : this._entity; + float num3 = this._rticalV - this._gravity * last_elapsed; + float num4 = this._rticalV - this._gravity * this._elapsed; + delta_y = (num3 + num4) / 2f * deltaTime; + this._pos.x = xentity.EngineObject.Position.x; + this._pos.y = xentity.EngineObject.Position.z; + vector = (this._des - this._pos) * Mathf.Min(1f, this._factor * deltaTime); + } + this._delta_x = vector.x; + this._delta_y = delta_y; + this._delta_z = vector.y; + } + + public KKSG.XQTEState GetQTESpecificPhase() + { + KKSG.XQTEState result = KKSG.XQTEState.QTE_None; + XEntity xentity = this._entity.IsTransform ? this._entity.Transformer : this._entity; + switch (this._phase) + { + case XBeHitPhase.Hit_Present: + switch (this._current_default_state) + { + case XBeHitState.Hit_Back: + result = ((this._bChange_to_fly && xentity.BeHit.HasFlyPresent) ? KKSG.XQTEState.QTE_HitFlyPresent : KKSG.XQTEState.QTE_HitBackPresent); + break; + case XBeHitState.Hit_Fly: + result = (xentity.BeHit.HasFlyPresent ? KKSG.XQTEState.QTE_HitFlyPresent : KKSG.XQTEState.QTE_HitBackPresent); + break; + case XBeHitState.Hit_Roll: + result = ((this._bChange_to_fly && xentity.BeHit.HasFlyPresent) ? KKSG.XQTEState.QTE_HitFlyPresent : (xentity.BeHit.HasRollPresent ? KKSG.XQTEState.QTE_HitRollPresent : KKSG.XQTEState.QTE_HitBackPresent)); + break; + } + break; + case XBeHitPhase.Hit_Landing: + result = (this._bHit_Bounce ? KKSG.XQTEState.QTE_HitFlyBounce : KKSG.XQTEState.QTE_HitFlyLand); + break; + case XBeHitPhase.Hit_Hard: + switch (this._current_default_state) + { + case XBeHitState.Hit_Back: + result = ((this._bChange_to_fly && xentity.BeHit.HasFlyPresent) ? KKSG.XQTEState.QTE_HitFlyStraight : KKSG.XQTEState.QTE_HitBackStraight); + break; + case XBeHitState.Hit_Fly: + result = (xentity.BeHit.HasFlyPresent ? KKSG.XQTEState.QTE_HitFlyStraight : KKSG.XQTEState.QTE_HitBackStraight); + break; + case XBeHitState.Hit_Roll: + result = ((this._bChange_to_fly && xentity.BeHit.HasFlyPresent) ? KKSG.XQTEState.QTE_HitFlyStraight : (xentity.BeHit.HasRollPresent ? KKSG.XQTEState.QTE_HitRollStraight : KKSG.XQTEState.QTE_HitBackStraight)); + break; + } + break; + case XBeHitPhase.Hit_GetUp: + switch (this._current_default_state) + { + case XBeHitState.Hit_Back: + result = ((this._bChange_to_fly && xentity.BeHit.HasFlyPresent) ? KKSG.XQTEState.QTE_HitFlyGetUp : KKSG.XQTEState.QTE_HitBackGetUp); + break; + case XBeHitState.Hit_Fly: + result = (xentity.BeHit.HasFlyPresent ? KKSG.XQTEState.QTE_HitFlyGetUp : KKSG.XQTEState.QTE_HitBackGetUp); + break; + case XBeHitState.Hit_Roll: + result = ((this._bChange_to_fly && xentity.BeHit.HasFlyPresent) ? KKSG.XQTEState.QTE_HitFlyGetUp : (xentity.BeHit.HasRollPresent ? KKSG.XQTEState.QTE_HitRollGetUp : KKSG.XQTEState.QTE_HitBackGetUp)); + break; + } + break; + } + return result; + } + + private void TrytoTirggerQTE(bool bEnd = false) + { + XEntity xentity = this._entity.IsTransform ? this._entity.Transformer : this._entity; + bool flag = !xentity.Destroying && xentity.QTE != null; + if (flag) + { + KKSG.XQTEState xqtestate = KKSG.XQTEState.QTE_None; + bool flag2 = !bEnd; + if (flag2) + { + xqtestate = this.GetQTESpecificPhase(); + bool flag3 = this._last_set_qte > KKSG.XQTEState.QTE_None; + if (flag3) + { + XSkillQTEEventArgs @event = XEventPool.GetEvent(); + @event.Firer = xentity; + @event.On = false; + @event.State = (uint)XFastEnumIntEqualityComparer.ToInt(this._last_set_qte); + XSingleton.singleton.FireEvent(@event); + } + this._last_set_qte = xqtestate; + } + else + { + this._last_set_qte = KKSG.XQTEState.QTE_None; + } + XSkillQTEEventArgs event2 = XEventPool.GetEvent(); + event2.Firer = xentity; + event2.On = !bEnd; + event2.State = (uint)XFastEnumIntEqualityComparer.ToInt(xqtestate); + XSingleton.singleton.FireEvent(event2); + } + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/Components/ActionStates/XBeHitComponent.cs.meta b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XBeHitComponent.cs.meta new file mode 100644 index 00000000..0c8c2e43 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XBeHitComponent.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: cc2a9d4766bab4f4fa1c4f44f5da2700 +timeCreated: 1611404550 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/Components/ActionStates/XBeHitEventArgs.cs b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XBeHitEventArgs.cs new file mode 100644 index 00000000..f922183f --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XBeHitEventArgs.cs @@ -0,0 +1,35 @@ +using System; +using UnityEngine; +using XUtliPoolLib; + +namespace XMainClient +{ + internal class XBeHitEventArgs : XActionArgs + { + public XHitData HitData { get; set; } + + public Vector3 HitDirection = Vector3.forward; + + public bool ForceToFlyHit = false; + + public float Paralyze = 1f; + + public XEntity HitFrom = null; + + public XBeHitEventArgs() + { + this._eDefine = XEventDefine.XEvent_BeHit; + } + + public override void Recycle() + { + this.HitData = null; + this.HitDirection = Vector3.forward; + this.ForceToFlyHit = false; + this.Paralyze = 1f; + this.HitFrom = null; + base.Recycle(); + XEventPool.Recycle(this); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/Components/ActionStates/XBeHitEventArgs.cs.meta b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XBeHitEventArgs.cs.meta new file mode 100644 index 00000000..5b27776f --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XBeHitEventArgs.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 4ffe45036c5ab5b4db40a90b75c418f5 +timeCreated: 1611403702 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/Components/ActionStates/XChargeComponent.cs b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XChargeComponent.cs new file mode 100644 index 00000000..c090c0cb --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XChargeComponent.cs @@ -0,0 +1,422 @@ +using System; +using UnityEngine; +using XUtliPoolLib; + +namespace XMainClient +{ + internal sealed class XChargeComponent : XActionStateComponent + { + public override uint ID + { + get + { + return XChargeComponent.uuID; + } + } + + public override float Speed + { + get + { + return this._step_speed; + } + } + + public override bool IsUsingCurve + { + get + { + return !base.IsFinished && this._using_curve; + } + } + + public override bool ShouldBePresent + { + get + { + return true; + } + } + + public override string PresentCommand + { + get + { + bool flag = this._entity.Skill.IsCasting() && this._entity.Skill.CurrentSkill.MainCore.Soul.Logical.Association && this._entity.Skill.CurrentSkill.MainCore.Soul.Logical.MoveType; + string result; + if (flag) + { + result = "ToMove"; + } + else + { + result = "ToStand"; + } + return result; + } + } + + public override string PresentName + { + get + { + bool flag = this._entity.Skill.IsCasting() && this._entity.Skill.CurrentSkill.MainCore.Soul.Logical.Association && this._entity.Skill.CurrentSkill.MainCore.Soul.Logical.MoveType; + string result; + if (flag) + { + result = "Move"; + } + else + { + result = "Stand"; + } + return result; + } + } + + public new static readonly uint uuID = XSingleton.singleton.XHash("Charge_Move"); + + private float _time_scale = 1f; + + private bool _gravity_disabled = false; + + private bool _standon_atend = true; + + private float _timeElapsed = 0f; + + private float _timeSpan = 0f; + + private float _land_time = 0f; + + private float _height = 0f; + + private float _gravity = 0f; + + private float _rticalV = 0f; + + private float _rotation_speed = 0f; + + private float _step_speed = 0f; + + private float _offset = 0f; + + private float _distance = 0f; + + private float _velocity = 0f; + + private float _height_drop = 0f; + + private XEntity _aim_to_target = null; + + private Vector3 _begin_at = Vector3.zero; + + private Vector3 _step_dir = Vector3.zero; + + private Vector3 _curve_step_dir = Vector3.zero; + + private IXCurve _curve_forward = null; + + private IXCurve _curve_side = null; + + private IXCurve _curve_up = null; + + private bool _using_curve = false; + + private bool _using_up = false; + + private bool _control_towards = false; + + private float _last_offset_forward = 0f; + + private float _last_offset_side = 0f; + + private float _last_offset_up = 0f; + + public override void OnAttachToHost(XObject host) + { + base.OnAttachToHost(host); + this._selfState = XStateDefine.XState_Charge; + } + + protected override void EventSubscribe() + { + base.RegisterEvent(XEventDefine.XEvent_Charge, new XComponent.XEventHandler(base.OnActionEvent)); + } + + public override void OnRejected(XStateDefine current) + { + } + + protected override void ActionUpdate(float deltaTime) + { + bool flag = XSingleton.singleton.IsLess(this._timeElapsed, this._timeSpan); + if (flag) + { + Vector3 vector = Vector3.zero; + float num = 0f; + this.Calibration(); + bool using_curve = this._using_curve; + if (using_curve) + { + this.GetCurveMove(ref vector, ref num, deltaTime); + bool flag2 = this._control_towards && this._entity.IsPlayer && XSingleton.singleton.Feeding; + if (flag2) + { + vector += this._step_dir * (this._velocity * deltaTime); + } + } + else + { + this.GetNormalMove(ref vector, ref num, deltaTime); + } + bool flag3 = this._timeElapsed > this._timeSpan; + if (flag3) + { + this._timeElapsed = this._timeSpan; + base.Finish(); + } + num -= ((this._land_time > 0f) ? (deltaTime * (this._height_drop / this._land_time)) : this._height_drop); + bool flag4 = this._using_up && this._timeElapsed <= this._land_time; + if (flag4) + { + this._gravity_disabled = true; + this._entity.DisableGravity(); + } + else + { + this._gravity_disabled = false; + } + bool flag5 = this._land_time == 0f && this._entity.Fly != null; + if (flag5) + { + this._height_drop = 0f; + } + bool flag6 = this._entity.Skill.IsCasting() && this._entity.Skill.CurrentSkill.MainCore.Soul.MultipleAttackSupported; + if (flag6) + { + this.CalibrateByMultipleDirection(ref vector, this._entity.Skill.CurrentSkill.MainCore); + } + bool flag7 = this._entity.Buffs != null && this._entity.Buffs.IsBuffStateOn(XBuffType.XBuffType_LockFoot); + if (flag7) + { + vector = Vector3.zero; + } + bool flag8 = this._distance - 0.5f < vector.magnitude; + if (flag8) + { + vector.Set(0f, vector.y, 0f); + } + bool isDummy = this._entity.IsDummy; + if (isDummy) + { + vector.Set(0f, vector.y, 0f); + } + this._entity.ApplyMove(vector.x, num, vector.z); + } + else + { + bool gravity_disabled = this._gravity_disabled; + if (gravity_disabled) + { + this._entity.DisableGravity(); + } + } + } + + protected override void Cancel(XStateDefine next) + { + this._timeElapsed = 0f; + this._rticalV = 0f; + this._gravity = 0f; + this._step_speed = 0f; + this._curve_forward = null; + this._curve_side = null; + this._using_curve = false; + bool gravity_disabled = this._gravity_disabled; + if (gravity_disabled) + { + this._entity.DisableGravity(); + } + } + + protected override bool OnGetEvent(XChargeEventArgs e, XStateDefine last) + { + this._gravity_disabled = false; + this._using_curve = e.Data.Using_Curve; + this._using_up = e.Data.Using_Up; + this._control_towards = e.Data.Control_Towards; + this._land_time = 0f; + this._time_scale = e.TimeScale; + this._aim_to_target = e.AimedTarget; + this._rotation_speed = (e.Data.AimTarget ? 0f : e.Data.Rotation_Speed); + bool using_curve = this._using_curve; + if (using_curve) + { + IXCurve curve = XSingleton.singleton.GetCurve(e.Data.Curve_Forward); + this._curve_forward = curve; + this._curve_side = XSingleton.singleton.GetCurve(e.Data.Curve_Side); + this._timeSpan = this._curve_forward.GetTime(this._curve_forward.length - 1) * this._time_scale; + bool using_up = this._using_up; + if (using_up) + { + IXCurve curve2 = XSingleton.singleton.GetCurve(e.Data.Curve_Up); + this._curve_up = curve2; + this._land_time = curve2.GetLandValue() * this._time_scale; + bool flag = this._land_time > 0f; + if (flag) + { + this._gravity_disabled = true; + this._entity.DisableGravity(); + } + } + this._offset = (this._curve_forward.GetValue(this._curve_forward.length - 1) - this._curve_forward.GetValue(0)) * this._entity.Scale; + this._velocity = e.Data.Velocity; + } + else + { + this._timeSpan = e.TimeSpan * this._time_scale; + this._offset = e.Data.Offset; + this._velocity = 0f; + } + this._begin_at = this._entity.MoveObj.Position; + this._standon_atend = e.Data.StandOnAtEnd; + this.Calibration(); + this.HeightDrop(); + this._height = e.Height * this._entity.Scale; + this._timeElapsed = e.TimeGone * this._time_scale; + return true; + } + + protected override void Begin() + { + bool using_curve = this._using_curve; + if (using_curve) + { + this._last_offset_forward = 0f; + this._last_offset_side = 0f; + this._last_offset_up = 0f; + } + else + { + this._step_speed = this._offset / this._timeSpan; + this._rticalV = this._height * 4f / this._timeSpan; + this._gravity = this._rticalV / this._timeSpan * 2f; + } + } + + private void Calibration() + { + bool flag = XEntity.ValideEntity(this._aim_to_target); + if (flag) + { + Vector3 vector = this._aim_to_target.MoveObj.Position - this._entity.MoveObj.Position; + this._distance = vector.magnitude; + this._entity.Net.ReportRotateAction(vector.normalized, this._entity.Attributes.RotateSpeed, this._entity.Skill.IsCasting() ? this._entity.Skill.CurrentSkill.Token : 0L); + } + else + { + this._distance = float.PositiveInfinity; + this._aim_to_target = null; + } + this._step_dir = (this._entity.Skill.IsCasting() ? (this._control_towards ? this.GetControlTowards() : this._entity.Skill.CurrentSkill.SkillTowardsTo) : this._entity.Rotate.GetMeaningfulFaceVector3()); + this._curve_step_dir = (this._entity.Skill.IsCasting() ? this._entity.Skill.CurrentSkill.SkillTowardsTo : this._entity.Rotate.GetMeaningfulFaceVector3()); + } + + private Vector3 GetControlTowards() + { + bool flag = this._entity.IsPlayer && XSingleton.singleton.Feeding; + Vector3 result; + if (flag) + { + result = XSingleton.singleton.Direction; + } + else + { + result = this._entity.Skill.CurrentSkill.SkillTowardsTo; + } + return result; + } + + private void HeightDrop() + { + bool standon_atend = this._standon_atend; + if (standon_atend) + { + Vector3 pos = this._begin_at + this._offset * this._step_dir; + float num = 0f; + bool flag = XSingleton.singleton.TryGetTerrainY(pos, out num); + if (flag) + { + this._height_drop = ((this._entity.Fly != null) ? 0f : (this._entity.MoveObj.Position.y - num)); + bool flag2 = this._height_drop < 0f; + if (flag2) + { + this._height_drop = 0f; + } + } + else + { + this._height_drop = 0f; + } + } + else + { + this._height_drop = 0f; + } + } + + private void GetNormalMove(ref Vector3 delta, ref float h, float deltaTime) + { + float num = this._rticalV - this._gravity * this._timeElapsed; + this._timeElapsed += deltaTime; + float num2 = this._rticalV - this._gravity * this._timeElapsed; + delta = this._step_speed * deltaTime * this._step_dir; + h = (num + num2) / 2f * deltaTime; + bool flag = this._rotation_speed != 0f && !XSingleton.singleton.SyncMode; + if (flag) + { + this._entity.MoveObj.Forward = XSingleton.singleton.HorizontalRotateVetor3(this._entity.MoveObj.Forward, this._rotation_speed * deltaTime, true); + bool flag2 = this._entity.Rotate != null; + if (flag2) + { + this._entity.Rotate.Cancel(); + } + } + } + + private void GetCurveMove(ref Vector3 delta, ref float h, float deltaTime) + { + this._timeElapsed += deltaTime; + float num = this._curve_forward.Evaluate(this._timeElapsed / this._time_scale) * this._entity.Scale; + float num2 = num - this._last_offset_forward; + this._last_offset_forward = num; + float num3 = this._curve_side.Evaluate(this._timeElapsed / this._time_scale) * this._entity.Scale; + float num4 = num3 - this._last_offset_side; + this._last_offset_side = num3; + bool using_up = this._using_up; + if (using_up) + { + float num5 = this._curve_up.Evaluate(this._timeElapsed / this._time_scale) * this._entity.Scale; + h = num5 - this._last_offset_up; + this._last_offset_up = num5; + } + Vector3 vector = num2 * this._curve_step_dir; + Vector3 vector2 = XSingleton.singleton.Horizontal(Vector3.Cross(Vector3.up, this._entity.MoveObj.Forward)); + Vector3 vector3 = num4 * vector2; + delta = vector + vector3; + delta.y = 0f; + } + + private void CalibrateByMultipleDirection(ref Vector3 delta, XSkillCore core) + { + float multipleDirectionFactor = core.GetMultipleDirectionFactor(); + bool flag = multipleDirectionFactor > 0.25f && multipleDirectionFactor < 0.75f; + if (flag) + { + float num = 1f - core.Soul.BackTowardsDecline; + float num2 = (multipleDirectionFactor - 0.25f) / 0.5f * 3.14159274f; + delta = delta.magnitude * (1f - Mathf.Sin(num2) * num) * delta.normalized; + } + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/Components/ActionStates/XChargeComponent.cs.meta b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XChargeComponent.cs.meta new file mode 100644 index 00000000..5f4acd25 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XChargeComponent.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 5a78700d4be304f4993825bb0aa7d79a +timeCreated: 1611403791 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/Components/ActionStates/XChargeEventArgs.cs b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XChargeEventArgs.cs new file mode 100644 index 00000000..77860e1d --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XChargeEventArgs.cs @@ -0,0 +1,39 @@ +using System; +using XUtliPoolLib; + +namespace XMainClient +{ + internal class XChargeEventArgs : XActionArgs + { + public XChargeData Data { get; set; } + + public float Height { get; set; } + + public float TimeSpan { get; set; } + + public XEntity AimedTarget = null; + + public float TimeScale = 1f; + + public float TimeGone; + + public XChargeEventArgs() + { + this._eDefine = XEventDefine.XEvent_Charge; + this.Data = null; + this.TimeGone = 0f; + } + + public override void Recycle() + { + this.Data = null; + this.AimedTarget = null; + this.Height = 0f; + this.TimeSpan = 0f; + this.TimeScale = 1f; + this.TimeGone = 0f; + base.Recycle(); + XEventPool.Recycle(this); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/Components/ActionStates/XChargeEventArgs.cs.meta b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XChargeEventArgs.cs.meta new file mode 100644 index 00000000..c341e1a5 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XChargeEventArgs.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 62d3b787308582e46aa3820f86321091 +timeCreated: 1611403842 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/Components/ActionStates/XDeathComponent.cs b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XDeathComponent.cs new file mode 100644 index 00000000..6ef5853f --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XDeathComponent.cs @@ -0,0 +1,335 @@ +using System; +using UnityEngine; +using XUtliPoolLib; + +namespace XMainClient +{ + internal sealed class XDeathComponent : XActionStateComponent + { + public override uint ID + { + get + { + return XDeathComponent.uuID; + } + } + + public float ClipLen + { + get + { + return this._clip_len; + } + set + { + this._clip_len = value; + } + } + + public IXCurve CurveH + { + get + { + return this._curve_h; + } + } + + public IXCurve CurveV + { + get + { + return this._curve_v; + } + } + + public float LandTime + { + get + { + return this._land_time; + } + } + + public float LandMax + { + get + { + return this._land_max; + } + } + + public override bool IsUsingCurve + { + get + { + return !base.IsFinished; + } + } + + public override string PresentCommand + { + get + { + return "ToDeath"; + } + } + + public override string PresentName + { + get + { + return "Death"; + } + } + + public override bool ShouldBePresent + { + get + { + return !this._presented; + } + } + + public override int CollisionLayer + { + get + { + return LayerMask.NameToLayer("NoneEntity"); + } + } + + public new static readonly uint uuID = XSingleton.singleton.XHash("Death"); + + private bool _presented = false; + + private float _elapsed = 0f; + + private float _clip_len = 0f; + + private float _last_offset = 0f; + + private float _last_height = 0f; + + private float _deltaH = 0f; + + private float _land_time = 0f; + + private float _land_max = 0f; + + private Vector3 _step_dir = Vector3.forward; + + private IXCurve _curve_h = null; + + private IXCurve _curve_v = null; + + private XEntity _killer = null; + + private XFx _death_fx = null; + + private uint _fade_out_token = 0u; + + private uint _destory_token = 0u; + + public override void OnAttachToHost(XObject host) + { + base.OnAttachToHost(host); + this._selfState = XStateDefine.XState_Death; + bool isNotEmptyObject = this._entity.EngineObject.IsNotEmptyObject; + if (isNotEmptyObject) + { + bool flag = string.IsNullOrEmpty(this._entity.Present.PresentLib.Death); + if (flag) + { + this._clip_len = 0f; + } + else + { + this._clip_len = 1f; + bool flag2 = this._entity.Present.PresentLib.DeathCurve != null && this._entity.Present.PresentLib.DeathCurve.Length != 0; + if (flag2) + { + IXCurve curve = XSingleton.singleton.GetCurve(this._entity.Present.CurvePrefix + this._entity.Present.PresentLib.DeathCurve[0]); + IXCurve curve2 = XSingleton.singleton.GetCurve(this._entity.Present.CurvePrefix + this._entity.Present.PresentLib.DeathCurve[1]); + this._curve_h = curve; + this._curve_v = curve2; + this._land_time = curve.GetLandValue(); + this._land_max = curve.GetMaxValue(); + } + } + } + } + + public override void OnDetachFromHost() + { + base.OnDetachFromHost(); + this._clip_len = 0f; + this._curve_h = null; + this._curve_v = null; + this._land_time = 0f; + this._land_max = 0f; + XSingleton.singleton.KillTimer(this._fade_out_token); + XSingleton.singleton.KillTimer(this._destory_token); + } + + protected override void EventSubscribe() + { + base.RegisterEvent(XEventDefine.XEvent_RealDead, new XComponent.XEventHandler(base.OnActionEvent)); + base.RegisterEvent(XEventDefine.XEvent_OnRevived, new XComponent.XEventHandler(this.OnRevive)); + } + + public override void OnRejected(XStateDefine current) + { + } + + protected override void Cancel(XStateDefine next) + { + bool flag = this._death_fx != null; + if (flag) + { + XSingleton.singleton.DestroyFx(this._death_fx, true); + } + this._death_fx = null; + this._killer = null; + XSingleton.singleton.KillTimer(this._fade_out_token); + XSingleton.singleton.KillTimer(this._destory_token); + } + + private bool OnRevive(XEventArgs e) + { + bool flag = this._entity.Machine.Current == XStateDefine.XState_Death; + if (flag) + { + this._entity.Machine.ForceToDefaultState(true); + } + this._presented = false; + return true; + } + + protected override void ActionUpdate(float deltaTime) + { + bool presented = this._presented; + if (presented) + { + XEntity xentity = this._entity.IsTransform ? this._entity.Transformer : this._entity; + this._elapsed += deltaTime; + bool flag = xentity.Death.CurveV == null || xentity.Death.CurveH == null; + if (!flag) + { + float num = xentity.Death.CurveV.Evaluate(this._elapsed) * xentity.Scale; + float num2 = xentity.Death.CurveH.Evaluate(this._elapsed) * xentity.Scale; + Vector3 vector = this._step_dir * (num - this._last_offset); + float x = vector.x; + float num3 = num2 - this._last_height; + float z = vector.z; + this._last_height = num2; + this._last_offset = num; + float num4 = XSingleton.singleton.IsLess(this._elapsed, xentity.Death.LandTime) ? (-(this._deltaH / xentity.Death.LandTime) * deltaTime) : (-Mathf.Sqrt(x * x + z * z)); + bool flag2 = this._elapsed < xentity.Death.LandTime; + if (flag2) + { + this._entity.DisableGravity(); + } + this._entity.ApplyMove(x, num3 + num4, z); + } + } + } + + public override string TriggerAnim(string pre) + { + this._presented = true; + this._entity.Ator.CrossFade(this.PresentName, 0f, 0, 0f); + return this.PresentName; + } + + protected override bool OnGetEvent(XRealDeadEventArgs e, XStateDefine last) + { + this._killer = e.Killer; + XEntity xentity = this._entity.IsTransform ? this._entity.Transformer : this._entity; + bool flag = xentity.Death.ClipLen > 0f; + if (flag) + { + xentity.Death.ClipLen = xentity.OverrideAnimClipGetLength("Death", xentity.Present.ActionPrefix + xentity.Present.PresentLib.Death, false); + } + return true; + } + + protected override void Begin() + { + XEntity xentity = this._entity.IsTransform ? this._entity.Transformer : this._entity; + this._entity.Net.KillIdle(); + bool flag = !this._entity.IsRole && xentity.Death.ClipLen > 0f; + if (flag) + { + this._fade_out_token = XSingleton.singleton.SetTimer(xentity.Death.ClipLen, new XTimerMgr.ElapsedEventHandler(this.OnFadeOut), null); + } + bool flag2 = !this._entity.IsPuppet && !XQualitySetting.GetQuality(EFun.ELowEffect); + if (flag2) + { + bool flag3 = !XEntity.FilterFx(this._entity, XFxMgr.FilterFxDis0); + if (flag3) + { + this._death_fx = XSingleton.singleton.CreateFx(string.IsNullOrEmpty(xentity.Present.PresentLib.DeathFx) ? "Effects/FX_Particle/NPC/xiaobing_die" : xentity.Present.PresentLib.DeathFx, null, true); + this._death_fx.Play(this._entity.EngineObject, Vector3.zero, Vector3.one, 1f, true, false, "", 0f); + } + } + XSingleton.singleton.PlaySound(xentity, AudioChannel.Motion, XAudioStateDefine.XState_Audio_Death); + bool flag4 = xentity.Death.CurveV != null; + if (flag4) + { + this._step_dir = (XEntity.ValideEntity(this._killer) ? ((xentity.Death.LandMax > 0f) ? XSingleton.singleton.Horizontal(this._entity.EngineObject.Position - this._killer.EngineObject.Position) : (-this._entity.EngineObject.Forward)) : ((xentity.Death.LandMax > 0f) ? XSingleton.singleton.Horizontal(this._entity.EngineObject.Position - XSingleton.singleton.Player.EngineObject.Position) : (-this._entity.EngineObject.Forward))); + Vector3 pos = this._entity.EngineObject.Position + xentity.Death.CurveV.Evaluate(xentity.Death.LandTime) * this._entity.Scale * this._step_dir; + float num = 0f; + bool flag5 = XSingleton.singleton.TryGetTerrainY(pos, out num); + if (flag5) + { + this._deltaH = this._entity.EngineObject.Position.y - num; + } + else + { + this._deltaH = 0f; + } + bool flag6 = this._deltaH < 0f; + if (flag6) + { + this._deltaH = 0f; + } + } + this._last_offset = 0f; + this._last_height = 0f; + this._elapsed = 0f; + this._entity.Dying(); + bool flag7 = !this._entity.IsRole; + if (flag7) + { + bool flag8 = xentity.Death.ClipLen > 0f; + if (flag8) + { + this._destory_token = XSingleton.singleton.SetTimer(xentity.Death.ClipLen + 1f, new XTimerMgr.ElapsedEventHandler(this.OnDestroy), null); + } + else + { + this.OnDestroy(null); + } + } + } + + private void OnFadeOut(object o) + { + XFadeOutEventArgs @event = XEventPool.GetEvent(); + @event.Out = 1f; + @event.Firer = this._entity; + XSingleton.singleton.FireEvent(@event); + } + + private void OnDestroy(object o) + { + bool flag = this._death_fx != null; + if (flag) + { + XSingleton.singleton.DestroyFx(this._death_fx, true); + } + this._death_fx = null; + this._entity.Died(); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/Components/ActionStates/XDeathComponent.cs.meta b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XDeathComponent.cs.meta new file mode 100644 index 00000000..26d7ed80 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XDeathComponent.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 271830e3a36d3d5479d15a99aa3708c0 +timeCreated: 1611403470 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/Components/ActionStates/XFallComponent.cs b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XFallComponent.cs new file mode 100644 index 00000000..18c13f3c --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XFallComponent.cs @@ -0,0 +1,109 @@ +using System; +using UnityEngine; +using XUtliPoolLib; + +namespace XMainClient +{ + internal sealed class XFallComponent : XActionStateComponent + { + public override uint ID + { + get + { + return XFallComponent.uuID; + } + } + + public override bool IsUsingCurve + { + get + { + return false; + } + } + + public override bool ShouldBePresent + { + get + { + bool isDead = this._entity.IsDead; + return !isDead && base.ShouldBePresent; + } + } + + public override string PresentCommand + { + get + { + return "ToFall"; + } + } + + public override string PresentName + { + get + { + return "Fall"; + } + } + + public new static readonly uint uuID = XSingleton.singleton.XHash("Basic_Fall"); + + private float _hvelocity = 0f; + + private float _gravity = -9.8f; + + private float _elapsed = 0f; + + protected override void EventSubscribe() + { + base.RegisterEvent(XEventDefine.XEvent_Fall, new XComponent.XEventHandler(base.OnActionEvent)); + } + + public override void OnAttachToHost(XObject host) + { + base.OnAttachToHost(host); + this._selfState = XStateDefine.XState_Fall; + } + + protected override void Cancel(XStateDefine next) + { + } + + protected override bool OnGetEvent(XFallEventArgs e, XStateDefine last) + { + this._hvelocity = e.HVelocity; + this._gravity = e.Gravity; + return true; + } + + protected override void Begin() + { + this._elapsed = 0f; + } + + protected override void ActionUpdate(float deltaTime) + { + bool flag = !this._entity.StandOn; + if (flag) + { + Vector3 vector = Vector3.zero; + this._elapsed += deltaTime; + this._hvelocity += (0f - this._hvelocity) * Mathf.Min(1f, deltaTime * 4f); + float num = this._gravity * this._elapsed; + vector.y += num * deltaTime; + Vector3 vector2 = XSingleton.singleton.Horizontal(this._entity.EngineObject.Forward); + vector += deltaTime * this._hvelocity * vector2; + this._entity.ApplyMove(vector); + } + else + { + base.Finish(); + } + } + + public override void OnRejected(XStateDefine current) + { + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/Components/ActionStates/XFallComponent.cs.meta b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XFallComponent.cs.meta new file mode 100644 index 00000000..9de4ec2f --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XFallComponent.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 5daac6f7d31161d42972f5b51a0d0fb5 +timeCreated: 1611403807 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/Components/ActionStates/XFallEventArgs.cs b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XFallEventArgs.cs new file mode 100644 index 00000000..efe6d354 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XFallEventArgs.cs @@ -0,0 +1,24 @@ +using System; + +namespace XMainClient +{ + internal class XFallEventArgs : XActionArgs + { + public float HVelocity { get; set; } + + public float Gravity { get; set; } + + public XFallEventArgs() + { + this._eDefine = XEventDefine.XEvent_Fall; + } + + public override void Recycle() + { + this.HVelocity = 0f; + this.Gravity = 0f; + base.Recycle(); + XEventPool.Recycle(this); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/Components/ActionStates/XFallEventArgs.cs.meta b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XFallEventArgs.cs.meta new file mode 100644 index 00000000..fc2c7cc8 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XFallEventArgs.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 4adc2287e8a9c124aaefe6ebcdba6bbd +timeCreated: 1611403666 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/Components/ActionStates/XFreezeComponent.cs b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XFreezeComponent.cs new file mode 100644 index 00000000..3a04200b --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XFreezeComponent.cs @@ -0,0 +1,229 @@ +using System; +using KKSG; +using UnityEngine; +using XUtliPoolLib; + +namespace XMainClient +{ + internal sealed class XFreezeComponent : XActionStateComponent + { + public override uint ID + { + get + { + return XFreezeComponent.uuID; + } + } + + public override bool IsUsingCurve + { + get + { + return false; + } + } + + public override string PresentCommand + { + get + { + return "ToFreezed"; + } + } + + public override string PresentName + { + get + { + return "Freezed"; + } + } + + public new static readonly uint uuID = XSingleton.singleton.XHash("Freezing_Presentation"); + + private float _freeze_time = 0f; + + private bool _present = false; + + private float _elapsed = 0f; + + private float _height_drop = 0f; + + private XFx _hit_fx = null; + + private XFx _hit_freeze_fx = null; + + public override void OnAttachToHost(XObject host) + { + base.OnAttachToHost(host); + this._selfState = XStateDefine.XState_Freeze; + this._freeze_time = 0f; + this._present = false; + this._elapsed = 0f; + bool isNotEmptyObject = this._entity.EngineObject.IsNotEmptyObject; + if (isNotEmptyObject) + { + this._entity.OverrideAnimClip("Freezed", this._entity.Present.PresentLib.Freeze, true, false); + } + } + + public override void OnDetachFromHost() + { + this.DestroyFx(ref this._hit_fx); + this.DestroyFx(ref this._hit_freeze_fx); + base.OnDetachFromHost(); + } + + public override string TriggerAnim(string pre) + { + bool flag = this._entity.Ator != null; + if (flag) + { + bool present = this._present; + if (present) + { + this._entity.Ator.speed = 1f; + this._entity.Ator.SetTrigger(this.PresentCommand); + pre = this.PresentCommand; + } + else + { + this._entity.Ator.speed = 0f; + } + } + return pre; + } + + protected override void Cancel(XStateDefine next) + { + bool flag = this._entity.Ator != null; + if (flag) + { + this._entity.Ator.speed = 1f; + } + this.DestroyFx(ref this._hit_fx); + this.DestroyFx(ref this._hit_freeze_fx); + this.TrytoTirggerQTE(true); + } + + protected override void EventSubscribe() + { + base.RegisterEvent(XEventDefine.XEvent_Freeze, new XComponent.XEventHandler(base.OnActionEvent)); + } + + protected override bool OnGetEvent(XFreezeEventArgs e, XStateDefine last) + { + this._freeze_time = ((e.HitData != null) ? e.HitData.FreezeDuration : e.Duration); + this._present = ((e.HitData != null) ? e.HitData.FreezePresent : e.Present); + bool flag = e.HitData != null; + if (flag) + { + bool flag2 = !string.IsNullOrEmpty(e.HitData.Fx); + if (flag2) + { + this.PlayHitFx(e.HitData.Fx, e.HitData.Fx_Follow, ref this._hit_fx); + } + bool flag3 = this._present && !string.IsNullOrEmpty(this._entity.Present.PresentLib.FreezeFx); + if (flag3) + { + this.PlayHitFx(this._entity.Present.PresentLib.FreezeFx, true, ref this._hit_freeze_fx); + } + } + XEndureEventArgs @event = XEventPool.GetEvent(); + @event.Firer = this._entity; + @event.Dir = e.Dir; + XSingleton.singleton.FireEvent(@event); + return true; + } + + protected override void Begin() + { + this._elapsed = 0f; + this._height_drop = this._entity.EngineObject.Position.y - ((this._entity.Fly != null) ? (XSingleton.singleton.TerrainY(this._entity.EngineObject.Position) + this._entity.Fly.CurrentHeight) : XSingleton.singleton.TerrainY(this._entity.EngineObject.Position)); + bool flag = this._height_drop < 0f; + if (flag) + { + this._height_drop = 0f; + } + this.TrytoTirggerQTE(false); + bool flag2 = !XSingleton.singleton.SyncMode && this._freeze_time <= 0f; + if (flag2) + { + base.Finish(); + } + } + + public override void OnRejected(XStateDefine current) + { + } + + protected override void ActionUpdate(float deltaTime) + { + bool flag = base.IsFinished || XSingleton.singleton.SyncMode; + if (!flag) + { + this._elapsed += deltaTime; + float num = deltaTime * (this._height_drop / this._freeze_time); + this._entity.ApplyMove(0f, -num, 0f); + bool flag2 = this._elapsed > this._freeze_time; + if (flag2) + { + base.Finish(); + } + bool flag3 = this._entity.Ator != null && !this._present; + if (flag3) + { + this._entity.Ator.speed = 0f; + } + } + } + + private void TrytoTirggerQTE(bool bEnd = false) + { + bool flag = !this._entity.Destroying && this._entity.QTE != null; + if (flag) + { + KKSG.XQTEState en = KKSG.XQTEState.QTE_None; + bool flag2 = !bEnd; + if (flag2) + { + en = KKSG.XQTEState.QTE_HitFreeze; + } + XSkillQTEEventArgs @event = XEventPool.GetEvent(); + @event.Firer = this._entity; + @event.On = !bEnd; + @event.State = (uint)XFastEnumIntEqualityComparer.ToInt(en); + XSingleton.singleton.FireEvent(@event); + } + } + + private void PlayHitFx(string fx, bool follow, ref XFx xfx) + { + bool flag = xfx != null && xfx.FxName != fx; + if (flag) + { + this.DestroyFx(ref xfx); + } + bool flag2 = XEntity.FilterFx(this._entity, XFxMgr.FilterFxDis1); + if (!flag2) + { + bool flag3 = xfx == null; + if (flag3) + { + xfx = XSingleton.singleton.CreateFx(fx, null, true); + } + xfx.Play(this._entity.EngineObject, Vector3.zero, ((this._entity.Radius > 0.5f) ? (this._entity.Radius * 2f) : 1f) * Vector3.one, 1f, follow, false, "", this._entity.Height * 0.5f); + } + } + + private void DestroyFx(ref XFx xfx) + { + bool flag = xfx != null; + if (flag) + { + XSingleton.singleton.DestroyFx(xfx, true); + xfx = null; + } + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/Components/ActionStates/XFreezeComponent.cs.meta b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XFreezeComponent.cs.meta new file mode 100644 index 00000000..13581314 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XFreezeComponent.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: fdda2cef18bc8e849a60b68929791560 +timeCreated: 1611404938 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/Components/ActionStates/XFreezeEventArgs.cs b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XFreezeEventArgs.cs new file mode 100644 index 00000000..c9411faa --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XFreezeEventArgs.cs @@ -0,0 +1,32 @@ +using System; +using UnityEngine; +using XUtliPoolLib; + +namespace XMainClient +{ + internal class XFreezeEventArgs : XActionArgs + { + public XHitData HitData { get; set; } + + public float Duration = 0f; + + public bool Present = false; + + public Vector3 Dir = Vector3.zero; + + public XFreezeEventArgs() + { + this._eDefine = XEventDefine.XEvent_Freeze; + } + + public override void Recycle() + { + this.HitData = null; + this.Duration = 0f; + this.Dir = Vector3.zero; + this.Present = false; + base.Recycle(); + XEventPool.Recycle(this); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/Components/ActionStates/XFreezeEventArgs.cs.meta b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XFreezeEventArgs.cs.meta new file mode 100644 index 00000000..230c76d9 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XFreezeEventArgs.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: aa19b044a26615a4db23e3ab2c562807 +timeCreated: 1611404301 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/Components/ActionStates/XIdleComponent.cs b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XIdleComponent.cs new file mode 100644 index 00000000..6835cb96 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XIdleComponent.cs @@ -0,0 +1,122 @@ +using System; +using XUtliPoolLib; + +namespace XMainClient +{ + internal sealed class XIdleComponent : XActionStateComponent + { + public override uint ID + { + get + { + return XIdleComponent.uuID; + } + } + + public override bool SyncPredicted + { + get + { + bool isViewGridScene = XSingleton.singleton.IsViewGridScene; + bool result; + if (isViewGridScene) + { + result = true; + } + else + { + bool syncMode = XSingleton.singleton.SyncMode; + if (syncMode) + { + bool flag = this._entity.Skill != null && this._entity.Skill.IsCasting(); + result = (!flag && this._entity.IsPlayer && !this._entity.IsPassive); + } + else + { + result = true; + } + } + return result; + } + } + + public override bool IsUsingCurve + { + get + { + return false; + } + } + + public override string PresentCommand + { + get + { + return "ToStand"; + } + } + + public override string PresentName + { + get + { + return "Stand"; + } + } + + public new static readonly uint uuID = XSingleton.singleton.XHash("Basic_Idle"); + + public override void OnAttachToHost(XObject host) + { + base.OnAttachToHost(host); + this._selfState = XStateDefine.XState_Idle; + this.PrepareAnimations(); + } + + protected override void EventSubscribe() + { + base.RegisterEvent(XEventDefine.XEvent_Idle, new XComponent.XEventHandler(base.OnActionEvent)); + base.RegisterEvent(XEventDefine.XEvent_OnMounted, new XComponent.XEventHandler(base.OnMountEvent)); + base.RegisterEvent(XEventDefine.XEvent_OnUnMounted, new XComponent.XEventHandler(base.OnMountEvent)); + } + + public override void OnRejected(XStateDefine current) + { + } + + protected override bool OnGetEvent(XIdleEventArgs e, XStateDefine last) + { + return true; + } + + protected override void OnMount(XMount mount) + { + bool flag = mount != null; + if (flag) + { + this._entity.OverrideAnimClip("Idle", this._entity.Present.PresentLib.AnimLocation.Replace('/', '_') + mount.Present.PresentLib.Idle + (this._entity.IsCopilotMounted ? "_follow" : ""), true, false); + } + else + { + this.PrepareAnimations(); + } + } + + private void PrepareAnimations() + { + bool isNotEmptyObject = this._entity.EngineObject.IsNotEmptyObject; + if (isNotEmptyObject) + { + bool flag = XSingleton.singleton.CurrentStage.Stage == EXStage.World && !string.IsNullOrEmpty(this._entity.Present.PresentLib.AttackIdle); + if (flag) + { + this._entity.OverrideAnimClip("Idle", this._entity.Present.PresentLib.AttackIdle, true, false); + } + else + { + this._entity.OverrideAnimClip("Idle", this._entity.Present.PresentLib.Idle, true, false); + } + } + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/Components/ActionStates/XIdleComponent.cs.meta b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XIdleComponent.cs.meta new file mode 100644 index 00000000..39855f15 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XIdleComponent.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 6af983d36e7cacf438cab3a92767ab22 +timeCreated: 1611403890 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/Components/ActionStates/XIdleEventArgs.cs b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XIdleEventArgs.cs new file mode 100644 index 00000000..15e8a7e4 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XIdleEventArgs.cs @@ -0,0 +1,18 @@ +using System; + +namespace XMainClient +{ + internal class XIdleEventArgs : XActionArgs + { + public XIdleEventArgs() + { + this._eDefine = XEventDefine.XEvent_Idle; + } + + public override void Recycle() + { + base.Recycle(); + XEventPool.Recycle(this); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/Components/ActionStates/XIdleEventArgs.cs.meta b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XIdleEventArgs.cs.meta new file mode 100644 index 00000000..b4b4392b --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XIdleEventArgs.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 3c27eeb1eb3466f4ba01c6bf644b0f1a +timeCreated: 1611403601 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/Components/ActionStates/XJumpComponent.cs b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XJumpComponent.cs new file mode 100644 index 00000000..3954c6ca --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XJumpComponent.cs @@ -0,0 +1,130 @@ +using System; +using UnityEngine; +using XUtliPoolLib; + +namespace XMainClient +{ + internal sealed class XJumpComponent : XActionStateComponent + { + public override uint ID + { + get + { + return XJumpComponent.uuID; + } + } + + public override bool IsUsingCurve + { + get + { + return false; + } + } + + public override string PresentCommand + { + get + { + return "ToJump"; + } + } + + public override string PresentName + { + get + { + return "Jump"; + } + } + + public new static readonly uint uuID = XSingleton.singleton.XHash("Basic_Jump"); + + private bool _jumpState = false; + + private float _hvelocity = 0f; + + private float _jumpforce = 4f; + + private float _gravity = -9.8f; + + private float _jumptime = 0f; + + protected override void EventSubscribe() + { + base.RegisterEvent(XEventDefine.XEvent_Jump, new XComponent.XEventHandler(base.OnActionEvent)); + } + + public override void OnAttachToHost(XObject host) + { + base.OnAttachToHost(host); + this._selfState = XStateDefine.XState_Jump; + } + + protected override void Cancel(XStateDefine next) + { + this._jumpState = false; + this._jumptime = 0f; + } + + protected override bool OnGetEvent(XJumpEventArgs e, XStateDefine last) + { + this._hvelocity = e.Hvelocity; + this._jumpforce = e.Vvelocity; + this._gravity = e.Gravity; + return true; + } + + protected override void Begin() + { + this._jumpState = true; + this._jumptime = 0f; + } + + protected override void ActionUpdate(float deltaTime) + { + Vector3 vector = Vector3.zero; + this._jumpState = !this.CollisionOnTop(); + bool jumpState = this._jumpState; + if (jumpState) + { + this._jumptime += deltaTime; + float num = this._gravity * this._jumptime * this._jumptime / 2f; + num += this._jumpforce * this._jumptime; + bool flag = XSingleton.singleton.IsGreater(this._jumptime, this._jumpforce / -this._gravity); + if (flag) + { + this._jumpState = false; + this.SwithToFall(); + } + vector.y += num; + Vector3 vector2 = XSingleton.singleton.Horizontal(this._entity.EngineObject.Forward); + vector += deltaTime * this._hvelocity * vector2; + this._entity.ApplyMove(vector); + } + else + { + this.SwithToFall(); + } + } + + public override void OnRejected(XStateDefine current) + { + } + + private void SwithToFall() + { + XFallEventArgs @event = XEventPool.GetEvent(); + @event.HVelocity = this._hvelocity; + @event.Gravity = this._gravity; + @event.Firer = this._host; + XSingleton.singleton.FireEvent(@event); + base.Finish(); + } + + private bool CollisionOnTop() + { + return false; + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/Components/ActionStates/XJumpComponent.cs.meta b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XJumpComponent.cs.meta new file mode 100644 index 00000000..2300b872 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XJumpComponent.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 3f5d799d46111904d8c180391ebcf46a +timeCreated: 1611403610 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/Components/ActionStates/XJumpEventArgs.cs b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XJumpEventArgs.cs new file mode 100644 index 00000000..27996cb1 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XJumpEventArgs.cs @@ -0,0 +1,27 @@ +using System; + +namespace XMainClient +{ + internal class XJumpEventArgs : XActionArgs + { + public float Gravity { get; set; } + + public float Hvelocity { get; set; } + + public float Vvelocity { get; set; } + + public XJumpEventArgs() + { + this._eDefine = XEventDefine.XEvent_Jump; + } + + public override void Recycle() + { + this.Gravity = 0f; + this.Hvelocity = 0f; + this.Vvelocity = 0f; + base.Recycle(); + XEventPool.Recycle(this); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/Components/ActionStates/XJumpEventArgs.cs.meta b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XJumpEventArgs.cs.meta new file mode 100644 index 00000000..d8fcc5a1 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XJumpEventArgs.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: d2de48c455c705c4b8f81299a4d16c4a +timeCreated: 1611404597 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/Components/ActionStates/XMoveComponent.cs b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XMoveComponent.cs new file mode 100644 index 00000000..37770981 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XMoveComponent.cs @@ -0,0 +1,548 @@ +using System; +using UnityEngine; +using XUtliPoolLib; + +namespace XMainClient +{ + internal sealed class XMoveComponent : XActionStateComponent + { + public override uint ID + { + get + { + return XMoveComponent.uuID; + } + } + + public override float Speed + { + get + { + return this._begin_inertia ? 0f : this._speed; + } + } + + public float AnimSpeed + { + get + { + return this._anim_speed; + } + set + { + this._anim_speed = value; + } + } + + public override bool IsUsingCurve + { + get + { + return false; + } + } + + public override bool SyncPredicted + { + get + { + return this._entity.IsClientPredicted || base.SyncPredicted; + } + } + + public override bool ShouldBePresent + { + get + { + return this._entity.Machine.Previous != XStateDefine.XState_Move; + } + } + + public override string PresentCommand + { + get + { + return "ToMove"; + } + } + + public override string PresentName + { + get + { + return "Move"; + } + } + + public new static readonly uint uuID = XSingleton.singleton.XHash("Basic_Move"); + + private bool _begin_inertia = false; + + private bool _stoppage = true; + + private float _speed = 0f; + + private float _last_speed = 0f; + + private float _target_speed = 0f; + + private float _anim_speed = 0f; + + private float _stoppage_dir = 0f; + + private float _acceleration = 0f; + + private float _last_angular = 0f; + + private Vector3 _move_dir = Vector3.forward; + + private Vector3 _destination = Vector3.zero; + + private bool _inertia = false; + + private bool _overlapped = false; + + private uint _track_fx_1 = 0u; + + private uint _track_fx_2 = 0u; + + private XTimerMgr.ElapsedEventHandler _playTrackFxCb = null; + + public XMoveComponent() + { + this._playTrackFxCb = new XTimerMgr.ElapsedEventHandler(this.PlayTrackFx); + } + + public override void OnAttachToHost(XObject host) + { + base.OnAttachToHost(host); + this._selfState = XStateDefine.XState_Move; + this._speed = 0f; + this._last_speed = 0f; + this._acceleration = 0f; + this.PrepareAnimations(); + } + + protected override void EventSubscribe() + { + base.RegisterEvent(XEventDefine.XEvent_Move, new XComponent.XEventHandler(base.OnActionEvent)); + base.RegisterEvent(XEventDefine.XEvent_OnMounted, new XComponent.XEventHandler(base.OnMountEvent)); + base.RegisterEvent(XEventDefine.XEvent_OnUnMounted, new XComponent.XEventHandler(base.OnMountEvent)); + } + + protected override bool InnerPermitted(XStateDefine state) + { + bool flag = !this._entity.IsPlayer && this.SyncPredicted; + bool result; + if (flag) + { + result = (state != XStateDefine.XState_Idle || this._stoppage); + } + else + { + result = (base.IsFinished || base.InnerPermitted(state)); + } + return result; + } + + protected override void Cancel(XStateDefine next) + { + bool flag = next != XStateDefine.XState_Move; + if (flag) + { + XEntity xentity = this._entity.IsTransform ? this._entity.Transformer : this._entity; + xentity.Machine.SetAnimationSpeed(1f); + for (int i = 0; i < xentity.Affiliates.Count; i++) + { + bool flag2 = xentity.Affiliates[i].Ator != null; + if (flag2) + { + xentity.Affiliates[i].Ator.speed = xentity.Ator.speed; + } + } + bool flag3 = xentity.IsMounted && xentity.Mount.Ator != null; + if (flag3) + { + xentity.Mount.Ator.speed = xentity.Ator.speed; + } + this._speed = 0f; + this._last_speed = 0f; + this._acceleration = 0f; + bool flag4 = this._track_fx_1 > 0u; + if (flag4) + { + XSingleton.singleton.KillTimer(this._track_fx_1); + } + bool flag5 = this._track_fx_2 > 0u; + if (flag5) + { + XSingleton.singleton.KillTimer(this._track_fx_2); + } + this._track_fx_1 = 0u; + this._track_fx_2 = 0u; + this._anim_speed = 0f; + bool flag6 = !this._entity.IsPlayer && this.SyncPredicted; + if (flag6) + { + this._entity.Net.ReportRotateAction(XSingleton.singleton.FloatToAngle(this._stoppage_dir)); + } + } + } + + protected override void Cease() + { + this._begin_inertia = false; + } + + public override void OnRejected(XStateDefine current) + { + } + + public override string TriggerAnim(string pre) + { + bool isPlayer = this._entity.IsPlayer; + if (isPlayer) + { + bool flag = this._track_fx_1 == 0u; + if (flag) + { + this._track_fx_1 = XSingleton.singleton.SetTimer(0.144f, this._playTrackFxCb, null); + } + bool flag2 = this._track_fx_2 == 0u; + if (flag2) + { + this._track_fx_2 = XSingleton.singleton.SetTimer(0.426f, this._playTrackFxCb, this); + } + } + string text = (base.IsFinished && this._entity.IsPlayer) ? "ToStand" : this.PresentCommand; + bool flag3 = pre != text; + if (flag3) + { + bool flag4 = this._entity.Ator != null; + if (flag4) + { + this._entity.Ator.SetTrigger(text); + } + } + return text; + } + + protected override void ActionUpdate(float deltaTime) + { + this._last_speed = this._speed; + bool isFinished = base.IsFinished; + if (!isFinished) + { + bool flag = this._speed == 0f && this._target_speed == 0f; + if (flag) + { + base.Finish(); + } + else + { + this._speed += deltaTime * this._acceleration; + bool flag2 = (this._speed - this._target_speed) * this._acceleration > 0f; + if (flag2) + { + this._speed = this._target_speed; + this._acceleration = 0f; + } + bool begin_inertia = this._begin_inertia; + if (!begin_inertia) + { + Vector3 movement = this._move_dir * ((this._speed + this._last_speed) * 0.5f) * deltaTime; + bool flag3 = this._entity.Buffs != null && this._entity.Buffs.IsBuffStateOn(XBuffType.XBuffType_LockFoot); + if (flag3) + { + movement = Vector3.zero; + } + this.CheckMove(ref movement); + bool flag4 = this._entity.IsPlayer || this._entity.IsEnemy; + if (flag4) + { + XSecurityStatistics xsecurityStatistics = XSecurityStatistics.TryGetStatistics(this._entity); + bool flag5 = xsecurityStatistics != null; + if (flag5) + { + xsecurityStatistics.OnMove(movement.magnitude); + } + } + //c 移动 + this._entity.ApplyMove(movement); + } + } + this._anim_speed = this._speed; + } + } + + public override void PostUpdate(float fDeltaT) + { + bool flag = this._entity.Machine.Current != XStateDefine.XState_Move; + if (!flag) + { + XEntity xentity = this._entity.IsTransform ? this._entity.Transformer : this._entity; + bool flag2 = xentity.Ator == null; + if (!flag2) + { + bool flag3 = XSingleton.singleton.IsLess(this._anim_speed, this._entity.Attributes.WalkSpeed); + if (flag3) + { + xentity.Machine.SetAnimationSpeed(Mathf.Max(0.5f, this._anim_speed / this._entity.Attributes.WalkSpeed)); + } + else + { + bool flag4 = XSingleton.singleton.IsGreater(this._anim_speed, this._entity.Attributes.RunSpeed); + if (flag4) + { + xentity.Machine.SetAnimationSpeed(this._anim_speed / this._entity.Attributes.RunSpeed); + } + else + { + xentity.Machine.SetAnimationSpeed(1f); + } + } + float value = this._anim_speed / this._entity.Attributes.RunSpeed; + bool flag5 = xentity.IsMounted && xentity.Mount.Ator != null; + if (flag5) + { + bool hasTurnPresetation = xentity.Mount.HasTurnPresetation; + if (hasTurnPresetation) + { + float num = xentity.Rotate.Angular(); + this._last_angular += (num - this._last_angular) * Mathf.Min(1f, fDeltaT * (float)xentity.Mount.AngularSpeed); + } + else + { + this._last_angular = 0f; + } + xentity.Ator.SetFloat("MoveFactor", value); + xentity.Ator.SetFloat("AngleFactor", this._last_angular); + for (int i = 0; i < xentity.Affiliates.Count; i++) + { + bool flag6 = xentity.Affiliates[i].Ator != null; + if (flag6) + { + xentity.Affiliates[i].Ator.speed = xentity.Ator.speed; + xentity.Affiliates[i].Ator.SetFloat("MoveFactor", value); + xentity.Affiliates[i].Ator.SetFloat("AngleFactor", this._last_angular); + } + } + bool flag7 = xentity.IsMounted && xentity.Mount.Ator != null; + if (flag7) + { + xentity.Mount.Ator.speed = xentity.Ator.speed; + xentity.Mount.Ator.SetFloat("MoveFactor", value); + xentity.Mount.Ator.SetFloat("AngleFactor", this._last_angular); + } + } + else + { + this._last_angular = 0f; + xentity.Ator.SetFloat("MoveFactor", value); + xentity.Ator.SetFloat("AngleFactor", 0f); + for (int j = 0; j < xentity.Affiliates.Count; j++) + { + bool flag8 = xentity.Affiliates[j].Ator != null; + if (flag8) + { + xentity.Affiliates[j].Ator.speed = xentity.Ator.speed; + xentity.Affiliates[j].Ator.SetFloat("MoveFactor", value); + xentity.Affiliates[j].Ator.SetFloat("AngleFactor", 0f); + } + } + } + } + } + } + + protected override bool OnGetEvent(XMoveEventArgs e, XStateDefine last) + { + this._stoppage = e.Stoppage; + this._stoppage_dir = e.StopTowards; + this._inertia = e.Inertia; + this._target_speed = e.Speed; + this._destination = e.Destination; + this._move_dir = this._destination - this._entity.MoveObj.Position; + this._move_dir.y = 0f; + float sqrMagnitude = this._move_dir.sqrMagnitude; + bool flag = sqrMagnitude == 0f || ((double)sqrMagnitude < 0.001 && this._entity.IsPlayer) || (sqrMagnitude < 0.1f && !this._entity.IsPlayer && this.SyncPredicted && this._stoppage); + if (flag) + { + this._move_dir = this._entity.MoveObj.Forward; + this._target_speed = 0f; + } + this._move_dir.Normalize(); + bool flag2 = this._entity.Fly != null; + if (flag2) + { + float num = XSingleton.singleton.TerrainY(this._destination); + bool flag3 = this._destination.y - num < this._entity.Fly.MinHeight; + if (flag3) + { + this._destination.y = num + (this._entity.Fly.MinHeight + this._entity.Fly.MaxHeight) * 0.5f; + } + } + bool flag4 = this._entity.IsPlayer && XSingleton.singleton.CurrentStage.Stage == EXStage.Hall; + if (flag4) + { + XMoveEventArgs @event = XEventPool.GetEvent(); + @event.Speed = this._target_speed; + @event.Destination = this._destination; + @event.Inertia = this._inertia; + @event.Firer = XSingleton.singleton.Doc; + XSingleton.singleton.FireEvent(@event); + } + return true; + } + + protected override void Begin() + { + this._begin_inertia = false; + bool flag = this._target_speed != this._speed; + if (flag) + { + bool flag2 = this._target_speed > this._speed; + if (flag2) + { + this._acceleration = this._entity.Attributes.RunSpeed * 5f; + } + else + { + this._acceleration = -this._entity.Attributes.RunSpeed * 6f; + } + } + else + { + this._acceleration = 0f; + } + this._entity.Net.ReportRotateAction(this._move_dir); + this._overlapped = false; + Vector3 zero = Vector3.zero; + this.CheckMove(ref zero); + } + + protected override void OnMount(XMount mount) + { + bool flag = mount != null; + if (flag) + { + this._entity.OverrideAnimClip("Walk", this._entity.Present.PresentLib.AnimLocation.Replace('/', '_') + mount.Present.PresentLib.Walk + (this._entity.IsCopilotMounted ? "_follow" : ""), true, false); + this._entity.OverrideAnimClip("Run", this._entity.Present.PresentLib.AnimLocation.Replace('/', '_') + mount.Present.PresentLib.Run + (this._entity.IsCopilotMounted ? "_follow" : ""), true, false); + bool hasTurnPresetation = mount.HasTurnPresetation; + if (hasTurnPresetation) + { + this._entity.OverrideAnimClip("RunLeft", this._entity.Present.PresentLib.AnimLocation.Replace('/', '_') + mount.Present.PresentLib.RunLeft + (this._entity.IsCopilotMounted ? "_follow" : ""), true, false); + this._entity.OverrideAnimClip("RunRight", this._entity.Present.PresentLib.AnimLocation.Replace('/', '_') + mount.Present.PresentLib.RunRight + (this._entity.IsCopilotMounted ? "_follow" : ""), true, false); + } + } + else + { + this.PrepareAnimations(); + } + this._entity.Machine.TriggerPresent(); + } + + private void CheckMove(ref Vector3 movement) + { + bool flag = !this._overlapped; + if (flag) + { + this._overlapped = this.Overlapped(ref movement); + bool overlapped = this._overlapped; + if (overlapped) + { + this._target_speed = 0f; + bool flag2 = this._inertia && this._speed > 0f; + if (flag2) + { + this._acceleration = -this._entity.Attributes.RunSpeed * 6f; + this._begin_inertia = true; + } + else + { + this._acceleration = 0f; + base.Finish(); + } + } + } + } + + private bool Overlapped(ref Vector3 movement) + { + Vector3 vector = this._entity.MoveObj.Position + movement; + vector.y = 0f; + Vector3 destination = this._destination; + destination.y = 0f; + Vector3 vector2 = destination - vector; + bool flag = vector2.sqrMagnitude > 0f; + bool result; + if (flag) + { + float num = Vector3.Angle(vector2, this._move_dir); + bool flag2 = num >= 90f; + if (flag2) + { + movement = this._destination - this._entity.MoveObj.Position; + bool flag3 = this._entity.Fly != null; + if (flag3) + { + movement.y = 0f; + } + result = true; + } + else + { + result = false; + } + } + else + { + result = true; + } + return result; + } + + private void PlayTrackFx(object o) + { + bool flag = string.IsNullOrEmpty(this._entity.Present.PresentLib.MoveFx); + if (!flag) + { + uint num = XSingleton.singleton.SetTimer(0.533f, this._playTrackFxCb, o); + bool flag2 = o == null; + if (flag2) + { + this._track_fx_1 = num; + } + else + { + this._track_fx_2 = num; + } + XSingleton.singleton.CreateAndPlay(this._entity.Present.PresentLib.MoveFx, this._entity.MoveObj, Vector3.zero, Vector3.one, 1f, false, 0.5f, true); + XSingleton.singleton.PlaySound(this._entity, AudioChannel.Motion, XAudioStateDefine.XState_Audio_Move); + } + } + + private void PrepareAnimations() + { + bool isNotEmptyObject = this._entity.EngineObject.IsNotEmptyObject; + if (isNotEmptyObject) + { + bool flag = XSingleton.singleton.CurrentStage.Stage == EXStage.World && !string.IsNullOrEmpty(this._entity.Present.PresentLib.AttackIdle); + if (flag) + { + this._entity.OverrideAnimClip("Walk", this._entity.Present.PresentLib.AttackWalk, true, false); + this._entity.OverrideAnimClip("Run", this._entity.Present.PresentLib.AttackRun, true, false); + this._entity.OverrideAnimClip("RunLeft", this._entity.Present.PresentLib.AttackRunLeft, true, false); + this._entity.OverrideAnimClip("RunRight", this._entity.Present.PresentLib.AttackRunRight, true, false); + } + else + { + this._entity.OverrideAnimClip("Walk", this._entity.Present.PresentLib.Walk, true, false); + this._entity.OverrideAnimClip("Run", this._entity.Present.PresentLib.Run, true, false); + this._entity.OverrideAnimClip("RunLeft", this._entity.Present.PresentLib.RunLeft, true, false); + this._entity.OverrideAnimClip("RunRight", this._entity.Present.PresentLib.RunRight, true, false); + } + } + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/Components/ActionStates/XMoveComponent.cs.meta b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XMoveComponent.cs.meta new file mode 100644 index 00000000..b3cd016d --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XMoveComponent.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 1463440e51231af4c92f71e5b87eb46f +timeCreated: 1611403257 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/Components/ActionStates/XMoveEventArgs.cs b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XMoveEventArgs.cs new file mode 100644 index 00000000..d56d8ca4 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XMoveEventArgs.cs @@ -0,0 +1,34 @@ +using System; +using UnityEngine; + +namespace XMainClient +{ + internal class XMoveEventArgs : XActionArgs + { + public Vector3 Destination = Vector3.zero; + + public float Speed = 0f; + + public bool Inertia = false; + + public bool Stoppage = true; + + public float StopTowards = 0f; + + public XMoveEventArgs() + { + this._eDefine = XEventDefine.XEvent_Move; + } + + public override void Recycle() + { + base.Recycle(); + this.Destination = Vector3.zero; + this.Speed = 0f; + this.Inertia = false; + this.Stoppage = true; + this.StopTowards = 0f; + XEventPool.Recycle(this); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/Components/ActionStates/XMoveEventArgs.cs.meta b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XMoveEventArgs.cs.meta new file mode 100644 index 00000000..17174164 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XMoveEventArgs.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 4ec55d210f9ed30409ee715d1cf40900 +timeCreated: 1611403699 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: diff --git a/Client/Assets/Scripts/XMainClient/Components/ActionStates/XMoveMobEventArgs.cs b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XMoveMobEventArgs.cs new file mode 100644 index 00000000..e071bcbb --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XMoveMobEventArgs.cs @@ -0,0 +1,18 @@ +using System; + +namespace XMainClient +{ + internal class XMoveMobEventArgs : XEventArgs + { + public XMoveMobEventArgs() + { + this._eDefine = XEventDefine.XEvent_Move_Mob; + } + + public override void Recycle() + { + base.Recycle(); + XEventPool.Recycle(this); + } + } +} diff --git a/Client/Assets/Scripts/XMainClient/Components/ActionStates/XMoveMobEventArgs.cs.meta b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XMoveMobEventArgs.cs.meta new file mode 100644 index 00000000..6b102440 --- /dev/null +++ b/Client/Assets/Scripts/XMainClient/Components/ActionStates/XMoveMobEventArgs.cs.meta @@ -0,0 +1,12 @@ +fileFormatVersion: 2 +guid: 5d9b6dd5005db9248a0051d1db971cd2 +timeCreated: 1611403807 +licenseType: Free +MonoImporter: + serializedVersion: 2 + defaultReferences: [] + executionOrder: 0 + icon: {instanceID: 0} + userData: + assetBundleName: + assetBundleVariant: -- cgit v1.1-26-g67d0