demiurge 0.2.0 → 0.4.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 16771a3630ea74f9412194ba68ec9ebc5181380c
-  data.tar.gz: 7bd716fe644a7be1e32bd49ab0d39d4cc66a0e97
+  metadata.gz: 499186009cfdb7fdec206e4f4d4e900629f4dea0
+  data.tar.gz: 299ca77666a7b07d559f11f15bbe53e812318550
 SHA512:
-  metadata.gz: b10caf567ea6f50864c594e22ac16708407e325ec72a543ec403a7439ede2c512c82f6bb383dc019ba343cd71dbd131fdc87b99a4a5108be7e3c7dc2fd6bac62
-  data.tar.gz: 4ec6595a79d26d53fb40c04725820239b434195b3979583f589a0615d07339cf104680b62cb5669bdb3851b2588f560a9d7b3f39a3fa6f97d152eac4a33c6226
+  metadata.gz: e47ef0f89c8ee90df35d167ff802e38977b73fd533eaad911e742bb54dcda86896cfffd05ee5a22cfeca543c5ff131bd269e13291f309b8f11ee97fbbb27df45
+  data.tar.gz: f397a906555572b4e34369edd098ca9b9e9f3eafc4a35c0bf6e009e8e60c56b1b1b70d3035f8ad346d341d09384ae4ced796131678c78968bfd37221c6563877

data/.gitignore

@@ -7,3 +7,4 @@
 /pkg/
 /spec/reports/
 /tmp/
+demiurge-*.gem

data/Gemfile

@@ -1,4 +1,7 @@
 source 'https://rubygems.org'
 
+# We're using new experimental TMX features at the moment - use the gem from Git
+gem "tmx", :git => "git@github.com:shawn42/tmx.git"
+
 # Specify your gem's dependencies in demiurge.gemspec
 gemspec

data/WORLD_FILES.md

@@ -45,7 +45,7 @@ with this example, but you'll need to change it later.
 Here's an example file containing a very simple zone for use with
 Demiurge-CreateJS:
 
-    zone "trackless island", "type" => "TmxZone" do
+    zone "trackless island" do
       tmx_location "start location" do
         manasource_tile_layout "tmx/trackless_island_main.tmx"
         description "A Mysterious Island"

data/lib/demiurge.rb

@@ -16,6 +16,7 @@ require "demiurge/zone"
 require "demiurge/location"
 require "demiurge/agent"
 require "demiurge/dsl"
+require "demiurge/tmx"
 
 require "multi_json"
 
@@ -43,6 +44,7 @@ module Demiurge
     attr_reader :ticks
 
     # @return [Hash{String=>String}] The current execution context for notifications and logging.
+    # @since 0.3.0
     attr_reader :execution_context
 
     # This is the constructor for a new Engine object. Most frequently
@@ -361,7 +363,7 @@ module Demiurge
     # @yield Evaluate the following block with the given context set
     # @api private
     # @return [void]
-    # @since 0.2.0
+    # @since 0.3.0
     def push_context(context)
       @execution_context.push(context)
       yield

data/lib/demiurge/action_item.rb

@@ -326,7 +326,7 @@ module Demiurge
     # @return [String, Integer, Integer] The location string, the X coordinate and the Y coordinate
     # @since 0.0.1
     def position_to_location_and_tile_coords(position)
-      ::Demiurge::TmxLocation.position_to_loc_coords(position)
+      ::Demiurge::TiledLocation.position_to_loc_coords(position)
     end
 
     # Cancel the current intention. Raise a NoCurrentIntentionError if there isn't one.
@@ -362,13 +362,14 @@ module Demiurge
     # walking animation or anything. Just put it where it needs to be.
     #
     # @param position [String] The position to move to
+    # @param options [Hash] A Hash of *how* the item moves there; this can be checked by your World Files or display library, though Demiurge won't use it directly.
     # @return [void]
     # @since 0.0.1
-    def move_to_instant(position)
+    def move_to_instant(position, options = {})
       # TODO: We don't have a great way to do this for non-agent entities. How does "accomodate" work for non-agents?
       # This may be app-specific.
 
-      loc_name, next_x, next_y = TmxLocation.position_to_loc_coords(position)
+      loc_name, next_x, next_y = TiledLocation.position_to_loc_coords(position)
       location = @item.engine.item_by_name(loc_name)
       if !location
         cancel_intention_if_present "Location #{loc_name.inspect} doesn't exist.", "position" => position, "mover" => @item.name

data/lib/demiurge/agent.rb

@@ -43,9 +43,10 @@ module Demiurge
     # happen, has happened already.
     #
     # @param pos [String] A position string to move to
+    # @param options [Hash] A hash of how to do the movement; Demiurge doesn't internally use this hash, but your World Files or display library may do so
     # @return [void]
     # @since 0.0.1
-    def move_to_position(pos)
+    def move_to_position(pos, options = {})
       old_pos = self.position
       old_loc = self.location_name
       old_zone_name = self.zone_name
@@ -64,7 +65,7 @@ module Demiurge
 
       @engine.send_notification({ old_position: old_pos, old_location: old_loc, new_position: self.position, new_location: new_loc },
                                   type: Demiurge::Notifications::MoveFrom, zone: old_zone_name, location: old_loc, actor: @name, include_context: true)
-      @engine.send_notification({ old_position: old_pos, old_location: old_loc, new_position: self.position, new_location: new_loc },
+      @engine.send_notification({ old_position: old_pos, old_location: old_loc, new_position: self.position, new_location: new_loc, options: options },
                                   type: Demiurge::Notifications::MoveTo, zone: self.zone_name, location: self.location_name, actor: @name, include_context: true)
     end
 
@@ -323,7 +324,7 @@ module Demiurge
       agent.state["wander_counter"] += 1
       wander_every = agent.state["wander_every"] || 3
       return if agent.state["wander_counter"] < wander_every
-      next_coords = agent.zone.adjacent_positions(agent.position)
+      next_coords = agent.location.adjacent_positions(agent.position)
       if next_coords.empty?
         @engine.admin_warning("Oh no! Wandering agent #{@name.inspect} is stuck and can't get out!",
                              "zone" => agent.zone_name, "location" => agent.location_name, "agent" => @name)
@@ -331,7 +332,7 @@ module Demiurge
       end
       chosen = next_coords.sample
       pos = "#{agent.location_name}##{chosen.join(",")}"
-      agent.move_to_position(pos)
+      agent.move_to_position(pos, { "method" => "wander" })
       agent.state["wander_counter"] = 0
     end
   end

data/lib/demiurge/container.rb

@@ -24,6 +24,14 @@ module Demiurge
       state["contents"]
     end
 
+    # Gets the contents array as items, not names.
+    #
+    # @return [Array<Demiurge::StateItem>] The array of items contained in this item
+    # @since 0.3.0
+    def contents
+      state["contents"].map { |name| @engine.item_by_name(name) }
+    end
+
     # The finished_init hook is called after all items are loaded. For
     # containers, this makes sure all items set as contents of this
     # container also have it correctly set as their position.

data/lib/demiurge/dsl.rb

@@ -1,5 +1,3 @@
-require_relative "../demiurge"
-
 class Demiurge::Engine
   # This method loads new World File code into an existing engine.  It
   # should be passed a list of filenames, normally roughly the same

data/lib/demiurge/location.rb

@@ -81,5 +81,161 @@ module Demiurge
       @state["exits"]
     end
 
+    # Returns an array of position strings for positions adjacent to
+    # the one given. In some areas this won't be meaningful. But for
+    # most "plain" areas, this gives possibilities of where is
+    # moveable for simple AIs.
+    #
+    # @return [Array<String>] Array of position strings
+    # @since 0.0.1
+    def adjacent_positions(pos, options = {})
+      @state["exits"].map { |e| e["to"] }
+    end
+  end
+
+  # A TiledLocation is a location that uses #x,y format for positions
+  # for a 2D grid in the location. Something like a TMX file defines a
+  # TiledLocation, but so does an infinitely generated tiled space.
+  #
+  # @since 0.3.0
+  class TiledLocation < Location
+    # Parse a tiled position string and return the X and Y tile coordinates
+    #
+    # @param pos [String] The position string to parse
+    # @return [Array<Integer,Integer>] The x, y coordinates
+    # @since 0.2.0
+    def self.position_to_coords(pos)
+      loc, x, y = position_to_loc_coords(pos)
+      return x, y
+    end
+
+    # Parse a tiled position string and return the location name and the X and Y tile coordinates
+    #
+    # @param pos [String] The position string to parse
+    # @return [Array<String,Integer,Integer>] The location name and x, y coordinates
+    # @since 0.2.0
+    def self.position_to_loc_coords(pos)
+      loc, coords = pos.split("#",2)
+      if coords
+        x, y = coords.split(",")
+        return loc, x.to_i, y.to_i
+      else
+        return loc, nil, nil
+      end
+    end
+
+    # When an item changes position in a TiledLocation, check if the
+    # new position leads out an exit. If so, send them where the exit
+    # leads instead.
+    #
+    # @param item [String] The item changing position
+    # @param old_pos [String] The position string the item is moving *from*
+    # @param new_pos [String] The position string the item is moving *to*
+    # @return [void]
+    # @since 0.2.0
+    def item_change_position(item, old_pos, new_pos)
+      exit = @state["exits"].detect { |e| e["from"] == new_pos }
+      return super unless exit  # No exit? Do what you were going to.
+
+      # Going to hit an exit? Cancel this motion and enqueue an
+      # intention to do so? Or just send them through? If the former,
+      # it's very hard to unblockably pass through an exit, even if
+      # that's what's wanted. If the latter, it's very hard to make
+      # going through an exit blockable.
+
+      # Eh, just send them through for now. We'll figure out how to
+      # make detecting and blocking exit intentions easy later.
+
+      item_change_location(item, old_pos, exit["to"])
+    end
+
+    # This just determines if the position is valid at all.  It does
+    # *not* check walkable/swimmable or even if it's big enough for a
+    # humanoid to stand in.
+    #
+    # @param pos [String] The position being checked
+    # @return [Boolean] Whether the position is valid
+    # @since 0.2.0
+    def valid_position?(pos)
+      return false unless pos[0...@name.size] == @name
+      return false unless pos[@name.size] == "#"
+      x, y = pos[(@name.size + 1)..-1].split(",", 2).map(&:to_i)
+      valid_coordinate?(x, y)
+    end
+
+    # Determine whether this position can accomodate the given agent's shape and size.
+    #
+    # @param agent [Demiurge::Agent] The agent being checked
+    # @param position [String] The position being checked
+    # @return [Boolean] Whether the position can accomodate the agent
+    # @since 0.2.0
+    def can_accomodate_agent?(agent, position)
+      loc, x, y = TiledLocation.position_to_loc_coords(position)
+      raise "Location #{@name.inspect} asked about different location #{loc.inspect} in can_accomodate_agent!" if loc != @name
+      shape = agent.state["shape"] || "humanoid"
+      can_accomodate_shape?(x, y, shape)
+    end
+
+    # Whether the coordinate is valid
+    #
+    # @param x [Integer] The X coordinate
+    # @param y [Integer] The Y coordinate
+    # @return [Boolean] Whether the coordinate is valid
+    # @since 0.3.0
+    def valid_coordinate?(x,y)
+      true
+    end
+
+    # Whether the location can accomodate an object of this size.
+    #
+    # @param left_x [Integer] The lower (leftmost) X coordinate
+    # @param upper_y [Integer] The higher (upper) Y coordinate
+    # @param width [Integer] How wide the checked object is
+    # @param height [Integer] How high the checked object is
+    # @return [Boolean] Whether the object can be accomodated
+    # @since 0.3.0
+    def can_accomodate_dimensions?(left_x, upper_y, width, height)
+      true
+    end
+
+    # Determine whether this coordinate location can accomodate an
+    # item of the given shape.
+    #
+    # For now, don't distinguish between walkable/swimmable or
+    # whatever, just say a collision value of 0 means valid,
+    # everything else is invalid.
+    #
+    # @param left_x [Integer] The lower (leftmost) X coordinate
+    # @param upper_y [Integer] The higher (upper) Y coordinate
+    # @return [Boolean] Whether the object can be accomodated
+    # @since 0.3.0
+    def can_accomodate_shape?(left_x, upper_y, shape)
+      case shape
+      when "humanoid"
+        return can_accomodate_dimensions?(left_x, upper_y, 2, 1)
+      when "tiny"
+        return can_accomodate_dimensions?(left_x, upper_y, 1, 1)
+      else
+        raise "Unknown shape #{shape.inspect} passed to can_accomodate_shape!"
+      end
+    end
+
+    # Return a legal position in this location
+    #
+    # @return [String] A legal position string
+    # @since 0.3.0
+    def any_legal_position
+      "#{@name}#0,0"
+    end
+
+    # Return the list of valid adjacent positions from this one
+    def adjacent_positions(pos, options = {})
+      location, pos_spec = pos.split("#", 2)
+      loc = @engine.item_by_name(location)
+      x, y = pos_spec.split(",").map(&:to_i)
+
+      shape = options[:shape] || "humanoid"
+      [[x - 1, y], [x + 1, y], [x, y - 1], [x, y + 1]].select { |xp, yp| loc.can_accomodate_shape?(xp, yp, shape) }
+    end
   end
 end

data/lib/demiurge/tmx.rb

@@ -1,34 +1,52 @@
-require "demiurge/dsl"
-
-require "tmx"
-
-# TMX support here includes basic/normal TMX support for products of
-# the Tiled map editor (see "http://mapeditor.org" and
-# "http://docs.mapeditor.org/en/latest/reference/tmx-map-format/") and
-# more complex tiled map support for formats based on the ManaSource
-# game engine, including variants like Source of Tales, Land of Fire,
-# The Mana World and others. For more information on the ManaSource
-# mapping format, see "http://doc.manasource.org/mapping.html".
-
-# In general, Tiled and "raw" TMX try to be all things to all
-# games. If you can use a tile editor for it, Tiled would like to do
-# that for you. ManaSource is a more specialized engine and
-# introduces new concepts like named "Fringe" layers to make it clear
-# how a humanoid sprite walks through the map, named "Collision"
-# layers for walkability and swimmability, known-format "objects" for
-# things like doors, warps, NPCs, NPC waypoints and monster spawns.
-# Not all of that will be duplicated in Demiurge, but support for such
-# things belongs in the ManaSource-specific TMX parsing code.
-
-# In the long run, it's very likely that there will be other TMX
-# "dialects" like ManaSource's. Indeed, Demiurge might eventually
-# specify its own TMX dialect to support non-ManaSource features like
-# procedural map generation. My intention is to add them in the same
-# way - they may be requested in the Demiurge World files in the DSL,
-# and they will be an additional parsing pass on the result of "basic"
-# TMX parsing.
+require "tmx"  # Require the TMX gem
 
 module Demiurge
+
+  # Demiurge::Tmx is the module for Tmx internals. This includes Tmx
+  # parsing, caching and general encapsulation.
+  #
+  # TMX support here includes basic/normal TMX support for products of
+  # the Tiled map editor (see "http://mapeditor.org" and
+  # "http://docs.mapeditor.org/en/latest/reference/tmx-map-format/") and
+  # more complex tiled map support for formats based on the ManaSource
+  # game engine, including variants like Source of Tales, Land of Fire,
+  # The Mana World and others. For more information on the ManaSource
+  # mapping format, see "http://doc.manasource.org/mapping.html".
+  #
+  # In general, Tiled and "raw" TMX try to be all things to all
+  # games. If you can use a tile editor for it, Tiled would like to do
+  # that for you. ManaSource is a more specialized engine and
+  # introduces new concepts like named "Fringe" layers to make it clear
+  # how a humanoid sprite walks through the map, named "Collision"
+  # layers for walkability and swimmability, known-format "objects" for
+  # things like doors, warps, NPCs, NPC waypoints and monster spawns.
+  # Not all of that will be duplicated in Demiurge, but support for such
+  # things belongs in the ManaSource-specific TMX parsing code.
+  #
+  # In the long run, it's very likely that there will be other TMX
+  # "dialects" like ManaSource's. Indeed, Demiurge might eventually
+  # specify its own TMX dialect to support non-ManaSource features like
+  # procedural map generation. My intention is to add them in the same
+  # way - they may be requested in the Demiurge World files in the DSL,
+  # and they will be an additional parsing pass on the result of "basic"
+  # TMX parsing.
+  #
+  # @todo This entire file feels like a plugin waiting to
+  #   happen. Putting it into Demiurge and monkeypatching seems slightly
+  #   weird and "off". There's nothing wrong with having TiledLocation
+  #   in Demiurge, and we do. But TMX, specifically, has a lot of
+  #   format-specific stuff that doesn't seem to belong in core
+  #   Demiurge. That's part of why it's off by itself in a separate
+  #   file. If we were to support a second tilemap format, that would
+  #   definitely seem to belong in a plugin. It's not clear what makes
+  #   TMX different other than it being the first supported map format.
+  #   The only thing keeping this from being the "demiurge-tmx" gem is
+  #   that I feel like the code is already diced too finely into gems
+  #   for its current level of maturity.
+  #
+  # @since 0.3.0
+  module Tmx; end
+
   module DSL
     # Monkeypatch to allow tmx_location in World File zones.
     class ZoneBuilder
@@ -56,384 +74,361 @@ module Demiurge
 
       # Specify a TMX file as the tile layout, but assume relatively little about the TMX format.
       def tile_layout(tmx_spec)
-        # Make sure this loads correctly, but use the cache for efficiency.
-        TmxLocation.tile_cache_entry(nil, tmx_spec)
-
-        @state["tile_layout"] = tmx_spec
+        @state["tile_layout_filename"] = tmx_spec
+        @state["tile_layout_type"] = "tmx"
       end
 
       # Specify a TMX file as the tile layout, and interpret it according to ManaSource TMX conventions.
       def manasource_tile_layout(tmx_spec)
-        # Make sure this loads correctly, but use the cache for efficiency.
-        TmxLocation.tile_cache_entry(tmx_spec, nil)
-
-        @state["manasource_tile_layout"] = tmx_spec
+        @state["tile_layout_filename"] = tmx_spec
+        @state["tile_layout_type"] = "manasource"
       end
 
       # Validate built_item before returning it
       def built_item
-        raise("A TMX location (name: #{@name.inspect}) must have a tile layout!") unless @state["tile_layout"] || @state["manasource_tile_layout"]
-        super
-      end
-    end
-  end
-
-  # A TmxZone can extract things like exits and collision data from
-  # tile structures parsed from TMX files.
-  class TmxZone < TileZone
-    # Let's resolve any exits through this zone. NOTE: cross-zone
-    # exits may be slightly wonky because the other zone hasn't
-    # necessarily performed its own finished_init yet.
-    def finished_init
-      super
-      exits = []
-      # Go through the contents looking for locations
-      contents = state["contents"].map { |ln| @engine.item_by_name(ln) }
-      contents.each do |location|
-        # ManaSource locations often store exits as objects in an
-        # object layer.  They don't cope with multiple locations that
-        # use the same TMX file since they identify the destination by
-        # the TMX filename.  In Demiurge, we don't let them cross zone
-        # boundaries to avoid unexpected behavior in other folks'
-        # zones.
-        if location.is_a?(TmxLocation) && location.state["manasource_tile_layout"]
-          location.tiles[:objects].select { |obj| obj[:type].downcase == "warp" }.each do |obj|
-            next unless obj[:properties]
-            dest_map_name = obj[:properties]["dest_map"]
-            dest_location = contents.detect { |loc| loc.is_a?(TmxLocation) && loc.tiles[:tmx_name] == dest_map_name }
-            if dest_location
-              dest_position = "#{dest_location.name}##{obj[:properties]["dest_x"]},#{obj[:properties]["dest_y"]}"
-              src_x_coord = obj[:x] / location.tiles[:spritesheet][:tilewidth]
-              src_y_coord = obj[:y] / location.tiles[:spritesheet][:tileheight]
-              src_position = "#{location.name}##{src_x_coord},#{src_y_coord}"
-              raise("Exit destination position #{dest_position.inspect} loaded from TMX location #{location.name.inspect} (TMX: #{location.tiles[:filename]}) is not valid!") unless dest_location.valid_position?(dest_position)
-              exits.push({ src_loc: location, src_pos: src_position, dest_pos: dest_position })
-            else
-              @engine.admin_warning "Unresolved TMX exit in #{location.name.inspect}: #{obj[:properties].inspect}!",
-                                    "location" => location.name, "properties" => obj[:properties]
-            end
-          end
-        end
-      end
-      exits.each do |exit|
-        exit[:src_loc].add_exit(from: exit[:src_pos], to: exit[:dest_pos])
+        raise("A TMX location (name: #{@name.inspect}) must have a tile layout!") unless @state["tile_layout_filename"]
+        item = super
+        item.tile_cache_entry  # Load the cache entry, make sure it works without error
+        item
       end
     end
-
-    # Return the list of valid adjacent positions from this one
-    def adjacent_positions(pos, options = {})
-      location, pos_spec = pos.split("#", 2)
-      loc = @engine.item_by_name(location)
-      x, y = pos_spec.split(",").map(&:to_i)
-
-      shape = options[:shape] || "humanoid"
-      [[x - 1, y], [x + 1, y], [x, y - 1], [x, y + 1]].select { |xp, yp| loc.can_accomodate_shape?(xp, yp, shape) }
-    end
   end
 
   # A TmxLocation is a special location that is attached to a tile
   # layout, a TMX file. This affects the size and shape of the room,
   # and how agents may travel through it. TmxLocations have X and Y
   # coordinates (grid coordinates) for their positions.
-  class TmxLocation < Location
-    # Parse a tiled position string and return the X and Y tile coordinates
-    def self.position_to_coords(pos)
-      loc, x, y = position_to_loc_coords(pos)
-      return x, y
+  #
+  # @since 0.2.0
+  class Tmx::TmxLocation < TiledLocation
+    # Get the default tile cache for newly-created
+    # TmxLocations. Demiurge provides one by default which can be
+    # overridden.
+    #
+    # @return [Demiurge::Tmx::TileCache] The current default TileCache for newly-created TmxLocations
+    # @since 0.3.0
+    def self.default_cache
+      @default_cache ||= ::Demiurge::Tmx::TmxCache.new
+      @default_cache
     end
 
-    # Parse a tiled position string and return the location name and the X and Y tile coordinates
-    def self.position_to_loc_coords(pos)
-      loc, coords = pos.split("#",2)
-      if coords
-        x, y = coords.split(",")
-        return loc, x.to_i, y.to_i
-      else
-        return loc, nil, nil
-      end
+    # Set the default cache for newly-created TmxLocations.
+    #
+    # @param cache [Demiurge::Tmx::TileCache] The tile cache for all subsequently-created TmxLocations
+    # @since 0.3.0
+    def self.set_default_cache(cache)
+      @default_cache = cache
     end
 
-    # When an item changes position in a TmxLocation, check if the new
-    # position leads out an exit. If so, send them where the exit
-    # leads instead.
-    def item_change_position(item, old_pos, new_pos)
-      exit = @state["exits"].detect { |e| e["from"] == new_pos }
-      return super unless exit  # No exit? Do what you were going to.
+    # Set the tile cache for this specific TmxLocation
+    #
+    # @param cache [Demiurge::Tmx::TileCache]
+    # @since 0.3.0
+    def set_cache(cache)
+      @cache = cache
+    end
 
-      # Going to hit an exit? Cancel this motion and enqueue an
-      # intention to do so? Or just send them through? If the former,
-      # it's very hard to unblockably pass through an exit, even if
-      # that's what's wanted. If the latter, it's very hard to make
-      # going through an exit blockable.
+    # Get the tile cache for this Tmxlocation
+    #
+    # @return [Demiurge::Tmx::TileCache]
+    # @since 0.3.0
+    def cache
+      @cache ||= self.class.default_cache
+    end
 
-      # Eh, just send them through for now. We'll figure out how to
-      # make detecting and blocking exit intentions easy later.
+    # Let's resolve any exits that go to other TMX locations.
+    #
+    # @since 0.3.0
+    def finished_init
+      super
+      exits = []
+      return unless @state["tile_layout_type"] == "manasource"
 
-      item_change_location(item, old_pos, exit["to"])
-    end
+      # Go through the contents looking for locations
+      zone_contents = self.zone.contents
+
+      # ManaSource locations often store exits as objects in an
+      # object layer.  They don't cope with multiple locations that
+      # use the same TMX file since they identify the destination by
+      # the TMX filename.  In Demiurge, we don't let them cross zone
+      # boundaries to avoid unexpected behavior in other folks'
+      # zones.
+      tile_cache_entry["objects"].select { |obj| obj["type"].downcase == "warp" }.each do |obj|
+        next unless obj["properties"]
+        dest_map_name = obj["properties"]["dest_map"]
+        dest_location = zone_contents.detect { |loc| loc.is_a?(::Demiurge::Tmx::TmxLocation) && loc.tile_cache_entry["tmx_name"] == dest_map_name }
+        if dest_location
+          entry = dest_location.tile_cache_entry
+          dest_position = "#{dest_location.name}##{obj["properties"]["dest_x"]},#{obj["properties"]["dest_y"]}"
+          src_x_coord = obj["x"] / tile_cache_entry["tilewidth"]
+          src_y_coord = obj["y"] / tile_cache_entry["tileheight"]
+          src_position = "#{name}##{src_x_coord},#{src_y_coord}"
+          raise("Exit destination position #{dest_position.inspect} loaded from TMX location #{name.inspect} (TMX: #{tile_cache_entry["filename"]}) is not valid!") unless dest_location.valid_position?(dest_position)
+          exits.push({ src_loc: self, src_pos: src_position, dest_pos: dest_position })
+        else
+          @engine.admin_warning "Unresolved TMX exit in #{name.inspect}: #{obj["properties"].inspect}!",
+                                "location" => name, "properties" => obj["properties"]
+        end
+      end
 
-    # This just determines if the position is valid at all.  It does
-    # *not* check walkable/swimmable or even if it's big enough for a
-    # humanoid to stand in.
-    def valid_position?(pos)
-      return false unless pos[0...@name.size] == @name
-      return false unless pos[@name.size] == "#"
-      x, y = pos[(@name.size + 1)..-1].split(",", 2).map(&:to_i)
-      valid_coordinate?(x, y)
+      exits.each do |exit|
+        exit[:src_loc].add_exit(from: exit[:src_pos], to: exit[:dest_pos])
+      end
     end
 
     # This checks the coordinate's validity, but not relative to any
     # specific person/item/whatever that could occupy the space.
+    #
+    # @return [Boolean] Whether the coordinate is valid
+    # @since 0.2.0
     def valid_coordinate?(x, y)
       return false if x < 0 || y < 0
-      return false if x >= tiles[:spritestack][:width] || y >= tiles[:spritestack][:height]
-      return true unless tiles[:collision]
-      return tiles[:collision][y][x] == 0
-    end
-
-    # Determine whether this position can accomodate the given agent's shape and size.
-    def can_accomodate_agent?(agent, position)
-      loc, x, y = TmxLocation.position_to_loc_coords(position)
-      raise "Location #{@name.inspect} asked about different location #{loc.inspect} in can_accomodate_agent!" if loc != @name
-      shape = agent.state["shape"] || "humanoid"
-      can_accomodate_shape?(x, y, shape)
+      return false if x >= tile_cache_entry["width"] || y >= tile_cache_entry["height"]
+      return true unless tile_cache_entry["collision"]
+      return tile_cache_entry["collision"][y * tile_cache_entry["width"] + x] == 0
     end
 
-    # Determine whether this coordinate location can accomodate a
+    # Determine whether this coordinate location can accommodate a
     # rectangular item of the given coordinate dimensions.
+    #
+    # @since 0.2.0
     def can_accomodate_dimensions?(left_x, upper_y, width, height)
       return false if left_x < 0 || upper_y < 0
       right_x = left_x + width - 1
       lower_y = upper_y + height - 1
-      return false if right_x >= tiles[:spritestack][:width] || lower_y >= tiles[:spritestack][:height]
-      return true unless tiles[:collision]
+      return false if right_x >= tile_cache_entry["width"] || lower_y >= tile_cache_entry["height"]
+      return true unless tile_cache_entry["collision"]
       (left_x..right_x).each do |x|
         (upper_y..lower_y).each do |y|
-          return false if tiles[:collision][y][x] != 0
+          return false if tile_cache_entry["collision"][y * tile_cache_entry["width"] + x] != 0
         end
       end
       return true
     end
 
-    # Determine whether this coordinate location can accomodate an
-    # item of the given shape.
-    #
-    # For now, don't distinguish between walkable/swimmable or
-    # whatever, just say a collision value of 0 means valid,
-    # everything else is invalid.
-    #
-    # TODO: figure out some configurable way to specify what tile
-    # value means invalid for TMX maps with more complex collision
-    # logic.
-    def can_accomodate_shape?(left_x, upper_y, shape)
-      case shape
-      when "humanoid"
-        return can_accomodate_dimensions?(left_x, upper_y, 2, 1)
-      when "tiny"
-        return can_accomodate_dimensions?(left_x, upper_y, 1, 1)
-      else
-        raise "Unknown shape #{shape.inspect} passed to can_accomodate_shape!"
-      end
-    end
-
     # For a TmxLocation's legal position, find somewhere not covered
     # as a collision on the collision map.
+    #
+    # @return [String] A legal position string within this location
+    # @since 0.2.0
     def any_legal_position
-      loc_tiles = self.tiles
-      if tiles[:collision]
+      entry = tile_cache_entry
+      if entry["collision"]
         # We have a collision layer? Fabulous. Scan upper-left to lower-right until we get something non-collidable.
-        (0...tiles[:spritestack][:width]).each do |x|
-          (0...tiles[:spritestack][:height]).each do |y|
-            if tiles[:collision][y][x] == 0
+        (0...entry["width"]).each do |x|
+          (0...entry["height"]).each do |y|
+            if entry["collision"][y * tile_cache_entry["width"] + x] == 0
               # We found a walkable spot.
               return "#{@name}##{x},#{y}"
             end
           end
         end
-      else
-        # Is there a start location? If so, return it. Guaranteed good, right?
-        start_loc = tiles[:objects].detect { |obj| obj[:name] == "start location" }
-        if start_loc
-          x = start_loc[:x] / tiles[:spritestack][:tilewidth]
-          y = start_loc[:y] / tiles[:spritestack][:tileheight]
-          return "#{@name}##{x},#{y}"
-        end
-        # If no start location and no collision data, is there a first location with coordinates?
-        if tiles[:objects].first[:x]
-          obj = tiles[:objects].first
-          return "#{@name}##{x},#{y}"
-        end
-        # Screw it, just return the upper left corner.
-        return "#{@name}#0,0"
+        # If we got here, there exists no walkable spot in the whole location.
       end
+      # Screw it, just return the upper left corner.
+      return "#{@name}#0,0"
     end
 
     # Return the tile object for this location
-    def tiles
-      raise("A TMX location (name: #{@name.inspect}) must have a tile layout!") unless state["tile_layout"] || state["manasource_tile_layout"]
-      TmxLocation.tile_cache_entry(state["manasource_tile_layout"], state["tile_layout"])
+    def tile_cache_entry
+      raise("A TMX location (name: #{@name.inspect}) must have a tile layout!") unless state["tile_layout_filename"]
+      cache.tmx_entry(@state["tile_layout_type"], @state["tile_layout_filename"])
     end
 
     # Return a TMX object's structure, for an object of the given name, or nil.
     def tmx_object_by_name(name)
-      tiles[:objects].detect { |o| o[:name] == name }
+      tile_cache_entry["objects"].detect { |o| o["name"] == name }
     end
 
     # Return the tile coordinates of the TMX object with the given name, or nil.
     def tmx_object_coords_by_name(name)
-      obj = tiles[:objects].detect { |o| o[:name] == name }
-      if obj
-        [ obj[:x] / tiles[:spritesheet][:tilewidth], obj[:y] / tiles[:spritesheet][:tileheight] ]
-      else
-        nil
-      end
+      obj = tmx_object_by_name(name)
+      return nil unless obj
+      [ obj["x"] / tile_cache_entry["tilewidth"], obj["y"] / tile_cache_entry["tileheight"] ]
     end
 
-    # Technically a StateItem of any kind has to be okay with its
-    # state changing totally out from under it at any time.  One way
-    # around that for TMX is a tile cache to parse new entries and
-    # re-return old ones.  This means if a file is changed at runtime,
-    # its cache entry won't be reloaded.
-    def self.tile_cache_entry(state_manasource_tile_layout, state_tile_layout)
-      smtl = state_manasource_tile_layout
-      stl = state_tile_layout
-      @tile_cache ||= {
-        "manasource_tile_layout" => {},
-        "tile_layout" => {},
-      }
-      if smtl
-        @tile_cache["manasource_tile_layout"][smtl] ||= Demiurge.sprites_from_manasource_tmx(smtl)
-      elsif stl
-        @tile_cache["tile_layout"][stl] ||= Demiurge.sprites_from_tmx(stl)
-      else
-        raise "A TMX location must have some kind of tile layout!"
-      end
-    end
   end
 end
 
-Demiurge::DSL::TopLevelBuilder.register_type "TmxZone", Demiurge::TmxZone
-Demiurge::DSL::TopLevelBuilder.register_type "TmxLocation", Demiurge::TmxLocation
+Demiurge::DSL::TopLevelBuilder.register_type "TmxLocation", Demiurge::Tmx::TmxLocation
+
+module Demiurge::Tmx
+  # A TmxCache loads and remembers TMX file maps from the tmx gem. For
+  # a variety of reasons, it's not great to reload TMX files every
+  # time we need to know about them, but it can also be a problem to
+  # store a copy of the parsed version every time and place we use it.
+  # Caching is, of course, a time-honored solution to this problem.
+  #
+  # @since 0.3.0
+  class TmxCache
+    # @return [String] Root directory the cache was created relative to
+    attr_reader :root_dir
+
+    # Create the TmxCache
+    #
+    # @param options [Hash] Options
+    # @option options [String] :root_dir The root directory to read TMX and TSX files relative to
+    # @return [void]
+    # @since 0.3.0
+    def initialize(options = {})
+      @root_dir = options[:root_dir] || Dir.pwd
+    end
 
-module Demiurge
-  # This is to support TMX files for ManaSource, ManaWorld, Land of
-  # Fire, Source of Tales and other Mana Project games. It can't be
-  # perfect since there's some variation between them, but it can
-  # follow most major conventions.
-
-  # Load a TMX file and calculate the objects inside including the
-  # Spritesheet and Spritestack. Assume this TMX file obeys ManaSource
-  # conventions such as fields for exits and names for layers.
-  def self.sprites_from_manasource_tmx(filename)
-    objs = sprites_from_tmx filename
-    stack = objs[:spritestack]
-
-    stack_layers = stack[:layers]
-
-    # Remove the collision layer, add as separate collision top-level entry
-    collision_index = stack_layers.index { |l| l[:name].downcase == "collision" }
-    collision_layer = stack_layers.delete_at collision_index if collision_index
-
-    # Some games make this true/false, others have separate visibility
-    # or swimmability in it. In general, we'll just expose the data.
-    objs[:collision] = collision_layer[:data] if collision_layer
-
-    # Remove the heights layer, add as separate heights top-level entry
-    heights_index = stack_layers.index { |l| ["height", "heights"].include?(l[:name].downcase)  }
-    heights_layer = stack_layers.delete_at heights_index if heights_index
-    objs[:heights] = heights_layer
-
-    fringe_index = stack_layers.index { |l| l[:name].downcase == "fringe" }
-    raise ::Demiurge::Errors::TmxFormatError.new("No Fringe layer found in ManaSource TMX File #{filename.inspect}!", "filename" => filename) unless fringe_index
-    stack_layers.each_with_index do |layer, index|
-      # Assign a Z value based on layer depth, with fringe = 0 as a special case
-      layer["z"] = (index - fringe_index) * 10.0
+    # Clear the TMX cache. Remove all existing entries. This can
+    # potentially break existing TMX-based objects. Objects often
+    # refer repeatedly back into the cache to avoid duplicating
+    # structures, and to pick up new changes to those structures.
+    #
+    # @return [void]
+    # @since 0.3.0
+    def clear_cache
+      @tile_cache = {}
+      nil
     end
 
-    objs
-  end
+    # Change the root directory this cache uses. Note that any
+    # existing TMX files with a different root would presumably
+    # change, so this clears the cache as a side effect.
+    #
+    # @param new_root [String] The new directory to use as TMX root for this cache
+    # @return [void]
+    # @since 0.3.0
+    def root_dir=(new_root)
+      clear_cache
+      @root_dir = new_root
+      nil
+    end
+
+    # Return a TMX entry for the given layout type and filename. A
+    # "layout type" is something like normal TMX (called "tmx") or
+    # Manasource-style (called "manasource".) But additional types are
+    # likely to be added in future versions of Pixiurge.
+    #
+    # @param layout_type [String] The subtype of TMX file; currently may be one of "tmx" or "manasource"
+    # @param layout_filename [String] The path to the TMX file relative to the tile cache's TMX root directory
+    # @return [Hash] The TMX cache entry, in an internal and potentially changeable format
+    # @api private
+    # @since 0.3.0
+    def tmx_entry(layout_type, layout_filename)
+      @tile_cache ||= {}
+      @tile_cache[layout_type] ||= {}
+      if @tile_cache[layout_type][layout_filename]
+        return @tile_cache[layout_type][layout_filename]
+      end
 
-  # Load a TMX file and calculate the objects inside including the
-  # Spritesheet and Spritestack. Do not assume this TMX file obeys any
-  # particular additional conventions beyond basic TMX format.
-  def self.sprites_from_tmx(filename)
-    spritesheet = {}
-    spritestack = {}
-
-    # This recursively loads things like tileset .tsx files
-    tiles = Tmx.load filename
-
-    spritestack[:name] = tiles.name || File.basename(filename).split(".")[0]
-    spritestack[:width] = tiles.width
-    spritestack[:height] = tiles.height
-    spritestack[:properties] = tiles.properties
-
-    spritesheet[:tilewidth] = tiles.tilewidth
-    spritesheet[:tileheight] = tiles.tileheight
-
-    spritesheet[:images] = tiles.tilesets.map do |tileset|
-      {
-        firstgid: tileset.firstgid,
-        tileset_name: tileset.name,
-        image: tileset.image,
-        imagewidth: tileset.imagewidth,
-        imageheight: tileset.imageheight,
-        tilewidth: tileset.tilewidth,
-        tileheight: tileset.tileheight,
-        oversize: tileset.tilewidth != tiles.tilewidth || tileset.tileheight != tiles.tileheight,
-        spacing: tileset.spacing,
-        margin: tileset.margin,
-        imagetrans: tileset.imagetrans, # Currently unused, color to treat as transparent
-        properties: tileset.properties,
-      }
+      if layout_type == "manasource"
+        @tile_cache[layout_type][layout_filename] = sprites_from_manasource_tmx(layout_filename)
+      elsif layout_type == "tmx"
+        @tile_cache[layout_type][layout_filename] = sprites_from_tmx(layout_filename)
+      else
+        raise "A TMX location must have a known type of layout (tmx or manasource), not #{layout_type.inspect}!"
+      end
+
+      @tile_cache[layout_type][layout_filename]
     end
-    spritesheet[:cyclic_animations] = animations_from_tilesets tiles.tilesets
-
-    spritesheet[:properties] = spritesheet[:images].map { |i| i[:properties] }.inject({}, &:merge)
-    spritesheet[:name] = spritesheet[:images].map { |i| i[:tileset_name] }.join("/")
-    spritestack[:spritesheet] = spritesheet[:name]
-
-    spritestack[:layers] = tiles.layers.map do |layer|
-      data = layer.data.each_slice(layer.width).to_a
-      {
-        name: layer.name,
-        data: data,
-        visible: layer.visible,
-        opacity: layer.opacity,
-        offsetx: layer.offsetx,  # Currently unused
-        offsety: layer.offsety,  # Currently unused
-        properties: layer.properties,
-      }
+
+    private
+
+    # This is to support TMX files for ManaSource, ManaWorld, Land of
+    # Fire, Source of Tales and other Mana Project games. It can't be
+    # perfect since there's some variation between them, but it can
+    # follow most major conventions.
+    #
+    # Load a TMX file and calculate additional information like
+    # animations from the given properties. Assume this TMX file obeys
+    # ManaSource conventions such as fields for exits and names for
+    # layers.
+    #
+    # @since 0.1.0
+    def sprites_from_manasource_tmx(filename)
+      entry = sprites_from_tmx filename
+
+      stack_layers = entry["map"]["layers"].select { |layer| layer["type"] == "tilelayer" }
+
+      # Remove the collision layer, add as separate collision top-level entry
+      collision_index = stack_layers.index { |l| l["name"].downcase == "collision" }
+      collision_layer = stack_layers.delete_at collision_index if collision_index
+
+      # Some games make this true/false, others have separate visibility
+      # or swimmability in it. In general, we'll just expose the data.
+      entry["collision"] = collision_layer["data"] if collision_layer
+
+      # Remove the heights layer, add as separate heights top-level entry
+      heights_index = stack_layers.index { |l| ["height", "heights"].include?(l["name"].downcase)  }
+      heights_layer = stack_layers.delete_at heights_index if heights_index
+      entry["heights"] = heights_layer
+
+      fringe_index = stack_layers.index { |l| l["name"].downcase == "fringe" }
+      raise ::Demiurge::Errors::TmxFormatError.new("No Fringe layer found in ManaSource TMX File #{filename.inspect}!", "filename" => filename) unless fringe_index
+      stack_layers.each_with_index do |layer, index|
+        # Assign a Z value based on layer depth, with fringe = 0 as a special case
+        layer["z"] = (index - fringe_index) * 10.0
+      end
+
+      entry
     end
 
-    objects = tiles.object_groups.flat_map { |og| og.objects.to_a }.map(&:to_h)
+    # Load a TMX file and JSONify it. This includes its various
+    # tilesets, such as embedded tilesets and TSX files.  Do not
+    # assume this TMX file obeys any particular additional conventions
+    # beyond basic TMX format.
+    #
+    # @since 0.1.0
+    def sprites_from_tmx(filename)
+      cache_entry = {}
+
+      # This recursively loads things like tileset .tsx files, so we
+      # change to the root dir.
+      Dir.chdir(@root_dir) do
+        tmx_map = Tmx.load filename
+        filename.sub!(/\.tmx\Z/, ".json")
+        cache_entry["map"] = MultiJson.load(tmx_map.export_to_string(:filename => filename, :format => :json))
+      end
 
-    { filename: filename, tmx_name: File.basename(filename).split(".")[0], spritesheet: spritesheet, spritestack: spritestack, objects: objects }
-  end
+      tiles = cache_entry["map"]
+      cache_entry["tilesets"] = tiles["tilesets"]
 
-  # Find the animations included in the TMX file
-  def self.animations_from_tilesets tilesets
-    tilesets.flat_map do |tileset|
-      (tileset.tiles || []).map do |tile|
-        p = tile["properties"]
-        if p && p["animation-frame0"]
-          section = 0
-          anim = []
-
-          while p["animation-frame#{section}"]
-            section_hash = {
-              frame: p["animation-frame#{section}"].to_i + tileset[:firstgid],
-              duration: p["animation-delay#{section}"].to_i
-            }
-            anim.push section_hash
-            section += 1
+      # Add entries to the top-level cache entry, but not inside the "map" structure
+      cache_entry["tmx_name"] = File.basename(filename).split(".")[0]
+      cache_entry["name"] = tiles["name"] || cache_entry["tmx_name"]
+      cache_entry["filename"] = filename
+      cache_entry["dir"] = filename.split("/")[0..-2].join(".")
+      cache_entry["animations"] = animations_from_tilesets cache_entry["tilesets"]
+      cache_entry["objects"] = tiles["layers"].flat_map { |layer| layer["objects"] || [] }
+
+      # Copy most-used properties into top-level cache entry
+      ["width", "height", "tilewidth", "tileheight"].each do |property|
+        cache_entry[property] = tiles[property]
+      end
+
+      cache_entry
+    end
+
+    # Extract the animations included in the TMX file
+    #
+    # @since 0.1.0
+    def animations_from_tilesets tilesets
+      tilesets.flat_map do |tileset|
+        (tileset["tiles"] || []).map do |tile|
+          p = tile["properties"]
+          if p && p["animation-frame0"]
+            section = 0
+            anim = []
+
+            while p["animation-frame#{section}"]
+              section_hash = {
+                "frame" => p["animation-frame#{section}"].to_i + tileset[:firstgid],
+                "duration" => p["animation-delay#{section}"].to_i
+              }
+              anim.push section_hash
+              section += 1
+            end
+            { "tile_anim_#{tile["id"].to_i + tileset[:firstgid]}" => anim }
+          else
+            nil
           end
-          { "tile_anim_#{tile["id"].to_i + tileset[:firstgid]}".to_sym => anim }
-        else
-          nil
-        end
-      end.compact
-    end.inject({}, &:merge)
+        end.compact
+      end.inject({}, &:merge)
+    end
   end
-
 end

data/lib/demiurge/version.rb

@@ -1,4 +1,4 @@
 module Demiurge
   # Current version of Demiurge
-  VERSION = "0.2.0"
+  VERSION = "0.4.0"
 end

data/lib/demiurge/zone.rb

@@ -74,35 +74,5 @@ module Demiurge
       end
       intentions
     end
-
-    # Returns an array of position strings for positions adjacent to
-    # the one given. In some Zones this won't be meaningful. But for
-    # most "plain" zones, this gives possibilities of where is
-    # moveable for simple AIs.
-    #
-    # @return [Array<String>] Array of position strings
-    # @since 0.0.1
-    def adjacent_positions(pos, options = {})
-      []
-    end
-  end
-
-  # In a RoomZone, locations are simple: you are in a Location, just
-  # one at once, and exits allow movement between them. This is
-  # similar to old MUDs, as well as games that present a store or
-  # conversation as a separate screen that takes over your interface.
-  #
-  # @since 0.0.1
-  class RoomZone < Zone
-  end
-
-  # In a TileZone, each Location is permitted to contain a coordinate
-  # grid of sub-locations.  A given entity occupies one or more
-  # sub-locations, but can't really be "in between" those
-  # coordinates. Most frequently, objects take up a single
-  # sub-location, or a small rectangle of them.
-  #
-  # @since 0.0.1
-  class TileZone < Zone
   end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: demiurge
 version: !ruby/object:Gem::Version
-  version: 0.2.0
+  version: 0.4.0
 platform: ruby
 authors:
 - Noah Gibbs
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-01-05 00:00:00.000000000 Z
+date: 2018-01-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: multi_json