示例#1
0
        private void ProcessServerMessage(string headerJson, string bodyJson, TcpClient client)
        {
            var header = JsonConvert.DeserializeObject <ServerProtocol.PacketHeader>(headerJson);

            if (header.Error != ErrorKind.Ok)
            {
                OnGotError?.Invoke(this, new ErrorEventArgs(header));
                return;
            }
            switch (header.Kind)
            {
            case ServerProtocol.MessageKind.Chat:
                OnGotMessage?.Invoke(this, new ChatEventArgs(header, JsonConvert.DeserializeObject <ServerProtocol.ChatPacket>(bodyJson)));
                break;

            case ServerProtocol.MessageKind.Info:
                OnGotInfo?.Invoke(this, new InfoEventArgs(header, JsonConvert.DeserializeObject <InfoPacket>(bodyJson)));
                break;

            case ServerProtocol.MessageKind.NewBodyOnline:
                OnGotNewBody?.Invoke(this, new NewBodyOnlineEventArgs(header, JsonConvert.DeserializeObject <NewBodyOnlinePacket>(bodyJson)));
                break;

            default:
                throw new InvalidOperationException();
            }
        }
示例#2
0
文件: Client1.cs 项目: AllahEdin/SpSh
        public void ReceiveMessage()
        {
            Byte[] data = new Byte[256];

            int i;

            while ((i = _stream.Read(data, 0, data.Length)) != 0)
            {
                //Int32 bytes = _stream.Read(data, 0, data.Length);
                string dataStr = System.Text.Encoding.ASCII.GetString(data, 0, i);
                Console.WriteLine("Client received: {0}", dataStr);
                Messages.Enqueue(dataStr);
                OnGotMessage?.Invoke();
            }
        }
示例#3
0
        public override void Update(GameTime gameTime)
        {
            WasConnected = IsConnected;

            if (Started)
            {
                if (IsServer)
                {
                    NetIncomingMessage _msg;
                    while ((_msg = _Server.ReadMessage()) != null)
                    {
                        switch (_msg.MessageType)
                        {
                        case NetIncomingMessageType.Data:
                            var _incMsg = ReadMessage(_msg);
                            OnGotMessage?.Invoke(_incMsg);
                            break;

                        case NetIncomingMessageType.VerboseDebugMessage:
                        case NetIncomingMessageType.DebugMessage:
                        case NetIncomingMessageType.WarningMessage:
                        case NetIncomingMessageType.ErrorMessage:
                            Console.WriteLine(_msg.ReadString());
                            break;

                        default:
                            Console.WriteLine("Unhandled type: " + _msg.MessageType);
                            break;
                        }
                        _Server.Recycle(_msg);
                    }
                }
                else
                {
                    NetIncomingMessage _msg;
                    while ((_msg = _Client.ReadMessage()) != null)
                    {
                        switch (_msg.MessageType)
                        {
                        case NetIncomingMessageType.Data:
                            var _incMsg = ReadMessage(_msg);
                            OnGotMessage?.Invoke(_incMsg);
                            break;

                        case NetIncomingMessageType.VerboseDebugMessage:
                        case NetIncomingMessageType.DebugMessage:
                        case NetIncomingMessageType.WarningMessage:
                        case NetIncomingMessageType.ErrorMessage:
                            Console.WriteLine(_msg.ReadString());
                            break;

                        default:
                            Console.WriteLine("Unhandled type: " + _msg.MessageType);
                            break;
                        }
                        _Client.Recycle(_msg);
                    }
                }
            }

            if (IsConnected && !WasConnected)
            {
                OnNewConnection?.Invoke();
            }

            if (!IsConnected && WasConnected)
            {
                OnLostConnection?.Invoke();
            }
        }