public static Optional <SizeData> TryParse(IBinaryMessage message)
{
return(message.TryParse(Name, reader =>
new SizeData(
new Size <Points>(reader.ReadInt32(), reader.ReadInt32()),
reader.ReadDouble())
));
}
public static byte[] DumpBytes(this IBinaryMessage message)
{
using (var buffer = new MemoryStream())
using (var writer = new BinaryWriter(buffer))
{
message.WriteDataTo(writer);
return(buffer.ToArray());
}
}
long LengthOf(IBinaryMessage message)
{
using (var stream = new MemoryStream())
using (var writer = new BinaryWriter(stream))
{
message.WriteTo(writer);
return(stream.Length);
}
}
public static CoalesceEntry ToCoalesceEntry(
this IBinaryMessage message, string coalesceKey, bool addFirst = false)
{
return(new CoalesceEntry()
{
BlobData = Optional.Some(message),
CoalesceKey = coalesceKey,
AddFirst = addFirst
});
}
static string GetMessageAsBase64ForUseInTestProcess(IBinaryMessage msg)
{
using (var m = new MemoryStream())
using (var w = new BinaryWriter(m))
{
msg.WriteTo(w);
m.Seek(0, SeekOrigin.Begin);
return(Convert.ToBase64String(m.GetBuffer(), 0, (int)m.Length));
}
}
public static Optional <NSEvent> TryParse(IBinaryMessage message)
{
return(message.TryParse(Name, reader =>
{
var length = reader.ReadInt32();
var data = reader.ReadBytes(length);
var nsData = NSData.FromArray(data);
return (NSEvent)NSKeyedUnarchiver.UnarchiveObject(nsData);
}));
}
public void Send(IBinaryMessage msg)
{
lock (_messages)
{
_messages.Enqueue(msg);
if (!_sendThreadActive)
{
_sendThreadActive = true;
ThreadPool.QueueUserWorkItem(o => SendThread());
}
}
}
public void OnCustomMessage(uint sourceId, IBinaryMessage message)
{
var handler = CustomMessage;
if (handler != null)
{
handler(this, new ServerProtocolMessageEventArgs {
DynamicId = sourceId,
Message = message
});
}
}
public static extern void WriteTo(this IBinaryMessage message, BinaryWriter writer)
{
using (var buffer = new Uno.IO.MemoryStream())
using (var bufferWriter = new BinaryWriter(buffer))
{
message.WriteDataTo(bufferWriter);
var length = (int)buffer.Position;
writer.Write(message.Type);
writer.Write(length);
writer.Write(buffer.GetBuffer().SubArray(0, length));
}
}
/// <summary>
/// Sends a message to every connected and authorized client
/// </summary>
/// <param name="message">a message to send</param>
public void Broadcast(IBinaryMessage message)
{
lock (_syncRoot)
{
foreach (var connection in _connections.Values)
{
if (connection.Authorized)
{
connection.Send(message);
}
}
}
}
public static void WriteBuildEvent(this ColoredTextWriter output, IBinaryMessage buildEvent)
{
buildEvent.DoSome(
(BuildLogged logEvent) =>
{
using (output.PushColor(logEvent.Color == System.ConsoleColor.Red ? System.ConsoleColor.Red : (System.ConsoleColor?)null))
output.Write(logEvent.Text);
},
(BuildIssueDetected arg) =>
{
using (output.PushColor(ToColor(arg.Severity)))
{
output.WriteLine(arg.ToString().StripSuffix("\n"));
}
});
}
public static Optional <T> TryParse <T>(this IBinaryMessage message, string type, Func <BinaryReader, T> action)
{
if (type != message.Type)
{
return(Optional.None <T>());
}
using (var buffer = new Uno.IO.MemoryStream())
using (var bufferWriter = new BinaryWriter(buffer))
using (var bufferReader = new BinaryReader(buffer))
{
message.WriteDataTo(bufferWriter);
buffer.Seek(0, Uno.IO.SeekOrigin.Begin);
return(action(bufferReader));
}
throw new Exception("It has happened.");
}
public override void RetranslateMessage(IBinaryMessage message)
{
base.RetranslateMessage(message);
{
var msg = message as EntityHealthMessage;
if (msg != null)
{
_playerCharacter.HealthImpact(msg.Change);
return;
}
}
{
var msg = message as EntityHealthStateMessage;
if (msg != null)
{
_playerCharacter.HealthState = msg.HealthState;
if (msg.HealthState == DynamicEntityHealthState.Normal)
{
_playerCharacter.DisplacementMode = EntityDisplacementModes.Walking;
}
return;
}
}
{
var msg = message as EntityAfflictionStateMessage;
if (msg != null)
{
_playerCharacter.Afflictions = msg.AfflictionState;
return;
}
}
}
//Analyse Network Message, and if needed Inject Field to the passed in Object
public void ProcessMessage(IBinaryMessage imsg)
{
switch ((MessageTypes)imsg.MessageId)
{
case MessageTypes.EntityData:
{
var msg = (EntityDataMessage)imsg;
if (msg.Entity != null)
{
PrepareEntity(msg.Entity);
}
}
break;
case MessageTypes.EntityIn:
{
var msg = (EntityInMessage)imsg;
if (msg.Entity != null)
{
PrepareEntity(msg.Entity);
}
}
break;
case MessageTypes.EntityEquipment:
{
var msg = (EntityEquipmentMessage)imsg;
if (msg.Entity != null)
{
PrepareEntity(msg.Entity);
}
}
break;
}
}
protected abstract void OnMessage(IBinaryMessage msg);
public static Optional <FocusState> TryParse(IBinaryMessage message)
{
return(message.TryParse(Type, reader =>
(FocusState)reader.ReadInt32()));
}
/// <summary>
/// Invokes required event from Received network Messages
/// </summary>
/// <param name="msg"></param>
private void InvokeEventForNetworkDataReceived(IBinaryMessage msg)
{
EntityFactory.ProcessMessage(msg);
if (msg is ITimeStampedMsg)
{
((ITimeStampedMsg)msg).MessageRecTime = DateTime.Now;
}
if ((MessageTypes)msg.MessageId != MessageTypes.BlockChange)
{
OnMessageBlockChange(_blocksChangedMessageBuffer.Flush(0, true));
}
switch ((MessageTypes)msg.MessageId)
{
case MessageTypes.Login:
OnMessageLogin((LoginMessage)msg);
break;
case MessageTypes.Chat:
OnMessageChat((ChatMessage)msg);
break;
case MessageTypes.Error:
OnMessageError((ErrorMessage)msg);
break;
case MessageTypes.DateTime:
OnMessageDateTime((DateTimeMessage)msg);
break;
case MessageTypes.GameInformation:
OnMessageGameInformation((GameInformationMessage)msg);
break;
case MessageTypes.BlockChange:
_blocksChangedMessageBuffer.Add((BlocksChangedMessage)msg);
break;
case MessageTypes.EntityPosition:
OnMessagePosition((EntityPositionMessage)msg);
break;
case MessageTypes.EntityDirection:
OnMessageDirection((EntityHeadDirectionMessage)msg);
break;
case MessageTypes.ChunkData:
OnMessageChunkData((ChunkDataMessage)msg);
break;
case MessageTypes.EntityIn:
OnMessageEntityIn((EntityInMessage)msg);
break;
case MessageTypes.EntityOut:
OnMessageEntityOut((EntityOutMessage)msg);
break;
case MessageTypes.LoginResult:
OnMessageLoginResult((LoginResultMessage)msg);
break;
case MessageTypes.EntityUse:
OnMessageEntityUse((EntityUseMessage)msg);
break;
case MessageTypes.Ping:
OnMessagePing((PingMessage)msg);
break;
case MessageTypes.EntityVoxelModel:
OnMessageEntityVoxelModel((EntityVoxelModelMessage)msg);
break;
case MessageTypes.ItemTransfer:
OnMessageItemTransfer((ItemTransferMessage)msg);
break;
case MessageTypes.EntityEquipment:
OnMessageEntityEquipment((EntityEquipmentMessage)msg);
break;
case MessageTypes.Weather:
OnMessageWeather((WeatherMessage)msg);
break;
case MessageTypes.EntityImpulse:
OnMessageEntityImpulse((EntityImpulseMessage)msg);
break;
case MessageTypes.EntityLock:
OnMessageEntityLockResult((EntityLockMessage)msg);
break;
case MessageTypes.EntityLockResult:
OnMessageEntityLockResult((EntityLockResultMessage)msg);
break;
case MessageTypes.UseFeedback:
OnMessageUseFeedback((UseFeedbackMessage)msg);
break;
case MessageTypes.EntityData:
OnMessageEntityData((EntityDataMessage)msg);
break;
case MessageTypes.EntityHealth:
OnMessageEntityHealth((EntityHealthMessage)msg);
break;
case MessageTypes.EntityHealthState:
OnMessageEntityHealthState((EntityHealthStateMessage)msg);
break;
case MessageTypes.EntityAfflictionState:
OnMessageEntityAfflictionState((EntityAfflictionStateMessage)msg);
break;
default:
throw new ArgumentOutOfRangeException("msg", "Invalid message received from server");
}
}
public void Send(IBinaryMessage message)
{
_send(message);
}
protected override void OnMessage(IBinaryMessage message)
{
switch ((MessageTypes)message.MessageId)
{
case MessageTypes.Login:
OnMessageLogin((LoginMessage)message);
break;
case MessageTypes.Chat:
OnMessageChat((ChatMessage)message);
break;
case MessageTypes.GetChunks:
OnMessageGetChunks((GetChunksMessage)message);
break;
case MessageTypes.EntityPosition:
OnMessagePosition((EntityPositionMessage)message);
break;
case MessageTypes.EntityDirection:
OnMessageDirection((EntityHeadDirectionMessage)message);
break;
case MessageTypes.EntityUse:
OnMessageEntityUse((EntityUseMessage)message);
break;
case MessageTypes.Ping:
OnMessagePing((PingMessage)message);
break;
case MessageTypes.EntityVoxelModel:
OnMessageEntityVoxelModel((EntityVoxelModelMessage)message);
break;
case MessageTypes.ItemTransfer:
OnMessageItemTransfer((ItemTransferMessage)message);
break;
case MessageTypes.EntityEquipment:
OnMessageEntityEquipment((EntityEquipmentMessage)message);
break;
case MessageTypes.EntityImpulse:
OnMessageEntityImpulse((EntityImpulseMessage)message);
break;
case MessageTypes.EntityLock:
OnMessageEntityLock((EntityLockMessage)message);
break;
case MessageTypes.RequestDateTimeSync:
OnMessageRequestDateTimeSync((RequestDateTimeSyncMessage)message);
break;
case MessageTypes.EntityIn:
OnMessageEntityIn((EntityInMessage)message);
break;
case MessageTypes.GetEntity:
OnMessageGetEntity((GetEntityMessage)message);
break;
case MessageTypes.EntityHealth:
OnMessageEntityHealth((EntityHealthMessage)message);
break;
case MessageTypes.EntityHealthState:
OnMessageEntityHealthState((EntityHealthStateMessage)message);
break;
case MessageTypes.EntityAfflictionState:
OnMessageEntityAfflictionState((EntityAfflictionStateMessage)message);
break;
default:
throw new ArgumentException("Invalid message id");
}
}
public static Optional <OpenGlVersion> TryParse(IBinaryMessage message)
{
return(message.TryParse(Type, reader =>
new OpenGlVersion(reader.ReadString(), reader.ReadString(), reader.ReadString())));
}
public static Optional <bool> TryParse(IBinaryMessage message)
{
return(message.TryParse(Type, reader => reader.ReadBoolean()));
}
/// <summary>
/// Retranslates message to the current area
/// </summary>
/// <param name="message"></param>
public virtual void RetranslateMessage(IBinaryMessage message)
{
CurrentArea.OnCustomMessage(DynamicEntity.DynamicId, message);
}
public static Optional <int> TryParse(IBinaryMessage message)
{
return(message.TryParse(Type, reader => reader.ReadInt32()));
}
public static Optional <IntPtr> TryParse(IBinaryMessage message)
{
return(message.TryParse(Type, reader =>
new IntPtr(reader.ReadInt32())));
}
