public override IEnumerable <Collider2D> Select(Boid2D boid)
{
IEnumerable <Collider2D> selections;
if (delegateSelector)
{
Vector2 pos = boid.transform.position;
selections = delegateSelector.Select(boid);
foreach (var overlap in selections)
{
Vector2 p = overlap.ClosestPoint(pos); // TODO ver si por fin dejo esto o lo de abajo
// Vector2 p = overlap.transform.position;
var sqrdist = (pos - p).sqrMagnitude;
if (sqrdist < radius * radius && mask.IsLayerInMask(overlap.gameObject.layer))
{
yield return(overlap);
}
}
}
else
{
selections = GetNear(boid);
foreach (var overlap in selections)
{
yield return(overlap);
}
}
}
// Faz dar a volta no mapa
void FixPosition(Boid2D subject)
{
float boundedX = Mathf.Repeat(subject.transform.position.x - bl.x, worldDimensions.x) + bl.x;
float boundedY = Mathf.Repeat(subject.transform.position.y - bl.y, worldDimensions.y) + bl.y;
subject.transform.position = new Vector2(boundedX, boundedY);
}
private void OnTriggerExit2D(Collider2D other)
{
if (mask.IsLayerInMask(other.gameObject.layer))
{
other.gameObject.layer = LayerMask.NameToLayer(newLayerName); // cambiar el layer
Boid2D boid = other.GetComponent <Boid2D>();
if (boid)
{
foreach (var flock in removeFlocks)
{
boid.RemoveFromFlock(flock);
}
foreach (var flock in addFlocks)
{
boid.AddToFlock(flock);
}
}
SpriteRenderer sp = other.GetComponent <SpriteRenderer>();
if (sp)
{
sp.sortingOrder = orderInLayer;
}
}
}
public override Vector2 Steer(Boid2D boid)
{
var pos = (Vector2)boid.transform.position;
var overlaps = selector.Select(boid);
Vector2 steer = Vector2.zero;
int count = 0;
foreach (var otherBoid in overlaps)
{
var closestPoint = otherBoid.ClosestPoint(pos);
var diff = pos - closestPoint;
var dist = diff.sqrMagnitude;
if (dist == 0)
{
dist = Eps;
}
steer += diff / dist;
count++;
}
if (count > 0)
{
return(steer / count);
}
else
{
return(Vector2.zero);
}
}
public override IEnumerable <Collider2D> Select(Boid2D boid)
{
foreach (var b in flock.boids)
{
yield return(b.attachedCollider);
}
}
Vector2 AntiPenetrate(Boid2D me, Boid2D[] neighbors)
{
var v = Vector2.zero;
if (FindInRadius(me.position, radiuses[INDEX_ANTI_PENET], neighbors).Count() > 0) {
v = Random.insideUnitCircle * maxSpeed;
}
return weights[INDEX_ANTI_PENET] * v;
}
private void OnRefugeeArrived(Boid2D obj)
{
_citizensRefuged++;
if (_citizensRefuged == _citizensCount)
{
winTimeline.Play();
}
}
protected void CreateBoid(Vector2 position, Vector2 velocity)
{
Boid2D boid = new Boid2D(position, velocity, configuration, spawnArea, unlimSpace);
Instantiate(boidPrefab, position, Quaternion.identity).InitBoid(boid);
boidsList.Add(boid);
}
// Start is called before the first frame update
void Start()
{
// Spawn boids
for (int i = 0; i < numBoids; i++)
{
Boid2D boid = Instantiate(prefab, Random.insideUnitCircle * 3, Quaternion.identity);
boids.Add(boid);
}
}
public override IEnumerable <Collider2D> Select(Boid2D boid)
{
foreach (var b in boids)
{
if (b != boid.attachedCollider)
{
yield return(b);
}
}
}
// Start is called before the first frame update
void Start()
{
bl = Camera.main.ScreenToWorldPoint(new Vector3(0, 0, -10));
tr = Camera.main.ScreenToWorldPoint(new Vector3(Screen.width, Screen.height, -10));
worldDimensions = new Vector2(tr.x - bl.x, tr.y - bl.y);
for (int i = 0; i < numBoids; i++)
{
Boid2D boid = Instantiate(prefab, Random.insideUnitCircle * 3, Quaternion.identity);
boids.Add(boid);
}
}
public float probRandom; // prbabilidad de moverse random
public override Vector2 Steer(Boid2D boid)
{
float random = Random.value;
if (random < probRandom)
{
return(Random.insideUnitCircle);
}
else
{
return(boid.velocity); // devolver la velocidad que ya tenía
}
}
private void OnTriggerEnter2D(Collider2D other)
{
if (other.CompareTag("Boid"))
{
Boid2D boid = other.GetComponent <Boid2D>();
if (boid)
{
boid.RemoveFromAllFlocks();
Destroy(other.gameObject);
eventRefugeeArrived?.Invoke(boid);
}
}
}
public override IEnumerable <Collider2D> Select(Boid2D boid)
{
var pos = (Vector2)boid.transform.position;
var overlaps = Physics2D.OverlapCircleAll(pos, radius);
foreach (var overlap in overlaps)
{
if (overlap.gameObject != boid.gameObject)
{
yield return(overlap);
}
}
}
void UpdateNeighbors(Boid2D subject)
{
List <Boid2D> updateNeighbors = new List <Boid2D>();
// Para cada boid do mundo(caso não seja ele mesmo) perguntamos ao boid em questão se é vizinho
foreach (Boid2D boid in boids)
{
if (boid != subject && subject.IsInsideFieldOfView(boid.transform.position))
{
updateNeighbors.Add(boid);
}
}
subject.neighbors = updateNeighbors;
}
private IEnumerable <Collider2D> GetNear(Boid2D boid)
{
var pos = (Vector2)boid.transform.position;
int overlapsCount = Physics2D.OverlapCircleNonAlloc(pos, radius, _overlapsBuffer, mask);
for (int i = 0; i < overlapsCount; i++)
{
var overlap = _overlapsBuffer[i];
if (overlap.gameObject != boid.gameObject)
{
yield return(overlap);
}
}
}
public override IEnumerable <Collider2D> Select(Boid2D boid)
{
Vector2 pos = boid.transform.position;
foreach (var b in boids)
{
Vector2 bpos = b.ClosestPoint(pos); // TODO ver si por fin dejo esto o lo de abajo
// Vector2 bpos = b.transform.position;
float sqrDist = (pos - bpos).sqrMagnitude;
if (sqrDist < radius * radius)
{
yield return(b);
}
}
}
Vector2 Cohesion(Boid2D me, Boid2D[] neighbors)
{
var v = Vector2.zero;
var count = 0;
var sqrMinRadius = radiuses[INDEX_ALIGNMENT] * radiuses[INDEX_ALIGNMENT];
foreach (var f in FindInRadius(me.position, radiuses[INDEX_COHESION], neighbors)) {
var distvec = f.position - me.position;
if (distvec.sqrMagnitude < sqrMinRadius)
continue;
v += f.position;
count++;
}
if (count > 0) {
v = v / count - me.position;
}
return weights[INDEX_COHESION] * v;
}
Vector2 Alignment(Boid2D me, Boid2D[] neighbors)
{
var v = Vector2.zero;
var count = 0;
var sqrMinRadius = radiuses[INDEX_SEPARATE] * radiuses[INDEX_SEPARATE];
foreach (var f in FindInRadius(me.position, radiuses[INDEX_ALIGNMENT], neighbors)) {
var distvec = f.position - me.position;
if (distvec.sqrMagnitude < sqrMinRadius)
continue;
v += f.velocity;
count++;
}
if (count > 0) {
v = v / count - me.velocity;
}
return weights[INDEX_ALIGNMENT] * v;
}
public override Vector2 Steer(Boid2D boid)
{
Vector2 pos = boid.position;
var boids = new List <Collider2D>(selector.Select(boid));
if (boids.Count > 0)
{
var meanPos = meanPosition(boids);
var radiusVec = pos - meanPos;
var tangent = radiusVec.ortoNormalized();
var clockOriented = GetOrientation(radiusVec, tangent, clockwise);
return(clockOriented);
}
else
{
return(Vector2.zero);
}
}
public override void UpdateVectors(List <IBoid> boids, BoidsBehaviourPreset preset)
{
Vector2 aligment = Vector2.zero;
Vector2 cohesion = Vector2.zero;
Vector2 separation = Vector2.zero;
Vector2 area = Vector2.zero;
int countOfNearby = 0;
for (int i = boids.Count - 1; i >= 0; i--)
{
Boid2D boid = (Boid2D)boids[i];
if (boid != this && IsNearby(boid))
{
aligment += boid.Velocity;
cohesion += boid.Position;
float distance = Vector2.Distance(Position, boid.Position);
separation += (Position - boid.Position) / Mathf.Pow(distance, 2);
countOfNearby++;
}
}
if (countOfNearby > 0)
{
aligment /= (float)countOfNearby;
cohesion /= (float)countOfNearby;
separation /= (float)countOfNearby;
cohesion -= Position;
aligment *= preset.aligment;
cohesion *= preset.cohesion;
separation *= preset.separation;
Vector2 newForce = (cohesion + aligment + separation);
currentDirection = (newForce + currentDirection).normalized;
}
}
public override Vector2 Steer(Boid2D boid)
{
var overlaps = selector.Select(boid);
Vector2 sum = Vector2.zero;
int count = 0;
foreach (var otherBoid in overlaps)
{
sum += (Vector2)otherBoid.transform.up; // dirección en la que apunta
count++;
}
if (count > 0)
{
return(sum / count);
}
else
{
return(Vector2.zero);
}
}
public void SpawnBoids()
{
if (flocks == null || flocks.Count == 0)
{
return;
}
for (int i = 0; i < count; i++)
{
// Instacnciar como hijo y relativo a la posición del 1er flock
var flockTransform = flocks[0].transform;
Vector3 flockPos = flockTransform.position;
Vector3 randPos = (Vector3)(Random.insideUnitCircle * spawnRadius) + flockPos;
Vector3 spawnPos = randPos + (Vector3)relPosition;
Boid2D boid = Instantiate(boidPrefab, spawnPos, Quaternion.identity, flockTransform);
foreach (var flock in flocks)
{
// añadirlo a todos los flocks
flock.AddBoid(boid);
}
}
}
public override Vector2 Steer(Boid2D boid)
{
var pos = (Vector2)boid.transform.position;
var overlaps = selector.Select(boid);
Vector2 sum = Vector2.zero;
int count = 0;
foreach (var otherBoid in overlaps)
{
sum += (Vector2)otherBoid.transform.position;
count++;
}
if (count > 0)
{
return((sum / count) - pos);
}
else
{
return(Vector2.zero);
}
}
public override Vector2 Steer(Boid2D boid)
{
var overlaps = selector.Select(boid);
Vector2 steer = Vector2.zero;
int count = 0;
foreach (var otherBoid in overlaps)
{
if (otherBoid.attachedRigidbody)
{
steer += otherBoid.attachedRigidbody.velocity;
count++;
}
}
if (count > 0)
{
return(steer / count);
}
else
{
return(boid.velocity);
}
}
public override Vector2 Steer(Boid2D boid)
{
return(dir.normalized * magnitude);
}
public void InitBoid(Boid2D boid)
{
this.boid = boid;
boid.SubscribeOnUpdatePosition(UpdatePosition);
}
private void DestroyBoid(Boid2D boid)
{
// eliminarlo de su/s flock/s
boid.RemoveFromAllFlocks();
Destroy(boid.gameObject);
}
private void OnCitizenAdded(Boid2D boid)
{
_citizensCount++;
boid.GetComponent <Health>().eventDied.AddListener(OnCitizenDied);
}
IEnumerable<Boid2D> FindInRadius(Vector2 center, float radius, Boid2D[] neighbors)
{
var sqrRadius = radius * radius;
foreach (var b in neighbors) {
if ((b.position - center).sqrMagnitude < sqrRadius)
yield return b;
}
}
public abstract Vector2 Steer(Boid2D boid);
Vector2 Separate(Boid2D me, Boid2D[] neighbors)
{
var v = Vector2.zero;
foreach (var f in FindInRadius(me.position, radiuses[INDEX_SEPARATE], neighbors)) {
var distvec = f.position - me.position;
v -= distvec;
}
return weights[INDEX_SEPARATE] * v;
}
public abstract IEnumerable <Collider2D> Select(Boid2D boid);
