joybox 1.0.0 → 1.1.0

data/motion/joybox/core/layer_color.rb

@@ -0,0 +1,47 @@
+module Joybox
+  module Core
+
+    class LayerColor < CCLayerColor
+
+      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 self.defaults
+      {
+        opacity: 255,
+        width: Screen.width,
+        height: Screen.height
+      }
+      end
+
+      def self.new(options = {})
+        options = options.nil? ? defaults : defaults.merge!(options)
+        options[:color] << options[:opacity]
+
+        layer = CCLayerColor.layerWithColor(options[:color], 
+                                            width: options[:width], 
+                                            height: options[:height])
+
+        layer.position = options[:position] if options.has_key? :position
+        layer
+      end
+      
+    end
+
+  end
+end

data/motion/joybox/core/node.rb

@@ -1,26 +1,36 @@
 class CCNode
 
   alias_method :add_child, :addChild
+  alias_method :run_action, :runAction
+  alias_method :stop_action, :stopAction
+  alias_method :stop_all_actions, :stopAllActions
+  alias_method :number_of_running_actions, :numberOfRunningActions
 
   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)
-
+  def add_children(*nodes)
     nodes.each do |node|
-
       self.addChild(node)
-
     end
-
   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
+
+  def running_actions?
+    self.number_of_running_actions > 0
+  end
+
 end

data/motion/joybox/core/scene.rb

@@ -4,17 +4,12 @@ module Joybox
     class Scene < CCScene
 
       def onEnter
-
         super
-
         on_enter if defined? (on_enter)
       end
 
-
       def onExit
-
         super
-
         on_exit if defined? (on_exit)
       end
 

data/motion/joybox/core/sprite.rb

@@ -3,27 +3,31 @@ module Joybox
 
     class Sprite < CCSprite
 
-      include Joybox::Common
+      extend Joybox::Common::Initialize
 
-      alias_method :run_action, :runAction
-      alias_method :stop_action, :stopAction
-      alias_method :stop_all_actions, :stopAllActions
       alias_method :bounding_box, :boundingBox
-
-
-      def self.new(options = {})
-        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)
-        sprite
+      alias_method :frame, :displayFrame
+      alias_method :frame=, :setDisplayFrame
+      attr_accessor :properties
+      
+      def initialize(options = {})
+        initialize_with_file_name(options) if options.has_key? (:file_name)
+        initialize_with_texture(options) if options.has_key? (:texture)
+        initialize_with_frame_name(options) if options.has_key? (:frame_name)
+        initialize_with_frame(options) if options.has_key? (:frame)
+        initialize_with_cg_image(options) if options.has_key?(:cg_image) && options.has_key?(:key)
+        self.position = options.delete(:position) if options.has_key? (:position)
+        self.properties = options
       end
-
+      
       def file_name=(file_name)
         texture = CCTextureCache.sharedTextureCache.addImage(file_name)
         self.setTexture(texture)
       end
+
+      def displays_frame?(frame)
+        isFrameDisplayed(frame)
+      end
       
       # Review this in another version, because I dont still quite convinced
       # that this is the correct approach. The alternative is two methods
@@ -49,25 +53,39 @@ module Joybox
         super
       end
 
+      def [](key)
+        @properties[key]
+      end
+
+      def []=(key, value)
+        @properties[key] = value
+      end
+
       private 
 
-      def self.new_with_file_name(options = {})
-        spriteWithFile(options[:file_name])
+      def initialize_with_file_name(options = {})
+        initWithFile(options.delete(:file_name)) if options[:rect].nil?
+        initWithFile(options.delete(:file_name), rect: options.delete(:rect)) unless options[:rect].nil?
+      end
+
+      def initialize_with_texture(options = {})
+        initWithTexture(options.delete(:texture)) if options[:rect].nil?
+        initWithTexture(options.delete(:texture), rect: options.delete(:rect)) unless options[:rect].nil? 
+      end
+
+      def initialize_with_frame_name(options = {})
+        initWithSpriteFrameName(options.delete(:frame_name))
       end
 
-      def self.new_with_texture(options = {})
-        if options.has_key? (:rect)
-          spriteWithTexture(options[:texture], rect: options[:rect])
-        else
-          spriteWithTexture(options:[:texture])
-        end
+      def initialize_with_frame(options = {})
+        initWithSpriteFrame(options.delete(:frame))
       end
 
-      def self.new_with_frame_name(options = {})
-        spriteWithSpriteFrameName(options[:frame_name])
+      def initialize_with_cg_image(options = {})
+        initWithCGImage(options.delete(:cg_image).CGImage, key: options.delete(:key))
       end
 
     end
 
   end
-end
+end

data/motion/joybox/core/sprite_batch.rb

@@ -3,19 +3,28 @@ module Joybox
 
     class SpriteBatch < CCSpriteBatchNode
 
-      def self.defaults
+      extend Joybox::Common::Initialize
+
+      def defaults
         {
-          capacity: 100
+          capacity: 29
         }
       end
 
+      def initialize(options = {})
+        options = options.nil? ? defaults : defaults.merge!(options)
+        initialize_with_file_name(options) if options.has_key? (:file_name)
+        initialize_with_texture(options) if options.has_key? (:texture)
+      end
 
-      def self.new(options = {})
+      private
 
-        options = options.nil? ? defaults : defaults.merge!(options)
+      def initialize_with_file_name(options = {})
+        initWithFile(options[:file_name], capacity: options[:capacity])
+      end
 
-        batchNodeWithFile(options[:file_name], 
-                          capacity: options[:capacity])
+      def initialize_with_texture(options = {})
+        initWithTexture(options[:texture], capacity: options[:capacity])
       end
 
     end

data/motion/joybox/core/sprite_frame_cache.rb

@@ -2,146 +2,97 @@ 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
+    addSpriteFrame(options[:frame], name: options[:name]) if options.has_key? (:frame)
   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,
+    from: 1,
     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]
+    frame_order = options[:order]
+    from_frame = frame_order ? frame_order.pop : 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  
-
+    loop do
       frame_name = "#{frame_prefix}#{from_frame}#{frame_suffix}"
-
       frame = self[frame_name]
-
       frames << frame unless frame.nil?
 
-      from_frame = from_frame + 1
-
+      from_frame = frame_order ? frame_order.pop : (from_frame + 1)
       break if frame.nil? or (from_frame > to_frame unless to_frame.nil?)
-    end 
+    end
 
     frames
   end
 
-end
+end

data/motion/joybox/debug/physics.rb

@@ -0,0 +1,40 @@
+module Joybox
+  module Debug
+    module Physics
+
+      class << self
+        attr_accessor :modes
+        attr_accessor :world
+        attr_accessor :draw
+      end
+      
+      def draw
+        super
+        initialize_physics_drawing if @world_symbol.nil?
+        draw_physics unless @world_symbol.nil?
+      end
+
+      def initialize_physics_drawing
+        @world_symbol = self.instance_variables.find do |symbol|
+          instance_variable_get(symbol).class == Joybox::Physics::World
+        end
+
+        unless @world_symbol.nil?
+          @physics_draw = PhysicsDraw.new(Joybox::Debug::Physics.modes)
+          instance_variable_get(@world_symbol).setDebugDraw(@physics_draw.draw)
+          Joybox::Debug::Physics.world = instance_variable_get(@world_symbol)
+          Joybox::Debug::Physics.draw = @physics_draw
+        end
+      end
+
+      def draw_physics
+        ccGLEnableVertexAttribs(KCCVertexAttribFlag_Position)
+        kmGLPushMatrix
+        instance_variable_get(@world_symbol).drawDebugData
+        kmGLPopMatrix
+      end
+
+    end
+
+  end
+end

data/motion/joybox/debug/physics_draw.rb

@@ -0,0 +1,191 @@
+module Joybox
+  module Debug
+    class PhysicsDraw
+
+      attr_accessor :draw
+
+      Modes = { shapes: 0x0001, joints: 0x0002, aabb: 0x0004, pairs: 0x0008, center_of_mass: 0x0010 }
+
+      def initialize(options = [])
+        @draw = B2DDraw.new
+
+        initialize_shader
+        initialize_drawing
+        
+        mode = options.reduce(0) { |sum, option| sum + Modes[option] }
+        @draw.drawFlags = mode unless options.empty?
+      end
+
+      def modes=(options = [])
+        modes = options.reduce(0) { |sum, option| sum + Modes[option] }
+        @draw.drawFlags = modes unless options.empty?
+      end
+
+      private
+
+      def initialize_shader
+        @shader_program = CCShaderCache.sharedShaderCache.programForKey(KCCShader_Position_uColor)
+        @color_location = glGetUniformLocation(@shader_program.program, :u_color)
+      end
+
+      def initialize_drawing
+        @draw.drawPolygon = lambda do |vertices, vertex_count, color|
+          prepare_for_drawing
+          draw_polygon(vertices, vertex_count, color)
+          check_for_drawing_errors
+        end
+
+        @draw.drawSolidPolygon = lambda do |vertices, vertex_count, color|
+          prepare_for_drawing
+          draw_solid_polygon(vertices, vertex_count, color)
+          check_for_drawing_errors
+        end
+
+        @draw.drawCircle = lambda do |center, radius, color|
+          prepare_for_drawing
+          draw_circle(center, radius, color)
+          check_for_drawing_errors
+        end
+
+        @draw.drawSolidCircle = lambda do |center, radius, axis, color|
+          prepare_for_drawing
+          draw_solid_circle(center, radius, axis, color)
+          check_for_drawing_errors
+        end
+
+        @draw.drawSegment = lambda do |first_point, second_point, color|
+          prepare_for_drawing
+          draw_segment(first_point, second_point, color)
+          check_for_drawing_errors
+        end
+
+        @draw.drawTransform = lambda do |transform|
+          prepare_for_drawing
+          draw_transform(transform)
+          check_for_drawing_errors
+        end 
+      end
+
+      def prepare_for_drawing
+        @shader_program.use
+        @shader_program.setUniformsForBuiltins
+      end
+
+      def set_drawing_color(color, alpha)
+        @shader_program.setUniformLocation(@color_location, 
+         withF1: color.red * alpha, 
+         f2: color.green * alpha, 
+         f3: color.blue * alpha, 
+         f4: alpha)
+      end
+
+      def check_for_drawing_errors
+        error = glGetError
+        print "error" if error > 0
+        # Todo print error message on the console "0x#{error}4x" if error > 0
+      end
+
+      def draw_polygon(box_vertices, vertex_count, color)
+        vertices = Pointer.new(:float, vertex_count * 2)
+        vertex_count.times do |i|
+          vertices[i * 2] = box_vertices[i].x.to_pixels 
+          vertices[i * 2 + 1] = box_vertices[i].y.to_pixels
+        end
+
+        set_drawing_color(color, 1)
+        glVertexAttribPointer(KCCVertexAttrib_Position, 2, GL_FLOAT, GL_FALSE, 0, vertices)
+        glDrawArrays(GL_LINE_LOOP, 0, vertex_count)
+      end
+
+      def draw_solid_polygon(box_vertices, vertex_count, color)
+        vertices = Pointer.new(:float, vertex_count * 2)
+        vertex_count.times do |i|
+          vertices[i * 2] = box_vertices[i].x.to_pixels 
+          vertices[i * 2 + 1] = box_vertices[i].y.to_pixels
+        end
+
+        set_drawing_color(color, 0.5)
+        glVertexAttribPointer(KCCVertexAttrib_Position, 2, GL_FLOAT, GL_FALSE, 0, vertices)
+        glDrawArrays(GL_TRIANGLE_FAN, 0, vertex_count)
+
+        set_drawing_color(color, 1)
+        glDrawArrays(GL_LINE_LOOP, 0, vertex_count)
+      end
+
+      def draw_circle(center, radius, color)
+        vertex_count = 16
+        increment = 2.0 * Math::PI / vertex_count
+        theta = 0.0
+
+        vertices = Pointer.new(:float, vertex_count * 2)
+        vertex_count.times do |i|
+          vertex = center + radius * CGPointMake(Math.cos(theta), Math.sin(theta))
+          vertex = vertex.to_pixel_coordinates
+
+          vertices[i * 2] = vertex.x
+          vertices[i * 2 + 1] = vertex.y
+          theta += increment
+        end
+
+        set_drawing_color(color, 1.0)
+        glVertexAttribPointer(KCCVertexAttrib_Position, 2, GL_FLOAT, GL_FALSE, 0, vertices)
+        glDrawArrays(GL_LINE_LOOP, 0, vertex_count)
+      end
+
+      def draw_solid_circle(center, radius, axis, color)
+        vertex_count = 16
+        increment = 2.0 * Math::PI / vertex_count
+        theta = 0.0
+
+        vertices = Pointer.new(:float, vertex_count * 2)
+        vertex_count.times do |i|
+          vertex = center + radius * CGPointMake(Math.cos(theta), Math.sin(theta))
+          vertex = vertex.to_pixel_coordinates
+
+          vertices[i * 2] = vertex.x
+          vertices[i * 2 + 1] = vertex.y
+          theta += increment
+        end
+
+        set_drawing_color(color, 0.5)
+        glVertexAttribPointer(KCCVertexAttrib_Position, 2, GL_FLOAT, GL_FALSE, 0, vertices)
+        glDrawArrays(GL_TRIANGLE_FAN, 0, vertex_count)
+
+        set_drawing_color(color, 1.0)
+        glDrawArrays(GL_LINE_LOOP, 0, vertex_count)
+
+        draw_segment(center, center + radius * axis, color)
+      end
+
+      def draw_segment(first_point, second_point, color)
+        vertices = Pointer.new(:float, 4)
+
+        vertices = Pointer.new(:float, 4)
+        vertices[0] = first_point.x.to_pixels  
+        vertices[1] = first_point.y.to_pixels
+        vertices[2] = second_point.x.to_pixels
+        vertices[3] = second_point.y.to_pixels
+        
+        set_drawing_color(color, 1)
+        glVertexAttribPointer(KCCVertexAttrib_Position, 2, GL_FLOAT, GL_FALSE, 0, vertices)
+        glDrawArrays(GL_LINES, 0, 2)
+      end
+
+      def draw_transform(transform)
+        axis_scale = 0.4
+        first_point = transform.metric_position
+
+        angle_x_axis = CGPointMake(Math.cos(transform.angle), Math.sin(transform.angle))
+        angle_y_axis = CGPointMake(-Math.sin(transform.angle), Math.cos(transform.angle)) 
+
+        second_point = first_point + axis_scale * angle_x_axis
+        draw_segment(first_point, second_point, Color.new(1, 0, 0))
+
+        second_point = first_point + axis_scale * angle_y_axis
+        draw_segment(first_point, second_point, Color.new(0, 0, 1))
+      end
+
+    end
+
+  end
+end