chess_vwong 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0fef94857588ea8e0075792e5d00e17bdcb59027
+  data.tar.gz: 0ce26be57dff21eac0ccdcd316f7e1b57ca6d807
+SHA512:
+  metadata.gz: 2d7d20933510dbe53257fc26c64d49a6b7027a1464762b1d3d151914f952f2a45e83d4c41f9c53030b7861ccd277c26480f68401aaa12b299932475e2b98d45b
+  data.tar.gz: 3e8d19fac4928cad5b852093e61b8efdb8d6c7264f390c77659faf28eb2b51cbecebfce185cf89a31dd37143698cbe0d830c8001b35c072b871d313085a8e887

data/.gitignore

@@ -0,0 +1,14 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in chess_vwong.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2015 Vincent Wong
+
+MIT License
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,52 @@
+# Chess
+
+A barebones version of command-line Chess for 2 players.
+
+TODO:
+  1. Alert Check/Mate
+  2. Castling & En-Passant Moves
+
+##Gameplay
+The game is played on a standard 8 by 8 board as show below.
+
+      A B C D E F G H  
+    8 ♖ ♘ ♗ ♕ ♔ ♗ ♘ ♖
+    7 ♙ ♙ ♙ ♙ ♙ ♙ ♙ ♙
+    6 _ _ _ _ _ _ _ _
+    5 _ _ _ _ _ _ _ _
+    4 _ _ _ _ _ _ _ _
+    3 _ _ _ _ _ _ _ _
+    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)
+
+If a command is invalid, the use will be alerted and prompted again until a valid command is entered.
+
+
+
+## Installation
+
+To install:
+
+    $ gem install chess_vwong
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/chess_vwong/fork )
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request
+
+

data/Rakefile

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

data/bin/chess_vwong

@@ -0,0 +1,21 @@
+#!/usr/bin/env ruby
+require 'chess_vwong'
+
+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 ""
+
+puts "---------------------------"
+puts "#{name_1} will be White"
+puts "#{name_2} will be Black"
+puts "---------------------------"
+puts ""
+puts "Let's begin!"
+
+bob = ChessVwong::Player.new(name_1, "w")
+peter = ChessVwong::Player.new(name_2, "b")
+players = [bob, peter]
+ChessVwong::Game.new(players).play

data/chess_vwong.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'chess_vwong/version'
+
+Gem::Specification.new do |spec|
+  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.files         = `git ls-files -z`.split("\x0")
+  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.add_development_dependency "bundler", "~> 1.7"
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "rspec"
+end

data/example/example_game.rb

@@ -0,0 +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 ""
+
+puts "---------------------------"
+puts "#{name_1} will be White"
+puts "#{name_2} will be Black"
+puts "---------------------------"
+puts ""
+puts "Let's begin!"
+
+bob = ChessVwong::Player.new(name_1, "w")
+peter = ChessVwong::Player.new(name_2, "b")
+players = [bob, peter]
+ChessVwong::Game.new(players).play

data/lib/chess_vwong/bishop.rb

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

data/lib/chess_vwong/board.rb

@@ -0,0 +1,207 @@
+module ChessVwong
+  class Board
+    attr_reader :grid
+    attr_accessor :chosen_piece, :node_path, :get_value
+
+    def initialize
+      @grid = default_grid
+    end
+
+    # Convert letter/number input into grid coordinates, if improper coordinates: empty array is returned
+    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}  
+      else
+        return []
+      end 
+    end
+
+    # Get piece & generate neighbours, extra helper-methods required for Pawns due to unique nature
+    def get_piece(input=gets.chomp, player)
+      @get_value = process_input(input)
+      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 
+      end
+    end
+
+    # Sets piece if within neighbour range & valid, also checks if pawn can beome Queen
+    def set_piece(input=gets.chomp, player)
+      value = process_input(input)
+      if value.count ==2
+        chosen_node = grid[value[1]][value[0]]
+        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
+          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
+
+
+
+    #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 
+        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]
+    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)    
+      elsif (start[0] < dest[0] && start[1] < dest[1]) || (start[0] > dest[0] && start[1] > dest[1])
+        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
+
+
+
+    def vertical_path(start, dest)
+      @node_path = []
+      # DOWN
+      if start[1] < dest[1]
+        (start[1]...dest[1]).each do |i|
+          node_path << grid[i][start[0]]
+        end
+      # UP
+      elsif start[1] > dest[1]
+        start[1].step(dest[1]+1, -1) do |i|
+          node_path << grid[i][start[0]]
+        end
+      end
+      node_path
+    end
+
+    def horizontal_path(start, dest)
+      @node_path = []
+      # RIGHT
+      if start[0] < dest[0]
+        (start[0]...dest[0]).each do |i|
+          node_path << grid[start[1]][i]
+        end
+      # LEFT
+      elsif start[0] > dest[0]
+        start[0].step(dest[0]+1, -1) do |i|
+          node_path << grid[start[1]][i]
+        end
+      end
+      node_path
+    end
+
+    def rising_path(start, dest)
+      @node_path = []
+      i = 0
+      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]
+          i += 1
+          j += 1
+        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]
+          i += 1
+          j -= 1
+        end         
+      end
+      node_path
+    end
+
+    def falling_path(start, dest)
+      @node_path = []
+      i = 0
+      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]
+          i += 1
+          j += 1
+        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]
+          i += 1
+          j -= 1
+        end         
+      end
+      node_path      
+    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
+        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
+      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
+
+

data/lib/chess_vwong/game.rb

@@ -0,0 +1,73 @@
+module ChessVwong
+  class Game
+    attr_reader :current_player, :other_player
+    attr_reader :board
+    def initialize(players, board = Board.new)
+      @current_player = players[0]
+      @other_player = players[1]
+      @board = board
+    end
+
+    def switch_players
+      @current_player, @other_player = @other_player, @current_player
+    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
+        board.formatted_grid
+        puts ""
+        solicit_get_piece
+        puts ""
+        solicit_set_piece
+        if game_over
+          puts game_over_message
+          board.formatted_grid
+          return
+        else
+          switch_players
+        end
+      end
+    end
+
+    private
+
+    def solicit_get_piece
+      loop do
+        puts "#{current_player.name}, Select a piece:"
+        if board.get_piece(current_player)
+          break
+        else
+           puts "Invalid Input!"
+         end
+      end          
+    end
+
+    def solicit_set_piece
+      loop do
+        puts "#{current_player.name}, Select a destination:"
+        if board.set_piece(current_player)
+          break
+        else
+           puts "Invalid Move!"
+         end
+      end      
+    end  
+
+    def game_over_message
+      "#{current_player.name} wins!"
+    end
+
+
+  end
+end
+
+  

data/lib/chess_vwong/king.rb

@@ -0,0 +1,17 @@
+module ChessVwong
+  class King < Piece
+
+    def character
+      color == "w" ? "\u{265A}" : "\u{2654}"
+    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.each do |move|
+        neigbour_helper(current_space, move[0], move[1])
+      end
+    end 
+
+  end
+end

data/lib/chess_vwong/knight.rb

@@ -0,0 +1,17 @@
+module ChessVwong
+  class Knight < Piece
+
+    def character
+      color == "w" ? "\u{265E}" : "\u{2658}"
+    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.each do |move|
+        neigbour_helper(current_space, move[0], move[1])
+      end
+    end 
+
+  end
+end

data/lib/chess_vwong/node.rb

@@ -0,0 +1,9 @@
+module ChessVwong
+  class Node
+    attr_accessor :occupied, :visited
+    def initialize
+      @occupied = []
+      @visited = []
+    end
+  end
+end

data/lib/chess_vwong/pawn.rb

@@ -0,0 +1,44 @@
+module ChessVwong
+  class Pawn < Piece
+
+    def character
+      color == "w" ? "\u{265F}" : "\u{2659}"
+    end
+
+    # Generate all possible Neighbouring Spaces
+    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)   
+      moves.each do |move|
+        neigbour_helper(current_space, move[0], move[1])
+      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"
+      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"
+      end
+    end
+
+
+    private 
+
+      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 
+      end
+
+  end
+end
+
+
+

data/lib/chess_vwong/piece.rb

@@ -0,0 +1,34 @@
+module ChessVwong
+  class Piece
+    attr_reader :color
+    attr_accessor :neighbours, :current_space
+    def initialize(current_space, color)
+      @current_space = current_space
+      @color = color
+      @neighbours = []  
+    end
+
+    # Ensuring the pieces can't go off board
+    def valid_space?(space)
+      true if space.all? {|coordinate| coordinate >= 1 && coordinate <9} 
+    end
+
+    def character
+      return 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
+
+
+
+  end
+end
+

data/lib/chess_vwong/player.rb

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

data/lib/chess_vwong/preload.rb

@@ -0,0 +1,65 @@
+module ChessVwong
+  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")]
+
+        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")]
+
+
+
+
+        #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)    
+
+      end
+      private
+      def load_pawns(row, color)
+        i = 0 
+        row.each do |node|
+          node.occupied << Pawn.new([i,1],color)
+          i += 1
+        end
+      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_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