private void Update()
{
if (!isMainMenu)
{
time += Time.deltaTime;
if (time > secondsTillPredatorSpawns)
{
time = 0f;
SpawnNewPredator();
if (PredatorCount % 2 == 0)
{
FlockingAgent predator = Instantiate(ultraPredator);
predator.transform.position = FlockingAgent.WorldMin;
predator.GetComponent <FollowPlayer>().Speed = Random.Range(0.5f, 1.7f);
FlockManager.Instance.AddAgent(predator);
++PredatorCount;
}
if (FlockManager.Instance.FlockCount < 100)
{
GameObject go = Instantiate(prize);
go.transform.position = RandomInRectWorldPosition();
}
}
}
}
public void AddAgent(FlockingAgent agent)
{
if (!agents.Contains(agent))
{
agents.Add(agent);
}
}
Vector3 VectorFieldRule(FlockingAgent fa)
{
Vector3 v = Vector3.zero;
v = vecField.GetDirection(fa.transform.position);
return(v * vectorField);
}
void LimitVelocity(FlockingAgent fa)
{
if (fa.velocity.magnitude > velLimit)
{
fa.velocity = (fa.velocity / fa.velocity.magnitude) * velLimit;
}
}
public void RemoveAgent(FlockingAgent agent)
{
if (agents.Contains(agent))
{
agents.Remove(agent);
}
}
Vector3 PredatorRule(FlockingAgent fa)
{
if ((fa.transform.position - tPredator.position).sqrMagnitude < predatorDistance * predatorDistance)
{
return(-predator * (tPredator.position - fa.transform.position).normalized);
}
return(Vector3.zero);
}
public void AddAgent(FlockingAgent agent)
{
agent.name = key.ToString();
flock.Add(agent.name, agent);
++key;
++FlockCount;
}
public FlockingAgent CreateNewPrey()
{
FlockingAgent agent = Instantiate(prey);
agent.transform.position = RandomInRectWorldPosition();
FlockManager.Instance.AddAgent(agent);
return(agent);
}
public FlockingAgent SpawnNewPredator()
{
FlockingAgent agent = Instantiate(predator);
agent.transform.position = GetRandomCorner();
FlockManager.Instance.AddAgent(agent);
++PredatorCount;
return(agent);
}
public List <Collider2D> GetObstacles(FlockingAgent agent, float radius, LayerMask layerMask)
{
List <Collider2D> colliderList = new List <Collider2D>();
var colliders = Physics2D.OverlapCircleAll(agent.transform.position, radius, layerMask);
foreach (Collider2D c in colliders)
{
colliderList.Add(c);
}
return(colliderList);
}
public void IncreaseFlockSize()
{
for (int i = 0; i < increaseFlockByCount; ++i)
{
FlockingAgent agent = Instantiate(prey);
agent.transform.position = GameManager.RandomInRectWorldPosition();
agent.RandomizeWeights();
agent.GetComponent <CircleCollider2D>().enabled = false;
FlockManager.Instance.AddAgent(agent);
}
FlockSize += increaseFlockByCount;
}
public override void OnEnable()
{
base.OnEnable();
if (_vision == null)
{
_vision = agent.GetComponent <Vision>();
}
if (_vision.HasTargets)
{
target_Agent = _vision.targets[0].GetComponentInParent <FlockingAgent>();//_vision.targets.transforms[0].GetComponentInParent<FlockingAgent>();
}
}
public virtual void OnEnable()
{
if (agent == null)
{
agent = GetComponent <FlockingAgent>();
if (agent == null)
{
agent = GetComponentInParent <FlockingAgent>();
}
Debug.Assert(agent != null, "Flocking Agent Not Found.");
}
agent.OnUpdate.AddListener(Tick);
}
void Start()
{
MaxSpeedSquared = MaxSpeed * MaxSpeed;
NeighbourRadiusSquared = NeighbourRadius * NeighbourRadius;
AvoidanceRadiusSquared = NeighbourRadiusSquared * AgentAvoidanceRadiusMultiplier * AgentAvoidanceRadiusMultiplier;
for (int i = 0; i < StartingAgentCount; i++)
{
FlockingAgent newAgent = Instantiate(AgentPrefab, Random.insideUnitCircle * StartingAgentCount * AgentDensity,
Quaternion.Euler(Vector3.forward * Random.Range(0.0f, 360.0f)), transform);
newAgent.name = "Agent " + i;
Agents.Add(newAgent);
}
}
Vector3 AlignmentRule(FlockingAgent fa)
{
Vector3 v = Vector3.zero;
foreach (FlockingAgent item in flokingAgents)
{
if (item != fa)
{
v += item.velocity;
}
}
v /= (flokingAgents.Length - 1);
return(((v - fa.velocity) / 8) * alignment);
}
Vector3 CohesionRule(FlockingAgent fa)
{
Vector3 v = Vector3.zero;
foreach (FlockingAgent item in flokingAgents)
{
if (item != fa)
{
v += item.transform.position;
}
}
v = v / (flokingAgents.Length - 1);
return((v - fa.transform.position).normalized * cohesion);
}
private void OnTriggerEnter2D(Collider2D other)
{
if (other.tag.Equals(Tag.Player))
{
int amountToBeSpawned = Random.Range(50, 100);
for (int i = 0; i < amountToBeSpawned; ++i)
{
FlockingAgent agent = GameManager.Instance.CreateNewPrey();
agent.RandomizeWeights();
}
Destroy(gameObject);
}
}
protected override void OnEnable()
{
base.OnEnable();
if (agent == null)
{
agent = GetComponent <FlockingAgent>();
if (agent == null)
{
agent = GetComponentInParent <FlockingAgent>();
}
Debug.Assert(agent != null, "Flocking Agent Not Found.");
}
agent.OnUpdate.AddListener(Tick);
}
private static void CreateNewPreyFromPlayer(string id1, string id2)
{
FlockingAgent agent1 = FlockManager.Instance.Get(id1);
FlockingAgent agent2 = FlockManager.Instance.Get(id2);
if (agent1 == null || agent2 == null)
{
return;
}
FlockingAgent parentPrey;
FlockingAgent player;
if (agent1.tag.Equals(Tag.Prey, StringComparison.Ordinal))
{
parentPrey = agent1;
player = agent2;
}
else
{
parentPrey = agent2;
player = agent1;
}
if (touchedIds.Contains(parentPrey.name))
{
return;
}
if (touchedIds.Contains(player.name))
{
return;
}
((OnUpdateFlockingAgent)parentPrey).AgentMated();
FlockingAgent newAgent = UnityEngine.Object.Instantiate(parentPrey);
FlockManager.Instance.AddAgent(newAgent);
touchedIds.Add(player.name);
touchedIds.Add(newAgent.name);
touchedIds.Add(parentPrey.name);
GameManager.Instance.StartCoroutine(FreeAgentToMateAgain(player.name, playerMateCoolDown));
GameManager.Instance.StartCoroutine(FreeAgentToMateAgain(newAgent.name, playerMateCoolDown));
GameManager.Instance.StartCoroutine(FreeAgentToMateAgain(parentPrey.name, preyMateCoolDoown));
}
Vector3 SeparationRule(FlockingAgent fa)
{
Vector3 v = Vector3.zero;
foreach (FlockingAgent item in flokingAgents)
{
if (item != fa)
{
if ((item.transform.position - fa.transform.position).sqrMagnitude < separationDistance * separationDistance)
{
v -= (item.transform.position - fa.transform.position);
}
}
}
v.Normalize();
return(v * separation);
}
public List <Transform> GetEnemies(FlockingAgent agent, float radius)
{
List <Transform> enemiesFound = new List <Transform>();
foreach (var enemy in enemies)
{
if (enemy == agent)
{
continue;
}
if (Vector2.Distance(agent.transform.position, enemy.transform.position) <= radius)
{
enemiesFound.Add(enemy);
}
}
return(enemiesFound);
}
public List <FlockingAgent> GetNeighbors(FlockingAgent agent, float radius)
{
List <FlockingAgent> neighborsFound = new List <FlockingAgent>();
foreach (var otherAgent in agents)
{
if (otherAgent == agent)
{
continue;
}
if (Vector2.Distance(agent.transform.position, otherAgent.transform.position) <= radius)
{
neighborsFound.Add(otherAgent);
}
}
return(neighborsFound);
}
public List <FlockingAgent> GetAgentsInRadius(string id, float radius)
{
List <FlockingAgent> nearbyAgents = new List <FlockingAgent>();
Vector2 position = flock[id].transform.position;
foreach (KeyValuePair <string, FlockingAgent> kvp in flock)
{
if (kvp.Key.Equals(id))
{
continue;
}
FlockingAgent agent = kvp.Value;
if (Vector2.Distance(position, agent.transform.position) < radius)
{
nearbyAgents.Add(agent);
}
}
return(nearbyAgents);
}
public virtual BaseCharacter Init(int groupHandle, float agentDensity, Stat baseStat, BaseState idle, BaseState attack, BaseState move, BaseState death, BaseState chase = null)
{
m_animator = GetComponent <Animator>();
m_stateMethodDic.Add(ECharacterState.Idle, idle);
m_stateMethodDic.Add(ECharacterState.Attack, attack);
m_stateMethodDic.Add(ECharacterState.Move, move);
m_stateMethodDic.Add(ECharacterState.Death, death);
m_agroCollider = gameObject.AddComponent <CircleCollider2D>();
m_agroCollider.radius = 3;
m_agroCollider.isTrigger = true;
m_stat = new StatFunction(baseStat);
m_agent = new FlockingAgent(this, groupHandle, agentDensity);
CharacterMng.Instance.AddGroupMember(groupHandle, this);
m_astarAgent = gameObject.AddComponent <AStarAgent>();
return(this);
}
public static void Run(FlockingAgent child, OnUpdateFlockingAgent parent1, OnUpdateFlockingAgent parent2)
{
float[] parent1Weights = parent1.Weights;
float[] parent2Weights = parent2.Weights;
float[] parameters = new float[FlockingAgent.ParameterSpace];
float parent1Likelihood = (parent1.MatedCount + 1) / (float)(parent1.MatedCount + parent2.MatedCount + 2);
for (int i = 0; i < FlockingAgent.ParameterSpace; ++i)
{
float maxVal;
if (i == 0)
{
maxVal = parent1.MaxRadius;
}
else
{
maxVal = parent2.MaxWeight;
}
if (ShouldMutate)
{
parameters[i] = Random.Range(0f, maxVal);
}
else if (Random.Range(0f, 1f) < parent1Likelihood)
{
parameters[i] = parent1Weights[i];
}
else
{
parameters[i] = parent2Weights[i];
}
}
child.UpdateWeights(parameters);
}
Vector3 BoundBoxRule(FlockingAgent fa)
{
Vector3 v = Vector3.zero;
float Xmin = boundBox.bounds.min.x,
Xmax = boundBox.bounds.max.x,
Ymin = boundBox.bounds.min.y,
Ymax = boundBox.bounds.max.y,
Zmin = boundBox.bounds.min.z,
Zmax = boundBox.bounds.max.z;
if (fa.transform.position.x < Xmin)
{
v.x = boundBoxWeight;
}
else if (fa.transform.position.x > Xmax)
{
v.x = -boundBoxWeight;
}
if (fa.transform.position.y < Ymin)
{
v.y = boundBoxWeight;
}
else if (fa.transform.position.y > Ymax)
{
v.y = -boundBoxWeight;
}
if (fa.transform.position.z < Zmin)
{
v.z = boundBoxWeight;
}
else if (fa.transform.position.z > Zmax)
{
v.z = -boundBoxWeight;
}
return(v);
}
private static void CreateNewPreyFromPrey(string id1, string id2)
{
if (touchedIds.Contains(id1))
{
return;
}
if (touchedIds.Contains(id2))
{
return;
}
touchedIds.Add(id1);
touchedIds.Add(id2);
FlockingAgent agent1 = FlockManager.Instance.Get(id1);
FlockingAgent agent2 = FlockManager.Instance.Get(id2);
if (agent1 == null || agent2 == null)
{
return;
}
FlockingAgent newAgent = GameManager.Instance.CreateNewPrey();
Evolution.Run(newAgent, (OnUpdateFlockingAgent)agent1, (OnUpdateFlockingAgent)agent2);
newAgent.transform.position = new Vector3(
agent1.transform.position.x + UnityEngine.Random.Range(-1f, 1f),
agent1.transform.position.y + UnityEngine.Random.Range(-1f, 1f),
agent1.transform.position.z);
((OnUpdateFlockingAgent)agent1).AgentMated();
((OnUpdateFlockingAgent)agent2).AgentMated();
GameManager.Instance.StartCoroutine(FreeAgentToMateAgain(agent1.name, preyMateCoolDoown));
GameManager.Instance.StartCoroutine(FreeAgentToMateAgain(agent2.name, preyMateCoolDoown));
}
//Using an abstract class because i don't want to instansiate any behaviour in this script
public abstract Vector2 MovementCalculation(FlockingAgent agent, List <Transform> Neighbours, Flocking Flock);
Vector3 LeaderRule(FlockingAgent fa)
{
return((tLeader.position - fa.transform.position).normalized * leader);
}
Vector3 WindDirection(FlockingAgent fa)
{
return(wind.direction);
}
