Esempio n. 1
0
        /// <summary>
        /// Return a new <see cref="IReadable"/> for supplied <see cref="ClientRawOpcode"/>.
        /// </summary>
        public static IReadable CreateRawMessage(ClientRawOpcode opcode)
        {
            if (!rawMessageFactories.TryGetValue(opcode, out RawMessageFactory factory))
            {
                log.Warn($"Received unknown raw opcode 0x{opcode:X}!");
                return(null);
            }

            return(factory.Invoke());
        }
Esempio n. 2
0
        /// <summary>
        /// Invoke message handler delegate for supplied <see cref="ClientRawOpcode"/>.
        /// </summary>
        public static void InvokeRawMessageHandler(NetworkSession session, ClientRawOpcode opcode, IReadable message)
        {
            if (!rawMessageHandlers.TryGetValue(opcode, out RawMessageHandler handler))
            {
                log.Warn($"Received unhandled raw opcode 0x{opcode:X}!");
                return;
            }

            handler.Invoke(session, message);
        }
Esempio n. 3
0
        /// <summary>
        ///
        /// </summary>
        public static void InvokeRawPacketHandler(NetworkSession session, ClientRawOpcode opcode, ClientRawPacket packet)
        {
            if (!rawPacketHandlers.TryGetValue(opcode, out RawPacketHandler handler))
            {
                log.Warn($"Received unhandled raw opcode 0x{opcode:X}!");
                return;
            }

            handler.Invoke(session, packet);
        }
Esempio n. 4
0
        /// <summary>
        ///
        /// </summary>
        private void ProcessRawPacket(byte[] payload)
        {
            using (var stream = new MemoryStream(payload))
            {
                using (var reader = new BinaryReader(stream))
                {
                    ClientRawOpcode opcode = (ClientRawOpcode)reader.ReadPackedUInt32();

                    ClientRawPacket packet = PacketManager.CreateRawPacket(opcode);
                    if (packet != null)
                    {
                        packet.Read(reader);
                        PacketManager.InvokeRawPacketHandler(this, opcode, packet);
                    }
                }
            }
        }
Esempio n. 5
0
        private void ProcessRawPacket(byte[] payload)
        {
            using (var stream = new MemoryStream(payload))
                using (var reader = new BinaryReader(stream))
                {
                    ClientRawOpcode opcode = (ClientRawOpcode)reader.ReadPackedUInt32();

                    IReadable packet = PacketManager.CreateRawMessage(opcode);
                    if (packet == null)
                    {
                        return;
                    }

                    log.Trace($"Received raw packet {opcode}(0x{opcode:X}).");

                    packet.Read(reader);
                    if (stream.Remaining() > 0)
                    {
                        log.Warn($"Failed to read entire contents of packet {opcode}(0x{opcode:X}).");
                    }

                    PacketManager.InvokeRawMessageHandler(this, opcode, packet);
                }
        }
 public RawMessageHandlerAttribute(ClientRawOpcode opcode)
 {
     Opcode = opcode;
 }
Esempio n. 7
0
 public ClientRawPacketAttribute(ClientRawOpcode opcode)
 {
     Opcode = opcode;
 }
Esempio n. 8
0
 public RawPacketHandlerAttribute(ClientRawOpcode opcode)
 {
     Opcode = opcode;
 }