ruby-miyako-mswin32 2.1.10 → 2.1.11

data/lib/Miyako/API/layout.rb

@@ -47,6 +47,9 @@ class Numeric
 end
 
 module Miyako
+  # for init_layout
+  module Screen
+  end
 
   #==レイアウト情報を示す構造体
   LayoutStruct = Struct.new(:pos, :size, :base, :snap, :on_move)
@@ -74,7 +77,7 @@ module Miyako
       @layout = LayoutStruct.new
       @layout.pos  = Point.new(0, 0)
       @layout.size = Size.new(0, 0)
-      @layout.base = Screen
+      @layout.base = Miyako::Screen
       @layout.snap = LayoutSnapStruct.new(nil, Array.new)
       @layout.on_move = []
     end
@@ -110,162 +113,162 @@ module Miyako
     #  move,move_toの各メソッド。
     #返却値:: ブロック管理配列
     def on_move
-			return @layout.on_move
+      return @layout.on_move
     end
 
     #===mixinしたインスタンスの位置を左端(x軸)に移動させる
-		#設置するとき、基準となる空間の内側に設置される
+    #設置するとき、基準となる空間の内側に設置される
     #ブロックでは、数値を返却することで、左端からのマージンを設定できる(正の方向へ移動)
     #ブロック引数は、自分自身の幅
     #返却値:: 自分自身
     def left!(&margin)
-			base = @layout.base.rect
-			t = @layout.pos[0]
-			@layout.pos[0] = base[0] + (margin ? margin[base[2]].to_i : 0)
+      base = @layout.base.rect
+      t = @layout.pos[0]
+      @layout.pos[0] = base[0] + (margin ? margin[base[2]].to_i : 0)
       @layout.snap.children.each{|c| c.left(&margin) }
       update_layout(@layout.pos[0]-t, 0)
       @layout.on_move.each{|block|
         block.call(self, @layout.pos[0], @layout.pos[1], @layout.pos[0]-t, 0)
       }
-			return self
+      return self
     end
 
     #===mixinしたインスタンスの位置を左端(x軸)に移動させる
-		#設置するとき、基準となる空間の外側に設置される
+    #設置するとき、基準となる空間の外側に設置される
     #ブロックでは、数値を返却することで、左端からのマージンを設定できる(負の方向へ移動)
     #ブロック引数は、自分自身の幅
     #返却値:: 自分自身
     def outside_left!(&margin)
-			base = @layout.base.rect
-			t = @layout.pos[0]
-			@layout.pos[0] = base[0] - @layout.size[0] - (margin ? margin[base[2]].to_i : 0)
+      base = @layout.base.rect
+      t = @layout.pos[0]
+      @layout.pos[0] = base[0] - @layout.size[0] - (margin ? margin[base[2]].to_i : 0)
       update_layout(@layout.pos[0]-t, 0)
       @layout.on_move.each{|block|
         block.call(self, @layout.pos[0], @layout.pos[1], @layout.pos[0]-t, 0)
       }
-			return self
+      return self
     end
 
     #===mixinしたインスタンスの位置を中間(ｘ軸)に移動させる
     #返却値:: 自分自身
     def center!
-			base = @layout.base.rect
-			t = @layout.pos[0]
-			@layout.pos[0] = base[0] + (base[2] >> 1) - (@layout.size[0] >> 1)
+      base = @layout.base.rect
+      t = @layout.pos[0]
+      @layout.pos[0] = base[0] + (base[2] >> 1) - (@layout.size[0] >> 1)
       update_layout(@layout.pos[0]-t, 0)
       @layout.on_move.each{|block|
         block.call(self, @layout.pos[0], @layout.pos[1], @layout.pos[0]-t, 0)
       }
-			return self
+      return self
     end
 
     #===mixinしたインスタンスの位置を右端(ｘ軸)に移動させる
-		#設置するとき、基準となる空間の内側に設置される
+    #設置するとき、基準となる空間の内側に設置される
     #ブロックでは、数値を返却することで、右端からのマージンを設定できる(負の方向へ移動)
     #ブロック引数は、自分自身の幅
     #返却値:: 自分自身
     def right!(&margin)
-			base = @layout.base.rect
-			t = @layout.pos[0]
-			@layout.pos[0] = base[0] + base[2] - @layout.size[0] - (margin ? margin[base[2]].to_i : 0)
+      base = @layout.base.rect
+      t = @layout.pos[0]
+      @layout.pos[0] = base[0] + base[2] - @layout.size[0] - (margin ? margin[base[2]].to_i : 0)
       update_layout(@layout.pos[0]-t, 0)
       @layout.on_move.each{|block|
         block.call(self, @layout.pos[0], @layout.pos[1], @layout.pos[0]-t, 0)
       }
-			return self
+      return self
     end
 
     #===mixinしたインスタンスの位置を右端(ｘ軸)に移動させる
-		#設置するとき、基準となる空間の外側に設置される
+    #設置するとき、基準となる空間の外側に設置される
     #ブロックでは、数値を返却することで、右端からのマージンを設定できる(正の方向へ移動)
     #ブロック引数は、自分自身の幅
     #返却値:: 自分自身
     def outside_right!(&margin)
-			base = @layout.base.rect
-			t = @layout.pos[0]
-			@layout.pos[0] = base[0] + base[2] + (margin ? margin[base[2]].to_i : 0)
+      base = @layout.base.rect
+      t = @layout.pos[0]
+      @layout.pos[0] = base[0] + base[2] + (margin ? margin[base[2]].to_i : 0)
       update_layout(@layout.pos[0]-t, 0)
       @layout.on_move.each{|block|
         block.call(self, @layout.pos[0], @layout.pos[1], @layout.pos[0]-t, 0)
       }
-			return self
+      return self
     end
 
     #===mixinしたインスタンスの位置を上端(y軸)に移動させる
-		#設置するとき、基準となる空間の内側に設置される
+    #設置するとき、基準となる空間の内側に設置される
     #ブロックでは、数値を返却することで、上端からのマージンを設定できる(正の方向へ移動)
     #ブロック引数は、自分自身の幅
     #返却値:: 自分自身
     def top!(&margin)
-			base = @layout.base.rect
-			t = @layout.pos[1]
-			@layout.pos[1] = base[1] + (margin ? margin[base[3]].to_i : 0)
+      base = @layout.base.rect
+      t = @layout.pos[1]
+      @layout.pos[1] = base[1] + (margin ? margin[base[3]].to_i : 0)
       update_layout(0, @layout.pos[1]-t)
       @layout.on_move.each{|block|
         block.call(self, @layout.pos[0], @layout.pos[1], 0, @layout.pos[1]-t)
       }
-			return self
+      return self
     end
 
     #===mixinしたインスタンスの位置を上端(y軸)に移動させる
-		#設置するとき、基準となる空間の内側に設置される
+    #設置するとき、基準となる空間の内側に設置される
     #ブロックでは、数値を返却することで、上端からのマージンを設定できる(負の方向へ移動)
     #ブロック引数は、自分自身の幅
     #返却値:: 自分自身
     def outside_top!(&margin)
-			base = @layout.base.rect
-			t = @layout.pos[1]
-			@layout.pos[1] = base[1] - @layout.size[1] - (margin ? margin[base[3]].to_i : 0)
+      base = @layout.base.rect
+      t = @layout.pos[1]
+      @layout.pos[1] = base[1] - @layout.size[1] - (margin ? margin[base[3]].to_i : 0)
       update_layout(0, @layout.pos[1]-t)
       @layout.on_move.each{|block|
         block.call(self, @layout.pos[0], @layout.pos[1], 0, @layout.pos[1]-t)
       }
-			return self
+      return self
     end
 
     #===mixinしたインスタンスの位置を中間(y軸)に移動させる
     #返却値:: 自分自身
     def middle!
-			base = @layout.base.rect
-			t = @layout.pos[1]
-			@layout.pos[1] = base[1] + (base[3] >> 1) - (@layout.size[1] >> 1)
+      base = @layout.base.rect
+      t = @layout.pos[1]
+      @layout.pos[1] = base[1] + (base[3] >> 1) - (@layout.size[1] >> 1)
       update_layout(0, @layout.pos[1]-t)
       @layout.on_move.each{|block|
         block.call(self, @layout.pos[0], @layout.pos[1], 0, @layout.pos[1]-t)
       }
-			return self
+      return self
     end
 
     #===mixinしたインスタンスの位置を下端(y軸)に移動させる
-		#設置するとき、基準となる空間の内側に設置される
+    #設置するとき、基準となる空間の内側に設置される
     #ブロックでは、数値を返却することで、下端からのマージンを設定できる(負の方向へ移動)
     #ブロック引数は、自分自身の幅
     #返却値:: 自分自身
     def bottom!(&margin)
-			base = @layout.base.rect
-			t = @layout.pos[1]
-			@layout.pos[1] = base[1] + base[3] - @layout.size[1] - (margin ? margin[base[3]].to_i : 0)
+      base = @layout.base.rect
+      t = @layout.pos[1]
+      @layout.pos[1] = base[1] + base[3] - @layout.size[1] - (margin ? margin[base[3]].to_i : 0)
       update_layout(0, @layout.pos[1]-t)
       @layout.on_move.each{|block|
         block.call(self, @layout.pos[0], @layout.pos[1], 0, @layout.pos[1]-t)
       }
-			return self
+      return self
     end
 
     #===mixinしたインスタンスの位置を下端(y軸)に移動させる
-		#設置するとき、基準となる空間の外側に設置される
+    #設置するとき、基準となる空間の外側に設置される
     #ブロックでは、数値を返却することで、下端からのマージンを設定できる(正の方向へ移動)
     #ブロック引数は、自分自身の幅
     #返却値:: 自分自身
     def outside_bottom!(&margin)
-			base = @layout.base.rect
-			t = @layout.pos[1]
-			@layout.pos[1] = base[1] + base[3] + (margin ? margin[base[3]].to_i : 0)
+      base = @layout.base.rect
+      t = @layout.pos[1]
+      @layout.pos[1] = base[1] + base[3] + (margin ? margin[base[3]].to_i : 0)
       update_layout(0, @layout.pos[1]-t)
       @layout.on_move.each{|block|
         block.call(self, @layout.pos[0], @layout.pos[1], 0, @layout.pos[1]-t)
       }
-			return self
+      return self
     end
 
     #===インスタンスを画面(スナップ先インスタンス)の中心に移動する
@@ -277,137 +280,137 @@ module Miyako
     end
 
     #===mixinしたインスタンスの位置を左端(x軸)に移動させたときの位置を返す
-		#但し、移動したときの位置を返すだけで、自身の位置は変わらない
-		#基準となる空間の内側に設置されたとして算出する
+    #但し、移動したときの位置を返すだけで、自身の位置は変わらない
+    #基準となる空間の内側に設置されたとして算出する
     #ブロックでは、数値を返却することで、左端からのマージンを設定できる(正の方向へ移動)
     #ブロック引数は、自分自身の幅
     #返却値:: 移動後の位置(Position構造体)
     def left(&margin)
-			base = @layout.base.rect
-			pos = @layout.pos.dup
-			pos[0] = base[0] + (margin ? margin[base[2]].to_i : 0)
+      base = @layout.base.rect
+      pos = @layout.pos.dup
+      pos[0] = base[0] + (margin ? margin[base[2]].to_i : 0)
       return pos
     end
 
     #===mixinしたインスタンスの位置を左端(x軸)に移動させたときの位置を返す
-		#但し、移動したときの位置を返すだけで、自身の位置は変わらない
-		#基準となる空間の外側に設置されたとして算出する
+    #但し、移動したときの位置を返すだけで、自身の位置は変わらない
+    #基準となる空間の外側に設置されたとして算出する
     #ブロックでは、数値を返却することで、左端からのマージンを設定できる(負の方向へ移動)
     #ブロック引数は、自分自身の幅
     #返却値:: 移動後の位置(Position構造体)
     def outside_left(&margin)
-			base = @layout.base.rect
-			pos = @layout.pos.dup
-			pos[0] = base[0] - @layout.size[0] - (margin ? margin[base[2]].to_i : 0)
+      base = @layout.base.rect
+      pos = @layout.pos.dup
+      pos[0] = base[0] - @layout.size[0] - (margin ? margin[base[2]].to_i : 0)
       return pos
     end
 
     #===mixinしたインスタンスの位置を中間(ｘ軸)に移動させたときの位置を返す
-		#但し、移動したときの位置を返すだけで、自身の位置は変わらない
+    #但し、移動したときの位置を返すだけで、自身の位置は変わらない
     #返却値:: 移動後の位置(Position構造体)
     def center
-			base = @layout.base.rect
-			pos = @layout.pos.dup
-			pos[0] = base[0] + (base[2] >> 1) - (@layout.size[0] >> 1)
+      base = @layout.base.rect
+      pos = @layout.pos.dup
+      pos[0] = base[0] + (base[2] >> 1) - (@layout.size[0] >> 1)
       return pos
     end
 
     #===mixinしたインスタンスの位置を右端(ｘ軸)に移動させたときの位置を返す
-		#但し、移動したときの位置を返すだけで、自身の位置は変わらない
-		#基準となる空間の内側に設置されたとして算出する
+    #但し、移動したときの位置を返すだけで、自身の位置は変わらない
+    #基準となる空間の内側に設置されたとして算出する
     #ブロックでは、数値を返却することで、右端からのマージンを設定できる(負の方向へ移動)
     #ブロック引数は、自分自身の幅
     #返却値:: 移動後の位置(Position構造体)
     def right(&margin)
-			base = @layout.base.rect
-			pos = @layout.pos.dup
-			pos[0] = base[0] + base[2] - @layout.size[0] - (margin ? margin[base[2]].to_i : 0)
+      base = @layout.base.rect
+      pos = @layout.pos.dup
+      pos[0] = base[0] + base[2] - @layout.size[0] - (margin ? margin[base[2]].to_i : 0)
       return pos
     end
 
     #===mixinしたインスタンスの位置を右端(ｘ軸)に移動させたときの位置を返す
-		#但し、移動したときの位置を返すだけで、自身の位置は変わらない
-		#基準となる空間の外側に設置されたとして算出する
+    #但し、移動したときの位置を返すだけで、自身の位置は変わらない
+    #基準となる空間の外側に設置されたとして算出する
     #ブロックでは、数値を返却することで、右端からのマージンを設定できる(正の方向へ移動)
     #ブロック引数は、自分自身の幅
     #返却値:: 移動後の位置(Position構造体)
     def outside_right(&margin)
-			base = @layout.base.rect
-			pos = @layout.pos.dup
-			pos[0] = base[0] + base[2] + (margin ? margin[base[2]].to_i : 0)
+      base = @layout.base.rect
+      pos = @layout.pos.dup
+      pos[0] = base[0] + base[2] + (margin ? margin[base[2]].to_i : 0)
       return pos
     end
 
     #===mixinしたインスタンスの位置を上端(y軸)に移動させたときの位置を返す
-		#但し、移動したときの位置を返すだけで、自身の位置は変わらない
-		#基準となる空間の内側に設置されたとして算出する
+    #但し、移動したときの位置を返すだけで、自身の位置は変わらない
+    #基準となる空間の内側に設置されたとして算出する
     #ブロックでは、数値を返却することで、上端からのマージンを設定できる(正の方向へ移動)
     #ブロック引数は、自分自身の幅
     #返却値:: 移動後の位置(Position構造体)
     def top(&margin)
-			base = @layout.base.rect
-			pos = @layout.pos.dup
-			pos[1] = base[1] + (margin ? margin[base[3]].to_i : 0)
+      base = @layout.base.rect
+      pos = @layout.pos.dup
+      pos[1] = base[1] + (margin ? margin[base[3]].to_i : 0)
       return pos
     end
 
     #===mixinしたインスタンスの位置を上端(y軸)に移動させたときの位置を返す
-		#但し、移動したときの位置を返すだけで、自身の位置は変わらない
-		#基準となる空間の外側に設置されたとして算出する
+    #但し、移動したときの位置を返すだけで、自身の位置は変わらない
+    #基準となる空間の外側に設置されたとして算出する
     #ブロックでは、数値を返却することで、上端からのマージンを設定できる(負の方向へ移動)
     #ブロック引数は、自分自身の幅
     #返却値:: 移動後の位置(Position構造体)
     def outside_top(&margin)
-			base = @layout.base.rect
-			pos = @layout.pos.dup
-			pos[1] = base[1] - @layout.size[1] - (margin ? margin[base[3]].to_i : 0)
+      base = @layout.base.rect
+      pos = @layout.pos.dup
+      pos[1] = base[1] - @layout.size[1] - (margin ? margin[base[3]].to_i : 0)
       return pos
     end
 
     #===mixinしたインスタンスの位置を中間(y軸)に移動させたときの位置を返す
-		#但し、移動したときの位置を返すだけで、自身の位置は変わらない
+    #但し、移動したときの位置を返すだけで、自身の位置は変わらない
     #返却値:: 移動後の位置(Position構造体)
     def middle
-			base = @layout.base.rect
-			pos = @layout.pos.dup
-			pos[1] = base[1] + (base[3] >> 1) - (@layout.size[1] >> 1)
+      base = @layout.base.rect
+      pos = @layout.pos.dup
+      pos[1] = base[1] + (base[3] >> 1) - (@layout.size[1] >> 1)
       return pos
     end
 
     #===mixinしたインスタンスの位置を下端(y軸)に移動させたときの位置を返す
-		#但し、移動したときの位置を返すだけで、自身の位置は変わらない
-		#基準となる空間の内側に設置されたとして算出する
+    #但し、移動したときの位置を返すだけで、自身の位置は変わらない
+    #基準となる空間の内側に設置されたとして算出する
     #ブロックでは、数値を返却することで、下端からのマージンを設定できる(負の方向へ移動)
     #ブロック引数は、自分自身の幅
     #返却値:: 移動後の位置(Position構造体)
     def bottom(&margin)
-			base = @layout.base.rect
-			pos = @layout.pos.dup
-			pos[1] = base[1] + base[3] - @layout.size[1] - (margin ? margin[base[3]].to_i : 0)
+      base = @layout.base.rect
+      pos = @layout.pos.dup
+      pos[1] = base[1] + base[3] - @layout.size[1] - (margin ? margin[base[3]].to_i : 0)
       return pos
     end
 
     #===mixinしたインスタンスの位置を下端(y軸)に移動させたときの位置を返す
-		#但し、移動したときの位置を返すだけで、自身の位置は変わらない
-		#基準となる空間の外側に設置されたとして算出する
+    #但し、移動したときの位置を返すだけで、自身の位置は変わらない
+    #基準となる空間の外側に設置されたとして算出する
     #ブロックでは、数値を返却することで、下端からのマージンを設定できる(正の方向へ移動)
     #ブロック引数は、自分自身の幅
     #返却値:: 移動後の位置(Position構造体)
     def outside_bottom(&margin)
-			base = @layout.base.rect
-			pos = @layout.pos.dup
-			pos[1] = base[1] + base[3] + (margin ? margin[base[3]].to_i : 0)
+      base = @layout.base.rect
+      pos = @layout.pos.dup
+      pos[1] = base[1] + base[3] + (margin ? margin[base[3]].to_i : 0)
       return pos
     end
 
     #===インスタンスを画面(スナップ先インスタンス)の中心に移動したときの位置を返す
-		#但し、移動したときの位置を返すだけで、自身の位置は変わらない
+    #但し、移動したときの位置を返すだけで、自身の位置は変わらない
     #返却値:: 移動後の位置(Position構造体)
     def centering
-			base = @layout.base.rect
-			pos = @layout.pos.dup
-			pos[0] = base[0] + (base[2] >> 1) - (@layout.size[0] >> 1)
-			pos[1] = base[1] + (base[3] >> 1) - (@layout.size[1] >> 1)
+      base = @layout.base.rect
+      pos = @layout.pos.dup
+      pos[0] = base[0] + (base[2] >> 1) - (@layout.size[0] >> 1)
+      pos[1] = base[1] + (base[3] >> 1) - (@layout.size[1] >> 1)
       return pos
     end
 
@@ -461,7 +464,7 @@ module Miyako
     alias :layout_size :size
 
     #===インスタンスのサイズをレイアウト情報に反映させる
-		#このメソッドが呼び出されると、スナップ先のインスタンスの位置情報がリセットされることに注意
+    #このメソッドが呼び出されると、スナップ先のインスタンスの位置情報がリセットされることに注意
     #_w_:: インスタンスの幅(たとえば、Sprite#ow の値)
     #_h_:: インスタンスの幅(たとえば、Sprite#oh の値)
     #返却値:: 自分自身を返す
@@ -508,7 +511,7 @@ module Miyako
     end
 
     #===すべてのインスタンスとの依存関係を解消する
-		#このメソッドが呼び出されると、スナップ先のインスタンスの位置情報がリセットされることに注意
+    #このメソッドが呼び出されると、スナップ先のインスタンスの位置情報がリセットされることに注意
     #返却値:: 自分自身を返す
     def reset_snap
       @layout.snap.sprite = nil
@@ -616,9 +619,9 @@ module Miyako
     # 生成される線分は、x方向が[pos.x,pos.x+ow-1]、y方向が[pos.y,pos.y+oh-1]となる
     #返却値:: 生成したSegments構造体インスタンス
     def segment
-			return Segments.new([@layout.pos[0],
+      return Segments.new([@layout.pos[0],
                           @layout.pos[0]+@layout.size[0]-1],
-			                   [@layout.pos[1],
+                         [@layout.pos[1],
                           @layout.pos[1]+@layout.size[1]-1])
     end
   end

data/lib/Miyako/API/modules.rb

@@ -86,6 +86,18 @@ module Miyako
       return 0
     end
 
+    #=== mixin されたインスタンスの部分矩形開始位置(x軸)を取得する
+    #返却値:: 部分矩形開始位置(デフォルトは0)
+    def ox=(v)
+      v
+    end
+
+    #=== mixin されたインスタンスの部分矩形開始位置(y軸)を取得する
+    #返却値::部分矩形開始位置(デフォルトは0)
+    def oy=(v)
+      v
+    end
+
     #=== mixin されたインスタンスの部分矩形幅を取得する
     #返却値:: インスタンスの幅(デフォルトは0)
     def ow
@@ -98,6 +110,18 @@ module Miyako
       return 0
     end
 
+    #=== mixin されたインスタンスの部分矩形幅を取得する
+    #返却値:: インスタンスの幅(デフォルトは0)
+    def ow=(v)
+      v
+    end
+
+    #=== mixin されたインスタンスの部分矩形高を取得する
+    #返却値:: インスタンスの高さ(デフォルトは0)
+    def oh=(v)
+      v
+    end
+
     #=== スプライトの部分矩形を返す
     #返却値:: Rect構造体インスタンス(デフォルトはnil)
     def part_rect
@@ -284,7 +308,7 @@ module Miyako
     #_v_:: 設定する値(true/false)
     #返却値:: 自分自身を返す
     def visible=(v)
-      self.sprite_only.each{|e| e.visible = v}
+      self.each{|e| e.visible = v if e.class.include?(SpriteBase) || e.class.include?(SpriteArray)}
       return self
     end
 
@@ -308,9 +332,9 @@ module Miyako
     #返却値:: 自分自身を返す
     def move!(dx, dy)
       if block_given?
-        self.sprite_only.each_with_index{|e, i| e.move!(*(yield e, i, dx, dy))}
+        self.each_with_index{|e, i| e.move!(*(yield e, i, dx, dy)) if e.class.include?(SpriteBase) || e.class.include?(SpriteArray)}
       else
-        self.sprite_only.each{|e| e.move!(dx, dy)}
+        self.each{|e| e.move!(dx, dy) if e.class.include?(SpriteBase) || e.class.include?(SpriteArray)}
       end
       self
     end
@@ -335,9 +359,9 @@ module Miyako
     #返却値:: 自分自身を返す
     def move_to!(x, y)
       if block_given?
-        self.sprite_only.each_with_index{|e, i| e.move_to!(*(yield e, i, x, y))}
+        self.each_with_index{|e, i| e.move_to!(*(yield e, i, x, y)) if  e.class.include?(SpriteBase) || e.class.include?(SpriteArray)}
       else
-        self.sprite_only.each{|e| e.move_to!(x, y)}
+        self.each{|e| e.move_to!(x, y) if e.class.include?(SpriteBase) || e.class.include?(SpriteArray)}
       end
       self
     end
@@ -346,7 +370,7 @@ module Miyako
     #各要素のstartメソッドを呼び出す
     #返却値:: 自分自身を返す
     def start
-      self.sprite_only.each{|sprite| sprite.start }
+      self.each{|sprite| sprite.start if e.class.include?(SpriteBase) || e.class.include?(SpriteArray) }
       return self
     end
 
@@ -354,7 +378,7 @@ module Miyako
     #各要素のstopメソッドを呼び出す
     #返却値:: 自分自身を返す
     def stop
-      self.sprite_only.each{|sprite| sprite.stop }
+      self.each{|sprite| sprite.stop if e.class.include?(SpriteBase) || e.class.include?(SpriteArray) }
       return self
     end
 
@@ -362,7 +386,7 @@ module Miyako
     #各要素のresetメソッドを呼び出す
     #返却値:: 自分自身を返す
     def reset
-      self.sprite_only.each{|sprite| sprite.reset }
+      self.each{|sprite| sprite.reset if e.class.include?(SpriteBase) || e.class.include?(SpriteArray) }
       return self
     end
 
@@ -370,9 +394,7 @@ module Miyako
     #各要素のupdate_animationメソッドを呼び出す
     #返却値:: 描く画像のupdate_spriteメソッドを呼び出した結果を配列で返す
     def update_animation
-      self.sprite_only.map{|e|
-        e.update_animation
-      }
+      self.map{|e| (e.class.include?(SpriteBase) || e.class.include?(SpriteArray)) ? e.update_animation : false }
     end
 
     #===指定した要素の内容を入れ替える
@@ -393,7 +415,7 @@ module Miyako
     #描画するインスタンスは、SpriteBaseモジュールがmixinされているクラスのみ
     #返却値:: 自分自身を帰す
     def render
-      self.sprite_only.each{|e| e.render }
+      self.each{|e| e.render if  e.class.include?(SpriteBase) || e.class.include?(SpriteArray) }
       return self
     end
 
@@ -402,9 +424,34 @@ module Miyako
     #_dst_:: 描画対象の画像インスタンス
     #返却値:: 自分自身を帰す
     def render_to(dst)
-      self.each{|e| e.render_to(dst) }
+      self.each{|e| e.render_to(dst) if  e.class.include?(SpriteBase) || e.class.include?(SpriteArray) }
       return self
     end
+
+    #===位置を指定して画面への描画を指示するメソッドのテンプレート
+    #オブジェクトで保持している位置情報ではなく、引数で渡された位置に描画する
+    #基本的に、メソッドのオーバーライドにより機能するが、pos,move_to!メソッドを持っているときは、
+    #これらのメソッドを呼び出して同じ動作を行うが処理速度的に課題あり
+    #ただし、上記のメソッドを持っていない場合は、単純にrenderメソッドを呼び出す
+    #_x_:: 描画位置のx座標
+    #_y_:: 描画位置のy座標
+    #返却値:: 自分自身を返す
+    def render_xy(x, y)
+      return self.each{|e| e.render_xy(x, y) if  e.class.include?(SpriteBase) || e.class.include?(SpriteArray) }
+    end
+
+    #===位置を指定して画像への描画を指示するメソッドのテンプレート
+    #オブジェクトで保持している位置情報ではなく、引数で渡された位置に描画する
+    #基本的に、メソッドのオーバーライドにより機能するが、pos,move_to!メソッドを持っているときは、
+    #これらのメソッドを呼び出して同じ動作を行うが、処理速度的に課題あり
+    #ただし、上記のメソッドを持っていない場合は、単純にrender_toメソッドを呼び出す
+    #_dst_:: 対象の画像
+    #_x_:: 描画位置のx座標
+    #_y_:: 描画位置のy座標
+    #返却値:: 自分自身を返す
+    def render_xy_to(dst, x, y)
+      return self.each{|e| e.render_xy_to(dst, x, y) if e.class.include?(SpriteBase) || e.class.include?(SpriteArray)}
+    end
   end
 
   #==ディープコピーを実装するモジュール