public NavNode GetBestNode(NavNode currentNode, NavNode startNode, NavNode destinationNode)
{
if (currentNode != null && startNode != null && currentNode.NeighbourRefs != null)
{
var foundNewNode = false;
var furthestFromStart = currentNode;
var furthestDistance = VectorFunctions.DistanceSquared(currentNode.Position, startNode.Position);
foreach (var neighbour in currentNode.NeighbourRefs)
{
var neighbourDistance =
VectorFunctions.DistanceSquared(neighbour.Position, startNode.Position);
if (neighbourDistance > furthestDistance)
{
furthestDistance = neighbourDistance;
furthestFromStart = neighbour;
foundNewNode = true;
}
}
if (foundNewNode)
{
return(furthestFromStart);
}
}
return(null);
}
protected void Update()
{
for (
var currentNoiseIndex = 0;
currentNoiseIndex < _noisesToUpdate.Count && currentNoiseIndex < NoiseServiceConstants.NoisesPerUpdate;
currentNoiseIndex++
)
{
var currentNoise = _noisesToUpdate[currentNoiseIndex];
foreach (var listenerEntry in _listenerEntries)
{
if (VectorFunctions.DistanceSquared(currentNoise.NoiseLocation, listenerEntry.Location) < currentNoise.NoiseRadius)
{
listenerEntry.Listener.OnNoiseHeard(currentNoise);
}
}
}
if (_noisesToUpdate.Count < NoiseServiceConstants.NoisesPerUpdate)
{
_noisesToUpdate.Clear();
}
else
{
_noisesToUpdate.RemoveRange(0, NoiseServiceConstants.NoisesPerUpdate - 1);
}
}
public NavNode GetBestNode(NavNode currentNode, NavNode startNode, NavNode destinationNode)
{
if (currentNode != null && destinationNode != null && currentNode.NeighbourRefs != null)
{
var foundNewNode = false;
var closestToTarget = currentNode;
var closestDistance = VectorFunctions.DistanceSquared(currentNode.Position, destinationNode.Position);
foreach (var neighbour in currentNode.NeighbourRefs)
{
var neighbourDistance =
VectorFunctions.DistanceSquared(neighbour.Position, destinationNode.Position);
if (neighbourDistance < closestDistance)
{
closestDistance = neighbourDistance;
closestToTarget = neighbour;
foundNewNode = true;
}
}
if (foundNewNode)
{
return(closestToTarget);
}
}
return(null);
}
public void DistSquared2D_ReturnsDistanceBetween2Vectors()
{
var firstVector = new Vector2(-2.0f, 101.1f);
var secondVector = new Vector2(12.0f, -30.0f);
Assert.AreEqual(Mathf.Pow((firstVector.x - secondVector.x), 2) + Mathf.Pow((firstVector.y - secondVector.y), 2),
VectorFunctions.DistanceSquared(firstVector, secondVector));
}
private void UpdatePointTarget()
{
if (VectorFunctions.DistanceSquared(_navMeshAgent.destination, gameObject.transform.position) < TargetCompleteRadiusSquared)
{
_delegate();
PlotCourse(gameObject.transform.position);
_delegate = null;
}
}
private void UpdateFollowTarget()
{
Vector2 followPosition = _followTarget.transform.position;
if (VectorFunctions.DistanceSquared(followPosition, _currentTargetLocation) >
DistanceSquaredThreshold)
{
SetTargetLocation(_followTarget.transform.position, () => {});
}
}
protected void Update()
{
var currentLocation = gameObject.transform.position;
if (VectorFunctions.DistanceSquared(currentLocation, _previousLocation) > NoiseListenerConstants.UpdateDistanceSquared)
{
UpdateListenerLocation(currentLocation);
}
_previousLocation = currentLocation;
}
private void UpdateNodeStatus()
{
if (_pathNodes.Count == 0)
{
UpdateRegionPathStatus();
if (_pathNodes.Count == 0)
{
return;
}
}
var targetNode = _pathNodes[0];
var currentPosition = new Vector2(gameObject.transform.position.x, gameObject.transform.position.y);
if (VectorFunctions.DistanceSquared(currentPosition, targetNode.Position) <
DistanceSquaredThreshold)
{
_pathNodes.RemoveAt(0);
if (_pathNodes.Count == 0)
{
UpdateRegionPathStatus();
}
}
else
{
var deltaX = targetNode.Position.x - gameObject.transform.position.x;
var deltaY = targetNode.Position.y - gameObject.transform.position.y;
if (deltaX > 0.2f)
{
_movement.ApplySidewaysMotion(1.0f);
}
else if (deltaX < -0.2f)
{
_movement.ApplySidewaysMotion(-1.0f);
}
if (deltaY > 0.2f)
{
_movement.ApplyForwardMotion(1.0f);
}
else if (deltaY < 0.2f)
{
_movement.ApplyForwardMotion(-1.0f);
}
}
}
public override EGoalStatus Update(float inDeltaTime)
{
if (_currentStatus == EGoalStatus.InProgress)
{
if (_currentTarget == null ||
VectorFunctions.DistanceSquared(Owner.transform.position, _currentTarget.transform.position) > _params.LoseFollowRadiusSquared ||
_currentTargetSpeciesInterface.IsSpeciesCryInProgress(ECryType.Negative))
{
_currentTarget = null;
_currentTargetSpeciesInterface = null;
_currentStatus = EGoalStatus.Failed;
}
}
return(_currentStatus);
}
public override float CalculateDesirability()
{
var desirability = 0.0f;
if (_justDetectedObject || _inProgress)
{
if (VectorFunctions.DistanceSquared(Owner.transform.position, _detectedObject.transform.position) <
_params.AbandonPursuitRadiusSquared)
{
desirability = _params.TargetDetectedDesirability;
}
}
_justDetectedObject = false;
return(desirability);
}
public NavNode GetNearestNavNode(NavRegion region, Vector2 position)
{
NavNode nearestNode = null;
var nearestDistance = 100000.0f;
foreach (var node in region.Nodes)
{
var distance = VectorFunctions.DistanceSquared(position, node.Position);
if (distance < nearestDistance)
{
nearestNode = node;
nearestDistance = distance;
}
}
return(nearestNode);
}
public void GetWildlifeInRadius_ReturnsCorrectDistanceSquared()
{
var checkLocation = new Vector3(2.0f, 20.0f, -10.0f);
_wildlife.RegisterWildlife(_species.gameObject);
var retrievedWildlife = _wildlife.GetWildlifeInRadius(checkLocation, 1000f);
Assert.AreEqual
(
VectorFunctions.DistanceSquared
(
checkLocation, _species.gameObject.transform.position
),
retrievedWildlife[0].DistanceSquared
);
}
private void UpdateFollowTarget()
{
var deltaTime = GetDeltaTime();
_currentFollowDelay += deltaTime;
if (_currentFollowDelay > FollowReplotDelay)
{
_currentFollowDelay = 0.0f;
var newLocation = GetSurroundingFollowPoint(_followTarget);
if (VectorFunctions.DistanceSquared(_navMeshAgent.destination, newLocation) > FollowReplotRangeSquared)
{
PlotCourse(newLocation);
}
}
}
public List <LocalWildlifeResult> GetWildlifeInRadius(Vector3 inLocation, float inRadius)
{
var thresholdSquared = Mathf.Pow(inRadius, 2);
_currentQueryResult = new List <LocalWildlifeResult>(_registeredWildlife.Count);
foreach (var registeredAnimal in _registeredWildlife)
{
var distanceSquared = VectorFunctions.DistanceSquared(inLocation, registeredAnimal.WildlifeGameObject.transform.position);
if (distanceSquared < thresholdSquared)
{
_currentQueryResult.Add(new LocalWildlifeResult(registeredAnimal, distanceSquared));
}
}
return(_currentQueryResult);
}
// ~IPatrolInterface
public int GetNearestStartingPatrolPoint()
{
var bestPatrolPointIndex = PatrolConstants.InvalidPatrolPoint;
var bestDistanceSquared = float.MaxValue;
Vector2 patrollerLocation = gameObject.transform.position;
for (var currentIndex = 0; currentIndex < PatrolPoints.Count; currentIndex++)
{
var distanceSquared = VectorFunctions.DistanceSquared(PatrolPoints[currentIndex], patrollerLocation);
if (distanceSquared < bestDistanceSquared || bestPatrolPointIndex == PatrolConstants.InvalidPatrolPoint)
{
bestPatrolPointIndex = currentIndex;
bestDistanceSquared = distanceSquared;
}
}
return(bestPatrolPointIndex);
}
private void SmoothPath()
{
for (var i = 0; i < _pathNodes.Count - 2; i++)
{
foreach (var neighbour in _pathNodes[i].NeighbourRefs)
{
if (neighbour != _pathNodes[i + 1] &&
Math.Abs
(
VectorFunctions.DistanceSquared(neighbour.Position, _pathNodes[i + 2].Position) -
VectorFunctions.DistanceSquared(_pathNodes[i + 1].Position, _pathNodes[i + 2].Position)
) < 0.2f
)
{
_pathNodes.RemoveAt(i + 1);
break;
}
}
}
}
private bool IsInAttackRadius(GameObject target)
{
return(VectorFunctions.DistanceSquared(gameObject.transform.position, target.transform.position) <
AttackRadiusSquared);
}
private bool WithinRadius()
{
return(VectorFunctions.DistanceSquared(_returnPoint, Owner.transform.position) < _maxDistanceSquared);
}
