public void AddItemToArray(int dimension, int spelerKolom, int spelerRij, Teken teken) { Teken[,] kolomsEnRijen = new Teken[dimension, dimension]; int spelerKolomInArray = spelerKolom - 1; int spelerRijInArray = spelerRij - 1; Console.WriteLine(kolomsEnRijen[spelerKolomInArray, spelerRijInArray]); switch (kolomsEnRijen[spelerKolomInArray, spelerRijInArray]) { case Teken.O: Console.WriteLine("Can't"); break; case Teken.X: Console.WriteLine("Can't"); break; default: kolomsEnRijen[spelerKolomInArray, spelerRijInArray] = teken; break; } Console.WriteLine(kolomsEnRijen[spelerKolomInArray, spelerRijInArray]); }
/// <summary> /// Zet de teken op het speelvlak. /// </summary> /// <param name="inzet">Waar de speler wil zetten.</param> /// <param name="teken">De teken van de speler.</param> /// <returns>Het nummer in de kolom die wordt gebruiken om teken te zetten.</returns> public int ZetTekenOpSpeelvlak(int inzet, Teken teken) { int inzetNummer = 0; for (int kolom = 0; kolom < this.Dimension; kolom++) { // als de veld vrij is. if (this.veldenInHetSpeelvlak[inzet, kolom] == Teken.Undefined) { inzetNummer = kolom; if (kolom == this.Dimension - 1) { // zet teken als de veld vrij is. this.veldenInHetSpeelvlak[inzet, kolom] = teken; return(inzetNummer); } } else { if (this.veldenInHetSpeelvlak[inzet, inzetNummer] == Teken.Undefined) { this.veldenInHetSpeelvlak[inzet, inzetNummer] = teken; return(inzetNummer); } } } return(inzetNummer); }
/// <summary> /// controleer of de rij heeft het zelfde teken. /// </summary> /// <param name="rij">Het loopt door dezen nummer.</param> /// <param name="teken">teken.</param> /// <returns>Heeft de functie vier vilden zijn gelijk of niet.</returns> private bool ZijnErVierTekenGelijkInEenRij(int rij, Teken teken) { int aantalTekenInEenrij = 0; for (int kolomNummer = 0; kolomNummer < this.Dimension; kolomNummer++) { if (aantalTekenInEenrij <= 4) { if (this.veldenInHetSpeelvlak[kolomNummer, rij] == teken) { aantalTekenInEenrij++; } else { aantalTekenInEenrij = 0; } } } if (aantalTekenInEenrij >= 4) { return(true); } return(false); }
/// <summary> /// Controleert of de er zijn vier teken in de kolom zijn gelijk. /// </summary> /// <param name="kolomNummer">Het nummer van de kolom.</param> /// <param name="teken">De teken die wordt gecontroleerd.</param> /// <returns>Heeft de functie vier vilden zijn gelijk of niet.</returns> private bool ZijnErVierTekenGelijkInEenKolom(int kolomNummer, Teken teken) { // Eigenlijk is doorKolom is de rij. int aantalTekenInEenrij = 0; for (int doorKolom = 0; doorKolom < this.Dimension; doorKolom++) { if (aantalTekenInEenrij <= 4) { if (this.veldenInHetSpeelvlak[kolomNummer, doorKolom] == teken) { aantalTekenInEenrij++; } else { aantalTekenInEenrij = 0; } } } if (aantalTekenInEenrij >= 4) { return(true); } return(false); }
/// <summary> /// Als de spel begint spelen dan start deze mehtod. /// </summary> /// <param name="speler">De naam van de speler.</param> /// <param name="dimensionVanDeBord">Hoe veel kolomen en rijen.</param> public void StartDeSpel(string speler, int dimensionVanDeBord, Teken teken) { // De speler voer . Console.WriteLine(speler + " Voer het kolomnummer toe dat u wilt invoeren ?"); int spelerKolomNummer; string spelerKolom = Console.ReadLine(); while (!int.TryParse(spelerKolom, out spelerKolomNummer) || (spelerKolomNummer > dimensionVanDeBord || spelerKolomNummer < 1)) { Console.WriteLine("Je mag alleen nummer invoeren of geef graag een nummer tussen 0 en " + dimensionVanDeBord); spelerKolom = Console.ReadLine(); } Console.WriteLine(speler + " Voer het rijnummer toe dat u wilt invoeren ?"); int spelerRijNummer; string spelerRij = Console.ReadLine(); while (!int.TryParse(spelerRij, out spelerRijNummer) || (spelerRijNummer > dimensionVanDeBord || spelerRijNummer < 1)) { Console.WriteLine("Je mag alleen nummer invoeren of geef graag een nummer tussen 1 en " + dimensionVanDeBord); spelerRij = Console.ReadLine(); } this.AddItemToArray(dimensionVanDeBord, spelerKolomNummer, spelerRijNummer, teken); Console.WriteLine(speler); }
/// <summary> /// Geeft de speler eigen teken die hij het nodig heeft om te spelen. /// </summary> /// <param name="speler">De speler die een teken wordt gekregen.</param> /// <param name="tekenVanSpeler">De teken.</param> private void ZetTeken(Speler speler, Teken tekenVanSpeler) { if (speler == null) { throw new ArgumentNullException("Mag speler niet null zijn"); } speler.ZetTeken(tekenVanSpeler); }
public Speler AddComputerSpeler(string naam, Teken teken) { Speler computerSpeler = new ComputerSpeler(naam); computerSpeler.TeGebruikenTeken = teken; this._spelers.Add(computerSpeler); return(computerSpeler); }
/// <summary> /// Add Een speler als computer speler. /// </summary> /// <param name="naam">Naam.</param> /// <param name="teken">Teken.</param> /// <returns>De computer speler.</returns> public Speler AddComputerSpeler(string naam, Teken teken) { Speler computerSpeler = new ComputerSpeler(naam) { TeGebruikenTeken = teken, }; this.spelers.Add(computerSpeler); return computerSpeler; }
private static Teken TegenHuidigeTeken(Teken huidigeteken) { if (huidigeteken == Teken.O) { return(Teken.X); } else { return(Teken.O); } }
/// <summary> /// Deze method geef een nieuwe speler als de speler niet al bestaat. /// </summary> /// <param name="naam">De naam van de human speler.</param> /// <param name="teken">welek teken gaat de spelr gebruiken.</param> /// <param name="dimension">Dimension.</param> /// <returns>Deze method geeft een neuwie speler terug.</returns> public Speler AddHumanSpeler(string naam, Teken teken, short dimension) { Speler speler = new HumanSpeler(naam, dimension) { TeGebruikenTeken = teken, }; this.Spelers.Add(speler); return(speler); }
/// <summary> /// Geeft tegen de huidige teken terug. /// </summary> /// <param name="teken">De huidige teken.</param> /// <returns>De tegen van de huidige teken.</returns> private Teken TegenDezeTeken(Teken teken) { if (teken == Teken.O) { return(Teken.X); } else { return(Teken.O); } }
private bool AreAllFieldsInTheColEqualTo(short col, Teken teken) { // loop door de rijen als er een teken anders is dan het gevraagde teken, return false for (short rij = 0; rij < this.Dimension; rij++) { if (this.veldenOphetBord[col, rij] != teken) { return(false); } } return(true); }
/// <summary> /// Deze method geef een nieuwe speler als de speler niet al bestaat. /// </summary> /// <param name="naam">De naam van de human speler.</param> /// <param name="teken">welek teken gaat de spelr gebruiken.</param> /// <returns>Deze method geeft een neuwie speler terug.</returns> public Speler AddHumanSpeler(string naam, Teken teken) { // bestaat deze speler al? if (this.FindSpelerByNaam(naam) != null) { throw new Exception("Speler bestaat al"); } Speler speler = new HumanSpeler(naam); speler.TeGebruikenTeken = teken; this._spelers.Add(speler); return(speler); }
/// <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); } } }
/// <summary> /// Deze method geef een nieuwe speler als de speler niet al bestaat. /// </summary> /// <param name="naam">De naam van de human speler.</param> /// <param name="teken">welek teken gaat de spelr gebruiken.</param> /// <returns>Deze method geeft een neuwie speler terug.</returns> public Speler AddHumanSpeler(string naam, Teken teken) { // bestaat deze speler al? if (this.FindSpelerByNaam(naam) != null) { throw new System.ArgumentException("Speler bestaat al"); } Speler speler = new HumanSpeler(naam) { TeGebruikenTeken = teken, }; this.spelers.Add(speler); return speler; }
/// <summary> /// Dit start het spel. /// </summary> /// <param name="dimension">Het formaat van het bord.</param> /// <returns>Het getekende bord.</returns> public Bord Start(short dimension) { // maak een bord, met de jusite dimension // hoe bepaal je wie mag beginnen? this._huidigeBord = new Bord(dimension, this); Teken teken = new Teken(); // wie begint? this._huidigeBord.TekenBord(); this.WieStart(); Speler huidigeSpeler = this._spelers[this.wieStart]; while (!this.stopDeSpel) { List <short> vrijVelden = this._huidigeBord.VrijVelden(); // teken het bord // vraag aan speler 1 wat hij wil doen Console.WriteLine(); huidigeSpeler.Zet(this._huidigeBord); this._huidigeBord.TekenBord(); if (this._huidigeBord.HeeftTekenGewonnen(huidigeSpeler.TeGebruikenTeken)) { Console.WriteLine(); Console.WriteLine(huidigeSpeler.Naam + " : Hoeraaaa " + huidigeSpeler.Naam + " je bent gewonnen !!!!"); Console.WriteLine(); huidigeSpeler.BeeindigBord(this._huidigeBord); Console.WriteLine(huidigeSpeler.Naam + " Je hebt : " + huidigeSpeler.Punten + " Punt !!"); this.VraagNieuwRondje(huidigeSpeler); } if (this._huidigeBord.IsBordFinished()) { this.stopDeSpel = true; Console.WriteLine("Het boord is vol !!!"); } huidigeSpeler = this.TegenSpeler(huidigeSpeler); } if (this.vraagEenRondje) { this.VraagNieuwRondje(huidigeSpeler); } return(this._huidigeBord); }
/// <summary> /// controleert of het speelvlak heeft het zelfde teken op vier velden. /// </summary> /// <param name="teken">De teken.</param> /// <returns>Heeft de speler gewonnen of niet.</returns> public bool HeeftGewonnen(Teken teken) { if (teken == Teken.Undefined) { throw new ArgumentException("Mag teken hier niet undefined."); } bool heeftIemandGewonnen = false; // wanneer heeft een teken gewonnen? // horizontaal een hele rij // roep voor elke row op het bord de functie AreAllFieldsInTheRowEqual aan for (int rij = 0; rij < this.Dimension && !heeftIemandGewonnen; rij++) { heeftIemandGewonnen = this.ZijnErVierTekenGelijkInEenKolom(rij, teken); if (heeftIemandGewonnen) { return(true); } } // verticaal een hele rij for (int col = 0; col < this.Dimension && !heeftIemandGewonnen; col++) { heeftIemandGewonnen = this.ZijnErVierTekenGelijkInEenRij(col, teken); if (heeftIemandGewonnen) { return(true); } } // richtsboven naar linksonder. if (this.ControleertRichtsbovenNaarLinksOnder(teken)) { return(true); } // Linksboven naar richtsonder. if (this.ControleertLinksBovenNaarRichtsOnder(teken)) { return(true); } return(false); }
/// <summary> /// tekent op het speelvlak het teken die de speler wil inzetten op het speelvlak. /// </summary> /// <param name="inzet">De keuze van de speler.</param> /// <param name="speelVlak">Het speelvalk.</param> /// <param name="teken">Het teken van de speler.</param> public void ZetTekenOpSpeelvlak(int inzet, SpeelVlak speelVlak, Teken teken) { if (teken == Teken.Undefined) { throw new ArgumentException("Mag niet de teken Undefined zijn of null."); } if (speelVlak == null) { throw new ArgumentException("mag niet het speelvlak null zijn."); } if (inzet < 0) { throw new ArgumentException("Mag niet het inzet nul of minder zijn."); } speelVlak.ZetTekenOpSpeelvlak(inzet, teken); }
/// <summary> /// Voeg een nieuwe speler toe. /// Verandert de situatie van een speler. /// </summary> /// <param name="naam">De naam van een nieuwe speler.</param> /// <param name="status">De situatie van een speler.</param> /// <param name="teken">Het teken die de speler zal gepruiken.</param> public void HandlSpeler(string naam, Status status, string teken) { Speler speler; if (naam == "Computer") { speler = this.AddComputerSpeler(naam); } else { // Voeg een speler aan het spel toe. speler = this.AddHumanSpeler(naam); } Teken tekenVanSpeler = this.enumHepler.EnumConvert <Teken>(teken); this.ZetTeken(speler, tekenVanSpeler); this.HuidigeSpeler = speler; // Chang the status of the speler. speler.ChangeStatus(status); }
/// <summary> /// Geeft de speler eigen teken die hij het nodig heeft om te spelen. /// </summary> /// <param name="socket">De client van de speler.</param> /// <param name="tekenVanSpeler">De teken die de speler heeft gekozen.</param> /// <returns>De naam van de speler.</returns> public string TekenenBehandl(Socket socket, Teken tekenVanSpeler) { if (socket == null) { throw new ArgumentException("Mag speler niet null zijn"); } Speler deSpeler = null; // Zoek naar de speler via zijn tcp. foreach (Speler speler in this.spelers) { // Als de speler is humen speler dan mag zoeken naar zijn tcp. if (speler.IsHumanSpeler) { HumanSpeler humanSpeler = speler as HumanSpeler; if (humanSpeler.TcpClient == socket) { deSpeler = speler; speler.ZetTeken(tekenVanSpeler); } } } // zoek naar de andere teken. Teken teken = this.TegenDezeTeken(tekenVanSpeler); // geef de andere teken aan de de andere speler. if (deSpeler != null) { this.ZetEenTekenVoorAnderSpeler(deSpeler, teken); return(deSpeler.Naam); } return(null); }
//constructor voor Kaart public Kaart(Kleur kleur, Teken teken, Rang rang) { Kaart_Kleur = kleur; Kaart_Rang = rang; Kaart_Teken = teken; }
// richtboven naar links onder. /// <summary> /// Controleert of de speler heeft vier op een rij vanaf richtboven naar links onder. /// </summary> /// <param name="teken">De teken die wordt gecontroleerd.</param> /// <returns>Heeft vier op een rij of niet.</returns> private bool ControleertRichtsbovenNaarLinksOnder(Teken teken) { int aantalTekenOpEenRij = 0; // start van af kolom 3 t/m de grootte. // Hier gaat |"""". boven naar links. boven - - > // linksboven naar beneden. for (int kolom = 3; kolom < this.Dimension; kolom++) { int kolomNummer = kolom; int rijNummer = 0; for (int rij = 0; rij < kolom + 1; rij++) { // Als de speler een teken op een rij heeft dan voeg een nummer aan de anntalTeken toe. if (this.veldenInHetSpeelvlak[kolomNummer--, rijNummer++] == teken) { aantalTekenOpEenRij++; } // Als de speler niet meer teken op een rij heeft dan doe de aantalTeken nul. else { aantalTekenOpEenRij = 0; } // Als de teken vier op een rij heeft dan geef true terug. if (aantalTekenOpEenRij >= 4) { return(true); } } // We gaan naar een nieuwe kolom en rij dus maak de aantalTeken nul. aantalTekenOpEenRij = 0; } // Hier gaat de speelvlak naar onder __|. // vanaf boven naar beneden. // links --> naar richt. int doorKolomLopen = this.Dimension; for (int rij = 0; rij < this.Dimension - 1; rij++) { doorKolomLopen--; int rijNummer = rij; int kolomNummer = this.Dimension - 1; for (int kolom = doorKolomLopen; kolom >= 0; kolom--) { // als de speler een teken op een rij heeft dan voeg een nummer aan de aantalTeken toe. if (this.veldenInHetSpeelvlak[kolomNummer--, rijNummer++] == teken) { aantalTekenOpEenRij++; } // Als de speler niet meer teken op een rij heeft dan doe de aantal Teken nul. else { aantalTekenOpEenRij = 0; } // Als de teken vier op een rij heeft dan geef true terug. if (aantalTekenOpEenRij >= 4) { return(true); } } aantalTekenOpEenRij = 0; } // Als de teken vier op een rij heeft dan geef true terug. return(aantalTekenOpEenRij == 4); }
// links boven naar richt onder /// <summary> /// Controleert of de speler heeft vier op een rij van af links boven naar richt onder. /// </summary> /// <param name="teken">De teken die wordt gecontroleerd.</param> /// <returns>Heeft vier op een rij of niet.</returns> private bool ControleertLinksBovenNaarRichtsOnder(Teken teken) { int aantalTekenOpEenRij = 0; int doorRijLopen = this.Dimension; // start vanaf linksboven naar richtsonder. // Linksboven . for (int kolom = 0; kolom < this.Dimension - 3; kolom++) { doorRijLopen--; int kolomNummer = kolom; int rijNummer = 0; for (int rij = doorRijLopen; rij >= 0; rij--) { // Als de speler een teken op een rij heeft dan voeg een nummer aan de aantal Teken toe. if (this.veldenInHetSpeelvlak[kolomNummer++, rijNummer++] == teken) { aantalTekenOpEenRij++; } // Als de speler niet meer teken op een rij heeft dan doe de aantal Teken nul. else { aantalTekenOpEenRij = 0; } if (aantalTekenOpEenRij >= 4) { return(true); } } aantalTekenOpEenRij = 0; } // links start. doorRijLopen = this.Dimension; for (int kolom = 0; kolom < this.Dimension - 3; kolom++) { doorRijLopen--; int kolomNummer = 0; int rijNummer = kolom; for (int rij = doorRijLopen; rij >= 0; rij--) { // Als de speler een teken op een rij heeft dan voeg een nummer aan de aantal Teken toe. if (this.veldenInHetSpeelvlak[kolomNummer++, rijNummer++] == teken) { aantalTekenOpEenRij++; } // Als de speler niet meer teken op een rij heeft dan doe de aantal Teken nul. else { aantalTekenOpEenRij = 0; } if (aantalTekenOpEenRij >= 4) { return(true); } } aantalTekenOpEenRij = 0; } return(false); }
/// <summary> /// controleert of het speelvlak heeft het zelfde teken op vier velden. /// </summary> /// <param name="teken">De teken.</param> /// <returns>Heeft de speler gewonnen of niet.</returns> public bool HeeftGewonnen(Teken teken) { bool heeftIemandGewonnen = false; // wanneer heeft een teken gewonnen? // horizontaal een hele rij // roep voor elke row op het bord de functie AreAllFieldsInTheRowEqual aan for (int rij = 0; rij < this.Dimension && !heeftIemandGewonnen; rij++) { heeftIemandGewonnen = this.ZijnErVierTekenGelijkInEenKolom(rij, teken); if (heeftIemandGewonnen) { return(true); } } // verticaal een hele rij for (int col = 0; col < this.Dimension && !heeftIemandGewonnen; col++) { heeftIemandGewonnen = this.ZijnErVierTekenGelijkInEenRij(col, teken); if (heeftIemandGewonnen) { return(true); } } heeftIemandGewonnen = true; for (int colrow = 0; colrow < this.Dimension; colrow++) { if (this.veldenInHetSpeelvlak[colrow, colrow] != teken) { heeftIemandGewonnen = false; break; } } if (heeftIemandGewonnen) { return(heeftIemandGewonnen); } // richtboven naar linksonder. // kolom naar rij int aantalTekenOpEenRij = 0; // Vanaf rij 3 starten. for (int kolom = 3; kolom < this.Dimension; kolom++) { int kolomNummer = kolom; int rijNummer = 0; for (int rij = 0; rij < kolom; rij++) { if (this.veldenInHetSpeelvlak[kolomNummer--, rijNummer++] == teken) { aantalTekenOpEenRij++; } else { aantalTekenOpEenRij = 0; } } } for (int kolom = this.Dimension - 1; kolom > 3; kolom--) { int kolomNummer = kolom; int rijNummer = 0; for (int rij = 0; rij < kolom; rij++) { if (this.veldenInHetSpeelvlak[kolomNummer--, rijNummer++] == teken) { } } } for (int kolom = this.Dimension - 3; kolom == 0; kolom--) { int kolomNummer = kolom; int rijNummer = 0; for (int rij = 0; rij < this.Dimension - 1; rij++) { if (kolomNummer == this.Dimension - 1) { break; } if (this.veldenInHetSpeelvlak[kolomNummer++, rijNummer++] == teken) { } } } for (int kolom = 0; kolom < this.Dimension - 3; kolom++) { int kolomNummer = 0; int rijNummer = kolom; for (int rij = 0; rij < this.Dimension - 1; rij++) { if (rijNummer == this.Dimension - 1) { break; } if (this.veldenInHetSpeelvlak[kolomNummer++, rijNummer++] == teken) { } } } // van links boven naar links onder. int maxDim = this.Dimension; maxDim--; heeftIemandGewonnen = true; for (int row = 0; row < this.Dimension; row++) { if (this.veldenInHetSpeelvlak[maxDim--, row] != teken) { heeftIemandGewonnen = false; break; } } return(heeftIemandGewonnen); }
/// <summary> /// functie om uit te vragen of een teken gewonnen heeft. /// </summary> /// <param name="teken">het teken waarvan gekeken moet worden of het gewonnen heeft. </param> /// <returns>true als het teken gewonnen heeft. </returns> public bool HeeftTekenGewonnen(Teken teken) { bool heeftIemandGewonnen = false; // wanneer heeft een teken gewonnen? // horizontaal een hele rij // roep voor elke row op het bord de functie AreAllFieldsInTheRowEqual aan for (short rij = 0; rij < this.Dimension && !heeftIemandGewonnen; rij++) { heeftIemandGewonnen = this.AreAllFieldsInTheRowEqualTo(rij, teken); if (heeftIemandGewonnen) { return(true); } } // verticaal een hele rij for (short col = 0; col < this.Dimension && !heeftIemandGewonnen; col++) { heeftIemandGewonnen = this.AreAllFieldsInTheColEqualTo(col, teken); if (heeftIemandGewonnen) { return(true); } } // diagonaal een hele rij heeftIemandGewonnen = true; // van linksboven naar rechtsonder for (short colrow = 0; colrow < this.Dimension; colrow++) { if (this.veldenOphetBord[colrow, colrow] != teken) { heeftIemandGewonnen = false; break; } } if (heeftIemandGewonnen) { return(heeftIemandGewonnen); } // van rechtsboven naar linksonder short maxDim = this.Dimension; maxDim--; heeftIemandGewonnen = true; for (short row = 0; row < this.Dimension; row++) { if (this.veldenOphetBord[maxDim--, row] != teken) { heeftIemandGewonnen = false; break; } } return(heeftIemandGewonnen); }
/// <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> /// Check of de speler heeft gewonnen of niet. /// </summary> /// <param name="speelVlak">Het speelvlak.</param> /// <param name="teken">De teken van de speler die zal nagaan.</param> /// <returns>Heeft vier op een rij of niet.</returns> public bool HeeftGewonnen(SpeelVlak speelVlak, Teken teken) { return(speelVlak.HeeftGewonnen(teken)); }
/// <summary> /// behanelt het berichtje die uit een cleint wordt gestuurd. /// </summary> /// <param name="message">De bericht.</param> /// <param name="socket">De client.</param> public override void ProcessStream(string message, Socket socket) { try { if (message == string.Empty) { throw new ArgumentException("Mag niet message empty zijn."); } if (socket == null) { throw new ArgumentException("Mag niet een client null zijn."); } Game game; // [0] is altijd de commando. // [1.....] is de rest van de bericht. string[] opgeknipt = message.Split(new char[] { '%' }); // change the string to enum. Commandos commando = EnumHelperl.EnumConvert <Commandos>(opgeknipt[0]); switch (commando) { case Commandos.VerzoekTotDeelnemenSpel: this.Send(socket, this.handler.StreamOntvanger(message, socket)); break; // Geef een teken aan een speler. // en geef de andere speler de andere teken. case Commandos.ZetTeken: string msg = string.Empty; Teken teken = EnumHelperl.EnumConvert <Teken>(opgeknipt[1].ToString()); game = this.GetGame(socket); game.TekenenBehandl(socket, teken); msg = $"{Events.TegenSpelerHeeftTekenIngezet.ToString()}%%{opgeknipt[1]}%%{game.TegenSpeler(game.GetSpelerViaTcp(socket)).GebruikTeken.ToString()}"; this.SendBerichtNaarDeTegenSpeler(game, msg, socket); Thread.Sleep(1000); this.Send(socket, Events.TekenIngezet.ToString()); break; // start het spel. case Commandos.Starten: this.GetGame(socket).StartHetSpel(); break; // doe zet op het speelvlak. case Commandos.DoeZet: game = this.GetGame(socket); if (game != null) { // eerst gaat het spel de inzet van de speler zetten. // dan gaat de controller dat nummertje uit de properties speler op halen. game.DoeInzet(opgeknipt[1], socket); Speler speler = game.GetSpelerViaTcp(socket); game.GameController.DoeInzet(speler); } break; case Commandos.NieuwRonde: game = this.GetGame(socket); if (game != null) { // Als de speler een nieuw rondje wil doen. // Er staat alleen een speler dan de situatie verandert tot wachten op andere speler. if (game.GetSpelers().Count == 1) { game.ZetSituatie(Status.Wachten); Thread.Sleep(500); this.SendBerichtNaarDeTegenSpeler(game, Events.WachtenNieuweSpeler.ToString(), socket); } else { // Als het spel twee spelers heeft dan gaat het door. game.GameController.NieuwRonde(); } } break; case Commandos.WilNietNieuweRonde: // neem de game. game = this.GetGame(socket); if (game != null) { this.VerWijdertHetSpelMetSpeller(socket); } socket.Close(); this.clienten.Remove(socket); break; } } catch (Exception e) { throw new ArgumentException(e.Message); } }
/// <summary> /// Geeft de andere speler een teken. /// </summary> /// <param name="speler">Een speler.</param> /// <param name="teken">De teken van de speler.</param> private void ZetEenTekenVoorAnderSpeler(Speler speler, Teken teken) { Speler tegenSpeler = this.TegenSpeler(speler); tegenSpeler.ZetTeken(teken); }
/// <summary> /// Zet een teken die de speler het gaat gebruiken. /// </summary> /// <param name="teken">De teken.</param> public void ZetTeken(Teken teken) { this.GebruikTeken = teken; }