bioshogi 0.0.3

data/lib/bioshogi/screen_image/pentagon.rb

@@ -0,0 +1,167 @@
+# 五角形の駒
+
+module Bioshogi
+  module ScreenImage
+    concern :Pentagon do
+      class_methods do
+        def default_params
+          super.merge({
+              # 駒用
+              :piece_pentagon_draw         => false,             # 駒の形を描画するか？(trueにしたらpiece_font_scaleを調整すること)
+              :pt_file                     => nil,               # ☗のテクスチャ(あれば piece_pentagon_fill_color より優先)
+              :piece_pentagon_fill_color   => "transparent",     # ☗の色 ()
+              :piece_pentagon_stroke_color => "transparent",     # ☗の縁取り色
+              :piece_pentagon_stroke_width => 1,                 # ☗の縁取り幅
+              :piece_pentagon_scale        => 0.85,              # ☗の大きさ 1.0 なら元のまま。つまりセルの横幅まで広がる
+
+              # 先後
+              :face_pentagon_stroke_color   => "hsla(0,0%,50%)",  # ☗の縁取り色(nilなら piece_pentagon_stroke_color を代用)
+              :face_pentagon_stroke_width   => 3,                 # ☗の縁取り幅(nilなら piece_pentagon_stroke_width を代用)
+              :face_pentagon_scale          => 0.7,               # ☗の大きさ 1.0 なら元のまま。つまりセルの横幅まで広がる
+              :face_pentagon_color          => {                  # ☗を白と黒で塗り分けるときの色
+                :black => {
+                  :fill   => "hsl(0,0%,5%)",
+                  :stroke => "hsl(0,0%,20%)",
+                },
+                :white => {
+                  :fill   => "hsl(0,0%,95%)",
+                  :stroke => "hsl(0,0%,80%)",
+                },
+              },
+
+              # 六角形のスタイル
+              #
+              #              |katahaba|   ----------------------
+              #             ／＼                         ↓
+              #            ／  ＼                     kaonaga
+              #          ／     ＼                       ↑
+              #         ／       ＼                      ｜
+              #       ／          ＼      ___________    ｜
+              #      |              |      ↓            ｜
+              #     |                 |   munenaga       ｜
+              #     |                 |    ↑            ｜
+              #    |        ●         |  ----------------------- 高さの中心
+              #   |                    |   ↓
+              #  |                     |  asinaga
+              # |                       |  ↑
+              # +-----------------------+ ---------
+              #             |→hunbari←|
+              #
+              # 1.0 = 半径相当 (横方向ならセル横幅/2で縦方向ならセル高さ/2)
+              # すべて中心からの相対距離
+              # 全体に対して *_scale でスケールする
+              #
+              :pentagon_profile => {
+                :munenaga => 0.7,  # 胸長
+                :katahaba => 0.76, # 肩幅(ふんばり幅と差が少ないと寸胴に見える)
+                :asinaga  => 1.0,  # 臍下
+                :hunbari  => 0.95, # ふんばり幅(1.0にするとデブに見える)
+                :kaonaga  => 1.0,  # 顔の長さ
+              },
+            })
+        end
+      end
+
+      def piece_pentagon_draw(v:, location:, piece: nil)
+        if params[:piece_pentagon_draw]
+          # pentagon_box_debug(v)
+          draw_context(@d_piece_layer) do |g|
+            w = params[:piece_pentagon_stroke_width]
+            if w && w.nonzero?
+              g.stroke(params[:piece_pentagon_stroke_color])
+              g.stroke_width(w)
+            end
+            if @s_pattern_layer
+              g.fill_pattern = @s_pattern_layer # テクスチャが足りない場合は繰り返し敷き詰められる。だいたい64pxあればよい。余裕を見て 128x128 で作ろう
+            end
+            g.fill(params[:piece_pentagon_fill_color])
+            g.polygon(*pentagon_real_points(v: v, location: location, scale: piece_pentagon_scale(piece)))
+          end
+        end
+      end
+
+      # ☗を白黒で塗り分ける
+      def face_pentagon_draw(v:, location:)
+        draw_context(@d_piece_layer) do |g|
+          color = face_pentagon_color(location)
+          w = face_pentagon_stroke_width
+          if w && w.nonzero?
+            g.stroke(color[:stroke] || params[:piece_pentagon_stroke_color])
+            g.stroke_width(w)
+          end
+          g.fill(color[:fill])
+          g.polygon(*pentagon_real_points(v: v, location: location, scale: face_pentagon_scale))
+        end
+      end
+
+      def pentagon_box_debug(v)
+        draw_context do |g|
+          g.stroke_width(1)
+          g.stroke("#000")
+          g.fill("transparent")
+          g.rectangle(*px(v), *px(v + V.one))
+        end
+      end
+
+      # 実座標化
+      # OPTIMIZE: cx, cy を除いた部分だけキャッシュした方がよくない？
+      def pentagon_real_points(v:, location:, scale: 1.0)
+        cx, cy = *px(v + V.half)  # 中央
+        pentagon_points.flat_map do |x, y|
+          [
+            cx + x * scale * location.value_sign,
+            cy + y * scale * location.value_sign,
+          ]
+        end
+      end
+
+      # 相対座標で☖の一周分
+      # pentagon_real_points の方で行う計算で固定のものはこちらで先に行っておく
+      def pentagon_points
+        @pentagon_points ||= yield_self do
+          e = params[:pentagon_profile]
+          [
+            [0.0,            -e[:kaonaga]],  # 頂点
+            [-e[:katahaba],  -e[:munenaga]], # 左肩
+            [-e[:hunbari],   +e[:asinaga]],  # 左後
+            [+e[:hunbari],   +e[:asinaga]],  # 右後
+            [+e[:katahaba],  -e[:munenaga]], # 右肩
+          ].collect do |x, y|
+            [
+              x * cell_w * 0.5,
+              y * cell_h * 0.5,
+            ]
+          end
+        end
+      end
+
+      ################################################################################ piece
+
+      def piece_pentagon_scale(piece)
+        params[:piece_pentagon_scale] * piece.scale
+      end
+
+      ################################################################################ turn
+
+      def face_pentagon_scale
+        params[:face_pentagon_scale] || piece_pentagon_scale
+      end
+
+      def face_pentagon_stroke_width
+        params[:face_pentagon_stroke_width] || params[:piece_pentagon_stroke_width]
+      end
+
+      def face_pentagon_color(location)
+        params[:face_pentagon_color][location.key]
+      end
+
+      ################################################################################
+
+      def pattern_layer_create
+        if v = params[:pt_file].presence
+          Magick::Image.read(Pathname(v).expand_path).first
+        end
+      end
+    end
+  end
+end

data/lib/bioshogi/screen_image/piece_font_weight_info.rb

@@ -0,0 +1,12 @@
+module Bioshogi
+  module ScreenImage
+    class PieceFontWeightInfo
+      include ApplicationMemoryRecord
+      memory_record [
+        { key: :is_piece_font_weight_auto,   name: "おまかせ", to_params: {                                                         }, },
+        { key: :is_piece_font_weight_normal, name: "細字",     to_params: { soldier_font_bold: false, stand_piece_font_bold: false, }, },
+        { key: :is_piece_font_weight_bold,   name: "太字",     to_params: { soldier_font_bold: true,  stand_piece_font_bold: true,  }, },
+      ]
+    end
+  end
+end

data/lib/bioshogi/screen_image/renderer.rb

@@ -0,0 +1,15 @@
+module Bioshogi
+  module ScreenImage
+    class Renderer
+      include Builder
+      include CoreMethods
+      include BoardMethods
+      include LayerMethods
+      include Pentagon
+      include SoldierMethods
+      include Stand
+      include TurnMethods
+      include Helper
+    end
+  end
+end

data/lib/bioshogi/screen_image/soldier_methods.rb

@@ -0,0 +1,136 @@
+module Bioshogi
+  module ScreenImage
+    concern :SoldierMethods do
+      def soldier_draw_all
+        container.board.soldiers.each(&method(:soldier_draw))                                                                                # 駒を描画
+      end
+
+      def soldier_draw(soldier)
+        if params[:piece_image_key]
+          soldier_draw_by_image(soldier)
+        else
+          soldier_draw_by_char(soldier)
+        end
+      end
+
+      def soldier_draw_by_char(soldier)
+        v = V[*soldier.place.to_xy]
+        location = soldier.location
+        color = nil
+        bold = false
+
+        if hand_log && soldier == hand_log.soldier
+          color ||= params[:last_soldier_font_color]
+          bold = true
+        end
+
+        if soldier.promoted
+          color ||= params[:promoted_font_color]
+        end
+
+        piece_pentagon_draw(v: v, location: location, piece: soldier.piece) # ☗☖
+
+        char_draw(
+          :layer     => @d_piece_layer,
+          :v         => v + piece_char_adjust(location),
+          :text      => soldier_name(soldier),
+          :location  => location,
+          :color     => color || params[:normal_piece_color_map][soldier.piece.key] || params[:piece_font_color],
+          :bold      => bold || params[:soldier_font_bold],
+          :font_scale => soldier_font_scale(soldier.piece),
+          )
+      end
+
+      def soldier_draw_by_image(soldier)
+        v = V[*soldier.place.to_xy]
+        piece_image_draw(v: v, location: soldier.location, piece: soldier.piece, promoted: soldier.promoted)
+      end
+
+      def piece_image_draw(v:, location:, piece:, promoted: false)
+        type = params[:piece_image_key]
+        key = [location.to_sfen, piece.sfen_char, promoted ? "1" : "0"].join.upcase
+        type_with_key = "#{type}/#{key}"
+        wh = cell_rect.collect(&:ceil)
+        cache_key = [type_with_key, wh].join("/")
+        @piece_image_draw ||= {}
+        image = @piece_image_draw[cache_key] ||= yield_self do
+          png_path = ASSETS_DIR.join("images/piece/#{type_with_key}.png")
+          image = Magick::Image.read(png_path).first
+          image.resize_to_fill(*wh)
+        end
+        @d_piece_layer.composite!(image, *px(v), Magick::OverCompositeOp)
+      end
+
+      def soldier_move_cell_draw
+        if params[:piece_move_cell_fill_color]
+          if hand_log
+            draw_context(@d_move_layer) do |g|
+              g.stroke("transparent")
+              g.fill = params[:piece_move_cell_fill_color]
+              cell_draw(g, current_place)
+              cell_draw(g, origin_place)
+            end
+          end
+        end
+      end
+
+      def char_draw(layer: nil, v:, text:, location:, font_scale:, color: params[:piece_font_color], bold: false, stroke_width: nil, stroke_color: nil)
+        g = Magick::Draw.new
+        g.rotation = location.angle
+        g.pointsize = cell_w * font_scale
+
+        font = nil
+        if bold
+          font = params[:font_bold]
+        end
+        font ||= params[:font_regular]
+
+        if font
+          g.font = font.to_s
+        end
+
+        if stroke_width && stroke_color
+          g.stroke_width = stroke_width
+          g.stroke       = stroke_color
+        end
+
+        g.fill = color
+        g.gravity = Magick::CenterGravity # annotate で指定した範囲の中央に描画する
+        g.annotate(layer, *cell_rect, *px(v), text) # annotate(image, w, h, x, y, text)
+      end
+
+      def soldier_name(soldier)
+        if soldier.piece.key == :king && soldier.location.key == :white
+          "王"
+        else
+          soldier.any_name
+        end
+      end
+
+      def current_place
+        if hand_log
+          soldier = hand_log.soldier
+          V[*hand_log.soldier.place.to_xy]
+        end
+      end
+
+      def origin_place
+        if hand_log
+          if hand_log.hand.kind_of?(Hand::Move)
+            V[*hand_log.hand.origin_soldier.place.to_xy]
+          end
+        end
+      end
+
+      # フォントの位置を微調整
+      def piece_char_adjust(location)
+        @piece_char_adjust ||= {}
+        @piece_char_adjust[location.key] ||= V[*params[:piece_char_adjust][location.key]] * location.value_sign
+      end
+
+      def soldier_font_scale(piece)
+        params[:soldier_font_scale] * piece.scale
+      end
+    end
+  end
+end

data/lib/bioshogi/screen_image/stand.rb

@@ -0,0 +1,132 @@
+module Bioshogi
+  module ScreenImage
+    concern :Stand do
+      class_methods do
+        def default_params
+          super.merge({
+              # 全体
+              :stand_board_gap             => 0.25,              # 盤と駒台の隙間(1.0 = 1セル幅)
+
+              # 持駒
+              :stand_piece_line_height     => 1.0,               # 持駒の高さ(1.0 = 1セル高)
+              :stand_piece_font_scale      => nil,               # 持駒(nil なら soldier_font_scale を代用)
+              :stand_piece_font_bold       => false,             # 持駒を太くする？
+
+              # 持駒数
+              :piece_count_bg_color        => "hsla(0,0%,100%,0.7)", # 駒数の背景
+              :piece_count_font_color      => "hsla(0,0%,  0%,0.9)", # *駒数の色(nilなら piece_font_color を代用)
+              :piece_count_font_scale      => 0.6,               # 持駒数の大きさ
+              :piece_count_stroke_color    => nil,               # 持駒数の縁取り色
+              :piece_count_stroke_width    => nil,               # 持駒数の縁取り太さ
+              :piece_count_position_adjust => {                  # 駒数の位置
+                :single                    => [0.7, 0.05],       # 駒数1桁のとき。[0, 0] なら該当の駒の中央
+                :double                    => [0.8, 0.05],       # 駒数2桁のとき
+              },
+
+              :piece_count_bg_scale        => 0,              # 駒数の背景の大きさ 0:なし 1.0:セルの半分
+              # :piece_count_bg_adjust => {                     # 駒数の背景の微調整
+              #   :black => [0.0, 0.0],
+              #   :white => [0.0, 0.0],
+              # },
+            })
+        end
+      end
+
+      def stand_draw
+        g = params[:stand_piece_line_height]
+
+        container.players.each do |player|
+          location = player.location
+          s = location.value_sign
+
+          if player.location.key == :black
+            v = v_bottom_right_outer
+          else
+            v = v_top_left_outer
+          end
+
+          h = V[0, player.piece_box.count] * g       # 駒数に対応した高さ
+          v -= h * s                                 # 右下から右端中央にずらす
+          v += V[params[:stand_board_gap], 0] * s    # 盤と持駒の隙間を開ける
+
+          face_pentagon_draw(v: v, location: location) # ☗☖
+
+          v += V[0, 1] * g * s
+
+          player.piece_box.each.with_index do |(piece_key, count), i|
+            piece = Piece.fetch(piece_key)
+
+            if params[:piece_image_key]
+              piece_image_draw(v: v, location: location, piece: piece)
+            else
+              # 持駒の影
+              piece_pentagon_draw(v: v, location: location, piece: piece)
+
+              # 持駒
+              char_draw(
+                  :layer      => @d_piece_layer,
+                  :v          => v + piece_char_adjust(location),
+                  :text       => piece.name,
+                  :location   => location,
+                  :color      => params[:stand_piece_color] || params[:piece_font_color],
+                  :font_scale => (params[:stand_piece_font_scale] || params[:soldier_font_scale]) * piece.scale,
+                  :bold       => params[:stand_piece_font_bold]
+                )
+            end
+
+            # 持駒数
+            piece_count_draw(v: v, count: count, location: location)
+            v += V[0, 1] * g * s
+          end
+        end
+      end
+
+      # 駒数
+      def piece_count_draw(v:, count:, location:)
+        if count >= 2
+          w = count <= 9 ? :single : :double
+          v = v + V[*params[:piece_count_position_adjust][w]] * location.value_sign
+          piece_count_bg_draw(v: v, location: location)
+          char_draw(
+            :layer        => @d_piece_count_layer,
+            :v            => v,
+            :text         => count.to_s,
+            :location     => location,
+            :color        => params[:piece_count_font_color] || params[:piece_font_color], # 地べたに描画するのでコントラスト比を下げるの重要
+            :font_scale   => params[:piece_count_font_scale],
+            :stroke_color => params[:piece_count_stroke_color],
+            :stroke_width => params[:piece_count_stroke_width],
+            )
+        end
+      end
+
+      # 駒数の下の丸
+      def piece_count_bg_draw(v:, location:)
+        if params[:piece_count_bg_color] && params[:piece_count_bg_scale].nonzero?
+          draw_context(@d_piece_count_layer) do |g|
+            g.fill(params[:piece_count_bg_color])
+
+            # v2 = v + V[*params[:piece_count_bg_adjust][w]] * location.value_sign
+            # v2 = v + (V.half + V[*params[:piece_count_bg_adjust]]) * location.value_sign
+            # g.ellipse(*px(v2), *(cell_rect * params[:piece_count_bg_scale] * location.value_sign), 0, 360) # x, y, w, h, angle(0 to 360)
+            # g.ellipse(*px(v2), *cell_rect, 0, 360) # x, y, w, h, angle(0 to 360)
+
+            # 個数は左上を原点とした枠の中心(CenterGravity)で表示するのでその位置に移動する
+            from = v + V.half                                               # 中心に移動
+            # from += V[*params[:piece_count_bg_adjust][location.key]] # 微調整
+            # fromを基点として大きさを決める
+            to = from + V.half * params[:piece_count_bg_scale]
+            g.circle(*px(from), *px(to)) # (x1, y1) と (x2, y2) の2点を通る円
+
+            # roundrectangle でも円風にできるけど原点が左上なので半径の調整が難しい
+
+            # ellipse より roundrectangle の方が扱いやすい？
+            # g.roundrectangle(*px(v + V.one * 0.25), *px(v + V.one), *(cell_rect * 0.25))
+            # roundrectangle2(g, v)
+            # g.rectangle(*px(v), *px(v + V.one * params[:piece_count_bg_scale] * s)) # debug
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bioshogi/screen_image/turn_methods.rb

@@ -0,0 +1,45 @@
+module Bioshogi
+  module ScreenImage
+    concern :TurnMethods do
+      class_methods do
+        def default_params
+          super.merge({
+              :turn_embed_key => "is_turn_embed_off",  # 現在の手数を埋めるか？
+            })
+        end
+      end
+
+      def turn_draw(layer)
+        if params[:turn_embed_key] == "is_turn_embed_on"
+          logger.info "turn_draw"
+
+          pointsize = cell_w * 0.75
+          w = pointsize * 4
+          h = pointsize
+          x = pointsize * 0.3
+          y = pointsize * 0.1
+
+          # r = cell_w * 0.5
+          # @d_turn_layer = Magick::Image.new(w, h) { |e| e.background_color = "transparent" }
+
+          # gc = Magick::Draw.new
+          # gc.fill(params[:piece_count_bg_color])
+          # from = [x + w/2, y + h/2]
+          # to   = [x + w/2 + r, y + h/2]
+          # gc.circle(*from, *to)
+          # gc.draw(@d_turn_layer)
+
+          gc = Magick::Draw.new
+          gc.annotate(layer, w, h, x, y, "#{@build_counter}") do |e|
+            e.font         = params[:font_bold].to_s
+            e.fill         = "hsla(0,0%,100%,1.0)"
+            e.pointsize    = pointsize
+            e.stroke_width = 2
+            e.stroke       = "hsla(0,0%,0%,0.75)"
+            e.gravity      = Magick::NorthWestGravity
+          end
+        end
+      end
+    end
+  end
+end

data/lib/bioshogi/screen_image.rb

@@ -0,0 +1,11 @@
+# 画像変換
+#
+#  Parser.parse(...).to_png
+#
+module Bioshogi
+  module ScreenImage
+    def self.renderer(...)
+      Renderer.new(...)
+    end
+  end
+end

data/lib/bioshogi/sfen.rb

@@ -0,0 +1,120 @@
+# frozen-string-literal: true
+
+module Bioshogi
+  class Sfen
+    STARTPOS_EXPANSION = "sfen lnsgkgsnl/1r5b1/ppppppppp/9/9/9/PPPPPPPPP/1B5R1/LNSGKGSNL b - 1"
+    BOARD_REGEXP       = "[#{Piece.collect(&:sfen_char).join}1-9+\/]+"
+    LOCATION_REGEXP    = "[#{Location.collect(&:to_sfen).join}]"
+    SFEN_REGEXP        = /(?:position\s+)?(?:sfen\s+)?(?<board>#{BOARD_REGEXP})\s+(?<b_or_w>#{LOCATION_REGEXP})\s+(?<hold_pieces>\S+)\s+(?<turn_counter_next>\d+)(\s+moves\s+(?<moves>.*))?/i
+
+    attr_reader :attributes
+    attr_reader :source
+
+    class << self
+      def accept?(source)
+        source.sub(/startpos/, STARTPOS_EXPANSION).match?(SFEN_REGEXP)
+      end
+
+      def parse(source)
+        new(source).tap(&:parse)
+      end
+
+      # position startpos を逆に position sfen ... 形式に変換
+      def startpos_remove(s)
+        s.sub(/startpos/, STARTPOS_EXPANSION)
+      end
+
+      # startpos スタイルに変更
+      def startpos_embed(s)
+        s.sub(STARTPOS_EXPANSION, "startpos")
+      end
+    end
+
+    def initialize(source)
+      @source = source
+    end
+
+    def parse
+      s = self.class.startpos_remove(source)
+      unless md = s.match(SFEN_REGEXP)
+        m = []
+        m << "入力のSFEN形式が不正確です"
+        if source.match?(/\s{2,}/)
+          m << "連続するスペースが含まれている個所が壊れているかもしれません"
+        end
+        if source.strip.match?(/\R/)
+          m << "途中で改行を含めないでください"
+        end
+        m = m.join("。")
+        m = "#{m} : #{source.strip.inspect}"
+        raise SyntaxDefact, m
+      end
+      @attributes = md.named_captures.symbolize_keys
+    end
+
+    def soldiers
+      BoardParser::SfenBoardParser.parse(attributes[:board]).soldiers
+    end
+
+    def location
+      Location.fetch(attributes[:b_or_w])
+    end
+
+    def piece_counts
+      hash = Location.inject({}) { |a, e| a.merge(e.key => {}) }
+      if str = attributes[:hold_pieces]
+        if str != "-"
+          str.scan(/(\d+)?(.)/) do |count, ch|
+            count = (count || 1).to_i
+            piece = Piece.fetch_by_sfen_char(ch)
+            location = Location.fetch_by_sfen_char(ch)
+            hash[location.key].update(piece.key => count) { |_, *c| c.sum }
+          end
+        end
+      end
+      hash
+    end
+
+    # 現在の局面+1が記載されているので -1 すること
+    def turn_base
+      if v = attributes[:turn_counter_next]
+        v.to_i.pred
+      end
+    end
+
+    def handicap?
+      turn_base.even? && location.key == :white
+    end
+
+    def move_infos
+      moves.collect { |e| { input: e } }
+    end
+
+    ################################################################################ 簡単にアクセスするためのメソッド
+
+    def moves
+      attributes[:moves].to_s.split
+    end
+
+    def board_and_b_or_w_and_piece_box_and_turn
+      attributes.fetch_values(:board, :b_or_w, :hold_pieces, :turn_counter_next).join(" ")
+    end
+
+    def kento_app_url
+      "https://www.kento-shogi.com/?#{kento_app_query_hash.to_query}"
+    end
+
+    def kento_app_query_hash
+      { initpos: board_and_b_or_w_and_piece_box_and_turn, moves: moves.join(".") }
+    end
+
+    def to_h
+      {
+        :soldiers     => soldiers,
+        :piece_counts => piece_counts,
+        :location     => location,
+        :moves        => moves,
+      }
+    end
+  end
+end

data/lib/bioshogi/sfen_importer.rb

@@ -0,0 +1,29 @@
+# frozen-string-literal: true
+module Bioshogi
+  class SfenImporter
+    def initialize(container, sfen_info)
+      @container = container
+      @sfen_info = sfen_info
+    end
+
+    def import_initial
+      @sfen_info.soldiers.each do |soldier|
+        player = @container.player_at(soldier.location)
+        player.board.place_on(soldier, validate: true)
+      end
+      @container.turn_info.handicap = @sfen_info.handicap?
+      @container.turn_info.turn_base = @sfen_info.turn_base
+      @sfen_info.piece_counts.each do |location_key, counts|
+        @container.player_at(location_key).piece_box.set(counts)
+      end
+      @container.before_run_process
+    end
+
+    def import_all
+      import_initial
+      @sfen_info.move_infos.each do |e|
+        @container.execute(e[:input])
+      end
+    end
+  end
+end

data/lib/bioshogi/simple_model.rb

@@ -0,0 +1,13 @@
+# frozen-string-literal: true
+
+module Bioshogi
+  module SimpleModel
+    def initialize(attributes)
+      attributes.each do |k, v|
+        public_send("#{k}=", v)
+      end
+
+      super()
+    end
+  end
+end