public void SendInitializeCommonPiece(BoardPosition position, PieceColor color) { foreach (var subscriber in this._subscribers) { subscriber.InitializeCommonPiece(position, color); } }
// returns all the available moves for a given color public List<MoveResult> GetAllAvailableMoves(PieceColor color) { var availables = new List<MoveResult>(); var listToCheck = color == PieceColor.Black ? Pieces.AlivePlayerOnePieces : Pieces.AlivePlayerTwoPieces; bool anyJumps; //for every living piece of said color for (var i = 0; i < listToCheck.Count; i++) { var piece = listToCheck[i]; anyJumps = false; for (var j = 0; j < availables.Count; j++) { //if any current available moves are a jump, then all future moves are invalid unless they are a jump - force only jump moves var m = availables[j]; if (m.Type == MoveType.Jump) //if the { anyJumps = true; break; } } //append the available moves onto the list availables.AddRange(GetAvailableMovesForPiece(piece, anyJumps)); } // if there are any jumps, you must take a jump if(availables.Any(m => m.Type == MoveType.Jump)) availables.RemoveAll(m => m.Type != MoveType.Jump); return availables; }
private void CheckForCapture(char leftX, char rightX, char y, PieceColor color) { if (this.Board.IsOccupiedSquare(leftX, y, color)) { this.AddValidMove(leftX, y, true); } if (this.Board.IsOccupiedSquare(rightX, y, color)) { this.AddValidMove(rightX, y, true); } // En Passant if (this.Board.EnPassantSquare != null) { if (this.Board.EnPassantSquare.X == leftX && this.Board.EnPassantSquare.Y == y) { this.AddValidMove(leftX, y, true, this.Board[leftX, this.Square.Y].Piece); } if (this.Board.EnPassantSquare.X == rightX && this.Board.EnPassantSquare.Y == y) { this.AddValidMove(rightX, y, true, this.Board[rightX, this.Square.Y].Piece); } } }
public Move(PieceColor color, BoardPosition initialPosition, BoardPosition endingPosition, bool pieceJumped = false, bool pieceCaptured = false) { if (initialPosition.ContainsPiece()) { throw new ArgumentException("Move initial posiiton must not contain a piece"); } if (endingPosition.ContainsPiece()) { throw new ArgumentException("Move ending posiiton must not contain a piece"); } if (pieceCaptured && !pieceJumped) { throw new ArgumentException("Capture moves are required to be configured as a jump move"); } if (!ValidateMove(initialPosition, endingPosition, pieceJumped, pieceCaptured)) { throw new ArgumentException("Invalid move requested"); } this.PieceColor = color; this.PieceJumped = pieceJumped; this.PieceCaptured = pieceCaptured; this.InitialPosition = initialPosition; this.EndingPosition = endingPosition; }
public Piece(PieceType type, PieceColor color, int col, int row, Board board) { this.Col = col; this.Row = row; this.X = col * Game.TILESIZE; this.Y = row * Game.TILESIZE; this.Color = color; this.Board = board; FirstMove = true; SetType(type); this.MouseDown += delegate(object s, MouseButtonEventArgs ev) { if (!Game.GameOver && ((!Game.IsConnected && Game.MyTurn(Color)) || (Game.IsConnected && Game.MainColor == Color && Game.MyTurn()))) { dragging = true; this.Cursor = Cursors.Hand; System.Windows.Controls.Canvas.SetZIndex(this, 1000); } }; this.MouseUp += new MouseButtonEventHandler(image_MouseUp); this.MouseMove += new MouseEventHandler(image_MouseMove); this.MouseLeave += new MouseEventHandler(image_MouseMove); }
private void AssertPieceLoaded(IEngine engine, string coord, Type type, PieceColor color) { var piece = engine.Board[coord].Piece; Assert.IsNotNull(piece); Assert.AreEqual(color, piece.Color); Assert.IsInstanceOfType(piece, type); }
/// <summary> /// Initializes a new instance of the Pawn class. /// </summary> /// <param name="color">Color, white or black, the piece represents.</param> public Pawn(PieceColor color) { m_iterator = new BoardIterator(null, Square.None, Direction.NoDirection); if (color == PieceColor.White) { m_color = PieceColor.White; m_opponentColor = PieceColor.Black; m_directions[0] = Direction.Up; m_directions[1] = Direction.UpLeft; m_directions[2] = Direction.UpRight; moveAgainRow = 2; } if (color == PieceColor.Black) { m_color = PieceColor.Black; m_opponentColor = PieceColor.White; m_directions[0] = Direction.Down; m_directions[1] = Direction.DownLeft; m_directions[2] = Direction.DownRight; moveAgainRow = 5; } }
private static Lines GetConsecutiveLines(Connect4Board b, PieceColor color, int col, Connect4Column move) { int horizontal = 1, vertical = 1, mainDiagonal = 1, antiDiagonal = 1; int nextX, nextY; for (nextX = col + 1, nextY = move.LastDropRow; nextX < Connect4Board.COLUMNS && b.GetPiece(nextY, nextX) == color; nextX++) horizontal++; for (nextX = col - 1; nextX >= 0 && b.GetPiece(nextY, nextX) == color; nextX--) horizontal++; for (nextX = col, nextY = move.LastDropRow + 1; nextY < Connect4Board.ROWS && b.GetPiece(nextY, nextX) == color; nextY++) vertical++; for (nextX = col, nextY = move.LastDropRow - 1; nextY >= 0 && b.GetPiece(nextY, nextX) == color; nextY--) vertical++; for (nextX = col + 1, nextY = move.LastDropRow + 1; nextX < Connect4Board.COLUMNS && nextY < Connect4Board.ROWS && b.GetPiece(nextY, nextX) == color; nextX++, nextY++) mainDiagonal++; for (nextX = col - 1, nextY = move.LastDropRow - 1; nextX >= 0 && nextY >= 0 && b.GetPiece(nextY, nextX) == color; nextX--, nextY--) mainDiagonal++; for (nextX = col + 1, nextY = move.LastDropRow - 1; nextX < Connect4Board.COLUMNS && nextY >= 0 && b.GetPiece(nextY, nextX) == color; nextX++, nextY--) antiDiagonal++; for (nextX = col - 1, nextY = move.LastDropRow + 1; nextX >= 0 && nextY < Connect4Board.ROWS && b.GetPiece(nextY, nextX) == color; nextX--, nextY++) antiDiagonal++; return new Lines(horizontal, vertical, mainDiagonal, antiDiagonal); }
public double Eval(CheckersBoard board, int level, PieceColor playerColor) { { double eval = 0; for (int x = 0; x < board.Width; x++) for (int y = 0; y < board.Height; y++) { var piece = board.GetPieceAt(x, y) as CheckersPiece; if (piece != null) { if (piece.Color == playerColor) { if (piece is Pawn) eval += _ownPawnStrength; else if (piece is Queen) eval += _ownQueenStrength; } else { if (piece is Pawn) eval -= _ownPawnStrength; else if (piece is Queen) eval -= _ownQueenStrength; } } } return eval; } }
public Board(Board b) { this.WhiteBitBoard = b.WhiteBitBoard; this.BlackBitBoard = b.BlackBitBoard; this.CurrentPlayer = b.CurrentPlayer; this.Evaluation = b.Evaluation; }
public ChessPieceViewModel(ChessPiece i_ChessPiece, PieceColor i_PieceColor, PieceSide i_PieceSide, int i_File, int i_Rank) { ChessCoord tempChessCoord = new ChessCoord(); tempChessCoord.File = i_File; tempChessCoord.Rank = i_Rank; m_ChessPieceModel = new ChessPieceModel(i_ChessPiece, i_PieceColor, i_PieceSide, tempChessCoord); }
private static Lines GetConsecutiveLines(OmokBoard b, PieceColor color, Point move) { int horizontal = 1, vertical = 1, mainDiagonal = 1, antiDiagonal = 1; int nextX, nextY; for (nextX = move.X + 1, nextY = move.Y; nextX < OmokBoard.COLUMNS && b.GetPiece(nextY, nextX) == color; nextX++) horizontal++; for (nextX = move.X - 1; nextX >= 0 && b.GetPiece(nextY, nextX) == color; nextX--) horizontal++; for (nextX = move.X, nextY = move.Y + 1; nextY < OmokBoard.ROWS && b.GetPiece(nextY, nextX) == color; nextY++) vertical++; for (nextX = move.X, nextY = move.Y - 1; nextY >= 0 && b.GetPiece(nextY, nextX) == color; nextY--) vertical++; for (nextX = move.X + 1, nextY = move.Y + 1; nextX < OmokBoard.COLUMNS && nextY < OmokBoard.ROWS && b.GetPiece(nextY, nextX) == color; nextX++, nextY++) mainDiagonal++; for (nextX = move.X - 1, nextY = move.Y - 1; nextX >= 0 && nextY >= 0 && b.GetPiece(nextY, nextX) == color; nextX--, nextY--) mainDiagonal++; for (nextX = move.X + 1, nextY = move.Y - 1; nextX < OmokBoard.COLUMNS && nextY >= 0 && b.GetPiece(nextY, nextX) == color; nextX++, nextY--) antiDiagonal++; for (nextX = move.X - 1, nextY = move.Y + 1; nextX >= 0 && nextY < OmokBoard.ROWS && b.GetPiece(nextY, nextX) == color; nextX--, nextY++) antiDiagonal++; return new Lines(horizontal, vertical, mainDiagonal, antiDiagonal); }
/// <summary> /// Instantiate <see cref="Piece"/> /// </summary> /// <param name="type"><see cref="Type"/></param> /// <param name="color"><see cref="Color"/></param> public Piece(PieceType type, PieceColor color) { _type = type; _color = color; Moves = new List<Move>(); Attacked = new List<Square>(); }
public Piece(Square position, Board board, PieceColor color) { this.position = position; this.board = board; this.color = color; this.board.Squares[position] = this; }
public void Whether_Rook_CantJumpOverAnotherPiece_On_CanMoveTo(PieceColor pieceColor) { var board = new Board(); var rook = new Rook(new Square(4, 4), board, PieceColor.White); var knight = new Knight(new Square(4, 5), board, pieceColor); Assert.That(rook.CanMoveTo(new Square(4, 6)), Is.False); }
public Piece(bool belongsToPlayerTwo, Point position, PieceColor color, int sumoness) { BelongsToPlayerTwo = belongsToPlayerTwo; Position = position; Color = color; MaxMoveLength = 7 - 2 * sumoness; Sumoness = sumoness; }
public FixedDepthPlayer(PieceColor c, int depth) : base(c) { if (depth >= 0) maxDepth = depth; else throw new ArgumentException("Depth must be at least 0"); }
public FixedTimePlayer(PieceColor c, int thinkTimeSeconds) : base(c) { if (thinkTimeSeconds > 0) this.thinkTimeSeconds = thinkTimeSeconds; else throw new ArgumentException("Think time must be greater than 0"); }
public void Whether_Queen_CantJumpOverAnotherPiece_On_CanMoveTo(PieceColor pieceColor) { var board = new Board(); var queen = new Queen(new Square(4, 4), board, PieceColor.White); var knight = new Knight(new Square(5, 5), board, pieceColor); Assert.That(queen.CanMoveTo(new Square(6, 6)), Is.False); }
public PgnMove(string pgnString) { Match m = r.Match(pgnString); if (m.Groups["Move"].Value == "") { ColorToPlay = PieceColor.Black; } else { ColorToPlay = PieceColor.White; } if (m.Groups["Castling"].Value == "") { PieceToPlay = StringToPiece(m.Groups["Piece"].Value, ColorToPlay); FromFile = StringToFile(m.Groups["File"].Value); FromRank = StringToRank(m.Groups["Rank"].Value); DestinationSquare = StringToSquare(m.Groups["Destination"].Value); PromotionPiece = StringToPromotion(m.Groups["Promotion"].Value); } else if (m.Groups["Castling"].Value == "O-O") { if (ColorToPlay == PieceColor.White) { DestinationSquare = Square.G1; PieceToPlay = Piece.WhiteKing; FromFile = 4; FromRank = 0; } if (ColorToPlay == PieceColor.Black) { DestinationSquare = Square.G8; PieceToPlay = Piece.BlackKing; FromFile = 4; FromRank = 7; } } else if (m.Groups["Castling"].Value == "O-O-O") { if (ColorToPlay == PieceColor.White) { DestinationSquare = Square.C1; PieceToPlay = Piece.WhiteKing; FromFile = 4; FromRank = 0; } if (ColorToPlay == PieceColor.Black) { DestinationSquare = Square.C8; PieceToPlay = Piece.BlackKing; FromFile = 4; FromRank = 7; } } }
public QueenPiece(PieceColor color, BoardPosition boardPosition) { this._color = color; this._boardPosition = boardPosition; this._blackImage = Image.FromFile(@"E:\Projetos\C#\ucs-xna-rmi-draughts\UCS.XNA.Draughts\UCS.Forms.Draughts\Resources\BlackQueen.png"); this._whiteImage = Image.FromFile(@"E:\Projetos\C#\ucs-xna-rmi-draughts\UCS.XNA.Draughts\UCS.Forms.Draughts\Resources\WhiteQueen.png"); this.InitializeValidMovementsList(); }
public void CalculateValidMoves(PieceColor playerColor) { // TODO: Parallel.ForEach<PieceBase>(this.Pieces, p => p.CalculateValidMoves()); foreach (PieceBase piece in this.Pieces) { if (piece.Color == playerColor) piece.CalculateValidMoves(); } }
public void Start(Position startingPosition, PieceColor playerToMove) { State = GameState.Normal; PlayerToMove = playerToMove; UpdateGameState(new Square(0, 0, new NullPiece(null)), new Square(0, 0, new NullPiece(null)), startingPosition, PlayerToMove.GetOppositeColor()); }
public Piece( PieceType type, PieceColor color ) { if (type == PieceType.None) throw new ArgumentException("Type must be specified"); if (color == PieceColor.None) throw new ArgumentException("Color must be specified"); _type = type; _color = color; }
public void Add(Pawn pawn, int xCoordinate, int yCoordinate, PieceColor pieceColor) { if (IsLegalBoardPosition(xCoordinate, yCoordinate)) { pawn.XCoordinate = xCoordinate; pawn.YCoordinate = yCoordinate; pieces[xCoordinate, yCoordinate] = pawn; } }
public double Eval(CheckersBoard board, int level, PieceColor playerColor) { { double myval = 0; double enemyval = 0; for (int x = 0; x < board.Width; x++) for (int y = 0; y < board.Height; y++) { CheckersPiece piece = board.GetPieceAt(x, y) as CheckersPiece; if (piece != null) { int factor = (piece.Color == PieceColor.White) ? (7 - y) : (y); if (piece.Color == playerColor) { if (piece is Pawn) myval += 100 + (factor * factor); else { myval += 200; if (y == 0) { if (x == 0) myval -= 40; else myval -= 20; } else if (y == 7) { if (x == 7) myval -= 40; else myval -= 20; } } } else { if (piece is Pawn) enemyval += 100 + (factor * factor); else { enemyval += 200; if (y == 0) { if (x == 0) enemyval -= 40; else enemyval -= 20; } else if (y == 7) { if (x == 7) enemyval -= 40; else enemyval -= 20; } } } } } if (enemyval == 0) return 100000 + level * level; else if (myval == 0) return -100000 - level * level; return (myval - enemyval); } }
// Apply a full move to the board // This swaps CurrentPlayer public bool ApplyMove(int xCoord, int yCoord, PieceColor color, Rotation r) { bool placed = this.PlacePieceAt(xCoord, yCoord, color); if (placed) { this.DoRotation(r); this.CurrentPlayer = (color == PieceColor.White) ? PieceColor.Black : PieceColor.White; } return placed; }
/// <summary> /// Gets a player's piece by its color. /// </summary> public Piece GetPieceByColor( PieceColor color ) { //Find piece foreach ( Piece p in pieces ) if ( p.color == color ) return p; //Return first piece if the proper piece could not be found return pieces [ 0 ]; }
public GameState(Player player) { _player = player; if (_player != null) { _myColor = _player.Index == 0 ? PieceColor.Black : PieceColor.White; } _depGameBoard = new Dependent(UpdateGameBoard); }
// change piece's color public void ChangeColor() { if (color == PieceColor.White) { color = PieceColor.Black; transform.renderer.material.color = new Color(0.412F, 0.412F, 0.412F, 1F); } else if (color == PieceColor.Black){ color = PieceColor.White; transform.renderer.material.color = new Color(1.0F, 1.0F, 1.0F, 1.0F); } }
public void ChangeColor(object c) { PieceColor color = (PieceColor)c; ChangeColor(color); }
public Centaur(PieceColor color, Position position) : base(color, PieceType.Centaur, position) { }
public void FindAndMoveKnightWithAmbiguousMove(string knightCoords, string knightCoords2, string moveAN, PieceColor currentPlayer) { //Arange var board = new Board(false); board.AddPiece(knightCoords, new Knight(currentPlayer)); board.AddPiece(knightCoords2, new Knight(currentPlayer)); board.AddPiece("b4", new Rook(PieceColor.White)); //Act Piece knight = board.PlayMove(moveAN, currentPlayer); //Assert Assert.Equal(knight, board.CellAt("b4").Piece); }
public void FindAndMoveKnightWithNoObstacles(string knightCoords, string moveAN, PieceColor currentPlayer) { //Arange var board = new Board(false); board.AddPiece(knightCoords, new Knight(currentPlayer)); //Act var move = MoveNotationConverter.ParseMoveNotation(moveAN, currentPlayer); var knight = board.PlayMove(moveAN, currentPlayer); //Assert Assert.Equal(knight, board.CellAt(move.Coordinate).Piece); Assert.IsType <Knight>(knight); Assert.Null(board.CellAt("d5").Piece); }
/// <inheritdoc/> public Queen(int x, int y, PieceColor color) : base(x, y, color, 9, Piece.Queen) { }
public Queen(PieceColor color, IMovable bishop, IMovable rook) : base(color) { this.Bishop = bishop; this.Rook = rook; }
public Marshall(PieceColor pieceColor, Point position) : base(pieceColor, position) { Image = Image.FromFile(pieceColor == PieceColor.White ? @"Assets/ChessPieces/WhiteMarshall.png" : @"Assets/ChessPieces/BlackMarshall.png"); }
public Rook(PieceColor color, Position position, ImmutableList <Move> moveHistory) : base(PieceType.Rook, color, position, moveHistory) { }
public Bishop(PieceColor color) { Name = "Bishop"; Symbol = 'B'; Color = color; }
/// <summary> /// Small helper to get the mangled key for an image /// </summary> /// <param name="job"></param> /// <param name="color"></param> /// <returns></returns> private static string GetPieceImageKey(PieceClass job, PieceColor color) { return(String.Concat(job.ToString(), color.ToString())); }
public void Add(Pawn pawn, int xCoordinate, int yCoordinate, PieceColor pieceColor) { throw new NotImplementedException("Need to implement ChessBoard.Add()"); }
protected Piece(PieceColor color) { Color = color; }
public void TryParseMove_ParsesPromotion(string input, string expectedStart, string expectedEnd, PieceColor color, SquareContents piece) { var endSq = MoveParser.ParseSquare(expectedEnd); var startSq = MoveParser.ParseSquare(expectedStart); var pieceColor = color == PieceColor.White ? SquareContents.White : SquareContents.Black; var board = BoardState.Empty.SetPiece(startSq, SquareContents.Pawn | pieceColor); var game = new Game(board, color); var result = game.Move(input); var expectedSquare = game.GetSquareContents(endSq.File, endSq.Rank); Assert.That(result, Is.EqualTo(ErrorCondition.None)); Assert.That(expectedSquare, Is.EqualTo(piece)); }
public override void ToString_GivenPieceBase_ShouldReturn(string position, PieceColor pieceColor, char symbol) => this.ToString(CreatePawn(position, pieceColor), position, symbol);
public Queen(PieceColor color) : base(color) { this.Type = ChessPieceType.Queen; }
public Pawn(PieceColor pieceColor) : base(pieceColor, PieceType.Pawn) { }
public Queen(Square position, PieceColor color) { Square = position; IsAlive = true; Color = color; }
public Pawn(int position, PieceColor color) : base(position, color) { Value = PieceValue.Pawn; }
// direction: 14, 12, 32, 36, 74, 78, 98, 96 ; public KnightPiece(int _row, int _column, PieceColor _color, Game _owner) : base(_row, _column, _color, PieceType.Knight, _owner) { CanJump = true; MoveRange = 1; }
public Spider(PieceColor color, int number) : base(color, number) { }
public Pawn(PieceColor color, ChessBoard board) : base(color, board) { MoveStrategy = new PawnAdapterStrategy(MoveCount, Direction, board); }
public Chessboard(string FEN) { PieceBoard = new Piece[8, 8]; string[] data = FEN.Split(' '); string[] pieces = data[0].Split('/'); int row = 0; int col = 0; for (int i = 0; i < pieces.Length; i++) { for (int j = 0; j < pieces[i].Length; j++) { if (Char.IsDigit(pieces[i][j])) { for (int k = 0; k < int.Parse(pieces[i][j].ToString()); k++) { PieceBoard[col, row] = new Empty(new Point(col, row), this, PieceColor.none); col++; } } else { PieceColor color = char.IsUpper(pieces[i][j]) ? PieceColor.white : PieceColor.black; if (char.ToLower(pieces[i][j]) == 'r') { PieceBoard[col, row] = new Rook(new Point(col, row), this, color); } else if (char.ToLower(pieces[i][j]) == 'n') { PieceBoard[col, row] = new Knight(new Point(col, row), this, color); } else if (char.ToLower(pieces[i][j]) == 'b') { PieceBoard[col, row] = new Bishop(new Point(col, row), this, color); } else if (char.ToLower(pieces[i][j]) == 'q') { PieceBoard[col, row] = new Queen(new Point(col, row), this, color); } else if (char.ToLower(pieces[i][j]) == 'k') { PieceBoard[col, row] = new King(new Point(col, row), this, color); } else if (char.ToLower(pieces[i][j]) == 'p') { PieceBoard[col, row] = new Pawn(new Point(col, row), this, color); } col++; } } col = 0; row++; } WhiteOnMove = (data[1][0] == 'w') ? true : false; foreach (char c in data[2]) { if (c == 'K') { WhiteCastlingShort = true; } else if (c == 'Q') { WhiteCastlingLong = true; } else if (c == 'k') { BlackCastlingShort = true; } else if (c == 'q') { BlackCastlingLong = true; } } }
public void FindAndMoveKnightWithObstaclesShouldThrowError(string knightCoords, string obstacleCoords, string moveAN, PieceColor currentPlayer) { //Arange var board = new Board(false); board.AddPiece(knightCoords, new Knight(currentPlayer)); board.AddPiece(obstacleCoords, new Bishop(currentPlayer)); //Act var move = MoveNotationConverter.ParseMoveNotation(moveAN, currentPlayer); //Assert Action exception = () => board.FindPieceWhoNeedsToBeMoved(moveAN, currentPlayer); Assert.Throws <InvalidOperationException>(exception); }
public override void ImplicitOperatorChar_GivenPieceColor_ShouldReturn(PieceColor pieceColor, char expected) => this.ImplicitOperatorChar(CreatePawn("a2", pieceColor), expected);
public bool IsEnemyPiece(PieceColor currentPlayer) { return(GetPieceColor() != currentPlayer); }
public override void ImplicitOperatorPiece_GivenPieceColor_ShouldReturn(PieceColor pieceColor, char symbol) => this.ImplicitOperatorPiece(CreatePawn("a2", pieceColor), symbol);
public HumanEngine(PieceColor color) { Color = color; }
public void ChangeColor(PieceColor c, float time) { new DelayCall().Init(time, c, ChangeColor); }
public Pawn(Point position, Chessboard board, PieceColor color) : base(position, board, color) { Letter = '\0'; }
public PieceBuilder As(PieceColor color) { this.color = color; return(this); }