bioshogi 0.0.3

data/lib/bioshogi/parser/header.rb

@@ -0,0 +1,82 @@
+module Bioshogi
+  module Parser
+    class Header
+      delegate :[], :to_h, :delete, :has_key?, to: :object
+
+      attr_accessor :object
+
+      def initialize(*args)
+        @object = Hash[*args]
+      end
+
+      def []=(key, value)
+        if v = normalize_value(value).presence
+          object[key] = v
+        end
+      end
+
+      def inspect
+        object.to_t.strip
+      end
+
+      def clone
+        self.class.new(object.clone)
+      end
+
+      def normalize
+        time_normalize
+        piece_normalize
+      end
+
+      private
+
+      def time_normalize
+        object.each do |key, value|
+          if key.match?(/日時?\z/) # "開始日" や "開始日時"
+            if v = value.presence
+              t = TimeParser.new(v).to_time
+              if t
+                format = "%Y/%m/%d"
+                if false
+                  if key.match?(/時\z/)
+                    format = "#{format} %T"
+                  end
+                else
+                  if t.hour == 0 && t.min == 0 && t.sec == 0
+                  else
+                    format = "#{format} %T"
+                  end
+                end
+                object[key] = t.strftime(format)
+              end
+            end
+          end
+        end
+      end
+
+      def piece_normalize
+        Location.each do |e|
+          e.call_names.each do |e|
+            key = "#{e}の持駒"
+            if v = object[key].presence
+              v = Piece.s_to_a(v)
+              v = Piece.a_to_s(v, ordered: true, separator: " ")
+              if v.present?
+                object[key] = v
+              else
+                object.delete(key)
+              end
+            end
+          end
+        end
+      end
+
+      def normalize_value(s)
+        s = s.gsub(/\p{blank}+/, " ")
+        s = s.tr("ａ-ｚＡ-Ｚ０-９", "a-zA-Z0-9")
+        s = s.strip
+        s
+      end
+    end
+  end
+end

data/lib/bioshogi/parser/inspector.rb

@@ -0,0 +1,47 @@
+module Bioshogi
+  module Parser
+    class Inspector
+      def initialize(parser)
+        @parser = parser
+      end
+
+      def inspect
+        av = []
+
+        if @parser.pi.board_source
+          av << "* pi.board_source"
+          av << @parser.pi.board_source.strip
+          av << " "
+        end
+
+        av << "* attributes"
+        av << {
+          :force_preset_info => @parser.pi.force_preset_info,
+          :force_location    => @parser.pi.force_location,
+          :force_handicap    => @parser.pi.force_handicap,
+        }.to_t.strip
+        av << " "
+
+        av << "* pi.header"
+        av << @parser.pi.header.inspect.strip
+        av << " "
+
+        if @parser.pi.board_source
+          av << "* @parser.pi.board_source"
+          av << @parser.pi.board_source.strip
+          av << " "
+        end
+
+        av << "* pi.move_infos"
+        av << @parser.pi.move_infos.to_t.strip
+        av << " "
+
+        av << "* @parser.pi.last_action_params"
+        av << @parser.pi.last_action_params.to_t.strip
+        av << " "
+
+        av.join("\n").strip
+      end
+    end
+  end
+end

data/lib/bioshogi/parser/kakinoki_methods.rb

@@ -0,0 +1,125 @@
+module Bioshogi
+  module Parser
+    # kif, ki2, bod に関係する処理だけ書くこと(重要)
+    # 間違って pi.header.rb に書いてしまってるのはどんどんこっちに移動させること
+    # pi.header.rb は CSA から見て不要なものが入っていてはいけない
+    concern :KakinokiMethods do
+      SYSTEM_COMMENT_CHAR        = "#"
+      KEY_VALUE_SEPARATOR        = "："
+
+      BOARD_REGEXP               = /(?<board>^\+\-.*\-\+$)/m
+      COMMENT_REGEXP             = /^\p{blank}*\*\p{blank}*(?<comment>.*)/
+      KEY_VALUE_REGEXP           = /^\s*([^#{KEY_VALUE_SEPARATOR}\n]+)#{KEY_VALUE_SEPARATOR}(.*)$/o
+      SYSTEM_COMMENT_LINE_REGEXP = /^\s*#{SYSTEM_COMMENT_CHAR}.*(\R|$)/o
+      HEADER_BODY_SEP_REGEXP     = /手数-+指手-+消費時間/
+      HEADER_PART_REGEXP         = /(?<header_dirty_part>.*?)^(#{HEADER_BODY_SEP_REGEXP}|[▲△☗☖▼▽]|まで)/mo
+
+      def parse
+        header_extract          # ヘッダー部分だけを抽出して扱いやすいテキストにする
+        key_value_store         # ヘッダーのキーと値のペアをとりあえず取り込む
+        unnecessary_keys_remove # 不要なキーの削除
+        player_piece_read       # そこから持駒の読み取る
+        force_preset_read       # 明示的な手合割の指定があれば読み取る (駒落ちモードに移行するのはここからだけ)
+        force_location_read     # 明示的な手番の指定があれば読み取る (あとでベースを切り替える)
+        kknk_board_read         # 盤面の読み取り
+        body_parse              # 指し手の読み取り
+        pi.header.normalize        # ヘッダーの書き換え
+      end
+
+      def kknk_board_read
+        if md = normalized_source.match(BOARD_REGEXP)
+          @pi.board_source = md[:board]
+          @pi.force_preset_info ||= Board.guess_preset_info(@pi.board_source)
+        end
+      end
+
+      def kknk_comment_read(line)
+        if md = line.match(COMMENT_REGEXP)
+          if @pi.move_infos.empty?
+            first_comments_add(md[:comment])
+          else
+            command_add(md[:comment])
+          end
+        end
+      end
+
+      private
+
+      def body_part
+        @body_part ||= yield_self do
+          # 激指で作った分岐対応KIFを読んだ場合「変化：8手」のような文字列が来た時点で打ち切る
+          normalized_source.remove(/^\p{blank}*変化：.*/m)
+        end
+      end
+
+      def header_extract
+        @kknk_head = normalized_source
+
+        # 厳密ではないけど上部に絞る
+        if md = @kknk_head.match(HEADER_PART_REGEXP)
+          @kknk_head = md[:header_dirty_part]
+        end
+
+        # 扱いやすいように全角スペースを半角化
+        @kknk_head = @kknk_head.gsub(/\p{blank}+/, " ")
+
+        # システムコメント行を削除
+        @kknk_head = @kknk_head.remove(SYSTEM_COMMENT_LINE_REGEXP)
+      end
+
+      # 2020-11-16
+      # ヘッダーは自由にカスタマイズできるのに何かのソフトの都合で受け入れられないキーワードがある
+      # そのため "*キー：値" のように * でコメントアウトしてヘッダーを入れている場合がある
+      # なので * を外して取り込むようにした
+      # しかし、受け入れないソフトがいるためアスタリスク込みで取り込むことにする
+      def key_value_store
+        # "foo\nbar:1".scan(/^([^:\n]+):(.*)/).to_a # => [["bar", "1"]]
+        @kknk_head.scan(KEY_VALUE_REGEXP).each do |key, value|
+          pi.header[key.strip] = value.strip
+        end
+      end
+
+      def unnecessary_keys_remove
+        pi.header.object.delete("変化")
+      end
+
+      def player_piece_read
+        Location.each do |e|
+          if v = e.call_names.collect { |e| pi.header["#{e}の持駒"] }.join.presence
+            @pi.player_piece_boxes[e.key].set(Piece.s_to_h(v))
+          end
+        end
+      end
+
+      def force_location_read
+        Location.each do |location|
+          if location.call_names.any? { |name| normalized_source.match?(/^#{name}番/) }
+            @pi.force_location = location
+            break
+          end
+        end
+      end
+
+      def force_preset_read
+        if v = pi.header["手合割"]
+          if e = PresetInfo[v]
+            @pi.force_preset_info = e
+            if e.handicap
+              @pi.force_handicap = e.handicap
+            end
+          end
+        end
+      end
+
+      def first_comments_add(comment)
+        @pi.first_comments << comment
+      end
+
+      # コメントは直前の棋譜の情報と共にする
+      def command_add(comment)
+        @pi.move_infos.last[:comments] ||= []
+        @pi.move_infos.last[:comments] << comment
+      end
+    end
+  end
+end

data/lib/bioshogi/parser/ki2_parser.rb

@@ -0,0 +1,39 @@
+# frozen-string-literal: true
+module Bioshogi
+  module Parser
+    class Ki2Parser < Base
+      include KakinokiMethods
+
+      ACCEPT_REGEXP = /^\p{blank}*(#{InputParser.regexp}|.*：.*)/o
+      MOVE_REGEXP   = /^\p{blank}*#{InputParser.regexp}/o
+
+      class << self
+        def accept?(source)
+          str = Source.wrap(source).to_s
+          if str.present?
+            if !KifParser.accept?(str) && !CsaParser.accept?(str)
+              str.match?(ACCEPT_REGEXP) || BoardParser::KakinokiBoardParser.accept?(str)
+            end
+          end
+        end
+      end
+
+      private
+
+      def body_parse
+        body_part.lines.each do |line|
+          kknk_comment_read(line)
+          if line.match?(MOVE_REGEXP)
+            @pi.move_infos += InputParser.scan(line).collect do |e|
+              { input: e }
+            end
+          end
+        end
+
+        if body_part.match?(/^まで\d+手で千日手/)
+          @pi.last_action_params = { last_action_key: "SENNICHITE" }
+        end
+      end
+    end
+  end
+end

data/lib/bioshogi/parser/kif_parser.rb

@@ -0,0 +1,60 @@
+# frozen-string-literal: true
+module Bioshogi
+  module Parser
+    class KifParser < Base
+      include KakinokiMethods
+
+      TURN_REGEXP    = /^\p{blank}*(?<turn_number>\d+)\p{blank}+/ # 後ろにスペースを含むこと
+      TIME_REGEXP    = /\p{blank}*(\(\p{blank}*(?<clock_part>.*)\))/
+      MOVE_REGEXP    = /#{TURN_REGEXP}(?<input>#{InputParser.regexp})#{TIME_REGEXP}?/o
+      LAST1_REGEXP   = /#{TURN_REGEXP}(?<last_action_key>.+)#{TIME_REGEXP}/o
+      LAST2_REGEXP   = /#{TURN_REGEXP}(?<last_action_key>.+)/o
+      LAST_REGEXP    = Regexp.union(LAST1_REGEXP, LAST2_REGEXP)
+      MIN_SEC_REGEXP = /(?<min>\d+):(?<sec>\d+)/
+
+      class << self
+        def accept?(source)
+          str = Source.wrap(source).to_s
+          str.match?(HEADER_BODY_SEP_REGEXP) || str.match?(MOVE_REGEXP) || str.match?(LAST_REGEXP)
+        end
+      end
+
+      private
+
+      def body_parse
+        body_part.lines.each do |line|
+          kknk_comment_read(line)
+          case
+          when md = line.match(MOVE_REGEXP)
+            input = md[:input].remove(/\p{blank}/)
+            used_seconds = min_sec_str_to_seconds(md[:clock_part])
+            @pi.move_infos << {
+              :turn_number  => md[:turn_number],
+              :input        => input,
+              :clock_part   => md[:clock_part],
+              :used_seconds => used_seconds,
+            }
+          when md = line.match(LAST_REGEXP)
+            last_action_key = md[:last_action_key].strip
+            if last_action_key.present?
+              used_seconds = min_sec_str_to_seconds(md[:clock_part])
+              @pi.last_action_params = {
+                :turn_number     => md[:turn_number],
+                :last_action_key => last_action_key,
+                :used_seconds    => used_seconds,
+              }
+            end
+          end
+        end
+      end
+
+      def min_sec_str_to_seconds(s)
+        if s.present?
+          if md = s.match(MIN_SEC_REGEXP)
+            md[:min].to_i.minutes + md[:sec].to_i.seconds
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bioshogi/parser/pi.rb

@@ -0,0 +1,45 @@
+# frozen-string-literal: true
+
+module Bioshogi
+  module Parser
+    class Pi
+      # 読み取り結果
+      attr_accessor :move_infos
+      attr_accessor :first_comments
+      attr_accessor :board_source
+      attr_accessor :last_action_params
+      attr_accessor :header
+      attr_accessor :force_preset_info
+      attr_accessor :force_location
+      attr_accessor :force_handicap
+      attr_accessor :player_piece_boxes
+      attr_accessor :sfen_info
+
+      # 変換時に必要なもの
+      attr_accessor :error_message
+
+      def initialize
+        @move_infos         = []
+        @first_comments     = []
+        @board_source       = nil
+        @last_action_params = nil
+        @header             = Header.new
+        @force_preset_info  = nil
+        @force_location     = nil
+        @force_handicap     = nil
+        @player_piece_boxes = Location.inject({}) { |a, e| a.merge(e.key => PieceBox.new) }
+        @error_message      = nil
+        @sfen_info          = nil
+      end
+
+      def clock_exist?
+        return @clock_exist if instance_variable_defined?(:@clock_exist)
+        @clock_exist ||= @move_infos.any? { |e| e[:used_seconds].to_i.nonzero? }
+      end
+
+      def clock_nothing?
+        !clock_exist?
+      end
+    end
+  end
+end

data/lib/bioshogi/parser/sfen_parser.rb

@@ -0,0 +1,26 @@
+# frozen-string-literal: true
+
+module Bioshogi
+  module Parser
+    class SfenParser < Base
+      class << self
+        def accept?(source)
+          str = Source.wrap(source).to_s
+          str.match?(/^(?:position|sfen)\b/i) || (str.lines.one? && Sfen.accept?(str))
+        end
+      end
+
+      def parse
+        @pi.sfen_info      = Sfen.parse(normalized_source)
+        @pi.move_infos     = @pi.sfen_info.move_infos
+        @pi.force_handicap = @pi.sfen_info.handicap?
+
+        @pi.sfen_info.piece_counts.each do |location_key, counts|
+          location = Location.fetch(location_key)
+          name = location.call_name(@pi.sfen_info.handicap?)
+          @pi.header["#{name}の持駒"] = Piece.h_to_s(counts)
+        end
+      end
+    end
+  end
+end

data/lib/bioshogi/parser/time_parser.rb

@@ -0,0 +1,24 @@
+module Bioshogi
+  module Parser
+    class TimeParser
+      def initialize(time_str)
+        @time_str = time_str
+      end
+
+      def to_time
+        case_a || case_b
+      end
+
+      private
+
+      def case_a
+        Time.parse(@time_str) rescue nil
+      end
+
+      def case_b
+        values = @time_str.scan(/\d+/).collect(&:to_i)
+        Time.local(*values) rescue nil
+      end
+    end
+  end
+end

data/lib/bioshogi/parser.rb

@@ -0,0 +1,40 @@
+# frozen-string-literal: true
+
+module Bioshogi
+  module Parser
+    extend self
+
+    # 担当するクラス
+    def accepted_class(source)
+      source = Source.wrap(source)
+      support_parsers.find { |e| e.accept?(source) }
+    end
+
+    # 棋譜ファイルのコンテンツを読み込む
+    def parse(source, options = {})
+      source = Source.wrap(source)
+      parser = accepted_class(source)
+      unless parser
+        raise FileFormatError, "棋譜のフォーマットが不明です : #{source}"
+      end
+      parser.parse(source, options)
+    end
+
+    # 棋譜ファイル自体を読み込む
+    def file_parse(file, options = {})
+      parse(Pathname(file).expand_path.read, options)
+    end
+
+    private
+
+    def support_parsers
+      [
+        SfenParser,
+        KifParser,
+        CsaParser,
+        Ki2Parser,
+        BodParser,
+      ]
+    end
+  end
+end

data/lib/bioshogi/piece/ek_score_info.rb

@@ -0,0 +1,22 @@
+# frozen-string-literal: true
+
+module Bioshogi
+  class Piece
+    class EkScoreInfo
+      N_SOLIDIERS_IN_OPPONENT_AREA_WITHOUT_KING = 10 # 玉を除く駒が何枚以上相手陣に入っていればよい
+
+      include ApplicationMemoryRecord
+      memory_record [
+        # https://www.shogi.or.jp/faq/amature-kitei.html
+        { key: :king,   ek_score: 0, },
+        { key: :rook,   ek_score: 5, },
+        { key: :bishop, ek_score: 5, },
+        { key: :gold,   ek_score: 1, },
+        { key: :silver, ek_score: 1, },
+        { key: :knight, ek_score: 1, },
+        { key: :lance,  ek_score: 1, },
+        { key: :pawn,   ek_score: 1, },
+      ]
+    end
+  end
+end

data/lib/bioshogi/piece/piece_csa.rb

@@ -0,0 +1,31 @@
+# frozen-string-literal: true
+
+module Bioshogi
+  class Piece
+    class PieceCsa
+      include ApplicationMemoryRecord
+      memory_record [
+        { key: :king,   basic_name: "OU", promoted_name: nil,  },
+        { key: :rook,   basic_name: "HI", promoted_name: "RY", },
+        { key: :bishop, basic_name: "KA", promoted_name: "UM", },
+        { key: :gold,   basic_name: "KI", promoted_name: nil,  },
+        { key: :silver, basic_name: "GI", promoted_name: "NG", },
+        { key: :knight, basic_name: "KE", promoted_name: "NK", },
+        { key: :lance,  basic_name: "KY", promoted_name: "NY", },
+        { key: :pawn,   basic_name: "FU", promoted_name: "TO", },
+      ]
+
+      def piece
+        Piece.fetch(key)
+      end
+
+      def any_name(promoted)
+        if promoted
+          promoted_name
+        else
+          basic_name
+        end
+      end
+    end
+  end
+end

data/lib/bioshogi/piece/piece_pressure.rb

@@ -0,0 +1,23 @@
+# frozen-string-literal: true
+
+module Bioshogi
+  class Piece
+    class PiecePressure
+      include ApplicationMemoryRecord
+      memory_record [
+        { key: :king,   attack_level: 4, promoted_attack_level: nil, defense_level: 0, promoted_defense_level:   0, standby_level: 0, },
+        { key: :rook,   attack_level: 4, promoted_attack_level: 5,   defense_level: 1, promoted_defense_level:   1, standby_level: 3, },
+        { key: :bishop, attack_level: 3, promoted_attack_level: 4,   defense_level: 0, promoted_defense_level:   2, standby_level: 2, },
+        { key: :gold,   attack_level: 3, promoted_attack_level: nil, defense_level: 1, promoted_defense_level: nil, standby_level: 2, },
+        { key: :silver, attack_level: 3, promoted_attack_level: 3,   defense_level: 1, promoted_defense_level:   1, standby_level: 2, },
+        { key: :knight, attack_level: 2, promoted_attack_level: 3,   defense_level: 0, promoted_defense_level:   1, standby_level: 1, },
+        { key: :lance,  attack_level: 1, promoted_attack_level: 3,   defense_level: 0, promoted_defense_level:   1, standby_level: 1, },
+        { key: :pawn,   attack_level: 1, promoted_attack_level: 3,   defense_level: 0, promoted_defense_level:   1, standby_level: 0, },
+      ]
+
+      def piece
+        Piece.fetch(key)
+      end
+    end
+  end
+end

data/lib/bioshogi/piece/piece_scale.rb

@@ -0,0 +1,19 @@
+# frozen-string-literal: true
+
+module Bioshogi
+  class Piece
+    class PieceScale
+      include ApplicationMemoryRecord
+      memory_record [
+        { key: :king,   scale: 1.00, },
+        { key: :rook,   scale: 1.00, },
+        { key: :bishop, scale: 1.00, },
+        { key: :gold,   scale: 0.97, },
+        { key: :silver, scale: 0.94, },
+        { key: :knight, scale: 0.91, },
+        { key: :lance,  scale: 0.88, },
+        { key: :pawn,   scale: 0.85, },
+      ]
+    end
+  end
+end

data/lib/bioshogi/piece/piece_score.rb

@@ -0,0 +1,31 @@
+# frozen-string-literal: true
+
+module Bioshogi
+  class Piece
+    class PieceScore
+      include ApplicationMemoryRecord
+      memory_record [
+        { key: :king,   basic_weight: 40000, promoted_weight: 0,    hold_weight: 40000, },
+        { key: :rook,   basic_weight:  2000, promoted_weight: 2200, hold_weight:  2100, },
+        { key: :bishop, basic_weight:  1800, promoted_weight: 2000, hold_weight:  1890, },
+        { key: :gold,   basic_weight:  1200, promoted_weight: 0,    hold_weight:  1260, },
+        { key: :silver, basic_weight:  1000, promoted_weight: 1200, hold_weight:  1050, },
+        { key: :knight, basic_weight:   700, promoted_weight: 1200, hold_weight:   735, },
+        { key: :lance,  basic_weight:   600, promoted_weight: 1200, hold_weight:   630, },
+        { key: :pawn,   basic_weight:   100, promoted_weight: 1200, hold_weight:   105, },
+      ]
+
+      def piece
+        Piece.fetch(key)
+      end
+
+      def any_weight(promoted)
+        if promoted
+          promoted_weight
+        else
+          basic_weight
+        end
+      end
+    end
+  end
+end