コード例 #1
0
        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);
        }
コード例 #2
0
        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);
        }
コード例 #3
0
 public EvtEvadeSuccess(uint targetID, uint attackerID, string skillID, AttackData attackData) : base(targetID)
 {
     this.attackerID = attackerID;
     this.skillID    = skillID;
     this.attackData = attackData;
 }
コード例 #4
0
 public EvtAfterBulletReflected(uint targetID, uint bulletID, uint launcherID, AttackData attackData) : base(targetID)
 {
     this.bulletID   = bulletID;
     this.launcherID = launcherID;
     this.attackData = attackData;
 }
コード例 #5
0
ファイル: MPMappings.cs プロジェクト: slb1988/agame
        public static Offset <MPAttackData> Serialize(FlatBufferBuilder builder, AttackData obj)
        {
            Offset <MPHitCollision> hitCollisionOffset = new Offset <MPHitCollision>();

            if (obj.hitCollision != null)
            {
                hitCollisionOffset = Serialize(builder, obj.hitCollision);
            }
            MPAttackData.StartMPAttackData(builder);
            MPAttackData.AddAttackerAniDamageRatio(builder, obj.attackerAniDamageRatio);
            MPAttackData.AddAttackerClass(builder, (byte)obj.attackerClass);
            MPAttackData.AddAttackerNature(builder, (byte)obj.attackerNature);
            MPAttackData.AddAttackerCategory(builder, obj.attackerCategory);
            MPAttackData.AddAttackerCritChance(builder, obj.attackerCritChance);
            MPAttackData.AddAttackerCritDamageRatio(builder, obj.attackerCritDamageRatio);
            MPAttackData.AddAttackerLevel(builder, obj.attackerLevel);
            MPAttackData.AddAttackerShieldDamageRatio(builder, obj.attackerShieldDamageRatio);
            MPAttackData.AddAttackerShieldDamageDelta(builder, obj.attackerShieldDamageDelta);
            MPAttackData.AddAttackerAttackPercentage(builder, obj.attackerAttackPercentage);
            MPAttackData.AddAttackerAttackValue(builder, obj.attackerAttackValue);
            MPAttackData.AddAddedAttackRatio(builder, obj.addedAttackRatio);
            MPAttackData.AddAddedDamageRatio(builder, obj.addedDamageRatio);
            MPAttackData.AddAttackerAddedAttackValue(builder, obj.attackerAddedAttackValue);
            MPAttackData.AddAttackerNormalDamage(builder, obj.attackerNormalDamage);
            MPAttackData.AddAttackerNormalDamagePercentage(builder, obj.attackerNormalDamagePercentage);
            MPAttackData.AddAddedAttackerNormalDamageRatio(builder, obj.addedAttackerNormalDamageRatio);
            MPAttackData.AddAttackerFireDamage(builder, obj.attackerFireDamage);
            MPAttackData.AddAttackerFireDamagePercentage(builder, obj.attackerFireDamagePercentage);
            MPAttackData.AddAddedAttackerFireDamageRatio(builder, obj.addedAttackerFireDamageRatio);
            MPAttackData.AddAttackerThunderDamage(builder, obj.attackerThunderDamage);
            MPAttackData.AddAttackerThunderDamagePercentage(builder, obj.attackerThunderDamagePercentage);
            MPAttackData.AddAddedAttackerThunderDamageRatio(builder, obj.addedAttackerThunderDamageRatio);
            MPAttackData.AddAttackerIceDamage(builder, obj.attackerIceDamage);
            MPAttackData.AddAttackerIceDamagePercentage(builder, obj.attackerIceDamagePercentage);
            MPAttackData.AddAddedAttackerIceDamageRatio(builder, obj.addedAttackerIceDamageRatio);
            MPAttackData.AddAttackerAlienDamage(builder, obj.attackerAlienDamage);
            MPAttackData.AddAttackerAlienDamagePercentage(builder, obj.attackerAlienDamagePercentage);
            MPAttackData.AddAddedAttackerAlienDamageRatio(builder, obj.addedAttackerAlienDamageRatio);
            MPAttackData.AddAttackeeAniDefenceRatio(builder, obj.attackeeAniDefenceRatio);
            MPAttackData.AddAttackeeNature(builder, (byte)obj.attackeeNature);
            MPAttackData.AddAttackeeClass(builder, (byte)obj.attackeeClass);
            MPAttackData.AddNatureDamageRatio(builder, obj.natureDamageRatio);
            MPAttackData.AddDamage(builder, obj.damage);
            MPAttackData.AddPlainDamage(builder, obj.plainDamage);
            MPAttackData.AddThunderDamage(builder, obj.thunderDamage);
            MPAttackData.AddIceDamage(builder, obj.iceDamage);
            MPAttackData.AddAlienDamage(builder, obj.alienDamage);
            MPAttackData.AddAniDamageRatio(builder, obj.aniDamageRatio);
            MPAttackData.AddRetreatVelocity(builder, obj.retreatVelocity);
            MPAttackData.AddFrameHalt(builder, obj.frameHalt);
            MPAttackData.AddIsAnimEventAttack(builder, obj.isAnimEventAttack);
            MPAttackData.AddIsInComboCount(builder, obj.isInComboCount);
            MPAttackData.AddAttackCategoryTag(builder, (int)obj.attackCategoryTag);
            MPAttackData.AddHitType(builder, (byte)obj.hitType);
            MPAttackData.AddHitFlag(builder, (int)obj.hitFlag);
            MPAttackData.AddHitLevel(builder, (byte)obj.hitLevel);
            MPAttackData.AddHitEffect(builder, (byte)obj.hitEffect);
            MPAttackData.AddHitEffectAux(builder, (byte)obj.hitEffectAux);
            MPAttackData.AddHitEffectPattern(builder, (byte)obj.hitEffectPattern);
            MPAttackData.AddKillEffect(builder, (byte)obj.killEffect);
            MPAttackData.AddRejectState(builder, (byte)obj.rejectState);
            MPAttackData.AddIsFromBullet(builder, obj.isFromBullet);
            MPAttackData.AddNoTriggerEvadeAndDefend(builder, obj.noTriggerEvadeAndDefend);
            MPAttackData.AddHitCollision(builder, hitCollisionOffset);
            MPAttackData.AddAttackEffectPattern(builder, (ushort)IndexedConfig <ConfigEntityAttackEffect> .Mapping.TryGet(obj.attackEffectPattern));
            MPAttackData.AddBeHitEffectPattern(builder, (ushort)IndexedConfig <ConfigEntityAttackEffect> .Mapping.TryGet(obj.beHitEffectPattern));
            MPAttackData.AddAttackCameraShake(builder, (ushort)IndexedConfig <ConfigEntityCameraShake> .Mapping.TryGet(obj.attackCameraShake));
            return(MPAttackData.EndMPAttackData(builder));
        }
コード例 #6
0
ファイル: MPMappings.cs プロジェクト: slb1988/agame
        public static AttackData Deserialize(MPAttackData table, AttackData obj)
        {
            if (obj == null)
            {
                obj = new AttackData();
            }
            obj.attackerAniDamageRatio          = table.AttackerAniDamageRatio;
            obj.attackerClass                   = (EntityClass)table.AttackerClass;
            obj.attackerNature                  = (EntityNature)table.AttackerNature;
            obj.attackerCategory                = table.AttackerCategory;
            obj.attackerCritChance              = table.AttackerCritChance;
            obj.attackerCritDamageRatio         = table.AttackerCritDamageRatio;
            obj.attackerLevel                   = table.AttackerLevel;
            obj.attackerShieldDamageRatio       = table.AttackerShieldDamageRatio;
            obj.attackerShieldDamageDelta       = table.AttackerShieldDamageDelta;
            obj.attackerAttackPercentage        = table.AttackerAttackPercentage;
            obj.attackerAttackValue             = table.AttackerAttackValue;
            obj.addedAttackRatio                = table.AddedAttackRatio;
            obj.addedDamageRatio                = table.AddedDamageRatio;
            obj.attackerAddedAttackValue        = table.AttackerAddedAttackValue;
            obj.attackerNormalDamage            = table.AttackerNormalDamage;
            obj.attackerNormalDamagePercentage  = table.AttackerNormalDamagePercentage;
            obj.addedAttackerNormalDamageRatio  = table.AddedAttackerNormalDamageRatio;
            obj.attackerFireDamage              = table.AttackerFireDamage;
            obj.attackerFireDamagePercentage    = table.AttackerFireDamagePercentage;
            obj.addedAttackerFireDamageRatio    = table.AddedAttackerFireDamageRatio;
            obj.attackerThunderDamage           = table.AttackerThunderDamage;
            obj.attackerThunderDamagePercentage = table.AttackerThunderDamagePercentage;
            obj.addedAttackerThunderDamageRatio = table.AddedAttackerThunderDamageRatio;
            obj.attackerIceDamage               = table.AttackerIceDamage;
            obj.attackerIceDamagePercentage     = table.AttackerIceDamagePercentage;
            obj.addedAttackerIceDamageRatio     = table.AddedAttackerIceDamageRatio;
            obj.attackerAlienDamage             = table.AttackerAlienDamage;
            obj.attackerAlienDamagePercentage   = table.AttackerAlienDamagePercentage;
            obj.addedAttackerAlienDamageRatio   = table.AddedAttackerAlienDamageRatio;
            obj.attackeeAniDefenceRatio         = table.AttackeeAniDefenceRatio;
            obj.attackeeNature                  = (EntityNature)table.AttackeeNature;
            obj.attackeeClass                   = (EntityClass)table.AttackeeClass;
            obj.natureDamageRatio               = table.NatureDamageRatio;
            obj.damage                  = table.Damage;
            obj.plainDamage             = table.PlainDamage;
            obj.thunderDamage           = table.ThunderDamage;
            obj.iceDamage               = table.IceDamage;
            obj.alienDamage             = table.AlienDamage;
            obj.aniDamageRatio          = table.AniDamageRatio;
            obj.retreatVelocity         = table.RetreatVelocity;
            obj.frameHalt               = table.FrameHalt;
            obj.isAnimEventAttack       = table.IsAnimEventAttack;
            obj.isInComboCount          = table.IsInComboCount;
            obj.attackCategoryTag       = (AttackResult.AttackCategoryTag)table.AttackCategoryTag;
            obj.hitType                 = (AttackResult.ActorHitType)table.HitType;
            obj.hitFlag                 = (AttackResult.ActorHitFlag)table.HitFlag;
            obj.hitLevel                = (AttackResult.ActorHitLevel)table.HitLevel;
            obj.hitEffect               = (AttackResult.AnimatorHitEffect)table.HitEffect;
            obj.hitEffectAux            = (AttackResult.AnimatorHitEffectAux)table.HitEffectAux;
            obj.hitEffectPattern        = (AttackResult.HitEffectPattern)table.HitEffectPattern;
            obj.killEffect              = (KillEffect)table.KillEffect;
            obj.rejectState             = (AttackResult.RejectType)table.RejectState;
            obj.isFromBullet            = table.IsFromBullet;
            obj.noTriggerEvadeAndDefend = table.NoTriggerEvadeAndDefend;
            if (table.GetHitCollision(GetCachedTable <MPHitCollision>()) != null)
            {
                obj.hitCollision = Deserialize(GetCachedTable <MPHitCollision>(), new AttackResult.HitCollsion());
            }
            obj.attackEffectPattern = IndexedConfig <ConfigEntityAttackEffect> .Mapping.TryGet(table.AttackEffectPattern);

            obj.beHitEffectPattern = IndexedConfig <ConfigEntityAttackEffect> .Mapping.TryGet(table.BeHitEffectPattern);

            obj.attackCameraShake = IndexedConfig <ConfigEntityCameraShake> .Mapping.TryGet(table.AttackCameraShake);

            return(obj);
        }
コード例 #7
0
ファイル: MPMappings.cs プロジェクト: slb1988/agame
 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));
 }