public Message Deserialize(Stream stream, out SerializationContext serializationContext) { serializationContext = null; var reader = new StreamReader(stream) { Position = 0 }; var subTypeInfo = this.packetInspector.FindSubType(reader); if (subTypeInfo == null) { return null; } var serializer = this.serializerResolver.GetSerializer(subTypeInfo.Type); if (serializer == null) { return null; } reader.Position = 0; serializationContext = new SerializationContext(this.serializerResolver); var message = new Message { Header = (Header)this.headerSerializer.Deserialize(reader, serializationContext), Body = (MessageBody)serializer.Deserialize(reader, serializationContext) }; return message; }
/// <summary> /// </summary> /// <param name="message"> /// </param> /// <returns> /// </returns> public byte[] Serialize(Message message) { using (var stream = new MemoryStream()) { this.serializer.Serialize(stream, message); return stream.ToArray(); } }
public byte[] Serialize(Message message, out SerializationContext serializationContext) { Contract.Requires<ArgumentNullException>(message != null); Contract.Requires<ArgumentNullException>(message.Header != null); Contract.Requires<ArgumentNullException>(message.Body != null); Contract.Ensures(Contract.Result<byte[]>() != null); Contract.Ensures(Contract.Result<byte[]>().Length >= 16); throw new NotImplementedException(); }
public byte[] Serialize(Message message, out SerializationContext serializationContext) { using (var memoryStream = new MemoryStream()) { this.messageSerializer.Serialize(memoryStream, message, out serializationContext); var buffer = memoryStream.GetBuffer(); if (buffer == null || buffer.Length < 16) { throw new InvalidOperationException(); } return buffer; } }
/// <summary> /// </summary> /// <param name="client"> /// </param> /// <param name="stat"> /// </param> /// <param name="value"> /// </param> /// <param name="announce"> /// </param> public static void Send(IZoneClient client, int stat, uint value, bool announce) { var statMessage = new StatMessage { Identity = client.Character.Identity, Stats = new[] { new GameTuple<CharacterStat, uint> { Value1 = (CharacterStat)stat, Value2 = value } } }; var statM = new Message { Body = statMessage }; if (!client.Character.DoNotDoTimers) { client.Character.Playfield.Publish( new IMSendAOtomationMessageToClient { client = client, message = statM }); } /* announce to playfield? */ if (announce) { client.Character.Playfield.AnnounceOthers(statMessage, client.Character.Identity); } }
public byte[] Serialize(Message message) { SerializationContext ignore; return this.Serialize(message, out ignore); }
/// <summary> /// </summary> /// <param name="sender"> /// </param> /// <param name="message"> /// </param> public MessageReceivedEvent(object sender, Message message) { this.sender = sender; this.message = message; }
/// <summary> /// </summary> /// <param name="sender"> /// </param> /// <param name="message"> /// </param> public void Publish(object sender, Message message) { IList<IHandleMessage> handlers; if (this.messageHandlers.TryGetValue(message.Body.GetType(), out handlers) == false) { return; } foreach (IHandleMessage handler in handlers) { handler.Handle(sender, message); } }
static void savePacket(int srcPort, Message message, Stream data) { if (message != null) { Console.WriteLine(srcPort+" "+message.Body.GetType().Name+" size="+message.Header.Size); //What packet do you get when you literally walk away from a conversation? Change playfield? //Can you have multiple conversations simultaneously? //You still need to fix your TCP parser to reassemble packets (erp) //What about timing information (for animations and reponses)? (probably also requires refactoring) if (message.Body is KnuBotOpenChatWindowMessage){ KnuBotOpenChatWindowMessage body = (KnuBotOpenChatWindowMessage)message.Body; string conversationIdentity = body.Identity.Instance.ToString(); Console.WriteLine(" Begin conversation with " +conversationIdentity); }else if(message.Body is KnuBotAnswerListMessage) { KnuBotAnswerListMessage body = (KnuBotAnswerListMessage)message.Body; Console.WriteLine(" Dialog Options: "); foreach(var option in body.DialogOptions){ Console.WriteLine(" - "+option.Text); } }else if(message.Body is KnuBotAnswerMessage){ KnuBotAnswerMessage body = (KnuBotAnswerMessage)message.Body; string conversationIdentity = body.Identity.Instance.ToString(); Console.WriteLine("Answered with option: " + body.Answer); Console.WriteLine("ok?"); }else if(message.Body is KnuBotAppendTextMessage){ KnuBotAppendTextMessage body = (KnuBotAppendTextMessage)message.Body; string conversationIdentity = body.Identity.Instance.ToString(); Console.WriteLine(conversationIdentity + " says: " + body.Text); Console.WriteLine("ok?"); }else if(message.Body is CharacterActionMessage){ CharacterActionMessage body = (CharacterActionMessage)message.Body; string identity = body.Identity.Instance.ToString(); Console.WriteLine(" Character " + identity + " performs action "+body.Action.ToString()); } } else { data.Position = 0; byte[] buffer = new byte[20]; int countRead = data.Read(buffer, 0, buffer.Length); bool allZero = true; foreach (byte b in buffer) { if (b != 0) { allZero = false; break; } } if (countRead <= 0) { Console.WriteLine(srcPort + " Could not deserialize: EMPTY PACKET"); } else if (allZero) { Console.WriteLine(srcPort + " Could not deserialize: ZEROES EVERYWHERE"); } else if (countRead > 0) { Console.WriteLine(srcPort + " Could not deserialize, unknown packet: " + BitConverter.ToString(buffer)); } else { Console.WriteLine(srcPort + " Could not deserialize, empty packet"); } } }
/// <summary> /// </summary> /// <param name="message"> /// </param> /// <exception cref="NotImplementedException"> /// </exception> public void Announce(Message message) { Announce(message.Body); }
private void OnSendCallback(Message message, byte[] packet, Action resumeHook) { Contract.Requires(packet != null); Contract.Requires(resumeHook != null); Contract.Requires(this.client != null); Contract.Requires(this.actionExecutionContext != null); if (message == null || message.Body == null) { this.bus.Publish(new PacketSentEvent(this.id, packet)); return; } this.triggerHandler.ExecuteTriggerActions(message.Body, resumeHook, this.actionExecutionContext); this.bus.Publish(new PacketSentEvent(this.id, packet)); }
public void Serialize(Stream stream, Message message) { Contract.Requires<ArgumentNullException>(stream != null); Contract.Requires<ArgumentNullException>(message != null); throw new NotImplementedException(); }
public void Serialize(Stream stream, Message message) { this.messageSerializer.Serialize(stream, message); }
public void Serialize(Stream stream, Message message, out SerializationContext serializationContext) { serializationContext = null; var serializer = this.serializerResolver.GetSerializer(message.Body.GetType()); if (serializer == null) { return; } serializationContext = new SerializationContext(this.serializerResolver); var writer = new StreamWriter(stream) { Position = 0 }; this.headerSerializer.Serialize(writer, serializationContext, message.Header); serializer.Serialize(writer, serializationContext, message.Body); var length = writer.Position; writer.Position = 6; writer.WriteInt16((short)length); }
public void Serialize(Stream stream, Message message) { SerializationContext ignore; this.Serialize(stream, message, out ignore); }