chess_vwong 0.0.1 → 0.0.2

data/lib/chess_vwong/game.rb

@@ -10,23 +10,20 @@ module ChessVwong
 
     def switch_players
       @current_player, @other_player = @other_player, @current_player
-    end   
-
-  
+    end
 
     def game_over
       return current_player if current_player.kill_list.last.instance_of?(King)
       false
     end
 
-
     def play
       board.preload_pieces
-      while true
+      loop do
         board.formatted_grid
-        puts ""
+        puts ''
         solicit_get_piece
-        puts ""
+        puts ''
         solicit_set_piece
         if game_over
           puts game_over_message
@@ -40,15 +37,27 @@ module ChessVwong
 
     private
 
+    
+
+    # def reset_doubled
+    #   grid.each do |row|
+    #     row.each do |node|
+    #       if node.occupied.first.instance_of?(Pawn)
+
+    #       end
+    #     end
+    #   end
+    # end
+
     def solicit_get_piece
       loop do
         puts "#{current_player.name}, Select a piece:"
         if board.get_piece(current_player)
           break
         else
-           puts "Invalid Input!"
+          puts 'Invalid Input!'
          end
-      end          
+      end
     end
 
     def solicit_set_piece
@@ -57,17 +66,13 @@ module ChessVwong
         if board.set_piece(current_player)
           break
         else
-           puts "Invalid Move!"
+          puts 'Invalid Move!'
          end
-      end      
-    end  
+      end
+    end
 
     def game_over_message
       "#{current_player.name} wins!"
     end
-
-
   end
 end
-
-  

data/lib/chess_vwong/king.rb

@@ -1,17 +1,15 @@
 module ChessVwong
   class King < Piece
-
     def character
-      color == "w" ? "\u{265A}" : "\u{2654}"
+      color == 'w' ? "\u{2654}" : "\u{265A}"
     end
 
     # Generate all possible Neighbouring Spaces
     def generate_neighbours(current_space)
-      moves = [[ 1, 0], [-1, 0], [0, 1], [0, -1], [-1, 1], [1, -1], [1,1], [-1,-1]]
+      moves = [[1, 0], [-1, 0], [0, 1], [0, -1], [-1, 1], [1, -1], [1, 1], [-1, -1]]
       moves.each do |move|
         neigbour_helper(current_space, move[0], move[1])
       end
-    end 
-
+    end
   end
-end
+end

data/lib/chess_vwong/knight.rb

@@ -1,17 +1,15 @@
 module ChessVwong
   class Knight < Piece
-
     def character
-      color == "w" ? "\u{265E}" : "\u{2658}"
+      color == 'w' ? "\u{2658}" : "\u{265E}"
     end
 
     # Generate all possible Neighbouring Spaces
     def generate_neighbours(current_space)
-      moves = [[ 1, 2], [-1, 2], [ 1,-2], [-1,-2], [ 2, 1], [-2, 1], [ 2,-1], [-2,-1]]
+      moves = [[1, 2], [-1, 2], [1, -2], [-1, -2], [2, 1], [-2, 1], [2, -1], [-2, -1]]
       moves.each do |move|
         neigbour_helper(current_space, move[0], move[1])
       end
-    end 
-
+    end
   end
-end
+end

data/lib/chess_vwong/node.rb

@@ -6,4 +6,4 @@ module ChessVwong
       @visited = []
     end
   end
-end
+end

data/lib/chess_vwong/pawn.rb

@@ -1,44 +1,45 @@
 module ChessVwong
   class Pawn < Piece
-
+    attr_accessor :doubled
     def character
-      color == "w" ? "\u{265F}" : "\u{2659}"
+      color == 'w' ? "\u{2659}" : "\u{265F}"
     end
 
     # Generate all possible Neighbouring Spaces
-    def generate_neighbours(current_space, node1=nil, node2=nil)
-      color == "w" ? moves = [[0, -1]] : moves = [[0, 1]]
+    def generate_neighbours(current_space, node1 = nil, node2 = nil)
+      color == 'w' ? moves = [[0, -1]] : moves = [[0, 1]]
       first_turn?(current_space, moves)
-      kill_move(node1, node2, moves)   
+      kill_move(node1, node2, moves)
       moves.each do |move|
         neigbour_helper(current_space, move[0], move[1])
       end
-    end 
+    end
 
     # if there is a enemy piece nearby, then give option to attack
     def kill_move(node1, node2, moves)
-      if color == "w"
-        moves << [-1,-1] if  node1 &&!node1.occupied.empty? && node1.occupied.first.color == "b"
-        moves << [1,-1] if node2 && !node2.occupied.empty? && node2.occupied.first.color == "b"
+      if color == 'w'
+        moves << [-1, -1] if  kill_conditions(node1, 'b') || ep_kill.first == "L"
+        moves << [1, -1] if kill_conditions(node2, 'b') || ep_kill.first == "R"
       else
-        moves << [-1,1] if node1 && !node1.occupied.empty? && node1.occupied.first.color == "w"
-        moves << [1,1] if node2 && !node2.occupied.empty? && node2.occupied.first.color == "w"
+        moves << [-1, 1] if kill_conditions(node1, 'w') || ep_kill.first == "L"
+        moves << [1, 1] if kill_conditions(node1, 'w') || ep_kill.first == "R"
       end
     end
 
+    private
 
-    private 
+    def kill_conditions(node, color)
+      node && !node.occupied.empty? && node.occupied.first.color == color
+    end
 
-      def first_turn?(current_space, moves)
-        if current_space[1] == 2 #Black
-          moves << [0,2]
-        elsif current_space[1] == 7 #White
-          moves << [0,-2]
-        end 
+    def first_turn?(current_space, moves)
+      if current_space[1] == 2 # Black
+        moves << [0, 2]
+        doubled = true
+      elsif current_space[1] == 7 # White
+        moves << [0, -2]
+        doubled = true
       end
-
+    end
   end
 end
-
-
-

data/lib/chess_vwong/piece.rb

@@ -1,34 +1,32 @@
 module ChessVwong
   class Piece
     attr_reader :color
-    attr_accessor :neighbours, :current_space
+    attr_accessor :neighbours, :current_space, :turns, :ep_kill
     def initialize(current_space, color)
       @current_space = current_space
       @color = color
-      @neighbours = []  
+      @turns = 0
+      @neighbours = []
+      @ep_kill = []
     end
 
     # Ensuring the pieces can't go off board
     def valid_space?(space)
-      true if space.all? {|coordinate| coordinate >= 1 && coordinate <9} 
+      true if space.all? { |coordinate| coordinate >= 1 && coordinate < 9 }
     end
 
     def character
-      return color
+      color
     end
 
     private
 
-      # Create 1 new Neighbouring space
-      def neigbour_helper(current_space, x, y)
-        new_x = current_space[0] + x
-        new_y = current_space[1] + y
-        neighbour = [new_x, new_y]
-        self.neighbours << neighbour if valid_space?(neighbour)
-      end
-
-
-
+    # Create 1 new Neighbouring space
+    def neigbour_helper(current_space, x, y)
+      new_x = current_space[0] + x
+      new_y = current_space[1] + y
+      neighbour = [new_x, new_y]
+      neighbours << neighbour if valid_space?(neighbour)
+    end
   end
 end
-

data/lib/chess_vwong/player.rb

@@ -2,11 +2,11 @@ module ChessVwong
   class Player
     attr_reader :name, :color
     attr_accessor :kill_list, :chosen_piece
-    def initialize(name, color="w")
+    def initialize(name, color = 'w')
       @name = name
       @color = color
       @kill_list = []
       @chosen_piece = []
     end
   end
-end
+end

data/lib/chess_vwong/preload.rb

@@ -1,65 +1,66 @@
 module ChessVwong
-  class Board    
+  class Board
     # private
-      # White on the Bottom, Black on Top
-      def preload_pieces 
-        white_pieces =  [Rook.new([0,7], "w"), Knight.new([1,7], "w"), Bishop.new([2,7], "w"), Queen.new([3,7], "w"), 
-                         King.new([4,7], "w"), Bishop.new([5,7], "w"), Knight.new([6,7], "w"), Rook.new([7,7], "w")]
+    # White on the Bottom, Black on Top
+    def preload_pieces
+      white_pieces =  [Rook.new([1, 8], 'w'), Knight.new([2, 8], 'w'), Bishop.new([3, 8], 'w'), Queen.new([4, 8], 'w'),
+                       King.new([5, 8], 'w'), Bishop.new([6, 8], 'w'), Knight.new([7, 8], 'w'), Rook.new([8, 8], 'w')]
 
-        black_pieces =  [Rook.new([0,0], "b"), Knight.new([1,0], "b"), Bishop.new([2,0], "b"), Queen.new([3,0], "b"), 
-                         King.new([4,0], "b"), Bishop.new([5,0], "b"), Knight.new([6,0], "b"), Rook.new([7,0], "b")]
+      black_pieces =  [Rook.new([1, 1], 'b'), Knight.new([2, 1], 'b'), Bishop.new([3, 1], 'b'), Queen.new([4, 1], 'b'),
+                       King.new([5, 1], 'b'), Bishop.new([6, 1], 'b'), Knight.new([7, 1], 'b'), Rook.new([8, 1], 'b')]
 
+      # Load Coord-Displays
+      load_alphabet(grid[0])
+      load_num_coord
 
+      
 
 
-        #Load Coord-Displays                 
-        load_alphabet(grid[0])
-        load_num_coord
-        # Black Pawns                 
-        load_pawns(grid[2], "b")
-        #White Pawns
-        load_pawns(grid[7], "w")
-        # White Pieces
-        load_back_pieces(grid[1], black_pieces)   
-        #Black Pieces
-        load_back_pieces(grid[8], white_pieces)    
+      # Black Pawns
+      load_pawns(grid[2], 'b')
+      # # White Pawns
+      load_pawns(grid[7], 'w')
+      # # White Pieces
+      load_back_pieces(grid[1], black_pieces)
+      # # Black Pieces
+      load_back_pieces(grid[8], white_pieces)
+    end
 
-      end
-      private
-      def load_pawns(row, color)
-        i = 0 
-        row.each do |node|
-          node.occupied << Pawn.new([i,1],color)
-          i += 1
-        end
-      end
+    private
 
-      def load_alphabet(row)
-        alphabet = ("A".."H").to_a
-        i = 0
-        while i < 8
-          row[i+1].occupied << Piece.new([0,0], alphabet[i])
-          i += 1
-        end        
+    def load_pawns(row, color)
+      i = 0
+      row.each do |node|
+        node.occupied << Pawn.new([i, 1], color)
+        i += 1
       end
+    end
 
-      def load_num_coord
-        i = 8
-        j=1
-        while i > 0
-          grid[j][0].occupied << Piece.new([0,0], i)
-          i -= 1
-          j += 1
-        end         
+    def load_alphabet(row)
+      alphabet = ('A'..'H').to_a
+      i = 0
+      while i < 8
+        row[i + 1].occupied << Piece.new([0, 0], alphabet[i])
+        i += 1
       end
+    end
 
-      def load_back_pieces(row, pieces) 
-        i = 0
-        while i < 8
-          row[i+1].occupied << pieces[i]
-          i += 1
-        end      
+    def load_num_coord
+      i = 8
+      j = 1
+      while i > 0
+        grid[j][0].occupied << Piece.new([0, 0], i)
+        i -= 1
+        j += 1
       end
+    end
 
+    def load_back_pieces(row, pieces)
+      i = 0
+      while i < 8
+        row[i + 1].occupied << pieces[i]
+        i += 1
+      end
+    end
   end
 end

data/lib/chess_vwong/queen.rb

@@ -1,28 +1,25 @@
 module ChessVwong
   class Queen < Piece
-
     def character
-      color == "w" ? "\u{265B}" : "\u{2655}"
+      color == 'w' ? "\u{2655}" : "\u{265B}"
     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]}
+      (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]}
+      (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
 end
-

data/lib/chess_vwong/rook.rb

@@ -1,22 +1,19 @@
 module ChessVwong
   class Rook < Piece
-
     def character
-      color == "w" ? "\u{265C}" : "\u{2656}"
+      color == 'w' ? "\u{2656}" : "\u{265C}"
     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]}
+      (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
 end
-