Ejemplo n.º 1
0
        protected override void OnUpdate()
        {
            Entities
            .ForEach((Entity entity, ref ClientPlayerLoginRequestPacket command, ref ReceiveRpcCommandRequestComponent reqSrc) =>
            {
                var playerId            = ++m_nextAvailablePlayerId;
                var networkConnectionId = (byte)EntityManager.GetComponentData <NetworkIdComponent>(reqSrc.SourceConnection).Value;

                Debug.Log($"[Server] Player connected from {reqSrc.SourceConnection}:{networkConnectionId}. Assigning id: {playerId}");

                var networkEntityId = ServerManager.Instance.NextNetworkEntityId;

                new ServerPlayerBuilder(networkEntityId, networkConnectionId, reqSrc.SourceConnection, playerId)
                .AddElementToBuffer(new TransferNetworkEntityToClient {
                    clientConnection = reqSrc.SourceConnection
                })
                .Build(PostUpdateCommands);

                ServerToClientRpcCommandBuilder
                .SendTo(reqSrc.SourceConnection, new ServerPlayerLoginResponsePacket
                {
                    playerId        = playerId,
                    networkEntityId = networkEntityId
                })
                .Build(PostUpdateCommands);

                PostUpdateCommands.DestroyEntity(entity);
            });
        }
        protected override void OnUpdate()
        {
            Entities
            .WithAll <TSelector, NetworkEntity, TransferNetworkEntityToAllClients>()
            .ForEach((Entity entity, ref NetworkEntity networkEntity, ref TSelector selectorComponent) =>
            {
                var command = CreateTransferCommandForEntity(entity, networkEntity, selectorComponent);
                ServerToClientRpcCommandBuilder.Broadcast()
                .AddCommand(command)
                .Build(PostUpdateCommands);

                PostUpdateCommands.RemoveComponent <TransferNetworkEntityToAllClients>(entity);
            });

            Entities
            .WithAll <TSelector, NetworkEntity, TransferNetworkEntityToClient>()
            .ForEach((Entity entity, DynamicBuffer <TransferNetworkEntityToClient> clients, ref NetworkEntity networkEntity, ref TSelector selectorComponent) =>
            {
                var command = CreateTransferCommandForEntity(entity, networkEntity, selectorComponent);
                foreach (var clientEntity in clients)
                {
                    ServerToClientRpcCommandBuilder.SendTo(clientEntity.clientConnection)
                    .AddCommand(command)
                    .Build(PostUpdateCommands);
                }

                PostUpdateCommands.RemoveComponent <TransferNetworkEntityToClient>(entity);
            });
        }
        protected override void OnUpdate()
        {
            Entities
            .ForEach((Entity entity, ref NetworkEntity networkEntity, ref ServerDestroy destroy) =>
            {
                ServerToClientRpcCommandBuilder
                .Broadcast(new ServerNetworkEntityDestroyCommand
                {
                    networkEntityId = networkEntity.networkEntityId
                })
                .Build(PostUpdateCommands);

                OnDestroyEntity(networkEntity.networkEntityId, entity);
            });


            Entities
            .WithNone <NetworkEntity>()
            .ForEach((Entity entity, ref ServerDestroy destroy) => { PostUpdateCommands.DestroyEntity(entity); });
        }
Ejemplo n.º 4
0
        protected override void OnUpdate()
        {
            Entities
            .ForEach((Entity entity, ref T command, ref ReceiveRpcCommandRequestComponent requestComponent) =>
            {
                if (ShouldDestroyEntity)
                {
                    PostUpdateCommands.DestroyEntity(entity);
                }

                int result = OnCommand(ref command, ref requestComponent);
                ServerToClientRpcCommandBuilder
                .SendTo(requestComponent.SourceConnection, new ManagedRpcCommandResult
                {
                    packetId = command.PacketId,
                    result   = result
                })
                .Build(PostUpdateCommands);
            });
        }
        protected override void OnUpdate()
        {
            Entities
            .WithAll <TSelector, TSelector2, NetworkEntity, NetworkEntityRegistered, TransferNetworkEntityToAllClients>()
            .ForEach((Entity entity, ref NetworkEntity networkEntity, ref TSelector selectorComponent, ref TSelector2 selectorComponent2) =>
            {
                if (ServerManager.Instance.HasConnections)
                {
                    var command = CreateTransferCommandForEntity(entity, ref networkEntity, ref selectorComponent, ref selectorComponent2);
                    ServerToClientRpcCommandBuilder
                    .Broadcast(command)
                    .Build(PostUpdateCommands);
                }

                PostUpdateCommands.RemoveComponent <TransferNetworkEntityToAllClients>(entity);
            });

            Entities
            .WithAll <TSelector, TSelector2, NetworkEntity, NetworkEntityRegistered, TransferNetworkEntityToClient>()
            .ForEach((Entity entity, DynamicBuffer <TransferNetworkEntityToClient> clients, ref NetworkEntity networkEntity, ref TSelector selectorComponent,
                      ref TSelector2 selectorComponent2) =>
            {
                if (ServerManager.Instance.HasConnections)
                {
                    var command = CreateTransferCommandForEntity(entity, ref networkEntity, ref selectorComponent, ref selectorComponent2);
                    foreach (var clientEntity in clients)
                    {
                        ServerToClientRpcCommandBuilder
                        .SendTo(clientEntity.clientConnection, command)
                        .Build(PostUpdateCommands);
                    }
                }

                PostUpdateCommands.RemoveComponent <TransferNetworkEntityToClient>(entity);
            });
        }