bioshogi 0.0.14 → 0.0.15

data/lib/bioshogi/official_formatter.rb

@@ -40,7 +40,7 @@ module Bioshogi
         s << @options[:separator]
       end
 
-      if type == "t_drop"
+      if type == :t_drop
         s << piece_name
         # 日本将棋連盟 棋譜の表記方法
         # https://www.shogi.or.jp/faq/kihuhyouki.html
@@ -53,15 +53,15 @@ module Bioshogi
         if @options[:force_drop] || !candidate_soldiers.empty?
           s << kw("打")
         end
-      elsif type == "t_promote_on"
+      elsif type == :t_promote_on
         s << piece_name
         s << motion
         s << kw("成")
-      elsif type == "t_promote_throw"
+      elsif type == :t_promote_throw
         s << piece_name
         s << motion
         s << kw("不成") # or "生"
-      elsif type == "t_move"
+      elsif type == :t_move
         s << soldier_name
         s << motion
       else
@@ -80,26 +80,26 @@ module Bioshogi
 
     def to_debug_hash
       {
-        :place_from     => place_from,
-        :place_to       => place_to,
-        :candidate_soldiers      => candidate_soldiers.collect(&:name),
-        :koreru_c       => koreru_c,
-        :_migi_idou     => _migi_idou?,
-        :_hidari_idou   => _hidari_idou?,
-        :_ue_idou       => _ue_idou?,
-        :_shita_idou    => _shita_idou?,
-        :_hidari_kara_c => _hidari_kara_c,
-        :_migi_kara_c   => _migi_kara_c,
-        :yoreru_c       => yoreru_c,
-        :agareru_c      => agareru_c,
-        :sagareru_c     => sagareru_c,
-        :shita_y        => shita_y,
-        :_tx            => _tx,
-        :_ty            => _ty,
-        :_ox            => _ox,
-        :_oy            => _oy,
-        :_xr            => _xr,
-        :_yr            => _yr,
+        :place_from         => place_from,
+        :place_to           => place_to,
+        :candidate_soldiers => candidate_soldiers.collect(&:name),
+        :koreru_c           => koreru_c,
+        :_migi_idou         => _migi_idou?,
+        :_hidari_idou       => _hidari_idou?,
+        :_ue_idou           => _ue_idou?,
+        :_shita_idou        => _shita_idou?,
+        :_hidari_kara_c     => _hidari_kara_c,
+        :_migi_kara_c       => _migi_kara_c,
+        :yoreru_c           => yoreru_c,
+        :agareru_c          => agareru_c,
+        :sagareru_c         => sagareru_c,
+        :shita_y            => shita_y,
+        :_tx                => _tx,
+        :_ty                => _ty,
+        :_ox                => _ox,
+        :_oy                => _oy,
+        :_xr                => _xr,
+        :_yr                => _yr,
       }
     end
 
@@ -281,37 +281,37 @@ module Bioshogi
 
     # 左からこれる駒の数
     def _hidari_kara_c
-      candidate_soldiers.count { |s| s.place.x.value < _tx }
+      candidate_soldiers.count { |s| s.place.column.value < _tx }
     end
 
     # 右からこれる駒の数
     def _migi_kara_c
-      candidate_soldiers.count { |s| s.place.x.value > _tx }
+      candidate_soldiers.count { |s| s.place.column.value > _tx }
     end
 
     # 水平に寄れる駒の数
     def yoreru_c
-      candidate_soldiers.count { |s| s.place.y.value == _ty }
+      candidate_soldiers.count { |s| s.place.row.value == _ty }
     end
 
     # 上がれる駒の数(移動先より下にある数)
     def agareru_c
-      candidate_soldiers.count { |s| s.place.y.value.send(_i(:>), _ty) }
+      candidate_soldiers.count { |s| s.place.row.value.send(_i(:>), _ty) }
     end
 
     # 下がれる駒の数(移動先より上にある数)
     def sagareru_c
-      candidate_soldiers.count { |s| s.place.y.value.send(_i(:<), _ty) }
+      candidate_soldiers.count { |s| s.place.row.value.send(_i(:<), _ty) }
     end
 
     # 移動先X
     def _tx
-      @_tx ||= place_to.x.value
+      @_tx ||= place_to.column.value
     end
 
     # 移動元Y
     def _ty
-      @_ty ||= place_to.y.value
+      @_ty ||= place_to.row.value
     end
 
     # プレイヤー視点から見た移動先の一つ下
@@ -326,31 +326,31 @@ module Bioshogi
 
     # 移動元X
     def _ox
-      @_ox ||= place_from.x.value
+      @_ox ||= place_from.column.value
     end
 
     # 移動先Y
     def _oy
-      @_oy ||= place_from.y.value
+      @_oy ||= place_from.row.value
     end
 
     # 候補手の座標範囲
     def _xr
-      @_xr ||= Range.new(*candidate_soldiers.collect { |e| e.place.x.value }.minmax)
+      @_xr ||= Range.new(*candidate_soldiers.collect { |e| e.place.column.value }.minmax)
     end
 
     def _yr
-      @_yr ||= Range.new(*candidate_soldiers.collect { |e| e.place.y.value }.minmax)
+      @_yr ||= Range.new(*candidate_soldiers.collect { |e| e.place.row.value }.minmax)
     end
 
     # 移動元で二つの龍が水平線上にいる？
     def idou_moto_no_ryu_ga_suihei_ni_iru?
-      candidate_soldiers.collect { |e| e.place.y.value }.uniq.size == 1
+      candidate_soldiers.collect { |e| e.place.row.value }.uniq.size == 1
     end
 
     # 移動先の水平線上よりすべて上 or すべて下
     # つまり、移動先のYが候補のYの範囲に含まれている
-    # だから candidate_soldiers.all?{|s|s.place.y.value < _ty} || candidate_soldiers.all?{|s|s.place.y.value > _ty} から !_yr.cover?(_ty) に変更できる
+    # だから candidate_soldiers.all?{|s|s.place.row.value < _ty} || candidate_soldiers.all?{|s|s.place.row.value > _ty} から !_yr.cover?(_ty) に変更できる
     def idousakino_suiheisenjou_yori_subete_ue_mataha_shita?
       !_yr.cover?(_ty)
     end

data/lib/bioshogi/order_info.rb

@@ -1,12 +1,14 @@
 # frozen-string-literal: true
 
-# ▲△とは関係がない
+# ▲△と混同しがちだが▲△は場所のことであって順番とは関係がない。
+# たとえば駒落ちの場合は△から指すため「△=後手」と解釈しているとおかしくなる。
+
 module Bioshogi
   class OrderInfo
     include ApplicationMemoryRecord
     memory_record [
-      { key: :sente, name: "先手"}, # 奇数回に指す側
-      { key: :gote,  name: "後手"}, # 偶数回に指す側
+      { key: :order_first,  name: "先手"}, # 奇数回に指す側
+      { key: :order_second, name: "後手"}, # 偶数回に指す側
     ]
   end
 end

data/lib/bioshogi/piece/piece_vector.rb

@@ -10,21 +10,27 @@ module Bioshogi
     class PieceVector
       include ApplicationMemoryRecord
       memory_record [
-        { key: :king,   basic_once_vectors: :pattern_king,       basic_repeat_vectors: nil,           promoted_once_vectors: nil,           promoted_repeat_vectors: nil,           },
-        { key: :rook,   basic_once_vectors: nil,                 basic_repeat_vectors: :pattern_plus, promoted_once_vectors: :pattern_x,    promoted_repeat_vectors: :pattern_plus, },
-        { key: :bishop, basic_once_vectors: nil,                 basic_repeat_vectors: :pattern_x,    promoted_once_vectors: :pattern_plus, promoted_repeat_vectors: :pattern_x,    },
-        { key: :gold,   basic_once_vectors: :pattern_gold,       basic_repeat_vectors: nil,           promoted_once_vectors: nil,           promoted_repeat_vectors: nil,           },
-        { key: :silver, basic_once_vectors: :pattern_silver,     basic_repeat_vectors: nil,           promoted_once_vectors: :pattern_gold, promoted_repeat_vectors: nil,           },
-        { key: :knight, basic_once_vectors: :pattern_knight,     basic_repeat_vectors: nil,           promoted_once_vectors: :pattern_gold, promoted_repeat_vectors: nil,           },
-        { key: :lance,  basic_once_vectors: nil,                 basic_repeat_vectors: :pattern_pawn, promoted_once_vectors: :pattern_gold, promoted_repeat_vectors: nil,           },
-        { key: :pawn,   basic_once_vectors: :pattern_pawn,       basic_repeat_vectors: nil,           promoted_once_vectors: :pattern_gold, promoted_repeat_vectors: nil,           },
+        { key: :king,   basic_once_vectors: :pattern_king,   basic_repeat_vectors: nil,           promoted_once_vectors: nil,           promoted_repeat_vectors: nil,           },
+        { key: :rook,   basic_once_vectors: nil,             basic_repeat_vectors: :pattern_plus, promoted_once_vectors: :pattern_x,    promoted_repeat_vectors: :pattern_plus, },
+        { key: :bishop, basic_once_vectors: nil,             basic_repeat_vectors: :pattern_x,    promoted_once_vectors: :pattern_plus, promoted_repeat_vectors: :pattern_x,    },
+        { key: :gold,   basic_once_vectors: :pattern_gold,   basic_repeat_vectors: nil,           promoted_once_vectors: nil,           promoted_repeat_vectors: nil,           },
+        { key: :silver, basic_once_vectors: :pattern_silver, basic_repeat_vectors: nil,           promoted_once_vectors: :pattern_gold, promoted_repeat_vectors: nil,           },
+        { key: :knight, basic_once_vectors: :pattern_knight, basic_repeat_vectors: nil,           promoted_once_vectors: :pattern_gold, promoted_repeat_vectors: nil,           },
+        { key: :lance,  basic_once_vectors: nil,             basic_repeat_vectors: :pattern_pawn, promoted_once_vectors: :pattern_gold, promoted_repeat_vectors: nil,           },
+        { key: :pawn,   basic_once_vectors: :pattern_pawn,   basic_repeat_vectors: nil,           promoted_once_vectors: :pattern_gold, promoted_repeat_vectors: nil,           },
+      ]
+
+      DELEGATE_METHODS = [
+        :brave?,
+        :all_vectors,
       ]
 
       def brave?
         attributes[:promoted_repeat_vectors]
       end
 
-      def all_vectors(promoted:, location:)
+      # すべてはこれで足りるので他のメソッドを public にするべからず
+      def all_vectors(location:, promoted: false)
         @all_vectors ||= {}
         @all_vectors[[promoted, location.key]] ||= yield_self do
           vectors = select_vectors(promoted)
@@ -49,7 +55,7 @@ module Bioshogi
       end
 
       def normalized_vectors(location, vectors)
-        vectors.collect { |e| e * location.value_sign }
+        vectors.collect { |e| e * location.sign_dir }
       end
 
       def basic_vectors

data/lib/bioshogi/piece.rb

@@ -103,7 +103,7 @@ module Bioshogi
       { key: :gold,   name: "金", basic_alias: nil,  promoted_name: nil,  promoted_formal_sheet_name: nil,    other_matched_promoted_names: nil,   sfen_char: "G", promotable: false, always_alive: true,  stronger: false, dengaku_target: false, tatakare_target: true,  maesusumeru: true,  },
       { key: :silver, name: "銀", basic_alias: nil,  promoted_name: "全", promoted_formal_sheet_name: "成銀", other_matched_promoted_names: nil,   sfen_char: "S", promotable: true,  always_alive: true,  stronger: false, dengaku_target: false, tatakare_target: true,  maesusumeru: true,  },
       { key: :knight, name: "桂", basic_alias: nil,  promoted_name: "圭", promoted_formal_sheet_name: "成桂", other_matched_promoted_names: "今",  sfen_char: "N", promotable: true,  always_alive: false, stronger: false, dengaku_target: false, tatakare_target: false, maesusumeru: false, },
-      { key: :lance,  name: "香", basic_alias: nil,  promoted_name: "杏", promoted_formal_sheet_name: "成香", other_matched_promoted_names: "仝",  sfen_char: "L", promotable: true,  always_alive: false, stronger: false, dengaku_target: false, tatakare_target: true,  maesusumeru: true,  },
+      { key: :lance,  name: "香", basic_alias: nil,  promoted_name: "杏", promoted_formal_sheet_name: "成香", other_matched_promoted_names: "仝",  sfen_char: "L", promotable: true,  always_alive: false, stronger: false, dengaku_target: false, tatakare_target: false, maesusumeru: true,  },
       { key: :pawn,   name: "歩", basic_alias: nil,  promoted_name: "と", promoted_formal_sheet_name: nil,    other_matched_promoted_names: nil,   sfen_char: "P", promotable: true,  always_alive: false, stronger: false, dengaku_target: false, tatakare_target: false, maesusumeru: true,  },
     ]
 
@@ -218,7 +218,7 @@ module Bioshogi
     def piece_vector
       @piece_vector ||= PieceVector.fetch(key)
     end
-    delegate :brave?, :all_vectors, to: :piece_vector
+    delegate *PieceVector::DELEGATE_METHODS, to: :piece_vector
 
     def piece_scale
       @piece_scale ||= PieceScale.fetch(key)

data/lib/bioshogi/place.rb

@@ -9,19 +9,19 @@
 
 module Bioshogi
   class Place
-    attr_accessor :x, :y
-
     class << self
       private :new
 
-      include Enumerable
+      begin
+        include Enumerable
 
-      def each(&block)
-        Dimension::PlaceY.dimension.times.flat_map { |y|
-          Dimension::PlaceX.dimension.times.collect { |x|
-            self[[x, y]]
-          }
-        }.each(&block)
+        def each(&block)
+          Dimension::Row.dimension_size.times.flat_map { |row|
+            Dimension::Column.dimension_size.times.collect { |column|
+              self[[column, row]]
+            }
+          }.each(&block)
+        end
       end
 
       def fetch(value)
@@ -33,28 +33,30 @@ module Bioshogi
           return value
         end
 
-        x = nil
-        y = nil
+        column = nil
+        row = nil
 
         case value
         when Array
           a, b = value
-          x = Dimension::PlaceX.lookup(a)
-          y = Dimension::PlaceY.lookup(b)
+          column = Dimension::Column.lookup(a)
+          row = Dimension::Row.lookup(b)
         when String
           a, b = value.chars
-          x = Dimension::PlaceX.lookup(a)
-          y = Dimension::PlaceY.lookup(b)
+          column = Dimension::Column.lookup(a)
+          row = Dimension::Row.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
+        # 座標は最大で99なのでインスタンスを使いまわす
+        # ただしグローバルな寸法が変わると不整合な状態になるため cache_clear を適切に呼ばないといけない
+        if column && row
+          @cache ||= {}
+          @cache[column] ||= {}
+          @cache[column][row] ||= new(column, row)
         end
       end
 
@@ -62,91 +64,121 @@ module Bioshogi
         lookup(value)
       end
 
+      def cache_clear
+        if @cache
+          @cache.each_value do |hv|
+            hv.each_value(&:cache_clear)
+          end
+        end
+      end
+
       def regexp
         /[一二三四五六七八九１-９1-9]{2}/
       end
     end
 
-    def initialize(x, y)
-      @x = x
-      @y = y
-    end
+    attr_accessor :column, :row
 
-    def inspect
-      "#<#{self.class.name} #{name}>"
+    # for Soldier
+    DELEGATE_METHODS = [
+      *Dimension::Column::DELEGATE_METHODS,
+      *Dimension::Row::DELEGATE_METHODS,
+
+      :relative_move_to,
+      :move_to_xy,
+      :king_default_place?,
+
+      :move_to_bottom_edge,
+      :move_to_top_edge,
+      :move_to_left_edge,
+      :move_to_right_edge,
+    ]
+
+    def initialize(column, row)
+      @column = column
+      @row = row
+      @cache = {}
+      freeze
     end
 
-    # 180度回転 ※上下対象ではない
-    def flip
-      self.class.fetch([@x.flip, @y.flip])
+    def cache_clear
+      to_a.each(&:cache_clear)
+      @cache.clear
     end
 
-    # x座標のみ反転
-    def flop
-      self.class.fetch([@x.flip, @y])
+    def inspect
+      "#<#{self.class.name} #{name}>"
     end
 
-    def flip_if_white(location)
-      if Location[location].key == :white
-        flip
-      else
-        self
-      end
+    ################################################################################
+
+    def to_s
+      name
     end
 
     def name
-      to_a.collect { |e| e.name }.join
+      @cache[:name] ||= to_a.collect(&:name).join
     end
 
     def zenkaku_number
-      to_a.collect(&:zenkaku_number).join
+      @cache[:zenkaku_number] ||= to_a.collect(&:zenkaku_number).join
     end
 
     def hankaku_number
-      to_a.collect(&:hankaku_number).join
+      @cache[:hankaku_number] ||= to_a.collect(&:hankaku_number).join
     end
 
     def yomiage
-      to_a.collect(&:yomiage).join
-    end
-
-    def to_s
-      name
+      @cache[:yomiage] ||= to_a.collect(&:yomiage).join
     end
 
     def to_sfen
-      to_a.collect(&:to_sfen).join
+      @cache[:to_sfen] ||= to_a.collect(&:to_sfen).join
     end
 
     def to_xy
-      [@x.value, @y.value]
+      @cache[:to_xy] ||= to_a.collect(&:value)
     end
 
     # "６八銀" なら [6, 8]
+    # キャッシュすると3倍速くなる
     def to_human_int
-      to_a.collect(&:to_human_int)
+      @cache[:to_human_int] ||= to_a.collect(&:to_human_int)
     end
 
-    # "６八銀" なら {x:6, y:8}
+    # "６八銀" なら {column:6, row:8}
+    # キャッシュすると2倍速くなる
     def to_human_h
-      { x: @x.to_human_int, y: @y.to_human_int }
+      @cache[:to_human_h] ||= Hash[[:column, :row].zip(to_human_int)]
     end
 
+    # ほぼキャッシュ効果なし。それどころか少し遅くなる。ただ配列を再生成しないのでこれでいいことにする。
     def to_a
-      [@x, @y]
+      @cache[:to_a] ||= [@column, @row]
     end
 
-    def vector_add(vector)
-      self.class.lookup([@x.value + vector.x, @y.value + vector.y])
+    ################################################################################
+
+    # 180度回転
+    def flip
+      @cache[:flip] ||= self.class.fetch(to_a.collect(&:flip))
     end
 
-    # def valid?
-    #   @x.valid? && @y.valid?
-    # end
-    #
-    # def invalid?
-    #   !valid?
-    # end
+    # column座標のみ反転
+    def flop
+      @cache[:flop] ||= self.class.fetch([@column.flip, @row])
+    end
+
+    # Soldier では独自に定義しているためここに Soldier からここに委譲してはいけない
+    def white_then_flip(location)
+      if Location[location].key == :white
+        flip
+      else
+        self
+      end
+    end
+
+    ################################################################################
 
     def ==(other)
       eql?(other)
@@ -164,8 +196,69 @@ module Bioshogi
       self.class == other.class && to_xy == other.to_xy
     end
 
-    def promotable?(location)
-      @y.promotable?(location)
+    ################################################################################ 移動
+
+    # より抽象的な方法で移動した位置を返す
+    def relative_move_to(location, vector, magnification: 1)
+      if vector.kind_of?(Symbol)
+        vector = V.public_send(vector)
+      end
+      xy_add(*(vector * location.sign_dir * magnification))
+    end
+
+    # 自玉の位置にいる？
+    def king_default_place?(location)
+      column_is_center?(location) && bottom_spaces(location) == 0
+    end
+
+    def xy_add(x, y)
+      self.class.lookup([@column.value + x, @row.value + y])
+    end
+    private :xy_add
+
+    def vector_add(vector)
+      xy_add(vector.x, vector.y)
+    end
+
+    # 上下左右 -1 +1 -1 +1 に進んだ位置を返す (white側の場合も考慮する)
+    # 2つ進んだ位置などを一発で調べたいときに使う
+    # なるべく使うな
+    def move_to_xy(location, x, y)
+      xy_add(x * location.sign_dir, y * location.sign_dir)
     end
+
+    ################################################################################ location から見た上下左右に寄せた位置を返す
+
+    def move_to_bottom_edge(location)
+      self.class.fetch([column, location.bottom])
+    end
+
+    def move_to_top_edge(location)
+      self.class.fetch([column, location.top])
+    end
+
+    def move_to_left_edge(location)
+      self.class.fetch([location.left, row])
+    end
+
+    def move_to_right_edge(location)
+      self.class.fetch([location.right, row])
+    end
+
+    ################################################################################ location から見た情報を返す
+
+    Dimension::Column::DELEGATE_METHODS.each do |name|
+      define_method(name) do |location|
+        @column.white_then_flip(location).public_send(name)
+      end
+    end
+
+    Dimension::Row::DELEGATE_METHODS.each do |name|
+      define_method(name) do |location|
+        @row.white_then_flip(location).public_send(name)
+      end
+    end
+
+    ################################################################################
   end
 end

data/lib/bioshogi/player/soldier_methods.rb

@@ -23,7 +23,7 @@ module Bioshogi
       # 入玉している？
       def king_soldier_entered?
         if soldier = king_soldier
-          soldier.place.promotable?(location)
+          soldier.place.opp_side?(location)
         end
       end
 
@@ -36,7 +36,7 @@ module Bioshogi
       def entered_soldiers
         soldiers.find_all do |e|
           if e.piece.key != :king
-            e.place.promotable?(location)
+            e.place.opp_side?(location)
           end
         end
       end

data/lib/bioshogi/screen_image/core_methods.rb

@@ -31,8 +31,8 @@ module Bioshogi
               :lattice_stroke_width     => 1,                           # 格子の線の太さ
               :inner_frame_stroke_width => 2,                           # 枠の線お太さ(nil なら lattice_stroke_width を代用)
               :inner_frame_fill_color   => nil,                         # 基本透明とする(基本指定なしでよい)
-              :dimension_w              => Dimension::PlaceX.dimension, # 横のセル数
-              :dimension_h              => Dimension::PlaceY.dimension, # 縦のセル数
+              :dimension_w              => Dimension::Column.dimension_size, # 横のセル数
+              :dimension_h              => Dimension::Row.dimension_size, # 縦のセル数
               :fg_file                  => nil,                         # 盤テクスチャ
 
               # optional

data/lib/bioshogi/screen_image/pentagon.rb

@@ -109,8 +109,8 @@ module Bioshogi
         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,
+            cx + x * scale * location.sign_dir,
+            cy + y * scale * location.sign_dir,
           ]
         end
       end

data/lib/bioshogi/screen_image/soldier_methods.rb

@@ -125,7 +125,7 @@ module Bioshogi
       # フォントの位置を微調整
       def piece_char_adjust(location)
         @piece_char_adjust ||= {}
-        @piece_char_adjust[location.key] ||= V[*params[:piece_char_adjust][location.key]] * location.value_sign
+        @piece_char_adjust[location.key] ||= V[*params[:piece_char_adjust][location.key]] * location.sign_dir
       end
 
       def soldier_font_scale(piece)

data/lib/bioshogi/screen_image/stand.rb

@@ -37,7 +37,7 @@ module Bioshogi
 
         container.players.each do |player|
           location = player.location
-          s = location.value_sign
+          s = location.sign_dir
 
           if player.location.key == :black
             v = v_bottom_right_outer
@@ -85,7 +85,7 @@ module Bioshogi
       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
+          v = v + V[*params[:piece_count_position_adjust][w]] * location.sign_dir
           piece_count_bg_draw(v: v, location: location)
           char_draw(
             :layer        => @d_piece_count_layer,
@@ -106,9 +106,9 @@ module Bioshogi
           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)
+            # v2 = v + V[*params[:piece_count_bg_adjust][w]] * location.sign_dir
+            # v2 = v + (V.half + V[*params[:piece_count_bg_adjust]]) * location.sign_dir
+            # g.ellipse(*px(v2), *(cell_rect * params[:piece_count_bg_scale] * location.sign_dir), 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)で表示するのでその位置に移動する