ruby-processing 1.0.4 → 1.0.5

data/samples/learning_processing/chapter_10/03_bouncing_balls_with_intersection.rb

@@ -1,69 +0,0 @@
-require 'ruby-processing'
-
-class BouncingBallsWithIntersection < Processing::App
-  def setup
-    smooth
-    # Create two balls.
-    @ball_1, @ball_2 = Ball.new(64), Ball.new(32)
-  end
-  
-  def draw
-    background 255
-    @ball_1.move
-    @ball_2.move
-    
-    # New! Methods on objects that you define can take each other as arguments.
-    # This is one way to have objects communicate.
-    # In this case they're checking to see if they intersect.
-    if @ball_1.intersect(@ball_2)
-      @ball_1.highlight
-      @ball_2.highlight
-    end
-    
-    @ball_1.display
-    @ball_2.display
-  end
-end
-
-
-class Ball
-  # We use attr_reader to make the @x, @y and @r instance variables readable by other objects.
-  attr_reader :x, :y, :r
-  
-  def initialize(temp_r)
-    @r = temp_r
-    @x, @y = rand($app.width), rand($app.height)
-    @x_speed, @y_speed = (rand * 10 - 5), (rand * 10 - 5)
-    @color = $app.color(100, 50)
-  end
-  
-  def move
-    @x += @x_speed # Move the ball horizontally
-    @y += @y_speed # Move the ball vertically
-    
-    @x_speed *= -1 unless (0..$app.width).include?(@x)
-    @y_speed *= -1 unless (0..$app.height).include?(@y)
-  end
-  
-  def highlight
-    @color = $app.color(0, 150)
-  end
-  
-  def display
-    $app.stroke 0
-    $app.fill @color
-    $app.ellipse @x, @y, @r*2, @r*2
-    # After the ball is displayed, the color is reset back to a dark gray.
-    @color = $app.color(100, 50)
-  end
-  
-  # A function that returns true or false based on whether or not two circles intersect.
-  # If distance is less than the sum of the radii, the circles touch.
-  # Objects that you define can be passed as arguments too!
-  def intersect(other_ball)
-    distance = $app.dist(@x, @y, other_ball.x, other_ball.y)
-    distance < @r + other_ball.r
-  end
-end
-
-BouncingBallsWithIntersection.new :title => "Bouncing Balls with Intersection", :width => 400, :height => 400

data/samples/learning_processing/chapter_10/04_a_timer.rb

@@ -1,24 +0,0 @@
-require 'ruby-processing'
-
-class Timer < Processing::App
-
-  def setup
-    background 0
-    @total_time = 5000
-    @saved_time = millis
-  end
-  
-  def draw
-    passed_time = millis - @saved_time
-    # Has 5 seconds passed?
-    if passed_time > @total_time
-      puts "5 seconds have passed!"
-      # Color a new background, and let's give it some color.
-      background rand(255), rand(255), rand(255)
-      @saved_time = millis  # Save the current time to restart the timer!
-    end
-  end
-  
-end
-
-Timer.new :title => "04 A Timer", :width => 200, :height => 200

data/samples/learning_processing/chapter_10/05_object_oriented_timer.rb

@@ -1,42 +0,0 @@
-require 'ruby-processing'
-
-class ObjectOrientedTimer < Processing::App
-
-  def setup
-    background 0
-    @timer = Timer.new(5000)
-    @timer.start
-  end
-  
-  def draw
-    if @timer.is_finished?
-      background rand(255)
-      @timer.start
-    end
-  end
-  
-end
-
-
-class Timer
-  def initialize(total_time)
-    @saved_time = nil         # When it started
-    @total_time = total_time  # How long it should last
-  end
-  
-  # When the timer starts it stores the current time in milliseconds
-  def start
-    @saved_time = $app.millis
-  end
-  
-  # The method is_finished? returns true if 5 seconds have passed.
-  # Most of the work of the timer is farmed out to this method.
-  def is_finished?
-    passed_time = $app.millis - @saved_time
-    passed_time > @total_time
-  end
-  
-  
-end
-
-ObjectOrientedTimer.new :title => "Object Oriented Timer", :width => 200, :height => 200

data/samples/learning_processing/chapter_10/06_simple_raindrop.rb

@@ -1,23 +0,0 @@
-require 'ruby-processing'
-
-class SimpleRaindrop < Processing::App
-
-  def setup
-    background 0
-    @x, @y = width / 2, 0
-    smooth
-    no_stroke
-  end
-  
-  def draw
-    background 255
-    # Show the drop
-    fill 50, 100, 150
-    ellipse @x, @y, 16, 16
-    # Move the drop
-    @y += 1
-  end
-  
-end
-
-SimpleRaindrop.new :title => "Simple Raindrop", :width => 400, :height => 400

data/samples/learning_processing/chapter_10/07_drops_one_at_a_time.rb

@@ -1,63 +0,0 @@
-require 'ruby-processing'
-
-class DropsOneAtATime < Processing::App
-
-  def setup
-    @max_drops = 1000         # The most drops we're going to have at once.
-    @drops = []               # An array to hold the drops
-    no_stroke
-    smooth
-  end
-  
-  def draw
-    background 255
-    @drops << Drop.new        # Create one drop
-    # Start over when we have too many.
-    @drops = [] if @drops.size > @max_drops
-    
-    # Move and display all the drops.
-    # New! We no longer move and display all the drops, but rather,
-    # only the ones that are still present in the @drops array.
-    @drops.each do |drop|
-      drop.move
-      drop.display
-    end
-  end
-  
-end
-
-
-class Drop
-  def initialize
-    @r = 8                    # All raindrops are the same size
-    @x = rand($app.width)     # Start with a random x location
-    @y = -@r * 4              # Start a little above the window
-    @speed = rand * 4 + 1     # Pick a random speed
-    @color = $app.color(50, 100, 150)
-  end
-  
-  # Move the raindrop down
-  def move
-    @y += @speed              # Increment y by speed
-  end
-  
-  # Check to see if it hit the bottom
-  def reached_bottom?
-    @y > $app.height + @r*4   # If we go a little beyond the bottom
-  end
-  
-  # Display the raindrop
-  def display
-    $app.fill @color
-    # For each number between 2 and the radius, draw an ellipse.
-    (2...@r).each { |i| $app.ellipse(@x, @y+i*4, i*2, i*2) }
-  end
-  
-  # If the drop is caught
-  def caught
-    @speed = 0                # Stop it from moving by setting speed to 0
-    @y = -1000                # Set the location way off the screen
-  end
-end
-
-DropsOneAtATime.new :title => "Drops One At A Time", :width => 400, :height => 400

data/samples/learning_processing/chapter_13/02_random_number_distribution.rb

@@ -1,24 +0,0 @@
-require 'ruby-processing'
-
-class RandomNumberDistributionSketch < Processing::App
-  def setup
-    # An array to keep track of how often numbers are picked.
-    @random_counts = Array.new(20, 0)
-  end
-
-  def draw
-    size = @random_counts.size
-    # Pick a random number and increase the count.
-    @random_counts[rand(size)] += 1
-    background 255
-    stroke 0
-    fill 175
-    # Draw a rectangle to graph results
-    @random_counts.each_with_index do |count, i|
-      rect i * width/size, 0, (width/size)-1, count  
-    end
-  end
-
-end
-
-RandomNumberDistributionSketch.new :title => "Random Number Distribution", :width => 200, :height => 200

data/samples/learning_processing/chapter_13/03_probabilities.rb

@@ -1,33 +0,0 @@
-require 'ruby-processing'
-
-class ProbabilitiesSketch < Processing::App
-  def setup
-    background 255
-    smooth
-    no_stroke
-  end
-
-  def draw
-    # Probabilities for 3 different cases
-    # These need to add up to 100%!
-    red_prob = 0.60   # 60% chance of red color
-    green_prob = 0.70 # 10% chance of green color
-    blue_prob = 1.00  # 30% chance of blue color
-
-    # Pick a random number between 0 and 1
-    num = rand  
-
-    case num
-      when (0.0..red_prob):         fill(255, 53,  2,   150)
-      when (red_prob..green_prob):  fill(156, 255, 28,  150)
-      when (green_prob..blue_prob): fill(10,  52,  178, 150)
-    end
-
-    # Draw ellipse
-    ellipse rand(width), rand(height), 64, 64
-  end
-
-end
-
-
-ProbabilitiesSketch.new :title => "Probabilities", :width => 400, :height => 400

data/samples/learning_processing/chapter_13/04_perlin_noise.rb

@@ -1,22 +0,0 @@
-require 'ruby-processing'
-
-class PerlinNoiseSketch < Processing::App
-  def setup
-    smooth
-    @time = 0.0
-    @increment = 0.01
-  end
-  
-  def draw
-    background 255
-
-    n = noise(@time) * width
-    @time += @increment
-    fill 0
-    ellipse width/2, height/2, n, n
-  end
-
-end
-
-
-PerlinNoiseSketch.new :title => "Perlin Noise", :width => 400, :height => 400

data/samples/learning_processing/chapter_13/06_oscillation.rb

@@ -1,29 +0,0 @@
-require 'ruby-processing'
-
-class OscillationSketch < Processing::App
-
-  def setup
-    @theta = 0.0
-    smooth
-  end
-
-  def draw
-    background 255
-    # The output of the sin() function oscillates smoothly between 1 and 1. 
-    # By adding 1 we get values between 0 and 2. 
-    # By multiplying by 100, we get values between 0 and 200 which can be used as the ellipse's x location.
-    x = (sin(@theta) + 1) * width/2
-
-    # with each cycle, increment theta
-    @theta += 0.05
-    fill 0
-    stroke 0
-
-    # draw the ellipse at the value produce by the sin
-    line width/2, 0, x, height/2
-    ellipse x, height/2, 16, 16
-  end
-
-end
-
-OscillationSketch.new :title => "Oscillation", :width => 200, :height => 200

data/samples/learning_processing/chapter_13/07_wave.rb

@@ -1,31 +0,0 @@
-require 'ruby-processing'
-
-class WaveSketch < Processing::App
-
-  def setup
-    @theta = 0
-    smooth
-  end
-
-  def draw
-    background 255
-    # Increment theta (try different values for " angular velocity " here)
-    @theta += 0.02
-    no_stroke
-    fill 0
-    x = @theta
-
-    # times is used to draw all the points along a sine wave (scaled to the pixel dimension of the window).
-    20.times do |i|
-      # Calculate y value based off of sine function
-      y = sin(x) * height/2
-      # Draw an ellipse
-      ellipse i*10, y+height/2, 16, 16
-      # Move along x-axis
-      x += 0.2
-    end
-  end
-
-end
-
-WaveSketch.new :title => "Oscillation", :width => 200, :height => 200

data/samples/learning_processing/chapter_13/08_recursion.rb

@@ -1,30 +0,0 @@
-require 'ruby-processing'
-
-class RecursionSketch < Processing::App
-
-  def setup
-    smooth
-  end
-
-  def draw
-    background 255
-    stroke 0
-    no_fill
-
-    draw_circle width/2, height/2, width/2
-  end
-
-  def draw_circle(x, y, radius)
-    ellipse x, y, radius, radius
-    # It's important to establish an end-point to recursion, or else it 
-    # would go forever. Comment out the following line to break the sketch.
-    return if radius < 2
-    # draw_circle calls itself twice, creating a branching effect. 
-    # For every circle, a smaller circle is drawn to the left and right.
-    draw_circle x+radius/2, y, radius/2
-    draw_circle x-radius/2, y, radius/2
-  end
-
-end
-
-RecursionSketch.new :title => "Recursion", :width => 200, :height => 200

data/samples/learning_processing/chapter_13/09_two_dimensional_array.rb

@@ -1,21 +0,0 @@
-require 'ruby-processing'
-
-class TwoDimensionalArraySketch < Processing::App
-
-  def setup
-    smooth
-    # initialize array with random values
-    @my_array = Array.new(width) { Array.new(height) { rand 255 }}
-    
-    # draw the points
-    width.times do |i|
-      height.times do |j|
-        stroke @my_array[i][j]
-        point i, j
-      end
-    end
-  end
-
-end
-
-TwoDimensionalArraySketch.new :title => "Two Dimensional Array", :width => 200, :height => 200

data/samples/learning_processing/chapter_13/10_two_dimensional_array_with_objects.rb

@@ -1,54 +0,0 @@
-require 'ruby-processing'
-
-# Let's start by defining the cell class.
-class Cell
-
-  def initialize(x, y, w, h, angle)
-    @x, @y = x, y
-    @w, @h = w, h
-    @angle = angle
-  end
-
-  # we oscillate by increasing the angle, here.
-  def oscillate
-    @angle += 0.02
-  end
-
-  def display
-    $app.stroke 255
-    # calculate color using sine wave
-    $app.fill 127 + 127 * Math.sin(@angle)
-    $app.rect @x, @y, @w, @h
-  end
-  
-  def oscillate_and_display
-    oscillate
-    display
-  end
-
-end
-
-
-# And then the sketch that holds many cells.
-class ArrayWithObjectsSketch < Processing::App
-
-  def setup
-    smooth
-    @cols = @rows = 20
-
-    # initialize array with random values
-    @grid = Array.new(@cols) do |i| 
-      Array.new(@rows) do |j|
-        Cell.new(i*20, j*20, 20, 20, i+j)
-      end
-    end
-  end
-
-  def draw
-    background 0
-    @grid.each { |array| array.each { |cell| cell.oscillate_and_display } }
-  end
-
-end
-
-ArrayWithObjectsSketch.new :title => "Two Dimensional Array with Objects", :width => 200, :height => 200