bioshogi 0.0.3

data/lib/bioshogi/ai/diver/nega_alpha_mate_diver.rb

@@ -0,0 +1,212 @@
+module Bioshogi
+  module Ai
+    module Diver
+      # 詰将棋専用
+      # ・評価値の大小は関係なく3つの状態しかない
+      # ・詰み   → +1
+      # ・不詰み → -1
+      # ・不明   →  0 (最深度に達っしたときその先はどうなるかわからないため)
+      class NegaAlphaMateDiver < Base
+        def initialize(*)
+          super
+
+          @params[:mate_mode] = true
+        end
+
+        def dive(player: params[:current_player], depth: 0, alpha: -SCORE_MAX, beta: +SCORE_MAX, hand_route: [])
+          tle_verify
+
+          container = player.container
+
+          if depth == 0
+            @eval_counter = 0
+          end
+
+          if logger
+            log = -> s { logger_info_on_depth(s, player: player, depth: depth, hand_route: hand_route) }
+          end
+
+          if depth_max <= depth
+            @eval_counter += 1
+
+            # raise if player.location.key == :white
+
+            # if player.mate_advantage?
+            #   if collect_children(player.op, log).empty?
+            #     score = 1
+            #   else
+            #     score = -1
+            #   end
+            # else
+            #   score = -1
+            # end
+
+            # if collect_children(player, log).empty?
+            #   score = -1
+            # else
+            #   score = 1
+            # end
+
+            # この先は詰みか不詰かわからないため0とする
+            score = 0
+
+            #   else
+            #     p 0
+            #     if player.mate_danger?
+            #       score = -SCORE_MAX
+            #     else
+            #       score = SCORE_MAX
+            #     end
+            #   end
+            # else
+            #   score = player.evaluator(params).score
+            # end
+            # score = player.evaluator(params).score
+
+            log["%+d" % score] if log
+            # p ["#{__FILE__}:#{__LINE__}", __method__, hand_route]
+            return [score, [], []]
+          end
+
+          children = collect_children(player, log)
+
+          # @hands_memo[depth] ||= children
+          # children = @hands_memo[depth]
+
+          if children.empty?
+            # 手が一つも生成できなかった場合は詰んでいる
+            # v = score_max_of(player, depth)
+            # best_pv = [MATE] # 注意。-SCORE_MAX を返すと alpha < v が成立しないため読み筋が返せない。
+
+            log["#{hand_route.collect(&:to_s).join(' ')} のあとで合法手がない(=詰み)"] if log
+
+            score = -1
+
+            if params[:motigoma_zero_denaito_dame]
+              if player.op.piece_box.count >= 1
+                score = 1
+              end
+            end
+
+            if score == -1
+              # # これで詰みが生じた指し手を収集できる
+              if f = params[:mate_proc]
+                f[player, score, hand_route]
+              end
+            end
+
+            return [score, [MATE]]
+          end
+
+          best_pv = []
+          best_hand = nil
+          # children_exist = false
+
+          children.each do |hand|
+            # unless hand.legal_hand?(container)
+            #   # log["skip: #{hand}"] if log
+            #   next
+            # end
+            # children_exist = true
+
+            log["#{hand}"] if log
+
+            # 玉が取られても相手の玉を取り返せば形勢は互角になる。
+            # そうなるとピンチであることに気づかない。
+            # だかから玉を取ったかどうかの判定を入れて玉を取った時点で最大の評価値にして探索を打ち切る
+
+            # 非合法手が混っている場合はこのチェックが重要になってくる
+            # if hand.king_captured?
+            #   raise
+            #   # alpha = SCORE_MAX - depth
+            #   # best_hand = hand
+            #   # best_pv = [best_hand]
+            #   return [SCORE_MAX, [hand]]
+            # else
+            v = nil
+            pv = nil
+            hand.sandbox_execute(container) do
+              v, pv = dive(player: player.opponent_player, depth: depth + 1, alpha: -beta, beta: -alpha, hand_route: hand_route + [hand])
+              log["#{v}, #{pv} = dive"] if log
+              v = -v                # 相手が良くなるほどこちらは不利になる
+            end
+
+            # if hand_route.first.to_s == "▲１二銀打"
+            #   p pv
+            #   p v
+            #   exit
+            # end
+
+            # p [alpha, v]
+            log["if #{alpha} < #{v}"] if log
+            if alpha < v
+              alpha = v
+              best_hand = hand
+              best_pv = [hand, *pv]
+              log["alpha = #{v}"] if log
+              log["best_pv = #{best_pv}"] if log
+              # best_pv = foo + [hand]
+            end
+
+            # if pv.include?(MATE)
+            #   onajino << [hand, *pv]
+            # end
+
+            # 詰将棋のときはすべての手を探すため break してはいけない
+            if alpha >= beta
+              if params[:no_break]
+              else
+                log["break if #{alpha} >= #{beta}"] if log
+                break
+              end
+            end
+          end
+
+          # if xlist.all?{|e| e >= 1}
+          # end
+
+          #   alpha = 1
+          # else
+          #   alpha = -1
+          # end
+
+          # unless children_exist
+          #   raise BioshogiError, "#{player.call_name}の指し手が一つもありません。すべての駒を取られている可能性があります\n#{container.to_bod}"
+          # end
+
+          if best_hand
+            log["★確 #{best_hand} (#{alpha}) ---------------------------------------- #{hand_route.collect(&:to_s).join(' ')}"] if log
+
+            # if best_pv.last. == MATE
+            #   onajino << [hand, *pv]
+            # end
+          end
+
+          # p [alpha, best_pv]
+          log["return [#{alpha}, #{best_pv}]"] if log
+          [alpha, best_pv]
+        end
+
+        # # 手を生成
+        # def collect_children(player, log)
+        #
+        #   if params[:base_player].nil?
+        #     raise "base_player (攻め手のプレイヤー) を指定してください"
+        #   end
+        #
+        #   if params[:base_player] == player
+        #     # 詰将棋モードなら自分だけ王手のみを生成する
+        #     v = player.create_all_hands(legal_only: true, mate_only: true).entries
+        #     log["王手のみの手を生成: #{v.collect(&:to_s).join(', ')}"] if log
+        #     v
+        #   else
+        #     # 王手を外す手だけを生成する
+        #     v = player.create_all_hands(legal_only: true).entries
+        #     log["王手解除の手を生成: #{v.collect(&:to_s).join(', ')}"] if log
+        #     v
+        #   end
+        # end
+      end
+    end
+  end
+end

data/lib/bioshogi/ai/diver/nega_max_diver.rb

@@ -0,0 +1,58 @@
+module Bioshogi
+  module Ai
+    module Diver
+      # コードはわかりやすいが遅い
+      class NegaMaxDiver < Base
+        def dive(player: params[:current_player], depth: 0, hand_route: [])
+          tle_verify
+
+          container = player.container
+
+          if depth == 0
+            @eval_counter = 0
+          end
+
+          if logger
+            log = -> s { logger_info_on_depth(s, player: player, depth: depth, hand_route: hand_route) }
+          end
+
+          # 一番深い局面に達したらはじめて評価する
+          if depth_max <= depth
+            @eval_counter += 1
+            score = player.evaluator(params).score
+            log["%+d" % score] if log
+            return [score, [], []]
+          end
+
+          children = collect_children(player, log)
+
+          if children.empty?
+            log["#{hand_route.collect(&:to_s).join(' ')} のあとで合法手がない(=詰み)"] if log
+            score = -score_max_of(player, depth)
+            if f = params[:mate_proc]
+              f[player, score, hand_route + [MATE]]
+            end
+            return [score, [MATE]]
+          end
+
+          max = -score_max_of(player, depth)
+          best_pv = [MATE]      # 初期値を詰みにしておくことで children が空のときに詰みが返る
+
+          children.each do |hand|
+            hand.sandbox_execute(container) do
+              log["#{hand}"] if log
+              v, pv = dive(player: player.opponent_player, depth: depth + 1, hand_route: hand_route + [hand])
+              v = -v # 相手の一番良い手は自分の一番悪い手としたいので符号を反転する
+              if v > max
+                best_pv = [hand, *pv]
+                max = v
+              end
+            end
+          end
+
+          [max, best_pv]
+        end
+      end
+    end
+  end
+end

data/lib/bioshogi/ai/diver/nega_scout_diver.rb

@@ -0,0 +1,120 @@
+module Bioshogi
+  module Ai
+    module Diver
+      # https://ja.wikipedia.org/wiki/Negascout
+      class NegaScoutDiver < Base
+        def dive(player: params[:current_player], depth: 0, alpha: -SCORE_MAX, beta: SCORE_MAX, hand_route: [])
+          tle_verify
+
+          container = player.container
+
+          if depth == 0
+            @eval_counter = 0
+          end
+
+          if logger
+            log = -> s { logger_info_on_depth(s, player: player, depth: depth, hand_route: hand_route) }
+          end
+
+          # 一番深く潜ったところで局面を評価する
+          if depth_max <= depth
+            @eval_counter += 1
+            score = player.evaluator(params).score
+            log["%+d" % score] if log
+            return [score, []]
+          end
+
+          children = collect_children(player, log)
+
+          # 再帰を簡潔に記述するため
+          recursive = -> hand, alpha2, beta2 {
+            # # 玉が取られても相手の玉を取り返せば形勢は互角になる。
+            # # そうなるとピンチであることに気づかない。
+            # # だかから玉を取ったかどうかの判定を入れて玉を取った時点で最大の評価値にして探索を打ち切る
+            if hand.king_captured?
+              raise
+              # v = SCORE_MAX - depth
+              v = SCORE_MAX
+              log["#{hand} -> #{v} #{player.location}勝"] if log
+              return [v, [hand]]
+            else
+              log["#{hand}"] if log
+              hand.sandbox_execute(container) do
+                v, pv = dive(player: player.opponent_player, depth: depth + 1, alpha: alpha2, beta: beta2, hand_route: hand_route + [hand])
+                v = -v
+                [v, pv]
+              end
+            end
+          }
+
+          # children が空の場合を考慮して初期値を投了級にしておく
+          max_v = -score_max_of(player, depth) # 浅いほど評価値を高くして最短で詰ますようにする
+          # max_v = -SCORE_MAX # 浅いほど評価値を高くして最短で詰ますようにする
+          best_pv = [MATE]      # 一度も更新されなかったら手がないということなので詰んでいる
+
+          # ここはなくてもいいけどベストな手から始めることで枝が減る
+          if true
+            # 効果的なもの順に並び換える→どうやって？？？
+            # children = container.move_ordering(player, children)
+            children = children.entries # FIXME: 並び返るために全取得すると遅延評価にした意味がない
+
+            # 最善候補を通常の窓で探索
+
+            # ベストな「合法手」を取得
+            hand = nil
+            loop do
+              hand = children.shift # FIXME: 配列として扱わなければ速くなるかも
+              if hand.nil?
+                break
+              end
+              if hand.legal_hand?(container)
+                break
+              end
+            end
+
+            if hand
+              v, pv = recursive.(hand, -beta, -alpha)
+              max_v = v
+              best_pv = [hand, *pv]
+              if beta <= v
+                return [v, [hand, *pv]]
+              end
+              if alpha < v
+                alpha = v
+              end
+            end
+          end
+
+          children.each do |hand|
+            unless hand.legal_hand?(container)
+              next
+            end
+
+            v, pv = recursive.(hand, -(alpha + 1), -alpha) # null window search
+            if beta <= v
+              return [v, [hand, *pv]]
+            end
+            if alpha < v
+              alpha = v
+              v, pv = recursive.(hand, -beta, -alpha) # 通常の窓で再探索
+              if beta <= v
+                return [v, [hand, *pv]]
+              end
+              if alpha < v
+                alpha = v
+              end
+            end
+
+            if max_v < v            # "<=" のなら評価値が同じ場合、後の方を優先する
+              max_v = v
+              best_pv = [hand, *pv]
+            end
+          end
+
+          log["★確 #{best_pv.first || '?'}"] if log
+          [max_v, best_pv]
+        end
+      end
+    end
+  end
+end

data/lib/bioshogi/ai/evaluator/attack_weight_table.rb

@@ -0,0 +1,52 @@
+# frozen-string-literal: true
+
+module Bioshogi
+  module Ai
+    module Evaluator
+
+      # http://www.yss-aya.com/book.html
+      AttackWeightTable = {
+        # 相手玉近くの自分の金銀の価値
+        :attack => [
+          [  50,  50,  50,  50,  50,  50,  50,  50,  50], # -8
+          [  50,  50,  50,  50,  50,  50,  50,  50,  50], # -7
+          [  50,  50,  50,  50,  50,  50,  50,  50,  50], # -6
+          [  54,  53,  51,  51,  50,  50,  50,  50,  50], # -5
+          [  70,  66,  62,  55,  53,  50,  50,  50,  50], # -4
+          [  90,  85,  80,  68,  68,  60,  53,  50,  50], # -3
+          [ 100,  97,  95,  85,  84,  71,  51,  50,  50], # -2
+          [ 132, 132, 129, 102,  95,  71,  51,  50,  50], # -1
+          [ 180, 145, 137, 115,  91,  75,  57,  50,  50], # 0
+          [ 170, 165, 150, 121,  94,  78,  58,  52,  50], # 1
+          [ 170, 160, 142, 114,  98,  80,  62,  55,  50], # 2
+          [ 140, 130, 110, 100,  95,  75,  54,  50,  50], # 3
+          [ 100,  99,  95,  87,  78,  69,  50,  50,  50], # 4
+          [  80,  78,  72,  67,  55,  51,  50,  50,  50], # 5
+          [  62,  60,  58,  52,  50,  50,  50,  50,  50], # 6
+          [  50,  50,  50,  50,  50,  50,  50,  50,  50], # 7
+          [  50,  50,  50,  50,  50,  50,  50,  50,  50], # 8
+        ],
+        # 自玉近くの自分の金銀の価値
+        :defense => [
+          [  50,  50,  50,  50,  50,  50,  50,  50,  50], # -8
+          [  56,  52,  50,  50,  50,  50,  50,  50,  50], # -7
+          [  64,  61,  55,  50,  50,  50,  50,  50,  50], # -6
+          [  79,  77,  70,  65,  54,  51,  50,  50,  50], # -5
+          [ 100,  99,  95,  87,  74,  58,  50,  50,  50], # -4
+          [ 116, 117, 101,  95,  88,  67,  54,  50,  50], # -3
+          [ 131, 129, 124, 114,  90,  71,  59,  51,  50], # -2
+          [ 137, 138, 132, 116,  96,  76,  61,  53,  50], # -1
+          [ 142, 142, 136, 118,  98,  79,  64,  52,  50], # 0
+          [ 132, 132, 129, 109,  95,  75,  60,  51,  50], # 1
+          [ 121, 120, 105,  97,  84,  66,  54,  50,  50], # 2
+          [  95,  93,  89,  75,  68,  58,  51,  50,  50], # 3
+          [  79,  76,  69,  60,  53,  50,  50,  50,  50], # 4
+          [  64,  61,  55,  51,  50,  50,  50,  50,  50], # 5
+          [  56,  52,  50,  50,  50,  50,  50,  50,  50], # 6
+          [  50,  50,  50,  50,  50,  50,  50,  50,  50], # 7
+          [  50,  50,  50,  50,  50,  50,  50,  50,  50], # 8
+        ],
+      }
+    end
+  end
+end

data/lib/bioshogi/ai/evaluator/base.rb

@@ -0,0 +1,40 @@
+# frozen-string-literal: true
+
+module Bioshogi
+  module Ai
+    module Evaluator
+      class Base
+        attr_reader :player
+        attr_reader :params
+
+        delegate :container, :board, to: :player
+        delegate :players, to: :container
+
+        def self.default_params
+          {}
+        end
+
+        def initialize(player, params = {})
+          @player = player
+          @params = self.class.default_params.merge(params)
+        end
+
+        # 自分基準評価値
+        def score
+          Bioshogi.run_counts["#{self.class.name}#score"] += 1
+          score_compute
+        end
+
+        private
+
+        def score_compute
+          (total_score(player) - total_score(player.op)).to_i
+        end
+
+        def total_score(player)
+          0
+        end
+      end
+    end
+  end
+end

data/lib/bioshogi/ai/evaluator/level0.rb

@@ -0,0 +1,25 @@
+# frozen-string-literal: true
+
+module Bioshogi
+  module Ai
+    module Evaluator
+      # 評価すること
+      # ・盤上の駒の価値
+      # ・詰将棋モードの場合はYの位置を考慮したら逆に面倒なことになるのでこの評価方法でよい
+      class Level0 < Base
+        private
+
+        def total_score(player)
+          w = 0
+          # w += player.piece_box.score
+          # w
+        end
+
+        # 自分基準評価値
+        def soldier_score(e)
+          e.abs_weight
+        end
+      end
+    end
+  end
+end

data/lib/bioshogi/ai/evaluator/level1.rb

@@ -0,0 +1,26 @@
+# frozen-string-literal: true
+
+module Bioshogi
+  module Ai
+    module Evaluator
+      # 評価すること
+      # ・盤上の駒の価値
+      # ・詰将棋モードの場合はYの位置を考慮したら逆に面倒なことになるのでこの評価方法でよい
+      class Level1 < Base
+        private
+
+        def total_score(player)
+          w = 0
+          w += player.piece_box.score
+          w += player.soldiers.sum { |e| soldier_score(e) }
+          w
+        end
+
+        # 自分基準評価値
+        def soldier_score(e)
+          e.abs_weight
+        end
+      end
+    end
+  end
+end

data/lib/bioshogi/ai/evaluator/level2.rb

@@ -0,0 +1,31 @@
+# frozen-string-literal: true
+
+module Bioshogi
+  module Ai
+    module Evaluator
+      class Level2 < Level1
+        private
+
+        # 評価すること
+        # ・盤上の駒の価値
+        # ・序盤で歩をつく
+        def soldier_score(e)
+          w = e.abs_weight
+
+          unless e.promoted
+            if t = OpeningBasicTable[:field][e.piece.key]
+              x, y = e.normalized_place.to_xy
+              w += t[y][x]
+            end
+            if t = OpeningBasicTable[:advance][e.piece.key]
+              s = t[e.bottom_spaces]
+              w += s
+            end
+          end
+
+          w
+        end
+      end
+    end
+  end
+end

data/lib/bioshogi/ai/evaluator/level3.rb

@@ -0,0 +1,121 @@
+# frozen-string-literal: true
+
+module Bioshogi
+  module Ai
+    module Evaluator
+      class Level3 < Base
+        def score_compute_report
+          rows = player.self_and_opponent.collect do |player|
+            {
+              "先後"           => "#{player.location} #{player == self.player ? "自分" : ''}",
+              "駒箱(常時加算)" => player.piece_box.score,
+              "序盤"           => "#{opening_score(player)} * #{(1.0 - pressure[player]).round(1)} = #{opening_score(player) * (1.0 - pressure[player])}",
+              "終盤"           => "#{final_stage_score(player)} * #{pressure[player].round(1)} = #{final_stage_score(player) * pressure[player]}",
+              "序終盤合計"     => total_score(player),
+            }
+          end
+          rows += [{"全体" => score_compute}]
+        end
+
+        private
+
+        def initialize(*)
+          super
+
+          # 途中で呼ばれると盤面が変化している場合があるので最初に作っておく
+          #
+          # YSS の場合は歩香桂以外では探索中でもきちんと動いた玉を考慮している
+          # > http://www.yss-aya.com/book.html
+          # > なお、高速化のため、歩、香、桂の小駒に対しては、探索途中で王が動いても再計算せずに、探索前の王の位置から増減表を作って加算している。
+          #
+          pressure
+        end
+
+        def total_score(player)
+          w = 0
+          w += player.piece_box.score
+          w += opening_score(player) * (1.0 - pressure[player]) # 序盤 * 序盤の重み
+          w += final_stage_score(player) * (0.0 + pressure[player]) # 終盤 * 終盤の重み
+          w
+        end
+
+        # 序盤評価値
+        def opening_score(player)
+          w = 0
+          player.soldiers.each do |e|
+            w += e.abs_weight
+            unless e.promoted # ← これを入れると序盤の「33角成」をダメな手だと教えられない、けどやっぱり成ってない駒だけを序盤駒とした方がいいか
+              if t = opening_basic_table[:field][e.piece.key]
+                x, y = e.normalized_place.to_xy
+                w += t[y][x]
+              end
+              if t = opening_basic_table[:advance][e.piece.key]
+                w += t[e.bottom_spaces]
+              end
+            end
+          end
+          w
+        end
+
+        # 終盤評価値
+        def final_stage_score(player)
+          w = 0
+          player.soldiers.each do |e|
+            w += e.abs_weight
+            w += a_d_score_of(player, player.op, :attack)  # 敵玉の近くにいるスコア
+            w -= a_d_score_of(player, player.my, :defense) # 自玉の近くにいるスコア
+          end
+          w
+        end
+
+        # プレイヤーそれぞれの終盤度
+        def pressure
+          @pressure ||= players.inject({}) { |a, e| a.merge(e => e.pressure_rate) }
+        end
+
+        def opening_basic_table
+          OpeningBasicTable
+        end
+
+        # player の 攻撃駒のスコア または 守り駒のスコア
+        #
+        # player: 自分
+        # target: 対象玉 (自分側 or 相手側)
+        # key: :attack or :defense
+        def a_d_score_of(player, target, key)
+          king_place = target.king_place
+          table = AttackWeightTable[key]
+          player.soldiers.sum { |e| soldier_score_for_scene(e, king_place, table) }
+        end
+
+        # 盤上の駒の位置による重み
+        def soldier_score_for_scene(e, king_place, table)
+          return 0 unless king_place
+
+          if e.promoted || e.piece.key == :gold || e.piece.key == :silver
+            # 相手の玉との距離
+            sx, sy = e.place.to_xy
+            tx, ty = king_place.to_xy
+            gx = tx - sx
+            gy = ty - sy
+
+            # (mx, my) はテーブルのセルの位置
+            # 金銀は上からの方が強いので縦は上と下でそれぞれ重みが違う
+            oy = table.size / 2 # 8
+            my = oy - gy        # 8 - (-2) = 10
+
+            # mx は左右対象
+            mx = gx.abs
+
+            w = table.dig(my, mx)
+            return 0 unless w
+            # p ["#{__FILE__}:#{__LINE__}", __method__, e, w, s, [mx, my], king_place]
+            w
+          else
+            0
+          end
+        end
+      end
+    end
+  end
+end