+scripts

1 files changed, 239 insertions, 0 deletions

diff --git a/Client/Assets/Scripts/XMainClient/XActionReceiver.cs b/Client/Assets/Scripts/XMainClient/XActionReceiver.cs
new file mode 100644
index 00000000..3a8ad8b6
--- /dev/null
+++ b/Client/Assets/Scripts/XMainClient/XActionReceiver.cs
@@ -0,0 +1,239 @@
+using System;

+using KKSG;

+using UnityEngine;

+using XUtliPoolLib;

+

+namespace XMainClient

+{

+	internal class XActionReceiver : XSingleton<XActionReceiver>

+	{

+		public void OnActionReceived(XEntity entity, StepSyncData data)

+		{

+			XStateDefine xstateDefine = (XStateDefine)(data.Common >> 12 & 15);

+			Vector3 pos;

+			pos= new Vector3((float)(data.PosXZ >> 16) / 100f, 0f, (float)(data.PosXZ & 65535) / 100f);

+			Vector3 face = XSingleton<XCommon>.singleton.FloatToAngle((float)(data.Common & 4095));

+			uint num = (uint)(data.Common >> 16);

+			bool flag = xstateDefine != XStateDefine.XState_Skill && entity.Skill != null && entity.Skill.IsCasting();

+			if (flag)

+			{

+				entity.Skill.EndSkill(false, true);

+			}

+			switch (xstateDefine)

+			{

+			case XStateDefine.XState_Idle:

+				entity.Net.OnIdle();

+				break;

+			case XStateDefine.XState_Move:

+			{

+				bool flag2 = entity.Machine.Current != XStateDefine.XState_Move;

+				if (flag2)

+				{

+					entity.Machine.Stop();

+					bool flag3 = entity.Net.SyncSequence != num;

+					if (flag3)

+					{

+						XMoveEventArgs @event = XEventPool<XMoveEventArgs>.GetEvent();

+						@event.Speed = (float)data.Velocity / 10f;

+						@event.Destination = entity.MoveObj.Position;

+						@event.Inertia = false;

+						@event.Firer = entity;

+						XSingleton<XEventMgr>.singleton.FireEvent(@event);

+					}

+				}

+				entity.Net.CorrectMoveSpeed((float)data.Velocity / 10f);

+				break;

+			}

+			case XStateDefine.XState_Freeze:

+			{

+				bool isPlayer = entity.IsPlayer;

+				if (isPlayer)

+				{

+					XSingleton<XActionSender>.singleton.Empty();

+				}

+				bool flag4 = entity.Net.SyncSequence != num;

+				if (flag4)

+				{

+					XEntity entity2 = XSingleton<XEntityMgr>.singleton.GetEntity(data.OpposerID);

+					bool flag5 = entity2 != null;

+					if (flag5)

+					{

+						bool freezedFromHit = data.FreezedFromHit;

+						if (freezedFromHit)

+						{

+							XSkillCore skill = entity2.SkillMgr.GetSkill((uint)data.Skillid);

+							bool flag6 = skill != null && skill.Soul.Hit != null && skill.Soul.Hit.Count > data.HitIdx;

+							if (flag6)

+							{

+								XHitData hitData = skill.Soul.Hit[data.HitIdx];

+								XFreezeEventArgs event2 = XEventPool<XFreezeEventArgs>.GetEvent();

+								event2.HitData = hitData;

+								event2.Dir = Vector3.forward;

+								event2.Firer = entity;

+								XSingleton<XEventMgr>.singleton.FireEvent(event2);

+							}

+						}

+						else

+						{

+							XFreezeEventArgs event3 = XEventPool<XFreezeEventArgs>.GetEvent();

+							event3.Present = data.PresentInFreezed;

+							event3.Dir = Vector3.forward;

+							event3.Firer = entity;

+							XSingleton<XEventMgr>.singleton.FireEvent(event3);

+						}

+					}

+				}

+				break;

+			}

+			case XStateDefine.XState_BeHit:

+			{

+				bool isPlayer2 = entity.IsPlayer;

+				if (isPlayer2)

+				{

+					XSingleton<XActionSender>.singleton.Empty();

+				}

+				bool flag7 = entity.Net.SyncSequence != num;

+				if (flag7)

+				{

+					XEntity entity3 = XSingleton<XEntityMgr>.singleton.GetEntity(data.OpposerID);

+					bool flag8 = entity3 != null;

+					if (flag8)

+					{

+						XSkillCore skill2 = entity3.SkillMgr.GetSkill((uint)data.Skillid);

+						bool flag9 = skill2 != null && skill2.Soul.Hit != null && skill2.Soul.Hit.Count > data.HitIdx;

+						if (flag9)

+						{

+							entity.Machine.Stop();

+							XHitData hitData2 = skill2.Soul.Hit[data.HitIdx];

+							entity.Machine.Stop();

+							XBeHitEventArgs event4 = XEventPool<XBeHitEventArgs>.GetEvent();

+							event4.DepracatedPass = true;

+							event4.HitDirection = Vector3.forward;

+							event4.HitData = hitData2;

+							event4.Firer = entity;

+							event4.HitFrom = entity3;

+							event4.Paralyze = (float)data.HitParalyzeFactor / 100f;

+							event4.ForceToFlyHit = data.HitForceToFly;

+							XSingleton<XEventMgr>.singleton.FireEvent(event4);

+						}

+					}

+				}

+				break;

+			}

+			case XStateDefine.XState_Death:

+			{

+				bool isPlayer3 = entity.IsPlayer;

+				if (isPlayer3)

+				{

+					XSingleton<XActionSender>.singleton.Empty();

+				}

+				break;

+			}

+			case XStateDefine.XState_Skill:

+			{

+				int num2 = data.SkillCommon & 255;

+				bool flag10 = num2 == 255;

+				if (flag10)

+				{

+					num2 = -1;

+				}

+				float num3 = (float)(data.SkillCommon >> 8 & 255) / 100f;

+				float num4 = (float)(data.SkillCommon >> 16 & 255) / 10f;

+				float num5 = (float)(data.SkillCommon >> 24 & 255) / 100f;

+				bool flag11 = entity.Net.SyncSequence != num;

+				if (flag11)

+				{

+					XEntity target = data.OpposerIDSpecified ? XSingleton<XEntityMgr>.singleton.GetEntity(data.OpposerID) : null;

+					bool flag12 = false;

+					XJAComboSkill xjacomboSkill = entity.Skill.CurrentSkill as XJAComboSkill;

+					bool flag13 = xjacomboSkill != null;

+					if (flag13)

+					{

+						uint num6 = (xjacomboSkill.MainCore.Soul.Ja == null || xjacomboSkill.MainCore.Soul.Ja.Count == 0) ? 0u : XSingleton<XCommon>.singleton.XHash(xjacomboSkill.MainCore.Soul.Ja[0].Name);

+						bool flag14 = num6 == (uint)data.Skillid;

+						if (flag14)

+						{

+							xjacomboSkill.ReFire((uint)data.Skillid, target, num2, num4, num);

+							flag12 = true;

+						}

+					}

+					bool flag15 = !flag12;

+					if (flag15)

+					{

+						entity.Skill.EndSkill(false, true);

+						XAttackEventArgs event5 = XEventPool<XAttackEventArgs>.GetEvent();

+						event5.Target = target;

+						event5.Identify = (uint)data.Skillid;

+						event5.Firer = entity;

+						event5.Slot = num2;

+						event5.TimeScale = num4;

+						event5.SyncSequence = num;

+						XSingleton<XEventMgr>.singleton.FireEvent(event5);

+					}

+					bool flag16 = num3 == 0f;

+					if (flag16)

+					{

+						bool flag17 = data.Skillid == (int)entity.SkillMgr.GetBrokenIdentity();

+						if (flag17)

+						{

+							XArmorBrokenArgs event6 = XEventPool<XArmorBrokenArgs>.GetEvent();

+							event6.Firer = entity;

+							XSingleton<XEventMgr>.singleton.FireEvent(event6);

+							XArmorBrokenArgs event7 = XEventPool<XArmorBrokenArgs>.GetEvent();

+							event7.Firer = XSingleton<XGame>.singleton.Doc;

+							event7.Self = entity;

+							XSingleton<XEventMgr>.singleton.FireEvent(event7);

+						}

+						else

+						{

+							bool flag18 = data.Skillid == (int)entity.SkillMgr.GetRecoveryIdentity();

+							if (flag18)

+							{

+								XArmorRecoverArgs event8 = XEventPool<XArmorRecoverArgs>.GetEvent();

+								event8.Firer = entity;

+								XSingleton<XEventMgr>.singleton.FireEvent(event8);

+								XArmorRecoverArgs event9 = XEventPool<XArmorRecoverArgs>.GetEvent();

+								event9.Firer = XSingleton<XGame>.singleton.Doc;

+								event9.Self = entity;

+								XSingleton<XEventMgr>.singleton.FireEvent(event9);

+							}

+						}

+					}

+				}

+				bool flag19 = num5 > 0f && entity.Skill.IsCasting();

+				if (flag19)

+				{

+					entity.Skill.TagTrigger();

+					entity.Skill.CurrentSkill.MultipleDirectionFactorByServer = num5;

+				}

+				break;

+			}

+			}

+			bool flag20 = xstateDefine > XStateDefine.XState_Idle;

+			if (flag20)

+			{

+				entity.Net.KillIdle();

+			}

+			entity.IsPassive = (data.PassiveSpecified && data.Passive);

+			entity.Net.CorrectNet(pos, face, num, entity.Skill != null && entity.Skill.Enabled && entity.Machine != null && entity.Machine.Enabled);

+		}

+

+		public void OnMoveReceived(XEntity entity, StepMoveData data)

+		{

+			Vector3 destination;

+			destination= new Vector3((float)(data.PosXZ >> 16) / 100f, 0f, (float)(data.PosXZ & 65535) / 100f);

+			XMoveEventArgs @event = XEventPool<XMoveEventArgs>.GetEvent();

+			@event.Speed = entity.Attributes.RunSpeed;

+			@event.Destination = destination;

+			@event.Inertia = data.Stoppage;

+			@event.Stoppage = data.Stoppage;

+			bool stoppage = data.Stoppage;

+			if (stoppage)

+			{

+				@event.StopTowards = (float)data.Face / 10f;

+			}

+			@event.Firer = entity;

+			XSingleton<XEventMgr>.singleton.FireEvent(@event);

+		}

+	}

+}