dxruby_tiled 0.1.0 → 1.0.0

data/lib/dxruby_tiled/tilelayer.rb

@@ -0,0 +1,116 @@
+module DXRuby
+  module Tiled
+    class TileLayer < Layer
+      attr_reader :width, :height, :startx, :starty
+      
+      def initialize(data, map)
+        super
+        if data[:chunks]
+          @x1 = data[:chunks].map {|chunk| chunk[:x] }.min
+          @y1 = data[:chunks].map {|chunk| chunk[:y] }.min
+          @x2 = data[:chunks].map {|chunk| chunk[:x] + chunk[:width ] }.max
+          @y2 = data[:chunks].map {|chunk| chunk[:y] + chunk[:height] }.max
+          @data = Array.new((@x2 - @x1) * (@y2 - @y1), 0)
+          data[:chunks].each do |chunk|
+            get_data(chunk[:data], data[:encoding], data[:compression]).each_with_index do |d, i|
+              x, y = chunk[:x] + i % chunk[:width] - @x1, chunk[:y] + i / chunk[:width] - @y1
+              @data[y * (@x2 - @x1) + x] = d
+            end
+          end
+        else
+          @x1 = data[:startx] || 0
+          @y1 = data[:starty] || 0
+          @x2 = @x1 + (data[:width ] || map.width )
+          @y2 = @y1 + (data[:height] || map.height)
+          @data = get_data(data[:data], data[:encoding], data[:compression])
+        end
+        @startx = @x1
+        @starty = @y1
+        @width  = @x2 - @x1
+        @height = @y2 - @y1
+        @tile_width  = map.tile_width
+        @tile_height = map.tile_height
+        @renderorder_x = map.renderorder_x
+        @renderorder_y = map.renderorder_y
+        @render_target = DXRuby::RenderTarget.new(DXRuby::Window.width, DXRuby::Window.height)
+        @tilesets = map.tilesets
+        
+        self.extend LoopTileLayer if map.loop
+      end
+      
+      def [](x, y)
+        x < @x1 || x >= @x2 || y < @y1 || y >= @y2 ?
+          0 : @data[(y - @y1) * @width + x - @x1]
+      end
+      
+      def []=(x, y, value)
+        return if x < @x1 || x >= @x2 || y < @y1 || y >= @y2
+        @data[(y - @y1) * @width + x - @x1] = value
+      end
+      
+      def include?(x, y)
+        x >= @x1 && x < @x2 && y >= @y1 && y < @y2
+      end
+      alias_method :member?, :include?
+      
+      def at(pos_x, pos_y)
+        x, y = xy_at(pos_x, pos_y)
+        self[x, y]
+      end
+      
+      def change_at(pos_x, pos_y, value)
+        x, y = xy_at(pos_x, pos_y)
+        self[x, y] = value
+      end
+      
+      def tile_at(pos_x, pos_y)
+        @tilesets[at(pos_x, pos_y)]
+      end
+      
+      def render(pos_x, pos_y, target = DXRuby::Window, z = 0, offset_x = 0, offset_y = 0, opacity = 1.0)
+        unless @render_target.width == target.width && @render_target.height == target.height
+          @render_target.resize(target.width, target.height)
+        end
+      end
+      alias_method :draw, :render
+    
+      private
+    
+      def get_data(data, encoding, compression)
+        case encoding
+        when "base64"
+          tmp = Base64.decode64(data)
+          case compression
+          when "gzip" # unsupported
+            raise NotImplementedError.new("GZip is unsupported.")
+          when "zlib"
+            data_array = Zlib::Inflate.inflate(tmp).unpack("L*")
+          else
+            data_array = tmp.unpack("L*")
+          end
+        else
+          data_array = data
+        end
+        data_array
+      end
+    end
+    
+    module LoopTileLayer
+      def [](x, y)
+        @data[((y - @y1) % @height) * @width + ((x - @x1) % @width)]
+      end
+      
+      def []=(x, y, value)
+        @data[((y - @y1) % @height) * @width + ((x - @x1) % @width)] = value
+      end
+      
+      def include?(x, y)
+        true
+      end
+      
+      def member?(x, y)
+        true
+      end
+    end
+  end
+end

data/lib/dxruby_tiled/tileset.rb

@@ -1,15 +1,16 @@
 module DXRuby
   module Tiled
     class Tileset
-      attr_reader :firstgid, :name, :tile_width, :tile_height,
+      attr_reader :firstgid, :source, :name, :tile_width, :tile_height,
                   :spacing, :margin, :tile_count, :columns, :tile_offset, :properties,
-                  :tile_images, :animations
+                  :tiles, :animations
       
       def initialize(data, map)
-        @data = data
-        @map  = map
+        @firstgid = data[:firstgid] || 1
+        @source = data[:source]
+        data_dir = @source ? File.dirname(@source) : map.data_dir
+        data = map.load_tileset(@source) if @source
         
-        @firstgid    = data[:firstgid]  || 1
         @name        = data[:name]
         @tile_width  = data[:tilewidth]  || map.tile_width
         @tile_height = data[:tileheight] || map.tile_height
@@ -17,18 +18,62 @@ module DXRuby
         @margin      = data[:margin]     || 0
         @tile_count  = data[:tilecount]
         @columns     = data[:columns]
-        @tile_offset = data[:tileoffset] # unsupported
+        @tile_offset = data[:tileoffset] || { x: 0, y: 0 }
         @properties  = data[:properties] || {}
         
-        image = @map.load_image(data[:image])
-        if data[:transparentcolor]
-          color = data[:transparentcolor].sub("#", "").scan(/../).map{|c| c.to_i(16) }
-          image.set_color_key(color)
+        @tiles = []
+        tile_images = []
+        if data[:image]
+          image = map.load_image(data[:image], data[:transparentcolor], data_dir)
+          image_width  = data[:imagewidth]  || image.width
+          image_height = data[:imageheight] || image.height
+          tile_images = split_image(image, image_width, image_height)
+          image.dispose()
+        else
+          data[:tiles].each_pair do |key, value|
+            tile_images[key.to_s.to_i] = map.load_image(value[:image], nil, data_dir)
+          end
+        end
+        @tile_count = tile_images.size unless @tile_count
+        
+        adjusted_offset_x = map.orientation == IsometricLayer ? map.tile_width / 2 : 0
+        adjusted_offset_y = @tile_offset[:y] + map.tile_height
+        tile_images.each_with_index do |image, i|
+          next unless image
+          @tiles[i] = Tile.new(
+            image,
+            @tile_offset[:x] - adjusted_offset_x,
+            @tile_offset[:y], adjusted_offset_y - image.height,
+            self
+          )
         end
-        image_width  = data[:imagewidth]  || image.width
-        image_height = data[:imageheight] || image.height
         
-        @tile_images = []
+        tiles_data = data[:tiles] || {}
+        set_types(tiles_data)
+        set_animations(tiles_data)
+        set_collisions(tiles_data)
+      end
+      
+      def dispose()
+        @tiles.each_value do |tile|
+          @tile.image.dispose()
+        end
+      end
+      
+      def delayed_dispose()
+        @tiles.each_value do |tile|
+          @tile.image.delayed_dispose()
+        end
+      end
+      
+      def disposed?()
+        @tiles[0].image.disposed?()
+      end
+      
+      private
+      
+      def split_image(image, image_width, image_height)
+        tile_images = []
         i = 0
         col = 1
         x = @margin
@@ -41,31 +86,59 @@ module DXRuby
           end
           break if y + @tile_height > image_height
           
-          @tile_images[i] = image.slice(x, y, @tile_width, @tile_height)
+          tile_images[i] = image.slice(x, y, @tile_width, @tile_height)
           x += @tile_width + @spacing
           i += 1
           col += 1
           break if @tile_count && i >= @tile_count
         end
-        @tile_count = i unless @tile_count
-        image.dispose()
-        
-        @animations = {}
-        (data[:tiles] || {}).each_pair do |key, value|
+        tile_images
+      end
+      
+      def set_types(tiles_data)
+        tiles_data.each_pair do |key, value|
+          next unless value.has_key?(:type)
+          @tiles[key.to_s.to_i].type = value[:type]
+        end
+      end
+      
+      def set_animations(tiles_data)
+        @animations = []
+        tiles_data.each_pair do |key, value|
           next unless value.has_key?(:animation)
-          anim_time  = []
-          anim_image = []
-          time = 0
+          anim_time = [0]
+          anim_tile = []
           value[:animation].each do |anim|
-            anim_time.push(time)
-            anim_image.push(@tile_images[anim[:tileid]])
-            time += anim[:duration]
+            anim_time.push(anim_time.last + anim[:duration])
+            anim_tile.push(@tiles[anim[:tileid]])
           end
-          anim_time.push(time)
-          @animations[@firstgid + key.to_s.to_i] = { time: anim_time, image: anim_image }
+          @tiles[key.to_s.to_i].set_animation(anim_time, anim_tile)
+          @animations.push(key.to_s.to_i)
         end
       end
       
+      def set_collisions(tiles_data)
+        tiles_data.each_pair do |key, value|
+          next unless value.has_key?(:objectgroup)
+          next unless value[:objectgroup].has_key?(:objects)
+          collision = []
+          value[:objectgroup][:objects].each do |obj|
+            case
+            when obj[:ellipse]
+              collision.push([obj[:x], obj[:y], (obj[:width] + obj[:height]) / 2])
+            when obj[:polygon]
+              (obj[:polygon].size - 2).times do |i|
+                collision.push([obj[:polygon][0    ][:x], obj[:polygon][0    ][:y],
+                                obj[:polygon][i + 1][:x], obj[:polygon][i + 1][:y],
+                                obj[:polygon][i + 2][:x], obj[:polygon][i + 2][:y]])
+              end
+            else
+              collision.push([obj[:x], obj[:y], obj[:x] + obj[:width], obj[:y] + obj[:height]])
+            end
+          end
+          @tiles[key.to_s.to_i].collision = collision
+        end
+      end
     end
   end
 end

data/lib/dxruby_tiled/tilesets.rb

@@ -1,34 +1,68 @@
 module DXRuby
   module Tiled
     class Tilesets
-      attr_reader :tile_images
+      attr_reader :tiles, :tile_left, :tile_right, :tile_top, :tile_bottom
       
       def initialize(data, map)
-        @data = data
-        @map  = map
-        
         @last_time = 0
-        @tile_images = [DXRuby::Image.new(32, 32)]
-        @tilesets = @data.map{|tileset| Tileset.new(tileset, @map)}
-        @animations = {}
+        @tiles = {}
+        dummy_tile = Tile.new(DXRuby::Image.new(map.tile_width, map.tile_height), 0, 0, 0)
+        def dummy_tile.render(x, y, target = DXRuby::Window, z_index = 0); end
+        def dummy_tile.draw(x, y, target = DXRuby::Window, z_index = 0); end
+        @tiles[0] = dummy_tile
+        @tiles.default = dummy_tile
         
+        @animations = []
+        @tilesets = data.map { |tileset| Tileset.new(tileset, map) }
+        hex = map.orientation == HexagonalLayer
         @tilesets.each do |tileset|
-          gid = tileset.firstgid || @tile_images.size
-          tileset.tile_images.each_index{|i| @tile_images[gid + i] = tileset.tile_images[i] }
-          @animations.merge!(tileset.animations)
+          gid = tileset.firstgid
+          tileset.tiles.each_with_index do |tile, i|
+            next unless tile
+            @tiles[gid + i] = tile
+            range = hex ? 1..15 : 1..7
+            k     = hex ? 0x10000000 : 0x20000000
+            range.each do |j|
+              tileid = j * k + gid + i
+              @tiles[tileid] = FlippedTile.new(tile, tileid, hex)
+            end
+          end
+          tileset.animations.each { |i| @animations.push(gid + i) }
         end
+        @tile_left   = @tiles.values.map { |tile| tile.offset_x }.min
+        @tile_top    = @tiles.values.map { |tile| tile.offset_y }.min
+        @tile_right  = @tiles.values.map { |tile| tile.offset_x + tile.width  }.max
+        @tile_bottom = @tiles.values.map { |tile| tile.offset_y + tile.height }.max
+      end
+      
+      def [](num)
+        @tiles[num]
       end
       
-      def animation()
+      def animate()
         return if @last_time == DXRuby::Window::running_time
         @last_time = DXRuby::Window::running_time
         
-        @animations.each_pair do |key, anim|
-          time = @last_time % anim[:time].last
-          @tile_images[key] = anim[:image][anim[:time].rindex{|t| time >= t }]
-        end
+        @animations.each { |i| @tiles[i].animate!(@last_time) }
+      end
+      
+      def gid_adjusted_by_source(gid, source)
+        gid + @tilesets.find { |tileset| tileset.source == source }.firstgid - 1
       end
       
+      def dispose()
+        @tilesets.each_value { |tileset| tileset.dispose() }
+        @tiles[0].image.dispose()
+      end
+      
+      def delayed_dispose()
+        @tilesets.each_value { |tileset| tileset.delayed_dispose() }
+        @tiles[0].image.delayed_dispose()
+      end
+      
+      def disposed?()
+        @tiles[0].image.disposed?()
+      end
     end
   end
 end

data/lib/dxruby_tiled/tmx_loader.rb

@@ -0,0 +1,271 @@
+require "dxruby_tiled"
+require "rexml/document"
+
+module DXRuby
+  module Tiled
+    module TMXLoader
+      module_function
+      
+      def load_tmx(tmxfile, encoding = Encoding::UTF_8, dir = nil)
+        Map.new(
+          TMXLoader.tmx_to_hash(TMXLoader.read_xmlfile(tmxfile, encoding)),
+          dir || File.dirname(tmxfile)
+        )
+      end
+      
+      def read_xmlfile(xmlfile, encoding = Encoding::UTF_8)
+        REXML::Document.new(DXRuby::Tiled.read_file(xmlfile, encoding))
+      end
+      
+      def element_to_hash(elm, attrs_i = [], attrs_f = [], attrs_b = [])
+        hash = {}
+        
+        elm.attributes.each_pair do |key, value|
+          str = value.to_s
+          if attrs_i.include?(key)
+            hash[key.to_sym] = str.to_i
+          elsif attrs_f.include?(key)
+            hash[key.to_sym] = str.to_f
+          elsif attrs_b.include?(key)
+            hash[key.to_sym] = !!str && str != "0" && str != "false"
+          else
+            hash[key.to_sym] = str
+          end
+        end
+        
+        hash
+      end
+      
+      def properties_parent_to_hash(element)
+        properties_hash = { properties: {}, propertytypes: {} }
+        
+        element.each_element("properties") do |properties|
+          properties.each_element_with_attribute("type") do |property|
+            name  = property.attribute("name" ).to_s.to_sym
+            type  = property.attribute("type" ).to_s
+            value = property.attribute("value").to_s
+            case type
+            when "string", "color", "file"
+              properties_hash[:properties][name] = value
+            when "int"
+              properties_hash[:properties][name] = value.to_i
+            when "float"
+              properties_hash[:properties][name] = value.to_f
+            when "bool"
+              properties_hash[:properties][name] = !!value && value != "0" && value != "false"
+            end
+            properties_hash[:propertytypes][name] = type
+          end
+        end
+        
+        properties_hash[:properties].empty? ? {} : properties_hash
+      end
+      
+      def tileset_to_hash(tileset_element)
+        tileset_hash = element_to_hash(tileset_element,
+          %w[firstgid tilewidth tileheight spacing margin tilecount columns]
+        )
+        tileset_hash.merge!(properties_parent_to_hash(tileset_element))
+        tileset_element.each_element("tileoffset") do |tileoffset|
+          tileset_hash[:tileoffset] = {
+            x: tileoffset.attribute("x").to_s.to_i,
+            y: tileoffset.attribute("y").to_s.to_i
+          }
+        end
+        tileset_element.each_element("image") do |image_element|
+          tileset_hash.merge!(image_to_hash(image_element))
+        end
+        tileset_hash[:tiles] = {}
+        tileset_element.each_element("tile") do |tile_element|
+          hash = element_to_hash(tile_element)
+          tile_hash = { type: hash[:type] }
+          tile_element.each_element("image") do |image_element|
+            tile_hash.merge!(image_to_hash(image_element))
+          end
+          tile_element.each_element("objectgroup") do |objectgroup_element|
+            tile_hash[:objectgroup] = objectgroup_to_hash(objectgroup_element)
+          end
+          tile_element.each_element("animation") do |animation_element|
+            tile_hash[:animation] = animation_to_array(animation_element)
+          end
+          tileset_hash[:tiles][hash[:id]] = tile_hash
+        end
+        
+        tileset_hash
+      end
+      
+      def image_to_hash(image_element)
+        hash = {}
+        
+        image_hash = element_to_hash(image_element, %w[width height])
+        hash[:image]            = image_hash[:source] if image_hash.has_key?(:source)
+        hash[:imagewidth]       = image_hash[:width ] if image_hash.has_key?(:width )
+        hash[:imageheight]      = image_hash[:height] if image_hash.has_key?(:height)
+        hash[:transparentcolor] = image_hash[:trans ] if image_hash.has_key?(:trans )
+        
+        hash
+      end
+      
+      def objectgroup_to_hash(objectgroup_element)
+        objectgroup_hash = element_to_hash(objectgroup_element,
+          %w[x y width height offsetx offsety],
+          %w[opacity],
+          %w[visible]
+        )
+        objectgroup_hash.merge!(properties_parent_to_hash(objectgroup_element))
+        objectgroup_hash[:objects] = []
+        objectgroup_element.each_element("object") do |object_element|
+          objectgroup_hash[:objects].push(object_to_hash(object_element))
+        end
+        
+        objectgroup_hash
+      end
+      
+      def object_to_hash(object_element)
+        object_hash = { rotation: 0, visible: true }
+        
+        object_hash.merge!(element_to_hash(object_element,
+          %w[id gid],
+          %w[x y width height rotation opacity],
+          %w[visible]
+        ))
+        object_hash.merge!(properties_parent_to_hash(object_element))
+        object_hash[:ellipse] = true unless object_element.get_elements("ellipse").empty?
+        object_hash[:point]   = true unless object_element.get_elements("point").empty?
+        object_element.each_element("polygon") do |polygon_element|
+          object_hash[:polygon] = polygon_element.attribute("points").to_s.split(" ").map do |point|
+            x, y = point.split(",").map(&:to_f)
+            { x: x, y: y }
+          end
+        end
+        object_element.each_element("polyline") do |polyline_element|
+          object_hash[:polyline] = polyline_element.attribute("points").to_s.split(" ").map do |point|
+            x, y = point.split(",").map(&:to_f)
+            { x: x, y: y }
+          end
+        end
+        object_element.each_element("text") do |text_element|
+          object_hash[:text] = element_to_hash(text_element,
+            %w[pixelsize],
+            %w[],
+            %w[wrap bold italic underline strikeout kerning]
+          )
+          object_hash[:text][:text] = text_element.text
+        end
+        
+        object_hash
+      end
+      
+      def animation_to_array(animation_element)
+        animations = []
+        
+        animation_element.each_element("frame") do |frame|
+          animations.push({
+            tileid:   frame.attribute("tileid"  ).to_s.to_i,
+            duration: frame.attribute("duration").to_s.to_i
+          })
+        end
+        
+        animations
+      end
+      
+      def layers_to_array(layers_parent_element)
+        layers_array = []
+        
+        layers_parent_element.each_child do |layer_element|
+          next unless layer_element.is_a?(REXML::Element)
+          layer_hash = element_to_hash(layer_element,
+            %w[x y width height offsetx offsety],
+            %w[opacity],
+            %w[visible]
+          )
+          layer_hash.merge!(properties_parent_to_hash(layer_element))
+          
+          case layer_element.name.to_s
+          when "layer"
+            layer_hash[:type] = "tilelayer"
+            data = layer_element.get_elements("data").first
+            data_hash = element_to_hash(data)
+            layer_hash[:compression] = data_hash[:compression] if data_hash.has_key?(:compression)
+            layer_hash[:encoding   ] = data_hash[:encoding   ] if data_hash.has_key?(:encoding   )
+            chunks = data.get_elements("chunk")
+            if chunks.empty?
+              if layer_hash[:encoding] == "csv"
+                layer_hash[:data] = data.text.strip.split(",").map(&:to_i)
+              else
+                layer_hash[:data] = data.text
+              end
+            else
+              layer_hash[:chunks] = []
+              chunks.each do |chunk|
+                chunk_hash = element_to_hash(chunk, %w[x y width height])
+                if layer_hash[:encoding] == "csv"
+                  chunk_hash[:data] = chunk.text.strip.split(",").map(&:to_i)
+                else
+                  chunk_hash[:data] = chunk.text
+                end
+                layer_hash[:chunks].push(chunk_hash)
+              end
+            end
+          when "objectgroup"
+            layer_hash[:type] = "objectgroup"
+            layer_hash.merge!(objectgroup_to_hash(layer_element))
+          when "imagelayer"
+            layer_hash[:type] = "imagelayer"
+            layer_element.each_element("image") do |image_element|
+              layer_hash.merge!(image_to_hash(image_element))
+            end
+          when "group"
+            layer_hash[:type] = "group"
+            layer_hash[:layers] = layers_to_array(layer_element)
+          else
+            next
+          end
+          layers_array.push(layer_hash)
+        end
+        
+        layers_array
+      end
+      
+      def tmx_to_hash(tmx)
+        map_element = tmx.root
+        hash = element_to_hash(map_element,
+          %w[width height tilewidth tileheight hexsidelength nextobjectid],
+          %w[version],
+          %w[]
+        )
+        hash.merge!(properties_parent_to_hash(map_element))
+        hash[:tilesets] = []
+        map_element.each_element("tileset") do |tileset_element|
+          hash[:tilesets].push(tileset_to_hash(tileset_element))
+        end
+        hash[:layers] = layers_to_array(map_element)
+        
+        hash
+      end
+      
+      def tsx_to_hash(tsx)
+        hash = tileset_to_hash(tsx.root)
+        
+        hash
+      end
+      
+      def tx_to_hash(tx)
+        hash = {}
+        
+        tx.root.each_element("tileset") do |tileset_element|
+          hash[:tileset] = element_to_hash(tileset_element,
+            %w[firstgid],
+            %w[],
+            %w[]
+          )
+        end
+        tx.root.each_element("object") do |object_element|
+          hash[:object] = object_to_hash(object_element)
+        end
+        
+        hash
+      end
+    end
+  end
+end