void Update()
{
if (spawning == false)
{
return;
}
if (UEnemyDestroyedListener.NumberOfActiveEnemies == 0)
{
ActiveWave = waveProvider.Next();
if (ActiveWave == null)
{
enabled = false;
return;
}
StartCoroutine(StartNewWave());
spawning = false;
return;
}
RespawnCooldown -= Time.deltaTime;
if (RespawnCooldown < 0 && waveEnemiesToSpawn > 0)
{
SpawnEnemy();
RespawnCooldown = ActiveWave.RespawnTime;
waveEnemiesToSpawn--;
}
}
public static List <EnemyWave> ParseWaveFile(TextAsset waveFile)
{
waves = new List <EnemyWave>();
currentWave = new EnemyWave();
foreach (string l in waveFile.text.Split(new[] { "\n" }, StringSplitOptions.None))
{
string line = l.Trim().ToLower();
if (line.Length == 0 || line.StartsWith("//"))
{
continue;
}
if (line.StartsWith("---"))
{
FinishWave();
continue;
}
ParseLine(line);
}
FinishWave();
return(waves);
}
//7
private void UpdateActiveWave()
{
//1
if (activeWave != null)
{
spawnCounter += Time.deltaTime;
//2
if (spawnCounter >= activeWave.timeBetweenSpawnInSeconds)
{
spawnCounter = 0f;
//3
if (activeWave.listOfEnemies.Count != 0)
{
GameObject enemy = (GameObject)Instantiate(
activeWave.listOfEnemies[0], WayPointManager.Instance.
GetSpawnPosition(activeWave.pathIndex), Quaternion.identity);
//5
enemy.GetComponent <Enemy>().pathIndex = activeWave.pathIndex;
//6
activeWave.listOfEnemies.RemoveAt(0);
}
else
{
//7
activeWave = null;
//8
if (activatedWaves.Count == enemyWaves.Count)
{
//all waves are over
}
}
}
}
}
private void UpdateActiveWave()
{
if (activeWave != null)
{
spawnCounter += Time.deltaTime;
// when wave is over
if (spawnCounter >= activeWave.timeBetweenSpawnsInSeconds)
{
spawnCounter = 0f;
// if wave is not over
if (activeWave.listOfEnemies.Count != 0)
{
GameObject enemy = (GameObject)Instantiate(activeWave.listOfEnemies[0], WayPointManager.Instance.GetSpawnPosition(activeWave.pathIndex), Quaternion.identity);
enemy.GetComponent <Enemy>().pathIndex = activeWave.pathIndex;
activeWave.listOfEnemies.RemoveAt(0);
}
else
{
activeWave = null;
if (activatedWaves.Count == enemyWaves.Count)
{
GameManager.Instance.enemySpawningOver = true;
// All waves are over
}
}
}
}
}
public State(EnemyWave wave)
{
this.wave = wave;
index = 0;
Debug.Assert(wave.spawnSequences.Length > 0, "Empty wave!");
sequence = wave.spawnSequences[0].Begin();
}
private void OnCollisionEnter2D(Collision2D collision)
{
if (collision.gameObject.name == "EnemyShot")
{
EnemyWave enemy = collision.gameObject.GetComponent <EnemyWave>();
if (enemy.power > this.power)
{
enemy.power = enemy.power - this.power;
Destroy(gameObject);
}
else if (enemy.power < this.power)
{
this.power = this.power - enemy.power;
Destroy(collision.gameObject);
}
else if (enemy.power == this.power)
{
if (this.transform.position.x > 0)
{
}
}
}
else if (collision.gameObject.name == "PlayerShot")
{
}
else if (collision.gameObject.name == "right tower")
{
print("tower hit");
}
}
public void StopSpawning()
{
elapsedTime = 0;
spawnCounter = 0;
activeWave = null;
activatedWaves.Clear();
enabled = false;
}
private void loadNextWave(Object source, ElapsedEventArgs e)
{
waveNumber++;
//_enemies.Clear(); //Allow Overlapping Waves
EnemyWave newWave = waves.BuildWave(waveNumber, _content);
_enemies.AddRange(newWave.getAllEnemies());
}
private void Start()
{
currentWave = waves.First.Value;
spawning = true;
currentWave.type1Amount = Mathf.RoundToInt((float)currentWave.enemyAmount * currentWave.type1Ratio);
currentWave.type2Amount = Mathf.RoundToInt((float)currentWave.enemyAmount * currentWave.type2Ratio);
changeWave = false;
}
/*public Wave(List<EnemyWave> enemyWaves) {
* allMicroWaveInBigWave = enemyWaves;
* }*/
public Wave(WaveData miniWaves)
{
for (int i = 0; i < miniWaves.waves.Length; i++)
{
EnemyWave actualMiniWave = new EnemyWave(miniWaves.waves[i]);
allMicroWaveInBigWave.Add(actualMiniWave);
}
}
/* Prepare first wave. */
void Start()
{
nextWave = GetNextWave();
uiCanvas.UpdateNextWaveTypeText(nextWave);
StartCoroutine(StartNextWave(gameStartTimer));
audioManager = FindObjectOfType <AudioManager> ();
}
public void InitializeData(Enemy enemy, EnemyWave wave)
{
Enemy = enemy;
Wave = wave;
StatsPanel.SetActive(false);
StatsPanel.GetComponent <SpawnerTattle>().InitializeText(Enemy, Wave);
EnemyImage.sprite = enemy.BaseEnemy.GetComponent <SpriteRenderer>().sprite;
}
IEnumerator WaitTimeBetweenEnemies(EnemyWave wave)
{
for (int i = 0; i < wave.GetEnemiesNumber(); i++)
{
ChangeEnemySettings(wave.GetEnemyPrefab(), wave);
Instantiate(wave.GetEnemyPrefab(), spawnPostion, Quaternion.identity);
yield return(new WaitForSeconds(wave.GetTimeBetweenEnemiesSpawns()));
}
}
public GameScenario(int scenarioId)
{
waves = DataManager.GetConfig <SpawnWaveConfigWrapper>().GetByScenarioId(scenarioId);
ScenarioId = scenarioId;
if (waves.Count > 0)
{
currentWave = new EnemyWave(waves[0].Id);
}
}
public WaveSimulatorDamageStats SimulateDamageToEnemies(
EnemyDescription enemy,
WaveSolution solution,
float HandMissileFreqency,
float HandMissileDamantPctAverage,
int enemyCount,
bool invincible)
{
DamageStats = new WaveSimulatorDamageStats();
InvincibleEnemies = invincible;
float waveTime = 0.0F;
float timeDelta = 1.0F / 72.0F;
float previousHandMissileTime = 0.0f;
EnemyWave waveDesc = new EnemyWave();
waveDesc.Count = enemyCount;
waveDesc.Enemy = enemy.Name;
waveDesc.DifficultyMultiplier = 1.0F;
ResetLevelDescState(LevelDesc);
TurretManager turrets = new TurretManager(LevelDesc);
ProjectileManager projectiles = new ProjectileManager(LevelDesc, LevelManager.LookupProjectile);
WaveInstance wave = new WaveInstance(LevelDesc, waveDesc, enemy, 0.0F, SimulatorDamageCallback);
for (int i = 0; i < solution.Turrets.Count; i++)
{
turrets.AddTurret(LevelManager.LookupTurret(solution.Turrets[i].Name), solution.Turrets[i].pos, projectiles);
}
Debug.Log("----------------------------------------");
Debug.Log(" Wave of " + enemyCount + " " + enemy.Name + "s");
Debug.Log("----------------------------------------");
do
{
wave.Advance(waveTime);
projectiles.AdvanceAll(waveTime);
turrets.Fire(waveTime);
float timeSinceLastHandMissile = waveTime - previousHandMissileTime;
if (timeSinceLastHandMissile >= HandMissileFreqency)
{
// Real projectiles have to incur flight time but we'll simulate
// the damage as instanntaneous to keep it simple. Also real projectiles
// have blast radius that should hit multiple enemies. We'll just hit one.
}
waveTime += timeDelta;
} while (!wave.IsCompleted);
DamageStats.DamagePerEnemy = DamageStats.DamageDealt / enemyCount;
return(DamageStats);
}
void CallEnemyWave()
{
EnemyWave wave = GetComponentInParent <EnemyWave> ();
if (wave != null)
{
wave.DestoryEnemy(this);
}
}
private void initializeNextWave()
{
spawnTimer = 0;
currentNbrOfEnemiesPerWave = (int)Math.Round(currentNbrOfEnemiesPerWave * enemiesMultiplierPerWave, 0);
spawnIntervalMax -= spawnIntervalMaxReductionPerWave;
spawnIntervalMax = Math.Max(spawnIntervalMin, spawnIntervalMax);
currentWave = new EnemyWave(enemyPrefabs, currentNbrOfEnemiesPerWave, spawnIntervalMin, spawnIntervalMax);
waveIndex++;
}
//public GameObject deathEffect; // we can use this to make a death effect when he explodes
// Start is called before the first frame update
void Start()
{
if (transform.parent != null)
{
wave = transform.parent.GetComponent <EnemyWave>();
}
scoreManager = GameObject.Find("Main Camera").GetComponent <ScoreManager>();
sprite = GetComponent <SpriteRenderer>();
oldMaterial = sprite.material;
}
public void SpawnWave(EnemyWave wave)
{
spawnTime = 0;
int toSpawnCount = wave.toSpawn.Length;
for (int i = 0; i < wave.toSpawn.Length; i++)
{
toSpawn.Add(wave.toSpawn[i]);
}
}
private static void FinishWave()
{
if (currentWave.IsEmpty())
{
return;
}
waves.Add(currentWave);
currentWave = new EnemyWave();
}
// TODO This function can be moved out of this class.
private EnemyWave BuildNextWave(int enemyWaveCounter)
{
EnemyWave enemyWave = Instantiate(enemyWavePrefab);
for (int i = 0; i < 4; ++i)
{
enemyWave.enemeies.Add(BuildEnemyList(enemyTypeOne, 3 * enemyWaveCounter, enemySpawnerController.GetEnemmySpawner(i)));
}
return(enemyWave);
}
public void SpawnWave()
{
if (currentWave < GameManager.Instance.mapManager.currentMap.EnemyWaves.Length)
{
GameManager.Instance.towerManager.SetTowerToBuild(null);
currentlySpawningEnemies = true;
EnemyWave waveInfo = GameManager.Instance.mapManager.currentMap.EnemyWaves[currentWave];
StartCoroutine(RunWave(waveInfo));
currentWave++;
}
}
public void InstantiateWave()
{
wave = GameObject.Instantiate(enemyWave);
EnemyWave script = wave.GetComponent <EnemyWave> ();
if (script != null)
{
script.InitWave(this, enemiesSpeed);
enemiesSpeed += enemiesSpeedUp;
}
}
void Update()
{
internalTimer -= Time.deltaTime;
if (internalTimer <= 0f)
{
if (activeWave == null)
{
waveStart.PlayDelayed(0f);
activeWave = new EnemyWave(currentDifficulty, FocusPattern[currentFocus], enemyArray);
waveCounter++;
waveText.text = "WAVE " + waveCounter.ToString();
//waveText.CrossFadeAlpha(0.0f, 5f, true);
//waveText.CrossFadeAlpha(1.0f, 5f, false);
waveText.GetComponent <Animator>().SetTrigger("Play");
}
else
{
GameObject newEnemy = activeWave.spawnEnemy();
//newEnemy.transform.parent = transform;
int[] spawnedAt = new int[3];
for (int i = 0; i < spawnedAt.Length; i++)
{
spawnedAt[i] = -1;
}
int curSpawn = 0;
while (newEnemy != null)
{
int newSpawn = -1;
while (Array.IndexOf(spawnedAt, newSpawn) != -1)
{
newSpawn = UnityEngine.Random.Range(0, spawnLocations.Length);
}
spawnedAt[curSpawn] = newSpawn;
newEnemy.transform.position = spawnLocations[spawnedAt[curSpawn]];
newEnemy = activeWave.spawnEnemy();
curSpawn++;
}
}
if (!(activeWave.Update()))
{
activeWave = null;
internalTimer = TimeBetweenWaves;
currentDifficulty++;
currentFocus++;
if (currentFocus >= FocusPattern.Length)
{
currentFocus = 0;
}
}
}
enemyCount.SetEnemyCount(GetEnemiesRemaining());
}
public void SetEnemyWave(EnemyWave enemyWave)
{
this.enemyWave = enemyWave;
//set details for missile speed and spawn interval
timePerSpawn = enemyWave.timePerMissileSpawn;
speedMultiplier = enemyWave.missileSpeedMultiplier;
//play wave changed audio
audioSource.Play();
}
public void Initialize(Player playerScript, DifficultyManager difficultyManagerScript, BasicMove basicMoveScript,
Vector2 initialMoveDir, EnemyWave assignedWave = null)
{
_playerScript = playerScript;
_difficultyManagerScript = difficultyManagerScript;
SetNextFiringInterval();
_basicMoveScript = basicMoveScript;
_assignedEnemyWave = assignedWave;
InitialMoveDir = initialMoveDir;
SetMoveDir(initialMoveDir);
}
private IEnumerator CreatingEnemyWave(EnemyWave wave)
{
DeadEnemyCount = 0;
for (int i = 0; i < wave.EnemyIndexes.Length; i++)
{
yield return(new WaitForSeconds(EnenySpawnDelay));
CreateEnemy(EnemyPrefabs [wave.EnemyIndexes [i]]);
FindTargetForDefenders();
}
yield break;
}
WavePrefabEntry GetEnemyPrefabEntryForWave(EnemyWave wave)
{
foreach (WavePrefabEntry entry in wavePrefabEntries)
{
if (entry.waveType == wave.waveType)
{
return(entry);
}
}
return(null);
}
/// <summary>
/// Dequeues the next wave and starts it.
/// </summary>
void StartWave()
{
currentEnemyWave = enemyWaves.Dequeue();
//get the total number of enemies in that wave
//which will be decremented upon each enemy death
numEnemiesInCurrentWave = currentEnemyWave.GetTotalNumberOfEnemies();
//pass the wave to the enemy spawner
//for it to spawn
enemySpawner.SetSpawnPool(currentEnemyWave);
}
public Enemy(List <Texture2D> textures, int column, int speed, EnemyWave actualWave)
{
int x = 0, i = 0;
this.speed = speed;
Random r = new Random();
switch (actualWave)
{
case EnemyWave.First:
health = 25;
i = 0;
break;
case EnemyWave.Second:
health = 50;
i = r.Next(0, 2);
break;
case EnemyWave.Third:
health = 75;
i = r.Next(0, 3);
break;
case EnemyWave.Fourth:
health = 100;
i = r.Next(0, 4);
break;
case EnemyWave.Fifth:
health = 125;
i = r.Next(0, 5);
break;
}
texture = textures[i];
switch (column)
{
case 1:
x = 270;
break;
case 2:
x = 540;
break;
case 3:
x = 810;
break;
}
location = new Rectangle(x, -270, 270, 270);
}
void Awake()
{
enemyWaveGenerator = this;
}
