dxruby_tiled 0.1.0 → 1.0.0

data/lib/dxruby_tiled.rb

@@ -1,25 +1,50 @@
-require "dxruby"
-require "json"
-require "zlib"
-require "base64"
+require "dxruby" unless defined? DXRuby
+require "json"   unless defined? JSON
+require "zlib"   unless defined? Zlib
+require "base64" unless defined? Base64
 require "dxruby_tiled/version"
 require "dxruby_tiled/map"
-require "dxruby_tiled/tilesets"
+require "dxruby_tiled/tile"
 require "dxruby_tiled/tileset"
+require "dxruby_tiled/tilesets"
 require "dxruby_tiled/layer"
+require "dxruby_tiled/tilelayer"
 require "dxruby_tiled/layer_orthogonal"
 require "dxruby_tiled/layer_isometric"
 require "dxruby_tiled/layer_staggered"
 require "dxruby_tiled/layer_hexagonal"
-require "dxruby_tiled/objectgroup" # unsupported
+require "dxruby_tiled/object"
+require "dxruby_tiled/objectgroup"
 require "dxruby_tiled/imagelayer"
+require "dxruby_tiled/grouplayer"
 
 module DXRuby
   module Tiled
-    def self.load_json(jsonfile, encoding = "UTF-8", dir = nil)
-      return Map.new(JSON.load(File.read(jsonfile, encoding: encoding), nil,
-                                symbolize_names: true, create_additions: false),
-                      dir || File.dirname(jsonfile))
+    module_function
+    autoload :TMXLoader, "dxruby_tiled/tmx_loader"
+    
+    def load(file, encoding = Encoding::UTF_8, dir = nil)
+      case File.extname(file)
+      when ".tmx", ".xml"
+        TMXLoader.load_tmx(file, encoding, dir)
+      else
+        load_json(file, encoding, dir)
+      end
+    end
+    
+    def read_file(file, encoding = Encoding::UTF_8)
+      File.read(file, encoding: encoding)
+    end
+    
+    def load_json(jsonfile, encoding = Encoding::UTF_8, dir = nil)
+      Map.new(read_jsonfile(jsonfile, encoding), dir || File.dirname(jsonfile))
+    end
+    
+    def read_jsonfile(jsonfile, encoding = Encoding::UTF_8)
+      JSON.parse(
+        read_file(jsonfile, encoding),
+        symbolize_names: true, create_additions: false
+      )
     end
   end
 end

data/lib/dxruby_tiled/grouplayer.rb

@@ -0,0 +1,30 @@
+module DXRuby
+  module Tiled
+    class GroupLayer < Layer
+      include Enumerable
+      
+      def initialize(data, map)
+        super
+        @layers = data[:layers].map do |layer|
+          Layer.create(layer, map)
+        end
+      end
+      
+      def [](name)
+        return @layers[name] if name.is_a? Integer
+        return @layers.find { |layer| layer.name == name }
+      end
+      
+      def each
+        @layers.each { |layer| yield layer }
+      end
+      
+      def render(x, y, target = DXRuby::Window, z = 0, offset_x = 0, offset_y = 0, opacity = 1.0)
+        @layers.each do |layer|
+          layer.render(x, y, target, z + @z_index, offset_x + @offset_x, offset_y + @offset_y, opacity * @opacity) if layer.visible
+        end
+      end
+      alias_method :draw, :render
+    end
+  end
+end

data/lib/dxruby_tiled/imagelayer.rb

@@ -1,35 +1,51 @@
 module DXRuby
   module Tiled
-    class ImageLayer
-      attr_reader :data, :name, :properties
-      attr_accessor :opacity, :visible, :offset_x, :offset_y, :fixed
+    class ImageLayer < Layer
+      attr_accessor :image, :fixed, :x_loop, :y_loop
       
       def initialize(data, map)
-        @original_data = data
-        @map = map
+        super
+        @x_loop = !!@properties[:x_loop]
+        @y_loop = !!@properties[:y_loop]
+        @image  = map.load_image(data[:image], data[:transparentcolor])
+        @map_loop = map.loop
+        @map_pixel_width  = map.pixel_width
+        @map_pixel_height = map.pixel_height
+      end
+      
+      def render(x, y, target = DXRuby::Window, z = 0, offset_x = 0, offset_y = 0, opacity = 1.0)
+        x_range = 0..0
+        if @x_loop
+          x0 = (@offset_x + offset_x - (@fixed? 0 : x)) % @image.width
+          x_range = -1..((target.width - 1) / @image.width)
+        elsif @fixed
+          x0 = @offset_x + offset_x
+        elsif @map_loop
+          x0 = (@offset_x + offset_x - x + target.width) % @map_pixel_width - target.width
+        else
+          x0 = @offset_x + offset_x - x
+        end
         
-        @name       = data[:name]
-        @opacity    = data[:opacity]    || 1.0
-        @visible    = data[:visible] != false
-        @offset_x   = data[:offsetx]    || 0
-        @offset_y   = data[:offsety]    || 0
-        @properties = data[:properties] || {}
-        @fixed      = @properties[:fixed]
+        y_range = 0..0
+        if @y_loop
+          y0 = (@offset_y + offset_y - (@fixed? 0 : y)) % @image.height
+          y_range = -1..((target.height - 1) / @image.height)
+        elsif @fixed
+          y0 = @offset_y + offset_y
+        elsif @map_loop
+          y0 = (@offset_y + offset_y - y + target.height) % @map_pixel_height - target.height
+        else
+          y0 = @offset_y + offset_y - y
+        end
         
-        @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)
+        x_range.each do |i_x|
+          y_range.each do |i_y|
+            target.draw_alpha(x0 + @image.width * i_x, y0 + @image.height * i_y,
+                              @image, 255 * opacity * @opacity, z + @z_index)
+          end
         end
       end
-      
-      def draw(x, y, target = DXRuby::Window)
-        x = (x + target.width)  % @map.pixel_width  - target.width  if @map.x_loop
-        y = (y + target.height) % @map.pixel_height - target.height if @map.y_loop
-        target.draw_alpha(@offset_x - (@fixed ? 0 : x), @offset_y - (@fixed? 0 : y),
-                          @image, (255 * @opacity).to_i)
-      end
-      
+      alias_method :draw, :render
     end
   end
 end

data/lib/dxruby_tiled/layer.rb

@@ -1,55 +1,32 @@
 module DXRuby
   module Tiled
     class Layer
-      attr_reader   :data, :name, :width, :height, :properties
-      attr_accessor :opacity, :visible, :offset_x, :offset_y
+      attr_reader   :name, :properties
+      attr_accessor :opacity, :visible, :offset_x, :offset_y, :z_index
+      
+      def self.create(data, map)
+        case data[:type]
+        when "tilelayer"
+          map.orientation.new(data, map)
+        when "objectgroup"
+          DXRuby::Tiled::ObjectGroup.new(data, map)
+        when "imagelayer"
+          DXRuby::Tiled::ImageLayer.new(data, map)
+        when "group"
+          DXRuby::Tiled::GroupLayer.new(data, map)
+        end
+      end
       
       def initialize(data, map)
-        @map = map
-        
         @name       = data[:name]
-        @width      = data[:width ]     || map.width
-        @height     = data[:height]     || map.height
         @opacity    = data[:opacity]    || 1.0
         @visible    = data[:visible] != false
         @offset_x   = data[:offsetx]    || 0
         @offset_y   = data[:offsety]    || 0
         @properties = data[:properties] || {}
-        
-        case data[:encoding]
-        when "base64"
-          tmp = Base64.decode64(data[:data])
-          case data[:compression]
-          when "gzip" # unsupported
-          when "zlib"
-            tmp = Zlib::Inflate.inflate(tmp).unpack("l*")
-          else
-            tmp = tmp.unpack("l*")
-          end
-        else
-          tmp = data[:data]
-        end
-        @data = tmp.each_slice(@width).to_a
-      end
-      
-      def [](x, y)
-        x = @map.x_loop ? x % @width  : x < 0 ? @width  : x
-        y = @map.y_loop ? y % @height : y < 0 ? @height : y
-        return @data.fetch(y, []).fetch(x, 0)
+        @z_index    = @properties[:z_index] || 0
+        @fixed      = !!@properties[:fixed]
       end
-      
-      def []=(x, y, value)
-        x = @map.x_loop ? x % @width  : x < 0 ? @width  : x
-        y = @map.y_loop ? y % @height : y < 0 ? @height : y
-        @data[y][x] = value
-      end
-      
-      def include?(x, y)
-        return (@map.x_loop || (0...@width).include?(x)) &&
-                (@map.y_loop || (0...@height).include?(y))
-      end
-      alias_method :member?, :include?
-      
     end
   end
 end

data/lib/dxruby_tiled/layer_hexagonal.rb

@@ -1,133 +1,136 @@
 module DXRuby
   module Tiled
-    class HexagonalLayer < Layer
+    class HexagonalLayer < TileLayer
+      def initialize(data, map)
+        super
+        @stagger_axis_y    = map.stagger_axis_y
+        @stagger_index_odd = map.stagger_index_odd
+        @hex_side_length   = map.hex_side_length
+      end
       
-      def draw(x, y, target = DXRuby::Window)
-        tile_images = @map.tilesets.tile_images
-        left, top = xy_at(x - @offset_x, y - @offset_x)
-        left -= 1
-        top  -= 1
-        off_x = x - @map.tile_width  / 2 + @offset_x
-        off_y = y - @map.tile_height / 2 + @offset_y
-        alpha = (@opacity * 255).floor
+      def render(pos_x, pos_y, target = DXRuby::Window, z = @z_index, offset_x = 0, offset_y = 0, opacity = 1.0)
+        super
+        
+        pos_x, pos_y = 0, 0 if @fixed
+        off_x = offset_x + @offset_x - pos_x
+        off_y = offset_y + @offset_y - pos_y
+        x1, y1 = xy_at(@tile_width  - @tilesets.tile_right  - off_x,
+                       @tile_height - @tilesets.tile_bottom - off_y)
+        x2, y2 = xy_at(@render_target.width  - @tilesets.tile_left - off_x - 1,
+                       @render_target.height - @tilesets.tile_top  - off_y - 1)
+        x_range = ((x1 - 1)..(x2 + 1))
+        y_range = ((y1 - 1)..(y2 + 1))
         
-        if @map.stagger_axis_y
-          tile_width  = @map.tile_width
-          tile_height = @map.tile_height - (@map.tile_height - @map.hex_side_length) / 2
-          x_range = left..(left + target.width  / tile_width  + 3).floor
-          y_range =  top..(top  + target.height / tile_height + 2).floor
-          
-          y_range.each do |y2|
-            x0 = @map.stagger_index_odd ^ y2.even? ? tile_width / 2 : 0
-            x_range.each do |x2|
-              image = tile_images[self[x2, y2]]
-              target.draw_alpha(x0 + x2 * tile_width  - off_x - image.width  / 2,
-                                     y2 * tile_height - off_y - image.height / 2,
-                                image, alpha)
+        if @stagger_axis_y
+          tile_width  = @tile_width
+          tile_height = @tile_height - (@tile_height - @hex_side_length) / 2
+          y_range.public_send(@renderorder_y ? :each : :reverse_each) do |y|
+            x0 = @stagger_index_odd ^ y.even? ? tile_width / 2 : 0
+            x_range.public_send(@renderorder_x ? :each : :reverse_each) do |x|
+              @tilesets[self[x, y]].render(
+                x * tile_width  + off_x + x0,
+                y * tile_height + off_y,
+                @render_target)
             end
           end
         else
-          tile_width  = @map.tile_width - (@map.tile_width - @map.hex_side_length) / 2
-          tile_height = @map.tile_height
-          x_range = left..(left + target.width  / tile_width  + 2).floor
-          y_range =  top..(top  + target.height / tile_height + 3).floor
-          
-          y_range.each do |y2|
-            x_range.each do |x2|
-              y0 = @map.stagger_index_odd ^ x2.even? ? tile_height / 2 : 0
-              image = tile_images[self[x2, y2]]
-              target.draw_alpha(     x2 * tile_width  - off_x - image.width  / 2,
-                                y0 + y2 * tile_height - off_y - image.height / 2,
-                                image, alpha)
+          tile_width  = @tile_width - (@tile_width - @hex_side_length) / 2
+          tile_height = @tile_height
+          y_range.public_send(@renderorder_y ? :each : :reverse_each) do |y|
+            x_range.public_send(@renderorder_x ? :each : :reverse_each) do |x|
+              next if @stagger_index_odd ^ x.even?
+              @tilesets[self[x, y]].render(
+                x * tile_width  + off_x,
+                y * tile_height + off_y,
+                @render_target)
+            end
+            x_range.public_send(@renderorder_x ? :each : :reverse_each) do |x|
+              next unless @stagger_index_odd ^ x.even?
+              @tilesets[self[x, y]].render(
+                x * tile_width  + off_x,
+                y * tile_height + off_y + tile_height / 2,
+                @render_target)
             end
           end
         end
+        
+        target.draw_alpha(0, 0, @render_target, @opacity * 255, z + @z_index)
       end
+      alias_method :draw, :render
       
-      def xy_at(x, y)
-        if @map.stagger_axis_y
-          height = @map.tile_height - (@map.tile_height - @map.hex_side_length) / 2
-          y2 = y / height
-          x -= @map.tile_width / 2 if @map.stagger_index_odd ^ y2.even?
-          x2 = x / @map.tile_width
-          x0 = x % @map.tile_width
-          y0 = y % height
-          if (y0 < (@map.tile_height - height) - x0 * (@map.tile_height - height) * 2 / @map.tile_width)
-            y2 -= 1
-            x2 += @map.stagger_index_odd ^ y2.even? ? -1 : 0
-          elsif (y0 < x0 * (@map.tile_height - height) * 2 / @map.tile_width - (@map.tile_height - height))
-            y2 -= 1
-            x2 += @map.stagger_index_odd ^ y2.even? ? 0 : 1
+      def xy_at(pos_x, pos_y)
+        if @stagger_axis_y
+          height = @tile_height - (@tile_height - @hex_side_length) / 2
+          y = (pos_y / height).floor
+          pos_x -= @tile_width / 2 if @stagger_index_odd ^ y.even?
+          x = (pos_x / @tile_width).floor
+          dx = pos_x % @tile_width
+          dy = pos_y % height
+          if (dy < (@tile_height - height) - dx * (@tile_height - height) * 2 / @tile_width)
+            y -= 1
+            x += @stagger_index_odd ^ y.even? ? -1 : 0
+          elsif (dy < dx * (@tile_height - height) * 2 / @tile_width - (@tile_height - height))
+            y -= 1
+            x += @stagger_index_odd ^ y.even? ? 0 : 1
           end
         else
-          width = @map.tile_width - (@map.tile_width - @map.hex_side_length) / 2
-          x2 = x / width
-          y -= @map.tile_height / 2 if @map.stagger_index_odd ^ x2.even?
-          y2 = y / @map.tile_height
-          x0 = x % width
-          y0 = y % @map.tile_height
-          if (y0 < @map.height / 2 - x0 * @map.tile_height / (@map.tile_width - width) / 2)
-            x2 -= 1
-            y2 += @map.stagger_index_odd ^ x2.even? ? -1 : 0
-          elsif (y0 > @map.height / 2 + x0 * @map.tile_height / (@map.tile_width - width) / 2)
-            x2 -= 1
-            y2 += @map.stagger_index_odd ^ x2.even? ? 0 : 1
+          width = @tile_width - (@tile_width - @hex_side_length) / 2
+          x = (pos_x / width).floor
+          pos_y -= @tile_height / 2 if @stagger_index_odd ^ x.even?
+          y = (pos_y / @tile_height).floor
+          dx = pos_x % width
+          dy = pos_y % @tile_height
+          if (dy * 2 < @tile_height - dx * @tile_height / (@tile_width - width))
+            x -= 1
+            y += @stagger_index_odd ^ x.even? ? -1 : 0
+          elsif (dy > @tile_height / 2 + dx * @tile_height / (@tile_width - width) / 2)
+            x -= 1
+            y += @stagger_index_odd ^ x.even? ? 0 : 1
           end
         end
-        return x2, y2
-      end
-      
-      def at(x, y)
-        tmp_x, tmp_y = xy_at(x, y)
-        return self[tmp_x, tmp_y]
-      end
-      
-      def change_at(x, y, value)
-        tmp_x, tmp_y = xy_at(x, y)
-        self[tmp_x, tmp_y] = value
+        return x, y
       end
       
       def vertexs(x, y)
-        if @map.stagger_axis_y
-          w, h = @map.tile_width / 2, @map.tile_height - (@map.tile_height - @map.hex_side_length) / 2
-          x0 = @map.stagger_index_odd ^ y.even? ? w : 0
+        if @stagger_axis_y
+          w, h = @tile_width / 2, @tile_height - (@tile_height - @hex_side_length) / 2
+          x0 = @stagger_index_odd ^ y.even? ? w : 0
           return [
             [ x0 + x * w * 2 + w    , y * h ],
-            [ x0 + x * w * 2        , y * h + h - @map.hex_side_length ],
+            [ x0 + x * w * 2        , y * h + h - @hex_side_length ],
             [ x0 + x * w * 2        , y * h + h ],
-            [ x0 + x * w * 2 + w    , y * h + @map.tile_height ],
+            [ x0 + x * w * 2 + w    , y * h + @tile_height ],
             [ x0 + x * w * 2 + w * 2, y * h + h ],
-            [ x0 + x * w * 2 + w * 2, y * h + h - @map.hex_side_length ]
+            [ x0 + x * w * 2 + w * 2, y * h + h - @hex_side_length ]
           ]
         else
-          w, h = @map.tile_width - (@map.tile_width - @map.hex_side_length) / 2, @map.tile_height / 2
-          y0 = @map.stagger_index_odd ^ x.even? ? h : 0
+          w, h = @tile_width - (@tile_width - @hex_side_length) / 2, @tile_height / 2
+          y0 = @stagger_index_odd ^ x.even? ? h : 0
           return [
-            [ x * w, y0 + y * h * 2 + h       , y * h ],
-            [ x * w + w - @map.hex_side_length, y0 + y * h * 2 ],
-            [ x * w + w                       , y0 + y * h * 2 ],
-            [ x * w + @map.tile_width         , y0 + y * h * 2 + h ],
-            [ x * w + w                       , y0 + y * h * 2 + h * 2 ],
-            [ x * w + w - @map.hex_side_length, y0 + y * h * 2 + h * 2 ]
+            [ x * w, y0 + y * h * 2 + h   , y * h ],
+            [ x * w + w - @hex_side_length, y0 + y * h * 2 ],
+            [ x * w + w                   , y0 + y * h * 2 ],
+            [ x * w + @tile_width         , y0 + y * h * 2 + h ],
+            [ x * w + w                   , y0 + y * h * 2 + h * 2 ],
+            [ x * w + w - @hex_side_length, y0 + y * h * 2 + h * 2 ]
           ]
         end
       end
       
       
       def self.pixel_width(map)
-        return map.stagger_axis_y ?
-                map.tile_width * (map.tile_width - (map.tile_width - map.hex_side_length) / 2) +
-                  (map.tile_width - map.hex_side_length) / 2 :
-                map.tile_width * (map.width + 1) / 2
+        map.stagger_axis_y ?
+          map.tile_width * (map.tile_width - (map.tile_width - map.hex_side_length) / 2) +
+            (map.tile_width - map.hex_side_length) / 2 :
+          map.tile_width * (map.width + 1) / 2
       end
       
       def self.pixel_height(map)
-        return map.stagger_axis_y ?
-                map.tile_height * (map.height + 1) / 2 :
-                map.tile_height * (map.tile_height - (map.tile_height - map.hex_side_length) / 2) +
-                  (map.tile_height - map.hex_side_length) / 2
+        map.stagger_axis_y ?
+          map.tile_height * (map.height + 1) / 2 :
+          map.tile_height * (map.tile_height - (map.tile_height - map.hex_side_length) / 2) +
+            (map.tile_height - map.hex_side_length) / 2
       end
-      
     end
   end
 end