zyps 0.4.1 → 0.5.1

data/bin/zyps

@@ -37,13 +37,6 @@ 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)
 		
@@ -81,6 +74,9 @@ class Application
 		enclosure.top = @height
 		enclosure.right = @width
 		@environment.environmental_factors << enclosure
+		
+		#Keep all objects under a certain speed.
+		@environment.environmental_factors << SpeedLimit.new(100)
 
 		#Create thread to update environment.
 		thread = Thread.new do
@@ -147,32 +143,24 @@ class Application
 					Utility.find_angle(@press_location, @release_location) #Move in direction of drag.
 				),
 				0,
-				1,
-				@tags_box.text.split(/,\s*/)
+				1
 			)
 			behavior = Behavior.new
-			condition_tags = @tag_condition_box.text
-			condition_tags.split(/,\s*/).each do |tag|
-				behavior.conditions << TagCondition.new(tag)
-			end
-			proximity = @proximity_condition_slider.value
-			behavior.conditions << ProximityCondition.new(proximity) if proximity > 0
-			age = @age_condition_slider.value
-			behavior.conditions << AgeCondition.new(age) if age > 0
-			acceleration = @acceleration_slider.value
-			behavior.actions << AccelerateAction.new(acceleration) if acceleration != 0
-			turn = @turn_slider.value
-			behavior.actions << TurnAction.new(turn) if turn != 0
-			approach_angle = @approach_slider.value
-			behavior.actions << ApproachAction.new(Vector.new(1, creature.vector.pitch), approach_angle) if approach_angle > 0
-			flee_angle = @flee_slider.value
-			behavior.actions << FleeAction.new(Vector.new(5, creature.vector.pitch), flee_angle) if flee_angle > 0
-			behavior.actions << EatAction.new(@environment) if @eat_flag.active?
-			apply_tags = @tag_action_box.text
-			apply_tags.split(/,\s*/).each do |tag|
-				behavior.actions << TagAction.new(tag)
-			end
+			behavior.conditions << ProximityCondition.new(200)
+			behavior.actions << AccelerateAction.new(1) if @accelerate_flag.active?
+			behavior.actions << TurnAction.new(90) if @turn_flag.active?
+			behavior.actions << ApproachAction.new(creature.vector, 720) if @approach_flag.active?
+			behavior.actions << FleeAction.new(creature.vector) if @flee_flag.active?
+			behavior.actions << PushAction.new(1000) if @push_flag.active?
+			behavior.actions << PullAction.new(1000) if @pull_flag.active?
+			behavior.actions << BlendAction.new(creature.color) if @paint_flag.active?
 			creature.behaviors << behavior
+			if @eat_flag.active?
+				behavior = Behavior.new
+				behavior.actions << EatAction.new(@environment)
+				behavior.conditions << ProximityCondition.new(10)
+				creature.behaviors << behavior
+			end
 			@environment.objects << creature
 		end
 		
@@ -195,64 +183,28 @@ class Application
 		attribute_controls.pack_start(@blue_slider, expand, fill, padding)
 		@red_slider.value, @green_slider.value, @blue_slider.value = 1, 1, 1
 				
-		#Add a text box for the tags.
-		attribute_controls.pack_start(Gtk::Label.new("Tags"), expand, fill, padding)
-		@tags_box = Gtk::Entry.new
-		attribute_controls.pack_start(@tags_box, expand, fill, padding)
-		
 		#Add the attribute controls to the panel.
 		control_panel.pack_start(attribute_controls, expand, fill, padding)
 		
-		#Create a group for the conditions.
-		condition_controls = Gtk::VBox.new(homogeneous, spacing)
-		condition_controls.pack_start(Gtk::Label.new("Target"), expand, fill, padding)
-		#Add a text box for the tag condition.
-		condition_controls.pack_start(Gtk::Label.new("Tags"), expand, fill, padding)
-		@tag_condition_box = Gtk::Entry.new
-		condition_controls.pack_start(@tag_condition_box, expand, fill, padding)
-		#Add a slider for the age condition.
-		@age_condition_slider = Gtk::HScale.new(0, 300, 30)
-		condition_controls.pack_start(Gtk::Label.new("Age"), expand, fill, padding)
-		condition_controls.pack_start(@age_condition_slider, expand, fill, padding)
-		#Add a slider for the proximity condition.
-		@proximity_condition_slider = Gtk::HScale.new(1, 100, 10)
-		condition_controls.pack_start(Gtk::Label.new("Proximity"), expand, fill, padding)
-		condition_controls.pack_start(@proximity_condition_slider, expand, fill, padding)
-		#Add the condition controls to the panel.
-		control_panel.pack_start(condition_controls, expand, fill, padding)
-
 		#Create a group for the actions.
 		action_controls = Gtk::VBox.new(homogeneous, spacing)
 		action_controls.pack_start(Gtk::Label.new("Actions"), expand, fill, padding)
-		#Add a slider for the accelerate action.
-		@acceleration_slider = Gtk::HScale.new(-10, 10, 2)
-		action_controls.pack_start(Gtk::Label.new("Accelerate"), expand, fill, padding)
-		action_controls.pack_start(@acceleration_slider, expand, fill, padding)
-		@acceleration_slider.value = 0
-		#Add a slider for the turn action.
-		@turn_slider = Gtk::HScale.new(-180, 180, 20)
-		action_controls.pack_start(Gtk::Label.new("Turn"), expand, fill, padding)
-		action_controls.pack_start(@turn_slider, expand, fill, padding)
-		@turn_slider.value = 0
-		#Add a slider for the approach angle.
-		@approach_slider = Gtk::HScale.new(-180, 180, 20)
-		action_controls.pack_start(Gtk::Label.new("Approach"), expand, fill, padding)
-		action_controls.pack_start(@approach_slider, expand, fill, padding)
-		@approach_slider.value = 0
-		#Add a slider for the flee action.
-		@flee_slider = Gtk::HScale.new(-180, 180, 20)
-		action_controls.pack_start(Gtk::Label.new("Flee"), expand, fill, padding)
-		action_controls.pack_start(@flee_slider, expand, fill, padding)
-		@flee_slider.value = 0
-		#Add a checkbox for the eat action.
+		@accelerate_flag = Gtk::CheckButton.new("Accelerate")
+		action_controls.pack_start(@accelerate_flag, expand, fill, padding)
+		@turn_flag = Gtk::CheckButton.new("Turn")
+		action_controls.pack_start(@turn_flag, expand, fill, padding)
+		@approach_flag = Gtk::CheckButton.new("Approach")
+		action_controls.pack_start(@approach_flag, expand, fill, padding)
+		@flee_flag = Gtk::CheckButton.new("Flee")
+		action_controls.pack_start(@flee_flag, expand, fill, padding)
+		@push_flag = Gtk::CheckButton.new("Push")
+		action_controls.pack_start(@push_flag, expand, fill, padding)
+		@pull_flag = Gtk::CheckButton.new("Pull")
+		action_controls.pack_start(@pull_flag, expand, fill, padding)
 		@eat_flag = Gtk::CheckButton.new("Eat")
 		action_controls.pack_start(@eat_flag, expand, fill, padding)
-		#Add a checkbox for the spawn action.
-		#TODO
-		#Add a text box for the tag action.
-		action_controls.pack_start(Gtk::Label.new("Apply Tag"), expand, fill, padding)
-		@tag_action_box = Gtk::Entry.new
-		action_controls.pack_start(@tag_action_box, expand, fill, padding)
+		@paint_flag = Gtk::CheckButton.new("Paint")
+		action_controls.pack_start(@paint_flag, expand, fill, padding)
 		#Add the action controls to the panel.
 		control_panel.pack_start(action_controls, expand, fill, padding)
 		

data/lib/zyps/actions.rb

@@ -35,6 +35,11 @@ class AccelerateAction < Action
 		self.rate = rate
 		@clock = Clock.new
 	end
+	#Begin tracking time between actions.
+	def start(actor, target)
+		super
+		@clock.reset_elapsed_time
+	end
 	#Increase or decrease speed according to elapsed time.
 	def do(actor, target)
 		actor.vector.speed += @clock.elapsed_time * rate
@@ -51,6 +56,11 @@ class TurnAction < Action
 		self.rate = rate
 		@clock = Clock.new
 	end
+	#Begin tracking time between actions.
+	def start(actor, target)
+		super
+		@clock.reset_elapsed_time
+	end
 	#Turn according to elapsed time.
 	def do(actor, target)
 		actor.vector.pitch += @clock.elapsed_time * rate
@@ -68,6 +78,11 @@ class ApproachAction < Action
 		self.heading, self.turn_rate = heading, turn_rate
 		@clock = Clock.new
 	end
+	#Begin tracking time between actions.
+	def start(actor, target)
+		super
+		@clock.reset_elapsed_time
+	end
 	#Accelerate toward the target, but limited by turn rate.
 	def do(actor, target)
 		#Find the difference between the current heading and the angle to the target.
@@ -105,6 +120,11 @@ class FleeAction < Action
 		self.heading, self.turn_rate = heading, turn_rate
 		@clock = Clock.new
 	end
+	#Begin tracking time between actions.
+	def start(actor, target)
+		super
+		@clock.reset_elapsed_time
+	end
 	#Accelerate away from the target, but limited by turn rate.
 	def do(actor, target)
 		#Find the difference between the current heading and the angle to the target.
@@ -142,6 +162,8 @@ class DestroyAction < Action
 	#Remove the target from the environment.
 	def do(actor, target)
 		@environment.objects.delete(target)
+		#Discontinue action.
+		return false
 	end
 end
 
@@ -150,10 +172,10 @@ end
 class EatAction < DestroyAction
 	#Remove the target from the environment, and increase actor's size by size of target.
 	def do(actor, target)
-		#Remove the target from the environment.
-		super
 		#Grow in size.
 		actor.size += target.size
+		#Remove the target from the environment.
+		super
 	end
 end
 
@@ -184,3 +206,53 @@ class BlendAction < Action
 		target.color += @color
 	end
 end
+
+
+#Pushes target away.
+class PushAction < Action
+	#Units/second to accelerate target by.
+	attr_accessor :force
+	def initialize(force = 1)
+		@force = force
+		@clock = Clock.new
+	end
+	#Begin tracking time between actions.
+	def start(actor, target)
+		super
+		@clock.reset_elapsed_time
+	end
+	#Accelerate away from the target, but limited by turn rate.
+	def do(actor, target)
+		#Angle to target is also angle of push force.
+		push_angle = Utility.find_angle(actor.location, target.location)
+		#Acceleration will be limited by elapsed time.
+		push_force = @force * @clock.elapsed_time
+		#Apply the force to the creature's movement vector.
+		target.vector += Vector.new(push_force, push_angle)
+	end
+end
+
+
+#Pulls target toward actor.
+class PullAction < Action
+	#Units/second to accelerate target by.
+	attr_accessor :force
+	def initialize(force = 1)
+		@force = force
+		@clock = Clock.new
+	end
+	#Begin tracking time between actions.
+	def start(actor, target)
+		super
+		@clock.reset_elapsed_time
+	end
+	#Accelerate away from the target, but limited by turn rate.
+	def do(actor, target)
+		#Angle from target to actor is also angle of pull force (opposite of that for push).
+		pull_angle = Utility.find_angle(target.location, actor.location)
+		#Acceleration will be limited by elapsed time.
+		pull_force = @force * @clock.elapsed_time
+		#Apply the force to the creature's movement vector.
+		target.vector += Vector.new(pull_force, pull_angle)
+	end
+end

data/lib/zyps/environmental_factors.rb

@@ -53,3 +53,19 @@ end
 
 
 
+#Keeps all objects at/under the assigned speed.
+class SpeedLimit < EnvironmentalFactor
+	
+	#Maximum allowed speed in units.
+	attr_accessor :maximum
+	def initialize(units)
+		self.maximum = units
+	end
+	#If object is over the speed, reduce its speed.
+	def act(object)
+		object.vector.speed = Utility.constrain_value(object.vector.speed, @maximum)
+	end
+end
+
+
+

data/lib/zyps.rb

@@ -37,7 +37,7 @@ class Environment
 	#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 every other object.
+	#Finally, each GameObject with an act() method is allowed to act on the environment.
 	def interact
 	
 		#Get time since last interaction.
@@ -51,12 +51,9 @@ class Environment
 			#Have all environmental factors interact with each object.
 			environmental_factors.each {|factor| factor.act(object)}
 			
-			#Have all creatures interact with each other.
+			#Have all creatures interact with the environment.
 			if object.respond_to?(:act)
-				objects.each do |target|
-					next if target.equal?(object) #Ensure object does not act on itself.
-					object.act(target)
-				end
+				object.act(self)
 			end
 			
 		end
@@ -126,9 +123,9 @@ class Creature < GameObject
 		self.behaviors = behaviors
 	end
 	
-	#Call Behavior.perform on each of the object's assigned Behaviors, with the object and a target as arguments.
-	def act(target)
-		behaviors.each {|behavior| behavior.perform(self, target)}
+	#Call Behavior.perform(self, environment) on each of the creature's assigned Behaviors.
+	def act(environment)
+		behaviors.each {|behavior| behavior.perform(self, environment)}
 	end
 	
 end
@@ -143,8 +140,32 @@ end
 
 
 #An action that one Creature takes on another.
-#Actions must implement a do(actor, target) instance method.
 class Action
+
+	#Whether the action was previously started.
+	attr_reader :started
+	
+	def initialize
+		@started = false
+	end
+	
+	#Start the action.
+	#Overriding subclasses must either call "super" or set the @started attribute to true.
+	def start(actor, target)
+		@started = true
+	end
+	
+	#Perform the action.
+	#Subclasses should override this.
+	def do(actor, target)
+	end
+	
+	#Stop the action.
+	#Overriding subclasses must either call "super" or set the @started attribute to false.
+	def stop(actor, target)
+		@started = false
+	end
+	
 end
 
 
@@ -161,7 +182,7 @@ 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.
+	#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
@@ -169,15 +190,63 @@ class Behavior
 	#Optionally takes an array of actions and one of conditions.
 	def initialize (actions = [], conditions = [])
 		self.actions, self.conditions = actions, conditions
+		#Tracks current target.
+		@active_target = nil
 	end
 	
-	#Calls each Proc object in the list of conditions with the subject and its target.  Returns nil if any condition returns false.
-	#Then calls each Proc object in the list of actions, also with the subject and its target.
-	def perform(subject, target)
-		conditions.each {|condition| return unless condition.test(subject, target)}
-		actions.each {|action| action.do(subject, target)}
+	#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)
+		
+		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)
+			end
+		rescue
+			#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.test(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.test(actor, target)}
+					@active_target = target
+					return target
+				end
+			end
+			#If there were no matches, throw an exception.
+			raise "No matching targets found."
+		end
+	
+	
 end
 
 
@@ -292,7 +361,7 @@ end
 class Clock
 
 	def initialize
-		@last_check_time = Time.new.to_f
+		reset_elapsed_time
 	end
 	
 	#Returns the time in (fractional) seconds since this method was last called (or on the first call, time since the Clock was created).
@@ -303,6 +372,10 @@ class Clock
 		elapsed_time
 	end
 	
+	def reset_elapsed_time
+		@last_check_time = Time.new.to_f
+	end
+	
 end
 
 

data/test/test_zyps.rb

@@ -125,6 +125,7 @@ class TestEnvironment < Test::Unit::TestCase
 		@environment = Environment.new
 		@environment.objects << Creature.new('1')
 		@environment.objects << Creature.new('2')
+		@environment.objects << Creature.new('3')
 		
 	end
 	
@@ -144,11 +145,13 @@ class TestEnvironment < Test::Unit::TestCase
 	
 	def test_interactions
 	
-		#Set up behavior that will log interactions.
-		behavior = Behavior.new
+		#Set up behaviors that will log interactions.
 		log = LogAction.new
-		behavior.actions << log
-		@environment.objects.each {|creature| creature.behaviors << behavior}
+		@environment.objects.each do |creature|
+			behavior = Behavior.new
+			behavior.actions << log
+			creature.behaviors << behavior
+		end
 		
 		#Have environment elements interact.
 		@environment.interact
@@ -211,10 +214,32 @@ class TestEnvironment < Test::Unit::TestCase
 		#Have environment elements interact.
 		@environment.interact
 
-		#Creature '1' should NOT have been acted on.
-		assert(log.interactions.find_all{|i| i == "2 targeting 1"}.length == 0)
-		#Creature '2' SHOULD have been acted on.
-		assert(log.interactions.find_all{|i| i == "1 targeting 2"}.length == 1)
+		assert_equal(0, log.interactions.find_all{|i| i == "2 targeting 1"}.length, "Creature '1' should NOT have been acted on.")
+		assert_equal(1, log.interactions.find_all{|i| i == "1 targeting 2"}.length, "Creature '2' SHOULD have been acted on.")
+		
+	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
 	
@@ -446,4 +471,82 @@ class TestUtility < Test::Unit::TestCase
 		))
 	end
 	
+end
+
+#TODO: Rewrite to pass environment.
+class TestBehavior < Test::Unit::TestCase
+
+	#Always true.
+	class TrueCondition < Condition
+		def test(actor, target)
+			true
+		end
+	end
+	#Always false.
+	class FalseCondition < Condition
+		def test(actor, target)
+			false
+		end
+	end
+	
+	
+	def setup
+		@actor = Creature.new('actor')
+		@target = Creature.new('target')
+		@other = Creature.new('other')
+		@environment = Environment.new
+		@environment.objects << @actor << @target << @other
+	end
+	
+	
+	#Tracks number of times its start, stop, and do methods are called.
+	class MockAction < Action
+		attr_accessor :start_count, :stop_count, :do_count
+		def initialize
+			@start_count, @stop_count, @do_count = 0, 0, 0
+		end
+		def start(actor, target)
+			super
+			@start_count += 1
+		end
+		def do(actor, target)
+			@do_count += 1
+		end
+		def stop(actor, target)
+			super
+			@stop_count += 1
+		end
+	end
+	
+	def test_actions
+	
+		#Set up a behavior with a true condition and a mock action.
+		behavior = Behavior.new
+		behavior.conditions << TrueCondition.new
+		action = MockAction.new
+		behavior.actions << action
+		
+		#Perform the behavior.
+		behavior.perform(@actor, @environment)
+		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)
+		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.")
+		
+		#Add a false condition to the behavior.
+		behavior.conditions << FalseCondition.new
+		#Perform the behavior.
+		behavior.perform(@actor, @environment)
+		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.")
+				
+	end
+	
+	
 end