bioshogi 0.0.17 → 0.0.18

data/lib/bioshogi/analysis/custom_detectors/gyokutousen_detector.rb

@@ -0,0 +1,88 @@
+# frozen-string-literal: true
+
+module Bioshogi
+  module Analysis
+    module CustomDetectors
+      class GyokutousenDetector
+        include ExecuterDsl
+
+        attr_reader :executor
+
+        def initialize(executor)
+          @executor = executor
+        end
+
+        def call
+          retval = perform_block do
+            # 【却下】すでに持っている
+            skip_if { player.tag_bundle.include?("玉頭戦") }
+
+            # 【条件】互いの玉が存在する
+            and_cond { king_soldiers.all? }
+
+            # 【条件】互いの玉の列の差が1以内である (column_range を使うよりおそらく高速なので先に判定するでほとんどを除外する)
+            and_cond { black_king.place.column.distance(white_king.place.column) <= 1 }
+
+            # 【条件】互いの玉が2段目以上である
+            and_cond { king_soldiers.all? { |e| e.bottom_spaces >= 1 } }
+
+            # 【条件】動かした駒が二つの玉の行の間にある
+            and_cond { row_range.cover?(soldier.place.row.value) }
+
+            # 【条件】動かした駒が二つの玉の列の間にある
+            and_cond { column_range.cover?(soldier.place.column.value) }
+
+            # 【条件】互いの玉の行の差が間隔3である (美濃状態=間隔5, 互いに3段目相当=間隔3)
+            and_cond { row_range.size <= (3 + 2) }
+
+            # 【却下】どちらかの玉頭が安全である
+            skip_if do
+              king_soldiers.any? do |soldier|
+                if v = soldier.relative_move_to(:up)
+                  if s = board[v]
+                    s.piece.key == :pawn && s.normal? && s.location == soldier.location
+                  end
+                end
+              end
+            end
+          end
+
+          if retval
+            tag_add("玉頭戦")
+          end
+        end
+
+        def king_soldiers
+          @king_soldiers ||= container.players.collect(&:king_soldier)
+        end
+
+        def black_king
+          @black_king ||= container.player_at(:black).king_soldier
+        end
+
+        def white_king
+          @white_king ||= container.player_at(:white).king_soldier
+        end
+
+        # 座標は左→右の順で大きくなるので先後関係なく座標が 小さい方..大きい方 になるようにする
+        def column_range
+          @column_range ||= yield_self do
+            a, b = king_soldiers.collect { |e| e.place.column.value }
+            if a > b
+              a, b = b, a
+            end
+            a..b
+          end
+        end
+
+        # 座標が上から下になっているため w..b でよい
+        def row_range
+          @row_range ||= yield_self do
+            b, w = king_soldiers.collect { |e| e.place.row.value }
+            w..b
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bioshogi/analysis/custom_detectors/hikakukoukan_detector.rb

@@ -0,0 +1,84 @@
+# frozen-string-literal: true
+
+# |-------------+----------------------------+----------------------------|
+# |             | パターン1                  | パターン2                  |
+# |-------------+----------------------------+----------------------------|
+# | 1手目(自分) | 飛車切り角ゲット(角角で得) | 角切り飛車ゲット(飛飛で損) |
+# | 2手目(相手) | 同歩 (飛飛で損)            | 同歩 (角角で得)            |
+# |-------------+----------------------------+----------------------------|
+
+# 序盤のロジックおよびコメントはパターン1として書いているが実際はパターン2にも当てはまる。
+# 最後で分岐する。
+
+module Bioshogi
+  module Analysis
+    module CustomDetectors
+      class HikakukoukanDetector
+        include ExecuterDsl
+
+        attr_reader :executor
+
+        def initialize(executor)
+          @executor = executor
+        end
+
+        def call
+          perform_block do
+            # 0手目を相手(bob)とする
+
+            # 【条件】何かで駒を取った
+            Assertion.assert { captured_soldier }
+
+            # 【条件】相手はしぶしぶ飛車を取った
+            and_cond { captured_soldier.piece.hisyakaku }
+
+            # 【条件】ちなみに平手風の手合割である
+            and_cond { preset_is(:hirate_like) }
+
+            # 1手前を自分(alice)とする
+
+            m = nil
+            if hand_log = previous_hand_log(1)
+              m = hand_log.move_hand
+            end
+
+            # 【条件】自分は駒を動かした
+            and_cond { m }
+
+            # 【条件】その駒は次に相手が取る飛車である
+            and_cond { m.soldier.piece == captured_soldier.piece }
+
+            # 【条件】その駒は刺し違える意図があった
+            and_cond { m.captured_soldier }
+
+            # 【条件】それは角だった (captured_soldier.piece.swaped は相手が取った飛車の反対なので角)
+            and_cond { m.captured_soldier.piece == captured_soldier.piece.swaped }
+
+            # そうして現状はこうなっている──
+
+            # 【条件】相手は持駒から歩を除くと飛車しかない
+            and_cond { player.piece_box.except(:pawn) == { captured_soldier.piece.key => 1 } }
+
+            # 【条件】一方自分は序盤で飛車を捨てて角を手持ちにした
+            and_cond { opponent_player.piece_box.except(:pawn) == { captured_soldier.piece.swaped.key => 1 } }
+
+            if captured_soldier.piece.key == :rook
+              # みずから飛車と角を交換した系
+              tag_define(hand_log, opponent_player, "序盤は飛車より角") # alice は飛車を切って角をゲットした
+              tag_define(self, player, "序盤は角より飛車")              # 一方で bob は飛車をゲットしたが使い道がない
+            else
+              # ムリヤリ早石田系
+              tag_define(hand_log, opponent_player, "序盤は角より飛車") # alice は飛車大好きなので角で飛車を取った
+              tag_define(self, player, "序盤は飛車より角")              # alice が勝手に角飛交換してくれたので bob は角が2枚になってうれしい
+            end
+          end
+        end
+
+        def tag_define(object1, object2, tag)
+          object1.tag_bundle << tag
+          object2.tag_bundle << tag
+        end
+      end
+    end
+  end
+end

data/lib/bioshogi/analysis/custom_detectors/hisyakaku_kiru_detector.rb

@@ -0,0 +1,53 @@
+# frozen-string-literal: true
+
+module Bioshogi
+  module Analysis
+    module CustomDetectors
+      class HisyakakuKiruDetector
+        include ExecuterDsl
+
+        attr_reader :executor
+
+        def initialize(executor)
+          @executor = executor
+        end
+
+        def call
+          perform_block do
+            # skip_if { true }
+
+            # 【条件】駒を取った
+            Assertion.assert { captured_soldier }
+
+            # 【条件】取った駒は強い
+            and_cond { captured_soldier.piece.hisyakaku }
+
+            # 1手前──
+
+            m = nil
+            if hand_log = previous_hand_log(1)
+              m = hand_log.move_hand
+            end
+
+            # 【条件】相手が駒を動かした
+            and_cond { m }
+
+            # 【条件】その駒は今取った駒である
+            and_cond { m.soldier == captured_soldier }
+
+            # 【条件】その駒は何かの駒を取った
+            and_cond { m.captured_soldier }
+
+            # 【条件】その駒は金銀と刺し違えた
+            and_cond { m.captured_soldier.piece.kingin }
+
+            # 55から73に角を切って馬になったとき切ったのは角だから移動元の駒を見る
+            tag = m.origin_soldier.xxx_kiri
+            hand_log.tag_bundle << tag
+            opponent_player.tag_bundle << tag
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bioshogi/analysis/custom_detectors/kakukoukan_detector.rb

@@ -0,0 +1,63 @@
+# frozen-string-literal: true
+
+module Bioshogi
+  module Analysis
+    module CustomDetectors
+      class KakukoukanDetector
+        include ExecuterDsl
+
+        attr_reader :executor
+
+        def initialize(executor)
+          @executor = executor
+        end
+
+        def call
+          retval = perform_block do
+            # 【条件】何かで駒を取った
+            Assertion.assert { captured_soldier }
+
+            # 【条件】序盤である
+            and_cond { container.joban }
+
+            # 【条件】角を取った
+            and_cond { captured_soldier.piece.key == :bishop }
+
+            # -1手目──
+
+            move_hand = nil
+            if hand_log = previous_hand_log(1)
+              move_hand = hand_log.move_hand
+            end
+
+            # 【条件】相手が駒を動かした
+            and_cond { move_hand }
+
+            # 【条件】その駒は角だった
+            and_cond { move_hand.soldier.piece.key == :bishop }
+
+            # 【条件】その駒は何かの駒を取った (刺し違える意図があった)
+            and_cond { move_hand.captured_soldier }
+
+            # 【条件】角だった
+            and_cond { move_hand.captured_soldier.piece.key == :bishop }
+          end
+
+          if retval
+            # 角交換された側
+            player.tag_bundle << "手得"
+            player.tag_bundle << "角交換"
+            tag_bundle << "手得"
+            tag_bundle << "角交換"
+
+            # 角交換した側
+            opponent_player.tag_bundle << "手損"
+            opponent_player.tag_bundle << "角交換"
+            previous_hand_log(1).tag_bundle << "手損"
+            previous_hand_log(1).tag_bundle << "角交換"
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bioshogi/analysis/custom_detectors/kakunihakaku_detector.rb

@@ -0,0 +1,72 @@
+# frozen-string-literal: true
+
+module Bioshogi
+  module Analysis
+    module CustomDetectors
+      class KakunihakakuDetector
+        include ExecuterDsl
+
+        attr_reader :executor
+
+        def initialize(executor)
+          @executor = executor
+        end
+
+        def call
+          perform_block do
+            # 現在──自分が角を取った
+
+            # 【条件】何かで駒を取った
+            Assertion.assert { captured_soldier }
+
+            # 【条件】馬か角を取った (取り返した)
+            and_cond { captured_soldier.piece.hisyakaku }
+
+            # 1手前──相手が角交換してきた
+
+            m1 = nil
+            if hand_log1 = previous_hand_log(1)
+              m1 = hand_log1.move_hand
+            end
+
+            # 【条件】相手が操作した
+            and_cond { m1 }
+
+            # 【条件】その駒は角か馬だった
+            and_cond { m1.soldier.piece.hisyakaku }
+
+            # 【条件】その駒は何かの駒を取った (刺し違える意図があった)
+            and_cond { m1.captured_soldier }
+
+            # 【条件】角 or 飛
+            and_cond { m1.captured_soldier.piece.hisyakaku && m1.captured_soldier.normal? }
+
+            # 【条件】「同*」である
+            and_cond { m1.soldier.place == soldier.place }
+
+            # 2手前──自分が生角または生飛車を打った
+
+            d2 = nil
+            if hand_log2 = previous_hand_log(2)
+              d2 = hand_log2.drop_hand # 打った
+            end
+
+            # 【条件】操作した
+            and_cond { d2 }
+
+            # 【条件】角打または飛打ちだった
+            and_cond { d2.soldier.piece.hisyakaku }
+
+            # 【条件】打った場所は今、角か馬を取り返した場所と同じである
+            and_cond { d2.soldier.place == soldier.place }
+
+            # 2手前に入れる
+            tag = "#{m1.origin_soldier.any_name}には#{d2.soldier.any_name}".gsub("飛", "飛車")
+            hand_log2.tag_bundle << tag
+            player.tag_bundle << tag
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bioshogi/analysis/custom_detectors/magic_square_detector.rb

@@ -0,0 +1,41 @@
+# frozen-string-literal: true
+
+module Bioshogi
+  module Analysis
+    module CustomDetectors
+      class MagicSquareDetector
+        include ExecuterDsl
+
+        attr_reader :executor
+
+        def initialize(executor)
+          @executor = executor
+        end
+
+        def call
+          perform_block do
+            # 【条件】平手風である
+            and_cond { preset_is(:hirate_like) }
+
+            # 【条件】自玉が1つ存在する
+            and_cond { player.king_soldier_only_one_exist? }
+
+            # 【条件】自玉のまわりが歩より高い価値の味方で囲まれている
+            and_cond do
+              basic_weight = Piece[:pawn].basic_weight
+              V.outer_vectors.all? do |e|
+                if v = player.king_soldier.relative_move_to(e)
+                  if s = board[v]
+                    s.relative_weight > basic_weight
+                  end
+                end
+              end
+            end
+
+            tag_add("魔方陣")
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bioshogi/analysis/custom_detectors/nyuugyoku_anaguma_detector.rb

@@ -0,0 +1,67 @@
+# frozen-string-literal: true
+
+module Bioshogi
+  module Analysis
+    module CustomDetectors
+      class NyuugyokuAnagumaDetector
+        include ExecuterDsl
+
+        attr_reader :executor
+
+        def initialize(executor)
+          @executor = executor
+        end
+
+        def call
+          retval = perform_block do
+            # 【条件】自玉が1つ存在する
+            and_cond { player.king_soldier_only_one_exist? }
+
+            # 【条件】自玉が隅にいる
+            and_cond { king_soldier.top_spaces == 0 && king_soldier.side_edge? }
+
+            # 【条件】動かしたまたは打った駒は銀以上の駒である
+            and_cond { soldier.abs_weight >= min_score }
+
+            # 【条件】駒は玉と同じ側である
+            and_cond { soldier.left_or_right == king_soldier.left_or_right }
+
+            # 【条件】駒は玉の近くである (2x2)
+            and_cond { soldier.place.in_outer_area?(king_soldier.place, 1) }
+          end
+
+          if retval
+            if soldier_count >= 3
+              tag_add(:"入玉穴熊", once: true)
+            end
+          end
+        end
+
+        # 玉の周辺の金以上の駒の数を数える
+        def soldier_count
+          @soldier_count ||= yield_self do
+            V.outer_vectors.count do |e|
+              if v = king_soldier.relative_move_to(e)
+                if s = board[v]
+                  if own?(s)
+                    s.abs_weight >= min_score
+                  end
+                end
+              end
+            end
+          end
+        end
+
+        # 自玉
+        def king_soldier
+          @king_soldier ||= player.king_soldier
+        end
+
+        # 金以上の駒の価値
+        def min_score
+          @min_score ||= Piece[:gold].basic_weight
+        end
+      end
+    end
+  end
+end

data/lib/bioshogi/analysis/custom_detectors/outbreak_detector.rb

@@ -0,0 +1,20 @@
+# frozen-string-literal: true
+
+module Bioshogi
+  module Analysis
+    module CustomDetectors
+      class OutbreakDetector
+        include ExecuterDsl
+
+        attr_reader :executor
+
+        def initialize(executor)
+          @executor = executor
+        end
+
+        def call
+        end
+      end
+    end
+  end
+end

data/lib/bioshogi/analysis/custom_trigger_info.rb

@@ -0,0 +1,16 @@
+module Bioshogi
+  module Analysis
+    class CustomTriggerInfo
+      include ApplicationMemoryRecord
+      memory_record [
+        { key: :ct_every,    name: "毎回",   },
+        { key: :ct_outbreak, name: "開戦時", },
+        { key: :ct_capture,  name: "キル時", },
+      ]
+
+      def custom_detector_infos
+        @custom_detector_infos ||= CustomDetectorInfo.custom_trigger_keys_hash[key]
+      end
+    end
+  end
+end