public string UpdateBoardDisplay()
{
string output = "";
string charForCurrentType;
for (int r = 0; r < model.mapSize; r++)
{
for (int c = 0; c < model.mapSize; c++)
{
BoardModel.SquareType currentSquareType = model.map[r, c];
charForCurrentType = model.GetTypeToChar(currentSquareType);
if (r == model.playerX)
{
if (c == model.playerY)
{
charForCurrentType = model.GetTypeToCharPlayer(model.currentPlayerSquareType);
}
}
output += charForCurrentType + " ";
}
output += "\n";
}
output += "\n";
output += " Player at (" + model.playerX + ", " + model.playerY + ")";
output += "\n last acction success = " + model.GetLastActionSuccess();
return(output);
}
/*
* Make a move
* @param position Board coordinates
*/
private void play(Coordinates position)
{
model.setPositionTo(position, turn);
viewer.setPositionTo(position, turn);
turn = BoardModel.swapType(turn);
checkEndGame();
}
/*
* Constructor
* param boardViewer Reference to its viewer
*/
public BoardPresenter(BoardViewer boardViewer)
{
model = new BoardModel();
viewer = boardViewer;
turn = BoardModel.SquareType.CROSS;
// Starts robot as opposite player
robot = new RobotPlayer(BoardModel.swapType(GameSettings.Instance.humanSide));
}
// Minmax recursive analysis
private int getMinMaxScore(BoardModel board, BoardModel.SquareType nextTurn)
{
List <Coordinates> possibleMoves = board.getEmptyPositions();
BoardModel.SquareType winner = board.computeWinner();
// Case robot wins, it's a positive score relative to decision tree depth
if (winner == this.side)
{
return(possibleMoves.Count + 1);
}
// Case robot loses, it's a negative score relative to decision tree depth
if (winner == BoardModel.swapType(side))
{
return(-possibleMoves.Count - 1);
}
// Case it's a draw leaf
if (possibleMoves.Count == 0)
{
return(0);
}
// Robot turn, maximizes score
if (nextTurn == this.side)
{
int maxScore = Int32.MinValue;
foreach (Coordinates move in possibleMoves)
{
BoardModel predictedBoard = new BoardModel(board);
predictedBoard.setPositionTo(move, nextTurn);
int score = getMinMaxScore(predictedBoard, BoardModel.swapType(nextTurn));
if (score > maxScore)
{
maxScore = score;
}
}
return(maxScore);
}
// Opponent turn, minimizes score
else
{
int minScore = Int32.MaxValue;
foreach (Coordinates move in possibleMoves)
{
BoardModel predictedBoard = new BoardModel(board);
predictedBoard.setPositionTo(move, nextTurn);
int score = getMinMaxScore(predictedBoard, BoardModel.swapType(nextTurn));
if (score < minScore)
{
minScore = score;
}
}
return(minScore);
}
}
// Decides next play analysing one play forward
private Coordinates decidesShallow(BoardModel board)
{
List <Coordinates> winningMoves = new List <Coordinates>();
List <Coordinates> preventLosingMoves = new List <Coordinates>();
List <Coordinates> neutralMoves = new List <Coordinates>();
foreach (Coordinates position in board.getPositions())
{
// Tests only possible moves
if (board.at(position) != BoardModel.SquareType.EMPTY)
{
continue;
}
BoardModel testBoard = new BoardModel(board);
// Tests for a winning move
testBoard.setPositionTo(position, side);
if (testBoard.computeWinner() == side)
{
winningMoves.Add(position);
continue;
}
// Tests for a move preventing a losing
BoardModel.SquareType opponentSide = BoardModel.swapType(side);
testBoard.setPositionTo(position, opponentSide);
if (testBoard.computeWinner() == opponentSide)
{
preventLosingMoves.Add(position);
continue;
}
// Else it's just a neutral move
neutralMoves.Add(position);
}
// Makes a random move in order of preference ( win > not lose )
foreach (List <Coordinates> moves in new List <Coordinates>[] {
winningMoves, preventLosingMoves, neutralMoves
})
{
if (moves.Count > 0)
{
System.Random random = new System.Random();
return(moves[random.Next(moves.Count)]);
}
}
// Error
return(new Coordinates(-1, -1));
}
/*
* Change the rendering of a square for a type ( cross or nought )
* @param position The position on the board
* @param type The type of the square ( cross or nought )
*/
public void setPositionTo(Coordinates position, BoardModel.SquareType type)
{
SpriteRenderer renderer = squares[position.x, position.y].GetComponent <SpriteRenderer>();
if (type == BoardModel.SquareType.CROSS)
{
renderer.sprite = crossSprite;
}
else if (type == BoardModel.SquareType.NOUGHT)
{
renderer.sprite = noughtSprite;
}
}
/*
* Check if there is a winner and stops the game if so
*/
private void checkEndGame()
{
BoardModel.SquareType winner = model.computeWinner();
if (winner != BoardModel.SquareType.EMPTY)
{
turn = BoardModel.SquareType.EMPTY;
viewer.endGame(winner);
}
else if (model.getEmptyPositions().Count == 0)
{
turn = BoardModel.SquareType.EMPTY;
viewer.endGame(BoardModel.SquareType.EMPTY);
}
}
public void Test02_Square_Type_Enum_Array_Setting_Values()
{
//Arrange
BoardModel m = new BoardModel(4);
m.map[0, 0] = BoardModel.SquareType.EDGE_OF_BOARD;
BoardModel.SquareType expectedResult = BoardModel.SquareType.EDGE_OF_BOARD;
//Act
BoardModel.SquareType result = m.map[0, 0];
//Assert
Assert.AreEqual(expectedResult, result);
}
public void test11_Player_Can_Light_Tile_From_Provider
(int playPositionX, int playPositionY, int mapSize, bool expectedResult, BoardModel.SquareType squareType)
{
//Arrange
BoardModel m = new BoardModel(mapSize);
m.map[2, 2] = squareType;
m.playerX = playPositionX;
m.playerY = playPositionY;
m.LightSquare();
//Act
bool result = m.GetLastActionSuccess();
//Assert
Assert.AreEqual(expectedResult, result);
}
public void test08_Out_Of_Bounds_ImpassableVolcano_ImpassablePit_Move
(int playPositionX, int playPositionY, int mapSize, bool expectedResult, BoardModel.SquareType squareType, BoardModel.CompassDirection direction)
{
//Arrange
BoardModel m = new BoardModel(mapSize);
m.playerX = playPositionX;
m.playerY = playPositionY;
//Out of bounds...
m.map[2, 3] = squareType;
m.PlayerWalk(direction);
//Act
bool result = m.GetLastActionSuccess();
//Assert
Assert.AreEqual(expectedResult, result);
}
/*
* Modify the winning text according to result
* @param winner Who is the winner: cross, nought or draw (EMPTY)
*/
public void setWinner(BoardModel.SquareType winner)
{
string text = "";
switch (winner)
{
case BoardModel.SquareType.EMPTY:
text = "It's a draw!";
break;
case BoardModel.SquareType.CROSS:
text = "Crosses are the winners!";
break;
case BoardModel.SquareType.NOUGHT:
text = "Noughts are the winners!";
break;
}
winnerText.GetComponent <Text>().text = text;
}
public void test09_Player_Can_Jump_From_Provider
(int playPositionX, int playPositionY, int mapSize, bool expectedResult, BoardModel.SquareType squareType1, BoardModel.SquareType squareType2, BoardModel.CompassDirection direction)
{
//Arrange
BoardModel m = new BoardModel(mapSize);
m.playerX = playPositionX;
m.playerY = playPositionY;
//Setup Map tiles(mock level)
m.map[3, 3] = squareType1;
m.map[2, 3] = squareType2;
m.PlayerJump(direction);
//Act
bool result = m.GetLastActionSuccess();
//Assert
Assert.AreEqual(expectedResult, result);
}
private string GetTypeToCharPlayer(BoardModel.SquareType currentPlayerSquareType)
{
string P = Player[(int)currentPlayerSquareType];
return(P);
}
/*
* Popups the winner canvas
* @param winner Who is the winner: cross, nought or draw (EMPTY)
*/
public void endGame(BoardModel.SquareType winner)
{
endGameCanvas.SetActive(true);
endGameCanvas.GetComponent <EndGameUI>().setWinner(winner);
}
private string GetTypeToChar(BoardModel.SquareType currentSquareType)
{
string t = SquareTypeToChar[(int)currentSquareType];
return(t);
}
/*
* Constructor
* @param type Side of the robot
*/
public RobotPlayer(BoardModel.SquareType side)
{
this.side = side;
}
/*
* Constructor
*/
private GameSettings()
{
// Default settings
humanSide = BoardModel.SquareType.CROSS;
difficulty = Difficulty.NORMAL;
}
public void test07_Player_Can_Walk_NORTH_SOUTH_EAST_WEST_From_Provider
(int playPositionX, int playPositionY, int mapSize, bool expectedResult, BoardModel.CompassDirection direction, BoardModel.SquareType mockLevelSquareType)
{
//Arrange
BoardModel m = new BoardModel(mapSize);
m.map[4, 5] = mockLevelSquareType; //North
m.map[5, 6] = mockLevelSquareType; //East
m.map[5, 5] = mockLevelSquareType; //Start Position
m.map[6, 5] = mockLevelSquareType; //South
m.map[5, 4] = mockLevelSquareType; //West
m.playerX = playPositionX;
m.playerY = playPositionY;
m.PlayerWalk(direction);
//Act
bool result = m.GetLastActionSuccess();
//Assert
Assert.AreEqual(expectedResult, result);
}
