ruby-chess 0.0.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 1452333c430641f1e9a88d3fc161f93088a77711
+  data.tar.gz: fc97265dbdb0b88f318f62f3154b29f9d26cd770
+SHA512:
+  metadata.gz: 298dd4574960b152a2492067d73b066663494f14efe1654f44a2871a1379e6e5edf8fe83c28924dfd53809419810ebaf24f12e4ecf9619e8c0a9812717a708db
+  data.tar.gz: d17700fb66c60e0e9e95bfe97cfd98a4465075395bfaf85b7fa4d9bf94d4a99da58184a414a1259c2e4ddf8de2fb490f440da9d827d625ef3be4452d4cc1bfaa

data/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 John Hager
+
+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,4 @@
+chess
+=====
+
+Chess in ruby

data/bin/ruby-chess.rb

@@ -0,0 +1,39 @@
+#!/usr/bin/env ruby
+
+require_relative '../lib/chess'
+
+game = Game.new
+
+def game.prompt_for_turn
+  puts "Resign or enter piece coordinates then move coordinate." 
+  print "Format: x,y:a,b for move (e.g. 3,1:3,3): "
+  ans = gets.chomp.downcase.gsub(/\s/, '')
+
+  if ans =~ /res/
+    self.resign 
+    sleep(3)
+    nil
+  else
+    ans.split(':').map do |point| 
+      point.split(',').map {|i| i.to_i}
+    end
+  end
+end 
+
+system "clear"
+game.show
+
+until game.over?
+  begin 
+    puts "#{game.turn.to_s.capitalize}'s turn"
+    ans = game.prompt_for_turn
+    game.play(*ans) if ans
+
+    system "clear"
+    game.show
+  rescue Game::IllegalMove
+    next
+  end
+end
+
+system "clear"

data/lib/bishop.rb

@@ -0,0 +1,43 @@
+module Bishop
+
+  extend self
+  include Moves
+
+  def illegal(board,x,y)
+    possible_moves = []
+
+    7.times do |coord|
+      possible_moves += Board.board_safe(
+        diagonal(coord) 
+      )
+    end
+
+    if not(possible_moves.any? {|move| move == [x,y]})
+      raise Game::IllegalMove, "#{x},#{y} is not a possible move" 
+    elsif board.at(x,y).friend_of?(self)
+      raise Game::IllegalMove, "#{x},#{y} is occupied by a friend"
+    elsif jumped?(board,x,y) 
+      raise Game::IllegalMove, "Bishops cannot jump" 
+    else
+      :legal_move
+    end
+  end
+end
+
+class WhiteBishop < WhitePiece 
+
+  include Bishop
+
+  def to_s
+    "WB"
+  end
+end
+
+class BlackBishop < BlackPiece
+
+  include Bishop
+
+  def to_s
+    "BB"
+  end
+end

data/lib/board.rb

@@ -0,0 +1,78 @@
+class Board 
+
+  BackRow = { white: 7, black: 0 }
+
+  attr_accessor :board, :en_passent
+  def initialize(flag = false)
+    @board = []
+    8.times do |y| 
+      row = [] 
+      8.times {|x| row << EmptySpace.new(x,y)}
+      @board << row
+    end 
+
+    unless flag
+      pieces = []
+      8.times do |x|
+        pieces << BlackPawn.new(x,6) << WhitePawn.new(x,1)
+      end
+
+      [0,7].each do |x|
+        pieces << BlackRook.new(x,7) << WhitePawn.new(x,0)
+      end
+
+      [1,6].each do |x|
+        pieces << BlackKnight.new(x,7) << WhiteKnight.new(x,0)
+      end
+
+      [2,5].each do |x|
+        pieces << BlackBishop.new(x,7) << WhiteBishop.new(x,0)
+      end 
+
+      pieces << BlackQueen.new(4,7) << WhiteQueen.new(3,0)
+      pieces << BlackKing.new(3,7)  << WhiteKing.new(4,0)
+
+      pieces.each {|piece| place(piece)}
+    end
+
+    @en_passent = NullSpace.new
+  end
+
+  def place(piece)
+    piece.place_on(self)
+  end
+
+  def remove(piece)
+    piece.remove_from(self)
+  end
+
+  def at(x,y)
+    board[y][x]
+  end
+
+  def enemies(piece)
+    board.flatten.select {|other| other.enemy_of?(piece)}
+  end
+
+  def move(piece, x, y)
+    piece.move(self, x, y)
+  end
+
+  def self.board_safe(points)
+    points.select do |point| 
+      not(point.any? {|cord| cord < 0 or cord > 7})
+    end 
+  end
+
+  def to_s
+    out = "\s\s"
+    out << (0..7).to_a.join(' ') << "\n" 
+
+    @board.each_with_index do |row, i| 
+      out << "#{i} " << (row.collect{|pc| pc.to_s}).join('') << "\n"
+    end
+    
+    out
+  end
+end
+

data/lib/chess.rb

@@ -0,0 +1,11 @@
+require_relative 'board'
+require_relative 'space'
+require_relative 'moves'
+require_relative 'piece'
+require_relative 'pawn'
+require_relative 'rook'
+require_relative 'knight'
+require_relative 'bishop'
+require_relative 'queen'
+require_relative 'king'
+require_relative 'game'

data/lib/game.rb

@@ -0,0 +1,81 @@
+class Game
+
+  attr_reader :turn
+  def initialize
+    @board = Board.new
+    @kings = {white: @board.at(4,0), black: @board.at(3,7)}
+    @moves = []
+    @turn = :white
+    @over = false
+  end
+
+  def show
+    puts @board
+  end
+
+  def over?
+    @over
+  end
+
+  def at(x,y)
+    @board.at(x,y)
+  end
+
+  def undo
+    move = @moves.pop
+    piece = at(*move[:piece][:point_a])
+    new_piece = piece.class.new(*move[:piece][:point_b])
+    capture = move[:capture]
+
+    @board.remove(piece)
+    @board.place(new_piece)
+    @board.place(capture)
+
+    switch_turn
+  end
+
+  def play(point_a, point_b) 
+    raise Game::IllegalMove, "Game over" if @over
+
+    piece, at_destination = at(*point_a), at(*point_b) 
+
+    unless piece.color == @turn
+        raise Game::IllegalMove, 
+          "It is #{@turn.to_s.capitalize}'s turn" 
+    end
+
+    @board.move(piece, *point_b)
+    @moves << {
+      piece: {
+        point_a: point_a,
+        point_b: point_b,
+      },
+      capture: at_destination,
+    }
+
+    if @kings[@turn].checked?(@board)
+      undo
+      raise Game::IllegalMove, "#{@turn}'s king is in check!"
+    end
+
+    switch_turn
+  end
+
+  def resign
+    @over = true
+    print "#{@turn.to_s.capitalize} resigns, "
+    switch_turn
+    puts "#{@turn.to_s.capitalize} wins!" 
+  end
+
+  private
+    def switch_turn 
+      @turn = @turn == :white ? :black : :white
+    end
+
+  public 
+    class IllegalMove < Exception 
+    end
+end
+
+

data/lib/king.rb

@@ -0,0 +1,107 @@
+module King
+
+  extend self
+  include Moves
+
+  def illegal(board,x,y)
+    x_diff = x-@x
+    possible_moves = []
+
+    possible_moves += Board.board_safe(
+        diagonal(1) + horizontal(1) + vertical(1) 
+    )
+
+    if @start #castling
+      possible_moves += [
+        [@x-(2 * @direction), @y], [@x+(2 * @direction), @y] 
+      ]
+    end
+
+    if not(possible_moves.any? {|move| move == [x,y]})
+      raise Game::IllegalMove, "#{x},#{y} is not a possible move" 
+    elsif board.at(x,y).friend_of?(self)
+      raise Game::IllegalMove, "#{x},#{y} is occupied by a friend"
+    elsif jumped?(board,x,y)
+      raise Game::IllegalMove, "Kings can't jump"
+    elsif checked?(board,x,y,x_diff)
+      raise Game::IllegalMove, "King can't move into check"
+    else
+      castle(board,x,y,x_diff) if (x_diff).abs > 1
+      :legal_move
+    end
+  end
+
+  def castle(board,x,y,x_diff)
+    direction = x_diff/x_diff.abs
+
+    # get rook, raise illegal move unless start, else move the rook
+    if direction > 0 # right
+      rook = board.at(7,y)
+      rook_x = x-1
+    else             # left
+      rook = board.at(0,y)
+      rook_x = x+1
+    end
+
+    if rook.is_a?(Rook) && rook.friend_of?(self) && rook.start
+      board.move(rook,rook_x,y)
+    else
+      raise Game::IllegalMove, "King cannot castle this way, now"
+    end
+  end
+
+  def checked?(board,x = @x, y = @y, x_diff = 0)
+    enemies = board.enemies(self)
+    spaces = [[x,y]]
+
+    if x_diff.abs > 1 #castling
+      spaces << [x - 1*(x_diff/x_diff.abs), y]
+    end
+
+    enemies.each do |enemy|
+      spaces.each do |space|
+        begin
+          enemy.illegal(board,*space)
+          return true
+        rescue Game::IllegalMove
+          :not_checked
+        end
+      end
+    end
+
+    return false 
+  end
+end
+
+class WhiteKing < WhitePiece
+ 
+  include King
+
+  attr_reader :start
+  def initialize(x,y)
+    super
+    @start = true
+    @direction = 1
+  end
+
+  def to_s
+    "W!"
+  end
+end
+
+class BlackKing < BlackPiece
+  
+  include King
+
+  attr_reader :start
+  def initialize(x,y)
+    super
+    @start = true
+    @direction = -1
+  end
+
+  def to_s
+    "B!"
+  end
+end
+

data/lib/knight.rb

@@ -0,0 +1,45 @@
+module Knight
+
+  extend self
+  include Moves
+
+  def illegal(board,x,y)
+    possible_moves = [
+      [@x+2, @y-1],
+      [@x+2, @y+1],
+      [@x-2, @y+1],
+      [@x-2, @y-1],
+      [@x+1, @y-2],
+      [@x-1, @y-2],
+      [@x+1, @y+2],
+      [@x-1, @y+2],
+    ]
+
+    if not(possible_moves.any? {|move| move == [x,y]})
+      raise Game::IllegalMove, "#{x},#{y} is not a possible move" 
+    elsif board.at(x,y).friend_of?(self)
+      raise Game::IllegalMove, "#{x},#{y} is occupied by a friend"
+    else
+      :legal_move
+    end
+  end
+end
+
+class WhiteKnight < WhitePiece
+
+  include Knight
+
+  def to_s
+    "WK"
+  end
+end
+
+class BlackKnight < BlackPiece
+
+  include Knight
+
+  def to_s
+    "BK"
+  end
+end
+

data/lib/moves.rb

@@ -0,0 +1,37 @@
+module Moves
+
+  def move(board,x,y)
+    illegal(board,x,y)
+
+    remove_from(board)
+    @x,@y = x,y
+    place_on(board)
+
+    @start &&= false
+  end
+
+  def diagonal(coord)
+    [
+      [@x-coord, @y-coord],
+      [@x+coord, @y-coord],
+      [@x-coord, @y+coord],
+      [@x+coord, @y+coord],
+    ]
+  end
+
+  def horizontal(coord)
+    [
+      [@x-coord, @y],
+      [@x+coord, @y],
+    ]
+  end
+
+  def vertical(coord)
+    [ 
+      [@x,       @y-coord],
+      [@x,       @y+coord],
+    ]
+  end
+end
+
+

data/lib/pawn.rb

@@ -0,0 +1,111 @@
+module Pawn
+
+  extend self
+
+  attr_reader :direction
+
+  # attempt to move the piece to x,y on the board
+  def move(board,x,y)
+    # check if it is an illegal move (raises Game::IllegalMove if it is)
+    illegal(board, x, y)
+
+    # make start false if it not already false
+    !@start || @start = false
+
+    # remove the piece from it's original position 
+    board.remove(self)
+    
+    # save the piece if it can be taken by en passent
+    board.en_passent = (@y-y).abs == 2 ? self : NullSpace.new 
+
+    # update the coordinates
+    @x, @y = x, y
+
+    # replace with queen if on back row
+    if @y == Board::BackRow[color]  
+      board.place(@queen.new(@x,@y))
+    else
+      # or place on board
+      place_on(board)
+    end
+  end
+
+  def illegal(board,x,y)
+    possible_moves = [
+      [@x, @y+(1 * @direction)],
+    ]
+    possible_moves << [@x, @y+(2 * @direction)] if @start
+    possible_moves = Board.board_safe(possible_moves)
+
+    possible_attack_moves = Board.board_safe([
+      [@x-1, @y+(1 * @direction)],
+      [@x+1, @y+(1 * @direction)] 
+    ])
+
+    en_passent = board.en_passent
+    en_passent_coord = en_passent.to_coord
+    en_passent_coord[1] &&= en_passent_coord[1] - en_passent.direction
+
+    if board.at(x,y).friend_of?(self)
+      error = "Your piece is blocking your path"
+    elsif board.at(x,y).enemy_of?(self)
+      unless possible_attack_moves.find {|move| move == [x,y]}
+        error = "Cannot move this way!"
+      end
+    elsif en_passent_coord == [x,y] 
+      unless possible_attack_moves.find {|move| move == [x,y]}
+        error = "Cannot move this way!"
+      else
+        en_passent.remove_from(board)
+      end
+    else
+      unless possible_moves.find {|move| move == [x,y]}
+        error = "Cannot move here!"
+      else
+        if jumped?(board,x,y)
+          raise Game::IllegalMove, "Pawns cannot jump!" 
+        end
+      end
+    end
+
+    raise Game::IllegalMove, error if error 
+  end
+
+  def jumped?(board,x,y)
+    return false unless (@y-y).abs == 2
+    !board.at(x,y-@direction).empty?
+  end
+end
+
+class WhitePawn < WhitePiece 
+
+  include Pawn 
+
+  def initialize(x,y)
+    super
+    @start = true
+    @direction = 1
+    @queen = WhiteQueen
+  end
+
+  def to_s
+    "WP"
+  end
+end
+
+class BlackPawn < BlackPiece 
+
+  include Pawn 
+
+  def initialize(x,y)
+    super
+    @start = true
+    @direction = -1
+    @queen = BlackQueen
+  end
+
+  def to_s
+    "BP"
+  end
+end
+

data/lib/piece.rb

@@ -0,0 +1,74 @@
+class Piece < EmptySpace
+
+  private
+    def jumped?(board,x,y) 
+      start, new = self.to_coord, [x,y]
+
+      # find all the spaces ([x,y]) between start and new
+      x_diff = (start.first - new.first)
+      y_diff = (start.last - new.last) 
+
+      moves_between = [] 
+
+      if x_diff == 0 # vertical movement
+        multiplyer = y_diff / y_diff.abs 
+
+        ((y_diff.abs)-1).times do |aug|
+          aug = (aug + 1) * multiplyer  
+          moves_between << [x, y + aug] 
+        end
+
+      elsif y_diff == 0 # horizontal movement
+        multiplyer = x_diff / x_diff.abs 
+
+        ((x_diff.abs)-1).times do |aug|
+          aug = (aug + 1) * multiplyer  
+          moves_between << [x + aug, y] 
+        end
+      else # diagonal movement
+        y_multiplyer = y_diff / y_diff.abs 
+        x_multiplyer = x_diff / x_diff.abs
+
+        ((x_diff.abs)-1).times do |aug|
+          y_aug = (aug + 1) * y_multiplyer  
+          x_aug = (aug + 1) * x_multiplyer
+          moves_between << [x + x_aug, y + y_aug] 
+        end
+      end
+
+      moves_between.any? {|coord| !board.at(*coord).empty?}
+    end
+end
+
+class BlackPiece < Piece 
+
+  def initialize(x,y)
+    super
+    @color = :black
+  end
+
+  def enemy_of?(piece)
+    piece.color == :white
+  end
+  
+  def friend_of?(piece)
+    piece.color == color
+  end
+end
+
+class WhitePiece < Piece
+
+  def initialize(x,y)
+    super 
+    @color = :white 
+  end
+
+  def enemy_of?(piece)
+    piece.color == :black 
+  end 
+
+  def friend_of?(piece)
+    piece.color == color
+  end
+end 
+

data/lib/queen.rb

@@ -0,0 +1,43 @@
+module Queen 
+
+  extend self
+  include Moves
+
+  def illegal(board,x,y)
+    possible_moves = []
+
+    7.times do |coord|
+      possible_moves += Board.board_safe(
+        diagonal(coord) + horizontal(coord) + vertical(coord) 
+      )
+    end
+
+    if not(possible_moves.any? {|move| move == [x,y]})
+      raise Game::IllegalMove, "#{x},#{y} is not a possible move" 
+    elsif board.at(x,y).friend_of?(self)
+      raise Game::IllegalMove, "#{x},#{y} is occupied by a friend"
+    elsif jumped?(board,x,y) 
+      raise Game::IllegalMove, "Queens cannot jump" 
+    else
+      :legal_move
+    end
+  end
+end
+
+class WhiteQueen < WhitePiece
+
+  include Queen
+
+  def to_s
+    "WQ"
+  end
+end
+
+class BlackQueen < BlackPiece
+
+  include Queen
+
+  def to_s
+    "BQ"
+  end
+end