Example #1
0
        /// <summary>Received some data from a client, let's see what we got.</summary>
        protected override void HandleUdpData(object sender, ProtocolDataEventArgs e)
        {
            // Get the message type.
            if (!e.Data.HasByte())
            {
                Logger.Warn("Received invalid packet, no SessionMessage type.");
                return;
            }
            var type = (SessionMessage)e.Data.ReadByte();

            // Get additional data.
            // TODO what happens with data?
            using (var data = e.Data.ReadPacketizable <Packet>())
            {
                switch (type)
                {
                case SessionMessage.GameInfoRequest:
                    // Game info was requested. Wrap it up and send it to the one asking.
                {
                    using (var requestArgs = new RequestEventArgs())
                    {
                        OnGameInfoRequested(requestArgs);     //< Get custom data to send, if any.
                        using (var packet = new Packet())
                        {
                            using (var packetInner = new Packet())
                            {
                                packetInner
                                .Write(MaxPlayers)
                                .Write(PlayerCount)
                                .Write(requestArgs.Data);
                                packet
                                .Write((byte)SessionMessage.GameInfoResponse)
                                .Write((IWritablePacket)packetInner);
                                Udp.Send(
                                    packet,
                                    e.RemoteEndPoint);
                            }
                        }
                    }
                }
                break;

                // Ignore the rest.
                default:
                    Logger.Trace("Unknown SessionMessage via UDP: {0}.", type);
                    break;
                }
            }
        }
Example #2
0
 /// <summary>Received some data from a client, let's see what we got.</summary>
 protected abstract void HandleUdpData(object sender, ProtocolDataEventArgs e);
Example #3
0
        /// <summary>Received some data from a client, let's see what we got.</summary>
        protected override void HandleUdpData(object sender, ProtocolDataEventArgs e)
        {
            // Get the message type.
            if (!e.Data.HasByte())
            {
                Logger.Warn("Received invalid packet, no SessionMessage type.");
                return;
            }
            var type = (SessionMessage)e.Data.ReadByte();

            // Get additional data.
            using (var packet = e.Data.ReadPacketizable <Packet>())
            {
                switch (type)
                {
                case SessionMessage.GameInfoResponse:
                    // Got some info on a running game. We only care if we're not in a game.
                    if (ConnectionState == ClientState.Unconnected)
                    {
                        if (packet == null)
                        {
                            // Bad data.
                            Logger.Warn("Invalid GameInfoResponse (no data).");
                        }
                        else
                        {
                            try
                            {
                                // Get number of max players.
                                var maxPlayers = packet.ReadInt32();

                                // Get number of current players.
                                var playerCount = packet.ReadInt32();

                                // Get additional data.
                                using (var customData = packet.ReadPacketizable <Packet>())
                                {
                                    Logger.Trace(
                                        "Got game info from host '{0}': {1}/{2} players, data of length {3}.",
                                        e.RemoteEndPoint,
                                        playerCount,
                                        maxPlayers,
                                        customData.Length);

                                    // Propagate to local program.
                                    OnGameInfoReceived(
                                        new GameInfoReceivedEventArgs(
                                            e.RemoteEndPoint,
                                            playerCount,
                                            maxPlayers,
                                            customData));
                                }
                            }
                            catch (PacketException ex)
                            {
                                // Bad data.
                                Logger.WarnException("Invalid GameInfoResponse.", ex);
                            }
                        }
                    }
                    break;

                case SessionMessage.Data:
                    // Custom data, just forward it if we're in a session.
                    if (ConnectionState == ClientState.Connected)
                    {
                        try
                        {
                            OnData(
                                new ClientDataEventArgs(
                                    packet, _tcp != null && Equals(e.RemoteEndPoint, _tcp.Client.RemoteEndPoint)));
                        }
                        catch (PacketException ex)
                        {
                            Logger.WarnException("Invalid Data.", ex);
                        }
                    }
                    break;

                // Nothing else is handled via UDP.
                default:
                    Logger.Debug("Unknown SessionMessage via UDP: {0}.", type);
                    break;
                }
            }
        }