bioshogi 0.0.3

data/lib/bioshogi/place.rb

@@ -0,0 +1,171 @@
+# frozen-string-literal: true
+#
+# 座標
+#
+#   Place["４三"].name   # => "４三"
+#   Place["４三"].name  # => "４三"
+#   Place["43"].name    # => "４三"
+#
+
+module Bioshogi
+  class Place
+    attr_accessor :x, :y
+
+    class << self
+      private :new
+
+      include Enumerable
+
+      def each(&block)
+        Dimension::PlaceY.dimension.times.flat_map { |y|
+          Dimension::PlaceX.dimension.times.collect { |x|
+            self[[x, y]]
+          }
+        }.each(&block)
+      end
+
+      def fetch(value)
+        lookup(value) or raise SyntaxDefact, "座標が読み取れません : #{value.inspect}"
+      end
+
+      def lookup(value)
+        if value.kind_of?(self)
+          return value
+        end
+
+        x = nil
+        y = nil
+
+        case value
+        when Array
+          a, b = value
+          x = Dimension::PlaceX.lookup(a)
+          y = Dimension::PlaceY.lookup(b)
+        when String
+          a, b = value.chars
+          x = Dimension::PlaceX.lookup(a)
+          y = Dimension::PlaceY.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
+        end
+      end
+
+      def [](value)
+        lookup(value)
+      end
+
+      def regexp
+        /[一二三四五六七八九１-９1-9]{2}/
+      end
+    end
+
+    def initialize(x, y)
+      @x = x
+      @y = y
+    end
+
+    def inspect
+      "#<#{self.class.name} #{name}>"
+    end
+
+    # 180度回転 ※上下対象ではない
+    def flip
+      self.class.fetch([@x.flip, @y.flip])
+    end
+
+    # x座標のみ反転
+    def flop
+      self.class.fetch([@x.flip, @y])
+    end
+
+    def flip_if_white(location)
+      if Location[location].key == :white
+        flip
+      else
+        self
+      end
+    end
+
+    def name
+      to_a.collect { |e| e.name }.join
+    end
+
+    def zenkaku_number
+      to_a.collect(&:zenkaku_number).join
+    end
+
+    def hankaku_number
+      to_a.collect(&:hankaku_number).join
+    end
+
+    def yomiage
+      to_a.collect(&:yomiage).join
+    end
+
+    def to_s
+      name
+    end
+
+    def to_sfen
+      to_a.collect(&:to_sfen).join
+    end
+
+    def to_xy
+      [@x.value, @y.value]
+    end
+
+    # "６八銀" なら [6, 8]
+    def to_human_int
+      to_a.collect(&:to_human_int)
+    end
+
+    # "６八銀" なら {x:6, y:8}
+    def to_human_h
+      { x: @x.to_human_int, y: @y.to_human_int }
+    end
+
+    def to_a
+      [@x, @y]
+    end
+
+    def vector_add(vector)
+      self.class.lookup([@x.value + vector.x, @y.value + vector.y])
+    end
+
+    # def valid?
+    #   @x.valid? && @y.valid?
+    # end
+    #
+    # def invalid?
+    #   !valid?
+    # end
+
+    def ==(other)
+      eql?(other)
+    end
+
+    def <=>(other)
+      to_xy <=> other.to_xy
+    end
+
+    def hash
+      to_xy.hash
+    end
+
+    def eql?(other)
+      self.class == other.class && to_xy == other.to_xy
+    end
+
+    def promotable?(location)
+      @y.promotable?(location)
+    end
+  end
+end

data/lib/bioshogi/player/other_methods.rb

@@ -0,0 +1,60 @@
+# frozen-string-literal: true
+
+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
+
+      # 大駒コンプリートしている？
+      def stronger_piece_completed?
+        stronger_piece_have_count >= 4
+      end
+
+      def stronger_piece_have_count
+        c = 0
+
+        # 持駒の大駒
+        c += piece_box[:rook] || 0
+        c += piece_box[:bishop] || 0
+
+        # 盤上の大駒
+        key = location.key
+        c += board.piece_count_of(key, :rook)
+        c += board.piece_count_of(key, :bishop)
+
+        c
+      end
+
+      # 入玉宣言時の得点合計(仮)
+      def ek_score_without_cond
+        soldiers_ek_score + piece_box.ek_score
+      end
+
+      # 入玉宣言時の得点合計(最終)
+      def ek_score_with_cond
+        if king_soldier_entered? && many_soliders_are_in_the_opponent_area?
+          ek_score_without_cond
+        end
+      end
+    end
+  end
+end

data/lib/bioshogi/player/piece_box_methods.rb

@@ -0,0 +1,33 @@
+# frozen-string-literal: true
+
+module Bioshogi
+  class Player
+    module PieceBoxMethods
+      attr_writer :piece_box
+
+      def piece_box
+        @piece_box ||= PieceBox.new
+      end
+
+      def pieces_add(str = "歩9角飛香2桂2銀2金2玉")
+        piece_box.add(Piece.s_to_h(str))
+      end
+
+      def pieces_set(str)
+        piece_box.set(Piece.s_to_h(str))
+      end
+
+      def piece_box_as_header
+        "#{call_name}の持駒：#{piece_box.to_s.presence || "なし"}"
+      end
+
+      def to_sfen
+        piece_box.to_sfen(location)
+      end
+
+      def to_csa
+        piece_box.to_csa(location)
+      end
+    end
+  end
+end

data/lib/bioshogi/player/pressure_methods.rb

@@ -0,0 +1,37 @@
+# frozen-string-literal: true
+
+module Bioshogi
+  class Player
+    module PressureMethods
+      # 圧力レベル
+      def soldiers_pressure_level
+        soldiers.sum(&:pressure_level)
+      end
+
+      # 圧力レベル(デバッグ用)
+      def pressure_report
+        rows = []
+        rows += soldiers.collect { |e| {"盤上" => e, "勢力" => e.pressure_level} }
+        rows += piece_box.collect { |piece_key, count|
+          piece = Piece[piece_key]
+          {
+            "勢力" => "#{piece.standby_level} * #{count}",
+            "持駒" => "#{piece}#{count}",
+          }
+        }
+        rows += [{"勢力" => "合計 #{pressure_level}"}]
+        rows += [{"勢力" => "終盤率 #{pressure_rate}"}]
+        rows += [{"勢力" => "序盤率 #{1.0 - pressure_rate}"}]
+        rows
+      end
+
+      def pressure_level
+        soldiers_pressure_level + piece_box.pressure_level
+      end
+
+      def pressure_rate(max = 16)
+        pressure_level.clamp(0, max).fdiv(max)
+      end
+    end
+  end
+end

data/lib/bioshogi/player/soldier_methods.rb

@@ -0,0 +1,45 @@
+# frozen-string-literal: true
+
+module Bioshogi
+  class Player
+    module SoldierMethods
+      def soldiers
+        board.surface.values.find_all { |e| e.location == location }
+      end
+
+      def king_soldier
+        soldiers.find { |e| e.piece.key == :king }
+      end
+
+      def to_s_soldiers
+        soldiers.collect(&:name_without_location).sort.join(" ")
+      end
+
+      # 入玉宣言時の盤上にある駒の得点合計
+      def soldiers_ek_score
+        soldiers.sum(&:ek_score)
+      end
+
+      # 入玉している？
+      def king_soldier_entered?
+        if soldier = king_soldier
+          soldier.place.promotable?(location)
+        end
+      end
+
+      # 玉を除く駒が10毎以上相手陣に入っているか？
+      def many_soliders_are_in_the_opponent_area?
+        entered_soldiers.count >= Piece::EkScoreInfo::N_SOLIDIERS_IN_OPPONENT_AREA_WITHOUT_KING
+      end
+
+      # 相手陣に入っている玉を除く駒
+      def entered_soldiers
+        soldiers.find_all do |e|
+          if e.piece.key != :king
+            e.place.promotable?(location)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bioshogi/player.rb

@@ -0,0 +1,101 @@
+# frozen-string-literal: true
+
+module Bioshogi
+  class Player
+    include Ai::PlayerBrainMod
+    include PieceBoxMethods
+    include SoldierMethods
+    include OtherMethods
+    include PressureMethods
+
+    attr_reader :location
+    attr_reader :container
+    attr_reader :executor
+
+    delegate :board, to: :container
+
+    def initialize(container:, location:)
+      @container = container
+      @location = location
+    end
+
+    def execute(str, options = {})
+      @executor = (options[:executor_class] || PlayerExecutor::Human).new(self, str, options)
+      @executor.execute
+    end
+
+    def opponent_player
+      @container.player_at(location.flip)
+    end
+
+    # 自分と相手
+    def self_and_opponent
+      [self, opponent_player]
+    end
+
+    def op
+      opponent_player
+    end
+
+    def my
+      self
+    end
+
+    def soldier_create(object, options = {})
+      if object.kind_of?(Array)
+        object.each do |e|
+          soldier_create(e, options)
+        end
+      else
+        if object.kind_of?(String)
+          soldier = Soldier.from_str(object, location: location)
+        else
+          soldier = object
+        end
+        if options[:from_stand]
+          piece_box.pick_out(soldier.piece)
+        end
+        board.place_on(soldier, validate: true)
+      end
+    end
+
+    def placement_from_human(str)
+      soldiers = InputParser.scan(str).collect { |s| Soldier.from_str(s, location: location) }
+      board.placement_from_soldiers(soldiers)
+    end
+
+    def candidate_soldiers(piece:, promoted:, place:)
+      piece_key = piece.key
+      soldiers.find_all do |e|
+        true &&
+          e.promoted == promoted &&                                      # 成っているかどうかで絞る
+          e.piece.key == piece_key &&                                    # 同じ種類に絞る
+          e.move_list(container).any? { |e| e.soldier.place == place } && # 目的地に来れる
+          true
+      end
+    end
+
+    concerning :HelperMethods do
+      def judge_key
+        if container.win_player == self
+          :win
+        else
+          :lose
+        end
+      end
+
+      def call_name
+        location.call_name(container.turn_info.handicap?)
+      end
+    end
+
+    def skill_set
+      @skill_set ||= Explain::SkillSet.new
+    end
+    delegate :attack_infos, :defense_infos, to: :skill_set
+
+    def single_clock
+      @single_clock ||= SingleClock.new
+    end
+  end
+end

data/lib/bioshogi/player_executor/base.rb

@@ -0,0 +1,120 @@
+# frozen-string-literal: true
+
+module Bioshogi
+  module PlayerExecutor
+    class Base
+      attr_reader :player
+      attr_reader :source
+      attr_reader :params
+
+      attr_reader :hand
+      attr_reader :drop_hand
+      attr_reader :move_hand
+
+      delegate :board, :piece_box, :container, to: :player
+      delegate :origin_soldier, :captured_soldier, to: :move_hand, allow_nil: true
+      delegate :soldier, to: :hand
+
+      def initialize(player, source, params = {})
+        @player = player
+        @source = source
+        @params = {}.merge(params)
+      end
+
+      def input
+        @input ||= yield_self do
+          md = InputParser.match!(@source)
+          input_adapter_class(md).new(player, md.named_captures.symbolize_keys, @source)
+        end
+      end
+
+      def perform_validations
+        unless container.params[:validate_enable]
+          return
+        end
+
+        input.perform_validations
+        if error = input.errors.first
+          ErrorHandler.new(self, error).call
+        end
+      end
+
+      def execute
+        perform_validations
+
+        # hand.execute で board が変化してしまうため実行するまえに取得しておく
+        # ただし candidate_soldiers は重いので to_ki2 しないのであれば呼ばない方がいい
+        @hand               = input.hand
+        @drop_hand          = input.drop_hand
+        @move_hand          = input.move_hand
+        @candidate_soldiers = nil
+        if container.params[:candidate_enable]
+          @candidate_soldiers = input.candidate_soldiers
+        end
+
+        hand.execute(container)
+        execute_after_process
+        if captured_soldier
+          piece_box_added(captured_soldier)
+        end
+
+        if move_hand
+          move_hand_process(move_hand)
+        end
+
+        perform_skill_monitor
+
+        clock_add_process
+        turn_ended_process
+
+        container.turn_info.turn_offset += 1
+
+        turn_changed_process
+
+        hand
+      end
+
+      def execute_after_process
+      end
+
+      def piece_box_added(captured_soldier)
+      end
+
+      def move_hand_process(move_hand)
+        if move_hand.soldier.piece.key == :king
+          player.king_place = move_hand.soldier.place
+        end
+      end
+
+      def clock_add_process
+      end
+
+      def turn_ended_process
+      end
+
+      def perform_skill_monitor
+      end
+
+      def turn_changed_process
+      end
+
+      private
+
+      def input_adapter_class(md)
+        case
+        when md[:kif_place_from]
+          InputAdapter::KifAdapter
+        when md[:sfen_to]
+          InputAdapter::SfenAdapter
+        when md[:csa_piece]
+          InputAdapter::CsaAdapter
+        else
+          InputAdapter::Ki2Adapter
+        end
+      end
+
+      def skill_set
+      end
+    end
+  end
+end

data/lib/bioshogi/player_executor/brain.rb

@@ -0,0 +1,7 @@
+module Bioshogi
+  module PlayerExecutor
+    # 指し手を保存しない
+    class Brain < Base
+    end
+  end
+end

data/lib/bioshogi/player_executor/error_handler.rb

@@ -0,0 +1,49 @@
+# frozen-string-literal: true
+
+module Bioshogi
+  module PlayerExecutor
+    class ErrorHandler
+      def initialize(context, error)
+        @context = context
+        @error = error
+      end
+
+      def call
+        raise error_object_create
+      end
+
+      private
+
+      def error_object_create
+        @error[:error_class].new(error_message).tap do |e|
+          e.instance_variable_set(:@container, @context.container)
+          e.define_singleton_method(:container) { @container }
+          e.instance_variable_set(:@input, @context.input)
+          e.define_singleton_method(:input) { @input }
+        end
+      end
+
+      def error_message
+        attributes = {
+          "手番"   => @context.player.call_name,
+          "指し手" => @context.input.source,
+          "棋譜"   => @context.container.hand_logs.to_kif_a.join(" "),
+        }
+
+        message = @error[:message]
+
+        # 一行に情報をつめこむ場合
+        if false
+          message = ["[#{@context.player.call_name}][#{@context.container.turn_info.turn_offset.next}手目][#{@context.input.source}]", message].join
+        end
+
+        str = []
+        str << message
+        str.concat(attributes.collect { |*e| e.join(": ") })
+        str << ""
+        str << @context.container.to_bod
+        str = str.collect(&:rstrip).join("\n")
+      end
+    end
+  end
+end

data/lib/bioshogi/player_executor/human.rb

@@ -0,0 +1,8 @@
+module Bioshogi
+  module PlayerExecutor
+    class Human < Base
+      include HandLogsMod
+      include Explain::MonitorMod
+    end
+  end
+end

data/lib/bioshogi/player_executor/without_monitor.rb

@@ -0,0 +1,7 @@
+module Bioshogi
+  module PlayerExecutor
+    class WithoutMonitor < Base
+      include HandLogsMod  # FIXME: 配列ではなく最後の手だけを持ちたい
+    end
+  end
+end