checkers_game_engine_sgallagher 0.0.2 → 0.0.3

data/lib/draughts.rb

@@ -0,0 +1,10 @@
+require 'draughts/board'
+require 'draughts/board_survey'
+require 'draughts/checker'
+require 'draughts/game'
+require 'draughts/gui'
+require 'draughts/move_check'
+require 'draughts/user_input'
+require 'draughts/computer_player'
+require 'draughts/evaluation'
+require 'draughts/minimax'

data/lib/draughts/board.rb

@@ -0,0 +1,98 @@
+class Board
+
+  def create_board
+    board = Array.new(8)
+    8.times { |index| board[index] = Array.new(8) }
+    populate_checkers(board)
+    board
+  end
+
+  def create_test_board
+    board = Array.new(8)
+    8.times { |index| board[index] = Array.new(8) }
+    board
+  end
+
+  def add_checker(board, color, x, y)
+    board[x][y] = Checker.new(x, y, color)
+  end
+
+  def place_checker_on_board(board, checker)
+    board[checker.x_pos][checker.y_pos] = checker
+  end
+
+  def populate_checkers(board)
+    0.upto(2) do |x_coord|
+      populate_checker(board, x_coord, :red)
+    end
+
+    5.upto(7) do |x_coord|
+      populate_checker(board, x_coord, :black)
+    end
+    board
+  end
+
+  def populate_checker(board, x_coord, color)
+    evens = [0, 2, 4, 6]
+    odds  = [1, 3, 5, 7]
+
+    apply_checker = lambda do |y_coord|
+      checker = Checker.new(x_coord, y_coord, color)
+      board[x_coord][y_coord] = checker
+    end
+
+    if x_coord.even?
+      evens.each(&apply_checker)
+    elsif x_coord.odd?
+      odds.each(&apply_checker)
+    end
+  end
+
+  def checkers_left(board, color)
+    checker_count = 0
+
+    board.each do |row|
+      row.each do |location|
+        if (location.nil? == false) and (location.color == color)
+          checker_count += 1
+        end
+      end
+    end
+    checker_count
+  end
+
+  def self.king_checkers_if_necessary(board)
+    board.each do |row|
+      row.each do |loc|
+        if (loc != nil) and (loc.color == :red) and (loc.x_pos == 7)
+          loc.make_king
+        elsif (loc != nil) and (loc.color == :black) and (loc.x_pos == 0)
+          loc.make_king
+        end
+      end
+    end
+  end
+
+  def self.remove_jumped_checker(board, x_origin, y_origin, x_destination, y_destination)
+    x_delta = (x_destination > x_origin) ? 1 : -1
+    y_delta = (y_destination > y_origin) ? 1 : -1
+
+    board[x_origin + x_delta][y_origin + y_delta] = nil
+    board
+  end
+
+  def self.return_jumped_checker(board, x_origin, y_origin, x_destination, y_destination)
+    jumping_checker_color = board[x_destination][y_destination].color
+    returning_checker_color = jumping_checker_color == :red ? :black : :red
+
+    x_delta = (x_destination > x_origin) ? 1 : -1
+    y_delta = (y_destination > y_origin) ? 1 : -1
+
+    board[x_origin + x_delta][y_origin + y_delta] = Checker.new(x_origin + x_delta, y_origin + y_delta, returning_checker_color)
+    board
+  end
+
+  def remove_checker(board, x, y)
+    board[x][y] = nil
+  end
+end

data/lib/draughts/board_survey.rb

@@ -0,0 +1,248 @@
+class BoardSurvey
+
+  attr_accessor :board, :current_player
+
+  QUADRANTS = ["upper_left", "upper_right", "lower_left", "lower_right"]
+
+  def invert_array(array)
+    array.map! { |x| -x }
+  end
+
+  def normal_deltas(current_player)
+    deltas = [1, 1, 1, -1, -1, 1, -1, -1]
+    current_player == :red ? deltas : invert_array(deltas)
+  end
+
+  def edge?(x)
+    x == 7 or x == 0
+  end
+
+  def edge_adjust(x, current_player, hash)
+    if x == 0
+      current_player == :red ? hash.merge({"lower_left" => nil, "lower_right" => nil}) : hash.merge({"upper_left" => nil, "upper_right" => nil})
+    else
+      current_player == :red ? hash.merge({"upper_left" => nil, "upper_right" => nil}) : hash.merge({"lower_left" => nil, "lower_right" => nil})
+    end
+  end
+
+  def deltas_to_board_locations(deltas, x, y)
+    board_coords = []
+    deltas.each_slice(2) do |slice|
+      board_coords << x + slice[0]
+      board_coords << y + slice[1]
+    end
+    board_coords
+  end
+
+  def assign_adjacent_board_coords(current_player, x, y)
+    jump_positions = Hash[QUADRANTS.zip(deltas_to_board_locations(normal_deltas(current_player), x, y).each_slice(2))]
+    if edge?(x)
+      return edge_adjust(x, current_player, jump_positions)
+    end
+    jump_positions
+  end
+
+  def determine_adjacent_positions_content(board, board_coords)
+    adjacent_content = {}
+    board_coords.each_pair { |quad, coords| coords.nil? ? adjacent_content[quad] = nil : adjacent_content[quad] = board[coords[0]][coords[1]] }
+    adjacent_content
+  end
+
+  def opposing_checker_adjacent(current_player, adjacent_content)
+    opposing_checker_adjacent = {}
+    adjacent_content.each_pair do |quad, content|
+      if content != nil
+        content.color != current_player ? opposing_checker_adjacent[quad] = true : opposing_checker_adjacent[quad] = false
+      else
+        opposing_checker_adjacent[quad] = false
+      end
+    end
+    opposing_checker_adjacent
+  end
+
+  def not_outside_bounds?(x, y)
+    move_check = MoveCheck.new
+    not move_check.out_of_bounds?(x, y)
+  end
+
+  def jump_possible?(board, deltas)
+    (not_outside_bounds?(deltas[0], deltas[1]) and board[deltas[0]][deltas[1]] == nil) ? true : false
+  end
+
+  def delta_translator(current_player, quad, x, y, mag)
+    deltas = []
+    if current_player == :red
+      case quad
+      when "upper_left"
+        x += mag; y += mag
+      when "upper_right"
+        x += mag; y -= mag
+      when "lower_left"
+        x -= mag; y += mag
+      when "lower_right"
+        x -= mag; y -= mag
+      end
+    else
+      case quad
+      when "upper_left"
+        x -= mag; y -= mag
+      when "upper_right"
+        x -= mag; y += mag
+      when "lower_left"
+        x += mag; y -= mag
+      when "lower_right"
+        x += mag; y += mag
+      end
+    end
+    deltas << x << y
+    deltas
+  end
+
+  def adjust_jump_locations_if_not_king(board, x, y, jump_locations)
+    unless board[x][y].is_king?
+      jump_locations["lower_left"]  = false
+      jump_locations["lower_right"] = false
+    end
+    jump_locations
+  end
+
+  def jump_locations(board, current_player, x, y, opposing_checkers)
+
+    jump_locations = {}
+    opposing_checkers.each_pair do |quad, present|
+      if present
+        deltas = delta_translator(current_player, quad, x, y, 2)
+        jump_possible?(board, deltas) ? jump_locations[quad] = true : jump_locations[quad] = false
+      else
+        jump_locations[quad] = false
+      end
+    end
+    adjust_jump_locations_if_not_king(board, x, y, jump_locations)
+    jump_locations
+  end
+
+  def coordinates_of_jump_landings(current_player,x, y, jump_locations)
+    jump_coords = []
+
+    jump_locations.each_pair do |quad, jump|
+      if jump
+        jump_coords << delta_translator(current_player, quad, x, y, 2)
+      end
+    end
+    jump_coords
+  end
+
+  def jump_location_finder_stack(board, current_player, x, y)
+    adj_board_coords = assign_adjacent_board_coords(current_player, x, y)
+    adj_content = determine_adjacent_positions_content(board, adj_board_coords)
+    opposing_checkers = opposing_checker_adjacent(current_player, adj_content)
+    jump_locations(board, current_player, x, y, opposing_checkers)
+  end
+
+  def generate_jump_locations_list(board, current_player)
+    coordinates_list = []
+
+    board.each do |row|
+      row.each do |loc|
+        if (loc != nil) and (loc.color == current_player)
+          jump_locations = jump_location_finder_stack(board, current_player, loc.x_pos, loc.y_pos)
+          coordinates_list << coordinates_of_jump_landings(current_player, loc.x_pos, loc.y_pos, jump_locations)
+        end
+      end
+  end
+    coordinates_list.flatten
+  end
+
+  def any_jumps_left?(board, current_player, x, y)
+    jumps = jump_location_finder_stack(board, current_player, x, y)
+    jumps.has_value?(true)
+  end
+
+  def surrounding_locations_for_checker(board, current_player, x, y)
+    #p "BOARDSURVEY::SURROUNDING board position = #{x}, #{y} - #{board[x][y]}"
+    deltas = normal_deltas(current_player)
+    possible_moves = deltas_to_board_locations(deltas, x, y)
+    if board[x][y].is_king? == false
+      possible_moves.slice!(4, 4)
+    end
+    possible_moves
+  end
+
+  def remove_out_of_bounds_locations(possible_moves)
+    corrected_possible_moves = []
+    possible_moves.each_slice(2) do |coords|
+      if ((coords[0] <= 7 and coords[0] >= 0) and (coords[1] <= 7 and coords[1] >= 0))
+        corrected_possible_moves << coords[0] << coords[1]
+      end
+    end
+    corrected_possible_moves
+  end
+
+  def normal_move_locations(possible_moves, board, current_player, x, y)
+    corrected_possible_moves = []
+    possible_moves.each_slice(2) do |coords|
+      if board[coords[0]][coords[1]] == nil
+        corrected_possible_moves << x << y << coords[0] << coords[1]
+      end
+    end
+    corrected_possible_moves
+  end
+
+  def normal_move_location_finder_stack(board, current_player, x, y)
+    locations = surrounding_locations_for_checker(board, current_player, x, y)
+    removed_out_of_bounds_locations = remove_out_of_bounds_locations(locations)
+    normal_move_locations = normal_move_locations(removed_out_of_bounds_locations, board, current_player, x, y)
+  end
+
+  def generate_normal_move_locations_list(board, current_player)
+    move_locations = []
+
+    board.each do |row|
+      row.each do |loc|
+        if (loc != nil) and (loc.color == current_player)
+          move_locations << normal_move_location_finder_stack(board, current_player, loc.x_pos, loc.y_pos)
+        end
+      end
+    end
+    move_locations.flatten
+  end
+
+  def coordinates_of_computer_jump_landings(current_player,x, y, jump_locations)
+    jump_coords = []
+
+    jump_locations.each_pair do |quad, jump|
+      if jump
+        jump_coords << x << y << delta_translator(current_player, quad, x, y, 2)
+      end
+    end
+    jump_coords
+  end
+
+  def generate_computer_jump_locations_list(board, current_player)
+    coordinates_list = []
+
+    board.each do |row|
+      row.each do |loc|
+        if (loc != nil) and (loc.color == current_player)
+          jump_locations = jump_location_finder_stack(board, current_player, loc.x_pos, loc.y_pos)
+          coordinates_list << coordinates_of_computer_jump_landings(current_player, loc.x_pos, loc.y_pos, jump_locations)
+        end
+      end
+    end
+    coordinates_list.flatten
+  end
+
+  def generate_all_possible_moves(board, current_player)
+    all_moves = generate_normal_move_locations_list(board, current_player)
+    all_moves << generate_computer_jump_locations_list(board, current_player)
+    all_moves.flatten
+  end
+
+  def generate_computer_moves(board, current_player)
+    all_moves = generate_computer_jump_locations_list(board, current_player)
+    if all_moves.size == 0
+      all_moves << generate_normal_move_locations_list(board, current_player)
+    end
+    all_moves.flatten
+  end
+end

data/lib/draughts/checker.rb

@@ -0,0 +1,18 @@
+class Checker
+  attr_accessor :x_pos, :y_pos, :color, :king_status
+
+  def initialize (x_location, y_location, color)
+    @x_pos = x_location
+    @y_pos = y_location
+    @color = color
+    @king_status = false
+  end
+
+  def is_king?
+    return @king_status
+  end
+
+  def make_king
+    @king_status = true
+  end
+end

data/lib/draughts/evaluation.rb

@@ -0,0 +1,70 @@
+class Evaluation
+
+  BOARD_WEIGHT = [ [   4, nil,   4, nil,   4, nil,   4, nil],
+                   [ nil,   3, nil,   3, nil,   3, nil,   4],
+                   [   4, nil,   2, nil,   2, nil,   3, nil],
+                   [ nil,   3, nil,   1, nil,   2, nil,   4],
+                   [   4, nil,   2, nil,   1, nil,   3, nil],
+                   [ nil,   3, nil,   2, nil,   2, nil,   4],
+                   [   4, nil,   3, nil,   3, nil,   3, nil],
+                   [ nil,   4, nil,   4, nil,   4, nil,   4], ]
+
+  def evaluate_board(board)
+    player_value = 0
+    opponent_value = 0
+
+    #color == :red ? opponent_color = :black : opponent_color = :red
+
+    board.each do |row|
+      row.each do |position|
+        if position.nil? == false
+          position.color == :red  ? player_value += calculate_value(position, :red) : opponent_value += calculate_value(position, :black)
+        end
+      end
+    end
+    #p "player value - opponent_value = #{player_value}  - #{opponent_value}"
+    return player_value - opponent_value
+  end
+
+  def evaluate_board2(board)
+    red_count= 0
+    black_count = 0
+
+    board.each do |row|
+      row.each do |position|
+        if position.nil? == false
+          position.color == :red  ? red_count += 1 : black_count += 1
+        end
+      end
+    end
+    #p "player value - opponent_value = #{player_value}  - #{opponent_value}"
+    #p "IN EVALUATE 2: net count = > #{red_count - black_count}"
+    return red_count - black_count
+  end
+
+  def calculate_value(position, color)
+    if color == :red
+      if position.x_pos == 7
+        value = 10
+      elsif position.x_pos == 5 or position.x_pos == 6
+        value = 7
+      else
+        value = 5
+      end
+    elsif color == :black
+      if position.x_pos == 0
+        value = 10
+      elsif position.x_pos == 1 or position.x_pos == 2
+        value = 7
+      else
+        value = 5
+      end
+    end
+
+    if position.is_king?
+      value = 10
+    end
+    #p "IN CALCULATE VALUE : positon, color, value = (#{position.x_pos}, #{position.y_pos}) , #{color} , #{value}"
+    return value * BOARD_WEIGHT[position.x_pos][position.y_pos]
+  end
+end

data/lib/draughts/game.rb

@@ -0,0 +1,68 @@
+class Game
+
+  attr_accessor :board, :gui, :single_player_game, :current_player , :x_orig, :y_orig, :x_dest, :y_dest
+
+  def initialize(view)
+    @view = view
+    @current_player = :red
+    @bs = BoardSurvey.new
+    @evaluation = Evaluation.new
+    @input = UserInput.new
+    @move_check = MoveCheck.new
+    @board = Board.new
+    @game_board = @board.create_board
+    @minmax = Minimax.new(@bs, @evaluation)
+  end
+
+  def play_test_game
+    @game_board = @board.create_test_board
+    @board.add_checker(@game_board, :red, 0, 0)
+    @board.add_checker(@game_board, :red, 0, 2)
+    @board.add_checker(@game_board, :black, 7, 5)
+    @board.add_checker(@game_board, :black, 7, 7)
+    play_game
+  end
+
+  def play_game
+    @view.intro
+    player_input = @view.one_or_two_player
+    @single_player_game = true  if player_input == "1\n"
+    while(game_over?(@game_board) == false)
+      message = nil
+      @view.render_board(@game_board)
+      if single_player_game and @current_player == :red
+        move = @minmax.best_move(@game_board, :red, 3)
+        coordinates = move
+        message = @move_check.move_validator(self, @game_board, :red,  coordinates[0], coordinates[1], coordinates[2], coordinates[3])
+      else
+        coordinates = @view.get_move_coordinates(@current_player)
+
+        message = @move_check.move_validator(self, @game_board, @current_player, coordinates[0], coordinates[1], coordinates[2], coordinates[3])
+      end
+      puts message unless (message.nil? or message == "jumping move")
+    end
+    @view.render_board(@game_board)
+    @view.display_game_ending_message(@game_board)
+  end
+
+  def move(board, x_origin, y_origin, x_destination, y_destination)
+    #moving
+    moving_checker = board[x_origin][y_origin]
+
+    # set new location for checker
+    moving_checker.x_pos = x_destination
+    moving_checker.y_pos = y_destination
+
+    # update board positions of checker
+    board[x_origin][y_origin] = nil
+    board[x_destination][y_destination] = moving_checker
+  end
+
+  def game_over?(board)
+    @board.checkers_left(board, :black) == 0 or @board.checkers_left(board, :red) == 0
+  end
+
+  def self.switch_player(current_player)
+    current_player == :red ? :black : :red
+  end
+end

data/lib/draughts/gui.rb

@@ -0,0 +1,63 @@
+class Gui
+
+  def initialize
+    @board = Board.new
+    @input = UserInput.new
+  end
+
+  def intro
+    puts 'Welcome to Checkers!'
+  end
+
+  def one_or_two_player
+    print "Do you want a one-player or two-player game (1 or 2) : "
+    response = gets
+  end
+
+  def get_move_coordinates(current_player)
+    print "#{current_player.to_s.upcase} make move(x1, y1, x2, y2): "
+    player_input = gets
+    coordinates = @input.translate_move_request_to_coordinates(player_input)
+  end
+
+  def render_board(board)
+    board_display = []
+    board_display << "\n         0     1     2     3     4     5     6    7    \n"
+    board_display << "\n      -------------------------------------------------\n"
+
+    0.upto(7) do |x_coord|
+      board_display << "  #{x_coord}   |  "
+      0.upto(7) do |y_coord|
+        if board[x_coord][y_coord].nil?
+          if (x_coord.even? && y_coord.odd?) || (x_coord.odd? && y_coord.even?)
+            board_display << "#" << "  |  "
+          elsif x_coord.even? && y_coord.even? || (x_coord.odd? && y_coord.odd?)
+            board_display << " " << "  |  "
+          end
+        elsif board[x_coord][y_coord].color == :red
+          if (board[x_coord][y_coord].is_king?) == true
+            board_display << "RK" << " |  "
+          else
+            board_display << "R" << "  |  "
+          end
+        elsif board[x_coord][y_coord].color == :black
+          if (board[x_coord][y_coord].is_king?) == true
+            board_display << "BK" << " |  "
+          else
+            board_display << "B" << "  |  "
+          end
+        end
+      end
+      board_display << "\n      -------------------------------------------------\n"
+    end
+    board_display << "\n"
+    board_display.join
+    board_display.each { |line| print line}
+  end
+
+  def display_game_ending_message(board)
+    winner = @board.checkers_left(board, :black) == 0 ? :red : :black
+    winner = winner.to_s.capitalize
+    return "\n\nCongratulations, #{winner}, You have won!!!"
+  end
+end

data/lib/draughts/minimax.rb

@@ -0,0 +1,151 @@
+class Minimax
+
+    INFINITY = 100000
+
+    # Best move -> Have a method that generates all the possible moves, then apply the minimax to each one of those board positions, match the highest score
+    #              and return the best move.
+    #
+    def initialize(board_survey, evaluation)
+      @bs = board_survey
+      @eval = evaluation
+      @jumped_checker = []
+    end
+
+    def best_move(board, player, depth)
+      #p "IN BEST MOVE : player -> #{player}"
+      move_scores = []
+      moves_list = @bs.generate_computer_moves(board, player)
+      moves_list.each_slice(4) do |move|
+      #p "IN BEST MOVE : before apply move"
+        apply_move(board, move)
+        move_scores << minimax(board, :black, depth)
+      #p "IN BEST MOVE : before unapply move"
+        unapply_move(board, move)
+      end
+      move_scores.flatten
+      #p "IN BEST MOVE : moves_list -> #{moves_list}"
+      #p "IN BEST MOVE : move_scores -> #{move_scores}"
+      best_score_index = move_scores.index(move_scores.max)
+      #p "IN BEST MOVE : best_score_index -> #{best_score_index}"
+      best_move_coords = moves_list.slice(best_score_index * 4, 4)
+      #p "IN BEST MOVE : best_move_coords -> #{best_move_coords}"
+      best_move_coords
+    end
+
+    def minimax(board, player, depth)
+      #p "IN MINIMAX: player -> #{player}"
+      if game_over?(board)
+        return who_won(board)
+      end
+
+      if depth == 0
+        evaluated_score = @eval.evaluate_board(board)
+        #p "IN MINIMAX -> returned value = #{evaluated_score}"
+        return @eval.evaluate_board(board)
+      else
+        player == :red ? best_score = -INFINITY : best_score = INFINITY
+
+        moves_list = @bs.generate_all_possible_moves(board, player)
+        #p "IN MINIMAX -> moves list = #{moves_list}"
+        if moves_list == nil
+          score = @eval.evaluate_board(board)
+        else
+          moves_list.each_slice(4) do |move|
+            #p "IN MINIMAX -> before apply move"
+            apply_move(board, move)
+            score = minimax(board, Game.switch_player(player), depth-1)
+            if player == :red
+              #p "IN MINIMAX -> in best score branch(red) -> #{best_score}"
+              best_score = score > best_score ? score : best_score
+            elsif player == :black
+              #p "IN MINIMAX -> in best score branch(black) -> #{best_score}"
+              best_score = score < best_score ? score : best_score
+            end
+            #p "IN MINIMAX -> before unapply move"
+            unapply_move(board, move)
+            #p "IN MINIMAX -> after unapply move board status = "
+            #puts Gui.render_board(board)
+          end
+        end
+      end
+      #p "IN MINIMAX -> best score = #{best_score}"
+      return best_score
+    end
+
+    def game_over?(board)
+      red_checkers = 0
+      black_checkers = 0
+
+      board.each do |row|
+        row.each do |position|
+          if position.nil? == false
+            position.color == :red ? red_checkers += 1 : black_checkers += 1
+          end
+        end
+      end
+      red_checkers == 0 or black_checkers == 0
+    end
+
+    def who_won(board)
+      red_checkers = 0
+      black_checkers = 0
+
+      board.each do |row|
+        row.each do |position|
+          if position.nil? == false
+            position.color == :red ? red_checkers += 1 : black_checkers += 1
+          end
+        end
+      end
+      red_checkers == 0 ? -INFINITY : INFINITY
+    end
+
+    def apply_move(board, move)
+      #p "IN APPLY MOVE: move -> #{move}"
+      checker = board[move[0]][move[1]]
+      board[move[2]][move[3]] = checker
+      board[move[0]][move[1]] = nil
+      checker.x_pos = move[2]
+      checker.y_pos = move[3]
+      if (move[2] - move[0]).abs == 2
+        #Board.remove_jumped_checker(board, move[0], move[1], move[2], move[3])
+        x_delta = (move[2] > move[0]) ? 1 : -1
+        y_delta = (move[3] > move[1]) ? 1 : -1
+        #p "MINIMAX::APPLY_MOVE -> move 1 - 4, x_delta, y_delta : #{move}, #{x_delta}, #{y_delta}"
+        #p "MINIMAX::APPLY_MOVE -> before assign, jumping_checker pos  = #{@jumped_checker}"
+        @jumped_checker.push(board[move[0] + x_delta][move[1] + y_delta])
+        #p "MINIMAX::APPLY_MOVE -> jumped_checker = #{@jumped_checker}"
+        #p "MINIMAX::APPLY_MOVE -> jumped pos = #{move[0] + x_delta } , #{move[1] + y_delta }"
+        board[move[0] + x_delta][move[1] + y_delta] = nil
+      end
+      board
+    end
+
+    def unapply_move(board, move)
+      #p "IN UNAPPLY MOVE: move -> #{move}"
+      if (move[2] - move[0]).abs == 2
+        #Board.return_jumped_checker(board, move[0], move[1], move[2], move[3])
+        x_delta = (move[2] > move[0]) ? 1 : -1
+        y_delta = (move[3] > move[1]) ? 1 : -1
+
+        #p "MINIMAX::UNAPPLY_MOVE -> move 1 - 4, x_delta, y_delta : #{move}, #{x_delta}, #{y_delta}"
+        #p "MINIMAX::UNAPPLY_MOVE -> jumped_checker = #{@jumped_checker}"
+        #p "MINIMAX::UNAPPLY_MOVE -> jumped pos = #{move[0] + x_delta } , #{move[1] + y_delta }"
+        board[move[0] + x_delta][move[1] + y_delta] = @jumped_checker.pop
+        board
+      end
+      #p "IN UNAPPLY MOVE: before unapplied move, board at x-orig, y-orig -> #{board[move[0]][move[1]]} and x-dest, y-dest -> #{board[move[2]][move[3]]}"
+      checker = board[move[2]][move[3]]
+      board[move[0]][move[1]] = checker
+      board[move[2]][move[3]] = nil
+      checker.x_pos = move[0]
+      checker.y_pos = move[1]
+      #p "IN UNAPPLY MOVE: after unapplied move, board at x-orig, y-orig -> #{board[move[0]][move[1]]} and x-dest, y-dest -> #{board[move[2]][move[3]]}"
+      #p "IN UNAPPLY MOVE: after unapplied move, TOTAL BOARD IS : #{board}}"
+      board
+    end
+
+    def other_player(player)
+      player == :red ? :black : :red
+    end
+end

data/lib/draughts/move_check.rb

@@ -0,0 +1,159 @@
+class MoveCheck
+
+  attr_accessor :board, :current_player
+
+  def initialize
+    @survey = BoardSurvey.new
+    @consecutive_jumps = false
+  end
+
+  def move_validator(game, board, current_player, x_origin, y_origin, x_destination, y_destination)
+    message = nil
+
+    case
+    when (@consecutive_jumps and board[x_origin][y_origin] != @consecutive_jumper)
+        message =  "You cannot jump with a different checker"
+    when out_of_bounds?(x_destination, y_destination)
+      message = "You cannot move off the board"
+
+    when no_checker_at_origin?(board, x_origin, y_origin)
+      message = "There is no checker to move in requested location"
+
+    when trying_to_move_opponents_checker?(board,current_player, x_origin, y_origin)
+      message = "You cannot move an opponents checker"
+
+    when trying_to_move_more_than_one_space_and_not_jumping?(x_origin, x_destination)
+      message = "You cannot move more than one space if not jumping"
+
+    when attempted_non_diagonal_move?(x_origin, y_origin, x_destination, y_destination)
+      message = "You can only move a checker diagonally"
+
+    when attempted_move_to_occupied_square?(board, x_destination, y_destination)
+      message = "You cannot move to an occupied square"
+
+    when non_king_moving_backwards?(board, current_player, x_origin, y_origin, x_destination)
+      message = "A non-king checker cannot move backwards"
+
+    when attempted_jump_of_empty_space?(board,current_player, x_origin, y_origin, x_destination, y_destination)
+      message = "You cannot jump an empty space"
+
+    when attempted_jump_of_own_checker?(board, current_player, x_origin, y_origin, x_destination, y_destination)
+      message = "You cannot jump a checker of your own color"
+
+    when jump_available_and_not_taken?(board, current_player, x_destination, y_destination)
+      message = "You must jump if a jump is available"
+
+    else
+      game.move(board, x_origin, y_origin, x_destination, y_destination)
+
+      if jumping_move?(x_origin, x_destination)
+        message = "jumping move"
+        Board.remove_jumped_checker(board, x_origin, y_origin, x_destination, y_destination)
+        @consecutive_jumps = false
+
+        if @survey.any_jumps_left?(board, current_player, x_destination, y_destination)
+          @consecutive_jumps = true
+          @consecutive_jumper = board[x_destination][y_destination]
+        end
+      end
+      Board.king_checkers_if_necessary(board)
+    end
+
+    if message == nil or (message == "jumping move" and @survey.any_jumps_left?(board, current_player, x_destination, y_destination)== false)
+       if @consecutive_jumps == false
+       game.current_player = Game.switch_player(game.current_player)
+       end
+    end
+    message
+  end
+
+  def jump_available?(board, current_player)
+    possible_jumps = @survey.generate_jump_locations_list(board, current_player)
+
+    possible_jumps.size > 0
+  end
+
+  def jump_available_and_not_taken?(board, current_player, x_destination, y_destination)
+    jump_possiblities = @survey.generate_jump_locations_list(board, current_player)
+
+    not_taken_jump = true
+    jump_possiblities.each_slice(2) do |i|
+      if(i[0] == x_destination) and (i[1] == y_destination)
+        not_taken_jump = false
+      end
+    end
+    (jump_available?(board, current_player) == true) and (not_taken_jump)
+  end
+
+  def jump_deltas(current_player, x_orig, y_orig, x_dest, y_dest)
+    deltas = []
+    x_dest > x_orig ? deltas << 1 : deltas << -1
+    y_dest > y_orig ? deltas << 1 : deltas << -1
+  end
+
+  def attempted_jump_of_empty_space?(board, current_player, x_origin, y_origin, x_destination, y_destination)
+    if jumping_move?(x_origin, x_destination)
+      deltas = jump_deltas(current_player, x_origin, y_origin, x_destination, y_destination)
+      board[x_origin + deltas[0]][y_origin + deltas[1]].nil?  ? true  : false
+    else
+      false
+    end
+  end
+
+  def attempted_jump_of_own_checker?(board, current_player, x_origin, y_origin, x_destination, y_destination)
+    if jumping_move?(x_origin, x_destination)
+      x_delta = (x_destination > x_origin) ? 1 : -1
+      y_delta = (y_destination > y_origin) ? 1 : -1
+
+      if current_player == :black
+       x_delta = (x_destination < x_origin) ? -1 : 1
+       y_delta = (y_destination < y_origin) ? -1 : 1
+     end
+
+      jumped_checker_x_value = x_origin + x_delta
+      jumped_checker_y_value = y_origin + y_delta
+
+      jumped_checker = board[jumped_checker_x_value][jumped_checker_y_value]
+
+      jumping_checker = board[x_origin][y_origin]
+
+      jumped_checker.color == jumping_checker.color
+    end
+  end
+
+  def jumping_move?(x_origin, x_destination)
+    (x_destination - x_origin).abs == 2
+  end
+
+  def out_of_bounds?(x, y)
+   ( x < 0  or y < 0) or (x > 7  or y > 7)
+  end
+
+  def no_checker_at_origin?(board, x_origin, y_origin)
+    board[x_origin][y_origin].nil?
+  end
+
+  def trying_to_move_opponents_checker?(board, current_player, x_origin, y_origin)
+    current_player != board[x_origin][y_origin].color
+  end
+
+  def trying_to_move_more_than_one_space_and_not_jumping?(x_origin, x_destination)
+    (x_destination - x_origin).abs > 2
+  end
+
+  def attempted_non_diagonal_move?(x_origin, y_origin, x_destination, y_destination)
+    (x_origin == x_destination) or (y_origin == y_destination)
+  end
+
+  def attempted_move_to_occupied_square?(board, x_destination, y_destination)
+    not board[x_destination][y_destination].nil?
+  end
+
+  def non_king_moving_backwards?(board, current_player, x_origin, y_origin, x_destination)
+    if current_player == :red
+      (x_destination < x_origin) and (board[x_origin][y_origin].is_king? == false)
+    else
+      (x_destination > x_origin) and (board[x_origin][y_origin].is_king? == false)
+    end
+  end
+end

data/lib/draughts/user_input.rb

@@ -0,0 +1,6 @@
+class UserInput
+  
+  def translate_move_request_to_coordinates(move_request)
+    coords_array = move_request.chomp.split(',').map { |x| x.to_i }
+  end
+end

metadata

@@ -1,45 +1,64 @@
---- !ruby/object:Gem::Specification
+--- !ruby/object:Gem::Specification 
 name: checkers_game_engine_sgallagher
-version: !ruby/object:Gem::Version
-  version: 0.0.2
+version: !ruby/object:Gem::Version 
   prerelease: 
+  version: 0.0.3
 platform: ruby
-authors:
-- Steven Gallagher
+authors: 
+  - Steven Gallagher
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2012-01-26 00:00:00.000000000Z
+
+date: 2012-01-26 00:00:00 Z
 dependencies: []
-description: Contains all the logic necessary to play a one or two player game of
-  checkers
+
+description: Contains all the logic necessary to play a one or two player game of checkers
 email: s.thomas.gallagher@gmail.com
 executables: []
+
 extensions: []
+
 extra_rdoc_files: []
-files: []
+
+files: 
+  - lib/draughts.rb
+  - lib/draughts/board.rb
+  - lib/draughts/board_survey.rb
+  - lib/draughts/checker.rb
+  - lib/draughts/computer_player.rb
+  - lib/draughts/evaluation.rb
+  - lib/draughts/game.rb
+  - lib/draughts/gui.rb
+  - lib/draughts/minimax.rb
+  - lib/draughts/move_check.rb
+  - lib/draughts/user_input.rb
 homepage: https://github.com/greenone1975/draughts
 licenses: []
+
 post_install_message: 
 rdoc_options: []
-require_paths:
-- lib
-required_ruby_version: !ruby/object:Gem::Requirement
+
+require_paths: 
+  - lib
+required_ruby_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
-required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
   none: false
-  requirements:
-  - - ! '>='
-    - !ruby/object:Gem::Version
-      version: '0'
+  requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: "0"
 requirements: []
+
 rubyforge_project: 
-rubygems_version: 1.8.15
+rubygems_version: 1.8.9
 signing_key: 
 specification_version: 3
 summary: Checkers game engine for one or two players
 test_files: []
+