just_backgammon 0.1.1 → 0.1.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: bd967102d4f2727319803b53b4ea83cc972daa66
-  data.tar.gz: 6394903527b497246a94db81c8e6a250e17fb87a
+  metadata.gz: c1ebb2844a2a6fef92a1ce1644cd4a16b984dbc0
+  data.tar.gz: 29d1a815550ca78b52da80cf48c3b7ab135e92f8
 SHA512:
-  metadata.gz: dee675efe5f10b43faa7bcb3055a6e1c7f21cc68f0e057159d507f1d661de2d315bb215ae5cc23f1cc15ebf2babf97763166ba2e0b527bffdf56531a128adac9
-  data.tar.gz: 603ad75ff8bb903dcec9e115be01896034f561922199c5f490409062f0c5e817ced6e1a4178b3c288c9565296a13de0c53475d3f0963462c705ef076c849e28f
+  metadata.gz: 3d06f071fb46878e406ddfe2bb16707cba385282cfe730d99a8e935f21647bb86212fe14898d247bbf86cab26a6b1f203c5853f725931275db535b492d428721
+  data.tar.gz: e518b7e4825bb4e88656b301de9740bfa6137701ed3ff675b93d9add0cbf618072ee452e76e3a1ed45a7caefc68ec523a073a73624c4728b64ce63f7d414655d

data/lib/just_backgammon/combined_move.rb

@@ -25,29 +25,34 @@ module JustBackgammon
     # @return [Array<Move>] the legs of the combined move.
     attr_reader :legs
 
-    def_delegator :legs, :size
-
-    # Does the combined move start from a point?
+    # Checks if the combined move start from a point.
     #
     # @return [Boolean]
     def from_point?
       first_leg.instance_of?(JustBackgammon::Point) if first_leg
     end
 
-    # Does the combined move start with an empty point?
+    # Checks if the combined move start with an empty point.
     #
     # @return [Boolean]
     def empty?
       first_leg.empty? if first_leg
     end
 
-    # Does the combined move have pieces owned by the opponent?
+    # Checks if the combined move have pieces owned by the opponent.
     #
     # @return [Boolean]
     def owned_by_opponent?(player_number)
       first_leg.owned_by_opponent?(player_number) if first_leg
     end
 
+    # Checks if the combined move have pieces owned by the opponent.
+    #
+    # @return [Boolean]
+    def multi_leg?
+      legs.size > 2
+    end
+
     private
 
     def first_leg # :nodoc:

data/lib/just_backgammon/game_state.rb

@@ -248,30 +248,17 @@ module JustBackgammon
         @errors.push JustBackgammon::BlockedError.new
       when move_list.any_wrong_direction?(current_player_number)
         @errors.push JustBackgammon::WrongDirectionError.new
-      when !move_list.all_moves_from_bar? && \
-        move_list.number_of_moves_from_bar != bar.number_of_pieces_owned_by_player(current_player_number) && \
-        points.destinations(bar, dice, current_player_number).size >= move_list.number_of_moves_from_bar
+      when move_list.pieces_still_on_bar?(current_player_number, points, dice, bar)
         @errors.push JustBackgammon::PiecesOnBarError.new
-      when move_list.any_bear_off? && \
-        !(points.not_home(current_player_number).map(&:number) - move_list.map { |m| m.from.number }).empty?
+      when move_list.cannot_bear_off?(current_player_number, points)
         @errors.push JustBackgammon::BearOffError.new
-      when current_player_has_moves? && move_list.dice_mismatch?(current_player_number, dice)
+      when move_list.dice_mismatch?(current_player_number, points, dice, bar)
         @errors.push JustBackgammon::DiceMismatchError.new
       end
 
       @errors.none?
     end
 
-    def current_player_has_moves?  # :nodoc:
-      if bar.any_pieces_for_player?(@current_player_number)
-        @points.destinations(bar, @dice, @current_player_number).any?
-      else
-        @points.owned_by_player(@current_player_number).any? do |p|
-          @points.destinations(p, @dice, @current_player_number).any?
-        end
-      end
-    end
-
     def perform_move(list)  # :nodoc:
       list.each do |move|
         from = find_point(move.from.number)
@@ -311,22 +298,22 @@ module JustBackgammon
       end
     end
 
-    def find_point(n)  # :nodoc:
-      case n
+    def find_point(identifier)  # :nodoc:
+      case identifier
       when 'bar'
         bar
       when 'off_board'
         off_board
       else
-        @points.find_by_number(n.to_i)
+        @points.find_by_number(identifier.to_i)
       end
     end
 
-    def sanitize_list(list)  # :nodoc:
-      move_list = list.map do |i|
-        JustBackgammon::Move.new({ from: find_point(i[:from]),  to: find_point(i[:to]) })
+    def sanitize_list(move_list)  # :nodoc:
+      moves = move_list.map do |move|
+        JustBackgammon::Move.new({ from: find_point(move[:from]),  to: find_point(move[:to]) })
       end
-      JustBackgammon::MoveList.new(moves: move_list)
+      JustBackgammon::MoveList.new(moves: moves)
     end
   end
 end

data/lib/just_backgammon/move_list.rb

@@ -31,12 +31,12 @@ module JustBackgammon
     #
     # @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 }
+      combined_data = moves.inject([]) do |combined, move|
+        matching_move = combined.find_index { |combined_move| combined_move.last.number == move.from.number }
         if matching_move
-          combined[matching_move].push(m.to)
+          combined[matching_move].push(move.to)
         else
-          combined.push([m.from, m.to])
+          combined.push([move.from, move.to])
         end
 
         combined
@@ -49,94 +49,116 @@ module JustBackgammon
     #
     # @return [Boolean]
     def piece_moves_multiple_times?
-      combined_moves.any? { |c| c.size > 2 }
+      combined_moves.any?(&:multi_leg?)
     end
 
     # Checks if any move have no points.
     #
     # @return [Boolean]
     def any_missing_point?
-      moves.any? { |m| m.missing_point? }
+      moves.any?(&: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? }
+      combined_moves.any? { |move| move.from_point? && move.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) }
+      combined_moves.any? { |move| move.from_point? && move.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) }
+      moves.any? { |move| move.from_bar? && move.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) }
+      moves.any? { |move| move.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) }
+      moves.any? { |move| move.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? }
+      moves.any?(&:bear_off?)
     end
 
     # Checks if all moves are from the bar.
     #
     # @return [Boolean]
     def all_moves_from_bar?
-      moves.all? { |m| m.from_bar? }
+      moves.all?(&: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
+      moves.select(&: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) }
+      moves.map { |move| move.absolute_distance_for_player(current_player_number) }
+    end
+
+    # Checks if there are still pieces on the bar.
+    #
+    # @return [Boolean]
+    def pieces_still_on_bar?(current_player_number, points, dice, bar)
+      !all_moves_from_bar? && \
+      number_of_moves_from_bar != bar.number_of_pieces_owned_by_player(current_player_number) && \
+      points.destinations(bar, dice, current_player_number).size >= number_of_moves_from_bar
+    end
+
+    # Checks if they player cannot bear off.
+    #
+    # @return [Boolean]
+    def cannot_bear_off?(current_player_number, points)
+      any_bear_off? && !(points.not_home(current_player_number).map(&:number) - map { |move| move.from.number }).empty?
     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
+    def dice_mismatch?(current_player_number, points, dice, bar)
+      current_player_has_moves?(current_player_number, points, dice, bar) && moves_mismatch_dice?(current_player_number, dice)
+    end
+
+    private
+
+    def moves_mismatch_dice?(current_player_number, dice) # :nodoc:
+      unallocated = dice.numbers.sort
       allocated = []
 
-      moves.each do |m|
-        move_distance = m.absolute_distance_for_player(current_player_number)
+      moves.each do |move|
+        move_distance = move.absolute_distance_for_player(current_player_number)
 
-        index = unallocated.index do |d|
-          if m.bear_off?
-            d >= move_distance
+        index = unallocated.index do |die_number|
+          if move.bear_off?
+            die_number >= move_distance
           else
-            d == move_distance
+            die_number == move_distance
           end
         end
 
@@ -145,8 +167,17 @@ module JustBackgammon
           allocated.push(die)
         end
       end
-
       allocated.size != moves.size
     end
+
+    def current_player_has_moves?(current_player_number, points, dice, bar)  # :nodoc:
+      if bar.any_pieces_for_player?(current_player_number)
+        points.destinations(bar, dice, current_player_number).any?
+      else
+        points.owned_by_player(current_player_number).any? do |point|
+          points.destinations(point, dice, current_player_number).any?
+        end
+      end
+    end
   end
 end

data/lib/just_backgammon/version.rb

@@ -1,4 +1,4 @@
 module JustBackgammon
   # :nodoc:
-  VERSION = "0.1.1"
+  VERSION = "0.1.2"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: just_backgammon
 version: !ruby/object:Gem::Version
-  version: 0.1.1
+  version: 0.1.2
 platform: ruby
 authors:
 - Mark Humphreys
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2016-09-19 00:00:00.000000000 Z
+date: 2016-09-22 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler