dxruby_tiled 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 988c6ed19ed82d78b9ccc6b7008715bbfa3c77ba
+  data.tar.gz: 10d757dfb2fc8fbad7096ad8e963a715b73cd655
+SHA512:
+  metadata.gz: 4a9926855f6b9eb883a07277e17fb472541755b895dc498661b9e9ef4c7e07b5075dc56ade5d60cad263a04773fe8495ec96d8d67f1f49cc2d2dd5c3ffca7e40
+  data.tar.gz: cbc1023393139166e5bc420605629ddff1237351d79e932ad03bb45dbfe8886ac3eb7f4a7af49abdf1b4404a40481c5d0651c324c9f4230cea0bcdb01f083a14

data/.gitignore

@@ -0,0 +1,9 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in dxruby_tiled.gemspec
+gemspec

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 nodai2hITC
+
+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.

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2017 TODO: Write your name
+
+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.

data/README.ja.md

@@ -0,0 +1,58 @@
+# DXRuby::Tiled
+
+[DXRuby](http://dxruby.osdn.jp/) を用いて、[Tiled Map Editor](http://www.mapeditor.org/) のデータを描画するライブラリです。
+
+
+## インストール
+
+    $ gem install dxruby_tiled
+
+	
+## 使用方法
+
+    require "dxruby_tiled"
+    
+    x, y = 0, 0
+    map = DXRuby::Tiled.load_json("tiledmapeditorfile.json")
+    
+    Window.loop do
+    map.draw(x, y)
+    end
+
+詳しくは、 examples/dxruby_tiled_test.rb 等をご参照あれ。
+
+
+## カスタムプロパティ
+
+- map - x_loop, y_loop
+-- x方向、y方向に関してループするマップになります。
+- imagelayer - fixed
+-- スクロールしない固定表示になります。
+
+## サポート状況
+
+### サポート済
+
+- タイルレイヤー（□型、◇型、六角形型）
+- 画像レイヤー
+- タイルのアニメーション
+
+### サポート予定
+
+- オブジェクトレイヤー
+- 当たり判定
+
+### サポート予定なし
+
+- TMX ファイルの読み込み
+
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/nodai2hITC/dxruby_tiled.
+
+
+## ライセンス
+
+[MIT License](http://opensource.org/licenses/MIT).
+

data/README.md

@@ -0,0 +1,56 @@
+# DXRuby::Tiled
+
+DXRuby::Tiled is a ruby library that draw [Tiled Map Editor](http://www.mapeditor.org/) data by using [DXRuby](http://dxruby.osdn.jp/)
+
+
+## Install
+
+    $ gem install dxruby_tiled
+
+	
+## How to use
+
+    require "dxruby_tiled"
+    
+    x, y = 0, 0
+    map = DXRuby::Tiled.load_json("tiledmapeditorfile.json")
+    
+    Window.loop do
+    map.draw(x, y)
+    end
+
+For more information, examples/dxruby_tiled_test.rb
+
+
+## Custom properties
+
+- map - x_loop, y_loop(bool)
+- imagelayer - fixed(bool)
+
+## Support status
+
+### Supported
+
+- tile layer (orthogonal, isometric, staggered, hexagonal)
+- image layer
+- animation
+
+### Will support
+
+- object layer
+- collision
+
+### Unsupported
+
+- load .tmx file
+
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/nodai2hITC/dxruby_tiled.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/dxruby_tiled.gemspec

@@ -0,0 +1,31 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'dxruby_tiled/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = "dxruby_tiled"
+  spec.version       = DXRuby::Tiled::VERSION
+  spec.authors       = ["nodai2h-ITC"]
+  
+  spec.summary       = %q{Draw TiledMapEditor JSON data by using DXRuby.}
+  spec.description   = %q{Draw TiledMapEditor JSON data by using DXRuby.}
+  spec.homepage      = "https://github.com/nodai2hITC/dxruby_tiled"
+  spec.license       = "MIT"
+
+  # Prevent pushing this gem to RubyGems.org. To allow pushes either set the 'allowed_push_host'
+  # to allow pushing to a single host or delete this section to allow pushing to any host.
+
+  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
+    f.match(%r{^(test|spec|features)/})
+  end
+  spec.bindir        = "exe"
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ["lib"]
+  
+  spec.add_dependency 'dxruby'
+  spec.add_dependency 'json'
+  
+  spec.add_development_dependency "bundler", "~> 1.14"
+  spec.add_development_dependency "rake", "~> 10.0"
+end

data/examples/dxruby_tiled_test.rb

@@ -0,0 +1,83 @@
+require "dxruby_tiled"
+
+puts "DXRuby::tiled example - ver 1.0.0"
+if ARGV[0] == "--help" || ARGV[0] == "-h"
+  puts "  usage: ruby dxruby_tiled_test.rb [jsonfile] [WindowWidth] [WindowHeight]"
+  exit
+end
+puts "Arrow Key: move (pressing the Shift key, slowly move)"
+puts "M: Display the mouseover tile."
+puts "L: Display layers."
+
+filename = ARGV[0] || Window.open_filename([["JSONファイル(*.json)", "*.json"]], "Tiled Map Editor の JSON ファイルを選択")
+exit unless filename
+
+map = DXRuby::Tiled.load_json(filename)
+Window.width  = ARGV[1].to_i if ARGV[1]
+Window.height = ARGV[2].to_i if ARGV[2]
+
+x, y = 0, 0
+draw_mouseovertile = true
+draw_layers        = false
+
+font = Font.new(16)
+
+mouseover_image = Image.new(32, 32, [128,128,128,255])
+
+max_tile_width  = map.tilesets.tile_images.max{|image| image.width  }.width
+max_tile_height = map.tilesets.tile_images.max{|image| image.height }.height
+
+Window.loop do
+  x += Input.x * (!Input.key_down?(K_LSHIFT) ? 5 : 1)
+  y += Input.y * (!Input.key_down?(K_LSHIFT) ? 5 : 1)
+  map.draw(x, y)
+  
+  tilelayer = map.layers.find{|layer| layer.is_a? DXRuby::Tiled::Layer }
+  pos_x, pos_y = tilelayer.xy_at(x + Input.mouse_x, y + Input.mouse_y)
+  vertexs = tilelayer.vertexs(pos_x, pos_y)
+  if vertexs.size == 4
+    Window.draw_morph(vertexs[0][0] - x, vertexs[0][1] - y,
+                      vertexs[1][0] - x, vertexs[1][1] - y,
+                      vertexs[2][0] - x, vertexs[2][1] - y,
+                      vertexs[3][0] - x, vertexs[3][1] - y, mouseover_image)
+  else
+    Window.draw_morph(vertexs[0][0] - x, vertexs[0][1] - y,
+                      vertexs[1][0] - x, vertexs[1][1] - y,
+                      vertexs[2][0] - x, vertexs[2][1] - y,
+                      vertexs[3][0] - x, vertexs[3][1] - y, mouseover_image)
+    Window.draw_morph(vertexs[3][0] - x, vertexs[3][1] - y,
+                      vertexs[4][0] - x, vertexs[4][1] - y,
+                      vertexs[5][0] - x, vertexs[5][1] - y,
+                      vertexs[0][0] - x, vertexs[0][1] - y, mouseover_image)
+  end
+  
+  draw_mouseovertile = !draw_mouseovertile if Input.key_push?(K_M)
+  if draw_mouseovertile
+    Window.draw_box_fill(Window.width - max_tile_width - 8, 0, Window.width, max_tile_height + 8, [92,92,92])
+    image = map.tilesets.tile_images[tilelayer[pos_x, pos_y]]
+    Window.draw(Window.width  - max_tile_width  / 2 - image.width  / 2 - 4,
+                                max_tile_height / 2 - image.height / 2 + 4, image)
+  end
+  
+  draw_layers = !draw_layers if Input.key_push?(K_L)
+  if draw_layers
+    tmp_y = Window.height
+    map.layers.each do |layer|
+      tmp_y -= 20
+      Window.draw_font(23 , tmp_y + 1, layer.name.to_s, font, color: [0,0,0])
+      Window.draw_font(22 , tmp_y, layer.name.to_s, font)
+      Window.draw_box_fill(2, tmp_y + 2, 18, tmp_y + 18, [255,255,255])
+      Window.draw_box_fill(3, tmp_y + 3, 17, tmp_y + 17, [0,0,0])
+      
+      if layer.visible
+        Window.draw_circle_fill(10, tmp_y + 10, 6, [255,255,255])
+      end
+      if Input.mouse_push?(M_LBUTTON) && Input.mouse_x >= 2 && Input.mouse_x <= 18 && Input.mouse_y >= tmp_y+2 && Input.mouse_y <= tmp_y+18
+        layer.visible = !layer.visible
+      end
+    end
+    
+  end
+  
+  Window.caption = "DXRuby_tiled - FPS:#{Window.real_fps} FILE:#{filename}"
+end

data/lib/dxruby_tiled.rb

@@ -0,0 +1,25 @@
+require "dxruby"
+require "json"
+require "zlib"
+require "base64"
+require "dxruby_tiled/version"
+require "dxruby_tiled/map"
+require "dxruby_tiled/tilesets"
+require "dxruby_tiled/tileset"
+require "dxruby_tiled/layer"
+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/imagelayer"
+
+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))
+    end
+  end
+end

data/lib/dxruby_tiled/imagelayer.rb

@@ -0,0 +1,35 @@
+module DXRuby
+  module Tiled
+    class ImageLayer
+      attr_reader :data, :name, :properties
+      attr_accessor :opacity, :visible, :offset_x, :offset_y, :fixed
+      
+      def initialize(data, map)
+        @original_data = data
+        @map = map
+        
+        @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]
+        
+        @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)
+        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
+      
+    end
+  end
+end

data/lib/dxruby_tiled/layer.rb

@@ -0,0 +1,55 @@
+module DXRuby
+  module Tiled
+    class Layer
+      attr_reader   :data, :name, :width, :height, :properties
+      attr_accessor :opacity, :visible, :offset_x, :offset_y
+      
+      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)
+      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

@@ -0,0 +1,133 @@
+module DXRuby
+  module Tiled
+    class HexagonalLayer < Layer
+      
+      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
+        
+        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)
+            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)
+            end
+          end
+        end
+      end
+      
+      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
+          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
+          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
+      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
+          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 ],
+            [ x0 + x * w * 2 + w    , y * h + @map.tile_height ],
+            [ x0 + x * w * 2 + w * 2, y * h + h ],
+            [ x0 + x * w * 2 + w * 2, y * h + h - @map.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
+          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 ]
+          ]
+        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
+      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
+      end
+      
+    end
+  end
+end

data/lib/dxruby_tiled/layer_isometric.rb

@@ -0,0 +1,69 @@
+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
+        
+        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)
+          end
+        end
+      end
+      
+      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
+      end
+      
+      def vertexs(x, y)
+        x0 = @map.pixel_width / 2
+        w, h = @map.tile_width / 2, @map.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     ]
+        ]
+      end
+      
+      
+      def self.pixel_width(map)
+        return map.tile_width  * (map.width + map.height) / 2
+      end
+      
+      def self.pixel_height(map)
+        return map.tile_height * (map.width + map.height) / 2
+      end
+      
+    end
+  end
+end

data/lib/dxruby_tiled/layer_orthogonal.rb

@@ -0,0 +1,59 @@
+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
+        
+        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)
+          end
+        end
+      end
+      
+      def xy_at(x, y)
+        return x / @map.tile_width, y / @map.tile_height
+      end
+      
+      def at(x, y)
+        return self[x / @map.tile_width, y / @map.tile_height]
+      end
+      
+      def change_at(x, y, value)
+        self[x / @map.tile_width, y / @map.tile_height] = value
+      end
+      
+      def vertexs(x, y)
+        w, h = @map.tile_width, @map.tile_height
+        return [
+          [ x * w    , y * h     ],
+          [ x * w    , y * h + h ],
+          [ x * w + w, y * h + h ],
+          [ x * w + w, y * h     ]
+        ]
+      end
+      
+      def self.pixel_width(map)
+        return map.tile_width * map.width
+      end
+      
+      def self.pixel_height(map)
+        return map.tile_height * map.height
+      end
+      
+    end
+  end
+end

data/lib/dxruby_tiled/layer_staggered.rb

@@ -0,0 +1,121 @@
+module DXRuby
+  module Tiled
+    class StaggeredLayer < 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
+        off_x = x - tile_width2  + @offset_x
+        off_y = y - tile_height2 + @offset_y
+        alpha = (@opacity * 255).floor
+        
+        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)
+            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)
+            end
+          end
+        end
+      end
+      
+      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
+          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
+          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
+      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
+          return [
+            [ x0 + x * w * 2 + w    , y * h         ],
+            [ x0 + x * w * 2        , y * h + h     ],
+            [ x0 + x * w * 2 + w    , y * h + h * 2 ],
+            [ x0 + x * w * 2 + w * 2, y * h + h     ]
+          ]
+        else
+          y0 = @map.stagger_index_odd ^ x.even? ? h : 0
+          return [
+            [ x * w + w    , y0 + y * h * 2         ],
+            [ x * w        , y0 + y * h * 2 + h     ],
+            [ x * w + w    , y0 + y * h * 2 + h * 2 ],
+            [ x * w + w * 2, y0 + y * h * 2 + h     ]
+          ]
+        end
+      end
+      
+      
+      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
+      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
+      end
+      
+    end
+  end
+end

data/lib/dxruby_tiled/map.rb

@@ -0,0 +1,91 @@
+module DXRuby
+  module Tiled
+    class Map
+      attr_reader   :data_dir, :tilesets, :layers,
+                    :version, :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
+      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
+          end
+        @width             = data[:width]         || 100
+        @height            = data[:height]        || 100
+        @tile_width        = data[:tilewidth]     || 32
+        @tile_height       = data[:tileheight]    || 32
+        @hex_side_length   = data[:hexsidelength] || 0
+        @stagger_axis_y    = data[:staggeraxis]  != "x"
+        @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
+        @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}
+        end
+        
+        @tilesets = Tilesets.new(data[:tilesets], 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 }
+      end
+      
+      def load_image(filename)
+        return DXRuby::Image.load(File.join(@data_dir, filename))
+      end
+      
+      def pixel_width()
+        return @orientation.pixel_width(self)
+      end
+      
+      def pixel_height()
+        return @orientation.pixel_height(self)
+      end
+      
+    end
+  end
+end

data/lib/dxruby_tiled/objectgroup.rb

@@ -0,0 +1,26 @@
+module DXRuby
+  module Tiled
+    class ObjectGroup # unsupported
+      attr_reader   :data, :name, :width, :height, :properties
+      attr_accessor :opacity, :visible, :offset_x, :offset_y
+      
+      def initialize(data, map)
+        @original_data = data
+        @map = map
+        
+        @name       = data[:name]
+        @color      = data[:color]      || [128, 128, 128]
+        @opacity    = data[:opacity]    || 1
+        @visible    = data[:visible] != false
+        @offset_x   = data[:offsetx]    || 0
+        @offset_y   = data[:offsety]    || 0
+        @properties = data[:properties] || {}
+        @draworder  = data[:draworder]  || "topdown"
+      end
+      
+      def draw(x, y, target = DXRuby::Window)
+      end
+
+    end
+  end
+end

data/lib/dxruby_tiled/tileset.rb

@@ -0,0 +1,71 @@
+module DXRuby
+  module Tiled
+    class Tileset
+      attr_reader :firstgid, :name, :tile_width, :tile_height,
+                  :spacing, :margin, :tile_count, :columns, :tile_offset, :properties,
+                  :tile_images, :animations
+      
+      def initialize(data, map)
+        @data = data
+        @map  = map
+        
+        @firstgid    = data[:firstgid]  || 1
+        @name        = data[:name]
+        @tile_width  = data[:tilewidth]  || map.tile_width
+        @tile_height = data[:tileheight] || map.tile_height
+        @spacing     = data[:spacing]    || 0
+        @margin      = data[:margin]     || 0
+        @tile_count  = data[:tilecount]
+        @columns     = data[:columns]
+        @tile_offset = data[:tileoffset] # unsupported
+        @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)
+        end
+        image_width  = data[:imagewidth]  || image.width
+        image_height = data[:imageheight] || image.height
+        
+        @tile_images = []
+        i = 0
+        col = 1
+        x = @margin
+        y = @margin
+        loop do
+          if x + @tile_width > image_width || (@columns && col > @columns)
+            x = @margin
+            y += @tile_height + @spacing
+            col = 1
+          end
+          break if y + @tile_height > image_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|
+          next unless value.has_key?(:animation)
+          anim_time  = []
+          anim_image = []
+          time = 0
+          value[:animation].each do |anim|
+            anim_time.push(time)
+            anim_image.push(@tile_images[anim[:tileid]])
+            time += anim[:duration]
+          end
+          anim_time.push(time)
+          @animations[@firstgid + key.to_s.to_i] = { time: anim_time, image: anim_image }
+        end
+      end
+      
+    end
+  end
+end

data/lib/dxruby_tiled/tilesets.rb

@@ -0,0 +1,34 @@
+module DXRuby
+  module Tiled
+    class Tilesets
+      attr_reader :tile_images
+      
+      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 = {}
+        
+        @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)
+        end
+      end
+      
+      def animation()
+        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
+      end
+      
+    end
+  end
+end

data/lib/dxruby_tiled/version.rb

@@ -0,0 +1,5 @@
+module DXRuby
+  module Tiled
+    VERSION = '0.1.0'
+  end
+end

metadata

@@ -0,0 +1,120 @@
+--- !ruby/object:Gem::Specification
+name: dxruby_tiled
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- nodai2h-ITC
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2017-02-24 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: dxruby
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.14'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+description: Draw TiledMapEditor JSON data by using DXRuby.
+email: 
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- LICENSE
+- LICENSE.txt
+- README.ja.md
+- README.md
+- Rakefile
+- dxruby_tiled.gemspec
+- examples/dxruby_tiled_test.rb
+- lib/dxruby_tiled.rb
+- lib/dxruby_tiled/imagelayer.rb
+- lib/dxruby_tiled/layer.rb
+- lib/dxruby_tiled/layer_hexagonal.rb
+- lib/dxruby_tiled/layer_isometric.rb
+- lib/dxruby_tiled/layer_orthogonal.rb
+- lib/dxruby_tiled/layer_staggered.rb
+- lib/dxruby_tiled/map.rb
+- lib/dxruby_tiled/objectgroup.rb
+- lib/dxruby_tiled/tileset.rb
+- lib/dxruby_tiled/tilesets.rb
+- lib/dxruby_tiled/version.rb
+homepage: https://github.com/nodai2hITC/dxruby_tiled
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.10
+signing_key: 
+specification_version: 4
+summary: Draw TiledMapEditor JSON data by using DXRuby.
+test_files: []