dxruby_tiled 0.1.0 → 1.0.0

data/lib/dxruby_tiled/layer_isometric.rb

@@ -1,69 +1,56 @@
-require "pry"
-
 module DXRuby
   module Tiled
-    class IsometricLayer < Layer
-      
-      def draw(x, y, target = DXRuby::Window)
-        tile_width2, tile_height2 = @map.tile_width / 2, @map.tile_height / 2
-        tile_images = @map.tilesets.tile_images
-        left, top = xy_at(x - @offset_x, y - @offset_x)
-        left -= 1
-        top  -= 1
-        x_range = 0..(target.width  / tile_width2 / 2 + 1).floor
-        y_range = 0..(target.height / tile_height2    + 3).floor
-        off_x = x - @map.pixel_width / 2 + @offset_x
-        off_y = y - tile_height2 + @offset_y
-        alpha = (@opacity * 255).to_i
+    class IsometricLayer < TileLayer
+      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
+        tile_width2, tile_height2 = @tile_width / 2, @tile_height / 2
+        off_x = offset_x + @offset_x - pos_x
+        off_y = offset_y + @offset_y - pos_y
+        left, top = xy_at(@tile_width  - @tilesets.tile_right  - off_x,
+                          @tile_height - @tilesets.tile_bottom - off_y)
+        x_range = -1..((@render_target.width  - @tilesets.tile_left)    / @tile_width  + 2)
+        y_range = -1..((@render_target.height - @tilesets.tile_top) * 2 / @tile_height + 4)
         
-        y_range.each do |yy|
-          x_range.each do |xx|
-            x2 = left + xx + yy / 2
-            y2 = top  - xx + (yy + 1) / 2
-            image = tile_images[self[x2, y2]]
-            target.draw_alpha(x2 * tile_width2  - y2 * tile_width2  - off_x - image.width  / 2,
-                              y2 * tile_height2 + x2 * tile_height2 - off_y - image.height / 2,
-                              image, alpha)
+        y_range.public_send(@renderorder_y ? :each : :reverse_each) do |tmp_y|
+          x_range.public_send(@renderorder_x ? :each : :reverse_each) do |tmp_x|
+            x = left + tmp_x + tmp_y / 2
+            y = top + (tmp_y + 1) / 2 - tmp_x
+            @tilesets[self[x, y]].render(
+              x * tile_width2  - y * tile_width2  + off_x,
+              y * tile_height2 + x * tile_height2 + off_y,
+              @render_target)
           end
         end
+        
+        target.draw_alpha(0, 0, @render_target, @opacity * 255, z + @z_index)
       end
+      alias_method :draw, :render
       
-      def xy_at(tmp_x, y)
-        x = tmp_x - @map.pixel_width / 2
-        return (1.0 * x / @map.tile_width + 1.0 * y / @map.tile_height).floor,
-                (1.0 * y / @map.tile_height - 1.0 * x / @map.tile_width).floor
-      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
+      def xy_at(pos_x, pos_y)
+        return (1.0 * pos_x / @tile_width  + 1.0 * pos_y / @tile_height).floor,
+               (1.0 * pos_y / @tile_height - 1.0 * pos_x / @tile_width ).floor
       end
       
       def vertexs(x, y)
-        x0 = @map.pixel_width / 2
-        w, h = @map.tile_width / 2, @map.tile_height / 2
+        w, h = @tile_width / 2, @tile_height / 2
         return [
-          [ x0 + x * w - y * w    , y * h + x * h         ],
-          [ x0 + x * w - y * w - w, y * h + x * h + h     ],
-          [ x0 + x * w - y * w    , y * h + x * h + h * 2 ],
-          [ x0 + x * w - y * w + w, y * h + x * h + h     ]
+          [ x * w - y * w    , y * h + x * h         ],
+          [ x * w - y * w - w, y * h + x * h + h     ],
+          [ x * w - y * w    , y * h + x * h + h * 2 ],
+          [ x * w - y * w + w, y * h + x * h + h     ]
         ]
       end
       
       
       def self.pixel_width(map)
-        return map.tile_width  * (map.width + map.height) / 2
+        map.tile_width  * (map.width + map.height) / 2
       end
       
       def self.pixel_height(map)
-        return map.tile_height * (map.width + map.height) / 2
+        map.tile_height * (map.width + map.height) / 2
       end
-      
     end
   end
 end

data/lib/dxruby_tiled/layer_orthogonal.rb

@@ -1,43 +1,44 @@
 module DXRuby
   module Tiled
-    class OrthogonalLayer < Layer
-      
-      def draw(x, y, target = DXRuby::Window)
-        tile_width, tile_height = @map.tile_width, @map.tile_height
-        tile_images = @map.tilesets.tile_images
-        left, top = xy_at(x - @offset_x, y - @offset_x)
-        x_range = left..(left + (target.width  / tile_width  + 1).floor)
-        y_range =  top..(top  + (target.height / tile_height + 1).floor)
-        off_x = left * tile_width  + (x - @offset_x) % tile_width  - tile_width  / 2
-        off_y =  top * tile_height + (y - @offset_y) % tile_height - tile_height / 2
-        alpha = (@opacity * 255).floor
-        x_range = x_range.to_a.reverse if @map.renderorder_x
-        y_range = y_range.to_a.reverse if @map.renderorder_y
+    class OrthogonalLayer < TileLayer
+      def render(pos_x, pos_y, target = DXRuby::Window, z = 0, 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)
         
-        y_range.each do |yy|
-          x_range.each do |xx|
-            image = tile_images[self[xx, yy]]
-            target.draw_alpha(xx * tile_width  - off_x - image.width  / 2,
-                              yy * tile_height - off_y - image.height / 2,
-                              image, alpha)
+        (y1..(y2 + 1)).public_send(@renderorder_y ? :each : :reverse_each) do |y|
+          (x1..(x2 + 1)).public_send(@renderorder_x ? :each : :reverse_each) do |x|
+            @tilesets[self[x, y]].render(
+              x * @tile_width  + off_x,
+              y * @tile_height + off_y,
+              @render_target)
           end
         end
+        
+        target.draw_alpha(0, 0, @render_target, @opacity * 255, z + @z_index)
       end
+      alias_method :draw, :render
       
-      def xy_at(x, y)
-        return x / @map.tile_width, y / @map.tile_height
+      def xy_at(pos_x, pos_y)
+        return pos_x.to_i / @tile_width, pos_y.to_i / @tile_height
       end
       
-      def at(x, y)
-        return self[x / @map.tile_width, y / @map.tile_height]
+      def at(pos_x, pos_y)
+        self[pos_x.to_i / @tile_width, pos_y.to_i / @tile_height]
       end
       
-      def change_at(x, y, value)
-        self[x / @map.tile_width, y / @map.tile_height] = value
+      def change_at(pos_x, pos_y, value)
+        self[pos_x.to_i / @tile_width, pos_y.to_i / @tile_height] = value
       end
       
       def vertexs(x, y)
-        w, h = @map.tile_width, @map.tile_height
+        w, h = @tile_width, @tile_height
         return [
           [ x * w    , y * h     ],
           [ x * w    , y * h + h ],
@@ -47,13 +48,12 @@ module DXRuby
       end
       
       def self.pixel_width(map)
-        return map.tile_width * map.width
+        map.tile_width * map.width
       end
       
       def self.pixel_height(map)
-        return map.tile_height * map.height
+        map.tile_height * map.height
       end
-      
     end
   end
 end

data/lib/dxruby_tiled/layer_staggered.rb

@@ -1,91 +1,95 @@
 module DXRuby
   module Tiled
-    class StaggeredLayer < Layer
+    class StaggeredLayer < TileLayer
+      def initialize(data, map)
+        super
+        @stagger_axis_y    = map.stagger_axis_y
+        @stagger_index_odd = map.stagger_index_odd
+      end
       
-      def draw(x, y, target = DXRuby::Window)
-        tile_width2, tile_height2 = @map.tile_width / 2, @map.tile_height / 2
-        tile_images = @map.tilesets.tile_images
-        left, top = xy_at(x - @offset_x, y - @offset_x)
-        left -= 1
-        top  -= 1
-        off_x = x - tile_width2  + @offset_x
-        off_y = y - tile_height2 + @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
+        tile_width2  = @tile_width / 2
+        tile_height2 = @tile_height / 2
+        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
-          x_range = left..(left + target.width  / tile_width2  / 2 + 1).floor
-          y_range =  top..(top  + target.height / tile_height2     + 3).floor
-          
-          y_range.each do |y2|
-            x0 = @map.stagger_index_odd ^ y2.even? ? tile_width2 : 0
-            x_range.each do |x2|
-              image = tile_images[self[x2, y2]]
-              target.draw_alpha(x0 + x2 * tile_width2 * 2 - off_x - image.width  / 2,
-                                     y2 * tile_height2    - off_y - image.height / 2,
-                                image, alpha)
+        if @stagger_axis_y
+          y_range.public_send(@renderorder_y ? :each : :reverse_each) do |y|
+            x0 = @stagger_index_odd ^ y.even? ? tile_width2 : 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_height2 + off_y,
+                @render_target)
             end
           end
         else
-          x_range = left..(left + target.width  / tile_width2      + 3).floor
-          y_range =  top..(top  + target.height / tile_height2 / 2 + 1).floor
-          
-          y_range.each do |y2|
-            x_range.each do |x2|
-              y0 = @map.stagger_index_odd ^ x2.even? ? tile_height2 : 0
-              image = tile_images[self[x2, y2]]
-              target.draw_alpha(     x2 * tile_width2      - off_x - image.width  / 2,
-                                y0 + y2 * tile_height2 * 2 - off_y - image.height / 2,
-                                image, alpha)
+          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_width2 + 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_width2 + off_x,
+                y * @tile_height + off_y + tile_height2,
+                @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
-          y2 = y * 2 / @map.tile_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 % (@map.tile_height / 2)
-          if (y0 < @map.tile_height / 2 - x0 * @map.tile_height / @map.tile_width)
-            y2 -= 1
-            x2 += @map.stagger_index_odd ^ y2.even? ? -1 : 0
-          elsif (y0 < x0 * @map.tile_height / @map.tile_width - @map.tile_height / 2)
-            y2 -= 1
-            x2 += @map.stagger_index_odd ^ y2.even? ? 0 : 1
+      def xy_at(pos_x, pos_y)
+        if @stagger_axis_y
+          y = (pos_y * 2 / @tile_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 % (@tile_height / 2)
+          if (dy < @tile_height / 2 - dx * @tile_height / @tile_width)
+            y -= 1
+            x += @stagger_index_odd ^ y.even? ? -1 : 0
+          elsif (dy < dx * @tile_height / @tile_width - @tile_height / 2)
+            y -= 1
+            x += @stagger_index_odd ^ y.even? ? 0 : 1
           end
         else
-          x2 = x * 2 / @map.tile_width
-          y -= @map.tile_height / 2 if @map.stagger_index_odd ^ x2.even?
-          y2 = y / @map.tile_height
-          x0 = x % (@map.tile_width / 2)
-          y0 = y % @map.tile_height
-          if (y0 < @map.tile_height / 2 - x0 * @map.tile_height / @map.tile_width)
-            x2 -= 1
-            y2 += @map.stagger_index_odd ^ x2.even? ? -1 : 0
-          elsif (y0 > x0 * @map.tile_height / @map.tile_width + @map.tile_height / 2)
-            x2 -= 1
-            y2 += @map.stagger_index_odd ^ x2.even? ? 0 : 1
+          x = (pos_x * 2 / @tile_width).floor
+          pos_y -= @tile_height / 2 if @stagger_index_odd ^ x.even?
+          y = (pos_y / @tile_height).floor
+          dx = pos_x % (@tile_width / 2)
+          dy = pos_y % @tile_height
+          if (dy < @tile_height / 2 - dx * @tile_height / @tile_width)
+            x -= 1
+            y += @stagger_index_odd ^ x.even? ? -1 : 0
+          elsif (dy > dx * @tile_height / @tile_width + @tile_height / 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)
-        w, h = @map.tile_width / 2, @map.tile_height / 2
-        if @map.stagger_axis_y
-          x0 = @map.stagger_index_odd ^ y.even? ? w : 0
+        w, h = @tile_width / 2, @tile_height / 2
+        if @stagger_axis_y
+          x0 = @stagger_index_odd ^ y.even? ? w : 0
           return [
             [ x0 + x * w * 2 + w    , y * h         ],
             [ x0 + x * w * 2        , y * h + h     ],
@@ -93,7 +97,7 @@ module DXRuby
             [ x0 + x * w * 2 + w * 2, y * h + h     ]
           ]
         else
-          y0 = @map.stagger_index_odd ^ x.even? ? h : 0
+          y0 = @stagger_index_odd ^ x.even? ? h : 0
           return [
             [ x * w + w    , y0 + y * h * 2         ],
             [ x * w        , y0 + y * h * 2 + h     ],
@@ -105,17 +109,16 @@ module DXRuby
       
       
       def self.pixel_width(map)
-        return map.stagger_axis_y ?
-                map.tile_width * map.width + map.tile_width / 2 :
-                map.tile_width * (map.width + 1) / 2
+        map.stagger_axis_y ?
+          map.tile_width * map.width + map.tile_width / 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.height + map.tile_height / 2
+        map.stagger_axis_y ?
+          map.tile_height * (map.height + 1) / 2 :
+          map.tile_height * map.height + map.tile_height / 2
       end
-      
     end
   end
 end

data/lib/dxruby_tiled/map.rb

@@ -2,25 +2,23 @@ module DXRuby
   module Tiled
     class Map
       attr_reader   :data_dir, :tilesets, :layers,
-                    :version, :orientation, :renderorder_x, :renderorder_y,
+                    :version, :tiledversion, :orientation, :renderorder_x, :renderorder_y,
                     :width, :height, :tile_width, :tile_height,
                     :hex_side_length, :stagger_axis_y, :stagger_index_odd,
-                    :next_object_id, :properties, :x_loop, :y_loop
+                    :properties, :loop
       attr_accessor :background_color
       
       def initialize(data, data_dir)
         @data_dir = data_dir
         
         @version         = data[:version]
-        @orientation     = case data[:orientation]
-          when "isometric"
-            IsometricLayer
-          when "staggered"
-            StaggeredLayer
-          when "hexagonal"
-            HexagonalLayer
-          else
-            OrthogonalLayer
+        @tiledversion    = data[:tiledversion]
+        @orientation     =
+          case data[:orientation]
+          when "isometric" then IsometricLayer
+          when "staggered" then StaggeredLayer
+          when "hexagonal" then HexagonalLayer
+          else                  OrthogonalLayer
           end
         @width             = data[:width]         || 100
         @height            = data[:height]        || 100
@@ -31,61 +29,79 @@ module DXRuby
         @stagger_index_odd = data[:staggerindex] != "even"
         @next_object_id    = data[:nextobjectid]  || 1
         @properties        = data[:properties]    || {}
-        @x_loop            = !!@properties[:x_loop]
-        @y_loop            = !!@properties[:y_loop]
-        @renderorder_x     = false
-        @renderorder_y     = false
-        case data[:renderorder]
-        when "left-down"
-          @renderorder_x = true
-        when "right-up"
-          @renderorder_y = true
-        when "left-up"
-          @renderorder_x = true
-          @renderorder_y = true
-        end
+        @loop              = !!@properties[:loop]
+        @renderorder_x     = !data[:renderorder].to_s.match("left")
+        @renderorder_y     = !data[:renderorder].to_s.match("top")
         @background_color = nil
         if data[:backgroundcolor]
-          @background_color = data[:backgroundcolor].sub("#", "").scan(/../).map do |color|
-            color.to_i(16)
-          end
-        end
-        
-        @layers = data[:layers].map do |layer|
-          case layer[:type]
-          when "tilelayer"
-            @orientation.new(layer, self)
-          when "objectgroup"
-            ObjectGroup.new(layer, self)
-          when "imagelayer"
-            ImageLayer.new(layer, self)
-          end
-        end
-        def @layers.name(name)
-          return self.find{|layer| layer.name == name}
+          @background_color = data[:backgroundcolor].sub("#", "").scan(/../).map{ |c| c.to_i(16) }
         end
         
         @tilesets = Tilesets.new(data[:tilesets], self)
+        @layers = GroupLayer.new({ layers: data[:layers] }, self)
+      end
+      
+      def render(x, y, target = DXRuby::Window, z = 0)
+        raise DXRuby::DXRubyError, "disposed object" if self.disposed?
+        @tilesets.animate
+        target.draw_box_fill(0, 0, target.width, target.height, @background_color, z) if @background_color
+        @layers.render(x, y, target, z)
+      end
+      alias_method :draw, :render
+      
+      def pixel_width
+        @orientation.pixel_width(self)
       end
       
-      def draw(x, y, target = DXRuby::Window)
-        target.draw_box_fill(0, 0, target.width, target.height, @background_color) if @background_color
-        tilesets.animation()
-        @layers.each{|layer| layer.draw(x, y, target) if layer.visible }
+      def pixel_height
+        @orientation.pixel_height(self)
       end
       
-      def load_image(filename)
-        return DXRuby::Image.load(File.join(@data_dir, filename))
+      def next_object_id
+        @next_object_id += 1
+        return @next_object_id - 1
       end
       
-      def pixel_width()
-        return @orientation.pixel_width(self)
+      def dispose
+        @tilesets.dispose
       end
       
-      def pixel_height()
-        return @orientation.pixel_height(self)
+      def delayed_dispose
+        @tilesets.delayed_dispose
       end
       
+      def disposed?
+        @tilesets.disposed?
+      end
+      
+      def load_image(filename, transparentcolor = nil, data_dir = @data_dir)
+        image = DXRuby::Image.load(File.join(data_dir, filename))
+        if transparentcolor
+          color = transparentcolor.sub("#", "").scan(/../).map { |c| c.to_i(16) }
+          image.set_color_key(color)
+        end
+        image
+      end
+      
+      def load_tileset(filename, encoding = Encoding::UTF_8, data_dir = @data_dir)
+        filepath = File.join(data_dir, filename)
+        case File.extname(filename)
+        when ".tsx", ".xml"
+          DXRuby::Tiled::TMXLoader.tsx_to_hash(DXRuby::Tiled::TMXLoader.read_xmlfile(filepath, encoding))
+        else
+          DXRuby::Tiled.read_jsonfile(filepath, encoding)
+        end
+      end
+      
+      def load_template(filename, encoding = Encoding::UTF_8, data_dir = @data_dir)
+        filepath = File.join(data_dir, filename)
+        case File.extname(filename)
+        when ".tx", ".xml"
+          DXRuby::Tiled::TMXLoader.tx_to_hash(DXRuby::Tiled::TMXLoader.read_xmlfile(filepath, encoding))
+        else
+          DXRuby::Tiled.read_jsonfile(filepath, encoding)
+        end
+      end
     end
   end
 end