propane 0.3.0.pre-java

data/lib/propane/runner.rb

@@ -0,0 +1,88 @@
+# encoding: utf-8
+# frozen_string_literal: false
+require "#{PROPANE_ROOT}/lib/propane"
+require "#{PROPANE_ROOT}/lib/propane/app"
+require 'optparse'
+
+module Propane
+  # Utility class to handle the different commands that the 'rp5' command
+  # offers. Able to run, watch, live, create, app, and unpack
+  class Runner
+    attr_reader :options, :name
+
+    def initialize
+      @options = {}
+    end
+
+    # Start running a propane sketch from the passed-in arguments
+    def self.execute
+      runner = new
+      runner.parse_options(ARGV)
+      runner.execute!
+    end
+
+    # Dispatch central.
+    def execute!
+      show_help if options.empty?
+      show_version if options[:version]
+      run_sketch if options[:run]
+      install if options[:install]
+    end
+
+    # Parse the command-line options. Keep it simple.
+    def parse_options(args)
+      opt_parser = OptionParser.new do |opts|
+        # Set a banner, displayed at the top
+        # of the help screen.
+        opts.banner = 'Usage: propane [options] sketch.rb'
+
+        # Define the options, and what they do
+        options[:version] = false
+        opts.on('-v', '--version', 'Propane Version') do
+          options[:version] = true
+        end
+
+        options[:install] = false
+        opts.on('-i', '--install', 'Installs jruby-complete') do
+          options[:install] = true
+        end
+
+        options[:run] = false
+        opts.on('-r', '--run', 'Run the sketch using jruby-complete') do
+          options[:run] = true
+        end
+
+        # This displays the help screen, all programs are
+        # assumed to have this option.
+        opts.on('-h', '--help', 'Display this screen') do
+          puts opts
+          exit
+        end
+      end
+      @name = opt_parser.parse(args)
+    end
+
+    def run_sketch
+      root = File.absolute_path(File.dirname(ARGV.shift))
+      sketch = File.join(root, name)
+      warn_format = 'File %s does not not Exist!'
+      return warn(format(warn_format, sketch)) unless File.exist?(sketch)
+      command = [
+        'java',
+        '-cp',
+        "#{PROPANE_ROOT}/lib/ruby/jruby-complete.jar",
+        'org.jruby.Main',
+        sketch.to_s
+      ].flatten
+      exec(*command)
+    end
+
+    def show_version
+      puts format('Propane version %s', Propane::VERSION)
+    end
+
+    def install
+      system "cd #{PROPANE_ROOT}/vendors && rake"
+    end
+  end # class Runner
+end # module Propane

data/lib/propane/underscorer.rb

@@ -0,0 +1,19 @@
+# encoding: utf-8
+# frozen_string_literal: false
+module Propane
+  # This class defines a single method that converts a method name
+  # from camel or mixed case to snake case.
+  #
+  class Underscorer
+    # Underscorer.("CamelCase") => "camel_case"
+    #
+    def self.call(input)
+      string = input.to_s
+      string.gsub(/::/, '/')
+            .gsub(/([A-Z]+)([A-Z][a-z])/, '\1_\2')
+            .gsub(/([a-z\d])([A-Z])/, '\1_\2')
+            .tr('-', '_')
+            .downcase
+    end
+  end
+end

data/lib/propane/version.rb

@@ -0,0 +1,5 @@
+# encoding: utf-8
+# frozen_string_literal: true
+module Propane
+  VERSION = '0.3.0.pre'.freeze
+end

data/library/boids/boids.rb

@@ -0,0 +1,201 @@
+# Boids -- after Tom de Smedt.
+# See his Python version: http://nodebox.net/code/index.php/Boids
+# This is an example of how a pure-Ruby library can work. Original for
+# ruby-processing Jeremy Ashkenas. Reworked, re-factored for JRubyArt 0.9+
+# by Martin Prout, features forwardable, keyword args, Vec3D and Vec2D.
+class Boid
+  attr_accessor :boids, :pos, :vel, :is_perching, :perch_time
+
+  def initialize(boids, pos)
+    @boids, @flock = boids, boids
+    @pos = pos
+    @vel = Vec3D.new
+    @is_perching = false
+    @perch_time = 0.0
+  end
+
+  def cohesion(d:)
+    # Boids gravitate towards the center of the flock,
+    # Which is the averaged position of the rest of the boids.
+    vect = Vec3D.new
+    @boids.each do |boid|
+      vect += boid.pos unless boid == self
+    end
+    count = @boids.length - 1.0
+    vect /= count
+    (vect - pos) / d
+  end
+
+  def separation(radius:)
+    # Boids don't like to cuddle.
+    vect = Vec3D.new
+    @boids.each do |boid|
+      if boid != self
+        dv = pos - boid.pos
+        vect += dv if dv.mag < radius
+      end
+    end
+    vect
+  end
+
+  def alignment(d:)
+    # Boids like to fly at the speed of traffic.
+    vect = Vec3D.new
+    @boids.each do |boid|
+      vect += boid.vel if boid != self
+    end
+    count = @boids.length - 1.0
+    vect /= count
+    (vect - vel) / d
+  end
+
+  def limit(max:)
+    # Tweet, Tweet! The boid police will bust you for breaking the speed limit.
+    most = [vel.x.abs, vel.y.abs, vel.z.abs].max
+    return if most < max
+    scale = max / most.to_f
+    @vel *= scale
+  end
+
+  def angle
+    Vec2D.new(vel.x, vel.y).heading
+  end
+
+  def goal(target, d = 50.0)
+    # Them boids is hungry.
+    (target - pos) / d
+  end
+end
+
+require 'forwardable'
+
+# The Boids class
+class Boids
+  include Enumerable
+  extend Forwardable
+  def_delegators(:@boids, :reject, :<<, :each, :shuffle!, :length, :next)
+
+  attr_reader :has_goal, :perch, :perch_tm, :perch_y
+
+  def initialize
+    @boids = []
+  end
+
+  def self.flock(n:, x:, y:, w:, h:)
+    flock = Boids.new.setup(n, x, y, w, h)
+    flock.goal(target: Vec3D.new(w / 2, h / 2, 0))
+  end
+
+  def setup(n, x, y, w, h)
+    n.times do
+      dx, dy = rand(w), rand(h)
+      z = rand(200.0)
+      self << Boid.new(self, Vec3D.new(x + dx, y + dy, z))
+    end
+    @x, @y, @w, @h = x, y, w, h
+    @scattered = false
+    @scatter = 0.005
+    @scatter_time = 50.0
+    @scatter_i = 0.0
+    @perch = 1.0 # Lower this number to divebomb.
+    @perch_y = h
+    @perch_tm = -> { 25.0 + rand(50.0) }
+    @has_goal = false
+    @flee = false
+    @goal = Vec3D.new
+    self
+  end
+
+  def scatter(chance = 0.005, frames = 50.0)
+    @scatter = chance
+    @scatter_time = frames
+  end
+
+  def no_scatter
+    @scatter = 0.0
+  end
+
+  def perch(ground = nil, chance = 1.0, frames = nil)
+    @perch_tm = frames.nil? ? -> { 25.0 + rand(50.0) } : frames
+    @perch_y = ground.nil? ? @h : ground
+    @perch = chance
+  end
+
+  def no_perch
+    @perch = 0.0
+  end
+
+  def goal(target:, flee: false)
+    @has_goal = true
+    @flee = flee
+    @goal = target
+    self
+  end
+
+  def no_goal
+    @has_goal = false
+  end
+
+  def constrain
+    # Put them boids in a cage.
+    dx, dy = @w * 0.1, @h * 0.1
+    each do |b|
+      b.vel.x += rand(dx) if b.pos.x < @x - dx
+      b.vel.x += rand(dy) if b.pos.y < @y - dy
+      b.vel.x -= rand(dx) if b.pos.x > @x + @w + dx
+      b.vel.y -= rand(dy) if b.pos.y > @y + @h + dy
+      b.vel.z += 10.0 if b.pos.z < 0.0
+      b.vel.z -= 10.0 if b.pos.z > 100.0
+      next unless b.pos.y > perch_y && rand < perch
+      b.pos.y = perch_y
+      b.vel.y = -(b.vel.y.abs) * 0.2
+      b.is_perching = true
+      b.perch_time = perch_tm.respond_to?(:call) ? perch_tm.call : perch_tm
+    end
+  end
+
+  def update(goal: 20.0, limit: 30.0, **args)
+    shuffled = args.fetch(:shuffled, true)
+    cohesion = args.fetch(:cohesion, 100)
+    separation = args.fetch(:separation, 10)
+    alignment = args.fetch(:alignment, 5.0)
+    # Just flutter, little boids ... just flutter away.
+    # Shuffling keeps things flowing smooth.
+    shuffle! if shuffled
+    m1 = 1.0 # cohesion
+    m2 = 1.0 # separation
+    m3 = 1.0 # alignment
+    m4 = 1.0 # goal
+    @scattered = true if !(@scattered) && rand < @scatter
+    if @scattered
+      m1 = -m1
+      m3 *= 0.25
+      @scatter_i += 1.0
+    end
+    if @scatter_i >= @scatter_time
+      @scattered = false
+      @scatter_i = 0.0
+    end
+    m4 = 0.0 unless has_goal
+    m4 = -m4 if @flee
+    each do |b|
+      if b.is_perching
+        if b.perch_time > 0.0
+          b.perch_time -= 1.0
+          next
+        else
+          b.is_perching = false
+        end
+      end
+      v1 = b.cohesion(d: cohesion)
+      v2 = b.separation(radius: separation)
+      v3 = b.alignment(d: alignment)
+      v4 = b.goal(@goal, goal)
+      # NB: vector must precede scalar in '*' operation below
+      b.vel += (v1 * m1 + v2 * m2 + v3 * m3 + v4 * m4)
+      b.limit(max: limit)
+      b.pos += b.vel
+    end
+    constrain
+  end
+end

data/library/control_panel/control_panel.rb

@@ -0,0 +1,172 @@
+# Here's a little library for quickly hooking up controls to sketches.
+# For messing with the parameters and such.
+# These controls will set instance variables on the sketches.
+
+# You can make sliders, checkboxes, buttons, and drop-down menus.
+# (optionally) pass the range and default value.
+
+module ControlPanel
+  # class used to create slider elements for control_panel
+  class Slider < javax.swing.JSlider
+    def initialize(control_panel, name, range, initial_value, proc = nil)
+      min = range.begin * 100
+      max = (
+        (range.exclude_end? && range.begin.respond_to?(:succ)) ?
+          range.max : range.end) * 100
+      super(min, max)
+      set_minor_tick_spacing((max - min).abs / 10)
+      set_paint_ticks true
+      # paint_labels = true
+      set_preferred_size(java.awt.Dimension.new(190, 30))
+      label = control_panel.add_element(self, name)
+      add_change_listener do
+        update_label(label, name, value)
+        $app.instance_variable_set("@#{name}", value) unless value.nil?
+        proc.call(value) if proc
+      end
+      set_value(initial_value ? initial_value * 100 : min)
+      fire_state_changed
+    end
+
+    def value
+      get_value / 100.0
+    end
+
+    def update_label(label, name, value)
+      value = value.to_s
+      value << '0' if value.length < 4
+      label.set_text "<html><br><b>#{name}: #{value}</b></html>"
+    end
+  end
+
+  # class used to combo_box menu elements for control_panel
+  class Menu < javax.swing.JComboBox
+    def initialize(control_panel, name, elements, initial_value, proc = nil)
+      super(elements.to_java(:String))
+      set_preferred_size(java.awt.Dimension.new(190, 30))
+      control_panel.add_element(self, name)
+      add_action_listener do
+        $app.instance_variable_set("@#{name}", value) unless value.nil?
+        proc.call(value) if proc
+      end
+      set_selected_index(initial_value ? elements.index(initial_value) : 0)
+    end
+
+    def value
+      get_selected_item
+    end
+  end
+
+  # Creates check-box elements for control_panel
+  class Checkbox < javax.swing.JCheckBox
+    def initialize(control_panel, name, proc = nil)
+      @control_panel = control_panel
+      super(name.to_s)
+      set_preferred_size(java.awt.Dimension.new(190, 64))
+      set_horizontal_alignment javax.swing.SwingConstants::CENTER
+      control_panel.add_element(self, name, false)
+      add_action_listener do
+        $app.instance_variable_set("@#{name}", value) unless value.nil?
+        proc.call(value) if proc
+      end
+    end
+
+    def value
+      is_selected
+    end
+  end
+
+  # Creates button elements for control_panel
+  class Button < javax.swing.JButton
+    def initialize(control_panel, name, proc = nil)
+      super(name.to_s)
+      set_preferred_size(java.awt.Dimension.new(170, 64))
+      control_panel.add_element(self, name, false, true)
+      add_action_listener do
+        $app.send(name.to_s)
+        proc.call(value) if proc
+      end
+    end
+  end
+
+  # class used to contain control_panel elements
+  class Panel < javax.swing.JFrame
+    java_import javax.swing.UIManager
+
+    attr_accessor :elements, :panel
+
+    def initialize
+      super()
+      @elements = []
+      @panel = javax.swing.JPanel.new(java.awt.FlowLayout.new(1, 0, 0))
+      set_feel
+    end
+
+    def display
+      add panel
+      set_size 200, 30 + (64 * elements.size)
+      set_default_close_operation javax.swing.JFrame::HIDE_ON_CLOSE
+      set_resizable false
+      set_location($app.width + 10, 0) unless $app.width + 10 > $app.displayWidth
+      panel.visible = true
+    end
+
+    def add_element(element, name, has_label = true, _button_ = false)
+      if has_label
+        label = javax.swing.JLabel.new("<html><br><b>#{name}</b></html>")
+        panel.add label
+      end
+      elements << element
+      panel.add element
+      has_label ? label : nil
+    end
+
+    def remove
+      remove_all
+      dispose
+    end
+
+    def slider(name, range = 0..100, initial_value = nil, &block)
+      Slider.new(self, name, range, initial_value, block || nil)
+    end
+
+    def menu(name, elements, initial_value = nil, &block)
+      Menu.new(self, name, elements, initial_value, block || nil)
+    end
+
+    def checkbox(name, initial_value = nil, &block)
+      checkbox = Checkbox.new(self, name, block || nil)
+      checkbox.do_click if initial_value == true
+    end
+
+    def button(name, &block)
+      Button.new(self, name, block || nil)
+    end
+
+    def look_feel(lf)
+      set_feel(lf)
+    end
+
+    private
+
+    def set_feel(lf = 'metal')
+      lafinfo = javax.swing.UIManager.getInstalledLookAndFeels
+      laf = lafinfo.select do |info|
+        info.getName.eql? lf.capitalize
+      end
+      javax.swing.UIManager.setLookAndFeel(laf[0].getClassName)
+    end
+  end
+
+  # instance methods module
+  module InstanceMethods
+    def control_panel
+      @control_panel ||= ControlPanel::Panel.new
+      return @control_panel unless block_given?
+      yield(@control_panel)
+      @control_panel.display
+    end
+  end
+end
+
+Propane::App.send :include, ControlPanel::InstanceMethods