// ===================================================================
// Methods
// ===================================================================
// Use this for initialization
private void Start()
{
// Init the a parent game object for all created projectile objects.
this.projectileParent = GameObject.Find(Shooter.PROJECTILES);
if (!this.projectileParent)
{
this.projectileParent = new GameObject(Shooter.PROJECTILES);
}
// Get the Gun object.
this.gun = gameObject.GetComponentInChildren <Gun>();
// Init the Animator.
this.animator = this.GetComponent <Animator>();
this.animator.SetBool(Shooter.IS_ATTACKING_NAME, false);
// Get Spawners parent, containing all the scene's AttackerSpawners..
this.spawnersParent = GameObject.Find(Shooter.SPAWNERS);
// Init shooter co-ords
this.defenderSnappedYPosition = Mathf.RoundToInt(this.transform.position.y);
this.defenderXPosition = this.transform.position.x;
// Get this lane's AttackerSpawner, throw error if one can't be found
this.laneSpawner = this.GetThisLaneSpawner();
}
private void SetLaneSpawner()
{
AttackerSpawner[] spawners = FindObjectsOfType <AttackerSpawner>();
foreach (AttackerSpawner spawner in spawners)
{
bool IsCloseEnough =
(Mathf.Abs(spawner.transform.position.y - transform.position.y) <=
Mathf.Epsilon); // find its lane's spawner
bool IsUpperCloseEnough =
(Mathf.Abs(spawner.transform.position.y - (transform.position.y + 1)) <=
Mathf.Epsilon); // find its upper lane's spawner
bool IsLowerCloseEnough =
(Mathf.Abs(spawner.transform.position.y - (transform.position.y - 1)) <=
Mathf.Epsilon); // find its lower lane's spawner
if (IsCloseEnough)
{
myLaneSpawner = spawner;
}
else if (IsUpperCloseEnough)
{
myUpperLaneSpawner = spawner;
}
else if (IsLowerCloseEnough)
{
myLowerLaneSpawner = spawner;
}
}
}
/// <summary>Sets the spawner in a defenders lane</summary>
/// <br />
/// <remarks>If a defender and a spawner have the same y value for their transform they are in the same lane</remarks>
private void SetLaneSpawner()
{
AttackerSpawner[] attackerSpawners = FindObjectsOfType <AttackerSpawner>();
foreach (AttackerSpawner attackerSpawner in attackerSpawners)
{
#region SETLANESPAWNER LONG COMMENT
// This is so the Cactus (shooter) knows if there's an attacker on his lane.
// If the spawner and defender are on the same lane, that means their Y axis is 0.
// We don't use 0 here because computers love messing up with numbers so we use
// "Mathf.Episolon" which means: smallest number found.
// (Mathf.Abs()) is for when you don't want a negative number, it will make it positive (absolute).
#endregion
bool isCloseEnough = (Mathf.Abs(attackerSpawner.transform.position.y - transform.position.y) <= Mathf.Epsilon);
// If I look in the array and find someone who's on the same Y axis...
if (isCloseEnough)
{
// Then I'll consider it "my spawner" and I can apply some methods on him only and not mess with the others.
myLaneSpawner = attackerSpawner;
}
}
}
void Start()
{
announcementText.enabled = false;
attackerSpawner = FindObjectOfType <AttackerSpawner>();
prepTime = attackerSpawner.GetPreparationTime();
levelDuration = prepTime + spawnDuration;
levelFinished = false;
timerSlider = GetComponent <Slider>();
timerSlider.value = Time.timeSinceLevelLoad / levelDuration;
nextAttackerTierUpdate = Time.timeSinceLevelLoad
+ attackerTierUpPeriod
+ prepTime;
StartCoroutine(Announce("Place your defenders", announcementDelay));
StartCoroutine(
DelayedAnnounce(
"Attackers incoming",
prepTime,
announcementDelay
)
);
}
private void Awake()
{
spawner = FindObjectOfType <AttackerSpawner>();
anim = GetComponent <Animator>();
levelController = FindObjectOfType <LevelController>();
SetSpawnLines();
}
private void StoreAttackerSpawnerIfOnCurrentLane(AttackerSpawner attackerSpawner)
{
bool isSpawnerCloseEnough = (Mathf.Abs(attackerSpawner.transform.position.y - transform.position.y) <= Mathf.Epsilon);
if (isSpawnerCloseEnough)
{
laneAttackerSpawner = attackerSpawner;
}
}
private void SetAttackerSpawmer()
{
var defender = GetComponent <Defender>();
line = defender.Line;
var attackerSpawners = FindObjectsOfType <AttackerSpawner>();
attackerSpawner = attackerSpawners.First(spawner => spawner.Line == line);
}
void SetMyLaneSpaner()
{
foreach (AttackerSpawner i in GameObject.FindObjectsOfType <AttackerSpawner>())
{
if (i.transform.position.y == transform.position.y)
{
myLaneSpawner = i;
}
}
}
private void SetLaneSpawner()
{
AttackerSpawner[] spawners = FindObjectsOfType <AttackerSpawner>();
foreach (AttackerSpawner spawner in spawners)
{
if (Mathf.Abs(spawner.transform.position.y - transform.position.y) <= Mathf.Epsilon)
{
myLaneSpawner = spawner;
}
}
}
private void Awake()
{
if (!instance)
{
instance = this;
}
else
{
Destroy(gameObject);
}
}
// Look through all spawners, and set thisRowSpawner if found
void FindThisRowSpawner()
{
AttackerSpawner[] spawners = GameObject.FindObjectsOfType<AttackerSpawner>();
foreach (AttackerSpawner spawner in spawners) {
if (transform.position.y == spawner.transform.position.y) {
thisRowSpawner = spawner;
return;
}
}
Debug.LogError (name + " can't find spawner in lane " + transform.position.y);
}
private void SetLaneSpawner()
{
AttackerSpawner[] spawners = FindObjectsOfType <AttackerSpawner>();
foreach (AttackerSpawner spawner in spawners)
{
if (GetComponent <Defender>().GetLaneNumber() == spawner.GetLaneNumber())
{
myLaneSpawner = spawner;
}
}
}
private void SetLaneSpawner()
{
AttackerSpawner[] spawners = GameObject.FindObjectsOfType <AttackerSpawner>();
foreach (AttackerSpawner curSpawner in spawners)
{
if (curSpawner.transform.position.y == gameObject.transform.position.y)
{
m_spawnerInLane = curSpawner;
return;
}
}
}
private void SetLaneSpawner()
{
spawners = FindObjectsOfType <AttackerSpawner>();
foreach (var spawner in spawners)
{
//is spawner and game object (defender) in same lane?
if (transform.position.y == Mathf.Floor(spawner.transform.position.y))
{
myLaneSpawner = spawner;
}
}
}
private void SetLaneSpawner()
{
AttackerSpawner[] attackerSpawners = FindObjectsOfType <AttackerSpawner>();
foreach (AttackerSpawner attackerSpawner in attackerSpawners)
{
bool IsCloseEnough = (Mathf.Abs(attackerSpawner.transform.position.y - transform.position.y) <= Mathf.Epsilon);
if (IsCloseEnough)
{
myLaneSpawner = attackerSpawner;
}
}
}
private void SetLaneSpawner()
{
AttackerSpawner[] spawners = FindObjectsOfType <AttackerSpawner>();
foreach (var spawner in spawners)
{
bool IsCloseEnough = (spawner.transform.position.y - transform.position.y == 0);
if (IsCloseEnough)
{
attackerSpawner = spawner;
}
}
}
void SetMyLaneSpawner()
{
AttackerSpawner[] allSpawner = GameObject.FindObjectsOfType <AttackerSpawner> ();
foreach (AttackerSpawner spawner in allSpawner)
{
if (spawner.transform.position.y == transform.position.y)
{
myLaneSpawner = spawner;
return;
}
}
}
private void SetLaneSpawner()
{
AttackerSpawner[] attackerSpawners = FindObjectsOfType <AttackerSpawner>();
foreach (AttackerSpawner spawner in attackerSpawners)
{
if (myLane == spawner.GetLane())
{
myLaneSpawner = spawner;
}
}
}
private void SetMyLaneSpawner()
{
var spawners = FindObjectsOfType <AttackerSpawner>();
foreach (var spawner in spawners)
{
if ((int)spawner.gameObject.transform.position.y == (int)gameObject.transform.position.y)
{
_myLaneAttackerSpawner = spawner;
}
}
}
private void setLaneSpawner()
{
AttackerSpawner[] spawners = FindObjectsOfType <AttackerSpawner>();
foreach (var item in spawners)
{
bool IsCloseEnough = (Mathf.Abs(item.transform.position.y - transform.position.y) <= Mathf.Epsilon);
if (IsCloseEnough)
{
myLaneSpawner = item;
}
}
}
private void SetAttackerSpawner()
{
AttackerSpawner[] attackerSpawners = FindObjectsOfType <AttackerSpawner>();
foreach (AttackerSpawner attackerSpawner in attackerSpawners)
{
bool isAligned = Mathf.Abs(this.transform.position.y - attackerSpawner.transform.position.y) <= Mathf.Epsilon;
if (isAligned)
{
alignedAttackerSpawner = attackerSpawner;
}
}
}
private void SetLaneSpawner()
{
AttackerSpawner[] spawners = FindObjectsOfType <AttackerSpawner>();
foreach (AttackerSpawner spawner in spawners)
{
bool isCloseEnough = (spawner.transform.position.y - transform.position.y <= Mathf.Epsilon);
if (isCloseEnough)
{
myLaneSpawner = spawner;
}
}
}
public void SetLaneSpawner()
{
AttackerSpawner[] attackerSpawners = FindObjectsOfType <AttackerSpawner>();
foreach (AttackerSpawner spawner in attackerSpawners)
{
bool isCloseEnough = (Mathf.Abs(spawner.transform.position.y - transform.position.y)) <= Mathf.Epsilon;
if (isCloseEnough)
{
myLaneSpawner = spawner;
}
}
}
//Look through all spawners and find the one in my lane
void SetMyLaneSpawner()
{
AttackerSpawner[] attackSpawnersArray = FindObjectsOfType <AttackerSpawner>();
foreach (AttackerSpawner thisSpawner in attackSpawnersArray)
{
if (thisSpawner.transform.position.y == gameObject.transform.position.y)
{
mySpawner = thisSpawner;
return;
}
}
}
void setLaneSpawner()
{
GameObject spawnerParent = GameObject.Find("Spawners");
foreach (AttackerSpawner spawner in spawnerParent.GetComponentsInChildren <AttackerSpawner>())
{
if (spawner.transform.position.y == gameObject.transform.position.y)
{
laneSpawner = spawner;
break;
}
}
}
private void FindSpawnerInLane()
{
AttackerSpawner[] attackerSpawners = GameObject.FindObjectsOfType <AttackerSpawner>();
foreach (AttackerSpawner spawner in attackerSpawners)
{
if (spawner.transform.position.y == gameObject.transform.position.y)
{
attackerSpawner = spawner;
return;
}
}
Debug.Log("No spawner found in lane");
}
// Look through all spawners, and set thisRowSpawner if found
void FindThisRowSpawner()
{
AttackerSpawner[] spawners = GameObject.FindObjectsOfType <AttackerSpawner>();
foreach (AttackerSpawner spawner in spawners)
{
if (transform.position.y == spawner.transform.position.y)
{
thisRowSpawner = spawner;
return;
}
}
Debug.LogError(name + " can't find spawner in lane " + transform.position.y);
}
private void SetLaneSpawner()
{
var spawners = FindObjectsOfType <AttackerSpawner>();
foreach (var spawner in spawners)
{
var isCloseEnough = (Mathf.Abs(spawner.transform.position.y - transform.position.y) <= Mathf.Epsilon);
if (isCloseEnough)
{
_myLaneSpawner = spawner;
}
}
}
private void SetLaneSpawner()
{
// figures out what lane the shooter is in by using the attacker spawners
AttackerSpawner[] attackerSpawners = FindObjectsOfType <AttackerSpawner>();
foreach (AttackerSpawner spawner in attackerSpawners)
{
bool IsCloseEnough = Mathf.Abs(spawner.transform.position.y - transform.position.y) <= Mathf.Epsilon;
if (IsCloseEnough)
{
myLaneSpawner = spawner;
}
}
}
private void SetLaneSpawner()
{
AttackerSpawner[] spawners = FindObjectsOfType <AttackerSpawner>();
foreach (AttackerSpawner spawner in spawners)
{
bool IsClosedEnough = Mathf.Abs(spawner.transform.position.y - transform.position.y) <= .5f;
if (IsClosedEnough)
{
myLaneSpawner = spawner;
}
}
}
void FindItsSpawner()
{
AttackerSpawner[] spawnArray = FindObjectsOfType <AttackerSpawner>();
foreach (AttackerSpawner spawner in spawnArray)
{
if (spawner.transform.position.y == transform.position.y)
{
attackerSpawner = spawner;
return;
}
}
Debug.LogError(name + " can't find its corresponding attacker spawner.");
}
