technohippy-Pongo 0.1.0

data/lib/pongo/abstract_particle.rb

@@ -0,0 +1,226 @@
+module Pongo
+  # The abstract base class for all particles.
+  #
+  # You should not instantiate this class directly -- instead use one of the subclasses.
+  class AbstractParticle < AbstractItem
+    attr_accessor :curr, :prev, :samp, :interval, :temp, :forces, :force_list, :collision, :first_collision
+    attr_accessor :kfr, :mass, :inv_mass, :friction, :fixed, :collidable, :center, :multisample
+
+    def initialize(x, y, is_fixed, mass, elasticity, friction) 
+      super()
+      @interval = Interval.new
+      @curr = Vector.new(x, y)
+      @prev = Vector.new(x, y)
+      @samp = Vector.new
+      @temp = Vector.new
+      @fixed = is_fixed
+      @forces = Vector.new
+      @force_list = []
+      @collision = Collision.new
+      @collidable = true
+      @first_collision = false
+      self.mass = mass
+      self.elasticity = elasticity
+      self.friction = friction
+      set_style
+      @center = Vector.new
+      @multisample = 0
+    end
+
+    def mass=(m)
+      raise ArgumentError.new('mass may not be set <= 0') if m <= 0
+      @mass = m
+      @inv_mass = 1.0 / m
+    end
+
+    # The elasticity of the particle. Standard values are between 0 and 1. 
+    # The higher the value, the greater the elasticity.
+    # 
+    # During collisions the elasticity values are combined. If one particle's
+    # elasticity is set to 0.4 and the other is set to 0.4 then the collision will
+    # be have a total elasticity of 0.8. The result will be the same if one particle
+    # has an elasticity of 0 and the other 0.8.
+    # 
+    # Setting the elasticity to greater than 1 (of a single particle, or in a combined
+    # collision) will cause particles to bounce with energy greater than naturally 
+    # possible.
+    def elasticity
+      @kfr
+    end
+
+    def elasticity=(k)
+      @kfr = k
+    end
+
+    def center
+      @center.set_to(px, py)
+      @center
+    end
+
+    # The surface friction of the particle. Values must be in the range of 0 to 1.
+    # 
+    # 0 is no friction (slippery), 1 is full friction (sticky).
+    # 
+    # During collisions, the friction values are summed, but are clamped between 1 
+    # and 0. For example, If two particles have 0.7 as their surface friction, then
+    # the resulting friction between the two particles will be 1 (full friction).
+    #
+    # There is a bug in the current release where colliding non-fixed particles with
+    # friction greater than 0 will behave erratically. A workaround is to only set 
+    # the friction of fixed particles.
+    def friction=(f)
+      raise ArgumentError.new('Legal friction must be >= 0 and <= 1') if f < 0 or 1 < f
+      @friction = f
+    end
+
+    def fixed?
+      @fixed
+    end
+
+    # The position of the particle. Getting the position of the particle is useful
+    # for drawing it or testing it for some custom purpose. 
+    # 
+    # <p>
+    # When you get the <code>position</code> of a particle you are given a copy of 
+    # the current location. Because of this you cannot change the position of a 
+    # particle by altering the <code>x</code> and <code>y</code> components of the 
+    # Vector you have retrieved from the position property. You have to do something
+    # instead like: <code> position = new Vector(100,100)</code>, or you can use the
+    # <code>px</code> and <code>py</code> properties instead.
+    # </p>
+    # 
+    # <p>
+    # You can alter the position of a particle three ways: change its position, set
+    # its velocity, or apply a force to it. Setting the position of a non-fixed 
+    # particle is not the same as setting its fixed property to true. A particle held
+    # in place by its position will behave as if it's attached there by a 0 length
+    # spring constraint. 
+    def position
+      @curr.dup
+    end
+
+    def position=(p)
+      @curr.copy(p)
+      @prev.copy(p)
+    end
+
+    def px
+      @curr.x
+    end
+
+    def px=(x)
+      @curr.x = x
+      @prev.x = x
+    end
+
+    def py
+      @curr.y
+    end
+
+    def py=(y)
+      @curr.y = y
+      @prev.y = y
+    end
+
+    # The velocity of the particle. If you need to change the motion of a particle, 
+    # you should either use this property, or one of the addForce methods. Generally,
+    # the addForce methods are best for slowly altering the motion. The velocity 
+    # property is good for instantaneously setting the velocity, e.g., for 
+    # projectiles.
+    def velocity
+      @curr - @prev
+    end
+
+    def velocity=(v)
+      @prev = @curr - v
+    end
+
+    # Determines if the particle can collide with other particles or constraints.
+    # The default state is true.
+    def collidable?
+      @collidable
+    end
+
+    def collidable!
+      @collidable = true
+    end
+
+    # Adds a force to the particle. Using this method to a force directly to the
+    # particle will only apply that force for a single APEngine.step() cycle. 
+    def add_force(force)
+      @force_list << force
+    end
+
+    # The <code>update()</code> method is called automatically during the
+    # APEngine.step() cycle. This method integrates the particle.
+    def update(dt2)
+      return if fixed?
+
+      accumulate_forces
+
+      @temp.copy(@curr)
+      nv = velocity + @forces.mult!(dt2)
+      @curr.plus!(nv.mult!(APEngine.damping))
+      @prev.copy(@temp)
+
+      clear_forces
+    end
+
+    # Resets the collision state of the particle. This value is used in conjuction
+    # with the CollisionEvent.FIRST_COLLISION event.
+    def reset_first_collision!
+      @first_collision = false
+    end
+    alias reset_first_collision reset_first_collision!
+
+    def components(collision_normal)
+      vel = velocity
+      vdotn = collision_normal.dot(vel)
+      @collision.vn = collision_normal * vdotn
+      @collision.vt = vel - collision.vn
+      @collision
+    end
+    alias get_components components
+
+    # Make sure to align  the overriden versions of this method in
+    # WheelParticle
+    def resolve_collision(mtd, vel, n, d, order, particle)
+      test_particle_events(particle)
+      return if fixed? or (not solid?) or (not particle.solid?)
+      @curr.copy(@samp)
+      @curr.plus!(mtd)
+      self.velocity = vel
+    end
+
+    def test_particle_events(p)
+      if has_event_listener(CollisionEvent::COLLIDE)
+        dispatch_event(CollisionEvent.new(CollisionEvent::COLLIDE, p))
+      end
+      if has_event_listener(CollisionEvent::FIRST_COLLIDE) and not @first_collision
+        @first_collision = true
+        dispatch_event(CollisionEvent.new(CollisionEvent::FIRST_COLLIDE, p))
+      end
+    end
+
+    def inv_mass
+      fixed? ? 0 : @inv_mass
+    end
+
+    # Accumulates both the particle forces and the global forces
+    def accumulate_forces
+      @force_list.each {|f| @forces.plus!(f.get_value(@inv_mass))}
+      APEngine.forces.each {|f| @forces.plus!(f.get_value(@inv_mass))}
+      @forces
+    end
+
+    # Clears out all forces on the particle
+    def clear_forces
+      @force_list.clear
+      @forces.set_to(0, 0)
+    end
+
+    def solid?
+      @solid
+    end
+  end
+end

data/lib/pongo/angular_constraint.rb

@@ -0,0 +1,108 @@
+require 'pongo/spring_constraint'
+
+module Pongo
+  # An Angular Constraint between 3 particles
+  class AngularConstraint < SpringConstraint
+    attr_accessor :p3, :min_ang, :max_ang, :min_break_ang, :max_break_ang
+
+    def initialize(p1, p2, p3, min_ang, max_ang, options={})
+      options = {:min_break_ang => -10, :max_break_ang => 10, :stiffness => 0.5, 
+        :dependent => false, :collidable => false, :rect_height => 1, :rect_scale => 1, 
+        :scale_to_length => false}.update(options)
+
+      super(p2, p2, stiffness, false, dependent, collidable, rect_height, rect_scale, scale_to_length)
+
+      self.p3 = p3
+      if min_ang == 10
+        self.min_ang = ac_radian
+        self.max_ang = ac_radian
+      else
+        self.min_ang = min_ang
+        self.max_ang = max_ang
+      end
+      self.min_break_ang = min_break_ang
+      self.max_break_ang = max_break_ang
+    end
+
+    # The current difference between the angle of p1, p2, and p3 and a straight line (pi)
+    def ac_radian
+      ang12 = Math.atan2(@p2.curr.y - @p1.curr.y, @p2.curr.x - @p1.curr.x)
+      ang23 = Math.atan2(@p3.curr.y - @p2.curr.y, @p3.curr.x - @p2.curr.x)
+      ang12 - ang23
+    end
+
+    # Returns true if the passed particle is one of the three particles attached 
+    # to this AngularConstraint.
+    def is_connected_to?(p)
+      [@p1, @p2, @p3].include?(p)
+    end
+
+    # Returns true if any connected particle's <code>fixed</code> property is true.
+    def fixed?
+      @p1.fixed? and @p2.fixed? and @p3.fixed?
+    end
+    alias fixed fixed?
+
+    def resolve
+      return if broken
+      
+      ang12 = Math.atan2(@p2.curr.y - @p1.curr.y, @p2.curr.x - @p1.curr.x)
+      ang23 = Math.atan2(self.p3.curr.y - @p2.curr.y, self.p3.curr.x - @p2.curr.x)
+
+      ang_diff = normalize_angle(ang12 - ang23)
+
+      p2_inv_mass = dependent ? 0 : @p2.inv_mass
+
+      sum_inv_mass = @p1.inv_mass + p2_inv_mass
+      mult1 = @p1.inv_mass / sum_inv_mass
+      mult2 = p2_inv_mass / sum_inv_mass
+      ang_change = 0
+
+      low_mid = (self.max_ang - self.min_ang) / 2
+      high_mid = (self.max_ang + self.min_ang) / 2
+      break_ang = (self.max_break_ang - self.min_break_ang) / 2
+
+      new_diff = normalize_angle(high_mid - ang_diff)
+
+      if new_diff > low_mid
+        if new_diff > break_ang
+          diff = new_diff - break_ang
+          broken = true
+          if has_event_listener(BreakEvent::ANGULAR)
+            dispatch_event(BreakEvent.new(BreakEvent::ANGULAR, diff))
+          end
+          return
+        end
+        ang_change = new_diff - low_mid
+      elsif new_diff < -low_mid
+        if new_diff < -break_ang
+          diff = new_dif + break_ang
+          broken = true
+          if has_event_listener(BreakEvent::ANGULAR)
+            dispatch_event(BreakEvent.new(BreakEvent::ANGULAR, diff))
+          end
+          return
+        end
+        ang_change = new_diff + low_mid
+      end
+
+      final_ang = ang_change * self.stiffness + ang12
+      displace_x = @p1.curr.x + (@p2.curr.x - @p1.curr.x) * mult1
+      displace_y = @p1.curr.y + (@p2.curr.y - @p1.curr.y) * mult1
+
+      @p1.curr.x = displace_x + Math.cos(final_ang + Math::PI) * rest_length * mult1
+      @p1.curr.x = displace_y + Math.sin(final_ang + Math::PI) * rest_length * mult1
+      @p2.curr.x = displace_x + Math.cos(final_ang) * rest_length * mult2
+      @p2.curr.y = displace_y + Math.sin(final_ang) * rest_length * mult2
+    end
+
+    protected
+
+    def normilize_angle(angle)
+      pi2 = Math::PI * 2
+      angle -= pi2 while angle > Math::PI
+      angle += pi2 while angle < -Math::PI
+      angle
+    end
+  end
+end

data/lib/pongo/apengine.rb

@@ -0,0 +1,157 @@
+require 'pongo/group'
+module Pongo
+  # The main engine class. 
+  class PhysicsEngine
+    attr_accessor :forces, :groups, :tile_step, :damping, :container, 
+      :constraint_cycles, :constraint_collision_cycles, :renderer, :logger
+
+    def container=(c)
+      @container = c
+      @renderer = c.renderer
+      @logger = c.logger
+    end
+
+    # Initializes the engine. You must call this method prior to adding any 
+    # particles or constraints.
+    def setup(options={}) #dt=0.25)
+      options = {
+        :dt => 0.25, :damping => 1, :constraint_cycles => 0, 
+        :constraint_collision_cycles => 1
+      }.update(options.is_a?(Numeric) ? {:dt => options} : options)
+
+      @time_step = options[:dt] * options[:dt]
+      @groups = []
+      @forces = []
+      self.damping = options[:damping]
+      self.constraint_cycles = options[:constraint_cycles]
+      self.constraint_collision_cycles = options[:constraint_collision_cycles] 
+
+      self.container = options[:container] if options[:container]
+      self.renderer = options[:renderer] if options[:renderer]
+      self.logger = options[:logger] if options[:logger]
+      self.gravity = options[:gravity] if options[:gravity]
+    end
+    alias init setup
+
+    # Adds a force to all particles in the system. The forces added to the APEngine
+    # class are persistent - once a force is added it is continually applied each
+    # APEngine.step() cycle.
+    def add_force(force)
+      @forces << force
+    end
+
+    def gravity=(val)
+      case val
+      when Numeric
+        add_force(VectorForce.new(false, 0, val))
+      when Array
+        add_force(VectorForce.new(false, *val))
+      when VectorForce
+        add_force(val)
+      else
+        raise ArgumentError
+      end
+    end
+
+    # Removes a force from the engine.
+    def remove_force(force)
+      @forces.remove(force)
+    end
+
+    # Removes all forces from the engine.
+    def remove_all_forces
+      @forces.clear
+    end
+
+    def build_group(collide_internal=false)
+      group = Group.new(collide_internal)
+      @groups << group
+      group
+    end
+
+    # Adds a Group to the engine.
+    def add_group(group)
+      @groups << group
+      group.is_parented = true
+      group.init
+    end
+
+    # Removes a Group from the engine.
+    def remove_group(group)
+      if @groups.delete(group)
+        group.is_parented = false
+        group.cleanup
+      end
+    end
+
+    # The main step function of the engine. This method should be called
+    # continously to advance the simulation. The faster this method is 
+    # called, the faster the simulation will run. Usually you would call
+    # this in your main program loop. 
+    def step
+      integrate
+      constraint_cycles.times do
+        satisfy_constraints
+      end
+      constraint_collision_cycles.times do
+        satisfy_constraints
+        check_collisions
+      end
+    end
+
+    # Calling this method will in turn call each Group's paint() method.
+    # Generally you would call this method after stepping the engine in
+    # the main program cycle.
+    def draw
+      @groups.each {|g| g.draw}
+    end
+    alias paint draw
+
+    def integrate
+      @groups.each {|g| g.integrate(@time_step)}
+    end
+
+    def satisfy_constraints
+      @groups.each {|g| g.satisfy_constraints}
+    end
+
+    def check_collisions
+      @groups.each {|g| g.check_collisions}
+    end
+
+    def <<(item)
+      if item.is_a?(Group)
+        add_group(item)
+      else
+        if @groups.empty?
+          @groups << Group.new(true) 
+          @groups.first.is_parented = true
+          @groups.first.init
+        end
+        @groups.last << item
+      end
+    end
+
+    def create_group(collide_internal=true, &block)
+      @groups << Group.new(collide_internal)
+      block.call(@groups.last) if block
+      @groups.last
+    end
+
+    def next_frame(options={})
+      options[:before].call if options[:before]
+      step
+      draw
+      options[:after].call if options[:after]
+    rescue
+      log($!)
+      raise $!
+    end
+
+    def log(message, level=:info)
+      message = message.message + "\n" + message.backtrace.join("\n") if message.is_a?(Exception)
+      @logger.send(level, message) if @logger
+    end
+  end
+  APEngine = PhysicsEngine.new
+end