private void makeTurn(IReversiTurn turn)
{
this.unhighlightAvailableTurns();
this.drawChangesForTurn(turn);
this._boardModel.ApplyTurn(turn);
this.getAvailableTurns();
this.highlightAvailableTurns();
}
public void ApplyTurn(IReversiTurn turn)
{
int newState = this.IsTurnOfBlackPlayer ? TAKEN_BY_BLACK : TAKEN_BY_WHITE;
this._cells[turn.Position.Row, turn.Position.Column] = newState;
foreach (ICellCoordinates flippedCell in turn.PositionsOfFlippedItems)
{
this._cells[flippedCell.Row, flippedCell.Column] = newState;
}
this.DoPassTurn();
}
private void makeTurnByAI()
{
if (tryPassTurnOrGameOver())
{
return;
}
IReversiTurn selectedTurn =
this._turnSelector.SelectBestTurnOnBoard(
this._validTurns,
this._boardModel);
this.makeTurn(selectedTurn);
}
private void drawChangesForTurn(IReversiTurn turn)
{
Material activePlayerColour =
this._boardModel.IsTurnOfBlackPlayer ?
this._blackItemMaterial :
this._whiteItemMaterial;
this.createBallWithColourAtCell(activePlayerColour, turn.Position);
foreach (ICellCoordinates flippedCell in turn.PositionsOfFlippedItems)
{
this.setColourForBallAtCell(activePlayerColour, flippedCell);
}
}
public IReversiTurn SelectBestTurnOnBoard(
IEnumerable <IReversiTurn> validTurns,
IBoardState board)
{
if (null == validTurns)
{
return(null);
}
IReversiTurn result =
validTurns.OrderByDescending(t => t.PositionsOfFlippedItems.Count())
.First();
return(result);
}
public IReversiTurn SelectBestTurnOnBoard(
IEnumerable <IReversiTurn> validTurns,
IBoardState board)
{
if (null == validTurns)
{
return(null);
}
Random rand = new Random();
int index = rand.Next(0, validTurns.Count());
IReversiTurn result = validTurns.ElementAt(index);
return(result);
}
private void handleTapOnCell(GameObject cellCube)
{
if (this.IsTurnOfAI)
{
return;
}
// TODO : maybe compute matrix index by reference
string cellName = cellCube.name;
ICellCoordinates selectedCellPosition = BoardCoordinatesConverter.CellNameToCoordinates(cellName);
if (tryPassTurnOrGameOver())
{
return;
}
var turnValidator = new SearchInSetTurnValidator(this._validTurns);
bool isSelectedTurnValid = turnValidator.IsValidPositionForTurnOnBoard(selectedCellPosition, this._boardModel);
if (!isSelectedTurnValid)
{
// TODO : maybe show alert
return;
}
IReversiTurn turn = this._validTurns.Where(t =>
{
string turnPositionName = BoardCoordinatesConverter.CoordinatesToCellName(t.Position);
return(cellName.Equals(turnPositionName));
}).First();
this.makeTurn(turn);
if (IS_OPPONENT_PLAYER_AI)
{
StartCoroutine("coroutineMakeTurnByAI");
}
}
public void TestReverseDiagonalFlips()
{
var sut = new TurnCalculator();
var board = new MatrixBoard();
{
board.IsTurnOfBlackPlayer = false;
board.TryConsumeNamedCellByWhitePlayer("A8");
board.TryConsumeNamedCellByWhitePlayer("H1");
board.TryConsumeNamedCellByBlackPlayer("B7");
board.TryConsumeNamedCellByBlackPlayer("C6");
board.TryConsumeNamedCellByBlackPlayer("D5");
board.TryConsumeNamedCellByBlackPlayer("E4");
board.TryConsumeNamedCellByBlackPlayer("G2");
}
var result = sut.GetValidTurnsForBoard(board);
Assert.IsNotNull(result);
Assert.AreEqual(1, result.Count());
IReversiTurn turn = result.First();
string strPosition = BoardCoordinatesConverter.CoordinatesToCellName(turn.Position);
Assert.AreEqual("F3", strPosition);
Assert.AreEqual(5, turn.PositionsOfFlippedItems.Count());
var sortedFlips =
turn.PositionsOfFlippedItems.OrderBy(c =>
{
return(BoardCoordinatesConverter.CoordinatesToCellName(c));
});
string strSortedFlips = BoardCoordinatesConverter.PrintCoordinates(sortedFlips);
string expectedFlips = "B7; C6; D5; E4; G2";
Assert.AreEqual(expectedFlips, strSortedFlips);
}
public IReversiTurn SelectBestTurnOnBoard(
IEnumerable <IReversiTurn> validTurns,
IBoardState board)
{
if (null == validTurns)
{
return(null);
}
int selectorsCount = this._selectorsSortedByPriorityAsc.Length;
for (int selectorIndex = 0; selectorIndex < selectorsCount; ++selectorIndex)
{
ITurnSelector currentSelector = this._selectorsSortedByPriorityAsc[selectorIndex];
IReversiTurn currentSuggestion = currentSelector.SelectBestTurnOnBoard(validTurns, board);
if (null != currentSuggestion)
{
return(currentSuggestion);
}
}
return(null);
}
public void TestTurnsForInitialState()
{
var turns = this._sut.GetValidTurnsForBoard(this._initialBoard);
Assert.IsNotNull(turns);
var turnsCount = turns.Count();
Assert.AreEqual(4, turnsCount);
IReversiTurn turn = null;
ICellCoordinates position = null;
ICellCoordinates flippedCell = null;
{
position = BoardCoordinatesConverter.CellNameToCoordinates("C5");
turn = turns.Where
(
t => (t.Position.Row == position.Row &&
t.Position.Column == position.Column)
).First();
Assert.IsNotNull(turn);
Assert.AreEqual(1, turn.PositionsOfFlippedItems.Count());
flippedCell = turn.PositionsOfFlippedItems.First();
Assert.IsNotNull(flippedCell);
string flippedCellName = BoardCoordinatesConverter.CoordinatesToCellName(flippedCell);
Assert.AreEqual("D5", flippedCellName);
}
{
position = BoardCoordinatesConverter.CellNameToCoordinates("D6");
turn = turns.Where
(
t => (t.Position.Row == position.Row &&
t.Position.Column == position.Column)
).First();
Assert.IsNotNull(turn);
Assert.AreEqual(1, turn.PositionsOfFlippedItems.Count());
flippedCell = turn.PositionsOfFlippedItems.First();
Assert.IsNotNull(flippedCell);
string flippedCellName = BoardCoordinatesConverter.CoordinatesToCellName(flippedCell);
Assert.AreEqual("D5", flippedCellName);
}
{
position = BoardCoordinatesConverter.CellNameToCoordinates("F4");
turn = turns.Where
(
t => (t.Position.Row == position.Row &&
t.Position.Column == position.Column)
).First();
Assert.IsNotNull(turn);
Assert.AreEqual(1, turn.PositionsOfFlippedItems.Count());
flippedCell = turn.PositionsOfFlippedItems.First();
Assert.IsNotNull(flippedCell);
string flippedCellName = BoardCoordinatesConverter.CoordinatesToCellName(flippedCell);
Assert.AreEqual("E4", flippedCellName);
}
{
position = BoardCoordinatesConverter.CellNameToCoordinates("E3");
turn = turns.Where
(
t => (t.Position.Row == position.Row &&
t.Position.Column == position.Column)
).First();
Assert.IsNotNull(turn);
Assert.AreEqual(1, turn.PositionsOfFlippedItems.Count());
flippedCell = turn.PositionsOfFlippedItems.First();
Assert.IsNotNull(flippedCell);
string flippedCellName = BoardCoordinatesConverter.CoordinatesToCellName(flippedCell);
Assert.AreEqual("E4", flippedCellName);
}
}
public void TestMultipleDirections()
{
var sut = new TurnCalculator();
var board = new MatrixBoard();
{
board.IsTurnOfBlackPlayer = false;
board.TryConsumeNamedCellByWhitePlayer("A1");
board.TryConsumeNamedCellByWhitePlayer("H1");
board.TryConsumeNamedCellByWhitePlayer("A8");
board.TryConsumeNamedCellByWhitePlayer("H8");
board.TryConsumeNamedCellByWhitePlayer("A4");
board.TryConsumeNamedCellByWhitePlayer("H4");
board.TryConsumeNamedCellByWhitePlayer("D1");
board.TryConsumeNamedCellByWhitePlayer("D8");
// Diagonal
board.TryConsumeNamedCellByBlackPlayer("B2");
board.TryConsumeNamedCellByBlackPlayer("C3");
board.TryConsumeNamedCellByBlackPlayer("E5");
board.TryConsumeNamedCellByBlackPlayer("F6");
board.TryConsumeNamedCellByBlackPlayer("G7");
// Horizontal
board.TryConsumeNamedCellByBlackPlayer("B4");
board.TryConsumeNamedCellByBlackPlayer("C4");
board.TryConsumeNamedCellByBlackPlayer("E4");
board.TryConsumeNamedCellByBlackPlayer("F4");
board.TryConsumeNamedCellByBlackPlayer("G4");
// Vertical
board.TryConsumeNamedCellByBlackPlayer("D2");
board.TryConsumeNamedCellByBlackPlayer("D3");
board.TryConsumeNamedCellByBlackPlayer("D5");
board.TryConsumeNamedCellByBlackPlayer("D6");
board.TryConsumeNamedCellByBlackPlayer("D7");
}
var result = sut.GetValidTurnsForBoard(board);
Assert.IsNotNull(result);
Assert.AreEqual(1, result.Count());
IReversiTurn turn = result.First();
string strPosition = BoardCoordinatesConverter.CoordinatesToCellName(turn.Position);
Assert.AreEqual("D4", strPosition);
Assert.AreEqual(15, turn.PositionsOfFlippedItems.Count());
var sortedFlips =
turn.PositionsOfFlippedItems.OrderBy(c =>
{
return(BoardCoordinatesConverter.CoordinatesToCellName(c));
});
string strSortedFlips = BoardCoordinatesConverter.PrintCoordinates(sortedFlips);
string expectedFlips = "B2; B4; C3; C4; D2; D3; D5; D6; D7; E4; E5; F4; F6; G4; G7";
Assert.AreEqual(expectedFlips, strSortedFlips);
}
