ruby-processing 2.6.2 → 2.6.3

data/samples/processing_app/topics/simulate/multiple_particle_systems.rb

@@ -4,156 +4,130 @@
 
 # Each burst is one instance of a particle system with Particles and
 # CrazyParticles (a subclass of Particle).
-
+require 'forwardable'
 load_library :vecmath
 
 module Runnable
   def run
-    self.reject! { |item| item.dead? }
-    self.each    { |item| item.run   }
+    reject! { |item| item.dead? }
+    each    { |item| item.run   }
   end
 end
 
+class ParticleSystem
+  include Enumerable, Runnable
+  extend Forwardable
+  def_delegators(:@particles, :reject!, :<<, :each, :empty?)
+  def_delegator(:@particles, :empty?, :dead?)
 
-class ParticleSystem 
-  extend Enumerable
-  include Runnable    
-  
-  attr_reader :particle_systems 
-  
   def initialize(number, origin)
-    @particle_systems = [] 
+    @particles = []
     @origin = origin
     kind = rand < 0.5 ? Sketch::Particle : Sketch::CrazyParticle
     number.times { self << kind.new(origin) }
   end
-  
-  def each &block
-    particle_systems.each &block    
-  end
-  
-  def << obj
-    particle_systems << obj
-  end
-  
-  def reject! &block
-    particle_systems.reject! &block
-  end
-  
-  def dead?
-    particle_systems.empty?
-  end  
 end
 
+attr_reader :particle_systems
 
 def setup
-  size 640, 580   
+  size 640, 580
   color_mode(RGB, 255, 255, 255, 100)
-  ellipse_mode(CENTER)    
-  @particle_systems = ParticleSystem.new(rand(21) + 5, Vec2D.new(width/2, height/2))
+  ellipse_mode(CENTER)
+  @particle_systems = ParticleSystem.new(rand(5..26), Vec2D.new(width / 2, height / 2))
 end
 
 def draw
   background 0
-  @particle_systems.run
+  particle_systems.run
 end
 
 def mouse_pressed
-  origin = rand(21) + 5
+  origin = rand(5..26)
   vector = Vec2D.new(mouse_x, mouse_y)
-  @particle_systems << ParticleSystem.new(origin, vector)
+  particle_systems << ParticleSystem.new(origin, vector)
 end
 
 
 class Particle
+  attr_reader :acceleration, :velocity
+
   def initialize(origin)
     @origin = origin
-    @velocity = Vec2D.new(rand(-1.0 .. 1), rand(-2.0 .. 0))
+    @velocity = Vec2D.new(rand(-1.0..1), rand(-2.0..0))
     @acceleration = Vec2D.new(0, 0.05)
     @radius = 10
     @lifespan = 100
   end
-  
+
   def run
     update
     grow
     render
     render_velocity_vector
   end
-  
+
   def update
-    @velocity += @acceleration
-    @origin += @velocity
+    @velocity += acceleration
+    @origin += velocity
   end
-  
+
   def grow
     @lifespan -= 1
   end
-  
+
   def dead?
     @lifespan <= 0
   end
-  
+
   def render
     stroke(255, @lifespan)
     fill(100, @lifespan)
     ellipse(@origin.x, @origin.y, @radius, @radius)
   end
-  
+
   def render_velocity_vector
     scale = 10
     arrow_size = 4
-    
     push_matrix
-    
     translate(@origin.x, @origin.y)
-    rotate(@velocity.heading)
-    
-    length = @velocity.mag * scale
-    
+    rotate(velocity.heading)
+    length = velocity.mag * scale
     line 0, 0, length, 0
     line length, 0, length - arrow_size, arrow_size / 2
     line length, 0, length - arrow_size, -arrow_size / 2
-    
     pop_matrix
   end
 end
 
-
 class CrazyParticle < Particle
   def initialize(origin)
     super
     @theta = 0
   end
-  
+
   def run
     update
     grow
     render
     render_rotation_line
   end
-  
+
   def update
     super
-    @theta += @velocity.x * @velocity.mag / 10
+    @theta += velocity.x * velocity.mag / 10
   end
-  
+
   def grow
     @lifespan -= 0.8
   end
-  
+
   def render_rotation_line
     push_matrix
-    
     translate(@origin.x, @origin.y)
     rotate(@theta)
-    
     stroke(255, @lifespan)
-    
     line(0, 0, 25, 0)
-    
     pop_matrix
   end
 end
-
-

data/samples/processing_app/topics/simulate/simple_particle_system.rb

@@ -3,7 +3,7 @@
 # Particles are generated each cycle, fall with gravity and fade out over
 # time. A ParticleSystem (Array) object manages a variable size list of
 # particles.
-
+require 'forwardable'
 load_library :vecmath
 
 attr_reader :ps
@@ -21,50 +21,39 @@ end
 
 module Runnable
   def run
-    self.reject! { |item| item.lifespan <= 0 }
-    self.each    { |item| item.run   }
+    reject! { |item| item.lifespan <= 0 }
+    each    { |item| item.run   }
   end
 end
 
-class ParticleSystem 
-  extend Enumerable 
-  include Runnable
-  
-  attr_reader :origin, :particle_system
+class ParticleSystem
+  include Enumerable, Runnable
+  extend Forwardable
+  def_delegators(:@particles, :reject!, :<<, :each, :empty?)
+  def_delegator(:@particles, :empty?, :dead?)
+
+  attr_reader :origin
 
   def initialize(loc)
-    @particle_system = []
-    @origin = loc.dup
+    @particles = []
+    @origin = loc
   end
-  
-  def each &block
-    particle_system.each &block    
-  end
-  
+
   def add_particle
-    particle_system << Particle.new(origin) 
+    self << Particle.new(origin)
   end
-  
-  def reject! &block
-    particle_system.reject! &block
-  end
-  
-  def dead?
-    particle_systems.empty?
-  end 
-
 end
 
 # A simple Particle class
 
-class Particle 
-  include Processing::Proxy 
-  
+class Particle
+  include Processing::Proxy
+
   attr_reader :loc, :vel, :acc, :lifespan
-  def initialize(l) 
+  def initialize(l)
     @acc = Vec2D.new(0, 0.05)
-    @vel = Vec2D.new(rand(-1.0 .. 1), rand(-2.0 .. 0))
-    @loc = l.dup
+    @vel = Vec2D.new(rand(-1.0..1), rand(-2.0..0))
+    @loc = l.copy
     @lifespan = 255.0
   end
 
@@ -86,5 +75,4 @@ class Particle
     fill(255,lifespan)
     ellipse(loc.x, loc.y, 8, 8)
   end
-  
 end

data/samples/processing_app/topics/simulate/smoke_particle_system.rb

@@ -10,128 +10,116 @@ attr_reader :ps, :img, :wind
 def setup
   size(640,360)
   @img = load_image('texture.png')
-  @ps = ParticleSystem.new(0, Vec2D.new(width/2, height - 60), img)
+  @ps = ParticleSystem.new(0, Vec2D.new(width / 2, height - 75), img)
 end
 
 def draw
-  background(0)  
-  # Calculate a 'wind' force based on mouse horizontal position
-  dx = map(mouse_x, 0, width, -0.2, 0.2)
-  @wind = Vec2D.new(dx, 0)
+  background(0)
+  # Calculate a "wind" force based on mouse horizontal position
+  dx = map1d(mouse_x, (0..width), (-0.2..0.2))
+  wind = Vec2D.new(dx, 0)
   ps.apply_force(wind)
   ps.run
-  2.times do
-    ps.add_particle
-  end
-  
-  # Draw a horizontal arrow representing the wind force
-  draw_vector(wind, Vec2D.new(width / 2, 50, 0), 500)
-  
+  2.times { ps.add_particle }
+  # Draw an arrow representing the wind force
+  draw_vector(wind, Vec2D.new(width / 2, 50), 500)
 end
 
 # Renders a vector object 'v' as an arrow and a location 'loc'
 def draw_vector(v, loc, scayl)
   push_matrix
+  arrowsize = 4
   # Translate to location to render vector
-  translate(loc.x, loc.y)  
+  translate(loc.x, loc.y)
+  stroke(255)
+  # Call vector heading function to get direction (note that pointing up is a heading of 0) and rotate
   rotate(v.heading)
-  # Calculate length of vector & scale as necessary
+  # Calculate length of vector & scale it to be bigger or smaller if necessary
   len = v.mag * scayl
-  # Draw three lines to make an arrow 
-  arrowsize = 4
-  stroke(255)
-  stroke_weight 2
+  # Draw three lines to make an arrow (draw pointing up since we've rotate to the proper direction)
   line(0, 0, len, 0)
-  stroke_weight 1
-  line(len, 0, len - arrowsize, +arrowsize/2)
-  line(len, 0, len - arrowsize, -arrowsize/2)
+  line(len, 0, len - arrowsize, arrowsize / 2)
+  line(len, 0, len - arrowsize, -arrowsize / 2)
   pop_matrix
 end
 
 module Runnable
   def run
-    self.reject! { |item| item.lifespan <= 0 }
-    self.each    { |item| item.run }
+    reject! { |item| item.lifespan <= 0 }
+    each    { |item| item.run }
   end
 end
 
+require 'forwardable'
+
+class ParticleSystem
+  include Enumerable, Runnable
+  extend Forwardable
+  def_delegators(:@particles, :reject!, :<<, :each)
 
-class ParticleSystem 
-  extend Enumerable
-  include Runnable
-  
   attr_reader :particles, :origin, :image, :generator
-  
+
   def initialize(num, location, image)
     @particles = []
-    @origin = location.dup
-    @image = image    
+    @origin = location.copy
+    @image = image
     (0 ... num).each do
       particles << Particle.new(origin, image)
     end
   end
-  
-  def each &block
-    particles.each &block    
-  end
 
-  def reject! &block
-    particles.reject! &block
-  end
-  
   def add_particle(p = Particle.new(origin, image))
-    particles << p
+    self << p
   end
-  
+
   # Method to add a force vector to all particles currently in the system
-  def apply_force(dir) 
-    self.each do |p|
+  def apply_force(dir)
+    each do |p|
       p.apply_force(dir)
-    end  
-  end 
+    end
+  end
 end
 
 # A simple Particle class
 
-class Particle 
-  include Processing::Proxy 
-  
+class Particle
+  include Processing::Proxy
+
   attr_reader :loc, :acc, :vel, :lifespan, :img, :generator
-  
-  def initialize(l, img_) 
+
+  def initialize(l, img_)
     @acc = Vec2D.new(0, 0)
     vx = random_gaussian * 0.3
     vy = random_gaussian * 0.3 - 1.0
     @vel = Vec2D.new(vx, vy)
-    @loc = l.dup
+    @loc = l.copy
     @lifespan = 100.0
     @img = img_
   end
-  
+
   def run
     update
     render
   end
-  
+
   # Method to update location
   def update
     @vel += acc
     @loc += vel
     @lifespan -= 1.0
   end
-  
+
   # Method to display
-  def render 
+  def render
     image_mode(CENTER)
     tint(255,lifespan)
     image(img, loc.x, loc.y)
   end
-  
+
   # Method to add a force vector to all particles currently in the system
-  def apply_force(f) 
+  def apply_force(f)
     @acc += f
   end
-  
 end
 
 

data/samples/processing_app/topics/simulate/springs.rb

@@ -1,21 +1,19 @@
-
-
 #
 # Ported from http://www.processing.org/learning/topics/springs.html
 #
-# Move the mouse over one of the circles and click to re-position. When you release the mouse, it will 
+# Move the mouse over one of the circles and click to re-position. When you release the mouse, it will
 # snap back into position. Each circle has a slightly different behavior.
 #
 
 
 def setup
-  size 200, 200  
+  size 400, 400
   no_stroke
-  smooth    
+  smooth 4
   @springs = []
-  @springs << Spring.new(self,  70, 160,  20, 0.98, 8.0, 0.1, @springs, 0)
-  @springs << Spring.new(self, 150, 110,  60, 0.95, 9.0, 0.1, @springs, 1)
-  @springs << Spring.new(self,  40,  70, 120, 0.90, 9.9, 0.1, @springs, 2)
+  @springs << Spring.new(70, 160,  20, 0.98, 8.0, 0.1, @springs, 0)
+  @springs << Spring.new(160, 130,  60, 0.95, 9.0, 0.1, @springs, 1)
+  @springs << Spring.new(80,  70, 120, 0.90, 9.9, 0.1, @springs, 2)
 end
 
 def draw
@@ -27,20 +25,18 @@ def draw
 end
 
 def mouse_pressed
-  @springs.each {|x| x.pressed}
+  @springs.each { |x| x.pressed }
 end
 
 def mouse_released
-  @springs.each {|x| x.released}
+  @springs.each { |x| x.released }
 end
 
+class Spring
+  include Processing::Proxy
 
+  def initialize(x, y, s, d, m, k, others, id)
 
-class Spring 
-  
-  def initialize(app, x, y, s, d, m, k, others, id)
-    @app = app
-    
     # Screen values
     @xpos      = @tempxpos = x
     @ypos      = @tempypos = y
@@ -48,7 +44,7 @@ class Spring
     @rest_posy = y       # Rest position Y
     @size      = s
     @damp      = d       # Damping
-    
+
     # Spring simulation constants
     @mass      = m       # Mass
     @kin       = k       # Spring constant
@@ -56,40 +52,40 @@ class Spring
     @me        = id      # Index of me in @friends
     @over      = false
     @move      = false
-    
+
     # Spring simulation variables
     @velx      = 0.0     # X Velocity
     @vely      = 0.0     # Y Velocity
     @accel     = 0       # Acceleration
     @force     = 0       # Force
   end
-  
+
   def update
     if (@move)
-      @rest_posx = @app.mouse_x
-      @rest_posy = @app.mouse_y
+      @rest_posx = mouse_x
+      @rest_posy = mouse_y
     end
-    
-    @force = -1 * @kin * (@tempypos - @rest_posy)   # f=-ky 
-    @accel = @force / @mass                         # Set the acceleration, f=ma == a=f/m 
-    @vely = @damp * (@vely + @accel);               # Set the velocity 
-    @tempypos = @tempypos + @vely;                  # Updated position 
-    
-    @force = -1 * @kin * (@tempxpos - @rest_posx)   # f=-ky 
-    @accel = @force / @mass;                        # Set the acceleration, f=ma == a=f/m 
-    @velx = @damp * (@velx + @accel);               # Set the velocity 
-    @tempxpos = @tempxpos + @velx;                  # Updated position 
-    
+
+    @force = -1 * @kin * (@tempypos - @rest_posy)   # f=-ky
+    @accel = @force / @mass                         # Set the acceleration, f=ma == a=f/m
+    @vely = @damp * (@vely + @accel);               # Set the velocity
+    @tempypos = @tempypos + @vely;                  # Updated position
+
+    @force = -1 * @kin * (@tempxpos - @rest_posx)   # f=-ky
+    @accel = @force / @mass;                        # Set the acceleration, f=ma == a=f/m
+    @velx = @damp * (@velx + @accel);               # Set the velocity
+    @tempxpos = @tempxpos + @velx;                  # Updated position
+
     @over = ((over? || @move) && !other_over?)
   end
-  
+
   # Test to see if mouse is over this spring
   def over?
-    dis_x = @tempxpos - @app.mouse_x
-    dis_y = @tempypos - @app.mouse_y
-    Math::sqrt(@app.sq(dis_x) + @app.sq(dis_y)) < @size/2
+    dis_x = @tempxpos - mouse_x
+    dis_y = @tempypos - mouse_y
+    Math::sqrt((dis_x * dis_x) + (dis_y * dis_y)) < @size/2
   end
-  
+
   # Make sure no other springs are active
   def other_over?
     @friends.each_with_index do |f, i|
@@ -101,24 +97,24 @@ class Spring
     end
     return false
   end
-  
+
   def display
     if (over?)
-      @app.fill(153)
+      fill(153)
     else
-      @app.fill(255)
+      fill(255)
     end
-    @app.ellipse(@tempxpos, @tempypos, @size, @size)
+    ellipse(@tempxpos, @tempypos, @size, @size)
   end
-  
+
   def pressed
     @move = over?
   end
-  
+
   def released
-    @move = false 
+    @move = false
     @rest_posx = @xpos
     @rest_posy = @ypos
   end
-  
+
 end