redshift 1.3.17 → 1.3.18

data/.bnsignore

@@ -0,0 +1,23 @@
+# The list of files that should be ignored by Mr Bones.
+# Lines that start with '#' are comments.
+#
+# A .gitignore file can be used instead by setting it as the ignore
+# file in your Rakefile:
+#
+#   PROJ.ignore_file = '.gitignore'
+#
+# For a project with a C extension, the following would be a good set of
+# exclude patterns (uncomment them if you want to use them):
+# *.[oa]
+# *~
+announcement.txt
+coverage
+doc
+pkg
+*.bck
+misc
+junk
+tmp
+*/tmp
+*/*/tmp
+*/junk

data/.gitignore

@@ -1,8 +1,9 @@
 *.bck
-pkg
-doc
-junk/*
-tmp/*
+/pkg
+junk
 tmp
-*/tmp
-*/junk
+*.o
+*.so
+/ext/*/*/Makefile
+/ext/*/*/*/Makefile
+/rdoc/*

data/README

@@ -1,5 +1,23 @@
-To install:
+= RedShift
+
+A framework for simulation of networks of hybrid automata, similar to SHIFT and Lambda-SHIFT. Includes ruby-based DSL for defining simulation components, and ruby/C code generation and runtime.
+
+There's no documentation yet. Start with the examples.
+
+== Requirements
+
+RedShift needs ruby 1.8.x and a compatible C compiler. If you can build native gems, you're all set.
+
+== Env vars
+
+If you have a multicore system and are using the gnu toolchain, set
+
+REDSHIFT_MAKE_ARGS='-j -l2'
+
+or some variation. You'll find that rebuilds of your simulation code go faster.
+
+----
+
+Copyright (C) 2001-2010, Joel VanderWerf, vjoel@users.sourceforge.net
+Distributed under the Ruby license. See www.ruby-lang.org.
 
-  ruby install.rb config
-  ruby install.rb setup
-  ruby install.rb install

data/RELEASE-NOTES

@@ -1,3 +1,19 @@
+redshift 1.3.18
+
+- added robots example
+
+- redshift builds isaac and buffer code at install time, rather than run time
+
+- added isaac extension and reverted tests to use it again
+
+- use REDSHIFT_MAKE_ARGS
+
+- added -j2 switch to test
+
+- added modular.rb for modular use of redshift DSL, and an example
+
+- some rdoc improvements
+
 redshift 1.3.17
 
 - added shell example with plotting and tk animation

data/examples/lotka-volterra.rb

@@ -24,7 +24,7 @@ require 'redshift/util/plot'
 include Plot::PlotUtils
 
 gnuplot do |plot|
-  plot.command %{set title "Lotla-Volterra"}
+  plot.command %{set title "Lotka-Volterra"}
   plot.command %{set xlabel "time"}
   plot.add data, %{using 1:2 title "foxes" with lines}
   plot.add data, %{using 1:3 title "rabbits" with lines}

data/examples/modular-component-def.rb

@@ -0,0 +1,49 @@
+# This example shows how to define things in a module and include that in a
+# Component or World class.
+
+require 'redshift'
+require 'redshift/util/modular'
+
+module ThermoStuff
+  extend Modular
+  
+  continuous :temp
+  
+  state :Heat, :Off
+
+  flow :Heat do # Must quote constants, since they are defined later
+    diff "temp' = (68 - temp)/3"
+  end
+
+  flow :Off do
+    diff "temp' = (45 - temp)/10"
+  end
+  
+  transition :Heat => :Off do
+    guard "temp > 68 - 0.1"
+  end
+  
+  transition :Off => :Heat do
+    guard "temp < 66"
+  end
+  
+  setup do
+    start :Off
+  end
+end
+
+class Thermostat < RedShift::Component
+  include ThermoStuff
+  
+  default do
+    self.temp = 35
+  end
+end
+
+world = RedShift::World.new
+thermostat = world.create Thermostat
+
+world.evolve 30 do |w|
+  printf "%6.2f: %7.3f %s\n", w.clock, thermostat.temp, thermostat.state
+end
+

data/examples/robots/README

@@ -0,0 +1,49 @@
+= Robots
+
+An example covering some of the basic language features plus some techniques for interactive simulation and for animating simulation output.
+
+To run the example:
+
+  ruby robots.rb
+  
+Press ^C to break into a command shell, and then ^D to continue the simulation run. The "help" command in the shell shows you the commands beyond the basic irb.
+
+Use -h from the command line to see the switches.
+
+To change the setup of the world, edit robots.rb. You can add and move robots and missles.
+
+You can also move the objects interactively in the Tk visualization.
+
+Currently, the robots move around and the missles track and hit them.
+
+= To do
+
+== robots physics
+
+- collision detection and effect on robot health
+
+- walls and obstacles
+
+== robot control
+
+- command language to evade attackers and launch missiles based on radar
+
+- maybe similar to RoboTalk (from RoboWar)
+
+- multirobot coordination using comm channels
+
+== game mechanics
+
+- robot shop
+
+- tournaments
+
+== dev tools
+
+- debugger
+
+- plotter
+
+== visualization
+
+- for each sensor, show nearest robot by drawing arrow

data/examples/robots/lib/base.rb

@@ -0,0 +1,38 @@
+# This file encapsulates some relatively uninteresting tweaks and additions
+# to make the demo go smoothly.
+
+require 'redshift'
+
+class RobotComponent < RedShift::Component
+  attr_accessor :name # for display; can be anything
+  attr_reader   :id   # for keeping track of tk objects; must be uniq int
+  
+  default do
+    @id = world.next_id
+    @name = id
+  end
+
+  def tk_delete
+    "delete #{id}"
+  end
+  
+  state :Done
+  
+  transition Done => Exit do
+    action do
+      world.exited << self
+    end
+  end
+end
+
+require 'shell-world'
+require 'robot'
+
+class RobotWorld < RedShift::World
+  include ShellWorld
+
+  def show_status
+    grep(Robot) {|r| r.show_status}
+    nil
+  end
+end

data/examples/robots/lib/explosion.rb

@@ -0,0 +1,48 @@
+class Explosion < RobotComponent
+  continuous :size, :max_size, :x, :y, :vx, :vy
+  continuous :t, :prev_t
+  
+  setup do
+    self.t = self.prev_t = 0
+  end
+  
+  state :Expanding
+  start Expanding
+   
+  flow Expanding do
+    diff " x' = vx "
+    diff " y' = vy "
+    diff " size' = 10 * sqrt(size) "
+    diff " t' = 1 "
+  end
+  
+  transition Expanding => Done do
+    guard " size > max_size "
+  end
+  
+  transition Expanding => Expanding do
+    guard " t > prev_t "
+    action do
+      world.grep(Robot) do |r|
+        if (x - r.x)**2 + (y - r.y)**2 < size**2
+          r.messages <<
+            Robot::InflictDamage.new(10*(max_size - size)*(t - prev_t))
+        end
+      end
+    end
+    reset :prev_t => "t"
+  end
+  
+  def tk_add
+    "add explosion #{id} - 0 #{x} #{y} 0 #{size} #{-size}"
+  end
+  
+  # emit string representing current state
+  def tk_update
+    fade = ("%x" % ((size / max_size) * 256)) * 2
+    "moveto #{id} #{x} #{y}\n" +
+    "param #{id} 0 #{size}\n" +
+    "param #{id} 1 #{-size}\n" +
+    "param #{id} 2 0xFF#{fade}"
+  end
+end

data/examples/robots/lib/missile.rb

@@ -0,0 +1,75 @@
+class Missile < RobotComponent
+  require 'explosion'
+  
+  link :target => Robot
+  
+  continuous :x, :y, :vx, :vy, :v, :heading, :power
+  constant :turn_rate
+  
+  state :Seeking
+  start Seeking
+  
+  default do
+    self.power = 40
+    self.v = 20
+    self.turn_rate = 60 * Math::PI / 180 # convert from degrees per sec
+  end
+
+  flow Seeking do
+    alg " vx = v * cos(heading) "
+    alg " vy = v * sin(heading) "
+
+    diff " x' = vx "
+    diff " y' = vy "
+    
+    diff "power' = -1"
+    
+    alg " distance =
+        sqrt(
+          pow(x - target.x, 2) +
+          pow(y - target.y, 2) ) "
+    
+    alg " angle =
+        atan2(target.y - y,
+              target.x - x) "
+    
+    alg " error = fmod(heading - angle, 2*#{Math::PI}) "
+    diff " heading' = turn_rate * (
+            error < #{-Math::PI/2} ?
+              #{-Math::PI/2} :
+              (error > #{Math::PI/2} ?
+                #{Math::PI/2} : -error)) "
+  end
+
+  transition Seeking => Done do
+    guard "power < 0"
+  end
+  
+  transition Seeking => Done do
+    guard "distance < 1"
+    action do
+      unless target.state == Exit
+        create Explosion do |e|
+          e.size = 1
+          e.max_size = power
+          e.x = x
+          e.y = y
+          e.vx = vx
+          e.vy = vy
+        end
+      end
+    end
+  end
+
+  # return string that adds an instance of the shape with label t.name,
+  # position based on (x, y), and rotation based on heading
+  def tk_add
+    "add missile #{id} - 11 #{x} #{y} #{heading}"
+  end
+  
+  # emit string representing current state
+  def tk_update
+    "moveto #{id} #{x} #{y}\n" +
+    "rot #{id} #{heading}"
+  end
+end

data/examples/robots/lib/radar.rb

@@ -0,0 +1,56 @@
+require 'tracker'
+
+class Radar < RobotComponent
+  constant :period => 0.200
+  continuous :t
+  continuous :distance
+  continuous :angle
+  attr_accessor :host_robot, :nearest_robot
+  link :nearest_tracker => Tracker
+  
+  attr_accessor :trackers
+  default do
+    self.trackers = []
+  end
+  
+  # add +robots+ to the list of objects tracked by this radar
+  def track_robots *robots
+    robots.flatten.each do |robot|
+      tracker = create Tracker
+      tracker.host = host_robot
+      tracker.target = robot
+      trackers << tracker
+    end
+  end
+  
+  state :Sleep, :Measure
+  start Sleep
+  
+  flow Sleep do
+    diff " t' = -1 "
+  end
+
+  flow Sleep, Measure do
+    alg " angle_deg = fmod(angle * #{180/Math::PI}, 360)"
+  end
+  
+  transition Sleep => Measure do
+    guard " t <= 0 "
+    action do
+      scan_for_nearest_robot
+    end
+  end
+  
+  transition Measure => Sleep do
+    reset :t => "period"
+  end
+
+  def scan_for_nearest_robot
+    self.nearest_tracker = trackers.min_by {|tracker| tracker.distance}
+    if nearest_tracker
+      self.nearest_robot = nearest_tracker.target ## how to delay this?
+      self.distance = nearest_tracker.distance
+      self.angle = nearest_tracker.angle
+    end
+  end
+end

data/examples/robots/lib/robot.rb

@@ -0,0 +1,105 @@
+class Robot < RobotComponent
+  require 'radar'
+  require 'explosion'
+  require 'missile'
+
+  continuous :x, :y, :vx, :vy, :v, :heading, :power, :health
+  link :radar => :Radar
+  
+  InflictDamage = Struct.new(:value)
+  queue :messages
+  
+  default do
+    self.radar = create Radar
+    radar.host_robot = self
+    
+    self.power = 100
+    self.health = 100
+  end
+  
+  state :Stopped, :Rolling, :Exploding
+  start :Rolling
+  
+  flow Stopped, Rolling do
+    alg " vx = v * cos(heading) "
+    alg " vy = v * sin(heading) "
+
+    alg " heading_deg = fmod(heading * #{180/Math::PI}, 360)"
+
+    diff " x' = vx "
+    diff " y' = vy "
+    
+    # a bit of friction, i.e. deceleration proportional to velocity
+    diff " v' = -0.01 * v"
+  end
+  
+  flow Rolling do
+    # it takes power to maintain speed
+    diff " power' = -1 "
+  end
+  
+  transition Rolling => Stopped do
+    guard " power <= 0 "
+  end
+  
+  transition Rolling => Exploding, Stopped => Exploding do
+    guard " health <= 0 "
+    action do
+      create Explosion do |e|
+        e.size = 1
+        e.max_size = 60
+        e.x = x
+        e.y = y
+        e.vx = vx
+        e.vy = vy
+      end
+    end
+  end
+  
+  transition Exploding => Done
+  
+  transition Rolling => Rolling, Stopped => Stopped do
+    wait :messages => InflictDamage
+    action do
+      m = messages.pop
+      case m
+      when RedShift::SimultaneousQueueEntries
+        dmg_msgs, other = m.partition {|n| InflictDamage === n}
+        messages.unpop other
+        dmg_msgs.each do |n|
+          self.health -= n.value
+        end
+      else
+        self.health -= m.value
+      end
+    end
+  end
+
+  # return string that adds an instance of the shape with label t.name,
+  # position based on (x, y), and rotation based on heading
+  def tk_add
+    "add robot #{id} - 10 #{x} #{y} #{heading}\n" +
+    "param #{id} 0 #{name}\n" +
+    "param #{id} 1 359\n" +
+    "param #{id} 2 359"
+  end
+  
+  # emit string representing current state
+  def tk_update
+    e = (power / 100.0) * 359.9
+    h = (health / 100.0) * 359.9
+    "moveto #{id} #{x} #{y}\n" +
+    "rot #{id} #{heading}\n" +
+    "param #{id} 1 #{e}\n" +
+    "param #{id} 2 #{h}"
+  end
+  
+  def show_status
+    printf \
+      "%5.3f sec: closest blip is %s, at %8.3f meters, bearing %3d degrees\n",
+      world.clock,
+      radar.nearest_robot ? radar.nearest_robot.name : "none",
+      radar.distance,
+      (radar.angle * 180/Math::PI).round.abs
+  end
+end