technohippy-Pongo 0.1.0

data/lib/pongo/iforce.rb

@@ -0,0 +1,7 @@
+module Pongo
+  class IForce
+    def get_value(inv_mass)
+      raise NotImplementedError
+    end
+  end
+end

data/lib/pongo/logger/logger.rb

@@ -0,0 +1,21 @@
+module Pongo
+  module Logger
+    class Logger
+      def print(message)
+        puts(message)
+      end
+
+      def error(message)
+        print("Error: #{message}")
+      end
+
+      def warn(message)
+        print("Warn: #{message}")
+      end
+
+      def info(message)
+        print("Info: #{message}")
+      end
+    end
+  end
+end

data/lib/pongo/logger/shoes_logger.rb

@@ -0,0 +1,15 @@
+require 'pongo/logger/logger'
+
+module Pongo
+  module Logger
+    class ShoesLogger < Logger
+      def initialize(shoes)
+        @shoes = shoes
+      end
+
+      def print(message)
+        @shoes.info(message)
+      end
+    end
+  end
+end

data/lib/pongo/logger/standard_logger.rb

@@ -0,0 +1,11 @@
+require 'pongo/logger/logger'
+
+module Pongo
+  module Logger
+    class StandardLogger < Logger
+      def print(message)
+        puts message
+      end
+    end
+  end
+end

data/lib/pongo/rectangle_particle.rb

@@ -0,0 +1,79 @@
+require 'pongo/abstract_particle'
+require 'pongo/util/math_util'
+
+module Pongo
+  class RectangleParticle < AbstractParticle
+    attr_accessor :extents, :axes, :radian 
+
+    def initialize(x, y, width, height, options={})
+      options = {:rotation => 0.0, :fixed => false, :mass => 1.0, :elasticity => 0.3, :friction => 0.0}.update(options)
+      super(x, y, options[:fixed], options[:mass], options[:elasticity], options[:friction])
+      @extents = [width/2.0, height/2.0]
+      @axes = [Vector.new, Vector.new]
+      self.radian = options[:rotation]
+    end
+
+    # The rotation of the RectangleParticle in radians. For drawing methods you may 
+    # want to use the <code>angle</code> property which gives the rotation in
+    # degrees from 0 to 360.
+    # 
+    # Note that while the RectangleParticle can be rotated, it does not have angular
+    # velocity. In otherwords, during collisions, the rotation is not altered, 
+    # and the energy of the rotation is not applied to other colliding particles.
+    def radian=(rad)
+      @radian = rad
+      set_axes(rad)
+    end
+
+    # The rotation of the RectangleParticle in degrees. 
+    def angle
+      self.radian * MathUtil::ONE_EIGHTY_OVER_PI
+    end
+    alias degree angle
+
+    def angle=(deg)
+      self.radian = deg * MathUtil::PI_OVER_ONE_EIGHTY
+    end
+    alias degree= angle=
+
+    def width=(w)
+      @extents[0] = w / 2.0
+    end
+
+    def width
+      @extents[0] * 2.0
+    end
+
+    def height=(h)
+      @extents[1] = h / 2.0
+    end
+
+    def height
+      @extents[1] * 2.0
+    end
+
+    def projection(axis)
+      radius = 
+        self.extents[0] * axis.dot(axes[0]).abs +
+        self.extents[1] * axis.dot(axes[1]).abs
+
+      c = @samp.dot(axis)
+
+      @interval.min = c - radius
+      @interval.max = c + radius
+      @interval
+    end
+    alias get_projection projection
+
+    def set_axes(rad)
+      s = Math.sin(rad)
+      c = Math.cos(rad)
+
+      self.axes[0].x = c
+      self.axes[0].y = s
+      self.axes[1].x = -s
+      self.axes[1].y = c
+    end
+    #alias axes= set_axes
+  end
+end

data/lib/pongo/renderer/renderer.rb

@@ -0,0 +1,61 @@
+module Pongo
+  module Renderer
+    class Renderer
+      def cleanup(item)
+        case item
+        when CircleParticle
+          cleanup_circle(item)
+        when RectangleParticle
+          cleanup_rectangle(item)
+        when WheelParticle
+          cleanup_wheel(item)
+        when SpringConstraint
+          cleanup_spring(item)
+        else
+          raise UnknownItemError.new(item.class.name)
+        end
+      end
+      def cleanup_circle(item); end
+      def cleanup_rectangle(item); end
+      def cleanup_wheel(item); end
+      def cleanup_spring(item); end
+
+      def draw(item)
+        return unless item.visible?
+        case item
+        when CircleParticle
+          draw_circle(item)
+        when RectangleParticle
+          draw_rectangle(item)
+        when WheelParticle
+          draw_wheel(item)
+        when SpringConstraint
+          draw_spring(item)
+        when AbstractCollection
+          item.particles.each {|p| p.draw if p.always_redraw? or not p.fixed?}
+          item.constraints.each {|c| c.draw if c.always_redraw? or not c.fixed?}
+        else
+          raise UnknownItemError.new(item.class.name)
+        end
+      end
+      def draw_circle(item); end
+      def draw_rectangle(item); end
+      def draw_wheel(item); end
+      def draw_spring(item); end
+
+      def with(options, &block)
+        @shoes.nostroke if options[:nostroke]
+        @shoes.stroke(options[:stroke]) if options[:stroke]
+        @shoes.fill(options[:fill]) if options[:fill]
+        @shoes.transform(options[:transform]) if options[:transform]
+        @shoes.rotate(options[:rotate]) if options[:rotate]
+        block.call(@shoes)
+        @shoes.rotate(-options[:rotate]) if options[:rotate]
+        @shoes.transform(:corner) if options[:transform]
+        @shoes.fill(@shoes.black) if options[:fill]
+        @shoes.stroke(@shoes.black) if options[:stroke]
+        @shoes.stroke(@shoes.black) if options[:nostroke]
+      end
+    end
+  end
+end

data/lib/pongo/renderer/shoes_renderer.rb

@@ -0,0 +1,51 @@
+require 'pongo/renderer/renderer'
+
+module Pongo
+  module Renderer
+    class ShoesRenderer < Renderer
+      attr_reader :shoes
+
+      def initialize(shoes)
+        @shoes = shoes
+      end
+
+      def draw_circle(item)
+        if item.user_data[:shape]
+          item.user_data[:shape].style(
+            :left => item.px - item.radius, 
+            :top => item.py - item.radius
+          )
+        else
+          item.user_data[:shape] = @shoes.oval(
+            item.px - item.radius, 
+            item.py - item.radius, 
+            item.radius * 2
+          )
+        end
+      end
+      alias draw_wheel draw_circle
+
+      def draw_rectangle(item)
+        item.user_data[:shape].remove if item.user_data[:shape]
+        with(:transform => :center, :rotate => -item.angle) do
+          item.user_data[:shape] = 
+            @shoes.rect(
+              :left => (item.px - item.width/2), 
+              :top => (item.py - item.height/2), 
+              :width => item.width, 
+              :height => item.height
+            )
+          end
+      end
+
+      def draw_spring(item)
+        if item.collidable?
+          draw_rectangle(item.scp)
+        else
+          item.user_data[:shape].remove if item.user_data[:shape]
+          item.user_data[:shape] = @shoes.line(item.p1.px, item.p1.py, item.p2.px, item.p2.py)
+        end
+      end
+    end
+  end
+end

data/lib/pongo/renderer/tk_renderer.rb

@@ -0,0 +1,73 @@
+require 'pongo/renderer/renderer'
+
+module Pongo
+  module Renderer
+    class TkRenderer < Renderer
+      def initialize(canvas)
+        @canvas = canvas
+      end
+
+      def draw_circle(item)
+        if item.user_data[:shape]
+          item.user_data[:shape].coords(
+            item.px - item.radius, 
+            item.py - item.radius,
+            item.px + item.radius, 
+            item.py + item.radius
+          )
+        else
+          item.user_data[:shape] =TkcOval.new(@canvas, 
+            item.px - item.radius, 
+            item.py - item.radius,
+            item.px + item.radius, 
+            item.py + item.radius,
+            :fill => 'black'
+          )
+        end
+      end
+      alias draw_wheel draw_circle
+
+      def draw_rectangle(item)
+        c = Vector.new(item.px, item.py)
+        x1 = -item.width/2 
+        y1 = -item.height/2 
+        x2 = item.width/2 
+        y2 = item.height/2
+        p1 = Vector.new(x1, y1).rotate!(item.radian) + c
+        p2 = Vector.new(x1, y2).rotate!(item.radian) + c
+        p3 = Vector.new(x2, y2).rotate!(item.radian) + c
+        p4 = Vector.new(x2, y1).rotate!(item.radian) + c
+        if item.user_data[:shape]
+          item.user_data[:shape].coords(
+            p1.x, p1.y,
+            p2.x, p2.y,
+            p3.x, p3.y,
+            p4.x, p4.y
+          )
+        else
+          item.user_data[:shape] = TkcPolygon.new(@canvas,
+            p1.x, p1.y,
+            p2.x, p2.y,
+            p3.x, p3.y,
+            p4.x, p4.y,
+            :fill => 'black'
+          )
+        end
+      end
+
+      def draw_spring(item)
+        if item.collidable?
+          draw_rectangle(item.scp)
+        else
+          if item.user_data[:shape]
+            item.user_data[:shape].coords(item.p1.px, 
+              item.p1.py, item.p2.px, item.p2.py)
+          else
+            item.user_data[:shape] =TkcLine.new(@canvas, item.p1.px, 
+              item.p1.py, item.p2.px, item.p2.py)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/pongo/rim_particle.rb

@@ -0,0 +1,53 @@
+require 'pongo/util/math_util'
+
+module Pongo
+  class RimParticle
+    attr_accessor :curr, :prev, :wr, :angular_velocity, :speed, :max_torque
+
+    # The RimParticle is really just a second component of the wheel model.
+    # The rim particle is simulated in a coordsystem relative to the wheel's 
+    # center, not in worldspace.
+    # 
+    # Origins of this code are from Raigan Burns, Metanet Software
+    def initialize(r, mt)
+      @curr = Vector.new(r, 0)
+      @prev = Vector.new(0, 0)
+      @speed = 0
+      @angular_velocity = 0
+      @max_torque = mt
+      @wr = r
+    end
+
+    def update(dt)
+      @speed = MathUtil.max(-@max_torque, MathUtil.min(@max_torque, @speed + @angular_velocity))
+
+      # apply torque
+      # this is the tangent vector at the rim particle
+      dx = -@curr.y
+      dy = @curr.x
+
+      # normalize so we can scale by the rotational speed
+      len = Math.sqrt(dx * dx + dy * dy)
+      dx /= len
+      dy /= len
+
+      @curr.x += @speed * dx
+      @curr.y += @speed * dy
+
+      ox = @prev.x
+      oy = @prev.y
+      px = @prev.x = @curr.x
+      py = @prev.y = @curr.y
+
+      @curr.x += APEngine.damping * (px - ox)
+      @curr.y += APEngine.damping * (py - oy)
+
+      # hold the rim particle in place
+      clen = @curr.magnitude
+      diff = (clen - wr) / clen
+
+      @curr.x -= @curr.x * diff
+      @curr.y -= @curr.y * diff
+    end
+  end
+end

data/lib/pongo/spring_constraint.rb

@@ -0,0 +1,128 @@
+require 'pongo/abstract_constraint'
+require 'pongo/spring_constraint_particle'
+require 'pongo/util/math_util'
+
+module Pongo
+  class SpringConstraint < AbstractConstraint
+    attr_accessor :p1, :p2, :rest_length, :collidable, :scp
+
+    def initialize(p1, p2, options={})
+      options = {:stiffness => 0.5, :collidable => false, :rect_height => 1, :rect_scale => 1, :scale_to_length => false}.update(options)
+      super(options[:stiffness])
+      @p1 = p1
+      @p2 = p2
+      check_particles_location
+      @rest_length = curr_length
+      set_collidable(options[:collidable], options[:rect_height], options[:rect_scale], options[:scale_to_length])
+    end
+
+    def radian
+      d = delta
+      Math.atan2(d.y, d.x)
+    end
+
+    def angle
+      radian * MathUtil::ONE_EIGHTY_OVER_PI
+    end
+
+    def center
+      (@p1.curr + @p2.curr) / 2
+    end
+
+    def rect_scale=(s)
+      if @scp
+        @scp.rect_scale = s
+      end
+    end
+
+    def rect_scale
+      @scp.rect_scale
+    end
+
+    def curr_length
+      @p1.curr.distance(@p2.curr)
+    end
+
+    def rect_height
+      @scp.rect_height
+    end
+
+    def rect_height=(h)
+      if @scp
+        @scp.rect_height = h
+      end
+    end
+
+    def rest_length=(r)
+      raise ArgumentError.new('restLength must be greater than 0') if r <= 0
+      @rest_length = r
+    end
+
+    def collidable?
+      @collidable
+    end
+
+    def fixed_end_limit
+      @scp.fixed_end_limit
+    end
+
+    def fixed_end_limit=(f)
+      if @scp
+        @scp.fixed_end_limit = f
+      end
+    end
+
+    def set_collidable(b, rect_height, rect_scale, scale_to_length)
+      if @collidable = b
+        @scp = SpringConstraintParticle.new(@p1, @p2, self, rect_height, rect_scale, scale_to_length)
+      else
+        @scp = nil
+      end
+    end
+
+    def is_connected_to?(p)
+      [@p1, @p2].include? p
+    end
+
+    def fixed
+      @p1.fixed? and @p2.fixed?
+    end
+    alias fixed? fixed
+
+    def init
+      cleanup
+      if collidable?
+        @scp.init
+      else
+        init_display
+      end
+      draw
+    end
+
+    def resolve
+      return if fixed?
+
+      delta_length = curr_length
+      diff = (delta_length - rest_length) / 
+        (delta_length * (@p1.inv_mass + @p2.inv_mass))
+      dmds = delta * (diff * stiffness)
+
+      @p1.curr.minus!(dmds * @p1.inv_mass)
+      @p2.curr.plus!( dmds * @p2.inv_mass)
+    end
+
+    def init_display
+      #raise NotImplementedError
+    end
+
+    def delta
+      @p1.curr - @p2.curr
+    end
+
+    def check_particles_location
+      if @p1.curr.x == @p2.curr.x and @p1.curr.y == @p2.curr.y
+        @p2.curr.x += 0.0001
+      end
+    end
+  end
+end