ruby-processing 1.0.1

data/samples/learning_processing/chapter_05/10_zoog_and_conditionals.rb

@@ -0,0 +1,53 @@
+require 'ruby-processing'
+
+class ZoogAndConditionals < Processing::App
+
+  def setup
+    @x, @y, @w, @h = 100.0, 100.0, 60.0, 60.0
+    @eye_size = 16.0
+    
+    # Zoog has variables for speed in the horizontal and vertical direction.
+    @x_speed, @y_speed = 3.0, 1.0
+    smooth  
+  end
+  
+  def draw
+    # Change the location of Zoog by speed
+    @x += @x_speed
+    @y += @y_speed
+    
+    # An IF statement with a logical OR determines if Zoog has reached either 
+    # the right or left edge of the screen.  
+    # When this is true, we multiply speed by -1, reversing Zoog's direction!
+    # Identical logic is applied to the y direction as well.
+    @x_speed *= -1 if @x > width || @x < 0
+    @y_speed *= -1 if @y > height || @y < 0
+    
+    background 255
+    ellipse_mode CENTER
+    rect_mode CENTER
+    
+    # Draw Zoog's body
+    stroke 0
+    fill 150
+    rect @x, @y, @w/6, @h*2
+    
+    # Draw Zoog's head
+    # added () to make order of operations a bit more clear
+    fill 255
+    ellipse @x, @y-@h/2, @w, @h 
+    
+    # Draw Zoog's eyes
+    fill 0 
+    ellipse @x-@w/3+1, @y-@h/2, @eye_size, @eye_size*2 
+    ellipse @x+@w/3-1, @y-@h/2, @eye_size, @eye_size*2
+    
+    # Draw Zoog's legs
+    stroke 0
+    line @x-@w/12, @y+@h, @x-@w/4, @y+@h+10
+    line @x+@w/12, @y+@h, @x+@w/4, @y+@h+10
+  end
+  
+end
+
+ZoogAndConditionals.new :title => "Zoog And Conditionals",  :width => 200,  :height => 200

data/samples/learning_processing/chapter_06/01_many_lines.rb

@@ -0,0 +1,29 @@
+require 'ruby-processing'
+
+class ManyLines < Processing::App
+
+  def setup
+    background 255
+    
+    # Legs  
+    stroke 0   
+    line 50, 60, 50, 80   
+    line 60, 60, 60, 80   
+    line 70, 60, 70, 80   
+    line 80, 60, 80, 80   
+    line 90, 60, 90, 80   
+    line 100, 60, 100, 80   
+    line 110, 60, 110, 80   
+    line 120, 60, 120, 80   
+    line 130, 60, 130, 80   
+    line 140, 60, 140, 80   
+    line 150, 60, 150, 80
+  end
+  
+  def draw
+  
+  end
+  
+end
+
+ManyLines.new :title => "Many Lines",  :width => 200,  :height => 200

data/samples/learning_processing/chapter_06/02_many_lines_with_variables.rb

@@ -0,0 +1,53 @@
+require 'ruby-processing'
+
+class ManyLinesWithVariables < Processing::App
+
+  def setup
+    background 255
+    
+    # Legs
+    stroke 0 
+    y = 80       # Vertical location of each line
+    x = 50       # Initial horizontal location for first line
+    spacing = 10 # How far apart is each line
+    len = 20     # Length of each line
+
+    # Draw the first leg.
+    line x, y, x, y + len  
+    # Add spacing so the next leg appears 10 pixels to the right.
+    x = x + spacing 
+
+    # You could continue this process for each leg, like in the original
+    # example, but it's pretty silly to repeat any chunk of code so many times:
+    
+    line x, y, x, y + len  
+    x = x + spacing
+    line x, y, x, y + len 
+    x = x + spacing
+    line x, y, x, y + len 
+    x = x + spacing
+    line x, y, x, y + len 
+    x = x + spacing
+    line x, y, x, y + len 
+    x = x + spacing
+    line x, y, x, y + len 
+    x = x + spacing
+    line x, y, x, y + len 
+    x = x + spacing
+    line x, y, x, y + len 
+    x = x + spacing
+    line x, y, x, y + len 
+    x = x + spacing
+    line x, y, x, y + len
+    
+    # A nicer way is to repeat that chunk of code with a block,
+    # you can see how in example 06.
+  end
+  
+  def draw
+  
+  end
+  
+end
+
+ManyLinesWithVariables.new :title => "Many Lines With Variables",  :width => 200,  :height => 200

data/samples/learning_processing/chapter_06/03_while_loop.rb

@@ -0,0 +1,30 @@
+require 'ruby-processing'
+
+class WhileLoop < Processing::App
+
+  def setup
+    background 255 
+
+    y = 80       # Vertical location of each line
+    x = 50       # Initial horizontal location for first line
+    spacing = 10 # How far apart is each line
+    len = 20     # Length of each line
+
+    # A variable to mark where the legs end.
+    end_legs = 150 
+    stroke 0 
+
+    # Draw each leg inside a while loop.
+    while  x <= end_legs 
+      line  x, y, x, y + len 
+      x = x + spacing
+    end
+  end
+  
+  def draw
+  
+  end
+  
+end
+
+WhileLoop.new :title => "While Loop",  :width => 200,  :height => 200

data/samples/learning_processing/chapter_06/04_infinite_loop.rb

@@ -0,0 +1,25 @@
+require 'ruby-processing'
+
+class InfiniteLoop < Processing::App
+
+  def setup
+  
+  end
+  
+  def draw
+    
+    x = 0
+    while x < 10
+      puts x
+      # Decrementing x results in an infinite loop here because the value of x will never be 10 or greater. 
+      # Be careful!
+      x = x - 1
+    end
+
+    # This example does not include the break function.
+    # To stop the runaway loop, close the window or use control-c in the terminal.
+  end
+  
+end
+
+InfiniteLoop.new :title => "Infinite Loop (Don't do this)", :width => 200, :height => 200

data/samples/learning_processing/chapter_06/05_another_infinite_loop.rb

@@ -0,0 +1,33 @@
+require 'ruby-processing'
+
+class AnotherInfiniteLoop < Processing::App
+
+  def setup
+    @y = 80        # Vertical location of each line
+    @x = 0         # Horizontal location of first line
+    @spacing = 10  # How far apart is each line
+    @len = 20      # Length of each line
+    @end_legs = 150 # Where should the lines stop?
+  end
+  
+  def draw
+    # The spacing variable, which sets the distance in between each line,
+    # is assigned a value equal to mouseX divided by two.
+    # THIS LINE IS COMMENTED OUT SO THAT THE SKETCH DOES NOT CRASH
+    # IF YOU PUT IT BACK IN THIS SKETCH WILL CRASH!
+    # @spacing = mouse_x / 2
+
+    # Exit Condition: when x is greater than endlegs.
+    while @x <= @end_legs
+      line @x, @y, @x, @y + @len
+      # Incrementation of x. 
+      # x always increases by the value of spacing.
+      #  What is the range of possible values for spacing?
+      @x = @x + @spacing
+    end
+  
+  end
+  
+end
+
+AnotherInfiniteLoop.new :title => "Another Infinite Loop", :width => 200, :height => 200

data/samples/learning_processing/chapter_06/06_legs_with_a_for_loop.rb

@@ -0,0 +1,41 @@
+require 'ruby-processing'
+
+class LegsWithAForLoop < Processing::App
+
+  def setup
+    background 255
+  end
+  
+  def reset_values
+    @x = 50       # Horizontal location of first line
+    @y = 80       # Vertical location of each line
+    @spacing = 10 # How far apart is each line
+    @len = 20     # Length of each line
+  end
+  
+  def draw
+    reset_values 
+    
+    # In ruby numbers also have methods.
+    # The times method allows you to run a given block of code 
+    # a certain number of times:
+    
+    10.times do
+      line @x, @y, @x, @y + @len
+      @x += @spacing
+    end
+    
+    # There's also an alternative method called step,
+    # You call it on the number you'd like to start with,
+    # passing it the end number, and the size of the steps to take:
+    # start_num.step(stop_num, step_size) { |value| do_something_with value ...
+    
+    50.step(150, @spacing) { |x| line x, @y, x, @y + @len }
+    
+    # The curly braces are an alternative form for writing do ... end.
+    # So, I guess this isn't much of a demonstration of the for loop... 
+  end
+  
+end
+
+LegsWithAForLoop.new :title => "Legs With A For Loop",  :width => 200,  :height => 200

data/samples/learning_processing/chapter_06/07_local_variables.rb

@@ -0,0 +1,39 @@
+require 'ruby-processing'
+
+class LocalVariables < Processing::App
+
+  def setup
+    # x is not available! It is local to the draw block of code.
+  end
+  
+  def draw
+    background 0 
+    x = 0
+    # x is available! Since it is declared within the draw
+    # block of code, it is available here. 
+    # Notice, however, that it is not available inside draw 
+    # above where it is declared. 
+    # Also, it is available inside the while block of code 
+    # because while is inside of draw.
+    
+    while x < width
+      stroke 255 
+      line x, 0, x, height 
+      x += 5
+    end
+    
+    # This could also be written with until:
+    # until x > width ...
+    # Or it could be written with step:
+    # 0.step(width, 5) do ...
+    
+  end
+  
+  def mouse_pressed
+    # x is not available! It is local to the draw block of code.
+    puts "The mouse was pressed!" 
+  end
+   
+end
+
+LocalVariables.new :title => "Local Variables", :width => 200, :height => 200

data/samples/learning_processing/chapter_06/08_lines_one_at_a_time.rb

@@ -0,0 +1,30 @@
+require 'ruby-processing'
+
+class LinesOneAtATime < Processing::App
+  
+  # No for loop here. Instead, a global variable.
+  # In ruby, global variables start with $.
+  $y = 0
+  
+  def setup
+    background 255
+    # Slowing down the frame rate so we can easily see the effect.
+    frame_rate 5
+  end
+  
+  def draw
+    # Draw a line
+    stroke 0 
+    # Only one line is drawn each time through draw.
+    line 0, $y, width, $y  
+    # Increment y
+    $y += 10
+
+    # Reset y back to 0 when it gets to the bottom of window
+    # In ruby, you can put if statements at the end, like speaking.
+    $y = 0 if $y > height
+  end
+  
+end
+
+LinesOneAtATime.new :title => "Lines One At A Time", :width => 200, :height => 200

data/samples/learning_processing/chapter_06/09_simple_while_loop_with_interactivity.rb

@@ -0,0 +1,41 @@
+require 'ruby-processing'
+
+class SimpleWhileLoopWithInteractivity < Processing::App
+
+  def setup
+    # no_stroke can go inside setup, because it only needs to be called once.
+    no_stroke  
+  end
+  
+  def draw
+    background 0 
+
+    # Start with i as 0
+    i = 0
+
+    # While i is less than the width of the window
+    while i < width
+      # The distance between the current rectangle and the mouse 
+      # is equal to the absolute value of the difference between i and mouseX.
+      distance = (mouse_x - i).abs  
+      # That distance is used to fill the color of a rectangle at horizontal location i.
+      fill distance 
+      rect i, 0, 10, height 
+      # Increase i by 10
+      i += 10
+    end
+    
+    # Un-comment the following lines to perform the same procedure
+    # for the height of the sketch, at half opacity.
+    # Uses a slightly different technique:
+    
+    # (height/10).times do |j|
+    #   distance = (mouse_y - j*10).abs
+    #   fill distance, 128
+    #   rect 0, j*10, width, 10
+    # end
+  end
+  
+end
+
+SimpleWhileLoopWithInteractivity.new :title => "Simple While Loop With Interactivity", :width => 255, :height => 255

data/samples/learning_processing/chapter_06/10_zoog_with_arms.rb

@@ -0,0 +1,56 @@
+require 'ruby-processing'
+
+class ZoogwithArms < Processing::App
+
+  def setup
+    @x, @y = 100,  100
+    @w, @h = 60,  60
+    @eye_size = 16
+    @speed = 1
+    smooth
+    
+    # Set ellipses and rects to CENTER mode
+    # We can do this in setup because we only need to do it once
+    ellipseMode CENTER 
+    rectMode CENTER
+  end
+  
+  def draw
+    # Change the x location of Zoog by speed
+    @x += @speed
+
+    # If we've reached an edge, reverse speed  i.e. multiply it by -1 
+    # Note if speed is a + number, square moves to the right, - to the left 
+    @speed *= -1 if @x > @width || @x < 0
+
+    background 255  # Draw a white background
+    stroke 0        # Set the stroke color to black
+
+    # Arms are incorporated into Zoog's design with a times loop.
+    6.times do |i|
+      y = i * 10 + @y + 5
+      line @x-@w/3, y, @x+@w/3, y
+    end
+
+    # Draw Zoog's body
+    fill 175 
+    rect @x, @y, @w/6, @h*2 
+
+    # Draw Zoog's head
+    fill 255 
+    ellipse @x, @y-@h/2, @w, @h 
+
+    # Draw Zoog's eyes
+    fill 0 
+    ellipse @x-@w/3+1, @y-@h/2, @eye_size, @eye_size*2 
+    ellipse @x+@w/3-1, @y-@h/2, @eye_size, @eye_size*2 
+
+    # Draw Zoog's legs
+    line @x-@w/12, @y+@h, @x-@w/4, @y+@h+10 
+    line @x+@w/12, @y+@h, @x+@w/4, @y+@h+10
+    
+  end
+  
+end
+
+ZoogwithArms.new :title => "Zoog with Arms",  :width => 200,  :height => 200