public Form1()
{
InitializeComponent();
newgame = new NewGameForm();
newgame.ShowDialog();
_size = newgame.tableSize;
_openFileDialog = new OpenFileDialog();
_saveFileDialog = new SaveFileDialog();
//model
_model = new TicTacToeGameModel(new TextFilePersistence());
_model._tableSize = _size;
_model.FieldChanged += FieldChanged;
_model.GameOver += GameOver;
_model.TimePassed += TimePassed;
_model.GameLoaded += GameLoaded;
//first new game has to have a size
_size = newgame.tableSize;
_model._tableSize = _size;
_model.NewGame();
_model._timerOn = true;
_model._timer.Start();
xTimeText.Text = "0";
oTimeText.Text = "0";
}
/// <summary>
/// Use this construtor for the "root" node
/// </summary>
/// <param name="currentGameModel"></param>
/// <param name="currentPlayer"></param>
/// <param name="currentPlayer"></param>
public TicTacToeDecisionNode(TicTacToeGameModel currentGameModel, SquareLetter originalLetter, SquareLetter currentLetter)
{
OriginalLetter = originalLetter;
CurrentPlayerLetter = currentLetter;
ThisModel = currentGameModel;
CreateChildNodes();
SetNodeOutcome(this, true, originalLetter);
}
public TicTacToeWindow(PlayerType player1Type, PlayerType player2Type)
{
DataContext = new TicTacToeGameModel(player1Type, player2Type);
InitializeComponent();
this.Loaded += TicTacToeWindow_Loaded;
}
public void LoadTest()
{
model = new TicTacToeGameModel(new TextFilePersistence()); Assert.IsTrue(model.SaveGame("D:'\'beadandok'\'c#'\'PotyogosAmoba'\'PotyogosAmoba"));
//here you need to select a save file to test the load
//uncomment, if this has to be tested too
OpenFileDialog open = new OpenFileDialog();
//if (open.ShowDialog() == DialogResult.OK) {
// Assert.IsTrue(model.LoadGame(open.FileName));
//}
}
public TicTacToeDecisionNode(TicTacToeGameModel currentGameModel, bool forOriginalPlayer, SquareLetter originalLetter, SquareLetter currentLetter, int i = -1, int j = -1)
{
LastRowMove = i;
LastColumnMove = j;
OriginalLetter = originalLetter;
CurrentPlayerLetter = currentLetter;
ThisModel = currentGameModel;
CreateChildNodes();
SetNodeOutcome(this, true, OriginalLetter);
}
public void NewGameTest()
{
model = new TicTacToeGameModel(new TextFilePersistence());
model._tableSize = 10;
model.NewGame();
for (int i = 0; i < model._tableSize; i++)
{
for (int j = 0; j < model._tableSize; j++)
{
Assert.AreEqual(model._tableMatrix[i, j], 0);
}
}
}
public void SaveTest()
{
model = new TicTacToeGameModel(new TextFilePersistence());
model._tableSize = 10;
model.NewGame();
model.StepGame(0, 0);
model.StepGame(0, 0);
model.StepGame(0, 1);
model.StepGame(0, 1);
model.StepGame(0, 2);
model.StepGame(0, 2);
Assert.IsTrue(model.SaveGame(".'\'PotyogosAmoba"));
}
/*
* private void Set_Can_Win(TicTacToeDecisionNode ticTacToeDecisionNode, Player originalPlayer)
* {
* if(ticTacToeDecisionNode.IsWinForOriginalPlayer)
* {
* ticTacToeDecisionNode.CanWinNode = true;
* return;
* }
*
* if(ticTacToeDecisionNode.CurrentPlayer.Letter == originalPlayer.Letter)
* {
* // if I am making the next move and any children is a winning move or a "killer move" it is also a killer move
* foreach(var childNode in ChildNodes)
* {
* if(childNode.IsWinForOriginalPlayer || childNode.CanWinNode)
* {
* ticTacToeDecisionNode.CanWinNode = true;
* return;
* }
* }
* }
* else
* {
* // if the other player is the next move and all of their children are killer moves, it is a killer move
* // if any of them are not killer moves, then it is not a killer move
* foreach (var childNode in ticTacToeDecisionNode.ChildNodes)
* {
* Set_Can_Win(childNode, originalPlayer);
* if (childNode.CanWinNode == false)
* {
* ticTacToeDecisionNode.CanWinNode = false;
* return;
* }
* }
* ticTacToeDecisionNode.CanWinNode = true;
* return;
* }
* }
*
* private void Set_Will_Lose(TicTacToeDecisionNode ticTacToeDecisionNode, Player playerForNode)
* {
* // No more child nodes, check these nodes
* if (ticTacToeDecisionNode.GameState == GameState.Tie)
* {
* ticTacToeDecisionNode.IsLosingNodeForOriginalPlayer = false;
* return;
* }
* else if (ticTacToeDecisionNode.GameState == GameState.Win && ticTacToeDecisionNode.WinningPlayer.Letter == playerForNode.Letter)
* {
* ticTacToeDecisionNode.IsLosingNodeForOriginalPlayer = false;
* return;
* }
* else if (ticTacToeDecisionNode.GameState == GameState.Win && ticTacToeDecisionNode.WinningPlayer.Letter != playerForNode.Letter)
* {
* ticTacToeDecisionNode.IsLosingNodeForOriginalPlayer = true;
* return;
* }
*
* if (ticTacToeDecisionNode.GameState != GameState.InProgress && ticTacToeDecisionNode.ChildNodes.Count > 0)
* {
* throw new InvalidOperationException("Invalid state");
* }
*
* foreach (var childNode in ticTacToeDecisionNode.ChildNodes)
* {
* Set_Will_Lose(childNode, playerForNode);
*
* if (childNode.IsLosingNodeForOriginalPlayer == false)
* {
* ticTacToeDecisionNode.IsLosingNodeForOriginalPlayer = false;
* return;
* }
* }
*
* ticTacToeDecisionNode.IsLosingNodeForOriginalPlayer = true;
* }
*
* private void Set_Will_Win_Or_Tie(TicTacToeDecisionNode ticTacToeDecisionNode, Player playerForNode)
* {
* // No more child nodes, check these nodes
* if (ChildNodes.Count == 0)
* {
* if (ticTacToeDecisionNode.GameState == GameState.Win && ticTacToeDecisionNode.WinningPlayer.Letter == playerForNode.Letter)
* {
* ticTacToeDecisionNode.IsNonLosingNodeForOriginalPlayer = true;
* return;
* }
* else if (ticTacToeDecisionNode.GameState == GameState.Win && ticTacToeDecisionNode.WinningPlayer.Letter != playerForNode.Letter)
* {
* ticTacToeDecisionNode.IsNonLosingNodeForOriginalPlayer = false;
* return;
* }
* else if (ticTacToeDecisionNode.GameState == GameState.Tie)
* {
* ticTacToeDecisionNode.IsNonLosingNodeForOriginalPlayer = true;
* return;
* }
* }
*
* if (ticTacToeDecisionNode.GameState != GameState.InProgress && ticTacToeDecisionNode.ChildNodes.Count > 0)
* {
* throw new InvalidOperationException("Invalid state");
* }
*
* foreach (var childNode in ticTacToeDecisionNode.ChildNodes)
* {
* Set_Will_Win_Or_Tie(childNode, playerForNode);
* if (childNode.IsNonLosingNodeForOriginalPlayer == false)
* {
* ticTacToeDecisionNode.IsNonLosingNodeForOriginalPlayer = false;
* return;
* }
* }
*
* ticTacToeDecisionNode.IsNonLosingNodeForOriginalPlayer = true;
* }
*
* private static void Set_Will_Win(TicTacToeDecisionNode ticTacToeDecisionNode, Player originalPlayer)
* {
* // No more child nodes, check these nodes
* if (ticTacToeDecisionNode.ChildNodes.Count == 0)
* {
* if (ticTacToeDecisionNode.GameState == GameState.Tie)
* {
* ticTacToeDecisionNode.IsWinForOriginalPlayer = false;
* return;
* }
* else if (ticTacToeDecisionNode.GameState == GameState.Win && ticTacToeDecisionNode.WinningPlayer.Letter != originalPlayer.Letter)
* {
* ticTacToeDecisionNode.IsWinForOriginalPlayer = false;
* return;
* }
* else if (ticTacToeDecisionNode.GameState == GameState.Win && ticTacToeDecisionNode.WinningPlayer.Letter == originalPlayer.Letter)
* {
* ticTacToeDecisionNode.IsWinForOriginalPlayer = true;
* return;
* }
* }
*
* if (ticTacToeDecisionNode.GameState != GameState.InProgress && ticTacToeDecisionNode.ChildNodes.Count > 0)
* {
* throw new InvalidOperationException("Invalid state");
* }
*
* foreach (var childNode in ticTacToeDecisionNode.ChildNodes)
* {
* Set_Will_Win(childNode, originalPlayer);
* if(childNode.IsWinForOriginalPlayer == false)
* {
* ticTacToeDecisionNode.IsWinForOriginalPlayer = false;
* return;
* }
* }
*
* ticTacToeDecisionNode.IsWinForOriginalPlayer = true;
* }
*/
private void CreateChildNodes()
{
if (IsBoardInWinningState(ThisModel))
{
// don't add child nodes
GameState = GameState.Win;
//CurrentPlayer = null;
}
else if (IsBoardFull(ThisModel))
{
// don't add child nodes - game over with no winner
GameState = GameState.Tie;
//CurrentPlayer = null;
}
else
{
// there are still empty nodes
GameState = GameState.InProgress;
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 3; j++)
{
if (!ThisModel.Board.Squares[i, j].Played)
{
// Get the current player for the next turn
SquareLetter nextLetter = SquareLetter.O;
Player currentPlayer = ThisModel.Player1;
if (CurrentPlayerLetter == ThisModel.Player1.Letter)
{
nextLetter = this.ThisModel.Player2.Letter;
currentPlayer = this.ThisModel.Player2;
}
else
{
nextLetter = this.ThisModel.Player1.Letter;
currentPlayer = this.ThisModel.Player1;
}
// create a new game state for hypothetical move
var newGameState = new TicTacToeGameModel(ThisModel.Player1.PlayerType, ThisModel.Player2.PlayerType, ThisModel.Board, currentPlayer, i, j);
var childNode = new TicTacToeDecisionNode(newGameState, !IsOriginalPlayer, OriginalLetter, nextLetter, i, j);
ChildNodes.Add(childNode);
}
}
}
}
}
public static bool IsBoardFull(TicTacToeGameModel thisModel)
{
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 3; j++)
{
if (!thisModel.Board.Squares[i, j].Played)
{
return(false);
}
}
}
return(true);
}
private bool IsBoardInWinningState(TicTacToeGameModel thisModel)
{
if (IsBoardInWinningStateForPlayer(ThisModel.Board, ThisModel.Player1.Letter))
{
WinningPlayer = new Player(this.ThisModel.Player1.Letter, this.ThisModel.Player1.PlayerType);
}
else if (IsBoardInWinningStateForPlayer(ThisModel.Board, ThisModel.Player2.Letter))
{
WinningPlayer = new Player(this.ThisModel.Player2.Letter, this.ThisModel.Player2.PlayerType);
}
else
{
return(false);
}
return(true);
}
public static MoveModel GetBestMove(TicTacToeGameModel model)
{
//get the best move for the current player
TicTacToeGameModel fakeGameModel = null;
try
{
fakeGameModel = new TicTacToeGameModel(model.Player1.PlayerType, model.Player2.PlayerType, model.Board, model.CurrentPlayer);
}
catch (Exception e)
{
Console.WriteLine("Unable to create game model");
throw e;
}
TicTacToeDecisionNode decisionNode = null;
try
{
Player lastPlayer = fakeGameModel.Player1;
//use last player as current player
if (fakeGameModel.CurrentPlayer == fakeGameModel.Player1)
{
lastPlayer = fakeGameModel.Player2;
}
decisionNode = new TicTacToeDecisionNode(fakeGameModel, fakeGameModel.CurrentPlayer.Letter, lastPlayer.Letter);
}
catch (Exception e)
{
Console.WriteLine("Unable to create decision node");
throw e;
}
MoveModel bestMove = null;
try
{
bestMove = decisionNode.GetBestMove();
}
catch (Exception e)
{
Console.WriteLine("Unable to get best move");
throw e;
}
return(bestMove);
}
public void NoMoreSpaceInColumnTest()
{
model = new TicTacToeGameModel(new TextFilePersistence());
model._tableSize = 10;
model.NewGame();
for (int i = 0; i < 10; i++)
{
model.StepGame(0, 0);
}
Assert.AreEqual(model._placed, 10);
Assert.AreEqual(model._currentPlayer, 1);
model.StepGame(0, 0);
Assert.AreEqual(model._placed, 10); //did not count as a step
Assert.AreEqual(model._currentPlayer, 1); //current player stays the same
}
public void StepTest()
{
model = new TicTacToeGameModel(new TextFilePersistence());
model._tableSize = 10;
model.NewGame();
model.StepGame(0, 0);
for (int i = 0; i < model._tableSize; i++)
{
for (int j = 0; j < model._tableSize; j++)
{
if (i == model._tableSize - 1 && j == 0)
{
Assert.AreEqual(model._tableMatrix[i, j], 1);
}
else
{
Assert.AreEqual(model._tableMatrix[i, j], 0);
}
}
}
Assert.AreEqual(model._currentPlayer, 2);
model.StepGame(0, 0);
for (int i = 0; i < model._tableSize; i++)
{
for (int j = 0; j < model._tableSize; j++)
{
if (i == model._tableSize - 1 && j == 0)
{
Assert.AreEqual(model._tableMatrix[i, j], 1);
}
else if (i == model._tableSize - 2 && j == 0)
{
Assert.AreEqual(model._tableMatrix[i, j], 2);
}
else
{
Assert.AreEqual(model._tableMatrix[i, j], 0);
}
}
}
Assert.AreEqual(model._currentPlayer, 1);
}
public void WinTest()
{
model = new TicTacToeGameModel(new TextFilePersistence());
model._tableSize = 10;
model.NewGame();
Assert.IsTrue(model.winningCoords == null); //noone has won yet
model.StepGame(0, 0);
Assert.IsTrue(model.winningCoords == null);
model.StepGame(0, 0);
Assert.IsTrue(model.winningCoords == null);
model.StepGame(0, 1);
Assert.IsTrue(model.winningCoords == null);
model.StepGame(0, 1);
Assert.IsTrue(model.winningCoords == null);
model.StepGame(0, 2);
Assert.IsTrue(model.winningCoords == null);
model.StepGame(0, 2);
Assert.IsTrue(model.winningCoords == null); //still noone
model.StepGame(0, 3);
Assert.IsTrue(model.winningCoords != null); //X won
Assert.IsTrue(model.winningCoords.Count != 0); //with these coordinates
}
public void InitTest()
{
model = new TicTacToeGameModel(new TextFilePersistence());
}
public TicTacToeWindow()
{
DataContext = new TicTacToeGameModel(PlayerType.Human, PlayerType.Human);
InitializeComponent();
}
