Ejemplo n.º 1
0
        public TransportGroupRouter(IConnectionTransporter transporter, TransportRouterConfig config)
        {
            _transporter = transporter;
            _config      = config;

            _groups      = config.Groups.Keys.ToList();
            _connections = new ArrayDictionary <TransportGroupId, IList <ConnectionId> >(
                id => id.Value,
                value => new TransportGroupId(value),
                config.Groups.Count);
            for (int i = 0; i < _groups.Count; i++)
            {
                var group       = _groups[i];
                var groupConfig = config.Groups[group];
                _connections[group] = new List <ConnectionId>(groupConfig.MaxConnections);
            }
            _dataHandlers = new ArrayDictionary <TransportGroupId, ITransportDataHandler>(
                id => id.Value,
                value => new TransportGroupId(value),
                config.Groups.Count);
            _connectionHandlers = new ArrayDictionary <TransportGroupId, ITransportConnectionHandler>(
                id => id.Value,
                value => new TransportGroupId(value),
                config.Groups.Count);

            transporter.OnConnectionOpened += OnConnectionEstablished;
            transporter.OnConnectionClosed += OnDisconnected;
            transporter.OnDataReceived     += OnDataReceived;
        }
Ejemplo n.º 2
0
        public LidgrenDefaultConnectionManager(IConnectionTransporter transporter)
        {
            _transporter = transporter;
            _connections = new Dictionary <ConnectionId, ConnectionRegistration>();

            _transporter.OnConnectionOpened += OnConnectionOpened;
            _transporter.OnConnectionClosed += OnConnectionClosed;
        }
Ejemplo n.º 3
0
        public static NetworkSystems Create(
            IConnectionTransporter transporter,
            IConnectionlessTransporter connectionlessTransporter,
            TransportRouterConfig groupRouterConfig,
            IDictionary <ObjectType, GameObject> replicationPrefabs,
            IMessageSender messageSender,
            IConnectionManager connectionManager)
        {
            ILatencyInfo latencyInfo         = transporter;
            var          networkMessageTypes = MessageExtensions.GenerateNetworkIds(MessageExtensions.GetNetworkMessageTypes());
            var          objectMessageTypes  = MessageExtensions.GenerateNetworkIds(MessageExtensions.GetObjectMessageTypes());

            var connectionlessMessageSender = new ConnectionlessMessageSender(connectionlessTransporter);

            var messagePool        = new MessagePool(MessageExtensions.CreateMessagePools(networkMessageTypes));
            var objectMessagePools = MessageExtensions.CreateMessagePools(objectMessageTypes);

            var groupRouter = new TransportGroupRouter(transporter, groupRouterConfig);

            Func <ObjectMessageRouter> objectMessageDispatcherFactory =
                () => new ObjectMessageRouter(latencyInfo, objectMessageTypes);
            var networkMessagePool = new BasicObjectPool <ReplicatedObjectStore.ObjectMessageSender.MulticastNetworkMessage>(
                pool => new ReplicatedObjectStore.ObjectMessageSender.MulticastNetworkMessage(pool, networkMessageTypes[typeof(BasicMessage.ToObject)]));
            var objectMessageSenderFactory = ReplicatedObjectStore.ObjectMessageSender.CreateFactory(
                messageSender,
                groupRouter,
                new TransportGroupId(2),
                networkMessagePool);

            var objectDependencies = new List <object> {
                latencyInfo
            };

            foreach (var pool in objectMessagePools)
            {
                objectDependencies.Add(pool.Value);
            }
            var replicationDecorator = ReplicatedObjectStore.GameObjectReplicationDecorator(objectMessageDispatcherFactory,
                                                                                            objectMessageSenderFactory,
                                                                                            objectDependencies,
                                                                                            objectMessageTypes);
            var replicatedObjectPools = replicationPrefabs
                                        .Select(kvPair => new KeyValuePair <ObjectType, Func <GameObject> >(kvPair.Key, kvPair.Value.ToFactory()))
                                        .ToDictionary(kvPair => kvPair.Key, kvPair => kvPair.Value);
            int replicatedObjectCapacity = 256;
            var objectMessageParser      = new ObjectMessageParser(objectMessageTypes);
            var replicatedObjectStore    = new ReplicatedObjectStore(objectMessageParser, replicatedObjectPools,
                                                                     replicationDecorator, replicatedObjectCapacity);

            return(new NetworkSystems(
                       messageSender,
                       connectionlessMessageSender,
                       messagePool,
                       connectionManager,
                       groupRouter,
                       replicatedObjectStore,
                       networkMessageTypes));
        }
Ejemplo n.º 4
0
        public DefaultConnectionManager(IConnectionTransporter transporter, ConnectionIdPool connectionIdPool)
        {
            _transporter      = transporter;
            _connectionIdPool = connectionIdPool;
            _connections      = new ArrayDictionary <ConnectionId, ConnectionRegistration>(connectionIdPool.MaxConnectionIds);

            _transporter.RequestApproval    += PassRequestApproval;
            _transporter.OnConnectionOpened += OnConnectionOpened;
            _transporter.OnConnectionClosed += OnConnectionClosed;
        }
Ejemplo n.º 5
0
        public TransportGroupRouter(IConnectionTransporter transporter, TransportRouterConfig config)
        {
            _transporter = transporter;
            _config      = config;

            var groupIds = config.Groups.Keys.ToList();

            _groups = new ArrayDictionary <TransportGroupId, ConnectionGroup>(config.Groups.Count);
            for (int i = 0; i < groupIds.Count; i++)
            {
                var groupId     = groupIds[i];
                var groupConfig = config.Groups[groupId];
                _groups[groupId] = new ConnectionGroup(groupId, maxConnections: groupConfig.MaxConnections);
            }
            _dataHandlers = new ArrayDictionary <TransportGroupId, ITransportDataHandler>(config.Groups.Count);

            transporter.OnConnectionOpened += OnConnectionEstablished;
            transporter.OnConnectionClosed += OnDisconnected;
            transporter.OnDataReceived     += OnDataReceived;
        }
Ejemplo n.º 6
0
        public static NetworkSystems Create(
            IConnectionTransporter transporter,
            IConnectionlessTransporter connectionlessTransporter,
            TransportRouterConfig groupRouterConfig,
            TransportGroupId objectGroupId,
            IReadOnlyDictionary <ObjectType, Func <GameObject> > replicatedObjectPools,
            IMessageSender messageSender,
            IConnectionManager connectionManager,
            ILatencyInfo latencyInfo,
            DependencyContainer globalDependencies)
        {
            var connectionlessMessageSender = new ConnectionlessMessageSender(connectionlessTransporter);

            var messagePools        = MessageTypes.CreateMessagePool(MessageTypes.NetworkMessageTypes);
            var objectMessagePools  = MessageTypes.CreateMessagePool(MessageTypes.ObjectMessageTypes);
            var objectMessageParser = new ObjectMessageParser(MessageTypes.ObjectMessageTypes);

            var dependencies = globalDependencies.Copy();

            dependencies.AddDependency("latencyInfo", latencyInfo);
            foreach (var pool in messagePools.Pools)
            {
                dependencies.AddDependency(pool.ToString(), pool);
            }
            foreach (var pool in objectMessagePools.Pools)
            {
                dependencies.AddDependency(pool.ToString(), pool);
            }

            var groupRouter = new TransportGroupRouter(transporter, groupRouterConfig);

            Func <GameObject, ObjectMessageRouter> objectMessageDispatcherFactory =
                gameObject => new ObjectMessageRouter(MessageTypes.ObjectMessageTypes, gameObject);
            var networkMessagePool = new BasicObjectPool <ReplicatedObjectStore.ObjectMessageSender.MulticastNetworkMessage>(
                pool => new ReplicatedObjectStore.ObjectMessageSender.MulticastNetworkMessage(pool, MessageTypes.NetworkMessageTypes[typeof(BasicMessage.ToObject)]));
            var objectMessageSenderFactory = ReplicatedObjectStore.ObjectMessageSender.CreateFactory(
                messageSender,
                groupRouter,
                objectGroupId,
                networkMessagePool);

            var replicationDecorator = ReplicatedObjectStore.GameObjectReplicationDecorator(objectMessageDispatcherFactory,
                                                                                            objectMessageSenderFactory,
                                                                                            dependencies,
                                                                                            MessageTypes.ObjectMessageTypes);
            int replicatedObjectCapacity = 256;
            var replicatedObjectStore    = new ReplicatedObjectStore(replicatedObjectPools,
                                                                     replicationDecorator, replicatedObjectCapacity);

            var replicator = new Replicator(replicatedObjectStore,
                                            groupRouter.GetConnectionGroup(objectGroupId),
                                            new NetworkReplicator(messageSender, messagePools),
                                            objectMessageParser);

            var defaultMessageRouter = new MessageRouter(MessageTypes.NetworkMessageTypes, latencyInfo);

            groupRouter.SetDataHandler(groupRouterConfig.DefaultGroup, defaultMessageRouter);

            return(new NetworkSystems(
                       messageSender,
                       connectionlessMessageSender,
                       messagePools,
                       connectionManager,
                       groupRouter,
                       defaultMessageRouter,
                       replicatedObjectStore,
                       MessageTypes.NetworkMessageTypes,
                       MessageTypes.ObjectMessageTypes,
                       replicator,
                       objectMessageParser));
        }