bioshogi 0.0.14 → 0.0.17

data/lib/bioshogi/piece/piece_vector.rb

@@ -10,21 +10,27 @@ module Bioshogi
     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,           },
+        { 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,           },
+      ]
+
+      DELEGATE_METHODS = [
+        :brave?,
+        :all_vectors,
       ]
 
       def brave?
         attributes[:promoted_repeat_vectors]
       end
 
-      def all_vectors(promoted:, location:)
+      # すべてはこれで足りるので他のメソッドを public にするべからず
+      def all_vectors(location:, promoted: false)
         @all_vectors ||= {}
         @all_vectors[[promoted, location.key]] ||= yield_self do
           vectors = select_vectors(promoted)
@@ -49,7 +55,7 @@ module Bioshogi
       end
 
       def normalized_vectors(location, vectors)
-        vectors.collect { |e| e * location.value_sign }
+        vectors.collect { |e| e * location.sign_dir }
       end
 
       def basic_vectors

data/lib/bioshogi/piece.rb

@@ -97,14 +97,14 @@ module Bioshogi
 
     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, dengaku_target: true,  tatakare_target: true,  maesusumeru: true,  },
-      { 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,  dengaku_target: true,  tatakare_target: true,  maesusumeru: 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,  dengaku_target: true,  tatakare_target: false, maesusumeru: false, },
-      { 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, dengaku_target: false, tatakare_target: true,  maesusumeru: true,  },
-      { 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, dengaku_target: false, tatakare_target: true,  maesusumeru: true,  },
-      { 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, dengaku_target: false, tatakare_target: false, maesusumeru: 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, dengaku_target: false, tatakare_target: true,  maesusumeru: true,  },
-      { 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, dengaku_target: false, tatakare_target: false, maesusumeru: true,  },
+      { 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,  strong: false, core_piece: true,  dengaku_target: true,  tatakare_target: true,  maesusumeru: true,  },
+      { 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,  strong: true,  core_piece: true,  dengaku_target: true,  tatakare_target: true,  maesusumeru: 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,  strong: true,  core_piece: true,  dengaku_target: true,  tatakare_target: false, maesusumeru: false, },
+      { 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,  strong: false, core_piece: false, dengaku_target: false, tatakare_target: true,  maesusumeru: true,  },
+      { 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,  strong: false, core_piece: false, dengaku_target: false, tatakare_target: true,  maesusumeru: true,  },
+      { key: :knight, name: "桂", basic_alias: nil,  promoted_name: "圭", promoted_formal_sheet_name: "成桂", other_matched_promoted_names: "今",  sfen_char: "N", promotable: true,  always_alive: false, strong: false, core_piece: false, dengaku_target: false, tatakare_target: false, maesusumeru: 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, strong: false, core_piece: false, dengaku_target: false, tatakare_target: false, maesusumeru: true,  },
+      { 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, strong: false, core_piece: false, dengaku_target: false, tatakare_target: false, maesusumeru: true,  },
     ]
 
     class << self
@@ -129,6 +129,10 @@ module Bioshogi
       def promoted_group
         @promoted_group ||= inject({}) { |a, e| a.merge(e.promoted_names.collect { |key| [key, e] }.to_h) }
       end
+
+      def strong_pieces
+        @strong_pieces ||= find_all(&:strong)
+      end
     end
 
     def inspect
@@ -143,6 +147,10 @@ module Bioshogi
       promotable
     end
 
+    def core_piece?
+      core_piece
+    end
+
     concerning :NameMethods do
       class_methods do
         def all_names
@@ -218,7 +226,7 @@ module Bioshogi
     def piece_vector
       @piece_vector ||= PieceVector.fetch(key)
     end
-    delegate :brave?, :all_vectors, to: :piece_vector
+    delegate *PieceVector::DELEGATE_METHODS, to: :piece_vector
 
     def piece_scale
       @piece_scale ||= PieceScale.fetch(key)

data/lib/bioshogi/piller_cop.rb

@@ -0,0 +1,47 @@
+# frozen-string-literal: true
+#
+# 駒柱をなるべく高速に判定する
+#
+module Bioshogi
+  class PillerCop
+    attr_reader :counts
+    attr_accessor :active
+    
+    def initialize
+      reset
+    end
+
+    def active?
+      @active
+    end
+
+    def reset
+      @counts = Array.new(Dimension::Column.dimension_size, 0)
+      @active = false
+    end
+
+    def set(place)
+      index = place.column.value
+      count = @counts[index] + 1
+      if count > Dimension::Row.dimension_size
+        raise MustNotHappen, "#{place.column.hankaku_number}の列に#{count}個目の駒を配置しようとしています。棋譜を二重に読ませようとしていませんか？"
+      end
+      @counts[index] = count
+      if count == Dimension::Row.dimension_size
+        @active = true
+      end
+    end
+
+    def remove(place)
+      index = place.column.value
+      count = @counts[index] - 1
+      if count.negative?
+        raise MustNotHappen, "#{place.column.hankaku_number}の列の駒の数がマイナスになろうとしていています"
+      end
+      @counts[index] = count
+      if count == Dimension::Row.dimension_size - 1
+        @active = false
+      end
+    end
+  end
+end

data/lib/bioshogi/place.rb

@@ -9,19 +9,19 @@
 
 module Bioshogi
   class Place
-    attr_accessor :x, :y
-
     class << self
       private :new
 
-      include Enumerable
+      begin
+        include Enumerable
 
-      def each(&block)
-        Dimension::PlaceY.dimension.times.flat_map { |y|
-          Dimension::PlaceX.dimension.times.collect { |x|
-            self[[x, y]]
-          }
-        }.each(&block)
+        def each(&block)
+          Dimension::Row.dimension_size.times.flat_map { |row|
+            Dimension::Column.dimension_size.times.collect { |column|
+              self[[column, row]]
+            }
+          }.each(&block)
+        end
       end
 
       def fetch(value)
@@ -33,28 +33,30 @@ module Bioshogi
           return value
         end
 
-        x = nil
-        y = nil
+        column = nil
+        row = nil
 
         case value
         when Array
           a, b = value
-          x = Dimension::PlaceX.lookup(a)
-          y = Dimension::PlaceY.lookup(b)
+          column = Dimension::Column.lookup(a)
+          row = Dimension::Row.lookup(b)
         when String
           a, b = value.chars
-          x = Dimension::PlaceX.lookup(a)
-          y = Dimension::PlaceY.lookup(b)
+          column = Dimension::Column.lookup(a)
+          row = Dimension::Row.lookup(b)
         else
           if respond_to?(:to_a)
             return lookup(value.to_a)
           end
         end
 
-        if x && y
-          @memo ||= {}
-          @memo[x] ||= {}
-          @memo[x][y] ||= new(x, y).freeze
+        # 座標は最大で99なのでインスタンスを使いまわす
+        # ただしグローバルな寸法が変わると不整合な状態になるため cache_clear を適切に呼ばないといけない
+        if column && row
+          @cache ||= {}
+          @cache[column] ||= {}
+          @cache[column][row] ||= new(column, row)
         end
       end
 
@@ -62,91 +64,125 @@ module Bioshogi
         lookup(value)
       end
 
+      def zero
+        fetch([0, 0])
+      end
+
+      def cache_clear
+        if @cache
+          @cache.each_value do |hv|
+            hv.each_value(&:cache_clear)
+          end
+        end
+      end
+
       def regexp
         /[一二三四五六七八九１-９1-9]{2}/
       end
     end
 
-    def initialize(x, y)
-      @x = x
-      @y = y
-    end
+    attr_accessor :column, :row
 
-    def inspect
-      "#<#{self.class.name} #{name}>"
+    # for Soldier
+    DELEGATE_METHODS = [
+      *Dimension::Column::DELEGATE_METHODS,
+      *Dimension::Row::DELEGATE_METHODS,
+
+      :relative_move_to,
+      :move_to_xy,
+      :king_default_place?,
+
+      :move_to_bottom_edge,
+      :move_to_top_edge,
+      :move_to_left_edge,
+      :move_to_right_edge,
+    ]
+
+    def initialize(column, row)
+      @column = column
+      @row = row
+      @cache = {}
+      freeze
     end
 
-    # 180度回転 ※上下対象ではない
-    def flip
-      self.class.fetch([@x.flip, @y.flip])
+    def cache_clear
+      to_a.each(&:cache_clear)
+      @cache.clear
     end
 
-    # x座標のみ反転
-    def flop
-      self.class.fetch([@x.flip, @y])
+    def inspect
+      "#<#{self.class.name} #{name}>"
     end
 
-    def flip_if_white(location)
-      if Location[location].key == :white
-        flip
-      else
-        self
-      end
+    ################################################################################
+
+    def to_s
+      name
     end
 
     def name
-      to_a.collect { |e| e.name }.join
+      @cache[:name] ||= to_a.collect(&:name).join
     end
 
     def zenkaku_number
-      to_a.collect(&:zenkaku_number).join
+      @cache[:zenkaku_number] ||= to_a.collect(&:zenkaku_number).join
     end
 
     def hankaku_number
-      to_a.collect(&:hankaku_number).join
+      @cache[:hankaku_number] ||= to_a.collect(&:hankaku_number).join
     end
 
     def yomiage
-      to_a.collect(&:yomiage).join
-    end
-
-    def to_s
-      name
+      @cache[:yomiage] ||= to_a.collect(&:yomiage).join
     end
 
     def to_sfen
-      to_a.collect(&:to_sfen).join
+      @cache[:to_sfen] ||= to_a.collect(&:to_sfen).join
     end
 
     def to_xy
-      [@x.value, @y.value]
+      @cache[:to_xy] ||= to_a.collect(&:value)
     end
 
     # "６八銀" なら [6, 8]
+    # キャッシュすると3倍速くなる
     def to_human_int
-      to_a.collect(&:to_human_int)
+      @cache[:to_human_int] ||= to_a.collect(&:to_human_int)
     end
 
-    # "６八銀" なら {x:6, y:8}
+    # "６八銀" なら {column:6, row:8}
+    # キャッシュすると2倍速くなる
     def to_human_h
-      { x: @x.to_human_int, y: @y.to_human_int }
+      @cache[:to_human_h] ||= Hash[[:column, :row].zip(to_human_int)]
     end
 
+    # ほぼキャッシュ効果なし。それどころか少し遅くなる。ただ配列を再生成しないのでこれでいいことにする。
     def to_a
-      [@x, @y]
+      @cache[:to_a] ||= [@column, @row]
     end
 
-    def vector_add(vector)
-      self.class.lookup([@x.value + vector.x, @y.value + vector.y])
+    ################################################################################
+
+    # 180度回転
+    def flip
+      @cache[:flip] ||= self.class.fetch(to_a.collect(&:flip))
     end
 
-    # def valid?
-    #   @x.valid? && @y.valid?
-    # end
-    #
-    # def invalid?
-    #   !valid?
-    # end
+    # column座標のみ反転
+    def flop
+      @cache[:flop] ||= self.class.fetch([@column.flip, @row])
+    end
+
+    # Soldier では独自に定義しているためここに Soldier からここに委譲してはいけない
+    def white_then_flip(location)
+      if Location[location].key == :white
+        flip
+      else
+        self
+      end
+    end
+
+    ################################################################################
 
     def ==(other)
       eql?(other)
@@ -164,8 +200,69 @@ module Bioshogi
       self.class == other.class && to_xy == other.to_xy
     end
 
-    def promotable?(location)
-      @y.promotable?(location)
+    ################################################################################ 移動
+
+    # より抽象的な方法で移動した位置を返す
+    def relative_move_to(location, vector, magnification: 1)
+      if vector.kind_of?(Symbol)
+        vector = V.public_send(vector)
+      end
+      xy_add(*(vector * location.sign_dir * magnification))
+    end
+
+    # 自玉の位置にいる？
+    def king_default_place?(location)
+      column_is_center?(location) && bottom_spaces(location) == 0
+    end
+
+    def xy_add(x, y)
+      self.class.lookup([@column.value + x, @row.value + y])
+    end
+    private :xy_add
+
+    def vector_add(vector)
+      xy_add(vector.x, vector.y)
+    end
+
+    # 上下左右 -1 +1 -1 +1 に進んだ位置を返す (white側の場合も考慮する)
+    # 2つ進んだ位置などを一発で調べたいときに使う
+    # なるべく使うな
+    def move_to_xy(location, x, y)
+      xy_add(x * location.sign_dir, y * location.sign_dir)
     end
+
+    ################################################################################ location から見た上下左右に寄せた位置を返す
+
+    def move_to_bottom_edge(location)
+      self.class.fetch([column, location.bottom])
+    end
+
+    def move_to_top_edge(location)
+      self.class.fetch([column, location.top])
+    end
+
+    def move_to_left_edge(location)
+      self.class.fetch([location.left, row])
+    end
+
+    def move_to_right_edge(location)
+      self.class.fetch([location.right, row])
+    end
+
+    ################################################################################ location から見た情報を返す
+
+    Dimension::Column::DELEGATE_METHODS.each do |name|
+      define_method(name) do |location|
+        @column.white_then_flip(location).public_send(name)
+      end
+    end
+
+    Dimension::Row::DELEGATE_METHODS.each do |name|
+      define_method(name) do |location|
+        @row.white_then_flip(location).public_send(name)
+      end
+    end
+
+    ################################################################################
   end
 end

data/lib/bioshogi/player/other_methods.rb

@@ -3,48 +3,31 @@
 module Bioshogi
   class Player
     module OtherMethods
-      attr_writer :king_moved_counter
-      attr_accessor :king_place
-      attr_accessor :king_first_moved_turn # 玉が最初に動いた手数
-      attr_accessor :death_counter         # 駒が死んだ数
-
-      def king_moved_counter
-        @king_moved_counter ||= 0
-      end
-
-      def king_place
-        @king_place ||= king_soldier&.place
-      end
-
-      def king_place_update
-        @king_place = king_soldier&.place
-      end
-
-      def used_piece_counts
-        @used_piece_counts ||= Hash.new(0)
-      end
+      STRONG_PIECE_ALL_COUNT = Location.count * Piece.strong_pieces.count
 
       ################################################################################
 
       # 大駒コンプリートしている？
-      def stronger_piece_completed?
-        stronger_piece_have_count >= 4
+      def strong_piece_completed?
+        strong_piece_have_count >= STRONG_PIECE_ALL_COUNT
       end
 
       # 大駒の数
-      def stronger_piece_have_count
-        count = 0
-
-        # 持駒の大駒
-        count += piece_box[:rook] || 0
-        count += piece_box[:bishop] || 0
+      def strong_piece_have_count
+        Piece.strong_pieces.sum do |e|
+          piece_box.fetch(e.key, 0) + board.specific_piece_count_for(location.key, e.key)
+        end
+      end
 
-        # 盤上の大駒
-        key = location.key
-        count += board.piece_count_of(key, :rook)
-        count += board.piece_count_of(key, :bishop)
+      ################################################################################
 
-        count
+      def zengoma?
+        if board.location_piece_counts[opponent_player.location.key] == 1              # 盤上の相手の駒が1つ
+          if opponent_player.piece_box.empty?                                          # 相手の持駒がない
+            location = opponent_player.location                                        # 相手の側
+            board.soldiers.one? { |e| e.piece.key == :king && e.location == location } # 相手の残りの駒が玉か？ (最後に重い処理を持ってくる)
+          end
+        end
       end
 
       ################################################################################

data/lib/bioshogi/player/piece_box_methods.rb

@@ -9,7 +9,7 @@ module Bioshogi
         @piece_box ||= PieceBox.new
       end
 
-      def pieces_add(str = "歩9角飛香2桂2銀2金2玉")
+      def pieces_add(str = PieceBox::ONE_SIDE_PIECES)
         piece_box.add(Piece.s_to_h(str))
       end
 

data/lib/bioshogi/player/soldier_methods.rb

@@ -3,12 +3,18 @@
 module Bioshogi
   class Player
     module SoldierMethods
-      def soldiers
-        board.surface.values.find_all { |e| e.location == location }
+      def core_soldier(piece_key)
+        board.core_soldier_places_hash.dig(location.key, piece_key)
       end
 
       def king_soldier
-        soldiers.find { |e| e.piece.key == :king }
+        core_soldier(:king)
+      end
+
+      ################################################################################
+
+      def soldiers
+        board.surface.values.find_all { |e| e.location == location }
       end
 
       def to_s_soldiers
@@ -23,11 +29,11 @@ module Bioshogi
       # 入玉している？
       def king_soldier_entered?
         if soldier = king_soldier
-          soldier.place.promotable?(location)
+          soldier.place.opp_side?(location)
         end
       end
 
-      # 玉を除く駒が10毎以上相手陣に入っているか？
+      # 玉を除く駒が10枚以上相手陣に入っているか？
       def many_soliders_are_in_the_opponent_area?
         entered_soldiers.count >= Piece::EkScoreInfo::N_SOLIDIERS_IN_OPPONENT_AREA_WITHOUT_KING
       end
@@ -36,7 +42,7 @@ module Bioshogi
       def entered_soldiers
         soldiers.find_all do |e|
           if e.piece.key != :king
-            e.place.promotable?(location)
+            e.place.opp_side?(location)
           end
         end
       end

data/lib/bioshogi/player.rb

@@ -6,6 +6,7 @@ module Bioshogi
     include PieceBoxMethods
     include SoldierMethods
     include OtherMethods
+    include Analysis::PlayerMethods
     include PressureMethods
 
     attr_reader :location

data/lib/bioshogi/player_executor/base.rb

@@ -29,7 +29,7 @@ module Bioshogi
       end
 
       def perform_validations
-        unless container.params[:validate_enable]
+        unless container.params[:validate_feature]
           return
         end
 
@@ -48,12 +48,13 @@ module Bioshogi
         @drop_hand          = input.drop_hand
         @move_hand          = input.move_hand
         @candidate_soldiers = nil
-        if container.params[:candidate_enable]
+        if container.params[:ki2_function]
           @candidate_soldiers = input.candidate_soldiers
         end
 
         hand.execute(container)
         execute_after_process
+
         if captured_soldier
           piece_box_added(captured_soldier)
         end