just_backgammon 0.1.0

data/lib/just_backgammon/move_list.rb

@@ -0,0 +1,151 @@
+require 'just_backgammon/combined_move'
+
+module JustBackgammon
+
+  # = MoveList
+  #
+  # A list of moves.
+  class MoveList
+    extend Forwardable
+
+    # A new instance of MoveList.
+    #
+    # @param [Array<Move>] moves
+    #   All the moves.
+    #
+    # ==== Example:
+    #   # Instantiates a new MoveList
+    #   JustBackgammon::MoveList.new([move_a, move_b])
+    def initialize(moves:)
+      @moves = moves
+    end
+
+    # @return [Array<Move>] all the moves
+    attr_reader :moves
+
+    def_delegator :moves, :each
+    def_delegator :moves, :map
+
+    # Combines moves if there are any that start where another ends.
+    #
+    # @return [Array<CombinedMove>]
+    def combined_moves
+      combined_data = moves.inject([]) do |combined, m|
+        matching_move = combined.find_index { |c| c.last.number == m.from.number }
+        if matching_move
+          combined[matching_move].push(m.to)
+        else
+          combined.push([m.from, m.to])
+        end
+
+        combined
+      end
+
+      combined_data.map { |legs| JustBackgammon::CombinedMove.new(legs: legs) }
+    end
+
+    # For any of the combined moves, checks if there is one with more two legs or more.
+    #
+    # @return [Boolean]
+    def piece_moves_multiple_times?
+      combined_moves.any? { |c| c.size > 2 }
+    end
+
+    # Checks if any move have no points.
+    #
+    # @return [Boolean]
+    def any_missing_point?
+      moves.any? { |m| m.missing_point? }
+    end
+
+    # Checks if any move have empty points.
+    #
+    # @return [Boolean]
+    def any_point_empty?
+      combined_moves.any? { |m| m.from_point? && m.empty? }
+    end
+
+    # Checks if any move have is owned by the opponent.
+    #
+    # @return [Boolean]
+    def any_point_owned_by_opponent?(current_player_number)
+      combined_moves.any? { |m| m.from_point? && m.owned_by_opponent?(current_player_number) }
+    end
+
+    # Checks if any move is from an empty bar.
+    #
+    # @return [Boolean]
+    def any_bar_empty_for_player?(current_player_number)
+      moves.any? { |m| m.from_bar? && m.empty_for_player?(current_player_number) }
+    end
+
+    # Checks if any move is blocked from moving.
+    #
+    # @return [Boolean]
+    def any_blocked?(current_player_number)
+      moves.any? { |m| m.blocked?(current_player_number) }
+    end
+
+    # Checks if any move is going the wrong direction.
+    #
+    # @return [Boolean]
+    def any_wrong_direction?(current_player_number)
+      moves.any? { |m| m.wrong_direction?(current_player_number) }
+    end
+
+    # Checks if any move is bearing off.
+    #
+    # @return [Boolean]
+    def any_bear_off?
+      moves.any? { |m| m.bear_off? }
+    end
+
+    # Checks if all moves are from the bar.
+    #
+    # @return [Boolean]
+    def all_moves_from_bar?
+      moves.all? { |m| m.from_bar? }
+    end
+
+    # The number of moves from the bar.
+    #
+    # @return [Fixnum]
+    def number_of_moves_from_bar
+      moves.select { |m| m.from_bar? }.size
+    end
+
+    # How far each of the moves go.
+    #
+    # @return [Array<Fixnum>]
+    def absolute_distances(current_player_number)
+      moves.map { |m| m.absolute_distance_for_player(current_player_number) }
+    end
+
+    # Checks if any of the moves don't match the dice rolls
+    #
+    # @return [Boolean]
+    def dice_mismatch?(current_player_number, dice)
+      unallocated = dice.numbers
+      allocated = []
+
+      moves.each do |m|
+        move_distance = m.absolute_distance_for_player(current_player_number)
+
+        index = unallocated.index do |d|
+          if m.bear_off?
+            d >= move_distance
+          else
+            d == move_distance
+          end
+        end
+
+        if index
+          die = unallocated.delete_at(index)
+          allocated.push(die)
+        end
+      end
+
+      allocated.size != moves.size
+    end
+  end
+end

data/lib/just_backgammon/off_board.rb

@@ -0,0 +1,73 @@
+require 'just_backgammon/off_board'
+require 'just_backgammon/piece'
+
+module JustBackgammon
+
+  # = OffBoard
+  #
+  # The off board is where pieces go when bearing off. Contains an array of pieces.
+  class OffBoard
+    extend Common
+
+    # A new instance of OffBoard.
+    #
+    # @param [Array<Hash>] pieces
+    #   All the pieces off board, each piece has an owner.
+    #
+    # ==== Example:
+    #   # Instantiates a new OffBoard
+    #   JustBackgammon::OffBoard.new({
+    #     pieces: [{owner: 1}, {owner: 1}]
+    #   })
+    def initialize(pieces:)
+      @pieces = Piece.load(pieces)
+    end
+
+    # @return [Array<Piece>] all the pieces on the bar, each piece has an owner
+    attr_reader :pieces
+
+    # The identifier of the bar, returns the string 'bar'.
+    #
+    # @return [String]
+    def number
+      'off_board'
+    end
+
+    # ALl the pieces owned by the specified player.
+    #
+    # @param [Fixnum] player_number
+    #   the specified player number.
+    #
+    # @return [Array<Piece>]
+    def pieces_owned_by_player(player_number)
+      pieces.select { |p| p.owner == player_number }
+    end
+
+    # Number of pieces owned by the specified player.
+    #
+    # @param [Fixnum] player_number
+    #   the specified player number.
+    #
+    # @return [Fixnum]
+    def number_of_pieces_owned_by_player(player_number)
+      pieces_owned_by_player(player_number).size
+    end
+
+    # Adds a piece off board.
+    #
+    # @param [Piece] piece
+    #   the piece to push off board.
+    #
+    # @return [Array<Piece>]
+    def push(piece)
+      @pieces.push(piece)
+    end
+
+    # A hashed serialized representation of off board.
+    #
+    # @return [Hash]
+    def as_json
+      { pieces: pieces.map(&:as_json) }
+    end
+  end
+end

data/lib/just_backgammon/piece.rb

@@ -0,0 +1,33 @@
+require 'just_backgammon/common'
+
+module JustBackgammon
+
+  # = Piece
+  #
+  # A piece owned by a player that moves around the board.
+  class Piece
+    extend Common
+
+    # A new instance of Piece.
+    #
+    # @param [Fixnum] owner
+    #   The owner of the piece.
+    #
+    # ==== Example:
+    #   # Instantiates a new Piece
+    #   JustBackgammon::Piece.new(1)
+    def initialize(owner:)
+      @owner = owner
+    end
+
+    # @return [Fixnum] the owner of the piece
+    attr_reader :owner
+
+    # A hashed serialized representation of the piece.
+    #
+    # @return [Hash]
+    def as_json
+      { owner: owner }
+    end
+  end
+end

data/lib/just_backgammon/point.rb

@@ -0,0 +1,104 @@
+require 'just_backgammon/common'
+require 'just_backgammon/piece'
+
+module JustBackgammon
+
+  # = Point
+  #
+  # A point where pieces can land on. Each one has a number.
+  class Point
+    extend Common
+    extend Forwardable
+
+    # A new instance of Point.
+    #
+    # @param [Array<Hash>] pieces
+    #   All the pieces on this point.
+    #
+    # @param [Fixnum] number
+    #   The point number and identifier.
+    #
+    # ==== Example:
+    #   # Instantiates a new Point
+    #   JustBackgammon::Point.new({
+    #     pieces: [{owner: 1}, {owner: 1}],
+    #     number: 1
+    #   })
+    def initialize(pieces: , number:)
+      @pieces = JustBackgammon::Piece.load(pieces)
+      @number = number
+    end
+
+    # @return [Array<Piece>] all the pieces on this point
+    attr_reader :pieces
+
+    # @return [Fixnum] the point number and identifier
+    attr_reader :number
+
+    def_delegator :pieces, :size
+    def_delegator :pieces, :empty?
+
+    # Removes a piece and returns it.
+    #
+    # @return [Piece,NilClass]
+    def pop
+      @pieces.pop
+    end
+
+    # Adds a piece to the point.
+    #
+    # @return [Array<Piece>]
+    def push(piece)
+      @pieces.push(piece)
+    end
+
+    # Checks if point has pieces owned by the specified player.
+    #
+    # @return [Boolean]
+    def owned_by_player?(player_number)
+      pieces.any? { |p| p.owner == player_number }
+    end
+
+    # Checks if point has pieces owned by the opponent of the specified player.
+    #
+    # @return [Boolean]
+    def owned_by_opponent?(player_number)
+      pieces.any? { |p| p.owner != player_number }
+    end
+
+    # Checks if point has more than one piece.
+    #
+    # @return [Boolean]
+    def blocked?
+      size > 1
+    end
+
+    # Checks if point has only one piece.
+    #
+    # @return [Boolean]
+    def blot?
+      size == 1
+    end
+
+    # Checks if point is a home point for specified player.
+    #
+    # @return [Boolean]
+    def home?(player_number)
+      case player_number
+      when 1
+        (19..24).include?(number)
+      when 2
+        (1..6).include?(number)
+      else
+        true
+      end
+    end
+
+    # A hashed serialized representation of the bar.
+    #
+    # @return [Hash]
+    def as_json
+      { number: number, pieces: pieces.map(&:as_json) }
+    end
+  end
+end

data/lib/just_backgammon/point_set.rb

@@ -0,0 +1,95 @@
+require 'just_backgammon/common'
+require 'just_backgammon/point'
+
+module JustBackgammon
+
+  # = PointSet
+  #
+  # A collection of points.
+  class PointSet
+    extend Common
+    extend Forwardable
+
+    # A new instance of Bar.
+    #
+    # @param [Array<Hash>] points
+    #   All the points in the set.
+    #
+    # ==== Example:
+    #   # Instantiates a new PointSet
+    #   JustBackgammon::PointSet.new({
+    #     points: [point_a, point_b]
+    #   })
+    def initialize(points:)
+      @points = Point.load(points)
+    end
+
+    # @return [Array<Point>] all the points in the set
+    attr_reader :points
+
+    def_delegator :points, :map
+    def_delegator :points, :any?
+    def_delegator :points, :size
+
+    # Finds a point with the matching number.
+    #
+    # @return [Point]
+    def find_by_number(number)
+      points.find { |p| p.number == number }
+    end
+
+    # Finds all points with pieces that are not yet home for the specified player.
+    #
+    # @return [PointSet]
+    def not_home(player_number)
+      not_home_points = points.select { |p| p.owned_by_player?(player_number) && !p.home?(player_number) }
+      self.class.new(points: not_home_points)
+    end
+
+    # Checks if any pieces are not yet home for the specified player.
+    #
+    # @return [Boolean]
+    def some_pieces_not_home?(player_number)
+      not_home(player_number).any?
+    end
+
+    # Finds all points owned by the specified player.
+    #
+    # @return [PointSet]
+    def owned_by_player(player_number)
+      owned = @points.select { |p| p.owned_by_player?(player_number) }
+      self.class.new(points: owned)
+    end
+
+    # Finds all destinations points from a point with a dice roll for the specified player.
+    #
+    # @return [PointSet]
+    def destinations(from, dice, player_number)
+      in_range = dice.map { |d| destination(from, d, player_number) }.compact
+      possible = in_range.select { |p| p.empty? || p.owned_by_player?(player_number) || p.blot? }
+      self.class.new(points: possible)
+    end
+
+    # A hashed serialized representation of the bar.
+    #
+    # @return [Hash]
+    def as_json
+      points.map(&:as_json)
+    end
+
+    private
+
+    def destination(from, die, player_number)  # :nodoc:
+      case player_number
+      when 1
+        from_number = from.instance_of?(Bar) ? 0 : from.number
+        find_by_number(from_number + die.number)
+      when 2
+        from_number = from.instance_of?(Bar) ? 25 : from.number
+        find_by_number(from_number - die.number)
+      else
+        nil
+      end
+    end
+  end
+end

data/lib/just_backgammon/version.rb

@@ -0,0 +1,4 @@
+module JustBackgammon
+  # :nodoc:
+  VERSION = "0.1.0"
+end

data/lib/just_backgammon.rb

@@ -0,0 +1,6 @@
+# :nodoc:
+module JustBackgammon
+
+end
+
+require 'just_backgammon/game_state'

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: just_backgammon
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Mark Humphreys
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-09-19 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !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'
+- !ruby/object:Gem::Dependency
+  name: minitest
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '5.0'
+description: Provides a representation of a backgammon game complete with rules enforcement
+  and serialisation.
+email:
+- mark@mrlhumphreys.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- just_backgammon.gemspec
+- lib/just_backgammon.rb
+- lib/just_backgammon/bar.rb
+- lib/just_backgammon/combined_move.rb
+- lib/just_backgammon/common.rb
+- lib/just_backgammon/dice_set.rb
+- lib/just_backgammon/die.rb
+- lib/just_backgammon/errors/bear_off_error.rb
+- lib/just_backgammon/errors/blocked_error.rb
+- lib/just_backgammon/errors/dice_mismatch_error.rb
+- lib/just_backgammon/errors/empty_bar_error.rb
+- lib/just_backgammon/errors/empty_point_error.rb
+- lib/just_backgammon/errors/moves_possible_error.rb
+- lib/just_backgammon/errors/not_players_turn_error.rb
+- lib/just_backgammon/errors/pieces_on_bar_error.rb
+- lib/just_backgammon/errors/point_not_found_error.rb
+- lib/just_backgammon/errors/point_ownership_error.rb
+- lib/just_backgammon/errors/wrong_direction_error.rb
+- lib/just_backgammon/errors/wrong_phase_error.rb
+- lib/just_backgammon/game_state.rb
+- lib/just_backgammon/move.rb
+- lib/just_backgammon/move_list.rb
+- lib/just_backgammon/off_board.rb
+- lib/just_backgammon/piece.rb
+- lib/just_backgammon/point.rb
+- lib/just_backgammon/point_set.rb
+- lib/just_backgammon/version.rb
+homepage: https://github.com/mrlhumphreys/just_backgammon
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.1'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.1
+signing_key: 
+specification_version: 4
+summary: A backgammon engine written in ruby
+test_files: []