dxruby_tiled 0.1.0 → 1.0.0

data/lib/dxruby_tiled/object.rb

@@ -0,0 +1,263 @@
+module DXRuby
+  module Tiled
+    class TMEObject < DXRuby::Sprite
+      attr_reader :object_id, :properties
+      attr_accessor :name, :type
+      
+      def self.create_from_hash(hash, map = nil)
+        hash[:id] ||= map.next_object_id
+        if hash[:template]
+          template = map.load_template(hash[:template])
+          gid, source = template[:object][:gid], template[:tileset][:source]
+          template[:object][:gid] = map.tilesets.gid_adjusted_by_source(gid, source)
+          hash.merge!(template[:object])
+        end
+        object = case
+        when hash[:point]
+          PointObject.create_from_hash(hash)
+        when hash[:ellipse]
+          EllipseObject.create_from_hash(hash)
+        when hash[:polygon]
+          PolygonObject.create_from_hash(hash)
+        when hash[:polyline]
+          PolylineObject.create_from_hash(hash)
+        when hash[:text]
+          TextObject.create_from_hash(hash)
+        when hash[:gid]
+          hash[:tile] = map.tilesets[hash[:gid]]
+          TileObject.create_from_hash(hash)
+        else
+          RectangleObject.create_from_hash(hash)
+        end
+        if map && map.orientation == IsometricLayer
+          object.extend(ObjectInIsometricMap)
+          object.width_height = 1.0 * map.tile_height / map.tile_width
+        end
+        object
+      end
+      
+      def initialize(x, y, options = {})
+        super x, y, nil
+        @name        = options[:name]
+        @type        = options[:type]
+        @object_id   = options[:id]
+        @width       = options[:width]
+        @height      = options[:height]
+        @properties  = options[:properties]
+        self.angle   = options[:rotation]
+        self.visible = options[:visible]
+        self.collision_sync = true
+      end
+    end
+    
+    class PointObject < TMEObject
+      def self.create_from_hash(hash)
+        self.new(hash[:x], hash[:y], hash)
+      end
+      
+      def initialize(x, y, width, height, options = {})
+        super x, y, options
+        self.collision = [0, 0]
+      end
+      
+      def draw; end
+    end
+    
+    class RectangleObject < TMEObject
+      def self.create_from_hash(hash)
+        self.new(hash[:x], hash[:y], hash[:width], hash[:height], hash)
+      end
+      
+      def initialize(x, y, width, height, options = {})
+        options[:width]  = width
+        options[:height] = height
+        super x, y, options
+        self.collision = [0, 0, @width, @height]
+      end
+      
+      def draw; end
+    end
+    
+    class EllipseObject < TMEObject
+      def self.create_from_hash(hash)
+        self.new(hash[:x], hash[:y], hash[:width], hash[:height], hash)
+      end
+      
+      def initialize(x, y, width, height, options = {})
+        options[:width]  = width
+        options[:height] = height
+        super x, y, options
+        self.collision = [@width / 2.0, @width / 2.0, @width / 2.0]
+        self.scale_y = 1.0 * @height / @width
+      end
+      
+      def draw; end
+    end
+    
+    class PolygonObject < TMEObject
+      def self.create_from_hash(hash)
+        self.new(hash[:x], hash[:y], hash[:polygon], hash)
+      end
+      
+      def initialize(x, y, vertexs, options)
+        super x, y, options
+        collision = []
+        (vertexs.size - 2).times do |i|
+          collision.push([vertexs[0    ][:x], vertexs[0    ][:y],
+                          vertexs[i + 1][:x], vertexs[i + 1][:y],
+                          vertexs[i + 2][:x], vertexs[i + 2][:y]])
+        end
+        self.collision = collision
+      end
+      
+      def draw; end
+    end
+    
+    class PolylineObject < TMEObject
+      def self.create_from_hash(hash)
+        self.new(hash[:x], hash[:y], hash[:polyline], hash)
+      end
+      
+      def initialize(x, y, vertexs, options)
+        super x, y, options
+        collision = []
+        (vertexs.size - 2).times do |i|
+          collision.push([vertexs[0    ][:x], vertexs[0    ][:y],
+                          vertexs[i + 1][:x], vertexs[i + 1][:y],
+                          vertexs[i + 2][:x], vertexs[i + 2][:y]])
+        end
+        self.collision = collision
+      end
+      
+      def draw; end
+    end
+    
+    class TextObject < TMEObject
+      attr_accessor :text
+      
+      def self.create_from_hash(hash)
+        self.new(hash[:x], hash[:y], hash[:width], hash[:height], hash[:text][:text], hash[:text])
+      end
+      
+      def initialize(x, y, width, height, text, options = {})
+        options[:width]  = width
+        options[:height] = height
+        super x, y, options
+        @text = text
+        @fontfamily = options[:fontfamily] || ""
+        @pixelsize  = options[:pixelsize] || 16
+        @wrap       = !!options[:wrap] # unsupported
+        @color      = (options[:color] || "000000").sub("#", "").scan(/../).map{ |c| c.to_i(16) }
+        @bold       = !!options[:bold]
+        @italic     = !!options[:italic]
+        @underline  = !!options[:underline] # unsupported
+        @strikeout  = !!options[:strikeout] # unsupported
+        @kerning    = options[:kerning] != false # unsupported
+        @halign     = options[:halign] || "left" # unsupported
+        @valign     = options[:valign] || "top" # unsupported
+        
+        @font = DXRuby::Font.new(@pixelsize, @fontfamily,
+          weight: @bold, italic: @italic, auto_fitting: true
+        )
+        self.collision = [0, 0, @width, @height]
+      end
+      
+      def draw
+        self.target.draw_font(self.x, self.y, @text, @font,
+          color: @color, center_x: 0, center_y: 0, angle: self.angle, z: self.z
+        )
+      end
+    end
+    
+    class TileObject < TMEObject
+      attr_reader :tile
+      attr_accessor :start_time
+      
+      def self.evolve(object)
+        new_object = self.new(x: object.x, y: object.y, tile: object.tile, id: @object_id)
+        %w[z angle scale_x scale_y center_x center_y 
+           alpha blend shader image target
+           collision collision_enable collision_sync visible offset_sync
+           name type start_time].each do |arg|
+          new_object.send(arg + "=", object.send(arg))
+        end
+      end
+      
+      def self.create_from_hash(hash)
+        self.new(hash[:x], hash[:y], hash[:tile], hash)
+      end
+      
+      def initialize(x, y, tile, options = {})
+        super x, y, options
+        @tile = tile
+        self.image = tile.original_image
+        if tile.is_a? FlippedTile
+          self.scale_x = tile.scale_x
+          self.scale_y = tile.scale_y
+          @tile = tile.tile
+          self.extend(FlippedTileObject)
+        end
+        self.angle    = options[:rotation]
+        self.center_x = -tile.offset_x
+        self.center_y = self.image.height - tile.offset_y
+        self.collision = tile.collision
+        self.collision_enable = tile.collision_enable
+        self.offset_sync = true
+        @start_time = nil
+      end
+      
+      def draw
+        @start_time ||= DXRuby::Window::running_time
+        tile = @tile.animate((DXRuby::Window::running_time - @start_time))
+        self.image    = tile.original_image
+        self.center_x = -tile.offset_x
+        self.center_y = self.image.height - tile.offset_y
+        super
+      end
+      
+      def tile=(tile)
+        @tile = tile
+        @start_time = nil
+      end
+      
+      def become(new_class)
+        new_class.evolve(self)
+      end
+    end
+    
+    module FlippedTileObject
+      def draw
+        @start_time ||= DXRuby::Window::running_time
+        tile = @tile.animate((DXRuby::Window::running_time - @start_time))
+        self.image = tile.original_image
+        sin = Math.sin(2 * Math::PI * self.angle / 360)
+        cos = Math.cos(2 * Math::PI * self.angle / 360)
+        cx = (self.image.width  * 0.5 + tile.offset_x) * self.scale_x.abs
+        cy = (self.image.height * 0.5 - tile.offset_y) * self.scale_y.abs
+        x = self.x + cx * cos + cy * sin
+        y = self.y - cy * cos + cx * sin
+        self.target.draw_ex(x, y, self.image,
+          scale_x:  self.scale_x,
+          scale_y:  self.scale_y,
+          alpha:    self.alpha,
+          blend:    self.blend,
+          angle:    self.angle,
+          shader:   self.shader,
+          z:        self.z,
+          offset_sync: true
+        )
+      end
+    end
+    
+    module ObjectInIsometricMap
+      attr_accessor :width_height
+      def draw
+        tmp_x, tmp_y = self.x, self.y
+        self.x = tmp_x - tmp_y
+        self.y = (tmp_x + tmp_y) * @width_height
+        super
+        self.x, self.y = tmp_x, tmp_y
+      end
+    end
+  end
+end

data/lib/dxruby_tiled/objectgroup.rb

@@ -1,26 +1,47 @@
 module DXRuby
   module Tiled
-    class ObjectGroup # unsupported
-      attr_reader   :data, :name, :width, :height, :properties
-      attr_accessor :opacity, :visible, :offset_x, :offset_y
+    class ObjectGroup < Layer
+      attr_reader :x, :y, :width, :height, :draworder, :objects
       
       def initialize(data, map)
-        @original_data = data
-        @map = map
+        super
+        @x         = data[:x]         || 0
+        @y         = data[:y]         || 0
+        @width     = data[:width ]    || map.width
+        @height    = data[:height]    || map.height
+        @draworder = data[:draworder] || "topdown"
         
-        @name       = data[:name]
-        @color      = data[:color]      || [128, 128, 128]
-        @opacity    = data[:opacity]    || 1
-        @visible    = data[:visible] != false
-        @offset_x   = data[:offsetx]    || 0
-        @offset_y   = data[:offsety]    || 0
-        @properties = data[:properties] || {}
-        @draworder  = data[:draworder]  || "topdown"
+        @render_target = DXRuby::RenderTarget.new(DXRuby::Window.width, DXRuby::Window.height)
+        @objects = data[:objects].map do |object_hash|
+          object = TMEObject.create_from_hash(object_hash, map)
+          object.target = @render_target
+          if object.is_a? TileObject
+            object.scale_x = 1.0 * object_hash[:width ] / object.image.width  * object.scale_x
+            object.scale_y = 1.0 * object_hash[:height] / object.image.height * object.scale_y
+          end
+          object
+        end
       end
       
-      def draw(x, y, target = DXRuby::Window)
+      def render(x, y, target = DXRuby::Window, z = 0, offset_x = 0, offset_y = 0, opacity = 1.0)
+        if @render_target.width != target.width || @render_target.height != target.height
+          @render_target.resize(target.width, target.height)
+        end
+        @render_target.ox = offset_x + @offset_x + (@fixed ? 0 : x)
+        @render_target.oy = offset_y + @offset_y + (@fixed ? 0 : y)
+        
+        DXRuby::Sprite.update(@objects)
+        DXRuby::Sprite.clean(@objects)
+        DXRuby::Sprite.draw(
+          case @draworder
+          when "topdown" then @objects.sort_by { |obj| obj.y }
+          when "index"   then @objects.sort_by { |obj| obj.object_id }
+          else @objects
+          end
+        )
+        target.draw_alpha(0, 0, @render_target, @opacity * 255, z + @z_index)
       end
-
+      alias_method :draw, :render
     end
   end
 end

data/lib/dxruby_tiled/tile.rb

@@ -0,0 +1,139 @@
+module DXRuby
+  module Tiled
+    class Tile
+      attr_reader :image, :original_image, :offset_x, :offset_y, :adjusted_offset_y, :tileset,
+                  :scale_x, :scale_y, :angle
+      attr_accessor :type, :collision, :collision_enable
+      
+      def initialize(image, offset_x, offset_y, adjusted_offset_y, tileset = nil)
+        @image = @original_image = image
+        @offset_x = offset_x
+        @offset_y = offset_y
+        @adjusted_offset_y = adjusted_offset_y
+        @tileset = tileset
+        @type = nil
+        @anim_time_total = 1
+        @anim_time = [0]
+        @anim_tile = [self]
+        @collision = nil
+        @collision_enable = true
+        @scale_x = 1
+        @scale_y = 1
+        @angle   = 0
+      end
+      
+      def width ; @image.width ; end
+      def height; @image.height; end
+      
+      def render(x, y, target = DXRuby::Window, z_index = 0)
+        target.draw(x + @offset_x, y + @adjusted_offset_y, @image, z_index)
+      end
+      alias_method :draw, :render
+      
+      def animate(current_time)
+        time = current_time % @anim_time_total
+        @anim_tile[@anim_time.rindex { |t| time >= t } ]
+      end
+      
+      def animate!(current_time)
+        time = current_time % @anim_time_total
+        tile = @anim_tile[@anim_time.rindex { |t| time >= t } ]
+        @image    = tile.original_image
+        @offset_x = tile.offset_x
+        @offset_y = tile.offset_y
+        @adjusted_offset_y = tile.adjusted_offset_y
+      end
+      
+      def set_animation(anim_time, anim_tile)
+        @anim_time = anim_time
+        @anim_tile = anim_tile
+        @anim_time_total = @anim_time.pop
+      end
+      
+      def to_sprite(x, y)
+        TileObject.new(x: x, y: y, tile: self)
+      end
+    end
+    
+    class FlippedTile
+      attr_reader :scale_x, :scale_y, :angle, :tile
+      
+      def initialize(tile, tileid, hex = false)
+        @tile = tile
+        if hex
+          @scale_x, @scale_y, @angle = case tileid & 0xf0000000
+          when 0x10000000 then [ 1,  1, 120]
+          when 0x20000000 then [ 1,  1,  60]
+          when 0x30000000 then [-1, -1,   0]
+          when 0x40000000 then [ 1, -1,   0]
+          when 0x50000000 then [-1,  1, 300]
+          when 0x60000000 then [-1,  1, 240]
+          when 0x70000000 then [-1,  1,   0]
+          when 0x80000000 then [-1,  1,   0]
+          when 0x90000000 then [-1,  1, 120]
+          when 0xa0000000 then [-1,  1,  60]
+          when 0xb0000000 then [ 1, -1,   0]
+          when 0xc0000000 then [-1, -1,   0]
+          when 0xd0000000 then [ 1,  1, 300]
+          when 0xe0000000 then [ 1,  1, 240]
+          when 0xf0000000 then [ 1,  1,   0]
+          end
+        else
+          @scale_x, @scale_y, @angle = case tileid & 0xe0000000
+          when 0x20000000 then [ 1, -1, 90]
+          when 0x40000000 then [ 1, -1,  0]
+          when 0x60000000 then [-1, -1, 90]
+          when 0x80000000 then [-1,  1,  0]
+          when 0xa0000000 then [ 1,  1, 90]
+          when 0xc0000000 then [-1, -1,  0]
+          when 0xe0000000 then [-1,  1, 90]
+          end
+        end
+        extend DXRuby::Tiled::DiagonallyFlippedTile if @angle == 90
+      end
+      
+      def render(x, y, target=DXRuby::Window, z_index = 0)
+        target.draw_ex(x + offset_x, y + adjusted_offset_y, @tile.image,
+                       { scale_x: @scale_x, scale_y: @scale_y, angle: @angle, z: z_index })
+      end
+      alias_method :draw, :render
+      
+      def width; @tile.width; end
+      def height; @tile.height; end
+      def image; @tile.image; end
+      def original_image; @tile.original_image; end
+      def offset_x; @tile.offset_x; end
+      def offset_y; @tile.offset_y; end
+      def adjusted_offset_y; @tile.adjusted_offset_y; end
+      def tileset; @tile.tileset; end
+      def type; @tile.type; end
+      def type=(value); @tile.type = value; end
+      def collision; @tile.collision; end
+      def collision=(value); @tile.collision = value; end
+      def collision_enable; @tile.collision_enable; end
+      def collision_enable=(value); @tile.collision_enable = value; end
+      
+      def to_sprite(x, y)
+        TileObject.new(x, y, self, rotation: @angle)
+      end
+    end
+    
+    module DiagonallyFlippedTile
+      def width ; @tile.height; end
+      def height; @tile.width ; end
+      
+      def offset_x
+        @tile.offset_x + (@tile.height - @tile.width) / 2
+      end
+      
+      def offset_y
+        @tile.offset_y + (@tile.height - @tile.width) / 2
+      end
+      
+      def adjusted_offset_y
+        @tile.adjusted_offset_y + (@tile.height - @tile.width) / 2
+      end
+    end
+  end
+end
+