joybox 0.0.5 → 0.0.6

data/{lib/joybox/cocos2d → motion/joybox}/common/screen.rb

@@ -12,25 +12,25 @@ module Joybox
 
       def self.width
 
-        CCDirector.sharedDirector.winSize.width
+        Joybox.director.winSize.width
       end
 
 
       def self.half_width
 
-        CCDirector.sharedDirector.winSize.width / 2
+        Joybox.director.winSize.width / 2
       end
 
 
       def self.height
 
-        CCDirector.sharedDirector.winSize.height
+        Joybox.director.winSize.height
       end
 
 
       def self.half_height
 
-        CCDirector.sharedDirector.winSize.height / 2
+        Joybox.director.winSize.height / 2
       end
 
     end

data/motion/joybox/core/layer.rb

@@ -0,0 +1,51 @@
+module Joybox
+  module Core
+
+    class Layer < CCLayer
+
+      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
+
+    end
+
+  end
+end

data/{lib/joybox/cocos2d → motion/joybox}/core/sprite.rb

@@ -3,13 +3,15 @@ module Joybox
 
     class Sprite < CCSprite
 
-      alias_method :stop_all_actions, :stopAllActions
       alias_method :run_action, :runAction
+      alias_method :stop_action, :stopAction
+      alias_method :stop_all_actions, :stopAllActions
 
       def self.new(options = {})
 
-        sprite ||= new_with_file(options) if options.has_key? (:file_name)
+        sprite ||= new_with_file_name(options) if options.has_key? (:file_name)
         sprite ||= new_with_texture(options) if options.has_key? (:texture)
+        sprite ||= new_with_frame_name(options) if options.has_key? (:frame_name)
 
         sprite.position = options[:position] if options.has_key? (:position)
 
@@ -22,9 +24,20 @@ module Joybox
         self.setTexture(texture)
       end
 
+      
+      # Review this in another version, because I dont still quite convinced
+      # that this is the correct approach. The alternative is two methods
+      # flip_x and flip_y, but I dont like them either.
+      def flip(options = {})
+
+        self.flipX = options[:x] if options.include?(:x)
+        self.flipY = options[:y] if options.include?(:y)
+      end
+
+
       private 
 
-      def self.new_with_file(options = {})
+      def self.new_with_file_name(options = {})
 
         spriteWithFile(options[:file_name])
       end
@@ -42,6 +55,12 @@ module Joybox
 
       end
 
+
+      def self.new_with_frame_name(options = {})
+
+        spriteWithSpriteFrameName(options[:frame_name])
+      end
+
     end
 
   end

data/motion/joybox/core/sprite_frame_cache.rb

@@ -0,0 +1,147 @@
+module Joybox
+  module Core
+
+  	class SpriteFrameCache < CCSpriteFrameCache
+
+      # Class Method Alias Method
+      class << self
+
+        alias_method :frames, :sharedSpriteFrameCache
+        alias_method :purge, :purgeSharedSpriteFrameCache
+
+      end
+
+    end 
+
+  end
+end
+
+# Open the CCSpriteFrameCache Class because of the singleton pattern
+class CCSpriteFrameCache
+
+  alias_method :remove_all, :removeSpriteFrames
+  alias_method :remove_unused_frames, :removeUnusedSpriteFrames     
+
+
+  def add(options = {})
+
+    add_frame_with_name(options) if options.has_key? (:name)
+    add_frames_with_file(options) if options.has_key? (:file_name)
+
+    # Check if it should fail silently or crash if any of the options
+    # above are sended
+  end
+
+
+  def add_frame_with_name(options = {})
+
+    if options.has_key? (:frame)
+
+      addSpriteFrame(options[:frame], name: options[:name])
+    end
+
+    # Check if it should fail silently or crash if any of the options
+    # above are sended
+  end
+
+
+  def add_frames_with_file(options = {})
+
+    if options.has_key? (:texture)
+
+      addSpriteFramesWithFile(options[:file_name], texture: options[:texture])
+
+    elsif options.has_key? (:texture_file_name)
+
+      addSpriteFramesWithFile(options[:file_name], textureFilename: options[:texture_file_name])
+    else
+
+      addSpriteFramesWithFile(options[:file_name])
+    end
+
+  end
+
+
+  def remove(options = {})
+
+    remove_frame_by_name(options) if options.has_key? (:name)
+    remove_frame_from_file(options) if options.has_key? (:file_name)
+    remove_frame_from_texture(options) if options.has_key? (:texture)
+
+    # Check if it should fail silently or crash if any of the options
+    # above are sended
+  end
+
+
+  def remove_frame_by_name(options = {})
+
+    removeSpriteFrameByName(options[:name])
+  end
+
+
+  def remove_frame_from_file(options = {})
+
+    removeSpriteFramesFromFile(options[:file_name])
+  end
+
+
+  def remove_frame_from_texture(options = {})
+
+     removeSpriteFramesFromTexture(options[:texture])
+  end
+
+
+  def [](name)
+
+    spriteFrameByName(name)
+  end
+
+
+  def []=(name, frame)
+
+    addSpriteFrame(frame, name: name)
+  end 
+
+
+  def default_where
+  {
+    from: 0,
+    to: nil
+  }
+  end
+
+
+  def where(options = {})
+
+    options = options.nil? ? default_where : default_where.merge!(options)
+
+    frame_prefix = options[:prefix]
+    frame_suffix = options[:suffix]
+
+    frames = Array.new
+
+    from_frame = options[:from]
+    to_frame = options[:to]
+
+
+    frame = nil
+
+    # Yukihiro Matsumoto recomends using loop instead of while or until statements
+    # http://blade.nagaokaut.ac.jp/cgi-bin/scat.rb/ruby/ruby-core/6745
+    loop do  
+
+      frame_name = "#{frame_prefix}#{from_frame}#{frame_suffix}"
+
+      frame = self[frame_name]
+
+      frames << frame unless frame.nil?
+
+      from_frame = from_frame + 1
+
+      break if frame.nil? or (from_frame > to_frame unless to_frame.nil?)
+    end 
+
+    frames
+  end
+
+end

data/{lib/joybox/cocos2d/cocos2d.rb → motion/joybox/joybox.rb}

@@ -3,9 +3,11 @@ module Joybox
   include Joybox::Common
   include Joybox::Core
   include Joybox::Actions
+  include Joybox::Animations
   include Joybox::UI
   include Joybox::Macros
-
+  include Joybox::Physics
+  
   module_function
 
   def director

data/{lib/joybox/box2d → motion/joybox/physics}/body.rb

@@ -1,4 +1,4 @@
-Joybox::Body = B2DBody
+Joybox::Physics::Body = B2DBody
 
 class B2DBody
 
@@ -22,7 +22,7 @@ class B2DBody
   end
 
 
-  def fixure_defaults
+  def fixture_defaults
     {
       friction: 0.2,
       restitution: 0,
@@ -32,10 +32,10 @@ class B2DBody
   end
 
 
-  def edge_fixure(*hash)
+  def edge_fixture(*hash)
 
     options = hash.pop
-    options = options.nil? ? fixure_defaults : fixure_defaults.merge!(options)
+    options = options.nil? ? fixture_defaults : fixture_defaults.merge!(options)
 
     # The following lines are needed to ensure that the start_point and 
     # end_points are CGPoints
@@ -45,29 +45,55 @@ class B2DBody
     edge_shape = B2DEdgeShape.alloc.initWithStartPoint(start_point.to_pixel_coordinates,
                                                        endPoint: end_point.to_pixel_coordinates)
 
-    addFixureForShape(edge_shape,
-                      friction: options[:friction],
-                      restitution: options[:restitution],
-                      density: options[:density],
-                      isSensor: options[:is_sensor])
+    addFixtureForShape(edge_shape,
+                       friction: options[:friction],
+                       restitution: options[:restitution],
+                       density: options[:density],
+                       isSensor: options[:is_sensor])
   end
 
 
-  def polygon_fixure(*hash)
+  def polygon_fixture(*hash)
 
     options = hash.pop
-    options = options.nil? ? fixure_defaults : fixure_defaults.merge!(options)
+    options = options.nil? ? fixture_defaults : fixture_defaults.merge!(options)
 
     # This line is needed to ensure that the box is a CGSize
     box_size = CGSizeMake(options[:box][0], options[:box][1])
 
     polygon_shape = B2DPolygonShape.alloc.initWithBoxSize(box_size.to_pixel_coordinates)
 
-    addFixureForShape(polygon_shape,
-                      friction: options[:friction],
-                      restitution: options[:restitution],
-                      density: options[:density],
-                      isSensor: options[:is_sensor])
+    addFixtureForShape(polygon_shape,
+                       friction: options[:friction],
+                       restitution: options[:restitution],
+                       density: options[:density],
+                       isSensor: options[:is_sensor])
+  end
+
+
+  def position=(position)
+
+    # This line is needed to ensure that the position is a CGPoint
+    position = CGPointMake(position[0], position[1])
+
+    # Coordinate system conversion
+    position = position.to_opengl_coordinates
+    position = position.to_pixel_coordinates
+
+    self.setPosition(position)
+  end
+
+
+  def circle_fixture(*hash)
+    options = hash.pop
+    options = options.nil? ? fixture_defaults : fixture_defaults.merge!(options)
+
+    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])
   end
 
 
@@ -106,4 +132,5 @@ class B2DBody
     applyTorque(options[:torque], 
                asImpulse: options[:as_impulse]) 
   end
-end
+  
+end

data/{lib/joybox/cocos2d/core → motion/joybox/physics}/physics_sprite.rb

@@ -24,7 +24,7 @@ module Joybox
       # to call the nodeToParentTransform method
       def nodeToParentTransform
 
-        position = @body.position.to_uikit_coordinates
+        position = @body.position.from_pixel_coordinates
 
         position = position + anchorPointInPoints if ignoreAnchorPointForPosition
 

data/motion/joybox/physics/world.rb

@@ -0,0 +1,79 @@
+module Joybox
+  module Physics
+
+    class World < B2DWorld
+
+      def self.defaults
+        {
+          gravity: [0, 0],
+          allows_sleeping: true,
+          continuos_physics: true
+        }
+      end
+
+
+      def self.new(options)
+
+        options = options.nil? ? defaults : defaults.merge!(options)
+
+        world = World.alloc.init 
+
+        world.gravity = options[:gravity]
+        world.allowsSleeping = options[:allows_sleeping]
+        world.continuosPhysics = options[:continuos_physics]
+
+        world
+      end
+
+
+      def step_defaults
+        {
+          velocity_interactions: 8,
+          position_interactions: 1
+        }
+      end
+
+
+      def step(options = {})
+
+        options = options.nil? ? step_defaults : step_defaults.merge!(options)
+
+        stepWithDelta(options[:delta], 
+          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 setup_collision_listener
+
+        @contact_listener = B2DContactListener.new
+        addContactListener(@contact_listener)
+
+        @listening_bodies = Hash.new
+
+        @contact_listener.beginContact = lambda { | first_body, second_body, is_touching |
+
+          @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
+        }
+      end
+
+
+      def when_collide(body, &block)
+
+        setup_collision_listener unless @contact_listener
+
+        @listening_bodies[body] = block
+      end
+
+    end
+
+  end
+end

data/{lib/joybox/cocos2d → motion/joybox}/ui/label.rb

@@ -8,6 +8,7 @@ module Joybox
 
       def self.defaults
         {
+          text: '',
           font_name: 'Marker Felt',
           font_size: 12
         }
@@ -19,8 +20,8 @@ module Joybox
         options = options.nil? ? defaults : defaults.merge!(options)
 
         label = Label.labelWithString(options[:text], 
-          fontName: options[:font_name], 
-          fontSize: options[:font_size])
+                                      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)

data/{lib/joybox/cocos2d → motion/joybox-ios}/common/cg_point.rb

@@ -5,9 +5,10 @@ class CGPoint
     Joybox.director.convertToGL(self)
   end
 
-  def to_uikit_coordinates
 
-    CGPointMake(self.x.from_pixels, self.y.from_pixels)
+  def from_opengl_coordinates
+
+    Joybox.director.convertToUI(self)
   end
 
 
@@ -17,6 +18,12 @@ class CGPoint
   end
 
 
+  def from_pixel_coordinates
+
+    CGPointMake(self.x.from_pixels, self.y.from_pixels)
+  end
+
+
   def == (point)
 
     point.is_a?(CGPoint) && CGPointEqualToPoint(self, point)

data/{lib/joybox/cocos2d → motion/joybox-ios}/common/ui_touch.rb

@@ -9,7 +9,7 @@ class UITouch
 
   def location
 
-    locationInView(self.view).to_opengl_coordinates
+    Joybox.director.convertTouchToGL(self)
   end
 
 end

data/{lib/joybox/cocos2d → motion/joybox-ios}/configuration/file_utils.rb

@@ -5,8 +5,6 @@ module Joybox
 
       def self.default_configuration
         {
-
-          enable_fallback_suffixes: false,
           set_iphone_retina_display_suffix: "-hd",
           set_ipad_suffix: "-ipad",
           set_ipad_retina_display_suffix: "-ipadhd"
@@ -21,7 +19,6 @@ module Joybox
 
         file_utils = FileUtils.sharedFileUtils
 
-        file_utils.setEnableFallbackSuffixes(options[:enable_fallback_suffixes])
         file_utils.setiPhoneRetinaDisplaySuffix(options[:set_iphone_retina_display_suffix])
         file_utils.setiPadSuffix(options[:set_ipad_suffix])
         file_utils.setiPadRetinaDisplaySuffix(options[:set_ipad_retina_display_suffix])

data/{lib/joybox/cocos2d → motion/joybox-ios}/core/layer.rb

@@ -9,56 +9,12 @@ module Joybox
 
         define_method("on_touches_#{touch_state}") do |&block|
 
-        self.isTouchEnabled = true if block_given?
+        self.touchEnabled = 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)

data/{lib/joybox/cocos2d → motion/joybox-ios}/director.rb

@@ -26,12 +26,12 @@ module Joybox
 
       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)
+      director.wantsFullScreenLayout = options[:wants_full_screen_layout]
+      director.displayStats = options[:display_stats]
+      director.animationInterval = options[:animation_interval]
+      director.projection = options[:projection]
+      director.enableRetinaDisplay(options[:enable_retina_display])
+      director.delegate = options[:delegate]
     end