some tidy up

Author: monkstone

samples/contributed/circle_collision.rb

@@ -2,109 +2,95 @@
 
 load_library :vecmath
 
-
+# The Ball class knows how to behave, their is a case for a separate boundary class
 class Ball
   attr_accessor :position, :r, :m, :velocity
-  
+
   def initialize(x = 0.0, y = 0.0, r = 0.0)
     @position = Vec2D.new(x, y)
     @r = r
     @m = r * 0.1
     @velocity = Vec2D.new(rand(-3.0..3), rand(-3.0..3))
-  end 
-  
+  end
+
   def update
     @position += velocity
   end
-  
-  def check_boundary width, height 
-    if !(r..width - r).include?(position.x)
-      (position.x > width - r)? position.x = width - r : position.x = r
+
+  def check_boundary(width, height)
+    unless (r..width - r).include?(position.x)
+      (position.x > width - r) ? position.x = width - r : position.x = r
       velocity.x *= -1
-    elsif !(r..height - r).include?(position.y)
-      (position.y > height - r)? position.y = height - r : position.y = r
-      velocity.y *= -1
-    end    
+    end
+    return if (r..height - r).include?(position.y)
+    (position.y > height - r) ? position.y = height - r : position.y = r
+    velocity.y *= -1
   end
-  
-  def check_collision other_ball    
-    
+
+  def check_collision(other_ball)
     # get distances between the balls components
     difference = other_ball.position - position
-    
     # calculate magnitude of the vector separating the balls
-
-    
-    if difference.mag < (r + other_ball.r) 
-      # get angle of difference
-      theta  = difference.heading
-      # precalculate trig values
-      sine = sin(theta)
-      cosine = cos(theta)
-      
-      # ball_array will hold rotated ball positions. You just
-      # need to worry about ball_array[1] position
-      ball_array = [Ball.new, Ball.new]
-      # other_ball's position is relative to ball's
-      # so you can use the vector between them (difference) as the 
-      # reference point in the rotation expressions.
-      # ball_array[0].x and ball_array[0].y will initialize
-      # automatically to 0.0, which is what you want
-      # since other_ball will rotate around ball
-      ball_array[1].position.x  = cosine * difference.x + sine * difference.y
-      ball_array[1].position.y  = cosine * difference.y - sine * difference.x
-      
-      # rotate Temporary velocities
-      velocity_array = [Vec2D.new, Vec2D.new]
-      velocity_array[0].x  = cosine * velocity.x + sine * velocity.y
-      velocity_array[0].y  = cosine * velocity.y - sine * velocity.x
-      velocity_array[1].x  = cosine * other_ball.velocity.x + sine * other_ball.velocity.y
-      velocity_array[1].y  = cosine * other_ball.velocity.y - sine * other_ball.velocity.x
-      
-      # Now that velocities are rotated, you can use 1D
-      # conservation of momentum equations to calculate 
-      # the final velocity along the x-axis.
-      final_velocities = [Vec2D.new, Vec2D.new]
-      # final rotated velocity for ball
-      final_velocities[0].x = ((m - other_ball.m) * velocity_array[0].x + 2 * other_ball.m * velocity_array[1].x) / (m + other_ball.m)
-      final_velocities[0].y = velocity_array[0].y
-      # final rotated velocity for ball
-      final_velocities[1].x = ((other_ball.m - m) * velocity_array[1].x + 2 * m * velocity_array[0].x) / (m + other_ball.m)
-      final_velocities[1].y = velocity_array[1].y
-      
-      # hack to avoid clumping
-      #ball_array[0].position.x += final_velocities[0].x
-      #ball_array[1].position.x += final_velocities[1].x
-      
-      # Rotate ball positions and velocities back
-      # Reverse signs in trig expressions to rotate 
-      # in the opposite direction
-      # rotate balls
-      final_positions = [Vec2D.new, Vec2D.new]
-      final_positions[0].x = cosine * ball_array[0].position.x - sine * ball_array[0].position.y
-      final_positions[0].y = cosine * ball_array[0].position.y + sine * ball_array[0].position.x
-      final_positions[1].x = cosine * ball_array[1].position.x - sine * ball_array[1].position.y
-      final_positions[1].y = cosine * ball_array[1].position.y + sine * ball_array[1].position.x
-      
-      # update balls to screen position
-      other_ball.position = position + final_positions[1]
-      @position += final_positions[0]
-      
-      # update velocities
-      velocity.x = cosine * final_velocities[0].x - sine * final_velocities[0].y
-      velocity.y = cosine * final_velocities[0].y + sine * final_velocities[0].x
-      other_ball.velocity.x = cosine * final_velocities[1].x - sine * final_velocities[1].y
-      other_ball.velocity.y = cosine * final_velocities[1].y + sine * final_velocities[1].x
-      
-    end
+    return unless difference.mag < (r + other_ball.r)
+    # get angle of difference
+    theta  = difference.heading
+    # precalculate trig values
+    sine = sin(theta)
+    cosine = cos(theta)
+    # ball_array will hold rotated ball positions. You just
+    # need to worry about ball_array[1] position
+    ball_array = [Ball.new, Ball.new]
+    # other_ball's position is relative to ball's
+    # so you can use the vector between them (difference) as the
+    # reference point in the rotation expressions.
+    # ball_array[0].x and ball_array[0].y will initialize
+    # automatically to 0.0, which is what you want
+    # since other_ball will rotate around ball
+    ball_array[1].position.x  = cosine * difference.x + sine * difference.y
+    ball_array[1].position.y  = cosine * difference.y - sine * difference.x
+    # rotate Temporary velocities
+    velocity_array = [Vec2D.new, Vec2D.new]
+    velocity_array[0].x  = cosine * velocity.x + sine * velocity.y
+    velocity_array[0].y  = cosine * velocity.y - sine * velocity.x
+    velocity_array[1].x  = cosine * other_ball.velocity.x + sine * other_ball.velocity.y
+    velocity_array[1].y  = cosine * other_ball.velocity.y - sine * other_ball.velocity.x
+    # Now that velocities are rotated, you can use 1D
+    # conservation of momentum equations to calculate
+    # the final velocity along the x-axis.
+    final_velocities = [Vec2D.new, Vec2D.new]
+    # final rotated velocity for ball
+    final_velocities[0].x = ((m - other_ball.m) * velocity_array[0].x + 2 * other_ball.m * velocity_array[1].x) / (m + other_ball.m)
+    final_velocities[0].y = velocity_array[0].y
+    # final rotated velocity for ball
+    final_velocities[1].x = ((other_ball.m - m) * velocity_array[1].x + 2 * m * velocity_array[0].x) / (m + other_ball.m)
+    final_velocities[1].y = velocity_array[1].y
+    # HACK: to avoid clumping
+    # ball_array[0].position.x += final_velocities[0].x
+    # ball_array[1].position.x += final_velocities[1].x
+    # Rotate ball positions and velocities back
+    # Reverse signs in trig expressions to rotate
+    # in the opposite direction
+    # rotate balls
+    final_positions = [Vec2D.new, Vec2D.new]
+    final_positions[0].x = cosine * ball_array[0].position.x - sine * ball_array[0].position.y
+    final_positions[0].y = cosine * ball_array[0].position.y + sine * ball_array[0].position.x
+    final_positions[1].x = cosine * ball_array[1].position.x - sine * ball_array[1].position.y
+    final_positions[1].y = cosine * ball_array[1].position.y + sine * ball_array[1].position.x
+    # update balls to screen position
+    other_ball.position = position + final_positions[1]
+    @position += final_positions[0]
+    # update velocities
+    velocity.x = cosine * final_velocities[0].x - sine * final_velocities[0].y
+    velocity.y = cosine * final_velocities[0].y + sine * final_velocities[0].x
+    other_ball.velocity.x = cosine * final_velocities[1].x - sine * final_velocities[1].y
+    other_ball.velocity.y = cosine * final_velocities[1].y + sine * final_velocities[1].x
   end
-  
+
   def display
     no_stroke
     fill(204)
     ellipse(position.x, position.y, r * 2, r * 2)
   end
-  
 end
 
 attr_reader :balls
@@ -114,16 +100,12 @@ def setup
   @balls = [Ball.new(100, 40, 20), Ball.new(200, 100, 80)]
 end
 
-
 def draw
-  background(51)  
-  balls.each do |b| 
+  background(51)
+  balls.each do |b|
     b.update
     b.display
     b.check_boundary width, height
   end
-  
   balls[0].check_collision(balls[1])
 end
-
-

samples/contributed/elegant_ball.rb

@@ -2,33 +2,26 @@
 # After a vanilla processing sketch by
 # Ben Notorianni aka lazydog
 #
-
 # elegant.rb
-
-
 load_library :vecmath
-
 attr_reader :start_t, :renderer
 
-def setup()
+def setup
   size(800, 800, P3D)
-  @renderer = AppRender.new(self) 
+  @renderer = AppRender.new(self)
   color_mode(RGB, 1)
 end
 
-
-
-def draw()
-  #background(0.25)
+def draw
   background(0)
   # Move the origin so that the scene is centered on the screen.
-  translate(width/2, height/2, 0.0)
+  translate(width / 2, height / 2, 0.0)
   # Set up the lighting.
   setup_lights
   # Rotate the local coordinate system.
   smooth_rotation(5.0, 6.7, 7.3)
   # Draw the inner object.
-  no_stroke()
+  no_stroke
   fill(smooth_colour(10.0, 12.0, 7.0))
   draw_icosahedron(5, 60.0, false)
   # Rotate the local coordinate system again.
@@ -42,12 +35,12 @@ def draw()
 def setup_lights
   ambient_light(0.025, 0.025, 0.025)
   directional_light(0.2, 0.2, 0.2, -1, -1, -1)
-  spot_light(1.0, 1.0, 1.0, -200, 0, 300, 1, 0, -1, Math::PI/4, 20)
+  spot_light(1.0, 1.0, 1.0, -200, 0, 300, 1, 0, -1, Math::PI / 4, 20)
 end
 
 ##
 # Generate a vector whose components change smoothly over time in the range [ 0, 1 ].
-# Each component uses a Math.sin() function to map the current time in milliseconds somewhere
+# Each component uses a Math.sin function to map the current time in milliseconds somewhere
 # in the range [ 0, 1 ].A 'speed' factor is specified for each component.
 #
 def smooth_vector(s1, s2, s3)
@@ -70,7 +63,7 @@ def smooth_colour(s1, s2, s3)
 
 ##
 # Rotate the current coordinate system.
-# Uses smooth_vector() to smoothly animate the rotation.
+# Uses smooth_vector to smoothly animate the rotation.
 #
 def smooth_rotation(s1, s2, s3)
   r1 = smooth_vector(s1, s2, s3)
@@ -91,24 +84,18 @@ def draw_icosahedron(depth, r, spherical)
   h = r / Math.sqrt(1.0 + gr * gr)
   v =
     [
-    Vec3D.new(0, -h, h*gr), Vec3D.new(0, -h, -h*gr), Vec3D.new(0, h, -h*gr), Vec3D.new(0, h, h*gr),
-    Vec3D.new(h, -h*gr, 0), Vec3D.new(h, h*gr, 0), Vec3D.new(-h, h*gr, 0), Vec3D.new(-h, -h*gr, 0),
-    Vec3D.new(-h*gr, 0, h), Vec3D.new(-h*gr, 0, -h), Vec3D.new(h*gr, 0, -h), Vec3D.new(h*gr, 0, h)
-  ]
-
+  Vec3D.new(0, -h, h * gr), Vec3D.new(0, -h, -h * gr), Vec3D.new(0, h, -h * gr), Vec3D.new(0, h, h * gr),
+  Vec3D.new(h, -h * gr, 0), Vec3D.new(h, h * gr, 0), Vec3D.new(-h, h * gr, 0), Vec3D.new(-h, -h * gr, 0),
+  Vec3D.new(-h * gr, 0, h), Vec3D.new(-h * gr, 0, -h), Vec3D.new(h * gr, 0, -h), Vec3D.new(h * gr, 0, h)
+    ]
   # Draw the 20 triangular faces of the icosahedron.
-  unless spherical then
-    r = 0.0
-  end
-
+  r = 0.0 unless spherical
   begin_shape(TRIANGLES)
-   
-  draw_triangle(depth, r, v[0], v[7],v[4])
+  draw_triangle(depth, r, v[0], v[7], v[4])
   draw_triangle(depth, r, v[0], v[4], v[11])
   draw_triangle(depth, r, v[0], v[11], v[3])
   draw_triangle(depth, r, v[0], v[3], v[8])
   draw_triangle(depth, r, v[0], v[8], v[7])
-
   draw_triangle(depth, r, v[1], v[4], v[7])
   draw_triangle(depth, r, v[1], v[10], v[4])
   draw_triangle(depth, r, v[10], v[11], v[4])
@@ -119,23 +106,20 @@ def draw_icosahedron(depth, r, spherical)
   draw_triangle(depth, r, v[8], v[9], v[6])
   draw_triangle(depth, r, v[9], v[7], v[8])
   draw_triangle(depth, r, v[7], v[1], v[9])
-
   draw_triangle(depth, r, v[2], v[1], v[9])
   draw_triangle(depth, r, v[2], v[10], v[1])
   draw_triangle(depth, r, v[2], v[5], v[10])
   draw_triangle(depth, r, v[2], v[6], v[5])
   draw_triangle(depth, r, v[2], v[9], v[6])
- 
-  end_shape()
+  end_shape
 end
 
 ##
 # Draw a triangle either immediately or subdivide it first.
 # If depth is 1 then draw the triangle otherwise subdivide first.
 #
 def draw_triangle(depth, r, p1, p2, p3)
-
-  if (depth == 1) then
+  if (depth == 1)
     p1.to_vertex(renderer)
     p2.to_vertex(renderer)
     p3.to_vertex(renderer)
@@ -144,15 +128,15 @@ def draw_triangle(depth, r, p1, p2, p3)
     v1 = (p1 + p2) * 0.5
     v2 = (p2 + p3) * 0.5
     v3 = (p3 + p1) * 0.5
-  unless (r == 0.0) then
-    # Project the verticies out onto the sphere with radius r.
-    v1.normalize!
-    v1 *= r
-    v2.normalize!
-    v2 *= r
-    v3.normalize!
-    v3 *= r
-  end
+    unless (r == 0.0)
+      # Project the verticies out onto the sphere with radius r.
+      v1.normalize!
+      v1 *= r
+      v2.normalize!
+      v2 *= r
+      v3.normalize!
+      v3 *= r
+    end
     ## Generate the next level of detail
     depth -= 1
     draw_triangle(depth, r, p1, v1, v3)
@@ -162,4 +146,3 @@ def draw_triangle(depth, r, p1, p2, p3)
     # draw_triangle(depth, r, v1, v2, v3)
   end
 end
-

samples/contributed/empathy.rb

@@ -14,7 +14,7 @@
 attr_reader :cells
 
 def setup
-  size(500, 500, P3D)
+  size(500, 500, P2D)
   stroke(0, 0, 0, 25)
   initialize_cells
   start_cell_updates if MULTI_THREADED
@@ -31,32 +31,30 @@ def initialize_cells
 end
 
 def start_cell_updates
-  Thread.new { Kernel.loop { cells.each { |cell| cell.update } } }
+  Thread.new { Kernel.loop { cells.each(&:update) } }
 end
 
 def draw
   background 255
-  cells.each { |cell| cell.sense } if started?
+  cells.each(&:sense) if started?
 end
 
 def started?
   pmouse_x != 0 || pmouse_y != 0
 end
 
 def mouse_pressed
-  cells.each { |cell| cell.reset }
+  cells.each(&:reset)
 end
 
 ##
 # The cell responds to mouse movement
 ##
-
 class Cell
   attr_reader :x, :y, :spin, :angle
   def initialize(x, y)
     @x, @y  = x, y
-    @spin   = 0
-    @angle  = 0
+    reset
   end
 
   def reset