retmx 0.0.1

data/lib/retmx.rb

@@ -0,0 +1,476 @@
+#Libreria para leer archivo TMX de mapeditor.org
+#Author:: Jovany Leandro G.C (mailto: info@manadalibre.org)
+#Copyright:: Copyright (c) 2011 Jovany Leandro G.C
+#License:: GPLv3 or any later version
+#date: 2011-12-10
+require 'rexml/document'
+require 'base64'
+require 'zlib'
+require 'csv'
+
+module RETMX
+  include REXML
+
+  def RETMX.load(file)
+    doc = Document.new (File.new(file))
+    m = Map.new(doc.root)
+  end
+
+
+  #Wraps any number of custom properties. Can be used as a child of the map, tile (when part of a tileset), layer, objectgroup and object elements.
+  class Properties
+    include Enumerable
+
+    attr_reader :xml
+
+
+    def initialize(xml)
+      @xml = xml
+      @property = {}
+      @xml.elements.each('properties/property') {|e|
+        @property[e.attributes['name']] = e.attributes['value']
+      }
+    end
+
+    def [](i)
+      @property[i]
+    end
+
+    def each
+      @property.each {|i| yield i}
+    end
+  end
+
+
+  #The +tilewidth+ and +tileheight+ properties determine the general grid size of the map. The individual tiles may have different sizes. Larger tiles will extend at the top and right (anchored to the bottom left).
+  class Map
+
+
+    #The TMX format version, generally 1.0
+    attr_reader :version
+
+    #Map orientation. Tiled supports "orthogonal" and "isometric" at the moment.
+    attr_reader :orientation
+
+    #The map width in tiles.
+    attr_reader :width
+
+    #The map height in tiles.
+    attr_reader :height
+
+    #The width of a tile.
+    attr_reader :tilewidth
+
+    #The height of a tile.
+    attr_reader :tileheight
+
+    #Layers on map
+    attr_reader :layers
+    
+    #Tileset on map
+    attr_reader :tilesets
+
+    #Objects groups on map
+    attr_reader :objectgroups
+
+    #Properties on map
+    attr_reader :property
+ 
+    #REXML internal
+    attr_reader :xml
+    def initialize(doc)
+      @version = doc.attributes['version']
+      @orientation = doc.attributes['orientation']
+      @width = doc.attributes['width'].to_i
+      @height = doc.attributes['height'].to_i
+      @tilewidth = doc.attributes['tilewidth'].to_i
+      @tileheight = doc.attributes['tileheight'].to_i
+      
+      @tilesets = {}
+      @layers = {}
+      @objectgroups = {}
+      @xml = doc
+
+      build(doc)
+    end
+
+    private
+    def build(doc)
+      doc.elements.each("tileset") { |e|
+        @tilesets[e.attributes['name']] = TileSet.new(self, e)
+      }
+      doc.elements.each("layer") { |e|
+        @layers[e.attributes['name']] = Layer.new(self, e)
+      }
+      doc.elements.each("objectgroup") { |e|
+        @objectgroups[e.attributes['name']] = ObjectGroup.new(self, e)
+      }
+      @property = Properties.new(doc)
+    end
+
+    #The object group is in fact a map layer, and is hence called "object layer" in Tiled Qt.
+    class ObjectGroup
+      include Enumerable
+
+      #The name of the object group.
+      attr_reader :name
+
+      #The x coordinate of the object group in tiles. Defaults to 0 and can no longer be changed in Tiled Qt.
+      attr_reader :x
+
+      #The y coordinate of the object group in tiles. Defaults to 0 and can no longer be changed in Tiled Qt.
+      attr_reader :y
+
+      #The width of the object group in tiles. Meaningless.
+      attr_reader :width
+
+      #The height of the object group in tiles. Meaningless
+      attr_reader :height
+
+
+      def initialize(map, xml)
+        @map = map
+        @objects = []
+        build(xml)
+      end
+
+
+      def each
+        @objects.each { |i| yield i}
+      end
+      
+      private
+      def build(xml)
+        xml.elements.each('object') {|e|
+          @objects << Object.new(self, e)
+        }
+      end
+
+
+=begin
+While tile layers are very suitable for anything repetitive aligned to the tile grid, sometimes you want to annotate your map with other information, not necessarily aligned to the grid. Hence the objects have their coordinates and size in pixels, but you can still easily align that to the grid when you want to.
+
+You generally use objects to add custom information to your tile map, such as spawn points, warps, exits, etc.
+
+When the object has a gid set, then it is represented by the image of the tile with that global ID. Currently that means width and height are ignored for such objects. The image alignment currently depends on the map orientation. In orthogonal orientation it's aligned to the bottom-left while in isometric it's aligned to the bottom-center.  
+=end
+      class Object
+        #The name of the object. An arbitrary string.
+        attr_reader :name
+
+        #The type of the object. An arbitrary string.
+        attr_reader :type
+        
+        #The x coordinate of the object in pixels.
+        attr_reader :x
+
+        #The y coordinate of the object in pixels.
+        attr_reader :y
+
+        #The width of the object in pixels.
+        attr_reader :width
+
+        #The height of the object in pixels.
+        attr_reader :height
+
+        #An reference to a tile (optional).
+        attr_reader :gid
+
+        def initialize(og, e)
+          @objectgroup = og
+          @name = e.attributes['name']
+          @type = e.attributes['type']
+          @x = e.attributes['x'].to_i
+          @y = e.attributes['y'].to_i
+          @width = e.attributes['width'].to_i
+          @height = e.attributes['height'].to_i
+          @gid = e.attributes['gid'].nil? ? nil : e.attributes['gid'].to_i
+        end
+      end
+    end
+
+    class Layer
+      #The name of the layer.
+      attr_reader :name
+
+      #The x coordinate of the layer in tiles. Defaults to 0 and can no longer be changed in Tiled Qt.
+      attr_reader :x
+
+      #The y coordinate of the layer in tiles. Defaults to 0 and can no longer be changed in Tiled Qt.
+      attr_reader :y
+
+      #The width of the layer in tiles. Traditionally required, but as of Tiled Qt always the same as the map width.
+      attr_reader :width
+
+      #The height of the layer in tiles. Traditionally required, but as of Tiled Qt always the same as the map height.
+      attr_reader :height
+
+      #The opacity of the layer as a value from 0 to 1. Defaults to 1.
+      attr_reader :opacity
+
+      #Whether the layer is shown (1) or hidden (0). Defaults to 1.
+      attr_reader :visible
+
+      #Data
+      attr_reader :data
+
+      #Map belongs
+      attr_reader :map
+      
+      #Properties 
+      attr_reader :property
+
+      #REXML internal
+      attr_reader :xml
+      def initialize(map, xml)
+
+        @name = xml.attributes['name']
+        @x =  xml.attributes['x'].nil? ? 0 : xml.attributes['x']
+        @y = xml.attributes['y'].nil? ? 0 : xml.attributes['y']
+        @width = xml.attributes['width'].nil? ? xml.parent.attributes['width'].to_i : xml.attributes['width'].to_i
+        @height = xml.attributes['height'].nil? ? xml.parent.attributes['height'].to_i : xml.attributes['height'].to_i
+        @opacity = xml.attributes['opacity'].nil? ? 1 : xml.attributes['opacity'].to_i
+        @visible = xml.attributes['visible'].nil? ? 1 : xml.attributes['visible'].to_i
+        @opacity = xml.attributes['opacity'].nil? ? 1 : xml.attributes['opacity'].to_f
+        @data = nil
+        @map = map
+        build(xml)
+      end
+
+      
+      #This function is used for render the layer
+      def render(&block) #:yields: block_y, block_x, tileset, index
+        @height.times {|by| #block row
+          @width.times {|bx| #block col
+            cell = @data[(by * @height) + bx]
+            @map.tilesets.each {|k, t|
+              if t.firstgid <= cell.gid
+                cell.gid -= t.firstgid
+                block.call(bx, by, t, cell)
+                break
+              end
+            }
+          }
+        }
+      end
+
+      private
+      def build(doc)
+        @data = Data.new(self, doc.elements['data'])
+        @property = Properties.new(doc)
+      end
+
+      class Data
+        include Enumerable
+        GID_FLIP_X = 1.<< 31
+        GID_FLIP_Y = 1.<< 30 
+
+        #The encoding used to encode the tile layer data. When used, it can be "base64" and "csv" at the moment.
+        attr_reader :encoding
+
+        #The compression used to compress the tile layer data. Tiled Qt supports "gzip" and "zlib".
+        attr_reader :compression
+
+        #Layer belongs
+        attr_reader :layer
+
+        #REXML internal
+        attr_reader :xml
+
+
+        def initialize(layer, xml)
+          @layer = layer
+          @xml = xml
+          @encoding = xml.attributes['encoding']
+          @compression = xml.attributes['compression']
+          
+          @raw = []
+          @raw_data = xml.text
+          @data = []
+          
+          #decoding
+          case @encoding
+            when 'base64'
+            @raw_data = Base64.decode64(@raw_data)
+            when 'csv'
+            @raw_data = @raw_data.tr("\n",'')
+          end
+
+          #inflate compress
+          case @compression
+          when 'zlib'
+            zs = Zlib::Inflate.new
+            @raw_data = zs.inflate(@raw_data)
+            zs.finish
+            zs.close
+          when 'gzip'
+            gz = Zlib::GzipReader.new(StringIO.new(@raw_data))
+            @raw_data = gz.read
+            gz.close
+          end
+
+          #Data XML
+          if @encoding.nil? and @compression.nil?
+            xml.elements.each('tile') {|e|
+              @raw << e.attributes['gid'].to_i
+            }
+          elsif @encoding == 'csv'
+            @raw = @raw_data.split(',').collect {|x| x.to_i}
+          else
+            @raw = @raw_data.unpack("V*")
+          end
+
+          get_data
+
+        end
+
+
+        def [] (i)
+          @data[i]
+        end
+
+        def each
+          @data.each { |i| yield i }
+        end
+
+        private
+
+        #Discover, global tile id
+        def decode_gid(raw_gid)
+          flags = 0
+          flags += 1 if raw_gid & GID_FLIP_X == GID_FLIP_X
+          flags += 2 if raw_gid & GID_FLIP_Y == GID_FLIP_Y
+          gid = raw_gid & ~(GID_FLIP_X | GID_FLIP_Y)
+          return [gid, flags]
+        end
+
+        #Extract array of gids from array of ints
+        def get_data
+          tile_index = 0
+          gi = Struct.new(:gid, :flags)
+          @layer.height.times {|y|
+            @layer.width.times {|x|
+              next_gid = @raw[tile_index]
+              gid, flags = decode_gid(next_gid)
+              @data[tile_index] = gi.new(gid, flags)
+              tile_index += 1             
+            }
+          }
+        end
+      end
+    end
+
+
+    class TileSet
+      #The first global tile ID of this tileset (this global ID maps to the first tile in this tileset).
+      attr_reader :firstgid
+      
+      #If this tileset is stored in an external TSX (Tile Set XML) file, this attribute refers to that file.
+      attr_reader :source
+
+      #The name of this tileset.
+      attr_reader :name
+
+      #The (maximum) width of the tiles in this tileset.
+      attr_reader :tilewidth
+
+      #The (maximum) height of the tiles in this tileset.
+      attr_reader :tileheight
+
+      #The spacing in pixels between the tiles in this tileset (applies to the tileset image).
+      attr_reader :spacing
+
+      #The margin around the tiles in this tileset (applies to the tileset image).
+      attr_reader :margin
+
+      #Image has
+      attr_reader :image
+
+      #Properties
+      attr_reader :property
+
+      #Map belongs
+      attr_reader :map
+      def initialize(map, xml)
+        @map = map
+        @firstgid = xml.attributes['firstgid'].to_i
+        @source = xml.attributes['source']
+        @name = xml.attributes['name']
+        @tilewidth = xml.attributes['tilewidth'].to_i
+        @tileheight = xml.attributes['tileheight'].to_i
+        @spacing = xml.attributes['spacing'].nil? ? 0 : xml.attributes['spacing'].to_i
+        @margin = xml.attributes['margin'].nil? ? 0 : xml.attributes['margin'].to_i
+
+        @image = nil
+        #array of Recs that know how cut a image
+        @tiles = []
+        build(xml)
+      end
+
+      
+      #Get tile at index +i+
+      def at(i)
+        return @tiles[i.gid] if i.respond_to? :gid
+        return @tiles[i]
+      end
+
+      private
+      def build(xml)
+        @image = Image.new(xml)
+        @property = Properties.new(xml)
+        xml.elements.each('tile') { |e| @tiles << Tile.new(e) }
+        
+
+
+        #Rect: x, y, w, h
+        srect = Struct.new(:x, :y, :w, :h)
+        stop_width = @image.width - @tilewidth
+        stop_height = @image.height - @tileheight
+        tile_num = 0
+        #calculate how cut image
+        @margin.step(stop_height, @tileheight + @spacing) {|y| 
+          @margin.step(stop_width, @tilewidth + @spacing) {|x| 
+            @tiles[tile_num] = srect.new(x, y, @tilewidth, @tileheight)
+            tile_num += 1
+          }
+        }
+      end
+
+      class Tile
+        #The local tile ID within its tileset.
+        attr_reader :id
+
+        def initialize(doc)
+          @id = doc.attributes['id']
+        end
+      end
+
+      class Image
+        #The reference to the tileset image file (Tiled supports most common image formats).
+        attr_reader :source
+        
+        #Defines a specific color that is treated as transparent (example value: "FF00FF" for magenta).
+        attr_reader :trans
+
+        #Width of image
+        attr_reader :width
+        
+        #Height of image
+        attr_reader :height
+
+        def initialize(xml)
+          doc = xml.elements['image']
+          @source = doc.attributes['source']
+          @trans = doc.attributes['trans']
+          @width = doc.attributes['width'].to_i
+          @height = doc.attributes['height'].to_i
+        end
+      end
+    end
+  end
+end
+
+
+if $0 == __FILE__
+  RETMX.load('test.tmx')
+end

metadata

@@ -0,0 +1,45 @@
+--- !ruby/object:Gem::Specification
+name: retmx
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Jovany Leandro G.C
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-12-10 00:00:00.000000000 Z
+dependencies: []
+description: 
+email: info@manadalibre.org
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/retmx.rb
+homepage: https://www.manadalibre.org/desarrollos/doku.php?id=videojuegos:librerias:retmx
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.11
+signing_key: 
+specification_version: 3
+summary: Libray for read TMX (mapeditor.org)
+test_files: []