bioshogi 0.0.3

data/Rakefile

@@ -0,0 +1,3 @@
+require "bundler/gem_tasks"
+
+Pathname.glob("lib/bioshogi/tasks/**/*.rake").each { |file| load(file) }

data/bin/bioshogi

@@ -0,0 +1,3 @@
+#!/usr/bin/env ruby
+require "bioshogi/cli"
+Bioshogi::Cli.start

data/bioshogi.gemspec

@@ -0,0 +1,44 @@
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) if !$LOAD_PATH.include?(lib)
+require 'bioshogi/version'
+
+Gem::Specification.new do |spec|
+  spec.name         = "bioshogi"
+  spec.version      = Bioshogi::VERSION
+  spec.author       = "Akira Ikeda"
+  spec.email        = "pinpon.ikeda@gmail.com"
+  spec.homepage     = "https://github.com/akicho8/bioshogi"
+  spec.summary      = "Shogi library"
+  spec.description  = "Shogi library"
+  spec.platform     = Gem::Platform::RUBY
+  spec.license      = "AGPL-3.0"
+
+  # https://pocke.hatenablog.com/entry/2020/10/24/171955
+  spec.files         = `git ls-files`.split($/).grep_v(%r{^(test|spec|features|demo|algorithm|experiment|min_max|bioshogi.png|doc)/})
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = [] # spec.files.grep(%r{^(test|spec|features|demo|algorithm|experiment|min_max)/})
+  spec.require_paths = ["lib"]
+  spec.rdoc_options  = ["--line-numbers", "--inline-source", "--charset=UTF-8", "--diagram", "--image-format=jpg"]
+
+  spec.add_development_dependency "bundler"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "test-unit"
+  spec.add_development_dependency "stackprof"
+  spec.add_development_dependency "pry"
+  spec.add_development_dependency "simplecov"
+  spec.add_development_dependency "byebug"
+
+  spec.add_dependency "activesupport", ">= 7.1.0"
+  spec.add_dependency "actionview"
+  spec.add_dependency "table_format"
+  spec.add_dependency "memory_record"
+  spec.add_dependency "tree_support"
+  spec.add_dependency "color"
+  spec.add_dependency "zeitwerk"
+  spec.add_dependency "thor"
+  spec.add_dependency "rmagick", ">= 5.0.0"
+  spec.add_dependency "systemu"
+  spec.add_dependency "rubyzip", ">= 2.3.0"
+  spec.add_dependency "faraday"
+end

data/credit.org

@@ -0,0 +1,6 @@
+|-------------------------------------------+-----------+-----------------|
+| Files                                     | Author(s) | License         |
+|-------------------------------------------+-----------+-----------------|
+| lib/bioshogi/assets/images/piece/Portella | Portella  | [[https://creativecommons.org/licenses/by-nc-sa/4.0/][CC BY-NC-SA 4.0]] |
+|-------------------------------------------+-----------+-----------------|
+

data/lib/bioshogi/ai/brain.rb

@@ -0,0 +1,202 @@
+# -*- coding: utf-8; compile-command: "bundle exec rspec ../../spec/brain_spec.rb" -*-
+# frozen-string-literal: true
+
+require "timeout"
+
+module Bioshogi
+  module Ai
+    # 指定の Diver を使って簡単に反復探索するためのクラス
+    class Brain
+      def self.human_format(infos)
+        infos.collect.with_index do |e, i|
+          {
+            "順位"       => i.next,
+            "候補手"     => e[:hand],
+            "読み筋"     => e[:best_pv].collect(&:to_s).join(" "),
+            "▲形勢"     => e[:black_side_score], # 先手視点の評価値
+            "評価局面数" => e[:eval_times],
+            "処理時間"   => e[:sec],
+            # "他の手"     => e[:other].collect { |a| a.collect(&:to_s).join(" ") }.join(", ")
+          }
+        end
+      end
+
+      attr_accessor :player, :params
+
+      delegate :container, :create_all_hands, to: :player
+      delegate :logger, :to => "Bioshogi", allow_nil: true
+
+      def initialize(player, params = {})
+        @player = player
+        @params = {
+          diver_class: Diver::NegaAlphaDiver,    # [Diver::NegaAlphaDiver, Diver::NegaScoutDiver]
+          evaluator_class: Evaluator::Level1, # [Evaluator::Base, Evaluator::Level1, Evaluator::Level2, Evaluator::Level3]
+
+          # legal_moves_all: false,         # すべての手を合法手に絞る(重い！)
+          # legal_moves_first_only: true,   # 最初の手だけ合法手に絞る
+        }.merge(params)
+      end
+
+      # ショートカット用
+      def diver_dive(params = {})
+        diver_instance(params.merge(current_player: player)).dive
+      end
+
+      # 反復深化深さ優先探索
+      # https://ja.wikipedia.org/wiki/%E5%8F%8D%E5%BE%A9%E6%B7%B1%E5%8C%96%E6%B7%B1%E3%81%95%E5%84%AA%E5%85%88%E6%8E%A2%E7%B4%A2
+      # > ゲーム木でIDDFSを使う場合、アルファ・ベータ枝刈りなどのヒューリスティックが反復によって改善されていき、
+      # > 最も深い探索でのスコアの推定値がより正確になるという利点がある。また、探索順序を改善することができるため、
+      # > 探索をより高速に行えるという利点もある（前の反復で最善とされた手を次の反復で最初に調べることでアルファ・ベータ法の効率が良くなる）。
+      def iterative_deepening(params = {})
+        # このパラメータはそのまま Diver に渡している
+        params = {
+          depth_max_range: 1..1,  # 1..3 なら時間がある限り1→2→3手と読み進めていく。3手詰限定なら 3..3 とする
+          time_limit: nil,        # nil なら時間制限なし。時間指定なしなら 深度を を 1..3 のようにする意味はなくて最初から 3..3 とすればよい
+          mate_mode: false,       # 王手になる手と、王手をかわす手だけを生成するか？
+
+          # 常に diver_instance に渡すもの
+          base_player: player,    # どちらのプレイヤーから開始したか。詰将棋のときなど先後で指し手の方針を明確に分ける必要があるため。
+          current_player: player.opponent_player, # Diver#dive の最初の player として使うため
+        }.merge(params)
+
+        if params[:time_limit]
+          params[:time_limit_exceeded] ||= Time.now + params[:time_limit]
+        end
+
+        if params[:mate_mode]
+          children = player.create_all_hands(legal_only: true, mate_only: true) # 王手になる手だけを生成
+        else
+          children = player.create_all_hands(legal_only: true)
+        end
+
+        # if true
+        #   # あまりに重いので読みの最初の手を合法手に絞る
+        #   children = children.find_all { |e| e.legal_hand?(container) }
+        # else
+        #   children = children.to_a # 何度も実行するためあえて配列化しておくの重要
+        # end
+
+        # ordered_children = children # 前の反復で最善とされた順に並んでいる手
+
+        hands = []
+        provisional_hands = []
+        mate = false
+        finished = catch :time_limit_exceeded do
+          params[:depth_max_range].each do |depth_max|
+            diver = diver_instance(params.merge(depth_max: depth_max))
+
+            provisional_hands = []
+            mate = false
+            children.each do |hand|
+              logger.debug "#ROOT #{hand}" if logger
+
+              # 即詰があれば探索を速攻打ち切る場合
+              # 無効にしてもいいけど他の探索で時間がかかったら、この深さの探索全体がTLEでキャンセルされる可能性がある
+              # if true
+              #   if hand.king_captured?
+              #     v = -SCORE_MAX
+              #     provisional_hands << {hand: hand, score: -v, black_side_score: -v * player.location.value_sign, best_pv: [], eval_times: 0, sec: 0}
+              #     mate = true
+              #     break
+              #   end
+              # end
+
+              hand.sandbox_execute(container) do
+                start_time = Time.now
+                v, pv = diver.dive(hand_route: [hand]) # TLEが発生してするとcatchまで飛ぶ
+                v = -v                                        # 相手の良い手は自分のマイナス
+                provisional_hands << {hand: hand, score: v, black_side_score: v * player.location.value_sign, best_pv: pv, eval_times: diver.eval_counter, sec: Time.now - start_time}
+                # 1手詰: (v >= SCORE_MAX - 0) 自分勝ち
+                # 2手詰: (v >= SCORE_MAX - 1) 相手勝ち
+                # 3手詰: (v >= SCORE_MAX - 2) 自分勝ち
+                # 4手詰: (v >= SCORE_MAX - 3) 相手勝ち
+                # 5手詰: (v >= SCORE_MAX - 4) 自分勝ち
+                if v >= SCORE_MAX
+                  mate = true     # 1手詰があった
+                end
+              end
+              # if hand.king_captured?
+              #   mate = true       # 即詰がある
+              # end
+            end
+            hands = provisional_hands
+
+            if true
+              hands = hands.sort_by { |e| -e[:score] } # 最善手順に並び換えて採用(途中でbreakするのは詰みがあったときぐらいなのであんまり効果ないかも)
+            end
+
+            if mate
+              break     # この深さで詰みを発見したらこれ以上は潜らない
+            end
+
+            # 次の反復では前の反復で最善とされた順で探索する
+            children = hands.collect { |e| e[:hand] }
+          end
+          true
+        end # catch
+
+        if finished
+          # すべての探索を終えた
+        else
+          # タイムアウトしてきた
+
+          # 詰みがあった場合は最後の provisional_hands を採用する
+          if mate
+            hands = provisional_hands.sort_by { |e| -e[:score] } # 最善手順に並び換えて採用
+          end
+        end
+
+        # 自分の合法手があるのに相手の手を1手も見つけられない状況
+        # TLEが早過ぎる場合に起きる
+        if !children.empty? && hands.empty?
+          raise BrainProcessingHeavy, "合法手を生成したにもかかわらず、指し手の候補を絞れません。制限時間を増やすか読みの深度を浅くしてください : #{params}"
+        end
+
+        hands
+      end
+
+      def diver_instance(args)
+        params[:diver_class].new(params.merge(args))
+      end
+
+      # Dimension::PlaceY.promotable_disabled
+      # Dimension.wh_change([2, 5])
+      # container = Container::Basic.new
+      # container.board.placement_from_shape <<~EOT
+      # +------+
+      # | ・v香|
+      # | ・v飛|
+      # | ・v歩|
+      # | ・ 飛|
+      # | ・ 香|
+      # +------+
+      # EOT
+      # brain = container.player_at(:black).brain(evaluator_class: Evaluator::Level2)
+      # brain.smart_score_list(depth_max: 2) # => [{:hand=><▲２四飛(14)>, :score=>105, :socre2=>105, :best_pv=>[<△１四歩(13)>, <▲１四飛(24)>], :eval_times=>12, :sec=>0.002647}, {:hand=><▲１三飛(14)>, :score=>103, :socre2=>103, :best_pv=>[<△１三飛(12)>, <▲１三香(15)>], :eval_times=>9, :sec=>0.001463}]
+      #
+      # 探索するけど探索の深さを延していかない
+      def smart_score_list(params = {})
+        diver = diver_instance(current_player: player.opponent_player)
+        create_all_hands(promoted_only: true).collect { |hand|
+          hand.sandbox_execute(container) do
+            start_time = Time.now
+            v, pv = diver.dive
+            {hand: hand, score: -v, socre2: -v * player.location.value_sign, best_pv: pv, eval_times: diver.eval_counter, sec: Time.now - start_time}
+          end
+        }.sort_by { |e| -e[:score] }
+      end
+
+      # すべての手を指してみて評価する (探索しない)
+      def fast_score_list(params = {})
+        evaluator = player.evaluator(params.merge(params))
+        create_all_hands(promoted_only: true).collect { |hand|
+          hand.sandbox_execute(container) do
+            start_time = Time.now
+            v = evaluator.score
+            {hand: hand, score: v, socre2: v * player.location.value_sign, best_pv: [], eval_times: 1, sec: Time.now - start_time}
+          end
+        }.sort_by { |e| -e[:score] }
+      end
+    end
+  end
+end

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

@@ -0,0 +1,114 @@
+module Bioshogi
+  module Ai
+    module Diver
+      class Base
+        MATE = "(詰み)"
+
+        attr_accessor :params
+        attr_accessor :eval_counter
+
+        # delegate :container, to: :player
+        # delegate :evaluate, to: :container
+        # delegate :place_on, to: :container
+        delegate :logger, :to => "Bioshogi", allow_nil: true
+
+        # iterative_deepening のパラメータがそのまま来ている
+        def initialize(params)
+          @params = {
+            depth_max: 0,         # 深度
+            log_take: nil,        # 2 なら最初の2階層までを表示
+          }.merge(params)
+
+          @eval_counter = 0
+        end
+
+        private
+
+        # ログを減らすには？
+        # ・brain.iterative_deepening(log_scope: "▲１二銀打") → 初手「▲１二銀打」から始まるもの
+        # ・brain.iterative_deepening(log_scope: "▲１二銀打") →
+        def logger_info_on_depth(str, context)
+          return unless logger
+
+          if context[:hand_route]
+            if log_scope = params[:log_scope]
+              unless context[:hand_route].collect(&:to_s).join(" ").start_with?(log_scope)
+                return
+              end
+            end
+          end
+
+          if v = params[:log_take]
+            if context[:depth] >= v
+              return
+            end
+          end
+
+          str = str.lines.collect { |e|
+            (" " * 4 * context[:depth]) + e
+          }.join.rstrip
+
+          if str.match?(/\n/)
+            str = "\n" + str
+          end
+
+          logger.info "    %d %s %s" % [
+            context[:depth],
+            context[:player].location,
+            str,
+          ]
+        end
+
+        def tle_verify
+          if t = params[:time_limit_exceeded]
+            if t <= Time.now
+              throw :time_limit_exceeded
+            end
+          end
+        end
+
+        def depth_max
+          params[:depth_max]
+        end
+
+        # 深いほど手がかかるので最大の評価値を下げる
+        def score_max_of(player, depth)
+          # if params[:mate_mode]
+          #   return 1
+          # end
+
+          v = SCORE_MAX - depth
+
+          # # 詰将棋のときは「持駒を持っているほどスコアを下げる」ことで持駒を使い切った手の方を優先する
+          # if params[:mate_mode]
+          #   v -= player.op.piece_box.count * 1000
+          # end
+
+          v
+        end
+
+        # 手を生成
+        def collect_children(player, log)
+          if params[:mate_mode]
+            if params[:base_player].nil?
+              raise "mate_mode: true (王手モード) のときは 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
+          else
+            player.create_all_hands(promoted_only: true).entries
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,122 @@
+module Bioshogi
+  module Ai
+    module Diver
+      class NegaAlphaDiver < 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 = nil
+            # if params[:mate_mode]
+            #   if params[:base_player] == player
+            #     if player.op.mate_danger?
+            #       score = SCORE_MAX
+            #     else
+            #       score = -SCORE_MAX
+            #     end
+            #   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
+            return [score, []]
+          end
+
+          children = collect_children(player, log)
+
+          if children.empty?
+            # 手が一つも生成できなかった場合は詰んでいる
+            v = score_max_of(player, depth)
+            alpha = -v
+            best_pv = [MATE] # 注意。-SCORE_MAX を返すと alpha < v が成立しないため読み筋が返せない。
+
+            log["#{hand_route.collect(&:to_s).join(' ')} のあとで合法手がない(=詰み)"] if log
+
+            # これで詰みが生じた指し手を収集できる
+            if f = params[:mate_proc]
+              f[player, -alpha, hand_route]
+            end
+
+            return [alpha, best_pv]
+          end
+
+          best_pv = []
+          best_hand = nil
+
+          children.each do |hand|
+            # unless hand.legal_hand?(container)
+            #   # log["skip: #{hand}"] if log
+            #   next
+            # end
+
+            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])
+              v = -v
+            end
+
+            if alpha < v
+              alpha = v
+              best_hand = hand
+              best_pv = [hand, *pv]
+            end
+
+            # 詰将棋のときはすべての手を探すため break してはいけない
+            if alpha >= beta
+              if params[:mate_mode]
+              else
+                break
+              end
+            end
+          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
+          end
+
+          [alpha, best_pv]
+        end
+      end
+    end
+  end
+end