private void NetworkOnMessageReceived(MessageTag messageTag, IDeserializer reader)
{
switch (messageTag)
{
case MessageTag.StartSimulation:
var pkt = new Init();
pkt.Deserialize(reader);
Time.fixedDeltaTime = 1f / pkt.TargetFPS;
_simulation.Init(pkt.Seed);
_simulationStarted = true;
break;
case MessageTag.Frame:
//Server sends in ReliableOrdered-mode, so we only care about the latest frame
//Also possible could be high-frequency unreliable messages and use redundant frames to fill up a framebuffer in case of frame loss during transmission
_simulation.AddFrame(new Frame {
Commands = _inputParser.DeserializeInput(reader)
});
//TODO: only for debugging, frames should be buffered & later executed in FixedUpdate
_simulation.Simulate();
LockstepNetwork.Instance.SendHashCode(new HashCode
{
FrameNumber = _simulation.FrameCounter,
Value = _simulation.HashCode
});
break;
}
}
private byte[] CreateBufferForSend(MessageTag messageTag, IMessage message)
{
using (var memoryStream = new MemoryStream())
{
return(CreateBufferForSend(memoryStream, messageTag, message));
}
}
private byte[] CreateBufferForSend(MemoryStream stream, MessageTag messageTag, IMessage message)
{
byte[] preabmleBuffer = new byte[] { (byte)messageTag };
stream.Write(preabmleBuffer, 0, preabmleBuffer.Length);
message.WriteDelimitedTo(stream);
return(stream.ToArray());
}
static UnknownFieldCollection ReadGroup(MessageTag startTag, MessageReader reader)
{
var group = new UnknownFieldCollection();
for(int stop = startTag.WithWireType(WireType.EndGroup), tag = reader.ReadInt32(); tag != stop; tag = reader.ReadInt32())
group.Add(new MessageTag(tag), reader);
return group;
}
private IMessage BuildProtobufOfTag(MessageTag tag)
{
switch (tag)
{
case MessageTag.kHeartbeatPingTag:
return(new HeartbeatPing());
case MessageTag.kHeartbeatAckTag:
return(new HeartbeatAck());
case MessageTag.kLoginRequestTag:
return(new LoginRequest());
case MessageTag.kLoginResponseTag:
return(new LoginResponse());
case MessageTag.kCloseTag:
return(new Close());
case MessageTag.kIqStanzaTag:
return(new IqStanza());
case MessageTag.kDataMessageStanzaTag:
return(new DataMessageStanza());
case MessageTag.kStreamErrorStanzaTag:
return(new StreamErrorStanza());
default:
return(null);
}
}
private void OnGotMessageTag(Stream stream)
{
messageTag = (MessageTag)stream.ReadByte();
Debug.WriteLine($"Received proto of type {messageTag}");
OnGotMessageSize(stream);
}
public async Task WhenReceiveHeartBeatPing_WhileListeningForPushNotification_ShouldSendBackHeartBeatAck()
{
FakeFcmConnection connection = null;
bool sentHeartBeatAck = false;
bool expectHeartBeatAck = true;
connection = new FakeFcmConnection((ctoken) =>
{
byte[] buffer = new byte[2048];
byte[] fakeData;
fakeData = new byte[] { 41 };
connection.SimulateDataReceived(fakeData);
fakeData = new byte[] { 3, 62, 10, 18, 99, 104, 114, 111, 109, 101, 45, 54, 51, 46, 48, 46, 51, 50, 51, 52, 46, 48, 18, 31, 117, 115, 101, 114, 64, 102, 105, 114, 101, 98, 97, 115, 101, 46, 99, 111, 109, 47, 110, 111, 116, 105, 102, 105, 99, 97, 116, 105, 111, 110, 115, 48, 1, 64, 192, 216, 151, 177, 230, 46, };
connection.SimulateDataReceived(fakeData);
fakeData = new byte[] { 7, 10, 16, 1, 26, 0, 58, 4, 8, 12, 18, 0, };
connection.SimulateDataReceived(fakeData);
expectHeartBeatAck = true;
fakeData = new byte[] { 0, 0 };
connection.SimulateDataReceived(fakeData);
expectHeartBeatAck = false;
return(Task.CompletedTask);
});
connection.DataSent += (s, data) =>
{
if (expectHeartBeatAck == true)
{
using (var memoryStream = new MemoryStream(data))
{
MessageTag currentTag = (MessageTag)memoryStream.ReadByte(); // read messageTag byte
if (currentTag == MessageTag.kHeartbeatAckTag)
{
var instance = HeartbeatAck.Parser.ParseDelimitedFrom(memoryStream);
if (instance != null)
{
sentHeartBeatAck = true;
}
}
}
}
};
FcmListener listener = new FcmListener(connection);
await listener.ConnectAsync();
await listener.LoginAsync(0, 0);
await listener.ListenAsync();
Assert.IsTrue(sentHeartBeatAck);
}
private static UnknownFieldCollection ReadGroup(MessageTag startTag, MessageReader reader)
{
UnknownFieldCollection group = new UnknownFieldCollection();
for (int stop = startTag.WithWireType(WireType.EndGroup),
tag = reader.ReadInt32(); tag != stop; tag = reader.ReadInt32())
{
group.Add(new MessageTag(tag), reader);
}
return(group);
}
internal string DecodeMessageTag(byte[] InputData, int Index)
{
var Tag = new MessageTag(InputData, Index);
KeyValuePair <string, MsgTagParamType> MessageTagInfo = MessageTagDictionary.ElementAt(Tag.Group).ElementAt(Tag.Index);
string Argument = "";
switch (MessageTagInfo.Value)
{
case MsgTagParamType.U8:
Argument = GetDataString(Tag.GetParamU8(), DataType.HexByte);
break;
case MsgTagParamType.U16:
Argument = GetDataString(Tag.GetParamU16(), DataType.HexUShort);
break;
// TODO: Rest of types
}
return(string.Format(MessageTagInfo.Key, Argument)); // TODO: Argument needs to be an array
}
/// <summary>
/// Send a message with a specified tag to the log console on MainWindow.
/// </summary>
/// <param name="message"></param>
/// <param name="type"></param>
public static void sendMessage(string message, MessageTag tag)
{
//Form form = MainWindow.ActiveForm;
//if (form != null)
//{
// if (form.GetType() == typeof(MainWindow))
// {
// mainWind = (MainWindow)form;
// }
// else
// {
// Console.WriteLine("Foreign instance of type <" + form.GetType().Name + "> cannot send messages.");
// return;
// }
//}
//else
//{
// Console.WriteLine("MainWindow has been closed.");
// Manager.stopJob(false);
//}
try
{
if (mainWind != null && !mainWind.IsDisposed && !mainWind.Disposing)
{
mainWind.addMessage(message, tag);
}
else
{
//Manager.stopJob(false);
}
}
catch (StackOverflowException)
{
// Doesn't matter
}
}
private static MessageEnvelope Deserialize(byte[] bytes, string exchange, ulong deliveryTag, bool redelivered, string routingKey, IBasicProperties basicProperties, MessageClientBase messageClient)
{
var envelope = MessageEnvelope.Deserialize(bytes, messageClient);
envelope.Exchange = exchange;
envelope.DeliveryTag = deliveryTag;
envelope.Redelivered = redelivered;
envelope.RoutingKey = routingKey;
envelope.BasicProperties = basicProperties;
if (basicProperties != null && basicProperties.Headers != null)
{
List <MessageTag> tags = new List <MessageTag>();
foreach (var key in basicProperties.Headers.Keys)
{
tags.Add(MessageTag.DemangleTag(key));
}
envelope.Tags = tags.ToArray();
}
return(envelope);
}
private void GetNextMessage()
{
messageTag = 0;
messageSize = 0;
state = ProcessingState.MCS_TAG_AND_SIZE;
var oldStream = dataStream;
// release the memory for read bytes
long unreadBytesCount = dataStream.UnreadBytesCount();
if (unreadBytesCount > 0)
{
byte[] unreadBytes = new byte[unreadBytesCount];
dataStream.Read(unreadBytes, 0, unreadBytes.Length);
dataStream = new MemoryStream(unreadBytes);
}
else
{
dataStream = new MemoryStream();
}
oldStream.Dispose();
}
public UnknownFieldString(MessageTag tag, MessageReader reader)
: base(tag, reader.CreateSubReader().ReadString())
{
}
public UnknownFieldVarint(MessageTag tag, long value)
: base(tag, value)
{
}
public UnknownFieldVarint(MessageTag tag, MessageReader reader)
: base(tag, reader.ReadInt64())
{
}
public static dynamic EntitytoJSON(dynamic entity, Type type)
{
if (type == typeof(Channel))
{
Channel channel = (Channel)entity;
return(new {
id = channel.ThreadId,
slug = channel.Slug,
title = channel.Title,
type = EnumToString(channel.Type, typeof(Channel.Types)),
description = channel.Description,
membership = EntitytoJSON(channel.Membership, typeof(Membership)),
memberships = EntitytoJSON(channel.Memberships ?? new Membership[] { }, typeof(Membership[])),
manager_user = channel.ManagerUser,
manager_details = EntitytoJSON(channel.ManagerDetails, typeof(User)),
members = channel.Members
});
}
else if (type == typeof(Channel[]))
{
List <dynamic> channels = new List <dynamic>();
foreach (var channel in (entity as Channel[]))
{
channels.Add(EntitytoJSON(channel, typeof(Channel)));
}
return(channels.ToArray());
}
else if (type == typeof(FriendRequest))
{
FriendRequest friendrequest = (FriendRequest)entity;
return(new {
requester = friendrequest.Requester,
addresser = friendrequest.Addresser,
friend_detail = EntitytoJSON(friendrequest.FriendDetails, typeof(User)),
request_date = friendrequest.RequestDate.ToUniversalTime(),
approval_date = friendrequest.ApprovalDate.ToUniversalTime(),
friendship_end_date = friendrequest.FriendshipEndDate.ToUniversalTime(),
active = friendrequest.Active
});
}
else if (type == typeof(FriendRequest[]))
{
List <dynamic> friendrequests = new List <dynamic>();
foreach (var friendrequest in (entity as FriendRequest[]))
{
friendrequests.Add(EntitytoJSON(friendrequest, typeof(FriendRequest)));
}
return(friendrequests);
}
else if (type == typeof(Entities.Friendship))
{
Entities.Friendship friendship = (Entities.Friendship)entity;
return(new {
id = friendship.FriendshipId,
requester_user = friendship.Requester,
addresser_user = friendship.Addresser,
request_date = friendship.RequestDate.ToUniversalTime(),
approval_date = friendship.ApprovalDate.ToUniversalTime(),
friendship_end_date = friendship.FriendshipEndDate.ToUniversalTime(),
active = friendship.Active
});
}
else if (type == typeof(Entities.Friendship[]))
{
List <dynamic> friendships = new List <dynamic>();
foreach (var friendship in (entity as Entities.Friendship[]))
{
friendships.Add(EntitytoJSON(friendship, typeof(Entities.Friendship)));
}
return(friendships.ToArray());
}
else if (type == typeof(Membership))
{
Membership membership = (Membership)entity;
return(new {
id = membership.MembershipId,
thread = membership.ThreadId,
user = membership.UserId,
last_seen_date = membership.LastSeenDate.ToUniversalTime(),
last_seen_message = membership.LastSeenMessageId,
active = membership.IsParticipant,
join_date = membership.JoinDate.ToUniversalTime(),
user_details = EntitytoJSON(membership.UserDetails, typeof(User)),
unchecked_count = membership.UncheckedCount
});
}
else if (type == typeof(Membership[]))
{
List <dynamic> memberships = new List <dynamic>();
foreach (var membership in (entity as Membership[]))
{
memberships.Add(EntitytoJSON(membership, typeof(Membership)));
}
return(memberships.ToArray());
}
else if (type == typeof(Message))
{
Message message = (Message)entity;
return(new {
id = message.MessageId,
thread = message.ThreadId,
user_sender = message.UserId,
contents = message.Contents,
sent_date = message.SentDate.ToUniversalTime(),
type = EnumToString(message.Type, typeof(Message.Types)),
tags = EntitytoJSON(message.Tags ?? new MessageTag[] { }, typeof(MessageTag[]))
});
}
else if (type == typeof(Message[]))
{
List <dynamic> messages = new List <dynamic>();
foreach (var message in (entity as Message[]))
{
messages.Add(JSONtoEntity(message, typeof(Message)));
}
return(messages.ToArray());
}
else if (type == typeof(MessageTag))
{
MessageTag tag = (MessageTag)entity;
return(new {
tagger_user = tag.TaggedUserId,
message = tag.MessageId,
placeholder_position = tag.PlaceholderPosition,
tagged_user_details = EntitytoJSON(tag.TaggedUserDetails, typeof(User))
});
}
else if (type == typeof(MessageTag[]))
{
List <dynamic> messagetags = new List <dynamic>();
foreach (var messagetag in (entity as MessageTag[]))
{
messagetags.Add(JSONtoEntity(messagetag, typeof(MessageTag)));
}
return(messagetags.ToArray());
}
else if (type == typeof(PrivateDiscussion))
{
PrivateDiscussion privatediscussion = (PrivateDiscussion)entity;
return(new {
id = privatediscussion.ThreadId,
slug = privatediscussion.Slug,
title = privatediscussion.Title,
type = EnumToString(privatediscussion.Type, typeof(PrivateDiscussion.Types)),
description = privatediscussion.Description,
creator_user = privatediscussion.CreatorUser,
manager_user = privatediscussion.ManagerUser,
manager_details = EntitytoJSON(privatediscussion.ManagerDetails, typeof(User)),
membership = EntitytoJSON(privatediscussion.Membership, typeof(Membership)),
memberships = EntitytoJSON(privatediscussion.Memberships, typeof(Membership[])),
interlocutor_membership = EntitytoJSON(privatediscussion.InterlocutorMembership, typeof(Membership))
});
}
else if (type == typeof(PrivateDiscussion[]))
{
List <dynamic> privatediscussions = new List <dynamic>();
foreach (var privatediscussion in (entity as PrivateDiscussion[]))
{
privatediscussions.Add(EntitytoJSON(privatediscussion, typeof(PrivateDiscussion)));
}
return(privatediscussions.ToArray());
}
else if (type == typeof(Thread))
{
Thread thread = (Thread)entity;
return(new {
id = thread.ThreadId,
slug = thread.Slug,
title = thread.Title,
type = EnumToString(thread.Type, typeof(Thread.Types)),
description = thread.Description,
creator_user = thread.CreatorUser,
manager_user = thread.ManagerUser,
manager_details = EntitytoJSON(thread.ManagerDetails, typeof(User)),
membership = EntitytoJSON(thread.Membership, typeof(Membership)),
memberships = EntitytoJSON(thread.Memberships, typeof(Membership[]))
});
}
else if (type == typeof(Thread[]))
{
List <dynamic> threads = new List <dynamic>();
foreach (var thread in (entity as Thread[]))
{
threads.Add(EntitytoJSON(thread, typeof(PrivateDiscussion)));
}
return(threads.ToArray());
}
else if (type == typeof(User))
{
User user = (User)entity;
return(new {
id = user.UserId,
username = user.Username,
first_name = user.FirstName,
last_name = user.LastName,
type = EnumToString(user.Type, typeof(User.Types)),
});
}
else if (type == typeof(User[]))
{
List <dynamic> users = new List <dynamic>();
foreach (var user in (entity as User[]))
{
users.Add(EntitytoJSON(user, typeof(User)));
}
return(users.ToArray());
}
else
{
throw new Exception("Unhandled Type " + type.ToString());
}
}
public UnknownFieldString(MessageTag tag, MessageReader reader)
: base(tag, reader.CreateSubReader().ReadString())
{
}
public byte[] ToMessage(ILTag payload)
{
var payloadBytes = payload.EncodedBytes;
return(MessageTag.AsILInt().Append(((ulong)payloadBytes.Length).AsILInt()).Append(payloadBytes));
}
public Request(Sim author, MessageTag message)
{
AuthorTag = author.Behavior.Tag;
Message = message;
Author = author;
}
public UnknownFieldFixed32(MessageTag tag, MessageReader reader)
: base(tag, reader.ReadFixedInt32())
{
}
public UnknownFieldGroup(MessageTag tag, MessageReader reader)
: base(tag, ReadGroup(tag, reader))
{
}
/// <summary>
/// Write the tag serialized data using the supplied writer.
/// </summary>
/// <remarks>
/// This is a really KLUDGY routine. Even though it deals with primitive
/// types it has knowledge of what those types mean. For example the UInt16ArrayTag
/// doesn't have a length value written, but the UInt32ArrayTag does. This is
/// a very brittle solution to this problem and needs to be fixed. The solution is
/// to have a serialize method for each tag type (uggh) - so you see why I took
/// this shortcut.
/// </remarks>
/// <param name="tag"></param>
/// <param name="writer"></param>
private static void SerializeTag(BBeBTag tag, BBeBinaryWriter writer)
{
ushort id = (ushort)(0xf500 + tag.Id);
if (tag.GetType() == typeof(ByteTag))
{
ByteTag t = (ByteTag)tag;
writer.Write(id);
writer.Write(t.Value);
}
else if (tag.GetType() == typeof(StreamTagGroup))
{
StreamTagSerializer.Serialize(writer, (StreamTagGroup)tag);
}
else if (tag.GetType() == typeof(ByteArrayTag))
{
ByteArrayTag t = (ByteArrayTag)tag;
if (t.Id == TagId.StreamStart)
{
byte[] data = t.Value;
writer.Write(BBeBLib.TagId.StreamSize);
writer.Write((uint)data.Length);
writer.Write(id);
writer.Write(data);
writer.Write(BBeBLib.TagId.StreamEnd);
}
else
{
writer.Write(id);
writer.Write(t.Value);
}
}
else if (tag.GetType() == typeof(UInt16Tag))
{
UInt16Tag t = (UInt16Tag)tag;
writer.Write(id);
writer.Write(t.Value);
}
else if (tag.GetType() == typeof(UInt16ArrayTag))
{
UInt16ArrayTag t = (UInt16ArrayTag)tag;
writer.Write(id);
foreach (ushort val in t.Value)
{
writer.Write(val);
}
}
else if (tag.GetType() == typeof(UInt32Tag))
{
UInt32Tag t = (UInt32Tag)tag;
// StreamSize is written out by the StreamStart tag as the data may be compressed
if (t.Id != TagId.StreamSize)
{
writer.Write(id);
// Zero byte tags (but have hardcoded data associated with them
if (t.Id != TagId.BaseButtonStart &&
t.Id != TagId.FocusinButtonStart &&
t.Id != TagId.PushButtonStart &&
t.Id != TagId.UpButtonStart)
{
writer.Write(t.Value);
}
}
}
else if (tag.GetType() == typeof(UInt32ArrayTag))
{
UInt32ArrayTag t = (UInt32ArrayTag)tag;
writer.Write(id);
// JumpTo doesn't have a length set and is hardcoded to 2!
if (t.Id != TagId.JumpTo)
{
writer.Write((ushort)t.Value.Length);
}
foreach (uint val in t.Value)
{
writer.Write(val);
}
}
else if (tag.GetType() == typeof(StringTag))
{
StringTag t = (StringTag)tag;
writer.Write(id);
writer.Write(t.Value);
}
else if (tag.GetType() == typeof(MessageTag))
{
MessageTag t = (MessageTag)tag;
writer.Write(id);
writer.Write((ushort)t.parameters);
byte[] data = System.Text.Encoding.Unicode.GetBytes(t.param1);
writer.Write((ushort)data.Length);
writer.Write(data);
data = System.Text.Encoding.Unicode.GetBytes(t.param2);
writer.Write((ushort)data.Length);
writer.Write(data);
}
else if (tag.GetType() == typeof(EmpDotsCodeTag))
{
EmpDotsCodeTag t = (EmpDotsCodeTag)tag;
writer.Write(id);
writer.Write((uint)t.Value);
SerializeTag(t.FontFace, writer);
writer.Write(t.DotsCode);
}
else if (tag.GetType() == typeof(IDOnlyTag))
{
IDOnlyTag t = (IDOnlyTag)tag;
if (t.Id != TagId.StreamEnd)
{
writer.Write(id);
}
}
else if (tag.GetType() == typeof(BBeBTag))
{
BBeBTag t = (BBeBTag)tag;
if (t.Id != TagId.StreamEnd)
{
writer.Write(id);
}
}
else
{
Debug.Assert(false, "Unknown tag type: " + tag.GetType().ToString());
}
}
public UnknownFieldVarint(MessageTag tag, MessageReader reader)
: base(tag, reader.ReadInt64())
{
}
public UnknownFieldFixed32(MessageTag tag, MessageReader reader)
: base(tag, reader.ReadFixedInt32())
{
}
public UnknownFieldVarint(MessageTag tag, long value)
: base(tag, value)
{
}
public UnknownFieldGroup(MessageTag tag, MessageReader reader)
: base(tag, ReadGroup(tag, reader))
{
}
