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;
}
