pbox2d 0.4.2-java → 0.5.0-java

data/examples/lib/particle_system.rb

@@ -2,8 +2,8 @@ require 'forwardable'
 
 module Runnable
   def run
-    reject!(&:done)
-    each(&:display)
+    reject! { |item| item.done }
+    each { |item| item.display }
   end
 end
 
@@ -14,15 +14,19 @@ class ParticleSystem
   def_delegator(:@particles, :empty?, :dead?)
 
   attr_reader :x, :y
-
-  def initialize(app, num, x, y)
-    @x, @y = x, y            # Store the origin point
-    # initialize array with some particles
-    @particles = Array.new(num, Particle.new(app, x, y))    
+  
+  def initialize(bd, num, x, y)
+    @particles = []          # Initialize the Array
+    @x, @y = x, y            # Store the origin point  
+    num.times do
+      self << Particle.new(bd, x, y)
+    end
   end
-
-  def add_particles(app, n)
-    n.times { self << Particle.new(app, x, y) }
+  
+  def add_particles(bd, n)
+    n.times do
+      self << Particle.new(bd, x, y)
+    end
   end
 end
 
@@ -30,40 +34,37 @@ end
 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
@@ -83,7 +84,7 @@ class Particle
     end
     end_shape
   end
-
+  
   # This function adds the rectangle to the box2d world
   def make_body(x, y, r)
     # Define and create the body
@@ -107,44 +108,3 @@ class Particle
     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

data/examples/lib/shape_system.rb

@@ -1,6 +1,6 @@
 module Runnable
   def run
-    reject! { |item| item.done? }
+    reject! { |item| item.done }
     each { |item| item.display }
   end
 end
@@ -11,13 +11,15 @@ class ShapeSystem
   def_delegators(:@polygons, :each, :reject!, :<<)
 
   attr_reader :bd
-
+  
   def initialize(bd)
     @bd = bd
     @polygons = []          # Initialize the Array
   end
-
+  
   def add_polygon(x, y)
     self << CustomShape.new(bd, x, y)
   end
 end
+
+

data/examples/lib/surface.rb

@@ -133,4 +133,4 @@ class Particle
     body.set_linear_velocity(Vec2.new(rand(-10..10), rand(5..10)))
     body.set_angular_velocity(rand(-10..10))
   end
-end
+end

data/examples/liquid_fun_test.rb

@@ -9,17 +9,19 @@ require_relative 'lib/box'
 
 attr_reader :boxes, :boundaries, :box2d
 
+Vect = Struct.new(:x, :y)
+
 def setup
-  size(640, 360, P2D)
+  sketch_title 'Liquid Fun Test'
   @box2d = Box2D.new(self)
   box2d.init_options(gravity: [0, -10])
-  box2d.create_world
+  box2d.create_world  
   @boxes = []
   box2d.world.set_particle_radius(0.15)
   box2d.world.set_particle_damping(0.2)
   @boundaries = [
-    Boundary.new(self, width / 4, height - 5, width / 2 - 50, 10),
-    Boundary.new(self, 3 * width / 4, height - 50, width / 2 - 50, 10)
+    Boundary.new(box2d, Vect.new(width / 4, height - 5), Vect.new(width / 2 - 50, 10)),
+    Boundary.new(box2d, Vect.new(3 * width / 4, height - 50), Vect.new(width / 2 - 50, 10))
   ]
 end
 
@@ -39,5 +41,9 @@ def draw
     point(pos.x, pos.y)
   end
   fill(0)
-  text(format('f.p.s %d', frame_rate.to_i), 10, 60)
+  text(format('f.p.s %d', frame_rate), 10, 60)
+end
+
+def settings
+  size(640, 360, P2D)
 end

data/examples/liquidy.rb

@@ -1,36 +1,40 @@
 require 'pbox2d'
 require_relative 'lib/particle_system'
+require_relative 'lib/boundary'
 attr_reader :box2d, :boundaries, :systems
 
+Vect = Struct.new(:x, :y)
+
 def setup
-  size(400, 300)
+  sketch_title 'Liquidy'
   @box2d = Box2D.new(self)
   box2d.init_options(gravity: [0, -20])
   box2d.create_world
-  # to set a custom gravity otherwise
-  # box2d.gravity([0, -20])
-  # Create Arrays
   @systems = []
   @boundaries = [
-    Boundary.new(self, 50, 100, 5, -0.3),
-    Boundary.new(self, 250, 175, 5, 0.5)
+    Boundary.new(box2d, Vect.new(50, 100), Vect.new(300, 5), -0.3),
+    Boundary.new(box2d, Vect.new(250, 175), Vect.new(300, 5), 0.5)
   ]
 end
 
 def draw
   background(255)
-  # Display all the boundaries
-  boundaries.each(&:display)
   # Run all the particle systems
-  return unless systems.size > 0
-  systems.each do |system|
-    system.run
-    # refresh particles (else we'll run out)
-    system.add_particles(self, rand(0..2))
+  if systems.size > 0
+    systems.each do |system|
+      system.run
+      system.add_particles(box2d, rand(0..2))
+    end
   end
+  # Display all the boundaries
+  boundaries.each(&:display)
 end
 
 def mouse_pressed
   # Add a new Particle System whenever the mouse is clicked
-  systems << ParticleSystem.new(self, 0, mouse_x, mouse_y)
+  systems << ParticleSystem.new(box2d, 0, mouse_x, mouse_y)
+end
+
+def settings
+  size(400,300)
 end

data/examples/mouse_joint/boundary.rb

@@ -36,7 +36,7 @@ class Boundary
     stroke(127)
     fill(127)
     stroke_weight(1)
-    rect_mode(Java::ProcessingCore::PConstants::CENTER)
+    rect_mode(Java::ProcessingCore::CENTER)
     a = b.get_angle
     push_matrix
     translate(x, y)

data/examples/mouse_joint/box.rb

@@ -34,7 +34,7 @@ class Box
     pos = box2d.body_coord(body)
     # Get its angle of rotation
     a = body.getAngle
-    rect_mode(Java::ProcessingCore::PConstants::CENTER)
+    rect_mode(Java::ProcessingCore::CENTER)
     push_matrix
     translate(pos.x, pos.y)
     rotate(a)

data/examples/mouse_joint/dummy_spring.rb

@@ -1,14 +1,13 @@
 # dummy_spring.rb by Martin Prout 
 # An example of duck-typing in ruby-processing
 
-# This class avoids the tests for null seen in vanilla processing version
+# This class avoids the tests for null of the vanilla processing version
 class DummySpring
   def initialize; end
   def update(_x, _y); end
   def display; end
-    
   # This is the key function where
-  # we attach a real spring between an x, y location
+  # we attach the spring to an x,y location
   # and the box object's location
   # @param x (will be mouse_x)
   # @param y (will be mouse_y)

data/examples/mouse_joint/mouse_joint.rb

@@ -21,15 +21,14 @@ def setup
   box2d.create_world
   # Make the box
   @box = Box.new(width / 2, height / 2)
-  # Make a dummy spring, that returns a real spring on :bind
+  # Make a dummy spring
   @spring = DummySpring.new
-  # Create a bunch of fixed boundaries
-  @boundaries = [
-    Boundary.new(width / 2, height - 5, width, 10, 0),
-    Boundary.new(width / 2, 5, width, 10, 0),
-    Boundary.new(width - 5, height / 2, 10, height, 0),
-    Boundary.new(5, height / 2, 10, height, 0)
-  ]
+  # Add a bunch of fixed boundaries
+  @boundaries = []
+  boundaries << Boundary.new(width / 2, height - 5, width, 10, 0)
+  boundaries << Boundary.new(width / 2, 5, width, 10, 0)
+  boundaries << Boundary.new(width - 5, height / 2, 10, height, 0)
+  boundaries << Boundary.new(5, height / 2, 10, height, 0)
 end
 
 # When the mouse is released we're done with the spring

data/examples/polygons.rb

@@ -2,25 +2,24 @@
 require 'pbox2d'
 require_relative 'lib/custom_shape'
 require_relative 'lib/boundary'
+require_relative 'lib/shape_system'
 
-attr_reader :box2d, :boundaries, :polygons
+attr_reader :box2d, :boundaries, :system
+
+Vect = Struct.new(:x, :y)
 
 def setup
-  size(640, 360)
+  sketch_title 'Polygons'
   smooth
-  # Initialize box2d physics and create the world
   @box2d = Box2D.new(self)
   box2d.init_options(gravity: [0, -20])
   box2d.create_world
-  # To later set a custom gravity
-  # box2d.gravity([0, -20]
-  # Create Arrays
-  @polygons = []
+  @system = ShapeSystem.new self
   @boundaries = [
-    Boundary.new(self, width / 4, height - 5, width / 2 - 50, 10),
-    Boundary.new(self, 3 * width / 4, height - 50, width / 2 - 50, 10),
-    Boundary.new(self, width - 5, height / 2, 10, height),
-    Boundary.new(self, 5, height / 2, 10, height)
+    Boundary.new(box2d, Vect.new(width / 4, height - 5), Vect.new(width / 2 - 50, 10)),
+    Boundary.new(box2d, Vect.new(3 * width / 4, height - 50), Vect.new(width / 2 - 50, 10)),
+    Boundary.new(box2d, Vect.new(width - 5, height / 2), Vect.new(10, height)),
+    Boundary.new(box2d, Vect.new(5, height / 2), Vect.new(10, height))
   ]
 end
 
@@ -29,12 +28,13 @@ def draw
   # Display all the boundaries
   boundaries.each(&:display)
   # Display all the polygons
-  polygons.each(&:display)
-  # polygons that leave the screen, we delete them
-  # (note they have to be deleted from both the box2d world and our list
-  polygons.reject!(&:done)
+  system.run
 end
 
 def mouse_pressed
-  polygons << CustomShape.new(self, mouse_x, mouse_y)
+  system << CustomShape.new(box2d, mouse_x, mouse_y)
+end
+
+def settings
+  size(640, 360)
 end

data/examples/quick_test.rb

@@ -1,4 +1,5 @@
 require 'pbox2d'
+require_relative 'lib/boundary'
 
 # A list we'll use to track fixed objects
 attr_reader :box2d, :boundaries, :boxes
@@ -6,8 +7,10 @@ attr_reader :box2d, :boundaries, :boxes
 java_alias :background_int, :background, [Java::int]
 java_alias :stroke_int, :stroke, [Java::int]
 
+Vect = Struct.new(:x, :y)
+
 def setup
-  size(400,300)
+  sketch_title 'Quick Test'
   stroke_int(0)  # set stroke this way to avoid overload warnings
   srand(5)
   # Initialize box2d physics and create the world
@@ -16,79 +19,42 @@ def setup
   box2d.init_options(scale: 10, gravity: [0, -20.0])
   box2d.create_world
   # Set a custom gravity
-  # box2d.gravity(0, -20)
-  # Create ArrayLists
+  # box2d.gravity(0, -20)  
+  # Create ArrayLists	
   @boxes = []
   @boundaries = [
-    Boundary.new(self, width / 4, height - 5, width / 2 - 50, 10),
-    Boundary.new(self, 3 * width / 4, height - 50, width / 2 - 50, 10)
+    Boundary.new(box2d, Vect.new(width / 4, height - 5), Vect.new(width / 2 - 50, 10)),
+    Boundary.new(box2d, Vect.new(3 * width / 4, height - 50), Vect.new(width / 2 - 50, 10))
   ]
 end
 
 def draw
-  background_int(255) # set background this way to avoid overload warnings
+  background_int(255) # set background this way to avoid overload warnings 
   # Boxes fall from the top every so often
-  boxes << Box.new(self, width / 2, 30) if rand < 0.99
-  boundaries.each(&:display)
-  boxes.each(&:display)
-  # Boxes that leave the screen, we delete them note they have to be deleted
-  # from both the box2d world and locally
-  boxes.reject!(&:done)
+  boxes << Box.new(box2d, width / 2, 30) if rand < 0.99
+  boundaries.each(&:display)  
+  boxes.each(&:display)  
+  # Boxes that leave the screen, we delete them note they have to be deleted 
+  # from both the box2d world and locally  
+  boxes.reject!(&:done)  
   exit if frame_count >= 908
 end
 
-class Boundary
-  extend Forwardable
-  def_delegators(:@app, :box2d, :fill, :rect, :rect_mode)
-  # A boundary is a simple rectangle with x, y, width, and height
-  attr_reader :x, :y, :w, :h, :b
-
-  def initialize(app, x ,y, w, h)
-    @app, @x ,@y, @w, @h = app, x ,y, w, h
-    # Create the body
-    bd = BodyDef.new
-    bd.position.set(box2d.processing_to_world(x, y))
-    @b = box2d.create_body(bd)
-    # Figure out the box2d coordinates
-    box2d_w = box2d.scale_to_world(w / 2)
-    box2d_h = box2d.scale_to_world(h / 2)
-    # Define the polygon
-    sd = PolygonShape.new
-    sd.setAsBox(box2d_w, box2d_h)
-    fd = FixtureDef.new
-    fd.shape = sd
-    fd.density = 0
-    fd.friction = 0.3
-    fd.restitution = 0.5
-    b.createFixture(fd)
-  end
-
-  # Draw the boundary, if it were at an angle we'd have to do something fancier
-  def display
-    fill(0)
-    rect_mode(Java::ProcessingCore::PConstants::CENTER)
-    rect(x, y, w, h)
-  end
-end
-
 # A rectangular box
 class Box
-  extend Forwardable
-  def_delegators(:@app, :box2d, :rect_mode, :rect,
-                 :push_matrix, :pop_matrix, :fill, :rotate,
-                 :stroke, :stroke_weight, :translate)
+  include Processing::Proxy
   # We need to keep track of a Body and a width and height
-  attr_reader :body, :w, :h
-
+  attr_reader :box2d, :body, :w, :h
+  
   # Constructor
-  def initialize(app, x, y)
+  def initialize(b2d, x, y)
     @w = rand(4..16)
     @h = rand(4..16)
-    @app = app
+    @box2d = b2d
     # Add the box to the box2d world
     make_body(Vec2.new(x, y), w, h)
   end
-
+  
   def done
     # Let's find the screen position of the particle
     pos = box2d.body_coord(body)
@@ -97,14 +63,14 @@ class Box
     box2d.destroy_body(body)
     true
   end
-
+  
   # Drawing the box
   def display
     # We look at each body and get its screen position
     pos = box2d.body_coord(body)
     # Get its angle of rotation
-    a = body.angle
-    rect_mode(Java::ProcessingCore::PConstants::CENTER)
+    a = body.angle    
+    rect_mode(CENTER)
     push_matrix
     translate(pos.x, pos.y)
     rotate(-a)
@@ -112,25 +78,25 @@ class Box
     rect(0, 0, w, h)
     pop_matrix
   end
-
+  
   # This function adds the rectangle to the box2d world
-  def make_body(center, w, h)
+  def make_body(center, w, h)    
     # Define a polygon (this is what we use for a rectangle)
     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)
+    sd.setAsBox(box2d_w, box2d_h)    
     # Define a fixture
     fd = FixtureDef.new
     fd.shape = sd
     # Parameters that affect physics
     fd.density = 1
     fd.friction = 0.3
-    fd.restitution = 0.5
+    fd.restitution = 0.5    
     # Define the body and make it from the shape
     bd = BodyDef.new
     bd.type = BodyType::DYNAMIC
-    bd.position.set(box2d.processing_to_world(center))
+    bd.position.set(box2d.processing_to_world(center))    
     cs = CircleShape.new
     @body = box2d.create_body(bd)
     body.create_fixture(fd)
@@ -139,3 +105,7 @@ class Box
     body.setAngularVelocity(rand(-5.0..5))
   end
 end
+
+def settings
+  size(400,300)
+end

data/examples/revolute_joint/revolute_joint.rb

@@ -10,8 +10,12 @@ require_relative 'particle_system'
 
 attr_reader :box2d, :windmill, :system
 
-def setup
+def settings
   size(640,360)
+end
+
+def setup
+  sketch_title 'Revolute Joint'
   @box2d = Box2D.new(self)
   box2d.createWorld
   @windmill = Windmill.new(width / 2, 175)

data/examples/test_contact/README.md

@@ -0,0 +1,6 @@
+### Custom ContactListener example
+
+This example is somewhat based on the CollisionListening example [Box2D for processing][] by Dan Shiffman, but with a CustomContact listener.  It uses the jruby way of implementing an interface (which is to `include` it as if it were a `module`). Note the use of the more elegant ruby way to discriminate between Boundary (has no `:change` method) and Particle (`responds_to? :change` method) objects.
+
+[Box2D for processing]:https://github.com/shiffman/Box2D-for-Processing
+

data/examples/test_contact/lib/boundary.rb

@@ -1,6 +1,6 @@
 require 'forwardable'
 
-CENTER ||= Java::ProcessingCore::PConstants::CENTER
+CENTER ||= Java::ProcessingCore::CENTER
 # The boundary class is used to create a floor in this
 # sketch. Note it does not have a change method
 class Boundary

data/examples/test_contact/lib/particle.rb

@@ -2,7 +2,7 @@
 # when two particles collide (no change just hitting boundary)
 class Particle
   extend Forwardable
-  def_delegators(:@app, :box2d, :begin_shape, :color, :end_shape, :line, :pop_matrix,
+  def_delegators(:@app, :box2d, :begin_shape, :end_shape, :line, :pop_matrix,
                  :ellipse, :translate, :rotate, :stroke, :push_matrix,
                  :fill, :no_fill, :stroke_weight)
   attr_accessor :body
@@ -12,7 +12,7 @@ class Particle
     @app, @x, @y, @radius = app, x, y, r
     # This function puts the particle in the Box2d world
     make_body(x, y, radius)
-    @col = color('#c0c0c0') # silver
+    @col = -5_263_441 # grey
     body.setUserData(self)
   end
 
@@ -23,7 +23,7 @@ class Particle
 
   # Change color when hit
   def change
-    @col = color('#cc0000') # red
+    @col = -65_536 # red
   end
 
   # Is the particle ready for deletion?

data/examples/test_contact/test_contact.rb

@@ -16,7 +16,8 @@ def setup
 end
 
 def draw
-  background(color('#ffffff'))
+  col = color('#ffffff')
+  background(col)
   particles << Particle.new(self, rand(width), 20, rand(4..8)) if rand < 0.1
   particles.each(&:display)
   particles.reject!(&:done)

data/lib/pbox2d/box2d.rb

@@ -36,6 +36,6 @@ class Box2D < Java::ProcessingBox2d::Box2DProcessing
   end
 
   def version
-    format('pbox2d version %s', Pbox2D::VERSION)
+    format('pbox2d version %s', Pbox2d::VERSION)
   end
 end

data/lib/pbox2d/version.rb

@@ -1,4 +1,3 @@
-# Module here just to keep namespace tidy
-module Pbox2D
-  VERSION = '0.4.2'
+module Pbox2d
+  VERSION = "0.5.0"
 end

data/pbox2d.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pbox2d/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'pbox2d'
+  spec.version       = Pbox2d::VERSION
+  spec.license       = 'FreeBSD/Simplified'
+  spec.has_rdoc = true
+  spec.extra_rdoc_files = ['README.md', 'LICENSE.md']
+  spec.authors       = ['Martin Prout']
+  spec.email         = ['martin_p@lineone.net']
+  spec.summary       = %q{jbox2d wrapped in a gem for JRubyArt}
+  spec.description   = <<-EOF
+"An exemplar for how processing/java libraries can be made available for use 
+in JRubyArt.  Features a maven build, also is an example of how to avoid an 
+overdose of java reflection by letting jruby sugar implement an interface"
+EOF
+  spec.homepage      = 'https://github.com/ruby-processing/jbox2d'
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.files << 'lib/box2d.jar'
+  spec.files << 'lib/jbox2d-library-2.3.1-SNAPSHOT.jar' 
+  spec.require_paths = ['lib']
+  spec.add_dependency 'jruby_art', '~> 1.0' 
+  spec.add_development_dependency "rake", "~> 10.0"
+  spec.add_development_dependency "minitest", "~> 5.8"
+  spec.platform='java'
+  spec.requirements << 'A decent graphics card'
+  spec.requirements << 'java runtime >= 1.8+'
+  spec.requirements << 'processing = 3.0.1+'
+  spec.requirements << 'maven = 3.3.3'
+end