public override void Execute(Steerable steerable)
{
base.Execute(steerable);
// Retrieve the amount of light energy possessed by the NPC performing this action
float myLightEnergy = steerable.GetComponent<LightSource>().LightEnergy.CurrentEnergy;
if (targetLightSource)
{
// If this fish has less light than its target
if(!alwaysSeek && (myLightEnergy < targetLightSource.LightEnergy.CurrentEnergy || alwaysFlee))
{
// Flee the light source since it is stronger than this fish
fleeWhenWeaker.Execute(steerable);
//Debug.Log("FLEE THE FISH: " + targetLightSource.name);
}
// Else, if this fish has more light than its target
else
{
// Seek the light source
seekWhenStronger.Execute(steerable);
}
}
else
{
// If the light source has been destroyed, stop performing this action.
ActionCompleted();
}
wallAvoidance.Execute(steerable);
}
public override void Execute(Steerable steerable)
{
base.Execute(steerable);
if (targetFlare)
{
// Override the steerable's min/max speed
if (overrideSteerableSpeed)
{
steerable.MinSpeed = minSpeed;
steerable.MaxSpeed = maxSpeed;
}
// Override the steerable's max force
if (overrideMaxForce)
{
steerable.MaxForce = maxForce;
}
// Seek the light source
arrivalForce.Execute(steerable);
}
else
{
// If the flare has been destroyed, stop seeking it
ActionCompleted();
}
wallAvoidance.Execute(steerable);
}
public override void Execute(Steerable steerable)
{
Player player = targetLightSource.gameObject.GetComponent<Player>();
if (!player.isSafe)
{
base.Execute(steerable);
if (overrideSteerableSpeed)
{
steerable.MinSpeed = minSpeed;
steerable.MaxSpeed = maxSpeed;
}
// Override the steerable's max force
if (overrideMaxForce)
{
steerable.MaxForce = maxForce;
}
Vector3 position = targetLightSource.transform.position;
if (overrideBossSpeed(steerable, position))
{
steerable.MinSpeed = speedMinIncreased;
steerable.MaxSpeed = speedMaxIncreased;
}
steerable.AddSeekForce(position, strengthMultiplier);
}
else
{
ActionCompleted();
}
wallAvoidance.Execute(steerable);
}
public override void Execute(Steerable steerable)
{
// Override the steerable's min/max speed
if (overrideSteerableSpeed)
{
steerable.MinSpeed = minSpeed;
steerable.MaxSpeed = maxSpeed;
}
// Override the steerable's max force
if (overrideMaxForce)
{
steerable.MaxForce = maxForce;
}
//checks if the boss fish is at the waypoint, if so then no need to move to waypoint anymore
if((Vector2)bigFish.GetComponent<Rigidbody>().velocity == Vector2.zero)
{
ActionCompleted();
}
else
{
steerable.AddMoveWaypointForce(waypointList, bigFish, slowingRadius, strengthMultiplier);
}
wallAvoidance.Execute(steerable);
}
public override void Execute(Steerable steerable)
{
base.Execute(steerable);
if (targetTransform)
{
// Override the steerable's min/max speed
if (overrideSteerableSpeed)
{
steerable.MinSpeed = minSpeed;
steerable.MaxSpeed = maxSpeed;
}
// Override the steerable's max force
if (overrideMaxForce)
{
steerable.MaxForce = maxForce;
}
// If player's lights are on, seek player
if (targetTransform.gameObject.CompareTag("Player"))
{
Player player = targetTransform.gameObject.GetComponent<Player>();
if (player.IsDetectable())
{
steerable.AddSeekForce(targetTransform.position, strengthMultiplier);
AkSoundEngine.PostEvent("Fish_Detection", targetTransform.gameObject);
}
}
else
{
steerable.AddSeekForce(targetTransform.position, strengthMultiplier);
}
}
}
public override void Execute(Steerable steerable)
{
base.Execute(steerable);
if (targetFlare)
{
// Override the steerable's min/max speed
if (overrideSteerableSpeed)
{
steerable.MinSpeed = minSpeed;
steerable.MaxSpeed = maxSpeed;
}
// Override the steerable's max force
if (overrideMaxForce)
{
steerable.MaxForce = maxForce;
}
// Seek the light source
arrivalForce.Execute(steerable);
}
else
{
// If the flare has been destroyed, stop seeking it
ActionCompleted();
}
wallAvoidance.Execute(steerable);
}
public override void Execute(Steerable steerable)
{
base.Execute(steerable);
// Retrieve the amount of light energy possessed by the NPC performing this action
float myLightEnergy = steerable.GetComponent <LightSource>().LightEnergy.CurrentEnergy;
if (targetLightSource)
{
// If this fish has less light than its target
if (!alwaysSeek && (myLightEnergy < targetLightSource.LightEnergy.CurrentEnergy || alwaysFlee))
{
// Flee the light source since it is stronger than this fish
fleeWhenWeaker.Execute(steerable);
//Debug.Log("FLEE THE FISH: " + targetLightSource.name);
}
// Else, if this fish has more light than its target
else
{
// Seek the light source
seekWhenStronger.Execute(steerable);
}
}
else
{
// If the light source has been destroyed, stop performing this action.
ActionCompleted();
}
wallAvoidance.Execute(steerable);
}
public override void Execute(Steerable steerable)
{
// Override the steerable's min/max speed
if (overrideSteerableSpeed)
{
steerable.MinSpeed = minSpeed;
steerable.MaxSpeed = maxSpeed;
}
// Override the steerable's max force
if (overrideMaxForce)
{
steerable.MaxForce = maxForce;
}
//checks if the boss fish is at the waypoint, if so then no need to move to waypoint anymore
if ((Vector2)bigFish.GetComponent <Rigidbody>().velocity == Vector2.zero)
{
ActionCompleted();
}
else
{
steerable.AddMoveWaypointForce(waypointList, bigFish, slowingRadius, strengthMultiplier);
}
wallAvoidance.Execute(steerable);
}
public override void Execute(Steerable steerable)
{
Player player = targetLightSource.gameObject.GetComponent <Player>();
if (!player.isSafe)
{
base.Execute(steerable);
if (overrideSteerableSpeed)
{
steerable.MinSpeed = minSpeed;
steerable.MaxSpeed = maxSpeed;
}
// Override the steerable's max force
if (overrideMaxForce)
{
steerable.MaxForce = maxForce;
}
Vector3 position = targetLightSource.transform.position;
if (overrideBossSpeed(steerable, position))
{
steerable.MinSpeed = speedMinIncreased;
steerable.MaxSpeed = speedMaxIncreased;
}
steerable.AddSeekForce(position, strengthMultiplier);
}
else
{
ActionCompleted();
}
wallAvoidance.Execute(steerable);
}
/// <summary>
/// Makes the steerable seek the current 'targetTransform' instance
/// </summary>
public override void Execute(Steerable steerable)
{
base.Execute(steerable);
if (targetTransform)
{
// Override the steerable's min/max speed
if (overrideSteerableSpeed)
{
steerable.MinSpeed = minSpeed;
steerable.MaxSpeed = maxSpeed;
}
// Override the steerable's max force
if (overrideMaxForce)
{
steerable.MaxForce = maxForce;
}
// If player's lights are on, seek player
if (targetTransform.gameObject.CompareTag("Player"))
{
Player player = targetTransform.gameObject.GetComponent <Player>();
if (player.IsDetectable)
{
steerable.AddSeekForce(targetTransform.position, strengthMultiplier);
PlaySeekSound();
}
}
else
{
steerable.AddSeekForce(targetTransform.position, strengthMultiplier);
}
}
}
/// <summary>
/// Called every frame when this action needs to be performed.
/// Applies a fleeing steering force on the given steerable
/// </summary>
public override void Execute(Steerable steerable)
{
base.Execute(steerable);
// If the action has elapsed its timer
if (useTimer && timeActive > timer)
{
// Inform subscribers that the action is completed. This stops the action's execution.
ActionCompleted();
// Reset the timer for the next time the action is performed.
ResetTimer();
}
if (targetTransform)
{
// If player's lights are on, seek player
if (targetTransform.gameObject.CompareTag("Player"))
{
Player player = targetTransform.gameObject.GetComponent <Player>();
if (player.IsDetectable)
{
// Override the steerable's min/max speed
if (overrideSteerableSpeed)
{
steerable.MinSpeed = minSpeed;
steerable.MaxSpeed = maxSpeed;
}
// Override the steerable's max force
if (overrideMaxForce)
{
steerable.MaxForce = maxForce;
}
}
else
{
// The player is hidden. Thus, the fish should stop fleeing
//ActionCompleted();
}
}
else
{
// Override the steerable's min/max speed
if (overrideSteerableSpeed)
{
steerable.MinSpeed = minSpeed;
steerable.MaxSpeed = maxSpeed;
}
// Override the steerable's max force
if (overrideMaxForce)
{
steerable.MaxForce = maxForce;
}
}
steerable.AddFleeForce(targetTransform.position, strengthMultiplier);
}
}
public override void Execute(Steerable steerable)
{
base.Execute(steerable);
if (targetSteerable)
{
steerable.AddPursueForce(targetSteerable, strengthMultiplier);
}
}
/// <summary>
/// Makes the steerable pursue the 'targetTransform' instance
/// </summary>
public override void Execute(Steerable steerable)
{
base.Execute(steerable);
if (targetSteerable)
{
steerable.AddPursueForce(targetSteerable, strengthMultiplier);
}
}
public override void OnAwake()
{
// Cache the 'Steerable' component attached to the GameObject performing this action
steerable = transform.GetComponent <Steerable>();
// Set the stopping condition's transform to the same Transform that is performing this 'Steer' action.
// This way, the stopping condition will be tested using this GameObject's position
stoppingCondition.SetTransform(base.transform);
}
private bool overrideBossSpeed(Steerable steerable, Vector3 target)
{
float distance = Vector2.Distance(steerable.transform.position, target);
if (distance >= distanceSpeedIncrease)
{
return(true);
}
return(false);
}
void Start()
{
// Cache the 'Steerable' component attached to the GameObject performing this action
steerable = transform.GetComponent <Steerable>();
// Set the stopping condition's transform to the same Transform that is performing this 'Steer' action.
// This way, the stopping condition will be tested using this GameObject's position
stoppingCondition.SetTransform(transform);
// Reset the stopping condition. The stopping condition now knows that the 'Steer' action just started.
stoppingCondition.Init();
}
public override void Execute(Steerable steerable)
{
base.Execute(steerable);
if (targetTransform)
{
steerable.AddArrivalForce(targetTransform.position, slowingRadius, strengthMultiplier);
}
else
{
// If the target transform is null, there is nothing to seek. Thus, stop the action
ActionCompleted();
}
}
/// <summary>
/// Initializes the fish object
/// </summary>
protected override void Awake()
{
// Call parent LightSource Awake() first
base.Awake();
// Initialize action priority dictionary
this.actions = new PriorityDictionary();
this.Move();
// Cache the 'Steerable' component attached to the GameObject performing this action
this.steerable = transform.GetComponent <Steerable>();
// Set the fish's initial swim direction
steerable.WanderAngle = defaultWanderAngle;
}
public override void Execute(Steerable steerable)
{
base.Execute(steerable);
if (targetTransform)
{
steerable.AddArrivalForce(targetTransform.position, slowingRadius, strengthMultiplier);
}
else
{
// If the target transform is null, there is nothing to seek. Thus, stop the action
ActionCompleted();
}
}
/** Returns a steering force which veers this object towards the given target's future position.
* This can be seen as a more intelligent version of the 'Seek' behaviour */
public Vector2 PursueForce(Steerable target)
{
// Compute the distance from this GameObject to his target
float distanceToTarget = (target.Transform.position - Transform.position).magnitude;
// Calculate the amount of time required for this object to reach his target
float timeToReachTarget = distanceToTarget / target.MaxSpeed;
// Determines the target's future position, in 'timeToReachTarget' amount of time
// This is the position this object will try to pursue to stay ahead of his target
Vector2 futureTargetPosition = (Vector2)target.Transform.position + target.Rigidbody.velocity * timeToReachTarget;
// The resulting steering force is the 'Seek' force to the target's future location
Vector2 pursueForce = SeekForce(futureTargetPosition);
return(pursueForce);
}
public void SeekToPositionMaxAcceleration()
{
Steerable steerer = new Steerable();
steerer.MaxSpeed = 10;
steerer.Acceleration = float.MaxValue;
steerer.Target = Vector2.One * 1000;
steerer.Behaviors.Add(new SeekBehavior());
float[] targetSpeed = new float[] { 10, 10, 10 };
for (int i = 0; i < targetSpeed.Length; ++i)
{
steerer.Update(ElapsedTime);
Assert.AreEqual <int>((int)targetSpeed[i], (int)Math.Round(steerer.Speed));
}
}
/// <summary>
/// Returns a steering force which makes this object evade the given target.
/// The target's SteeringManager component is passed to access the target's
/// max speed easily.
/// </summary>
public Vector2 EvadeForce(Steerable targetToEvade)
{
// Compute the distance from this GameObject to his target to evade
float distanceToTarget = (targetToEvade.Transform.position - Transform.position).magnitude;
// Calculate the amount of time required for this object to reach his target
float timeToReachTarget = distanceToTarget / targetToEvade.MaxSpeed;
// Determines the target's future position, in 'timeToReachTarget' amount of time
// This is the position this object will try to evade to stay away from his target
Vector2 futureTargetPosition = (Vector2)targetToEvade.Transform.position + targetToEvade.Rigidbody.velocity * timeToReachTarget;
// Calculate the steering force needed to veer away from the target's future position
Vector2 evadeForce = FleeForce(futureTargetPosition);
// Return the steering force used to evade the given target
return(evadeForce);
}
public void ArriveAtPosition()
{
Steerable steerer = new Steerable();
steerer.MaxSpeed = 10;
steerer.Acceleration = 20.02345f;
steerer.Target = Vector2.One * 100;
steerer.Behaviors.Add(new ArriveBehavior());
float[] targetSpeed = new float[] { 2, 4, 6, 8, 10, 10, 10 };
for (int i = 0; i < targetSpeed.Length; ++i)
{
steerer.Update(ElapsedTime);
Assert.AreEqual <int>((int)targetSpeed[i], (int)Math.Round(steerer.Speed));
}
bool hasStopped = false;
bool hasFullyStopped = false;
for (int i = 0; i < 2000; ++i)
{
steerer.Update(ElapsedTime);
if (hasStopped)
{
Assert.IsTrue(steerer.Speed < steerer.MaxSpeed);
if (steerer.Speed <= 0)
{
hasFullyStopped = true;
Assert.IsTrue(Vector2.Distance(Vector2.One * 100, steerer.Position) < 1f);
}
if (hasFullyStopped)
{
Assert.IsTrue(steerer.Speed <= float.Epsilon);
}
}
if ((int)Math.Round(steerer.Speed) != (int)Math.Round(steerer.MaxSpeed))
{
hasStopped = true;
}
}
Assert.IsTrue(hasStopped);
Assert.IsTrue(hasFullyStopped);
}
public override void Execute(Steerable steerable)
{
// Override the steerable's min/max speed
if (overrideSteerableSpeed)
{
steerable.MinSpeed = minSpeed;
steerable.MaxSpeed = maxSpeed;
}
// Override the steerable's max force
if (overrideMaxForce)
{
steerable.MaxForce = maxForce;
}
cohesion.Execute(steerable);
alignment.Execute(steerable);
separation.Execute(steerable);
wallAvoidance.Execute(steerable);
wander.Execute(steerable);
}
public override void Execute(Steerable steerable)
{
// Override the steerable's min/max speed
if (overrideSteerableSpeed)
{
steerable.MinSpeed = minSpeed;
steerable.MaxSpeed = maxSpeed;
}
// Override the steerable's max force
if (overrideMaxForce)
{
steerable.MaxForce = maxForce;
}
cohesion.Execute(steerable);
alignment.Execute(steerable);
separation.Execute(steerable);
wallAvoidance.Execute(steerable);
wander.Execute(steerable);
}
public void ArriveAtPositionNearby()
{
Steerable steerer = new Steerable();
steerer.MaxSpeed = 10;
steerer.Acceleration = 20.02345f;
steerer.Target = Vector2.One * 5;
steerer.Behaviors.Add(new ArriveBehavior());
bool hasStopped = false;
bool hasFullyStopped = false;
float previousSpeed = float.MinValue;
for (int i = 0; i < 200; ++i)
{
steerer.Update(ElapsedTime);
if (hasStopped)
{
Assert.IsTrue(steerer.Speed < steerer.MaxSpeed);
if (steerer.Speed <= 0)
{
hasFullyStopped = true;
Assert.IsTrue(Vector2.Distance(Vector2.One * 5, steerer.Position) < 0.5f);
}
if (hasFullyStopped)
{
Assert.IsTrue(steerer.Speed <= float.Epsilon);
}
}
if (steerer.Speed < previousSpeed)
{
hasStopped = true;
}
previousSpeed = steerer.Speed;
}
Assert.IsTrue(hasStopped);
Assert.IsTrue(hasFullyStopped);
}
protected Vector3 followLeader(Steerable leader, float followingDist)
{
/*Produces a steering towards poit just behind a leader
* * @param leader object to follow as the leader
* * @param followingDist the distance to which we follow the leader
* @return following force
*/
Vector3 tv = -leader.velocity;
tv = Vector3.Normalize(tv) * followingDist;
Vector3 behindPos = leader.transform.position + tv;
Vector3 steering = seek(behindPos, true);
//steering = steering + separation (1f);
// steering = Vector3.ClampMagnitude (steering, 0.02f);
// steering = steering / mass;
return(steering);
}
/// <summary>
/// Creates a new instance of Navigator.
/// </summary>
public Navigator()
{
steerable = new Steerable();
steerable.BlendMode = SteeringBehaviorBlendMode.Solo;
steerable.Behaviors.Add(new StuckAvoidanceBehavior());
steerable.Behaviors.Add(wallAvoidance = new WallAvoidanceBehavior()
{
Enabled = false
});
steerable.Behaviors.Add(steerableAvoidance = new SteerableAvoidanceBehavior()
{
Enabled = false
});
steerable.Behaviors.Add(separation = new SeparationBehavior()
{
Enabled = false
});
steerable.Behaviors.Add(arrive = new ArriveBehavior()
{
Enabled = false
});
waypoints = new Queue <Vector3>();
}
public Pursue(int priority, string id, Steerable targetSteerable)
: base(priority, id)
{
this.targetSteerable = targetSteerable;
}
public Pursue(int priority, string id, Steerable targetSteerable) : base(priority, id)
{
this.targetSteerable = targetSteerable;
}
// void Execute(Steerable steerable, SteeringBehavior steeringBehavior);
/// <summary>
/// Called every frame when this action needs to be performed.
/// Applies the action on the given steerable
/// </summary>
public virtual void Execute(Steerable steerable)
{
timeActive += Time.deltaTime;
}
void Start()
{
// Cache the 'Steerable' component attached to the GameObject performing this action
steerable = transform.GetComponent<Steerable>();
// Set the stopping condition's transform to the same Transform that is performing this 'Steer' action.
// This way, the stopping condition will be tested using this GameObject's position
stoppingCondition.SetTransform(transform);
// Reset the stopping condition. The stopping condition now knows that the 'Steer' action just started.
stoppingCondition.Init();
}
/// <summary>
/// Initializes the fish object
/// </summary>
protected override void Awake()
{
// Call parent LightSource Awake() first
base.Awake();
// Initialize action priority dictionary
this.actions = new PriorityDictionary();
this.Move();
// Cache the 'Steerable' component attached to the GameObject performing this action
this.steerable = transform.GetComponent<Steerable>();
// Set the fish's initial swim direction
steerable.WanderAngle = defaultWanderAngle;
}
/// <summary>
/// Adds a force which evades the given target. Instead of simply moving away from his target, this seekable flees
/// his target's future position, making him smarter at dodging his target.
/// </summary>
/// <param name="multiplier">The amount by which the seek force is multiplied before being added to the steerable's steering force
public void AddEvadeForce(Steerable targetToEvade, float multiplier)
{
steeringForce += EvadeForce(targetToEvade) * multiplier;
}
public override void Execute(Steerable steerable)
{
base.Execute(steerable);
steerable.AddWallAvoidanceForce(avoidanceForce, maxViewDistance, obstacleLayer, strengthMultiplier);
}
/// <summary>
/// Adds a force which steers the steerable away from its neighbours
/// </summary>
public override void Execute(Steerable steerable)
{
base.Execute(steerable);
steerable.AddSeparationForce(strengthMultiplier);
}
/// <summary>
/// Pursue the given target. Moves the steerable to his target's future position.
/// </summary>
/// <param name="multiplier">The amount by which the seek force is multiplied before being added to the steerable's steering force
public void AddPursueForce(Steerable target, float multiplier)
{
steeringForce += PursueForce (target) * multiplier;
}
/// <summary>
/// Adds a force which evades the given target. Instead of simply moving away from his target, this seekable flees
/// his target's future position, making him smarter at dodging his target.
/// </summary>
/// <param name="multiplier">The amount by which the seek force is multiplied before being added to the steerable's steering force
public void AddEvadeForce(Steerable targetToEvade, float multiplier)
{
steeringForce += EvadeForce (targetToEvade) * multiplier;
}
/// <summary>
/// Executes the wander action on the given steerable, making it
/// wander in a random direction
/// </summary>
public override void Execute(Steerable steerable)
{
base.Execute(steerable);
steerable.AddWanderForce(circleDistance, circleRadius, angleChange, strengthMultiplier);
}
public override void Execute(Steerable steerable)
{
base.Execute(steerable);
// If the action has elapsed its timer
if (useTimer && timeActive > timer)
{
//Debug.Log("Flee timer elapsed.");
// Inform subscribers that the action is completed. This stops the action's execution.
ActionCompleted();
// Reset the timer for the next time the action is performed.
ResetTimer();
}
if (targetTransform)
{
// If player's lights are on, seek player
if (targetTransform.gameObject.CompareTag("Player"))
{
Player player = targetTransform.gameObject.GetComponent<Player>();
if (player.IsDetectable())
{
// Override the steerable's min/max speed
if (overrideSteerableSpeed)
{
steerable.MinSpeed = minSpeed;
steerable.MaxSpeed = maxSpeed;
}
// Override the steerable's max force
if (overrideMaxForce)
{
steerable.MaxForce = maxForce;
}
//Debug.Log("FLEE THE PLAYER [Flee.Execute()]");
}
else
{
// The player is hidden. Thus, the fish should stop fleeing
//ActionCompleted();
}
}
else
{
// Override the steerable's min/max speed
if (overrideSteerableSpeed)
{
steerable.MinSpeed = minSpeed;
steerable.MaxSpeed = maxSpeed;
}
// Override the steerable's max force
if (overrideMaxForce)
{
steerable.MaxForce = maxForce;
}
}
steerable.AddFleeForce(targetTransform.position, strengthMultiplier);
}
}
/// <summary>
/// Returns a steering force which makes this object evade the given target.
/// The target's SteeringManager component is passed to access the target's
/// max speed easily.
/// </summary>
private Vector2 EvadeForce(Steerable targetToEvade)
{
// Compute the distance from this GameObject to his target to evade
float distanceToTarget = (targetToEvade.Transform.position - Transform.position).magnitude;
// Calculate the amount of time required for this object to reach his target
float timeToReachTarget = distanceToTarget / targetToEvade.MaxSpeed;
// Determines the target's future position, in 'timeToReachTarget' amount of time
// This is the position this object will try to evade to stay away from his target
Vector2 futureTargetPosition = (Vector2)targetToEvade.Transform.position + (Vector2)targetToEvade.Rigidbody.velocity * timeToReachTarget;
// Calculate the steering force needed to veer away from the target's future position
Vector2 evadeForce = FleeForce(futureTargetPosition);
// Return the steering force used to evade the given target
return evadeForce;
}
/// <summary>
/// Pursue the given target. Moves the steerable to his target's future position.
/// </summary>
/// <param name="multiplier">The amount by which the seek force is multiplied before being added to the steerable's steering force
public void AddPursueForce(Steerable target, float multiplier)
{
steeringForce += PursueForce(target) * multiplier;
}
// Need to be able to set these floats elsewhere;
public override void Execute(Steerable steerable)
{
base.Execute(steerable);
steerable.AddWanderForce(circleDistance, circleRadius, angleChange, strengthMultiplier);
}
/** Returns a steering force which veers this object towards the given target's future position.
* This can be seen as a more intelligent version of the 'Seek' behaviour */
private Vector2 PursueForce(Steerable target)
{
// Compute the distance from this GameObject to his target
float distanceToTarget = (target.Transform.position - Transform.position).magnitude;
// Calculate the amount of time required for this object to reach his target
float timeToReachTarget = distanceToTarget / target.MaxSpeed;
// Determines the target's future position, in 'timeToReachTarget' amount of time
// This is the position this object will try to pursue to stay ahead of his target
Vector2 futureTargetPosition = (Vector2)target.Transform.position + (Vector2)target.Rigidbody.velocity * timeToReachTarget;
// The resulting steering force is the 'Seek' force to the target's future location
Vector2 pursueForce = SeekForce(futureTargetPosition);
return pursueForce;
}
/// <summary>
/// Called every frame when the action needs to be performed.
/// Applies a steering force on the given steerable
/// </summary>
public override void Execute(Steerable steerable)
{
base.Execute(steerable);
steerable.AddAlignmentForce(strengthMultiplier);
}
protected Vector3 followLeader(Steerable leader, float followingDist){
/*Produces a steering towards poit just behind a leader
* * @param leader object to follow as the leader
* * @param followingDist the distance to which we follow the leader
* @return following force
*/
Vector3 tv = -leader.velocity;
tv = Vector3.Normalize (tv) * followingDist;
Vector3 behindPos = leader.transform.position + tv;
Vector3 steering = seek (behindPos, true);
//steering = steering + separation (1f);
// steering = Vector3.ClampMagnitude (steering, 0.02f);
// steering = steering / mass;
return steering;
}
private bool overrideBossSpeed(Steerable steerable, Vector3 target)
{
float distance = Vector2.Distance(steerable.transform.position, target);
if (distance >= distanceSpeedIncrease)
{
return true;
}
return false;
}
public override void Execute(Steerable steerable)
{
base.Execute(steerable);
steerable.AddAlignmentForce(strengthMultiplier);
}
public override void Execute(Steerable steerable)
{
base.Execute(steerable);
steerable.AddSeparationForce(strengthMultiplier);
}
public override void Execute(Steerable steerable)
{
base.Execute(steerable);
steerable.AddWallAvoidanceForce(avoidanceForce, maxViewDistance, obstacleLayer, strengthMultiplier);
}
