joybox 1.0.0 → 1.1.0

data/motion/joybox/physics/world.rb

@@ -3,29 +3,41 @@ module Joybox
 
     class World < B2DWorld
 
-      def self.defaults
+      extend Joybox::Common::Initialize
+
+      alias_method :bodies, :bodyList
+      alias_method :allows_sleeping?, :allowsSleeping
+      alias_method :allows_sleeping=, :setAllowsSleeping
+      alias_method :proxy_count, :proxyCount
+      alias_method :body_count, :bodyCount
+      alias_method :joint_count, :jointCount
+      alias_method :contact_count, :contactCount
+      alias_method :tree_height, :treeHeight
+      alias_method :tree_balance, :treeBalance
+      alias_method :tree_quality, :treeQuality
+      alias_method :locked?, :isLocked
+      alias_method :auto_clear_forces?, :autoClearForces
+      alias_method :auto_clear_forces=, :setAutoClearForces
+      alias_method :create_body, :createBody
+      alias_method :clear_forces, :clearForces
+      alias_method :draw_debug_data, :drawDebugData
+      alias_method :continuous_physics, :continuousPhysics
+
+      def defaults
         {
           gravity: [0, 0],
-          allows_sleeping: true,
-          continuous_physics: true
+          allows_sleeping: true
         }
       end
 
-
-      def self.new(options)
-
+      def initialize(options = {})
         options = options.nil? ? defaults : defaults.merge!(options)
 
-        world = World.alloc.init
-
-        world.gravity = options[:gravity]
-        world.allowsSleeping = options[:allows_sleeping]
-        world.continuousPhysics = options[:continuous_physics]
-
-        world
+        init
+        self.gravity = options[:gravity]
+        self.allowsSleeping = options[:allows_sleeping]
       end
 
-
       def step_defaults
         {
           velocity_interactions: 8,
@@ -33,44 +45,103 @@ module Joybox
         }
       end
 
-
       def step(options = {})
-
         options = options.nil? ? step_defaults : step_defaults.merge!(options)
 
         stepWithDelta(options[:delta],
-          velocityInteractions: options[:velocity_interactions],
-          positionInteractions: options[:position_interactions])
+                      velocityInteractions: options[:velocity_interactions],
+                      positionInteractions: options[:position_interactions])
       end
 
-
       def new_body(options = {}, &block)
         body = Body.new(self, options)
         body.instance_eval(&block) if block
         body
       end
 
+      def destroy_body(body)
+        destroyBody(body)
+        @listening_sprites.delete(body[:sprite]) unless @listening_sprites.nil?
+      end
 
-      def setup_collision_listener
+      def should_collide(&block)
+        @should_collide = block
 
-        @contact_listener = B2DContactListener.new
-        addContactListener(@contact_listener)
+        @contact_filter = B2DContactFilter.new;
+        @contact_filter.shouldCollide = lambda do |first_fixture, second_fixture|
+          @should_collide.call(first_fixture, second_fixture)
+        end
+
+        setContactFilter(@contact_filter)
+      end
 
-        @listening_bodies = Hash.new
+      def setup_collision_listener
+        @contact_listener = B2DContactListener.new
+        setContactListener(@contact_listener)
+
+        @listening_sprites = Hash.new
+
+        @contact_listener.beginContact = lambda do |first_body, second_body, is_touching|
+          # TODO: Find a better way to do this assignment
+          collision = [first_body, second_body] if @listening_sprites.has_key? first_body[:sprite]
+          collision = [second_body, first_body] if @listening_sprites.has_key? second_body[:sprite]
+  
+          unless collision.nil?
+            object = collision[1][:sprite].nil? ? collision[1] : collision[1][:sprite]
+            @listening_sprites[collision[0][:sprite]].call(object, is_touching)
+          end
+
+          @on_collision.call(first_body, second_body, is_touching) unless @on_collision.nil?
+        end
+      end
 
-        @contact_listener.beginContact = lambda { | first_body, second_body, is_touching |
+      def when_collide(sprite, &block)
+        setup_collision_listener unless @contact_listener
+        @listening_sprites[sprite] = block
+      end
 
-          @listening_bodies[first_body].call(second_body, is_touching) if @listening_bodies.include? first_body
-          @listening_bodies[second_body].call(first_body, is_touching) if @listening_bodies.include? second_body
-        }
+      def on_collision(&block)
+        setup_collision_listener unless @contact_listener
+        @on_collision = block
       end
 
+      def on_fixture_destroyed(&block)
+        @when_fixture_destroyed = block
 
-      def when_collide(body, &block)
+        @destruction_listener = B2DDestructionListener.new;
+        @destruction_listener.fixtureSayGoodbye = lambda do |fixture|
+          @when_fixture_destroyed.call(fixture)
+        end
 
-        setup_collision_listener unless @contact_listener
+        setDestructionListener(@destruction_listener)
+      end 
+
+      def query(options = {}, &block)
+        @query = block
+        @query_callback = B2DQueryCallback.new
+        @query_callback.reportFixture = lambda do |fixture|
+          @query.call(fixture)
+        end
+
+        aabb = AABB.new
+        aabb.lower_bound = CGPointMake(options[:lower_bound][0], options[:lower_bound][1])
+        aabb.upper_bound = CGPointMake(options[:upper_bound][0], options[:upper_bound][1])
+        queryAABBWithCallback(@query_callback, andAABB:aabb)
+      end
+
+      def ray_cast(options = {}, &block)
+        @ray_cast = block
+        @ray_cast_callback = B2DRayCastCallback.new
+        @ray_cast_callback.reportFixture = lambda do |fixture, point, normal, fraction|
+          @ray_cast.call(fixture, point.from_pixel_coordinates, normal, fraction)
+        end
+
+        first_point = CGPointMake(options[:first_point][0], options[:first_point][1])
+        second_point = CGPointMake(options[:second_point][0], options[:second_point][1])
 
-        @listening_bodies[body] = block
+        rayCastWithCallback(@ray_cast_callback,
+                            andPoint1:first_point.from_pixel_coordinates,
+                            andPoint2:second_point.from_pixel_coordinates)
       end
 
     end

data/motion/joybox/tmx/object_layer.rb

@@ -0,0 +1,12 @@
+Joybox::TMX::ObjectLayer = CCTMXObjectGroup
+
+class CCTMXObjectGroup
+  
+  alias_method :name, :groupName
+  alias_method :offset, :positionOffset
+
+  def [](key)
+    objectNamed(key)
+  end
+
+end

data/motion/joybox/tmx/tile_layer.rb

@@ -0,0 +1,74 @@
+Joybox::TMX::TileLayer = CCTMXLayer
+
+class CCTMXLayer
+
+  include Joybox::Common
+
+  alias_method :name, :layerName
+  alias_method :name=, :setLayerName
+  alias_method :tiles_size, :layerSize
+  alias_method :tiles_size=, :setLayerSize
+  alias_method :map_of_tiles, :tiles
+  alias_method :map_of_tiles=, :setTiles
+  alias_method :tile_set, :tileset
+  alias_method :tile_set=, :setTileset
+  alias_method :orientation, :layerOrientation
+  alias_method :orientation=, :setLayerOrientation
+  alias_method :release_map, :releaseMap
+  alias_method :setup_tiles, :setupTiles
+
+  Orthogonal = 0
+  Hexagonal = 1
+  Isometric = 2
+
+  def tile_size
+    return mapTileSize unless Device.retina?
+    return mapTileSize.half if Device.retina?
+  end
+
+  def size
+    [layerSize.width * tile_size.width, layerSize.height * tile_size.height].to_size
+  end
+
+  def point_for_coordinate(coordinate)
+    positionAt(coordinate)
+  end
+
+  def coordinate_for_point(point)
+    point = point.to_point unless point.is_a? (CGPoint)
+    x = point.x / tile_size.width
+    y = (size.height - point.y) / tile_size.height
+    [x.floor, y.floor].to_point
+  end
+
+  def sprite_at(point)
+    coordinate = coordinate_for_point(point)
+    tileAt(coordinate)
+  end
+
+  def tile_type_at(point)
+    coordinate = coordinate_for_point(point)
+    tileGIDAt(coordinate)
+  end
+
+  def remove_tile_at(point)
+    coordinate = coordinate_for_point(point)
+    removeTileAt(coordinate)
+  end
+
+  def set_tile_type_at(point, tile_type)
+    coordinate = coordinate_for_point(point)
+    setTileGID(tile_type, at: coordinate)
+  end
+
+  def [](point)
+    coordinate = coordinate_for_point(point)
+    tileGIDAt(coordinate)
+  end
+
+  def []=(point, tile_type)
+    coordinate = coordinate_for_point(point)
+    setTileGID(tile_type, at: coordinate)
+  end
+
+end

data/motion/joybox/tmx/tile_map.rb

@@ -0,0 +1,112 @@
+module Joybox
+  module TMX
+
+    class ObjectLayers
+      def initialize(map); @map = map; end
+      def [](key); @map.objectGroupNamed(key); end
+    end
+
+    class TileLayers
+      def initialize(map); @map = map; end
+      def [](key); @map.layerNamed(key); end
+    end
+
+    class Tiles
+      def initialize(map); @map = map; end
+      def [](key); @map.propertiesForGID(key) || Hash.new; end
+    end
+
+    class TileMap < CCTMXTiledMap
+
+      include Joybox::Common
+      extend Joybox::Common::Initialize
+
+      alias_method :tiles_size, :mapSize
+      alias_method :orientation, :mapOrientation
+      alias_method :objects, :objectGroups
+      alias_method :objects=, :setObjectGroups
+      alias_method :properties_for_tile_type, :propertiesForGID
+
+      Orthogonal = 0
+      Hexagonal = 1
+      Isometric = 2
+
+      def initialize(options = {})
+        # Todo print error message on the console
+        return unless [:file_name, :xml].any? { |k| options.has_key? k }
+
+        initWithTMXFile(options[:file_name]) unless options.has_key? :xml
+        initWithXML(options[:xml], resourcePath: options[:resource_path]) unless options.has_key? :file_name
+      end
+
+      def object(query)
+        keys = query.split('#')
+        key = keys.shift
+
+        layer = objectGroupNamed(key) unless key.nil?
+        return layer unless key = keys.shift
+        object = layer[key]
+        return object unless key = keys.shift
+
+        if key.casecmp(:position)
+          position = [object[:x], object[:y]].to_point
+          position = position.half if Device.retina?
+          position
+        else
+          object[key]
+        end
+      end
+
+      def tile_layers
+        TileLayers.new(self)
+      end
+
+      def object_layers
+        ObjectLayers.new(self)
+      end
+
+      def tiles
+        Tiles.new(self)
+      end
+
+      def tile_size
+        return tileSize unless Device.retina?
+        return tileSize.half if Device.retina?
+      end
+
+      def size
+        [mapSize.width * tile_size.width, mapSize.height * tile_size.height].to_size
+      end
+
+      def bounding_box
+        [position.x, position.y, size.width, size.height].to_rect
+      end
+
+      def contains_point?(point)
+        point = point.to_point unless point.is_a? (CGPoint)
+        CGRectContainsPoint(bounding_box, point)
+      end
+
+      def coordinate_for_point(point)
+        point = point.to_point unless point.is_a? (CGPoint)
+        x = point.x / tile_size.width
+        y = (size.height - point.y) / tile_size.height
+        [x.floor, y.floor].to_point
+      end
+
+      def step_by(position, new_position)
+        delta =  new_position - position
+        if delta.x.abs > delta.y.abs
+          position.x += tile_size.width if delta.x > 0
+          position.x -= tile_size.width unless delta.x > 0
+        else
+          position.y += tile_size.height if delta.y > 0
+          position.y -= tile_size.height unless delta.y > 0
+        end
+        position
+      end
+
+    end
+    
+  end
+end

data/motion/joybox/tmx/tile_set.rb

@@ -0,0 +1,26 @@
+Joybox::TMX::TileSet = CCTMXTilesetInfo
+
+class CCTMXTilesetInfo
+  
+  include Joybox::Common
+  
+  alias_method :first_tile_type, :firstGid
+  alias_method :first_tile_type, :setFirstGid
+  alias_method :image_file_name, :sourceImage
+  alias_method :image_file_name=, :setSourceImage
+  alias_method :image_size, :imageSize
+  alias_method :image_size=, :setImageSize
+  alias_method :tile_offset, :tileOffset
+  alias_method :tile_offset=, :setTileOffset
+  alias_method :anchor_point, :tileAnchorPoint
+
+  def tile_size
+    return tileSize unless Device.retina?
+    return tileSize.half if Device.retina?
+  end
+
+  def rect_for_tile_type(tile_type)
+    rectForGID(tile_type)
+  end
+
+end

data/motion/joybox/tmx/tmx.rb

@@ -0,0 +1,16 @@
+module Joybox
+  module TMX
+    
+    include Joybox::Common
+
+    def center_at(position)
+      x = [position.x, Screen.half_width].max
+      y = [position.y, Screen.half_height].max
+      x = [x, @tile_map.size.width - Screen.half_width].min
+      y = [y, @tile_map.size.height - Screen.half_height].min
+
+      self.position = Screen.center - [x, y].to_point
+    end
+
+  end
+end

data/motion/joybox/ui/label.rb

@@ -3,33 +3,61 @@ module Joybox
 
     class Label < CCLabelTTF
 
+      extend Joybox::Common::Initialize
+
       alias_method :text=, :setString
       alias_method :set_text, :setString
-
-      def self.defaults
+      alias_method :text, :string
+      alias_method :alignment, :horizontalAlignment
+      alias_method :alignment=, :setHorizontalAlignment
+      alias_method :vertical_alignment, :verticalAlignment
+      alias_method :vertical_alignment=, :setVerticalAlignment
+      alias_method :font_name, :fontName
+      alias_method :font_name=, :setFontName
+      alias_method :font_size, :fontSize
+      alias_method :font_size=, :setFontSize
+
+      TextAlignmentLeft = 0
+      TextAlignmentCenter = 1
+      TextAlignmentRight = 2
+
+      TextAlignmentTop = 0
+      TextAlignmentBottom = 2
+
+      LineBreakWordWrap = 0
+      LineBreakCharacterWrap = 1
+      LineBreakClip = 2
+      LineBreakHeadTruncation = 3
+      LineBreakTailTruncation = 4
+      LineBreakMiddleTruncation = 5
+
+      def defaults
         {
           text: '',
+          dimensions: CGSizeZero,
+          alignment: TextAlignmentCenter,
+          vertical_alignment: TextAlignmentTop,
           font_name: 'Marker Felt',
-          font_size: 12
+          font_size: 12,
+          line_break_mode: LineBreakWordWrap
         }
       end
 
-
-      def self.new(options = {})
-
+      def initialize(options = {})
         options = options.nil? ? defaults : defaults.merge!(options)
 
-        label = Label.labelWithString(options[:text], 
-                                      fontName: options[:font_name], 
-                                      fontSize: options[:font_size])
-
-        label.position = options[:position] if options.has_key? (:position)
-        label.color = options[:color] if options.has_key? (:color)
-
-        label
+        self.initWithString(options[:text], 
+                            fontName: options[:font_name], 
+                            fontSize: options[:font_size],
+                            dimensions: options[:dimensions],
+                            hAlignment: options[:alignment],
+                            vAlignment: options[:vertical_alignment],
+                            lineBreakMode: options[:line_break_mode])
+        
+        self.position = options[:position] if options.has_key? (:position)
+        self.color = options[:color] if options.has_key? (:color)
       end
-
     end
 
   end
-end
+end