cyross-ruby-miyako 2.0.0 → 2.0.5.1.0

data/lib/Miyako/API/fixedmap.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
@@ -31,7 +31,8 @@ module Miyako
     @@idx_ix = [-1, 2, 4]
     @@idx_iy = [-1, 0, 6]
 
-    attr_reader :name, :map_layers, :pos, :w, :h
+    attr_accessor :visible #レンダリングの可否(true->描画 false->非描画)
+    attr_reader :name, :map_layers, :mapchips, :pos, :size, :w, :h
 
     #==あとで書く
     class FixedMapLayer #:nodoc: all
@@ -39,7 +40,8 @@ module Miyako
 
       @@use_chip_list = Hash.new(nil)
       
-      attr_accessor :mapchip_units
+      attr_accessor :visible #レンダリングの可否(true->描画 false->非描画)
+      attr_accessor :mapchip, :mapchip_units
       attr_reader :pos
 
       def round(v, max) #:nodoc:
@@ -53,9 +55,9 @@ module Miyako
         @ch = @real_size.h % @oh == 0 ? @real_size.h / @oh : (@real_size.h + @oh - 1)/ @oh + 1
       end
 
-      def initialize(mapchip, mapdat, layer_size, pos) #:nodoc:
+      def initialize(mapchip, mapdat, layer_size) #:nodoc:
         @mapchip = mapchip
-        @pos = pos.dup
+        @pos = Point.new(0, 0)
         @size = layer_size.dup
         @ow = @mapchip.chip_size.w
         @oh = @mapchip.chip_size.h
@@ -64,7 +66,7 @@ module Miyako
         @baseimg = nil
         @baseimg = @mapchip.chip_image
         @units = nil
-        @visible = false
+        @visible = true
         @divpx = get_div_array(0, @real_size.w, @ow)
         @divpy = get_div_array(0, @real_size.h, @oh)
         @modpx = get_mod_array(0, @real_size.w, @ow)
@@ -104,170 +106,237 @@ module Miyako
                          @modpy2[round(y, @size.h)])
       end
 
-      def get_code(x, y) #:nodoc:
-        pos = convert_position(x, y)
+      #===指定の矩形のキャラクタに掛かるマップチップの左上位置の組み合わせを返す
+      #但し、引数には、Rect(x,y,w,h)形式のインスタンスを渡す
+      #_rect_:: キャラクタの矩形
+      #返却値:: マップチップ左上位置の配列(キャラクタに掛かる位置の組み合わせ)
+      def product_position(rect)
+        return Utility.product_position(rect, @mapchip.chip_size)
+      end
+
+      #===指定の矩形のキャラクタに掛かるマップチップの左上位置の組み合わせを返す
+      #但し、引数には、Square([x1,y1,x2,y2])形式のインスタンスを渡す
+      #_square_:: キャラクタの矩形
+      #返却値:: マップチップ左上位置の配列(キャラクタに掛かる位置の組み合わせ)
+      def product_position_by_square(square)
+        return Utility.product_position_by_square(square, @mapchip.chip_size)
+      end
+
+      #===実座標を使用して、指定のレイヤー・位置のマップチップ番号を取得
+      #イベントレイヤーでの番号はイベント番号と一致する
+      #_x_:: マップチップ単位での位置(ピクセル単位)
+      #_y_:: マップチップ単位での位置(ピクセル単位）
+      #返却値:: マップチップ番号(マップチップが設定されている時は0以上の整数、設定されていない場合は-1が返る)
+      def get_code(x, y)
+        pos = convert_position(x / @mapchip.chip_size[0], y / @mapchip.chip_size[1])
         return @mapdat[pos.y][pos.x]
       end
 
+      #===キャラクタとマップチップが重なっているかどうか問い合わせる
+      #指定の矩形のキャラクタが、指定の位置のマップチップのコリジョンと重なっているかどうか問い合わせる
+      #引数は、Rect(x,y,w,h)形式(Rect構造体、[x,y,w,h]の配列)で渡す
+      #指定の位置のマップチップ番号が-1(未定義)のときはfalseを返す
+      #_type_:: 移動形式(0以上の整数)
+      #_pos_:: 調査対象のマップチップの位置
+      #_collision_:: キャラクタのコリジョン
+      #_rect_:: キャラクタの矩形
+      #返却値:: コリジョンが重なっていればtrueを返す
+      def collision?(type, pos, collision, rect)
+        code = get_code(*pos.to_a)
+        return false if code == -1
+        return @mapchip.collision_table[type][code].collision?(pos, collision, rect)
+      end
+
+      #===キャラクタとマップチップが隣り合っているかどうか問い合わせる
+      #指定の矩形のキャラクタが、指定の位置のマップチップのコリジョンと隣り合っているかどうか問い合わせる
+      #引数は、Rect(x,y,w,h)形式(Rect構造体、[x,y,w,h]の配列)で渡す
+      #指定の位置のマップチップ番号が-1(未定義)のときはfalseを返す
+      #_type_:: 移動形式(0以上の整数)
+      #_pos_:: 調査対象のマップチップの位置
+      #_collision_:: キャラクタのコリジョン
+      #_rect_:: キャラクタの矩形
+      #返却値:: コリジョンが隣り合っていればtrueを返す
+      def meet?(type, pos, collision, rect)
+        code = get_code(*pos.to_a)
+        return false if code == -1
+        return @mapchip.collision_table[type][code].meet?(pos, collision, rect)
+      end
+
+      #===キャラクタとマップチップが覆い被さっているかどうか問い合わせる
+      #指定の矩形のキャラクタが、指定の位置のマップチップのコリジョンを覆い被さっているかどうか問い合わせる
+      #引数は、Rect(x,y,w,h)形式(Rect構造体、[x,y,w,h]の配列)で渡す
+      #指定の位置のマップチップ番号が-1(未定義)のときはfalseを返す
+      #_type_:: 移動形式(0以上の整数)
+      #_pos_:: 調査対象のマップチップの位置
+      #_collision_:: キャラクタのコリジョン
+      #_rect_:: キャラクタの矩形
+      #返却値:: どちらかのコリジョンが覆い被さっていればtrueを返す
+      def cover?(type, pos, collision, rect)
+        code = get_code(*pos.to_a)
+        return false if code == -1
+        return @mapchip.collision_table[type][code].cover?(pos, collision, rect)
+      end
+
+      #===キャラクタとマップチップが重なっているかどうか問い合わせる
+      #指定の位置と方向で、指定の位置のマップチップ上で移動できるかどうか問い合わせる
+      #指定の位置のマップチップ番号が-1(未定義)のとき、移動していない(dx==0 and dy==0)ときはtrueを返す
+      #_type_:: 移動形式(0以上の整数)
+      #_inout_:: 入退形式(:in もしくは :out)
+      #_pos_:: 調査対象のマップチップの位置
+      #_dx_:: 移動量(x座標)
+      #_dy_:: 移動量(y座標)
+      #返却値:: 移動可能ならばtrueを返す
+      def can_access?(type, inout, pos, dx, dy)
+        code = get_code(pos[0]+dx, pos[1]+dy)
+        return true if code == -1
+        index = AccessIndex.index2(inout, dx, dy)
+        return true if index == -1
+        return @mapchip.access_table[type][code][index]
+      end
+
       def dispose #:nodoc:
         @mapdat = nil
         @baseimg = nil
       end
 
+      #===マップレイヤーを画面に描画する
+      #すべてのマップチップを画面に描画する
+      #ブロック付きで呼び出し可能(レシーバに対応したSpriteUnit構造体が引数として得られるので、補正をかけることが出来る)
+      #(ブロック引数のインスタンスは複写しているので、メソッドの引数として渡した値が持つSpriteUnitには影響しない)
+      #ブロックの引数は、|画面のSpriteUnit|となる。
+      #visibleメソッドの値がfalseのときは描画されない。
+      #返却値:: 自分自身を返す
+      def render
+      end
+
+      #===マップを画像に描画する
+      #すべてのマップチップを画像に描画する
+      #各レイヤ－を、レイヤーインデックス番号の若い順に描画する
+      #但し、マップイベントは描画しない
+      #ブロック付きで呼び出し可能(レシーバに対応したSpriteUnit構造体が引数として得られるので、補正をかけることが出来る)
+      #(ブロック引数のインスタンスは複写しているので、メソッドの引数として渡した値が持つSpriteUnitには影響しない)
+      #ブロックの引数は、|転送先のSpriteUnit|となる。
+      #visibleメソッドの値がfalseのときは描画されない。
+      #_dst_:: 転送先ビットマップ(to_unitメソッドを呼び出すことが出来る/値がnilではないインスタンス)
+      #返却値:: 自分自身を返す
+      def render_to(dst)
+      end
+
       def_delegators(:@size, :w, :h)
     end
 
-    #===あとで書く
-    #_mapchip_:: あとで書く
-    #_layer_csv_:: あとで書く
+
+    #===インスタンスを生成する
+    #各レイヤにMapChip構造体を渡す
+    #但し、すべてのレイヤーに同一のMapChip構造体を使うときは、単体で渡すことも可能
+    #第1引数にto_aメソッドが実装されていれば、配列化した要素をMapChip構造体として各レイヤに渡す
+    #また、各レイヤにMapChip構造体を渡すとき、レイヤ数より要素数が少ないときは、
+    #先頭に戻って繰り返し渡す仕様になっている
+    #各MapChip構造体のマップチップの大きさを同じにしておく必要がある
+    #_mapchips_:: マップチップ構造体群(MapChip構造体単体もしくは配列)
+    #_layer_csv_:: レイヤーファイル(CSVファイル)
     #_event_manager_:: MapEventManagerクラスのインスタンス
-    #_pos_:: あとで書く
-    #返却値:: あとで書く
-    def initialize(mapchip, layer_csv, event_manager, pos = Point.new(0, 0))
+    #返却値:: 生成したインスタンス
+    def initialize(mapchips, layer_csv, event_manager)
       init_layout
+      @visible = true
+      @event_layers = []
       @em = event_manager.dup
       @em.set(self)
-      @mapchip = mapchip
-      @pos = Point.new(*(pos.to_a))
-      @coll = Collision.new(Rect.new(0, 0, 0, 0), Point.new(0, 0))
+      @mapchips = mapchips.to_a
       layer_data = CSV.readlines(layer_csv)
 
       raise MiyakoError, "This file is not Miyako Map Layer file! : #{layer_csv}" unless layer_data.shift[0] == "Miyako Maplayer"
 
       tmp = layer_data.shift # 空行の空読み込み
 
-      layer_size = Size.new(tmp[0].to_i, tmp[1].to_i)
-      @w = layer_size.w * @mapchip.chip_size.w
-      @h = layer_size.h * @mapchip.chip_size.h
+      @size = Size.new(tmp[0].to_i, tmp[1].to_i)
+      @w = @size.w * @mapchips.first.chip_size.w
+      @h = @size.h * @mapchips.first.chip_size.h
 
       layers = layer_data.shift[0].to_i
 
-      brlist = {}
+      evlist = []
+      brlist = []
       layers.times{|n|
         name = layer_data.shift[0]
-        if name == "<event>"
-          name = :event
-        else
-          name = /\<(\d+)\>/.match(name).to_a[1].to_i
-        end
         values = []
-        layer_size.h.times{|y|
+        @size.h.times{|y|
           values << layer_data.shift.map{|m| m.to_i}
         }
-        brlist[name] = values
+        if name == "<event>"
+          evlist << values
+        else
+          brlist << values
+        end
       }
 
-      @map_layers = Array.new
       @event_layer = nil
 
-      if brlist.has_key?(:event)
-        @event_layer = Array.new
-        brlist[:event].each_with_index{|ly, y|
+      evlist.each{|events|
+        event_layer = Array.new
+        events.each_with_index{|ly, y|
           ly.each_with_index{|code, x|
             next unless @em.include?(code)
-            @event_layer.push(@em.create(code, x * @mapchip.chip_size.w, y * @mapchip.chip_size.h))
+            event_layer.push(@em.create(code, x * @mapchips.first.chip_size.w, y * @mapchips.first.chip_size.h))
           }
         }
-        layers -= 1
-      end
+        @event_layers << event_layer
+      }
+
+      mc = @mapchips.cycle
+      @mapchips = mc.take(layers)
       @map_layers = []
-      layers.times{|i|
-        br = brlist[i].map{|b| b.map{|bb| bb >= @mapchip.chips ? -1 : bb } }
-        @map_layers.push(FixedMapLayer.new(@mapchip, br, layer_size, pos))
+      brlist.each{|br|
+        br = br.map{|b| b.map{|bb| bb >= @mapchips.first.chips ? -1 : bb } }
+        @map_layers.push(FixedMapLayer.new(mc.next, br, @size))
       }
       set_layout_size(@w, @h)
     end
 
     #===マップにイベントを追加する
-    #_code_:: イベント番号(FixedMap.newメソッドで渡したイベント番号に対応)
+    #_idx_:: 追加するイベントレイヤの指標
+    #_code_:: イベント番号(Map.newメソッドで渡したイベント番号に対応)
     #_x_:: マップ上の位置(x方向)
     #_y_:: マップ常温位置(y方向)
     #返却値:: 自分自身を返す
-    def add_event(code, x, y)
+    def add_event(idx, code, x, y)
       return self unless @em.include?(code)
-      @event_layer.push(@em.create(code, x, y))
+      @event_layers[idx].push(@em.create(code, x, y))
       return self
     end
 
     def update_layout_position #:nodoc:
-      d = Point.new(@layout.pos[0]-@pos.x, @layout.pos[1]-@pos.y)
-      @pos.move_to(*@layout.pos)
-      @map_layers.each{|ml| ml.pos.move_to(*@pos) }
+      @map_layers.each{|ml| ml.pos.move_to(*@layout.pos) }
     end
 
     def [](idx) #:nodoc:
       return @map_layers[idx]
     end
 
-    #===あとで書く
-    #_idx_:: あとで書く
-    #_x_:: あとで書く
-    #_y_:: あとで書く
-    #返却値:: あとで書く
-    def get_code_real(idx, x, y)
-      code = @map_layers[idx].get_code((x-@pos[0]) / @mapchip.chip_size[0], (y-@pos[1]) / @mapchip.chip_size[1])
-      yield code if block_given?
-      return code
-    end
-
-    #===あとで書く
-    #_idx_:: あとで書く
-    #_x_:: あとで書く
-    #_y_:: あとで書く
-    #返却値:: あとで書く
-    def get_code(idx, x, y)
+    #===実座標を使用して、指定のレイヤー・位置のマップチップ番号を取得
+    #イベントレイヤーでの番号はイベント番号と一致する
+    #ブロックを渡すと、求めたマップチップ番号をブロック引数として受け取る評価を行える
+    #_idx_:: マップレイヤー配列のインデックス
+    #_x_:: マップチップ単位での位置(ピクセル単位)
+    #_y_:: マップチップ単位での位置(ピクセル単位）
+    #返却値:: マップチップ番号(マップチップが設定されている時は0以上の整数、設定されていない場合は-1が返る)
+    def get_code(idx, x = 0, y = 0)
       code = @map_layers[idx].get_code(x, y)
       yield code if block_given?
       return code
     end
 
-    #===あとで書く
-    #_idx_:: あとで書く
-    #_code_:: あとで書く
-    #_base_:: あとで書く
-    #返却値:: あとで書く
+    #===対象のマップチップ番号の画像を置き換える
+    #_idx_:: 置き換えるマップチップレイヤー番号
+    #_code_:: 置き換えるマップチップ番号
+    #_base_:: 置き換え対象の画像・アニメーション
+    #返却値:: 自分自身を返す
     def set_mapchip_base(idx, code, base)
       @map_layers[idx].mapchip_units[code] = base
       return self
     end
 
-    #===あとで書く
-    #_type_:: あとで書く
-    #_rect_:: あとで書く
-    #_collision_:: あとで書く
-    #返却値:: あとで書く
-    def get_amount_by_rect(type, rect, collision)
-      mma = MapMoveAmount.new([], collision.direction.dup)
-      return mma if(mma.amount[0] == 0 && mma.amount[1] == 0)
-      dx, dy = collision.direction[0]*collision.amount[0], collision.direction[1]*collision.amount[1]
-      x, y = rect[0]-@pos[0], rect[1]-@pos[1]
-      collision.pos = Point.new(x, y)
-      px1, px2 = (x+dx) / @mapchip.chip_size[0], (x+rect[2]-1+dx) / @mapchip.chip_size[0]
-      py1, py2 = (y+dy) / @mapchip.chip_size[1], (y+rect[3]-1+dy) / @mapchip.chip_size[1]
-      (py1..py2).each{|py|
-        rpy = py * @mapchip.chip_size[1]
-        (px1..px2).each{|px|
-          rpx = px * @mapchip.chip_size[0]
-          @map_layers.each_with_index{|ml, idx|
-            code = ml.get_code(px, py)
-            next if code == -1 # not use chip
-            @coll = @mapchip.collision_table[type][code].dup
-            @coll.pos  = Point.new(rpx, rpy)
-            atable = @mapchip.access_table[type][code]
-            if @coll.into?(collision)
-              mma.amount[0] = mma.amount[0] & atable[@@idx_ix[collision.direction[0]]]
-              mma.amount[1] = mma.amount[1] & atable[@@idx_iy[collision.direction[1]]]
-              mma.collisions << [idx, code, :into]
-            end
-          }
-        }
-      }
-      mma.amount[0] *= collision.amount[0]
-      mma.amount[1] *= collision.amount[1]
-      yield mma if block_given?
-      return mma
-    end
-
     #===現在の画面の最大の大きさを矩形で取得する
     #但し、FixedMapの場合は最大の大きさ=画面の大きさなので、rectと同じ値が得られる
     #返却値:: 画像の大きさ(Rect構造体のインスタンス)
@@ -275,41 +344,85 @@ module Miyako
       return self.rect
     end
 
-    #===あとで書く
-    #返却値:: あとで書く
+    #===スプライトに変換した画像を表示する
+    #すべてのパーツを貼り付けた、１枚のスプライトを返す
+    #引数1個のブロックを渡せば、スプライトに補正をかけることが出来る
+    #返却値:: 描画したスプライト
+    def to_sprite
+      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
+
+    #===SpriteUnit構造体を生成する
+    #いったんSpriteインスタンスを作成し、それをもとにSpriteUnit構造体を生成する。
+    #返却値:: 生成したSpriteUnit構造体
+    def to_unit
+      return self.to_sprite.to_unit
+    end
+
+    #===マップチップ１枚の大きさを取得する
+    #マップチップの大きさが32×32ピクセルの場合は、[32,32]のSize構造体が返る
+    #返却値:: マップチップのサイズ(Size構造体)
     def chipSize
-      return @mapchip.chip_size
+      return @mapchips.first.chip_size
     end
 
-    #===あとで書く
-    #返却値:: あとで書く
+    #===すべてのマップイベントを終了させる
+    #マップに登録しているイベントすべてのfinalメソッドを呼び出す
     def final
-      @event_layer.each{|e| e.final } if @event_layer
+      @event_layers.each{|ee| ee.each{|e| e.final }}
     end
 
-    #===あとで書く
-    #返却値:: あとで書く
+    #===マップ情報を解放する
     def dispose
       @map_layers.each{|l|
         l.dispose
         l = nil
       }
       @map_layers = Array.new
-      if @event_layer
-        @event_layer.each{|e| e.dispose }
-        @event_layer = nil
-      end
-    end
 
-    def re_size #:nodoc:
-      @map_layers.each{|l| l.reSize }
-      return self
+      @event_layers.each{|ee|
+        ee.each{|e| e.dispose }
+        ee.clear
+      }
+      @event_layers.clear
+
+      @mapchips.clear
+      @mapchips = nil
     end
 
     #===マップに登録しているイベントインスタンス(マップイベント)を取得する
     #返却値:: マップイベントの配列
     def events
-      return @event_layer || []
+      return @event_layers
+    end
+
+    #===マップを画面に描画する
+    #すべてのマップチップを画面に描画する
+    #各レイヤ－を、レイヤーインデックス番号の若い順に描画する
+    #但し、マップイベントは描画しない
+    #ブロック付きで呼び出し可能(レシーバに対応したSpriteUnit構造体が引数として得られるので、補正をかけることが出来る)
+    #(ブロック引数のインスタンスは複写しているので、メソッドの引数として渡した値が持つSpriteUnitには影響しない)
+    #ブロックの引数は、|画面のSpriteUnit|となる。
+    #visibleメソッドの値がfalseのときは描画されない。
+    #返却値:: 自分自身を返す
+    def render
+    end
+
+    #===マップレイヤーを画像に転送する
+    #すべてのマップチップを画像に描画する
+    #ブロック付きで呼び出し可能(レシーバに対応したSpriteUnit構造体が引数として得られるので、補正をかけることが出来る)
+    #(ブロック引数のインスタンスは複写しているので、メソッドの引数として渡した値が持つSpriteUnitには影響しない)
+    #ブロックの引数は、|転送先のSpriteUnit|となる。
+    #visibleメソッドの値がfalseのときは描画されない。
+    #_dst_:: 転送先ビットマップ(to_unitメソッドを呼び出すことが出来る/値がnilではないインスタンス)
+    #返却値:: 自分自身を返す
+    def render_to(dst)
     end
   end
 end