cyross-ruby-miyako 2.0.0 → 2.0.5.1.0

data/lib/Miyako/API/choices.rb

@@ -2,7 +2,7 @@
 =begin
 --
 Miyako v2.0
-Copyright (C) 2007-2008  Cyross Makoto
+Copyright (C) 2007-2009  Cyross Makoto
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
@@ -22,10 +22,10 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 
 module Miyako
   #==選択肢構造体
-  #選択肢を構成する要素の集合
+  # 選択肢を構成する要素の集合
   #
-  #複数のChoice構造体のインスタンスをまとめて、配列として構成されている
-  #選択肢を表示させるときは、body 自体の表示位置を変更させる必要がある
+  # 複数のChoice構造体のインスタンスをまとめて、配列として構成されている
+  # 選択肢を表示させるときは、body 自体の表示位置を変更させる必要がある
   #
   #_body_:: 選択肢を示す画像
   #_body_selected_:: 選択肢を示す画像(選択時) 
@@ -37,10 +37,14 @@ module Miyako
   #_up_:: 上方向を選択したときに参照するChoice構造体のインスタンス
   #_down_:: 下方向を選択したときに参照するChoice構造体のインスタンス
   #_base_:: 構造体が要素となっている配列
-  Choice = Struct.new(:body, :body_selected, :condition, :selected, :result, :left, :right, :up, :down, :base)
+  #_attribute_:: 属性を示すハッシュ
+  #_end_select_proc_:: この選択肢を選択したときに優先的に処理するブロック。
+  #ブロックは1つの引数を取る(コマンド選択テキストボックス))。
+  #デフォルトはnil(何もしない)
+  Choice = Struct.new(:body, :body_selected, :condition, :selected, :result, :left, :right, :up, :down, :base, :attribute, :end_select_proc)
 
   #==選択肢を管理するクラス
-  #選択肢は、Shapeクラスから生成したスプライトもしくは画像で構成される
+  # 選択肢は、Shapeクラスから生成したスプライトもしくは画像で構成される
   class Choices
     include Layout
     include SpriteBase
@@ -48,18 +52,34 @@ module Miyako
     include Enumerable
     extend Forwardable
 
+    attr_accessor :visible #レンダリングの可否(true->描画 false->非描画)
+
     # インスタンスを生成する
     # 返却値:: 生成された Choices クラスのインスタンス
     def initialize
+      init_layout
       @choices = []
       @now = nil
       @non_select = false
       @last_selected = nil
+      @result = nil
+      @visible = true
+      set_layout_size(1, 1)
+    end
+
+    def update_layout_position #:nodoc:
+      dx = @layout.pos[0] - rect[0]
+      dy = @layout.pos[1] - rect[1]
+      @choices.each{|ch|
+        ch.each{|cc|
+          cc.body.move(dx, dy)
+          cc.body_selected.move(dx, dy) if cc.body_selected && cc.body != cc.body_selected
+        }
+      }
     end
 
     # 選択肢を作成する
     # Choice 構造体のインスタンスを作成する
-    # 
     # 構造体には、引数bodyと、必ず true を返す条件ブロックが登録されている。残りは nil
     #_body_:: 選択肢を示す画像
     #_body_selected_:: 選択肢を示す画像(選択時)。デフォルトはnil
@@ -67,7 +87,7 @@ module Miyako
     #返却値:: 生成された Choice構造体のインスタンス
     def Choices.create_choice(body, body_selected = nil, selected = false)
       choice = Choice.new(body, body_selected, Proc.new{ true }, selected,
-                          nil, nil, nil, nil, nil, nil)
+                          nil, nil, nil, nil, nil, nil, {}, nil)
       choice.left = choice
       choice.right = choice
       choice.up = choice
@@ -80,6 +100,8 @@ module Miyako
       choices.each{|v| v.base = choices}
       @choices.push(choices)
       @last_selected = @choices[0][0] if (@choices.length == 1 && @last_selcted == nil)
+      rect = self.broad_rect
+      set_layout_size(rect.w, rect.h)
       return self
     end
 
@@ -96,32 +118,76 @@ module Miyako
 
     def_delegators(:@choices, :push, :pop, :shift, :unshift, :[], :[]=, :clear, :length)
 
+    #===選択を開始しているかどうかを問い合わせる
+    # start_choiceメソッドを呼び出して、コマンド選択が始まっているかどうかを問い合わせ、始まっているときはtrueを返す
+    #返却値:: 選択を開始しているときはtrueを返す
+    def choicing?
+      return @now != nil
+    end
+
     #===選択を開始する
-    #選択肢の初期位置を指定することができる
+    # 選択肢の初期位置を指定することができる
+    # 第1引数にnilを渡すと、最後に選択した選択肢が最初に選択状態にある選択肢となる
+    # (例)
+    # choices.start_choice # [0][0]で示す位置の選択肢を選択する
+    # choices.start_choice(5,1) # [5][1]で示す位置の選択肢を選択する
+    # choices.start_choice(nil) # 最後に選択した選択肢を選択する(未選択だったときは全省略時の呼び出しと等価)
     #_x_:: 初期位置(x 座標)。規定値は 0。nilを渡すと、最後に選択した選択肢が選ばれる。
     #_y_:: 初期位置(y 座標)。規定値は 0
     def start_choice(x = 0, y = 0)
-      raise MiyakoError, "Illegal choice position! [#{x}][#{y}]" if (x != nil && x < 0 || x >= @choices.length || y < 0 || y >= @choices[x].length)
+      raise MiyakoError, "Illegal choice position! [#{x}][#{y}]" if (x != nil && (x < 0 || x >= @choices.length || y < 0 || y >= @choices[x].length))
       @now = x ? @choices[x][y] : @last_selected
       @now.selected = true
       @last_selected = @now
       @non_select = false
+      @result = nil
+    end
+
+    #===選択を終了する
+    # 選択の終了処理を行う
+    # 引数に選択に使用したテキストボックスを渡し、選択状態にあるしたChoice構造体に
+    #end_select_procブロックを渡しているとき、そのブロックを評価する
+    # (そのとき、引数とした渡ってきたテキストボックスをブロック引数に取る)。
+    #
+    #_command_box_:: 選択に使用したテキストボックス。デフォルトはnil
+    def end_choice(command_box = nil)
+      return unless @now
+      return @now.end_select_proc.call(command_box) if (command_box != nil && @now.end_select_proc != nil)
+      @result = @now.result
+      @now.selected = false
+      @last_selected = @now
+      @now = nil
+      @non_select = true
     end
 
     #===選択肢本体を取得する
-    #選択肢の表示対象となる
-    #返却値::
+    # 選択肢の表示対象となるインスタンスを取得する
+    # Choice構造体にbody_selectedが設定されている時はbody_selected、そうでなければbodyを返す
+    # まだ選択が開始されていなければnilが返る
+    #返却値:: 選択肢本体(選択時)
     def body
+      return nil unless @now
       return @now.body_selected ? @now.body_selected : @now.body
     end
 
     #===選択結果を取得する
-    #現在の選択肢が所持している結果インスタンスを返す
+    # 現在の選択肢が所持している結果インスタンスを返す
+    # まだ選択が開始されていなければnilが返る
     #返却値:: 選択結果
     def result
+      return @result unless @now
       return @now.result
     end
 
+    #===現在選択している選択肢の属性をアクセスする
+    # 属性を編集・参照できるハッシュを取得する
+    # まだ選択が開始されていなければnilが返る
+    #返却値:: 属性(対応するChoice#attributeメソッドの値)
+    def attribute
+      return nil unless @now
+      return @now.attribute
+    end
+
     def update_choices(org, nxt) #:nodoc:
       obase = org.base
       nbase = nxt.base
@@ -143,27 +209,73 @@ module Miyako
     #現在の選択状態を、全部選択していない状態にする
     #返却値:: 自分自身を返す
     def non_select
-      @now.base.each{|c| c.selected = false }
+      @now.base.each{|c| c.selected = false } if @now
       @non_select = true
       return self
     end
 
+    #===選択肢が選択状態かを問い合わせる
+    #現在、選択肢が選択状態か非選択状態(non_selectメソッド呼び出しなど)かを問い合わせる
+    #返却値:: 選択状態ならtrue、非選択状態ならfalseを返す
+    def any_select?
+      return !@non_select
+    end
+
     #===選択肢を変更する
-    #現在の選択状態を、全部選択していない状態にする
+    #指定の位置の現在の選択状態を、選択状態にする
     #_x_:: x方向位置
     #_y_:: y方向位置
     #返却値:: 自分自身を返す
     def select(x, y)
+      raise MiyakoError, "Not select yet!" unless @now
       raise MiyakoError, "Illegal choice position! [#{x}][#{y}]" if (x < 0 || x >= @choices.length || y < 0 || y >= @choices[x].length)
-      @now = @choices[x][y]
+      @non_select = false
+      @last_selected = @now
+      @now.selected = false
+      obj = @choices[x][y]
+      update_choices(@now, obj)
+      @now = obj
+      @now.selected = true
       return self
     end
 
+    #===画面上の座標から、該当する選択肢を変更する
+    #マウスカーソル位置などの座標から、座標を含む選択肢を選択状態にする
+    #該当する場所が無ければfalseを返す
+    #まだ選択を開始していないときはfalseを返す
+    #_x_:: x方向位置
+    #_y_:: y方向位置
+    #返却値:: 選択肢が見つかったときはtrue、見つからなかったときはfalseを返す
+    def attach(x, y)
+      return false unless @now
+      obj = @now.base.detect{|ch| ch.selected ? ch.body_selected.broad_rect.in_range?(x, y) : ch.body.broad_rect.in_range?(x, y) }
+      return false unless obj
+      @non_select = false
+      @last_selected = @now
+      @now.selected = false
+      update_choices(@now, obj)
+      @now = obj
+      @now.selected = true
+      return true
+    end
+
+    #===画面上の座標から、該当する選択肢があるかどうかを問い合わせる
+    #マウスカーソル位置などの座標から、座標を含む選択肢があるときはtrue、無いときはfalseを返す
+    #まだ選択を開始していないときはfalseを返す
+    #_x_:: x方向位置
+    #_y_:: y方向位置
+    #返却値:: 選択肢が見つかったときはtrue、見つからなかったときはfalseを返す
+    def attach?(x, y)
+      return false unless @now
+      obj = @now.base.detect{|ch| ch.selected ? ch.body_selected.broad_rect.in_range?(x, y) : ch.body.broad_rect.in_range?(x, y) }
+      return obj ? true : false
+    end
+
     #===選択肢を非選択状態に変更する
     #現在の選択状態を、全部選択していない状態にする
     #返却値:: 自分自身を返す
     def non_select
-      @now.base.each{|c| c.selected = false }
+      @now.base.each{|c| c.selected = false } if @now
       @non_select = true
       return self
     end
@@ -172,8 +284,11 @@ module Miyako
     #現在表示できる選択肢を、現在の状態で描画するよう指示する
     #ブロック付きで呼び出し可能(レシーバに対応したSpriteUnit構造体が引数として得られるので、補正をかけることが出来る。
     #ブロックの引数は、|インスタンスのSpriteUnit, 画面のSpriteUnit|となる。
+    #visibleメソッドの値がfalseのとき、選択が開始されていない時は描画されない。
     #返却値:: 自分自身を返す
     def render(&block)
+      return unless @visible
+      return self unless @now
       @now.base.each{|c|
         ((c.body_selected && c.selected) ?
           c.body_selected.render(&block) :
@@ -186,9 +301,12 @@ module Miyako
     #現在表示できる選択肢を、現在の状態で描画するよう指示する
     #ブロック付きで呼び出し可能(レシーバに対応したSpriteUnit構造体が引数として得られるので、補正をかけることが出来る。
     #ブロックの引数は、|インスタンスのSpriteUnit, 画像のSpriteUnit|となる。
+    #visibleメソッドの値がfalseのとき、選択が開始されていない時は描画されない。
     #_dst_:: 描画対象の画像インスタンス
     #返却値:: 自分自身を返す
     def render_to(dst, &block)
+      return self unless @visible
+      return self unless @now
       @now.base.each{|c|
         ((c.body_selected && c.selected) ?
           c.body_selected.render_to(dst, &block) :
@@ -199,35 +317,55 @@ module Miyako
 
     #===スプライトに変換した画像を表示する
     #すべてのパーツを貼り付けた、１枚のスプライトを返す
+    #引数1個のブロックを渡せば、スプライトに補正をかけることが出来る
+    #ただし、選択が開始されていなければnilを返す
     #返却値:: 生成したスプライト
     def to_sprite
+      return nil unless @now
       rect = self.broad_rect
       sprite = Sprite.new(:size=>rect.to_a[2,2], :type=>:ac)
+      Drawing.fill(sprite, [0,0,0])
+      Bitmap.ck_to_ac!(sprite, [0,0,0])
       self.render_to(sprite){|sunit, dunit| sunit.x -= rect.x; sunit.y -= rect.y }
+      yield sprite if block_given?
       return sprite
     end
 
-    #===現在の画面の最大の大きさを矩形で取得する
-    #選択肢の状態により、取得できる矩形の大きさが変わる
-    #但し、選択肢が一つも見つからなかったときはnilを返す
+    #===現在登録している選択肢の最大の大きさを矩形で取得する
+    # 現在インスタンスが所持している選択肢全てから左上座標、右下座標を取得し、矩形の形式で返す
+    # 但し、選択肢が一つも登録されていない時はRect(0,0,1,1)を返す
     #返却値:: 生成された矩形(Rect構造体のインスタンス)
     def broad_rect
-      choice_list = @now.base.find_all{|c| c.condition.call }.map{|c| (c.body_selected && c.selected) ? c.body_selected : c.body}
-      return nil if choice_list.length == 0
-      return Rect.new(*(choice_list[0].rect.to_a)) if choice_list.length == 1
-      rect = choice_list.shift.to_a
-      rect_list = rect.zip(*(choice_list.map{|c| c.broad_rect.to_a}))
-      # width -> right
-      rect_list[2] = rect_list[2].zip(rect_list[0]).map{|xw| xw[0] + xw[1]}
-      # height -> bottom
-      rect_list[3] = rect_list[3].zip(rect_list[1]).map{|xw| xw[0] + xw[1]}
-      x, y = rect_list[0].min, rect_list[1].min
-      return Rect.new(x, y, rect_list[2].max - x, rect_list[3].max - y)
-    end
-
-    # 選択肢を左移動させる
+      return Rect.new(0, 0, 1, 1) if @choices.length == 0
+      xx = []
+      yy = []
+      @choices.each{|ch|
+        ch.each{|cc|
+          xx << cc.body.x
+          yy << cc.body.y
+          if cc.body_selected
+            xx << cc.body_selected.x
+            yy << cc.body_selected.y
+          end
+        }
+      }
+      min_x, max_x = xx.minmax
+      min_y, max_y = yy.minmax
+      return Rect.new(min_x, min_y, max_x-min_x+1, max_y-min_y+1)
+    end
+
+    #===現在登録している選択肢の大きさを矩形で取得する
+    # 内容はbroad_rectメソッドの結果と同じ
+    #返却値:: 生成された矩形(Rect構造体のインスタンス)
+    def rect
+      return self.broad_rect
+    end
+
+    #===選択肢を左移動させる
+    # 但し、まだ選択が開始されていなければ何もしない
     # 返却値:: 自分自身を返す
-    def left
+    def left_choice
+      return self unless @now
       @last_selected = @now
       @now.selected = false
       obj = @now.left
@@ -237,9 +375,11 @@ module Miyako
       return self
     end
 
-    # 選択肢を右移動させる
+    #===選択肢を右移動させる
+    # 但し、まだ選択が開始されていなければ何もしない
     # 返却値:: 自分自身を返す
-    def right
+    def right_choice
+      return self unless @now
       @last_selected = @now
       @now.selected = false
       obj = @now.right
@@ -249,9 +389,11 @@ module Miyako
       return self
     end
 
-    # 選択肢を上移動させる
+    #===選択肢を上移動させる
+    # 但し、まだ選択が開始されていなければ何もしない
     # 返却値:: 自分自身を返す
-    def up
+    def up_choice
+      return self unless @now
       @last_selected = @now
       @now.selected = false
       obj = @now.up
@@ -261,9 +403,11 @@ module Miyako
       return self
     end
 
-    # 選択肢を下移動させる
+    #===選択肢を下移動させる
+    # 但し、まだ選択が開始されていなければ何もしない
     # 返却値:: 自分自身を返す
-    def down
+    def down_choice
+      return self unless @now
       @last_selected = @now
       @now.selected = false
       obj = @now.down
@@ -273,31 +417,54 @@ module Miyako
       return self
     end
 
-    # 選択肢のアニメーションを開始する
+    #===選択肢のアニメーションを開始する
+    # 但し、まだ選択が開始されていなければ何もしない
     # 返却値:: 自分自身を返す
     def start
-      @now.base.each{|c| c.body.start if c.condition.call }
+      return self unless @now
+      @now.base.each{|c|
+        if c.condition.call
+          c.body.start
+          c.body_selected.start if c.body != c.body_selected
+        end
+      }
       return self
     end
 
-    # 選択肢のアニメーションを終了させる
+    #===選択肢のアニメーションを終了させる
+    # 但し、まだ選択が開始されていなければ何もしない
     # 返却値:: 自分自身を返す
     def stop
-      @now.base.each{|c| c.body.stop if c.condition.call }
+      return self unless @now
+      @now.base.each{|c|
+        if c.condition.call
+          c.body.stop
+          c.body_selected.stop if c.body != c.body_selected
+        end
+      }
       return self
     end
 
-    # 選択肢のアニメーションの再生位置を最初に戻す
+    #===選択肢のアニメーションの再生位置を最初に戻す
+    # 但し、まだ選択が開始されていなければ何もしない
     # 返却値:: 自分自身を返す
     def reset
-      @now.base.each{|c| c.body.reset if c.condition.call }
+      return self unless @now
+      @now.base.each{|c|
+        if c.condition.call
+          c.body.reset
+          c.body_selected.reset if c.body != c.body_selected
+        end
+      }
       return self
     end
 
-    # 選択肢のアニメーションを更新させる
+    #===選択肢のアニメーションを更新させる
     # (手動で更新する必要があるときに呼び出す)
+    # 但し、まだ選択が開始されていなければ何もしない
     # 返却値:: 自分自身を返す
     def update_animation
+      return self unless @now
       @now.base.each{|c|
         ((c.body_selected && c.selected) ?
          c.body_selected.update_animation :

data/lib/Miyako/API/collision.rb

@@ -2,7 +2,7 @@
 =begin
 --
 Miyako v2.0
-Copyright (C) 2007-2008  Cyross Makoto
+Copyright (C) 2007-2009  Cyross Makoto
 
 This library is free software; you can redistribute it and/or
 modify it under the terms of the GNU Lesser General Public
@@ -21,135 +21,74 @@ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
 =end
 
 module Miyako
-  #==当たり判定領域(コリジョン)クラス
-  #コリジョンの範囲は、元データ(スプライト等)の左上端を[0,0]として考案する
-  #本クラスに設定できる方向(direction)・移動量(amount)は、コリジョンの範囲・位置に影響しない
+  #==矩形当たり判定領域(コリジョン)クラス
+  # コリジョンの範囲は、元データ(スプライト等)の左上端を[0.0,0.0]として考案する
+  # コリジョンで使用する値は、実数での設定が可能
   class Collision
     extend Forwardable
 
     # コリジョンの範囲([x,y,w,h])
-    attr_accessor :rect
-    # 元データの位置([x,y])
-    attr_accessor :pos
-    # 移動方向([dx,dy], dx,dy:-1,0,1)
-    attr_accessor :direction
-    # 移動量([w,h])
-    attr_accessor :amount
+    attr_reader :rect
+    # 移動時イベントブロック配列
     
     #===コリジョンのインスタンスを作成する
+    # 幅・高さが0以下のときは例外が発生する
+    # 内部では、矩形当たり判定相手の時でも対応できるように矩形情報に変換して同時に持っている。
+    # そのとき、引数circumがtrueのときは、円を矩形の外接円と認識して、内部の矩形(正方形)の長さを算出する。
+    # circumがfalseのときは、円を矩形の内接円と認識して、内部の矩形(正方形)の長さを算出する。
     #_rect_:: コリジョンを設定する範囲
-    #_pos_:: 元データの位置
+    #_circum_:: 矩形当たり判定とみなす時、円を外接円とするときはtrueを設定する。デフォルトはtrue
     #返却値:: 作成されたコリジョン
-    def initialize(rect, pos)
+    def initialize(rect, circum = true)
       @rect = Rect.new(*(rect.to_a[0..3]))
-      @pos = Point.new(*(pos.to_a[0..1]))
-      @direction = Point.new(0, 0)
-      @amount = Size.new(0, 0)
-    end
-
-    #===コリジョンの方向を転換する
-    #_dx_:: 変換する方向(x軸方向、-1,0,1の3種類)
-    #_dy_:: 変換する方向(y軸方向、-1,0,1の3種類)
-    #返却値:: 自分自身を返す
-    def turn(dx, dy)
-      @direction = Point.new(dx, dy)
-      return self
-    end
-
-    #===コリジョンの移動量を変更する
-    #_mx_:: 変更する移動量(x軸方向)
-    #_my_:: 変更する移動量(y軸方向)
-    #返却値:: 自分自身を返す
-    def adjust(mx, my)
-      @amount = Size.new(mx, my)
-      return self
+      raise MiyakoError, "Illegal width! #{@rect[2]}" if @rect[2] < Float::EPSILON
+      raise MiyakoError, "Illegal height! #{@rect[3]}" if @rect[3] < Float::EPSILON
+      w = @rect[2].to_f
+      h = @rect[2].to_f
+      @center = Point.new(@rect[0].to_f + w / 2.0, @rect[1].to_f + h / 2.0)
+      @radius = circum ? Math.sqrt(w ** 2 + h ** 2) / 2.0 : [w, h].min / 2.0
     end
 
     #===当たり判定を行う(領域が重なっている)
+    #_pos1_:: 自分自身の位置(Point/Rect/Square構造体、2要素以上の配列、もしくはx,yメソッドを持つインスタンス)
     #_c2_:: 判定対象のコリジョンインスタンス
+    #_pos2_:: c2の位置(Point/Rect/Square構造体、2要素以上の配列、もしくはx,yメソッドを持つインスタンス)
     #返却値:: 1ピクセルでも重なっていれば true を返す
-    def collision?(c2)
-      return Collision.collision?(self, c2)
+    def collision?(pos1, c2, pos2)
+      return Collision.collision?(self, pos1, c2, pos2)
     end
 
-    #===当たり判定を行う(領域が当たっている(重なっていない))
+    #===当たり判定を行う(領域がピクセル単位で隣り合っている)
+    #_pos1_:: 自分自身の位置(Point/Rect/Square構造体、2要素以上の配列、もしくはx,yメソッドを持つインスタンス)
     #_c2_:: 判定対象のコリジョンインスタンス
-    #返却値:: 領域が当たっていれば true を返す
-    def meet?(c2)
-      return Collision.meet?(self, c2)
-    end
-
-    #===当たり判定を行う(移動後に領域が重なっている(移動前は重なっていない))
-    #_c2_:: 判定対象のコリジョンインスタンス
-    #返却値:: 1ピクセルでも重なっていれば true を返す
-    def into?(c2)
-      return Collision.into?(self, c2)
-    end
-
-    #===当たり判定を行う(移動後に領域が離れている(移動前は重なっている))
-    #_c2_:: 判定対象のコリジョンインスタンス
-    #返却値:: 1ピクセルでも重なっていれば true を返す
-    def out?(c2)
-      return Collision.out?(self, c2)
+    #_pos2_:: c2の位置(Point/Rect/Square構造体、2要素以上の配列、もしくはx,yメソッドを持つインスタンス)
+    #返却値:: 領域が隣り合っていれば true を返す
+    def meet?(pos1, c2, pos2)
+      return Collision.meet?(self, pos1, c2, pos2)
     end
 
     #===当たり判定を行う(どちらかの領域がもう一方にすっぽり覆われている))
+    #_pos1_:: 自分自身の位置(Point/Rect/Square構造体、2要素以上の配列、もしくはx,yメソッドを持つインスタンス)
     #_c2_:: 判定対象のコリジョンインスタンス
+    #_pos2_:: c2の位置(Point/Rect/Square構造体、2要素以上の配列、もしくはx,yメソッドを持つインスタンス)
     #返却値:: 領域が覆われていれば true を返す
-    def cover?(c2)
-      return Collision.cover?(self, c2)
-    end
-
-    #===コリジョンをの位置を、指定の移動量で移動する
-    #_x_:: 移動量(x方向)。単位はピクセル
-    #_y_:: 移動量(y方向)。単位はピクセル
-    #返却値:: 自分自身を返す
-    def move(x, y)
-      @pos.move(x, y)
-      return self
-    end
-
-    #===コリジョンをの位置を、指定の位置へ移動する
-    #_x_:: 移動先の位置(x方向)。単位はピクセル
-    #_y_:: 移動先の位置(y方向)。単位はピクセル
-    #返却値:: 自分自身を返す
-    def move_to(x, y)
-      @pos.move_to(x, y)
-      return self
+    def cover?(pos1, c2, pos2)
+      return Collision.cover?(self, pos1, c2, pos2)
     end
 
     #===当たり判定を行う(領域が重なっている)
     #_c1_:: 判定対象のコリジョンインスタンス(1)
+    #_pos1_:: c1の位置(Point/Rect/Square構造体、2要素以上の配列、もしくはx,yメソッドを持つインスタンス)
     #_c2_:: 判定対象のコリジョンインスタンス(2)
+    #_pos2_:: c2の位置(Point/Rect/Square構造体、2要素以上の配列、もしくはx,yメソッドを持つインスタンス)
     #返却値:: 1ピクセルでも重なっていれば true を返す
-    def Collision.collision?(c1, c2)
-      l1 = c1.pos[0] + c1.rect[0]
-      t1 = c1.pos[1] + c1.rect[1]
-      r1 = l1 + c1.rect[2] - 1
-      b1 = t1 + c1.rect[3] - 1
-      l2 = c2.pos[0] + c2.rect[0]
-      t2 = c2.pos[1] + c2.rect[1]
-      r2 = l2 + c2.rect[2] - 1
-      b2 = t2 + c2.rect[3] - 1
-      v =  0
-      v |= 1 if l1 <= l2 && l2 <= r1
-      v |= 1 if l1 <= r2 && r2 <= r1
-      v |= 2 if t1 <= t2 && t2 <= b1
-      v |= 2 if t1 <= b2 && b2 <= b1
-      return v == 3
-    end
-
-    #===当たり判定を行う(移動後の領域が重なっている)
-    #_c1_:: 判定対象のコリジョンインスタンス(1)
-    #_c2_:: 判定対象のコリジョンインスタンス(2)
-    #返却値:: 1ピクセルでも重なっていれば true を返す
-    def Collision.collision_with_move?(c1, c2)
-      l1 = c1.pos[0] + c1.rect[0] + c1.direction[0] * c1.amount[0]
-      t1 = c1.pos[1] + c1.rect[1] + c1.direction[1] * c1.amount[1]
+    def Collision.collision?(c1, pos1, c2, pos2)
+      l1 = pos1[0] + c1.rect[0]
+      t1 = pos1[1] + c1.rect[1]
       r1 = l1 + c1.rect[2] - 1
       b1 = t1 + c1.rect[3] - 1
-      l2 = c2.pos[0] + c2.rect[0] + c2.direction[0] * c2.amount[0]
-      t2 = c2.pos[1] + c2.rect[1] + c2.direction[1] * c2.amount[1]
+      l2 = pos2[0] + c2.rect[0]
+      t2 = pos2[1] + c2.rect[1]
       r2 = l2 + c2.rect[2] - 1
       b2 = t2 + c2.rect[3] - 1
       v =  0
@@ -160,17 +99,19 @@ module Miyako
       return v == 3
     end
 
-    #===当たり判定を行う(領域が当たっている(重なっていない))
+    #===当たり判定を行う(領域がピクセル単位で隣り合っている)
     #_c1_:: 判定対象のコリジョンインスタンス(1)
+    #_pos1_:: c1の位置(Point/Rect/Square構造体、2要素以上の配列、もしくはx,yメソッドを持つインスタンス)
     #_c2_:: 判定対象のコリジョンインスタンス(2)
-    #返却値:: 領域が当たっていれば true を返す
-    def Collision.meet?(c1, c2)
-      l1 = c1.pos[0] + c1.rect[0]
-      t1 = c1.pos[1] + c1.rect[1]
+    #_pos2_:: c2の位置(Point/Rect/Square構造体、2要素以上の配列、もしくはx,yメソッドを持つインスタンス)
+    #返却値:: 領域が隣り合っていれば true を返す
+    def Collision.meet?(c1, pos1, c2, pos2)
+      l1 = pos1[0] + c1.rect[0]
+      t1 = pos1[1] + c1.rect[1]
       r1 = l1 + c1.rect[2]
       b1 = t1 + c1.rect[3]
-      l2 = c2.pos[0] + c2.rect[0]
-      t2 = c2.pos[1] + c2.rect[1]
+      l2 = pos2[0] + c2.rect[0]
+      t2 = pos2[1] + c2.rect[1]
       r2 = l2 + c2.rect[2]
       b2 = t2 + c2.rect[3]
       v =  0
@@ -181,104 +122,231 @@ module Miyako
       return v == 1
     end
 
-    #===当たり判定を行う(移動後に領域が重なっている(移動前は重なっていない))
+    #===当たり判定を行う(どちらかの領域がもう一方にすっぽり覆われている))
     #_c1_:: 判定対象のコリジョンインスタンス(1)
+    #_pos1_:: c1の位置(Point/Rect/Square構造体、2要素以上の配列、もしくはx,yメソッドを持つインスタンス)
     #_c2_:: 判定対象のコリジョンインスタンス(2)
+    #_pos2_:: c2の位置(Point/Rect/Square構造体、2要素以上の配列、もしくはx,yメソッドを持つインスタンス)
+    #返却値:: 領域が覆われていれば true を返す
+    def Collision.cover?(c1, pos1, c2, pos2)
+      l1 = pos1[0] + c1.rect[0]
+      t1 = pos1[1] + c1.rect[1]
+      r1 = l1 + c1.rect[2]
+      b1 = t1 + c1.rect[3]
+      l2 = pos2[0] + c2.rect[0]
+      t2 = pos2[1] + c2.rect[1]
+      r2 = l2 + c2.rect[2]
+      b2 = t2 + c2.rect[3]
+      v =  0
+      v |= 1 if l1 >= l2 && r2 <= r1
+      v |= 2 if t1 >= t2 && b2 <= b1
+      v |= 4 if l2 >= l1 && r1 <= r2
+      v |= 8 if t2 >= t1 && b1 <= b2
+      return v & 3 == 3 || v & 12 == 12
+    end
+
+    #== インスタンスの内容を解放する
+    #返却値:: なし
+    def dispose
+      @rect = nil
+    end
+  end
+
+  #==円形当たり判定領域(サークルコリジョン)クラス
+  # 円形の当たり判定を実装する。
+  # コリジョンは中心位置と半径で構成され、円形当たり判定同士で衝突判定を行う
+  # コリジョンで使用する値は、実数での設定が可能
+  class CircleCollision
+    extend Forwardable
+
+    # コリジョンの中心点([x,y])
+    attr_reader :center
+    # コリジョンの半径
+    attr_reader :radius
+    # 移動時イベントブロック配列
+    
+    #===コリジョンのインスタンスを作成する
+    # コリジョンの半径が0もしくはマイナスのとき例外が発生する
+    # 内部では、矩形当たり判定相手の時でも対応できるように矩形情報に変換して同時に持っている。
+    # そのとき、引数circumがtrueのときは、円を矩形の外接円と認識して、内部の矩形(正方形)の長さを算出する。
+    # circumがfalseのときは、円を矩形の内接円と認識して、内部の矩形(正方形)の長さを算出する。
+    #_center_:: コリジョンを設定する範囲
+    #_radius_:: コリジョンの半径
+    #_circum_:: 矩形当たり判定とみなす時、円を外接円とするときはtrueを設定する。デフォルトはtrue
+    #返却値:: 作成されたコリジョン
+    def initialize(center, radius, circum = true)
+      raise MiyakoError, "illegal radius! #{radius}" if radius < Float::EPSILON
+      @center = Point.new(*(center.to_a[0..1]))
+      @radius = radius
+      if circum
+        rad = @radius.to_f / Math.sqrt(2.0)
+        @rect = Rect.new(@center[0]-rad, @center[1]-rad, rad*2.0, rad*2.0)
+      else
+        @rect = Rect.new(@center[0]-@radius, @center[1]-@radius, @radius*2.0, @radius*2.0)
+      end
+    end
+
+    #===当たり判定間の距離を算出する
+    #_pos1_:: 自分自身の位置(Point/Rect/Square構造体、2要素以上の配列、もしくはx,yメソッドを持つインスタンス)
+    #_c2_:: 判定対象のコリジョンインスタンス
+    #_pos2_:: c2の位置(Point/Rect/Square構造体、2要素以上の配列、もしくはx,yメソッドを持つインスタンス)
+    #返却値:: 1ピクセルでも重なっていれば true を返す
+    def interval(pos1, c2, pos2)
+      return CircleCollision.interval(self, pos1, c2, pos2)
+    end
+
+    #===当たり判定を行う(領域が重なっている)
+    #_pos1_:: 自分自身の位置(Point/Rect/Square構造体、2要素以上の配列、もしくはx,yメソッドを持つインスタンス)
+    #_c2_:: 判定対象のコリジョンインスタンス
+    #_pos2_:: c2の位置(Point/Rect/Square構造体、2要素以上の配列、もしくはx,yメソッドを持つインスタンス)
     #返却値:: 1ピクセルでも重なっていれば true を返す
-    def Collision.into?(c1, c2)
-      f1 = Collision.collision?(c1, c2)
-      f2 = Collision.collision_with_move?(c1, c2)
-      return !f1 & f2
+    def collision?(pos1, c2, pos2)
+      return CircleCollision.collision?(self, pos1, c2, pos2)
     end
 
-    #===当たり判定を行う(移動後に領域が離れている(移動前は重なっている))
+    #===当たり判定を行う(領域がピクセル単位で隣り合っている)
+    #_pos1_:: 自分自身の位置(Point/Rect/Square構造体、2要素以上の配列、もしくはx,yメソッドを持つインスタンス)
+    #_c2_:: 判定対象のコリジョンインスタンス
+    #_pos2_:: c2の位置(Point/Rect/Square構造体、2要素以上の配列、もしくはx,yメソッドを持つインスタンス)
+    #返却値:: 領域が隣り合っていれば true を返す
+    def meet?(pos1, c2, pos2)
+      return CircleCollision.meet?(self, pos1, c2, pos2)
+    end
+
+    #===当たり判定を行う(どちらかの領域がもう一方にすっぽり覆われている))
+    #_pos1_:: 自分自身の位置(Point/Rect/Square構造体、2要素以上の配列、もしくはx,yメソッドを持つインスタンス)
+    #_c2_:: 判定対象のコリジョンインスタンス
+    #_pos2_:: c2の位置(Point/Rect/Square構造体、2要素以上の配列、もしくはx,yメソッドを持つインスタンス)
+    #返却値:: 領域が覆われていれば true を返す
+    def cover?(pos1, c2, pos2)
+      return CircleCollision.cover?(self, pos1, c2, pos2)
+    end
+
+    #===当たり判定間の距離を算出する
+    # ２つの当たり判定がどの程度離れているかを算出する。
+    # 返ってくる値は、衝突していなければ正の実数、衝突していれば負の実数で返ってくる
     #_c1_:: 判定対象のコリジョンインスタンス(1)
+    #_pos1_:: c1の位置(Point/Rect/Square構造体、2要素以上の配列、もしくはx,yメソッドを持つインスタンス)
     #_c2_:: 判定対象のコリジョンインスタンス(2)
+    #_pos2_:: c2の位置(Point/Rect/Square構造体、2要素以上の配列、もしくはx,yメソッドを持つインスタンス)
+    #返却値:: 当たり判定間の距離
+    def CircleCollision.interval(c1, pos1, c2, pos2)
+      #2点間の距離を求める
+      d = Math.sqrt((((c1.center[0].to_f + pos1[0].to_f) - (c2.center[0].to_f + pos2[0].to_f)) ** 2) +
+                    (((c1.center[1].to_f + pos1[1].to_f) - (c2.center[1].to_f + pos2[1].to_f)) ** 2))
+      #半径の和を求める
+      r  = c1.radius.to_f + c2.radius.to_f
+      distance = d - r
+      return distance.abs < Float::EPSILON ? 0.0 : distance
+    end
+
+    #===当たり判定を行う(領域が重なっている)
+    #_c1_:: 判定対象のコリジョンインスタンス(1)
+    #_pos1_:: c1の位置(Point/Rect/Square構造体、2要素以上の配列、もしくはx,yメソッドを持つインスタンス)
+    #_c2_:: 判定対象のコリジョンインスタンス(2)
+    #_pos2_:: c2の位置(Point/Rect/Square構造体、2要素以上の配列、もしくはx,yメソッドを持つインスタンス)
     #返却値:: 1ピクセルでも重なっていれば true を返す
-    def Collision.out?(c1, c2)
-      f1 = Collision.collision?(c1, c2)
-      f2 = Collision.collision_with_move?(c1, c2)
-      return f1 & !f2
+    def CircleCollision.collision?(c1, pos1, c2, pos2)
+      #2点間の距離を求める
+      d = (((c1.center[0] + pos1[0]) - (c2.center[0] + pos2[0])) ** 2) +
+          (((c1.center[1] + pos1[1]) - (c2.center[1] + pos2[1])) ** 2)
+      #半径の和を求める
+      r  = (c1.radius + c2.radius) ** 2
+      return d <= r
+    end
+
+    #===当たり判定を行う(領域がピクセル単位で隣り合っている)
+    # 但し、実際の矩形範囲が偶数の時は性格に判定できない場合があるため注意
+    #_c1_:: 判定対象のコリジョンインスタンス(1)
+    #_pos1_:: c1の位置(Point/Rect/Square構造体、2要素以上の配列、もしくはx,yメソッドを持つインスタンス)
+    #_c2_:: 判定対象のコリジョンインスタンス(2)
+    #_pos2_:: c2の位置(Point/Rect/Square構造体、2要素以上の配列、もしくはx,yメソッドを持つインスタンス)
+    #返却値:: 領域が隣り合っていれば true を返す
+    def CircleCollision.meet?(c1, pos1, c2, pos2)
+      #2点間の距離を求める
+      d = (((c1.center[0] + pos1[0]) - (c2.center[0] + pos2[0])) ** 2) +
+          (((c1.center[1] + pos1[1]) - (c2.center[1] + pos2[1])) ** 2)
+      #半径の和を求める
+      r  = (c1.radius + c2.radius) ** 2
+      return d == r
     end
 
     #===当たり判定を行う(どちらかの領域がもう一方にすっぽり覆われている))
     #_c1_:: 判定対象のコリジョンインスタンス(1)
+    #_pos1_:: c1の位置(Point/Rect/Square構造体、2要素以上の配列、もしくはx,yメソッドを持つインスタンス)
     #_c2_:: 判定対象のコリジョンインスタンス(2)
+    #_pos2_:: c2の位置(Point/Rect/Square構造体、2要素以上の配列、もしくはx,yメソッドを持つインスタンス)
     #返却値:: 領域が覆われていれば true を返す
-    def Collision.cover?(c1, c2)
-      l1 = c1.pos[0] + c1.rect[0]
-      t1 = c1.pos[1] + c1.rect[1]
-      r1 = l1 + c1.rect[2]
-      b1 = t1 + c1.rect[3]
-      l2 = c2.pos[0] + c2.rect[0]
-      t2 = c2.pos[1] + c2.rect[1]
-      r2 = l2 + c2.rect[2]
-      b2 = t2 + c2.rect[3]
-      v =  0
-      v |= 1 if l1 <= l2 && r2 <= r1
-      v |= 2 if t1 <= t2 && b2 <= b1
-      v |= 4 if l2 <= l1 && r1 <= r2
-      v |= 8 if t2 <= t1 && b1 <= b2
-      return v == 3 || v == 12
+    def CircleCollision.cover?(c1, pos1, c2, pos2)
+      #2点間の距離を求める
+      d = ((c1.center[0] + pos1[0]) - (c2.center[0] + pos2[0])) ** 2 +
+          ((c1.center[1] + pos1[1]) - (c2.center[1] + pos2[1])) ** 2
+      #半径の差分を求める
+      r  = c1.radius ** 2 - 2 * (c1.radius * c2.radius) + c2.radius ** 2
+      return d <= r
     end
 
-    #===あとで書く
-    #返却値:: あとで書く
+    #== インスタンスの内容を解放する
+    #返却値:: なし
     def dispose
-      @pos.clear
-      @pos = nil
-      @rect.clear
-      @rect = nil
-      @amount.clear
-      @amount = nil
-      @direction.clear
-      @direction = nil
+      @point = nil
     end
   end
 
   #==コリジョン管理クラス
-  #複数のコリジョンと元オブジェクトを配列の様に一括管理できる
-  #当たり判定を一括処理することで高速化を図る
+  # 複数のコリジョンと元オブジェクトを配列の様に一括管理できる
+  # 当たり判定を一括処理することで高速化を図る
   class Collisions
     include Enumerable
     extend Forwardable
 
     #===コリジョンのインスタンスを作成する
+    # points引数の各要素は、以下の3つの条件のどれかに適合する必要がある。しない場合は例外が発生する
+    # 1)[x,y]の要素を持つ配列
+    # 2)Point構造体、Rect構造体、もしくはSquare構造体
+    # 3)x,yメソッドを持つ
     #_collisions_:: コリジョンの配列。デフォルトは []
-    #_pos_:: 元データの配列。デフォルトは []
+    #_points_:: 位置情報の配列。デフォルトは []
     #返却値:: 作成されたインスタンス
-    def initialize(collisions=[], bodies=[])
-      @collisions = Array.new(collisions).zip(bodies)
+    def initialize(collisions=[], points=[])
+      @collisions = Array.new(collisions).zip(points)
     end
 
-    #===コリジョンと本体を追加する
+    #===コリジョンと位置情報を追加する
+    # point引数は、以下の3つの条件のどれかに適合する必要がある。しない場合は例外が発生する
+    # 1)[x,y]の要素を持つ配列
+    # 2)Point構造体、Rect構造体、もしくはSquare構造体
+    # 3)x,yメソッドを持つ
     #_collisions_:: コリジョン
-    #_pos_:: 元データ
+    #_point_:: 位置情報
     #返却値:: 自分自身を返す
-    def add(collision, body)
-      @collisions << [collision, body]
+    def add(collision, point)
+      @collisions << [collision, point]
       return self
     end
 
-    #===インスタンスに、コリジョンと本体の集合を追加する
+    #===インスタンスに、コリジョンと位置情報の集合を追加する
+    # points引数の各要素は、以下の3つの条件のどれかに適合する必要がある。しない場合は例外が発生する
+    # 1)[x,y]の要素を持つ配列
+    # 2)Point構造体、Rect構造体、もしくはSquare構造体
+    # 3)x,yメソッドを持つ
     #_collisions_:: コリジョンの配列
-    #_pos_:: 元データの配列
+    #_points_:: 位置情報の配列
     #返却値:: 自分自身を返す
-    def append(collisions, bodies)
-      @collisions.concat(collisions.zip(bodies))
+    def append(collisions, points)
+      @collisions.concat(collisions.zip(points))
       return self
     end
 
     #===インデックス形式でのコリジョン・本体の取得
     #_idx_:: 配列のインデックス番号
-    #返却値:: インデックスに対応したコリジョンと本体との対。
+    #返却値:: インデックスに対応したコリジョンと位置情報との対。
     #インデックスが範囲外の時はnilが返る
     def [](idx)
       return @collisions[idx]
     end
     
     #===コリジョン・本体の削除
-    #対応したインデックスのコリジョンと
     #_idx_:: 配列のインデックス番号
     #返却値:: 削除したコリジョンと本体との対
     #インデックスが範囲外の時はnilが返る
@@ -295,8 +363,8 @@ module Miyako
     end
 
     #===タッピングを行う
-    #ブロックを渡すことにより、タッピングを行う
-    #ブロック内の引数は、|コリジョン,本体|の２が渡される
+    # ブロックを渡すことにより、タッピングを行う
+    # ブロック内の引数は、|コリジョン,本体|の２が渡される
     #返却値:: 自分自身を返す
     def each
       @collisions.each{|cb| yield cb[0], cb[1] }
@@ -304,138 +372,86 @@ module Miyako
     end
 
     #===タッピングを行う
-    #ブロックを渡すことにより、タッピングを行う
-    #ブロック内の引数は、|コリジョン,本体|の２が渡される
+    # ブロックを渡すことにより、タッピングを行う
+    # ブロック内の引数は、|コリジョン,本体|の２が渡される
     #_idx_:: 配列のインデックス
     #返却値:: 自分自身を返す
     def tap(idx)
       yield @collisions[idx][0], @collisions[idx][1]
       return self
     end
-
-    #===すべてのコリジョンの方向を転換する
-    #_dx_:: 変換する方向(x軸方向、-1,0,1の3種類)
-    #_dy_:: 変換する方向(y軸方向、-1,0,1の3種類)
-    #返却値:: 自分自身を返す
-    def turn(dx, dy)
-      @collisions.each{|cs| cs.turn(dx, dy) }
-      return self
-    end
-
-    #===すべてのコリジョンの移動量を変更する
-    #_mx_:: 変更する移動量(x軸方向)
-    #_my_:: 変更する移動量(y軸方向)
-    #返却値:: 自分自身を返す
-    def adjust(mx, my)
-      @collisions.each{|cs| cs.adjust(mx, my) }
-      return self
-    end
     
-    #===当たり判定を行う(領域が重なっている)
-    #判定に引っかかったコリジョンが一つでもあれば、最初に引っかかったコリジョンを返す
-    #当たり判定に引っかかったコリジョンが無い場合はnilを返す
+    #===当たり判定を行う(配列のどれかの領域が重なっている)
+    # 重なったコリジョンが一つでもあれば、最初に引っかかったコリジョンを返す
+    # 重なったコリジョンが無い場合はnilを返す
     #_c_:: 判定対象のコリジョンインスタンス
+    #_pos_:: cの位置(Point/Rect/Square構造体、もしくは2要素の配列)
     #返却値:: コリジョンと本体の対。
-    def collision?(c)
-      return @collisions.detect{|cc| c.collision?(cc[0])}
+    def collision?(c, pos)
+      return @collisions.detect{|cc| c.collision?(pos, cc[0], cc[1])}
     end
 
-    #===当たり判定を行う(領域が当たっている(重なっていない))
-    #判定に引っかかったコリジョンが一つでもあれば、最初に引っかかったコリジョンを返す
-    #当たり判定に引っかかったコリジョンが無い場合はnilを返す
+    #===当たり判定を行う(配列のどれかの領域がピクセル単位で隣り合っている)
+    # 隣り合ったコリジョンが一つでもあれば、最初に引っかかったコリジョンを返す
+    # 隣り合ったコリジョンが無い場合はnilを返す
     #_c_:: 判定対象のコリジョンインスタンス
-    #返却値:: コリジョンと本体の対。
-    #返却値:: 領域が当たっていれば true を返す
-    def meet?(c)
-      return @collisions.detect{|cc| c.meet?(cc[0])}
-    end
-
-    #===当たり判定を行う(移動後に領域が重なっている(移動前は重なっていない))
-    #判定に引っかかったコリジョンが一つでもあれば、最初に引っかかったコリジョンを返す
-    #当たり判定に引っかかったコリジョンが無い場合はnilを返す
-    #_c_:: 判定対象のコリジョンインスタンス
-    #返却値:: コリジョンと本体の対。
-    #返却値:: 1ピクセルでも重なっていれば true を返す
-    def into?(c)
-      return @collisions.detect{|cc| c.into?(cc[0])}
-    end
-
-    #===当たり判定を行う(移動後に領域が離れている(移動前は重なっている))
-    #判定に引っかかったコリジョンが一つでもあれば、最初に引っかかったコリジョンを返す
-    #当たり判定に引っかかったコリジョンが無い場合はnilを返す
-    #_c_:: 判定対象のコリジョンインスタンス
-    #返却値:: コリジョンと本体の対。
-    #返却値:: 1ピクセルでも重なっていれば true を返す
-    def out?(c)
-      return @collisions.detect{|cc| c.out?(cc[0])}
+    #_pos_:: cの位置(Point/Rect/Square構造体、もしくは2要素の配列)
+    #返却値:: 隣り合っていれば true を返す
+    def meet?(c, pos)
+      return @collisions.detect{|cc| c.meet?(pos, cc[0], cc[1])}
     end
 
     #===当たり判定を行う(どちらかの領域がもう一方にすっぽり覆われている))
-    #判定に引っかかったコリジョンが一つでもあれば、最初に引っかかったコリジョンを返す
-    #当たり判定に引っかかったコリジョンが無い場合はnilを返す
+    # 覆われたコリジョンが一つでもあれば、最初に引っかかったコリジョンを返す
+    # 覆われたコリジョンが無い場合はnilを返す
     #_c_:: 判定対象のコリジョンインスタンス
-    #返却値:: コリジョンと本体の対。
+    #_pos_:: cの位置(Point/Rect/Square構造体、もしくは2要素の配列)
     #返却値:: 領域が覆われていれば true を返す
-    def cover?(c)
-      return @collisions.detect{|cc| c.cover?(cc[0])}
+    def cover?(c, pos)
+      return @collisions.detect{|cc| c.cover?(pos, cc[0], cc[1])}
     end
 
     #===当たり判定を行う(領域が重なっている)
-    #判定に引っかかったコリジョンが一つでもあれば、すべてのコリジョンの配列を返す
-    #当たり判定に引っかかったコリジョンが無い場合はnilを返す
-    #_c_:: 判定対象のコリジョンインスタンス
-    #返却値:: コリジョンと本体の対の配列。
-    def collision_all?(c)
-      return @collisions.select{|cc| c.collision?(cc[0])}
-    end
-
-    #===当たり判定を行う(領域が当たっている(重なっていない))
-    #判定に引っかかったコリジョンが一つでもあれば、すべてのコリジョンの配列を返す
-    #当たり判定に引っかかったコリジョンが無い場合はnilを返す
-    #_c_:: 判定対象のコリジョンインスタンス
-    #返却値:: コリジョンと本体の対の配列。
-    def meet_all?(c)
-      return @collisions.select{|cc| c.meet?(cc[0])}
-    end
-
-    #===当たり判定を行う(移動後に領域が重なっている(移動前は重なっていない))
-    #判定に引っかかったコリジョンが一つでもあれば、すべてのコリジョンの配列を返す
-    #当たり判定に引っかかったコリジョンが無い場合はnilを返す
+    # 重なったコリジョンが一つでもあれば、すべてのコリジョンの配列を返す
+    # 重なったコリジョンが無い場合はnilを返す
     #_c_:: 判定対象のコリジョンインスタンス
+    #_pos_:: cの位置(Point/Rect/Square構造体、もしくは2要素の配列)
     #返却値:: コリジョンと本体の対の配列。
-    def into_all?(c)
-      return @collisions.select{|cc| c.into?(cc[0])}
+    def collision_all?(c, pos)
+      return @collisions.select{|cc| c.collision?(pos, cc[0], cc[1])}
     end
 
-    #===当たり判定を行う(移動後に領域が離れている(移動前は重なっている))
-    #判定に引っかかったコリジョンが一つでもあれば、すべてのコリジョンの配列を返す
-    #当たり判定に引っかかったコリジョンが無い場合はnilを返す
+    #===当たり判定を行う(領域がピクセル単位で隣り合っている)
+    # 隣り合ったコリジョンが一つでもあれば、すべてのコリジョンの配列を返す
+    # 隣り合ったコリジョンが無い場合はnilを返す
     #_c_:: 判定対象のコリジョンインスタンス
+    #_pos_:: cの位置(Point/Rect/Square構造体、もしくは2要素の配列)
     #返却値:: コリジョンと本体の対の配列。
-    def out_all?(c)
-      return @collisions.select{|cc| c.out?(cc[0])}
+    def meet_all?(c, pos)
+      return @collisions.select{|cc| c.meet?(pos, cc[0], cc[1])}
     end
 
     #===当たり判定を行う(どちらかの領域がもう一方にすっぽり覆われている))
-    #判定に引っかかったコリジョンが一つでもあれば、すべてのコリジョンの配列を返す 
-    #当たり判定に引っかかったコリジョンが無い場合はnilを返す
+    # 覆われたコリジョンが一つでもあれば、すべてのコリジョンの配列を返す 
+    # 覆われたコリジョンが無い場合はnilを返す
     #_c_:: 判定対象のコリジョンインスタンス
+    #_pos_:: cの位置(Point/Rect/Square構造体、もしくは2要素の配列)
     #返却値:: コリジョンと本体の対の配列。
-    def cover_all?(c)
-      return @collisions.select{|cc| c.cover?(cc[0])}
+    def cover_all?(c, pos)
+      return @collisions.select{|cc| c.cover?(pos, cc[0], cc[1])}
     end
 
     #===インデックス形式でのコリジョン・本体の取得
-    #判定に引っかかったコリジョンが一つでもあれば、すべてのコリジョンの配列を返す    
-    #当たり判定に引っかかったコリジョンが無い場合はnilを返す
+    # 判定に引っかかったコリジョンが一つでもあれば、すべてのコリジョンの配列を返す    
+    # 当たり判定に引っかかったコリジョンが無い場合はnilを返す
     #_idx_:: 配列のインデックス番号
     #返却値:: インデックスに対応したコリジョンと本体との対
     def [](idx)
       return [@collisions[idx], @bodies[idx]]
     end
 
-    #===あとで書く
-    #返却値:: あとで書く
+    #===オブジェクトを解放する
+    #返却値:: なし
     def dispose
       @collisions.clear
       @collisions = nil