zyps 0.6.3 → 0.7.0

data/lib/zyps.rb

@@ -30,15 +30,34 @@ class Environment
 	#An array of EnvironmentalFactor objects that act on any GameObject in the Environment.
 	attr_accessor :environmental_factors
 	
-	def initialize (objects = [], environmental_factors = [])
-		self.objects, self.environmental_factors = objects, environmental_factors
+	#Takes a hash with these keys and defaults:
+	#	:objects => [], 
+	#	:environmental_factors => []
+	def initialize (options = {})
+		options = {
+			:objects => [], 
+			:environmental_factors => []
+		}.merge(options)
+		self.objects, self.environmental_factors = options[:objects], options[:environmental_factors]
 		@clock = Clock.new
 	end
 	
+	#Make a deep copy.
+	def copy
+		copy = self.clone #Currently, we overwrite everything anyway, but we may add some clonable attributes later.
+		#Make a deep copy of all objects.
+		copy.objects = []
+		@objects.each {|object| copy.objects << object.copy}
+		#Make a deep copy of all environmental_factors.
+		copy.environmental_factors = []
+		@environmental_factors.each {|environmental_factor| copy.environmental_factors << environmental_factor.copy}
+		copy
+	end
+	
 	#Allow everything in the environment to interact with each other.
 	#Objects are first moved according to their preexisting vectors and the amount of time since the last call.
-	#Then each EnvironmentalFactor is allowed to act on each object.
-	#Finally, each GameObject with an act() method is allowed to act on the environment.
+	#Then, each GameObject with an act() method is allowed to act on the environment.
+	#Finally, each EnvironmentalFactor is allowed to act on the Environment.
 	def interact
 	
 		#Get time since last interaction.
@@ -46,7 +65,6 @@ class Environment
 		
 		objects.each do |object|
 		
-		
 			#Move each object according to its vector.
 			begin
 				object.move(elapsed_time)
@@ -57,22 +75,11 @@ class Environment
 				next
 			end
 			
-			#Have all environmental factors interact with each object.
-			environmental_factors.each do |factor|
-				begin
-					factor.act(object)
-				#Remove misbehaving environmental factors.
-				rescue Exception => exception
-					environmental_factors.delete(factor)
-					puts exception, exception.backtrace
-					next
-				end
-			end
-			
 			#Have all creatures interact with the environment.
 			if object.respond_to?(:act)
 				begin
-					object.act(self)
+					#Have creature act on all GameObjects other than itself.
+					object.act(objects.reject{|target| target.equal?(object)})
 				#Remove misbehaving objects.
 				rescue Exception => exception
 					puts exception, exception.backtrace
@@ -84,6 +91,18 @@ class Environment
 			
 		end
 		
+		#Have all environmental factors interact with environment.
+		environmental_factors.each do |factor|
+			begin
+				factor.act(self)
+			#Remove misbehaving environmental factors.
+			rescue Exception => exception
+				environmental_factors.delete(factor)
+				puts exception, exception.backtrace
+				next
+			end
+		end
+			
 		#Mark environment as changed.
 		changed
 		
@@ -115,8 +134,25 @@ class GameObject
 	#An array of Strings with tags that determine how the object will be treated by Creature and EnvironmentalFactor objects in its environment.
 	attr_accessor :tags
 	
-	def initialize (name = nil, location = Location.new, color = Color.new, vector = Vector.new, age = 0, size = 1, tags = [])
-		self.name, self.location, self.color, self.vector, self.age, self.size, self.tags = name, location, color, vector, age, size, tags
+	#Takes a hash with these keys and defaults:
+	#	:name => nil,
+	#	:location => Location.new,
+	#	:color => Color.new,
+	#	:vector => Vector.new,
+	#	:age => 0,
+	#	:size => 1,
+	#	:tags => []
+	def initialize (options = {})
+		options = {
+			:name => nil,
+			:location => Location.new,
+			:color => Color.new,
+			:vector => Vector.new,
+			:age => 0,
+			:size => 1,
+			:tags => []
+		}.merge(options)
+		self.name, self.location, self.color, self.vector, self.age, self.size, self.tags = options[:name], options[:location], options[:color], options[:vector], options[:age], options[:size], options[:tags]
 		@identifier = generate_identifier
 	end
 	
@@ -169,9 +205,21 @@ class Creature < GameObject
 	attr_accessor :behaviors
 	
 	#Identical to the GameObject constructor, except that it also takes a list of Behavior objects.
-	def initialize (name = nil, location = Location.new, color = Color.new, vector = Vector.new, age = 0, size = 1, tags = [], behaviors = [])
-		super(name, location, color, vector, age, size, tags)
-		self.behaviors = behaviors
+	#Takes a hash with these keys and defaults:
+	#	:name => nil
+	#	:location => Location.new
+	#	:color => Color.new
+	#	:vector => Vector.new
+	#	:age => 0
+	#	:size => 1
+	#	:tags => []
+	#	:behaviors => []
+	def initialize (options = {})
+		options = {
+			:behaviors => []
+		}.merge(options)
+		super
+		self.behaviors = options[:behaviors]
 	end
 	
 	#Make a deep copy.
@@ -183,9 +231,9 @@ class Creature < GameObject
 		copy
 	end
 	
-	#Call Behavior.perform(self, environment) on each of the creature's assigned Behaviors.
-	def act(environment)
-		behaviors.each {|behavior| behavior.perform(self, environment)}
+	#Performs all assigned behaviors on the targets.
+	def act(targets)
+		behaviors.each {|behavior| behavior.perform(self, targets)}
 	end
 	
 end
@@ -218,7 +266,6 @@ class Action
 		@started = true
 	end
 	
-	#Action subclasses must implement a do(actor, target) instance method.
 	def do(actor, target)
 		raise NotImplementedError.new("Action subclasses must implement a do(actor, target) instance method.")
 	end
@@ -229,6 +276,9 @@ class Action
 		@started = false
 	end
 	
+	#Synonym for started
+	def started?; started; end
+	
 end
 
 
@@ -239,9 +289,8 @@ class Condition
 	#Make a deep copy.
 	def copy; self.clone; end
 	
-	#Condition subclasses must implement a met?(actor, target) instance method.
-	def met?(actor, target)
-		raise NotImplementedError.new("Condition subclasses must implement a met?(actor, target) instance method.")
+	def select(actor, targets)
+		raise NotImplementedError.new("Condition subclasses must implement a select(actor, target) instance method.")
 	end
 	
 end
@@ -253,14 +302,18 @@ end
 #Likewise, the subject can change its own attributes, it can approach or flee from the target, it can spawn new Creatures or GameObjects (like bullets), or anything else.
 class Behavior
 
-	#A list of Condition objects, which are called with the object itself and its target.  A condition can consider the tags on the target, the distance from the subject, or any other criteria.  If any condition returns false, the behavior will not be carried out (or stopped if it has begun).
 	attr_accessor :conditions
-	#A list of Action objects, which are called with the object and its target when all conditions are met.  An action can act on the subject or its target.
 	attr_accessor :actions
 	
-	#Optionally takes an array of actions and one of conditions.
-	def initialize (actions = [], conditions = [])
-		self.actions, self.conditions = actions, conditions
+	#Takes a hash with these keys and defaults:
+	#	:actions => []
+	#	:conditions => []
+	def initialize (options = {})
+		options = {
+			:actions => [],
+			:conditions => []
+		}.merge(options)
+		self.actions, self.conditions = options[:actions], options[:conditions]
 		#Tracks current target.
 		@active_target = nil
 	end
@@ -277,59 +330,25 @@ class Behavior
 		copy
 	end
 	
-	#Test all conditions against each object in the evironment.
-	#For the first object that meets all of them, mark it active (and operate on it first next time).
-	#Then call start() (if applicable) and perform() for all actions against the active target.
-	#If any action or condition returns false, stop all actions, and deselect the active target.
-	def perform(actor, environment)
+	#Finds targets that meet all conditions, then acts on them.
+	#Calls select(actor, targets) on each Condition, each time discarding targets that fail.
+	#Then on each Action, calls Action#start(actor, targets) (if not already started) followed by Action#do(actor, targets).
+	#If no matching targets are found, calls Action#stop(actor, targets) on each Action.
+	def perform(actor, targets)
 		
-		begin
-			#Select a target.
-			target = select_target(actor, environment.objects)
-			#Do the actions on the target.
-			actions.each do |action|
-				action.start(actor, target) unless action.started
-				action.do(actor, target)
+		choices = targets.clone
+		conditions.each {|condition| choices = condition.select(actor, choices)}
+		actions.each do |action|
+			if ! choices.empty?
+				action.start(actor, choices) unless action.started?
+				action.do(actor, choices)
+			else
+				action.stop(actor, targets) #Not choices; that array is empty.
 			end
-		rescue NoMatchException => exception
-			#If the behavior can no longer be performed, halt it.
-			stop(actor, target)
 		end
 		
 	end
 	
-	
-	private
-
-		#Stop all actions and de-select the active target.
-		def stop(actor, target)
-			actions.each do |action|
-				action.stop(actor, target) if action.started
-			end
-			@active_target = nil
-		end
-		
-		#Select a target that matches all conditions.
-		def select_target(actor, targets)
-			#If a target is already active, still present in the environment, and all conditions are true for it, simply re-select it.
-			if @active_target and targets.include?(@active_target) and conditions.all?{|condition| condition.met?(actor, @active_target)}
-				return @active_target 
-			end
-			#For each object in environment:
-			targets.each do |target|
-				#Don't let actor target itself.
-				next if target == actor
-				#If all conditions match (or there are no conditions), select the object.
-				if conditions.all?{|condition| condition.met?(actor, target)}
-					@active_target = target
-					return target
-				end
-			end
-			#If there were no matches, throw an exception.
-			raise NoMatchException, "No matching targets found."
-		end
-	
-	
 end
 
 
@@ -546,6 +565,4 @@ module Utility
 end
 
 
-class NoMatchException < RuntimeError; end
-
 end #module Zyps

data/test/test_zyps.rb

@@ -17,6 +17,8 @@
 
 
 require 'zyps'
+require 'zyps/actions'
+require 'zyps/conditions'
 require 'test/unit'
 
 
@@ -34,14 +36,7 @@ class TestGameObject < Test::Unit::TestCase
 
 	def test_constraints
 		#Test at initialization.
-		object = GameObject.new(
-			"", #Name.
-			Location.new,
-			Color.new,
-			Vector.new,
-			0,
-			-1 #Size.
-		)
+		object = GameObject.new(:size => -1)
 		assert_equal(0, object.size)
 		#Test accessors.
 		object = GameObject.new
@@ -112,14 +107,14 @@ class TestCreature < Test::Unit::TestCase
 	def test_explicit_initialization
 		behavior = Behavior.new
 		creature = Creature.new(
-			"name",
-			Location.new(10, -3),
-			Color.new(0.5, 0.6, 0.7),
-			Vector.new(1.5, 225),
-			2.001, #Age.
-			5.0, #Size.
-			["predator", "blue team"],
-			[behavior]
+			:name => "name",
+			:location => Location.new(10, -3),
+			:color => Color.new(0.5, 0.6, 0.7),
+			:vector => Vector.new(1.5, 225),
+			:age => 2.001,
+			:size => 5.0, #Size.
+			:tags => ["predator", "blue team"],
+			:behaviors => [behavior]
 		)
 		assert_equal("name", creature.name)
 		assert_equal(10, creature.location.x)
@@ -158,9 +153,9 @@ class TestEnvironment < Test::Unit::TestCase
 	
 		#Create an environment and add creatures.
 		@environment = Environment.new
-		@environment.objects << Creature.new('1')
-		@environment.objects << Creature.new('2')
-		@environment.objects << Creature.new('3')
+		@environment.objects << Creature.new(:name => '1')
+		@environment.objects << Creature.new(:name => '2')
+		@environment.objects << Creature.new(:name => '3')
 		
 	end
 	
@@ -172,9 +167,11 @@ class TestEnvironment < Test::Unit::TestCase
 			#Interactions will be logged here.
 			@interactions = []
 		end
-		def do(actor, target)
+		def do(actor, targets)
 			#Log the interaction.
-			@interactions << "#{actor.name} targeting #{target.name}"
+			targets.each do |target|
+				@interactions << "#{actor.name} targeting #{target.name}"
+			end
 		end
 	end
 	
@@ -207,9 +204,9 @@ class TestEnvironment < Test::Unit::TestCase
 			#Interactions will be logged here.
 			@interactions = []
 		end
-		def act(target)
+		def act(environment)
 			#Log the interaction.
-			@interactions << "Environment targeting #{target.name}"
+			environment.objects.each {|target| @interactions << "Environment targeting #{target.name}"}
 		end
 	end
 	
@@ -231,8 +228,8 @@ class TestEnvironment < Test::Unit::TestCase
 	
 	#A condition that is false unless actor and target have specific names.
 	class NameCondition < Condition
-		def met?(actor, target)
-			return true if actor.name == '1' and target.name == '2'
+		def select(actor, targets)
+			targets.find_all {|target| actor.name == '1' and target.name == '2'}
 		end
 	end
 	
@@ -255,30 +252,6 @@ class TestEnvironment < Test::Unit::TestCase
 	end
 	
 	
-	#Test that creatures can switch targets when one is removed from the environment.
-	def test_object_removal
-	
-		#Set up behaviors that will log interactions.
-		log = LogAction.new
-		@environment.objects.each do |creature|
-			behavior = Behavior.new
-			behavior.actions << log
-			creature.behaviors << behavior
-		end
-		
-		#Have environment elements interact.
-		@environment.interact
-		#Remove the original target from the environment.
-		@environment.objects.delete_at(1)
-		#Interact again.
-		@environment.interact
-
-		#Look for expected interactions (each should only occur once).
-		assert_equal(1, log.interactions.find_all{|i| i == "1 targeting 3"}.length)
-		
-	end
-	
-	
 end
 
 
@@ -486,23 +459,23 @@ class TestUtility < Test::Unit::TestCase
 	def test_collided?
 		#Objects apart.
 		assert(! Utility.collided?(
-			GameObject.new("", Location.new(0, 0), Color.new, Vector.new, 0, 0.196), #Radius = 0.25
-			GameObject.new("", Location.new(1, 0), Color.new, Vector.new, 0, 0.196)
+			GameObject.new(:location => Location.new(0, 0), :size =>0.196), #Radius = 0.25
+			GameObject.new(:location => Location.new(1, 0), :size =>0.196)
 		))
 		#Objects touching (not a collision).
 		assert(! Utility.collided?(
-			GameObject.new("", Location.new(0, 0), Color.new, Vector.new, 0, 0.785), #Radius = 0.5
-			GameObject.new("", Location.new(1, 0), Color.new, Vector.new, 0, 0.785)
+			GameObject.new(:location => Location.new(0, 0), :size =>0.785), #Radius = 0.5
+			GameObject.new(:location => Location.new(1, 0), :size =>0.785)
 		))
 		#Objects collided.
 		assert(Utility.collided?(
-			GameObject.new("", Location.new(0, 0), Color.new, Vector.new, 0, 1.766), #Radius = 0.75
-			GameObject.new("", Location.new(1, 0), Color.new, Vector.new, 0, 1.766)
+			GameObject.new(:location => Location.new(0, 0), :size =>1.766), #Radius = 0.75
+			GameObject.new(:location => Location.new(1, 0), :size =>1.766)
 		))
 		#Objects in same place.
 		assert(Utility.collided?(
-			GameObject.new("", Location.new(0, 0)),
-			GameObject.new("", Location.new(0, 0))
+			GameObject.new(:location => Location.new(0, 0)),
+			GameObject.new(:location => Location.new(0, 0))
 		))
 	end
 	
@@ -511,26 +484,26 @@ end
 
 class TestBehavior < Test::Unit::TestCase
 
-	#Always true.
+	#True for all targets.
 	class TrueCondition < Condition
-		def met?(actor, target)
-			true
+		def select(actor, targets)
+			targets #Select all targets.
 		end
 	end
-	#Always false.
+	#False for all targets.
 	class FalseCondition < Condition
-		def met?(actor, target)
-			false
+		def select(actor, targets)
+			[] #Select no targets.
 		end
 	end
 	
 	
 	def setup
-		@actor = Creature.new('actor')
-		@target = Creature.new('target')
-		@other = Creature.new('other')
-		@environment = Environment.new
-		@environment.objects << @actor << @target << @other
+		@actor = Creature.new(:name => 'actor')
+		@target = Creature.new(:name => 'target')
+		@other = Creature.new(:name => 'other')
+		@targets = []
+		@targets << @target << @other
 	end
 	
 	
@@ -540,14 +513,14 @@ class TestBehavior < Test::Unit::TestCase
 		def initialize
 			@start_count, @stop_count, @do_count = 0, 0, 0
 		end
-		def start(actor, target)
+		def start(actor, targets)
 			super
 			@start_count += 1
 		end
-		def do(actor, target)
+		def do(actor, targets)
 			@do_count += 1
 		end
-		def stop(actor, target)
+		def stop(actor, targets)
 			super
 			@stop_count += 1
 		end
@@ -562,13 +535,13 @@ class TestBehavior < Test::Unit::TestCase
 		behavior.actions << action
 		
 		#Perform the behavior.
-		behavior.perform(@actor, @environment)
+		behavior.perform(@actor, @targets)
 		assert_equal(1, action.start_count, "start() should have been called on the mock action.")
 		assert_equal(1, action.do_count, "do() should have been called.")
 		assert_equal(0, action.stop_count, "stop() should NOT have been called.")
 		
 		#Perform the behavior again.
-		behavior.perform(@actor, @environment)
+		behavior.perform(@actor, @targets)
 		assert_equal(1, action.start_count, "start() should NOT have been called.")
 		assert_equal(2, action.do_count, "do() should have been called.")
 		assert_equal(0, action.stop_count, "stop() should NOT have been called.")
@@ -576,7 +549,7 @@ class TestBehavior < Test::Unit::TestCase
 		#Add a false condition to the behavior.
 		behavior.conditions << FalseCondition.new
 		#Perform the behavior.
-		behavior.perform(@actor, @environment)
+		behavior.perform(@actor, @targets)
 		assert_equal(1, action.start_count, "start() should NOT have been called.")
 		assert_equal(2, action.do_count, "do() should NOT have been called, because conditions are no longer true.")
 		assert_equal(1, action.stop_count, "stop() SHOULD have been called.")
@@ -597,4 +570,4 @@ class TestBehavior < Test::Unit::TestCase
 	end
 	
 	
-end
+end

data/test/zyps/test_actions.rb

@@ -40,9 +40,9 @@ class TestActions < Test::Unit::TestCase
 
 	#Create and populate an environment.
 	def setup
-		@actor = Creature.new('actor', Location.new(0, 0))
-		@target1 = Creature.new('target1', Location.new(1, 1))
-		@target2 = Creature.new('target2', Location.new(-2, -2))
+		@actor = Creature.new(:name => 'actor', :location => Location.new(0, 0))
+		@target1 = Creature.new(:name => 'target1', :location => Location.new(1, 1))
+		@target2 = Creature.new(:name => 'target2', :location => Location.new(-2, -2))
 		#Create an environment, and add the objects.
 		@environment = Environment.new
 		#Order is important - we want to act on target 1 first.
@@ -77,104 +77,53 @@ class TestActions < Test::Unit::TestCase
 	
 	#A TurnAction turns the actor at a given rate.
 	def test_turn_action
-		#Turn 1 degree per second.
-		add_action(TurnAction.new(1), @actor)
+		@actor.vector = Vector.new(1, 0)
+		#Turn 45 degrees off-heading at 1 unit/second.
+		add_action(TurnAction.new(1, 45), @actor)
 		@environment.interact
-		#Clock always returns 0.1 seconds, so actor should be turned 0.1 degrees.
-		assert_in_delta(0.1, @actor.vector.pitch, REQUIRED_ACCURACY)
+		#Clock always returns 0.1 seconds, so ensure actor's vector is adjusted accordingly.
+		assert_in_delta(3.778, @actor.vector.pitch, REQUIRED_ACCURACY)
+		assert_in_delta(1.073, @actor.vector.speed, REQUIRED_ACCURACY)
 	end
 	
 	
 	#An ApproachAction pushes the actor toward the target.
 	def test_approach_action
 	
-		#Create an ApproachAction with a 0-degree vector, turn rate of 40 degrees/sec.
+		#Create an ApproachAction with 1 unit/sec thrust.
 		@actor.vector = Vector.new(0, 0)
-		action = ApproachAction.new(40, Vector.new(1, 0))
-		add_action(action, @actor)
-		#Act.
-		@environment.interact
-		#Ensure action's thrust vector is correct for 0.1 seconds.
-		assert_in_delta(1.0, action.heading.speed, REQUIRED_ACCURACY)
-		assert_in_delta(4.0, action.heading.pitch, REQUIRED_ACCURACY)
-		#Ensure actor's resulting vector is correct.
-		assert_in_delta(0.997, @actor.vector.x, REQUIRED_ACCURACY)
-		assert_in_delta(0.069, @actor.vector.y, REQUIRED_ACCURACY)
-
-	end
-	
-	#Ensure ApproachAction doesn't oversteer.
-	def test_approach_action_accuracy
-	
-		#Create an ApproachAction with a 0-degree vector, turn rate high enough to turn more than 45 degrees in 0.1 seconds.
-		#Action should only turn as far as target.
-		@actor.vector = Vector.new(0, 0)
-		action = ApproachAction.new(500, Vector.new(1, 0))
-		add_action(action, @actor)
+		add_action(ApproachAction.new(1), @actor)
 		#Act.
 		@environment.interact
+		#Ensure actor's vector is correct after action's thrust is applied for 0.1 seconds.
+		assert_in_delta(0.1, @actor.vector.speed, REQUIRED_ACCURACY)
+		assert_in_delta(45, @actor.vector.pitch, REQUIRED_ACCURACY)
 
-		#Ensure actor is approaching target directly.
-		assert_in_delta(1.0, action.heading.speed, REQUIRED_ACCURACY)
-		assert_in_delta(45, action.heading.pitch, REQUIRED_ACCURACY)
-		#Ensure actor's resulting vector is correct.
-		assert_in_delta(0.707, @actor.vector.x, REQUIRED_ACCURACY)
-		assert_in_delta(0.707, @actor.vector.y, REQUIRED_ACCURACY)
-		
 	end
 	
-	
 	#A FleeAction pushes the actor away from a target.
 	def test_flee_action
 
 		#Create a FleeAction with a 0-degree vector, turn rate of 40 degrees/sec.
 		@actor.vector = Vector.new(0, 0)
-		action = FleeAction.new(40, Vector.new(1, 0))
-		add_action(action, @actor)
-		#Act.
-		@environment.interact
-		#Ensure action's thrust vector is correct for 0.1 seconds.
-		assert_in_delta(1.0, action.heading.speed, REQUIRED_ACCURACY)
-		assert_in_delta(356.0, action.heading.pitch, REQUIRED_ACCURACY) #Should be heading away.
-		#Ensure actor's resulting vector is correct.
-		assert_in_delta(0.997, @actor.vector.x, REQUIRED_ACCURACY)
-		assert_in_delta(-0.069, @actor.vector.y, REQUIRED_ACCURACY)
-	end
-	
-	#Ensure flee action doesn't oversteer.
-	def test_flee_action_accuracy
-	
-		#Create a FleeAction with a 0-degree vector, turn rate high enough to turn more than 135 degrees in 0.1 seconds.
-		#Action should turn directly away from target, but no farther.
-		@actor.vector = Vector.new(0, 0)
-		action = FleeAction.new(1400, Vector.new(1, 0))
+		action = FleeAction.new(1)
 		add_action(action, @actor)
 		#Act.
 		@environment.interact
-		#Ensure actor is fleeing directly away from target.
-		assert_in_delta(1.0, action.heading.speed, REQUIRED_ACCURACY)
-		assert_in_delta(225, action.heading.pitch, REQUIRED_ACCURACY)
-		#Ensure actor's resulting vector is correct.
-		assert_in_delta(-0.707, @actor.vector.x, REQUIRED_ACCURACY)
-		assert_in_delta(-0.707, @actor.vector.y, REQUIRED_ACCURACY)
-		
+		#Ensure actor's resulting vector is correct after 0.1 seconds of thrust.
+		assert_in_delta(0.1, @actor.vector.speed, REQUIRED_ACCURACY)
+		assert_in_delta(225, @actor.vector.pitch, REQUIRED_ACCURACY)
 	end
 	
-	
 	#A DestroyAction removes the target from the environment.
 	def test_destroy_action
 		#Create a DestroyAction, linked to the environment.
 		add_action(DestroyAction.new(@environment), @actor)
 		#Act.
 		@environment.interact
-		#Verify target is removed from environment.
+		#Verify targets are removed from environment.
 		assert(! @environment.objects.include?(@target1))
-		#Verify non-target is removed from environment.
-		assert(@environment.objects.include?(@target2))
-		#Act again.
-		@environment.interact
-		#Verify targets were switched.
-		assert(! @environment.objects.include?(@target2), "Targets should have been switched.")
+		assert(! @environment.objects.include?(@target2))
 	end
 	
 	
@@ -185,11 +134,13 @@ class TestActions < Test::Unit::TestCase
 		#Act.
 		@actor.size = 1
 		@target1.size = 1
+		@target2.size = 2
 		@environment.interact
-		#Verify target is removed from environment.
+		#Verify targets are removed from environment.
 		assert(! @environment.objects.include?(@target1))
+		assert(! @environment.objects.include?(@target2))
 		#Verify creature has grown by the appropriate amount.
-		assert_in_delta(2, @actor.size, REQUIRED_ACCURACY)
+		assert_in_delta(4, @actor.size, REQUIRED_ACCURACY)
 	end