chess_game 0.0.11

data/lib/chess/move_helper.rb

@@ -0,0 +1,185 @@
+class String
+
+  # "-" overloaded on string to assist in differencing algebraic notation strings
+  def -(next_loc)
+    if next_loc.length == 2 && self.length == 2
+      x = self[0].ord - next_loc[0].ord
+      y = self[1].ord - next_loc[1].ord
+      return x, y
+    end
+  end
+
+  def passed?
+    nil
+  end
+
+  def passable?
+    nil
+  end
+
+  def passable=(o)
+    nil
+  end
+
+  def color
+    nil
+  end
+
+  def opponent?(o = nil)
+    nil
+  end
+
+  def location
+    nil
+  end
+
+  def location=(o = nil)
+    nil
+  end
+
+  def move(o = nil, p = nil)
+    nil
+  end
+
+  def friend?(o = nil)
+    nil
+  end
+
+  def rank?
+    ("1".."8").any? { |x| self[0] == x }
+  end
+
+  def file?
+    ("A".."H").any? { |x| self[0] == x }
+  end
+
+
+end
+
+def squares_between(loc_1, loc_2)
+  x, y = loc_2 - loc_1
+
+  if x == y && y == 0
+    return nil
+  end
+
+  if x > 0
+    x_range = (loc_1[0]..loc_2[0]).to_a
+  elsif x < 0
+    x_range = (loc_2[0]..loc_1[0]).to_a.reverse
+  end
+  if y > 0
+    y_range = (loc_1[1]..loc_2[1]).to_a
+  elsif y < 0
+    y_range = (loc_2[1]..loc_1[1]).to_a.reverse
+  end
+
+  if x != 0 && y == 0
+    y_range = Array.new(x_range.length, loc_1[1])
+  elsif x == 0 && y != 0
+    x_range = Array.new(y_range.length, loc_1[0])
+  end
+
+  # zip up the ranges to made a clean list of square between
+  squares_between = []
+  x_range.zip(y_range).each { |x| squares_between << x.join }
+
+  # trim off the first and last squares
+  squares_between.delete_at(0)
+  squares_between.delete_at(-1)
+  return squares_between
+end
+
+def check_castle(king, board, horiz_move, vert_move)
+  if king.moves > 0 || horiz_move.abs != 2
+    return false
+  end
+
+  unless vert_move == 0
+    return false
+  end
+
+  if king.black?
+    return false unless king.location == "E8"
+    queen_rook = board.board["A8"]
+    king_rook = board.board["H8"]
+    horiz_move < 0 ? attack = "D8" : attack = "F8"
+  elsif king.white?
+    return false unless king.location == "E1"
+    queen_rook = board.board["A1"]
+    king_rook = board.board["H1"]
+    horiz_move < 0 ? attack = "D1" : attack = "F1"
+  else
+    return nil
+  end
+
+  # check if the square the king passes through is under attack
+  # place a "test king" and see if he is in check
+  test_king = King.new(king.color, attack)
+
+  # need to remove the old king to place a test piece
+  board.rv_piece(king.location)
+  if board[attack] == " "
+    board.set_piece(test_king)
+  else
+    board.set_piece(king)
+    return false
+  end
+
+  if test_king.check?(board)
+    board.set_piece(king)
+    board.rv_piece(attack)
+    return false
+  end
+
+  # remove the test piece and reset the king
+  board.rv_piece(attack)
+  board.set_piece(king)
+
+  if horiz_move < 0
+    queen_rook.is_a?(Rook) && queen_rook.moves == 0 ? true : (return false)
+  elsif horiz_move > 0
+    king_rook.is_a?(Rook) && king_rook.moves == 0 ? true : (return false)
+  end
+end
+
+# check if a castling move was done by the king and move the complementary rook
+def castle_complement(piece, board)
+  if piece.moves == 1
+    if piece.is_a?(King)
+
+      case piece.location
+      when "C1"
+        rook = board["A1"]
+        rook_new_loc = "D1"
+      when "G1"
+        rook = board["H1"]
+        rook_new_loc = "F1"
+      when "C8"
+        rook = board["A8"]
+        rook_new_loc = "D8"
+      when "G8"
+        rook = board["H8"]
+        rook_new_loc = "F8"
+      end
+
+      if rook.is_a?(Rook)
+        # pick up the king so the rook can move
+        board.rv_piece(piece.location)
+
+        # move the rook
+
+        board.rv_piece(rook.location)
+        rook.location = rook_new_loc
+        board.set_piece(rook)
+
+        # replace the king after
+        board.set_piece(piece)
+      end
+    end
+  end
+end
+
+def relative_square(location, x, y)
+  (location[0].ord + x).chr + (location[1].ord + y).chr
+end

data/lib/chess/pawn.rb

@@ -0,0 +1,58 @@
+require_relative 'piece.rb'
+
+class Pawn < Piece
+
+  WHITE_PAWN_ICON = "\u2659"
+  BLACK_PAWN_ICON = "\u265F"
+
+  def initialize(color = "white", location = "A1")
+    case color.downcase
+    when "white"
+      @icon = WHITE_PAWN_ICON
+    when "black"
+      @icon = BLACK_PAWN_ICON
+    end
+    super
+  end
+
+  def move(new_loc, board)
+    x, y = new_loc - @location
+    @passable = true if y.abs == 2
+    super
+  end
+
+  def valid_move?(new_loc, board)
+    x, y = new_loc - @location
+
+    y *= -1 if self.black?
+
+    if x == 0 && y == 1 && board[new_loc] == " "
+    elsif x == 0 && y == 2 && @moves == 0 && board[new_loc] == " "
+    elsif y == 1 && x.abs == 1 && board.board[new_loc].opponent?(self)
+    elsif en_passant?(new_loc, board)
+    else
+      board.move_status = "Pawns cannot make that move."
+      return false
+    end
+    super
+
+  end
+
+  def en_passant?(new_loc, board)
+    x, y = new_loc - @location
+    return false unless x.abs == 1 && y.abs == 1
+    passing_square = relative_square(@location, x, 0)
+    passed_piece = board[passing_square]
+    return false unless passed_piece.is_a?(Pawn)
+    # conditions for en passant, must be opposing pawn that moved forward twice to
+    # the square it would have occupied if it was only moved one square
+    if self.opponent?(passed_piece) && passed_piece.passable?
+      # board.rv_piece(passing_square)
+      passed_piece.passed = true
+      return passed_piece.location
+    else
+      return false
+    end
+  end
+
+end

data/lib/chess/piece.rb

@@ -0,0 +1,134 @@
+require_relative 'move_helper.rb'
+
+class Piece
+
+  def initialize(color = "white", location = 'A1')
+    @color = color
+    @location = location.upcase
+    @moves = 0
+
+    # for determining en passant
+    @passable = false
+    @passed = false
+  end
+
+  def passable?
+    @passable
+  end
+
+  def passable=(o)
+    @passable = o
+  end
+
+  def passed?
+    @passed
+  end
+
+  def passed=(o)
+    @passed = o
+  end
+
+  def moves
+    @moves
+  end
+
+  def moves=(moves)
+    @moves = moves
+  end
+
+  def color
+    @color
+  end
+
+  def location
+    @location
+  end
+
+  def file
+    @location[0]
+  end
+
+  def rank
+    @location[1]
+  end
+
+  def location=(location)
+    @location = location
+  end
+
+  def icon
+    @icon
+  end
+
+  def to_s
+    @icon
+  end
+
+  def black?
+    @color == "black"
+  end
+
+  def white?
+    @color == "white"
+  end
+
+  def opponent?(piece)
+    piece.color != @color
+  end
+
+  def friend?(piece)
+    piece.color == @color
+  end
+
+  def move(new_loc, board)
+    if self.valid_move?(new_loc, board)
+      @moves += 1
+      @location = new_loc
+    else
+      return nil
+    end
+  end
+
+  def can_promote?
+    ((@color == "white" && self.rank == "8") || (@color == "black" && self.rank == "1")) && self.is_a?(Pawn)
+  end
+
+  def my_king(board)
+    # tells a player where his beloved monarch is
+    board.board.each do |location, piece|
+      if piece.is_a?(King) && piece.color == self.color
+        return piece
+      end
+    end
+  end
+
+  def valid_move?(new_loc, board)
+    if board[new_loc].nil?
+      board.move_status = "Position is off the board"
+      return false
+    elsif @location == new_loc
+      board.move_status = "Piece must move"
+      return false
+    elsif board.piece_between?(@location, new_loc)
+      board.move_status = "Piece in between move"
+      return false
+    elsif self.friend?(board[new_loc])
+      board.move_status = "Can't take your own piece"
+      return false
+    else
+      return true
+    end
+  end
+
+  def ==(o)
+    o.class == self.class && o.state == state
+  end
+  alias_method :eql?, :==
+
+  protected
+
+    def state
+      [@color, @location, @moves]
+    end
+
+end

data/lib/chess/player.rb

@@ -0,0 +1,36 @@
+class Player
+
+  def initialize(color = "white")
+    @color = color
+  end
+
+
+  def color
+    @color
+  end
+
+  def move(loc_1, loc_2, board)
+
+    return nil unless loc_1.is_a?(String) && loc_2.is_a?(String)
+
+    loc_1.upcase!
+    loc_2.upcase!
+
+    return nil unless loc_1[0].file? && loc_2[0].file? && loc_1[1].rank? && loc_2[1].rank?
+    if board.board[loc_1].color == @color
+      unless self.king(board).will_be_in_check?(loc_1, loc_2, board)
+        board.move(loc_1, loc_2)
+      else
+        board.move_status = "Can't put your king into Check"
+        return nil
+      end
+    end
+
+  end
+
+  def king(board)
+    king = board.board.select do |square, piece|
+      return piece if piece.color == self.color && piece.class == King
+    end
+  end
+end

data/lib/chess/queen.rb

@@ -0,0 +1,30 @@
+require_relative 'piece.rb'
+
+class Queen < Piece
+
+  WHITE_QUEEN_ICON = "\u2655"
+  BLACK_QUEEN_ICON = "\u265B"
+
+  def initialize(color = "white", location = "A1")
+    case color.downcase
+    when "white"
+      @icon = WHITE_QUEEN_ICON
+    when "black"
+      @icon = BLACK_QUEEN_ICON
+    end
+    super
+  end
+
+  def valid_move?(new_loc, board)
+    x, y = new_loc - @location
+    if x.abs == y.abs
+    elsif x == 0 && y.abs > 0
+    elsif y == 0 && x.abs > 0
+    else
+      board.move_status = "Queens cannot make that move."
+      return false
+    end
+    super
+  end
+
+end

data/lib/chess/rook.rb

@@ -0,0 +1,30 @@
+require_relative 'piece.rb'
+
+class Rook < Piece
+
+  WHITE_ROOK_ICON = "\u2656"
+  BLACK_ROOK_ICON = "\u265C"
+
+  def initialize(color = "white", location = "A1")
+    case color.downcase
+    when "white"
+      @icon = WHITE_ROOK_ICON
+    when "black"
+      @icon = BLACK_ROOK_ICON
+    end
+    super
+  end
+
+  def valid_move?(new_loc, board)
+    x, y = new_loc - @location
+
+    if x == 0 && y.abs > 0
+    elsif y == 0 && x.abs > 0
+    else
+      board.move_status = "Rooks cannot make that move."
+      return false
+    end
+    super
+  end
+
+end

data/lib/chess/version.rb

@@ -0,0 +1,3 @@
+module Chess
+  VERSION = "0.0.1"
+end

data/lib/chess.rb

@@ -0,0 +1,71 @@
+require_relative 'chess/board.rb'
+
+module Chess
+  def self.play
+    @game = Game.new
+
+    @board = @game.board
+
+    players = [@game.white_player, @game.black_player]
+
+    player = @game.turn
+    opponent = @game.opponent
+
+    loop do
+
+      @board.display
+
+      # look for pieces that need promotion
+      promote = @board.piece_to_promote?
+      if promote
+        puts "Promote your piece, enter 'Queen', 'Knight', 'Bishop', or 'Rook'"
+        new_piece = Kernel.const_get(gets.chomp.to_sym)
+        @board.promote(promote.location, new_piece)
+      end
+
+      # look for check and checkmate conditions
+      if player.king(@board).checkmate?(@board)
+        puts "#{player.color.capitalize} Player, you are in " + "CHECKMATE".colorize(:red)
+        puts "#{opponent.color.capitalize} Player " + "WINS".colorize(:green)
+        break
+      elsif player.king(@board).stalemate?(@board)
+        puts "#{player.color.capitalize} Player, you are in " + "STALEMATE".colorize(:yellow)
+        puts "DRAW"
+        break
+      elsif player.king(@board).check?(@board)
+        puts "#{player.color.capitalize} Player, you are in " + "CHECK".colorize(:yellow)
+      end
+
+      puts "#{player.color.capitalize} Player, enter your move:"
+      locs = gets.chomp.split(" ")
+
+      # handle special cases, otherwise run the move
+      case locs[0]
+      when "exit", "quit"
+        puts "Are you sure? (y/n)"
+        y_or_n = gets.chomp
+        break if y_or_n[0].upcase == "Y"
+      when "save"
+        puts "enter a name to save the game as:"
+        file_name = gets.chomp
+        @game.save("save/#{file_name}")
+        break
+      when "load"
+        puts "enter the name of the game you want to load:"
+        file_name = gets.chomp
+        @game = Game.load("save/#{file_name}")
+        @board = @game.board
+        players = [@game.white_player, @game.black_player]
+        player, opponent = @game.turn, @game.opponent
+      else
+        unless player.move(locs[0], locs[1], @board).nil?
+        player, opponent = opponent, player
+        @game.turn = player
+        @game.opponent = opponent
+        else
+          puts "Invalid move, try again".colorize(:red)
+        end
+      end
+    end
+  end
+end

data/spec/bishop_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+require_relative '../lib/chess/bishop.rb'
+
+describe Bishop do
+
+  it { should be_a_kind_of(Piece) }
+  it { should respond_to :color }
+  it { should respond_to :location }
+
+  it "should know what its character is" do
+    @bishop = Bishop.new("White", "A1")
+    expect(@bishop.icon).to eq("\u2657")
+  end
+
+  describe "valid moves" do
+    before { @bishop = Bishop.new("white", "D4") }
+    before { @board = Board.new }
+
+    it "should not be able to move vertically to any position" do
+      expect(@bishop.valid_move?("A3", @board)).to be_falsey
+    end
+
+    it "should not be able to move horizontally to any position" do
+      expect(@bishop.valid_move?("D8", @board)).to be_falsey
+    end
+
+    it "should be able to move diagonally" do
+      expect(@bishop.valid_move?("C3", @board)).to be_truthy
+    end
+  end
+
+end