zyps 0.6.3 → 0.7.0

data/lib/zyps/actions.rb

@@ -48,7 +48,13 @@ class TimedAction < Action
 	end
 	
 	#Begin tracking time between actions.
-	def start(actor, target)
+	def start(actor, targets)
+		super
+		@clock.reset_elapsed_time
+	end
+	
+	#Halt tracking time between actions.
+	def stop(actor, targets)
 		super
 		@clock.reset_elapsed_time
 	end
@@ -58,9 +64,9 @@ end
 
 #Head toward a target.
 class FaceAction < Action
-	#Set the actor's heading to point directly at target.
-	def do(actor, target)
-		actor.vector.pitch = Utility.find_angle(actor.location, target.location)
+	#Set the actor's heading to point directly at first target.
+	def do(actor, targets)
+		actor.vector.pitch = Utility.find_angle(actor.location, targets[0].location)
 	end
 end
 
@@ -71,111 +77,56 @@ class AccelerateAction < TimedAction
 	#Can be negative to slow down or go in reverse.
 	attr_accessor :rate
 	#Increase or decrease speed according to elapsed time.
-	def do(actor, target)
+	def do(actor, targets)
 		actor.vector.speed += delta
 	end
 end
 
 
-#Turn over time.
+#Apply a thrust that turns actor.
 class TurnAction < TimedAction
-	#Degrees per second to turn.
-	#Positive turns clockwise, negative turns counter-clockwise.
-	attr_accessor :rate
-	#Turn according to elapsed time.
-	def do(actor, target)
-		actor.vector.pitch += delta
+	#Angle to turn at.
+	attr_accessor :angle
+	def initialize(rate, angle)
+		super
+		@angle = angle
+	end
+	def do(actor, targets)
+		actor.vector += Vector.new(
+			delta,
+			actor.vector.pitch + @angle
+		)
 	end
 end
 
 
 #Approaches the target, but obeys law of inertia.
 class ApproachAction < TimedAction
-	#Direction/speed actor is accelerating in.
-	attr_accessor :heading
-	#Degrees per second the direction of acceleration can change.
-	attr_accessor :rate
-	def initialize(rate = 360, heading = Vector.new)
-		super
-		self.heading = heading
-	end
-	#Make a deep copy.
-	def copy
-		copy = super
-		copy.heading = @heading.copy
-		copy
-	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.
-		turn_angle = Utility.find_angle(actor.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
-		#The creature can only turn as fast as the elapsed time, of course.
-		maximum_turn = delta
-		if turn_angle.abs > maximum_turn
-			if turn_angle > 0
-				turn_angle = maximum_turn
-			else
-				turn_angle = maximum_turn * -1
-			end
-		end
-		#Turn the appropriate amount.
-		@heading.pitch += turn_angle
-		#Apply the heading to the creature's movement vector.
-		actor.vector += @heading
+	#Accelerate toward the first target, but limited by rate.
+	def do(actor, targets)
+		#Apply thrust to the creature's movement vector, adjusted by elapsed time.
+		actor.vector += Vector.new(
+			delta,
+			Utility.find_angle(actor.location, targets[0].location)
+		)
 	end
 end
 
 
 #Flees from the target, but obeys law of inertia.
 class FleeAction < TimedAction
-	#Direction/speed actor is accelerating in.
-	attr_accessor :heading
-	#Degrees per second the direction of acceleration can change.
-	attr_accessor :rate
-	def initialize(rate = 360, heading = Vector.new)
-		super
-		self.heading = heading
-	end
-	#Make a deep copy.
-	def copy
-		copy = super
-		copy.heading = @heading.copy
-		copy
-	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.
-		turn_angle = Utility.find_angle(actor.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
-		#The creature can only turn as fast as the elapsed time, of course.
-		maximum_turn = delta
-		if turn_angle.abs > maximum_turn
-			if turn_angle > 0
-				turn_angle = maximum_turn
-			else
-				turn_angle = maximum_turn * -1
-			end
-		end
-		#Turn the appropriate amount.
-		@heading.pitch += turn_angle
-		#Apply the heading to the creature's movement vector.
-		actor.vector += @heading
+	#Accelerate away from the first target, but limited by turn rate.
+	def do(actor, targets)
+		#Apply thrust to the creature's movement vector, adjusted by elapsed time.
+		actor.vector += Vector.new(
+			delta,
+			Utility.find_angle(actor.location, targets[0].location) + 180
+		)
 	end
 end
 
 
-#Destroy the target.
+#Destroy the targets.
 class DestroyAction < Action
 	#The environment to remove objects from.
 	attr_accessor :environment
@@ -183,19 +134,23 @@ class DestroyAction < Action
 		self.environment = environment
 	end
 	#Remove the target from the environment.
-	def do(actor, target)
-		@environment.objects.delete(target)
+	def do(actor, targets)
+		targets.each do |target|
+			@environment.objects.delete(target)
+		end
 	end
 end
 
 
-#Destroy the target and grow in size.
+#Destroy the targets and grow in size.
 class EatAction < DestroyAction
-	#Remove the target from the environment, and increase actor's size by size of target.
-	def do(actor, target)
+	#Remove the targets from the environment, and increase actor's size by size of targets.
+	def do(actor, targets)
 		#Grow in size.
-		actor.size += target.size
-		#Remove the target from the environment.
+		targets.each do |target|
+			actor.size += target.size
+		end
+		#Remove the targets from the environment.
 		super
 	end
 end
@@ -203,44 +158,50 @@ end
 
 #Add a tag to the target.
 class TagAction < Action
-	#Tag to apply to target.
+	#Tag to apply to targets.
 	attr_accessor :tag
 	def initialize(tag)
 		self.tag = tag
 	end
-	#Apply the given tag to the target.
-	def do(actor, target)
-		target.tags << tag unless target.tags.include?(tag)
+	#Apply the given tag to the targets.
+	def do(actor, targets)
+		targets.each do |target|
+			target.tags << tag unless target.tags.include?(tag)
+		end
 	end
 end
 
 
 #Blend the target's color with another color.
 class BlendAction < Action
-	#Color to apply to target.
+	#Color to apply to targets.
 	attr_accessor :color
 	def initialize(color)
 		self.color = color
 	end
-	#Blend the target's color with the assigned color.
-	def do(actor, target)
-		target.color += @color
+	#Blend the targets' color with the assigned color.
+	def do(actor, targets)
+		targets.each do |target|
+			target.color += @color
+		end
 	end
 end
 
 
 #Pushes target away.
 class PushAction < TimedAction
-	#Units/second to accelerate target by.
+	#Units/second to accelerate targets by.
 	attr_accessor :rate
-	#Accelerate the target away from the actor, but limited by elapsed time.
-	def do(actor, target)
-		#Angle to target is also angle of push force.
-		push_angle = Utility.find_angle(actor.location, target.location)
+	#Push the targets away from the actor, with force limited by elapsed time.
+	def do(actor, targets)
 		#Acceleration will be limited by elapsed time.
 		push_force = delta
-		#Apply the force to the creature's movement vector.
-		target.vector += Vector.new(push_force, push_angle)
+		targets.each do |target|
+			#Angle to target is also angle of push force.
+			push_angle = Utility.find_angle(actor.location, target.location)
+			#Apply the force to the creature's movement vector.
+			target.vector += Vector.new(push_force, push_angle)
+		end
 	end
 end
 
@@ -249,14 +210,16 @@ end
 class PullAction < TimedAction
 	#Units/second to accelerate target by.
 	attr_accessor :rate
-	#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)
+	#Pull the targets toward the actor, with force limited by elapsed time.
+	def do(actor, targets)
 		#Acceleration will be limited by elapsed time.
 		pull_force = delta
-		#Apply the force to the creature's movement vector.
-		target.vector += Vector.new(pull_force, pull_angle)
+		targets.each do |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)
+			#Apply the force to the creature's movement vector.
+			target.vector += Vector.new(pull_force, pull_angle)
+		end
 	end
 end
 
@@ -272,31 +235,33 @@ class BreedAction < Action
 		@clock = Clock.new
 		@time_since_last_action = 0
 	end
-	def do(actor, target)
-		#Skip action if target is not a Creature.
-		return unless target.is_a?(Creature)
-		#Get time since last action, and skip if it hasn't been long enough.
-		@time_since_last_action += @clock.elapsed_time
-		return unless @time_since_last_action >= @delay
-		#Create a child.
-		child = Creature.new
-		#Combine colors.
-		child.color = actor.color + target.color
-		#Combine behaviors EXCEPT those with BreedActions.
-		behaviors = (actor.behaviors + target.behaviors).find_all do |behavior|
-			! behavior.actions.any?{|action| action.is_a?(BreedAction)}
+	def do(actor, targets)
+		targets.each do |target|
+			#Skip action if target is not a Creature.
+			next unless target.is_a?(Creature)
+			#Get time since last action, and skip if it hasn't been long enough.
+			@time_since_last_action += @clock.elapsed_time
+			return unless @time_since_last_action >= @delay
+			#Create a child.
+			child = Creature.new
+			#Combine colors.
+			child.color = actor.color + target.color
+			#Combine behaviors EXCEPT those with BreedActions.
+			behaviors = (actor.behaviors + target.behaviors).find_all do |behavior|
+				! behavior.actions.any?{|action| action.is_a?(BreedAction)}
+			end
+			behaviors.each {|behavior| child.behaviors << behavior.copy}
+			#Location should equal actor's.
+			child.location = actor.location.copy
+			#Add parents' vectors to get child's vector.
+			child.vector = actor.vector + target.vector
+			#Child's size should be half the average size of the parents'.
+			child.size = ((actor.size + target.size) / 2) / 2
+			#Add child to environment.
+			@environment.objects << child
+			#Reset elapsed time.
+			@time_since_last_action = 0
 		end
-		behaviors.each {|behavior| child.behaviors << behavior.copy}
-		#Location should equal actor's.
-		child.location = actor.location.copy
-		#Add parents' vectors to get child's vector.
-		child.vector = actor.vector + target.vector
-		#Child's size should be half the average size of the parents'.
-		child.size = ((actor.size + target.size) / 2) / 2
-		#Add child to environment.
-		@environment.objects << child
-		#Reset elapsed time.
-		@time_since_last_action = 0
 	end
 end
 

data/lib/zyps/conditions.rb

@@ -21,53 +21,77 @@ require 'zyps'
 module Zyps
 
 
-#Act only on objects with the correct tag.
+#Select objects with the correct tag.
 class TagCondition < Condition
 	#The tag to look for on the target.
 	attr_accessor :tag
 	def initialize(tag)
 		self.tag = tag
 	end
-	#True if the target has the assigned tag.
-	def met?(actor, target)
-		target.tags.include?(@tag)
+	#Returns an array of targets which have the assigned tag.
+	def select(actor, targets)
+		targets.find_all {|target| target.tags.include?(@tag)}
 	end
 end
 
 
-#Act only on objects older than the given age.
+#Select objects older than the given age.
 class AgeCondition < Condition
 	#The minimum age in seconds.
 	attr_accessor :age
 	def initialize(age)
 		self.age = age
 	end
-	#True if the target is older than the assigned age.
-	def met?(actor, target)
-		target.age > @age
+	#Returns an array of targets which are older than the assigned age.
+	def select(actor, targets)
+		targets.find_all {|target| target.age > @age}
 	end
 end
 
 
-#Act only on objects closer than the given distance.
+#Select objects that are closer than the given distance.
 class ProximityCondition < Condition
 	#The maximum number of units away the target can be.
 	attr_accessor :distance
 	def initialize(distance)
 		self.distance = distance
 	end
-	#True if the actor and target are equal to or closer than the given distance.
-	def met?(actor, target)
-		Utility.find_distance(actor.location, target.location) <= @distance
+	#Returns an array of targets that are at the given distance or closer.
+	def select(actor, targets)
+		targets.find_all {|target| Utility.find_distance(actor.location, target.location) <= @distance}
 	end
 end
 
 
 #True only if collided with target.
 class CollisionCondition < Condition
-	#True if the objects have collided.
-	def met?(actor, target)
-		Utility.collided?(actor, target)
+	#Returns an array of targets that have collided with the actor.
+	def select(actor, targets)
+		targets.find_all {|target| Utility.collided?(actor, target)}
+	end
+end
+
+
+#True if the actor's strength is equal to or greater than the target's. 
+class StrengthCondition < Condition
+	#Returns an array of targets that are weaker than the actor.
+	#For now, strength is based merely on size.
+	def select(actor, targets)
+		targets.find_all {|target| actor.size >= target.size}
+	end
+end
+
+
+#True if the actor and target are of the same Ruby class.
+class ClassCondition < Condition
+	#The class of target to look for.
+	attr_accessor :target_class
+	def initialize(target_class)
+		self.target_class = target_class
+	end
+	#Returns an array of targets that are of the selected Ruby class.
+	def select(actor, targets)
+		targets.grep(target_class)
 	end
 end
 

data/lib/zyps/environmental_factors.rb

@@ -33,32 +33,44 @@ class Enclosure < EnvironmentalFactor
 	#Y coordinate of bottom boundary.
 	attr_accessor :bottom
 	
-	def initialize(left = 0, top = 0, right = 0, bottom = 0)
-		self.left, self.top, self.right, self.bottom = left, top, right, bottom
+	#Takes a hash with these keys and defaults:
+	#	:left => 0
+	#	:top => 0
+	#	:right => 0
+	#	:bottom => 0
+	def initialize(options = {})
+		options = {
+			:left => 0,
+			:top => 0,
+			:right => 0,
+			:bottom => 0
+		}.merge(options)
+		self.left, self.top, self.right, self.bottom = options[:left], options[:top], options[:right], options[:bottom]
 	end
 	
 	#If object is beyond a boundary, set its position equal to the boundary and reflect it.
-	def act(object)
-		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)
+	def act(environment)
+		environment.objects.each do |object|
+			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
 
 
-
 #Keeps all objects at/under the assigned speed.
 class SpeedLimit < EnvironmentalFactor
 	
@@ -70,8 +82,10 @@ class SpeedLimit < EnvironmentalFactor
 	end
 	
 	#If object is over the speed, reduce its speed.
-	def act(object)
-		object.vector.speed = Utility.constrain_value(object.vector.speed, @maximum)
+	def act(environment)
+		environment.objects.each do |object|
+			object.vector.speed = Utility.constrain_value(object.vector.speed, @maximum)
+		end
 	end
 	
 end
@@ -85,15 +99,16 @@ class Accelerator < EnvironmentalFactor
 	
 	def initialize(vector)
 		self.vector = vector
-		@clocks = {} #Don't use Hash.new <block>, as it can't transmit via DRb.
+		@clock = Clock.new
 	end
 
 	#Accelerate the target away from the actor, but limited by elapsed time.
-	def act(object)
-		#Track time since last action for each GameObject.
-		@clocks[object] ||= Clock.new
-		#Push on object.
-		object.vector += Vector.new(@vector.speed * @clocks[object].elapsed_time, @vector.pitch)
+	def act(environment)
+		elapsed_time = @clock.elapsed_time
+		environment.objects.each do |object|
+			#Push on object.
+			object.vector += Vector.new(@vector.speed * elapsed_time, @vector.pitch)
+		end
 	end
 
 end
@@ -124,25 +139,26 @@ class Friction < EnvironmentalFactor
 	
 	def initialize(force)
 		self.force = force
-		#Track time since last action for each GameObject.
-		@clocks = {} #Don't use Hash.new <block>, as it can't transmit via DRb.
+		#Track time since last action.
+		@clock = Clock.new
 	end
 	
 	#Reduce the target's speed at the given rate.
-	def act(object)
-		#Track time since last action for each GameObject.
-		@clocks[object] ||= Clock.new
-		#Slow object.
-		acceleration = @force * @clocks[object].elapsed_time
-		speed = object.vector.speed
-		if speed > 0
-			speed -= acceleration 
-			speed = 0 if speed < 0
-		elsif speed < 0
-			speed += acceleration
-			speed = 0 if speed > 0
+	def act(environment)
+		elapsed_time = @clock.elapsed_time
+		environment.objects.each do |object|
+			#Slow object.
+			acceleration = @force * elapsed_time
+			speed = object.vector.speed
+			if speed > 0
+				speed -= acceleration 
+				speed = 0 if speed < 0
+			elsif speed < 0
+				speed += acceleration
+				speed = 0 if speed > 0
+			end
+			object.vector.speed = speed
 		end
-		object.vector.speed = speed
 	end
 	
 end
@@ -150,21 +166,17 @@ end
 
 class PopulationLimit < EnvironmentalFactor
 	
-	#Environment to remove objects from.
-	attr_accessor :environment
 	#Maximum allowed population.
 	attr_accessor :count
 	
-	def initialize(environment, count)
-		self.environment = environment
+	def initialize(count)
 		self.count = count
 	end
 	
 	#Remove target if there are too many objects in environment.
-	def act(object)
-		if environment.objects.length > @count
-			environment.objects.delete(object)
-		end
+	def act(environment)
+		excess = environment.objects.length - @count
+		environment.objects.slice!(0, excess) if excess > 0
 	end
 	
 end