joybox 1.0.0 → 1.1.0

data/motion/joybox/physics/circle_shape.rb

@@ -0,0 +1,31 @@
+Joybox::Physics::CircleShape = B2DCircleShape
+
+class B2DCircleShape
+
+  extend Joybox::Common::Initialize
+
+  alias_method :vertices_count, :vertexCount
+  alias_method :metric_position, :position
+
+  def initialize(options = {})
+    initWithRadius(options[:radius].from_pixels)
+  end
+
+  def position
+    metric_position.to_pixel_coordinates
+  end
+
+  def support_vertex_index_by_direction(direction)
+    direction = direction.to_point unless direction.is_a? (CGPoint)
+    getSupport(direction.from_pixel_coordinates)
+  end
+
+  def support_vertex_by_direction(direction)
+    direction = direction.to_point unless direction.is_a? (CGPoint)
+    getSupportVertex(direction.from_pixel_coordinates).to_pixel_coordinates
+  end
+
+  def vertex_by_index(index)
+    getVertex(index).to_pixel_coordinates
+  end
+end

data/motion/joybox/physics/edge_shape.rb

@@ -0,0 +1,37 @@
+Joybox::Physics::EdgeShape = B2DEdgeShape
+
+class B2DEdgeShape
+
+  extend Joybox::Common::Initialize
+
+  alias_method :metric_start_point, :startVertex
+  alias_method :metric_end_point, :endVertex
+  alias_method :has_start_adjacent_point?, :hasStartAdjacentVertex
+  alias_method :metric_start_adjacent_point, :startAdjacentVertex
+  alias_method :has_end_adjacent_point?, :hasEndAdjacentVertex
+  alias_method :metric_end_adjacent_point, :endAdjacentVertex
+
+  def initialize(options = {})
+    start_point = CGPointMake(options[:start_point][0], options[:start_point][1])
+    end_point = CGPointMake(options[:end_point][0], options[:end_point][1])
+
+    initWithStartVertex(start_point.from_pixel_coordinates, endVertex: end_point.from_pixel_coordinates)
+  end
+
+  def start_point
+    self.startVertex.to_pixel_coordinates
+  end
+
+  def end_point
+    self.endVertex.to_pixel_coordinates
+  end
+
+  def start_adjacent_point
+    self.startAdjacentVertex.to_pixel_coordinates
+  end
+  
+  def end_adjacent_point
+    self.endAdjacentVertex.to_pixel_coordinates
+  end
+
+end

data/motion/joybox/physics/filter.rb

@@ -0,0 +1,17 @@
+Joybox::Physics::Filter = B2DFilter
+
+class B2DFilter
+
+  alias_method :category_bits, :categoryBits
+  alias_method :category_bits=, :setCategoryBits
+  alias_method :mask_bits, :maskBits
+  alias_method :mask_bits=, :setMaskBits
+  
+  def group_index
+    groupIndex
+  end
+
+  def group_index=(group_index)
+    setGroupIndex(group_index)
+  end
+end

data/motion/joybox/physics/fixture.rb

@@ -0,0 +1,52 @@
+Joybox::Physics::Fixture = B2DFixture
+
+class B2DFixture
+
+  alias_method :sensor?, :isSensor
+  alias_method :mass_data, :massData
+  alias_method :metric_aabb, :aabb
+
+  CircleType = 0
+  EdgeType = 1
+  PolygonType = 2
+  ChainType = 3
+  CountType = 4 
+
+  def filter_data
+    filterData
+  end
+
+  def filter_data=(filter_data)
+    setFilterData(filter_data)
+  end
+
+  def contains_point?(point)
+    point = point.to_point.from_pixel_coordinates
+    testPoint(point)
+  end
+
+  def aabb(options = {})
+    unless [:child_index].all? { |k| options.has_key? k }
+      return # Todo print error message on the console
+    end
+
+    metric_aabb(options[:child_index])
+  end
+
+  def ray_cast(options = {}, &block)
+    unless [:first_point, :second_point, :maximum_fraction, :child_index].all? { |k| options.has_key? k }
+      return # Todo print error message on the console
+    end
+
+    ray_cast_input = RayCastInput.new
+    ray_cast_input.first_point = options[:first_point]
+    ray_cast_input.second_point = options[:second_point]
+    ray_cast_input.maximum_fraction = options[:maximum_fraction]
+
+    ray_cast_output = RayCastOutput.new
+
+    hits = rayCastWithOutput(ray_cast_output, input:ray_cast_input, andChildIndex: options[:child_index])
+    block.call(hits, ray_cast_output.normal, ray_cast_output.fraction)
+  end
+  
+end

data/motion/joybox/physics/mass_data.rb

@@ -0,0 +1,19 @@
+Joybox::Physics::MassData = B2DMassData
+
+class B2DMassData
+
+  alias_method :rotational_inertia, :I
+  alias_method :rotational_inertia=, :setI
+  alias_method :metric_center, :centre
+  alias_method :metric_center=, :setCentre
+
+  def center
+    metric_center.to_pixel_coordinates
+  end
+
+  def center=(center)
+    center = center.to_point unless center.is_a? (CGPoint)
+    self.metric_center = center.from_pixel_coordinates
+  end
+  
+end

data/motion/joybox/physics/physics_sprite.rb

@@ -1,16 +1,14 @@
-# TODO: Revisar el nombre de esto
 module Joybox
-  module Core
+  module Physics
 
-    class PhysicsSprite < Sprite
+    class PhysicsSprite < Joybox::Core::Sprite
 
       attr_accessor :body
 
-      def self.new(options = {})
-        sprite = super 
-        sprite.body = options[:body] if options.include? :body
-
-        sprite
+      def initialize(options = {})
+        super
+        self.body = options.delete(:body) if options.has_key? :body
+        self.body[:sprite] = self
       end
 
       # We need this method to return true, so Cocos2d continue
@@ -19,22 +17,57 @@ module Joybox
         true 
       end
 
+      def position
+        if @body and not self.running_actions?
+          @body.position
+        else
+          super
+        end
+      end
+
       def position=(position)
-        @body.position = position
+        if @body and not self.running_actions?
+          @body.position = position
+        else
+          super
+        end
       end
 
-      def position
-        @body.position.from_pixel_coordinates
+      def rotation
+        if @body and not self.running_actions?
+          @body.rotation
+        else
+          super
+        end
+      end
+
+      def rotation=(rotation)
+        if @body and not self.running_actions?
+          @body.rotation = rotation
+        else
+          super
+        end
+      end
+
+      def run_action(action)
+        callback = Callback.with do 
+          @body.position = self.position unless @body.nil?
+          @body.angle = self.rotation unless @body.nil?
+        end
+        sequence = Sequence.with actions: [action, callback]
+        super(sequence)
+
+        self.position = @body.position unless @body.nil?
       end
 
       def nodeToParentTransform
-        return super if @body.nil?
+        return super if @body.nil? or self.running_actions?
 
         super
         
-        position = @body.position.from_pixel_coordinates
+        position = @body.position
         position = position + anchorPointInPoints if ignoreAnchorPointForPosition
-        angle = @body.angle
+        angle = @body.radian_angle
 
         x = position.x
         y = position.y
@@ -46,10 +79,11 @@ module Joybox
           y = y + sine * -anchorPointInPoints.x + cosine * -anchorPointInPoints.y        
         end
 
-        CGAffineTransformMake(cosine, sine, -sine, cosine, x, y)
+        rotated_transform = CGAffineTransformMake(cosine, sine, -sine, cosine, x, y)
+        CGAffineTransformScale(rotated_transform, self.scaleX, self.scaleY)
       end
 
     end
 
   end
-end
+end

data/motion/joybox/physics/polygon_shape.rb

@@ -0,0 +1,54 @@
+Joybox::Physics::PolygonShape = B2DPolygonShape
+
+class B2DPolygonShape
+
+  extend Joybox::Common::Initialize
+
+  alias_method :vertices_count, :vertexCount
+  alias_method :metric_centroid, :centroid
+  alias_method :metric_vertices, :vertices
+  alias_method :metric_normals, :normals
+
+  def initialize(options = {})
+    initialize_with_box(options) if options.has_key? :box
+    initialize_with_vertices(options) if options.has_key? :vertices
+  end
+
+  def initialize_with_box(options = {})
+    half_width = (options[:box][0]).from_pixels
+    half_height = (options[:box][1]).from_pixels
+
+    initWithHalfWidth(half_width, 
+                      andHalfHeight: half_height) unless options.has_key? :center
+    initWithHalfWidth(half_width, 
+                      halfHeight: half_height, 
+                      center: options[:center], 
+                      andAngle: options[:angle]) if options.has_key? :center
+  end
+
+  def initialize_with_vertices(options = {})
+    vertices = Pointer.new(CGPoint.type, options[:vertices].size)
+    options[:vertices].each_with_index do |vertex, index|
+      vertices[index] = CGPointMake(vertex[0], vertex[1]).from_pixel_coordinates
+    end
+
+    initWithVertices(vertices, andVertexCount: options[:vertices].size)
+  end
+
+  def centroid
+    metric_centroid.to_pixel_coordinates
+  end
+
+  def vertices
+    Array.new(vertices_count){ |i| metric_vertices[i].to_pixel_coordinates }
+  end
+
+  def normals
+    Array.new(vertices_count){ |i| metric_normals[i].to_pixel_coordinates }
+  end
+
+  def vertex_by_index(index)
+    getVertex(index).to_pixel_coordinates
+  end
+
+end

data/motion/joybox/physics/profile.rb

@@ -0,0 +1,14 @@
+Joybox::Physics::Profile = B2DProfile
+
+class B2DProfile
+
+  alias_method :solve_init, :solveInit
+  alias_method :solve_init=, :setSolveInit
+  alias_method :solve_velocity, :solveVelocity
+  alias_method :solve_velocity=, :setSolveVelocity
+  alias_method :solve_position, :solvePosition
+  alias_method :solve_position=, :setSolvePosition
+  alias_method :solve_TOI, :solveTOI
+  alias_method :solve_TOI=, :setSolveTOI
+  
+end

data/motion/joybox/physics/ray_cast_input.rb

@@ -0,0 +1,30 @@
+Joybox::Physics::RayCastInput = B2DRayCastInput
+
+class B2DRayCastInput
+
+  alias_method :metric_first_point, :point1
+  alias_method :metric_first_point=, :setPoint1
+  alias_method :metric_second_point, :point2
+  alias_method :metric_second_point=, :setPoint2
+  alias_method :maximum_fraction, :maxFraction
+  alias_method :maximum_fraction=, :setMaxFraction
+
+  def first_point
+    metric_first_point.to_pixel_coordinates
+  end
+
+  def first_point=(point)
+    point = point.to_point unless point.is_a? (CGPoint)
+    self.metric_first_point = point.from_pixel_coordinates
+  end
+
+  def second_point
+    metric_second_point.to_pixel_coordinates
+  end
+
+  def second_point=(point)
+    point = point.to_point unless point.is_a? (CGPoint)
+    self.metric_second_point = point.from_pixel_coordinates
+  end
+  
+end

data/motion/joybox/physics/ray_cast_output.rb

@@ -0,0 +1,17 @@
+Joybox::Physics::RayCastOutput = B2DRayCastOutput
+
+class B2DRayCastOutput
+
+  alias_method :metric_normal, :normal
+  alias_method :metric_normal=, :setNormal
+
+  def normal
+    metric_normal.to_pixel_coordinates
+  end
+
+  def normal=(normal)
+    normal = normal.to_point unless normal.is_a? (CGPoint)
+    self.metric_normal = normal.from_pixel_coordinates
+  end
+
+end

data/motion/joybox/physics/shape.rb

@@ -0,0 +1,61 @@
+Joybox::Physics::Shape = B2DMassData
+
+class B2DShape
+
+  alias_method :child_count, :childCount
+  alias_method :metric_radius, :radius
+
+  CircleType = 0
+  EdgeType = 1
+  PolygonType = 2
+  ChainType = 3
+  CountType = 4 
+
+  def radius
+    metric_radius.to_pixels
+  end
+
+  def contains_point?(point)
+    point = point.to_point unless point.is_a? (CGPoint)
+    testPointWithTransform(Transform.new, andPoint: point.from_pixel_coordinates)
+  end
+
+  def ray_cast(options = {}, &block)
+    unless [:first_point, :second_point, :maximum_fraction, :child_index].all? { |k| options.has_key? k }
+      return # Todo print error message on the console
+    end
+
+    ray_cast_input = RayCastInput.new
+    ray_cast_input.first_point = options[:first_point]
+    ray_cast_input.second_point = options[:second_point]
+    ray_cast_input.maximum_fraction = options[:maximum_fraction]
+
+    ray_cast_output = RayCastOutput.new
+
+    hits = rayCastWithOutput(ray_cast_output, 
+                             input: ray_cast_input, 
+                             transform: Transform.new, 
+                             andChildren: options[:child_index])
+    block.call(hits, ray_cast_output.normal, ray_cast_output.fraction)
+  end
+  
+  def compute_aabb(options = {})
+    unless options.has_key? :child_index
+      return # Todo print error message on the console
+    end
+    
+    aabb = AABB.new
+    computeAABB(aabb, withTransform: Transform.new, andChildIndex: options[:child_index])
+    aabb
+  end
+
+  def compute_mass(options = {})
+    unless options.has_key? :density
+      return # Todo print error message on the console
+    end
+
+    mass_data = MassData.new
+    computeMass(mass_data, withDensity: options[:density])
+    mass_data
+  end
+end

data/motion/joybox/physics/transform.rb

@@ -0,0 +1,17 @@
+Joybox::Physics::Transform = B2DTransform
+
+class B2DTransform
+
+  alias_method :metric_position, :point
+  alias_method :metric_position=, :setPoint
+
+  def position
+    metric_position.to_pixel_coordinates
+  end
+
+  def position=(point)
+    point = point.to_point unless point.is_a? (CGPoint)
+    self.metric_position = point.from_pixel_coordinates
+  end
+
+end