ruby_chess 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0f9cebf323ed1409f108613fc3f1403b327858f4
+  data.tar.gz: 801a167cb2e0c90e86ae7811fd39ceb09e351eb5
+SHA512:
+  metadata.gz: 5f7cdb3f6eb1c0558f54fb686912fff36a4e468991f21aa4959bd1e3002c823df2a5181ec7192ed2fde286952dc1929debbfbca0a29a4ee90abe7b4ba4b60938
+  data.tar.gz: 6aa63e24024b75cb0d2e85d7edd3a8c50a14361527564cd51534b2b3d01295d495a3cb7bf254856f7047561837fbee952a66020755ac810925851c4d6e07872c

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/.travis.yml

@@ -0,0 +1,3 @@
+language: ruby
+rvm:
+  - 2.1.2

data/Gemfile

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

data/README.md

@@ -0,0 +1,39 @@
+# RubyChess
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/ruby_chess`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'ruby_chess'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install ruby_chess
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release` to create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+1. Fork it ( https://github.com/[my-github-username]/ruby_chess/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 @@
+require "bundler/gem_tasks"

data/bin/ruby_chess

@@ -0,0 +1,5 @@
+#!/usr/bin/env ruby
+
+require 'ruby_chess'
+t = RubyChess.new
+t.run

data/lib/board.rb

@@ -0,0 +1,187 @@
+# coding: utf-8
+require 'colorize'
+require 'io/console'
+require_relative 'pieces'
+require_relative 'errors'
+
+class Board
+
+  attr_reader :grid, :cursor
+
+  def initialize(setup = true)
+    @grid = Array.new(8) { Array.new(8) }
+    @cursor = [0,0]
+
+    populate_board if setup
+  end
+
+  def move(start_pos, end_pos, color)
+    raise OffBoardError unless on_board?(start_pos) && on_board?(end_pos)
+    raise NoPieceError unless piece_at(start_pos)
+    raise WrongColorError unless piece_at(start_pos).color == color
+
+    current_piece = piece_at(start_pos)
+    if current_piece.valid_moves.include?(end_pos)
+      move!(start_pos, end_pos)
+    else
+      raise InvalidMoveError
+    end
+  end
+
+  def move!(start_pos, end_pos)
+    current_piece = piece_at(start_pos)
+    self[start_pos] = nil
+    self[end_pos] = current_piece
+    current_piece.pos = end_pos
+    current_piece.moved = true
+  end
+
+  def move_cursor
+    input = ""
+    until input == "\r"
+      render(@cursor)
+      input = STDIN.getch
+      @cursor[0] += 1 if input == 'k' && @cursor[0] + 1 < 8
+      @cursor[0] -= 1 if input == 'i' && @cursor[0] - 1 >= 0
+      @cursor[1] -= 1 if input == 'j' && @cursor[1] - 1 >= 0
+      @cursor[1] += 1 if input == 'l' && @cursor[1] + 1 < 8
+
+    end
+    @cursor.dup
+  end
+
+  def [](pos)
+    @grid[pos.first][pos.last]
+  end
+
+  def []=(pos, piece)
+    @grid[pos.first][pos.last] = piece
+  end
+
+  def on_board?(pos)
+    (pos[0]).between?(0, 7) && (pos[1]).between?(0, 7)
+  end
+
+  def occupied?(pos)
+    return false unless on_board?(pos)
+    !!self[pos]
+  end
+
+  def won?
+    checkmate?(:white) || checkmate?(:black)
+  end
+
+  def stalemate?(color)
+    pieces(color).all? { |piece| piece.valid_moves.empty? } && !in_check?(color)
+  end
+
+  def piece_at(pos)
+    self[pos]
+  end
+
+  def checkmate?(color)
+    pieces(color).all? { |piece| piece.valid_moves.empty? } &&
+    in_check?(color)
+  end
+
+  def in_check?(color)
+    opponent_color = color == :white ? :black : :white
+    king_pos = king(color).pos
+    pieces(opponent_color).any? do |piece|
+      piece.moves.include?(king_pos)
+    end
+  end
+
+  def deep_dup
+    dup_board = Board.new(false)
+
+    [:white, :black].each do |color|
+      pieces(color).each do |piece|
+        duped_piece = piece.dup(dup_board)
+        dup_board[duped_piece.pos] = duped_piece
+      end
+    end
+
+    dup_board
+  end
+
+  def render(cursor = nil)
+    system('clear')
+    print ("   " + ('a'..'h').to_a.join(" ") + "\n")
+    self.grid.each_with_index do |row, i|
+      print "#{i + 1} "
+      row.each_with_index do |space, j|
+        if cursor.nil?
+          if (i + j).odd?
+            background = :light_black
+          else
+            background = :light_blue
+          end
+        else
+          if @cursor == [i,j]
+            background = :yellow
+          elsif (i + j).odd?
+            background = :light_black
+          else
+            background = :light_blue
+          end
+        end
+        if space.nil?
+          print '  '.colorize(:background => background)
+        else
+          print "#{space.symbol} ".colorize(:color => space.color,
+            :background => background)
+        end
+      end
+      print " #{i + 1}"
+      puts
+    end
+    print ("  " + ('a'..'h').to_a.join(" ") + "\n")
+  end
+
+
+  def king(color)
+    pieces(color).find { |piece| piece.is_a?(King)}
+  end
+
+  def pieces(color)
+    pieces = @grid.flatten.compact
+    pieces.select { |piece| piece.color == color}
+  end
+
+  def populate_board
+    [[1,:white], [6, :black]].each do |row|
+      @grid[row.first].map!.with_index do |space, i|
+        Pawn.new(self, row.last, [row.first, i])
+      end
+    end
+
+    [[0, :white], [7, :black]].each do |row|
+      @grid[row.first].map!.with_index do |space, i|
+        case i
+        when 0
+          Rook.new(self, row.last, [row.first, i])
+        when 1
+          Knight.new(self, row.last, [row.first, i])
+        when 2
+          Bishop.new(self, row.last, [row.first, i])
+        when 3
+          King.new(self, row.last, [row.first, i])
+        when 4
+          Queen.new(self, row.last, [row.first, i])
+        when 5
+          Bishop.new(self, row.last, [row.first, i])
+        when 6
+          Knight.new(self, row.last, [row.first, i])
+        when 7
+          Rook.new(self, row.last, [row.first, i])
+        end
+      end
+    end
+  end
+end
+
+if __FILE__ == $PROGRAM_NAME
+  board = Board.new
+  board.render
+end

data/lib/errors.rb

@@ -0,0 +1,32 @@
+class MoveError < IOError
+end
+
+class InvalidMoveError < MoveError
+  def message
+    "Not one of the possible moves for that piece."
+  end
+end
+
+class NoPieceError < MoveError
+  def message
+    "You didn't select a piece."
+  end
+end
+
+class WrongColorError < MoveError
+  def message
+    "You are attempting to move your opponent's piece"
+  end
+end
+
+class BadInputError < MoveError
+  def message
+    "Excuse me? Please provide valid input."
+  end
+end
+
+class OffBoardError < MoveError
+  def message
+    "That position is off the board."
+  end
+end

data/lib/game.rb

@@ -0,0 +1,60 @@
+# coding: utf-8
+require_relative 'board'
+require_relative 'players/human_player.rb'
+require_relative 'players/computer_player.rb'
+
+class Game
+  attr_accessor :board
+
+  def initialize(player_white, player_black)
+    @board = Board.new
+    @player_white = player_white
+    @player_white.board = @board
+    @player_black = player_black
+    @player_black.board = @board
+    @current_player = player_white
+  end
+
+  def right_color?(pos)
+    @board[pos].color == @current_player.color
+  end
+
+  def switch_player
+    if @current_player == @player_white
+      @current_player = @player_black
+    else
+      @current_player = @player_white
+    end
+  end
+
+  def game_status
+    message = ""
+    if @board.in_check?(@current_player.color)
+      message += "#{@current_player.color.to_s.capitalize} is in check \n"
+    end
+    message += "#{@current_player.color.to_s.capitalize}'s turn \n"
+  end
+
+  def play
+    until @board.won? || @board.stalemate?(@current_player.color)
+      begin
+        board.render
+        puts game_status
+        start_pos, end_pos = @current_player.make_move
+        @board.move(start_pos, end_pos, @current_player.color)
+        switch_player
+      rescue MoveError => e
+        puts e.message
+        puts "Enter to continue"
+        gets
+      end
+    end
+    board.render
+    if @board.stalemate?(@current_player.color)
+      puts "Stalemate"
+    else
+      switch_player
+      puts "#{@current_player.color.to_s.capitalize} wins!"
+    end
+  end
+end

data/lib/pieces/bishop.rb

@@ -0,0 +1,19 @@
+# coding: utf-8
+require_relative 'sliding_piece'
+
+class Bishop < SlidingPiece
+  def symbol
+    '♝'
+  end
+
+  def move_dirs
+    [[1, 1],
+    [-1, 1],
+    [1, -1],
+    [-1, -1]]
+  end
+
+  def value
+    3
+  end
+end

data/lib/pieces/king.rb

@@ -0,0 +1,21 @@
+# coding: utf-8
+require_relative 'stepping_piece'
+
+class King < SteppingPiece
+  def symbol
+    '♚'
+  end
+
+  def move_diffs
+    [
+      [1, 1],
+      [1, 0],
+      [0, 1],
+      [-1, 1],
+      [1, -1],
+      [-1, -1],
+      [-1, 0],
+      [0, -1]
+    ]
+  end
+end

data/lib/pieces/knight.rb

@@ -0,0 +1,25 @@
+# coding: utf-8
+require_relative 'stepping_piece'
+
+class Knight < SteppingPiece
+  def symbol
+    '♞'
+  end
+
+  def move_diffs
+    [
+      [1, 2],
+      [2, 1],
+      [-1, 2],
+      [2, -1],
+      [-1, -2],
+      [-2, -1],
+      [-2, 1],
+      [1, -2]
+    ]
+  end
+
+  def value
+    3
+  end
+end

data/lib/pieces/pawn.rb

@@ -0,0 +1,41 @@
+# coding: utf-8
+require_relative 'piece'
+
+class Pawn < Piece
+  NORMAL_MOVE = [1, 0]
+  INITIAL_MOVE = [2, 0]
+  ATTACK_MOVES = [[1, 1], [1, -1]]
+
+
+  def symbol
+    '♟'
+  end
+
+  def moves
+    moves = []
+    modifier = self.color == :white ? 1 : -1
+
+    normal_move = sum_positions(NORMAL_MOVE.map { |move| move * modifier }, @pos)
+    unless @board.occupied?(normal_move)
+      moves << normal_move
+    end
+
+    initial_move = sum_positions(INITIAL_MOVE.map { |move| move * modifier }, @pos)
+    if !@moved && moves.include?(normal_move) && !@board.occupied?(initial_move)
+      moves << initial_move
+    end
+
+    ATTACK_MOVES.each do |attack_move|
+      potential_pos = sum_positions(@pos.dup, attack_move.map { |move| move * modifier })
+      if @board.occupied?(potential_pos) && @board.piece_at(potential_pos).color != @color
+        moves << potential_pos
+      end
+    end
+
+    moves.select { |move| @board.on_board?(move)}
+  end
+
+  def value
+    1
+  end
+end

data/lib/pieces/piece.rb

@@ -0,0 +1,42 @@
+# coding: utf-8
+class Piece
+  attr_reader :color
+  attr_accessor :pos, :moved
+
+  def initialize(board, color, pos)
+    @board = board
+    @color = color
+    @pos = pos
+    @moved = false
+  end
+
+  def in_range_of_enemy?
+    @color == :white ? enemy_color = :black : enemy_color = :white
+    @board.pieces(enemy_color).each do |piece|
+      return true if piece.valid_moves.include?(@pos)
+    end
+    false
+  end
+
+  def symbol
+    raise NotImplementedError.new ("No symbol!")
+  end
+
+  def dup(dup_board)
+    self.class.new(dup_board, @color, @pos.dup)
+  end
+
+  def valid_moves
+    moves.reject { |move| move_into_check?(move) }
+  end
+
+  def move_into_check?(move)
+    duped_board = @board.deep_dup
+    duped_board.move!(self.pos, move)
+    duped_board.in_check?(@color)
+  end
+
+  def sum_positions(pos1, pos2)
+    [pos1.first + pos2.first, pos1.last + pos2.last]
+  end
+end

data/lib/pieces/queen.rb

@@ -0,0 +1,22 @@
+# coding: utf-8
+require_relative 'sliding_piece'
+
+class Queen < SlidingPiece
+  def symbol
+    '♛'
+  end
+
+  def move_dirs
+    [[1, 0],
+    [0, 1],
+    [-1, 0],
+    [0, -1],
+    [1, 1],
+    [-1, 1],
+    [1, -1],
+    [-1, -1]]
+  end
+  def value
+    9
+  end
+end

data/lib/pieces/rook.rb

@@ -0,0 +1,20 @@
+# coding: utf-8
+require_relative 'sliding_piece'
+
+class Rook < SlidingPiece
+  def symbol
+    '♜'
+  end
+
+  def move_dirs
+    [
+      [1, 0],
+      [0, 1],
+      [-1, 0],
+      [0, -1]
+    ]
+  end
+  def value
+    5
+  end
+end

data/lib/pieces/sliding_piece.rb

@@ -0,0 +1,36 @@
+# coding: utf-8
+require_relative 'piece'
+
+class SlidingPiece < Piece
+
+  def moves
+    moves = []
+    move_dirs.each do |dir|
+      moves += explore(dir)
+    end
+
+    moves
+  end
+
+  def explore(dir)
+    pos = @pos.dup
+    positions = []
+
+    while @board.on_board?([pos[0] + dir[0], pos[1] + dir[1]])
+      pos[0] += dir[0]
+      pos[1] += dir[1]
+      if @board.occupied?(pos)
+        if @board.piece_at(pos).color == self.color
+          break
+        else
+          positions << pos.dup
+          break
+        end
+      end
+
+      positions << pos.dup
+    end
+
+    positions
+  end
+end

data/lib/pieces/stepping_piece.rb

@@ -0,0 +1,19 @@
+# coding: utf-8
+require_relative 'piece'
+
+class SteppingPiece < Piece
+
+  def moves
+    moves = []
+    move_diffs.each do |diff|
+      new_pos = [@pos.first + diff.first, @pos.last + diff.last]
+      next unless @board.on_board?(new_pos)
+      if @board.occupied?(new_pos)
+        next if @board.piece_at(new_pos).color == self.color
+      end
+      moves << new_pos
+    end
+
+    moves
+  end
+end

data/lib/pieces.rb

@@ -0,0 +1,6 @@
+require_relative 'pieces/king.rb'
+require_relative 'pieces/knight.rb'
+require_relative 'pieces/pawn.rb'
+require_relative 'pieces/queen.rb'
+require_relative 'pieces/rook.rb'
+require_relative 'pieces/bishop.rb'

data/lib/players/computer_player.rb

@@ -0,0 +1,63 @@
+class ComputerPlayer
+  attr_reader :color
+  attr_writer :board
+
+  def initialize(color)
+    @color = color
+  end
+
+  def make_move
+    valid_moves_hash = {}
+    @board.pieces(@color).each do |piece|
+      valid_moves_hash[piece.pos] = piece.valid_moves unless piece.valid_moves.empty?
+    end
+
+    rand_key = valid_moves_hash.keys.sample
+    random_move = [rand_key, valid_moves_hash[rand_key].sample]
+
+    good_moves = []
+    neutral_moves = []
+    death_moves = []
+
+    valid_moves_hash.each_pair do |start_pos, potential_positions|
+      potential_positions.each do |potential_pos|
+        if death_move?([start_pos, potential_pos])
+          death_moves << [start_pos, potential_pos]
+        elsif @board.piece_at(potential_pos)
+          good_moves << [start_pos, potential_pos]
+        else
+          neutral_moves << [start_pos, potential_pos]
+        end
+      end
+    end
+    sleep(0.001)
+
+    if !good_moves.empty?
+      chosen_move = best_move(good_moves)
+    elsif !neutral_moves.empty?
+      chosen_move = neutral_moves.sample
+    else
+      chosen_move = death_moves.sample
+    end
+    chosen_move
+  end
+
+  #finds highest value target from good_moves
+  #GOOD MOVES MUST BE AN ARRAY OF CAPTURE MOVES
+  def best_move(good_moves)
+    best_move = good_moves.sample
+    good_moves.each do |move|
+      if @board.piece_at(move.last).value >
+                          @board.piece_at(best_move.last).value
+        best_move = move
+      end
+    end
+    best_move
+  end
+
+  def death_move?(move)
+    duped_board = @board.deep_dup
+    duped_board.move!(move.first, move.last)
+    duped_board.piece_at(move.last).in_range_of_enemy?
+  end
+end

data/lib/players/human_player.rb

@@ -0,0 +1,27 @@
+class HumanPlayer
+  attr_reader :color
+  attr_writer :board
+
+  def initialize(color)
+    @color = color
+  end
+
+  def make_move
+    # puts "Enter your move"
+    # i1, i2 = gets.chomp.split
+    # raise BadInputError if i2.nil?
+
+    i1 = @board.move_cursor
+
+    i2 = @board.move_cursor
+
+    [i1, i2]
+  end
+
+  # def input_to_pos(input)
+  #   letter, number = input.split("")
+  #   coord2 = letter.ord - 'a'.ord
+  #   coord1 = number.to_i - 1
+  #   [coord1, coord2]
+  # end
+end

data/lib/ruby_chess/version.rb

@@ -0,0 +1,3 @@
+class RubyChess
+  VERSION = "0.1.0"
+end

data/lib/ruby_chess.rb

@@ -0,0 +1,49 @@
+# coding: utf-8
+require_relative 'game'
+require_relative 'players/human_player.rb'
+require_relative 'players/computer_player.rb'
+
+class RubyChess
+
+  def run
+    clear_screen
+    choose_players
+    game = Game.new(@white_player, @black_player)
+    game.play
+    run if reset == 'y' || reset =='Y' || reset == 'yes' || reset == 'Yes'
+  end
+
+  def choose_players
+    puts "Welcome to RubyChess by Joe Daly"
+    puts
+    puts "Who will play white? (Human or Computer)"
+    white_choice = gets.chomp
+    puts "Who will play black? (Human or Computer)"
+    black_choice = gets.chomp
+
+    set_players(white_choice, black_choice)
+  end
+
+  def clear_screen
+    system('clear')
+  end
+
+  def reset
+    puts "Would you like to play again? (y/n)"
+    gets.chomp
+  end
+
+  def set_players(white_choice, black_choice)
+    if white_choice == 'Human' || white_choice == 'human'
+      @white_player = HumanPlayer.new(:white)
+    else
+      @white_player = ComputerPlayer.new(:white)
+    end
+    if black_choice == 'Human' || black_choice == 'human'
+      @black_player = HumanPlayer.new(:black)
+    else
+      @black_player = ComputerPlayer.new(:black)
+    end
+  end
+
+end

data/ruby_chess.gemspec

@@ -0,0 +1,20 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'ruby_chess/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "ruby_chess"
+  spec.version       = RubyChess::VERSION
+  spec.authors       = ["Joseph Daly"]
+  spec.email         = ["josefdaly@gmail.com"]
+  spec.summary       = "Joe's Chess game for ruby"
+  spec.description   = "Joe's Chess game for ruby"
+  spec.homepage      = "https://github.com/josefdaly/RubyChess"
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.executables   = ["ruby_chess"]
+  spec.require_paths = ["lib"]
+
+  spec.add_development_dependency "bundler", "~> 1.9"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

metadata

@@ -0,0 +1,96 @@
+--- !ruby/object:Gem::Specification
+name: ruby_chess
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Joseph Daly
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-06-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.9'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Joe's Chess game for ruby
+email:
+- josefdaly@gmail.com
+executables:
+- ruby_chess
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- Gemfile
+- README.md
+- Rakefile
+- bin/ruby_chess
+- lib/board.rb
+- lib/errors.rb
+- lib/game.rb
+- lib/pieces.rb
+- lib/pieces/bishop.rb
+- lib/pieces/king.rb
+- lib/pieces/knight.rb
+- lib/pieces/pawn.rb
+- lib/pieces/piece.rb
+- lib/pieces/queen.rb
+- lib/pieces/rook.rb
+- lib/pieces/sliding_piece.rb
+- lib/pieces/stepping_piece.rb
+- lib/players/computer_player.rb
+- lib/players/human_player.rb
+- lib/ruby_chess.rb
+- lib/ruby_chess/version.rb
+- ruby_chess.gemspec
+homepage: https://github.com/josefdaly/RubyChess
+licenses: []
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.4.6
+signing_key: 
+specification_version: 4
+summary: Joe's Chess game for ruby
+test_files: []