public static void Serialize(Stream stream, JoinGameResponse instance)
{
BinaryWriter binaryWriter = new BinaryWriter(stream);
if (instance.HasRequestId)
{
stream.WriteByte(9);
binaryWriter.Write(instance.RequestId);
}
if (instance.HasQueued)
{
stream.WriteByte(16);
ProtocolParser.WriteBool(stream, instance.Queued);
}
if (instance.ConnectInfo.get_Count() > 0)
{
using (List <ConnectInfo> .Enumerator enumerator = instance.ConnectInfo.GetEnumerator())
{
while (enumerator.MoveNext())
{
ConnectInfo current = enumerator.get_Current();
stream.WriteByte(26);
ProtocolParser.WriteUInt32(stream, current.GetSerializedSize());
bnet.protocol.game_master.ConnectInfo.Serialize(stream, current);
}
}
}
}
public static void Serialize(Stream stream, FriendInvitation instance)
{
if (instance.HasFirstReceived)
{
stream.WriteByte(8);
ProtocolParser.WriteBool(stream, instance.FirstReceived);
}
if (instance.Role.get_Count() > 0)
{
stream.WriteByte(18);
uint num = 0u;
using (List <uint> .Enumerator enumerator = instance.Role.GetEnumerator())
{
while (enumerator.MoveNext())
{
uint current = enumerator.get_Current();
num += ProtocolParser.SizeOfUInt32(current);
}
}
ProtocolParser.WriteUInt32(stream, num);
using (List <uint> .Enumerator enumerator2 = instance.Role.GetEnumerator())
{
while (enumerator2.MoveNext())
{
uint current2 = enumerator2.get_Current();
ProtocolParser.WriteUInt32(stream, current2);
}
}
}
}
public static void Serialize(Stream stream, GameSessionInfo instance)
{
if (instance.HasStartTime)
{
stream.WriteByte(24);
ProtocolParser.WriteUInt32(stream, instance.StartTime);
}
if (instance.HasLocation)
{
stream.WriteByte(34);
ProtocolParser.WriteUInt32(stream, instance.Location.GetSerializedSize());
GameSessionLocation.Serialize(stream, instance.Location);
}
if (instance.HasHasBenefactor)
{
stream.WriteByte(40);
ProtocolParser.WriteBool(stream, instance.HasBenefactor);
}
if (instance.HasIsUsingIgr)
{
stream.WriteByte(48);
ProtocolParser.WriteBool(stream, instance.IsUsingIgr);
}
if (instance.HasParentalControlsActive)
{
stream.WriteByte(56);
ProtocolParser.WriteBool(stream, instance.ParentalControlsActive);
}
}
public static void Serialize(Stream stream, GameStatus instance)
{
BinaryWriter binaryWriter = new BinaryWriter(stream);
if (instance.HasIsSuspended)
{
stream.WriteByte(32);
ProtocolParser.WriteBool(stream, instance.IsSuspended);
}
if (instance.HasIsBanned)
{
stream.WriteByte(40);
ProtocolParser.WriteBool(stream, instance.IsBanned);
}
if (instance.HasSuspensionExpires)
{
stream.WriteByte(48);
ProtocolParser.WriteUInt64(stream, instance.SuspensionExpires);
}
if (instance.HasProgram)
{
stream.WriteByte(61);
binaryWriter.Write(instance.Program);
}
}
public static void Serialize(Stream stream, ChannelState instance)
{
if (instance.HasEntityId)
{
stream.WriteByte(10);
ProtocolParser.WriteUInt32(stream, instance.EntityId.GetSerializedSize());
EntityId.Serialize(stream, instance.EntityId);
}
if (instance.FieldOperation.get_Count() > 0)
{
using (List <FieldOperation> .Enumerator enumerator = instance.FieldOperation.GetEnumerator())
{
while (enumerator.MoveNext())
{
FieldOperation current = enumerator.get_Current();
stream.WriteByte(18);
ProtocolParser.WriteUInt32(stream, current.GetSerializedSize());
bnet.protocol.presence.FieldOperation.Serialize(stream, current);
}
}
}
if (instance.HasHealing)
{
stream.WriteByte(24);
ProtocolParser.WriteBool(stream, instance.Healing);
}
}
public static void Serialize(Stream stream, GameAccountStateNotification instance)
{
if (instance.HasState)
{
stream.WriteByte(10);
ProtocolParser.WriteUInt32(stream, instance.State.GetSerializedSize());
GameAccountState.Serialize(stream, instance.State);
}
if (instance.HasSubscriberId)
{
stream.WriteByte(16);
ProtocolParser.WriteUInt64(stream, instance.SubscriberId);
}
if (instance.HasGameAccountTags)
{
stream.WriteByte(26);
ProtocolParser.WriteUInt32(stream, instance.GameAccountTags.GetSerializedSize());
GameAccountFieldTags.Serialize(stream, instance.GameAccountTags);
}
if (instance.HasSubscriptionCompleted)
{
stream.WriteByte(32);
ProtocolParser.WriteBool(stream, instance.SubscriptionCompleted);
}
}
public static void SerializeDelta(Stream stream, PuzzleReset instance, PuzzleReset previous)
{
MemoryStream memoryStream = Pool.Get <MemoryStream>();
stream.WriteByte(8);
ProtocolParser.WriteBool(stream, instance.playerBlocksReset);
if (instance.playerDetectionRadius != previous.playerDetectionRadius)
{
stream.WriteByte(21);
ProtocolParser.WriteSingle(stream, instance.playerDetectionRadius);
}
if (instance.playerDetectionOrigin != previous.playerDetectionOrigin)
{
stream.WriteByte(26);
memoryStream.SetLength((long)0);
Vector3Serialized.SerializeDelta(memoryStream, instance.playerDetectionOrigin, previous.playerDetectionOrigin);
uint length = (uint)memoryStream.Length;
ProtocolParser.WriteUInt32(stream, length);
stream.Write(memoryStream.GetBuffer(), 0, (int)length);
}
if (instance.timeBetweenResets != previous.timeBetweenResets)
{
stream.WriteByte(37);
ProtocolParser.WriteSingle(stream, instance.timeBetweenResets);
}
stream.WriteByte(40);
ProtocolParser.WriteBool(stream, instance.scaleWithServerPopulation);
Pool.FreeMemoryStream(ref memoryStream);
}
public static void Serialize(Stream stream, AccountSettingsNotification instance)
{
if (instance.Licenses.Count > 0)
{
foreach (AccountLicense accountLicense in instance.Licenses)
{
stream.WriteByte(10);
ProtocolParser.WriteUInt32(stream, accountLicense.GetSerializedSize());
AccountLicense.Serialize(stream, accountLicense);
}
}
if (instance.HasIsUsingRid)
{
stream.WriteByte(16);
ProtocolParser.WriteBool(stream, instance.IsUsingRid);
}
if (instance.HasIsPlayingFromIgr)
{
stream.WriteByte(24);
ProtocolParser.WriteBool(stream, instance.IsPlayingFromIgr);
}
if (instance.HasCanReceiveVoice)
{
stream.WriteByte(32);
ProtocolParser.WriteBool(stream, instance.CanReceiveVoice);
}
if (instance.HasCanSendVoice)
{
stream.WriteByte(40);
ProtocolParser.WriteBool(stream, instance.CanSendVoice);
}
}
public static void Serialize(Stream stream, JoinChannelResponse instance)
{
if (instance.HasObjectId)
{
stream.WriteByte(8);
ProtocolParser.WriteUInt64(stream, instance.ObjectId);
}
if (instance.HasRequireFriendValidation)
{
stream.WriteByte(16);
ProtocolParser.WriteBool(stream, instance.RequireFriendValidation);
}
if (instance.PrivilegedAccount.get_Count() > 0)
{
using (List <EntityId> .Enumerator enumerator = instance.PrivilegedAccount.GetEnumerator())
{
while (enumerator.MoveNext())
{
EntityId current = enumerator.get_Current();
stream.WriteByte(26);
ProtocolParser.WriteUInt32(stream, current.GetSerializedSize());
EntityId.Serialize(stream, current);
}
}
}
}
public static void Serialize(Stream stream, AccountInfo instance)
{
BinaryWriter binaryWriter = new BinaryWriter(stream);
if (instance.HasAccountPaid)
{
stream.WriteByte(8);
ProtocolParser.WriteBool(stream, instance.AccountPaid);
}
if (instance.HasCountryId)
{
stream.WriteByte(21);
binaryWriter.Write(instance.CountryId);
}
if (instance.HasBattleTag)
{
stream.WriteByte(26);
ProtocolParser.WriteBytes(stream, Encoding.UTF8.GetBytes(instance.BattleTag));
}
if (instance.HasManualReview)
{
stream.WriteByte(32);
ProtocolParser.WriteBool(stream, instance.ManualReview);
}
}
public static void SerializeDelta(Stream stream, PlayerTeam.TeamMember instance, PlayerTeam.TeamMember previous)
{
MemoryStream memoryStream = Pool.Get <MemoryStream>();
if (instance.displayName != null && instance.displayName != previous.displayName)
{
stream.WriteByte(10);
ProtocolParser.WriteString(stream, instance.displayName);
}
if (instance.userID != previous.userID)
{
stream.WriteByte(16);
ProtocolParser.WriteUInt64(stream, instance.userID);
}
if (instance.healthFraction != previous.healthFraction)
{
stream.WriteByte(29);
ProtocolParser.WriteSingle(stream, instance.healthFraction);
}
if (instance.position != previous.position)
{
stream.WriteByte(34);
memoryStream.SetLength((long)0);
Vector3Serialized.SerializeDelta(memoryStream, instance.position, previous.position);
uint length = (uint)memoryStream.Length;
ProtocolParser.WriteUInt32(stream, length);
stream.Write(memoryStream.GetBuffer(), 0, (int)length);
}
stream.WriteByte(40);
ProtocolParser.WriteBool(stream, instance.online);
Pool.FreeMemoryStream(ref memoryStream);
}
public static void Serialize(Stream stream, ChangeGameRequest instance)
{
if (instance.GameHandle == null)
{
throw new ArgumentNullException("GameHandle", "Required by proto specification.");
}
stream.WriteByte(10);
ProtocolParser.WriteUInt32(stream, instance.GameHandle.GetSerializedSize());
GameHandle.Serialize(stream, instance.GameHandle);
if (instance.HasOpen)
{
stream.WriteByte(16);
ProtocolParser.WriteBool(stream, instance.Open);
}
if (instance.Attribute.get_Count() > 0)
{
using (List <Attribute> .Enumerator enumerator = instance.Attribute.GetEnumerator())
{
while (enumerator.MoveNext())
{
Attribute current = enumerator.get_Current();
stream.WriteByte(26);
ProtocolParser.WriteUInt32(stream, current.GetSerializedSize());
bnet.protocol.attribute.Attribute.Serialize(stream, current);
}
}
}
if (instance.HasReplace)
{
stream.WriteByte(32);
ProtocolParser.WriteBool(stream, instance.Replace);
}
}
public static void Serialize(Stream stream, GetChannelInfoRequest instance)
{
if (instance.HasAgentId)
{
stream.WriteByte(10);
ProtocolParser.WriteUInt32(stream, instance.AgentId.GetSerializedSize());
EntityId.Serialize(stream, instance.AgentId);
}
if (instance.ChannelId == null)
{
throw new ArgumentNullException("ChannelId", "Required by proto specification.");
}
stream.WriteByte(18);
ProtocolParser.WriteUInt32(stream, instance.ChannelId.GetSerializedSize());
EntityId.Serialize(stream, instance.ChannelId);
if (instance.HasFetchState)
{
stream.WriteByte(24);
ProtocolParser.WriteBool(stream, instance.FetchState);
}
if (instance.HasFetchMembers)
{
stream.WriteByte(32);
ProtocolParser.WriteBool(stream, instance.FetchMembers);
}
}
public static void SerializeDelta(Stream stream, RespawnInformation instance, RespawnInformation previous)
{
MemoryStream memoryStream = Pool.Get <MemoryStream>();
if (instance.spawnOptions != null)
{
for (int i = 0; i < instance.spawnOptions.Count; i++)
{
RespawnInformation.SpawnOptions item = instance.spawnOptions[i];
stream.WriteByte(10);
memoryStream.SetLength((long)0);
RespawnInformation.SpawnOptions.SerializeDelta(memoryStream, item, item);
uint length = (uint)memoryStream.Length;
ProtocolParser.WriteUInt32(stream, length);
stream.Write(memoryStream.GetBuffer(), 0, (int)length);
}
}
if (instance.previousLife != null)
{
stream.WriteByte(18);
memoryStream.SetLength((long)0);
PlayerLifeStory.SerializeDelta(memoryStream, instance.previousLife, previous.previousLife);
uint num = (uint)memoryStream.Length;
ProtocolParser.WriteUInt32(stream, num);
stream.Write(memoryStream.GetBuffer(), 0, (int)num);
}
stream.WriteByte(24);
ProtocolParser.WriteBool(stream, instance.fadeIn);
Pool.FreeMemoryStream(ref memoryStream);
}
public static void Serialize(Stream stream, AddMemberRequest instance)
{
if (instance.HasAgentId)
{
stream.WriteByte(10);
ProtocolParser.WriteUInt32(stream, instance.AgentId.GetSerializedSize());
EntityId.Serialize(stream, instance.AgentId);
}
if (instance.MemberIdentity == null)
{
throw new ArgumentNullException("MemberIdentity", "Required by proto specification.");
}
stream.WriteByte(18);
ProtocolParser.WriteUInt32(stream, instance.MemberIdentity.GetSerializedSize());
Identity.Serialize(stream, instance.MemberIdentity);
if (instance.MemberState == null)
{
throw new ArgumentNullException("MemberState", "Required by proto specification.");
}
stream.WriteByte(26);
ProtocolParser.WriteUInt32(stream, instance.MemberState.GetSerializedSize());
bnet.protocol.channel.MemberState.Serialize(stream, instance.MemberState);
stream.WriteByte(32);
ProtocolParser.WriteUInt64(stream, instance.ObjectId);
if (instance.HasSubscribe)
{
stream.WriteByte(40);
ProtocolParser.WriteBool(stream, instance.Subscribe);
}
}
public static void Serialize(Stream stream, ChangeGameRequest instance)
{
if (instance.GameHandle == null)
{
throw new ArgumentNullException("GameHandle", "Required by proto specification.");
}
stream.WriteByte(10);
ProtocolParser.WriteUInt32(stream, instance.GameHandle.GetSerializedSize());
GameHandle.Serialize(stream, instance.GameHandle);
if (instance.HasOpen)
{
stream.WriteByte(16);
ProtocolParser.WriteBool(stream, instance.Open);
}
if (instance.Attribute.Count > 0)
{
foreach (bnet.protocol.attribute.Attribute attribute in instance.Attribute)
{
stream.WriteByte(26);
ProtocolParser.WriteUInt32(stream, attribute.GetSerializedSize());
bnet.protocol.attribute.Attribute.Serialize(stream, attribute);
}
}
if (instance.HasReplace)
{
stream.WriteByte(32);
ProtocolParser.WriteBool(stream, instance.Replace);
}
}
public static void Serialize(Stream stream, GameProperties instance)
{
BinaryWriter binaryWriter = new BinaryWriter(stream);
if (instance.CreationAttributes.Count > 0)
{
foreach (bnet.protocol.attribute.Attribute attribute in instance.CreationAttributes)
{
stream.WriteByte(10);
ProtocolParser.WriteUInt32(stream, attribute.GetSerializedSize());
bnet.protocol.attribute.Attribute.Serialize(stream, attribute);
}
}
if (instance.HasFilter)
{
stream.WriteByte(18);
ProtocolParser.WriteUInt32(stream, instance.Filter.GetSerializedSize());
AttributeFilter.Serialize(stream, instance.Filter);
}
if (instance.HasCreate)
{
stream.WriteByte(24);
ProtocolParser.WriteBool(stream, instance.Create);
}
if (instance.HasOpen)
{
stream.WriteByte(32);
ProtocolParser.WriteBool(stream, instance.Open);
}
if (instance.HasProgramId)
{
stream.WriteByte(45);
binaryWriter.Write(instance.ProgramId);
}
}
public static void Serialize(Stream stream, JoinGameRequest instance)
{
if (instance.GameHandle == null)
{
throw new ArgumentNullException("GameHandle", "Required by proto specification.");
}
stream.WriteByte(10);
ProtocolParser.WriteUInt32(stream, instance.GameHandle.GetSerializedSize());
GameHandle.Serialize(stream, instance.GameHandle);
if (instance.Player.get_Count() > 0)
{
using (List <Player> .Enumerator enumerator = instance.Player.GetEnumerator())
{
while (enumerator.MoveNext())
{
Player current = enumerator.get_Current();
stream.WriteByte(18);
ProtocolParser.WriteUInt32(stream, current.GetSerializedSize());
bnet.protocol.game_master.Player.Serialize(stream, current);
}
}
}
if (instance.HasAdvancedNotification)
{
stream.WriteByte(24);
ProtocolParser.WriteBool(stream, instance.AdvancedNotification);
}
}
public static void SerializeDelta(Stream stream, VendingMachine.SellOrder instance, VendingMachine.SellOrder previous)
{
MemoryStream memoryStream = Pool.Get <MemoryStream>();
if (instance.itemToSellID != previous.itemToSellID)
{
stream.WriteByte(8);
ProtocolParser.WriteUInt64(stream, (ulong)instance.itemToSellID);
}
if (instance.itemToSellAmount != previous.itemToSellAmount)
{
stream.WriteByte(16);
ProtocolParser.WriteUInt64(stream, (ulong)instance.itemToSellAmount);
}
if (instance.currencyID != previous.currencyID)
{
stream.WriteByte(24);
ProtocolParser.WriteUInt64(stream, (ulong)instance.currencyID);
}
if (instance.currencyAmountPerItem != previous.currencyAmountPerItem)
{
stream.WriteByte(32);
ProtocolParser.WriteUInt64(stream, (ulong)instance.currencyAmountPerItem);
}
if (instance.inStock != previous.inStock)
{
stream.WriteByte(40);
ProtocolParser.WriteUInt64(stream, (ulong)instance.inStock);
}
stream.WriteByte(48);
ProtocolParser.WriteBool(stream, instance.currencyIsBP);
stream.WriteByte(56);
ProtocolParser.WriteBool(stream, instance.itemToSellIsBP);
Pool.FreeMemoryStream(ref memoryStream);
}
public static void Serialize(Stream stream, ChannelState instance)
{
BinaryWriter binaryWriter = new BinaryWriter(stream);
if (instance.HasIdentity)
{
stream.WriteByte(10);
ProtocolParser.WriteBytes(stream, Encoding.get_UTF8().GetBytes(instance.Identity));
}
if (instance.HasProgram)
{
stream.WriteByte(21);
binaryWriter.Write(instance.Program);
}
if (instance.HasLocale)
{
stream.WriteByte(29);
binaryWriter.Write(instance.Locale);
}
if (instance.HasPublic)
{
stream.WriteByte(32);
ProtocolParser.WriteBool(stream, instance.Public);
}
if (instance.HasBucketIndex)
{
stream.WriteByte(40);
ProtocolParser.WriteUInt32(stream, instance.BucketIndex);
}
}
public static void Serialize(Stream stream, GameLevelInfo instance)
{
BinaryWriter binaryWriter = new BinaryWriter(stream);
if (instance.HasIsStarterEdition)
{
stream.WriteByte(24);
ProtocolParser.WriteBool(stream, instance.IsStarterEdition);
}
if (instance.HasIsTrial)
{
stream.WriteByte(32);
ProtocolParser.WriteBool(stream, instance.IsTrial);
}
if (instance.HasIsLifetime)
{
stream.WriteByte(40);
ProtocolParser.WriteBool(stream, instance.IsLifetime);
}
if (instance.HasIsRestricted)
{
stream.WriteByte(48);
ProtocolParser.WriteBool(stream, instance.IsRestricted);
}
if (instance.HasIsBeta)
{
stream.WriteByte(56);
ProtocolParser.WriteBool(stream, instance.IsBeta);
}
if (instance.HasName)
{
stream.WriteByte(66);
ProtocolParser.WriteBytes(stream, Encoding.get_UTF8().GetBytes(instance.Name));
}
if (instance.HasProgram)
{
stream.WriteByte(77);
binaryWriter.Write(instance.Program);
}
if (instance.Licenses.get_Count() > 0)
{
using (List <AccountLicense> .Enumerator enumerator = instance.Licenses.GetEnumerator())
{
while (enumerator.MoveNext())
{
AccountLicense current = enumerator.get_Current();
stream.WriteByte(82);
ProtocolParser.WriteUInt32(stream, current.GetSerializedSize());
AccountLicense.Serialize(stream, current);
}
}
}
if (instance.HasRealmPermissions)
{
stream.WriteByte(88);
ProtocolParser.WriteUInt32(stream, instance.RealmPermissions);
}
}
public static void SerializeDelta(Stream stream, CreateBuilding instance, CreateBuilding previous)
{
MemoryStream memoryStream = Pool.Get <MemoryStream>();
if (instance.entity != previous.entity)
{
stream.WriteByte(8);
ProtocolParser.WriteUInt32(stream, instance.entity);
}
if (instance.socket != previous.socket)
{
stream.WriteByte(16);
ProtocolParser.WriteUInt32(stream, instance.socket);
}
stream.WriteByte(24);
ProtocolParser.WriteBool(stream, instance.onterrain);
if (instance.position != previous.position)
{
stream.WriteByte(34);
memoryStream.SetLength((long)0);
Vector3Serialized.SerializeDelta(memoryStream, instance.position, previous.position);
uint length = (uint)memoryStream.Length;
ProtocolParser.WriteUInt32(stream, length);
stream.Write(memoryStream.GetBuffer(), 0, (int)length);
}
if (instance.normal != previous.normal)
{
stream.WriteByte(42);
memoryStream.SetLength((long)0);
Vector3Serialized.SerializeDelta(memoryStream, instance.normal, previous.normal);
uint num = (uint)memoryStream.Length;
ProtocolParser.WriteUInt32(stream, num);
stream.Write(memoryStream.GetBuffer(), 0, (int)num);
}
stream.WriteByte(50);
memoryStream.SetLength((long)0);
RaySerialized.SerializeDelta(memoryStream, instance.ray, previous.ray);
uint length1 = (uint)memoryStream.Length;
ProtocolParser.WriteUInt32(stream, length1);
stream.Write(memoryStream.GetBuffer(), 0, (int)length1);
if (instance.blockID != previous.blockID)
{
stream.WriteByte(56);
ProtocolParser.WriteUInt32(stream, instance.blockID);
}
if (instance.rotation != previous.rotation)
{
stream.WriteByte(66);
memoryStream.SetLength((long)0);
Vector3Serialized.SerializeDelta(memoryStream, instance.rotation, previous.rotation);
uint num1 = (uint)memoryStream.Length;
ProtocolParser.WriteUInt32(stream, num1);
stream.Write(memoryStream.GetBuffer(), 0, (int)num1);
}
Pool.FreeMemoryStream(ref memoryStream);
}
public static void Serialize(Stream stream, Role instance)
{
stream.WriteByte(8);
ProtocolParser.WriteUInt32(stream, instance.Id);
if (instance.Name == null)
{
throw new ArgumentNullException("Name", "Required by proto specification.");
}
stream.WriteByte(18);
ProtocolParser.WriteBytes(stream, Encoding.UTF8.GetBytes(instance.Name));
if (instance.Privilege.Count > 0)
{
foreach (string s in instance.Privilege)
{
stream.WriteByte(26);
ProtocolParser.WriteBytes(stream, Encoding.UTF8.GetBytes(s));
}
}
if (instance.AssignableRole.Count > 0)
{
stream.WriteByte(34);
uint num = 0u;
foreach (uint val in instance.AssignableRole)
{
num += ProtocolParser.SizeOfUInt32(val);
}
ProtocolParser.WriteUInt32(stream, num);
foreach (uint val2 in instance.AssignableRole)
{
ProtocolParser.WriteUInt32(stream, val2);
}
}
if (instance.HasRequired)
{
stream.WriteByte(40);
ProtocolParser.WriteBool(stream, instance.Required);
}
if (instance.HasUnique)
{
stream.WriteByte(48);
ProtocolParser.WriteBool(stream, instance.Unique);
}
if (instance.HasRelegationRole)
{
stream.WriteByte(56);
ProtocolParser.WriteUInt32(stream, instance.RelegationRole);
}
if (instance.Attribute.Count > 0)
{
foreach (bnet.protocol.attribute.Attribute attribute in instance.Attribute)
{
stream.WriteByte(66);
ProtocolParser.WriteUInt32(stream, attribute.GetSerializedSize());
bnet.protocol.attribute.Attribute.Serialize(stream, attribute);
}
}
}
public static void Serialize(Stream stream, ArcadeGame.arcadeEnt instance)
{
MemoryStream memoryStream = Pool.Get <MemoryStream>();
stream.WriteByte(8);
ProtocolParser.WriteUInt32(stream, instance.id);
if (instance.name == null)
{
throw new ArgumentNullException("name", "Required by proto specification.");
}
stream.WriteByte(18);
ProtocolParser.WriteString(stream, instance.name);
stream.WriteByte(24);
ProtocolParser.WriteUInt32(stream, instance.spriteID);
stream.WriteByte(32);
ProtocolParser.WriteUInt32(stream, instance.soundID);
stream.WriteByte(40);
ProtocolParser.WriteBool(stream, instance.visible);
stream.WriteByte(50);
memoryStream.SetLength((long)0);
Vector3Serialized.Serialize(memoryStream, instance.position);
uint length = (uint)memoryStream.Length;
ProtocolParser.WriteUInt32(stream, length);
stream.Write(memoryStream.GetBuffer(), 0, (int)length);
stream.WriteByte(58);
memoryStream.SetLength((long)0);
Vector3Serialized.Serialize(memoryStream, instance.heading);
uint num = (uint)memoryStream.Length;
ProtocolParser.WriteUInt32(stream, num);
stream.Write(memoryStream.GetBuffer(), 0, (int)num);
stream.WriteByte(64);
ProtocolParser.WriteBool(stream, instance.enabled);
stream.WriteByte(74);
memoryStream.SetLength((long)0);
Vector3Serialized.Serialize(memoryStream, instance.scale);
uint length1 = (uint)memoryStream.Length;
ProtocolParser.WriteUInt32(stream, length1);
stream.Write(memoryStream.GetBuffer(), 0, (int)length1);
stream.WriteByte(82);
memoryStream.SetLength((long)0);
Vector3Serialized.Serialize(memoryStream, instance.colliderScale);
uint num1 = (uint)memoryStream.Length;
ProtocolParser.WriteUInt32(stream, num1);
stream.Write(memoryStream.GetBuffer(), 0, (int)num1);
stream.WriteByte(93);
ProtocolParser.WriteSingle(stream, instance.alpha);
stream.WriteByte(96);
ProtocolParser.WriteUInt32(stream, instance.prefabID);
stream.WriteByte(104);
ProtocolParser.WriteUInt32(stream, instance.parentID);
Pool.FreeMemoryStream(ref memoryStream);
}
public static void Serialize(Stream stream, MemberState instance)
{
if (instance.Attribute.get_Count() > 0)
{
using (List <Attribute> .Enumerator enumerator = instance.Attribute.GetEnumerator())
{
while (enumerator.MoveNext())
{
Attribute current = enumerator.get_Current();
stream.WriteByte(10);
ProtocolParser.WriteUInt32(stream, current.GetSerializedSize());
bnet.protocol.attribute.Attribute.Serialize(stream, current);
}
}
}
if (instance.Role.get_Count() > 0)
{
stream.WriteByte(18);
uint num = 0u;
using (List <uint> .Enumerator enumerator2 = instance.Role.GetEnumerator())
{
while (enumerator2.MoveNext())
{
uint current2 = enumerator2.get_Current();
num += ProtocolParser.SizeOfUInt32(current2);
}
}
ProtocolParser.WriteUInt32(stream, num);
using (List <uint> .Enumerator enumerator3 = instance.Role.GetEnumerator())
{
while (enumerator3.MoveNext())
{
uint current3 = enumerator3.get_Current();
ProtocolParser.WriteUInt32(stream, current3);
}
}
}
if (instance.HasPrivileges)
{
stream.WriteByte(24);
ProtocolParser.WriteUInt64(stream, instance.Privileges);
}
if (instance.HasInfo)
{
stream.WriteByte(34);
ProtocolParser.WriteUInt32(stream, instance.Info.GetSerializedSize());
AccountInfo.Serialize(stream, instance.Info);
}
if (instance.HasHidden)
{
stream.WriteByte(40);
ProtocolParser.WriteBool(stream, instance.Hidden);
}
}
public static void Serialize(Stream stream, GameLevelInfo instance)
{
BinaryWriter binaryWriter = new BinaryWriter(stream);
if (instance.HasIsStarterEdition)
{
stream.WriteByte(24);
ProtocolParser.WriteBool(stream, instance.IsStarterEdition);
}
if (instance.HasIsTrial)
{
stream.WriteByte(32);
ProtocolParser.WriteBool(stream, instance.IsTrial);
}
if (instance.HasIsLifetime)
{
stream.WriteByte(40);
ProtocolParser.WriteBool(stream, instance.IsLifetime);
}
if (instance.HasIsRestricted)
{
stream.WriteByte(48);
ProtocolParser.WriteBool(stream, instance.IsRestricted);
}
if (instance.HasIsBeta)
{
stream.WriteByte(56);
ProtocolParser.WriteBool(stream, instance.IsBeta);
}
if (instance.HasName)
{
stream.WriteByte(66);
ProtocolParser.WriteBytes(stream, Encoding.UTF8.GetBytes(instance.Name));
}
if (instance.HasProgram)
{
stream.WriteByte(77);
binaryWriter.Write(instance.Program);
}
if (instance.Licenses.Count > 0)
{
foreach (AccountLicense accountLicense in instance.Licenses)
{
stream.WriteByte(82);
ProtocolParser.WriteUInt32(stream, accountLicense.GetSerializedSize());
AccountLicense.Serialize(stream, accountLicense);
}
}
if (instance.HasRealmPermissions)
{
stream.WriteByte(88);
ProtocolParser.WriteUInt32(stream, instance.RealmPermissions);
}
}
public static void Serialize(Stream stream, GenericSpawner.SpawnedEnt instance)
{
MemoryStream memoryStream = Pool.Get <MemoryStream>();
stream.WriteByte(8);
ProtocolParser.WriteUInt32(stream, instance.uid);
stream.WriteByte(16);
ProtocolParser.WriteUInt32(stream, instance.spawnPointIndex);
stream.WriteByte(24);
ProtocolParser.WriteBool(stream, instance.mobile);
Pool.FreeMemoryStream(ref memoryStream);
}
public static void Serialize(Stream stream, BuildingBlock instance)
{
MemoryStream memoryStream = Pool.Get <MemoryStream>();
stream.WriteByte(8);
ProtocolParser.WriteUInt64(stream, (ulong)instance.model);
stream.WriteByte(16);
ProtocolParser.WriteUInt64(stream, (ulong)instance.grade);
stream.WriteByte(24);
ProtocolParser.WriteBool(stream, instance.beingDemolished);
Pool.FreeMemoryStream(ref memoryStream);
}
public static void Serialize(Stream stream, ChallengeExternalResult instance)
{
if (instance.HasRequestToken)
{
stream.WriteByte(10);
ProtocolParser.WriteBytes(stream, Encoding.get_UTF8().GetBytes(instance.RequestToken));
}
if (instance.HasPassed)
{
stream.WriteByte(16);
ProtocolParser.WriteBool(stream, instance.Passed);
}
}
public static void Serialize(Stream stream, GetAccountRequest instance)
{
if (instance.HasRef)
{
stream.WriteByte(10);
ProtocolParser.WriteUInt32(stream, instance.Ref.GetSerializedSize());
AccountReference.Serialize(stream, instance.Ref);
}
if (instance.HasFetchAll)
{
stream.WriteByte(80);
ProtocolParser.WriteBool(stream, instance.FetchAll);
}
if (instance.HasFetchBlob)
{
stream.WriteByte(88);
ProtocolParser.WriteBool(stream, instance.FetchBlob);
}
if (instance.HasFetchId)
{
stream.WriteByte(96);
ProtocolParser.WriteBool(stream, instance.FetchId);
}
if (instance.HasFetchEmail)
{
stream.WriteByte(104);
ProtocolParser.WriteBool(stream, instance.FetchEmail);
}
if (instance.HasFetchBattleTag)
{
stream.WriteByte(112);
ProtocolParser.WriteBool(stream, instance.FetchBattleTag);
}
if (instance.HasFetchFullName)
{
stream.WriteByte(120);
ProtocolParser.WriteBool(stream, instance.FetchFullName);
}
if (instance.HasFetchLinks)
{
stream.WriteByte(128);
stream.WriteByte(1);
ProtocolParser.WriteBool(stream, instance.FetchLinks);
}
if (instance.HasFetchParentalControls)
{
stream.WriteByte(136);
stream.WriteByte(1);
ProtocolParser.WriteBool(stream, instance.FetchParentalControls);
}
}
