Example #1
0
 public Tlv(SocketMessageTypes type, Guid guid)
 {
     Type = (byte)((int)type);
     byte[] bytes = guid.ToByteArray();
     // We need to change the format since the server
     // use uuid
     Array.Reverse(bytes, 0, 4);
     Array.Reverse(bytes, 4, 2);
     Array.Reverse(bytes, 6, 2);
     Value = bytes;
 }
Example #2
0
        private dynamic RetreiveData(SocketMessageTypes type, byte[] bytes)
        {
            switch (type)
            {
            //Raw bytes
            case SocketMessageTypes.ServerConnectionResponse:
            case SocketMessageTypes.ServerStrokeSent:
            case SocketMessageTypes.ServerStartsDrawing:
            case SocketMessageTypes.ServerEndsDrawing:
            case SocketMessageTypes.LobbyDeleted:
            case SocketMessageTypes.UserDeletedStroke:
                return(bytes);

            //Message pack;
            default:
                return(MessagePackSerializer.Deserialize <dynamic>(bytes, ContractlessStandardResolver.Options));
            }
        }
Example #3
0
 public Tlv(SocketMessageTypes type, byte[] bytes)
 {
     Type  = (byte)(int)type;
     Value = bytes;
 }
Example #4
0
 /// <summary>
 /// Convert the message in byte
 /// </summary>
 /// <param name="type"></param>
 /// <param name="message"></param>
 public Tlv(SocketMessageTypes type, string message)
 {
     Type  = (byte)((int)type);
     Value = Encoding.UTF8.GetBytes(message);
 }
Example #5
0
 /// <summary>
 /// Serialize the message using message pack
 /// </summary>
 /// <param name="type"></param>
 /// <param name="message"></param>
 public Tlv(SocketMessageTypes type, dynamic message)
 {
     Type  = (byte)((int)type);
     Value = MessagePackSerializer.Serialize(message, ContractlessStandardResolver.Options);
 }
Example #6
0
 public Tlv(SocketMessageTypes type)
 {
     Type = (byte)((int)type);
 }
Example #7
0
        private void MessagesListener()
        {
            byte[]  typeAndLength = new byte[3];
            dynamic data          = null;

            //TODO cancel the Task using a token
            while (_socket.Connected)
            {
                try
                {
                    // Read the type and the length
                    int count = 0;
                    while (count < 3)
                    {
                        count += _stream.Read(typeAndLength, count, 3 - count);
                    }

                    SocketMessageTypes type = (SocketMessageTypes)typeAndLength[0];
                    int length = (typeAndLength[1] << 8) + typeAndLength[2];
                    if (length > 0)
                    {
                        //Read the data
                        byte[] bytes = new byte[length];
                        count = 0;
                        while (count < length)
                        {
                            count += _stream.Read(bytes, count, length - count);
                        }

                        data = RetreiveData(type, bytes);
                    }

                    System.Diagnostics.Debug.WriteLine($"socket <--- [{type}]");
                    switch (type)
                    {
                    case SocketMessageTypes.ServerConnectionResponse:
                        OnConnectionResponse(this);
                        break;

                    case SocketMessageTypes.ServerDisconnection:
                        OnServerDisconnected(this);
                        break;

                    case SocketMessageTypes.HealthCheck:
                        OnHealthCheck(this);
                        break;

                    case SocketMessageTypes.MessageReceived:
                        OnMessageReceived(this, new ChatEventArgs(data));
                        break;

                    case SocketMessageTypes.UserJoinedChannel:
                        OnUserJoinedChannel(this, new ChatEventArgs(data));
                        break;

                    case SocketMessageTypes.UserLeftChannel:
                        OnUserLeftChannel(this, new ChatEventArgs(data));
                        break;

                    case SocketMessageTypes.UserCreatedChannel:
                        OnUserCreatedChannel(this, new ChatEventArgs(data));
                        break;

                    case SocketMessageTypes.UserDeletedChannel:
                        OnUserDeletedChannel(this, new ChatEventArgs(data));
                        break;

                    case SocketMessageTypes.ServerStrokeSent:
                        OnServerStrokeSent(this, new StrokeSentEventArgs(data));
                        break;

                    case SocketMessageTypes.ServerStartsDrawing:
                        OnServerStartsDrawing(this, new DrawingEventArgs(data));
                        break;

                    case SocketMessageTypes.ServerEndsDrawing:
                        OnServerEndsDrawing(this, new DrawingEventArgs(data));
                        break;

                    case SocketMessageTypes.DrawingPreviewResponse:
                        OnDrawingPreviewResponse(this, new DrawingEventArgs(data));
                        break;

                    case SocketMessageTypes.ServerMessage:
                        OnServerMessage(this, new SocketErrorEventArgs(data));
                        break;

                    case SocketMessageTypes.JoinLobbyResponse:
                        OnJoinLobbyResponse(this, new LobbyEventArgs(data));
                        break;

                    case SocketMessageTypes.UserJoinedLobby:
                        OnUserJoinedLobby(this, new LobbyEventArgs(data));
                        break;

                    case SocketMessageTypes.QuitLobbyResponse:
                        OnLeftLobby(this, new LobbyEventArgs(data));
                        break;

                    case SocketMessageTypes.StartGameResponse:
                        OnStartGameResponse(this, new LobbyEventArgs(data));
                        break;

                    case SocketMessageTypes.LobbyCreated:
                        OnLobbyCreated(this, new LobbyEventArgs(data));
                        break;

                    case SocketMessageTypes.LobbyDeleted:
                        OnLobbyDeleted(this, new LobbyEventArgs(data));
                        break;

                    case SocketMessageTypes.MatchStarted:
                        OnMatchStarted(this);
                        break;

                    case SocketMessageTypes.MatchEnd:
                        OnMatchEnded(this, new MatchEventArgs(data));
                        break;

                    case SocketMessageTypes.PlayerLeftMatch:
                        OnPlayerLeftMatch(this, new MatchEventArgs(data));
                        break;

                    case SocketMessageTypes.NewDrawer:
                        OnNewPlayerIsDrawing(this, new MatchEventArgs(data));
                        break;

                    case SocketMessageTypes.YourTurnToDraw:
                        OnYourTurnToDraw(this, new MatchEventArgs(data));
                        break;

                    case SocketMessageTypes.TimesUp:
                        OnMatchTimesUp(this, new MatchEventArgs(data));
                        break;

                    case SocketMessageTypes.MatchSync:
                        OnMatchSync(this, new MatchEventArgs(data));
                        break;

                    case SocketMessageTypes.GuessResponse:
                        OnGuessResponse(this, new MatchEventArgs(data));
                        break;

                    case SocketMessageTypes.PlayerGuessed:
                        OnPlayerGuessedTheWord(this, new MatchEventArgs(data));
                        break;

                    case SocketMessageTypes.MatchCheckPoint:
                        OnMatchCheckPoint(this, new MatchEventArgs(data));
                        break;

                    case SocketMessageTypes.AreYouReady:
                        OnAreYouReady(this, new MatchEventArgs(data));
                        break;

                    case SocketMessageTypes.UserDeletedStroke:
                        OnUserDeleteStroke(this, new DrawingEventArgs(data));
                        break;

                    case SocketMessageTypes.HintResponse:
                        OnHintResponse(this, new MatchEventArgs(data));
                        break;

                    case SocketMessageTypes.MatchRoundEnded:
                        OnRoundEnded(this, new MatchEventArgs(data));
                        break;

                    case SocketMessageTypes.CoopWordGuessed:
                        OnCoopWordGuessed(this, new MatchEventArgs(data));
                        break;

                    case SocketMessageTypes.CoopTeamateGuessedIncorrectly:
                        OnCoopTeamateGuessedIncorrectly(this, new MatchEventArgs(data));
                        break;

                    case SocketMessageTypes.UserChangedName:
                        OnUserChangedName(this, new ChatEventArgs(data));
                        break;

                    case SocketMessageTypes.GameCancel:
                        OnGameCancel(this, new MatchEventArgs(data));
                        break;

                    default:
                        throw new InvalidDataException();
                    }
                }
                catch
                {
                    // Here, an exception can be thrown on a logout or if the read timeout.
                }
            }
        }