public DynamicFollowPath(KinematicData character, Path path)
{
this.Target = new KinematicData();
this.Character = character;
this.Path = path;
EmptyMovementOutput = new MovementOutput();
}
public override MovementOutput GetMovement()
{
MovementOutput output = new MovementOutput();
foreach(var boid in Flock)
{
Vector3 direction = Character.position - boid.position;
float distance = direction.sqrMagnitude;
if(distance < Radius * Radius)
{
float SeparationStrength = Mathf.Min(SeparationFactor / (distance * distance), MaxAcceleration);
direction.Normalize();
output.linear += direction * SeparationStrength;
}
}
if(output.linear.sqrMagnitude > MaxAcceleration * MaxAcceleration)
{
output.linear.Normalize();
output.linear *= MaxAcceleration;
}
Debug.DrawRay(Character.position, output.linear, this.MovementDebugColor);
return output;
}
public override MovementOutput GetMovement()
{
MovementOutput output = new MovementOutput();
Vector3 direction = new Vector3();
foreach (KinematicData boid in flock)
{
if(boid != Character){
direction = Character.position - boid.position;
if (direction.magnitude < radius)
{
separationStrength = Mathf.Min(separationFactor / (direction.magnitude * direction.magnitude), MaxAcceleration);
direction.Normalize();
output.linear += direction * separationStrength;
}
}
}
if(output.linear.magnitude > MaxAcceleration){
output.linear.Normalize();
output.linear*=MaxAcceleration;
}
if (PriorityManager.debugMode)
Debug.DrawRay(Character.position, output.linear, Color.gray);
return output;
}
public override MovementOutput GetMovement()
{
var output = new MovementOutput();
Vector3 desiredOrientation = this.Target.position - this.Character.position;
float linearAngle = MathHelper.ConvertVectorToOrientation(desiredOrientation);
if (this.Character.velocity.sqrMagnitude <= Mathf.Pow(MinSpeed, 2f))
{
output.linear = MathHelper.ConvertOrientationToVector(this.Character.orientation);
output.linear.Normalize();
output.linear *= this.MaxAcceleration;
return output;
}
float velocity = Character.velocity.sqrMagnitude / this.MaxSpeed * this.MaxSpeed;
float currentAngle = MaxAngle * (1 - velocity);
if (Mathf.Pow(linearAngle, 2f) > Mathf.Pow(currentAngle, 2f))
{
output.linear = MathHelper.ConvertOrientationToVector(currentAngle);
output.linear.Normalize();
output.linear *= this.MaxAcceleration * 0.5f;
}
else if (desiredOrientation.sqrMagnitude > 0)
{
desiredOrientation.Normalize();
desiredOrientation *= this.MaxAcceleration;
output.linear = desiredOrientation;
}
return output;
}
public override MovementOutput GetMovement()
{
// 1) calculate desired velocity
MovementOutput desiredOutput = this.DesiredMovement.GetMovement();
Vector3 desiredVelocity = this.Character.velocity + desiredOutput.linear;
if (desiredVelocity.magnitude > this.MaxSpeed)
{
desiredVelocity.Normalize();
desiredVelocity *= this.MaxSpeed;
}
// 2) generate samples
List <Vector3> samples = new List <Vector3>();
samples.Add(desiredVelocity);
samples.Add(this.LastSample);
for (int i = 0; i < NumSamples; i++)
{
float angle = Random.Range(0, Util.MathConstants.MATH_2PI);
float magnitude = Random.Range(MaxSpeed / 2, MaxSpeed);
Vector3 velocitySample = Util.MathHelper.ConvertOrientationToVector(angle) * magnitude;
samples.Add(velocitySample);
}
// 3) evaluate and get best sample
base.Target.velocity = getBestSample(samples);
//Debug.Log(base.Target.velocity);
return(base.GetMovement());
}
public override MovementOutput GetMovement()
{
MovementOutput output = new MovementOutput();
foreach (DynamicCharacter boid in Flock)
{
if (boid.KinematicData != this.Character)
{
Direction = this.Character.position - boid.KinematicData.position;
if (Direction.sqrMagnitude < Radius)
{
float separationStrength = System.Math.Min(SeparationFactor / (Direction.magnitude * Direction.magnitude), MaxAcceleration);
Direction.Normalize();
output.linear += Direction * separationStrength;
}
}
}
if (output.linear.magnitude > MaxAcceleration)
{
output.linear.Normalize();
output.linear *= MaxAcceleration;
}
return output;
}
public override MovementOutput GetMovement()
{
var output = new MovementOutput();
foreach (KinematicData boid in flock)
{
if (boid != this.Character)
{
var direction = this.Character.position - boid.position;
if (direction.magnitude < radius)
{
var separationStrength = Math.Min(separationFactor / (direction.magnitude * direction.magnitude), maxAcceleration);
direction.Normalize();
output.linear += direction * separationStrength;
}
}
}
if (output.linear.magnitude > maxAcceleration)
{
output.linear.Normalize();
output.linear *= maxAcceleration;
}
Debug.DrawRay(this.Character.position, output.linear, Color.red);
return(output);
}
public override MovementOutput GetMovement()
{
var output = new MovementOutput();
foreach (DynamicCharacter boid in Flock)
{
if (Character == boid.KinematicData)
{
continue;
}
Vector3 direction = Character.position - boid.KinematicData.position;
float distance = direction.magnitude;
if (distance < FlockRadius)
{
float separationStrength = Math.Min(SeparationFactor / (distance * distance), MaxAcceleration);
output.linear += direction.normalized * separationStrength;
}
}
if (output.linear.magnitude > MaxAcceleration)
{
output.linear.Normalize();
output.linear *= MaxAcceleration;
}
output.angular = 0.0f;
//Debug.DrawRay (Character.position, output.linear, Color.blue);
return(output);
}
public override MovementOutput GetMovement()
{
MovementOutput output = new MovementOutput();
foreach (DynamicCharacter boid in Flock)
{
if (boid.KinematicData != this.Character)
{
Vector3 direction = this.Character.Position - boid.KinematicData.Position;
float distance = direction.magnitude;
if (distance < Radius)
{
float separationStrength = Mathf.Min(SeparationFactor / (distance * distance), this.MaxAcceleration);
direction.Normalize();
output.linear += direction * separationStrength;
}
}
}
if (output.linear.magnitude > this.MaxAcceleration)
{
output.linear.Normalize();
output.linear *= this.MaxAcceleration;
}
return(output);
}
public override MovementOutput GetMovement()
{
float targetSpeed;
MovementOutput output = new MovementOutput();
var direction = this.Target.position - this.Character.position;
var distance = direction.magnitude;
if (distance < this.TargetRadius)
{
targetSpeed = 0.0f;
direction = this.Character.position;
}
else if (distance > this.SlowRadius)
{
//maximum speed
targetSpeed = this.MaxSpeed;
}
else
{
targetSpeed = this.MaxSpeed * distance / this.SlowRadius;
}
direction.Normalize();
this.TargetVelocity.velocity = direction.normalized * targetSpeed;
return(base.GetMovement());
}
public override MovementOutput GetMovement()
{
var output = new MovementOutput();
KinematicData character = this.Character;
float sqrRadius = this.Radius * this.Radius;
foreach (var boid in this.Flock)
{
if (boid != character)
{
var direction = character.position - boid.position;
if (direction.sqrMagnitude < sqrRadius)
{
var separationStrength = Math.Min(this.SeparationFactor / (direction.sqrMagnitude), this.MaxAcceleration);
output.linear += direction * separationStrength;
}
}
}
if (output.linear.sqrMagnitude > this.MaxAcceleration * this.MaxAcceleration)
{
output.linear = output.linear.normalized * this.MaxAcceleration;
}
return(output);
}
public override MovementOutput GetMovement()
{
var output = new MovementOutput();
UnityEngine.Vector3 deltaPos = OtherCharaterData.position - Character.position;
UnityEngine.Vector3 deltaVel = OtherCharaterData.velocity - Character.velocity;
float deltaSpeed = deltaVel.magnitude;
if (deltaSpeed <= 0.001)
return output;
float timeToClosest = -UnityEngine.Vector3.Dot(deltaPos, deltaVel) / (deltaSpeed * deltaSpeed);
if (timeToClosest > MaximumTimeLookAhead)
return output;
float distance = deltaPos.magnitude;
float minSeparation = distance - deltaSpeed * timeToClosest;
if (minSeparation > 2 * AvoidMargin)
return new MovementOutput();
if (minSeparation <= 0 || distance < 2 * AvoidMargin)
output.linear = Character.position - OtherCharaterData.position;
else
output.linear = (deltaPos + deltaVel * timeToClosest) * -1;
output.linear = output.linear.normalized * MaxAcceleration;
return output;
}
public override MovementOutput GetMovement()
{
MovementOutput desiredOutput = this.DesiredMovement.GetMovement();
Vector3 desiredVelocity = this.Character.velocity + desiredOutput.linear;
//Debug.Log("desiredOutput.linear = " + desiredOutput.linear);
if (desiredVelocity.magnitude > this.MaxSpeed)
{
desiredVelocity = desiredVelocity.normalized;
desiredVelocity *= this.MaxSpeed;
}
List <Vector3> samples = new List <Vector3>();
samples.Add(desiredVelocity);
float angle;
float magnitude;
Vector3 velocitySample;
for (var i = 0; i < 30; i++)
{
angle = Random.Range(0, Util.MathConstants.MATH_2PI);
magnitude = Random.Range(0, MaxSpeed);
velocitySample = Util.MathHelper.ConvertOrientationToVector(angle) * magnitude;
samples.Add(velocitySample);
//Debug.DrawRay(Character.Position, velocitySample, Color.gray);
}
base.Target.velocity = GetBestSample(desiredVelocity, samples);
return(base.GetMovement());
}
public override MovementOutput GetMovement()
{
MovementOutput tempOutput;
var finalOutput = new MovementOutput();
var totalWeight = 0.0f;
foreach (MovementWithWeight movementWithWeight in this.Movements)
{
movementWithWeight.Movement.Character = this.Character;
tempOutput = movementWithWeight.Movement.GetMovement();
if (tempOutput.SquareMagnitude() > 0)
{
finalOutput.linear += tempOutput.linear * movementWithWeight.Weight;
finalOutput.angular += tempOutput.angular * movementWithWeight.Weight;
totalWeight += movementWithWeight.Weight;
}
}
if (totalWeight > 0)
{
//in case the totalWeight is not 1, we need to normalize
float normalizationFactor = 1.0f/totalWeight;
finalOutput.linear *= normalizationFactor;
finalOutput.angular *= normalizationFactor;
}
return finalOutput;
}
public override MovementOutput GetMovement()
{
var output = new MovementOutput();
output.linear = this.Target.position - this.Character.position;
if (output.linear.sqrMagnitude < this.Radius * this.Radius)
{
output.linear = Vector3.zero;
}
else
{
// We'd like to arrive in timeToTarget seconds
output.linear *= (1.0f / this.TimeToTarget);
// If that is too fast, then clip the speed
if (output.linear.sqrMagnitude > this.MaxSpeed * this.MaxSpeed)
{
output.linear.Normalize();
output.linear *= this.MaxSpeed;
}
}
return(output);
}
public DynamicVelocityMatch()
{
this.StopVelocityDelta = 0.05f;
this.TimeToTargetSpeed = 0.5f;
this.TargetVelocity = new KinematicData();
this.Output = new MovementOutput();
}
public override MovementOutput GetMovement()
{
MovementOutput tempOutput;
var finalOutput = new MovementOutput();
var totalWeight = 0.0f;
foreach (MovementWithWeight movementWithWeight in this.Movements)
{
movementWithWeight.Movement.Character = this.Character;
tempOutput = movementWithWeight.Movement.GetMovement();
Debug.DrawRay(this.Character.position, tempOutput.linear * movementWithWeight.Weight, movementWithWeight.Movement.MovementDebugColor);
if (tempOutput.SquareMagnitude() > 0)
{
finalOutput.linear += tempOutput.linear * movementWithWeight.Weight;
finalOutput.angular += tempOutput.angular * movementWithWeight.Weight;
totalWeight += movementWithWeight.Weight;
}
}
if (totalWeight > 0)
{
//in case the totalWeight is not 1, we need to normalize
float normalizationFactor = 1.0f / totalWeight;
finalOutput.linear *= normalizationFactor;
finalOutput.angular *= normalizationFactor;
}
return(finalOutput);
}
public override MovementOutput GetMovement()
{
var output = new MovementOutput();
output.linear = this.Target.position - this.Character.position;
if (output.linear.sqrMagnitude < this.Radius*this.Radius)
{
output.linear = Vector3.zero;
}
else
{
// We'd like to arrive in timeToTarget seconds
output.linear *= (1.0f/this.TimeToTarget);
// If that is too fast, then clip the speed
if (output.linear.sqrMagnitude > this.MaxSpeed*this.MaxSpeed)
{
output.linear.Normalize();
output.linear *= this.MaxSpeed;
}
}
return output;
}
public override MovementOutput GetMovement()
{
MovementOutput desiredOutput = this.DesiredMovement.GetMovement();
Vector3 desiredVelocity = this.Character.velocity + desiredOutput.linear;
if (desiredVelocity.magnitude > this.MaxSpeed)
{
desiredVelocity = desiredVelocity.normalized;
desiredVelocity *= this.MaxSpeed;
}
List <Vector3> samples = new List <Vector3> {
desiredVelocity
};
for (int i = 0; i < this.NumSamples; i++)
{
float angle = Random.Range(0, MathConstants.MATH_2PI);
float magnitude = Random.Range(0, this.MaxSpeed);
Vector3 velocitySample = MathHelper.ConvertOrientationToVector(angle) * magnitude;
samples.Add(velocitySample);
}
base.Target.velocity = GetBestSample(desiredVelocity, samples);
return(base.GetMovement());
}
public override MovementOutput GetMovement()
{
var output = new MovementOutput();
foreach (DynamicCharacter boid in Flock)
{
if (boid.KinematicData != this.Character)
{
Vector3 direction = this.Character.position - boid.KinematicData.position;
float distance = direction.sqrMagnitude;
if (distance < Radius)
{
float separationStrength = Math.Min(SeparationFactor / (distance * distance), MaxAcceleration);
direction.Normalize();
output.linear += direction * separationStrength;
}
}
}
if (output.linear.sqrMagnitude > MaxAcceleration)
{
output.linear.Normalize();
output.linear *= MaxAcceleration;
}
return output;
}
public override MovementOutput GetMovement()
{
var output = new MovementOutput();
foreach (var boid in flock)
{
if (!boid.Equals(this.Character))
{
Vector3 direction = this.Character.position - boid.KinematicData.position;
float distance = direction.magnitude;
if (distance < radius)
{
float separationStrength = Mathf.Min((separationFactor / (distance * distance)), MaxAcceleration);
Vector3 normal = direction.normalized;
output.linear += normal * separationStrength;
}
}
}
if (output.linear.magnitude > MaxAcceleration)
{
output.linear = output.linear.normalized;
output.linear *= MaxAcceleration;
}
return(output);
}
protected override MovementOutput FilterMovementOutput(MovementOutput output, DynamicCharacter character)
{
float charOrientation = character.KinematicData.orientation;
float charSpeed = character.KinematicData.velocity.sqrMagnitude;
float velocity = MathHelper.ConvertVectorToOrientation(output.linear);
float angleDiff = MathHelper.SmallestDifferenceBetweenTwoAngles(charOrientation, velocity);
// OPTIMIZACAO: trocar a divisao por multiplicacao
if (angleDiff > MathConstants.MATH_PI_2 / 6f && charSpeed >= 729) // 729 = 27^2
{
output.linear = MathHelper.ConvertOrientationToVector(MathConstants.MATH_PI_2 / 6f).normalized;
character.KinematicData.velocity = character.KinematicData.velocity.normalized * 22f;
return(output);
}
if (angleDiff > MathConstants.MATH_PI_2 / 3f && charSpeed >= 484) // 484 = 22^2
{
output.linear = MathHelper.ConvertOrientationToVector(MathConstants.MATH_PI_2 / 3f).normalized;
character.KinematicData.velocity = character.KinematicData.velocity.normalized * 18f;
return(output);
}
if (angleDiff > MathConstants.MATH_PI_4 && charSpeed >= 289) // 289 = 17^2
{
output.linear = MathHelper.ConvertOrientationToVector(MathConstants.MATH_PI_4).normalized;
character.KinematicData.velocity = character.KinematicData.velocity.normalized * 15f;
return(output);
}
if (angleDiff > MathConstants.MATH_PI_2 && charSpeed >= 225) // 225 = 15^2
{
output.linear = MathHelper.ConvertOrientationToVector(MathConstants.MATH_PI_2).normalized;
character.KinematicData.velocity = character.KinematicData.velocity.normalized * 13f;
return(output);
}
return(output);
}
public override MovementOutput GetMovement()
{
MovementOutput output = new MovementOutput();
Vector3 direction;
float strength;
foreach (var boid in this.Flock.FlockMembers)
{
if (boid.KinematicData != this.Character)
{
direction = this.Character.position - boid.KinematicData.position;
var sqrDistance = direction.sqrMagnitude;
if (sqrDistance < this.FlockRadius * this.FlockRadius)
{
//var angle = MathHelper.ConvertVectorToOrientation(direction*-1);
//if (Math.Abs((angle - this.Character.orientation)%MathConstants.MATH_PI) <= MathConstants.MATH_PI_2)
//{
strength = Math.Min(this.SeparationFactor / sqrDistance, this.MaxAcceleration);
direction.Normalize();
output.linear += strength * direction;
//}
}
}
}
if (output.linear.sqrMagnitude > this.MaxAcceleration * this.MaxAcceleration)
{
output.linear.Normalize();
output.linear *= this.MaxAcceleration;
}
return(output);
}
public override MovementOutput GetMovement()
{
MovementOutput output = new MovementOutput();
Vector3 direction;
float strength;
foreach (var boid in this.Flock.FlockMembers)
{
if (boid.KinematicData != this.Character)
{
direction = this.Character.position - boid.KinematicData.position;
var sqrDistance = direction.sqrMagnitude;
if (sqrDistance < this.FlockRadius*this.FlockRadius)
{
//var angle = MathHelper.ConvertVectorToOrientation(direction*-1);
//if (Math.Abs((angle - this.Character.orientation)%MathConstants.MATH_PI) <= MathConstants.MATH_PI_2)
//{
strength = Math.Min(this.SeparationFactor/sqrDistance, this.MaxAcceleration);
direction.Normalize();
output.linear += strength*direction;
//}
}
}
}
if (output.linear.sqrMagnitude > this.MaxAcceleration*this.MaxAcceleration)
{
output.linear.Normalize();
output.linear *= this.MaxAcceleration;
}
return output;
}
public override MovementOutput GetMovement()
{
var output = new MovementOutput();
var deltaPos = this.Target.position - this.Character.position;
var distance = deltaPos.magnitude;
var deltaVel = this.Target.velocity - this.Character.velocity;
var deltaSpeed = deltaVel.magnitude;
if (!(deltaSpeed > 0)) return output;
var timeToClosest = - Vector3.Dot(deltaPos,deltaVel)/(deltaSpeed*deltaSpeed);
if (timeToClosest > this.MaxTimeLookAhead) return output;
var minSeparation = distance - deltaSpeed*timeToClosest;
if(minSeparation > 2*this.AvoidMargin) return output;
if (minSeparation <= 0 || distance < 2*this.AvoidMargin)
{
output.linear = this.Character.position - this.Target.position;
}
else
{
output.linear = (deltaPos + deltaVel*timeToClosest)*-1;
}
output.linear.Normalize();
output.linear *= this.MaxAcceleration;
return output;
}
public DynamicFollowPath()
{
this.Target = new KinematicData();
EmptyMovementOutput = new MovementOutput();
Movement = new DynamicSeek();
PathOffset = 0.1f;
}
public override MovementOutput GetMovement()
{
Vector3 direction = Target.position - Character.position;
float distance = Vector3.Magnitude(direction);
float targetSpeed;
if (distance < StopRadius)
{
Arrived = true;
var output = new MovementOutput();
return(output);
}
if (distance > SlowRadius)
{
targetSpeed = this.MaxAcceleration;
}
else
{
targetSpeed = this.MaxAcceleration * (distance / SlowRadius);
}
this.MovingTarget = new KinematicData();
this.MovingTarget.velocity = direction.normalized * targetSpeed;
return(base.GetMovement());
}
public override MovementOutput GetMovement()
{
MovementOutput steering = new MovementOutput();
// Percorrer cada canal
if (goal.hasOrientation)
{
// usar o DynamicAlign...
DynamicVelocityMatch da = new DynamicVelocityMatch()
{
Character = this.Character,
Target = new KinematicData(),
MaxAcceleration = this.MaxAcceleration
};
da.Target.orientation = goal.orientation;
steering.angular = da.GetMovement().angular;
}
if (goal.hasPosition)
{
// usar o DynamicSeek
DynamicArrive ds = new DynamicArrive()
{
Character = this.Character,
Target = new KinematicData(),
MaxAcceleration = this.MaxAcceleration,
SlowRadius = 8.0f,
StopRadius = 4.0f
};
/* if (ds.Target.orientation > goal.orientation)
* {
* ds.Target.position += 0.1f;
* }
* else
* {
* ds.Target.position -= 0.1f;
* }*/
ds.Target.position = goal.position;
steering.linear = ds.GetMovement().linear;
}
// velocidades e possivelmente erros
steering.linear.Normalize();
steering.linear *= this.MaxAcceleration;
steering.angular *= this.MaxAcceleration;
steering.linear.y = 0.0f; // Failsafe
// Debug.Log("X->"+ Character.position.x + " Y->" + Character.position.y + " Z->" + Character.position.z);
// Debug.Log("Orientation->" + Character.orientation.ToString());
return(steering);
}
public override MovementOutput GetMovement()
{
RaycastHit hit;
MovementOutput movementOutput = new MovementOutput();
Color mainRayColor = Color.white;
Color leftRayColor = Color.white;
Color rightRayColor = Color.white;
/*
* if (this.Character.velocity.magnitude == 0)
* {
* return movementOutput;
* }
*/
Ray mainRay = new Ray(this.Character.Position, this.Character.velocity.normalized);
// +-45 graus
const float Degrees45 = (float)0.52359877559;
Vector3 leftWhisker = MathHelper.Rotate2D(this.Character.velocity, -Degrees45);
Vector3 rightWhisker = MathHelper.Rotate2D(this.Character.velocity, Degrees45);
Ray leftRay = new Ray(this.Character.Position, leftWhisker.normalized);
Ray rightRay = new Ray(this.Character.Position, rightWhisker.normalized);
bool collision = false;
//Check Collisions
if (ObstacleCollider.Raycast(mainRay, out hit, this.MaxLookAhead))
{
mainRayColor = Color.red;
collision = true;
}
else if (ObstacleCollider.Raycast(leftRay, out hit, this.MaxLookAhead / 2))
{
leftRayColor = Color.red;
collision = true;
}
else if (ObstacleCollider.Raycast(rightRay, out hit, this.MaxLookAhead / 2))
{
rightRayColor = Color.red;
collision = true;
}
if (collision)
{
base.Target.Position = hit.point + hit.normal * this.AvoidMargin;
//??base.Target.Position.y = 0;
movementOutput = base.GetMovement();
movementOutput.linear.y = 0;
}
Debug.DrawRay(this.Character.Position, this.Character.velocity.normalized * this.MaxLookAhead, mainRayColor);
Debug.DrawRay(this.Character.Position, leftWhisker.normalized * this.MaxLookAhead / 3, leftRayColor);
Debug.DrawRay(this.Character.Position, rightWhisker.normalized * this.MaxLookAhead / 3, rightRayColor);
return(movementOutput);
}
public override MovementOutput GetMovement()
{
MovementOutput output = new MovementOutput();
if (this.Character.velocity.magnitude < Delta)
return output;
output.linear = -this.Character.velocity;
output.linear *= TimeToStop;
return output;
}
public DynamicFollowPath(KinematicData character, Path path)
{
this.Target = new KinematicData();
this.Character = character;
this.Path = path;
this.EmptyMovementOutput = new MovementOutput();
//don't forget to set all properties
//arrive properties
}
public override MovementOutput GetMovement()
{
MovementOutput steering = new MovementOutput();
// Percorrer cada canal
if (goal.hasOrientation)
{
// usar o DynamicAlign...
DynamicVelocityMatch da = new DynamicVelocityMatch()
{
Character = this.Character,
Target = new KinematicData(),
MaxAcceleration = this.MaxAcceleration
};
da.Target.orientation = goal.orientation;
steering.angular = da.GetMovement().angular;
}
if (goal.hasPosition)
{
// usar o DynamicSeek
DynamicArrive ds = new DynamicArrive()
{
Character = this.Character,
Target = new KinematicData(),
MaxAcceleration = this.MaxAcceleration,
SlowRadius = 8.0f,
StopRadius = 4.0f
};
/* if (ds.Target.orientation > goal.orientation)
{
ds.Target.position += 0.1f;
}
else
{
ds.Target.position -= 0.1f;
}*/
ds.Target.position = goal.position;
steering.linear = ds.GetMovement().linear;
}
// velocidades e possivelmente erros
steering.linear.Normalize();
steering.linear *= this.MaxAcceleration;
steering.angular *= this.MaxAcceleration;
steering.linear.y = 0.0f; // Failsafe
// Debug.Log("X->"+ Character.position.x + " Y->" + Character.position.y + " Z->" + Character.position.z);
// Debug.Log("Orientation->" + Character.orientation.ToString());
return steering;
}
public DynamicFollowPath(KinematicData character)
{
PathOffset = 0.4f;
Target = new KinematicData();
Character = character;
EmptyMovementOutput = new MovementOutput
{
linear = Vector3.zero
};
}
public DynamicFollowPath(KinematicData character)
{
PathOffset = 0.4f;
Target = new KinematicData();
Character = character;
EmptyMovementOutput = new MovementOutput
{
linear = Vector3.zero
};
}
public override MovementOutput GetMovement()
{
var output = new MovementOutput();
this.WanderOrientation += TurnAngle * RandomHelper.RandomBinomial();
this.Target.orientation = WanderOrientation + this.Character.orientation;
var circleCenter = this.Character.position + WanderOffset * this.Character.GetOrientationAsVector();
this.Target = new KinematicData(circleCenter + WanderRadius * this.Target.GetOrientationAsVector(), Target.velocity, this.Target.orientation, TurnAngle);
return base.GetMovement();
}
public override MovementOutput GetMovement()
{
MovementOutput output = new MovementOutput();
if (this.Character.velocity.magnitude < Delta)
{
return(output);
}
output.linear = -this.Character.velocity;
output.linear *= TimeToStop;
return(output);
}
public override MovementOutput GetMovement()
{
var output = new MovementOutput();
output.linear = (this.MovingTarget.velocity - this.Character.velocity)/this.TimeToTargetSpeed;
if (output.linear.sqrMagnitude > this.MaxAcceleration*this.MaxAcceleration)
{
output.linear = output.linear.normalized*this.MaxAcceleration;
}
output.angular = 0;
return output;
}
public override MovementOutput GetMovement()
{
var output = new MovementOutput();
// Move forward in the current direction
output.linear = this.Character.GetOrientationAsVector();
output.linear *= this.MaxSpeed;
// Turn a little
output.angular = RandomHelper.RandomBinomial() * this.MaxRotation;
return(output);
}
public override MovementOutput GetMovement()
{
var output = new MovementOutput();
output.linear = this.Target.position - this.Character.position;
if (output.linear.sqrMagnitude > 0)
{
output.linear.Normalize();
output.linear *= this.MaxAcceleration;
}
return output;
}
public override MovementOutput GetMovement()
{
var output = new MovementOutput();
output.linear = this.Target.position - this.Character.position;
if (output.linear.sqrMagnitude > 0)
{
output.linear.Normalize();
output.linear *= this.MaxAcceleration;
}
return(output);
}
public override MovementOutput GetMovement()
{
var output = new MovementOutput();
// Move forward in the current direction
output.linear = this.Character.GetOrientationAsVector();
output.linear *= this.MaxSpeed;
// Turn a little
output.angular = RandomHelper.RandomBinomial() * this.MaxRotation;
return output;
}
// Update is called once per frame
public void Update()
{
if (this.Movement != null)
{
MovementOutput steering = this.Movement.GetMovement();
this.KinematicData.Integrate(steering, this.Drag, Time.deltaTime);
this.KinematicData.SetOrientationFromVelocity();
this.KinematicData.TrimMaxSpeed(this.MaxSpeed);
this.GameObject.transform.position = this.KinematicData.position;
this.GameObject.transform.rotation = Quaternion.AngleAxis(this.KinematicData.orientation * MathConstants.MATH_180_PI, Vector3.up);
}
}
public DynamicFollowPath(KinematicData character, Path path)
{
//arrive properties
this.SlowRadius = 5.0f;
this.TargetRadius = 1.0f;
this.Target = new KinematicData();
this.Character = character;
this.Path = path;
this.CurrentParam = 1.0f;
this.PathOffset = 5.0f;
this.EmptyMovementOutput = new MovementOutput();
}
public override MovementOutput GetMovement()
{
var output = new MovementOutput();
WanderOrientation += (Random.value - Random.value) * wanderRate;
WanderOffset = 10f;
WanderRadius = 8f;
float targetOrientation = WanderOrientation + Character.orientation;
Vector3 circleCenter = Character.position + WanderOffset * MathHelper.ConvertOrientationToVector(Character.orientation);
Vector3 offsetCenter = circleCenter + WanderRadius * MathHelper.ConvertOrientationToVector(targetOrientation);
//this.Target = new KinematicData(offsetCenter, Target.velocity, targetOrientation, TurnAngle);
output.linear = (offsetCenter - Character.position).normalized * MaxAcceleration;
return output;
}
public override MovementOutput GetMovement()
{
var output = new MovementOutput();
output.linear = (this.MovingTarget.velocity - this.Character.velocity) / this.TimeToTargetSpeed;
if (output.linear.sqrMagnitude > this.MaxAcceleration * this.MaxAcceleration)
{
output.linear = output.linear.normalized * this.MaxAcceleration;
}
output.angular = 0;
return(output);
}
// Update is called once per frame
public void Update()
{
if (this.Movement != null)
{
MovementOutput output = this.Movement.GetMovement();
if (output != null)
{
this.KinematicData.Integrate(output, this.Drag, Time.deltaTime);
this.KinematicData.SetOrientationFromVelocity();
this.KinematicData.TrimMaxSpeed(this.MaxSpeed);
}
}
}
public override MovementOutput GetMovement()
{
var output = new MovementOutput();
output.linear = this.Character.GetOrientationAsVector();
if (output.linear.sqrMagnitude > 0)
{
output.linear.Normalize();
output.linear *= this.MaxAcceleration;
}
return(output);
}
public override MovementOutput GetMovement()
{
var output = new MovementOutput();
output.linear = this.Character.GetOrientationAsVector();
if (output.linear.sqrMagnitude > 0)
{
output.linear.Normalize();
output.linear *= this.MaxAcceleration;
}
return output;
}
public override MovementOutput GetMovement()
{
var output = new MovementOutput();
output.angular = (this.Target.rotation - this.Character.rotation) / TimeToTargetRotation;
var angularAcceleration = Mathf.Abs(output.angular);
if(angularAcceleration > MaxAngularAccelaration)
{
output.angular = Mathf.Sign(output.angular) * MaxAngularAccelaration;
}
output.linear = new Vector3();
return output;
}
public DynamicFollowPath(KinematicData character, Path path)
{
this.MaxSpeed = 150.0f;
this.SlowRadius = 5.0f;
this.TimeToTargetSpeed = 1.0f;
this.StopRadius = 0.5f;
this.MaxAcceleration = 50.0f;
this.Target = new KinematicData();
this.Character = character;
this.Path = path;
this.CurrentParam = 0.0f;
this.PathOffset = 1.0f;
this.EmptyMovementOutput = new MovementOutput();
}
public DynamicFollowPath(KinematicData character, GlobalPath path)
{
this.Target = new KinematicData();
this.ArriveTarget = new KinematicData();
this.Character = character;
this.Path = path;
this.EmptyMovementOutput = new MovementOutput();
this.MaxAcceleration = 30.0f;
this.MaxSpeed = 20.0f;
this.StopRadius = 0f;
this.SlowRadius = 1.0f;
this.TimeToTargetSpeed = 0.01f;
this.PathOffset = 0.7f;
this.CurrentParam = 0.0f;
}
public override MovementOutput GetMovement()
{
var output = new MovementOutput();
this.WanderOrientation += TurnAngle * RandomHelper.RandomBinomial();
this.Target.orientation = WanderOrientation + this.Character.orientation;
var circleCenter = this.Character.position + WanderOffset * this.Character.GetOrientationAsVector();
this.Target = new KinematicData(circleCenter + WanderRadius * this.Target.GetOrientationAsVector(), Target.velocity, this.Target.orientation, TurnAngle);
return(base.GetMovement());
}
public override MovementOutput GetMovement()
{
var output = new MovementOutput();
/*if (this.Target == null)
Debug.Log ("target null");
if (this.Character == null)
Debug.Log ("char null");*/
output.linear = this.Target.position - this.Character.position;
if (output.linear.sqrMagnitude > 0)
{
output.linear.Normalize();
output.linear *= this.MaxAcceleration;
}
return output;
}
public override MovementOutput GetMovement()
{
name = string.Empty;
MovementOutput tempOutput;
var finalOutput = new MovementOutput();
var totalWeight = 0.0f;
foreach (MovementWithWeight movementWithWeight in this.Movements)
{
movementWithWeight.Movement.Character = this.Character;
tempOutput = movementWithWeight.Movement.GetMovement();
if (tempOutput.SquareMagnitude() > 0)
{
finalOutput.linear += tempOutput.linear * movementWithWeight.Weight;
finalOutput.angular += tempOutput.angular * movementWithWeight.Weight;
totalWeight += movementWithWeight.Weight;
if (this.UpdateName)
{
this.name += string.Format("{0} :\n\tLinear: {1} ,\n\tAngular: {2} ,\n\tWeight: {3} ;\n",
movementWithWeight.Movement.Name,
finalOutput.linear,
finalOutput.angular,
movementWithWeight.Weight);
}
}
}
if (totalWeight > 0)
{
//in case the totalWeight is not 1, we need to normalize
float normalizationFactor = 1.0f / totalWeight;
finalOutput.linear *= normalizationFactor;
finalOutput.angular *= normalizationFactor;
}
return finalOutput;
}
public override MovementOutput GetMovement()
{
float targetSpeed;
MovementOutput output = new MovementOutput();
var direction = this.Target.position - this.Character.position;
var distance = direction.magnitude;
if (distance < this.TargetRadius)
{
output.linear = Vector3.zero;
return output;
}
if (distance > this.SlowRadius)
{
//maximum speed
targetSpeed = this.MaxSpeed;
}
else
{
targetSpeed = this.MaxSpeed*distance/this.SlowRadius;
}
direction.Normalize();
direction *= targetSpeed;
output.linear = direction - this.Character.velocity;
output.linear /= this.TimeToTarget;
// If that is too fast, then clip the acceleration
if (output.linear.sqrMagnitude > this.MaxAcceleration*this.MaxAcceleration)
{
output.linear.Normalize();
output.linear *= this.MaxAcceleration;
}
return output;
}
public override MovementOutput GetMovement()
{
/*if (targets == null)
return new MovementOutput();*/
float shortestTime = Mathf.Infinity;
Vector3 deltaPos, deltaVel, closestDeltaPos = new Vector3(), closestDeltaVel = new Vector3();
float closestDistance = 0f, deltaSpeed = 0f, timeToClosest = 0f, closestMinSeparation = 0f;
KinematicData closestTarget = new KinematicData();
deltaPos = Target.position - Character.position;
deltaVel = Target.velocity - Character.velocity;
deltaSpeed = deltaVel.magnitude;
if (deltaSpeed == 0) return new MovementOutput(); ;
timeToClosest = -(Vector3.Dot(deltaPos,deltaVel))/(deltaSpeed*deltaSpeed);
if (timeToClosest > MaxTimeLookAhead) return new MovementOutput(); ;
float distance = deltaPos.magnitude;
float minSeparation = distance - deltaSpeed*timeToClosest;
if (minSeparation > 2 * collisionRadius) return new MovementOutput(); ;
if(timeToClosest > 0 && timeToClosest < shortestTime){
shortestTime = timeToClosest;
closestTarget = Target;
closestMinSeparation = minSeparation;
closestDistance = distance;
closestDeltaPos = deltaPos;
closestDeltaVel = deltaVel;
}
if(shortestTime == Mathf.Infinity) return new MovementOutput();
Vector3 avoidanceDirection;
if(closestMinSeparation <= 0 || closestDistance < 2*collisionRadius)
avoidanceDirection = Character.position - closestTarget.position;
else
avoidanceDirection = (closestDeltaPos + closestDeltaVel * shortestTime)*-1;
MovementOutput output = new MovementOutput();
output.linear = avoidanceDirection.normalized*MaxAcceleration;
if (PriorityManager.debugMode)
Debug.DrawRay(Character.position, avoidanceDirection.normalized * MaxAcceleration, Color.black);
return output;
}
public override MovementOutput GetMovement()
{
MovementOutput output = new MovementOutput ();
if (Target == null || Character == null) {
return output;
}
Vector3 deltaPos = Target.position - Character.position;
Vector3 deltaVel = Target.velocity - Character.velocity;
float deltaSpeed = deltaVel.magnitude;
if (deltaSpeed == 0f) {
return output;
}
float timeToClosest = - Vector3.Dot (deltaPos, deltaVel) / (deltaSpeed * deltaSpeed);
if (timeToClosest > maxTimeLookAhead) {
return output;
}
var distance = deltaPos.magnitude;
float minSeparation = distance - deltaSpeed * timeToClosest;
if (minSeparation > 2f * avoidMargin) {
return output;
}
if (minSeparation <= 0f || distance < 2f * avoidMargin) {
output.linear = Character.position - Target.position;
} else {
output.linear = -(deltaPos + deltaVel * timeToClosest);
}
output.linear = output.linear.normalized * MaxAcceleration;
Debug.DrawRay (Character.position, output.linear, this.MovementDebugColor);
return output;
}
public override MovementOutput GetMovement()
{
MovementOutput steering = new MovementOutput();
// Percorrer cada canal
if (goal.hasOrientation)
{
// usar o DynamicAlign...
DynamicVelocityMatch da = new DynamicVelocityMatch()
{
Character = this.Character,
Target = new KinematicData(),
MaxAcceleration = this.MaxAcceleration
};
da.Target.orientation = goal.orientation;
steering.angular += da.GetMovement().angular;
}
if (goal.hasPosition)
{
// usar o DynamicSeek
DynamicSeek ds = new DynamicSeek()
{
Character = this.Character,
Target = new KinematicData(),
MaxAcceleration = this.MaxAcceleration
};
ds.Target.position = goal.position;
steering.linear += ds.GetMovement().linear;
}
// velocidades e possivelmente erros
steering.linear.Normalize();
steering.linear *= this.MaxAcceleration;
steering.angular *= this.MaxAcceleration;
return steering;
}
public override MovementOutput GetMovement()
{
Vector3 direction = Target.position - Character.position;
float distance = Vector3.Magnitude(direction);
float targetSpeed;
if (distance < StopRadius)
{
Arrived = true;
var output = new MovementOutput();
return output;
}
if (distance > SlowRadius)
targetSpeed = this.MaxAcceleration;
else
targetSpeed = this.MaxAcceleration * (distance / SlowRadius);
this.MovingTarget = new KinematicData();
this.MovingTarget.velocity = direction.normalized * targetSpeed;
return base.GetMovement();
}
public override MovementOutput GetMovement()
{
var output = new MovementOutput();
float goalDistance = (this.GoalPosition - this.Character.position).sqrMagnitude;
if (goalDistance < StopRadius)
{
Debug.Log("ARRIVED");
Character.Arrived = true;
return output;
}
output.linear = this.Target.position - this.Character.position;
if (output.linear.sqrMagnitude > 0)
{
output.linear.Normalize();
output.linear *= this.MaxAcceleration;
}
return output;
}
