rationalize lib

Author: monkstone

samples/external_library/ruby_gem/jbox2d/lib/boundary.rb

@@ -1,30 +1,37 @@
-require 'forwardable'
-
-# The boundary class is used to create fixtures
 class Boundary
-  extend Forwardable
-  def_delegators(:@app, :fill, :stroke, :rect, :rect_mode, :box2d)
-  attr_reader :x, :y, :w, :h, :b
-  def initialize(app, x, y, w, h)
-    @app, @x, @y, @w, @h = app, x, y, w, h
+  include Processing::Proxy
+  attr_reader :box2d, :b, :pos, :size, :a
+  
+  def initialize(b2d, pos, sz, a = 0)
+    @box2d, @pos, @size, @a = b2d, pos, sz, a
+    # Define the polygon
     sd = PolygonShape.new
-    box2d_w = box2d.scale_to_world(w / 2)
-    box2d_h = box2d.scale_to_world(h / 2)
-    sd.setAsBox(box2d_w, box2d_h)
+    # Figure out the box2d coordinates
+    box2d_w = box2d.scale_to_world(size.x / 2)
+    box2d_h = box2d.scale_to_world(size.y / 2)
+    # We're just a box
+    sd.set_as_box(box2d_w, box2d_h)
     # Create the body
     bd = BodyDef.new
     bd.type = BodyType::STATIC
-    bd.position.set(box2d.processing_to_world(x, y))
+    bd.angle = a
+    bd.position.set(box2d.processing_to_world(pos.x, pos.y))
     @b = box2d.create_body(bd)
     # Attached the shape to the body using a Fixture
     b.create_fixture(sd, 1)
   end
 
-  # Draw the boundary, if it were at an angle we'd have to do something fancier
+  # Draw the boundary, it doesn't move so we don't have to ask the Body for location
   def display
     fill(0)
     stroke(0)
-    rect_mode(Java::ProcessingCore::PConstants::CENTER)
-    rect(x, y, w, h)
+    stroke_weight(1)
+    rect_mode(CENTER)
+    a = b.get_angle
+    push_matrix
+    translate(pos.x, pos.y)
+    rotate(-a)
+    rect(0, 0, size.x,size.y)
+    pop_matrix
   end
 end

samples/external_library/ruby_gem/jbox2d/lib/custom_listener.rb

@@ -1,5 +1,3 @@
-require 'pbox2d'
-
 class CustomShape
   include Processing::Proxy
   # We need to keep track of a Body and a width and height
@@ -15,16 +13,16 @@ def initialize(b2d, x, y)
   # This function removes the particle from the box2d world
   def kill_body!
     box2d.destroy_body(body)
-    true
   end
 
   # Is the particle ready for deletion?
-  def done?
+  def done
     # Let's find the screen position of the particle
     pos = box2d.body_coord(body)
     # Is it off the bottom of the screen?
     return false unless pos.y > box2d.height
     kill_body!
+    true
   end
 
   # Drawing the box
@@ -73,63 +71,4 @@ def make_body(center)
   end
 end
 
-class Boundary
-  include Processing::Proxy
-  attr_reader :box2d, :b, :x, :y, :w, :h
-  def initialize(b2d, x, y, w, h, a)
-    @box2d, @x, @y, @w, @h = b2d, x, y, w, h
-    # Define the polygon
-    sd = PolygonShape.new
-    # Figure out the box2d coordinates
-    box2d_w = box2d.scale_to_world(w / 2)
-    box2d_h = box2d.scale_to_world(h / 2)
-    # We're just a box
-    sd.set_as_box(box2d_w, box2d_h)
-    # Create the body
-    bd = BodyDef.new
-    bd.type = BodyType::STATIC
-    bd.angle = a
-    bd.position.set(box2d.processing_to_world(x, y))
-    @b = box2d.create_body(bd)
-    # Attached the shape to the body using a Fixture
-    b.create_fixture(sd, 1)
-  end
-
-  # Draw the boundary, it doesn't move so we don't have to ask 
-  # the Body for location
-  def display
-    fill(0)
-    stroke(0)
-    stroke_weight(1)
-    rect_mode(CENTER)
-    a = b.get_angle
-    push_matrix
-    translate(x, y)
-    rotate(-a)
-    rect(0, 0, w, h)
-    pop_matrix
-  end
-end
-
-module Runnable
-  def run
-    reject! { |item| item.done? }
-    each { |item| item.display }
-  end
-end
 
-class ParticleSystem
-  include Enumerable, Runnable
-  extend Forwardable
-  attr_reader :particles
-  
-  def_delegators(:@particles, :each, :reject!, :<<)
-  
-  def initialize
-    @particles = []    
-  end
-  
-  def add_shape(b2d, x, y)
-    @particles  << CustomShape.new(b2d, x, y)
-  end
-end

samples/external_library/ruby_gem/jbox2d/lib/custom_shape.rb

@@ -2,8 +2,8 @@
 
 module Runnable
   def run
-    reject!(&:done)
-    each(&:display)
+    reject! { |item| item.done }
+    each { |item| item.display }
   end
 end
 
@@ -14,18 +14,18 @@ class ParticleSystem
   def_delegator(:@particles, :empty?, :dead?)
 
   attr_reader :x, :y
-
-  def initialize(app, num, x, y)
+  
+  def initialize(bd, num, x, y)
     @particles = []          # Initialize the Array
-    @x, @y = x, y            # Store the origin point
+    @x, @y = x, y            # Store the origin point  
     num.times do
-      self << Particle.new(app, x, y)
+      self << Particle.new(bd, x, y)
     end
   end
-
-  def add_particles(app, n)
+  
+  def add_particles(bd, n)
     n.times do
-      self << Particle.new(app, x, y)
+      self << Particle.new(bd, x, y)
     end
   end
 end
@@ -34,40 +34,37 @@ def add_particles(app, n)
 require 'pbox2d'
 
 class Particle
-  extend Forwardable
-  def_delegators(:@app, :box2d, :begin_shape, :end_shape,
-                 :vertex, :translate, :rotate, :stroke,
-                 :fill, :no_fill, :stroke_weight)
+  include Processing::Proxy
   TRAIL_SIZE = 6
   # We need to keep track of a Body
-
-  attr_reader :trail, :body
-
+  
+  attr_reader :trail, :body, :box2d
+  
   # Constructor
-  def initialize(app, x, y)
-    @app = app
+  def initialize(b2d, x, y)
+    @box2d = b2d
     @trail = Array.new(TRAIL_SIZE, [x, y])
     # Add the box to the box2d world
     # Here's a little trick, let's make a tiny tiny radius
     # This way we have collisions, but they don't overwhelm the system
     make_body(x, y, 0.2)
   end
-
+  
   # This function removes the particle from the box2d world
   def kill_body
     box2d.destroy_body(body)
   end
-
+  
   # Is the particle ready for deletion?
   def done
     # Let's find the screen position of the particle
     pos = box2d.body_coord(body)
     # Is it off the bottom of the screen?
-    return false unless pos.y > box2d.height + 20
+    return false unless (pos.y > box2d.height + 20)
     kill_body
     true
   end
-
+  
   # Drawing the box
   def display
     # We look at each body and get its screen position
@@ -87,7 +84,7 @@ def display
     end
     end_shape
   end
-
+  
   # This function adds the rectangle to the box2d world
   def make_body(x, y, r)
     # Define and create the body
@@ -111,44 +108,3 @@ def make_body(x, y, r)
     body.create_fixture(fd)
   end
 end
-
-class Boundary
-  extend Forwardable
-  def_delegators(:@app, :box2d, :push_matrix, :pop_matrix, :stroke, :width,
-                 :vertex, :translate, :rotate, :rect_mode, :rect,
-                 :fill, :no_fill, :stroke_weight)
-  attr_reader :b, :x, :y, :h
-
-  def initialize(app, x, y, h, a)
-    @app, @x, @y, @h = app, x, y, h
-    # Define the polygon
-    sd = PolygonShape.new
-    # Figure out the box2d coordinates
-    box2d_w = box2d.scale_to_world(width / 2)
-    box2d_h = box2d.scale_to_world(h / 2)
-    # We're just a box
-    sd.set_as_box(box2d_w, box2d_h)
-    # Create the body
-    bd = BodyDef.new
-    bd.type = BodyType::STATIC
-    bd.angle = a
-    bd.position.set(box2d.processing_to_world(x, y))
-    @b = box2d.create_body(bd)
-    # Attached the shape to the body using a Fixture
-    b.create_fixture(sd, 1)
-  end
-
-  # Draw the boundary, it doesn't move so we don't have to ask the Body for location
-  def display
-    fill(0)
-    stroke(0)
-    stroke_weight(1)
-    rect_mode(Java::ProcessingCore::PConstants::CENTER)
-    a = b.get_angle
-    push_matrix
-    translate(x, y)
-    rotate(-a)
-    rect(0, 0, width, h)
-    pop_matrix
-  end
-end