chess_vwong 0.0.1

data/lib/chess_vwong/queen.rb

@@ -0,0 +1,28 @@
+module ChessVwong
+  class Queen < Piece
+
+    def character
+      color == "w" ? "\u{265B}" : "\u{2655}"
+    end
+
+    # Generate all possible Neighbouring Nodes
+    def generate_neighbours(current_space)
+      moves = []
+      # Diaganol
+      (1..8).each {|i| moves << [i, i]}
+      (1..8).each {|i| moves << [i, -i]}
+      (1..8).each {|i| moves << [-i, i]}
+      (1..8).each {|i| moves << [-i, -i]}
+      # Straight
+      (1..8).each {|i| moves << [i, 0]}
+      (1..8).each {|i| moves << [0, i]}
+      (1..8).each {|i| moves << [-i, 0]}
+      (1..8).each {|i| moves << [0, -i]}
+      moves.each do |move|
+        neigbour_helper(current_space, move[0], move[1])
+      end
+    end 
+
+  end
+end
+

data/lib/chess_vwong/rook.rb

@@ -0,0 +1,22 @@
+module ChessVwong
+  class Rook < Piece
+
+    def character
+      color == "w" ? "\u{265C}" : "\u{2656}"
+    end
+
+    # Generate all possible Neighbouring Nodes
+    def generate_neighbours(current_space)
+      moves = []
+      (1..8).each {|i| moves << [i, 0]}
+      (1..8).each {|i| moves << [0, i]}
+      (1..8).each {|i| moves << [-i, 0]}
+      (1..8).each {|i| moves << [0, -i]}
+      moves.each do |move|
+        neigbour_helper(current_space, move[0], move[1])
+      end
+    end 
+
+  end
+end
+

data/lib/chess_vwong/version.rb

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

data/lib/chess_vwong.rb

@@ -0,0 +1,23 @@
+# require "chess_vwong/version"
+
+module ChessVwong
+  # Your code goes here...
+end
+
+
+require_relative "./chess_vwong/node.rb"
+require_relative "./chess_vwong/player.rb"
+require_relative "./chess_vwong/piece.rb"
+require_relative "./chess_vwong/knight.rb"
+require_relative "./chess_vwong/rook.rb"
+require_relative "./chess_vwong/king.rb"
+require_relative "./chess_vwong/bishop.rb"
+require_relative "./chess_vwong/queen.rb"
+require_relative "./chess_vwong/pawn.rb"
+require_relative "./chess_vwong/board.rb"
+require_relative "./chess_vwong/preload.rb"
+require_relative "./chess_vwong/game.rb"
+
+# board = ChessVwong::Board.new
+# board.preload_pieces 
+# board.formatted_grid

data/spec/bishop_spec.rb

@@ -0,0 +1,50 @@
+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"
+      end
+
+      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}"
+      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  
+
+    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]
+        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]
+        bishop.generate_neighbours(current_space)
+        expect(bishop.neighbours.count).to eq 11
+      end      
+
+    end
+
+
+  end
+end

data/spec/board_spec.rb

@@ -0,0 +1,293 @@
+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
+        expect(board.grid.size).to eq 9
+      end
+       
+      it "creates 8 things in each row" do
+        board.grid.each do |row|
+          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]
+      end
+
+      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]
+      end
+
+      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      
+    end
+
+    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
+      end
+
+      it "it removes piece from selected node" do
+        chosen_node = board.grid[3][2]
+        chosen_node.occupied << knight
+        board.get_piece("B6", player_1)
+        expect(chosen_node.occupied).to eq []
+      end
+
+      it "it generates neighbours of selected piece" do
+        chosen_node = board.grid[1][1]
+        chosen_node.occupied << knight
+        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
+        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)
+        expect(piece.neighbours.count).to eq 4
+      end
+
+      it "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)
+        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      
+
+    end
+
+    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)
+        new_node = board.grid[1][4]
+        expect(new_node.occupied).to eq [knight]
+      end
+
+      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)
+        new_node = board.grid[5][1]
+        expect(new_node.occupied).to eq [pawn]
+      end
+
+      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
+      end
+
+      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]        
+      end
+
+      it "adds piece to Player's kill list if piece is over taken" do 
+        chosen_node = board.grid[1][1]
+        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)
+        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
+      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
+      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
+      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
+      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       
+      end
+
+      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
+        chosen_node = board.grid[3][0]
+        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
+      end
+
+      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 
+      end
+
+      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
+        chosen_node = board.grid[2][4]
+        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
+      end
+
+      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      
+    end
+
+    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
+      end
+
+      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    
+      end
+
+      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    
+      end
+
+      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    
+      end
+
+
+      # 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    
+      # end
+
+      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 = board.grid[2][2]
+        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         
+    end
+
+  end
+end

data/spec/game_spec.rb

@@ -0,0 +1,38 @@
+require "spec_helper"
+module ChessVwong
+  describe Game do
+
+    let (:bob) { Player.new("Bob", "w") }
+    let (:peter) { Player.new("Peter", "b") }
+    let (:king) { King.new([0,0], "b") }
+    let (:game) { Game.new([bob, peter]) }
+
+    context "#switch_players" do
+      it "will set @current_player to @other_player" do
+        current_player = bob
+        other_player = peter
+        game.switch_players
+        expect(game.current_player).to eq peter
+      end
+     
+      it "will set @other_player to @current_player" do
+        current_player = bob
+        other_player = peter
+        game.switch_players
+        expect(game.other_player).to eq bob
+      end
+    end
+
+    context "#game_over" do
+      it "should return winner if king has just been killed" do 
+        game.current_player.kill_list << king
+        expect(game.game_over).to eq game.current_player
+      end
+
+      it "should return false if no King" do 
+        expect(game.game_over).to eq false
+      end      
+    end
+
+  end
+end

data/spec/king_spec.rb

@@ -0,0 +1,51 @@
+require "spec_helper"
+
+module ChessVwong
+  describe King do 
+    let (:current_space) { [1,1]}
+    let (:king) { King.new(current_space,"w")}
+    context "#initialize" do
+      it "should return Piece attributes: color" do
+        expect(king.color).to eq "w"
+      end
+
+      it "should return Piece attributes: current_space" do
+        expect(king.current_space).to eq current_space
+      end
+    end
+
+    context "#character" do
+      it "should return a white king character" do
+        expect(king.character).to eq "\u{265A}"
+      end
+
+      it "should return a black king character" do
+        king_2 = King.new(current_space,"b")
+        expect(king_2.character).to eq "\u{2654}"
+      end    
+    end  
+
+    context "#generate_neighbours" do
+
+      it "should return only 16 neighbour when [1,1]" do
+        king.generate_neighbours(current_space)
+        expect(king.neighbours.count).to eq 3
+      end
+
+      it "should return only 14 neighbour when [8,8]" do
+        current_space = [8,8]
+        king.generate_neighbours(current_space)
+        expect(king.neighbours.count).to eq 3
+      end
+
+      it "should return only 14 neighbour when in the middle" do
+        current_space = [3,3]
+        king.generate_neighbours(current_space)
+        expect(king.neighbours.count).to eq 8
+      end   
+
+    end
+
+
+  end
+end

data/spec/knight_spec.rb

@@ -0,0 +1,73 @@
+require "spec_helper"
+
+module ChessVwong
+  describe Knight do 
+    let (:current_space) {[1,1]}
+    let (:knight) { Knight.new(current_space, "w")}
+    context "#initialize" do
+      it "should return Piece attributes: color" do
+        expect(knight.color).to eq "w"
+      end
+
+      it "should return Piece attributes: current_space" do
+        expect(knight.current_space).to eq current_space
+      end
+    end
+
+    context "#character" do
+      it "should return a white knight character" do
+        expect(knight.character).to eq "\u{265E}"
+      end
+
+      it "should return a black knight character" do
+        knight_2 = Knight.new(current_space,"b")
+        expect(knight_2.character).to eq "\u{2658}"
+      end    
+    end  
+
+    context "#generate_neighbours" do
+      it "should return only 2 neighbour when [1,1]" do
+        knight.generate_neighbours(current_space)
+        expect(knight.neighbours.count).to eq 2
+      end
+
+      it "should return only 2 neighbour when [7,7]" do
+        current_space = [8,8]
+        knight.generate_neighbours(current_space)
+        expect(knight.neighbours.count).to eq 2
+      end
+
+      it "should return only 4 neighbour when on left edge" do
+        current_space = [1,4]
+        knight.generate_neighbours(current_space)
+        expect(knight.neighbours.count).to eq 4
+      end
+
+      it "should return only 4 neighbour when on right edge" do
+        current_space = [8,4]
+        knight.generate_neighbours(current_space)
+        expect(knight.neighbours.count).to eq 4
+      end
+
+      it "should return only 4 neighbour when on top edge" do
+        current_space = [4,1]
+        knight.generate_neighbours(current_space)
+        expect(knight.neighbours.count).to eq 4
+      end
+
+      it "should return only 4 neighbour when on right edge" do
+        current_space = [4,8]
+        knight.generate_neighbours(current_space)
+        expect(knight.neighbours.count).to eq 4
+      end
+
+      it "should return 8 neighbour when in middle" do
+        current_space = [4,4]
+        knight.generate_neighbours(current_space)
+        expect(knight.neighbours.count).to eq 8
+      end
+    end
+
+
+  end
+end

data/spec/node_spec.rb

@@ -0,0 +1,24 @@
+require "spec_helper"
+
+module ChessVwong
+  describe Node do 
+    let (:node) { Node.new}
+    let (:knight) { Knight.new(node, "w")}
+
+    context "#intialize" do
+      # it "is initialized with x,y coordinates for its value" do
+      #   expect(node.value).to eq [0,0]
+      # end
+
+      it "defaults to unoccupied" do
+        expect(node.occupied).to eq []
+      end       
+
+      it "can accept pieces as occupants" do
+        node.occupied << knight
+        expect(node.occupied).to eq [knight]
+      end                      
+    end
+    
+  end
+end