Exemplo n.º 1
0
        /// <summary>
        /// Handel de client.
        /// </summary>
        /// <param name="client">client.</param>
        /// <param name="server">server.</param>
        private async Task HandleClientAsync(TcpClient tcpClient, Server server)
        {
            try
            {
                await server.StartListeningAsync(tcpClient.GetStream(), tcpClient);

                // server.StartListening(client.GetStream(), client);
            }
            catch
            {
                GameOX gameToDelete = null;
                Speler speler       = this.spelHandler.GetSpelerFromTcpClient(tcpClient);
                GameOX game         = this.spelHandler.GetGameFromTcpClient(tcpClient);
                game.Annuleer(speler);
                if (game.Status == GameOXStatussen.Finished)
                {
                    // dan heb ik geen spelers meer bij deze game
                    // game mag verwijderd worden
                    // maar ik mag niet verwijderen in een foreach
                    gameToDelete = game;
                }

                if (gameToDelete != null)
                {
                    this.spelHandler.Remove(gameToDelete);
                }
            }
        }
Exemplo n.º 2
0
        /// <summary>
        /// terug geven als de spel is gestart.
        /// </summary>
        /// <param name="game">huidige game.</param>
        /// <returns>De message die naar de client gaat als string. De namen van de spelers en de dimension.</returns>
        public static string CreateSpelgestartEvent(GameOX game)
        {
            // wat ga ik terug geven?
            // het commando en de lijste met spelers die meedoen, & gescheiden
            StringBuilder spelersnamen = new StringBuilder();

            foreach (Speler speler in game.Spelers)
            {
                if (game.FindSpelerByNaam(speler) == speler.Naam)
                {
                    speler.Naam = speler.Naam + 1;
                }

                break;
            }

            foreach (var speler in game.Spelers)
            {
                if (spelersnamen.Length == 0)
                {
                    spelersnamen.AppendFormat("{0}", speler.Naam);
                }
                else
                {
                    spelersnamen.AppendFormat("&{0}", speler.Naam);
                    spelersnamen.AppendFormat("&{0}", speler.Dimension);
                }
            }

            return(string.Format("{0}{1}", CreateEvent(Events.SpelGestart), spelersnamen.ToString()));
        }
Exemplo n.º 3
0
        /// <summary>
        /// Create nieuw game.
        /// </summary>
        /// <param name="dimension">dimension.</param>
        /// <param name="player">player.</param>
        /// <param name="tcpClient">tcpClient.</param>
        /// <returns>nieuw game.</returns>
        public GameOX CreateGame(short dimension, string player, TcpClient tcpClient)
        {
            GameOX gameOX = new GameOX(dimension);

            this.currentSpellen.Add(gameOX);
            gameOX.AddPlayer(player, tcpClient, dimension);
            gameOX.AddBord(dimension);

            return(gameOX);
        }
Exemplo n.º 4
0
        /// <summary>
        /// Geef een teken aan de speler.
        /// </summary>
        /// <param name="teken">Teken.</param>
        /// <param name="game">game.</param>
        /// <param name="client">Huidige client.</param>
        public static void AddTekenToSpeler(Teken teken, GameOX game, TcpClient client)
        {
            Teken huidigeTeken = teken;

            foreach (Speler speler in game.Spelers)
            {
                if (speler.TcpClient == client)
                {
                    speler.TeGebruikenTeken = teken;
                }
                else
                {
                    speler.TeGebruikenTeken = TegenHuidigeTeken(huidigeTeken);
                }
            }
        }
Exemplo n.º 5
0
        /// <summary>
        /// Als het spel is starten , Dan geven hier de naam met de dimension als string en het gaat naar de client.
        /// </summary>
        /// <param name="game">De game.</param>
        /// <returns>De message die naar de client gaat.</returns>
        public static string CreateStartGameCommando(GameOX game)
        {
            // wat ga ik terug geven?
            // het commando en de lijste met spelers die meedoen, & gescheiden
            StringBuilder spelersnamen = new StringBuilder();

            foreach (var speler in game.Spelers)
            {
                if (spelersnamen.Length == 0)
                {
                    spelersnamen.AppendFormat("{0}", speler.Naam);
                }
                else
                {
                    spelersnamen.AppendFormat("&{0}", speler.Naam);
                }
            }

            return(string.Format("{0}{1}", CreateCommando(Commandos.StartSpel), spelersnamen.ToString()));
        }
        /// <summary>
        /// functie die de parameters in string krijgt en die string opknipt in de params die nodig zijn.
        /// </summary>
        /// <param name="messageParams">params uit het bericht, gedeelte na de # en gescheiden door &amp;.</param>
        /// <param name="game">Huidig game.</param>
        /// <returns>Message als twee delen.</returns>
        public string HandleFromMessage(string messageParams, out GameOX game)
        {
            string[] opgeknipt             = messageParams.Split(new char[] { '&' });
            string[] opgekniptDeTweedeDeel = messageParams.Split(new char[] { '*' });

            // lengte van de arrayu moet
            // 0 moet naam zijn
            // 1 moet dimension zijn
            if (opgeknipt.Length != 2)
            {
                // andere foutmelding
                throw new ArgumentException("U hebt geen nummer ingevoerd");
            }

            // Als  de naam leeg is dan mag niet door gaan
            if (string.IsNullOrWhiteSpace(opgeknipt[0]))
            {
                throw new ArgumentException("Er staat geen naam, Voeg een naam.");
            }

            // Probeer te omzetten string to nummer
            if (!short.TryParse(opgeknipt[1], out short dimension))
            {
                throw new ArgumentOutOfRangeException("U hebt geen nummer ingevoerd");
            }

            if (opgekniptDeTweedeDeel.Length == 1)
            {
                opgekniptDeTweedeDeel[0] = null;
            }

            // Als het grootre dan 9 of kleiner dan 2 is mag dan niet door gaan.
            if (dimension < 2 || dimension > 9)
            {
                throw new ArgumentOutOfRangeException("U hebt geen nummer ingevoerd");
            }

            return(this.Handle(opgeknipt[0], dimension, opgekniptDeTweedeDeel[0], out game));
        }
Exemplo n.º 7
0
 /// <summary>
 /// De spelr doet een zet.
 /// </summary>
 /// <param name="nummer">Het nummer die de speler heeft gekozen.</param>
 /// <param name="gameOX">Het Spel.</param>
 /// <param name="bord">Het bord.</param>
 public override void SpelStartedHandler(short nummer, GameOX gameOX, Bord bord)
 {
     this.Zet(nummer, bord, gameOX);
 }
Exemplo n.º 8
0
        /// <summary>
        /// Process van de server.
        /// </summary>
        /// <param name="stream">Stream die uit de client komt.</param>
        /// <param name="client"> Client.</param>
        /// <returns>informatie.</returns>
        /// <exception cref="System.InvalidOperationException">Wordt gegooid wanneer een commando wordt aangeroepen op een ongeldig moment.</exception>
        protected override string ProcessStream(string stream, TcpClient client)
        {
            // bepaal de opdracht
            // de opdracht is het gedeelte in de msg voor de #
            // daarna komen de parameters.
            string commandParams = string.Empty;
            string returnMessage = null;
            GameOX game          = null;

            Commandos commando = CommandoHelper.SplitCommandAndParamsFromMessage(stream, out commandParams);

            /*foreach (GameOX games in this.gameOXen)
             * {
             *  foreach (TcpClient tcp in games.TcpClients)
             *  {
             *      if (tcp == client)
             *      {
             *          game = games;
             *      }
             *  }
             * }*/

            // Add een client to clientLijst.
            try
            {
                switch (commando)
                {
                // Verdeel between de naam van de speler en de dimension van het bord
                // wanneer de commandos is equal VerzoekTotDeelnemenSpel
                case Commandos.VerzoekTotDeelnemenSpel:
                    VerzoekTotDeelnemenSpelCommandHandler handler = new VerzoekTotDeelnemenSpelCommandHandler(this.spelHandler, client);
                    returnMessage = handler.HandleFromMessage(commandParams, out game);
                    if (game.Status == GameOXStatussen.Gestart)
                    {
                        this.ProcessReturnMessage(returnMessage, game.TcpClients);
                        game.Start(client, game);
                    }
                    else
                    {
                        this.ProcessReturnMessage(returnMessage, client);
                    }

                    break;

                case Commandos.SpelTegenComputer:
                    VerzoekTotDeelnemenSpelCommandHandler handlerTegenComputerSpelen = new VerzoekTotDeelnemenSpelCommandHandler(this.spelHandler, client);
                    returnMessage = handlerTegenComputerSpelen.HandleFromMessage(commandParams, out game);
                    this.ProcessReturnMessage(returnMessage, client);

                    game = this.spelHandler.GetGameFromTcpClient(client);
                    game.Start(client, game);
                    break;

                case Commandos.SpelerGestart:
                    game = this.spelHandler.GetGameFromTcpClient(client);
                    Teken teken = TekenHelper.CreateTekenEnum(commandParams);
                    TekenHelper.AddTekenToSpeler(teken, game, client);
                    returnMessage = EventHelper.CreateEvents(Events.YourTurn);
                    this.ProcessReturnMessage(returnMessage, client);

                    // stuur een wacht bericht naar andere speler.
                    returnMessage = this.spelHandler.TegeHuidigeClient(client, game.TcpClients, out this.tegenHuidigeClient);
                    this.ProcessReturnMessage(returnMessage, this.tegenHuidigeClient);
                    break;

                case Commandos.StartSpel:
                    // returnMessage = EventHelper.CreateSpelerGestartEvent();
                    //  ProcessReturnMessage(returnMessage, tcpClients);
                    break;

                case Commandos.DoeZet:
                    // stuur een wacht bericht naar andere speler.
                    returnMessage = this.spelHandler.TegeHuidigeClient(client, game.TcpClients, out this.tegenHuidigeClient);
                    this.ProcessReturnMessage(returnMessage, this.tegenHuidigeClient);
                    short nummer = short.Parse(commandParams);

                    // Handel de info van de speler
                    this.spelHandler.GetGameFromTcpClient(client);
                    game = this.spelHandler.GetGameFromTcpClient(client);
                    game.ChekOfHetValidBeZitIs(client, nummer, game);
                    break;

                case Commandos.WachtenOpAndereDeelnemer:
                    if (game == null)
                    {
                        throw new InvalidOperationException($"Het commando {nameof(Commandos.WachtenOpAndereDeelnemer)} mag niet worden gebruikt wanneer er nog geen game is gestart.");
                    }

                    this.ProcessReturnMessage(returnMessage, game.TcpClients);
                    break;

                case Commandos.NieuwRondje:
                    if (game == null)
                    {
                        throw new InvalidOperationException($"Het commando {nameof(Commandos.WachtenOpAndereDeelnemer)} mag niet worden gebruikt wanneer er nog geen game is gestart.");
                    }

                    this.ProcessReturnMessage(returnMessage, game.TcpClients);
                    break;

                case Commandos.BeeindigSpel:
                    game = this.spelHandler.GetGameFromTcpClient(client);
                    game.StartNieuwRondje(client, game);

                    break;
                }
            }
            catch (Exception exp)
            {
                // ok dan krijg ik een foutmelding, stuur die dan terug
                returnMessage = EventHelper.CreateErrorEvent(exp);
            }

            return(returnMessage);
        }
        /// <summary>
        /// handle het command af.
        /// </summary>
        /// <param name="spelersnaam"> naam van de speler.</param>
        /// <param name="dimension">dimension van het spel.</param>
        /// <param name="tegenComputer">Tegen de cpmputer spelen.</param>
        /// <param name="game">Huidig game.</param>
        /// <return>De message die gereturnd moet worden. </return>
        /// <returns>De messge.</returns>
        public string Handle(string spelersnaam, short dimension, string tegenComputer, out GameOX game)
        {
            string returnMessage = string.Empty;

            game = null;
            if (string.IsNullOrWhiteSpace(tegenComputer))
            {
                // zoek in de spelHandler of er al een open spel is met die dimension
                game = this.spelHandler.GetOpenSpelbyDimension(dimension);

                // zo ja, voeg speler toe en start spel
                if (game != null)
                {
                    game.AddPlayer(spelersnaam, this.tcpClient, dimension);

                    foreach (Speler speler in game.Spelers)
                    {
                        if (game.FindSpelerByNaam(speler) == speler.Naam)
                        {
                            speler.Naam = speler.Naam + 1;
                        }

                        break;
                    }

                    game.IsGestart();
                    game.TcpClients.Add(this.tcpClient);
                    returnMessage = EventHelper.CreateSpelgestartEvent(game);

                    return(returnMessage);

                    // // bepaal wie er gaat beginnen
                    // voor nu, speler 1 begint
                    //  stuur naar speler 1 bericht dat hij moet beginnen
                    //  stuur naar speler 2 bericht dat hij moet wachten
                }
                else
                {
                    // nee, maak spel aan
                    // voeg de speler toe
                    // en zet op de wachtlijst
                    game = this.spelHandler.CreateGame(dimension, spelersnaam, this.tcpClient);

                    game.WachtOpAndereSpeler();
                    game.TcpClients.Add(this.tcpClient);

                    // de speler moet wachten op een andere
                    returnMessage = EventHelper.CreateWachtenOpEenAndereDeelnemenEvent();
                }
            }
            else
            {
                string[] deNaam = spelersnaam.Split(new char[] { '*' });
                game = this.spelHandler.CreateGame(dimension, deNaam[1], this.tcpClient);
                game.AddCpmputerSpeler(deNaam[0], dimension);
                game.IsGestart();
                game.TcpClients.Add(this.tcpClient);
                returnMessage = EventHelper.CreateSpelgestartEvent(game);
            }

            // wat wil ik nu terugsturen?
            // Commandos.StartSpel), spelersnamen.ToString()
            return(returnMessage);
        }
Exemplo n.º 10
0
 public void Remove(GameOX game)
 {
     this.currentSpellen.Remove(game);
 }