public List <GameObject> CutLine(Vector3 lineStart, Vector3 lineEnd)
{
var dist = Vector3.Distance(lineStart, lineEnd);
var step = 100;
var count = 0;
var pieces = new List <GameObject>();
var direction = (lineEnd - lineStart).normalized;
while (count < dist)
{
var origin = lineStart + direction * count;
transform.position = origin;
var dt = lineStart - origin;
float rad = Mathf.Atan2(dt.y, dt.x);
float degree = rad * Mathf.Rad2Deg;
degree += 90;
transform.localEulerAngles = new Vector3(0f, 0, degree);
pieces = Cut();
count += step;
}
lineRenderer.SetPosition(0, lineStart);
lineRenderer.SetPosition(1, lineEnd);
return(pieces);
}
private void spawnPlayer()
{
Vector3 pos = new Vector3();
// if(player != null)
// Destroy(player);
bool canSpawnunit = false;
int loopCount = 0;
while (!canSpawnunit)
{
pos = UnityEngine.Random.insideUnitSphere * playerSpawnSphereRadius + transform.position;
bool isPositionTooClose = false;
foreach (var formerPosition in occupiedPositions)
{
if (Vector3.Distance(formerPosition, pos) < minDistanceBetweenShips)
{
isPositionTooClose = true;
}
}
if (!isPositionTooClose)
{
canSpawnunit = true;
}
else
{
loopCount++;
if (loopCount >= PLACEMENT_LOOP_MAX)
{
playerSpawnSphereRadius += 5;
loopCount = 0;
}
}
}
GameObject playerObj = GameObject.Find("Player");
// if (!playerObj || gMInstance.restartNumber > 0)
// {
// player = Pool.Instance.get(PoolableTypes.Player);
// }
// else
// {
// player = playerObj;
// }
player = playerObj.transform.Find("PlayerShip").gameObject;
player.transform.position = pos;
GameObjectStateManager.Instance.initializeDynamicObjects();
Ship playerShip = player.GetComponent <Ship>();
if (playerShip)
{
playerShip.creationSetup();
}
occupiedPositions.Add(pos);
}
/// <summary>
/// Gets the next position in the path, ignoring positions that
/// we are already at
/// </summary>
/// <returns>The next viable position in the path, or a vector 3 of Positive Infinity if no point is found</returns>
private Vector3 GetNextPosInPath(NavMeshPath path)
{
/*
* We need to be able to dismiss points that the car has reached but not the
* nav mesh agent so we look around a car and check if the next point in the path is
* within a given radius. If it is then we choose the second to next point in the path
* so that our movement is smooth
*/
if (path != null)
{
//Loop all of the positions that we have and check if there are any
//that are over the distance we need, if there is one return it
foreach (Vector3 pathPos in path.corners)
{
if (Vector3.Distance(transform.position, pathPos) > minPointHitDist)
{
return(pathPos);
}
}
}
//No points found or path invalid, return positive infinity vector
return(Vector3.positiveInfinity);
}
public override void Reason(GameObject player, GameObject npc)
{
GameObject target = npcDetector.getNpcInRange(typeToDetect, npc.transform.position, detectrange);
if (target != null)
{
BaseAI baseAi = npc.GetComponent <BaseAI>();
baseAi.wanderAttackTransistion(target);
}
else
{
if (Vector3.Distance(startPosition, npc.transform.position)
>= MAX_DISTANCE_TILL_RETURN_TO_START)
{
goBackToStart = true;
}
if (goBackToStart)
{
wanderForce = getSeek(npc.transform.position, startPosition);
if (Vector3.Distance(startPosition, npc.transform.position) <
DISTANCE_TILL_STOP_RETURN)
{
goBackToStart = false;
}
}
else
{
wanderForce = getWander(npc.transform);
}
wanderForce += getAvoidance(npc);
}
}
private void DrawQuads(VisData node, int depth, List <VisData> camList)
{
if (node.IsLeaf)
{
uint ptrQuadBlock = (uint)(uint)(((node.ptrQuadBlock) / LevelShift.Div) + LevelShift.Offset);
uint numQuadBlock = node.numQuadBlock;
for (int i = 0; i < numQuadBlock; i++)
{
long index = ptrQuadBlock + i;
Gizmos.color = new Color(1, 0, 1, 0.333f);
if (index < 0 && index > (visiQuadCompId.Count - 1))
{
break;
}
VisiQuad quad = visiQuadCompId[(int)Mathf.Min(Mathf.Max(index, 0), visiQuadCompId.Count - 1)];
if (Vector3.Distance(quad.Position, camera.transform.position) < 32.0f)
{
Transform child = quad.transform.GetChild(1);
child.gameObject.SetActive(false);
child = quad.transform.GetChild(0);
child.gameObject.SetActive(true);
}
else if (Vector3.Distance(quad.Position, camera.transform.position) < 128.0f)
{
Transform child = quad.transform.GetChild(1);
child.gameObject.SetActive(true);
child = quad.transform.GetChild(0);
child.gameObject.SetActive(false);
}
else
{
Transform child = quad.transform.GetChild(1);
child.gameObject.SetActive(false);
child = quad.transform.GetChild(0);
child.gameObject.SetActive(false);
}
}
}
else
{
VisData leftNode = visdata[node.leftChild & 0x3fff];
VisData rightNode = visdata[node.rightChild & 0x3fff];
Bounds bounds = node.bbox.GetBounds();
bool canRender = false;
if (GeometryUtility.TestPlanesAABB(planes, bounds))
{
canRender = true;
}
else if (depth > 0 && camList.Contains(node))
{
canRender = true;
depth--;
}
if (canRender)
{
DrawQuads(leftNode, depth - 1, camList);
DrawQuads(rightNode, depth - 1, camList);
}
}
}
void CleverHide()
{
float dist = Mathf.Infinity;
Vector3 chosenSpot = Vector3.zero;
Vector3 chosenDir = Vector3.zero;
GameObject chosenGO = World.Instance.GetHidingSpots()[0];
for (int i = 0; i < World.Instance.GetHidingSpots().Length; i++)
{
Vector3 hideDir = World.Instance.GetHidingSpots()[i].transform.position - target.transform.position;
Vector3 hidePos = World.Instance.GetHidingSpots()[i].transform.position + hideDir.normalized * 10; //10 is hide range
if (Vector3.Distance(transform.position, hidePos) < dist)
{
chosenSpot = hidePos;
chosenDir = hideDir;
chosenGO = World.Instance.GetHidingSpots()[i];
dist = Vector3.Distance(transform.position, hidePos);
}
}
Collider hideCol = chosenGO.GetComponent <Collider>();
Ray backRay = new Ray(chosenSpot, -chosenDir.normalized);
RaycastHit info;
float distance = 100.0f;
hideCol.Raycast(backRay, out info, distance);
Seek(info.point + chosenDir.normalized * 5);
}
// 0 3 6 9 .. がパスの橋
Option <Unit> NearestHandle(V3 pos)
{
var nearestObj = Option.None <Unit>();
float nearestDistance = 0;
for (int o = 0; o < objects.Count; o += 3)
{
var obj0 = objects[o + 1];
var obj1 = objects[o + 2];
var obj = NearObject(pos, obj0, obj1);
//if ( obj1 != null )
{
V3 p = objects[o].transform.position;
float dist = V3.Distance(pos, p);
if (!nearestObj.HasValue)
{
nearestObj = obj.Some();
nearestDistance = dist;
continue;
}
if (dist < nearestDistance)
{
nearestObj = obj.Some();
nearestDistance = dist;
}
}
}
return(nearestObj);
}
/// <summary>
/// The Process method here is handling AI behaviour.
/// The best way to handle AI would be to have a separate system for this, but for
/// the sake of this example the AI logic is embedded in this processor.
/// </summary>
protected override void Process()
{
// TODO: Set these as AI system constants.
const float aiAwarenessRadius = 100f;
const float idealDistance = 10f;
Collider[] colliders = Physics.OverlapSphere(this.profile.Rigidbody.position, aiAwarenessRadius, System.ShooterMask);
if (colliders.Length == 1)
{
return;
}
float closestDistance = Mathf.Infinity;
ShooterProcessor closest = null;
// Find closest shooter.
for (int i = 0; i < colliders.Length; i++)
{
// There are only two colliders, which are direct child of the main instance transform.
if (colliders[i].transform.parent == this.profile.Transform)
{
continue;
}
if (!this.worldSystem.WorldInstance.FindShooter(colliders[i].transform.parent, out ShooterProcessor iteration))
{
continue;
}
// Important note: Shooter's this.profile.Transform.position is always 0,0,0!
// this.profile.Rigidbody or this.profile.Head hold the true position.
float distance = Vector3.Distance(this.profile.Rigidbody.position, iteration.Profile.Rigidbody.position);
if (distance >= closestDistance)
{
continue;
}
closestDistance = distance;
closest = iteration;
}
if (closest == null)
{
// Roam.
this.profile.Rigidbody.velocity = new Vector3(UnityEngine.Random.value, 0, UnityEngine.Random.value).normalized *System.MoveSpeed;
return;
}
Vector3 enemyDirection = (closest.Profile.Rigidbody.position - this.profile.Rigidbody.position).normalized;
this.profile.Rigidbody.velocity = closestDistance >= idealDistance ?
enemyDirection.normalized * System.MoveSpeed :
Vector3.zero;
// Ready to fire.
Aim(enemyDirection);
Shoot();
}
private IEnumerator MoveToPositionRoutine(Vector3 newPosition)
{
float startTime = 0;
float distance = Vector3.Distance(transform.position, newPosition);
float totalTime = distance / movingSpeed;
while (startTime < totalTime)
{
transform.position = Vector3.Lerp(transform.position, newPosition, startTime);
if (transform.position == newPosition)
{
isMoving = false;
yield break;
}
startTime += Time.deltaTime;
yield return(null);
}
isMoving = false;
}
private Meme IsCloseEnoughForBreeding(MemeController c)
{
return(Vector3.Distance(transform.position, _target.transform.position) <
1
? Memes["Breed"]
: null);
}
private IEnumerator AttackCoroutine(GameObject player)
{
while (true)
{
var currentPosition = transform.position;
var targetPosition = player.transform.position;
var totalDistance = Vector3.Distance(currentPosition, targetPosition);
var t = totalDistance / _chargeSpeed;
_sequence = DOTween.Sequence();
_sequence.AppendCallback(() => _collider.enabled = false);
_sequence.Append(transform.DOMove(targetPosition, t).SetEase(Ease.Linear));
_sequence.AppendCallback(() => TryDoDamage(player));
_sequence.Append(transform.DOMove(currentPosition, t).SetEase(Ease.Linear));
_sequence.AppendCallback(() => _collider.enabled = true);
_sequence.Play();
while (!_sequence.IsComplete())
{
var currentDistance = Vector3.Distance(transform.position, currentPosition);
_animator.SetFloat(_attackStateAnimationHash, currentDistance / totalDistance);
yield return(null);
}
yield return(new WaitForSeconds(_attacksInterval));
}
}
private Meme IsCloseEnoughForDrinking(MemeController c)
{
return(Vector3.Distance(transform.position, _target.transform.position) <
characteristics.AnimalCharacteristics.EatRange
? Memes["Drink"]
: null);
}
private static void SendTCPDataRadius(int exceptClient, Packet _packet, Vector3 position, float sendRadius)
{
//_packet.WriteLength();
for (int i = 1; i <= GameServer.MaxPlayers; i++)
{
if (GameServer.clients[i].player != null)
{
if (i == exceptClient)
{
continue;
}
Vector3 targetPosition;
if (GameServer.clients[i].player.data.is_on_ship)
{
targetPosition = GameServer.clients[i].player.transform.position;
}
else
{
targetPosition = GameServer.clients[i].player.playerInstance.transform.position;
}
float distance = Vector3.Distance(position, targetPosition);
if (Math.Abs(distance) < sendRadius)
{
/*GameServer.server.Send(GameServer.clients[i].connectionId,
* new List<AsyncTCPServer.Message>() {
* new AsyncTCPServer.Message(1, _packet.ToArray())
* });*/
GameServer.server.Send(GameServer.clients[i].ipPort, _packet.ToArray());
}
}
}
}
// Update is called once per frame
void Update()
{
if (Giro)
{
ruleta.transform.Rotate(Vector3.forward * (RotationSpeed * Time.deltaTime));
StartCoroutine(girando());
if (RotationSpeed <= 0)
{
Giro = false;
print("Se detuvo");
float dist = Int32.MaxValue;
string select = "";
foreach (GameObject txt in textosObj)
{
if (Vector3.Distance(txt.transform.position, puntero.transform.position) < dist)
{
dist = Vector3.Distance(txt.transform.position, puntero.transform.position);
select = txt.GetComponent <Text>().text;
}
}
print("Seleccion -> " + select);
RotationSpeed = _rotationSpeed;
}
}
else
{
RotationSpeed = _rotationSpeed;
}
}
private IEnumerator TranslateMealToMouth()
{
if (!isCollectible)
{
yield break;
}
_collider2D.enabled = false;
_rb.bodyType = RigidbodyType2D.Static;
while (Vector3.Distance(transform.position, _catMouth.position) > 0.3f)
{
transform.position = Vector3.MoveTowards(transform.position, _catMouth.position, _step);
if (transform.lossyScale.x > 0.8f)
{
var mealTransform = transform;
var scale = mealTransform.localScale.x;
scale -= 0.01f;
mealTransform.localScale = new Vector3(scale, scale, scale);
}
yield return(Yielders.FixedUpdate);
}
if (!isFreezeEvent)
{
OnCollect?.Invoke(gameObject);
isCollectedEvent.Invoke();
DestroyObject();
}
else
{
Reject();
}
}
private List <int[]> CreateAtomsGraph(Vector3[] atomsPositons)
{
List <int[]> ris = new List <int[]>();
allSolutionAtomsPositions = new Vector3[atomsPositons.Length + 1];
allSolutionAtomsPositions[0] = Vector3.zero; // primo posto riservato al pivot
for (int i = 1; i < allSolutionAtomsPositions.Length; i++)
{
allSolutionAtomsPositions[i] = atomsPositons[i - 1];
}
for (int i = 0; i < allSolutionAtomsPositions.Length; i++)
{
for (int j = 0; j < allSolutionAtomsPositions.Length; j++)
{
if (i == j)
{
continue;
}
int[] possibleBond = { i, j };
if (ris.Any(p => p.SequenceEqual(possibleBond)))
{
continue;
}
ris.Add(possibleBond);
distancesGraph.Add(Vector3.Distance(allSolutionAtomsPositions[i], allSolutionAtomsPositions[j]));
}
}
return(ris);
}
void IBattleCharacter.MoveTo(UVector3 position)
{
if (!Agent || !Agent.enabled)
{
return;
}
IsStop = false;
this.Agent.Resume();
var pos = position.ToUVer3();
UnityEngine.AI.NavMeshHit hit;
if (UnityEngine.AI.NavMesh.SamplePosition(pos, out hit, 10000, this.Agent.areaMask))
{
targetPos = hit.position;
}
else
{
return;
}
if (Vector3.Distance(targetPos.Value, this.transform.position) < 0.2f)
{
stopMove();
return;
}
this.Agent.SetDestination(targetPos.Value);
}
public IEnumerator _chooseTarget()
{
float shortestRange = Mathf.Infinity;
Transform closestEnemy = null;
foreach (Transform enemy in enemiesList)
{
float distanceToEnemy = Vector3.Distance(player.transform.position, enemy.transform.position);
if (distanceToEnemy < shortestRange)
{
shortestRange = distanceToEnemy;
closestEnemy = enemy;
}
}
if (closestEnemy != null && shortestRange <= shootRange)
{
inRange = true;
target = closestEnemy.transform;
firePoint.LookAt(target);
}
else
{
inRange = false;
target = null;
}
yield return(new WaitForSeconds(1f));
}
private void FindClosestTarget()
{
GameObject[] targets = GameObject.FindGameObjectsWithTag("Creep");
float minDistance = Mathf.Infinity;
GameObject tempTarget = null;
foreach (var target in targets)
{
float currentDistance = Vector3.Distance(transform.position, target.transform.position);
if (currentDistance < minDistance)
{
tempTarget = target;
minDistance = currentDistance;
}
}
if (tempTarget && minDistance <= _stats.AttackRange)
{
_target = tempTarget;
}
else
{
_target = null;
}
}
PlayerCharacter GetClosestEnemy()
{
PlayerCharacter tMin = null;
float minDist = aggro_range;
Vector3 currentPos = transform.position;
foreach (Client client in GameServer.clients.Values)
{
if (client.player && client.player.playerCharacter && !client.player.playerCharacter.data.dead)
{
PlayerCharacter p = client.player.playerCharacter;
dist = Vector3.Distance(p.transform.position, currentPos);
if (dist < minDist)
{
tMin = p;
minDist = dist;
ServerSend.NPCTarget(id, p.id, (int)GameObjectType.dragon, transform.position);
break;
}
}
}
if (tMin != null)
{
bool ok = NavMesh.CalculatePath(transform.position, tMin.transform.position, NavMesh.AllAreas, path);
if (path.status != NavMeshPathStatus.PathComplete)
{
return(null);
}
}
return(tMin);
}
Option <Unit> NearestObj(V3 pos, out float distance)
{
var nearestObj = Option.None <Unit>();
float nearestDistance = 0;
distance = nearestDistance;
for (int o = 0; o < objects.Count; o++)
{
var obj = objects[o];
//if ( obj1 != null )
{
V3 p = objects[o].transform.position;
float dist = V3.Distance(pos, p);
if (!nearestObj.HasValue)
{
nearestObj = obj.Some();
nearestDistance = dist;
distance = dist;
continue;
}
if (dist < nearestDistance)
{
nearestObj = obj.Some();
nearestDistance = dist;
distance = dist;
}
}
}
return(nearestObj);
}
void ChooseNextEnemy()
{
PlayerCharacter maxDamageEnemy = null;
float maxDamage = 0;
foreach (int playerId in playerDamage.Keys)
{
PlayerCharacter player = GameServer.clients[playerId].player.playerCharacter;
if (playerDamage[playerId] > maxDamage && Vector3.Distance(transform.position, player.transform.position) <= chaseRange)
{
maxDamage = playerDamage[playerId];
maxDamageEnemy = GameServer.clients[playerId].player.playerCharacter;
}
}
if (maxDamageEnemy)
{
enemy = maxDamageEnemy;
}
else
{
enemy = GetClosestEnemy();
}
if (enemy != null)
{
bool ok = NavMesh.CalculatePath(transform.position, enemy.transform.position, NavMesh.AllAreas, path);
if (path.status != NavMeshPathStatus.PathComplete)
{
enemy = null;
}
}
}
private IEnumerator Movement(Transform firstItem, Transform secondItem, SwitchDelegate onSwitched = null)
{
var pos1 = firstItem.position;
var pos2 = secondItem.position;
var speed = 5f * Time.deltaTime;
var delay = new WaitForSeconds(0.3f);
onSwitched = _onSwitched;
while (true)
{
secondItem.position = Vector3.MoveTowards(secondItem.position, pos1, speed);
firstItem.position = Vector3.MoveTowards(firstItem.position, pos2, speed);
// at the end of movement
if (Vector3.Distance(firstItem.position, pos2) < 0.1f)
{
firstItem.position = pos2;
secondItem.position = pos1;
yield return(delay);
onSwitched?.Invoke();
Debug.Log("valid");
yield break;
}
yield return(null);
}
}
private void handleZeroPlanetIsoView()
{
if (_planetNum != 0)
{
return;
}
print("planet is 0");
var dir = new Vector3(xDisToStar, yDisToStar, zDisToStar).normalized;
var isoIdealPos = _starPos + dir * _dirMultiplierCam;
isoStarViewPos.position = isoIdealPos;
camera.GetComponent <ThirdPersonCamera>().isometricStarViewPos.position = isoIdealPos;
print("iso position " + isoIdealPos);
// move player a little bit closer to the star when first enter iso view
var dirA = (player.position - _starPos).normalized;
var playerIsoStartPos = transform.position - dirA * _dirMultiplierPlayer;
var playerToStarDist = Vector3.Distance(playerIsoStartPos, _starPos);
if (playerToStarDist > 180)
{
playerIsoStartPos = transform.position + dirA * _dirMultiplierPlayer;
}
print("playerToStarDist --- " + playerToStarDist);
player.GetComponent <ThirdPersonPlayer>().playerIsoEnterPos = playerIsoStartPos;
}
private void Update()
{
if (_freezeDuration <= 0f)
{
var distance = Vector3.Distance(transform.position, Player.Instance.transform.position);
var direction = -(transform.position - Player.Instance.transform.position).normalized;
transform.rotation = Quaternion.LookRotation(direction, Vector3.up);
_speedMod = Mathf.Lerp(_speedMod, 1f, Time.deltaTime * 2f);
if (distance > StopDistance || _speedMod < 0)
{
transform.position += Preset.Speed * Time.deltaTime * direction * _speedMod;
}
else
{
DealDamageToPlayer();
}
}
else
{
_freezeDuration -= Time.deltaTime;
}
PushCloseEnemies();
}
private void calculatePerpendicularDir(Vector3 planetOnePos, Vector3 planetTwoPos)
{
var dirA = planetOnePos - _starPos;
var dirB = planetTwoPos - _starPos;
var normalDir = Vector3.Cross(dirA, dirB).normalized;
GetComponent <Orbit>().normalVector = normalDir;
var isoIdealPos = _starPos + normalDir * _dirMultiplierCam;
isoStarViewPos.position = isoIdealPos;
camera.GetComponent <ThirdPersonCamera>().isometricStarViewPos.position = isoIdealPos;
if (!_firstEnter)
{
return;
}
var playerToStar = Vector3.Distance(player.position, _starPos);
print("playerToStarDist --- " + playerToStar);
var playerIsoStartPos = transform.position + dirB.normalized * _dirMultiplierPlayer;
var playerToStarDist = Vector3.Distance(playerIsoStartPos, _starPos);
if (playerToStarDist > 250)
{
playerIsoStartPos = transform.position - dirB.normalized * _dirMultiplierPlayer;
}
player.GetComponent <ThirdPersonPlayer>().playerIsoEnterPos = playerIsoStartPos;
_firstEnter = false;
}
private bool CheckMinDistanceApart(Vector3 pos, List <Vector3> spawned)
{
if (spawned.Count == 0)
{
return(true);
}
bool ok = false;
var apart = new List <Vector3>();
for (int i = 0; i < spawned.Count; i++)
{
var dist = Vector3.Distance(pos, spawned[i]);
Debug.Log(dist);
if (dist >= minDistanceApart)
{
apart.Add(spawned[i]);
}
}
if (apart.Count < spawned.Count)
{
for (int i = 0; i < spawned.Count; i++)
{
if (!apart.Contains(spawned[i]))
{
spawned.RemoveAt(i);
}
}
}
return(ok);
}
public Vector3Int FindNearestLocalPoint(Vector3 worldPoint, Block target)
{
var targetPos = MyGrid.FirstOrDefault(x => x.Value.Equals(target)).Key;
List <Vector3Int> adjacentPoints = GetAdjacentPoints(targetPos);
foreach (var point in adjacentPoints)
{
if (MyGrid.ContainsKey(point))
{
adjacentPoints.Remove(point);
}
}
float minimumDistance = float.MaxValue;
Vector3Int closestLocalPoint = new Vector3Int();
foreach (var point in adjacentPoints)
{
var adjacentWorldPoint = ConvertLocalToWorldPoint(point);
if (Math.Min(minimumDistance, Vector3.Distance(adjacentWorldPoint, worldPoint)) != minimumDistance)
{
closestLocalPoint = point;
minimumDistance = Math.Min(minimumDistance, Vector3.Distance(adjacentWorldPoint, worldPoint));
}
}
return(closestLocalPoint);
}
public static float CalculateDistance(Vector3 leftOriginLocal_mm, Vector3 leftDirection, Vector3 rightOriginLocal_mm, Vector3 rightDirection)
{
Vector3 p1;
Vector3 p2;
var linesAreNotParallel = ClosestPointsOnTwoLines(out p1, out p2, ref rightOriginLocal_mm, ref rightDirection, ref leftOriginLocal_mm, ref leftDirection);
var combinedGazeOrigin_mm = (leftOriginLocal_mm + rightOriginLocal_mm) / 2f;
var convergencePoint = (p1 + p2) / 2f;
var distance_mm = Vector3.Distance(convergencePoint, combinedGazeOrigin_mm);
if (float.IsNaN(distance_mm))
{
return(_lastDistance_mm);
}
if (!linesAreNotParallel || distance_mm > _maximumDistance_mm || float.IsInfinity(distance_mm))
{
distance_mm = _maximumDistance_mm;
}
if (distance_mm < _minimumDistance_mm)
{
distance_mm = _minimumDistance_mm;
}
_lastDistance_mm = distance_mm;
return(distance_mm);
}
protected void Hearing()
{
// If the bee is heading towards the hive, don't interrupt
if (mainTarget != null && mainTarget.gameObject == hive.gameObject)
{
return;
}
// If the noise maker is not set
if (playerNoiseMaker == null)
{
player = GameObject.FindGameObjectWithTag("Player");
playerNoiseMaker = player.GetComponent <NoiseMaker>();
}
// If we did not fail to find the player's noise maker
if (playerNoiseMaker != null)
{
// If we're close enough to hear the player
if (Vector3.Distance(player.transform.position, transform.position) <= playerNoiseMaker.volume + hearingRadius)
{
HearPlayer(player);
}
}
}
