Exemple #1
0
        public static NetworkCommandBinding From <TRequest, TResponse>(NetworkCommandType source, NetworkCommandHandler <TRequest, TResponse> handler)
            where TRequest : NetworkCommand where TResponse : NetworkCommand
        {
            switch (source)
            {
            // Request that are from client are handled as requests on the master.
            case NetworkCommandType.FromClient:
                return(new NetworkCommandBinding()
                {
                    CommandInternalType = NetworkCommand.CommandTypeFor(typeof(TRequest)),
                    _deserializeRequest = JsonUtility.FromJson <TRequest>,
                    _handleRequest = async(net, clientId, command) => await handler.ProcessRequestOnMaster(net as INetworkMaster, command as TRequest, clientId),
                });

            // Request that are from master are handled as requests on the client.
            case NetworkCommandType.FromMaster:
                return(new NetworkCommandBinding()
                {
                    CommandInternalType = NetworkCommand.CommandTypeFor(typeof(TRequest)),
                    _deserializeRequest = JsonUtility.FromJson <TRequest>,
                    _handleRequest = async(net, clientId, command) => await handler.ProcessRequestOnClient(net as INetworkClient, command as TRequest)
                });

            default:
                throw new ArgumentOutOfRangeException(nameof(source), source, null);
            }
        }
        private async Task OnMessageAsync(MessageFromClient message)
        {
            try
            {
                var networkCommand = JsonUtility.FromJson <NetworkCommand>(message.data);
                if (networkCommand.commandInternalIsResponse)
                {
                    _connection.ResolveTransaction(networkCommand, message.data);
                }
                else
                {
                    try
                    {
                        var responseToClient = await _commands.ProcessIncomingMessage(_connection, networkCommand, message.data, _master, message.client_id);

                        responseToClient.commandInternalType       = NetworkCommand.CommandTypeFor(responseToClient.GetType());
                        responseToClient.commandInternalIsResponse = true;
                        responseToClient.commandInternalId         = networkCommand.commandInternalId;
                        await _connection.Send(responseToClient, message.client_id);
                    }
                    catch (Exception error)
                    {
                        _manager.Logger.OnError(error);
                        await _connection.Send(new NetworkCommandError()
                        {
                            message                   = error.Message,
                            commandInternalType       = NetworkCommand.CommandTypeFor(typeof(NetworkCommandError)),
                            commandInternalIsResponse = true,
                            commandInternalId         = networkCommand.commandInternalId
                        }, message.client_id);
                    }
                }
            }
            catch (Exception error)
            {
                _manager.Logger.OnError(error);
            }
        }