qi 10.0.0.beta4 → 10.0.0.beta6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: ba69668b35781db7bbad0806b6940d99924fa3693355f01538b14bb8ebf159e7
-  data.tar.gz: 8447f2df3687f661762d1a99adffc31640d693f52a4012adf2f89825b2614239
+  metadata.gz: 638a4dafc9645e200d72d7799afb3f28cca3a81f7cd887e5f29c64974e5776e0
+  data.tar.gz: 5e74a8a31f894187b404a3c41ed1a1434916880925934f2fe627e19472f99084
 SHA512:
-  metadata.gz: 00aa0f50dd054bc1c15a0de068b4c7e2e3e18d2fc63da9db8c781f72058efc472409fe474545a6b088cb9a5b62ad87120baebbb3ad24e3cada79d6a3726f02c6
-  data.tar.gz: d6909071d69cd7308e2655a5331b1d522e424cf05b002a73da5a54e4c7f570533d44c7db23111f4b609d876bf415b742127e0613b38685a49ccc465638c57427
+  metadata.gz: 41a6e8c87db922ca87d992b62909c6cf5d87d8900d12c9bc0b43d94d1882040d168678ee9d3f6be85904b7f275a0eaa9c42e32364b0d7c5e4766ec84953fdb10
+  data.tar.gz: 14323df90b7e942fbae1a1db4f3e23f071c4fdd62bd969797a39909c710e599534c5eaa2fd4b6a01ffbe91f48d25122a28c32b599fc5731f9b3c14b72c2f8a74

data/README.md

@@ -13,7 +13,7 @@
 Add this line to your application's Gemfile:
 
 ```ruby
-gem "qi", ">= 10.0.0.beta3"
+gem "qi", ">= 10.0.0.beta5"
 ```
 
 And then execute:
@@ -33,13 +33,42 @@ gem install qi --pre
 ```ruby
 require "qi"
 
-captures  = %w[S r r b g g g g s n n n n p p p p p p p p p p p p p p p p p]
-squares   = { "3": "s", "4": "k", "5": "s", "22": "+P", "43": "+B" }
-
-captures, squares = Qi(*captures, **squares).call("43": nil, "13": "+B")
-
-captures  # => ["S", "r", "r", "b", "g", "g", "g", "g", "s", "n", "n", "n", "n", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p"]
-squares   # => {:"3"=>"s", :"4"=>"k", :"5"=>"s", :"22"=>"+P", :"13"=>"+B"}
+is_north_turn   = false
+north_captures  = %w[r r b g g g g s n n n n p p p p p p p p p p p p p p p p p]
+south_captures  = %w[S]
+squares         = { 3 => "s", 4 => "k", 5 => "s", 22 => "+P", 43 => "+B" }
+
+qi0 = Qi.new(is_north_turn, north_captures, south_captures, squares)
+
+qi0.north_captures  # => ["b", "g", "g", "g", "g", "n", "n", "n", "n", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "r", "r", "s"]
+qi0.south_captures  # => ["S"]
+qi0.squares         # => {3=>"s", 4=>"k", 5=>"s", 22=>"+P", 43=>"+B"}
+qi0.north_turn?     # => false
+qi0.south_turn?     # => true
+qi0.serialize       # => "SouthTurn===S,b,g,g,g,g,n,n,n,n,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,r,r,s===3:s,4:k,5:s,22:+P,43:+B"
+qi0.inspect         # => "<Qi SouthTurn===S,b,g,g,g,g,n,n,n,n,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,r,r,s===3:s,4:k,5:s,22:+P,43:+B>"
+
+qi0.to_a
+# [false,
+#  ["b", "g", "g", "g", "g", "n", "n", "n", "n", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "r", "r", "s"],
+#  ["S"],
+#  {3=>"s", 4=>"k", 5=>"s", 22=>"+P", 43=>"+B"}]
+
+qi1 = qi0.commit({ 43 => nil, 13 => "+B" })
+
+qi1.north_captures  # => ["b", "g", "g", "g", "g", "n", "n", "n", "n", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "r", "r", "s"]
+qi1.south_captures  # => ["S"]
+qi1.squares         # => {3=>"s", 4=>"k", 5=>"s", 22=>"+P", 13=>"+B"}
+qi1.north_turn?     # => true
+qi1.south_turn?     # => false
+qi1.serialize       # => "NorthTurn===S,b,g,g,g,g,n,n,n,n,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,r,r,s===3:s,4:k,5:s,22:+P,13:+B"
+qi1.inspect         # => "<Qi NorthTurn===S,b,g,g,g,g,n,n,n,n,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,p,r,r,s===3:s,4:k,5:s,22:+P,13:+B>"
+
+qi1.to_a
+# [true,
+#  ["b", "g", "g", "g", "g", "n", "n", "n", "n", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "p", "r", "r", "s"],
+#  ["S"],
+#  {3=>"s", 4=>"k", 5=>"s", 22=>"+P", 13=>"+B"}]
 ```
 
 ## License

data/lib/qi.rb

@@ -1,7 +1,128 @@
 # frozen_string_literal: true
 
-require_relative "kernel"
+# A class that represents the state of a game.
+class Qi
+  # @!attribute [r] north_captures
+  #   @return [Array] an array of pieces captured by the north player
+  # @!attribute [r] south_captures
+  #   @return [Array] an array of pieces captured by the south player
+  # @!attribute [r] squares
+  #   @return [Hash] a hash of pieces on the board
+  attr_reader :north_captures, :south_captures, :squares
 
-# The Qi abstraction.
-module Qi
+  # Initializes a new Qi object with the given attributes.
+  #
+  # @param is_north_turn [Boolean] a boolean value indicating whose turn it is
+  # @param north_captures [Array<Object>] an array of pieces captured by the north player
+  # @param south_captures [Array<Object>] an array of pieces captured by the south player
+  # @param squares [Hash<Object, Object>] a hash of squares on the board
+  def initialize(is_north_turn, north_captures, south_captures, squares)
+    # Assign the parameters to instance variables.
+    @is_north_turn  = is_north_turn
+    @north_captures = north_captures.sort
+    @south_captures = south_captures.sort
+    @squares        = squares.compact
+  end
+
+  # Returns a new Qi object that represents the state after applying the given changes.
+  #
+  # @param diffs [Hash<Object, Object>] a hash of changes to apply to the squares hash
+  # @param in_hand [Object, nil] the piece that is in hand or nil if none
+  # @param is_drop [Boolean] a boolean value indicating whether the in hand piece is dropped or not
+  # @return [Qi] a new Qi object with modified attributes, where:
+  #   - the turn is switched
+  #   - the captures are updated according to the in hand piece and the drop flag
+  #   - the squares are merged with the diffs hash
+  def commit(diffs = {}, in_hand = nil, is_drop: false)
+    modified_squares = squares.merge(diffs)
+    modified_captures = update_captures(in_hand, is_drop:)
+    self.class.new(!north_turn?, *modified_captures, modified_squares)
+  end
+
+  # Checks if it is the north turn or not.
+  #
+  # @return [Boolean] true if it is the north turn and false otherwise
+  def north_turn?
+    @is_north_turn
+  end
+
+  # Checks if it is not the north turn or not.
+  #
+  # @return [Boolean] true if it is not the north turn and false otherwise
+  def south_turn?
+    !north_turn?
+  end
+
+  # Returns an array representation of the Qi object's attributes.
+  #
+  # @return [Array(Boolean, Array<Object>, Array<Object>, Hash<Object, Object>)] an array containing four elements:
+  #   - a boolean value indicating whose turn it is
+  #   - an array of pieces captured by the north player
+  #   - an array of pieces captured by the south player
+  #   - a hash of squares on the board
+  def to_a
+    [
+      north_turn?,
+      north_captures,
+      south_captures,
+      squares
+    ]
+  end
+
+  # Returns a string representation of the Qi object's attributes.
+  #
+  # @return [String] a string containing three parts separated by "===":
+  #   - the current turn, either "NorthTurn" or "SouthTurn"
+  #   - the captures, sorted and joined by ","
+  #   - the squares, mapped to "coordinate:piece" pairs and joined by ","
+  def serialize
+    serialized_turn     = (north_turn? ? "NorthTurn" : "SouthTurn")
+    serialized_captures = (north_captures + south_captures).sort.join(",")
+    serialized_squares  = squares.keys.map { |i| "#{i}:#{squares.fetch(i)}" }.join(",")
+
+    "#{serialized_turn}===#{serialized_captures}===#{serialized_squares}"
+  end
+
+  # Returns a human-readable representation of the Qi object.
+  #
+  # @return [String] a string containing the class name and the serialized attributes
+  def inspect
+    "<#{self.class} #{serialize}>"
+  end
+
+  private
+
+  # Updates the captures arrays based on the piece in hand and whether it is dropped or not.
+  #
+  # @param in_hand [Object, nil] the piece that is in hand or nil if none
+  # @param is_drop [Boolean] a boolean value indicating whether the in hand piece is dropped or not
+  # @return [Array] an array containing the updated north and south captures arrays
+  def update_captures(in_hand, is_drop:)
+    return [north_captures, south_captures] if in_hand.nil?
+
+    captures = north_turn? ? north_captures : south_captures
+    other_captures = north_turn? ? south_captures : north_captures
+
+    if is_drop
+      captures = remove_from_captures(in_hand, *captures)
+    else
+      captures += [in_hand]
+    end
+
+    north_turn? ? [captures, other_captures] : [other_captures, captures]
+  end
+
+  # Removes the last occurrence of a piece from an array of captures and returns the modified array.
+  #
+  # @param piece [Object] the piece to be removed
+  # @param captures [Array<Object>] the array of captures
+  # @return [Array<Object>] the modified array of captures
+  # @raise [IndexError] if the piece is not found in the array
+  def remove_from_captures(piece, *captures)
+    index = captures.rindex(piece)
+    raise ::IndexError, "#{piece} not found!" if index.nil?
+
+    captures.delete_at(index)
+    captures
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: qi
 version: !ruby/object:Gem::Version
-  version: 10.0.0.beta4
+  version: 10.0.0.beta6
 platform: ruby
 authors:
 - Cyril Kato
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2023-04-21 00:00:00.000000000 Z
+date: 2023-04-23 00:00:00.000000000 Z
 dependencies: []
 description: An abstraction that could help to update positions for games like Shogi.
 email: contact@cyril.email
@@ -18,9 +18,7 @@ extra_rdoc_files: []
 files:
 - LICENSE.md
 - README.md
-- lib/kernel.rb
 - lib/qi.rb
-- lib/qi/action.rb
 homepage: https://github.com/sashite/qi.rb
 licenses:
 - MIT

data/lib/kernel.rb

@@ -1,18 +0,0 @@
-# frozen_string_literal: true
-# shareable_constant_value: none
-
-# warn_indent: true
-
-require_relative File.join("qi", "action")
-
-# The Kernel module.
-module Kernel
-  # Abstraction to build positions.
-  #
-  # @return [Array] An action to change the position.
-  #
-  # @api public
-  def Qi(*captures, **squares)
-    ::Qi::Action.new(*captures, **squares)
-  end
-end

data/lib/qi/action.rb

@@ -1,34 +0,0 @@
-# frozen_string_literal: true
-
-module Qi
-  # The Action abstraction.
-  class Action
-    CAPTURE_CHAR = "&"
-    DROP_CHAR    = "*"
-
-    # Action initializer.
-    def initialize(*captures, **squares)
-      @captures = captures
-      @squares  = squares
-    end
-
-    # Commit an action to the position.
-    #
-    # @return [Array] An action to change the position.
-    def call(**diffs)
-      captures = @captures + Array(diffs.delete(CAPTURE_CHAR))
-      drop     = diffs.delete(DROP_CHAR)
-
-      unless drop.nil?
-        index = captures.rindex(drop)
-        raise ::IndexError, "Piece #{drop.inspect} not captured!" if index.nil?
-
-        captures.delete_at(index)
-      end
-
-      squares = @squares.merge(diffs).compact
-
-      [captures.sort, squares]
-    end
-  end
-end