Пример #1
0
        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 returnMessage = null;

            // ik jkrijg hier een event

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

            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(_spelHandler, client);
                 *                      returnMessage = handler.HandleFromMessage(commandParams);
                 *                      break;
                 *              }
                 */
            }
            catch (Exception exp)
            {
                // ok dan krijg ik een foutmelding, stuur die dan terug
                returnMessage = EventHelper.CreateErrorEvent(exp);
            }

            return(returnMessage);
        }
Пример #2
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);
        }
Пример #3
0
        /// <inheritdoc/>
        protected override string ProcessStream(string stream, TcpClient client)
        {
            // bepaal het event
            // het event is het gedeelte in de msg voor de #
            // daarna komen de parameters
            string eventParams   = string.Empty;
            string returnMessage = null;
            Events events        = EventHelper.SplitEventAndParamsFromMessage(stream, out eventParams);

            string[] opgeknipt          = eventParams.Split(new char[] { '&' });
            string[] opgekniptDerdeDeel = eventParams.Split(new char[] { ',' });

            try
            {
                switch (events)
                {
                case Events.Error:
                    Console.WriteLine(eventParams);
                    break;

                case Events.SpelGestart:
                    Console.WriteLine("We gaan starten " + opgeknipt[0] + " Tegen " + opgeknipt[1] + " De dimension is : " + opgeknipt[2]);
                    break;

                case Events.SpelerGestart:
                    Console.WriteLine(opgeknipt[1]);
                    Console.WriteLine(" Je mag starten !!");
                    Console.WriteLine("Welke teken wil je gebruiken, O of X ?");
                    ConsoleKeyInfo teken;
                    teken = Console.ReadKey();
                    while (teken.Key != ConsoleKey.O && teken.Key != ConsoleKey.X)
                    {
                        Console.WriteLine("Fout ! Je mag andre teken gepruiken.");
                        teken = Console.ReadKey();
                    }

                    this.SpelerGestart(teken.Key.ToString());
                    break;

                case Events.YourTurn:
                    if (opgeknipt.Length > 1)
                    {
                        Console.WriteLine(opgeknipt[1]);
                    }

                    Console.WriteLine();
                    Console.WriteLine("Geef een nummer toe !!");
                    string nummerString = Console.ReadLine();
                    short  nummer;
                    while (!short.TryParse(nummerString, out nummer))
                    {
                        Console.WriteLine("Geef maar een nummer toe !!!");
                        nummerString = Console.ReadLine();
                    }

                    this.DoeZet(nummer);
                    break;

                case Events.Winnaar:
                    string[] opgekniptDerdeDeelDrie = opgekniptDerdeDeel[0].Split(new char[] { '&' });
                    Console.WriteLine(opgekniptDerdeDeel[1] + " Is gewonnen !!!!");
                    Console.WriteLine(opgekniptDerdeDeel[1] + " heeft : " + opgekniptDerdeDeelDrie[1] + " Punt / Punten !");
                    break;

                case Events.BordIsVol:
                    Console.WriteLine("Het bord is vol !!");
                    break;

                case Events.NieuwRondje:
                    Console.WriteLine("Wil je nog een rondje , J of N?");
                    string nieuwRondjes = Console.ReadLine();
                    nieuwRondjes.ToLower();
                    while ((nieuwRondjes != "j") && (nieuwRondjes != "n"))
                    {
                        Console.WriteLine("Geef maar J of N !");
                        nieuwRondjes = Console.ReadLine();
                    }

                    switch (nieuwRondjes)
                    {
                    case "j":
                        this.NieuwRondje(nieuwRondjes);
                        break;

                    case "n":
                        this.BeeindigSpel();
                        break;
                    }

                    break;

                case Events.StartNieuwRond:
                    Console.WriteLine(opgekniptDerdeDeel[0]);
                    Console.WriteLine("Geef een nummer toe !!");
                    string nummerString2 = Console.ReadLine();
                    short  nNnummer;
                    while (!short.TryParse(nummerString2, out nNnummer))
                    {
                        Console.WriteLine("Geef maar een nummer toe !!!");
                        nummerString = Console.ReadLine();
                    }

                    this.DoeZet(nNnummer);
                    break;

                case Events.IsGewonnen:
                    Console.WriteLine("Hoeraaaaa " + opgeknipt[1] + " is Gewonnen ");
                    break;

                case Events.NiemandGewonnen:
                    Console.WriteLine("Niemand heeft gewonnen ...");
                    break;

                case Events.HetIsBezit:
                    Console.WriteLine("Het is bezit of ongeldig nummer, je mag ander nummer geven.");
                    string nummerString3 = Console.ReadLine();
                    short  num;
                    while (!short.TryParse(nummerString3, out num))
                    {
                        Console.WriteLine("Geef maar een nummer toe !!!");
                        nummerString = Console.ReadLine();
                    }

                    this.DoeZet(num);
                    break;

                case Events.NieuwSpel:
                    string[] opgekniptNieuwe = opgeknipt[1].Split(new char[] { ',' });
                    Console.WriteLine("Andere speler heeft het spel verleten. Wil je nog een spel doen , J of N");
                    string nieuwSpel = Console.ReadLine();
                    nieuwSpel.ToLower();
                    while ((nieuwSpel != "j") && (nieuwSpel != "n"))
                    {
                        Console.WriteLine("Geef maar J of N !");
                        nieuwSpel = Console.ReadLine();
                    }

                    switch (nieuwSpel)
                    {
                    case "j":
                        short a = short.Parse(opgekniptDerdeDeel[1]);
                        this.VerzoekOmStartenSpel(opgekniptNieuwe[0], a);
                        break;

                    case "n":
                        Console.WriteLine("Tot ziens !!");
                        break;
                    }

                    break;

                case Events.WachtenOpAndereDeelnemer:
                    if (opgeknipt.Length > 1)
                    {
                        Console.WriteLine(opgeknipt[1]);
                    }

                    Console.WriteLine("wachten op andere speler");
                    break;
                }
            }
            catch (Exception exp)
            {
                // ok dan krijg ik een foutmelding, stuur die dan terug
                returnMessage = EventHelper.CreateErrorEvent(exp);
            }

            return(returnMessage);
        }