joybox 0.0.3

data/lib/joybox/cocos2d/core/layer.rb

@@ -0,0 +1,87 @@
+module Joybox
+  module Core
+
+    class Layer < CCLayer
+
+      touch_states = [:began, :moved, :ended, :cancelled]
+
+      touch_states.each do |touch_state|
+
+        define_method("on_touches_#{touch_state}") do |&block|
+
+        self.isTouchEnabled = true if block_given?
+
+        instance_variable_set("@on_touches_#{touch_state}_block", block)
+        end
+      end
+
+
+      def self.scene
+
+        define_singleton_method(:scene) do 
+
+          scene = CCScene.new
+
+          menu_layer = self.new
+
+          scene << menu_layer
+        end
+      end
+
+
+      def onEnter
+
+        super
+
+        on_enter if defined? (on_enter)
+      end
+
+
+      def onExit
+
+        super
+
+        on_exit if defined? (on_exit)
+      end
+
+
+      def schedule_update(&block)
+
+        @schedule_update_block = block if block_given?
+
+        scheduleUpdate
+      end
+
+
+      def update(dt)
+
+        @schedule_update_block.call(dt) if @schedule_update_block
+      end
+
+
+      # These methods can't be autogenerated using metaprogramming
+      # because Objective-C will call them
+      def ccTouchesBegan(touches, withEvent: event)
+
+        @on_touches_began_block.call(touches, event) if @on_touches_began_block
+      end
+
+      def ccTouchesMoved(touches, withEvent: event)
+
+        @on_touches_moved_block.call(touches, event) if @on_touches_moved_block
+      end
+
+      def ccTouchesEnded(touches, withEvent: event)
+
+        @on_touches_ended_block.call(touches, event) if @on_touches_ended_block
+      end
+
+      def ccTouchesCancelled(touches, withEvent: event)
+
+        @on_touches_cancelled_block.call(touches, event) if @on_touches_cancelled_block
+      end
+
+    end
+
+  end
+end

data/lib/joybox/cocos2d/core/node.rb

@@ -0,0 +1,26 @@
+class CCNode
+
+  alias_method :add_child, :addChild
+
+  def << (node)
+
+    self.addChild(node)
+  end
+
+  def self.inherited(base)
+
+    base.send(:include, Joybox)
+  end
+
+  #TODO: Revisar el nombre de este metodo
+  def add_childs(*nodes)
+
+    nodes.each do |node|
+
+      self.addChild(node)
+
+    end
+
+  end 
+
+end

data/lib/joybox/cocos2d/core/physics_sprite.rb

@@ -0,0 +1,52 @@
+# TODO: Revisar el nombre de esto
+module Joybox
+  module Core
+
+    class PhysicsSprite < Sprite
+
+      attr_accessor :body
+
+      def self.new(options = {})
+
+        sprite = super 
+        sprite.body = options[:body] if options.include? :body
+
+        sprite
+      end
+
+
+      def dirty
+
+        true
+      end
+
+      # We need this method to return true, so Cocos2d continue
+      # to call the nodeToParentTransform method
+      def nodeToParentTransform
+
+        position = @body.position.to_uikit_coordinates
+
+        position = position + anchorPointInPoints if ignoreAnchorPointForPosition
+
+        angle = @body.angle
+
+        x = position.x
+        y = position.y
+        cosine = Math.cos(angle)
+        sine = Math.sin(angle)
+
+
+        unless anchorPointInPoints == CGPointZero
+
+          x = x + cosine * -anchorPointInPoints.x + -sine * -anchorPointInPoints.y
+          y = y + sine * -anchorPointInPoints.x + cosine * -anchorPointInPoints.y        
+        end
+
+
+        CGAffineTransformMake(cosine, sine, -sine, cosine, x, y)
+      end
+
+    end
+
+  end
+end

data/lib/joybox/cocos2d/core/scene.rb

@@ -0,0 +1,24 @@
+module Joybox
+  module Core
+
+    class Scene < CCScene
+
+      def onEnter
+
+        super
+
+        on_enter if defined? (on_enter)
+      end
+
+
+      def onExit
+
+        super
+
+        on_exit if defined? (on_exit)
+      end
+
+    end
+
+  end
+end

data/lib/joybox/cocos2d/core/sprite.rb

@@ -0,0 +1,43 @@
+module Joybox
+  module Core
+
+    class Sprite < CCSprite
+
+      alias_method :stop_all_actions, :stopAllActions
+      alias_method :run_action, :runAction
+
+      def self.new(options = {})
+
+        sprite ||= new_with_file(options) if options.has_key? (:file_name)
+        sprite ||= new_with_texture(options) if options.has_key? (:texture)
+
+        sprite.position = options[:position] if options.has_key? (:position)
+
+        sprite
+      end
+
+
+      private 
+
+      def self.new_with_file(options = {})
+
+        spriteWithFile(options[:file_name])
+      end
+
+
+      def self.new_with_texture(options = {})
+
+        if options.has_key? (:rect)
+
+          spriteWithTexture(options[:texture], rect: options[:rect])
+        else
+
+          spriteWithTexture(options:[:texture])
+        end
+
+      end
+
+    end
+
+  end
+end

data/lib/joybox/cocos2d/core/sprite_batch.rb

@@ -0,0 +1,24 @@
+module Joybox
+  module Core
+
+    class SpriteBatch < CCSpriteBatchNode
+
+      def self.defaults
+        {
+          capacity: 100
+        }
+      end
+
+
+      def self.new(options = {})
+
+        options = options.nil? ? defaults : defaults.merge!(options)
+
+        batchNodeWithFile(options[:file_name], 
+                          capacity: options[:capacity])
+      end
+
+    end
+
+  end
+end

data/lib/joybox/cocos2d/director.rb

@@ -0,0 +1,43 @@
+module Joybox
+  class Director < CCDirectorDisplayLink
+
+    alias_method :push_scene, :pushScene
+    alias_method :pop_scene, :popScene
+    alias_method :pop_to_root_scene, :popToRootScene
+    alias_method :replace_scene, :replaceScene
+    alias_method :stop_animation, :stopAnimation
+    alias_method :start_animation, :startAnimation
+    alias_method :purge_cached_data, :purgeCachedData
+    alias_method :set_next_delta_time_zero, :setNextDeltaTimeZero
+
+    def self.default_configuration
+      {
+        wants_full_screen_layout: true,
+        display_stats: false,
+        animation_interval: 1.0/60,
+        projection: KCCDirectorProjection2D,
+        enable_retina_display: true,
+        delegate: nil
+      }
+    end
+
+    def self.configure(options = {})
+      options = options.nil? ? default_configuration : default_configuration.merge!(options)
+
+      director = Director.sharedDirector
+
+      director.wantsFullScreenLayout = options.fetch(:wants_full_screen_layout)
+      director.displayStats = options.fetch(:display_stats)
+      director.animationInterval = options.fetch(:animation_interval)
+      director.projection = options.fetch(:projection)
+      director.enableRetinaDisplay(options.fetch(:enable_retina_display))
+      director.delegate = options.fetch(:delegate)
+    end
+
+
+    def << (scene)
+      self.push_scene(scene)
+    end
+
+  end
+end

data/lib/joybox/cocos2d/macros.rb

@@ -0,0 +1,234 @@
+# Extracted from the Cocos2D source: https://github.com/cocos2d/cocos2d-iphone
+# amazing work! Thank you Cocos2D team (https://github.com/cocos2d)!
+#
+# Ruby Motion does detect the original functions (Ex: ccp), thats why we
+# have to change the name of the method prefix to jbp (joy box point)
+#
+module Joybox
+  module Macros
+    # Creates a CGPoint
+    def jbp(x, y)
+      CGPointMake(x, y)
+    end
+
+    # Opposite of point
+    def jbpNeg(point)
+      jbp(-point.x, -point.y)
+    end
+
+    # Sum of two points
+    def jbpAdd(first_point, second_point)
+      jbp(first_point.x + second_point.x, first_point.y + second_point.y)
+    end
+
+    # Difference of two points
+    def jbpSub(first_point, second_point)
+      jbp(first_point.x - second_point.x, first_point.y - second_point.y)
+    end
+
+    # Point multiplied by factor
+    def jbpMult(first_point, factor)
+      jbp(first_point.x * factor, first_point.y * factor)
+    end
+
+    # Midpoint between two points
+    def jbpMidPoint(first_point, second_point)
+      jbpMult(jbpAdd(first_point, second_point), 0.5)
+    end
+
+    # Product of two points
+    def jbpDot(first_point, second_point)
+      first_point.x * second_point.x + first_point.y * second_point.y
+    end
+
+    # Cross product of two points
+    def jbpCross(first_point, second_point)
+      first_point.x * second_point.y - first_point.y * second_point.x
+    end
+
+    # Perpendicular of point, rotated 90 degrees counter-clockwise
+    def jbpPerp(point)
+      jbp(-point.y, point.x)
+    end
+
+    # Perpendicular of v, rotated 90 degrees clockwise
+    def jbpRPerp(point)
+      jbp(point.y, -point.x)
+    end
+
+    # Projection of first point over second point
+    def jbpProject(first_point, second_point)
+      jbpMult(second_point, jbpDot(first_point, second_point) / jbpDot(second_point, second_point))
+    end
+
+    # Rotates two points
+    def jbpRotate(first_point, second_point)
+      jbp(first_point.x * second_point.x - first_point.y * second_point.y,
+          first_point.x * second_point.y + first_point.y * second_point.x)
+    end
+
+    # Unrotates two points
+    def jbpUnrotate(first_point, second_point)
+      jbp(first_point.x * second_point.x + first_point.y * second_point.y,
+          first_point.y * second_point.x - first_point.x * second_point.y)
+    end
+
+    # Square lenght of a CGPoint
+    def jbpLengthSQ(point)
+      jbpDot(point, point)
+    end
+
+    # Square distance between two points
+    def jbpDistanceSQ(first_point, second_point)
+      jbpLengthSQ(jbpSub(first_point, second_point))
+    end
+
+    # Distance between point an origin
+    def jbpLenght(point)
+      Math.sqrt(jbpLengthSQ(point))
+    end
+
+    # Distance between two points
+    def jbpDistance(first_point, second_point)
+      jbpLenght(jbpSub(first_point, second_point))
+    end
+
+    # Point multiplied to a lenght of 1
+    def jbpNormalize(point)
+      jbpMult(point, 1.0 / jbpLenght(point))
+    end
+
+    # Converts radians to a normalized vector
+    def jbpForAngle(angle)
+      jbp(Math.cos(angle), Math.sin(angle))
+    end
+
+    # Converts vector to radians
+    def jbpToAngle(point)
+      Math.atan2(v.y, v.x)
+    end
+
+    # Clamp a value between from and to
+    def clamp(value, minimum_inclusive, maximum_inclusive)
+      if minimum_inclusive > maximum_inclusive
+
+        swap = minimum_inclusive
+
+        minimum_inclusive = maximum_inclusive
+        maximum_inclusive = swap
+      end
+
+      value < minimum_inclusive ? minimum_inclusive : value < maximum_inclusive ? value : maximum_inclusive
+    end
+
+    # Clamp a point between from and to
+    def jbpClamp(point, minimum_inclusive, maximum_inclusive)
+      jbp(clamp(point.x, minimum_inclusive.x, maximum_inclusive.x),
+          clamp(point.y, minimum_inclusive.y, maximum_inclusive.y))
+    end
+
+    # CGSize from a CGPoint
+    def jbpFromSize(size)
+      jbp(size.width, size.height)
+    end
+
+    # Run a math operation function on each point component
+    def jbpCompOp(point, &block)
+      jbp(block.call(point.x), block.call(point.y))
+    end
+
+    # Linear interpolation between two points
+    def jbpLerp(first_point, second_point, alpha)
+      jbpAdd(jbpMult(first_point, 1 - alpha), jbpMult(second_point, alpha))
+    end
+
+    # Determine if two points are equal with some degree of variance
+    def jbpFuzzyEqual(first_point, second_point, variance)
+      if first_point.x - variance <= second_point.x and second_point.x <= first_point.x + variance
+        if first_point.y - variance <= second_point.y and second_point.y <= first_point.y + variance
+          return true
+        end
+      end
+
+      false
+    end
+
+    # Multiples the first and second point
+    def jbpCompMult(first_point, second_point)
+      jbp(first_point.x * second_point.x, first_point.y * second_point.y)
+    end
+
+    # Signed angle in radians between two vector directions
+    def jbpAngleSigned(first_point, second_point)
+      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 = 0.0 if angle.abs < Float::EPSILON
+      angle
+    end
+
+    # Angle in radians between two vector directions
+    def jbpAngle(first_point, second_point)
+      angle = Math.acos(jbpDot(jbpNormalize(first_point), jbpNormalize(second_point)))
+      angle = 0.0 if angle.abs < Float::EPSILON
+      angle
+    end
+
+    # Rotates a point counter-clockwise by the angle around the pivot
+    def jbpRotateByAngle(first_point, pivot_point, angle)
+      rotation_point = jbpSub(first_point, pivot_point)
+      cosine = Math.cos(angle)
+      sine = Math.sin(angle)
+
+      rotation_point.x = rotation_point.x * cosine - rotation_point.y * sine + pivot_point.x
+      rotation_point.y = rotation_point.y * sine + rotation_point.y * cosine + pivot_point.y
+
+      rotation_point
+    end
+
+    # 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
+
+      x_b_to_a = point_b.x - point_a.x
+      y_b_to_a = point_b.y - point_a.y
+      x_d_to_c = point_d.x - point_c.x
+      y_d_to_c = point_d.y - point_c.y
+      x_a_to_c = point_a.x - point_c.x
+      y_a_to_c = point_a.y - point_c.y
+
+      s = x_d_to_c * y_a_to_c - y_d_to_c * x_a_to_c
+      t = x_b_to_a * y_a_to_c - y_b_to_a * x_a_to_c
+
+      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
+
+        # Lines parallel and not incident
+        return nil
+      end
+
+      { s: hit_point / denom, t: second_hit_point / 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
+    end
+
+    # Intersection point between the two lines
+    def jbpIntersectPoint(point_a, point_b, point_c, point_d)
+      r = jbpLineIntersect(point_a, point_b, point_c, point_d)
+      return CGPointZero unless r
+      return CGPointMake(point_a.x + r[:s] * (point_b.x - point_a.x), point_a.y + r[:s] * (point_b.y - point_a.y))
+    end
+
+  end
+end