metro 0.3.4 → 0.3.5

data/lib/metro/models/ui/space.rb

@@ -0,0 +1,152 @@
+module Metro
+  module UI
+
+    #
+    # Adds a 2D Physics Space to the Scene
+    #
+    # @see http://beoran.github.io/chipmunk/
+    #
+    # @example Adding a space to the scene
+    #
+    #     class MainScene < GameScene
+    #       draw :space, model: "metro::ui::space"
+    #       draw :hero, position: Game.center
+    #
+    #       def show
+    #         space.add_object(hero)
+    #         space.gravity_affects(hero)
+    #       end
+    #
+    #       def update
+    #         space.step
+    #         space.clean_up
+    #       end
+    #     end
+    #
+    # Adding a space to a scene allows for objects with a
+    # `body` and `shape` to be added and affected by
+    # collisions and gravity.
+    #
+    class Space < Model
+
+      # @attribute
+      # Amount of viscous damping to apply to the space. A value of 0.9 means
+      # that each body will lose 10% of it’s velocity per second. Defaults to 1.
+      # Like gravity can be overridden on a per body basis.
+      property :damping, default: 0.5
+
+      # @attribute
+      # Each update cycle the space will perform a number of steps equal to
+      # this value. The higher the value the better the resolution will be for
+      # collisions between objects, the lower the value the sloppier the
+      # resolution will be for collisions.
+      property :sampling_per_update, default: 6
+
+      # @attribute
+      # The amount of time the space should be stepped. This step value is
+      # multiplied by the #sampling_per_update value.
+      property :delta, default: (1.0/60.0)
+
+      # @attribute
+      # The amount of gravitationl force to apply to bodies within the space.
+      # This is by default a force at the center of the object applied downward.
+      property :gravitational_forces, type: :array,
+        default: [ CP::Vec2.new(0,1000), CP::Vec2.new(0,0) ]
+
+      # Add a single object to the space. This object will have a reference
+      # stored here and it's body and shape added to the space so that it
+      # collide with other objects added to the space.
+      #
+      # @param [Object<#body,#shape>] object add a new object to the space. The
+      #   object has a `body` and a `shape`.
+      #
+      def add_object(object)
+        space_objects.push(object)
+        space.add_body object.body
+        space.add_shape object.shape
+      end
+
+      # Remove a single object from the space. This object will remove the
+      # reference stored within the space as well as removing the body and
+      # shape that was added to the space.
+      #
+      def remove_object(object)
+        space_objects.delete(object)
+        space.remove_body(object.body)
+        space.remove_shape(object.shape)
+      end
+
+      # Add multiple objects to the space.
+      # @see #add_object
+      def add_objects(objects)
+        Array(objects).each {|object| add_object(object) }
+      end
+
+      # When the first shape collides with the second shape perform
+      # the following block of code.
+      def collision_between(first,second,&block)
+        space.add_collision_func(first,second,&block)
+      end
+
+      # This method allows the space to declare which objects are effected by
+      # gravity during their time within the space.
+      #
+      # @note for the object to be affected by gravity it still needs to be
+      #   added to the space first.
+      #
+      def gravity_affects(object)
+        victims_of_gravity.push object
+      end
+
+      # Access to the raw Chimpmunk Space object
+      # @see http://beoran.github.io/chipmunk/#Space
+      attr_reader :space
+
+
+      # This method needs to be called each update loop. This will update and
+      # move all the objects currently within the space and start the resolution
+      # of collisions.
+      def step
+        sampling_per_update.to_i.times { space.step(delta) }
+      end
+
+      # This method needs to be called each update loop. This will reset all
+      # the forces on the existing objects. This essentially keeps them from
+      # accelerating out of control. It will also rebuild the shape positioning
+      # for collisions. In a static frame, the level does not scroll, the
+      # rebuiling is not necessary, but for levels where it moves this is
+      # important.
+      #
+      def clean_up
+        space_objects.each {|object| object.body.reset_forces }
+        space.rehash_static
+      end
+
+      def show
+        @space = CP::Space.new
+        @space.damping = damping
+      end
+
+      def update
+        apply_gravity_to victims_of_gravity
+      end
+
+      # @return [Array<Object>] a list of objects currently mantained by the
+      #   space.
+      def space_objects
+        @space_objects ||= []
+      end
+
+      # @return [Array<Object>] all of the objects that are affected by gravity
+      def victims_of_gravity
+        @victims_of_gravity ||= []
+      end
+
+      # Apply gravity to the specified objects.
+      def apply_gravity_to(objects)
+        objects.each {|object| object.body.apply_force *gravitational_forces }
+      end
+
+    end
+  end
+end

data/lib/metro/models/ui/sprite.rb

@@ -50,7 +50,7 @@ module Metro
 
       # @return [Float] the left-most x position of the sprite
       def left
-        x - width * center_x
+        x - width * center_x * x_factor
       end
 
       # @return [Float] the right-most x position of the sprite
@@ -60,7 +60,7 @@ module Metro
 
       # @return [Float] the top-most y position of the sprite
       def top
-        y - height * center_y
+        y - height * center_y * y_factor
       end
 
       # @return [Float] the bottom-most y position of the sprite

data/lib/metro/models/ui/tile_map.rb

@@ -0,0 +1,133 @@
+module Metro
+  module UI
+    #
+    # Draws a TileMap within the scene.
+    #
+    # @example Creating a tile map with a Tiled TMX file
+    #
+    #     class MainScene < GameScene
+    #       draw :tile_map, model: "metro::ui::tile_map",
+    #         file: "first_level.tmx"
+    #     end
+    #
+    # The viewport, or camera, of the TileMap is static but
+    # can be set to follow a particular actor within the scene.
+    # The viewport will continue to move according to the position
+    # of the specified actor.
+    #
+    # @example Creating a tile map that will follow the hero
+    #
+    #     class MainScene < GameScene
+    #       draw :hero
+    #       draw :tile_map, model: "metro::ui::tile_map",
+    #         file: "first_level.tmx", follow: :hero
+    #     end
+    #
+    #
+    class TileMap < ::Metro::Model
+
+      # @attribute
+      # The Tiled File (*.tmx) that will be parsed and loaded for the tile map
+      property :file, type: :text
+
+      # @attribute
+      # The actor that the viewport of the scene will follow.
+      property :follow, type: :text
+
+      # @attribute
+      # The rotation of each tile within the scene. This is by default
+      # 0 and should likely remain 0.
+      property :rotation
+
+      #
+      # Return the viewport for the map. The default viewport will be
+      # the dimensions of the current Game.
+      #
+      # @return [RectangleBounds] the bounds of the current viewport
+      def viewport
+        @viewport ||= Game.bounds
+      end
+
+      # @attribute
+      # Set the viewport of the map, by default ths viewport will be
+      # the dimensions of the current Game, so this may not be
+      # necessary to set.
+      attr_writer :viewport
+
+      #
+      # @return [TMX::Map] the map object found in the specified TMX file.
+      #
+      def map
+        @map ||= begin
+          map = ::Tmx.load asset_path(file)
+          map.tilesets.each {|tileset| tileset.window = window }
+          map
+        end
+      end
+
+      #
+      # Find objects that match the specified type or by the specified
+      # parameters. If no parameter is provided then all the objects are
+      # returned
+      #
+      # @example Finding all the objects with the type :floor
+      #
+      #    objects(:floor)
+      #
+      # @example Finding all the objects with the name 'tree'
+      #
+      #    objects(name: 'tree')
+      def objects(params=nil)
+        params ? map.objects.find(params) : map.objects
+      end
+
+      def update
+        shift_viewport_to_center_who_we_are_following
+      end
+
+      def draw
+        layers.each {|layer| layer.draw }
+      end
+
+      private
+
+      def layers
+        @layers ||= map.layers.collect do |layer|
+          tml = TileLayer.new
+          tml.extend layer_positioning
+          tml.rotation = rotation
+          tml.viewport = viewport
+          tml.map = map
+          tml.layer = layer
+          tml.tilesets = map.tilesets
+          tml
+        end
+      end
+
+      def layer_positioning
+        { orthogonal: "Metro::Tmx::TileLayer::OrthogonalPositioning",
+          isometric: "Metro::Tmx::TileLayer::IsometricPositioning" }[map.orientation.to_sym].constantize
+      end
+
+      def following
+        scene.send(follow) if follow
+      end
+
+      def shift_viewport_to_center_who_we_are_following
+        return unless following
+
+        diff_x = (following.x - Game.center.x).to_i
+
+        if diff_x >= 1 or diff_x <= -1
+          viewport.shift(Point.at(diff_x,0))
+        end
+
+      end
+
+    end
+  end
+end
+
+require_relative 'tmx/tile_layer'
+require_relative 'tmx/isometric_position'
+require_relative 'tmx/orthogonal_position'

data/lib/metro/models/ui/tmx/isometric_position.rb

@@ -0,0 +1,43 @@
+module Metro
+  module Tmx
+    class TileLayer
+
+      module IsometricPositioning
+
+        def position_of_image(image,row,column)
+          pos_x = x_position(row,column) - (map.tilewidth - image.width)/2
+          pos_y = y_position(row,column) + (map.tileheight - image.height)/2
+          ::Metro::Units::Bounds.new left: pos_x, top: pos_y, right: pos_x + map.tilewidth, bottom: pos_y + map.tileheight
+        end
+
+        def half_tilewidth
+          @half_tilewidth ||= map.tilewidth/2
+        end
+
+        def half_tileheight
+          @half_tileheight ||= map.tileheight/2
+        end
+
+        def start_x
+          @start_x ||= x + map.tilewidth * map.width / 2
+        end
+
+        def x_position(row,column)
+          row_start_x = start_x - half_tilewidth * row
+          row_start_x + half_tilewidth * column
+        end
+
+        def start_y
+          y
+        end
+
+        def y_position(row,column)
+          row_start_y = start_y + half_tileheight * row
+          row_start_y + half_tileheight * column
+        end
+
+      end
+
+    end
+  end
+end

data/lib/metro/models/ui/tmx/orthogonal_position.rb

@@ -0,0 +1,15 @@
+module Metro
+  module Tmx
+    class TileLayer
+
+      module OrthogonalPositioning
+        def position_of_image(image,row,column)
+          pos_x = x + column * map.tilewidth + map.tilewidth / 2
+          pos_y = y + row * map.tileheight + map.tileheight / 2
+          ::Metro::Units::RectangleBounds.new left: pos_x, top: pos_y, right: pos_x + map.tilewidth, bottom: pos_y + map.tileheight/2
+        end
+      end
+
+    end
+  end
+end

data/lib/metro/models/ui/tmx/tile_layer.rb

@@ -0,0 +1,78 @@
+module Metro
+  module UI
+    class TileLayer < ::Metro::Model
+      property :rotation
+
+      attr_accessor :map
+      attr_accessor :layer
+      attr_accessor :tilesets
+      attr_accessor :viewport
+
+      def data
+        layer.data
+      end
+
+      def x
+        viewport.left
+      end
+
+      def y
+        viewport.top
+      end
+
+      def z_order
+        -1
+      end
+
+      def draw
+        tiles_within_viewport.each do |bounds,image|
+          image.draw_rot(bounds.left - x,bounds.top - y,z_order,rotation)
+        end
+      end
+
+      private
+
+      def tiles_within_viewport
+        enlarged_viewport = viewport.enlarge(left: map.tilewidth, right: map.tilewidth, top: map.tileheight, bottom: map.tileheight)
+        tile_bounds.find_all {|bounds,images| enlarged_viewport.intersect?(bounds) }
+      end
+
+      def tile_bounds
+        @tile_bounds ||= build_tiles_index
+      end
+
+      def build_tiles_index
+        data.each_with_index.map do |image_index,position|
+          next if image_index == 0
+          image = tileset_image(image_index)
+          [ position_of_image(image,row(position),column(position)), image ]
+        end.compact
+      end
+
+      def tileset_image(image_index)
+        unless cached_images[image_index]
+          tileset = map.tilesets.find do |t|
+            image_index >= t.firstgid && image_index < t.firstgid + t.images.count
+          end
+          tileset_image_index = image_index - tileset.firstgid
+          cached_images[image_index] = tileset.images[tileset_image_index]
+        end
+
+        cached_images[image_index]
+      end
+
+      def row(position)
+        position / layer.width
+      end
+
+      def column(position)
+        position % layer.width
+      end
+
+      def cached_images
+        @cached_images ||= {}
+      end
+    end
+
+  end
+end

data/lib/metro/models/ui/ui.rb

@@ -9,4 +9,7 @@ require_relative 'model_label'
 require_relative 'model_labeler'
 require_relative 'fps'
 require_relative 'sprite'
+require_relative 'physics_sprite'
 require_relative 'animated_sprite'
+require_relative 'tile_map'
+require_relative 'space'