zyps 0.1.1 → 0.2.1

data/README.txt

@@ -26,10 +26,28 @@ Make sure you have administrative privileges, then type the following at a comma
 
 Ensure Ruby-GNOME2 is installed and working.
 
-To see the demo, at a command line, type:
+At a command line, type:
+
+	zyps
+
+To see a tutorial on the library, at a command line, type:
 
 	zyps_demo
 
+To run a DRb server others can connect to and add creatures (NOTE: not thoroughly tested and probably insecure!):
+
+	zyps_server [options]
+	  -h, --help                       Display program help.
+	  -m, --max-population [number]    The maximum number of allowed game
+	                                   objects.  25 by default.
+	  -p, --port [number]              Port number to run the server on.
+	                                   If not defined, next available one
+	                                   will be selected and the URI printed
+	                                   to STDOUT.
+	  -f, --fps [frames]               Number of frames to draw per second.
+	      --view-width [pixels]        Window width.  800 by default.
+	      --view-height [pixels]       Window height.  600 by default.
+
 
 == Development
 

data/bin/zyps

@@ -28,14 +28,366 @@ rescue LoadError
 end
 
 
-begin
+#Generates new creatures and places them in an environment.
+class Generator
 
-	puts "This is just a placeholder for the final application."
-	puts "To see a demonstration of the library, please run 'zyps_demo'."
+	#Environment creatures will be spawned into.
+	attr_accessor :environment
+	#Boundary that all new objects must be inside.
+	attr_accessor :min_x, :min_y, :max_x, :max_y
+	#Array of tags to choose from when generating new one.
+	attr_accessor :tag_pool
+	#Array of colors to choose from when generating new one.
+	attr_accessor :color_pool
+	#The maximum speed a new creature should be going.
+	attr_accessor :max_speed
+	#The maximum number of behaviors a creature can have.
+	attr_accessor :max_behaviors
+	#The maximum number of conditions a Behavior can have.
+	attr_accessor :max_conditions
+	#The maximum number of actions a Behavior can have.
+	attr_accessor :max_actions
+	
+	def initialize(environment, min_x, min_y, max_x, max_y)
+		@environment, @min_x, @min_y, @max_x, @max_y = environment, min_x, min_y, max_x, max_y
+		@tag_pool = %q{foo bar baz}
+		@color_pool = []
+		@max_behaviors = 2
+		@max_conditions = 2
+		@max_actions = 2
+		@max_speed = 100
+	end
+	
+	#Create a creature.
+	def create_creature()
+	
+		creature = Creature.new()
+		#Create a Color.
+		creature.color = create_color
+		#Create a Location.
+		creature.location = create_location
+		#Create a Vector.
+		creature.vector = create_vector()
+		#Create a random tag.
+		creature.tags << create_tag()
+		#Create a random number of behaviors.
+		generate_number(0, @max_behaviors).to_i.times {creature.behaviors << create_behavior()}
+		
+		creature
+		
+	end
+	
+	#Create a random tag.
+	#Chooses from tag_pool.
+	def create_tag()
+		@tag_pool[generate_number(0, @tag_pool.length).to_i]
+	end
+	#Create a random Color.
+	#Chooses from color_pool, or creates a random one from scratch if color_pool is empty.
+	def create_color()
+		if (color_pool.length != 0) then
+			return @color_pool[generate_number(0, @color_pool.length).to_i]
+		else
+			return Color.new(generate_random_number(0, 1), generate_random_number(0, 1), generate_random_number(0, 1))
+		end
+	end
+	#Create a random Location.
+	def create_location()
+		Location.new(
+			generate_random_number(0, @max_x - @min_x) + @min_x,
+			generate_random_number(0, @max_y - @min_y) + @min_y
+		)
+	end
+	#Create a random Vector.
+	def create_vector()
+		Vector.new(generate_number(0, @max_speed), generate_number(0, 360))
+	end
+	#Create a random Behavior.
+	def create_behavior()
+		behavior = Behavior.new
+		action_count = generate_number(0, @max_actions).to_i
+		action_count.times do
+			behavior.actions << create_action()
+		end
+		#Only add conditions if there's an action.
+		if action_count > 0 then
+			#There should always be a proximity condition.
+			behavior.conditions << create_proximity_condition()
+			#Add some additional conditions.
+			generate_random_number(0, @max_conditions).to_i.times do
+				behavior.conditions << create_condition()
+			end
+		end
+		behavior
+	end
+	#Create a random condition.
+	def create_condition()
+		case generate_number(0, 2).to_i
+		when 0
+			return create_tag_condition()
+		when 1
+			return create_age_condition()
+		else
+			raise "Invalid condition"
+		end
+	end
+	#Create a condition that looks for a random tag.
+	def create_tag_condition()
+		tag = create_tag()
+		lambda {|creature, target| target.tags.include?(tag)}
+	end
+	#Create a condition that looks for a random age.
+	def create_age_condition()
+		age = generate_number(0, 60)
+		lambda {|creature, target| target.age > age}
+	end
+	#Create a condition that looks for a random proximity.
+	def create_proximity_condition()
+		proximity = generate_number(0, 100)
+		lambda do |creature, target|
+			Utility.find_distance(creature.location, target.location) < proximity
+		end
+	end
+	#Create a random action.
+	def create_action()
+		case generate_random_number(0, 9).to_i
+		when 0
+			return create_accelerate_action()
+		when 1
+			return create_approach_action()
+		when 2
+			return create_flee_action()
+		when 3
+			return create_blend_action()
+		when 4
+			return create_mate_action()
+		when 5
+			return create_spawn_action()
+		when 6
+			return create_turn_action()
+		when 7
+			return create_eat_action()
+		when 8
+			return create_tag_action()
+		else
+			raise "Invalid action"
+		end
+	end
+	#Create an action that accelerates at a random rate.
+	def create_accelerate_action()
+		clock = Clock.new()
+		rate = generate_number(0, 10)
+		lambda {|creature, target| creature.vector.speed += rate * clock.elapsed_time}
+	end
+	#Create an action that turns in a circle.
+	def create_turn_action()
+		clock = Clock.new()
+		rate = generate_number(0, 360)
+		lambda {|creature, target| creature.vector.pitch += rate * clock.elapsed_time}
+	end
+	#Create an action that approaches the target.
+	def create_approach_action()
+		heading = Vector.new
+		rate = generate_number(0, 20)
+		lambda do |creature, target|
+			#Find the difference between the current heading and the angle to the target.
+			turn_angle = Utility.find_angle(creature.location, target.location) - heading.pitch
+			#If the angle is the long way around from the current heading, change it to the smaller angle.
+			if turn_angle > 180 then
+				turn_angle -= 360.0
+			elsif turn_angle < -180 then
+				turn_angle += 360.0
+			end
+			#If turn angle is greater than allowed turn speed, reduce it.
+			turn_angle = Utility.constrain_value(turn_angle, rate)
+			#Turn the appropriate amount.
+			heading.pitch += turn_angle
+			#Apply the heading to the creature's movement vector.
+			creature.vector += heading
+		end
+	end
+	#Create an action that flees from the target.
+	def create_flee_action()
+		heading = Vector.new
+		rate = generate_number(0, 20)
+		lambda do |creature, target|
+			#Find the difference between the current heading and the angle AWAY from the target.
+			turn_angle = Utility.find_angle(creature.location, target.location) - heading.pitch + 180
+			#If the angle is the long way around from the current heading, change it to the smaller angle.
+			if turn_angle > 180 then
+				turn_angle -= 360.0
+			elsif turn_angle < -180 then
+				turn_angle += 360.0
+			end
+			#If turn angle is greater than allowed turn speed, reduce it.
+			turn_angle = Utility.constrain_value(turn_angle, rate)
+			#Turn the appropriate amount.
+			heading.pitch += turn_angle
+			#Apply the heading to the creature's movement vector.
+			creature.vector += heading
+		end
+	end
+	#Create an action that shifts the subject's color to match the target.
+	def create_blend_action()
+		lambda {|creature, target| creature.color += target.color}
+	end
+	#Create an action that mates with the target.
+	def create_mate_action()
+		#TODO
+		lambda {|creature, target| }
+	end
+	#Create an action that spawns a new creature.
+	def create_spawn_action()
+		#TODO
+		lambda {|creature, target| }
+	end
+	#Create an action that eats the target.
+	def create_eat_action()
+		lambda {|creature, target| @environment.objects.delete(target)}
+	end
+	#Create an action that applies a tag to the target.
+	def create_tag_action()
+		tag = create_tag()
+		lambda {|creature, target| target.tags << tag unless target.tags.include?(tag)}
+	end
+	#Generate a number between the given minimum and maximum, based on the current system time.
+	def generate_number(minimum, maximum)
+		(Time.new.to_f % (maximum - minimum)) + minimum
+	end
+	#Generate a random number between the given minimum and maximum.
+	def generate_random_number(minimum, maximum)
+		value = rand * (maximum - minimum) + minimum
+	end
+end
 
-rescue => exception
 
+#Keeps all objects within a set of walls.
+class Enclose < Behavior
+	attr_accessor :left, :top, :right, :bottom
+	def initialize
+		super
+		@actions << lambda do |boundary, object|
+			#If object is beyond a boundary, set its position equal to the boundary and reflect it.
+			if (object.location.x < @left) then
+				object.location.x = @left
+				object.vector.pitch = Utility.find_reflection_angle(90, object.vector.pitch)
+			elsif (object.location.x > @right) then
+				object.location.x = @right
+				object.vector.pitch = Utility.find_reflection_angle(270, object.vector.pitch)
+			end
+			if (object.location.y < @top) then
+				object.location.y = @top
+				object.vector.pitch = Utility.find_reflection_angle(0, object.vector.pitch)
+			elsif (object.location.y > @bottom) then
+				object.location.y = @bottom
+				object.vector.pitch = Utility.find_reflection_angle(180, object.vector.pitch)
+			end
+		end
+	end
+end
+
+
+class Application
+
+	#Tags to randomly choose from.
+	attr_accessor :tag_pool
+	#Colors to randomly choose from.
+	attr_accessor :color_pool
+	#Seconds between creature creation.
+	attr_accessor :birth_rate
+	
+	#Create app window, game environment, and view.
+	def initialize(width, height)
+		
+		@width, @height = width, height
+		@tag_pool, @color_pool = [], []
+		@birth_rate = 1
+
+		#Create a window, and set GTK up to quit when it is closed.
+		window = Gtk::Window.new
+		window.signal_connect("delete_event") {false}
+		window.signal_connect("destroy") {Gtk.main_quit}
+		
+		#Add view to window.
+		@view = TrailsView.new(@width, @height)
+		window.add(@view.canvas)
+		window.show_all
+		
+		#Create environment.
+		@environment = Environment.new
+		
+		#Point view at environment.
+		@environment.add_observer(@view)
+		
+	end
+	
+	
+	def main
+	
+		#Keep all objects within a boundary.
+		enclose = Enclose.new()
+		enclose.left = 0
+		enclose.right = @width
+		enclose.top = 0
+		enclose.bottom = @height
+		@environment.environmental_factors << EnvironmentalFactor.new([enclose])
+
+		#Create a creature generator.
+		generator = Generator.new(@environment, 0, 0, @width, @height)
+		generator.tag_pool = @tag_pool
+		generator.color_pool = @color_pool
+
+		#Create thread to update environment.
+		thread = Thread.new do
+			begin
+				birth_clock = Clock.new
+				time_since_birth = 0
+				loop do
+					@environment.interact
+					#Control population.
+					@environment.objects.shift while @environment.objects.length > 25
+					#Create new creature every few seconds.
+					if (time_since_birth += birth_clock.elapsed_time) > birth_rate
+						@environment.objects << generator.create_creature()
+						time_since_birth = 0
+					end
+					#Delay 1/60th second to avoid screen flicker.
+					sleep 1.0 / 60.0
+				end
+			rescue Exception => exception
+				puts exception, exception.backtrace
+			end
+		end
+		
+		#Activate the GUI.
+		Gtk.main
+		
+	end
+	
+
+end
+
+
+begin
+	TAG_POOL = %w{x y z}
+	COLOR_POOL = [
+		Color.new(1, 0, 0),
+		Color.new(1, 0.75, 0),
+		Color.new(1, 1, 0),
+		Color.new(0, 1, 0),
+		Color.new(0, 0, 1),
+		Color.new(1, 0, 1)
+	]
+	#The view width.
+	WIDTH = 500
+	#The view height.
+	HEIGHT = 400
+	#Run the application.
+	application = Application.new(WIDTH, HEIGHT)
+	application.color_pool = COLOR_POOL
+	application.tag_pool = TAG_POOL
+	application.main
+rescue => exception
 	#Print error to STDERR and exit with an abnormal status.
 	abort "Error: " + exception.message + exception.backtrace.join("\n")
-
 end

data/bin/zyps_demo

@@ -28,8 +28,6 @@ rescue LoadError
 end
 
 
-
-
 class Demo
 
 	#The view width.
@@ -521,5 +519,10 @@ class Demo
 end
 
 
-#Run the demos.
-Demo.new.main
+begin
+	#Run the demos.
+	Demo.new.main
+rescue => exception
+	#Print error to STDERR and exit with an abnormal status.
+	abort "Error: " + exception.message
+end

data/bin/zyps_server

@@ -0,0 +1,178 @@
+#!/usr/local/bin/ruby
+
+# Copyright 2007 Jay McGavren, jay@mcgavren.com.
+# 
+# This file is part of Zyps.
+# 
+# Zyps is free software; you can redistribute it and/or modify
+# it under the terms of the GNU Lesser General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+# 
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+# 
+# You should have received a copy of the GNU Lesser General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+
+
+begin
+	require 'optparse'
+	require 'zyps'
+	require 'zyps/views/trails'
+	require 'drb'
+rescue LoadError
+	require 'optparse'
+	require 'rubygems'
+	require 'zyps'
+	require 'zyps/views/trails'
+	require 'drb'
+end
+
+
+#An Environment intended for serving over DRb.
+class RemoteEnvironment < Environment
+	def initialize
+		super
+		@objects.extend DRbUndumped
+		@environmental_factors.extend DRbUndumped
+	end
+	def objects=(value)
+		@objects = value
+		@objects.extend DRbUndumped
+	end
+	def environmental_factors=(value)
+		@environmental_factors = value
+		@environmental_factors.extend DRbUndumped
+	end
+end
+
+
+#A server for a Zyps Environment.
+class EnvironmentServer
+
+	#Port to open service on.
+	attr_accessor :port
+	#Maximum allowed number of objects.
+	attr_accessor :max_population
+	#View dimensions.
+	attr_accessor :view_width, :view_height
+	
+	#Set up default values.
+	def initialize(port = nil, max_population = 25, fps = 60, view_width = 800, view_height = 600)
+		@port, @max_population, @fps, @view_width, @view_height = port, max_population, fps, view_width, view_height
+	end
+
+	#Create app window, game environment, view, and network service.
+	def main
+	
+		#A clock to track frames to draw this second.
+		clock = Clock.new
+	
+		#Create a window, and set GTK up to quit when it is closed.
+		window = Gtk::Window.new
+		window.signal_connect("delete_event") {false}
+		window.signal_connect("destroy") {Gtk.main_quit}
+		
+		#Add view to window.
+		view = TrailsView.new(@view_width, @view_height)
+		window.add(view.canvas)
+		window.show_all
+		
+		#Create environment.
+		environment = RemoteEnvironment.new
+		#Point view at environment.
+		environment.add_observer(view)
+		
+		#Create thread to update environment.
+		update_thread = Thread.new do
+			begin
+				loop do
+					environment.interact
+					#Control population.
+					environment.objects.shift while environment.objects.length > @max_population
+					#Sleep for the rest of this frame.
+					delay = (1.0 / @fps) - clock.elapsed_time
+					sleep delay if delay > 0
+				end
+			rescue Exception => exception
+				puts exception, exception.backtrace
+			end
+		end
+		
+		#Start a network service.
+		DRb.start_service(
+			@port ? "druby://localhost:#{@port}" : nil,
+			environment
+		)
+		#If port was automatically chosen, display our URI.
+		puts DRb.uri unless @port
+		
+		#Activate the GUI.
+		Gtk.main
+		
+	end
+	
+	
+	#Set attributes according to command-line arguments.
+	def process_options(arguments)
+	
+		#Set up option parser.
+		options = OptionParser.new
+		
+		#Define valid options.
+		options.on("-h", "--help", TrueClass, "Display program help.") {
+			puts options.help
+			exit
+		}
+		options.on(
+			"-m",
+			"--max-population [number]",
+			Integer,
+			"The maximum number of allowed game objects.  25 by default."
+		) {|value| @max_population = value}
+		options.on(
+			"-p",
+			"--port [number]",
+			Integer,
+			"Port number to run the server on.  If not defined, next available one will be selected and the URI printed to STDOUT."
+		) {|value| @port = value}
+		options.on(
+			"-f",
+			"--fps [frames]",
+			Integer,
+			"Number of frames to draw per second."
+		) {|value| @fps = value}
+		options.on(
+			"--view-width [pixels]",
+			Integer,
+			"Window width.  800 by default."
+		) {|value| @view_width = value}
+		options.on(
+			"--view-height [pixels]",
+			Integer,
+			"Window height.  600 by default."
+		) {|value| @view_height = value}
+		
+		#Parse the options, printing usage if parsing fails.
+		options.parse(arguments) rescue puts "#{$!}\nType '#{$0} --help' for valid options."
+		
+	end
+
+
+end
+
+
+begin
+	#Create a server.
+	server = EnvironmentServer.new
+	#Parse the command line.
+	server.process_options(ARGV)
+	#Start the server.
+	server.main
+rescue => exception
+	#Print error to STDERR and exit with an abnormal status.
+	abort "Error: " + exception.message + exception.backtrace.join("\n")
+end

data/lib/zyps.rb

@@ -19,7 +19,6 @@
 require 'observer'
 
 
-
 #A virtual environment.
 class Environment
 
@@ -47,17 +46,16 @@ class Environment
 		objects.each do |object|
 		
 			#Move each object according to its vector.
-			object.location.x += object.vector.x * elapsed_time
-			object.location.y += object.vector.y * elapsed_time
+			object.move(elapsed_time)
 			
 			#Have all environmental factors interact with each object.
-			environmental_factors.each {|factor| factor.act(factor, object)}
+			environmental_factors.each {|factor| factor.act(object)}
 			
 			#Have all creatures interact with each other.
 			if object.respond_to?(:act)
 				objects.each do |target|
 					next if target.equal?(object) #Ensure object does not act on itself.
-					object.act(object, target)
+					object.act(target)
 				end
 			end
 			
@@ -78,6 +76,9 @@ end
 #An object in the virtual environment.
 class GameObject
 
+	#A universal identifier for the object.
+	#Needed for DRb transmission, etc.
+	attr_reader :identifier
 	#The object's Location in space.
 	attr_accessor :location
 	#A Color that will be used to draw the object.
@@ -91,9 +92,16 @@ class GameObject
 	
 	def initialize (name = nil, location = Location.new, color = Color.new, vector = Vector.new, age = 0, tags = [])
 		@name, @location, @color, @vector, @tags = name, location, color, vector, tags
+		@identifier = rand(99999999) #TODO: Current setup won't necessarily be unique.
 		self.age = age
 	end
 	
+	#Move according to vector over the given number of seconds.
+	def move (elapsed_time)
+		@location.x += @vector.x * elapsed_time
+		@location.y += @vector.y * elapsed_time
+	end
+	
 	#Time since the object was created, in seconds.
 	def age; Time.new.to_f - @birth_time; end
 	def age=(age); @birth_time = Time.new.to_f - age; end
@@ -106,8 +114,8 @@ end
 module Responsive
 
 	#Call Behavior.perform on each of the object's assigned Behaviors, with the object and a target as arguments.
-	def act(subject, target)
-		behaviors.each {|behavior| behavior.perform(subject, target)}
+	def act(target)
+		behaviors.each {|behavior| behavior.perform(self, target)}
 	end
 	
 end
@@ -188,7 +196,7 @@ class Color
 	attr_accessor :red, :green, :blue
 	
 	def initialize (red = 1, green = 1, blue = 1)
-		@red, @green, @blue = red, green, blue
+		self.red, self.green, self.blue = red, green, blue
 	end
 	
 	#Automatically constrains value to the range 0 - 1.
@@ -248,7 +256,6 @@ class Vector
 	def pitch=(degrees)
 		#Constrain degrees to 0 to 360.
 		value = degrees % 360
-		value += 360 if value < 0
 		#Store as radians internally.
 		@pitch = Utility.to_radians(value)
 	end
@@ -352,7 +359,21 @@ module Utility
 		value
 	end
 	
-end
-
-
+	#Given a normal and an angle, find the reflection angle.
+	def Utility.find_reflection_angle(normal, angle)
+		incidence_angle = normal - angle
+		reflection_angle = normal + incidence_angle
+		reflection_angle %= 360
+		reflection_angle
+	end
 
+	#Given a location and the upper left and lower right corners of a box, determine if the point is within the box.
+	def Utility.inside_box?(point, upper_left, lower_right)
+		return false if point.x < upper_left.x
+		return false if point.y < upper_left.y
+		return false if point.x > lower_right.x
+		return false if point.y > lower_right.y
+		true
+	end
+	
+end

data/lib/zyps/views/trails.rb

@@ -84,20 +84,20 @@ class TrailsView
 		
 		#For each GameObject in the environment:
 		environment.objects.each do |object|
-		
+
 			#Add the object's current location to the list.
-			@locations[object] << [object.location.x, object.location.y]
+			@locations[object.identifier] << [object.location.x, object.location.y]
 			#If the list is larger than the number of tail segments, delete the first position.
-			@locations[object].shift if @locations[object].length > @trail_length
+			@locations[object.identifier].shift if @locations[object.identifier].length > @trail_length
 			
 			#For each location in this object's list:
-			@locations[object].each_with_index do |location, index|
+			@locations[object.identifier].each_with_index do |location, index|
 			
 				#Skip first location.
 				next if index == 0
 				
 				#Divide the current segment number by trail segment count to get the multiplier to use for brightness and width.
-				multiplier = index.to_f / @locations[object].length.to_f
+				multiplier = index.to_f / @locations[object.identifier].length.to_f
 				
 				#Set the drawing color to use the object's colors, adjusted by the multiplier.
 				graphics_context.rgb_fg_color = Gdk::Color.new( #Don't use Gdk::GC.foreground= here, as that requires a color to be in the color map already.
@@ -115,7 +115,7 @@ class TrailsView
 				)
 				
 				#Get previous location so we can draw a line from it.
-				previous_location = @locations[object][index - 1]
+				previous_location = @locations[object.identifier][index - 1]
 				
 				#Draw a line with the current width from the prior location to the current location.
 				buffer.draw_line(

data/test/test_zyps.rb

@@ -20,11 +20,31 @@ require 'zyps'
 require 'test/unit'
 
 
+class TestGameObject < Test::Unit::TestCase
+
+
+	def test_move
+		#Set up moving object.
+		object = GameObject.new
+		object.location = Location.new(0, 0)
+		object.vector = Vector.new(1.4142, 45)
+		#Move for 1 second.
+		object.move(1)
+		#Check object moved to expected coordinates.
+		assert_in_delta(1, object.location.x, 0.001)
+		assert_in_delta(1, object.location.y, 0.001)
+	end
+
+
+end
+
+
 class TestCreature < Test::Unit::TestCase
 
 
 	def test_default_initialization
 		creature = Creature.new
+		assert_not_nil(creature.identifier)
 		assert_equal(0, creature.location.x)
 		assert_equal(0, creature.location.y)
 		assert_equal(1, creature.color.red)
@@ -36,6 +56,8 @@ class TestCreature < Test::Unit::TestCase
 		assert_in_delta(0, creature.age, 0.1)
 		assert_equal([], creature.tags)
 		assert_equal([], creature.behaviors)
+		#Identifiers should be unique.
+		assert_not_equal(creature.identifier, Creature.new.identifier)
 	end
 	
 	
@@ -98,7 +120,8 @@ class TestEnvironment < Test::Unit::TestCase
 		#Look for expected interactions (each should only occur once).
 		assert(@interactions.find_all{|i| i == "2 targeting 1"}.length == 1)
 		assert(@interactions.find_all{|i| i == "1 targeting 2"}.length == 1)
-		#TODO: Ensure creatures don't target selves.
+		assert(@interactions.find_all{|i| i == "1 targeting 1"}.length == 0)
+		assert(@interactions.find_all{|i| i == "2 targeting 2"}.length == 0)
 		
 	end
 	
@@ -305,6 +328,32 @@ class TestUtility < Test::Unit::TestCase
 		assert_in_delta(1.4142, Utility.find_distance(origin, Location.new(-1,-1)), 0.001)
 		assert_in_delta(1.4142, Utility.find_distance(origin, Location.new(1,-1)), 0.001)
 	end
+	
+	
+	def test_find_reflection_angle
+		assert_equal(210, Utility.find_reflection_angle(0, 150))
+		assert_equal(330, Utility.find_reflection_angle(0, 30))
+		assert_equal(150, Utility.find_reflection_angle(90, 30))
+		assert_equal(210, Utility.find_reflection_angle(90, 330))
+		assert_equal(30, Utility.find_reflection_angle(180, 330))
+		assert_equal(150, Utility.find_reflection_angle(180, 210))
+		assert_equal(330, Utility.find_reflection_angle(270, 210))
+		assert_equal(30, Utility.find_reflection_angle(270, 150))
+	end
 
 	
-end
+	def test_inside_box?
+		#Too far left.
+		assert(! Utility.inside_box?(Location.new(1, 3), Location.new(2, 2), Location.new(4, 4)))
+		#Too far right.
+		assert(! Utility.inside_box?(Location.new(5, 3), Location.new(2, 2), Location.new(4, 4)))
+		#Too far up.
+		assert(! Utility.inside_box?(Location.new(3, 1), Location.new(2, 2), Location.new(4, 4)))
+		#Too far down.
+		assert(! Utility.inside_box?(Location.new(3, 5), Location.new(2, 2), Location.new(4, 4)))
+		#Inside.
+		assert(Utility.inside_box?(Location.new(3, 3), Location.new(2, 2), Location.new(4, 4)))
+	end
+
+	
+end

metadata

@@ -3,8 +3,8 @@ rubygems_version: 0.9.2
 specification_version: 1
 name: zyps
 version: !ruby/object:Gem::Version 
-  version: 0.1.1
-date: 2007-07-25 00:00:00 -07:00
+  version: 0.2.1
+date: 2007-08-06 00:00:00 -07:00
 summary: A simulation/game with autonomous creatures
 require_paths: 
 - lib
@@ -34,6 +34,7 @@ files:
 - README.txt
 - bin/zyps
 - bin/zyps_demo
+- bin/zyps_server
 - lib/zyps
 - lib/zyps/views
 - lib/zyps/views/trails.rb
@@ -53,6 +54,7 @@ extra_rdoc_files:
 executables: 
 - zyps
 - zyps_demo
+- zyps_server
 extensions: []
 
 requirements: