ruby-processing 1.0.11 → 2.4.1

data/samples/processing_app/topics/animation/sequential.rb

@@ -0,0 +1,42 @@
+#
+# Sequential
+# by James Paterson.  
+# 
+# Displaying a sequence of images creates the illusion of motion. 
+# Twelve images are loaded and each is displayed individually in a loop. 
+#
+
+
+NUM_FRAMES = 12  # The number of frames in the animation
+attr_reader :frame, :images
+    
+def setup
+  size(640, 360)
+  frame_rate(24)
+  @frame = 0
+  @images = []
+  images << loadImage("PT_anim0000.gif")
+  images << loadImage("PT_anim0001.gif") 
+  images << loadImage("PT_anim0002.gif")
+  images << loadImage("PT_anim0003.gif") 
+  images << loadImage("PT_anim0004.gif")
+  images << loadImage("PT_anim0005.gif") 
+  images << loadImage("PT_anim0006.gif")
+  images << loadImage("PT_anim0007.gif") 
+  images << loadImage("PT_anim0008.gif")
+  images << loadImage("PT_anim0009.gif") 
+  images << loadImage("PT_anim0010.gif")
+  images << loadImage("PT_anim0011.gif")
+end 
+ 
+def draw 
+  background(0)
+  @frame = (frame + 1) % NUM_FRAMES  # Use % to cycle through frames
+  offset = 0
+  (-100 ... width).step(images[0].width) do |i|  
+    image(images[(frame+offset) % NUM_FRAMES], i, -20)
+    offset+=2
+    image(images[(frame+offset) % NUM_FRAMES], i, height/2)
+    offset+=2
+  end
+end

data/samples/processing_app/topics/cellular_automata/game_of_life.rb

@@ -0,0 +1,125 @@
+#
+# A Processing implementation of Game of Life
+# By Joan Soler-Adillon
+#
+# Press SPACE BAR to pause and change the cell's values with the mouse
+# On pause, click to activate/deactivate cells
+# Press R to randomly reset the cells' grid
+# Press C to clear the cells' grid
+#
+# The original Game of Life was created by John Conway in 1970.
+#
+
+CELL_SIZE = 5
+ALIVE = true
+DEAD = false
+ALIVE_START = 150
+INTERVAL = 100
+
+attr_reader :pause, :cells, :row, :column, :last_time, :alive, :cells_buffer
+
+def setup
+  size(960, 640)
+  @pause = false
+  # Instantiate arrays 
+  @row = width / CELL_SIZE
+  @column = height / CELL_SIZE
+  @cells = Array.new(row) {Array.new(column) {(rand(1000) > ALIVE_START)? DEAD : ALIVE}}  
+  @last_time = 0
+  @alive = color(100, 255, 100)
+  # This stroke will draw the background grid (live cells)
+  stroke(48, 100)  
+  noSmooth  
+end
+
+def draw
+  background(0)   
+  #Draw live cells
+  row.times do |x|
+    column.times do |y|
+      if (cells[x][y])
+        fill(alive)
+        rect(x * CELL_SIZE, y * CELL_SIZE, CELL_SIZE, CELL_SIZE)
+      end
+    end
+  end
+  # Iterate if timer ticks
+  if (millis - last_time > INTERVAL)
+    if (!pause)
+      tick!
+      @last_time = millis
+    end
+  end 
+  
+  # Create  new cells manually on pause
+  if (pause && mouse_pressed?)
+    # # Map and avoid out of bound errors
+    over_x = (map(mouse_x, 0, width, 0, row)).to_i
+    over_x = constrain(over_x, 0, row - 1)
+    over_y = (map(mouse_y, 0, height, 0, column)).to_i
+    over_y = constrain(over_y, 0, column - 1)
+    
+    # Check against cells in buffer
+    if (cells_buffer[over_x][over_y])  # Cell is alive
+      cells[over_x][over_y] = DEAD # Kill
+      fill(0) #reflect changed status
+    else  # Cell is dead
+      cells[over_x][over_y] = ALIVE # Make alive
+      fill(alive) # Fill alive color
+    end
+    
+  elsif (pause && !mouse_pressed?)  # And then save to buffer once mouse goes up
+    # Save cells to buffer (so we operate with one array keeping the other intact)
+    @cells_buffer = clone2d(cells)
+  end
+end
+
+def tick!  # When the clock ticks
+  # Save cells to buffer (so we operate with one array keeping the other intact)
+  @cells_buffer = clone2d(cells)
+  # Visit each cell:
+  row.times do |x|
+    column.times do |y|
+      # And visit all the neighbours of each cell
+      neighbours = 0 # We'll count the neighbours
+      (x - 1 .. x + 1).each do |xx|
+        (y - 1 .. y + 1).each do |yy|
+          # Make sure you are not out of bounds
+          if [(xx>=0), (xx<row), (yy>=0), (yy<column)].all? {|in_bounds| in_bounds == true}  
+            # Make sure to check against self
+            if ![(xx == x), (yy == y)].all? {|is_self| is_self == true}   
+              if (cells_buffer[xx][yy]) # true == ALIVE
+                neighbours += 1 # Check alive neighbours and count them
+              end # alive
+            end # End of if self
+          end # End of if grid bounds
+        end # End of yy loop
+      end #End of xx loop
+      # We've checked the neighbours: apply rules in one line (only in ruby)!
+      cells[x][y] = (cells_buffer[x][y])?  ((2 .. 3) === neighbours) : (neighbours == 3)
+    end # End of y loop
+  end # End of x loop
+end # End of function
+
+def key_pressed
+  case key
+  when 'r', 'R'
+    # Restart: reinitialization of cells    
+    @cells = Array.new(row) {Array.new(column) {(rand(1000) > ALIVE_START)? DEAD : ALIVE}}    
+  when ' ' # On/off of pause
+    @pause = !pause
+  when 'c', 'C' # Clear all
+    @cells = Array.new(row) {Array.new(column) {DEAD}}
+  end
+end
+
+def clone2d array
+  result = []
+  array.each do |val|
+    result << val.clone
+  end
+  return result
+end
+
+
+

data/samples/processing_app/topics/cellular_automata/library/ca/ca.rb

@@ -0,0 +1,91 @@
+SCL = 1 # cell length
+
+class CA
+  include Processing::Proxy
+  attr_reader :rules, :generation, :cells, :height, :width
+  
+  def initialize(rules = [])
+    @width = $app.width
+    @height = $app.height
+    if rules.length > 0
+      @rules = rules
+    else
+      randomize
+    end
+    @cells = Array.new(width / SCL, 0)
+    restart
+  end
+  
+  # Set the rules of the CA
+  def set_rules(r)
+    @rules = r
+  end
+  
+  # Return a random ruleset
+  def randomize
+    @rules = Array.new(8) {(rand(100) > 50)? 1 : 0}
+  end
+  
+  # Reset to generation 0
+  def restart
+    @cells = Array.new(width / SCL, 0)
+    cells[cells.length/2] = 1    # We arbitrarily start with just the middle cell having a state of "1"
+    @generation = 0
+  end
+  
+  # The process of creating the new generation
+  def generate
+    # First we create an empty array for the new values
+    nextgen = Array.new(cells.length, 0)
+    # For every spot, determine new state by examing current state, and neighbour states
+    # Ignore edges that only have one neighbour
+    (1 ... cells.length - 1).each do |i|
+      left = cells[i-1]   # Left neighbour state
+      me = cells[i]       # Current state
+      right = cells[i+1]  # Right neighbour state
+      nextgen[i] = execute_rules(left, me, right) # Compute next generation state based on ruleset
+    end
+    # Copy the array into current value
+    (1 .. cells.length - 1).each do |i|
+      cells[i] = nextgen[i]
+    end
+    @generation += 1
+  end
+  
+  # This is the easy part, just draw the cells, fill 255 for '1', fill 0 for '0'
+  def render
+    (0 ... cells.length).each do |i|
+      if (cells[i] == 1)
+        fill(255)
+      else 
+        fill(0)
+      end
+      no_stroke
+      rect(i*SCL, generation*SCL, SCL, SCL)
+    end
+  end
+  
+  
+  def execute_rules(a, b, c)
+    val = 0
+    case a + b + c
+    when 3
+      val = 0
+    when 0
+      val = 7
+    when 1
+      val = (a == 1)? 3 : (b == 1)? 5 : 6
+    when 2
+      val = (c == 0)? 1 : (a == 0)? 4 : 2
+    else
+      return val   # default is zero
+    end
+    return rules[val] # otherwise val is index
+  end
+  
+  
+  # The CA is done if it reaches the bottom of the screen
+  def finished?
+    return (generation > (height/SCL))
+  end
+end