Beispiel #1
0
        private async Task <NetworkPacket> ProcessRequest(StreamSocket socket, NetworkPacket packet)
        {
            AcknowledgePacket acknowledgement = new AcknowledgePacket();

            if (packet.Type == PacketType.LobbyCommand)
            {
                LobbyCommandPacket command = packet as LobbyCommandPacket;
                if (command.Command == LobbyCommands.SetupGame)
                {
                    string   hostID = command.PlayerID;
                    GameData game   = _gameList[_playerList[hostID].GameID];
                    await GamePage.gameInstance.StartServer(hostID, _playerList, game);
                }
                else
                {
                    await CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(CoreDispatcherPriority.Normal,
                                                                                  () => { OnLobbyCommand(command); });
                }
            }
            else if (packet.Type == PacketType.LobbyData)
            {
                LobbyData lobbyData = packet as LobbyData;
                _playerList = lobbyData._playerList;
                _gameList   = lobbyData._gameList;
                OnLobbyUpdated("playerList");
                OnLobbyUpdated("gamesList");
            }
            return(acknowledgement);
        }
Beispiel #2
0
        private Task UpdateAllClients()
        {
            LobbyData data = new LobbyData(_playerList, _gameList);

            var destinationSockets =
                from player in _playerList.Values
                select player.Location;

            return(_lobbyDataConnection.SendPacketToAll(destinationSockets.ToList(), data));
        }
Beispiel #3
0
        internal async void OnPacketReceived(object network, PacketReceivedEventArgs args)
        {
            StreamSocket  source = args.Source;
            NetworkPacket packet = args.Packet;

            if (packet.Type == PacketType.LobbyCommand)
            {
                LobbyCommandPacket command  = packet as LobbyCommandPacket;
                string             playerID = command.PlayerID;

                if (Server)
                {
                    switch ((int)command.Command)
                    {
                    case (int)LobbyCommands.EnterLobby:
                        await ProcessEnterLobbyCommand(playerID, source.Information.RemoteAddress.DisplayName);

                        break;

                    case (int)LobbyCommands.LeaveLobby:
                        ProcessLeaveLobbyCommand(playerID);
                        break;

                    case (int)LobbyCommands.HostGame:
                        string hostIPAddress = command.Data;
                        ProcessHostGameCommand(playerID, hostIPAddress);
                        break;

                    case (int)LobbyCommands.JoinGame:
                        string hostID = command.Data;
                        ProcessJoinGameCommand(playerID, hostID);
                        break;

                    case (int)LobbyCommands.LeaveGame:
                        ProcessLeaveGameCommand(playerID);
                        break;

                    case (int)LobbyCommands.SetupGame:
                        await ProcessSetupGameCommand(playerID);

                        break;
                    }
                    await UpdateAllClients();

                    MenuManager.PlayerListChanged();
                }
                else
                {
                    switch ((int)command.Command)
                    {
                    case (int)LobbyCommands.EjectThisUser:
                        ProcessEjectThisUserCommand();
                        break;
                    }
                }
            }
            else if (packet.Type == PacketType.LobbyData && !Server)
            {
                LobbyData data = packet as LobbyData;
                _playerList = data._playerList;
                _gameList   = data._gameList;
                MenuManager.PlayerListChanged();
            }
        }