chess_vwong 0.0.1 → 0.0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 0fef94857588ea8e0075792e5d00e17bdcb59027
-  data.tar.gz: 0ce26be57dff21eac0ccdcd316f7e1b57ca6d807
+  metadata.gz: cb647ae34dfaa1eaa314c5ad0cf0701d0f0168c4
+  data.tar.gz: 0228a61d3ca95cf530ee2a18e5d349f6a6af5c87
 SHA512:
-  metadata.gz: 2d7d20933510dbe53257fc26c64d49a6b7027a1464762b1d3d151914f952f2a45e83d4c41f9c53030b7861ccd277c26480f68401aaa12b299932475e2b98d45b
-  data.tar.gz: 3e8d19fac4928cad5b852093e61b8efdb8d6c7264f390c77659faf28eb2b51cbecebfce185cf89a31dd37143698cbe0d830c8001b35c072b871d313085a8e887
+  metadata.gz: c902df6af2f44d4c80cee1bb94876c874a0d11fa17e218e29efaf04d7acc8cab86cfbf60b940da679f68ac64d50c5748b5a4347e5ec2c7f0564e90fe4eee0a2f
+  data.tar.gz: 91fdd57b4579d629b0f4caa6e0114830e843dc0b74226ea638ead07a51d3b09385f7d83f1e5e29d004d2d33b084f486f0c38400501ffbde5b6ec9c03f7206f53

data/README.md

@@ -1,35 +1,42 @@
 # Chess
 
-A barebones version of command-line Chess for 2 players.
+A barebones version of command-line Chess for 2 players. 
+
+Although currently missing the feature that declares Check, it is completely playable and includes all special moves(castling, en passant, promotion, and a pawn's double step on its first move).
 
 TODO:
-  1. Alert Check/Mate
-  2. Castling & En-Passant Moves
+  1. Declare Check/Mate
+  2. En-Passant(first-turn) bug 
 
 ##Gameplay
-The game is played on a standard 8 by 8 board as show below.
+The game is played on a standard 8x8 board as shown below.
 
       A B C D E F G H  
-    8 ♖ ♘ ♗ ♕ ♔ ♗ ♘ ♖
-    7 ♙ ♙ ♙ ♙ ♙ ♙ ♙ ♙
+    8 ♜ ♞ ♝ ♛ ♚ ♝ ♞ ♜
+    7 ♟ ♟ ♟ ♟ ♟ ♟ ♟ ♟
     6 _ _ _ _ _ _ _ _
     5 _ _ _ _ _ _ _ _
     4 _ _ _ _ _ _ _ _
     3 _ _ _ _ _ _ _ _
-    2 ♟ ♟ ♟ ♟ ♟ ♟ ♟ ♟
-    1 ♜ ♞ ♝ ♛ ♚ ♝ ♞ ♜
+    2 ♙ ♙ ♙ ♙ ♙ ♙ ♙ ♙
+    1 ♖ ♘ ♗ ♕ ♔ ♗ ♘ ♖
 
 A user will first be prompted to select a chess piece belonging to his/her color. Once a the chess piece has been chosen, he/she will then be prompted to select a space to move that chess piece. 
 
-To enter a command, simply type in the X and Y coordinate without any spaces or commas seperating the two, for example:
-  * A2
-  * H7
-
-(Lowercases are also accepted)
+###Basic Commands
+To enter a command, simply type in the X and Y coordinate without any spaces or commas seperating the two. Eg. A2, H7 or B6  (Lowercases are also accepted).
 
 If a command is invalid, the use will be alerted and prompted again until a valid command is entered.
 
+###Special moves
+
+All special moves in a chess game (castling, en passant, promotion, and a pawn's double step on its first move) are recognized and allowed during game play.
+
+Note: 
 
+  i) To initialize Castling, select Rook THEN select King. Restricted by Check not applied yet.
+  
+  ii) Restriction of En-Passant as first turn since double-stepped not applied yet.
 
 ## Installation
 
@@ -39,7 +46,13 @@ To install:
 
 ## Usage
 
-TODO: Write usage instructions here
+Once gem has successfully installed, simply type:
+
+    $ chess_vwong    
+
+Or clone the repo locally and run: 
+
+    $ rake play  
 
 ## Contributing
 

data/Rakefile

@@ -1,4 +1,4 @@
-desc "Play Chess"
+desc 'Play Chess'
 task :play do
-  ruby "-w bin/chess_vwong.rb"
-end
+  ruby '-w bin/chess_vwong'
+end

data/bin/chess_vwong

@@ -1,21 +1,21 @@
 #!/usr/bin/env ruby
 require 'chess_vwong'
 
-puts "Welcome to Chess"
-puts "Player 1, please Enter your name:"
+puts 'Welcome to Chess'
+puts 'Player 1, please Enter your name:'
 name_1 = gets.chomp
-puts "Player 2, please Enter your name:"
+puts 'Player 2, please Enter your name:'
 name_2 = gets.chomp
-puts ""
+puts ''
 
-puts "---------------------------"
+puts '---------------------------'
 puts "#{name_1} will be White"
 puts "#{name_2} will be Black"
-puts "---------------------------"
-puts ""
+puts '---------------------------'
+puts ''
 puts "Let's begin!"
 
-bob = ChessVwong::Player.new(name_1, "w")
-peter = ChessVwong::Player.new(name_2, "b")
+bob = ChessVwong::Player.new(name_1, 'w')
+peter = ChessVwong::Player.new(name_2, 'b')
 players = [bob, peter]
-ChessVwong::Game.new(players).play
+ChessVwong::Game.new(players).play

data/chess_vwong.gemspec

@@ -4,21 +4,21 @@ $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
 require 'chess_vwong/version'
 
 Gem::Specification.new do |spec|
-  spec.name          = "chess_vwong"
+  spec.name          = 'chess_vwong'
   spec.version       = ChessVwong::VERSION
-  spec.authors       = ["Vincent Wong"]
-  spec.email         = ["wingyu64@gmail.com"]
-  spec.summary       = %q{2-player CLI Chess}
-  spec.description   = %q{2-player CLI Chess}
-  spec.homepage      = ""
-  spec.license       = "MIT"
+  spec.authors       = ['Vincent Wong']
+  spec.email         = ['wingyu64@gmail.com']
+  spec.summary       = '2-player CLI Chess'
+  spec.description   = '2-player CLI Chess'
+  spec.homepage      = 'https://github.com/wingyu/chess_vwong'
+  spec.license       = 'MIT'
 
   spec.files         = `git ls-files -z`.split("\x0")
-  spec.executables   = "chess_vwong"#spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.executables   = 'chess_vwong' # spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
   spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
-  spec.require_paths = ["lib"]
+  spec.require_paths = ['lib']
 
-  spec.add_development_dependency "bundler", "~> 1.7"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec"
+  spec.add_development_dependency 'bundler', '~> 1.7'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec'
 end

data/example/example_game.rb

@@ -1,20 +1,20 @@
-require_relative "../lib/chess_vwong.rb"
- 
-puts "Welcome to Chess"
-puts "Player 1, please Enter your name:"
-name_1 = gets.chomp
-puts "Player 2, please Enter your name:"
-name_2 = gets.chomp
-puts ""
+require_relative '../lib/chess_vwong.rb'
 
-puts "---------------------------"
-puts "#{name_1} will be White"
-puts "#{name_2} will be Black"
-puts "---------------------------"
-puts ""
-puts "Let's begin!"
+puts 'Welcome to Chess'
+# puts "Player 1, please Enter your name:"
+# name_1 = gets.chomp
+# puts "Player 2, please Enter your name:"
+# name_2 = gets.chomp
+# puts ""
 
-bob = ChessVwong::Player.new(name_1, "w")
-peter = ChessVwong::Player.new(name_2, "b")
+# puts "---------------------------"
+# puts "#{name_1} will be White"
+# puts "#{name_2} will be Black"
+# puts "---------------------------"
+# puts ""
+# puts "Let's begin!"
+
+bob = ChessVwong::Player.new('WHITE', 'w')
+peter = ChessVwong::Player.new('BLACK', 'b')
 players = [bob, peter]
-ChessVwong::Game.new(players).play
+ChessVwong::Game.new(players).play

data/lib/chess_vwong.rb

@@ -1,23 +1,19 @@
-# require "chess_vwong/version"
+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'
 
-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/lib/chess_vwong/bishop.rb

@@ -1,22 +1,19 @@
 module ChessVwong
   class Bishop < Piece
-
     def character
-      color == "w" ? "\u{265D}" : "\u{2657}"
+      color == 'w' ? "\u{2657}" : "\u{265D}"
     end
 
     # Generate all possible Neighbouring Nodes
     def generate_neighbours(current_space)
       moves = []
-      (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] }
       moves.each do |move|
         neigbour_helper(current_space, move[0], move[1])
       end
-    end 
-
+    end
   end
 end
-

data/lib/chess_vwong/board.rb

@@ -7,86 +7,75 @@ module ChessVwong
       @grid = default_grid
     end
 
-    # Convert letter/number input into grid coordinates, if improper coordinates: empty array is returned
+    # Convert letter/number input into grid coordinates, if improper coordinates: empty array is returned (bandaid fix) so loop continues
     def process_input(input)
       if input[0] =~ /[A-Za-z]/
-        grid_values = input.tr!("87654321", "12345678")        
-        grid_values = input.upcase.tr!("ABCDEFGH", "12345678")
-        grid_values = grid_values.split("")
-        grid_values.map! {|i|i.to_i}  
+        grid_values = input.tr!('87654321', '12345678')
+        grid_values = input.upcase.tr!('ABCDEFGH', '12345678')
+        grid_values = grid_values.split('')
+        grid_values.map!(&:to_i)
       else
         return []
-      end 
+      end
     end
 
     # Get piece & generate neighbours, extra helper-methods required for Pawns due to unique nature
-    def get_piece(input=gets.chomp, player)
+    def get_piece(input = gets.chomp, player)
       @get_value = process_input(input)
-      if get_value.count ==2
+      if get_value.count == 2
         chosen_node = grid[get_value[1]][get_value[0]]
         unless chosen_node.occupied.empty? || chosen_node.occupied.first.color != player.color
-          @chosen_piece = chosen_node.occupied.pop() 
-          chosen_piece.instance_of?(Pawn) ? pawn_kill_helper(chosen_piece, get_value) : @chosen_piece.generate_neighbours(get_value)
-          return @chosen_piece
-        end 
+          @chosen_piece = chosen_node.occupied.pop
+          pawn_moves_helper(chosen_piece) #if pawn selected, check if unique moves apply
+          return chosen_piece
+        end
       end
     end
 
-    # Sets piece if within neighbour range & valid, also checks if pawn can beome Queen
-    def set_piece(input=gets.chomp, player)
+
+
+    # Sets piece if within neighbour range & valid, also checks for unique moves
+    def set_piece(input = gets.chomp, player)
       value = process_input(input)
-      if value.count ==2
+      if value.count == 2
         chosen_node = grid[value[1]][value[0]]
+        #Castling
+        return apply_castling(chosen_piece) if chosen_piece.instance_of?(Rook) && chosen_node.occupied.first.instance_of?(King) && clear_path?(get_value, value)
+        #En Passant  
+        return en_pass_kill(chosen_piece, player, chosen_node) if chosen_piece.instance_of?(Pawn) && chosen_node.occupied.empty? && !chosen_piece.ep_kill.empty?
+        #Standard & Promotion
         if chosen_piece.neighbours.include?(value) && valid_path?(@get_value, value)
-          chosen_piece.current_space = value
-          chosen_node.occupied << chosen_piece  
-          player.kill_list << chosen_node.occupied.shift() if chosen_node.occupied.count > 1
+          standard_move(chosen_piece, chosen_node, value, player)
           pawn_to_queen(chosen_piece, chosen_node) if chosen_piece.instance_of?(Pawn)
           return chosen_node.occupied
-        end  
-      end 
-    end
-
-    # Print's out Board
-    def formatted_grid
-      grid.each do |row|
-        puts row.map { |node| node.occupied.empty? ? "_" : node.occupied.first.character}.join(" ")
+        end
       end
     end
 
-
-
-    #Checks if path is valid
+    # Checks if path is valid
     def valid_path?(start, dest)
-      #if End node is empty OR end_node is occupied with enemy_piece then check if path is clear
-      if grid[dest[1]][dest[0]].occupied.empty? || !grid[dest[1]][dest[0]].occupied.empty? && grid[dest[1]][dest[0]].occupied.first.color != chosen_piece.color 
+      # if End node is empty OR end_node is occupied with enemy_piece then check if path is clear
+      if grid[dest[1]][dest[0]].occupied.empty? || !grid[dest[1]][dest[0]].occupied.empty? && grid[dest[1]][dest[0]].occupied.first.color != chosen_piece.color
         chosen_piece.instance_of?(Knight) ? true : clear_path?(start, dest)
       else
         false
       end
     end
 
-
-    def scan_for_check
-      # execute it for selected piece that was most recently moves AND every king move
-    end
-
-    #Checks if path is clear [x,y] = grid[y][x]
+    # Checks if path is clear. [x,y] = grid[y][x]
     def clear_path?(start, dest)
       if (start[0] < dest[0] && start[1] > dest[1]) || (start[0] > dest[0] && start[1] < dest[1])
-        rising_path(start, dest)    
+        rising_path(start, dest)
       elsif (start[0] < dest[0] && start[1] < dest[1]) || (start[0] > dest[0] && start[1] > dest[1])
-        falling_path(start, dest)                          
+        falling_path(start, dest)
       elsif start[1] != dest[1]
         vertical_path(start, dest)
       elsif start[0] != dest[0]
         horizontal_path(start, dest)
-      end    
-      return process_path
+      end
+      process_path
     end
 
-
-
     def vertical_path(start, dest)
       @node_path = []
       # DOWN
@@ -96,7 +85,7 @@ module ChessVwong
         end
       # UP
       elsif start[1] > dest[1]
-        start[1].step(dest[1]+1, -1) do |i|
+        start[1].step(dest[1] + 1, -1) do |i|
           node_path << grid[i][start[0]]
         end
       end
@@ -112,7 +101,7 @@ module ChessVwong
         end
       # LEFT
       elsif start[0] > dest[0]
-        start[0].step(dest[0]+1, -1) do |i|
+        start[0].step(dest[0] + 1, -1) do |i|
           node_path << grid[start[1]][i]
         end
       end
@@ -122,21 +111,21 @@ module ChessVwong
     def rising_path(start, dest)
       @node_path = []
       i = 0
-      j = start[0]      
-      #UP_RIGHT 
+      j = start[0]
+      # UP_RIGHT
       if start[0] < dest[0] && start[1] > dest[1]
         while j < dest[0]
-          node_path << grid[start[1] - i][start[0]+i]
+          node_path << grid[start[1] - i][start[0] + i]
           i += 1
           j += 1
-        end 
-      #DOWN_LEFT
+        end
+      # DOWN_LEFT
       elsif start[0] > dest[0] && start[1] < dest[1]
         while j > dest[0]
-          node_path << grid[start[1] + i][start[0]-i]
+          node_path << grid[start[1] + i][start[0] - i]
           i += 1
           j -= 1
-        end         
+        end
       end
       node_path
     end
@@ -144,64 +133,137 @@ module ChessVwong
     def falling_path(start, dest)
       @node_path = []
       i = 0
-      j = start[0]   
-      # DOWN_RIGHT    
+      j = start[0]
+      # DOWN_RIGHT
       if start[0] < dest[0] && start[1] < dest[1]
         while j < dest[0]
-          node_path << grid[start[1] + i][start[0]+i]
+          node_path << grid[start[1] + i][start[0] + i]
           i += 1
           j += 1
-        end 
+        end
       # UP_LEFT
       elsif start[0] > dest[0] && start[1] > dest[1]
         while j > dest[0]
-          node_path << grid[start[1]-i][start[0]-i]
+          node_path << grid[start[1] - i][start[0] - i]
           i += 1
           j -= 1
-        end         
+        end
       end
-      node_path      
+      node_path
     end
 
+    def apply_castling(rook)
+      king = grid[rook.current_space[1]][5].occupied.pop
+      if king.turns == 0 && rook.turns == 0
+        if rook.current_space[0] == 1 # Long Castle
+          switch_rook_castle(rook, king, 4, 3)
+        elsif rook.current_space[0] == 8 # Short Castle
+          switch_rook_castle(rook, king, 6, 7)
+        end
+      end
+    end
 
-    private
-      def default_grid
-        Array.new(9) { Array.new(9) { Node.new } }
+    # Print's out Board
+    def formatted_grid
+      grid.each do |row|
+        puts row.map { |node| node.occupied.empty? ? '_' : node.occupied.first.character }.join(' ')
       end
+    end
+
+    private
+
+    def default_grid
+      Array.new(9) { Array.new(9) { Node.new } }
+    end
 
-      # Goes through each node to see if it's Blocked
-      def process_path
-        node_path.each do |node|
-          unless node.occupied.empty? 
-            return false
-          end
+    # Goes through each node to see if it's Blocked
+    def process_path
+      node_path.each do |node|
+        unless node.occupied.empty?
+          return false
         end
       end
+    end
 
-      # if Pawn is selected, nearby spaces analyzed if enemries are present, if so they have additional moves
-      def pawn_kill_helper(chosen_piece, get_value)
-        if chosen_piece.color == "w"
-          node1 = grid[get_value[1] - 1][get_value[0] - 1]
-          node2 = grid[get_value[1] - 1][get_value[0] + 1]
-          @chosen_piece.generate_neighbours(get_value, node1, node2)
-        else
-          node1 = grid[get_value[1] + 1][get_value[0] - 1]
-          node2 = grid[get_value[1] + 1][get_value[0] + 1]  
-          @chosen_piece.generate_neighbours(get_value, node1, node2)        
-        end
+    def standard_move(piece, node, value, player)
+      piece.ep_kill =[] #resetting ability to En Passant
+      piece.current_space = value
+      piece.turns += 1
+      node.occupied << piece
+      player.kill_list << node.occupied.shift if  node.occupied.count > 1
+    end
+
+    # ######UNIQUE MOVES##############
+
+    # Check for en_passant or normal kill moves
+    def pawn_moves_helper(piece)
+      if piece.instance_of?(Pawn) 
+        en_pass_check(piece, piece.current_space[0], piece.current_space[1])
+        pawn_kill_helper(piece, get_value)
+      else
+        @chosen_piece.generate_neighbours(get_value)
+      end  
+    end
+
+    # if Pawn is selected, nearby spaces analyzed if enemies are present, if so they have additional moves
+    def pawn_kill_helper(chosen_piece, get_value)
+      if chosen_piece.color == 'w'
+        node1 = grid[get_value[1] - 1][get_value[0] - 1]
+        node2 = grid[get_value[1] - 1][get_value[0] + 1]
+        @chosen_piece.generate_neighbours(get_value, node1, node2)
+      else
+        node1 = grid[get_value[1] + 1][get_value[0] - 1]
+        node2 = grid[get_value[1] + 1][get_value[0] + 1]
+        @chosen_piece.generate_neighbours(get_value, node1, node2)
       end
+    end
 
-      def pawn_to_queen(pawn, current_node)
-        if pawn.color == "w" && pawn.current_space[1] == 1
-          current_node.occupied.pop()
-          current_node.occupied << Queen.new(pawn.current_space, "w")
-        elsif pawn.color == "b" && pawn.current_space[1] == 8 
-          current_node.occupied.pop()
-          current_node.occupied << Queen.new(pawn.current_space, "b")
-        end
+    def pawn_to_queen(pawn, current_node)
+      if pawn.color == 'w' && pawn.current_space[1] == 1
+        current_node.occupied.pop
+        current_node.occupied << Queen.new(pawn.current_space, 'w')
+      elsif pawn.color == 'b' && pawn.current_space[1] == 8
+        current_node.occupied.pop
+        current_node.occupied << Queen.new(pawn.current_space, 'b')
       end
+    end
 
-  end
-end
+    
+    def en_pass_kill(pawn, player, node)
+      x = pawn.current_space[0]
+      y = pawn.current_space[1]
+      if pawn.ep_kill.last == "L"
+        player.kill_list << grid[y][x-1].occupied.pop()
+        node.occupied << pawn
+      elsif pawn.ep_kill.last == "R"
+        player.kill_list << grid[y][x+1].occupied.pop()
+        node.occupied << pawn
+      end
+      pawn.ep_kill =[] #resetting ability to En Passant
+    end
+    
+    def en_pass_check(pawn, x, y)
+      l_piece = grid[y][x-1].occupied.first
+      r_piece = grid[y][x+1].occupied.first
+      en_pass_helper(pawn, l_piece, "L") #adjacent enemy on left
+      en_pass_helper(pawn, r_piece, "R") #adjacent enemy on right
+    end
 
+    def en_pass_helper(pawn, piece, side)
+      if piece.instance_of?(Pawn) && piece.color != pawn.color 
+        pawn.color == 'w' ? set_en_pass(pawn, piece, 4, side) : set_en_pass(pawn, piece, 5, side) #set row depending on color
+      end
+    end
+
+    def set_en_pass(pawn, piece, row, side)
+      pawn.ep_kill << side if piece.turns == 1 && piece.current_space[1] == row #if enemy pawn has double-stepped, add ep_kill to pawn
+    end
 
+    def switch_rook_castle(rook, king, rook_space, king_space)
+      rook.current_space[0] = rook_space
+      grid[rook.current_space[1]][rook_space].occupied << rook
+      king.current_space[0] = king_space
+      grid[rook.current_space[1]][king_space].occupied << king
+    end
+  end
+end