private bool OnBulletRefected(EvtAfterBulletReflected evt)
        {
            AbilityTriggerBullet bullet = Singleton <EventManager> .Instance.GetActor <AbilityTriggerBullet>(evt.bulletID);

            MonoTriggerBullet triggerBullet = bullet.triggerBullet;

            bullet.Setup(base.actor, triggerBullet.speed, MixinTargetting.All, triggerBullet.IgnoreTimeScale, triggerBullet.AliveDuration);
            evt.attackData.attackerAttackValue *= base.instancedAbility.Evaluate(this.config.DamageRatio);
            Vector3 position = Singleton <EventManager> .Instance.GetEntity(evt.launcherID).GetAttachPoint("RootNode").position;

            BaseAbilityActor actor = Singleton <EventManager> .Instance.GetActor <BaseAbilityActor>(evt.launcherID);

            if (Vector3.Angle(base.instancedAbility.caster.entity.transform.forward, actor.entity.transform.position - base.instancedAbility.caster.entity.transform.position) < this.config.Angle)
            {
                if (this.config.IsReflectToLauncher)
                {
                    triggerBullet.SetupTracing(position, triggerBullet._traceLerpCoef, triggerBullet._traceLerpCoefAcc, false);
                    triggerBullet.transform.forward = -triggerBullet.transform.forward;
                }
                else
                {
                    position.y += UnityEngine.Random.Range((float)1f, (float)3f);
                    Vector3 rhs          = position - base.entity.XZPosition;
                    float   sqrMagnitude = rhs.sqrMagnitude;
                    rhs.y = 0f;
                    Vector3 onUnitSphere = UnityEngine.Random.onUnitSphere;
                    if (Vector3.Dot(onUnitSphere, rhs) < 0f)
                    {
                        onUnitSphere = -onUnitSphere;
                    }
                    onUnitSphere.y = Mathf.Abs(onUnitSphere.y);
                    triggerBullet.transform.forward = onUnitSphere;
                    triggerBullet.SetupTracing((Vector3)((onUnitSphere.normalized * sqrMagnitude) * 0.8f), triggerBullet._traceLerpCoef, triggerBullet._traceLerpCoefAcc, false);
                }
                if (this.config.ResetAliveDuration)
                {
                    triggerBullet.AliveDuration = this.config.NewAliveDuration;
                }
                base.actor.abilityPlugin.HandleActionTargetDispatch(this.config.ReflectSuccessActions, base.instancedAbility, base.instancedModifier, Singleton <EventManager> .Instance.GetActor <BaseAbilityActor>(evt.launcherID), evt);
            }
            else
            {
                EvtBulletHit hit = new EvtBulletHit(triggerBullet.GetRuntimeID(), base.actor.runtimeID)
                {
                    ownerID           = base.actor.runtimeID,
                    cannotBeReflected = true
                };
                Vector3 vector4 = triggerBullet.transform.position - ((Vector3)((Time.deltaTime * triggerBullet.BulletTimeScale) * triggerBullet.transform.GetComponent <Rigidbody>().velocity));
                AttackResult.HitCollsion collsion = new AttackResult.HitCollsion {
                    hitPoint = vector4,
                    hitDir   = triggerBullet.transform.forward
                };
                hit.hitCollision = collsion;
                Singleton <EventManager> .Instance.FireEvent(hit, MPEventDispatchMode.Normal);
            }
            return(false);
        }
        protected override bool ListenBulletHit(EvtBulletHit evt)
        {
            if (base.selfIdentity.isAuthority)
            {
                Singleton <MPEventManager> .Instance.MarkEventReplicate(evt);

                return(base.ListenBulletHit(evt));
            }
            return(false);
        }
Example #3
0
 private void OnTriggerEnter(Collider other)
 {
     if (((this._collisionMask.value & (((int)1) << other.gameObject.layer)) != 0) && this._collisionEnabled)
     {
         BaseMonoEntity componentInParent = other.GetComponentInParent <BaseMonoEntity>();
         if (Singleton <RuntimeIDManager> .Instance.ParseCategory(componentInParent.GetRuntimeID()) == 4)
         {
             if (this._enteredIDs.Contains(componentInParent.GetRuntimeID()))
             {
                 return;
             }
         }
         else if (!componentInParent.IsActive() || this._enteredIDs.Contains(componentInParent.GetRuntimeID()))
         {
             return;
         }
         BaseMonoEntity owner = componentInParent;
         if (componentInParent is BaseMonoDynamicObject)
         {
             BaseMonoDynamicObject obj2 = (BaseMonoDynamicObject)componentInParent;
             if ((obj2.dynamicType == BaseMonoDynamicObject.DynamicType.EvadeDummy) && (obj2.owner != null))
             {
                 this._enteredIDs.Add(obj2.owner.GetRuntimeID());
             }
         }
         else if (componentInParent is MonoBodyPartEntity)
         {
             owner = ((MonoBodyPartEntity)componentInParent).owner;
         }
         if (!(owner is BaseMonoAbilityEntity) || !((BaseMonoAbilityEntity)owner).isGhost)
         {
             this._enteredIDs.Add(owner.GetRuntimeID());
             EvtBulletHit evt = new EvtBulletHit(base._runtimeID, owner.GetRuntimeID())
             {
                 ownerID = base.ownerID
             };
             Vector3 position = base.transform.position - ((Vector3)((Time.deltaTime * this.BulletTimeScale) * this._rigidbody.velocity));
             AttackResult.HitCollsion collsion = new AttackResult.HitCollsion {
                 hitPoint = other.ClosestPointOnBounds(position),
                 hitDir   = this.CreateHitForward()
             };
             evt.hitCollision = collsion;
             Singleton <EventManager> .Instance.FireEvent(evt, MPEventDispatchMode.Normal);
         }
     }
 }
Example #4
0
 public static EvtBulletHit Deserialize(Packet_Event_EvtBulletHit table, EvtBulletHit obj)
 {
     if (obj == null)
     {
         obj = new EvtBulletHit();
     }
     obj.targetID = table.TargetID;
     obj.otherID  = table.OtherID;
     if (table.GetHitCollision(GetCachedTable <MPHitCollision>()) != null)
     {
         obj.hitCollision = Deserialize(GetCachedTable <MPHitCollision>(), new AttackResult.HitCollsion());
     }
     obj.hitEnvironment    = table.HitEnvironment;
     obj.hitGround         = table.HitGround;
     obj.cannotBeReflected = table.CannotBeReflected;
     return(obj);
 }
Example #5
0
        protected override void Update()
        {
            AttackResult.HitCollsion collsion;
            base.Update();
            if (this._resetTimer != null)
            {
                this._resetTimer.Core(1f);
                if (this._resetTimer.isTimeUp)
                {
                    this._enteredIDs.Clear();
                    this._resetTimer.Reset(false);
                }
            }
            if (this._aliveTimer.isActive)
            {
                this._aliveTimer.Core(this.BulletTimeScale);
                if (this._aliveTimer.isTimeUp)
                {
                    EvtBulletHit evt = new EvtBulletHit(base._runtimeID)
                    {
                        ownerID = base.ownerID
                    };
                    collsion = new AttackResult.HitCollsion {
                        hitDir   = this.CreateHitForward(),
                        hitPoint = base.transform.position
                    };
                    evt.hitCollision = collsion;
                    evt.hitGround    = true;
                    evt.selfExplode  = true;
                    Singleton <EventManager> .Instance.FireEvent(evt, MPEventDispatchMode.Normal);

                    this._aliveTimer.Reset(false);
                }
            }
            if (InLevelData.IsOutOfStage(this.XZPosition))
            {
                EvtBulletHit hit2 = new EvtBulletHit(base._runtimeID)
                {
                    ownerID = base.ownerID
                };
                collsion = new AttackResult.HitCollsion {
                    hitDir   = this.CreateHitForward(),
                    hitPoint = base.transform.position
                };
                hit2.hitCollision = collsion;
                Singleton <EventManager> .Instance.FireEvent(hit2, MPEventDispatchMode.Normal);
            }
            else if ((base.transform.position.y < 0.05f) && this._collisionEnabled)
            {
                EvtBulletHit hit3 = new EvtBulletHit(base._runtimeID)
                {
                    ownerID = base.ownerID
                };
                collsion = new AttackResult.HitCollsion {
                    hitDir   = this.CreateHitForward(),
                    hitPoint = base.transform.position
                };
                hit3.hitCollision = collsion;
                hit3.hitGround    = true;
                Singleton <EventManager> .Instance.FireEvent(hit3, MPEventDispatchMode.Normal);
            }
            else if (this._state == BulletState.Linear)
            {
                this.speed += (this.acceleration * Time.deltaTime) * this.BulletTimeScale;
                this._rigidbody.velocity = (Vector3)((this.speed * base.transform.forward) * this.BulletTimeScale);
            }
            else if (this._state == BulletState.TracePosition)
            {
                this._traceLerpCoef += (this._traceLerpCoefAcc * Time.deltaTime) * this.BulletTimeScale;
                Vector3 forward = base.transform.forward;
                Vector3 vector3 = this._targetPosition - this._rigidbody.position;
                if (vector3.magnitude >= this.targetReachThreshold)
                {
                    forward = Vector3.Normalize(this._targetPosition - this._rigidbody.position);
                    float num = Vector3.Angle(forward, base.transform.forward);
                    if (!this._passBy || (num < 90.0))
                    {
                        base.transform.forward = Vector3.Slerp(base.transform.forward, forward, (Time.deltaTime * this.BulletTimeScale) * this._traceLerpCoef);
                    }
                    this.speed += (this.acceleration * Time.deltaTime) * this.BulletTimeScale;
                    this._rigidbody.velocity = (Vector3)(((this.speed * base.transform.forward) + this.speedAdd) * this.BulletTimeScale);
                }
                else
                {
                    this._rigidbody.velocity = (Vector3)(base.transform.forward * 0f);
                    if (this._collisionEnabled)
                    {
                        EvtBulletHit hit4 = new EvtBulletHit(base._runtimeID)
                        {
                            ownerID = base.ownerID
                        };
                        collsion = new AttackResult.HitCollsion {
                            hitDir   = this.CreateHitForward(),
                            hitPoint = base.transform.position
                        };
                        hit4.hitCollision = collsion;
                        hit4.hitGround    = true;
                        Singleton <EventManager> .Instance.FireEvent(hit4, MPEventDispatchMode.Normal);
                    }
                }
            }
            else if (((this._state == BulletState.Placing) && (this._placingTimer != null)) && this._placingTimer.isActive)
            {
                this._placingTimer.Core(this.BulletTimeScale);
                if (!this._placingTimer.isTimeUp)
                {
                    base.transform.position  = Vector3.Slerp(this._originalPosition, this._placingPosition, this._placingTimer.timer / this._placingTimer.timespan);
                    this._collisionEnabled   = false;
                    this._collisionMask      = -1;
                    this._rigidbody.velocity = (Vector3)((this.speed * base.transform.forward) * this.BulletTimeScale);
                }
                else
                {
                    this._state = BulletState.TracePosition;
                    this._placingTimer.Reset(false);
                    this.speed             = this._resumeSpeed;
                    this._collisionEnabled = true;
                }
            }
        }
        protected override bool ListenBulletHit(EvtBulletHit evt)
        {
            if (!base._bulletAttackDatas.ContainsKey(evt.targetID))
            {
                return(false);
            }
            BaseMPIdentity identity = Singleton <MPManager> .Instance.TryGetIdentity(evt.otherID);

            if (((identity != null) && !identity.isAuthority) && !identity.remoteMode.IsRemoteReceive())
            {
                return(false);
            }
            AttackData attackData = base._bulletAttackDatas[evt.targetID];

            attackData.isFromBullet = true;
            bool           flag   = base.baseConfig.BulletHitType == BulletHitBehavior.DestroyAndDoExplodeDamage;
            bool           flag2  = (base.baseConfig.BulletHitType == BulletHitBehavior.DestroyAndDoExplodeDamage) || (base.baseConfig.BulletHitType == BulletHitBehavior.DestroyAndDamageHitTarget);
            bool           flag3  = true;
            bool           flag4  = base.baseConfig.BulletHitType == BulletHitBehavior.NoDestroyAndRefresh;
            BaseMonoEntity entity = Singleton <EventManager> .Instance.GetEntity(evt.otherID);

            BaseAbilityActor actor = Singleton <EventManager> .Instance.GetActor(evt.otherID) as BaseAbilityActor;

            if ((entity is MonoDummyDynamicObject) || ((identity != null) && !identity.remoteMode.IsRemoteReceive()))
            {
                flag2 = false;
                flag  = false;
                flag3 = false;
                flag4 = false;
            }
            else if (evt.hitEnvironment)
            {
                flag2 = true;
                flag4 = false;
            }
            else if ((!evt.cannotBeReflected && (actor != null)) && actor.abilityState.ContainsState(AbilityState.ReflectBullet))
            {
                Singleton <EventManager> .Instance.FireEvent(new EvtAfterBulletReflected(evt.otherID, evt.targetID, base.actor.runtimeID, base._bulletAttackDatas[evt.targetID]), MPEventDispatchMode.Normal);

                return(false);
            }
            AbilityTriggerBullet bulletActor = Singleton <EventManager> .Instance.GetActor <AbilityTriggerBullet>(evt.targetID);

            if (flag2)
            {
                bulletActor.Kill();
                base._bulletAttackDatas.Remove(evt.targetID);
            }
            else
            {
                attackData = attackData.Clone();
            }
            if (flag4)
            {
                bulletActor.triggerBullet.ResetInside(base.baseConfig.ResetTime);
            }
            base._evtsLs.Clear();
            if (evt.hitEnvironment)
            {
                if (!evt.hitGround)
                {
                    return(true);
                }
                EvtHittingOther item = new EvtHittingOther(base.actor.runtimeID, evt.otherID, attackData)
                {
                    hitCollision = evt.hitCollision
                };
                base._evtsLs.Add(item);
            }
            else
            {
                attackData.hitCollision = evt.hitCollision;
                base._evtsLs.Add(new EvtHittingOther(base.actor.runtimeID, evt.otherID, base.baseConfig.HitAnimEventID, attackData));
            }
            if (flag)
            {
                List <CollisionResult> list = CollisionDetectPattern.CylinderCollisionDetectBySphere(evt.hitCollision.hitPoint, evt.hitCollision.hitPoint, base.instancedAbility.Evaluate(base.baseConfig.HitExplodeRadius), 1f, Singleton <EventManager> .Instance.GetAbilityHitboxTargettingMask(base.actor.runtimeID, base.baseConfig.Targetting));
                float y = evt.hitCollision.hitPoint.y;
                for (int j = 0; j < list.Count; j++)
                {
                    CollisionResult result = list[j];
                    BaseMonoEntity  collisionResultEntity = AttackPattern.GetCollisionResultEntity(result.entity);
                    if ((collisionResultEntity != null) && (collisionResultEntity.GetRuntimeID() != evt.otherID))
                    {
                        result.hitPoint.y = y;
                        AttackData data2 = attackData.Clone();
                        AttackResult.HitCollsion collsion = new AttackResult.HitCollsion {
                            hitDir   = result.hitForward,
                            hitPoint = result.hitPoint
                        };
                        data2.hitCollision = collsion;
                        base._evtsLs.Add(new EvtHittingOther(base.actor.runtimeID, collisionResultEntity.GetRuntimeID(), base.baseConfig.HitAnimEventID, data2));
                    }
                }
            }
            if (flag3)
            {
                Vector3 hitPoint = evt.hitCollision.hitPoint;
                if (base.baseConfig.ExplodeEffectGround)
                {
                    hitPoint.y = 0f;
                }
                Vector3 hitDir = evt.hitCollision.hitDir;
                hitDir.y = 0f;
                base.FireTriggerBulletHitExplodeEffect(bulletActor, hitPoint, hitDir, false);
            }
            if (base.baseConfig.HitExplodeActions.Length > 0)
            {
                for (int k = 0; k < base._evtsLs.Count; k++)
                {
                    base.actor.abilityPlugin.HandleActionTargetDispatch(base.baseConfig.HitExplodeActions, base.instancedAbility, base.instancedModifier, Singleton <EventManager> .Instance.GetActor <BaseAbilityActor>(base._evtsLs[k].toID), evt);
                }
            }
            for (int i = 0; i < base._evtsLs.Count; i++)
            {
                EvtHittingOther other2 = base._evtsLs[i];
                AttackPattern.SendHitEvent(base.actor.runtimeID, other2.toID, other2.animEventID, other2.hitCollision, other2.attackData, false, MPEventDispatchMode.CheckRemoteMode);
            }
            return(true);
        }
        protected virtual bool ListenBulletHit(EvtBulletHit evt)
        {
            if (!this._bulletAttackDatas.ContainsKey(evt.targetID))
            {
                return(false);
            }
            AttackData attackData = this._bulletAttackDatas[evt.targetID];

            attackData.isFromBullet = true;
            bool           flag   = this.baseConfig.BulletHitType == BulletHitBehavior.DestroyAndDoExplodeDamage;
            bool           flag2  = (this.baseConfig.BulletHitType == BulletHitBehavior.DestroyAndDoExplodeDamage) || (this.baseConfig.BulletHitType == BulletHitBehavior.DestroyAndDamageHitTarget);
            bool           flag3  = true;
            bool           flag4  = this.baseConfig.BulletHitType == BulletHitBehavior.NoDestroyAndRefresh;
            BaseMonoEntity entity = Singleton <EventManager> .Instance.GetEntity(evt.otherID);

            BaseAbilityActor actor = Singleton <EventManager> .Instance.GetActor(evt.otherID) as BaseAbilityActor;

            if (entity is MonoDummyDynamicObject)
            {
                flag2 = false;
                flag  = false;
                flag3 = false;
                flag4 = false;
            }
            else if (evt.hitEnvironment)
            {
                flag2 = true;
                flag4 = false;
            }
            else if ((!evt.cannotBeReflected && (actor != null)) && actor.abilityState.ContainsState(AbilityState.ReflectBullet))
            {
                Singleton <EventManager> .Instance.FireEvent(new EvtAfterBulletReflected(evt.otherID, evt.targetID, base.actor.runtimeID, this._bulletAttackDatas[evt.targetID]), MPEventDispatchMode.Normal);

                return(false);
            }
            AbilityTriggerBullet bulletActor = Singleton <EventManager> .Instance.GetActor <AbilityTriggerBullet>(evt.targetID);

            if (flag2)
            {
                if (bulletActor != null)
                {
                    bulletActor.Kill();
                }
                this._bulletAttackDatas.Remove(evt.targetID);
            }
            else
            {
                attackData = attackData.Clone();
            }
            if (flag4 && (bulletActor != null))
            {
                bulletActor.triggerBullet.ResetInside(this.baseConfig.ResetTime);
            }
            this._evtsLs.Clear();
            if (evt.hitEnvironment)
            {
                if (!evt.hitGround)
                {
                    return(true);
                }
                EvtHittingOther item = new EvtHittingOther(base.actor.runtimeID, evt.otherID, attackData)
                {
                    hitCollision = evt.hitCollision
                };
                this._evtsLs.Add(item);
            }
            else
            {
                attackData.hitCollision = evt.hitCollision;
                this._evtsLs.Add(new EvtHittingOther(base.actor.runtimeID, evt.otherID, this.baseConfig.HitAnimEventID, attackData));
            }
            if (flag)
            {
                List <CollisionResult> list = CollisionDetectPattern.CylinderCollisionDetectBySphere(evt.hitCollision.hitPoint, evt.hitCollision.hitPoint, base.instancedAbility.Evaluate(this.baseConfig.HitExplodeRadius), 1f, Singleton <EventManager> .Instance.GetAbilityHitboxTargettingMask(base.actor.runtimeID, this.baseConfig.Targetting));
                float y = evt.hitCollision.hitPoint.y;
                for (int j = 0; j < list.Count; j++)
                {
                    CollisionResult result = list[j];
                    BaseMonoEntity  collisionResultEntity = AttackPattern.GetCollisionResultEntity(result.entity);
                    if ((collisionResultEntity != null) && (collisionResultEntity.GetRuntimeID() != evt.otherID))
                    {
                        result.hitPoint.y = y;
                        AttackData data2 = attackData.Clone();
                        AttackResult.HitCollsion collsion = new AttackResult.HitCollsion {
                            hitDir   = result.hitForward,
                            hitPoint = result.hitPoint
                        };
                        data2.hitCollision = collsion;
                        this._evtsLs.Add(new EvtHittingOther(base.actor.runtimeID, collisionResultEntity.GetRuntimeID(), this.baseConfig.HitAnimEventID, data2));
                    }
                }
            }
            if (flag3)
            {
                Vector3 hitPoint = evt.hitCollision.hitPoint;
                if (this.baseConfig.ExplodeEffectGround)
                {
                    hitPoint.y = 0f;
                }
                Vector3 hitDir = evt.hitCollision.hitDir;
                hitDir.y = 0f;
                bool selfExplode = evt.selfExplode;
                if (bulletActor != null)
                {
                    this.FireTriggerBulletHitExplodeEffect(bulletActor, hitPoint, hitDir, selfExplode);
                }
            }
            if ((this.baseConfig.HitExplodeActions.Length > 0) && (!evt.selfExplode || !this.baseConfig.MuteSelfHitExplodeActions))
            {
                for (int k = 0; k < this._evtsLs.Count; k++)
                {
                    if (base.actor.abilityPlugin != null)
                    {
                        base.actor.abilityPlugin.HandleActionTargetDispatch(this.baseConfig.HitExplodeActions, base.instancedAbility, base.instancedModifier, Singleton <EventManager> .Instance.GetActor <BaseAbilityActor>(this._evtsLs[k].toID), evt);
                    }
                }
            }
            for (int i = 0; i < this._evtsLs.Count; i++)
            {
                EvtHittingOther other2 = this._evtsLs[i];
                if (this.baseConfig.IsHitChangeTargetDirection && (other2.attackData.hitEffect >= AttackResult.AnimatorHitEffect.ThrowUp))
                {
                    BaseAbilityActor actor2 = Singleton <EventManager> .Instance.GetActor <BaseAbilityActor>(other2.toID);

                    if (actor2 != null)
                    {
                        actor2.entity.transform.forward = -other2.attackData.hitCollision.hitDir;
                    }
                }
                Singleton <EventManager> .Instance.FireEvent(other2, MPEventDispatchMode.Normal);
            }
            return(true);
        }
Example #8
0
        public static Offset <Packet_Event_EvtBulletHit> Serialize(FlatBufferBuilder builder, EvtBulletHit obj)
        {
            Offset <MPHitCollision> hitCollisionOffset = new Offset <MPHitCollision>();

            if (obj.hitCollision != null)
            {
                hitCollisionOffset = Serialize(builder, obj.hitCollision);
            }
            Packet_Event_EvtBulletHit.StartPacket_Event_EvtBulletHit(builder);
            Packet_Event_EvtBulletHit.AddTargetID(builder, obj.targetID);
            Packet_Event_EvtBulletHit.AddOtherID(builder, obj.otherID);
            Packet_Event_EvtBulletHit.AddHitCollision(builder, hitCollisionOffset);
            Packet_Event_EvtBulletHit.AddHitEnvironment(builder, obj.hitEnvironment);
            Packet_Event_EvtBulletHit.AddHitGround(builder, obj.hitGround);
            Packet_Event_EvtBulletHit.AddCannotBeReflected(builder, obj.cannotBeReflected);
            return(Packet_Event_EvtBulletHit.EndPacket_Event_EvtBulletHit(builder));
        }
Example #9
0
 public static object DeserializeToObject(Table table, object obj)
 {
     if (table.GetType() == typeof(MoleMole.MPProtocol.MPStageData))
     {
         if (obj == null)
         {
             obj = new MoleMole.MPStageData();
         }
         return(Deserialize((MoleMole.MPProtocol.MPStageData)table, (MoleMole.MPStageData)obj));
     }
     if (table.GetType() == typeof(MoleMole.MPProtocol.MPAvatarDataItem))
     {
         if (obj == null)
         {
             obj = new MoleMole.MPAvatarDataItem();
         }
         return(Deserialize((MoleMole.MPProtocol.MPAvatarDataItem)table, (MoleMole.MPAvatarDataItem)obj));
     }
     if (table.GetType() == typeof(Packet_Event_EvtHittingOther))
     {
         if (obj == null)
         {
             obj = new EvtHittingOther();
         }
         return(Deserialize((Packet_Event_EvtHittingOther)table, (EvtHittingOther)obj));
     }
     if (table.GetType() == typeof(Packet_Event_EvtBeingHit))
     {
         if (obj == null)
         {
             obj = new EvtBeingHit();
         }
         return(Deserialize((Packet_Event_EvtBeingHit)table, (EvtBeingHit)obj));
     }
     if (table.GetType() == typeof(Packet_Event_EvtAttackLanded))
     {
         if (obj == null)
         {
             obj = new EvtAttackLanded();
         }
         return(Deserialize((Packet_Event_EvtAttackLanded)table, (EvtAttackLanded)obj));
     }
     if (table.GetType() == typeof(Packet_Event_EvtEvadeSuccess))
     {
         if (obj == null)
         {
             obj = new EvtEvadeSuccess();
         }
         return(Deserialize((Packet_Event_EvtEvadeSuccess)table, (EvtEvadeSuccess)obj));
     }
     if (table.GetType() == typeof(Packet_Event_EvtBulletHit))
     {
         if (obj == null)
         {
             obj = new EvtBulletHit();
         }
         return(Deserialize((Packet_Event_EvtBulletHit)table, (EvtBulletHit)obj));
     }
     if (table.GetType() == typeof(MPAttackData))
     {
         if (obj == null)
         {
             obj = new AttackData();
         }
         return(Deserialize((MPAttackData)table, (AttackData)obj));
     }
     if (table.GetType() == typeof(MPAttackResult))
     {
         if (obj == null)
         {
             obj = new AttackResult();
         }
         return(Deserialize((MPAttackResult)table, (AttackResult)obj));
     }
     if (table.GetType() != typeof(MPHitCollision))
     {
         return(obj);
     }
     if (obj == null)
     {
         obj = new AttackResult.HitCollsion();
     }
     return(Deserialize((MPHitCollision)table, (AttackResult.HitCollsion)obj));
 }