public void SetNewNode(PheromoneNode oldNode, PheromoneNode newNode)
{
if (!oldNode || !newNode)
{
TrailDie();
return;
}
if (pHome == oldNode)
{
pHome = newNode;
}
if (pAway == oldNode)
{
pAway = newNode;
}
/* if (pHome == null || pAway == null)
* Debug.Log("f*****g nulls");
* if (gameObject == null || !drawTrail)
* Debug.Log("YOOO");*/
if (pHome != null && pAway != null)
{
drawTrail.Initialize(pHome.transform.position, pAway.transform.position);
}
}
void OnTriggerEnter2D(Collider2D coli)
{
PheromoneNode coliNode = coli.GetComponent <PheromoneNode>();
if (coliNode && coliNode != lastVisitedNode && !coliNode.initialRoot)
{
if (antMode == AntMode.Scout && coliNode.trails.Count >= 1)
{
DropPheromone();
//PheromoneManager.DropPheromone(lastVisitedNode, GetPherType(), transform.position);
}
ArriveAtNode(coliNode);
}
else if (coli.gameObject.GetComponent <DeadAntScript>() != null)
{
//Just touuched dead ant
takeDamage(GV.DMG_FROM_CORPSES * Time.deltaTime);
}
/*else if(coli.CompareTag("Ant"))
* {
*
* }
*/
}
public void OnMouseDown()
{
Vector2 clickPoint = Camera.main.ScreenToWorldPoint(Input.mousePosition);
RaycastHit2D[] hits = Physics2D.RaycastAll(clickPoint, Vector2.zero);
PheromoneNode clickedNode = null;
if (hits.Length != 0)
{
foreach (RaycastHit2D rhit in hits) //def better way of doing this, but debug function
{
if (rhit.transform.CompareTag("Node"))
{
clickedNode = rhit.collider.gameObject.GetComponent <PheromoneNode>();
}
}
}
if (clickedNode) //if not null
{
SetNewLastClicked(clickedNode);
}
else //otherwise make a new one
{
SetNewLastClicked(PheromoneManager.DropPheromone(lastClicked, GV.PhermoneTypes.Friendly, clickPoint));
}
foreach (PheromoneTrail pt in FindObjectsOfType <PheromoneTrail>())
{
pt.strength = 40;
}
}
public void Start()
{
PheromoneNode pn = gameObject.AddComponent <PheromoneNode>();
pn.InitializeNode(null);
pn.immortal = true;
}
public static bool PherTrailIsEqual(PheromoneTrail p1, PheromoneNode pn1, PheromoneNode pn2)
{
if ((p1.pHome == pn1 || p1.pHome == pn2) && (p1.pAway == pn1 || p1.pAway == pn2))
{
return(true);
}
return(false);
}
public void CreatePheromoneTrail(PheromoneNode home, PheromoneNode away, GV.PhermoneTypes pherType)
{
PheromoneTrail newPt = Instantiate <GameObject>(phermoneTrailPrefab).GetComponent <PheromoneTrail>();
newPt.GetComponent <DrawLineSprite>().Initialize(new Vector2(), new Vector2());
newPt.Initialize(home, away, pherType);
pheromoneTrails.Add(newPt);
}
private PheromoneNode RetrieveNewNode(GV.PhermoneTypes pherType, Vector2 spawnLocation)
{
GameObject newNodeGO = Instantiate(phermoneNodePrefab, spawnLocation, Quaternion.identity) as GameObject;
PheromoneNode newNode = newNodeGO.GetComponent <PheromoneNode>();
newNode.initialRoot = true;
pheromoneNodes.Add(newNode);
return(newNode);
}
private void SetNewLastClicked(PheromoneNode pn)
{
if (lastClicked)
{
lastClicked.GetComponent <SpriteRenderer>().color = Color.green;
}
pn.GetComponent <SpriteRenderer>().color = Color.red;
lastClicked = pn;
}
public void Initialize(PheromoneNode _home, PheromoneNode _away, GV.PhermoneTypes _pherType)
{
pherType = _pherType;
pHome = _home;
pAway = _away;
strength = GV.PHEROMONE_START_ENERGY;
if (pHome && pAway)
{
drawTrail.Initialize(pHome.transform.position, pAway.transform.position);
}
}
void OnCollisionStay2D(Collision2D coli)
{
if (coli.gameObject.CompareTag("Node"))
{
lastNode = coli.gameObject.GetComponent <PheromoneNode>();
}
else if (coli.gameObject.GetComponent <Ant>())
{
coli.gameObject.GetComponent <Ant>().takeDamage(GV.PLAYER_DMG * Time.deltaTime);
playerEnergy -= GV.PLAYER_DMG_TAKEN * Time.deltaTime;
}
}
PheromoneNode DropPheromoneOnExistingTrail(PheromoneTrail pt)
{
PheromoneNode pn = PheromoneManager.DropPheromone(lastVisitedNode, GetPherType(), transform.position);
if (lastVisitedNode)
{
lastVisitedNode.initialRoot = false;
}
lastVisitedNode = pn;
timeSinceLastEvent = 0;
//pt.SplitByNode(pn);
return(pn);
}
PheromoneNode DropPheromone(Transform foodLoc)
{
PheromoneNode pn = PheromoneManager.DropPheromone(lastVisitedNode, GetPherType(), foodLoc.position);
if (lastVisitedNode)
{
lastVisitedNode.initialRoot = false;
}
lastVisitedNode = pn;
timeSinceLastEvent = 0;
ArriveAtNode(pn);
return(pn);
}
void RightClick()
{
if (playerEnergy > GV.PLAYER_CLICK_E_COST)
{
bool bnsDmg = lastNode != null;
onTheMove = true;
goalLocation = GetMousePosition();
playerEnergy -= GV.PLAYER_CLICK_E_COST;
lastNode = PheromoneManager.DropPheromone(lastNode, GV.PhermoneTypes.Friendly, transform.position);
if (bnsDmg && lastNode.trails.Count > 0 && lastNode.trails[0] != null)
{
lastNode.trails[0].strength = (int)GV.PLAYER_PHER_START;
}
}
}
public static PheromoneNode DropPheromone(PheromoneNode parentNode, GV.PhermoneTypes pherType, Vector2 atPos)
{
List <PheromoneNode> allNearbyPher = GetAllNearbyByTag <PheromoneNode>("Node", GV.PHEROMONE_PLACEMENT_ABSORPTION_RADIUS, atPos);
if (allNearbyPher.Contains(parentNode) && !parentNode.immortal) //this means parent node will be consumed, so it cannot be a parent
{
parentNode = null;
}
PheromoneNode pn = FindObjectOfType <PheromoneManager>().CreateNewNode(parentNode, pherType, atPos);
foreach (PheromoneNode toMerge in allNearbyPher)
{
if (!toMerge.immortal && !toMerge.initialRoot)
{
pn.AbsorbNode(toMerge);
}
}
return(pn);
}
public PheromoneNode CreateNewNode(PheromoneNode parentNode, GV.PhermoneTypes pherType, Vector2 spawnLocation)
{
if (parentNode == null)
{
return(RetrieveNewNode(pherType, spawnLocation));
}
GameObject newNodeGO = Instantiate(phermoneNodePrefab, spawnLocation, Quaternion.identity) as GameObject;
GameObject newTrailGO = Instantiate <GameObject>(phermoneTrailPrefab);
PheromoneNode newNode = newNodeGO.GetComponent <PheromoneNode>();
PheromoneTrail newTrail = newTrailGO.GetComponent <PheromoneTrail>();
newTrail.Initialize(parentNode, newNode, pherType);
parentNode.AddTrail(newTrail);
parentNode.initialRoot = false;
newNode.InitializeNode(newTrail);
pheromoneNodes.Add(newNode);
pheromoneTrails.Add(newTrail);
return(newNode);
}
private void AbsorbTrails(PheromoneNode toAbsorb)
{
foreach (PheromoneTrail pt in toAbsorb.trails) //for each trail i will absorb
{
if (pt != null)
{
pt.SetNewNode(toAbsorb, this); //setup
PheromoneTrail trailToAbsorbTrail = PheromoneTrail.PherListContains(trails, pt);
if (!trailToAbsorbTrail)
{
trails.Add(pt);
}
else
{
trailToAbsorbTrail.strength += pt.strength;
//pt.TrailDie();
pt.SetNewNode(null, null); //since it already exist, and we dont need it, delete it.
}
}
}
}
public void SplitByNode(PheromoneNode newNode)
{
FindObjectOfType <PheromoneManager>().CreatePheromoneTrail(pHome, newNode, pherType);
pHome = newNode;
drawTrail.Initialize(pHome.transform.position, pAway.transform.position);
}
public PheromoneNode AbsorbNode(PheromoneNode toMerge)
{
AbsorbTrails(toMerge);
FindObjectOfType <PheromoneManager>().DeleteNode(toMerge);
return(this);
}
public void DeleteNode(PheromoneNode pn)
{
pheromoneNodes.Remove(pn);
GameObject.Destroy(pn.gameObject);
}
public PheromoneNode GetOtherNode(PheromoneNode otherNode)
{
return((otherNode == pHome) ? pAway : pHome);
}
void ArriveAtNode(PheromoneNode pn)
{
if (lastVisitedNode)
{
lastVisitedNode.initialRoot = false;
}
int workingBackTrack = backtrackWeight;
if (currentTrail) //since might get deleted during
{
if (holding != null && !holding.isZero())
{
currentTrail.strength += GV.BASE_PHER_STRENTH * GV.HOLDING_RES_PHER_MULTIPLIER;
}
else
{
currentTrail.strength += GV.BASE_PHER_STRENTH;
}
}
else
{
workingBackTrack = 0;
}
int totalWeight = pn.GetTotalPhermoneWeights(currentTrail) + scoutingWeight + workingBackTrack;
int randomResult = Random.Range(1, totalWeight + 1);
PheromoneTrail isBackTrackTrail = currentTrail;
if (hasBackTracked)
{
PheromoneTrail tempTrail = pn.SelectNewTrailByWeight(randomResult, currentTrail, workingBackTrack);
currentTrail = pn.SelectNewTrailByWeight(randomResult, currentTrail, workingBackTrack);
if (currentTrail == null || currentTrail.strength > tempTrail.strength)
{
currentTrail = tempTrail;
}
hasBackTracked = false;
}
else
{
currentTrail = pn.SelectNewTrailByWeight(randomResult, currentTrail, workingBackTrack);
}
if (currentTrail != null && isBackTrackTrail != null && isBackTrackTrail == currentTrail)
{
hasBackTracked = !hasBackTracked;
}
lastVisitedNode = pn;
if (currentTrail)
{
if (currentTrail.GetOtherNode(pn) == null)
{
currentTrail.TrailDie();
}
else
{
goalSpot = currentTrail.GetOtherNode(pn).transform.position;
antMode = AntMode.Forage;
}
}
else
{
ScoutModeActivate();
}
}
