mirror of
https://github.com/tym1116/BH3.git
synced 2025-12-16 08:25:20 +01:00
730 lines
29 KiB
C#
730 lines
29 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
using FlatBuffers;
|
|
using MoleMole.Config;
|
|
using MoleMole.MPProtocol;
|
|
using UnityEngine;
|
|
|
|
namespace MoleMole
|
|
{
|
|
public static class MPMappings
|
|
{
|
|
public static Dictionary<Type, Table> _tableCache = new Dictionary<Type, Table>();
|
|
|
|
public static Dictionary<Type, Struct> _structCache = new Dictionary<Type, Struct>();
|
|
|
|
public static IntMapping<Type> MPPacketMapping = new IntMapping<Type>(new Type[17]
|
|
{
|
|
typeof(Packet_Ability_InvocationTable),
|
|
typeof(Packet_Basic_Destroy),
|
|
typeof(Packet_Basic_Instantiate),
|
|
typeof(Packet_Entity_AnimatorParameterChange),
|
|
typeof(Packet_Entity_AnimatorStateChange),
|
|
typeof(Packet_Entity_Kill),
|
|
typeof(Packet_Entity_TransformSync),
|
|
typeof(Packet_Event_EvtAttackLanded),
|
|
typeof(Packet_Event_EvtBeingHit),
|
|
typeof(Packet_Event_EvtBulletHit),
|
|
typeof(Packet_Event_EvtEvadeSuccess),
|
|
typeof(Packet_Event_EvtHittingOther),
|
|
typeof(Packet_Level_CreateStageFullData),
|
|
typeof(Packet_Level_PeerStageReady),
|
|
typeof(Packet_Level_RequestLevelBuff),
|
|
typeof(Packet_Level_ResultLevelBuff),
|
|
typeof(Packet_Monster_MonsterCreation)
|
|
});
|
|
|
|
public static IntMapping<Type> MPPeerMapping = new IntMapping<Type>(new Type[4]
|
|
{
|
|
typeof(AvatarIdentity),
|
|
typeof(LevelIdentity),
|
|
typeof(MonsterIdentity),
|
|
typeof(PeerIdentity)
|
|
});
|
|
|
|
public static Table[] cachedRecvPackets;
|
|
|
|
private static bool _inited;
|
|
|
|
public static T GetCachedTable<T>() where T : Table, new()
|
|
{
|
|
Table value;
|
|
if (!_tableCache.TryGetValue(typeof(T), out value))
|
|
{
|
|
value = new T();
|
|
_tableCache.Add(typeof(T), value);
|
|
}
|
|
return (T)value;
|
|
}
|
|
|
|
public static T GetCachedStruct<T>() where T : Struct, new()
|
|
{
|
|
Struct value;
|
|
if (!_structCache.TryGetValue(typeof(T), out value))
|
|
{
|
|
value = new T();
|
|
_structCache.Add(typeof(T), value);
|
|
}
|
|
return (T)value;
|
|
}
|
|
|
|
public static Type SerializeToProtocol(FlatBufferBuilder builder, object obj)
|
|
{
|
|
int rootTable = 0;
|
|
Type result = null;
|
|
if (obj.GetType() == typeof(MPStageData))
|
|
{
|
|
result = typeof(MoleMole.MPProtocol.MPStageData);
|
|
rootTable = Serialize(builder, (MPStageData)obj).Value;
|
|
}
|
|
else if (obj.GetType() == typeof(MPAvatarDataItem))
|
|
{
|
|
result = typeof(MoleMole.MPProtocol.MPAvatarDataItem);
|
|
rootTable = Serialize(builder, (MPAvatarDataItem)obj).Value;
|
|
}
|
|
else if (obj.GetType() == typeof(EvtHittingOther))
|
|
{
|
|
result = typeof(Packet_Event_EvtHittingOther);
|
|
rootTable = Serialize(builder, (EvtHittingOther)obj).Value;
|
|
}
|
|
else if (obj.GetType() == typeof(EvtBeingHit))
|
|
{
|
|
result = typeof(Packet_Event_EvtBeingHit);
|
|
rootTable = Serialize(builder, (EvtBeingHit)obj).Value;
|
|
}
|
|
else if (obj.GetType() == typeof(EvtAttackLanded))
|
|
{
|
|
result = typeof(Packet_Event_EvtAttackLanded);
|
|
rootTable = Serialize(builder, (EvtAttackLanded)obj).Value;
|
|
}
|
|
else if (obj.GetType() == typeof(EvtEvadeSuccess))
|
|
{
|
|
result = typeof(Packet_Event_EvtEvadeSuccess);
|
|
rootTable = Serialize(builder, (EvtEvadeSuccess)obj).Value;
|
|
}
|
|
else if (obj.GetType() == typeof(EvtBulletHit))
|
|
{
|
|
result = typeof(Packet_Event_EvtBulletHit);
|
|
rootTable = Serialize(builder, (EvtBulletHit)obj).Value;
|
|
}
|
|
else if (obj.GetType() == typeof(AttackData))
|
|
{
|
|
result = typeof(MPAttackData);
|
|
rootTable = Serialize(builder, (AttackData)obj).Value;
|
|
}
|
|
else if (obj.GetType() == typeof(AttackResult))
|
|
{
|
|
result = typeof(MPAttackResult);
|
|
rootTable = Serialize(builder, (AttackResult)obj).Value;
|
|
}
|
|
else if (obj.GetType() == typeof(AttackResult.HitCollsion))
|
|
{
|
|
result = typeof(MPHitCollision);
|
|
rootTable = Serialize(builder, (AttackResult.HitCollsion)obj).Value;
|
|
}
|
|
builder.Finish(rootTable);
|
|
return result;
|
|
}
|
|
|
|
public static object DeserializeToObject(Table table, object obj)
|
|
{
|
|
if (table.GetType() == typeof(MoleMole.MPProtocol.MPStageData))
|
|
{
|
|
if (obj == null)
|
|
{
|
|
obj = new MPStageData();
|
|
}
|
|
return Deserialize((MoleMole.MPProtocol.MPStageData)table, (MPStageData)obj);
|
|
}
|
|
if (table.GetType() == typeof(MoleMole.MPProtocol.MPAvatarDataItem))
|
|
{
|
|
if (obj == null)
|
|
{
|
|
obj = new MPAvatarDataItem();
|
|
}
|
|
return Deserialize((MoleMole.MPProtocol.MPAvatarDataItem)table, (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))
|
|
{
|
|
if (obj == null)
|
|
{
|
|
obj = new AttackResult.HitCollsion();
|
|
}
|
|
return Deserialize((MPHitCollision)table, (AttackResult.HitCollsion)obj);
|
|
}
|
|
return obj;
|
|
}
|
|
|
|
public static Offset<MoleMole.MPProtocol.MPStageData> Serialize(FlatBufferBuilder builder, MPStageData obj)
|
|
{
|
|
StringOffset stageNameOffset = default(StringOffset);
|
|
if (obj.stageName != null)
|
|
{
|
|
stageNameOffset = builder.CreateString(obj.stageName);
|
|
}
|
|
MoleMole.MPProtocol.MPStageData.StartMPStageData(builder);
|
|
MoleMole.MPProtocol.MPStageData.AddStageName(builder, stageNameOffset);
|
|
return MoleMole.MPProtocol.MPStageData.EndMPStageData(builder);
|
|
}
|
|
|
|
public static Offset<MoleMole.MPProtocol.MPAvatarDataItem> Serialize(FlatBufferBuilder builder, MPAvatarDataItem obj)
|
|
{
|
|
MoleMole.MPProtocol.MPAvatarDataItem.StartMPAvatarDataItem(builder);
|
|
MoleMole.MPProtocol.MPAvatarDataItem.AddAvatarID(builder, obj.avatarID);
|
|
MoleMole.MPProtocol.MPAvatarDataItem.AddLevel(builder, obj.level);
|
|
MoleMole.MPProtocol.MPAvatarDataItem.AddStar(builder, obj.star);
|
|
MoleMole.MPProtocol.MPAvatarDataItem.AddFinalHP(builder, obj.finalHP);
|
|
MoleMole.MPProtocol.MPAvatarDataItem.AddFinalSP(builder, obj.finalSP);
|
|
MoleMole.MPProtocol.MPAvatarDataItem.AddFinalAttack(builder, obj.finalAttack);
|
|
MoleMole.MPProtocol.MPAvatarDataItem.AddFinalCritical(builder, obj.finalCritical);
|
|
MoleMole.MPProtocol.MPAvatarDataItem.AddFinalDefense(builder, obj.finalDefense);
|
|
return MoleMole.MPProtocol.MPAvatarDataItem.EndMPAvatarDataItem(builder);
|
|
}
|
|
|
|
public static Offset<MPVector3> Serialize(FlatBufferBuilder builder, Vector3 obj)
|
|
{
|
|
return MPVector3.CreateMPVector3(builder, obj.x, obj.y, obj.z);
|
|
}
|
|
|
|
public static Offset<Packet_Event_EvtHittingOther> Serialize(FlatBufferBuilder builder, EvtHittingOther obj)
|
|
{
|
|
StringOffset animEventIDOffset = default(StringOffset);
|
|
if (obj.animEventID != null)
|
|
{
|
|
animEventIDOffset = builder.CreateString(obj.animEventID);
|
|
}
|
|
Offset<MPAttackData> attackDataOffset = default(Offset<MPAttackData>);
|
|
if (obj.attackData != null)
|
|
{
|
|
attackDataOffset = Serialize(builder, obj.attackData);
|
|
}
|
|
Offset<MPHitCollision> hitCollisionOffset = default(Offset<MPHitCollision>);
|
|
if (obj.hitCollision != null)
|
|
{
|
|
hitCollisionOffset = Serialize(builder, obj.hitCollision);
|
|
}
|
|
Packet_Event_EvtHittingOther.StartPacket_Event_EvtHittingOther(builder);
|
|
Packet_Event_EvtHittingOther.AddTargetID(builder, obj.targetID);
|
|
Packet_Event_EvtHittingOther.AddToID(builder, obj.toID);
|
|
Packet_Event_EvtHittingOther.AddAnimEventID(builder, animEventIDOffset);
|
|
Packet_Event_EvtHittingOther.AddAttackData(builder, attackDataOffset);
|
|
Packet_Event_EvtHittingOther.AddHitCollision(builder, hitCollisionOffset);
|
|
return Packet_Event_EvtHittingOther.EndPacket_Event_EvtHittingOther(builder);
|
|
}
|
|
|
|
public static Offset<Packet_Event_EvtBeingHit> Serialize(FlatBufferBuilder builder, EvtBeingHit obj)
|
|
{
|
|
StringOffset animEventIDOffset = default(StringOffset);
|
|
if (obj.animEventID != null)
|
|
{
|
|
animEventIDOffset = builder.CreateString(obj.animEventID);
|
|
}
|
|
Offset<MPAttackData> attackDataOffset = default(Offset<MPAttackData>);
|
|
if (obj.attackData != null)
|
|
{
|
|
attackDataOffset = Serialize(builder, obj.attackData);
|
|
}
|
|
Packet_Event_EvtBeingHit.StartPacket_Event_EvtBeingHit(builder);
|
|
Packet_Event_EvtBeingHit.AddTargetID(builder, obj.targetID);
|
|
Packet_Event_EvtBeingHit.AddSourceID(builder, obj.sourceID);
|
|
Packet_Event_EvtBeingHit.AddAnimEventID(builder, animEventIDOffset);
|
|
Packet_Event_EvtBeingHit.AddAttackData(builder, attackDataOffset);
|
|
Packet_Event_EvtBeingHit.AddBeHitEffect(builder, (byte)obj.beHitEffect);
|
|
Packet_Event_EvtBeingHit.AddResolvedDamage(builder, obj.resolvedDamage);
|
|
return Packet_Event_EvtBeingHit.EndPacket_Event_EvtBeingHit(builder);
|
|
}
|
|
|
|
public static Offset<Packet_Event_EvtAttackLanded> Serialize(FlatBufferBuilder builder, EvtAttackLanded obj)
|
|
{
|
|
StringOffset animEventIDOffset = default(StringOffset);
|
|
if (obj.animEventID != null)
|
|
{
|
|
animEventIDOffset = builder.CreateString(obj.animEventID);
|
|
}
|
|
Offset<MPAttackResult> attackResultOffset = default(Offset<MPAttackResult>);
|
|
if (obj.attackResult != null)
|
|
{
|
|
attackResultOffset = Serialize(builder, obj.attackResult);
|
|
}
|
|
Packet_Event_EvtAttackLanded.StartPacket_Event_EvtAttackLanded(builder);
|
|
Packet_Event_EvtAttackLanded.AddTargetID(builder, obj.targetID);
|
|
Packet_Event_EvtAttackLanded.AddAttackeeID(builder, obj.attackeeID);
|
|
Packet_Event_EvtAttackLanded.AddAnimEventID(builder, animEventIDOffset);
|
|
Packet_Event_EvtAttackLanded.AddAttackResult(builder, attackResultOffset);
|
|
return Packet_Event_EvtAttackLanded.EndPacket_Event_EvtAttackLanded(builder);
|
|
}
|
|
|
|
public static Offset<Packet_Event_EvtEvadeSuccess> Serialize(FlatBufferBuilder builder, EvtEvadeSuccess obj)
|
|
{
|
|
StringOffset skillIDOffset = default(StringOffset);
|
|
if (obj.skillID != null)
|
|
{
|
|
skillIDOffset = builder.CreateString(obj.skillID);
|
|
}
|
|
Offset<MPAttackData> attackDataOffset = default(Offset<MPAttackData>);
|
|
if (obj.attackData != null)
|
|
{
|
|
attackDataOffset = Serialize(builder, obj.attackData);
|
|
}
|
|
Packet_Event_EvtEvadeSuccess.StartPacket_Event_EvtEvadeSuccess(builder);
|
|
Packet_Event_EvtEvadeSuccess.AddTargetID(builder, obj.targetID);
|
|
Packet_Event_EvtEvadeSuccess.AddAttackerID(builder, obj.attackerID);
|
|
Packet_Event_EvtEvadeSuccess.AddSkillID(builder, skillIDOffset);
|
|
Packet_Event_EvtEvadeSuccess.AddAttackData(builder, attackDataOffset);
|
|
return Packet_Event_EvtEvadeSuccess.EndPacket_Event_EvtEvadeSuccess(builder);
|
|
}
|
|
|
|
public static Offset<Packet_Event_EvtBulletHit> Serialize(FlatBufferBuilder builder, EvtBulletHit obj)
|
|
{
|
|
Offset<MPHitCollision> hitCollisionOffset = default(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);
|
|
}
|
|
|
|
public static Offset<MPAttackData> Serialize(FlatBufferBuilder builder, AttackData obj)
|
|
{
|
|
Offset<MPHitCollision> hitCollisionOffset = default(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);
|
|
}
|
|
|
|
public static Offset<MPAttackResult> Serialize(FlatBufferBuilder builder, AttackResult obj)
|
|
{
|
|
Offset<MPHitCollision> hitCollisionOffset = default(Offset<MPHitCollision>);
|
|
if (obj.hitCollision != null)
|
|
{
|
|
hitCollisionOffset = Serialize(builder, obj.hitCollision);
|
|
}
|
|
MPAttackResult.StartMPAttackResult(builder);
|
|
MPAttackResult.AddDamage(builder, obj.damage);
|
|
MPAttackResult.AddPlainDamage(builder, obj.plainDamage);
|
|
MPAttackResult.AddThunderDamage(builder, obj.thunderDamage);
|
|
MPAttackResult.AddIceDamage(builder, obj.iceDamage);
|
|
MPAttackResult.AddAlienDamage(builder, obj.alienDamage);
|
|
MPAttackResult.AddAniDamageRatio(builder, obj.aniDamageRatio);
|
|
MPAttackResult.AddRetreatVelocity(builder, obj.retreatVelocity);
|
|
MPAttackResult.AddFrameHalt(builder, obj.frameHalt);
|
|
MPAttackResult.AddIsAnimEventAttack(builder, obj.isAnimEventAttack);
|
|
MPAttackResult.AddIsInComboCount(builder, obj.isInComboCount);
|
|
MPAttackResult.AddAttackCategoryTag(builder, (int)obj.attackCategoryTag);
|
|
MPAttackResult.AddHitType(builder, (byte)obj.hitType);
|
|
MPAttackResult.AddHitFlag(builder, (int)obj.hitFlag);
|
|
MPAttackResult.AddHitLevel(builder, (byte)obj.hitLevel);
|
|
MPAttackResult.AddHitEffect(builder, (byte)obj.hitEffect);
|
|
MPAttackResult.AddHitEffectAux(builder, (byte)obj.hitEffectAux);
|
|
MPAttackResult.AddHitEffectPattern(builder, (byte)obj.hitEffectPattern);
|
|
MPAttackResult.AddKillEffect(builder, (byte)obj.killEffect);
|
|
MPAttackResult.AddRejectState(builder, (byte)obj.rejectState);
|
|
MPAttackResult.AddIsFromBullet(builder, obj.isFromBullet);
|
|
MPAttackResult.AddNoTriggerEvadeAndDefend(builder, obj.noTriggerEvadeAndDefend);
|
|
MPAttackResult.AddHitCollision(builder, hitCollisionOffset);
|
|
MPAttackResult.AddAttackEffectPattern(builder, (ushort)IndexedConfig<ConfigEntityAttackEffect>.Mapping.TryGet(obj.attackEffectPattern));
|
|
MPAttackResult.AddBeHitEffectPattern(builder, (ushort)IndexedConfig<ConfigEntityAttackEffect>.Mapping.TryGet(obj.beHitEffectPattern));
|
|
MPAttackResult.AddAttackCameraShake(builder, (ushort)IndexedConfig<ConfigEntityCameraShake>.Mapping.TryGet(obj.attackCameraShake));
|
|
return MPAttackResult.EndMPAttackResult(builder);
|
|
}
|
|
|
|
public static Offset<MPHitCollision> Serialize(FlatBufferBuilder builder, AttackResult.HitCollsion obj)
|
|
{
|
|
MPHitCollision.StartMPHitCollision(builder);
|
|
Offset<MPVector3> hitDirOffset = Serialize(builder, obj.hitDir);
|
|
MPHitCollision.AddHitDir(builder, hitDirOffset);
|
|
Offset<MPVector3> hitPointOffset = Serialize(builder, obj.hitPoint);
|
|
MPHitCollision.AddHitPoint(builder, hitPointOffset);
|
|
return MPHitCollision.EndMPHitCollision(builder);
|
|
}
|
|
|
|
public static MPStageData Deserialize(MoleMole.MPProtocol.MPStageData table, MPStageData obj)
|
|
{
|
|
if (obj == null)
|
|
{
|
|
obj = new MPStageData();
|
|
}
|
|
obj.stageName = table.StageName;
|
|
return obj;
|
|
}
|
|
|
|
public static MPAvatarDataItem Deserialize(MoleMole.MPProtocol.MPAvatarDataItem table, MPAvatarDataItem obj)
|
|
{
|
|
if (obj == null)
|
|
{
|
|
obj = new MPAvatarDataItem();
|
|
}
|
|
obj.avatarID = table.AvatarID;
|
|
obj.level = table.Level;
|
|
obj.star = table.Star;
|
|
obj.finalHP = table.FinalHP;
|
|
obj.finalSP = table.FinalSP;
|
|
obj.finalAttack = table.FinalAttack;
|
|
obj.finalCritical = table.FinalCritical;
|
|
obj.finalDefense = table.FinalDefense;
|
|
return obj;
|
|
}
|
|
|
|
public static Vector3 Deserialize(MPVector3 table)
|
|
{
|
|
return new Vector3
|
|
{
|
|
x = table.X,
|
|
y = table.Y,
|
|
z = table.Z
|
|
};
|
|
}
|
|
|
|
public static EvtHittingOther Deserialize(Packet_Event_EvtHittingOther table, EvtHittingOther obj)
|
|
{
|
|
if (obj == null)
|
|
{
|
|
obj = new EvtHittingOther();
|
|
}
|
|
obj.targetID = table.TargetID;
|
|
obj.toID = table.ToID;
|
|
obj.animEventID = table.AnimEventID;
|
|
if (table.GetAttackData(GetCachedTable<MPAttackData>()) != null)
|
|
{
|
|
obj.attackData = Deserialize(GetCachedTable<MPAttackData>(), new AttackData());
|
|
}
|
|
if (table.GetHitCollision(GetCachedTable<MPHitCollision>()) != null)
|
|
{
|
|
obj.hitCollision = Deserialize(GetCachedTable<MPHitCollision>(), new AttackResult.HitCollsion());
|
|
}
|
|
return obj;
|
|
}
|
|
|
|
public static EvtBeingHit Deserialize(Packet_Event_EvtBeingHit table, EvtBeingHit obj)
|
|
{
|
|
if (obj == null)
|
|
{
|
|
obj = new EvtBeingHit();
|
|
}
|
|
obj.targetID = table.TargetID;
|
|
obj.sourceID = table.SourceID;
|
|
obj.animEventID = table.AnimEventID;
|
|
if (table.GetAttackData(GetCachedTable<MPAttackData>()) != null)
|
|
{
|
|
obj.attackData = Deserialize(GetCachedTable<MPAttackData>(), new AttackData());
|
|
}
|
|
obj.beHitEffect = (BeHitEffect)table.BeHitEffect;
|
|
obj.resolvedDamage = table.ResolvedDamage;
|
|
return obj;
|
|
}
|
|
|
|
public static EvtAttackLanded Deserialize(Packet_Event_EvtAttackLanded table, EvtAttackLanded obj)
|
|
{
|
|
if (obj == null)
|
|
{
|
|
obj = new EvtAttackLanded();
|
|
}
|
|
obj.targetID = table.TargetID;
|
|
obj.attackeeID = table.AttackeeID;
|
|
obj.animEventID = table.AnimEventID;
|
|
if (table.GetAttackResult(GetCachedTable<MPAttackResult>()) != null)
|
|
{
|
|
obj.attackResult = Deserialize(GetCachedTable<MPAttackResult>(), new AttackResult());
|
|
}
|
|
return obj;
|
|
}
|
|
|
|
public static EvtEvadeSuccess Deserialize(Packet_Event_EvtEvadeSuccess table, EvtEvadeSuccess obj)
|
|
{
|
|
if (obj == null)
|
|
{
|
|
obj = new EvtEvadeSuccess();
|
|
}
|
|
obj.targetID = table.TargetID;
|
|
obj.attackerID = table.AttackerID;
|
|
obj.skillID = table.SkillID;
|
|
if (table.GetAttackData(GetCachedTable<MPAttackData>()) != null)
|
|
{
|
|
obj.attackData = Deserialize(GetCachedTable<MPAttackData>(), new AttackData());
|
|
}
|
|
return obj;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
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;
|
|
}
|
|
|
|
public static AttackResult Deserialize(MPAttackResult table, AttackResult obj)
|
|
{
|
|
if (obj == null)
|
|
{
|
|
obj = new AttackResult();
|
|
}
|
|
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;
|
|
}
|
|
|
|
public static AttackResult.HitCollsion Deserialize(MPHitCollision table, AttackResult.HitCollsion obj)
|
|
{
|
|
if (obj == null)
|
|
{
|
|
obj = new AttackResult.HitCollsion();
|
|
}
|
|
if (table.GetHitDir(GetCachedStruct<MPVector3>()) != null)
|
|
{
|
|
obj.hitDir = Deserialize(GetCachedStruct<MPVector3>());
|
|
}
|
|
if (table.GetHitPoint(GetCachedStruct<MPVector3>()) != null)
|
|
{
|
|
obj.hitPoint = Deserialize(GetCachedStruct<MPVector3>());
|
|
}
|
|
return obj;
|
|
}
|
|
|
|
public static void InitMPMappings()
|
|
{
|
|
if (!_inited)
|
|
{
|
|
int length = MPPacketMapping.length;
|
|
cachedRecvPackets = new Table[length + 1];
|
|
for (int i = 1; i <= length; i++)
|
|
{
|
|
Type type = MPPacketMapping.Get(i);
|
|
cachedRecvPackets[i] = (Table)Activator.CreateInstance(type);
|
|
}
|
|
_inited = true;
|
|
}
|
|
}
|
|
}
|
|
}
|