bioshogi 0.0.3

data/lib/bioshogi/piece/piece_vector.rb

@@ -0,0 +1,156 @@
+# frozen-string-literal: true
+#
+# basic_once_vectors      通常の1ベクトル
+# basic_repeat_vectors    通常の繰り返しベクトル
+# promoted_once_vectors   成ったときの1ベクトル
+# promoted_repeat_vectors 成ったときの繰り返しベクトル
+#
+module Bioshogi
+  class Piece
+    class PieceVector
+      include ApplicationMemoryRecord
+      memory_record [
+        { key: :king,   basic_once_vectors: :pattern_king,       basic_repeat_vectors: nil,           promoted_once_vectors: nil,           promoted_repeat_vectors: nil,           },
+        { key: :rook,   basic_once_vectors: nil,                 basic_repeat_vectors: :pattern_plus, promoted_once_vectors: :pattern_x,    promoted_repeat_vectors: :pattern_plus, },
+        { key: :bishop, basic_once_vectors: nil,                 basic_repeat_vectors: :pattern_x,    promoted_once_vectors: :pattern_plus, promoted_repeat_vectors: :pattern_x,    },
+        { key: :gold,   basic_once_vectors: :pattern_gold,       basic_repeat_vectors: nil,           promoted_once_vectors: nil,           promoted_repeat_vectors: nil,           },
+        { key: :silver, basic_once_vectors: :pattern_silver,     basic_repeat_vectors: nil,           promoted_once_vectors: :pattern_gold, promoted_repeat_vectors: nil,           },
+        { key: :knight, basic_once_vectors: :pattern_knight,     basic_repeat_vectors: nil,           promoted_once_vectors: :pattern_gold, promoted_repeat_vectors: nil,           },
+        { key: :lance,  basic_once_vectors: nil,                 basic_repeat_vectors: :pattern_pawn, promoted_once_vectors: :pattern_gold, promoted_repeat_vectors: nil,           },
+        { key: :pawn,   basic_once_vectors: :pattern_pawn,       basic_repeat_vectors: nil,           promoted_once_vectors: :pattern_gold, promoted_repeat_vectors: nil,           },
+      ]
+
+      def brave?
+        attributes[:promoted_repeat_vectors]
+      end
+
+      def all_vectors(promoted:, location:)
+        @all_vectors ||= {}
+        @all_vectors[[promoted, location.key]] ||= yield_self do
+          vectors = select_vectors(promoted)
+          normalized_vectors(location, vectors)
+        end
+      end
+
+      private
+
+      def select_vectors(promoted)
+        raise MustNotHappen if !piece.promotable? && promoted
+
+        if promoted
+          promoted_vectors
+        else
+          basic_vectors
+        end
+      end
+
+      def piece
+        Piece.fetch(key)
+      end
+
+      def normalized_vectors(location, vectors)
+        vectors.collect { |e| e * location.value_sign }
+      end
+
+      def basic_vectors
+        @basic_vectors ||= build_vectors(basic_once_vectors, basic_repeat_vectors)
+      end
+
+      def promoted_vectors
+        @promoted_vectors ||= build_vectors(promoted_once_vectors, promoted_repeat_vectors)
+      end
+
+      def build_vectors(ov, rv)
+        v = ov.compact + rv.compact
+        if v.size != v.uniq.size
+          raise MustNotHappen
+        end
+
+        [
+          *ov.compact.collect { |v| V::OnceVector[*v]   },
+          *rv.compact.collect { |v| V::RepeatVector[*v] },
+        ]
+      end
+
+      def basic_once_vectors
+        vectors_at(super)
+      end
+
+      def basic_repeat_vectors
+        vectors_at(super)
+      end
+
+      def promoted_once_vectors
+        vectors_at(super)
+      end
+
+      def promoted_repeat_vectors
+        vectors_at(super)
+      end
+
+      def vectors_at(value)
+        if value
+          send(value)
+        else
+          []
+        end
+      end
+
+      def pattern_plus
+        [
+          nil,     [0,-1],     nil,
+          [-1, 0],    nil, [+1, 0],
+          nil,     [0,+1],     nil,
+        ]
+      end
+
+      def pattern_x
+        [
+          [-1, -1], nil, [+1, -1],
+          nil,      nil,     nil,
+          [-1, +1], nil, [+1, +1],
+        ]
+      end
+
+      def pattern_silver
+        [
+          [-1, -1], [0, -1], [+1, -1],
+          nil,          nil,      nil,
+          [-1, +1],     nil, [+1, +1],
+        ]
+      end
+
+      def pattern_gold
+        [
+          [-1, -1], [0, -1], [+1, -1],
+          [-1,  0],          [+1,  0],
+          nil,      [0, +1],      nil,
+        ]
+      end
+
+      def pattern_king
+        [
+          [-1, -1], [0, -1], [+1, -1],
+          [-1,  0],     nil, [+1,  0],
+          [-1, +1], [0, +1], [+1, +1],
+        ]
+      end
+
+      def pattern_knight
+        [
+          [-1, -2], nil, [+1, -2],
+          nil,      nil,      nil,
+          nil,      nil,      nil,
+        ]
+      end
+
+      def pattern_pawn
+        [
+          nil, [0, -1], nil,
+          nil,     nil, nil,
+          nil,     nil, nil,
+        ]
+      end
+    end
+  end
+end

data/lib/bioshogi/piece/yomiage_piece_info.rb

@@ -0,0 +1,31 @@
+# frozen-string-literal: true
+
+module Bioshogi
+  class Piece
+    class YomiagePieceInfo
+      include ApplicationMemoryRecord
+      memory_record [
+        { key: :king,   name: "gyoku",  promoted_name: nil,         },
+        { key: :rook,   name: "hisha",  promoted_name: "ryu",       }, # 「飛車」だと発音がおかしいため
+        { key: :bishop, name: "kaku",   promoted_name: "うま",      }, # 「角」は「かど」、「馬」は「ば」と読まれてしまうため
+        { key: :gold,   name: "kin",    promoted_name: nil,         },
+        { key: :silver, name: "銀",     promoted_name: "なり銀",    }, # 「なりgin」は「なりじん」と読まれてしまう
+        { key: :knight, name: "keima",  promoted_name: "なりkei",   },
+        { key: :lance,  name: "kyo",    promoted_name: "なりkyo",   },
+        { key: :pawn,   name: "hu",     promoted_name: "「と」",    },
+      ]
+
+      def piece
+        Piece.fetch(key)
+      end
+
+      def yomiage(promoted)
+        if promoted
+          promoted_name
+        else
+          name
+        end
+      end
+    end
+  end
+end

data/lib/bioshogi/piece.rb

@@ -0,0 +1,276 @@
+# -*- coding: utf-8; compile-command: "bundle execute rspec ../../spec/piece_spec.rb" -*-
+# frozen-string-literal: true
+#
+#  Piece.s_to_h("飛0 角 竜1 馬2 龍2")                    # => {:rook=>3, :bishop=>3}
+#  Piece.h_to_a(rook: 2, bishop: 1).collect(&:name)      # => ["飛", "飛", "角"]
+#  Piece.s_to_a("飛0 角 竜1 馬2 龍2 飛").collect(&:name) # => ["飛", "飛", "飛", "飛", "角", "角", "角"]
+#  Piece.a_to_s([:bishop, "竜", "竜"])                   # => "飛二 角"
+#  Piece.s_to_h2("▲歩2 飛 △歩二飛 ▲金")               # => {:black=>{:pawn=>2, :rook=>1, :gold=>1}, :white=>{:pawn=>2, :rook=>1}}
+#  Piece.h_to_s(bishop: 1, rook: 2)                      # => "飛二 角"
+#
+
+module Bioshogi
+  class Piece
+    class << self
+      # 持駒文字列から駒配列に変換
+      # Piece.s_to_a("飛0 角 竜1 馬2 龍2 飛").collect(&:name) # => ["飛", "飛", "飛", "飛", "角", "角", "角"]
+      def s_to_a(str)
+        s_to_h(str).yield_self { |v| h_to_a(v) }
+      end
+
+      # 持駒文字列から駒個数のハッシュに変換
+      # Piece.s_to_h("飛0 角 竜1 馬2 龍2") # => {:rook=>3, :bishop=>3}
+      def s_to_h(str)
+        str = KanjiNumber.kanji_to_number_string(str)
+        str = str.remove(/\p{blank}/)
+        str.scan(/(#{Piece.all_names.join("|")})(\d+)?/o).inject({}) do |a, (piece, count)|
+          piece = Piece.fetch(piece)
+          a.merge(piece.key => (count || 1).to_i) {|_, v1, v2| v1 + v2 }
+        end
+      end
+
+      # 駒個数のハッシュから駒配列に変換
+      # Piece.h_to_a(rook: 2, bishop: 1).collect(&:name)      # => ["飛", "飛", "角"]
+      def h_to_a(hv)
+        hv.flat_map do |piece_key, count|
+          count.times.collect { Piece.fetch(piece_key) }
+        end
+      end
+
+      # 駒個数のハッシュから持駒文字列に変換
+      # Piece.h_to_s(bishop: 1, rook: 2) # => "飛二 角"
+      def h_to_s(hv, options = {})
+        options = {
+          :ordered   => true, # 価値の高い順に並べる
+          :separator => " ",
+        }.merge(options)
+
+        hv = hv.collect { |key, count| [Piece.fetch(key), count] }
+
+        if options[:ordered]
+          hv = hv.sort_by { |e, _| -e.basic_weight }
+        end
+
+        hv = hv.reject { |piece, count| count.zero? }
+
+        hv.map { |piece, count|
+          raise MustNotHappen if count < 0
+          if count >= 2
+            count = KanjiNumber.number_to_kanji(count)
+          else
+            count = ""
+          end
+          "#{piece.name}#{count}"
+        }.join(options[:separator])
+      end
+
+      # 駒配列から持駒文字列に変換
+      # Piece.a_to_s(["竜", :pawn, "竜"], ordered: true, separator: "/") # => "飛二/歩"
+      def a_to_s(pieces, options = {})
+        h_to_s(a_to_h(pieces), options)
+      end
+
+      # 駒配列から個数のハッシュに変換
+      def a_to_h(pieces)
+        pieces = pieces.collect { |e| Piece.fetch(e) }
+        pieces.group_by(&:key).transform_values(&:size) # ruby 2.7 では tally が使える
+      end
+
+      # 持駒文字列から駒個数のハッシュに変換しつつさらに先後で分ける
+      # Piece.s_to_h2("▲歩2 飛 △歩二飛 ▲金") # => {:black=>{:pawn=>2, :rook=>1, :gold=>1}, :white=>{:pawn=>2, :rook=>1}}
+      def s_to_h2(str)
+        hash = Location.inject({}) { |a, e| a.merge(e.key => []) }
+        str.scan(/([#{Location.polygon_chars_str}])([^#{Location.polygon_chars_str}]+)/) do |triangle, str|
+          location = Location[triangle]
+          hash[location.key] << str
+        end
+        hash.transform_values { |e| s_to_h(e.join) }
+      end
+    end
+
+    include ApplicationMemoryRecord
+    memory_record [
+      { key: :king,   name: "玉", basic_alias: "王", promoted_name: nil,  promoted_formal_sheet_name: nil,    other_matched_promoted_names: nil,   sfen_char: "K", promotable: false, always_alive: true,  stronger: false, },
+      { key: :rook,   name: "飛", basic_alias: nil,  promoted_name: "龍", promoted_formal_sheet_name: nil,    other_matched_promoted_names: "竜",  sfen_char: "R", promotable: true,  always_alive: true,  stronger: true,  },
+      { key: :bishop, name: "角", basic_alias: nil,  promoted_name: "馬", promoted_formal_sheet_name: nil,    other_matched_promoted_names: nil,   sfen_char: "B", promotable: true,  always_alive: true,  stronger: true,  },
+      { key: :gold,   name: "金", basic_alias: nil,  promoted_name: nil,  promoted_formal_sheet_name: nil,    other_matched_promoted_names: nil,   sfen_char: "G", promotable: false, always_alive: true,  stronger: false, },
+      { key: :silver, name: "銀", basic_alias: nil,  promoted_name: "全", promoted_formal_sheet_name: "成銀", other_matched_promoted_names: nil,   sfen_char: "S", promotable: true,  always_alive: true,  stronger: false, },
+      { key: :knight, name: "桂", basic_alias: nil,  promoted_name: "圭", promoted_formal_sheet_name: "成桂", other_matched_promoted_names: "今",  sfen_char: "N", promotable: true,  always_alive: false, stronger: false, },
+      { key: :lance,  name: "香", basic_alias: nil,  promoted_name: "杏", promoted_formal_sheet_name: "成香", other_matched_promoted_names: "仝",  sfen_char: "L", promotable: true,  always_alive: false, stronger: false, },
+      { key: :pawn,   name: "歩", basic_alias: nil,  promoted_name: "と", promoted_formal_sheet_name: nil,    other_matched_promoted_names: nil,   sfen_char: "P", promotable: true,  always_alive: false, stronger: false, },
+    ]
+
+    class << self
+      def lookup(value)
+        basic_group[value] || promoted_group[value] || super
+      end
+
+      def fetch(value)
+        super
+      rescue => error
+        raise PieceNotFound, [
+          "#{value.inspect} に対応する駒がありません",
+          error.message,
+          "keys: #{(basic_group.keys + promoted_group.keys).inspect}",
+        ].join("\n")
+      end
+
+      def basic_group
+        @basic_group ||= inject({}) { |a, e| a.merge(e.basic_names.collect { |key| [key, e] }.to_h) }
+      end
+
+      def promoted_group
+        @promoted_group ||= inject({}) { |a, e| a.merge(e.promoted_names.collect { |key| [key, e] }.to_h) }
+      end
+    end
+
+    def inspect
+      "<#{self.class.name}:#{object_id} #{name} #{key}>"
+    end
+
+    def to_h
+      attributes
+    end
+
+    concerning :NameMethods do
+      class_methods do
+        def all_names
+          @all_names ||= flat_map(&:names)
+        end
+
+        def all_names_set
+          @all_names_set ||= all_names.to_set
+        end
+
+        # 未使用
+        def all_basic_names
+          @all_basic_names ||= flat_map(&:basic_names)
+        end
+
+        # 未使用
+        def all_basic_names_set
+          @all_basic_names_set ||= all_basic_names.to_set
+        end
+      end
+
+      # char_type:
+      #   single_char: "全"
+      #   formal_sheet: "成銀"
+      def any_name(promoted, options = {})
+        if promoted
+          if options[:char_type] == :formal_sheet
+            promoted_formal_sheet_name || promoted_name
+          else
+            promoted_name
+          end
+        else
+          name
+        end
+      end
+
+      def names
+        basic_names + promoted_names
+      end
+
+      def basic_names
+        [name, basic_alias, csa.basic_name, sfen_char, key].flatten.compact
+      end
+
+      def promoted_names
+        [promoted_name, *promoted_formal_sheet_name, *other_matched_promoted_names, csa.promoted_name].flatten.compact
+      end
+    end
+
+    concerning :SfenMethods do
+      class_methods do
+        def fetch_by_sfen_char(ch)
+          fetch(ch.upcase)
+        end
+      end
+
+      # http://shogidokoro.starfree.jp/usi.html
+      # "S"  先手の銀
+      # "s"  後手の銀
+      # "+s" 後手の成銀
+      def to_sfen(promoted: false, location: :black)
+        [
+          promoted ? "+" : nil,
+          sfen_char.public_send(Location[location].key == :black ? :upcase : :downcase),
+        ].join
+      end
+    end
+
+    concerning :CsaMethods do
+      def csa
+        @csa ||= PieceCsa.fetch(key)
+      end
+    end
+
+    concerning :OtherMethods do
+      def promotable?
+        promotable
+      end
+    end
+
+    concerning :VectorMethods do
+      included do
+        delegate :brave?, :all_vectors, to: :piece_vector
+      end
+
+      def piece_vector
+        @piece_vector ||= PieceVector.fetch(key)
+      end
+    end
+
+    concerning :ScaleMethods do
+      included do
+        delegate :scale, to: :piece_scale
+      end
+
+      def piece_scale
+        @piece_scale ||= PieceScale.fetch(key)
+      end
+    end
+
+    concerning :ScoreMethods do
+      included do
+        delegate :any_weight, :basic_weight, :promoted_weight, :hold_weight, to: :piece_score
+      end
+
+      def piece_score
+        @piece_score ||= PieceScore.fetch(key)
+      end
+    end
+
+    concerning :PressureMethods do
+      included do
+        delegate :attack_level, :promoted_attack_level, :defense_level, :promoted_defense_level, :standby_level, to: :piece_pressure
+      end
+
+      def piece_pressure
+        @piece_pressure ||= PiecePressure.fetch(key)
+      end
+    end
+
+    concerning :KifuyomiMethods do
+      included do
+        delegate :yomiage, to: :yomiage_piece_info
+      end
+
+      def yomiage_piece_info
+        @yomiage_piece_info ||= YomiagePieceInfo.fetch(key)
+      end
+    end
+
+    concerning :EkScoreInfoMethods do
+      included do
+        delegate :ek_score, to: :ek_score_info
+      end
+
+      def ek_score_info
+        @ek_score_info ||= EkScoreInfo.fetch(key)
+      end
+    end
+  end
+end
+

data/lib/bioshogi/piece_box.rb

@@ -0,0 +1,152 @@
+# frozen-string-literal: true
+
+module Bioshogi
+  class PieceBox < SimpleDelegator
+    ONE_SIDE_PIECES = "玉飛角金2銀2桂2香2歩9"
+
+    class << self
+      def real_box
+        new(all_piece_counts)
+      end
+
+      private
+
+      def all_piece_counts
+        @all_piece_counts ||= Piece.s_to_h(ONE_SIDE_PIECES * 2).freeze
+      end
+    end
+
+    def initialize(value = {})
+      super(value.dup)
+    end
+
+    def pick_out(piece)
+      piece = Piece.fetch(piece)
+      unless exist?(piece)
+        raise HoldPieceNotFound, "持駒から#{piece.name}を取り出そうとしましたが#{piece.name}を持っていません : #{to_h}"
+      end
+      add(piece => -1)
+      piece
+    end
+
+    def pick_out_without_king
+      Piece.h_to_a(object.except(:king))
+    end
+
+    def pieces
+      Piece.h_to_a(object)
+    end
+
+    def exist?(piece)
+      piece = Piece.fetch(piece)
+      (object[piece.key] || 0).positive?
+    end
+
+    def add(hash)
+      hash.each do |key, c|
+        piece = Piece.fetch(key)
+        n = object[piece.key] || 0
+        new_c = n + c
+        if new_c.positive?
+          object[piece.key] = new_c
+        elsif new_c.negative?
+          raise HoldPieceNotFound, "#{piece.name}は#{n}しかないのに#{c}したので#{new_c}になりました : #{to_h}"
+        else
+          object.delete(piece.key)
+        end
+      end
+      self
+    end
+
+    def safe_add(hash)
+      hash.each do |key, count|
+        object[key] = (object[key] || 0) + count
+      end
+      self
+    end
+
+    def safe_sub(hash)
+      hash.each do |key, count|
+        object[key] = (object[key] || 0) - count
+      end
+      self
+    end
+
+    def set(hash)
+      object.replace(hash)
+    end
+
+    def normalize!
+      object.reject! { |_, c| c <= 0 }
+    end
+
+    def score
+      object.collect { |piece_key, count|
+        Piece[piece_key].hold_weight * count
+      }.sum
+    end
+
+    def detail_score
+      object.collect { |piece_key, count|
+        piece = Piece[piece_key]
+        {piece: piece.name, count: count, weight: piece.hold_weight, total: piece.hold_weight * count}
+      }
+    end
+
+    def pressure_level
+      object.sum { |piece_key, count| Piece[piece_key].standby_level * count }
+    end
+
+    ################################################################################ 入玉時のスコア
+
+    def ek_score
+      object.sum do |piece_key, count|
+        Piece[piece_key].ek_score * count
+      end
+    end
+
+    ################################################################################ formatter
+
+    def to_s(options = {})
+      Piece.h_to_s(object, options)
+    end
+
+    # http://yaneuraou.yaneu.com/2016/07/15/sfen%E6%96%87%E5%AD%97%E5%88%97%E3%81%AF%E4%B8%80%E6%84%8F%E3%81%AB%E5%AE%9A%E3%81%BE%E3%82%89%E3%81%AA%E3%81%84%E4%BB%B6/#:~:text=%E2%86%92%202016%2F7%2F15%2024,%E6%AD%A9%E3%80%8D%E3%81%AE%E9%A0%86%E7%95%AA%E3%81%A8%E3%81%97%E3%81%BE%E3%81%99%E3%80%82
+    def to_sfen(location)
+      location = Location[location]
+      sorted_piece_objects_hash.sort_by { |piece, _|
+        -piece.basic_weight
+      }.flat_map { |piece, count|
+        [(count >= 2 ? count : ""), piece.to_sfen(location: location)]
+      }.join
+    end
+
+    def to_csa(location)
+      if object.empty?
+        return ""
+      end
+      location = Location[location]
+      [
+        "P",
+        location.csa_sign,
+        sorted_piece_objects_hash.flat_map { |piece, count|
+          ["00", piece.csa.basic_name] * count
+        },
+      ].join
+    end
+
+    private
+
+    def sorted_piece_objects_hash
+      object.collect { |key, count|
+        [Piece.fetch(key), count]
+      }.sort_by { |piece, _|
+        -piece.basic_weight
+      }
+    end
+
+    def object
+      __getobj__
+    end
+  end
+end