/// <summary>
/// Override the play.
/// </summary>
public override void Play()
{
this.Engine.Render.ShowWelcomeScreen();
var boardBuilder = new BoardBuilder(this.Engine.RowCount, this.Engine.ColumnCount);
this.Engine.Board = boardBuilder.Generate(this.Engine.MineCount);
this.Engine.Render.ShowBoard(this.Engine.Board);
var command = this.Engine.Render.SetCommand(this.Engine.CommandFactory);
command.Execute();
}
public void ShouldMove(Position newPosition)
{
var board = BoardBuilder.New().Build();
board.ClearBoard();
var bishop = BishopBuilder.New().WithBoard(board).Build();
board.AddPiece(bishop);
var moved = bishop.Move(newPosition);
Assert.True(moved && bishop.Position.Equals(newPosition) && bishop.QuantityMove > 0);
}
public void ShouldMove(Position actualPosition, Position newPosition, EColor color)
{
var board = BoardBuilder.New().Build();
board.ClearBoard();
var pawn = PawnBuilder.New().WithColor(color).WithPosition(actualPosition).WithBoard(board).Build();
board.AddPiece(pawn);
var moved = pawn.Move(newPosition);
Assert.True(moved && pawn.Position.Equals(newPosition) && pawn.QuantityMove == 1);
}
static void Main(string[] args)
{
/*var host = Dns.GetHostEntry(Dns.GetHostName());
* foreach (var ip in host.AddressList) {
* if (ip.AddressFamily == AddressFamily.InterNetwork) {
* Console.WriteLine(ip.ToString());
* }
* }
* throw new Exception("No network adapters with an IPv4 address in the system!");*/
/*ConnectionForm m = new ConnectionForm();
* m.Show();*/
/*Application.EnableVisualStyles();
* Application.SetCompatibleTextRenderingDefault(false);
* Application.Run(new InitialForm());*/
//singleton
GameController.Instance.netListener = new Net.NetListener();
//factory
Checker.Checker c1 = CheckerFactory.CreateChecker("Pawn", Color.Green, 0, 0);
//prototype (deep clone)
Checker.Checker c2 = (Checker.Checker)c1.Clone();
Console.WriteLine(c1.color == c2.color);
//prototype (shallow clone)
ClassicBoard classicBoard1 = new ClassicBoard(Color.DarkRed, Color.WhiteSmoke, 10);
ClassicBoard classicBoard2 = (ClassicBoard)classicBoard1.Clone();
Console.WriteLine(classicBoard1.subject == classicBoard2.subject);
//builder
BoardBuilder builder = new BoardBuilder();
builder.addFirstColor(Color.Red);
builder.addSecondColor(Color.White);
GameBoard board = builder.getBoard(10, 10);
// command
Checker.Checker ch = new Checker.Checker(Color.Black, 2, 2, CheckerType.Pawn);
Command command = new MoveDownLeftCommand(ch);
command.Execute();
command = new MoveDownRightCommand(ch);
command.Execute();
Console.ReadLine();
}
public void ShouldMove(Position newPosition)
{
var board = BoardBuilder.New().Build();
board.ClearBoard();
var knight = KnightBuilder.New().WithColor(EColor.Black).WithBoard(board).Build();
board.AddPiece(knight);
var moved = knight.Move(newPosition);
Assert.True(moved && knight.Position.Equals(newPosition) && knight.QuantityMove > 0);
}
public void ShouldAddPiece()
{
var board = BoardBuilder.New().Build();
board.ClearBoard();
var pawn = PawnBuilder.New().Build();
board.AddPiece(pawn);
var existisPieceOnBoard = board.Pieces.Any(p => p.Equals(pawn));
Assert.True(existisPieceOnBoard);
}
public void ShouldNotMove(Position newPosition)
{
var board = BoardBuilder.New().Build();
board.ClearBoard();
var bishop = BishopBuilder.New().WithBoard(board).Build();
var actualPosition = bishop.Position;
board.AddPiece(bishop);
var notMoved = !bishop.Move(newPosition);
Assert.True(notMoved && bishop.Position.Equals(actualPosition) && bishop.QuantityMove == 0);
}
public void ShouldNotMoveWithPiecesOnBoard(Position positionPieceToAddBoard, EColor colorPieceToAddBoard, Position actualPosition, EColor color, Position newPosition)
{
var board = BoardBuilder.New().Build();
board.ClearBoard();
var pieceToAddBoard = PawnBuilder.New().WithPosition(positionPieceToAddBoard).WithColor(colorPieceToAddBoard).WithBoard(board).Build();
board.AddPiece(pieceToAddBoard);
var pawn = PawnBuilder.New().WithColor(color).WithPosition(actualPosition).WithBoard(board).Build();
var notMoved = !pawn.Move(newPosition);
Assert.True(notMoved && pawn.Position.Equals(actualPosition) && pawn.QuantityMove == 0);
}
public void ShouldNotMove(Position newPosition)
{
var actualPosition = new Position(EColumn.D, ELine.Four);
var board = BoardBuilder.New().Build();
board.ClearBoard();
var rook = RookBuilder.New().WithColor(EColor.White).WithPosition(actualPosition).WithBoard(board).Build();
board.AddPiece(rook);
var notMoved = !rook.Move(newPosition);
Assert.True(notMoved && rook.Position.Equals(actualPosition) && rook.QuantityMove == 0);
}
public void ShouldMoveWithPiecesOnBoard(Position positionPieceToAddBoard, EColor colorPieceToAddBoard, Position newPosition)
{
var board = BoardBuilder.New().Build();
board.ClearBoard();
var pieceToAddBoard = PawnBuilder.New().WithPosition(positionPieceToAddBoard).WithColor(colorPieceToAddBoard).WithBoard(board).Build();
board.AddPiece(pieceToAddBoard);
var rook = RookBuilder.New().WithColor(EColor.White).WithPosition(new Position(EColumn.D, ELine.Four)).WithBoard(board).Build();
var moved = rook.Move(newPosition);
Assert.True(moved && rook.Position.Equals(newPosition) && rook.QuantityMove > 0);
}
public void ShouldMoveWithPiecesOnBoard(Position positionPieceToAddBoard, EColor colorPieceToAddBoard, Position newPosition)
{
var board = BoardBuilder.New().Build();
board.ClearBoard();
var pieceToAddBoard = KnightBuilder.New().WithPosition(positionPieceToAddBoard).WithColor(colorPieceToAddBoard).WithBoard(board).Build();
board.AddPiece(pieceToAddBoard);
var knight = KnightBuilder.New().WithColor(EColor.Black).WithBoard(board).Build();
var moved = knight.Move(newPosition);
Assert.True(moved && knight.Position.Equals(newPosition) && knight.QuantityMove > 0);
}
public void ShouldNotMove(Position newPosition)
{
var board = BoardBuilder.New().Build();
board.ClearBoard();
var king = KingBuilder.New().WithBoard(board).Build();
var actualPosition = king.Position;
board.AddPiece(king);
var notMoved = !king.Move(newPosition);
Assert.True(notMoved && king.Position.Equals(actualPosition) && king.QuantityMove == 0);
}
public void ShouldMoveWithPiecesOnBoard(Position positionPieceToAddBoard, EColor colorPieceToAddBoard, Position newPosition)
{
var board = BoardBuilder.New().Build();
board.ClearBoard();
var pieceToAddBoard = QueenBuilder.New().WithPosition(positionPieceToAddBoard).WithColor(colorPieceToAddBoard).WithBoard(board).Build();
board.AddPiece(pieceToAddBoard);
var queen = QueenBuilder.New().WithBoard(board).Build();
var moved = queen.Move(newPosition);
Assert.True(moved && queen.Position.Equals(newPosition) && queen.QuantityMove > 0);
}
public void ShouldNotMove(Position newPosition)
{
var board = BoardBuilder.New().Build();
board.ClearBoard();
var queen = QueenBuilder.New().WithBoard(board).Build();
var actualPosition = queen.Position;
board.AddPiece(queen);
var notMoved = !queen.Move(newPosition);
Assert.True(notMoved && queen.Position.Equals(actualPosition) && queen.QuantityMove == 0);
}
protected TileMover SetupBasicField(BoardSize size)
{
GameObject gameSize = new GameObject("GameSize");
{
GameOption settings = gameSize.AddComponent <GameOption>();
settings.Option = new SizeSelector.GameSize()
{
X = size.X, Y = size.Y, Name = "test"
};
}
GameObject root = new GameObject("root");
{
root.AddComponent <Canvas>();
}
GameObject tile = new GameObject("Tile", new[] { typeof(Tile), typeof(Image) });
{
GameObject text = new GameObject("text", new[] { typeof(Text) });
text.transform.SetParent(tile.transform);
Tile t = tile.GetComponent <Tile>();
Image img = tile.GetComponent <Image>();
Text txt = text.GetComponent <Text>();
t.setSerials(img, txt);
}
GameObject builder = new GameObject("board", new[] { typeof(RectTransform) });
builder.transform.SetParent(root.transform);
BoardBuilder bld = builder.AddComponent <BoardBuilder>();
bld.setPrefab(tile);
TileMover mover = builder.AddComponent <TileMover>();
mover.AddStyle(new TileStyle {
Color = Color.yellow, score = 2, SecondaryTextColour = false
});
mover.AddStyle(new TileStyle {
Color = Color.red, score = 4, SecondaryTextColour = false
});
mover.Score = 1;
mover.AddUnknownStyle(new TileStyle {
Color = Color.black, score = 4, SecondaryTextColour = true
});
return(mover);
}
public void ShouldKillPiece()
{
var board = BoardBuilder.New().Build();
board.ClearBoard();
var pawn = PawnBuilder.New().WithBoard(board).Build();
board.AddPiece(pawn);
board.KillPiece(pawn);
var removedPiecefromBoard = !board.Pieces.Any(p => p.Equals(pawn));
var pieceIsDead = board.DeadPieces.Any(p => p.Equals(pawn));
Assert.True(removedPiecefromBoard && pieceIsDead);
}
public void BuildBoard_ShouldBuildBoardCorrectly()
{
var board = BoardBuilder.buildBoard(2);
var map = board.Map;
Assert.NotNull(map['A'][0]);
Assert.NotNull(map['A'][1]);
Assert.NotNull(map['B'][0]);
Assert.NotNull(map['B'][1]);
Assert.AreEqual(map['A'][0].Key, "A1");
Assert.AreEqual(map['A'][1].Key, "A2");
Assert.AreEqual(map['B'][0].Key, "B1");
Assert.AreEqual(map['B'][1].Key, "B2");
}
public void ShouldUndoMove()
{
var board = BoardBuilder.New().Build();
board.ClearBoard();
var firstPosition = new Position(EColumn.B, ELine.Two);
var pawn = PawnBuilder.New().WithPosition(firstPosition).WithBoard(board).Build();
board.AddPiece(pawn);
var moved = pawn.Move(new Position(EColumn.B, ELine.Four));
pawn.UndoMove();
Assert.True(moved && pawn.Position.Equals(firstPosition) && pawn.QuantityMove == 0);
}
public void ShouldNotMoveWithPiecesOnBoard(Position positionPieceToAddBoard, EColor colorPieceToAddBoard, Position newPosition)
{
var board = BoardBuilder.New().Build();
board.ClearBoard();
var pieceToAddBoard = KingBuilder.New().WithPosition(positionPieceToAddBoard).WithColor(colorPieceToAddBoard).WithBoard(board).Build();
board.AddPiece(pieceToAddBoard);
var king = KingBuilder.New().WithBoard(board).Build();
var actualPosition = king.Position;
var notMoved = !king.Move(newPosition);
Assert.True(notMoved && king.Position.Equals(actualPosition) && king.QuantityMove == 0);
}
// called from BoardCellController when creating the board
public void Initialize(BoardBuilder parent, int _iPos, int _jPos)
{
boardBuilder = parent;
iPos = _iPos;
jPos = _jPos;
state = BoardCellState.Empty;
cellAnim = gameObject.GetComponentInChildren <CellAnimator>();
animator = cellAnim.GetComponent <Animator>();
cellHighlight = gameObject.GetComponentInChildren <CellHighlight>();
cellBackground = gameObject.GetComponentInChildren <CellBackground>();
cellBackground.Init(iPos, jPos);
}
public BoardViewModel()
{
this.Players = this.InitializePlayers();
this.CurrentPlayer = this.Players[0];
this.scoreCalculator = new ScoreCalculator();
this.gameOverDetector = new GameOverDetector();
this.dialogService = new DialogService();
BoardBuilder boardBuilder = new BoardBuilder();
this.board = boardBuilder.CreateBoard(this.Players);
this.movementFinder = new MovementFinder(this.board);
this.FieldSize = 50;
}
private static GameBoard CreateStartingBoard(IServiceProvider serviceProvider)
{
BoardBuilder boardBuilder = serviceProvider
.GetService <IGameOfLifeFactory>()
!.BoardBuilder;
GameBoard board = boardBuilder.SetSizeX(3)
.SetSizeY(3)
.SetAlive(0, 1)
.SetAlive(1, 1)
.SetAlive(2, 1)
.GetBoard();
return(board);
}
public void TestBishop()
{
IBoardBuilder boardBuilder = new BoardBuilder();
IBoard board = boardBuilder.Columns(8).Rows(8).AddPiece(new Piece(PieceType.BISHOP, new BoardPosition(1, 1), this.whitePlayer)).Build();
IPieceMovementStrategies pms = new ClassicPieceMovementStrategies();
Assert.False(pms.PieceMovementStrategy(board.GetPieceAtPosition(new BoardPosition(1, 1))).GetPossibleMoves(board).Contains(new BoardPosition(1, 1)));
Assert.True(pms.PieceMovementStrategy(board.GetPieceAtPosition(new BoardPosition(1, 1))).GetPossibleMoves(board).Contains(new BoardPosition(7, 7)));
Assert.True(pms.PieceMovementStrategy(board.GetPieceAtPosition(new BoardPosition(1, 1))).GetPossibleMoves(board).Contains(new BoardPosition(0, 0)));
Assert.False(pms.PieceMovementStrategy(board.GetPieceAtPosition(new BoardPosition(1, 1))).GetPossibleMoves(board).Contains(new BoardPosition(7, 0)));
Assert.True(pms.PieceMovementStrategy(board.GetPieceAtPosition(new BoardPosition(1, 1))).GetPossibleMoves(board).Contains(new BoardPosition(5, 5)));
Assert.False(pms.PieceMovementStrategy(board.GetPieceAtPosition(new BoardPosition(1, 1))).GetPossibleMoves(board).Contains(new BoardPosition(1, 4)));
}
public void ShouldNotAddSamePiece(Position positionPieceToAddOnBoard, EColor colorPieceToAddOnBoard)
{
var board = BoardBuilder.New().Build();
board.ClearBoard();
var pieceToAddOnBoard = PawnBuilder.New().WithPosition(positionPieceToAddOnBoard).WithColor(colorPieceToAddOnBoard).Build();
board.AddPiece(pieceToAddOnBoard);
var newPiece = PawnBuilder.New().WithPosition(positionPieceToAddOnBoard).WithColor(colorPieceToAddOnBoard).Build();;
board.AddPiece(newPiece);
var notExistisPieceOnBoard = !board.Pieces.Any(p => p.Equals(newPiece));
Assert.True(notExistisPieceOnBoard);
}
public void StringToTypeGrid()
{
var stringGrid = "1202 2102 1202 0021";
var grid = BoardBuilder.StringToTypeGrid(stringGrid);
Assert.AreEqual(1, grid[0, 0]);
Assert.AreEqual(2, grid[0, 1]);
Assert.AreEqual(0, grid[0, 2]);
Assert.AreEqual(2, grid[0, 3]);
Assert.AreEqual(0, grid[3, 0]);
Assert.AreEqual(0, grid[3, 1]);
Assert.AreEqual(2, grid[3, 2]);
Assert.AreEqual(1, grid[3, 3]);
}
public void Play()
{
isGameEnded = false;
BoardBuilder builder = new BoardBuilder();
board = builder.BuildBoard();
this.timer = new Timer(1000);
timer.Elapsed += OnTimedEvent;
timer.Elapsed += DecreaseTimerInterval;
timer.AutoReset = true;
timer.Enabled = true;
timer.Start();
isRunning = true;
StartInputPeriod();
}
public void TestQueenCaptureAndMovement()
{
IBoardBuilder boardBuilder = new BoardBuilder();
IBoard board = boardBuilder.Columns(8).Rows(8)
.AddPiece(new Piece(PieceType.QUEEN, new BoardPosition(0, 0), this.whitePlayer))
.AddPiece(new Piece(PieceType.ROOK, new BoardPosition(2, 0), this.blackPlayer))
.Build();
IPieceMovementStrategies pms = new ClassicPieceMovementStrategies();
//Test that the queen can eat the rook
Assert.True(pms.PieceMovementStrategy(board.GetPieceAtPosition(new BoardPosition(0, 0))).GetPossibleMoves(board).Contains(new BoardPosition(2, 0)));
//But cant go past it
Assert.False(pms.PieceMovementStrategy(board.GetPieceAtPosition(new BoardPosition(0, 0))).GetPossibleMoves(board).Contains(new BoardPosition(3, 0)));
}
public void TestKnight()
{
IBoardBuilder boardBuilder = new BoardBuilder();
IBoard board = boardBuilder
.Columns(8)
.Rows(8)
.AddPiece(new Piece(PieceType.KNIGHT, new BoardPosition(3, 3), this.whitePlayer))
.Build();
IPieceMovementStrategies pms = new ClassicPieceMovementStrategies();
Assert.False(pms.PieceMovementStrategy(board.GetPieceAtPosition(new BoardPosition(3, 3))).GetPossibleMoves(board).Contains(new BoardPosition(3, 5)));
Assert.True(pms.PieceMovementStrategy(board.GetPieceAtPosition(new BoardPosition(3, 3))).GetPossibleMoves(board).Contains(new BoardPosition(1, 4)));
Assert.False(pms.PieceMovementStrategy(board.GetPieceAtPosition(new BoardPosition(3, 3))).GetPossibleMoves(board).Contains(new BoardPosition(1, 5)));
}
public void ShouldExchangePieceForAnother()
{
var board = BoardBuilder.New().Build();
var pawn = PawnBuilder.New().WithColor(EColor.White).WithBoard(board).Build();
var position = pawn.Position;
board.AddPiece(pawn);
var knight = KnightBuilder.New().WithColor(EColor.White).WithBoard(board).Build();
board.AddPiece(knight);
board.KillPiece(knight);
board.ExchangePieceForAnother(pawn, knight);
var newKnight = board.GetPieceFromPosition(position);
Assert.True(newKnight != null && newKnight.Position.Equals(position) && !board.Pieces.Any(p => p == knight) && !board.DeadPieces.Any(p => p == knight) && board.DeadPieces.Any(p => p == pawn));
}
public void Builds_initial_board_correctly()
{
var board = BoardBuilder.Build();
Assert.That(board.Dump(), Is.EqualTo(new[]
{
"♜♞♝♛♚♝♞♜",
"♟♟♟♟♟♟♟♟",
" ",
" ",
" ",
" ",
"♙♙♙♙♙♙♙♙",
"♖♘♗♕♔♗♘♖"
}));
}
public void ItBuilds_GameBoard()
{
// Prepare:
var score = new RealScore();
var boardDirector = new BoardDirector(new EasyStrategy(), 0, score, new Position(0, 0), new List <Bullet>());
var builder = new BoardBuilder();
// Act:
boardDirector.Construct(builder);
var board = builder.Build();
// Assert:
Assert.NotNull(board);
Assert.IsType <GameBoard>(board);
}
