chess_vwong 0.0.1 → 0.0.2

data/lib/chess_vwong/version.rb

@@ -1,3 +1,3 @@
 module ChessVwong
-  VERSION = "0.0.1"
+  VERSION = '0.0.2'
 end

data/spec/bishop_spec.rb

@@ -1,50 +1,47 @@
-require "spec_helper"
+require 'spec_helper'
 
 module ChessVwong
-  describe Bishop do 
-    let (:current_space) { [1,1]}
-    let (:bishop) { Bishop.new(current_space,"w")}
-    context "#initialize" do
-      it "should return Piece attributes: color" do
-        expect(bishop.color).to eq "w"
+  describe Bishop do
+    let (:current_space) { [1, 1] }
+    let (:bishop) { Bishop.new(current_space, 'w') }
+    context '#initialize' do
+      it 'should return Piece attributes: color' do
+        expect(bishop.color).to eq 'w'
       end
 
-      it "should return Piece attributes: current_space" do
+      it 'should return Piece attributes: current_space' do
         expect(bishop.current_space).to eq current_space
       end
     end
 
-    context "#character" do
-      it "should return a white bishop character" do
-        expect(bishop.character).to eq "\u{265D}"
+    context '#character' do
+      it 'should return a white bishop character' do
+        expect(bishop.character).to eq "\u{2657}"
       end
 
-      it "should return a black bishop character" do
-        bishop_2 = Bishop.new(current_space,"b")
-        expect(bishop_2.character).to eq "\u{2657}"
-      end    
-    end  
+      it 'should return a black bishop character' do
+        bishop_2 = Bishop.new(current_space, 'b')
+        expect(bishop_2.character).to eq "\u{265D}"
+      end
+    end
 
-    context "#generate_neighbours" do
-      it "should return only 7 neighbour when [1,1]" do
+    context '#generate_neighbours' do
+      it 'should return only 7 neighbour when [1,1]' do
         bishop.generate_neighbours(current_space)
         expect(bishop.neighbours.count).to eq 7
       end
 
-      it "should return only 7 neighbour when [8,8]" do
-        current_space = [8,8]
+      it 'should return only 7 neighbour when [8,8]' do
+        current_space = [8, 8]
         bishop.generate_neighbours(current_space)
         expect(bishop.neighbours.count).to eq 7
       end
 
-      it "should return only 13 neighbour when in the middle" do
-        current_space = [3,3]
+      it 'should return only 13 neighbour when in the middle' do
+        current_space = [3, 3]
         bishop.generate_neighbours(current_space)
         expect(bishop.neighbours.count).to eq 11
-      end      
-
+      end
     end
-
-
   end
-end
+end

data/spec/board_spec.rb

@@ -1,293 +1,373 @@
-require "spec_helper"
+require 'spec_helper'
 
 module ChessVwong
-  describe Board do 
-    let (:board) { Board.new}
-    let (:player_1) { Player.new("bob")}
-    let (:player_2) { Player.new("peter", "b")}
-    let (:knight) { Knight.new( [0,0], "w")}
-    let (:knight_2) { Knight.new( [0,0], "b")}
-    let (:rook) { Rook.new( [3,3], "w")}
-    let (:pawn) { Pawn.new( [6,6], "w")}
-    let (:pawn_2) { Pawn.new( [6,6], "b")}
-
-    context "#initialize" do
-      it "sets the grid with 8 rows" do
+  describe Board do
+    let (:board) { Board.new }
+    let (:player_1) { Player.new('bob') }
+    let (:player_2) { Player.new('peter', 'b') }
+    let (:knight) { Knight.new([1, 1], 'w') }
+    let (:knight_2) { Knight.new([1, 1], 'b') }
+    let (:rook) { Rook.new([3, 3], 'w') }
+    let (:rook_2) { Rook.new([1, 1], 'b') }
+    let (:king) { King.new([5, 8], 'w') }
+    let (:king_2) { King.new([5, 1], 'b') }
+    let (:pawn) { Pawn.new([7, 7], 'w') }
+    let (:pawn_2) { Pawn.new([7, 7], 'b') }
+
+    context '#initialize' do
+      it 'sets the grid with 8 rows' do
         expect(board.grid.size).to eq 9
       end
-       
-      it "creates 8 things in each row" do
+
+      it 'creates 8 things in each row' do
         board.grid.each do |row|
-          expect(row.size).to eq 9  
+          expect(row.size).to eq 9
         end
       end
     end
 
-    context "#process_input" do
-      it "should turn A1 to [1,8]" do
-        expect(board.process_input("A1")).to eq [1,8]
+    context '#process_input' do
+      it 'should turn A1 to [1,8]' do
+        expect(board.process_input('A1')).to eq [1, 8]
       end
 
-      it "should turn a1 to [1,8]" do
-        expect(board.process_input("a1")).to eq [1,8]
+      it 'should turn a1 to [1,8]' do
+        expect(board.process_input('a1')).to eq [1, 8]
       end
 
-      it "should turn H7 to [8,2]" do
-        expect(board.process_input("H7")).to eq [8,2]
+      it 'should turn H7 to [8,2]' do
+        expect(board.process_input('H7')).to eq [8, 2]
       end
 
-      it "should turn H1 to [8,8]" do
-        expect(board.process_input("H1")).to eq [8,8]
+      it 'should turn H1 to [8,8]' do
+        expect(board.process_input('H1')).to eq [8, 8]
       end
 
-      it "should turn b2 to [2,7]" do
-        expect(board.process_input("B2")).to eq [2,7]
-      end      
+      it 'should turn b2 to [2,7]' do
+        expect(board.process_input('B2')).to eq [2, 7]
+      end
     end
 
-    context "#get_piece" do
-      it "gets the piece from selected node" do
+    context '#get_piece' do
+      it 'gets the piece from selected node' do
         chosen_node = board.grid[3][2]
         chosen_node.occupied << knight
-        expect(board.get_piece("B6", player_1)).to eq knight
+        expect(board.get_piece('B6', player_1)).to eq knight
       end
 
-      it "it removes piece from selected node" do
+      it 'removes piece from selected node' do
         chosen_node = board.grid[3][2]
         chosen_node.occupied << knight
-        board.get_piece("B6", player_1)
+        board.get_piece('B6', player_1)
         expect(chosen_node.occupied).to eq []
       end
 
-      it "it generates neighbours of selected piece" do
+      it 'generates neighbours of selected piece' do
         chosen_node = board.grid[1][1]
         chosen_node.occupied << knight
-        piece = board.get_piece("A8", player_1)
+        piece = board.get_piece('A8', player_1)
         expect(piece.neighbours.count).to eq 2
       end
 
-
-      it "it generates neighbours of Pawn if enemies nearby" do
+      it 'generates neighbours of Pawn if enemies nearby' do
         chosen_node = board.grid[7][7]
         chosen_node.occupied << pawn
         enemy_node1 = board.grid[6][6]
         enemy_node1.occupied << knight_2
         enemy_node2 = board.grid[6][8]
-        enemy_node2.occupied << knight_2        
-        piece = board.get_piece("G2",player_1)
+        enemy_node2.occupied << knight_2
+        piece = board.get_piece('G2', player_1)
         expect(piece.neighbours.count).to eq 4
       end
 
-      it "it generates neighbours of Pawn if no enemies nearby" do
+      it 'generates neighbours of Pawn if no enemies nearby' do
         chosen_node = board.grid[7][7]
         chosen_node.occupied << pawn
         enemy_node1 = board.grid[6][6]
         enemy_node1.occupied << knight
         enemy_node2 = board.grid[6][8]
-        enemy_node2.occupied << knight        
-        piece = board.get_piece("G2",player_1)
+        enemy_node2.occupied << knight
+        piece = board.get_piece('G2', player_1)
         expect(piece.neighbours.count).to eq 2
       end
 
-      it "it should return nil if no piece found" do
-        expect(board.get_piece("A1", player_1)).to eq nil
-      end      
+      it 'should return nil if no piece found' do
+        expect(board.get_piece('A1', player_1)).to eq nil
+      end
 
+      it "should activate ep_kill to white pawn with enemy on LEFT" do
+        node1 = board.grid[4][2]
+        node2 = board.grid[2][1]
+        node1.occupied << Pawn.new([2, 4], 'w')
+        node2.occupied << Pawn.new([1, 2], 'b')
+
+        board.get_piece('A7', player_2)
+        board.set_piece('A5', player_2)
+        ep_pawn = board.get_piece('B5', player_1)
+        expect(ep_pawn.ep_kill).to eq ["L"]
+      end
+
+      it "should activate ep_kill to white pawn on RIGHT" do
+        node1 = board.grid[4][2]
+        node2 = board.grid[2][3]
+        node1.occupied << Pawn.new([2, 4], 'w')
+        node2.occupied << Pawn.new([3, 2], 'b')
+
+        board.get_piece('C7', player_2)
+        board.set_piece('C5', player_2)
+        ep_pawn = board.get_piece('B5', player_1)
+        expect(ep_pawn.ep_kill).to eq ["R"]
+      end 
+
+      it "should activate ep_kill to black pawn with enemy on LEFT" do
+        node1 = board.grid[5][2]
+        node2 = board.grid[7][1] 
+        node1.occupied << Pawn.new([2, 5], 'b')
+        node2.occupied << Pawn.new([1, 7], 'w')
+
+        board.get_piece('A2', player_1)
+        board.set_piece('A4', player_1)
+        ep_pawn = board.get_piece('B4', player_2)
+        expect(ep_pawn.ep_kill).to eq ["L"]
+      end
+
+      it "should activate ep_kill to black pawn on RIGHT" do
+        node1 = board.grid[5][2]
+        node2 = board.grid[7][3] 
+        node1.occupied << Pawn.new([2, 5], 'b')
+        node2.occupied << Pawn.new([3, 7], 'w')
+
+        board.get_piece('C2', player_1)
+        board.set_piece('C4', player_1)
+        ep_pawn = board.get_piece('B4', player_2)
+        expect(ep_pawn.ep_kill).to eq ["R"]
+      end      
     end
 
-    context "#set_piece" do 
-      it "sets Knight to selected node" do
+    context '#set_piece' do
+      it 'sets Knight to selected node' do
         chosen_node = board.grid[3][3]
-        chosen_node.occupied << knight      
-        board.get_piece("C6", player_1)
-        board.set_piece("D8", player_1)
+        chosen_node.occupied << knight
+        board.get_piece('C6', player_1)
+        board.set_piece('D8', player_1)
         new_node = board.grid[1][4]
         expect(new_node.occupied).to eq [knight]
       end
 
-      it "sets Pawn to selected node" do
+      it 'sets Pawn to selected node' do
         chosen_node = board.grid[6][1]
-        chosen_node.occupied << pawn      
-        board.get_piece("A3", player_1)
-        board.set_piece("A4", player_1)
+        chosen_node.occupied << pawn
+        board.get_piece('A3', player_1)
+        board.set_piece('A4', player_1)
         new_node = board.grid[5][1]
         expect(new_node.occupied).to eq [pawn]
       end
 
-      it "returns nil if outside piece's range" do
+      it 'returns nil if outside piece\'s range' do
         chosen_node = board.grid[1][1]
-        chosen_node.occupied << knight      
-        board.get_piece("A8", player_1)      
-        expect(board.set_piece("A1", player_1)).to eq nil
+        chosen_node.occupied << knight
+        board.get_piece('A8', player_1)
+        expect(board.set_piece('A1', player_1)).to eq nil
       end
 
-      it "should turn Pawn to Queen" do
+      it 'should turn Pawn to Queen' do
         chosen_node = board.grid[2][1]
-        chosen_node.occupied << pawn      
-        board.get_piece("A7", player_1)      
-        expect(board.set_piece("A8", player_1)).to_not eq [pawn]        
+        chosen_node.occupied << pawn
+        board.get_piece('A7', player_1)
+        expect(board.set_piece('A8', player_1)).to_not eq [pawn]
       end
 
-      it "adds piece to Player's kill list if piece is over taken" do 
+      it 'adds piece to Player\'s kill list if piece is over taken' do
         chosen_node = board.grid[1][1]
-        chosen_node.occupied << knight    
+        chosen_node.occupied << knight
         new_node = board.grid[2][3]
         new_node.occupied << knight_2
-        board.get_piece("A8", player_1)
-        board.set_piece("C7", player_1)
+        board.get_piece('A8', player_1)
+        board.set_piece('C7', player_1)
         expect(player_1.kill_list).to eq [knight_2]
       end
     end
 
-
-
     # ########DETERMINING CLEAR PATHS #################
-    context "#vertical_path" do
-      it "should return postive node_paths" do
-        expect(board.vertical_path([6,0], [6,6]).count).to eq 6
+    context '#vertical_path' do
+      it 'should return postive node_paths' do
+        expect(board.vertical_path([6, 0], [6, 6]).count).to eq 6
       end
 
-      it "should return negative node_paths" do
-        expect(board.vertical_path([0,6], [0,0]).count).to eq 6
-      end      
+      it 'should return negative node_paths' do
+        expect(board.vertical_path([0, 6], [0, 0]).count).to eq 6
+      end
     end
 
-    context "#horizontal_path" do
-      it "should return postive node_paths" do
-        expect(board.horizontal_path([0,0], [6,0]).count).to eq 6
+    context '#horizontal_path' do
+      it 'should return postive node_paths' do
+        expect(board.horizontal_path([0, 0], [6, 0]).count).to eq 6
       end
 
-      it "should return negative node_paths" do
-        expect(board.horizontal_path([6,0], [0,0]).count).to eq 6
-      end       
+      it 'should return negative node_paths' do
+        expect(board.horizontal_path([6, 0], [0, 0]).count).to eq 6
+      end
     end
 
-    context "#rising_path" do
-      it "should return postive node_paths" do
-        expect(board.rising_path([3,3], [6,0]).count).to eq 3
+    context '#rising_path' do
+      it 'should return postive node_paths' do
+        expect(board.rising_path([3, 3], [6, 0]).count).to eq 3
       end
 
-      it "should return negative node_paths" do
-        expect(board.rising_path([3,3], [0, 6]).count).to eq 3
-      end       
+      it 'should return negative node_paths' do
+        expect(board.rising_path([3, 3], [0, 6]).count).to eq 3
+      end
     end
 
-    context "#falling_path" do
-      it "should return postive node_paths" do
-        expect(board.falling_path([3,3], [0,0]).count).to eq 3
+    context '#falling_path' do
+      it 'should return postive node_paths' do
+        expect(board.falling_path([3, 3], [0, 0]).count).to eq 3
       end
 
-      it "should return postive node_paths" do
-        expect(board.falling_path([3,3], [7,7]).count).to eq 4
-      end 
+      it 'should return postive node_paths' do
+        expect(board.falling_path([3, 3], [7, 7]).count).to eq 4
+      end
     end
 
-
-    context "#clear_path?" do 
-      it "should return true if vertical_path is clear" do 
-        expect(board.clear_path?([0,0], [0,4])).to_not eq false       
+    context '#clear_path?' do
+      it 'should return true if vertical_path is clear' do
+        expect(board.clear_path?([0, 0], [0, 4])).to_not eq false
       end
 
-      it "should return true if vertical_path is clear, downwards" do 
-        expect(board.clear_path?([0,6], [0,4])).to_not eq false       
+      it 'should return true if vertical_path is clear, downwards' do
+        expect(board.clear_path?([0, 6], [0, 4])).to_not eq false
       end
 
-      it "should return false if vertical_path is unclear" do
+      it 'should return false if vertical_path is unclear' do
         chosen_node = board.grid[3][0]
-        chosen_node.occupied << knight 
-        expect(board.clear_path?([0,0], [0,4])).to eq false       
+        chosen_node.occupied << knight
+        expect(board.clear_path?([0, 0], [0, 4])).to eq false
       end
 
-      it "should return true if horizontal_path is clear" do
-        expect(board.clear_path?([0,0], [6,0])).to_not eq false
+      it 'should return true if horizontal_path is clear' do
+        expect(board.clear_path?([0, 0], [6, 0])).to_not eq false
       end
 
-      it "should return false if horizontal_path is unclear" do
+      it 'should return false if horizontal_path is unclear' do
         chosen_node = board.grid[0][3]
-        chosen_node.occupied << knight 
-        expect(board.clear_path?([0,0], [6,0])).to eq false 
+        chosen_node.occupied << knight
+        expect(board.clear_path?([0, 0], [6, 0])).to eq false
       end
 
-      it "should return true if rising_path is clear" do
-        expect(board.clear_path?([3,3], [0,6])).to_not eq false
+      it 'should return true if rising_path is clear' do
+        expect(board.clear_path?([3, 3], [0, 6])).to_not eq false
       end
 
-
-      it "should return false if rising_path is unclear" do
+      it 'should return false if rising_path is unclear' do
         chosen_node = board.grid[2][4]
-        chosen_node.occupied << knight 
-        expect(board.clear_path?([3,3], [5,1])).to eq false
+        chosen_node.occupied << knight
+        expect(board.clear_path?([3, 3], [5, 1])).to eq false
       end
 
-      it "should return true if falling_path is clear" do
-        expect(board.clear_path?([3,3], [0,0])).to_not eq false
+      it 'should return true if falling_path is clear' do
+        expect(board.clear_path?([3, 3], [0, 0])).to_not eq false
       end
 
-      it "should return false if horizontal_path is unclear" do
+      it 'should return false if horizontal_path is unclear' do
         chosen_node = board.grid[4][4]
-        chosen_node.occupied << knight 
-        expect(board.clear_path?([3,3], [7,7])).to eq false
-      end      
+        chosen_node.occupied << knight
+        expect(board.clear_path?([3, 3], [7, 7])).to eq false
+      end
     end
 
-    context "valid_path" do
-      it "should be valid if path is clear" do 
+    context 'valid_path' do
+      it 'should be valid if path is clear' do
         chosen_node = board.grid[3][3]
         chosen_node.occupied << rook
-        board.get_piece("D3", player_1)
-        expect(board.valid_path?(board.get_value, [7,3])).to_not eq false
+        board.get_piece('D3', player_1)
+        expect(board.valid_path?(board.get_value, [7, 3])).to_not eq false
       end
 
-      it "should be invalid if path is blocked" do
+      it 'should be invalid if path is blocked' do
         chosen_node = board.grid[3][3]
         chosen_node.occupied << rook
         blocked_node = board.grid[3][5]
-        blocked_node.occupied << knight       
-        board.get_piece("C6", player_1)
-        expect(board.valid_path?(board.get_value, [7,3])).to eq false    
+        blocked_node.occupied << knight
+        board.get_piece('C6', player_1)
+        expect(board.valid_path?(board.get_value, [7, 3])).to eq false
       end
 
-      it "should be invalid if path is blocked" do
+      it 'should be invalid if path is blocked' do
         chosen_node = board.grid[3][3]
         chosen_node.occupied << rook
         blocked_node = board.grid[4][3]
-        blocked_node.occupied << knight       
-        board.get_piece("C6", player_1)
-        expect(board.valid_path?(board.get_value, [3,7])).to eq false    
+        blocked_node.occupied << knight
+        board.get_piece('C6', player_1)
+        expect(board.valid_path?(board.get_value, [3, 7])).to eq false
       end
 
-      it "should be invalid if end_node is occupied with same color" do
+      it 'should be invalid if end_node is occupied with same color' do
         chosen_node = board.grid[3][3]
         chosen_node.occupied << rook
         blocked_node = board.grid[3][7]
-        blocked_node.occupied << knight       
-        board.get_piece("C6", player_1)
-        expect(board.valid_path?(board.get_value, [7,3])).to eq false    
+        blocked_node.occupied << knight
+        board.get_piece('C6', player_1)
+        expect(board.valid_path?(board.get_value, [7, 3])).to eq false
       end
 
-
-      # it "should be valid if end_node is occupied with different color" do
+      # it 'should be valid if end_node is occupied with different color' do
       #   chosen_node = board.grid[3][3]
       #   chosen_node.occupied << rook
       #   blocked_node = board.grid[3][7]
-      #   blocked_node.occupied << knight_2       
-      #   board.get_piece("C6", player_1)
-      #   expect(board.valid_path?(board.get_value, [7,3])).to_not eq false    
+      #   blocked_node.occupied << knight_2
+      #   board.get_piece('C6', player_1)
+      #   expect(board.valid_path?(board.get_value, [7,3])).to_not eq false
       # end
 
-      it "should be valid if using Knight and path is blocked" do
+      it 'should be valid if using Knight and path is blocked' do
         chosen_node = board.grid[1][1]
         chosen_node.occupied << knight
         blocked_node = board.grid[1][2]
-        blocked_node.occupied << rook  
+        blocked_node.occupied << rook
         blocked_node = board.grid[2][2]
-        blocked_node.occupied << rook  
+        blocked_node.occupied << rook
         blocked_node = board.grid[2][1]
-        blocked_node.occupied << rook                       
-        board.get_piece("A8", player_1)
-        expect(board.valid_path?(board.get_value, [3,2])).to_not eq false
-      end         
+        blocked_node.occupied << rook
+        board.get_piece('A8', player_1)
+        expect(board.valid_path?(board.get_value, [3, 2])).to_not eq false
+      end
     end
 
+    context 'apply_castling' do
+      it 'should long-castle BLACK' do
+        board.grid[1][5].occupied << king_2
+        board.grid[1][1].occupied << rook_2
+        board.apply_castling(rook_2)
+        expect(board.grid[1][3].occupied).to eq [king_2]
+        expect(board.grid[1][4].occupied).to eq [rook_2]
+      end
+
+      it 'should short-castle BLACK' do
+        rook_2.current_space = [8, 1]
+        board.grid[1][5].occupied << king_2
+        board.grid[1][8].occupied << rook_2
+        board.apply_castling(rook_2)
+        expect(board.grid[1][7].occupied).to eq [king_2]
+        expect(board.grid[1][6].occupied).to eq [rook_2]
+      end
+
+      it 'should long-castle WHITE' do
+        rook.current_space = [1, 8]
+        board.grid[8][5].occupied << king
+        board.grid[8][1].occupied << rook
+        board.apply_castling(rook)
+        expect(board.grid[8][3].occupied).to eq [king]
+        expect(board.grid[8][4].occupied).to eq [rook]
+      end
+
+      it 'should short-castle WHITE' do
+        rook.current_space = [8, 8]
+        board.grid[8][5].occupied << king
+        board.grid[8][8].occupied << rook
+        board.apply_castling(rook)
+        expect(board.grid[8][7].occupied).to eq [king]
+        expect(board.grid[8][6].occupied).to eq [rook]
+      end
+    end
   end
-end
+end