public void AvailableMovesFound()
{
var board = builder.FromTypeGrid("0110 0212 2012 2222");
var logic = new PlayLogic(board);
Assert.IsTrue(logic.HasAvailableMoves());
}
public void NoAvailableMoves()
{
var board = builder.FromTypeGrid("01 01");
var logic = new PlayLogic(board);
Assert.IsFalse(logic.HasAvailableMoves());
}
public void NewPieceHasExpectedCoords()
{
var board = builder.FromTypeGrid(new int[, ] {
{ 0, 1, 2, 0 },
{ 1, 0, 0, 2 },
{ 1, 1, 1, 2 },
{ 0, 1, 1, 2 }
});
var game = new Game(board, GameRules.ClassicRules, PieceType.GetRange(0, 3));
var moves = new PlayLogic(board).AvailableMoves();
foreach (var move in moves)
{
var simulator = MoveSimulator.FromPotentialMove(board, move, game.NextPieceIfPlaying(move));
simulator.Simulate();
var coord = simulator.moveCoord;
var piece = simulator.oldPiece;
var actions = simulator.GetMove().consequences;
var newPieceAction = actions.First(IsNewPieceAction) as NewPieceAction;
Assert.AreEqual(new Coord {
col = coord.col, row = board.Size - piece.size
}, newPieceAction.coord);
}
}
public void FindsObstaclesAbove()
{
var board = builder.FromTypeGrid("0012 0011 1211 0120");
var logic = new PlayLogic(board);
var expected = new Piece[] { board.Get(c02) };
var piece = board.Get(c11);
var obstacles = logic.GetObstaclesAbove(piece);
CollectionAssert.AreEqual(expected, obstacles);
}
public void MovesSearchDoesNotChangeBoard()
{
var board = boardGen.GenerateRandom(8, 4);
var logic = new PlayLogic(board);
var clone = board.Clone();
logic.AvailableMoves();
Assert.IsTrue(clone.Matches(board), "board matches after searching for available moves");
}
public void NoObstaclesAbove()
{
var board = builder.FromTypeGrid("0102 1011 1221 0120");
var logic = new PlayLogic(board);
foreach (var piece in board.Pieces.Keys)
{
CollectionAssert.IsEmpty(logic.GetObstaclesAbove(piece));
}
}
void AvailableMovesAreValid(Board board, int fromType, int numTypes)
{
var game = new Game(board, GameRules.ClassicRules, PieceType.GetRange(fromType, numTypes));
var logic = new PlayLogic(board);
foreach (var move in logic.AvailableMoves())
{
System.Console.WriteLine("move: " + move);
game.Execute(move);
game.Undo();
}
}
public PlayResponse Play(string gameId, int playerId, Book request)
{
var logic = (LogicContainer)HttpContext.Current.Cache[gameId + playerId];
var play = new PlayLogic(gameId, logic, request).Play(out logic);
logic.HandCards.Remove(play);
HttpContext.Current.Application[gameId + playerId] = logic;
return(new PlayResponse {
card = play.ToString()
});
}
public void FindsDroppablesAboveDouble()
{
var board = builder.FromTypeGrid("0101 1101 1100 1110");
var logic = new PlayLogic(board);
var expected = Coord.SquareRange(c02, 2).Select(c => board.Get(c));
var pieceCoords = Coord.SquareRange(c00, 2);
foreach (var coord in pieceCoords)
{
var droppables = logic.GetDroppablesAbove(board.Get(coord));
CollectionAssert.AreEquivalent(expected, droppables);
}
}
public void SpecialCaseAvailableMoves()
{
var board = builder.FromTypeGrid("0111 0011 1100 1100");
board.RotateRight();
var game = new Game(board, GameRules.ClassicRules, PieceType.GetRange(0, 2));
var logic = new PlayLogic(board);
foreach (var move in logic.AvailableMoves())
{
game.Execute(move);
game.Undo();
}
Assert.Pass("All moves could be done");
}
public void CanAlwaysSimulateAvailableMovesRnd()
{
for (int i = 0; i < 10; i++)
{
var board = generator.GenerateRandom(8, 3);
var game = new Game(board, GameRules.ClassicRules, PieceType.GetRange(0, 3));
var logic = new PlayLogic(board);
var moves = logic.AvailableMoves();
foreach (var move in moves)
{
var simulator = MoveSimulator.FromPotentialMove(board, move, game.NextPieceIfPlaying(move));
simulator.Simulate();
Assert.IsTrue(simulator.IsMovePossible());
}
}
}
public void NotDroppableIfNotAligned()
{
var board = builder.FromTypeGrid(new int[, ] {
{ 0, 1, 2, 2 },
{ 1, 1, 2, 2 },
{ 1, 0, 0, 1 },
{ 0, 0, 0, 1 }
});
var logic = new PlayLogic(board);
var bigPiece = board.Get(c22);
foreach (var piece in board.GetAll(c10, c20, c11, c21))
{
var droppables = logic.GetDroppablesAbove(piece);
CollectionAssert.DoesNotContain(droppables, bigPiece);
}
}
public void AvailableMovesAreSameWhenRotating()
{
var board = builder.FromTypeGrid("0111 0011 1100 1100");
var movesTop = new PlayLogic(board).AvailableMoves();
board.RotateTo(Orientation.Right);
var movesRight = new PlayLogic(board).AvailableMoves();
board.RotateTo(Orientation.Left);
var movesLeft = new PlayLogic(board).AvailableMoves();
board.RotateTo(Orientation.Bottom);
var movesBottom = new PlayLogic(board).AvailableMoves();
CollectionAssert.AreEquivalent(movesTop, movesRight);
CollectionAssert.AreEquivalent(movesTop, movesLeft);
CollectionAssert.AreEquivalent(movesTop, movesBottom);
}
public void AlonePieces()
{
var board = builder.FromTypeGrid(new int[, ] {
{ 0, 1, 2, 0 },
{ 1, 1, 0, 2 },
{ 1, 2, 1, 1 },
{ 0, 1, 1, 0 }
});
var logic = new PlayLogic(board);
foreach (var coord in new Coord[] { c00, c11, c22 })
{
Assert.IsTrue(logic.IsAlone(coord));
}
foreach (var coord in new Coord[] { c01, c02, c12 })
{
Assert.IsFalse(logic.IsAlone(coord));
}
}
public void PiecesInAvailableMovesAreAlone()
{
var board = builder.FromTypeGrid(new int[, ] {
{ 0, 1, 2, 0 },
{ 1, 0, 0, 2 },
{ 1, 1, 1, 2 },
{ 0, 1, 1, 2 }
});
var logic = new PlayLogic(board);
var moves = logic.AvailableMoves();
var orientation = board.Orientation;
foreach (var move in moves)
{
board.RotateTo(move.orientation);
var matchingPieces = board.GetMatchingNeighbours(board.Get(move.coord));
Assert.IsEmpty(matchingPieces);
board.RotateTo(orientation);
}
}
public void NewPieceHasExpectedSize()
{
var board = builder.FromTypeGrid(new int[, ] {
{ 0, 1, 2, 0 },
{ 2, 1, 0, 2 },
{ 1, 2, 1, 1 },
{ 0, 1, 1, 1 }
});
var game = new Game(board, GameRules.ClassicRules, PieceType.GetRange(0, 3));
var logic = new PlayLogic(board);
foreach (var move in logic.AvailableMoves())
{
var simulator = MoveSimulator.FromPotentialMove(board, move, game.NextPieceIfPlaying(move));
simulator.Simulate();
var actions = simulator.GetMove().consequences;
var newPieceAction = actions.First(IsNewPieceAction) as NewPieceAction;
Assert.AreEqual(simulator.oldPiece.size, newPieceAction.newPiece.size);
}
}
public void FindsDroppablesAbove()
{
var board = builder.FromTypeGrid(new int[, ] {
{ 0, 1, 2, 0 },
{ 1, 1, 0, 2 },
{ 1, 2, 1, 1 },
{ 0, 1, 1, 1 }
});
var logic = new PlayLogic(board);
var tests = new Dictionary <Coord, Coord[]> {
{ c00, new Coord[] { c01, c02, c03 } },
{ c02, new Coord[] { c03 } },
{ c11, new Coord[] { c12, c13 } },
{ c20, new Coord[] { c22, c23, c32, c33 } }
};
foreach (var coord in tests.Keys)
{
var droppables = logic.GetDroppablesAbove(board.Get(coord));
var expected = board.GetAll(tests[coord]);
CollectionAssert.AreEquivalent(expected, droppables);
}
}
public void FallActionsFallPieceSizeRnd()
{
for (int i = 0; i < 50; i++)
{
var board = generator.GenerateRandom(4, 3);
var game = new Game(board, GameRules.ClassicRules, PieceType.GetRange(0, 3));
var logic = new PlayLogic(board);
foreach (var potentialMove in logic.AvailableMoves())
{
var simulator = MoveSimulator.FromPotentialMove(board, potentialMove, game.NextPieceIfPlaying(potentialMove));
simulator.Simulate();
var move = simulator.GetMove();
var fallActions = move.consequences.Where(IsFallAction);
foreach (var action in fallActions)
{
var orientatedCoord = board.TransportCoord(potentialMove.coord, potentialMove.orientation);
var removedPiece = board.Get(orientatedCoord);
Assert.AreEqual(removedPiece.size, (action as FallAction).rows,
"Fall Action:\n" + action + ",\nboard:\n" + board + "\nmove:\n" + potentialMove);
}
}
}
}
void Awake()
{
m_Instance = this;
topLimitParentObject = GameObject.Find(ConstantValue.TopLimitParenObjectName);
}
