public static void Serialize(Stream stream, ModuleLoadRequest instance)
{
if (instance.ModuleHandle == null)
{
throw new ArgumentNullException("ModuleHandle", "Required by proto specification.");
}
stream.WriteByte(10);
ProtocolParser.WriteUInt32(stream, instance.ModuleHandle.GetSerializedSize());
ContentHandle.Serialize(stream, instance.ModuleHandle);
if (instance.HasMessage)
{
stream.WriteByte(18);
ProtocolParser.WriteBytes(stream, instance.Message);
}
}
public static void Serialize(Stream stream, ConnectRequest instance)
{
if (instance.HasClientId)
{
stream.WriteByte(10);
ProtocolParser.WriteUInt32(stream, instance.ClientId.GetSerializedSize());
ProcessId.Serialize(stream, instance.ClientId);
}
if (instance.HasBindRequest)
{
stream.WriteByte(18);
ProtocolParser.WriteUInt32(stream, instance.BindRequest.GetSerializedSize());
BindRequest.Serialize(stream, instance.BindRequest);
}
}
public static void Serialize(Stream stream, GetWalletListRequest instance)
{
if (instance.AccountId == null)
{
throw new ArgumentNullException("AccountId", "Required by proto specification.");
}
stream.WriteByte(10);
ProtocolParser.WriteUInt32(stream, instance.AccountId.GetSerializedSize());
bnet.protocol.account.AccountId.Serialize(stream, instance.AccountId);
if (instance.HasRefresh)
{
stream.WriteByte(16);
ProtocolParser.WriteBool(stream, instance.Refresh);
}
}
public static void Serialize(Stream stream, Identity instance)
{
if (instance.HasAccountId)
{
stream.WriteByte(10);
ProtocolParser.WriteUInt32(stream, instance.AccountId.GetSerializedSize());
EntityId.Serialize(stream, instance.AccountId);
}
if (instance.HasGameAccountId)
{
stream.WriteByte(18);
ProtocolParser.WriteUInt32(stream, instance.GameAccountId.GetSerializedSize());
EntityId.Serialize(stream, instance.GameAccountId);
}
}
public static void Serialize(Stream stream, AccountStateTagged instance)
{
if (instance.HasAccountState)
{
stream.WriteByte(10);
ProtocolParser.WriteUInt32(stream, instance.AccountState.GetSerializedSize());
AccountState.Serialize(stream, instance.AccountState);
}
if (instance.HasTags)
{
stream.WriteByte(18);
ProtocolParser.WriteUInt32(stream, instance.Tags.GetSerializedSize());
AccountFieldTags.Serialize(stream, instance.Tags);
}
}
public static void Serialize(Stream stream, HotAirBalloon instance)
{
MemoryStream memoryStream = Pool.Get <MemoryStream>();
stream.WriteByte(13);
ProtocolParser.WriteSingle(stream, instance.inflationAmount);
stream.WriteByte(18);
memoryStream.SetLength((long)0);
Vector3Serialized.Serialize(memoryStream, instance.velocity);
uint length = (uint)memoryStream.Length;
ProtocolParser.WriteUInt32(stream, length);
stream.Write(memoryStream.GetBuffer(), 0, (int)length);
Pool.FreeMemoryStream(ref memoryStream);
}
public static void SerializeDelta(Stream stream, SpinnerWheel instance, SpinnerWheel previous)
{
MemoryStream memoryStream = Pool.Get <MemoryStream>();
if (instance.spin != previous.spin)
{
stream.WriteByte(10);
memoryStream.SetLength((long)0);
Vector3Serialized.SerializeDelta(memoryStream, instance.spin, previous.spin);
uint length = (uint)memoryStream.Length;
ProtocolParser.WriteUInt32(stream, length);
stream.Write(memoryStream.GetBuffer(), 0, (int)length);
}
Pool.FreeMemoryStream(ref memoryStream);
}
public static void Serialize(Stream stream, GameAccountStateTagged instance)
{
if (instance.HasGameAccountState)
{
stream.WriteByte(10);
ProtocolParser.WriteUInt32(stream, instance.GameAccountState.GetSerializedSize());
bnet.protocol.account.GameAccountState.Serialize(stream, instance.GameAccountState);
}
if (instance.HasGameAccountTags)
{
stream.WriteByte(18);
ProtocolParser.WriteUInt32(stream, instance.GameAccountTags.GetSerializedSize());
GameAccountFieldTags.Serialize(stream, instance.GameAccountTags);
}
}
public static void Serialize(Stream stream, InvitationRemovedNotification instance)
{
if (instance.Invitation == null)
{
throw new ArgumentNullException("Invitation", "Required by proto specification.");
}
stream.WriteByte(10);
ProtocolParser.WriteUInt32(stream, instance.Invitation.GetSerializedSize());
Invitation.Serialize(stream, instance.Invitation);
if (instance.HasReason)
{
stream.WriteByte(16);
ProtocolParser.WriteUInt32(stream, instance.Reason);
}
}
public static void Serialize(Stream stream, FieldOperation instance)
{
if (instance.Field == null)
{
throw new ArgumentNullException("Field", "Required by proto specification.");
}
stream.WriteByte(10);
ProtocolParser.WriteUInt32(stream, instance.Field.GetSerializedSize());
bnet.protocol.presence.Field.Serialize(stream, instance.Field);
if (instance.HasOperation)
{
stream.WriteByte(16);
ProtocolParser.WriteUInt64(stream, (ulong)instance.Operation);
}
}
public static void Serialize(Stream stream, GetGameTimeRemainingInfoRequest instance)
{
if (instance.HasGameAccountId)
{
stream.WriteByte(10);
ProtocolParser.WriteUInt32(stream, instance.GameAccountId.GetSerializedSize());
EntityId.Serialize(stream, instance.GameAccountId);
}
if (instance.HasAccountId)
{
stream.WriteByte(18);
ProtocolParser.WriteUInt32(stream, instance.AccountId.GetSerializedSize());
EntityId.Serialize(stream, instance.AccountId);
}
}
public static void Serialize(Stream stream, ObjectAddress instance)
{
if (instance.Host == null)
{
throw new ArgumentNullException("Host", "Required by proto specification.");
}
stream.WriteByte(10);
ProtocolParser.WriteUInt32(stream, instance.Host.GetSerializedSize());
ProcessId.Serialize(stream, instance.Host);
if (instance.HasObjectId)
{
stream.WriteByte(16);
ProtocolParser.WriteUInt64(stream, instance.ObjectId);
}
}
public static void Serialize(Stream stream, GameEndedNotification 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.HasReason)
{
stream.WriteByte(16);
ProtocolParser.WriteUInt32(stream, instance.Reason);
}
}
public static void Serialize(Stream stream, GameAccountSessionNotification instance)
{
if (instance.HasGameAccount)
{
stream.WriteByte(10);
ProtocolParser.WriteUInt32(stream, instance.GameAccount.GetSerializedSize());
GameAccountHandle.Serialize(stream, instance.GameAccount);
}
if (instance.HasSessionInfo)
{
stream.WriteByte(18);
ProtocolParser.WriteUInt32(stream, instance.SessionInfo.GetSerializedSize());
GameSessionUpdateInfo.Serialize(stream, instance.SessionInfo);
}
}
public static void Serialize(Stream stream, GetGameAccountStateResponse instance)
{
if (instance.HasState)
{
stream.WriteByte(10);
ProtocolParser.WriteUInt32(stream, instance.State.GetSerializedSize());
GameAccountState.Serialize(stream, instance.State);
}
if (instance.HasTags)
{
stream.WriteByte(18);
ProtocolParser.WriteUInt32(stream, instance.Tags.GetSerializedSize());
GameAccountFieldTags.Serialize(stream, instance.Tags);
}
}
public static void SerializeDelta(Stream stream, StorageBox instance, StorageBox previous)
{
MemoryStream memoryStream = Pool.Get <MemoryStream>();
if (instance.contents != null)
{
stream.WriteByte(10);
memoryStream.SetLength((long)0);
ItemContainer.SerializeDelta(memoryStream, instance.contents, previous.contents);
uint length = (uint)memoryStream.Length;
ProtocolParser.WriteUInt32(stream, length);
stream.Write(memoryStream.GetBuffer(), 0, (int)length);
}
Pool.FreeMemoryStream(ref memoryStream);
}
public static void Serialize(Stream stream, AccountState instance)
{
if (instance.HasAccountLevelInfo)
{
stream.WriteByte(10);
ProtocolParser.WriteUInt32(stream, instance.AccountLevelInfo.GetSerializedSize());
bnet.protocol.account.AccountLevelInfo.Serialize(stream, instance.AccountLevelInfo);
}
if (instance.HasPrivacyInfo)
{
stream.WriteByte(18);
ProtocolParser.WriteUInt32(stream, instance.PrivacyInfo.GetSerializedSize());
bnet.protocol.account.PrivacyInfo.Serialize(stream, instance.PrivacyInfo);
}
if (instance.HasParentalControlInfo)
{
stream.WriteByte(26);
ProtocolParser.WriteUInt32(stream, instance.ParentalControlInfo.GetSerializedSize());
bnet.protocol.account.ParentalControlInfo.Serialize(stream, instance.ParentalControlInfo);
}
if (instance.GameLevelInfo.Count > 0)
{
foreach (bnet.protocol.account.GameLevelInfo gameLevelInfo in instance.GameLevelInfo)
{
stream.WriteByte(42);
ProtocolParser.WriteUInt32(stream, gameLevelInfo.GetSerializedSize());
bnet.protocol.account.GameLevelInfo.Serialize(stream, gameLevelInfo);
}
}
if (instance.GameStatus.Count > 0)
{
foreach (bnet.protocol.account.GameStatus gameStatu in instance.GameStatus)
{
stream.WriteByte(50);
ProtocolParser.WriteUInt32(stream, gameStatu.GetSerializedSize());
bnet.protocol.account.GameStatus.Serialize(stream, gameStatu);
}
}
if (instance.GameAccounts.Count > 0)
{
foreach (GameAccountList gameAccount in instance.GameAccounts)
{
stream.WriteByte(58);
ProtocolParser.WriteUInt32(stream, gameAccount.GetSerializedSize());
GameAccountList.Serialize(stream, gameAccount);
}
}
}
public static void Serialize(Stream stream, GameFactoryDescription instance)
{
BinaryWriter binaryWriter = new BinaryWriter(stream);
stream.WriteByte(9);
binaryWriter.Write(instance.Id);
if (instance.HasName)
{
stream.WriteByte(18);
ProtocolParser.WriteBytes(stream, Encoding.get_UTF8().GetBytes(instance.Name));
}
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.StatsBucket.get_Count() > 0)
{
using (List <GameStatsBucket> .Enumerator enumerator2 = instance.StatsBucket.GetEnumerator())
{
while (enumerator2.MoveNext())
{
GameStatsBucket current2 = enumerator2.get_Current();
stream.WriteByte(34);
ProtocolParser.WriteUInt32(stream, current2.GetSerializedSize());
GameStatsBucket.Serialize(stream, current2);
}
}
}
if (instance.HasUnseededId)
{
stream.WriteByte(41);
binaryWriter.Write(instance.UnseededId);
}
if (instance.HasAllowQueueing)
{
stream.WriteByte(48);
ProtocolParser.WriteBool(stream, instance.AllowQueueing);
}
}
public static void Serialize(Stream stream, Notification instance)
{
if (instance.HasSenderId)
{
stream.WriteByte(10);
ProtocolParser.WriteUInt32(stream, instance.SenderId.GetSerializedSize());
EntityId.Serialize(stream, instance.SenderId);
}
if (instance.TargetId == null)
{
throw new ArgumentNullException("TargetId", "Required by proto specification.");
}
stream.WriteByte(18);
ProtocolParser.WriteUInt32(stream, instance.TargetId.GetSerializedSize());
EntityId.Serialize(stream, instance.TargetId);
if (instance.Type == null)
{
throw new ArgumentNullException("Type", "Required by proto specification.");
}
stream.WriteByte(26);
ProtocolParser.WriteBytes(stream, Encoding.UTF8.GetBytes(instance.Type));
if (instance.Attribute.Count > 0)
{
foreach (bnet.protocol.attribute.Attribute attribute in instance.Attribute)
{
stream.WriteByte(34);
ProtocolParser.WriteUInt32(stream, attribute.GetSerializedSize());
bnet.protocol.attribute.Attribute.Serialize(stream, attribute);
}
}
if (instance.HasSenderAccountId)
{
stream.WriteByte(42);
ProtocolParser.WriteUInt32(stream, instance.SenderAccountId.GetSerializedSize());
EntityId.Serialize(stream, instance.SenderAccountId);
}
if (instance.HasTargetAccountId)
{
stream.WriteByte(50);
ProtocolParser.WriteUInt32(stream, instance.TargetAccountId.GetSerializedSize());
EntityId.Serialize(stream, instance.TargetAccountId);
}
if (instance.HasSenderBattleTag)
{
stream.WriteByte(58);
ProtocolParser.WriteBytes(stream, Encoding.UTF8.GetBytes(instance.SenderBattleTag));
}
}
public static void Serialize(Stream stream, LogonResult instance)
{
stream.WriteByte(8);
ProtocolParser.WriteUInt32(stream, instance.ErrorCode);
if (instance.HasAccount)
{
stream.WriteByte(18);
ProtocolParser.WriteUInt32(stream, instance.Account.GetSerializedSize());
EntityId.Serialize(stream, instance.Account);
}
if (instance.GameAccount.Count > 0)
{
foreach (EntityId entityId in instance.GameAccount)
{
stream.WriteByte(26);
ProtocolParser.WriteUInt32(stream, entityId.GetSerializedSize());
EntityId.Serialize(stream, entityId);
}
}
if (instance.HasEmail)
{
stream.WriteByte(34);
ProtocolParser.WriteBytes(stream, Encoding.UTF8.GetBytes(instance.Email));
}
if (instance.AvailableRegion.Count > 0)
{
foreach (uint val in instance.AvailableRegion)
{
stream.WriteByte(40);
ProtocolParser.WriteUInt32(stream, val);
}
}
if (instance.HasConnectedRegion)
{
stream.WriteByte(48);
ProtocolParser.WriteUInt32(stream, instance.ConnectedRegion);
}
if (instance.HasBattleTag)
{
stream.WriteByte(58);
ProtocolParser.WriteBytes(stream, Encoding.UTF8.GetBytes(instance.BattleTag));
}
if (instance.HasGeoipCountry)
{
stream.WriteByte(66);
ProtocolParser.WriteBytes(stream, Encoding.UTF8.GetBytes(instance.GeoipCountry));
}
}
public static void Serialize(Stream stream, UpdateChannelStateNotification instance)
{
if (instance.HasAgentId)
{
stream.WriteByte(10);
ProtocolParser.WriteUInt32(stream, instance.AgentId.GetSerializedSize());
EntityId.Serialize(stream, instance.AgentId);
}
if (instance.StateChange == null)
{
throw new ArgumentNullException("StateChange", "Required by proto specification.");
}
stream.WriteByte(18);
ProtocolParser.WriteUInt32(stream, instance.StateChange.GetSerializedSize());
ChannelState.Serialize(stream, instance.StateChange);
}
public static void Serialize(Stream stream, UnsubscribeRequest instance)
{
if (instance.HasAgentId)
{
stream.WriteByte(10);
ProtocolParser.WriteUInt32(stream, instance.AgentId.GetSerializedSize());
EntityId.Serialize(stream, instance.AgentId);
}
if (instance.EntityId == null)
{
throw new ArgumentNullException("EntityId", "Required by proto specification.");
}
stream.WriteByte(18);
ProtocolParser.WriteUInt32(stream, instance.EntityId.GetSerializedSize());
EntityId.Serialize(stream, instance.EntityId);
}
public static void Serialize(Stream stream, AccountServiceConfig instance)
{
if (instance.Region.get_Count() > 0)
{
using (List <AccountServiceRegion> .Enumerator enumerator = instance.Region.GetEnumerator())
{
while (enumerator.MoveNext())
{
AccountServiceRegion current = enumerator.get_Current();
stream.WriteByte(10);
ProtocolParser.WriteUInt32(stream, current.GetSerializedSize());
AccountServiceRegion.Serialize(stream, current);
}
}
}
}
public static void Serialize(Stream stream, ErrorInfo instance)
{
if (instance.ObjectAddress == null)
{
throw new ArgumentNullException("ObjectAddress", "Required by proto specification.");
}
stream.WriteByte(10);
ProtocolParser.WriteUInt32(stream, instance.ObjectAddress.GetSerializedSize());
bnet.protocol.ObjectAddress.Serialize(stream, instance.ObjectAddress);
stream.WriteByte(16);
ProtocolParser.WriteUInt32(stream, instance.Status);
stream.WriteByte(24);
ProtocolParser.WriteUInt32(stream, instance.ServiceHash);
stream.WriteByte(32);
ProtocolParser.WriteUInt32(stream, instance.MethodId);
}
public static void Serialize(Stream stream, FindChannelRequest instance)
{
if (instance.HasAgentIdentity)
{
stream.WriteByte(10);
ProtocolParser.WriteUInt32(stream, instance.AgentIdentity.GetSerializedSize());
Identity.Serialize(stream, instance.AgentIdentity);
}
if (instance.Options == null)
{
throw new ArgumentNullException("Options", "Required by proto specification.");
}
stream.WriteByte(18);
ProtocolParser.WriteUInt32(stream, instance.Options.GetSerializedSize());
FindChannelOptions.Serialize(stream, instance.Options);
}
public static void Serialize(Stream stream, UpdateFriendStateNotification instance)
{
if (instance.ChangedFriend == null)
{
throw new ArgumentNullException("ChangedFriend", "Required by proto specification.");
}
stream.WriteByte(10);
ProtocolParser.WriteUInt32(stream, instance.ChangedFriend.GetSerializedSize());
Friend.Serialize(stream, instance.ChangedFriend);
if (instance.HasGameAccountId)
{
stream.WriteByte(18);
ProtocolParser.WriteUInt32(stream, instance.GameAccountId.GetSerializedSize());
EntityId.Serialize(stream, instance.GameAccountId);
}
}
public static void Serialize(Stream stream, WordFilters instance)
{
if (instance.Filters.get_Count() > 0)
{
using (List <WordFilter> .Enumerator enumerator = instance.Filters.GetEnumerator())
{
while (enumerator.MoveNext())
{
WordFilter current = enumerator.get_Current();
stream.WriteByte(10);
ProtocolParser.WriteUInt32(stream, current.GetSerializedSize());
WordFilter.Serialize(stream, current);
}
}
}
}
public static void Serialize(Stream stream, GetWalletListResponse instance)
{
if (instance.Wallets.get_Count() > 0)
{
using (List <Wallet> .Enumerator enumerator = instance.Wallets.GetEnumerator())
{
while (enumerator.MoveNext())
{
Wallet current = enumerator.get_Current();
stream.WriteByte(10);
ProtocolParser.WriteUInt32(stream, current.GetSerializedSize());
Wallet.Serialize(stream, current);
}
}
}
}
public static void Serialize(Stream stream, SubscriptionUpdateRequest instance)
{
if (instance.Ref.get_Count() > 0)
{
using (List <SubscriberReference> .Enumerator enumerator = instance.Ref.GetEnumerator())
{
while (enumerator.MoveNext())
{
SubscriberReference current = enumerator.get_Current();
stream.WriteByte(18);
ProtocolParser.WriteUInt32(stream, current.GetSerializedSize());
SubscriberReference.Serialize(stream, current);
}
}
}
}
public static void Serialize(Stream stream, GetEBalanceRestrictionsResponse instance)
{
if (instance.CurrencyRestrictions.get_Count() > 0)
{
using (List <CurrencyRestriction> .Enumerator enumerator = instance.CurrencyRestrictions.GetEnumerator())
{
while (enumerator.MoveNext())
{
CurrencyRestriction current = enumerator.get_Current();
stream.WriteByte(10);
ProtocolParser.WriteUInt32(stream, current.GetSerializedSize());
CurrencyRestriction.Serialize(stream, current);
}
}
}
}
