technohippy-Pongo 0.1.0

data/History.txt

@@ -0,0 +1,17 @@
+=== 0.1.1 / 2009-08-01
+
+* add cardemo
+* fix some bugs
+
+=== 0.1.0 / 2009-07-24
+
+* 1 major enhancement
+
+  * barely work
+
+=== 1.0.0 / 2009-07-21
+
+* 1 major enhancement
+
+  * Birthday!
+

data/Manifest.txt

@@ -0,0 +1,52 @@
+History.txt
+lib/pongo/abstract_collection.rb
+lib/pongo/abstract_constraint.rb
+lib/pongo/abstract_item.rb
+lib/pongo/abstract_particle.rb
+lib/pongo/angular_constraint.rb
+lib/pongo/apengine.rb
+lib/pongo/circle_particle.rb
+lib/pongo/collision.rb
+lib/pongo/collision_detector.rb
+lib/pongo/collision_event.rb
+lib/pongo/collision_resolver.rb
+lib/pongo/util/interval.rb
+lib/pongo/util/math_util.rb
+lib/pongo/util/numeric_ext.rb
+lib/pongo/util/vector.rb
+lib/pongo/composite.rb
+lib/pongo/group.rb
+lib/pongo/iforce.rb
+lib/pongo/logger/logger.rb
+lib/pongo/logger/shoes_logger.rb
+lib/pongo/logger/standard_logger.rb
+lib/pongo/rectangle_particle.rb
+lib/pongo/renderer/renderer.rb
+lib/pongo/renderer/shoes_renderer.rb
+lib/pongo/renderer/tk_renderer.rb
+lib/pongo/rim_particle.rb
+lib/pongo/spring_constraint.rb
+lib/pongo/spring_constraint_particle.rb
+lib/pongo/vector_force.rb
+lib/pongo/wheel_particle.rb
+lib/pongo.rb
+Manifest.txt
+Rakefile
+README.txt
+sample/cardemo/bridge.rb
+sample/cardemo/capsule.rb
+sample/cardemo/car.rb
+sample/cardemo/rect_composite.rb
+sample/cardemo/rotator.rb
+sample/cardemo/surfaces.rb
+sample/cardemo/swing_door.rb
+sample/robodemo/body.rb
+sample/robodemo/leg.rb
+sample/robodemo/motor.rb
+sample/robodemo/robot.rb
+sample/shoes/basic.rb
+sample/shoes/cardemo.rb
+sample/shoes/robodemo.rb
+sample/shoes/simple.rb
+sample/tk/basic.rb
+sample/tk/robotdemo.rb

data/README.txt

@@ -0,0 +1,93 @@
+= Pongo
+
+* http://github.com/technohippy/Pongo/
+
+== DESCRIPTION:
+
+Ruby port of APE (Actionscript Physics Engine)
+
+== FEATURES/PROBLEMS:
+
+* CircleParticles
+* RectangleParticles
+* WheelParticles
+* SpringConstraints
+* Grouping
+* Collision
+
+see also: http://www.cove.org/ape/index.htm
+
+== EXECUTE SAMPLES:
+
+* ruby sample/tk/robotdemo.rb
+* shoes sample/shoes/robotdemo.rb
+* shoes sample/shoes/cardemo.rb
+
+== SYNOPSIS:
+
+  require 'pongo'
+  require 'pongo/renderer/shoes_renderer'
+  require 'pongo/logger/shoes_logger'
+
+  include Pongo
+  Shoes.app :width => 500, :height => 350 do
+    APEngine.renderer = Renderer::ShoesRenderer.new(self)
+    APEngine.logger = Logger::ShoesLogger.new(self)
+    APEngine.setup
+    APEngine.add_force VectorForce.new(false, 0, 2)
+
+    default_group = Group.new
+    default_group.collide_internal = true
+
+    ball = CircleParticle.new(245, 100, 10)
+    default_group.add_particle(ball)
+
+    ground = RectangleParticle.new(250, 250, 300, 50, 0, true)
+    ground.always_redraw!
+    default_group.add_particle(ground)
+
+    APEngine.add_group(default_group)
+
+    animate(60) do |anim|
+      APEngine.step
+      APEngine.draw
+    end
+  end
+
+== REQUIREMENTS:
+
+* Shoes2 ( http://shoooes.net/ )
+
+== INSTALL:
+
+* sudo gem install pongo
+
+== IMAGES:
+
+* http://www.flickr.com/photos/24557420@N05/3366850475/
+* http://www.aa.alles.or.jp/~palette/icon/icon.html
+
+== LICENSE:
+
+(The MIT License)
+
+Copyright (c) 2009 Ando Yasushi
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/lib/pongo.rb

@@ -0,0 +1,33 @@
+$: << File.expand_path(File.dirname(__FILE__))
+
+require 'pongo/abstract_collection'
+require 'pongo/abstract_constraint'
+require 'pongo/abstract_item'
+require 'pongo/abstract_particle'
+require 'pongo/angular_constraint'
+require 'pongo/apengine'
+require 'pongo/circle_particle'
+require 'pongo/collision'
+require 'pongo/collision_detector'
+require 'pongo/collision_event'
+require 'pongo/collision_resolver'
+require 'pongo/composite'
+require 'pongo/group'
+require 'pongo/iforce'
+require 'pongo/rectangle_particle'
+require 'pongo/rim_particle'
+require 'pongo/spring_constraint'
+require 'pongo/spring_constraint_particle'
+require 'pongo/vector_force'
+require 'pongo/wheel_particle'
+
+require 'pongo/util/interval'
+require 'pongo/util/math_util'
+require 'pongo/util/numeric_ext'
+require 'pongo/util/vector'
+
+module Pongo
+  VERSION = '0.1.0'
+  class SubclassResponsibilityError < StandardError; end
+  class UnknownItemError < StandardError; end
+end

data/lib/pongo/abstract_collection.rb

@@ -0,0 +1,135 @@
+require 'pongo/abstract_item'
+
+module Pongo
+  class AbstractCollection < AbstractItem
+    attr_accessor :sprite, :particles, :constraints, :is_parented
+
+    def initialize
+      super
+      self.is_parented = false
+      self.particles = []
+      self.constraints = []
+    end
+
+    def <<(item)
+      case item
+      when AbstractParticle
+        add_particle(item)
+      when AbstractConstraint
+        add_constraint(item)
+      end
+    end
+
+    def add_particle(particle)
+      particle.init if parented?
+      particles << particle
+    end
+
+    def remove_particle(particle)
+      if particles.delete(particle)
+        particle.cleanup
+      end
+    end
+
+    def add_constraint(constraint)
+      constraint.init if parented?
+      constraints << constraint
+    end
+
+    def remove_constraint(constraint)
+      if constraints.delete(constraint)
+        constraint.cleanup
+      end
+    end
+
+    def init
+      particles.each {|p| p.init}
+      constraints.each {|c| c.init}
+    end
+
+    def draw
+      if renderer
+        renderer.draw(self)
+      else
+        particles.each {|p| p.draw if p.always_redraw? or not p.fixed?}
+        constraints.each {|c| c.draw if c.always_redraw? or not c.fixed?}
+      end
+    end
+    alias paint draw
+
+    def cleanup
+      if renderer
+        renderer.cleanup(self)
+      else
+        particles.each {|p| p.cleanup}
+        constraints.each {|c| c.cleanup}
+      end
+    end
+
+    def all
+      particles + constraints
+    end
+    alias get_all all
+
+    def parented?
+      @is_parented
+    end
+
+    def integrate(dt2)
+      particles.each {|p| p.update(dt2)}
+    end
+
+    def satisfy_constraints
+      constraints.each {|c| c.resolve}
+    end
+
+    def collidable_particles(constraint=nil)
+      particles.select do |p| 
+        p.collidable? and (constraint.nil? or not constraint.is_connected_to?(p))
+      end
+    end
+
+    def collidable_constraints(particle=nil)
+      constraints.select do |c| 
+        c.collidable? and (particle.nil? or not c.is_connected_to?(particle))
+      end
+    end
+
+    def check_internal_collisions
+      collidable_particles.each do |pa|
+        collidable_particles.each do |pb|
+          CollisionDetector.test(pa, pb)
+        end
+
+        collidable_constraints(pa).each do |c|
+          c.scp.update_position
+          CollisionDetector.test(pa, c.scp)
+        end
+      end
+    end
+
+    def check_collisions_vs_collection(collection)
+      # every particle in this collection...
+      collidable_particles.each do |pga|
+        # ...vs every particle in the other collection
+        collection.collidable_particles.each do |pgb|
+          CollisionDetector.test(pga, pgb)
+        end
+
+        # ...vs every constraint in the other collection
+        collection.collidable_constraints(pga).each do |cgb|
+          cgb.scp.update_position
+          CollisionDetector.test(pga, cgb.scp)
+        end
+      end
+
+      # every constraint in this collection...
+      collidable_constraints.each do |cga|
+        collection.collidable_particles(cga).each do |pgb|
+          cga.scp.update_position
+          CollisionDetector.test(pgb, cga.scp)
+        end
+      end
+    end
+  end
+end

data/lib/pongo/abstract_constraint.rb

@@ -0,0 +1,25 @@
+require 'pongo/abstract_item'
+
+module Pongo
+  # The abstract base class for all constraints. 
+  #
+  # You should not instantiate this class directly -- instead use one of the subclasses.
+  class AbstractConstraint < AbstractItem
+    # The stiffness of the constraint. Higher values result in result in 
+    # stiffer constraints. Values should be > 0 and <= 1. Depending on the situation, 
+    # setting constraints to very high values may result in instability.
+    attr_accessor :stiffness
+
+    def initialize(stiffness)
+      super()
+      @stiffness = stiffness
+      set_style
+    end
+
+    # Corrects the position of the attached particles based on their position and
+    # mass. This method is called automatically during the APEngine.step() cycle.
+    def resolve
+      raise SubclassResponsibilityError
+    end
+  end
+end

data/lib/pongo/abstract_item.rb

@@ -0,0 +1,93 @@
+module Pongo
+  class AbstractItem
+    attr_accessor :solid, :visible, :always_repaint, :renderer
+    attr_reader :line_thickness, :line_color, :line_alpha, :fill_color, :fill_alpha, :display_object, :display_object_offset, :display_object_rotation
+    attr_reader :user_data
+
+    def initialize
+      @solid = true
+      @visible = true
+      @always_repaint = false
+      @events = Hash.new
+      @user_data = {}
+    end
+
+    def visible?
+      @visible
+    end
+
+    def visible!
+      @visible = true
+    end
+
+    def renderer
+      @renderer || APEngine.renderer
+    end
+
+    # This method is automatically called when an item's parent group is added to the engine,
+    # an item's Composite is added to a Group, or the item is added to a Composite or Group.
+    def init
+      cleanup
+      draw
+    end
+
+    def cleanup
+      renderer.cleanup(self)
+    end
+
+    def draw
+      renderer.draw(self)
+    end
+    alias paint draw
+
+    def has_event_listener(event_type)
+      @events[event_type]
+    end
+
+    def add_event_listener(event_type, callable=nil, &block)
+      (@events[event_type] ||= []) << (callable || block)
+    end
+
+    def dispatch_event(event)
+      (@events[event.type] || []).each do |listener|
+        listener.call(event)
+      end
+    end
+
+    # For performance, fixed Particles and SpringConstraints don't have their <code>paint()</code>
+    # method called in order to avoid unnecessary redrawing. A SpringConstraint is considered
+    # fixed if its two connecting Particles are fixed. Setting this property to <code>true</code>
+    # forces <code>paint()</code> to be called if this Particle or SpringConstraint <code>fixed</code>
+    # property is true. If you are rotating a fixed Particle or SpringConstraint then you would set 
+    # it's repaintFixed property to true. This property has no effect if a Particle or 
+    # SpringConstraint is not fixed.
+    def always_redraw?
+      @always_repaint
+    end
+    alias always_redraw always_redraw?
+
+    def always_redraw=(bool)
+      @always_repaint = bool
+    end
+
+    def always_redraw!
+      @always_repaint = true
+    end
+
+    def set_style(line_thickness=0, line_color=0x000000, line_alpha=1, fill_color=0xffffff, fill_alpha=1)
+      set_line(line_thickness, line_color, line_alpha)
+      set_fill(fill_color, fill_alpha)
+    end
+
+    def set_line(thickness=0, color=0x000000, alpha=1)
+      @line_thickness = thickness
+      @line_color = color
+      @line_alpha = alpha
+    end
+
+    def set_fill(color=0xffffff, alpha=1)
+      @fill_color = color
+      @fill_alpha = alpha
+    end
+  end
+end