tmx 0.0.1

data/.gitignore

@@ -0,0 +1,12 @@
+pkg
+*.swp
+*.log
+doc
+coverage
+.DS_Store
+.yardoc
+tmp
+tags
+ctags
+.bundle
+*.lock

data/Gemfile

@@ -0,0 +1,4 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in gosu-tmx.gemspec
+gemspec

data/README.markdown

@@ -0,0 +1,92 @@
+# README
+## WHAT IS THIS
+
+Eventually, a usable TMX map loader that works with Gosu and doesn't care 
+whether you're using Chingu or some home-grown game engine of your own
+devising.
+
+### WHY ON EARTH
+
+I like Chingu and a TMX loader already exists for it, but it's just not the
+right tool for what I want to do. Hopefully others will find this useful as
+well. :)
+
+### WHAT IS MISSING
+
+Here's what's not: so far, map data is loaded and layers, object groups and
+tile sets are created. 
+
+Validating the XML document to its DTD would be nice too, but I'll be buggered
+if I can get Nokogiri to actually load the DTD. There is inadequate or no
+documentation on this topic. Probably we'll just have mysterious failures on
+unsupported or erroneous TMX files, which is not ideal.
+
+Possible consideration for the future: move the dependency on Gosu into a
+separate, mixable, matchable module. Maybe add explicit Chingu support too.
+Handle tile set creation and drawing ops the same way we do object creation:
+define a callback hook and let the user take care of it. Awesome.
+
+Help is welcome, obviously.
+
+## INSTALL
+
+Don't do it yet. The API is so unstable it does not have a half life but a
+quarter life.
+
+### PREREQUISITES
+
+* ruby >= 1.9.1 (probably)
+* nokogiri
+
+## LICENSE
+
+This software is available under the terms of the MIT license for no better
+reason than that this is the license of Gosu itself. This means that you are
+technically allowed to use my hard work as part of your proprietary,
+commercial product with no obligation to give anything back but credit where
+it's due. Use your discretion on that one.
+
+The full license is reproduced here for posterity:
+
+> Copyright © 2009–2010 Eris
+> 
+> Permission is hereby granted, free of charge, to any person
+> obtaining a copy of this software and associated documentation
+> files (the "Software"), to deal in the Software without
+> restriction, including without limitation the rights to use,
+> copy, modify, merge, publish, distribute, sublicense, and/or sell
+> copies of the Software, and to permit persons to whom the
+> Software is furnished to do so, subject to the following
+> conditions:
+> 
+> The above copyright notice and this permission notice shall be
+> included in all copies or substantial portions of the Software.
+> 
+> THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+> EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+> OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+> NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT
+> HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+> WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+> FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
+> OTHER DEALINGS IN THE SOFTWARE.
+
+## AUTHORS
+
+* Eris <eris.discord@gmail.com>
+* your name here!
+
+## SEE ALSO
+
+* [Gosu][], a 2D game development library for Ruby and C++
+* [Chingu][], a higher level game library built on top of Gosu
+* [Chipmunk][], a 2D rigid body physics engine in C
+* [chipmunk-ffi][], more up-to-date Ruby bindings for Chipmunk
+* [Tiled][], a flexible tile map editor and the origin of the TMX format (I
+  think).
+
+[chingu]: http://github.com/ippa/chingu
+[chipmunk]: http://code.google.com/p/chipmunk-physics
+[chipmunk-ffi]: http://github.com/shawn42/chipmunk-ffi
+[gosu]: http://libgosu.org
+[tiled]: http://mapeditor.org/

data/Rakefile

@@ -0,0 +1,11 @@
+require 'rspec/core/rake_task'
+require "bundler/gem_tasks"
+
+desc 'Default: run specs.'
+task :default => :spec
+
+desc "Run specs"
+RSpec::Core::RakeTask.new do |t|
+# t.pattern = "./spec/**/*_spec.rb" # don't need this, it's default.
+  # Put spec opts in a file named .rspec in root
+end

data/data/test.tmx

@@ -0,0 +1,62 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<map version="1.0" orientation="orthogonal" width="16" height="16" tilewidth="16" tileheight="16">
+ <properties>
+  <property name="bg1" value="#402010"/>
+  <property name="bg2" value="#100000"/>
+	<property name="fg1" value="#00ff0000"/>
+	<property name="fg2" value="#10ff0000"/>
+  <property name="display_name" value="Test Map"/>
+ </properties>
+ <tileset firstgid="1" name="debug" tilewidth="16" tileheight="16">
+  <image source="test-tiles.png"/>
+ </tileset>
+ <layer name="background" width="16" height="16" opacity="0.75">
+  <data encoding="base64" compression="gzip">
+   H4sIAAAAAAAAA2NgGAXogInK5rGh0aNgFAwWAADxvIrYAAQAAA==
+  </data>
+ </layer>
+ <layer name="obstacle" width="16" height="16">
+  <data encoding="base64" compression="gzip">
+   H4sIAAAAAAAAA82T4QqAIAyEZ1Jakb3/27YjB2MMMfvjwSHMfTp1BiIqg47sTOPKk/EXvWeCAnupLmqMDR7aa95RnVQumfye+vV6GM+PfEtgV/b9g5/p/UR4u+jEe3ncSTIx9Ia9J4/H3pvDezUmwwvbw0uN0h+658Stv4t59NIDVh+CwAAEAAA=
+  </data>
+ </layer>
+ <objectgroup name="doors" width="16" height="16">
+  <object name="door1" type="Door" x="128" y="208" width="16" height="32">
+   <properties>
+    <property name="image" value="door.png"/>
+    <property name="target" value="door2"/>
+   </properties>
+  </object>
+  <object name="door2" type="Door" x="64" y="32" width="16" height="32">
+   <properties>
+    <property name="image" value="door.png"/>
+    <property name="target" value="door1"/>
+   </properties>
+  </object>
+ </objectgroup>
+ <objectgroup name="objects" width="16" height="16">
+  <properties>
+   <property name="what_is_this" value="it's boxes ok"/>
+  </properties>
+  <object name="cardboard_box" type="Box" x="160" y="160" width="32" height="32">
+   <properties>
+    <property name="image" value="tid:16"/>
+   </properties>
+  </object>
+  <object name="stone_block" type="Box" x="192" y="32" width="32" height="32">
+   <properties>
+    <property name="image" value="tid:16"/>
+   </properties>
+  </object>
+  <object name="dude" type="Dude" x="80" y="144" width="16" height="32">
+   <properties>
+    <property name="image" value="dude.png"/>
+   </properties>
+  </object>
+ </objectgroup>
+ <layer name="foreground" width="16" height="16" opacity="0.75">
+  <data encoding="base64" compression="gzip">
+   H4sIAAAAAAAAA2NgGAWjYPABRiBmIoAJATYCeCD1EwMo1U8MAADF4i9MAAQAAA==
+  </data>
+ </layer>
+</map>

data/examples/example-chingu.rb

@@ -0,0 +1,114 @@
+require 'chingu'
+require 'tmx'
+require 'opengl' # Chingu needs it for retrofy
+
+class Float
+  INFINITY = 1.0 / 0.0 unless const_defined? :INFINITY
+end
+
+class Box < Chingu::GameObject
+  # "It's just a box."
+  
+  # (Chingu takes care of everything we need here (it's magic))
+end
+
+class Door < Chingu::GameObject
+  # this ought to take you somewhere else
+end
+
+class Dude < Chingu::GameObject
+	# maybe your player logic goes here
+end
+
+class MapState < Chingu::GameState
+  has_trait :viewport
+  
+  def initialize map_name, *rest
+    super *rest
+    
+    # load our map
+    @map = TMX::Map.new $window, map_name,
+      :on_object => method(:create_chingu_object)
+    @banner = Gosu::Image.from_text $window,
+      @map.properties[:display_name],
+      'Helvetica', 24
+    
+    $window.caption = 'tmx demo - %s' % @map.properties[:display_name]
+  end
+  
+  def create_chingu_object name, group, properties
+    map = group.map
+    obj_class = Kernel.const_get properties[:type] rescue nil
+    
+    # assert that the object is a valid type
+    raise TypeError, "#{properties[:type]} is not a game object" \
+      unless obj_class.is_a? Class \
+      and    obj_class.ancestors.include? Chingu::BasicGameObject
+    
+    # load image
+    image_name = properties[:image]
+    image = case image_name
+      when /^tid:(\d+)$/
+        # a tile from the map's tile set
+        map.tile_set[Integer($1)]
+      when nil
+        # default image
+        Gosu::Image['default']
+      else
+        # image as named
+        Gosu::Image[File.join 'data', image_name]
+      end
+    
+    # convert TMX properties to what Chingu is expecting
+    properties.merge! \
+      :image    => image.retrofy,
+      :x        => properties[:x] + properties[:width]  / 2,
+      :y        => properties[:y] + properties[:height] / 2,
+      :factor_x => properties[:width].to_f  / image.width,
+      :factor_y => properties[:height].to_f / image.height,
+      :zorder   => 1
+    
+    # create and return the game object
+    obj_class.create properties
+  end
+  
+  def update
+    super
+    # move the map opposite the mouse pointer, with lag
+    viewport.x = 0.9 * viewport.x + 0.1 * ($window.mouse_x - $window.width  + @map.width  / 2)
+    viewport.y = 0.9 * viewport.y + 0.1 * ($window.mouse_y - $window.height + @map.height / 2)
+  end
+  
+  def draw
+    super
+    
+    fill_gradient \
+      :from   => @map.properties[:bg1],
+      :to     => @map.properties[:bg2],
+      :zorder => -Float::INFINITY
+    
+    # map is not a game object
+    @map.draw -viewport.x, -viewport.y
+    
+    fill_gradient \
+      :from   => @map.properties[:fg1],
+      :to     => @map.properties[:fg2],
+      :zorder => Float::INFINITY
+    
+    @banner.draw 8, 8, Float::INFINITY
+  end
+end
+
+class MapWindow < Chingu::Window
+  def initialize
+    super 400, 200, false
+    
+    # global inputs for our demo
+    self.input = { :escape => :close }
+    
+    # load that map
+    push_game_state MapState.new('data/test.tmx')
+  end
+end
+
+MapWindow.new.show

data/lib/tmx.rb

@@ -0,0 +1,16 @@
+autoload :Base64,   'base64'
+autoload :Nokogiri, 'nokogiri'
+autoload :WeakRef,  'weakref'
+# autoload :Zlib,     'zlib'
+
+# mysterious autoload failure
+require 'zlib'
+
+require 'tmx/nokogiri_additions'
+
+module Tmx
+  autoload :Coder,       'tmx/coder'
+  autoload :Layer,       'tmx/layer'
+  autoload :Map,         'tmx/map'
+  autoload :ObjectGroup, 'tmx/object_group'
+end

data/lib/tmx/coder.rb

@@ -0,0 +1,39 @@
+module Tmx
+  module Coder
+    # default coders
+    autoload :Base64, 'tmx/coder/base64'
+    autoload :Gzip,   'tmx/coder/gzip'
+    
+    def self.encode str, *encodings
+      encodings.reject(&:nil?).reduce(str) do |data, encoding|
+        find_coder(encoding).encode(data)
+      end
+    end # encode
+    
+    def self.decode str, *encodings
+      encodings.reject(&:nil?).reverse.reduce(str) do |data, encoding|
+        find_coder(encoding).decode(data)
+      end
+    end # decode
+    
+    def self.find_coder name
+      const_name = name.to_s.capitalize.gsub /(?:\b|_)([a-z])/, &:upcase
+      if const_defined? const_name
+        const_get const_name
+      else
+        raise NameError, "unknown coder #{name}"
+      end
+    end # find_coder
+    
+    def self.register_coder name, mod
+      const_name = name.to_s.capitalize.gsub /(?:\b|_)([a-z])/, &:upcase
+      if not const_defined? const_name
+        const_set const_name, mod
+      else
+        raise NameError, "coder #{name} already registered"
+      end
+    end # register_coder
+    
+  end # Coder
+  
+end

data/lib/tmx/coder/base64.rb

@@ -0,0 +1,13 @@
+module Tmx
+  module Coder
+    module Base64
+      def self.encode str
+        ::Base64.strict_encode64 str
+      end
+      
+      def self.decode str
+        ::Base64.decode64 str
+      end
+    end # Base64
+  end
+end

data/lib/tmx/coder/gzip.rb

@@ -0,0 +1,21 @@
+module Tmx
+  module Coder
+    module Gzip
+      def self.encode str
+        buffer = String.new
+        writer = Zlib::GzipWriter.new(StringIO.new(buffer))
+        writer << str
+        writer.close
+        buffer
+      end
+      
+      def self.decode str
+        reader = Zlib::GzipReader.new(StringIO.new(str))
+        output = reader.read
+        reader.close
+        output
+      end
+      
+    end # Gzip
+  end
+end

data/lib/tmx/layer.rb

@@ -0,0 +1,74 @@
+module Tmx
+  class Layer
+    attr_reader :properties
+    attr_reader :columns, :rows
+    
+    def initialize map, data, properties
+      @map        = WeakRef.new map
+      @properties = properties.dup
+      
+      @columns = @properties.delete(:width)  or raise ArgumentError, "layer width is required"
+      @rows    = @properties.delete(:height) or raise ArgumentError, "layer height is required"
+            
+      @tile_ids = case data
+        when String then data.unpack('V*')
+        when Array  then data.dup
+        when nil    then Array.new @columns * @rows, 0
+        else raise ArgumentError, "data must be a binary string or an array of integers"
+        end
+    end # initialize
+    
+    def map; @map.__getobj__ end
+    
+    def [] x, y
+      raise IndexError unless x_range.include? x and y_range.include? y
+      @tile_ids[offset(x, y)]
+    end
+    
+    def []= x, y, id
+      raise IndexError unless x_range.include? x and y_range.include? y
+      @tile_ids[offset(x, y)] = id
+    end
+    
+    def each_tile_id &block
+      y_range.each do |y|
+        x_range.each do |x|
+          yield x, y, @tile_ids[offset(x, y)]
+        end
+      end
+    end # each_tile_id
+    
+    def x_range; 0...@columns end
+    def y_range; 0...@rows    end
+    
+    # def draw x_off, y_off, z_off, x_range, y_range
+    #   x_range = [x_range.min, 0].max .. [x_range.max, @columns  - 1].min
+    #   y_range = [y_range.min, 0].max .. [y_range.max, @rows     - 1].min
+    #   
+    #   tile_set    = @map.tile_set
+    #   tile_width  = @map.tile_width
+    #   tile_height = @map.tile_height
+    #   
+    #   y_range.each do |y|
+    #     tile_y_off = y_off + y * tile_height
+    #     
+    #     x_range.each do |x|
+    #       tile_x_off = x_off + x * tile_width
+    #       tile_index = @tile_ids[offset(x, y)]
+    #       
+    #       image = tile_set[tile_index]
+    #       next if image.nil?
+    #       
+    #       image.draw tile_x_off, tile_y_off, z_off, 1, 1, @color
+    #     end
+    #   end
+    # end
+    
+    private
+    
+    def offset x, y
+      x + y * @columns
+    end
+    
+  end # Layer
+end

data/lib/tmx/map.rb

@@ -0,0 +1,147 @@
+module Tmx
+  class Map
+    # autoload :TileCache, 'tmx/map/tile_cache'
+    autoload :XMLLoader, 'tmx/map/xml_loader'
+    
+    include XMLLoader
+    
+    attr_reader :properties
+    attr_reader :columns,    :rows
+    attr_reader :width,      :height
+    attr_reader :tile_width, :tile_height
+    
+    attr_reader :layers, :object_groups#, :tile_set
+    
+    DEFAULT_OPTIONS = {
+      # Scales pixel units to tile units (if true) or user-defined scale (if
+      # numeric) when passing them to callbacks.
+      :scale_units => false,
+      
+      # Hooks for object, layer and tile set creation. Only on_object is
+      # implemented so far.
+      :on_tile_set => nil,
+      :on_layer    => nil,
+      :on_object   => nil,
+      
+      # This option discards all layer, object group and tile set info after
+      # building the tile cache; uses less memory if you don't intend to
+      # modify the map at run time.
+      :discard_structure   => false,
+      
+      # These three options allow finer grained control of what to throw away
+      # in case you intend to modify only certain aspects of the map.
+      :discard_layer_info  => false,
+      :discard_object_info => false,
+    }
+    
+    def initialize file_name, options = {}
+      options = DEFAULT_OPTIONS.merge options
+      
+      # TODO move this XML code to an external module
+      # TODO allow file name or xml document?
+      # TODO allow other map formats?
+      
+      mapdef = File.open(file_name) do |io|
+        doc = Nokogiri::XML(io) { |conf| conf.noent.noblanks }
+        
+        # TODO figure out why this always fails
+        # errors = doc.validate
+        
+        doc.root
+      end
+      
+      # TODO proper version check; learn about Tmx versions if there are any
+      raise "Only version 1.0 maps are currently supported" unless mapdef['version']     == '1.0'
+      raise "Only orthogonal maps are currently supported"  unless mapdef['orientation'] == 'orthogonal'
+      
+      # @cache  = TileCache.new self
+      
+      @tile_width  = mapdef['tilewidth'].to_i
+      @tile_height = mapdef['tileheight'].to_i
+      
+      @columns = mapdef['width'].to_i
+      @rows    = mapdef['height'].to_i
+      
+      @scale_units = case options[:scale_units]
+        when Numeric      then options[:scale_units].to_f
+        when :tile_width  then 1.0 / @tile_width
+        when :tile_height then 1.0 / @tile_height
+        when true         then 1.0 / [@tile_width, @tile_height].min
+        else false
+        end 
+      
+      if @scale_units
+        @width  = @columns.to_f * @scale_units
+        @height = @rows.to_f    * @scale_units
+      else
+        @width  = @columns * @tile_width
+        @height = @rows    * @tile_height
+      end
+      
+      @properties = mapdef.tmx_parse_properties
+      
+#      @tile_set = TileSet.new self
+      
+      @layers        = Hash[]
+      @object_groups = Hash[]
+      
+      # callback for custom object creation
+      @on_object = options[:on_object]
+      
+      # mapdef.xpath('tileset').each do |xml|
+      #   @tile_set.load_tiles *parse_tile_set_def(xml)
+      # end
+      
+      mapdef.xpath('layer').each do |xml|
+        layer = parse_layer_def xml
+        name  = layer.properties[:name]
+        @layers[name] = layer
+      end # layers
+      
+
+      mapdef.xpath('objectgroup').each do |xml|
+        group = parse_object_group_def xml
+        name  = group.name
+        @object_groups[name] = group
+      end # object groups
+      
+      # @cache.rebuild!
+      
+      discard_structure = @properties.delete(:discard_structure)
+      
+      @layers        = nil if @properties.delete(:discard_layer_info)  || discard_structure
+      # @tile_sets     = nil if @properties.delete(:discard_tile_info)   || discard_structure
+      @object_groups = nil if @properties.delete(:discard_object_info) || discard_structure
+      
+    end # initialize
+    
+    # def create_tile_set name, file_name_or_images, properties
+    #   raise NotImplementedError
+    # end
+    
+    def create_layer name, data, properties
+      raise NotImplementedError
+    end
+    
+    def create_object_group name, properties
+      raise NotImplementedError
+    end
+    
+    def draw x_off, y_off, z_off = 0, x_range = 0...@columns, y_range = 0...@rows
+      # @cache.draw x_off, y_off, z_off, x_range, y_range
+      @layers.each_value.with_index do |layer, index|
+        layer.draw x_off, y_off, z_off + index, x_range, y_range
+      end
+    end # draw
+    
+    protected
+    
+    def on_object name, group, properties
+      if @on_object
+        @on_object.call name, group, properties
+      else
+        properties
+      end
+    end # on_object
+  end # Map
+end

data/lib/tmx/map/tile_cache.rb

@@ -0,0 +1,83 @@
+module Tmx
+  # WARNING this is currently deprecated and not actually used
+  class Map::TileCache
+    def initialize map
+      @map = WeakRef.new map
+      
+      @tile_cache = []
+      @map_cache  = []
+      
+      @layer_count = 0
+      
+      @columns,    @rows        = 0, 0
+      @tile_width, @tile_height = 0, 0
+    end # initialize
+    
+    def rebuild!
+      rebuild_tile_set!
+      rebuild_map!
+    end
+    
+    def rebuild_tile_set!
+      raise RuntimeError, "tile set information has been discarded" if @map.tile_sets.nil?
+      
+      @tile_cache.clear
+      @map.tile_sets.each_value do |tile_set|
+        @tile_cache[tile_set.range] = tile_set.tiles
+      end
+    end
+    
+    def rebuild_map!
+      raise RuntimeError, "layer information has been discarded" if @map.layers.nil?
+      
+      @map_cache.clear
+      
+      @layer_count = @map.layers.count
+      
+      @columns,    @rows        = @map.columns,    @map.rows
+      @tile_width, @tile_height = @map.tile_width, @map.tile_height
+      
+      @map.layers.each_value.with_index do |layer, layer_index|
+        (0...@rows).each do |y|
+          (0...@columns).each do |x|
+            index   = _tile_index layer_index, x, y
+            tile_id = layer[x, y]
+            @map_cache[index] = @tile_cache[tile_id]
+          end
+        end
+      end
+    end # rebuild_map!
+    
+    def draw x_off, y_off, z_off, x_range, y_range
+      x_range = [x_range.min, 0].max .. [x_range.max, @columns  - 1].min
+      y_range = [y_range.min, 0].max .. [y_range.max, @rows     - 1].min
+      
+      y_range.each do |y|
+        tile_y_off = y_off + y * @tile_height
+        
+        x_range.each do |x|
+          tile_x_off = x_off + x * @tile_width
+          
+          range = _tile_range x, y
+          @map_cache[range].each.with_index do |image, z|
+            next if image.nil?
+            image.draw tile_x_off, tile_y_off, z_off + z
+          end
+          
+        end
+      end
+    end # draw
+    
+    protected
+    
+    def _tile_index layer_index, x, y
+      y * @columns * @layer_count + x * @layer_count + layer_index
+    end
+    
+    def _tile_range x, y
+      first = _tile_index 0, x, y
+      first...(first + @layer_count)
+    end
+    
+  end
+end

data/lib/tmx/map/xml_loader.rb

@@ -0,0 +1,41 @@
+module Tmx
+  module Map::XMLLoader
+    protected
+    
+    def parse_tile_set_def xml
+      properties = xml.tmx_parse_attributes
+      image_path = File.absolute_path xml.xpath('image/@source').first.value, File.dirname(xml.document.url)
+      [ image_path, properties ]
+    end
+  
+    def parse_layer_def xml
+      properties = xml.tmx_parse_properties.merge! xml.tmx_parse_attributes
+      Layer.new self, xml.tmx_data, properties
+    end
+  
+    def parse_object_group_def xml
+      properties = xml.tmx_parse_properties.merge! xml.tmx_parse_attributes
+      group = ObjectGroup.new self, properties
+    
+      xml.xpath('object').each do |child|
+        obj = parse_object_def(child, group)
+        group.add obj if obj
+      end
+    
+      group
+    end # parse_object_group_def
+  
+    def parse_object_def xml, group
+      properties = xml.tmx_parse_properties.merge! xml.tmx_parse_attributes
+      # name       = properties[:name]
+      name       = properties[:name]
+    
+      [:x, :y, :width, :height].each do |key|
+        properties[key] = properties[key] * @scale_units
+      end if @scale_units
+    
+      on_object name, group, properties
+    end
+  
+  end # Map::XMLLoader
+end

data/lib/tmx/nokogiri_additions.rb

@@ -0,0 +1,56 @@
+# TODO investigate writing Nokogiri::TMX class hierarchy (yeah right)
+
+class Nokogiri::XML::Node
+  def to_sym; self.to_s.to_sym end
+  
+  def to_i; self.to_s.to_i end
+  def to_f; self.to_s.to_f end
+  def to_c; self.to_s.to_c end
+  def to_r; self.to_s.to_r end
+  
+  def tmx_parse
+    str = to_s
+    case str
+    when ''                                            then nil
+    when %r(^ (?: false | no  | off )             $)ix then false
+    when %r(^ (?: true  | yes | on  )             $)ix then true
+    when %r(^ [+-]?     \d+        / [+-]?  \d+   $)ix then str.to_r
+    when %r(^ [+-]? (?: \d+ \. \d+   [+-] ) \d+ i $)ix then str.to_c
+    when %r(^ [+-]?     \d+ \. \d+                $)ix then str.to_f
+    when %r(^ [+-]?     \d+                       $)ix then str.to_i
+    when %r(^ \# [0-9a-f]{6} $)ix
+      0xff000000 | str[1..6].to_i(16)
+    when %r(^ \# [0-9a-f]{8} $)ix
+      str[1..8].to_i(16)
+    else str
+    end
+  end
+end
+
+class Nokogiri::XML::Element
+  def tmx_parse_attributes
+    attributes.reduce({}) do |h, pair|
+      name  = pair[0].to_sym
+      value = pair[1].tmx_parse
+      h.merge name => value
+    end
+  end
+  
+  def tmx_parse_properties
+    properties_element = xpath('properties').first or return {}
+    properties_element.xpath('property').reduce({}) do |h, property|
+      name  = property.attribute('name').to_sym
+      value = property.attribute('value').tmx_parse
+      h.merge! name => value
+    end
+  end
+  
+  def tmx_data
+    data = ''
+    xpath('data').each do |data_element|
+      attrs = data_element.tmx_parse_attributes
+      data << Tmx::Coder.decode(data_element.text, attrs[:compression], attrs[:encoding])
+    end
+    data
+  end
+end

data/lib/tmx/object_group.rb

@@ -0,0 +1,30 @@
+module Tmx
+  class ObjectGroup
+    include Enumerable
+    
+    attr_reader :properties
+    attr_reader :name
+    
+    def initialize map, properties = {}
+      @map        = WeakRef.new map
+      @properties = properties
+      @objects    = Hash[]
+      
+      @name = properties.delete :name
+    end
+    
+    def map; @map.__getobj__ end
+    
+    def add obj
+      @objects[obj.object_id] = obj
+    end
+    
+    def remove obj
+      @objects.delete obj.object_id
+    end
+    
+    def each &block
+      @objects.each_value &block
+    end
+  end
+end

data/lib/tmx/tile_set.rb

@@ -0,0 +1,35 @@
+module Tmx
+  # class TileSet
+  #   def initialize map
+  #     @map   = WeakRef.new map
+  #     @tiles = [ nil ]
+  #   end
+  #   
+  #   def load_tiles file_name_or_images, properties = {}
+  #     properties  = properties.dup
+  #     first_id    = properties.delete :firstgid
+  #     tile_width  = properties.delete :tilewidth
+  #     tile_height = properties.delete :tileheight
+  #     
+  #     @tiles[first_id..-1] = case file_name_or_images
+  #       when String then Gosu::Image.load_tiles(@map.window, file_name_or_images, tile_width, tile_height, true).freeze
+  #       when Array  then file_name_or_images.dup
+  #       else raise ArgumentError, "must supply a file name or an array of images"
+  #       end
+  #     
+  #   end # load_tiles
+  #   
+  #   def map; @map.__getobj__ end
+  #   
+  #   def [] tile_id
+  #     raise IndexError unless (0...@tiles.length).include? tile_id
+  #     @tiles[tile_id]
+  #   end
+  #   
+  #   def []= tile_id, image
+  #     raise IndexError unless (1...@tiles.length).include? tile_id
+  #     @tiles[tile_id] = image
+  #   end
+  #   
+  # end
+end

data/lib/tmx/version.rb

@@ -0,0 +1,3 @@
+module Tmx
+  VERSION = "0.0.1"
+end

data/spec/coder_spec.rb

@@ -0,0 +1,29 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+describe 'Coder' do
+  it 'can find the default coders' do
+    Tmx::Coder.find_coder(:base64).should_not == nil
+    Tmx::Coder.find_coder(:gzip).should_not   == nil
+  end
+  
+  CODER_TEST_STRING = <<-EOS
+    Lorem ipsum dolor sit amet, consecteteur adapiscing elit.
+  EOS
+  
+  def coder_round_trip *encodings
+    encoded = Tmx::Coder.encode CODER_TEST_STRING, *encodings
+    decoded = Tmx::Coder.decode encoded, *encodings
+    decoded.should == CODER_TEST_STRING
+  end
+  
+  it 'can round trip base64' do
+    coder_round_trip :base64
+  end
+  
+  it 'can round trip gzip' do
+    coder_round_trip :gzip
+  end
+  
+  it 'can round trip multiple encodings' do
+    coder_round_trip :gzip, :base64
+  end
+end

data/spec/map_spec.rb

@@ -0,0 +1,50 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+describe 'Map' do
+  it 'can load the test map' do
+    $map = Tmx::Map.new File.join($data_dir, 'test.tmx'),
+      :scale_units => false
+    $map.should.is_a? Tmx::Map
+  end
+  
+  it 'has the correct dimensions' do
+    $map.columns.should == 16
+    $map.rows.should    == 16
+    
+    $map.width.should  == 16 * $map.tile_width
+    $map.height.should == 16 * $map.tile_height
+  end
+  
+  it 'has the correct tile dimensions' do
+    $map.tile_width.should  == 16
+    $map.tile_height.should == 16
+  end
+  
+  # it 'loads all tile set definitions into one flat set' do
+  #   $map.tile_set.should.is_a? Tmx::TileSet
+  #   $map.tile_set[0].should == nil
+  #   $map.tile_set[1].should.is_a? Gosu::Image
+  # end
+  
+  it 'loads all layers' do
+    $map.layers.count.should == 3
+    $map.layers.each do |name, layer|
+      layer.should.is_a? Tmx::Layer
+    end
+  end
+  
+  it 'loads all object groups' do
+    $map.object_groups.count.should == 2
+    $map.object_groups.each do |name, group|
+      Tmx::ObjectGroup.should === group
+    end
+  end
+  
+  # it 'can draw itself' do
+  #   $window.run_test\
+  #     :time   => 1.0,
+  #     :before => proc { @x, @y = 0, 0 },
+  #     :update => proc { @y -= 1 },
+  #     :draw   => proc { $map.draw @x, @y },
+  # end
+  
+end

data/spec/nokogiri_spec.rb

@@ -0,0 +1,5 @@
+require File.join(File.dirname(__FILE__), 'spec_helper')
+describe 'nokogiri additions' do
+  before(:all) { $doc = File.join($data_dir, 'test.tmx') }
+  after(:all)  { $doc = nil }
+end

data/spec/object_group_spec.rb

@@ -0,0 +1,41 @@
+
+require File.join(File.dirname(__FILE__), 'spec_helper')
+describe 'object groups' do
+  
+# {:image=>"door.png", :target=>"door2", :name=>"door1", :type=>"Door", :x=>128, :y=>208, :width=>16, :height=>32}
+# {:image=>"door.png", :target=>"door1", :name=>"door2", :type=>"Door", :x=>64, :y=>32, :width=>16, :height=>32}
+
+  it 'loads all object group properties' do
+    map = Tmx::Map.new File.join($data_dir, 'test.tmx'), :scale_units => false
+    object_group = map.object_groups["doors"]
+    object_group.should_not be_nil
+
+    captured = []
+    object_group.each do |obj|
+      captured << obj
+    end
+
+    obj = captured.first
+
+    obj[:target].should == "door2"
+    obj[:image].should == "door.png"
+    obj[:type].should == "Door"
+    obj[:x].should == 128
+    obj[:y].should == 208
+    obj[:width].should == 16
+    obj[:height].should == 32
+    obj[:name].should == "door1"
+
+    obj = captured.last
+    obj[:target].should == "door1"
+    obj[:image].should == "door.png"
+    obj[:type].should == "Door"
+    obj[:x].should == 64
+    obj[:y].should == 32
+    obj[:width].should == 16
+    obj[:height].should == 32
+    obj[:name].should == "door2"
+  end
+  
+  
+end

data/spec/spec_helper.rb

@@ -0,0 +1,52 @@
+
+tmx_root = File.dirname(File.dirname(__FILE__))
+
+$:.unshift File.join(tmx_root, 'lib')
+$data_dir = File.join(tmx_root, 'data')
+
+require 'gosu'
+require 'tmx'
+
+class TMXSpecWindow < Gosu::Window
+  def initialize
+    super 400, 200, false
+  end
+  
+  def run_test options = {}
+    @before = options.delete :before
+    @update = options.delete :update
+    @draw   = options.delete :draw
+    @after  = options.delete :after
+    
+    @time_limit = options.delete(:time) || 1.0
+    @start_time = Gosu.milliseconds / 1000.0
+    
+    @before.call if @before
+    
+    show
+  end
+  
+  def end_test
+    @after.call if @after
+    close
+  end
+  
+  def update
+    this_time = Gosu.milliseconds / 1000.0
+    @start_time
+    
+    @update.call(Gosu.milliseconds) if @update
+    
+    if this_time - @start_time > @time_limit
+      end_test
+    end
+    
+    @last_time = this_time
+  end
+  
+  def draw
+    @draw.call(Gosu.milliseconds) if @draw
+  end
+end
+
+$window = TMXSpecWindow.new

data/tmx.gemspec

@@ -0,0 +1,27 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "tmx/version"
+
+Gem::Specification.new do |s|
+  s.name        = "tmx"
+  s.version     = Tmx::VERSION
+  s.authors     = ["erisdiscord"]
+  s.email       = ["eris.discord@gmail.com"]
+  s.homepage    = ""
+  s.summary     = %q{Eventually, a usable TMX map loader that works with Gosu and doesn't care whether you're using Chingu or some home-grown game engine of your own devising.}
+  s.description = %q{Eventually, a usable TMX map loader that works with Gosu and doesn't care whether you're using Chingu or some home-grown game engine of your own devising.}
+
+  s.rubyforge_project = "tmx"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+
+  s.add_development_dependency "rake"
+  s.add_development_dependency "rspec"
+  s.add_development_dependency "gosu"
+
+  s.add_runtime_dependency "nokogiri"
+end

metadata

@@ -0,0 +1,123 @@
+--- !ruby/object:Gem::Specification
+name: tmx
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- erisdiscord
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-10-04 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &2161052740 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2161052740
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &2161052300 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2161052300
+- !ruby/object:Gem::Dependency
+  name: gosu
+  requirement: &2161051880 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *2161051880
+- !ruby/object:Gem::Dependency
+  name: nokogiri
+  requirement: &2161051440 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *2161051440
+description: Eventually, a usable TMX map loader that works with Gosu and doesn't
+  care whether you're using Chingu or some home-grown game engine of your own devising.
+email:
+- eris.discord@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- README.markdown
+- Rakefile
+- data/door.png
+- data/dude.png
+- data/test-tiles.png
+- data/test.tmx
+- examples/example-chingu.rb
+- lib/tmx.rb
+- lib/tmx/coder.rb
+- lib/tmx/coder/base64.rb
+- lib/tmx/coder/gzip.rb
+- lib/tmx/layer.rb
+- lib/tmx/map.rb
+- lib/tmx/map/tile_cache.rb
+- lib/tmx/map/xml_loader.rb
+- lib/tmx/nokogiri_additions.rb
+- lib/tmx/object_group.rb
+- lib/tmx/tile_set.rb
+- lib/tmx/version.rb
+- spec/coder_spec.rb
+- spec/map_spec.rb
+- spec/nokogiri_spec.rb
+- spec/object_group_spec.rb
+- spec/spec_helper.rb
+- tmx.gemspec
+homepage: ''
+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: tmx
+rubygems_version: 1.8.6
+signing_key: 
+specification_version: 3
+summary: Eventually, a usable TMX map loader that works with Gosu and doesn't care
+  whether you're using Chingu or some home-grown game engine of your own devising.
+test_files:
+- spec/coder_spec.rb
+- spec/map_spec.rb
+- spec/nokogiri_spec.rb
+- spec/object_group_spec.rb
+- spec/spec_helper.rb