ruby-processing 2.6.3 → 2.6.4

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

@@ -1,41 +0,0 @@
-#
-# 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 << load_image('PT_anim0000.gif')
-  images << load_image('PT_anim0001.gif')
-  images << load_image('PT_anim0002.gif')
-  images << load_image('PT_anim0003.gif')
-  images << load_image('PT_anim0004.gif')
-  images << load_image('PT_anim0005.gif')
-  images << load_image('PT_anim0006.gif')
-  images << load_image('PT_anim0007.gif')
-  images << load_image('PT_anim0008.gif')
-  images << load_image('PT_anim0009.gif')
-  images << load_image('PT_anim0010.gif')
-  images << load_image('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

@@ -1,125 +0,0 @@
-#
-# 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

@@ -1,91 +0,0 @@
-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.empty?
-      @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(0..1)}
-  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?
-    generation > (height/SCL)
-  end
-end