Example #1
0
 private void LoadSettingsControls()
 {
     if (TryToLogIn())
     {
         MyNetworkUser newUser = (MyNetworkUser)Global.MyUser;
         playerNameTextBox.Text = newUser.Name;
         emailTextBox.Text      = newUser.Email;
         Refresh();
     }
     else
     {
         typeGameChoiceTabControl.SelectedIndex = previousTabSelectedIndex;
     }
 }
Example #2
0
        private async void LoadTableAsync()
        {
            MyNetworkUser user = Global.MyUser as MyNetworkUser;

            if (user == null)
            {
                throw new ArgumentException();
            }

            gameHeaders = await user.GetListOfOpenedGamesAsync() ?? new List <OpenedGameHeaderMessageObject>();

            foreach (OpenedGameHeaderMessageObject gameHeader in gameHeaders)
            {
                Invoke(new Action(() => multiDayListBox.Items.Add(gameHeader)));
            }
        }
        /// <summary>
        ///     Logs user into server.
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        private async void Log(object sender, EventArgs e)
        {
            // local validation

            /*if (loginTextBox.Text.Length < 3 || loginTextBox.Text.Length > 15)
             * {
             *
             * }
             * if (passwordTextBox.Text.Length < 4 || passwordTextBox.Text.Length > 50)
             * {
             *
             * }*/
            // server side validation
            IPEndPoint endPoint = new IPEndPoint(IPAddress.Parse("127.0.0.1"), 5000);
            TcpClient  client   = new TcpClient();
            {
#if (!DEBUG)
                try
                {
#endif
                await client.ConnectAsync(endPoint.Address, endPoint.Port);

#if (!DEBUG)
            }
            catch (SocketException)
            {
                MessageBox.Show("Server is unavailable, please, contact the administrator.");
                return;
            }
#endif
            }
            MyNetworkUser user = new MyNetworkUser(loginTextBox.Text, client, endPoint); // returned user

            // cant log in, return
            if (!await user.LogInAsync(passwordTextBox.Text))
            {
                MessageBox.Show("Invalid credentials!");
                return;
            }

            User = user;

            // close the form
            Close();

            DialogResult = DialogResult.OK;
        }
Example #4
0
        private async Task CreateNewGame(HumanPlayer creatingPlayer, ICollection <AiPlayer> aiPlayers, string mapName,
                                         int freeSlotsCount)
        {
            if (TryToLogIn())
            {
                MyNetworkUser networkUser = (MyNetworkUser)Global.MyUser;
                bool          successful  = await networkUser.CreateGameAsync(creatingPlayer, aiPlayers, mapName, freeSlotsCount);

                if (successful == false)
                {
                    Invoke(new Action(() => MessageBox.Show($"The game could not be created.")));
                    return;
                }

                // TODO: load appropriate screen
                Invoke(new Action(() => typeGameChoiceTabControl.SelectedIndex = 0));
            }
        }
Example #5
0
        private async void OpenGame(object sender, EventArgs e)
        {
            if (gameHeaders == null)
            {
                return;
            }

            int selectedIndex = multiDayListBox.SelectedIndex;

            if (selectedIndex == -1)
            {
                return;
            }

            OpenedGameHeaderMessageObject chosenGame = gameHeaders.ElementAtOrDefault(selectedIndex);

            if (chosenGame == null)
            {
                return;
            }

            MyNetworkUser networkUser = Global.MyUser as MyNetworkUser;

            if (networkUser == null)
            {
                return;
            }

            JoinNetworkGameForm joinForm     = new JoinNetworkGameForm();
            DialogResult        dialogResult = joinForm.ShowDialog();

            if (dialogResult == DialogResult.OK)
            {
                HumanPlayer player = joinForm.GetPlayer();

                await networkUser.JoinOpenedGameAsync(player, chosenGame.GameId);
            }
        }
Example #6
0
        private bool TryToLogIn()
        {
            if (Global.MyUser.UserType != UserType.MyNetworkUser)
            {
                ServerLoggingForm serverLoggingForm = new ServerLoggingForm();

                DialogResult dialogResult;
                if (InvokeRequired)
                {
                    dialogResult = (DialogResult)Invoke(new Action(() => serverLoggingForm.ShowDialog()));
                }
                else
                {
                    dialogResult = serverLoggingForm.ShowDialog();
                }

                switch (dialogResult)
                {
                case DialogResult.OK:
                    Global.MyUser = serverLoggingForm.User;
                    break;

                default:
                    if (InvokeRequired)
                    {
                        Invoke(new Action(() => typeGameChoiceTabControl.SelectedIndex = previousTabSelectedIndex));
                    }
                    else
                    {
                        typeGameChoiceTabControl.SelectedIndex = previousTabSelectedIndex;
                    }
                    return(false);
                }
            }
            else
            {
                MyNetworkUser converted = (MyNetworkUser)Global.MyUser;
                bool          amILogged = converted.IsLoggedIn();

                if (!amILogged)
                {
                    ServerLoggingForm serverLoggingForm = new ServerLoggingForm();

                    DialogResult dialogResult;
                    if (InvokeRequired)
                    {
                        dialogResult = (DialogResult)Invoke(new Action(() => serverLoggingForm.ShowDialog()));
                    }
                    else
                    {
                        dialogResult = serverLoggingForm.ShowDialog();
                    }

                    switch (dialogResult)
                    {
                    case DialogResult.OK:
                        Global.MyUser = serverLoggingForm.User;
                        break;

                    default:
                        if (InvokeRequired)
                        {
                            Invoke(new Action(() => typeGameChoiceTabControl.SelectedIndex =
                                                  previousTabSelectedIndex));
                        }
                        else
                        {
                            typeGameChoiceTabControl.SelectedIndex = previousTabSelectedIndex;
                        }
                        return(false);
                    }
                }
            }
            return(true);
        }
        public async Task RunAsync()
        {
            try
            {
                bool isLoggedIn = false;

                while (!token.IsCancellationRequested)
                {
                    NetworkStream stream = client.GetStream();

                    Task delayTask = Task.Delay(TimeSpan.FromSeconds(50000));
                    Task <SerializationObjectWrapper> deserializationTask =
                        SerializationObjectWrapper.DeserializeAsync(stream);
                    Task completedTask = await Task.WhenAny(delayTask, deserializationTask);

                    // client didnt send anything
                    if (completedTask == delayTask)
                    {
                        Dispose();
                        throw new ClientNotRespondingException();
                    }
                    // its non blocking now
                    object deserializedObject = deserializationTask.Result.Value;

                    await TypeSwitch.DoAsync(
                        deserializedObject,
                        TypeSwitch.Case <UserLogInRequestMessage>(async message =>
                    {
                        MyNetworkUser user = message.LoggingUser;

                        string passwordHash;
                        {
                            // calculate hash
                            byte[] data  = Encoding.ASCII.GetBytes(user.Password);
                            data         = new SHA256Managed().ComputeHash(data);
                            passwordHash = Encoding.ASCII.GetString(data);
                        }
                        using (WarlightDbContext db = new WarlightDbContext())
                        {
                            var matchedUser = (from dbUser in db.Users
                                               where (dbUser.Name == user.Name) &&
                                               (dbUser.PasswordHash == passwordHash)
                                               select dbUser).AsEnumerable().FirstOrDefault();
                            bool existsMatchingUser = matchedUser != null;
                            SerializationObjectWrapper userWrapper =
                                new SerializationObjectWrapper <UserLogInResponseMessage>
                            {
                                TypedValue = new UserLogInResponseMessage
                                {
                                    SuccessfullyLoggedIn = existsMatchingUser,
                                    Email = matchedUser?.Email
                                }
                            };
                            await userWrapper.SerializeAsync(stream);

                            isLoggedIn = existsMatchingUser;
                        }
                    }),
                        TypeSwitch.Case <CreateGameRequestMessage>(async message =>
                    {
                        async Task RequestUnsuccessfulResponse(Stream responseStream)
                        {
                            SerializationObjectWrapper response
                                = new SerializationObjectWrapper <CreateGameResponseMessage>
                                {
                                    TypedValue = new CreateGameResponseMessage
                                    {
                                        Successful = false
                                    }
                                };
                            await response.SerializeAsync(responseStream);
                        }

                        async Task RequestSuccessfulResponse(Stream responseStream)
                        {
                            SerializationObjectWrapper response
                                = new SerializationObjectWrapper <CreateGameResponseMessage>
                                {
                                    TypedValue = new CreateGameResponseMessage
                                    {
                                        Successful = true
                                    }
                                };
                            await response.SerializeAsync(responseStream);
                        }

                        if ((isLoggedIn == false) || (message.FreeSlotsCount == 0))
                        {
                            await RequestUnsuccessfulResponse(stream);
                            return;
                        }

                        using (WarlightDbContext db = new WarlightDbContext())
                        {
                            MapInfo mapInfo = db.GetMatchingMap(message.MapName);
                            if (mapInfo == null)
                            {
                                await RequestUnsuccessfulResponse(stream);
                                return;
                            }

                            Map map = new Map(mapInfo.Id,
                                              mapInfo.Name,
                                              mapInfo.PlayersLimit, mapInfo.TemplatePath);

                            HumanPlayer creatingPlayer = message.CreatingPlayer;
                            GameObjectsLib.GameUser.User creatingUser = creatingPlayer.User;

                            User userInfo = db.GetMatchingUser(creatingUser.Name);
                            if (userInfo == null)
                            {
                                await RequestUnsuccessfulResponse(stream);
                                return;
                            }

                            int newGameId = db.GetMaxOpenedGameId() + 1;

                            var players = new List <Player>
                            {
                                creatingPlayer
                            };

                            ICollection <AiPlayer> aiPlayers = message.AiPlayers ?? new List <AiPlayer>();
                            players.AddRange(aiPlayers);

                            GameFactory factory = new GameFactory();
                            Game game           = factory.CreateGame(newGameId, GameType.MultiplayerNetwork, map, players, fogOfWar: true);

                            OpenedGame openedGame = new OpenedGame
                            {
                                Id                = newGameId,
                                MapName           = map.Name,
                                AiPlayersCount    = aiPlayers.Count,
                                HumanPlayersCount = 1,
                                OpenedSlotsNumber = message.FreeSlotsCount,
                                SignedUsers       = new HashSet <Entities.User>
                                {
                                    userInfo
                                },
                                GameCreatedDateTime = DateTime.Now.ToString()
                            };

                            openedGame.SetGame(game);
                            userInfo.OpenedGames.Add(openedGame);
                            db.OpenedGames.Add(openedGame);

                            await db.SaveChangesAsync();

                            await RequestSuccessfulResponse(stream);
                        }
                    }),
                        TypeSwitch.Case <LoadMyGamesListRequestMessage>(async message =>
                    {
                        MyNetworkUser user = message.RequestingUser;

                        using (WarlightDbContext db = new WarlightDbContext())
                        {
                            var matchingUser = db.GetMatchingUser(user.Name);

                            IEnumerable <OpenedGame> openedGames = from openedGame in db.OpenedGames.AsEnumerable()
                                                                   where openedGame.SignedUsers.Contains(
                                matchingUser)
                                                                   select openedGame;
                            IEnumerable <StartedGame> startedGames =
                                from startedGame in db.StartedGames.AsEnumerable()
                                where startedGame.PlayingUsers.Contains(matchingUser)
                                select startedGame;

                            var result = new List <GameHeaderMessageObject>();
                            foreach (OpenedGame openedGame in openedGames)
                            {
                                result.Add(new OpenedGameHeaderMessageObject
                                {
                                    GameId            = openedGame.Id,
                                    AiPlayersCount    = openedGame.AiPlayersCount,
                                    HumanPlayersCount = openedGame.HumanPlayersCount,
                                    MapName           = openedGame.MapName,
                                    GameCreated       = DateTime.Parse(openedGame.GameCreatedDateTime)
                                });
                            }
                            foreach (StartedGame startedGame in startedGames)
                            {
                                result.Add(new StartedGameHeaderMessageObject
                                {
                                    GameId            = startedGame.Id,
                                    AiPlayersCount    = startedGame.AiPlayersCount,
                                    HumanPlayersCount = startedGame.HumanPlayersCount,
                                    MapName           = startedGame.MapName,
                                    GameStarted       = DateTime.Parse(startedGame.GameStartedDateTime),
                                    RoundStarted      = DateTime.Parse(startedGame.LastRound.RoundStartedDateTime)
                                });
                            }

                            {
                                SerializationObjectWrapper wrapper =
                                    new SerializationObjectWrapper <LoadMyGamesListResponseMessage>
                                {
                                    TypedValue = new LoadMyGamesListResponseMessage
                                    {
                                        GameHeaderMessageObjects = result
                                    }
                                };
                                await wrapper.SerializeAsync(stream);
                            }
                        }
                    }),
                        TypeSwitch.Case <LoadOpenedGamesListRequestMessage>(async message =>
                    {
                        MyNetworkUser user = message.RequestingUser;

                        using (WarlightDbContext db = new WarlightDbContext())
                        {
                            if (db.GetMatchingUser(user.Name) == null)
                            {
                                return;
                            }

                            IQueryable <OpenedGame> openedGames = from openedGame in db.OpenedGames
                                                                  from dbUser in openedGame.SignedUsers
                                                                  where dbUser.Name != user.Name
                                                                  select openedGame;

                            {
                                SerializationObjectWrapper wrapper =
                                    new SerializationObjectWrapper <LoadOpenedGamesListResponseMessage>
                                {
                                    TypedValue = new LoadOpenedGamesListResponseMessage
                                    {
                                        GameHeaderMessageObjects = openedGames.AsEnumerable().Select(
                                            x => new OpenedGameHeaderMessageObject
                                        {
                                            AiPlayersCount    = x.AiPlayersCount,
                                            GameCreated       = DateTime.Parse(x.GameCreatedDateTime),
                                            GameId            = x.Id,
                                            HumanPlayersCount = x.HumanPlayersCount,
                                            MapName           = x.MapName
                                        })
                                    }
                                };
                                await wrapper.SerializeAsync(stream);
                            }
                        }
                    }),
                        TypeSwitch.Case <JoinGameRequestMessage>(async message =>
                    {
                        HumanPlayer player = message.RequestingPlayer;

                        using (WarlightDbContext db = new WarlightDbContext())
                        {
                            var matchingUser = db.GetMatchingUser(player.User.Name);

                            if (matchingUser == null)
                            {
                                await Send(stream, new JoinGameResponseMessage
                                {
                                    SuccessfullyJoined = false
                                });
                                return;
                            }

                            OpenedGame matchingOpenedGame = db.GetMatchingOpenedGame(message.OpenedGameId);

                            if (matchingOpenedGame == null)
                            {
                                await Send(stream, new JoinGameResponseMessage
                                {
                                    SuccessfullyJoined = false
                                });
                                return;
                            }

                            Game openedGame = await matchingOpenedGame.GetGameAsync();

                            matchingOpenedGame.SignedUsers.Add(matchingUser);
                            openedGame.Players.Add(player);

                            matchingOpenedGame.SetGame(openedGame);
                            matchingOpenedGame.OpenedSlotsNumber--;
                            matchingOpenedGame.HumanPlayersCount++;

                            await db.SaveChangesAsync();

                            await Send(stream, new JoinGameResponseMessage
                            {
                                SuccessfullyJoined = true
                            });

                            if (matchingOpenedGame.OpenedSlotsNumber == 0)
                            {
                                // TODO: start the game
                                db.OpenedGames.Remove(matchingOpenedGame);

                                StartedGame startedGame = new StartedGame
                                {
                                    AiPlayersCount      = matchingOpenedGame.AiPlayersCount,
                                    GameStartedDateTime = DateTime.Now.ToString(),
                                    HumanPlayersCount   = matchingOpenedGame.HumanPlayersCount,
                                    MapName             = matchingOpenedGame.MapName,
                                    PlayingUsers        = matchingOpenedGame.SignedUsers
                                };
                            }
                        }
                    })
                        );

                    // find out the type
                }
            }
            finally
            {
                Dispose();
            }
        }