chess_game 0.0.11

data/spec/board_spec.rb

@@ -0,0 +1,206 @@
+require_relative '../lib/chess/board.rb'
+
+describe Board do
+
+  before { @board = Board.new }
+
+  it { should respond_to :board }
+  it { should respond_to :piece_between? }
+
+  describe "algebraic notation" do
+
+    it "should respond to algebraic notation" do
+      @board.board["A1"] = "Hello"
+      expect(@board.board["A1"]).to eq("Hello")
+    end
+
+    it "should return nil if the hash is out of bounds" do
+      expect(@board.board["Z8"]).to be nil
+    end
+
+    it "should not be nil if the hash is in bounds" do
+      expect(@board.board["A1"]).to_not be nil
+    end
+
+  end
+
+  describe "setting up the game" do
+
+    it "should have a pawn on A2" do
+      expect(@board.board["A2"]).to be_a(Pawn)
+    end
+
+    it "should have a queen on D8" do
+      expect(@board.board["D8"]).to be_a(Queen)
+    end
+
+    it "should be empty on D4" do
+      expect(@board.board["D4"]).to eq(" ")
+    end
+
+  end
+
+  it "should be able to set pieces on the board" do
+    @white_pawn = Pawn.new("white", "D4")
+    @board.set_piece(@white_pawn)
+    expect(@board.board["D4"]).to eq(@white_pawn)
+  end
+
+  it "should be able to remove pieces from the board" do
+    @board.rv_piece("E5")
+    expect(@board.board["E5"]).to eq(" ")
+  end
+
+  describe "making moves" do
+
+    it "should know when a notation refers to a spot off the board" do
+      expect(@board.on_board?("Z1")).to be_falsey
+    end
+
+    it "should know when a notation refers to a spot on the board" do
+      expect(@board.on_board?("A1")).to be_truthy
+    end
+
+    describe "knowing which squares are between two locations" do
+
+      it "should be able to see the squares between on a veritcal move" do
+        expect(squares_between("A1", "A5")).to eq(["A2", "A3", "A4"])
+      end
+
+      it "should be able to see the squares between on a horizontal move" do
+        expect(squares_between("H8", "C8")).to eq(["G8", "F8", "E8", "D8"])
+      end
+
+      it "should be albe to see the squares between on a diagonal move" do
+        expect(squares_between("H8", "C3")).to eq(["G7", "F6", "E5", "D4"])
+      end
+
+    end
+
+    describe "return value" do
+      it "should return the square a piece moved to" do
+        expect(@board.move("B8", "A6")).to eq("A6")
+      end
+
+      it "should not return the square if the move is bad" do
+        expect(@board.move("B8", "B6")).to_not eq("B6")
+      end
+    end
+
+    describe "piece between" do
+      it "should know when pieces are in between two locations" do
+        expect(@board.piece_between?("A1", "A3")).to be_truthy
+      end
+
+      it "should know when there are no pieces in between two locations" do
+        expect(@board.piece_between?("A2", "A4")).to be_falsey
+      end
+    end
+
+    describe "for white pawn" do
+
+      before { @board.move("D2", "D4") }
+
+      it "should be able to move a white pawn two spaces forward" do
+        expect(@board.board["D4"]).to be_a(Pawn)
+      end
+
+      it "should not be able to move a white pawn two spaces on the next turn" do
+        @board.move("D4", "D6")
+        expect(@board.board["D6"]).to eq(" ")
+      end
+
+      it "should be able to move a white pawn one space on the next turn" do
+        @board.move("D4", "D5")
+        expect(@board.board["D5"]).to be_a(Pawn)
+      end
+    end
+
+    describe "for a white knight" do
+
+      it "should be able to jump the front row of pawns" do
+        @board.move("B1", "A3")
+        expect(@board.board["A3"]).to be_a(Knight)
+      end
+
+      it "should not be able to take its own color" do
+        @board.move("B1", "D2")
+        expect(@board.board["D2"]).to be_a(Pawn)
+      end
+
+      describe "taking an opposing color" do
+        before do
+          @board.move("B1", "A3")
+          @board.move("A3", "B5")
+          @board.move("B5", "C7")
+          @knight = @board.board["C7"]
+        end
+
+        it "should have a white piece on the square" do
+          expect(@knight.color).to eq("white")
+        end
+
+        it "should be be a knight" do
+          expect(@knight).to be_a(Knight)
+        end
+      end
+    end
+
+    describe "undoing moves" do
+
+      it "should be able to undo moves" do
+        @board.move("D2", "D4")
+        @board.undo_last_move
+        expect(@board["D2"]).to be_a(Pawn)
+        expect(@board["D2"].moves).to eq(0)
+      end
+
+    end
+  end
+
+  describe "pawn promotion" do
+
+    before do
+      @board = Board.new
+      @promote = Pawn.new("white", "A8")
+      @board.set_piece(@promote)
+    end
+
+    it "should be able to promote to a queen" do
+      @board.promote("A8", :queen)
+      expect(@board["A8"]).to be_a(Queen)
+    end
+
+    it "should be able to promote to a Knight" do
+      @board.promote("A8", :knight)
+      expect(@board["A8"]).to be_a(Knight)
+    end
+
+    it "should be able to promote to a Bishop" do
+      @board.promote("A8", :bishop)
+      expect(@board["A8"]).to be_a(Bishop)
+    end
+
+    it "should be able to promote to a Rook" do
+      @board.promote("A8", :rook)
+      expect(@board["A8"]).to be_a(Rook)
+    end
+
+    it "should not be able to promote to a King" do
+      @board.promote("A8", :king)
+      expect(@board["A8"]).to_not be_a(King)
+    end
+
+    it "should know when a piece can be promoted" do
+      expect(@board.piece_to_promote?).to eq(@promote)
+    end
+
+  end
+
+  it "should be able to clear the board" do
+    @board.clear
+    pieces = @board.board.select{ |square, piece| piece.is_a?(Piece)}
+    expect(pieces.empty?).to be_truthy
+  end
+
+end

data/spec/game_spec.rb

@@ -0,0 +1,32 @@
+require_relative "../lib/chess/game.rb"
+require 'spec_helper'
+
+describe Game do
+
+  before { @game = Game.new }
+
+  it "should be able to save and load the game" do
+    @game.save("game.dat")
+    @same_game = Game.load("game.dat")
+    expect(@game.board.to_a).to eq(@same_game.board.to_a)
+  end
+
+  it "should keep a record of moves made" do
+    @game.move("D2", "D4")
+    expect(@game.movelist.first == "#{Pawn::WHITE_PAWN_ICON} D2 D4")
+  end
+
+  it "should allow moves of the player whose turn it is" do
+    expect(@game.move("D2", "D4")).to be_truthy
+  end
+
+  it "should not allow moves of the wrong player" do
+    expect(@game.move("D7", "D5")).to be_falsey
+  end
+
+  it "should swap the player and opponent" do
+    @game.move("D2", "D4")
+    expect(@game.turn).to eq(@game.black_player)
+  end
+
+end

data/spec/king_spec.rb

@@ -0,0 +1,167 @@
+require_relative '../lib/chess/king.rb'
+require 'spec_helper'
+
+describe King do
+
+  it { should be_a_kind_of(Piece) }
+  it { should respond_to :color }
+  it { should respond_to :location }
+
+  it "should know what its character is" do
+    @king = King.new("White", "A1")
+    expect(@king.icon).to eq("\u2654")
+  end
+
+  describe "valid moves" do
+    before { @king = King.new("white", "D4") }
+    before { @board = Board.new }
+
+    it "should be able to move vertically one position" do
+      expect(@king.valid_move?("D3", @board)).to be_truthy
+    end
+
+    it "should be able to move horizontally one position" do
+      expect(@king.valid_move?("C4", @board)).to be_truthy
+    end
+
+    it "should be able to move diagonally one position" do
+      expect(@king.valid_move?("C3", @board)).to be_truthy
+    end
+
+    it "should not be able to move more than one position" do
+      expect(@king.valid_move?("B2", @board)).to be_falsey
+    end
+
+    describe "castling" do
+
+      before do
+        @board = Board.new
+        @king = @board["E1"]
+        @op_king = @board["E8"]
+        @board.rv_piece("F1")
+        @board.rv_piece("G1")
+      end
+
+      it "should be valid to move twice horizontally on the first move\
+          when there is a rook on that side and no other pieces between" do
+        expect(@king.valid_move?("G1", @board))
+      end
+
+      it "should move the king to the correct location" do
+        @board.move("E1", "G1")
+        expect(@board["G1"]).to be_a(King)
+        expect(@king.location).to eq("G1")
+      end
+
+      it "should move the rook to the correct location" do
+        @board.move("E1", "G1")
+        expect(@board["F1"]).to be_a(Rook)
+      end
+
+      it "should not be able to castle if it is in check" do
+        @board.move("E7", "E6")
+        @board.move("D2", "D3")
+        @board.move("F8", "B4")
+        # king is now in check
+        expect(@king.valid_move?("G1", @board)).to be_falsey
+      end
+
+      it "should not be able to castle into check" do
+        @board.move("E7", "E6")
+        @board.move("D8", "G5")
+        @board.move("G5", "G2")
+        expect(@king.valid_move?("G1", @board)).to be_falsey
+      end
+
+      it "should not be able to pass through a square being attacked" do
+        @board.move("E7", "E6")
+        @board.move("D8", "F6")
+        @board.move("F2", "F3")
+        @board.move("F6", "F3")
+        expect(@king.check?(@board)).to be_falsey
+        expect(@king.valid_move?("G1", @board)).to be_falsey
+        expect(@board["F1"]).to eq(" ")
+      end
+
+      it "should be able to move through empty squares" do
+        @board.move("D2", "D4")
+        @board.move("D7", "D5")
+        @board.move("C1", "E3")
+        @board.move("C8", "E6")
+        @board.move("B1", "C3")
+        @board.move("B8", "C6")
+        @board.move("D1", "D3")
+        @board.move("D8", "D6")
+        expect(@king.valid_move?("C1", @board)).to be_truthy
+        expect(@op_king.valid_move?("C8", @board)).to be_truthy
+        expect(@op_king.valid_move?("C1", @board)).to be_falsey
+        expect(@king.will_be_in_check?(@king.location, "C1", @board)).to be_falsey
+      end
+
+    end
+  end
+
+  describe "in_check?" do
+
+    before do
+      @board = Board.new
+      @black_king = @board["E8"]
+      @white_king = @board["E1"]
+    end
+
+    it "should know when it is in check" do
+      @board.move("C2", "C3")
+      @board.move("D7", "D6")
+      @board.move("D1", "A4")
+      expect(@black_king.check?(@board)).to be_truthy
+    end
+
+    it "should know when it is not in check" do
+      expect(@black_king.check?(@board)).to be_falsey
+    end
+
+    it "should know when it will be in check" do
+      @board.move("E2", "E3")
+      @board.move("F1", "B5")
+      expect(@black_king.will_be_in_check?("D7", "D6", @board)).to be_truthy
+    end
+
+    it "should not be in checkmate if the king is not in check" do
+      expect(@white_king.checkmate?(@board)).to be_falsey
+    end
+
+    it "should know when a check is a checkmate" do
+      @board.move("F2", "F3")
+      @board.move("E7", "E5")
+      @board.move("G2", "G4")
+      @board.move("D8", "H4")
+      expect(@white_king.checkmate?(@board)).to be_truthy
+    end
+
+    it "should know when a check is not a checkmate" do
+      @board.move("F2", "F3")
+      @board.move("E7", "E5")
+      @board.move("G1", "H3")
+      @board.move("D8", "H4")
+      expect(@white_king.checkmate?(@board)).to be_falsey
+    end
+
+    it "should know when a game is a stalemate" do
+      @board.clear
+      @white_king.location = "H1"
+      @white_pawn = Pawn.new("white", "H2")
+      @black_pawn = Pawn.new("black", "H3")
+      @black_rook = Rook.new("black", "G4")
+      @board.set_piece(@black_king)
+      @board.set_piece(@white_king)
+      @board.set_piece(@black_rook)
+      @board.set_piece(@white_pawn)
+      @board.set_piece(@black_pawn)
+      expect(@white_king.checkmate?(@board)).to be_falsey
+      expect(@white_king.stalemate?(@board)).to be_truthy
+    end
+
+
+  end
+
+end

data/spec/knight_spec.rb

@@ -0,0 +1,57 @@
+require_relative '../lib/chess/knight.rb'
+require_relative '../lib/chess/board.rb'
+
+describe Knight do
+
+  it { should be_a_kind_of(Piece) }
+  it { should respond_to :color }
+  it { should respond_to :location }
+
+  it "should know what its character is" do
+    @knight = Knight.new("White", "A1")
+    expect(@knight.icon).to eq("\u2658")
+  end
+
+  describe "valid moves" do
+    before { @knight = Knight.new("white", "D5") }
+    before { @board = Board.new }
+
+    it "should be able to move in an 'L'" do
+      expect(@knight.valid_move?("F6", @board)).to be_truthy
+      expect(@knight.valid_move?("F4", @board)).to be_truthy
+      expect(@knight.valid_move?("E3", @board)).to be_truthy
+      expect(@knight.valid_move?("E7", @board)).to be_truthy
+      expect(@knight.valid_move?("C7", @board)).to be_truthy
+      expect(@knight.valid_move?("B6", @board)).to be_truthy
+      expect(@knight.valid_move?("B4", @board)).to be_truthy
+      expect(@knight.valid_move?("C3", @board)).to be_truthy
+    end
+
+    it "should not be able to move horizontally to any position" do
+      expect(@knight.valid_move?("H4", @board)).to be_falsey
+    end
+
+    it "should not be able to move diagonally" do
+      expect(@knight.valid_move?("B2", @board)).to be_falsey
+    end
+
+    it "should be able to jump pieces" do
+      expect(@board.board["B1"].valid_move?("C3", @board)).to be_truthy
+    end
+
+    it "should be able to block a checkmate" do
+      @board.clear
+      @board.set_piece(King.new("white", "E1"))
+      @board.set_piece(King.new("black", "E8"))
+      @board.set_piece(Queen.new("black", "E7"))
+      @board.set_piece(Knight.new("white", "G1"))
+      @board.set_piece(Pawn.new("white", "D1"))
+      @board.set_piece(Pawn.new("white", "F2"))
+      @board.set_piece(Pawn.new("white", "D2"))
+      @board.set_piece(Rook.new("white", "F1"))
+      @white_king = @board["E1"]
+      expect(@white_king.checkmate?(@board)).to be_falsey
+    end
+  end
+
+end

data/spec/pawn_spec.rb

@@ -0,0 +1,144 @@
+require_relative '../lib/chess/pawn.rb'
+require 'stringio'
+require 'spec_helper'
+
+describe Pawn do
+
+  it { should be_a_kind_of(Piece) }
+  it { should respond_to :color }
+  it { should respond_to :location }
+
+  it "should know what its character is" do
+    @pawn = Pawn.new("White", "A1")
+    expect(@pawn.icon).to eq("\u2659")
+  end
+
+  it "white should print the white pawn character" do
+    @pawn = Pawn.new("white")
+    $stdout = StringIO.new
+    print @pawn
+    expect($stdout.string).to include("\u2659")
+  end
+
+  it "black should print the white pawn character" do
+    @pawn = Pawn.new("black")
+    $stdout = StringIO.new
+    print @pawn
+    expect($stdout.string).to include("\u265F")
+  end
+
+  describe "valid moves" do
+    before do
+      @board = Board.new
+      @white_pawn = @board.board["D2"]
+      @black_pawn = @board.board["D7"]
+    end
+
+    it "should be able to move forward once ordinarility" do
+      expect(@white_pawn.valid_move?("D3", @board)).to be_truthy
+    end
+
+    it "should be able to move forward once ordinarility" do
+      expect(@black_pawn.valid_move?("D6", @board)).to be_truthy
+    end
+
+    it "should be able to move forward twice on the first move" do
+      expect(@white_pawn.valid_move?("D4", @board)).to be_truthy
+    end
+
+    it "should not be able to move forward when the square is occupied" do
+      @opponent = Pawn.new("black", "D3")
+      @board.set_piece(@opponent)
+      expect(@white_pawn.valid_move?("D3", @board)).to be_falsey
+      expect(@white_pawn.valid_move?("D4", @board)).to be_falsey
+    end
+
+
+    it "should not be able to move forward three times" do
+      expect(@white_pawn.valid_move?("D5", @board)).to be_falsey
+    end
+
+    it "should not be able to move left or right" do
+      expect(@white_pawn.valid_move?("C2", @board)).to be_falsey
+    end
+
+    it "should not be able to move diagonally" do
+      expect(@white_pawn.valid_move?("C3", @board)).to be_falsey
+    end
+
+    it "should not be able to move backwards" do
+      expect(@white_pawn.valid_move?("D1", @board)).to be_falsey
+    end
+
+  end
+
+  describe "taking other pieces" do
+
+    it "should be able to move diagonally to take other pieces" do
+      @board = Board.new
+      @white_pawn = @board.board["D2"]
+      @black_pawn = Pawn.new("black", "C3")
+      @board.set_piece(@black_pawn)
+      expect(@white_pawn.valid_move?("C3", @board)).to be_truthy
+    end
+
+    it "should occupy the square it takes a piece from" do
+      @board = Board.new
+      @white_pawn = @board.board["D2"]
+      @black_pawn = Pawn.new("black", "C3")
+      @board.set_piece(@black_pawn)
+      @board.move("D2", "C3")
+      expect(@board["C3"]).to eq(@white_pawn)
+    end
+
+    describe "captureing pieces en passant" do
+      before do
+        @board = Board.new
+        @white_pawn = @board.board["D2"]
+        @black_pawn = @board.board["E7"]
+        @board.move("D2", "D4")
+        @board.move("D4", "D5")
+        @board.move("E7", "E5")
+      end
+
+      it "should return the square of the passed piece" do
+        expect(@white_pawn.en_passant?("E6", @board)).to eq("E5")
+      end
+
+      it "should remove the passed piece from the board" do
+        @board.move("D5", "E6")
+        expect(@board["E5"]).to eq(" ")
+      end
+
+      it "should place the pawn in the moved-to location" do
+        @board.move("D5", "E6")
+        expect(@board["E6"]).to be_a(Pawn)
+      end
+
+      it "should only be able to pass a just-moved piece" do
+        @board.move("A2", "A4")
+        @board.move("A7", "A5")
+        expect(@board.move("D5", "E6")).to be_falsey
+      end
+    end
+  end
+
+  describe "upgrading pawns" do
+
+    before do
+      @board = Board.new
+      @white_pawn = Pawn.new("white", "A8")
+      @white_rook = Rook.new("white", "H8")
+      @board.set_piece(@white_pawn)
+    end
+
+    it "should be able to promote when on last rank" do
+      expect(@white_pawn.can_promote?).to be_truthy
+    end
+
+    it "should not be able to promote a non-pawn piece" do
+      expect(@white_rook.can_promote?).to be_falsey
+    end
+
+  end
+end

data/spec/piece_spec.rb

@@ -0,0 +1,43 @@
+require_relative '../lib/chess/piece.rb'
+
+describe Piece do
+
+  it { should respond_to :color }
+  it { should respond_to :location }
+  it { should respond_to :move }
+
+  describe "validating moves" do
+
+    # see specific piece specs
+
+  end
+
+  it "should know if another piece is an opponent" do
+    @black_piece = Piece.new("black", "A1")
+    @white_piece = Piece.new("white", "A2")
+    expect(@black_piece.opponent?(@white_piece)).to be_truthy
+    expect(@black_piece.opponent?(@black_piece)).to be_falsey
+  end
+
+  it "should know who its fearless leader (king) is" do
+    @board = Board.new
+    @piece = @board["A1"]
+    expect(@piece.my_king(@board)).to be_a(King)
+  end
+
+  describe "rank and file" do
+    before do
+      @board = Board.new
+      @piece = @board["A1"]
+    end
+
+    it "should know what the piece's file is" do
+      expect(@piece.file).to eq("A")
+    end
+
+    it "should know what the piece's rank is" do
+      expect(@piece.rank).to eq("1")
+    end
+  end
+
+end

data/spec/player_spec.rb

@@ -0,0 +1,47 @@
+require_relative "../lib/chess/player.rb"
+require_relative "../lib/chess/board.rb"
+
+describe Player do
+
+  it { should respond_to :color }
+  it { should respond_to :move }
+
+  describe "making moves" do
+    before do
+      @board = Board.new
+      @w_player = Player.new("white")
+      @b_player = Player.new("black")
+    end
+    it "should be able to move its own color" do
+      @w_player.move("D2", "D3", @board)
+      expect(@board["D3"]).to be_a(Pawn)
+    end
+    it "should not be able to move the other player's pieces" do
+      @w_player.move("D7", "D6", @board)
+      expect(@board["D6"]).to eq(" ")
+    end
+  end
+
+  it "should know which piece is their king" do
+    @board = Board.new
+    @w_player = Player.new("white")
+    @b_player = Player.new("black")
+    @w_king = @w_player.king(@board)
+    @b_king = @b_player.king(@board)
+    expect(@w_king).to be_a(King)
+    expect(@b_king).to be_a(King)
+    expect(@w_king.location).to eq("E1")
+    expect(@b_king.location).to eq("E8")
+  end
+
+  it "should not let the player make a move that puts the king in check" do
+    @board = Board.new
+    @w_player = Player.new("white")
+    @b_player = Player.new("black")
+    @w_player.move("E2", "E3", @board)
+    @w_player.move("F1", "B5", @board)
+    expect(@b_player.move("D7", "D6", @board)).to_not eq("D6")
+  end
+
+
+end