ari_chess 1.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: e585e588e19ed3831464788d43fa361379491a05
+  data.tar.gz: d338793003e5d77b78c10334ac8cda065f2dd50c
+SHA512:
+  metadata.gz: 2d98651dd5cfa93d7fafa750e6bc6a52ceb8287c2ac522afc12c0d9e605017b74c4757e12845e5b0d20cfe8548f599522a8f40ecf717effbc2cfb005346c3c0f
+  data.tar.gz: fe9fb67bffaaafe01f7b2d069c39aeec1a14646017a6dcfa5d5fb5e2a1dd2ebe1c90f87be2244dbfdb1482215a507f18cfb559ac42e6f6f08a6c10a5d770f7c3

data/lib/ari_chess/board.rb

@@ -0,0 +1,145 @@
+require_relative 'named_pieces'
+require 'colorize'
+
+class Board
+  attr_reader :grid
+
+  def initialize(grid = Array.new(8) { Array.new(8) })
+    @grid = grid
+  end
+
+  def on_board?(pos)
+    pos.all? { |coord| coord.between?(0, 7) }
+  end
+
+  def move(start_pos, end_pos)
+    validate_move(start_pos, end_pos)
+
+    move!(start_pos, end_pos)
+  end
+
+  def validate_move(start_pos, end_pos)
+    piece = self[start_pos]
+
+    error_message = nil
+
+    if piece.nil?
+      error_message = "Invalid move! Start position is empty."
+    elsif !piece.moves.include?(end_pos)
+      error_message = "Invalid move!"
+    elsif !piece.valid_moves.include?(end_pos)
+      error_message = "Invalid move! This move would move you into check."
+    end
+
+    raise InvalidMoveError.new(error_message) unless error_message.nil?
+
+    nil
+  end
+
+  def move!(start_pos, end_pos)
+    piece = self[start_pos]
+
+    self[end_pos] = piece
+    piece.update_piece(end_pos)
+
+    self[start_pos] = nil
+  end
+
+  def dup
+    new_board = Board.new
+
+    white_pieces = find_pieces(:W)
+    black_pieces = find_pieces(:B)
+
+    (white_pieces + black_pieces).each do |piece|
+        new_board[piece.pos] = piece.dup(new_board)
+    end
+
+    new_board
+  end
+
+  def checkmate?(color)
+    in_check?(color) && find_pieces(color).all? do |piece|
+      piece.valid_moves.empty?
+    end
+  end
+
+  def in_check?(color)
+    opposing_color = (color == :W ? :B : :W)
+    opposing_pieces = find_pieces(opposing_color)
+    king = find_pieces(color, "King")[0]
+
+    opposing_pieces.any? { |piece| piece.moves.include?(king.pos) }
+  end
+
+  def find_pieces(color, type = nil)
+    colored_pieces = grid.flatten.compact.select { |piece| piece.color == color }
+    colored_pieces.select! { |piece| piece.class.to_s == type } unless type.nil?
+
+    colored_pieces
+  end
+
+  def [](pos)
+    x, y = pos
+    @grid[x][y]
+  end
+
+  def []=(pos, value)
+    x, y = pos
+    @grid[x][y] = value
+  end
+
+  def inspect
+    ""
+  end
+
+  def render
+    square_num = 0 #tracks grid for alternating color
+    row_num = 0
+
+    puts "   a  b  c  d  e  f  g  h"
+    grid.each_with_index do |row, n|
+      row_string = ""
+      row.each do |square|
+        color = (square_num + row_num).even? ? :light_white : :light_black
+        row_string << (square.nil? ? "   " : " " + square.to_s + " ").colorize(:background => color)
+        square_num += 1
+      end
+      puts "#{(-1 * n) + 8} " + row_string
+      row_num += 1
+    end
+
+    nil
+  end
+
+  def setup_pieces
+    populate_row(0, :B, base_row_pieces)
+    populate_row(1, :B, Array.new(8) { Pawn })
+
+    populate_row(7, :W, base_row_pieces)
+    populate_row(6, :W, Array.new(8) { Pawn })
+
+    nil
+  end
+
+  def populate_row(row_idx, color, pieces)
+    grid[row_idx].each_index do |idx|
+      self[[row_idx, idx]] = pieces[idx].new([row_idx, idx], self, color)
+    end
+
+    nil
+  end
+
+  def base_row_pieces
+    [
+      Rook,
+      Knight,
+      Bishop,
+      Queen,
+      King,
+      Bishop,
+      Knight,
+      Rook
+    ]
+  end
+end

data/lib/ari_chess/error.rb

@@ -0,0 +1,7 @@
+class InvalidMoveError < StandardError
+  attr_reader :message
+
+  def initialize(message = nil)
+    @message ||= "Invalid move!"
+  end
+end

data/lib/ari_chess/game.rb

@@ -0,0 +1,97 @@
+require_relative 'board'
+require_relative 'error'
+
+class Game
+  attr_reader :board
+  attr_accessor :current_player
+
+  def initialize
+    @board = Board.new
+    @board.setup_pieces
+    @current_player = :W
+  end
+
+  def play
+    until board.checkmate?(current_player)
+      system("clear")
+      board.render
+      play_turn
+      switch_player
+    end
+
+    system("clear")
+    board.render
+    switch_player
+    puts "Game over! #{current_player} wins!"
+  end
+
+  def switch_player
+    self.current_player = (current_player == :W ? :B : :W)
+  end
+
+  def play_turn
+    board.move(*get_move)
+  rescue InvalidMoveError => e
+      puts e.message
+      retry
+  end
+
+  def get_move
+    input = prompt
+    parse_positions(input)
+  end
+
+
+  def parse_positions(input)
+    matched_input = /\s*(\w\d),*\s*(\w\d)\s*/.match(input)
+    raise InvalidMoveError if matched_input.nil?
+    positions = matched_input.captures
+    parsed_positions = positions.map { |position| parse(position) }
+    validate_move(parsed_positions.first)
+
+    parsed_positions
+  end
+
+  def validate_move(start_pos)
+    error_message = nil
+
+    piece = board[start_pos]
+    if piece.nil?
+      error_message = "Invalid move! Start position is empty."
+    elsif current_player != board[start_pos].color
+      error_message = "Invalid move! Chosen piece is not yours."
+    end
+
+    raise InvalidMoveError.new(error_message) unless error_message.nil?
+
+    nil
+  end
+
+  def prompt
+    print "\n"
+    puts "#{current_player}'s turn. Enter a move (e.g. 'a2 a3'):"
+    print "> "
+    input = gets.chomp.downcase
+  end
+
+  def parse(move)
+    raise InvalidMoveError if move.length != 2
+    col, row = move.split("")
+    row = to_i(row)
+    unless move_in_range?(row, col)
+      raise InvalidMoveError
+    end
+
+    [(-1 * row) + 8, col.ord - 97]
+  end
+
+  def to_i(row)
+    row = Integer(row)
+  rescue ArgumentError
+    raise InvalidMoveError
+  end
+
+  def move_in_range?(row, col)
+    col.between?("a", "h") && row.between?(1, 8)
+  end
+end

data/lib/ari_chess/named_pieces.rb

@@ -0,0 +1,164 @@
+require_relative 'piece'
+
+class Pawn < Piece
+  CAPTURE_DELTAS = [
+    [1, -1], #capture
+    [1,  1], #capture
+  ]
+
+  STEP_DELTA = [
+    [1,  0] #anytime
+  ]
+
+  DOUBLE_STEP_DELTA = [
+    [2,  0], #first move
+  ]
+
+  attr_accessor :first_move
+
+  def initialize(pos, board, color)
+    super
+    @first_move = true
+  end
+
+  def first_move?
+    @first_move
+  end
+
+  def dup(new_board)
+    copy = super
+    copy.first_move = first_move
+
+    copy
+  end
+
+  def moves
+    possible_moves = []
+
+    possible_moves.concat(capturable_positions)
+
+    step_pos = new_pos(deltas(STEP_DELTA).first)
+
+    if board[step_pos].nil?
+      possible_moves << step_pos
+    else
+      return possible_moves
+    end
+
+    if first_move?
+      possible_moves << double_step_pos unless double_step_pos.empty?
+    end
+
+    possible_moves
+  end
+
+  def double_step_pos
+    position = new_pos(deltas(DOUBLE_STEP_DELTA).first)
+    return position if board[position].nil?
+
+    []
+  end
+
+  def capturable_positions
+    deltas(CAPTURE_DELTAS).map { |delta| new_pos(delta) }.select do |position|
+      !board[position].nil? && board[position].color != color
+    end
+  end
+
+  def new_pos(delta)
+    x, y = pos
+    dx, dy = delta
+
+    [x + dx, y + dy]
+  end
+
+  def deltas(specific_deltas)
+    color == :B ? specific_deltas : specific_deltas.map { |dx, dy| [dx * -1, dy] }
+  end
+
+  def update_piece(pos)
+    super
+    self.first_move = false
+  end
+
+  def to_s
+    color == :W ? "\u2659" : "\u265F"
+  end
+end
+
+class Knight < SteppingPiece
+  DELTAS = [
+    [-2, -1],
+    [-2,  1],
+    [-1, -2],
+    [-1,  2],
+    [ 1, -2],
+    [ 1,  2],
+    [ 2, -1],
+    [ 2,  1]
+  ]
+
+  def to_s
+    color == :W ? "\u2658" : "\u265E"
+  end
+end
+
+class King < SteppingPiece
+  DELTAS = [
+    [ 1,  1],
+    [ 1,  0],
+    [ 1, -1],
+    [ 0, -1],
+    [-1, -1],
+    [-1,  0],
+    [-1,  1],
+    [ 0,  1],
+  ]
+
+  def to_s
+    color == :W ? "\u2654" : "\u265A"
+  end
+end
+
+class Bishop < SlidingPiece
+  DELTAS = [
+    [ 1,  1],
+    [ 1, -1],
+    [-1, -1],
+    [-1,  1],
+  ]
+
+  def to_s
+    color == :W ? "\u2657" : "\u265D"
+  end
+end
+
+class Rook < SlidingPiece
+  DELTAS = [
+    [ 1,  0],
+    [ 0, -1],
+    [-1,  0],
+    [ 0,  1],
+  ]
+
+  def to_s
+    color == :W ? "\u2656" : "\u265C"
+  end
+end
+
+class Queen < SlidingPiece
+  DELTAS = [
+    [ 1,  1],
+    [ 1,  0],
+    [ 1, -1],
+    [ 0, -1],
+    [-1, -1],
+    [-1,  0],
+    [-1,  1],
+    [ 0,  1],
+  ]
+
+  def to_s
+    color == :W ? "\u2655" : "\u265B"
+  end
+end

data/lib/ari_chess/piece.rb

@@ -0,0 +1,78 @@
+class Piece
+  attr_accessor :pos, :board, :color
+
+  def initialize(pos = nil, board = nil, color = nil)
+    @pos = pos
+    @board = board
+    @color = color
+  end
+
+  def moves
+    positions = []
+
+    deltas.each do |delta|
+      possible_moves = potential_moves(delta)
+      positions.concat(possible_moves) #unless possible_moves.nil?
+    end
+
+    positions
+  end
+
+  def update_piece(pos)
+    self.pos = pos
+  end
+
+  def next_pos(pos, delta)
+    x, y = pos
+    dx, dy = delta
+
+    [x + dx, y + dy]
+  end
+
+  def valid_pos?(pos)
+    board.on_board?(pos) && (board[pos].nil? || board[pos].color != color)
+  end
+
+  def move_into_check?(possible_pos)
+    new_board = board.dup
+    new_board.move!(pos, possible_pos)
+    new_board.in_check?(color)
+  end
+
+  def valid_moves
+    moves.reject { |move| move_into_check?(move) }
+  end
+
+  def deltas
+    self.class::DELTAS
+  end
+
+  def dup(new_board)
+    self.class.new(pos, new_board, color)
+  end
+end
+
+class SlidingPiece < Piece
+  def potential_moves(delta)
+    moves = []
+    captured_piece = false
+    current_pos = pos
+
+    until captured_piece || !valid_pos?(move = next_pos(current_pos, delta))
+      moves << move
+      captured_piece = true if !board[move].nil? && board[move].color != color
+      current_pos = move
+    end
+
+    moves
+  end
+end
+
+class SteppingPiece < Piece
+  def potential_moves(delta)
+    move = next_pos(pos, delta)
+    return [move] if valid_pos?(move)
+
+    []
+  end
+end

data/lib/ari_chess.rb

@@ -0,0 +1,22 @@
+require 'ari_chess/game'
+
+class Chess
+  def self.play
+    system("clear")
+    puts "ARI'S CLI CHESS"
+    print "\n"
+    puts "This game is simple. Technically it's for two players."
+    puts "Enter moves in the format 'a2 a3' (omit the quotes)."
+    puts "The positions can be space- or comma-delimited."
+    puts "The game will block you from putting yourself in check."
+    puts "You might want to zoom in a bit."
+    print "\n"
+    puts "Hit ENTER to play."
+    print "\n"
+
+    until (prompt = gets.chomp) == ""
+    end
+
+    Game.new.play
+  end
+end

metadata

@@ -0,0 +1,64 @@
+--- !ruby/object:Gem::Specification
+name: ari_chess
+version: !ruby/object:Gem::Version
+  version: 1.1.0
+platform: ruby
+authors:
+- Ari Borensztein
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-10-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: colorize
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.7.7
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 0.7.7
+description: A simple CLI chess game
+email: ariboren@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/ari_chess.rb
+- lib/ari_chess/board.rb
+- lib/ari_chess/error.rb
+- lib/ari_chess/game.rb
+- lib/ari_chess/named_pieces.rb
+- lib/ari_chess/piece.rb
+homepage: http://rubygems.org/gems/ari_chess
+licenses:
+- MIT
+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.2.2
+signing_key: 
+specification_version: 4
+summary: Chess
+test_files: []
+has_rdoc: