bioshogi 0.0.3

data/lib/bioshogi/input_adapter/shared_validation.rb

@@ -0,0 +1,110 @@
+# frozen-string-literal: true
+
+module Bioshogi
+  module InputAdapter
+    concern :SharedValidation do
+      def hard_validations
+        super
+
+        if move_hand
+          if move_hand.promote_trigger? && origin_soldier.promoted
+            errors_add AlredyPromoted, "成りを明示しましたがすでに成っています"
+          end
+
+          if move_hand.promote_trigger?
+            unless origin_soldier.next_promotable?(place)
+              errors_add NotPromotable, "#{origin_soldier.place}から#{place}への移動では成れません"
+            end
+          end
+
+          if player.location != origin_soldier.location
+            # player.location.name         => ▲
+            # origin_soldier.location.name => △
+            message = []
+            message << "相手の駒を動かそうとしています"
+            message.concat(turn_error_messages)
+            message = message.join("。")
+            errors_add ReversePlayerPieceMoveError, message
+          end
+
+          if s = board.surface[soldier.place]
+            if s.location == player.location
+              errors_add SamePlayerBattlerOverwrideError, "自分の駒を取ろうとしています"
+            end
+          end
+
+          # この検証を外すと次の !candidate_soldiers.include?(move_hand.origin_soldier) の検証にひっかかるので外してもよいけど、
+          # エラーの原因を明確にするために入れてある
+          if !promote_trigger && origin_soldier
+            if origin_soldier.promoted && !promoted
+              errors_add PromotedPieceToNormalPiece, "成った状態から成らない状態に戻れません"
+            end
+          end
+
+          if player.container.params[:validate_warp_skip]
+          else
+            # 初手 "25歩(27)" とした場合
+            unless candidate_soldiers.include?(move_hand.origin_soldier)
+              errors_add SoldierWarpError, "#{move_hand}としましたが#{place_from}から#{place}には移動できません"
+            end
+          end
+        end
+
+        if drop_trigger
+          if board.surface[place]
+            errors_add PieceAlredyExist, "駒の上に打とうとしています"
+          end
+        end
+      end
+
+      def soft_validations
+        super
+
+        if player.container.params[:validate_double_pawn_skip]
+        else
+          if drop_hand
+            if collision_soldier = soldier.collision_pawn(board)
+              errors_add DoublePawnCommonError, "二歩です。すでに#{collision_soldier}があるため#{drop_hand}ができません"
+            end
+          end
+        end
+
+        unless soldier.alive?
+          errors_add DeadPieceRuleError, "#{soldier}は死に駒です。「#{soldier}成」の間違いかもしれません"
+        end
+      end
+
+      def turn_error_messages
+        av = []
+        av << "手番違いかもしれません"
+
+        av << yield_self {
+          m = []
+          m << "#{player.container.turn_info.turn_offset.next}手目は#{player.location.pentagon_mark}の手番ですが"
+          m << "#{player.opponent_player.location.pentagon_mark}が着手しました"
+          m.join
+        }
+
+        if player.container.turn_info.handicap?
+          av << "手合割は「駒落ち」です"
+        end
+
+        if player.container.turn_info.display_turn == 0
+          if player.container.turn_info.handicap?
+            av << "平手で手番のハンデを貰っている場合は☗側が初手を指してください"
+          end
+        end
+
+        if player.container.turn_info.handicap?
+          av << "詰将棋で「上手・下手」の表記を用いている場合は「後手・先手」に直してください"
+        end
+
+        # if player.container.turn_info.display_turn > 0
+        #   av << "将棋倶楽部24の場合、反則(二手指し)による不正な棋譜になっている場合があります"
+        # end
+
+        av
+      end
+    end
+  end
+end

data/lib/bioshogi/input_parser.rb

@@ -0,0 +1,74 @@
+# frozen-string-literal: true
+
+module Bioshogi
+  module InputParser
+    extend self
+
+    def match!(str)
+      md = str.to_s.match(regexp)
+      unless md
+        raise SyntaxDefact, "表記が間違っています : #{str.inspect}"
+      end
+      md
+    end
+
+    def scan(str)
+      str.to_s.scan(regexp).collect(&:join)
+    end
+
+    def slice_one(str)
+      scan(str.to_s).first
+    end
+
+    def regexp
+      @regexp ||= Regexp.union(kif_or_ki2_regexp, csa_regexp, sfen_regexp)
+    end
+
+    private
+
+    def kif_or_ki2_regexp
+      ki2_location = /(?<ki2_location>[#{Location.polygon_chars_str}])/o
+      kif_place = /(?<kif_place>#{Place.regexp})/o
+      ki2_same = /(?<ki2_same>同)\p{blank}*/
+
+      ki2_as_it_is = /(?<ki2_as_it_is>不成|生)/
+      ki2_promote_trigger = /(?<ki2_promote_trigger>成)/
+      kif_drop_trigger = /(?<kif_drop_trigger>[打合])/
+
+      ki2_one_up = /(?<ki2_one_up>直)/
+      ki2_left_right = /(?<ki2_left_right>[左右])/
+      ki2_up_down = /(?<ki2_up_down>[上行引寄])/ # 行は上のalias
+
+      /
+        #{ki2_location}?
+        (#{kif_place}#{ki2_same}|#{ki2_same}#{kif_place}|#{kif_place}|#{ki2_same}) # 12同 or 同12 or 12 or 同 に対応
+        (?<kif_piece>#{Piece.all_names.join("|")})
+        (#{ki2_one_up}|#{ki2_left_right}?#{ki2_up_down}?)?
+        (#{ki2_as_it_is}|#{ki2_promote_trigger}|#{kif_drop_trigger})?
+        (?<kif_place_from>\(\d{2}\))? # scan の結果を join したものがマッチした元の文字列と一致するように () も含める
+      /ox
+    end
+
+    def csa_regexp
+      csa_piece = Piece.flat_map { |e| [e.csa.basic_name, e.csa.promoted_name] }.compact.join("|")
+
+      /
+        (?<csa_sign>[+-])?
+        (?<csa_from>[0-9]{2}) # 00 = 駒台
+        (?<csa_to>[1-9]{2})
+
+        (?<csa_piece>#{csa_piece})
+      /ox
+    end
+
+    def sfen_regexp
+      sfen_drop_piece = Piece.collect(&:sfen_char).compact.join
+      sfen_to = /[1-9][[:lower:]]/
+
+      drop_part = /(?<sfen_drop_piece>[#{sfen_drop_piece}])(?<sfen_drop_trigger>\*)(?<sfen_to>#{sfen_to})/o
+      move_part = /(?<sfen_from>#{sfen_to})(?<sfen_to>#{sfen_to})(?<sfen_promote_trigger>\+)?/o
+
+      /((#{drop_part})|(#{move_part}))/o
+    end
+  end
+end

data/lib/bioshogi/kanji_number.rb

@@ -0,0 +1,128 @@
+if $0 == __FILE__
+  require "active_support/core_ext/module/attribute_accessors"
+end
+
+module Bioshogi
+  module KanjiNumber
+    extend self
+
+    # 100までで良いなら2にしとくと気持ち程度速くなる
+    # 2なら百まで
+    # 3なら千まで
+    # 6なら兆まで
+    mattr_accessor(:unit_size) { 6 }
+
+    # 万(4)を超えたら「万」ではなく「一万」とする
+    mattr_accessor(:one_number_insert_level) { 4 }
+
+    KANJI_TABLE = "〇一二三四五六七八九"
+    UNIT_TABLE  = "十百千万憶兆"
+
+    # KanjiNumber.kanji_to_number_string("")         # => ""
+    # KanjiNumber.kanji_to_number_string("歩")       # => "歩"
+    # KanjiNumber.kanji_to_number_string("歩〇")     # => "歩0"
+    # KanjiNumber.kanji_to_number_string("歩九")     # => "歩9"
+    # KanjiNumber.kanji_to_number_string("歩十")     # => "歩10"
+    # KanjiNumber.kanji_to_number_string("歩十〇")   # => "歩10"
+    # KanjiNumber.kanji_to_number_string("歩十一")   # => "歩11"
+    # KanjiNumber.kanji_to_number_string("歩十九")   # => "歩19"
+    # KanjiNumber.kanji_to_number_string("歩二十")   # => "歩20"
+    # KanjiNumber.kanji_to_number_string("歩二十〇") # => "歩20"
+    # KanjiNumber.kanji_to_number_string("歩二十一") # => "歩21"
+    #
+    # https://qiita.com/alfa/items/24611f664949709f530d
+    # http://d.hatena.ne.jp/rubikitch/20081201/1228142072
+    def kanji_to_number_string(str)
+      s = str.tr(KANJI_TABLE, "0-9")
+      unit_size.times do |i|
+        s = s.gsub(/(?<number>\d+)?(?<unit>#{UNIT_TABLE[i]})(?<rest>\d+)?/) do |s| # ブロック引数に md がきてほしい
+          md = Regexp.last_match
+          v = (md[:number] || 1).to_i * 10**(i+1)
+          v + md[:rest].to_i
+        end
+      end
+      s
+    end
+
+    # KanjiNumber.number_to_kanji(0)  # => "〇"
+    # KanjiNumber.number_to_kanji(1)  # => "一"
+    # KanjiNumber.number_to_kanji(10) # => "十"
+    # KanjiNumber.number_to_kanji(12) # => "十二"
+    # KanjiNumber.number_to_kanji(2)  # => "二"
+    # KanjiNumber.number_to_kanji(23) # => "二十三"
+    def number_to_kanji(v)
+      out = []
+      unit_size.step(by: -1, to: 1).each do |x|
+        s = UNIT_TABLE[x - 1]
+        d = 10**x
+        q, r = v.divmod(d)
+        case
+        when q == 1
+          if x >= one_number_insert_level
+            out << KANJI_TABLE[q] + s # "万" はおかしいので "一万" とする
+          else
+            out << s                  # "百" はおかしくないので "一" を入れない
+          end
+        when q >= 2
+          out << KANJI_TABLE[q] + s   # 2以上は "二百" とする
+        end
+        v = r
+      end
+      if v == 0 && out.empty?
+        out << KANJI_TABLE[v]   # ここをはずせば 0 のとき表示しない。「零」などに変更も可
+      elsif v >= 1
+        out << KANJI_TABLE[v]
+      end
+      out.join
+    end
+
+    def regexp
+      /[#{UNIT_TABLE}#{KANJI_TABLE}]+/o
+    end
+
+    def extract(s, &block)
+      s.scan(regexp, &block)
+    end
+  end
+
+  if $0 == __FILE__
+    KanjiNumber.kanji_to_number_string("")               # => ""
+    KanjiNumber.kanji_to_number_string("歩")             # => "歩"
+    KanjiNumber.kanji_to_number_string("歩〇")           # => "歩0"
+    KanjiNumber.kanji_to_number_string("歩九")           # => "歩9"
+    KanjiNumber.kanji_to_number_string("歩十")           # => "歩10"
+    KanjiNumber.kanji_to_number_string("歩十〇")         # => "歩10"
+    KanjiNumber.kanji_to_number_string("歩十一")         # => "歩11"
+    KanjiNumber.kanji_to_number_string("歩十九")         # => "歩19"
+    KanjiNumber.kanji_to_number_string("歩二十")         # => "歩20"
+    KanjiNumber.kanji_to_number_string("歩二十〇")       # => "歩20"
+    KanjiNumber.kanji_to_number_string("歩二十一")       # => "歩21"
+    KanjiNumber.kanji_to_number_string("歩百二十三")     # => "歩123"
+    KanjiNumber.kanji_to_number_string("歩千二百三十四") # => "歩1234"
+
+    KanjiNumber.kanji_to_number_string("歩十")           # => "歩10"
+    KanjiNumber.kanji_to_number_string("歩百")           # => "歩100"
+    KanjiNumber.kanji_to_number_string("歩千")           # => "歩1000"
+    KanjiNumber.kanji_to_number_string("歩1万")          # => "歩10000"
+    KanjiNumber.kanji_to_number_string("歩1憶")          # => "歩100000"
+    KanjiNumber.kanji_to_number_string("歩1兆")          # => "歩1000000"
+
+    KanjiNumber.number_to_kanji(0)                      # => "〇"
+    KanjiNumber.number_to_kanji(1)                      # => "一"
+    KanjiNumber.number_to_kanji(10)                     # => "十"
+    KanjiNumber.number_to_kanji(12)                     # => "十二"
+    KanjiNumber.number_to_kanji(2)                      # => "二"
+    KanjiNumber.number_to_kanji(23)                     # => "二十三"
+    KanjiNumber.number_to_kanji(123)                    # => "百二十三"
+    KanjiNumber.number_to_kanji(120)                    # => "百二十"
+    KanjiNumber.number_to_kanji(100)                    # => "百"
+    KanjiNumber.number_to_kanji(1000)                   # => "千"
+    KanjiNumber.number_to_kanji(10000)                  # => "一万"
+    KanjiNumber.number_to_kanji(100000)                 # => "一憶"
+    KanjiNumber.number_to_kanji(1000000)                # => "一兆"
+    KanjiNumber.number_to_kanji(1234.5678)              # => "千二百三十四"
+
+    KanjiNumber.extract("歩百二十三") # => ["百二十三"]
+    KanjiNumber.regexp                # => /[十百千万憶兆〇一二三四五六七八九]+/
+  end
+end

data/lib/bioshogi/kifu_format_info.rb

@@ -0,0 +1,15 @@
+module Bioshogi
+  class KifuFormatInfo
+    include ApplicationMemoryRecord
+    memory_record [
+      { key: "kif",  },
+      { key: "ki2",  },
+      { key: "csa",  },
+      { key: "sfen", },
+    ]
+
+    def name
+      @name ||= key.to_s.upcase
+    end
+  end
+end

data/lib/bioshogi/location.rb

@@ -0,0 +1,131 @@
+# frozen-string-literal: true
+#
+# 上下のみを表わす
+#
+# - 先手後手というのは平手の場合だけの名称
+# - 駒落ちなら、まず名称が上手下手に代わり、もともと後手と呼ばれていた上側が先に指す
+# - 先手というのが「先に指す」という意味で使われるなら「先手」は位置を特定できない。駒落ちなら△で、平手なら▲になる。
+# - だから上下の位置を表わすのに先手後手の名前を使うのはまちがい
+# - 上下は△▲だけに対応する
+#
+module Bioshogi
+  class Location
+    include ApplicationMemoryRecord
+    memory_record [
+      { key: :black, name: "▲", pentagon_mark: "☗", equality_name: "先手", handicap_name: "下手", equality_yomiage: "先手", handicap_yomiage: "したて", flip_mark: "▼", varrow: " ", csa_sign: "+", angle: 0,   other_match_chars: ["☗"], to_sfen: "b", normalize_key: :itself, value_sign: +1, checkmate_yomiage: "せめかた",  },
+      { key: :white, name: "△", pentagon_mark: "☖", equality_name: "後手", handicap_name: "上手", equality_yomiage: "後手", handicap_yomiage: "うわて", flip_mark: "▽", varrow: "v", csa_sign: "-", angle: 180, other_match_chars: ["☖"], to_sfen: "w", normalize_key: :flip,   value_sign: -1, checkmate_yomiage: "gyokugata", },
+    ]
+
+    class << self
+      # lookup(-1).key     # => :white
+      # lookup(:white).key # => :white
+      def lookup(value)
+        v = super
+
+        unless v
+          if value.kind_of?(Integer)
+            v = lookup(value.modulo(count))
+          end
+        end
+
+        unless v
+          v = find { |e| e.match_target_values_set.include?(value) }
+        end
+
+        v
+      end
+
+      def polygon_chars_str
+        @polygon_chars_str ||= flat_map { |e| [e.mark, e.flip_mark, e.pentagon_mark] }.join
+      end
+
+      # b w とかではなく sfen の駒の文字の大文字小文字で判断する
+      # だから v をキーにしたテーブルにするのはやめたほうがいい
+      def fetch_by_sfen_char(ch)
+        if ch.match?(/[[:upper:]]/)
+          self[:black]
+        else
+          self[:white]
+        end
+      end
+
+      def call_names
+        @call_names ||= flat_map(&:call_names)
+      end
+    end
+
+    def call_names
+      [equality_name, handicap_name]
+    end
+
+    def call_name(handicap)
+      public_send(call_name_method_name(handicap))
+    end
+
+    def yomiage(handicap)
+      if handicap
+        handicap_yomiage
+      else
+        equality_yomiage
+      end
+    end
+
+    def mark
+      name
+    end
+
+    def black?
+      key == :black
+    end
+
+    def white?
+      key == :white
+    end
+
+    def which_value(a, b)
+      black? ? a : b
+    end
+
+    def flip
+      @flip ||= self.class.fetch(code.next.modulo(self.class.count))
+    end
+
+    alias next_location flip
+
+    def match_target_values_set
+      @match_target_values_set ||= [
+        key,
+        mark,
+        flip_mark,
+        pentagon_mark,
+        other_match_chars,
+        to_sfen,
+        name,
+        name.chars.first,
+        code,
+        varrow,
+        csa_sign,
+        equality_name,
+        handicap_name,
+      ].flatten.compact.to_set
+    end
+
+    # FIXME: とる
+    # HTMLにするとき楽なように後手なら transform: rotate(180deg) を返す
+    def style_transform
+      if angle.nonzero?
+        "transform: rotate(#{angle}deg)"
+      end
+    end
+
+    private
+
+    def call_name_method_name(handicap)
+      if handicap
+        :handicap_name
+      else
+        :equality_name
+      end
+    end
+  end
+end

data/lib/bioshogi/logger.rb

@@ -0,0 +1,5 @@
+# frozen-string-literal: true
+
+module Bioshogi
+  mattr_accessor(:logger) { ActiveSupport::TaggedLogging.new(ActiveSupport::Logger.new(File::NULL)) }
+end

data/lib/bioshogi/main_clock.rb

@@ -0,0 +1,21 @@
+module Bioshogi
+  class MainClock
+    def initialize
+      @single_clocks = Location.inject({}) { |a, e| a.merge(e => SingleClock.new) }
+      @counter = 0
+    end
+
+    def add(v)
+      @single_clocks[Location[@counter]].add(v)
+      @counter += 1
+    end
+
+    def last_clock
+      @single_clocks[Location[@counter.pred]]
+    end
+
+    def to_s
+      last_clock.to_s
+    end
+  end
+end

data/lib/bioshogi/media.rb

@@ -0,0 +1,85 @@
+module Bioshogi
+  module Media
+    extend self
+
+    def duration(file)
+      info = JSON.parse(`ffprobe -v warning -print_format json -show_entries format=duration #{file}`)
+      info["format"]["duration"].to_f
+    end
+
+    # def video_bit_rate(file)
+    #   info = JSON.parse(`ffprobe -v warning -print_format json -show_entries format=bit_rate #{file}`)
+    #   info["format"]["bit_rate"].to_f
+    # end
+
+    def as_json(file)
+      JSON.parse(`ffprobe -v quiet -print_format json -show_streams #{file}`)
+    end
+
+    def streams(file)
+      attrs = as_json(file).deep_symbolize_keys
+      attrs[:streams]
+    end
+
+    def pretty_inspect(file)
+      JSON.parse(`ffprobe -v warning -pretty -print_format json -show_streams #{file}`)
+    end
+
+    def inspect(file)
+      `ffprobe -hide_banner #{file} 2>&1 | grep Stream`
+    end
+
+    def p(file)
+      puts inspect(file)
+    end
+
+    def format(file)
+      JSON.parse(`ffprobe -v warning -pretty -print_format json -show_format #{file}`)["format"]
+    end
+
+    def tags(file)
+      format(file)["tags"]
+    end
+
+    def video_inspect(file)
+      info = pretty_inspect(file)
+      info["streams"].find { |e| e["codec_type"] == "video" }
+    end
+
+    def video_bit_rate(file)
+      if e = video_inspect(file)
+        e["bit_rate"]
+      end
+    end
+
+    def audio_inspect(file)
+      info = pretty_inspect(file)
+      info["streams"].find { |e| e["codec_type"] == "audio" }
+    end
+
+    def audio_bit_rate(file)
+      if e = audio_inspect(file)
+        e["bit_rate"]
+      end
+    end
+
+    # [Parsed_volumedetect_0 @ 0x7fd26b623100] n_samples: 423808
+    # [Parsed_volumedetect_0 @ 0x7fd26b623100] mean_volume: -16.1 dB
+    # [Parsed_volumedetect_0 @ 0x7fd26b623100] max_volume: -0.1 dB
+    # [Parsed_volumedetect_0 @ 0x7fd26b623100] histogram_0db: 44
+    # [Parsed_volumedetect_0 @ 0x7fd26b623100] histogram_1db: 71
+    # [Parsed_volumedetect_0 @ 0x7fd26b623100] histogram_2db: 71
+    # [Parsed_volumedetect_0 @ 0x7fd26b623100] histogram_3db: 242
+    def volume_info(file)
+      `ffmpeg -hide_banner -i #{file} -vn -af volumedetect -f null - 2>&1`
+    end
+
+    # あとどれだけボリュームを上げられるか
+    # [Parsed_volumedetect_0 @ 0x7fd26b623100] max_volume: -0.1 dB
+    # であれば 0.1 上げられる
+    def enough_volume(file)
+      md = volume_info(file).match(/max_volume:\s*(\S+)/)
+      md.captures.first.to_f * -1
+    end
+  end
+end