joybox 1.0.0 → 1.1.0

data/motion/joybox/joybox.rb

@@ -7,11 +7,19 @@ module Joybox
   include Joybox::UI
   include Joybox::Macros
   include Joybox::Physics
-  
+  include Joybox::Audio
+
+  attr_accessor :random
+
   module_function
 
   def director
     Director.sharedDirector
   end
 
+  def generate_seed
+    @random ||= Random.new
+    @random.rand(10...100)
+  end
+
 end

data/motion/joybox/macros.rb

@@ -51,7 +51,7 @@ module Joybox
       jbp(-point.y, point.x)
     end
 
-    # Perpendicular of v, rotated 90 degrees clockwise
+    # Perpendicular of point, rotated 90 degrees clockwise
     def jbpRPerp(point)
       jbp(point.y, -point.x)
     end
@@ -73,7 +73,7 @@ module Joybox
           first_point.y * second_point.x - first_point.x * second_point.y)
     end
 
-    # Square lenght of a CGPoint
+    # Square lenght of a point
     def jbpLengthSQ(point)
       jbpDot(point, point)
     end
@@ -93,7 +93,7 @@ module Joybox
       jbpLength(jbpSub(first_point, second_point))
     end
 
-    # Point multiplied to a lenght of 1
+    # Point multiplied to a length of 1
     def jbpNormalize(point)
       jbpMult(point, 1.0 / jbpLength(point))
     end
@@ -105,7 +105,7 @@ module Joybox
 
     # Converts vector to radians
     def jbpToAngle(point)
-      Math.atan2(v.y, v.x)
+      Math.atan2(point.y, point.x)
     end
 
     # Clamp a value between from and to
@@ -127,7 +127,7 @@ module Joybox
           clamp(point.y, minimum_inclusive.y, maximum_inclusive.y))
     end
 
-    # CGSize from a CGPoint
+    # CGPoint from a CGSize
     def jbpFromSize(size)
       jbp(size.width, size.height)
     end
@@ -163,8 +163,8 @@ module Joybox
       first_point = jbpNormalize(first_point)
       second_point = jbpNormalize(second_point)
 
-      angle = Math.atan2(first_point.x * second_point.y - first_point.y * second_point.x),
-        jbpDot(first_point, second_point)
+      angle = Math.atan2(first_point.x * second_point.y - first_point.y * second_point.x,
+        jbpDot(first_point, second_point))
 
       angle = 0.0 if angle.abs < Float::EPSILON
       angle
@@ -192,7 +192,7 @@ module Joybox
     # Evaluates if two lines intersect
     def jbpLineIntersect(point_a, point_b, point_c, point_d)
       # Line undefined
-      return false if point_a.x == point_b.x && point_a.y == point_b.y || point_c.x == point_d.x && point_c.y == point_d.y
+      return nil if point_a.x == point_b.x && point_a.y == point_b.y || point_c.x == point_d.x && point_c.y == point_d.y
 
       x_b_to_a = point_b.x - point_a.x
       y_b_to_a = point_b.y - point_a.y
@@ -207,20 +207,20 @@ module Joybox
       denom = y_d_to_c * x_b_to_a - x_d_to_c * y_b_to_a
       if denom == 0
         # Lines incident
-        return { s: hit_point, t: second_hit_point } unless s != 0 && t != 0
+        return { s: s, t: t } if s == 0 && t == 0
 
         # Lines parallel and not incident
         return nil
       end
 
-      { s: hit_point / denom, t: second_hit_point / denom }
+      { s: s / denom, t: t / denom }
     end
 
     # Evaluates if two segments intersect
     def jbpSegmentIntersect(point_a, point_b, point_c, point_d)
       r = jbpLineIntersect(point_a, point_b, point_c, point_d)
-      return false unless r[:s] >= 0.0 && r[:s] <= 1.0 && r[:t] >= 0.0 && r[:t] <= 1.0
-      return true
+      return false if r.nil?
+      return r[:s] >= 0.0 && r[:s] <= 1.0 && r[:t] >= 0.0 && r[:t] <= 1.0 ? true : false
     end
 
     # Intersection point between the two lines
@@ -231,4 +231,4 @@ module Joybox
     end
 
   end
-end
+end

data/motion/joybox/physics/aabb.rb

@@ -0,0 +1,28 @@
+Joybox::Physics::AABB = B2DAABB
+
+class B2DAABB
+  
+  alias_method :metric_lower_bound, :lowerBound
+  alias_method :metric_lower_bound=, :setLowerBound
+  alias_method :metric_upper_bound, :upperBound
+  alias_method :metric_upper_bound=, :setUpperBound
+
+  def lower_bound
+    lowerBound.to_pixel_coordinates
+  end
+
+  def lower_bound=(bound)
+    bound = bound.to_point unless bound.is_a? (CGPoint)
+    self.lowerBound = bound.from_pixel_coordinates
+  end
+
+  def upper_bound
+    upperBound.to_pixel_coordinates
+  end
+
+  def upper_bound=(bound)
+    bound = bound.to_point unless bound.is_a? (CGPoint)
+    self.upperBound = bound.from_pixel_coordinates
+  end
+
+end

data/motion/joybox/physics/body.rb

@@ -2,134 +2,229 @@ Joybox::Physics::Body = B2DBody
 
 class B2DBody
 
+  alias_method :world_center, :worldCenter
+  alias_method :local_center, :localCenter
+  alias_method :linear_velocity, :linearVelocity
+  alias_method :linear_velocity=, :setLinearVelocity
+  alias_method :angular_velocity, :angularVelocity
+  alias_method :angular_velocity=, :setAngularVelocity
+  alias_method :linear_damping, :linearDamping
+  alias_method :linear_damping=, :setLinearDamping
+  alias_method :angular_damping, :angularDamping
+  alias_method :angular_damping=, :setAngularDamping
+  alias_method :gravity_scale, :gravityScale
+  alias_method :gravity_scale=, :setGravityScale
+  alias_method :bullet?, :isBullet
+  alias_method :bullet=, :setBullet
+  alias_method :awake?, :isAwake
+  alias_method :awake=, :setAwake
+  alias_method :active?, :isActive
+  alias_method :fixed_rotation?, :isFixedRotation
+  alias_method :fixed_rotation=, :setFixedRotation
+  alias_method :sleeping_allowed?, :isSleepingAllowed
+  alias_method :sleeping_allowed=, :setSleepingAllowed
+  alias_method :reset_mass, :resetMassData
+  alias_method :fixtures, :fixtureList
+  alias_method :destroy_fixture, :destroyFixture
+  alias_method :metric_position, :position
+  alias_method :radian_angle, :angle
+
+  Static = 0
+  Kinematic = 1
+  Dynamic = 2
+
   def self.defaults
     {
       position: [0, 0],
-      type: KStaticBodyType
+      angle: 0,
+      linear_velocity: [0, 0],
+      angular_velocity: 0,
+      linear_damping: 0,
+      angular_damping: 0,
+      allow_sleep: true,
+      awake: true,
+      fixed_rotation: false,
+      bullet: false,
+      type: Static,
+      active: true,
+      gravity_scale: 1.0
     }
   end
 
+  def mass_data
+    massData
+  end
 
-  def self.new(world, options = {})
+  def mass_data=(mass_data)
+    setMassData(mass_data)
+  end
 
+  def self.new(world, options = {})
     options = options.nil? ? defaults : defaults.merge!(options)
 
-    # This line is needed to ensure that the position is a CGPoint
+    body_definition = B2DBodyDef.new()
     position = CGPointMake(options[:position][0], options[:position][1])
-
-    world.createBodyInPosition(position.to_pixel_coordinates,
-                               type: options[:type])
+    body_definition.position = position.from_pixel_coordinates
+    body_definition.angle = options[:angle].to_radians * -1
+    linear_velocity = CGPointMake(options[:linear_velocity][0], options[:linear_velocity][1])
+    body_definition.linearVelocity = linear_velocity.from_pixel_coordinates
+    body_definition.angularVelocity = options[:angular_velocity]
+    body_definition.linearDamping = options[:linear_damping]
+    body_definition.angularDamping = options[:angular_damping]
+    body_definition.allowSleep = options[:allow_sleep]
+    body_definition.awake = options[:awake]
+    body_definition.fixedRotation = options[:fixed_rotation]
+    body_definition.bullet = options[:bullet]
+    body_definition.type = options[:type]
+    body_definition.active = options[:active]
+    body_definition.gravityScale = options[:gravity_scale]
+
+    body = world.createBody(body_definition)
+    body.userData = Hash.new
+    body
   end
 
+  def ==(body)
+    body.is_a?(self.class) && self.isEqualToBody(body)
+  end 
 
-  def fixture_defaults
-    {
-      friction: 0.2,
-      restitution: 0,
-      density: 0,
-      is_sensor: false
-    }
+  def position
+    metric_position.to_pixel_coordinates
+  end
+
+  def position=(position)
+    position = CGPointMake(position[0], position[1])
+    position = position.from_pixel_coordinates
+    self.setTransformWithPosition(position, andAngle: radian_angle)
   end
 
+  def angle
+    radian_angle.from_radians * -1
+  end
 
-  def edge_fixture(*hash)
+  def angle=(angle)
+    self.setTransformWithPosition(metric_position, andAngle: angle.to_radians * -1)
+  end
 
-    options = hash.pop
-    options = options.nil? ? fixture_defaults : fixture_defaults.merge!(options)
+  def to_world_point(local_point)
+    local_point = local_point.to_point.from_pixel_coordinates
+    worldPoint(local_point).to_pixel_coordinates
+  end
 
-    # The following lines are needed to ensure that the start_point and 
-    # end_points are CGPoints
-    start_point = CGPointMake(options[:start_point][0], options[:start_point][1])
-    end_point = CGPointMake(options[:end_point][0], options[:end_point][1])
+  def to_world_vector(local_vector)
+    local_vector = local_vector.to_point.from_pixel_coordinates
+    worldVector(local_vector).to_pixel_coordinates
+  end
 
-    edge_shape = B2DEdgeShape.alloc.initWithStartPoint(start_point.to_pixel_coordinates,
-                                                       endPoint: end_point.to_pixel_coordinates)
+  def to_local_point(world_point)
+    world_point = world_point.to_point.from_pixel_coordinates
+    localPoint(world_point).to_pixel_coordinates
+  end
 
-    addFixtureForShape(edge_shape,
-                       friction: options[:friction],
-                       restitution: options[:restitution],
-                       density: options[:density],
-                       isSensor: options[:is_sensor])
+  def to_local_vector(world_vector)
+    world_vector = world_vector.to_point.from_pixel_coordinates
+    localVector(world_vector).to_pixel_coordinates
   end
 
+  def linear_velocity_at(options = {})
+    point = options[:local_point] if options.has_key? :local_point
+    point = options[:world_point] if options.has_key? :world_point
+    point = point.to_point.from_pixel_coordinates
 
-  def polygon_fixture(*hash)
+    return linearVelocityFromLocalPoint(point) if options.has_key? :local_point
+    return linearVelocityFromWorldPoint(point) if options.has_key? :world_point
+  end
 
-    options = hash.pop
-    options = options.nil? ? fixture_defaults : fixture_defaults.merge!(options)
+  def [](key)
+    self.userData[key]
+  end
 
-    # This line is needed to ensure that the box is a CGSize
-    box_size = CGSizeMake(options[:box][0], options[:box][1])
+  def []=(key, value)
+    self.userData[key] = value
+  end 
 
-    polygon_shape = B2DPolygonShape.alloc.initWithBoxSize(box_size.to_pixel_coordinates)
+  def new_fixture(&block)
+    instance_eval(&block) if block
+  end
 
-    addFixtureForShape(polygon_shape,
-                       friction: options[:friction],
-                       restitution: options[:restitution],
-                       density: options[:density],
-                       isSensor: options[:is_sensor])
+  def fixture(options = {})
+    add_fixture(options, options[:shape])
   end
 
+  def edge_fixture(options = {})
+    edge_shape = B2DEdgeShape.new(options)
+    add_fixture(options, edge_shape)
+  end
 
-  def position=(position)
+  def polygon_fixture(options = {})
+    polygon_shape = B2DPolygonShape.new(options)
+    add_fixture(options, polygon_shape)
+  end
 
-    # This line is needed to ensure that the position is a CGPoint
-    position = CGPointMake(position[0], position[1])
+  def circle_fixture(options = {})
+    circle_shape = B2DCircleShape.new(options)
+    add_fixture(options, circle_shape)
+  end
 
-    # Coordinate system conversion
-    position = position.to_pixel_coordinates
+  def chain_fixture(options = {})
+    chain_shape = B2DChainShape.new(options)
+    add_fixture(options, chain_shape)
+  end
 
-    self.setPosition(position)
+  def add_fixture_defaults
+    {
+      friction: 0.2,
+      restitution: 0,
+      density: 0,
+      is_sensor: false
+    }
   end
 
+  def add_fixture(options = {}, shape)
+    options = options.nil? ? add_fixture_defaults : add_fixture_defaults.merge!(options)
 
-  def circle_fixture(*hash)
-    options = hash.pop
-    options = options.nil? ? fixture_defaults : fixture_defaults.merge!(options)
+    fixture_definition = B2DFixtureDef.new
+    fixture_definition.shape = shape;
+    fixture_definition.friction = options[:friction];
+    fixture_definition.restitution = options[:friction];
+    fixture_definition.density = options[:density];
+    fixture_definition.isSensor = options[:is_sensor];
 
-    circle_shape = B2DCircleShape.alloc.initWithRadius(options[:radius].to_pixels)
-    addFixtureForShape(circle_shape,
-                       friction: options[:friction],
-                       restitution: options[:restitution],
-                       density: options[:density],
-                       isSensor: options[:is_sensor])
+    createFixture(fixture_definition)
   end
 
-
   def apply_force_defaults
     {
-      location: self.center,
       as_impulse: true
     }
   end
 
-
   def apply_force(options = {})
-
     options = options.nil? ? apply_force_defaults : apply_force_defaults.merge!(options)
+    force = CGPointMake(options[:force][0], options[:force][1]).from_pixel_coordinates
 
-    # This line is needed to ensure that the force is a CGPoint
-    force = CGPointMake(options[:force][0], options[:force][1])
+    if options.has_key? :location
+      location = CGPointMake(options[:location][0], options[:location][1])
+      location = location.from_pixel_coordinates
+    else
+      location = local_center
+    end
 
-    applyForce(force.to_pixel_coordinates, 
-               atLocation: options[:location], 
-               asImpulse: options[:as_impulse]) 
+    applyLinearImpulse(force, atPoint: location) if options[:as_impulse]
+    applyForce(force, atPoint: location) unless options[:as_impulse]
   end
 
-
   def apply_torque_defaults
     {
       as_impulse: true
     }
   end
 
-
   def apply_torque(options = {})
-
     options = options.nil? ? apply_torque_defaults : apply_torque_defaults.merge!(options)
 
-    applyTorque(options[:torque], 
-               asImpulse: options[:as_impulse]) 
+    applyTorque(options[:torque]) unless options[:as_impulse]
+    applyAngularImpulse(options[:torque]) if options[:as_impulse]
   end
   
-end
+end

data/motion/joybox/physics/chain_shape.rb

@@ -0,0 +1,71 @@
+Joybox::Physics::ChainShape = B2DChainShape
+
+class B2DChainShape
+
+  extend Joybox::Common::Initialize
+
+  alias_method :metric_vertices, :vertices
+  alias_method :has_previous_vertex?, :hasPreviousVertex
+  alias_method :has_next_vertex?, :hasNextVertex
+  alias_method :metric_previous_vertex, :previousVertex
+  alias_method :metric_previous_vertex=, :setPreviousVertex
+  alias_method :metric_next_vertex, :nextVertex
+  alias_method :metric_next_vertex=, :setNextVertex
+
+  def initialize(options = {})
+    init
+    initialize_with_loop(options) if options.has_key? :loop
+    initialize_with_chain(options) if options.has_key? :chain
+  end
+
+  def initialize_with_loop(options = {})
+    vertices = Pointer.new(CGPoint.type, options[:loop].size)
+    options[:loop].each_with_index do |vertex, index|
+      vertices[index] = CGPointMake(vertex[0], vertex[1]).from_pixel_coordinates
+    end
+    
+    createLoopWithVertices(vertices, andVertexCount: options[:loop].size)
+  end
+
+  def initialize_with_chain(options = {})
+    vertices = Pointer.new(CGPoint.type, options[:chain].size)
+    options[:chain].each_with_index do |vertex, index|
+      vertices[index] = CGPointMake(vertex[0], vertex[1]).from_pixel_coordinates
+    end
+
+    createChainWithVertices(vertices, andVertexCount: options[:chain].size)
+  end
+
+  def vertices_count
+    vertexCount
+  end
+
+  def vertices
+    Array.new(vertices_count){ |i| metric_vertices[i].to_pixel_coordinates }
+  end
+
+  def previous_vertex
+    previousVertex.to_pixel_coordinates
+  end
+
+  def previous_vertex=(vertex)
+    vertex = vertex.to_point unless vertex.is_a? (CGPoint)
+    setPreviousVertex(vertex.from_pixel_coordinates)
+  end
+
+  def next_vertex
+    nextVertex.to_pixel_coordinates
+  end
+
+  def next_vertex=(vertex)
+    vertex = vertex.to_point unless vertex.is_a? (CGPoint)
+    setNextVertex(vertex.from_pixel_coordinates)
+  end
+
+  def edge_shape_by_index(index)
+    edge_shape = EdgeShape.new start_point: [0, 0], end_point: [0, 0]
+    getChildEdge(edge_shape, withIndex: index)
+    edge_shape
+  end
+
+end