/// <summary>
/// The more formal connected client model structor
/// </summary>
/// <param name="clientSocket"></param>
/// <param name="listenerSocket"></param>
public ReversiClientModel(TcpClient clientSocket, TcpListener listenerSocket) : base(clientSocket, listenerSocket)
{
Game = null;
LastMove = new GameMoveModel();
ClientPlayer = new PlayerModel();
TimeConnectedWhen = DateTime.Now;
}
/// <summary>
/// A default constructor
/// </summary>
public ReversiClientModel() : base(null, null)
{
Game = null;
LastMove = new GameMoveModel();
ClientPlayer = new PlayerModel();
TimeConnectedWhen = DateTime.Now;
}
/// <summary>
/// The event to fire when the square is clicked.
/// </summary>
/// <param name="sender"></param>
/// <param name="e"></param>
private void GameSquare_OnMouseLeftButtonDown(object sender, MouseButtonEventArgs e)
{
var obj = sender as FrameworkElement;
var myObject = obj.DataContext as ReversiSquareVM;
var Parent = VisualTreeHelper.GetParent(obj);
var windowobj = TreeHelper.TryFindParent <MainWindow>(obj);
var rcvm_obj = windowobj.DataContext as ReversiClientViewModel;
//var movemodel = rcvm_obj.Model.LastMove;
var player = rcvm_obj.ThisPlayerViewModel.IdType;
// MessageBox.Show("Index " + movemodel.MoveIndex.ToString());
if (myObject.Model.HasPiece)
{
return;
}
//MessageBox.Show("Index: " + myObject.Model.Index + " was clicked");
var movemodel = new GameMoveModel(player, myObject.Model.Index);
// Send move to server
rcvm_obj.Model.LastMove = movemodel;
DataTransmission.SerializeData <GameMoveModel>(rcvm_obj.Model.LastMove, rcvm_obj.Model.ConnectionSocket);
}
public ReversiClientModel(ClientModel clientModel, string name) : base(clientModel)
{
ReversiClientModel model = (ReversiClientModel)clientModel;
Game = null;
LastMove = new GameMoveModel();
ClientPlayer = new PlayerModel(model.ClientPlayer.PlayerId, model.ClientPlayer.IdType, name);
this.ClientProcess = clientModel.ClientProcess;
this.ClientMainThread = clientModel.ClientMainThread;
this.TimeConnectedWhen = DateTime.Now;
}
public async Task <HttpResponseMessage> Post(GameMoveModel model)
{
var results = new GameMoveResultsModel();
var player = ApplicationUser.GetCurrentPlayer(this.User);
var point = new DomainModel.Point(model.MoveToX, model.MoveToY);
var game = await this.gameService.PerformMoveAsync(model.GameID, player.ID, model.TokenID, point);
results.Add(player, game);
return(Request.CreateResponse(HttpStatusCode.OK, results));
}
public async Task <IActionResult> Move(int gameId, [FromBody] GameMoveModel move)
{
var playerId = base.HttpContext.GetPlayerId();
var request = new GameMove.Request()
{
GameId = gameId,
PlayerId = playerId,
Card = move.Card,
TileId = move.TileId
};
var response = await this.mediator.Send(request, default);
return(base.Json(new { GameId = response.GameId, Cards = response.Cards, Tiles = response.Tiles }));
}
///// <summary>
///// Removes a player from the staging area to the gameroom.
///// </summary>
//private static void RemovePlayersFromStaging()
//{
// for (int i = ReversiSettings.ReversiPlayersPerGame - 1; i >= 0; i--)
// {
// StagingArea.RemoveAt(i);
// }
//}
/// <summary>
/// The main thread routine for each game
/// </summary>
/// <param name="data">The game staging area list of client models</param>
private void InitializeMatchup(object data)
{
List <ReversiClientModel> clientModels = (List <ReversiClientModel>)data;
//// Create the game instance which moves the players to the game room
ReversiGameModel game = new ReversiGameModel(clientModels);
RunningGames.Add(game.GameId, game); // add the game to the dictionary of running games
Console.WriteLine("... GameServer: Matchup pairing complete. Game " + game.GameId.ToString() + " is ready to start.");
Console.WriteLine(game.DisplayGameInfoComplete());
// Send the game object to each of the clients.
foreach (KeyValuePair <int, ClientModel> item in game.CurrentPlayersList)
{
ReversiClientModel client = (ReversiClientModel)item.Value;
// Send the game data to each of the players
Console.WriteLine("Sending initial game matchup to players");
DataTransmission.SerializeData <ReversiGameModel>(game, client.ConnectionSocket);
// And remove the players from the Staging area.
StagingArea.Remove(client);
}
//// The main game loop. Process individual moves here
List <TcpClient> sockets = game.GetPlayersSocketList();
while (!game.GameIsOver)
{
// If the game is paused ignore the user input
if (game.GameIsPaused == true)
{
continue;
}
if (game.GameOverCheckRequired)
{
if (game.CheckGameOver(game.CurrentPlayer) == true)
{
Console.WriteLine("No available moves for " + game.CurrentPlayer);
game.GameIsOver = true;
break;
}
Console.WriteLine("Valid moves available for " + game.CurrentPlayer);
game.AvailableMovesList.ForEach(Console.WriteLine);
game.GameOverCheckRequired = false;
}
// If the current turn is valid and complete, switch to the next player
if (game.TurnComplete)
{
Console.WriteLine(game.Gameboard.DrawGameboardString());
game.NextPlayer();
game.TurnComplete = false;
game.GameOverCheckRequired = true;
// Update the game model for all players...
SendGameToAll(game);
}
List <ClientModel> disconnectList = new List <ClientModel>();
foreach (KeyValuePair <int, ClientModel> item in game.CurrentPlayersList)
{
ClientModel client = item.Value;
Socket s = client.ConnectionSocket.Client;
// Check for disconnected sockets
if (!SocketConnected(s))
{
Console.WriteLine("GameServer: (GameID #" + game.GameId + ")");
disconnectList.Add(client);
}
}
// Remove any disconnected players from the game...
foreach (ClientModel disconnectClient in disconnectList)
{
ClientDisconnectedEventArgs args = new ClientDisconnectedEventArgs
{
client = disconnectClient,
TimeOfDisconnect = DateTime.Now
};
game.GameIsPaused = true;
OnClientDisconnected(args);
game.RemovePlayerFromGame(((ClientModel)disconnectClient));
try
{
disconnectClient.ConnectionSocket.Close();
}
catch
{
// Do nothing
}
}
// Now proceed through the current player list, looking for moves sent by the clients
foreach (KeyValuePair <int, ClientModel> item in game.CurrentPlayersList)
{
NetworkStream stream;
try
{
stream = item.Value.ConnectionSocket.GetStream();
}
catch (ObjectDisposedException e)
{
// Catches a disposed socket possibility here in case it hasn't been fully disposed yet.
continue;
}
if (stream.DataAvailable)
{
GameMoveModel move = DataTransmission.DeserializeData <GameMoveModel>(item.Value.ConnectionSocket);
Console.WriteLine("GameServer: (GameID #" + game.GameId + ")" + move.ByPlayer + " move request received");
if (move.ByPlayer == game.CurrentPlayer)
{
game.CurrentMoveIndex = move.MoveIndex;
// Check that the move was valid.
if (game.PlayTurn())
{
Console.WriteLine("GameServer: (GameID #" + game.GameId + ")" + move.ByPlayer + " submitted a valid move");
game.TurnComplete = true;
game.CurrentMoveIndex = move.MoveIndex;
}
}
else
{
Console.WriteLine("GameServer: (GameID #" + game.GameId + ") Move received by opponent. Ignoring...");
}
}
}
}
// At this point the game is over.
Console.WriteLine("The game is over...");
}
