bioshogi 0.0.3

data/lib/bioshogi/simulator.rb

@@ -0,0 +1,44 @@
+# frozen-string-literal: true
+
+module Bioshogi
+  class Simulator
+    def self.run(...)
+      new(...).tap(&:run)
+    end
+
+    attr_accessor :container
+    attr_accessor :attributes
+    attr_accessor :snapshots
+
+    def initialize(attributes)
+      @attributes = attributes
+      @container = Container::Basic.new
+      @snapshots = []
+    end
+
+    def run(&block)
+      container.board.placement_from_any(attributes[:board])
+
+      if v = attributes[:pieces]
+        Location.each do |e|
+          if str = v[e.key]
+            container.player_at(e).pieces_add(str)
+          end
+        end
+      end
+
+      snapshots << container.deep_dup
+      if block
+        yield snapshots.last
+      end
+      InputParser.scan(attributes[:execute]).each do |str|
+        container.execute(str)
+        snapshots << container.deep_dup
+        if block
+          yield snapshots.last
+        end
+      end
+      snapshots
+    end
+  end
+end

data/lib/bioshogi/single_clock.rb

@@ -0,0 +1,36 @@
+# frozen-string-literal: true
+
+module Bioshogi
+  class SingleClock
+    attr_reader :total_seconds
+    attr_reader :used_seconds
+
+    def initialize
+      @total_seconds = 0
+      @used_seconds = 0
+    end
+
+    def add(v)
+      v = v.to_i
+      if v.negative?
+        # 将棋ウォーズの棋譜はまれにマイナスの消費時間が存在してこれになる
+        raise TimeMinusError, "消費時間がマイナスになっています : #{v}"
+      end
+      @total_seconds += v
+      @used_seconds = v
+    end
+
+    def to_s
+      h, r = @total_seconds.divmod(1.hour)
+      m, s = r.divmod(1.minute)
+      "(%02d:%02d/%02d:%02d:%02d)" % [*@used_seconds.divmod(1.minute), h, m, s]
+    end
+
+    def to_h
+      {
+        :total_seconds => total_seconds,
+        :used_seconds => used_seconds,
+      }
+    end
+  end
+end

data/lib/bioshogi/soldier.rb

@@ -0,0 +1,293 @@
+# -*- coding: utf-8; compile-command: "bundle execute rspec ../../spec/soldier_spec.rb" -*-
+# frozen-string-literal: true
+
+module Bioshogi
+  class Soldier
+    class << self
+      def from_str(str, attributes = {})
+        if str.kind_of?(self)
+          return str
+        end
+
+        md = str.match(/\A(?<location>[#{Location.polygon_chars_str}])?(?<place>..)(?<piece>#{Piece.all_names.join("|")})\z/o)
+        md or raise SyntaxDefact, "表記が間違っています。'６八銀' や '68銀' のように1つだけ入力してください : #{str.inspect}"
+
+        location = nil
+        if v = md[:location]
+          location = Location[v]
+        end
+        if v = attributes[:location]
+          location = Location[v]
+        end
+        attrs = {place: Place.fetch(md[:place]), location: location}
+        new_with_promoted(md[:piece], attrs)
+      end
+
+      def piece_and_promoted(object)
+        case
+        when piece = Piece.basic_group[object]
+          promoted = false
+        when piece = Piece.promoted_group[object]
+          promoted = true
+        else
+          raise PieceNotFound, "#{object.inspect} に対応する駒がありません"
+        end
+        { piece: piece, promoted: promoted }
+      end
+
+      def new_with_promoted(object, attributes = {})
+        create(piece_and_promoted(object).merge(attributes))
+      end
+
+      def preset_one_side_soldiers(preset_key, location: :black)
+        location = Location[location]
+        PresetInfo.fetch(preset_key).board_parser.location_adjust[location.key]
+      end
+
+      # 先後それぞれの形を指定する
+      # Soldier.preset_soldiers(white: "裸玉", black: "裸玉").collect(&:name) # => ["▲５九玉", "△５一玉"]
+      def preset_soldiers(preset_key)
+        PresetInfo.fetch(preset_key || :"平手").sorted_soldiers
+      end
+
+      def create(...)
+        new(...).freeze
+      end
+    end
+
+    include SimpleModel
+
+    attr_accessor :piece
+    attr_accessor :promoted
+    attr_accessor :location
+    attr_accessor :place
+
+    private_class_method :new
+
+    def initialize(*)
+      super
+
+      Assertion.assert { piece          }
+      Assertion.assert { !promoted.nil? }
+      Assertion.assert { location       }
+      Assertion.assert { place          }
+    end
+
+    def attributes
+      { piece: piece, promoted: promoted, place: place, location: location }
+    end
+
+    # 手合割などを調べる際に並び順で異なるオブジェクトと見なされないようにするためだけに用意した
+    # だから何をキーにしてもよい。place は基本ユニークなのでこれで並べる
+    def <=>(other)
+      place <=> other.place
+    end
+
+    def ==(other)
+      eql?(other)
+    end
+
+    def eql?(other)
+      self.class == other.class && attributes == other.attributes
+    end
+
+    def hash
+      attributes.hash
+    end
+
+    def flip
+      self.class.create(piece: piece, promoted: promoted, place: place.flip, location: location.flip)
+    end
+
+    def flop
+      self.class.create(piece: piece, promoted: promoted, place: place.flop, location: location)
+    end
+
+    def flip_if_white
+      if location.key == :white
+        flip
+      else
+        self
+      end
+    end
+
+    def all_vectors
+      piece.all_vectors(promoted: promoted, location: location)
+    end
+
+    # 死に駒ではない？
+    def alive?
+      v = false
+      v ||= piece.always_alive # 死に駒にならない駒か？ (基本、後ろに移動できる駒)
+      v ||= promoted           # すでに成っているか？ (成っている駒は金の動きなので後ろに移動できる)
+      v ||= all_vectors.any? { |e| place.vector_add(e) } # ちょっとでも動ける？
+    end
+
+    def merge(attributes)
+      self.class.create(self.attributes.merge(attributes))
+    end
+
+    ################################################################################ Utility
+
+    # 自分を移動元の状態と考えて to に移動したとき成れるか？
+    def next_promotable?(to)
+      piece.promotable? && !promoted && (place.promotable?(location) || to.promotable?(location))
+    end
+
+    # 移動可能な座標を取得
+    def move_list(board, options = {})
+      SoldierWalker.call(board, self, options)
+    end
+
+    # 二歩？
+    def collision_pawn(board)
+      if piece.key == :pawn && !promoted
+        board.vertical_pieces(place.x).find do |e|
+          e.piece.key == :pawn && !e.promoted && e.location == location
+        end
+      end
+    end
+
+    # いまの状態で board に置いたとき「二歩」にも「死に駒」にもならないか？
+    def rule_valid?(board)
+      !collision_pawn(board) && alive?
+    end
+
+    # 自分を▲側に補正したときの座標
+    def normalized_place
+      place.flip_if_white(location)
+    end
+
+    # 入玉宣言時の得点
+    def ek_score
+      if place.promotable?(location)
+        piece.ek_score
+      else
+        0
+      end
+    end
+
+    # 手筋判定用
+    concerning :TechniqueMatcherMethods do
+      # 自分の側の一番下を0としてどれだけ前に進んでいるかを返す
+      def bottom_spaces
+        Dimension::PlaceY.dimension - 1 - top_spaces
+      end
+
+      # 自分の側の一番上を0としてあとどれだけで突き当たるかの値
+      def top_spaces
+        place.flip_if_white(location).y.value
+      end
+
+      # 「左右の壁からどれだけ離れているかの値」の小さい方(先後関係なし)
+      def smaller_one_of_side_spaces
+        [place.x.value, __distance_from_right].min
+      end
+
+      # 左右の壁に近い方に進むときの符号(先手視点なので先後関係なし)
+      def sign_to_goto_closer_side
+        if place.x.value > __distance_from_right
+          1
+        else
+          -1
+        end
+      end
+
+      # 先手から見て右からの距離
+      def __distance_from_right
+        Dimension::PlaceX.dimension - 1 - place.x.value
+      end
+
+      # センターにいる？
+      def center_place?
+        place.x.value == Dimension::PlaceX.dimension / 2
+      end
+
+      # 自玉の位置にいる？
+      def initial_place?
+        center_place? && bottom_spaces == 0
+      end
+
+      # 駒の重さ(=価値) 常にプラス
+      def abs_weight
+        piece.any_weight(promoted)
+      end
+
+      # 駒の重さ(=価値)。先手視点。後手ならマイナスになる
+      def relative_weight
+        abs_weight * location.value_sign
+      end
+
+      # 敵への駒の圧力(終盤度)
+      def pressure_level(area = 4)
+        case
+        when top_spaces < area
+          if promoted
+            piece.promoted_attack_level
+          else
+            piece.attack_level
+          end
+        when bottom_spaces < area
+          if promoted
+            -piece.promoted_defense_level
+          else
+            -piece.defense_level
+          end
+        else
+          0
+        end
+      end
+    end
+
+    ################################################################################ Formatter
+
+    def to_s
+      name
+    end
+
+    def name(options = {})
+      location.name + place.name + any_name(options)
+    end
+
+    def name_without_location(options = {})
+      place.name + any_name(options)
+    end
+
+    def any_name(options = {})
+      piece.any_name(promoted, options)
+    end
+
+    def yomiage
+      piece.yomiage(promoted)
+    end
+
+    def to_bod
+      location.varrow + any_name
+    end
+
+    def to_sfen
+      piece.to_sfen(promoted: promoted, location: location)
+    end
+
+    def to_csa_bod
+      location.csa_sign + to_csa
+    end
+
+    def to_csa
+      piece.csa.any_name(promoted)
+    end
+
+    def to_akf
+      {
+        :piece    => piece.key,
+        :promoted => promoted,
+        :place    => place.to_human_h,
+        :location => location.key,
+      }
+    end
+
+    def inspect
+      "<#{self.class.name} #{name.inspect}>"
+    end
+  end
+end

data/lib/bioshogi/soldier_box.rb

@@ -0,0 +1,38 @@
+# frozen-string-literal: true
+#
+# soldier_box = SoldierBox.new
+# soldier_box << Soldier.from_str("△５一玉")
+# soldier_box << Soldier.from_str("▲６八銀")
+# soldier_box.collect(&:name)                                             # => ["△５一玉", "▲６八銀"]
+# soldier_box.sorted_soldiers.collect(&:name)                             # => ["▲６八銀", "△５一玉"]
+# soldier_box.place_as_key_table.collect { |p, s| [p.name, s.name] }.to_h # => {"５一"=>"△５一玉", "６八"=>"▲６八銀"}
+# soldier_box.location_split.transform_values { |e| e.collect(&:name) }   # => {:black=>["▲６八銀"], :white=>["△５一玉"]}
+# soldier_box.location_adjust.transform_values { |e| e.collect(&:name) }  # => {:black=>["▲６八銀", "△５一玉"], :white=>["△４二銀", "▲５九玉"]}
+#
+module Bioshogi
+  class SoldierBox < Array
+    def soldiers
+      self
+    end
+
+    def sorted_soldiers
+      @sorted_soldiers ||= soldiers.sort.freeze
+    end
+
+    def place_as_key_table
+      @place_as_key_table ||= soldiers.inject({}) { |a, e| a.merge(e.place => e) }.freeze
+    end
+
+    # ▲または△から見た状態に補正した全体のデータ
+    def location_adjust
+      @location_adjust ||= Location.inject({}) { |a, location|
+        a.merge(location.key => sorted_soldiers.collect { |e| e.public_send(location.normalize_key) })
+      }.freeze
+    end
+
+    # ▲△に分割
+    def location_split
+      @location_split ||= Location.inject({}) { |a, e| a.merge(e.key => []) }.merge(sorted_soldiers.group_by { |e| e.location.key }).freeze
+    end
+  end
+end

data/lib/bioshogi/soldier_walker.rb

@@ -0,0 +1,122 @@
+# frozen-string-literal: true
+module Bioshogi
+  module SoldierWalker
+    extend self
+
+    # soldier が移動可能な手をすべて取得する
+    #
+    # アルゴリズム
+    #
+    #     １       １
+    #   +---+    +---+
+    #   | ・|一  | ・|一
+    #   | ・|二  | ・|二
+    #   | 香|三  | 杏|三
+    #   +---+    +---+
+    #
+    #   ▲１三香の場合
+    #   A. "１二" に移動してみて、その状態でさらに動けるなら "１二香" をストアしつつ、成れるなら成ってさらに動けるなら "１二杏" もストア
+    #   B. "１一" に移動してみて、その状態でさらに動けるなら "１一杏" をストアしつつ、成れるなら成ってさらに動けるなら "１三杏" をストア
+    #
+    #   ▲１三杏 の場合
+    #   C. "１二" に移動してみて、その状態でさらに動けるなら "１二杏" をストア。動けないので成れるなら成って→成れない
+    #   D. "１一" に移動してみて → 移動できない
+    #
+    #   となるので成っているかどうかにかかわらず B の方法でやればいい
+    #
+    def call(container, soldier, options = {})
+      Enumerator.new do |yielder|
+        soldier.all_vectors.each do |vector|
+          place = soldier.place
+          loop do
+            place = place.vector_add(vector)
+
+            # 盤外に出たら終わり
+            unless place
+              break
+            end
+
+            captured_soldier = container.board.surface[place]
+
+            # 自分の駒に衝突したら終わり
+            if captured_soldier && captured_soldier.location == soldier.location
+              break
+            end
+
+            # 空または相手駒の升には行ける(取れる)
+            piece_store(container, soldier, place, captured_soldier, yielder, options)
+
+            # 相手駒があるのでこれ以上は進めない
+            if captured_soldier
+              break
+            end
+
+            # いっぽだけベクトルならそれで終わり
+            if vector.kind_of?(V::OnceVector)
+              break
+            end
+          end
+        end
+      end
+    end
+
+    private
+
+    # place の場所は空なので player の soldier を place に置けそうだ
+    # でも place に置いてそれ以上動けなかったら反則になるので
+    # 1. それ以上動けるなら置く
+    # 2. 成れるなら成ってみて、それ以上動けるなら置く
+    def piece_store(container, origin_soldier, place, captured_soldier, yielder, options)
+      if options[:king_captured_only]
+        if captured_soldier && captured_soldier.piece.key == :king
+        else
+          return
+        end
+      end
+
+      # 死に駒にならないのであれば有効
+      soldier = origin_soldier.merge(place: place)
+
+      # 成れるなら成る
+      if origin_soldier.next_promotable?(soldier.place)
+        move_hand = Hand::Move.create(soldier: soldier.merge(promoted: true), origin_soldier: origin_soldier, captured_soldier: captured_soldier)
+        success = piece_store_core(container, move_hand, yielder, options)
+        if success
+          if options[:promoted_only]
+            # 成と不成の両方がある(かもしれない)場合は成の方だけ生成する
+            # これは本当はよくない
+            # 暫定的な対処
+            # 探索があまりに重いのでこうしている
+            return
+          end
+        end
+      end
+
+      if soldier.alive?
+        # すでに成っている(または成らない)手を生成
+        move_hand = Hand::Move.create(soldier: soldier, origin_soldier: origin_soldier, captured_soldier: captured_soldier)
+        piece_store_core(container, move_hand, yielder, options)
+      end
+    end
+
+    def piece_store_core(container, move_hand, yielder, options)
+      # 自玉に王手がかかる手は除外するか？
+      if options[:legal_only]
+        unless move_hand.legal_hand?(container)
+          return
+        end
+      end
+
+      # 相手に王手がかかる手だけにする
+      if options[:mate_only]
+        unless move_hand.mate_hand?(container)
+          return
+        end
+      end
+
+      yielder << move_hand
+
+      move_hand
+    end
+  end
+end

data/lib/bioshogi/source.rb

@@ -0,0 +1,30 @@
+module Bioshogi
+  class Source
+    class << self
+      def wrap(value)
+        if value.kind_of? self
+          return value
+        end
+        new(value)
+      end
+    end
+
+    private_class_method :new
+
+    def initialize(str)
+      if str.respond_to?(:expand_path)
+        str = str.expand_path
+      end
+      if str.respond_to?(:read)
+        str = str.read
+      end
+      str = str.to_s.toutf8.rstrip + "\n"
+      str = str.gsub(/\p{blank}*\R/, "\n") # バイナリだとここで死ぬ
+      @value = str.freeze
+    end
+
+    def to_s
+      @value
+    end
+  end
+end

data/lib/bioshogi/tasks/about.rake

@@ -0,0 +1,5 @@
+desc "About"
+task :about do
+  require "bioshogi"
+  tp Bioshogi::VERSION
+end

data/lib/bioshogi/tasks/chore.rake

@@ -0,0 +1,8 @@
+desc "bundle update (alias)"
+task :bu => :bundle_update
+
+desc "bundle update"
+task :bundle_update do
+  system "bundle update"
+  system "cd experiment && bundle update"
+end

data/lib/bioshogi/tasks/clean.rake

@@ -0,0 +1,4 @@
+desc "experiment以下のダンダースコアで始まるファイルを全削除"
+task :clean do
+  system %(fd -u -g '_*' experiment -x rm -f)
+end

data/lib/bioshogi/tasks/color_theme.rake

@@ -0,0 +1,9 @@
+namespace :color_theme do
+  desc "配色テーマのキャッシュ生成"
+  task "cache_build" do
+    require "bioshogi"
+    Bioshogi::ScreenImage::ColorThemeInfo.each do |e|
+      e.color_theme_cache_build(verbose: true)
+    end
+  end
+end

data/lib/bioshogi/tasks/demo.rake

@@ -0,0 +1,11 @@
+desc "デモ生成"
+task :demo do
+  require "bioshogi"
+  Bioshogi::Formatter::Animation::DemoBuilder.new.call
+  # Dir.chdir("#{__dir__}/experiment/animation_builder") do
+  #   system "ruby 0100_demo.rb"
+  # end
+  # Dir.chdir("#{__dir__}/experiment/screen_image_renderer") do
+  #   system "ruby 0100_demo.rb"
+  # end
+end

data/lib/bioshogi/tasks/doc.rake

@@ -0,0 +1,11 @@
+task :doc => "doc:generate"
+
+namespace :doc do
+  desc "[g] generate README.md"
+  task "generate" do
+    system "sh", "-vec", <<~EOT, exception: true
+saferenum -x doc
+source2md generate --xmp-out-exclude -o NEW_README.md doc/0*
+EOT
+  end
+end

data/lib/bioshogi/tasks/extreme_validator.rake

@@ -0,0 +1,8 @@
+desc "2ch棋譜読み込み変換テスト(LIMIT=xxx)"
+task "extreme_validator" do
+  require "bioshogi"
+  Bioshogi::ExtremeValidator.new(limit: ENV["LIMIT"]).call
+end
+
+desc "alias to extreme_validator"
+task :"2" => :extreme_validator

data/lib/bioshogi/tasks/generate.rake

@@ -0,0 +1,9 @@
+desc "各戦法のレア度や戦法が確定する手数のテーブルの生成"
+task :generate do
+  require "bioshogi"
+  Bioshogi::Explain::DistributionRatioGenerator.new.generate
+  Bioshogi::Explain::TacticHitTurnTableGenerator.new.generate
+end
+
+desc "alias to generate"
+task :g => :generate

data/lib/bioshogi/tasks/loader.rake

@@ -0,0 +1,9 @@
+desc "ファイル名と配置の関係が正しいのを確認する"
+task :loader do
+  require "bioshogi"
+  Zeitwerk::Loader.eager_load_all
+  puts "OK"
+end
+
+desc "alias to loader"
+task :l => :loader

data/lib/bioshogi/tasks/normalize.rake

@@ -0,0 +1,8 @@
+desc "戦法ファイルの正規化"
+task :normalize do
+  require "bioshogi"
+  Bioshogi::Explain::FileNormalizer.new.call
+end
+
+desc "alias to normalize"
+task :n => :normalize

data/lib/bioshogi/tasks/tactic_validator.rake

@@ -0,0 +1,8 @@
+desc "戦法判定確認"
+task :tactic_validate do
+  require "bioshogi"
+  Bioshogi::Explain::TacticValidator.new.call
+end
+
+desc "alias to tactic_validate"
+task :v => :tactic_validate