/// <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);
}
}
}
/// <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()));
}
/// <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);
}
/// <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>
/// 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 &.</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));
}
/// <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);
}
/// <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);
}
public void Remove(GameOX game)
{
this.currentSpellen.Remove(game);
}
