public static Whisper.Messages.TreeMessage Deserialize(Stream stream, Whisper.Messages.TreeMessage instance)
{
while (true)
{
ProtocolBuffers.Key key = null;
int keyByte = stream.ReadByte();
if (keyByte == -1)
{
break;
}
//Optimized reading of known fields with field ID < 16
switch (keyByte)
{
case 10: //Field 1 LengthDelimited
instance.Name = ProtocolParser.ReadString(stream);
break;
case 18: //Field 2 LengthDelimited
instance.TreeChunkHash = ProtocolParser.ReadBytes(stream);
break;
default:
key = ProtocolParser.ReadKey((byte)keyByte, stream);
break;
}
if (key == null)
{
continue;
}
//Reading field ID > 16 and unknown field ID/wire type combinations
switch (key.Field)
{
case 0:
throw new InvalidDataException("Invalid field id: 0, something went wrong in the stream");
default:
ProtocolParser.SkipKey(stream, key);
break;
}
}
return(instance);
}
public uint GetSerializedSize()
{
uint num = 0u;
if (this.Account.get_Count() > 0)
{
using (List <AccountId> .Enumerator enumerator = this.Account.GetEnumerator())
{
while (enumerator.MoveNext())
{
AccountId current = enumerator.get_Current();
num += 1u;
uint serializedSize = current.GetSerializedSize();
num += serializedSize + ProtocolParser.SizeOfUInt32(serializedSize);
}
}
}
if (this.GameAccount.get_Count() > 0)
{
using (List <GameAccountHandle> .Enumerator enumerator2 = this.GameAccount.GetEnumerator())
{
while (enumerator2.MoveNext())
{
GameAccountHandle current2 = enumerator2.get_Current();
num += 1u;
uint serializedSize2 = current2.GetSerializedSize();
num += serializedSize2 + ProtocolParser.SizeOfUInt32(serializedSize2);
}
}
}
if (this.Email.get_Count() > 0)
{
using (List <string> .Enumerator enumerator3 = this.Email.GetEnumerator())
{
while (enumerator3.MoveNext())
{
string current3 = enumerator3.get_Current();
num += 1u;
uint byteCount = (uint)Encoding.get_UTF8().GetByteCount(current3);
num += ProtocolParser.SizeOfUInt32(byteCount) + byteCount;
}
}
}
return(num);
}
public static AccountLicense Deserialize(Stream stream, AccountLicense instance, long limit)
{
while (limit < 0L || stream.get_Position() < limit)
{
int num = stream.ReadByte();
if (num == -1)
{
if (limit >= 0L)
{
throw new EndOfStreamException();
}
return(instance);
}
else
{
int num2 = num;
if (num2 != 8)
{
if (num2 != 16)
{
Key key = ProtocolParser.ReadKey((byte)num, stream);
uint field = key.Field;
if (field == 0u)
{
throw new ProtocolBufferException("Invalid field id: 0, something went wrong in the stream");
}
ProtocolParser.SkipKey(stream, key);
}
else
{
instance.Expires = ProtocolParser.ReadUInt64(stream);
}
}
else
{
instance.Id = ProtocolParser.ReadUInt32(stream);
}
}
}
if (stream.get_Position() == limit)
{
return(instance);
}
throw new ProtocolBufferException("Read past max limit");
}
public static GameAccountLink Deserialize(Stream stream, GameAccountLink instance, long limit)
{
while (limit < 0L || stream.Position < limit)
{
int num = stream.ReadByte();
if (num == -1)
{
if (limit >= 0L)
{
throw new EndOfStreamException();
}
return(instance);
}
else if (num != 10)
{
if (num != 18)
{
Key key = ProtocolParser.ReadKey((byte)num, stream);
uint field = key.Field;
if (field == 0u)
{
throw new ProtocolBufferException("Invalid field id: 0, something went wrong in the stream");
}
ProtocolParser.SkipKey(stream, key);
}
else
{
instance.Name = ProtocolParser.ReadString(stream);
}
}
else if (instance.GameAccount == null)
{
instance.GameAccount = GameAccountHandle.DeserializeLengthDelimited(stream);
}
else
{
GameAccountHandle.DeserializeLengthDelimited(stream, instance.GameAccount);
}
}
if (stream.Position == limit)
{
return(instance);
}
throw new ProtocolBufferException("Read past max limit");
}
public static IsIgrAddressRequest Deserialize(Stream stream, IsIgrAddressRequest instance, long limit)
{
while (limit < 0L || stream.get_Position() < limit)
{
int num = stream.ReadByte();
if (num == -1)
{
if (limit >= 0L)
{
throw new EndOfStreamException();
}
return(instance);
}
else
{
int num2 = num;
if (num2 != 10)
{
if (num2 != 16)
{
Key key = ProtocolParser.ReadKey((byte)num, stream);
uint field = key.Field;
if (field == 0u)
{
throw new ProtocolBufferException("Invalid field id: 0, something went wrong in the stream");
}
ProtocolParser.SkipKey(stream, key);
}
else
{
instance.Region = ProtocolParser.ReadUInt32(stream);
}
}
else
{
instance.ClientAddress = ProtocolParser.ReadString(stream);
}
}
}
if (stream.get_Position() == limit)
{
return(instance);
}
throw new ProtocolBufferException("Read past max limit");
}
public static ChallengeExternalResult Deserialize(Stream stream, ChallengeExternalResult instance, long limit)
{
instance.Passed = true;
while (true)
{
if (limit < (long)0 || stream.Position < limit)
{
int num = stream.ReadByte();
if (num == -1)
{
if (limit >= (long)0)
{
throw new EndOfStreamException();
}
break;
}
else if (num == 10)
{
instance.RequestToken = ProtocolParser.ReadString(stream);
}
else if (num == 16)
{
instance.Passed = ProtocolParser.ReadBool(stream);
}
else
{
Key key = ProtocolParser.ReadKey((byte)num, stream);
if (key.Field == 0)
{
throw new ProtocolBufferException("Invalid field id: 0, something went wrong in the stream");
}
ProtocolParser.SkipKey(stream, key);
}
}
else
{
if (stream.Position != limit)
{
throw new ProtocolBufferException("Read past max limit");
}
break;
}
}
return(instance);
}
public uint GetSerializedSize()
{
uint num = 0u;
uint serializedSize = this.AgentId.GetSerializedSize();
num += serializedSize + ProtocolParser.SizeOfUInt32(serializedSize);
if (this.Descriptions.Count > 0)
{
foreach (ChannelCountDescription channelCountDescription in this.Descriptions)
{
num += 1u;
uint serializedSize2 = channelCountDescription.GetSerializedSize();
num += serializedSize2 + ProtocolParser.SizeOfUInt32(serializedSize2);
}
}
num += 1u;
return(num);
}
public static void Serialize(Stream stream, ClientReady.ClientInfo instance)
{
MemoryStream memoryStream = Pool.Get <MemoryStream>();
if (instance.name == null)
{
throw new ArgumentNullException("name", "Required by proto specification.");
}
stream.WriteByte(10);
ProtocolParser.WriteString(stream, instance.name);
if (instance.@value == null)
{
throw new ArgumentNullException("value", "Required by proto specification.");
}
stream.WriteByte(18);
ProtocolParser.WriteString(stream, instance.@value);
Pool.FreeMemoryStream(ref memoryStream);
}
public static void Serialize(Stream stream, ChallengeExternalRequest instance)
{
if (instance.HasRequestToken)
{
stream.WriteByte(10);
ProtocolParser.WriteBytes(stream, Encoding.UTF8.GetBytes(instance.RequestToken));
}
if (instance.HasPayloadType)
{
stream.WriteByte(18);
ProtocolParser.WriteBytes(stream, Encoding.UTF8.GetBytes(instance.PayloadType));
}
if (instance.HasPayload)
{
stream.WriteByte(26);
ProtocolParser.WriteBytes(stream, instance.Payload);
}
}
public static void Serialize(Stream stream, CAIS instance)
{
if (instance.HasPlayedMinutes)
{
stream.WriteByte(8);
ProtocolParser.WriteUInt32(stream, instance.PlayedMinutes);
}
if (instance.HasRestedMinutes)
{
stream.WriteByte(16);
ProtocolParser.WriteUInt32(stream, instance.RestedMinutes);
}
if (instance.HasLastHeardTime)
{
stream.WriteByte(24);
ProtocolParser.WriteUInt64(stream, instance.LastHeardTime);
}
}
public static void Serialize(Stream stream, GetPlayerVariablesRequest instance)
{
if (instance.PlayerVariables.Count > 0)
{
foreach (PlayerVariables playerVariables in instance.PlayerVariables)
{
stream.WriteByte(10);
ProtocolParser.WriteUInt32(stream, playerVariables.GetSerializedSize());
bnet.protocol.game_utilities.PlayerVariables.Serialize(stream, playerVariables);
}
}
if (instance.HasHost)
{
stream.WriteByte(18);
ProtocolParser.WriteUInt32(stream, instance.Host.GetSerializedSize());
ProcessId.Serialize(stream, instance.Host);
}
}
public uint GetSerializedSize()
{
uint num = 0u;
if (this.HasState)
{
num += 1u;
uint serializedSize = this.State.GetSerializedSize();
num += serializedSize + ProtocolParser.SizeOfUInt32(serializedSize);
}
if (this.HasTags)
{
num += 1u;
uint serializedSize2 = this.Tags.GetSerializedSize();
num += serializedSize2 + ProtocolParser.SizeOfUInt32(serializedSize2);
}
return(num);
}
public uint GetSerializedSize()
{
uint num = 0;
if (this.HasState)
{
num++;
uint serializedSize = this.State.GetSerializedSize();
num = num + serializedSize + ProtocolParser.SizeOfUInt32(serializedSize);
}
if (this.HasTags)
{
num++;
uint serializedSize1 = this.Tags.GetSerializedSize();
num = num + serializedSize1 + ProtocolParser.SizeOfUInt32(serializedSize1);
}
return(num);
}
public uint GetSerializedSize()
{
uint num = 0u;
if (this.HasClientId)
{
num += 1u;
uint serializedSize = this.ClientId.GetSerializedSize();
num += serializedSize + ProtocolParser.SizeOfUInt32(serializedSize);
}
if (this.HasBindRequest)
{
num += 1u;
uint serializedSize2 = this.BindRequest.GetSerializedSize();
num += serializedSize2 + ProtocolParser.SizeOfUInt32(serializedSize2);
}
return(num);
}
public uint GetSerializedSize()
{
uint num = 0;
uint serializedSize = this.Description.GetSerializedSize();
num = num + serializedSize + ProtocolParser.SizeOfUInt32(serializedSize);
if (this.Member.Count > 0)
{
foreach (bnet.protocol.channel.Member member in this.Member)
{
num++;
uint serializedSize1 = member.GetSerializedSize();
num = num + serializedSize1 + ProtocolParser.SizeOfUInt32(serializedSize1);
}
}
num++;
return(num);
}
public static void Serialize(Stream stream, AttributeFilter instance)
{
stream.WriteByte(8);
ProtocolParser.WriteUInt64(stream, (ulong)((long)instance.Op));
if (instance.Attribute.get_Count() > 0)
{
using (List <Attribute> .Enumerator enumerator = instance.Attribute.GetEnumerator())
{
while (enumerator.MoveNext())
{
Attribute current = enumerator.get_Current();
stream.WriteByte(18);
ProtocolParser.WriteUInt32(stream, current.GetSerializedSize());
bnet.protocol.attribute.Attribute.Serialize(stream, current);
}
}
}
}
public static void Serialize(Stream stream, ChallengeAnsweredResponse instance)
{
if (instance.HasData)
{
stream.WriteByte(10);
ProtocolParser.WriteBytes(stream, instance.Data);
}
if (instance.HasDoRetry)
{
stream.WriteByte(16);
ProtocolParser.WriteBool(stream, instance.DoRetry);
}
if (instance.HasRecordNotFound)
{
stream.WriteByte(24);
ProtocolParser.WriteBool(stream, instance.RecordNotFound);
}
}
public static void SerializeDelta(Stream stream, GenericSpawner.SpawnedEnt instance, GenericSpawner.SpawnedEnt previous)
{
MemoryStream memoryStream = Pool.Get <MemoryStream>();
if (instance.uid != previous.uid)
{
stream.WriteByte(8);
ProtocolParser.WriteUInt32(stream, instance.uid);
}
if (instance.spawnPointIndex != previous.spawnPointIndex)
{
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, PersistantPlayer instance)
{
MemoryStream memoryStream = Pool.Get <MemoryStream>();
if (instance.unlockedItems != null)
{
for (int i = 0; i < instance.unlockedItems.Count; i++)
{
int item = instance.unlockedItems[i];
stream.WriteByte(24);
ProtocolParser.WriteUInt64(stream, (ulong)item);
}
}
stream.WriteByte(160);
stream.WriteByte(6);
ProtocolParser.WriteUInt64(stream, (ulong)instance.protocolVersion);
Pool.FreeMemoryStream(ref memoryStream);
}
/// <summary>
/// Helper for sending messages
/// </summary>
private void SendMessage(IPipeMessage message)
{
PipeHeader h = PipeHeader.Next();
h.TypeID = message.TypeID;
//Send Header
#if DEBUG
//Console.WriteLine("PipeRepo: Header(" + h.TypeID + ", " + h.DebugNumber + ")");
#endif
ProtocolParser.WriteBytes(output, PipeHeader.SerializeToBytes(h));
//Send Message
#if DEBUG
//Console.WriteLine("PipeRepo: Message(" + message + ")");
#endif
byte[] messageBytes = GetMessageBytes(message);
ProtocolParser.WriteBytes(output, messageBytes);
}
public uint GetSerializedSize()
{
uint num = 0;
uint serializedSize = this.EntityId.GetSerializedSize();
num = num + serializedSize + ProtocolParser.SizeOfUInt32(serializedSize);
if (this.FieldOperation.Count > 0)
{
foreach (bnet.protocol.presence.FieldOperation fieldOperation in this.FieldOperation)
{
num++;
uint serializedSize1 = fieldOperation.GetSerializedSize();
num = num + serializedSize1 + ProtocolParser.SizeOfUInt32(serializedSize1);
}
}
num++;
return(num);
}
public uint GetSerializedSize()
{
uint num = 0u;
if (this.HasChannelId)
{
num += 1u;
uint serializedSize = this.ChannelId.GetSerializedSize();
num += serializedSize + ProtocolParser.SizeOfUInt32(serializedSize);
}
if (this.HasChannelType)
{
num += 1u;
uint byteCount = (uint)Encoding.get_UTF8().GetByteCount(this.ChannelType);
num += ProtocolParser.SizeOfUInt32(byteCount) + byteCount;
}
return(num);
}
public override Chunk ReadChunk(ChunkHash chunkHash)
{
RequestReadChunk msg = new RequestReadChunk();
msg.ChunkHash = chunkHash.bytes;
SendMessage(msg);
ReplyReadChunk reply = ReplyReadChunk.Deserialize(ProtocolParser.ReadBytes(input));
Chunk c = new Chunk(reply.ChunkData);
//Verify Hash
if (c.ChunkHash.Equals(chunkHash) == false)
{
throw new InvalidDataException("Hash mismatch: " + chunkHash);
}
return(c);
}
public uint GetSerializedSize()
{
uint num = 0;
if (this.HasGameAccount)
{
num++;
uint serializedSize = this.GameAccount.GetSerializedSize();
num = num + serializedSize + ProtocolParser.SizeOfUInt32(serializedSize);
}
if (this.HasSessionInfo)
{
num++;
uint serializedSize1 = this.SessionInfo.GetSerializedSize();
num = num + serializedSize1 + ProtocolParser.SizeOfUInt32(serializedSize1);
}
return(num);
}
public uint GetSerializedSize()
{
uint num = 0u;
if (this.HasGameAccountId)
{
num += 1u;
uint serializedSize = this.GameAccountId.GetSerializedSize();
num += serializedSize + ProtocolParser.SizeOfUInt32(serializedSize);
}
if (this.HasAccountId)
{
num += 1u;
uint serializedSize2 = this.AccountId.GetSerializedSize();
num += serializedSize2 + ProtocolParser.SizeOfUInt32(serializedSize2);
}
return(num);
}
public uint GetSerializedSize()
{
uint num = 0u;
uint byteCount = (uint)Encoding.UTF8.GetByteCount(this.Answer);
num += ProtocolParser.SizeOfUInt32(byteCount) + byteCount;
if (this.HasData)
{
num += 1u;
num += ProtocolParser.SizeOfUInt32(this.Data.Length) + (uint)this.Data.Length;
}
if (this.HasId)
{
num += 1u;
num += ProtocolParser.SizeOfUInt32(this.Id);
}
return(num + 1u);
}
public static void SerializeDelta(Stream stream, BuildingBlock instance, BuildingBlock previous)
{
MemoryStream memoryStream = Pool.Get <MemoryStream>();
if (instance.model != previous.model)
{
stream.WriteByte(8);
ProtocolParser.WriteUInt64(stream, (ulong)instance.model);
}
if (instance.grade != previous.grade)
{
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, GameTimeRemainingInfo instance)
{
if (instance.HasMinutesRemaining)
{
stream.WriteByte(8);
ProtocolParser.WriteUInt32(stream, instance.MinutesRemaining);
}
if (instance.HasParentalDailyMinutesRemaining)
{
stream.WriteByte(16);
ProtocolParser.WriteUInt32(stream, instance.ParentalDailyMinutesRemaining);
}
if (instance.HasParentalWeeklyMinutesRemaining)
{
stream.WriteByte(24);
ProtocolParser.WriteUInt32(stream, instance.ParentalWeeklyMinutesRemaining);
}
}
public static void Serialize(Stream stream, GameSessionLocation instance)
{
if (instance.HasIpAddress)
{
stream.WriteByte(10);
ProtocolParser.WriteBytes(stream, Encoding.get_UTF8().GetBytes(instance.IpAddress));
}
if (instance.HasCountry)
{
stream.WriteByte(16);
ProtocolParser.WriteUInt32(stream, instance.Country);
}
if (instance.HasCity)
{
stream.WriteByte(26);
ProtocolParser.WriteBytes(stream, Encoding.get_UTF8().GetBytes(instance.City));
}
}
public uint GetSerializedSize()
{
uint num = 0u;
uint serializedSize = this.Filter.GetSerializedSize();
num += serializedSize + ProtocolParser.SizeOfUInt32(serializedSize);
if (this.HasStartIndex)
{
num += 1u;
num += ProtocolParser.SizeOfUInt32(this.StartIndex);
}
if (this.HasMaxResults)
{
num += 1u;
num += ProtocolParser.SizeOfUInt32(this.MaxResults);
}
return(num + 1u);
}
