public void IsFull()
{
var context = new BoardProperties(4, 4, 5);
var positions = new PositionFactory().Create(context);
var patterns = new PatternFactory().Create();
var matcher = new PatternMatcher(patterns);
var boardFactories = new IBoardFactory[]
{
new BoardFactory(context, positions),
new PatternBoardFactory(context, positions, matcher)
};
foreach (var boardFactory in boardFactories)
{
IGame game = new GameFactory().CreateGame(
boardFactory,
new NextAvailablePlayer(positions),
new NextAvailablePlayer(positions),
new BasicJudge(context, positions)
);
game.Start();
foreach (var i in Enumerable.Range(0, context.RowSize * context.ColSize))
{
Assert.AreEqual(game.GameStatus, GameStatus.NotEnd);
game.Run();
}
Assert.AreEqual(game.GameStatus, GameStatus.Tie);
Assert.IsTrue(game.Board.IsFull());
}
}
public void Setup()
{
this.context = new BoardProperties();
this.positions = new PositionFactory().Create(context);
this.boardEmpty = new BoardFactory(context, positions).Create();
this.boardFull = new BoardFactory(context, positions).Create();
var piece = PieceType.P1;
foreach (var p in this.positions.Positions)
{
this.boardFull.Set(p, piece);
piece = piece.GetOther();
}
this.boardHalfFull = new BoardFactory(context, positions).Create();
var ran = new Random(1);
foreach (int i in Enumerable.Range(0, this.positions.Positions.Count() / 2))
{
var emptyPositions = this.positions.GetEmptyPositions(this.boardHalfFull);
var p = emptyPositions.ElementAt(ran.Next(0, emptyPositions.Count()));
this.boardHalfFull.Set(p, piece);
piece = piece.GetOther();
}
}
public void PositionCount()
{
var context = new BoardProperties();
var positions = new PositionFactory().Create(context);
Assert.AreEqual(context.RowSize * context.ColSize, positions.Positions.Count());
}
private Line CreateLine(BoardProperties context, LineType type, int row, int col)
{
IEnumerable <Position> positions;
if (type.Equals(LineType.Row))
{
positions = GetRow(context, row);
}
else if (type.Equals(LineType.Column))
{
positions = GetColumn(context, col);
}
else if (type.Equals(LineType.DiagonalOne))
{
positions = GetDiagonalOne(context, row, col);
}
else if (type.Equals(LineType.DiagonalTwo))
{
positions = GetDiagonalTwo(context, row, col);
}
else
{
throw new ArgumentException(type.ToString());
}
return(new Line(type, positions.ToList()));
}
public void WhenOpponentHasOpenThreeThenBlockIt2()
{
var boardString = new[]
{
// 23456
" ", // 0
" ", // 1
" X ", // 2
" XO ", // 3
" XXO ", // 4
" O ", // 5
" ", // 6
" ", // 7
};
var context = new BoardProperties(boardString.Length, boardString[0].Length);
var positions = new PositionFactory().Create(context);
var board = Utils.ParseBoard(boardString, context, positions);
var expected = new[] { new Position(1, 2), new Position(5, 2) };
int count = 0;
foreach (var aiPlayer in GetAiPlayers(context, positions, PieceType.P2))
{
var move = aiPlayer.MakeAMove(board);
Assert.IsTrue(expected.Contains(move), $"Assertion failed on player {count}, whose move is {move.ToString()}.");
count++;
}
}
public PositionManager Create(BoardProperties context)
{
var lineGroups = LineTypeExtensions.GetAll().ToDictionary(t => t, t => (ILines)CreateLineGroup(context, t));
var positionManager = new PositionManager(context, lineGroups);
return(positionManager);
}
private LineGroup CreateLineGroup(BoardProperties context, LineType type)
{
var lines = GetIndexes(context, type)
.Select(i => (IPositions)CreateLine(context, type, i.Item1, i.Item2)).ToList();
var lineGroup = new LineGroup(type, lines);
return(lineGroup);
}
private static IJudge GetJudge()
{
var context = new BoardProperties();
var positions = new PositionFactory().Create(context);
var patternRepo = new PatternFactory().Create();
return(new PatternJudge(positions, patternRepo, new PatternMatcher(patternRepo)));
}
private IEnumerable <Position> GetDiagonalTwo(BoardProperties context, int row, int col)
{
do
{
yield return(new Position(row, col));
row--;
col++;
} while (context.IsWithinBoard(row, col));
}
void IReflectorPersistance.Properties()
{
BoardProperties editor = new BoardProperties(this);
editor.ShowDialog();
if (editor.DialogResult == DialogResult.OK)
{
RootPeiceType = editor.GetSelectedType();
}
editor.Dispose();
}
public void TestEmpty()
{
var context = new BoardProperties();
var positions = new PositionFactory().Create(context);
Board board = new Board(context);
PieceType result = GetJudge().GetWinner(board);
PieceType expect = PieceType.Empty;
Assert.AreEqual(expect, result);
}
public void DeepClone()
{
var context = new BoardProperties();
var positions = new PositionFactory().Create(context);
Board board = new Board(context);
var board2 = (Board)board.DeepClone();
board2.Set(new Position(0, 0), PieceType.P1);
// Assert
Assert.AreEqual(PieceType.P1, board2.Get(new Position(0, 0)));
Assert.AreEqual(PieceType.Empty, board.Get(new Position(0, 0)));
}
public void TestD24()
{
var context = new BoardProperties();
var positions = new PositionFactory().Create(context);
Board board = new Board(context);
PieceType result;
PieceType expect;
board.Set(new Position(6, 10), PieceType.P1);
board.Set(new Position(7, 9), PieceType.P1);
board.Set(new Position(8, 8), PieceType.P1);
board.Set(new Position(9, 7), PieceType.P2);
board.Set(new Position(10, 6), PieceType.P1);
result = GetJudge().GetWinner(board);
expect = PieceType.Empty;
Assert.AreEqual(expect, result);
}
public void TestRow1()
{
var context = new BoardProperties();
var positions = new PositionFactory().Create(context);
Board board = new Board(context);
board.Set(new Position(3, 3), PieceType.P1);
board.Set(new Position(3, 4), PieceType.P1);
board.Set(new Position(3, 5), PieceType.P1);
board.Set(new Position(3, 6), PieceType.P1);
board.Set(new Position(3, 7), PieceType.P1);
PieceType result = GetJudge().GetWinner(board);
PieceType expect = PieceType.P1;
Assert.AreEqual(expect, result);
}
public void TestD22()
{
var context = new BoardProperties();
var positions = new PositionFactory().Create(context);
Board board = new Board(context);
PieceType result;
PieceType expect;
board.Set(new Position(0, 5), PieceType.P1);
board.Set(new Position(1, 4), PieceType.P1);
board.Set(new Position(2, 3), PieceType.P1);
board.Set(new Position(3, 2), PieceType.P2);
board.Set(new Position(4, 1), PieceType.P1);
result = GetJudge().GetWinner(board);
expect = PieceType.Empty;
Assert.AreEqual(expect, result);
}
public IHttpActionResult Solve(BoardProperties boardProperties)
{
if (boardProperties == null)
{
return(BadRequest("Invalid Request Object"));
}
if (boardProperties.Letters.Length != (int)boardProperties.Style)
{
return(BadRequest("Invalid Letter Count " + boardProperties.Letters.Length + ". Must use " + (int)boardProperties.Style + " letters. "));
}
var board = BoardFactory.CreateBoard(boardProperties.Style, boardProperties.Dictionary, boardProperties.Board, boardProperties.Letters);
var json = JToken.FromObject(board.Solve());
return(Ok(json));
}
public void MatchOpenThreePattenThenFound()
{
// Arrange
var positions = new[]
{
new Position(0, 0),
new Position(0, 1),
new Position(0, 2),
new Position(0, 3),
new Position(0, 4)
};
var pieces = new[]
{
PieceType.Empty,
PieceType.P1,
PieceType.P1,
PieceType.P1,
PieceType.Empty
};
var context = new BoardProperties();
IBoard board = new Board(context);
IPositions line = new FreeLine(positions);
foreach (var i in Enumerable.Range(0, positions.Count()))
{
board.Set(positions[i], pieces[i]);
}
IPattern pattern = new Pattern(PatternType.OpenThree, PatternPositionType.Any, player: PieceType.P1, pieces: pieces);
var matcher = new PatternMatcher(new PatternFactory().Create());
// Act
var result = matcher.MatchInternal(board, line, new HashSet <IPattern> {
pattern
});
// Assert
Assert.AreEqual(1, result.Count());
CollectionAssert.AreEqual(positions, result.First().Positions.ToList());
}
private static void DisplayBoard(IBoard board, BoardProperties context)
{
Console.Write(" ");
for (var i = 0; i < context.ColSize; i++)
{
Console.Write(string.Format(" {0}", i));
}
Console.WriteLine();
for (var i = 0; i < context.RowSize; i++)
{
Console.Write(string.Format("{0,2:00} ", i));
for (var j = 0; j < context.ColSize; j++)
{
Console.Write(" ");
Console.Write(PieceToDisplayChar[board.Get(new Position(i, j))]);
}
Console.WriteLine();
}
}
public static IBoard ParseBoard(string[] boardString, BoardProperties context, PositionManager positions)
{
if (context.RowSize != boardString.Length || boardString.Any(s => s.Length != context.ColSize))
{
throw new ArgumentException("The board string does not consist with the board sizes in context.");
}
IBoardFactory boardFactory = new BoardFactory(context, positions);
IBoard board = boardFactory.Create();
foreach (Position p in positions.Positions)
{
char pieceChar = boardString[p.Row][p.Col];
PieceType piece = CharToPiece[pieceChar];
board.Set(p, piece);
}
return(board);
}
public void TestDiagonalIndexes()
{
var b = new BoardProperties();
var positions = new PositionFactory().Create(b);
var d1Lines = positions.LineGroups[LineType.DiagonalOne];
foreach (var p in positions.Positions)
{
int index = positions.GetDiagonalOneIndex(p);
Assert.IsTrue(d1Lines.Lines[index].Positions.Contains(p));
}
var d2Lines = positions.LineGroups[LineType.DiagonalTwo];
foreach (var p in positions.Positions)
{
int index = positions.GetDiagonalTwoIndex(p);
Assert.IsTrue(d2Lines.Lines[index].Positions.Contains(p));
}
}
public void PatternJudgeWontTakeHalfThreeAsFive()
{
var boardString = new[]
{
// 2345678910
" ", // 0
" O ", // 1
" X ", // 2
" XX X ", // 3
" XOOO ", // 4
" XXO ", // 5
" OOOX ", // 6
" ", // 7
" ", // 8
" ", // 9
" ", // 10
};
var context = new BoardProperties(boardString.Length, boardString[0].Length);
var positions = new PositionFactory().Create(context);
var patterns = new PatternFactory().Create();
var matcher = new PatternMatcher(patterns);
var boardFactory = new BoardFactory(context, positions);
var patternBoardFactory = new PatternBoardFactory(context, positions, matcher);
var centerScorer = new CenterScorer(context, positions);
var patternScorer = new PatternScorer(positions, patterns, matcher);
var aggregatedScorer = new AggregatedScorer(new[]
{
new Tuple <IScorer, double>(patternScorer, 1),
new Tuple <IScorer, double>(centerScorer, 0.01)
});
var judge = new PatternJudge(positions, patterns, matcher);
var board = Utils.ParseBoard(boardString, context, positions);
var winner = judge.GetWinner(board);
Assert.AreEqual(PieceType.Empty, winner);
}
private IEnumerable <IPlayer> GetAiPlayers(BoardProperties context, PositionManager positions, PieceType player)
{
var patterns = new PatternFactory().Create();
var matcher = new PatternMatcher(patterns);
var patternBoardFactory = new PatternBoardFactory(context, positions, matcher);
var centerScorer = new CenterScorer(context, positions);
var patternScorer = new PatternScorer(positions, patterns, matcher);
var aggregatedScorer = new AggregatedScorer(new[]
{
new Tuple <IScorer, double>(patternScorer, 1),
new Tuple <IScorer, double>(centerScorer, 0.01)
});
var judge = new BasicJudge(context, positions);
var emptyMoveEnumerator = new EmptyPositionMoveEnumerator(positions);
var scoredMoveEnumerator = new ScoredMoveEnumerator(positions, aggregatedScorer);
return(new[]
{
new AbPruningAi(player, 1, aggregatedScorer, scoredMoveEnumerator, patternBoardFactory, judge),
new AbPruningAi(player, 2, aggregatedScorer, scoredMoveEnumerator, patternBoardFactory, judge),
new AbPruningAi(player, 3, aggregatedScorer, scoredMoveEnumerator, patternBoardFactory, judge)
});
}
private IEnumerable <Tuple <int, int> > GetIndexes(BoardProperties context, LineType type)
{
if (type.Equals(LineType.Row))
{
return(context.RowIndexes.Select(i => new Tuple <int, int>(i, -1)));
}
if (type.Equals(LineType.Column))
{
return(context.ColIndexes.Select(i => new Tuple <int, int>(-1, i)));
}
if (type.Equals(LineType.DiagonalOne))
{
return(context.GetDiagonalOneIndexes());
}
if (type.Equals(LineType.DiagonalTwo))
{
return(context.GetDiagonalTwoIndexes());
}
throw new ArgumentOutOfRangeException(string.Format("Unconsidered subclass of Line: '{0}'.", type.ToString()));
}
public static void Main(string[] args)
{
var context = new BoardProperties();
var positions = new PositionFactory().Create(context);
var patterns = new PatternFactory().Create();
var matcher = new PatternMatcher(patterns);
var boardFactory = new BoardFactory(context, positions);
var patternBoardFactory = new PatternBoardFactory(context, positions, matcher);
var centerScorer = new CenterScorer(context, positions);
var patternScorer = new PatternScorer(positions, patterns, matcher);
var aggregatedScorer = new AggregatedScorer(new[]
{
new Tuple <IScorer, double>(patternScorer, 1),
new Tuple <IScorer, double>(centerScorer, 0.01)
});
var judge = new PatternJudge(positions, patterns, matcher);
var emptyMoveEnumerator = new EmptyPositionMoveEnumerator(positions);
var scoredMoveEnumerator = new ScoredMoveEnumerator(positions, aggregatedScorer);
IGame game = new GameFactory().CreateGame(boardFactory,
//new HumanPlayer(),
//new RandomPlayer(positions),
//new RandomPlayer(positions),
new AbPruningAi(PieceType.P1, 3, aggregatedScorer, scoredMoveEnumerator, patternBoardFactory, judge),
new AbPruningAi(PieceType.P2, 3, aggregatedScorer, scoredMoveEnumerator, patternBoardFactory, judge),
//new AbPruningAi(PieceType.P2, 2, patternScorer, emptyMoveEnumerator, patternBoardFactory, judge),
judge
);
game.Start();
var board = game.Board;
DisplayBoard(board, context);
do
{
Stopwatch stopWatch = new Stopwatch();
stopWatch.Start();
game.Run();
stopWatch.Stop();
TimeSpan ts = stopWatch.Elapsed;
string elapsedTime = $"{ts.Minutes:00}:{ts.Seconds:00}.{ts.Milliseconds / 10:00}";
Console.WriteLine($"Elapsed time {elapsedTime}.");
Debug.WriteLine($"Elapsed time {elapsedTime}.");
DisplayBoard(board, context);
DebugInfo(positions, board, matcher);
if (game.GameStatus == GameStatus.P1Win)
{
Console.WriteLine("Winner is player 1.");
}
else if (game.GameStatus == GameStatus.P2Win)
{
Console.WriteLine("Winner is player 2.");
}
else if (game.GameStatus == GameStatus.Tie)
{
Console.WriteLine("Game ties.");
}
//System.Threading.Thread.Sleep(500);
//Console.ReadLine();
} while (game.GameStatus == GameStatus.NotEnd);
Console.ReadLine();
}
public CenterScorer(BoardProperties context, PositionManager positions)
{
this.context = context;
this.positions = positions;
}
private IEnumerable <Position> GetColumn(BoardProperties context, int col)
{
return(context.RowIndexes.Select(i => new Position(i, col)));
}
public BasicJudge(BoardProperties context, PositionManager positions)
{
_context = context;
_positions = positions;
}
private IEnumerable <Position> GetRow(BoardProperties context, int row)
{
return(context.ColIndexes.Select(i => new Position(row, i)));
}
void Awake()
{
Instance = this;
}
public PatternBoardFactory(BoardProperties context, PositionManager positions, PatternMatcher matcher)
{
this.context = context;
this.positions = positions;
this.matcher = matcher;
}
