public void CheckForFinishedWave()
{
if (spawnerState == SpawnerState.WaitingForFinish && EnemiesList.List.Count == 0)
{
spawnerState = SpawnerState.Counting;
}
}
void BegingNextWave()
{
// Debug.Log("Wave Completed");
state = SpawnerState.COUNTING;
nextWaveCountdown = waveDelay;
if (waveNumber + 1 >= waves.Length)
{
if (toLoop)
{
waveNumber = 0;
Debug.Log("Looping through the waves again");
}
else
{
state = SpawnerState.WAITING;
return;
}
// check if all the waves are done for and add code to loop the waves
}
else
{
waveNumber++;
}
}
IEnumerator Spawn()
{
// Delay inicial
state = SpawnerState.InitialDelay;
yield return(new WaitForSecondsRealtime(initialDelay));
state = SpawnerState.Spawning;
GameObject spanwnedObject;
for (currentWave = 0; currentWave < waves.Length; currentWave++)
{
for (int o = 0; o < waves[currentWave].waveObject.amount; o++)
{
spanwnedObject = Instantiate(waves[currentWave].waveObject.objectToSpawn);
spanwnedObject.transform.position = transform.position;
// Intervalo entre objetos de uma Wave
if (o < waves[currentWave].waveObject.amount - 1)
{
yield return(new WaitForSecondsRealtime(waves[currentWave].intervalBetweenObjects));
}
}
// Intervalo entre Waves
yield return(new WaitForSecondsRealtime(intervalBetweenWaves));
}
if (loop)
{
StartSpawn();
}
else
{
state = SpawnerState.Ended;
}
}
private void LateUpdate()
{
if (keyEnemy == null & isKeyEnemySpawned)
{
state = SpawnerState.onEnd;
}
}
private void StartWave(int index)
{
_wave = WaveData.Waves[index];
_waveIndex = index;
_startTimer = _wave.Delay;
WaveText.text = "WAVE " + (index + 1);
AmtText.text = _wave.Amount.ToString();
FreqText.text = string.Format("@ {0:F1}/s", _wave.Frequency);
TimerImage.fillAmount = 1;
_waveDuration = _wave.Amount / _wave.Frequency;
var times = new List <float>();
for (var i = 0; i < _wave.Amount; ++i)
{
times.Add(Random.Range(0, _waveDuration));
}
times.Sort();
_spawnTimes = new Queue <float>(times);
State = SpawnerState.Waiting;
WaveUiContainer.transform.localScale = Vector3.zero;
WaveUiContainer.transform.DOScale(_waveScale, 1)
.SetEase(Ease.OutCubic);
}
/// <summary>
/// Handles the finished wave, sets the round to the next one, if it's last, finish the game
/// #COMPLETE THIS (GAMEMASTER SCRIPT - Update() {if round > maxround) win the game
/// </summary>
void WaveCompleted()
{
state = SpawnerState.COUNTDOWN;
Debug.Log("WaveSpawner state: " + state);
GameMaster.waveCountdown = GameMaster.ammountOfTimeBetweenWaves;
if (GameMaster.Round < GameMaster.MaxRound)
{
GameMaster.Round++;
GameMaster.waveCountdown = GameMaster.ammountOfTimeBetweenWaves;
if (GameMaster.Round == GameMaster.MaxRound)
{
Debug.Log("Last round completed! GG");
}
else
{
Debug.Log("Wave completed, setting the game round to the : " + GameMaster.Round);
}
}
if (!IsAnyAttackerAlive())
{
if (GameMaster.Round == GameMaster.MaxRound)
{
state = SpawnerState.FINISHED;
Debug.Log("WaveSpawner state: " + state);
}
}
}
private void FixedUpdate()
{
switch (state)
{
case SpawnerState.onActive:
if (!enemySpawnList[curIndex].isSpawnIntervalOut())
{
enemySpawnList[curIndex].countSpawnInterval(Time.fixedDeltaTime);
}
else
{
if (curIndex != keyEnemyIndex)
{
Instantiate(enemyPool[enemySpawnList[curIndex].enemy])
.GetComponent <Enemy_EnemyStraightLineRouter>().setRoute(enemyRouteJsonPool[enemySpawnList[curIndex].route]);;
}
else
{
keyEnemy = Instantiate(enemyPool[enemySpawnList[curIndex].enemy]);
keyEnemy.GetComponent <Enemy_EnemyStraightLineRouter>().setRoute(enemyRouteJsonPool[enemySpawnList[curIndex].route]);
isKeyEnemySpawned = true;
}
curIndex += 1;
if (curIndex >= enemySpawnList.Length)
{
state = SpawnerState.onEnd;
}
}
break;
case SpawnerState.onEnd:
break;
}
}
IEnumerator SpawnWave(Waves _wave)
{
state = SpawnerState.spawning;
int count;
float rate;
foreach (WaveBurst enemy in _wave.burst)
{
count = enemy.count;
if (count == 0)
{
count = Random.Range(1, 10);
}
rate = enemy.rate;
if (rate == 0)
{
rate = Random.Range(1, 5);
}
for (int i = 0; i < count; i++)
{
SpawnEnemy(enemy.enemyType);
yield return(new WaitForSeconds(1f / rate));
}
}
state = SpawnerState.waiting;
yield break;
}
/// <inheritdoc />
protected override void NotifyStateSwitch(SpawnerState newState)
{
if (newState != SpawnerState.Active)
{
hasBursted = false;
}
}
public void Spawner()
{
switch (spawnerState)
{
case SpawnerState.Spawning:
{
SpawnNextWave();
break;
}
case SpawnerState.WaitingForFinish:
{
CheckForFinishedWave();
break;
}
case SpawnerState.Counting:
{
WaveCountDown();
break;
}
case SpawnerState.Finished:
{
if (waves.Count > 0)
{
spawnerState = SpawnerState.Counting;
}
break;
}
default:
break;
}
}
public void SpawnNextWave()
{
if (spawnerState == SpawnerState.Spawning)
{
if (waves.Count < 1)
{
print("No more waves to spawn!");
spawnerState = SpawnerState.Finished;
return;
}
Wave waveToSpawn = waves[0];
if (waveToSpawn.segments.Count < 1)
{
print("No wave segments to spawn!");
return;
}
foreach (var segment in waveToSpawn.segments)
{
if (segment.enemyToSpawn != null)
{
for (int i = 0; i < segment.NumberOfEnemies; i++)
{
SpawnEnemy(segment.enemyToSpawn, segment.EnemyLevel);
}
}
}
currentWaveDelayTime = 0;
spawnerState = SpawnerState.WaitingForFinish;
waves.RemoveAt(0);
}
}
IEnumerator NewWave()
{
state = SpawnerState.Counting; // We are counting down to the next wave
count++; // Increment the current wave number
Events.NewWave(count, countdown); // Trigger new wave event to display the subscribed UI
yield return(new WaitForSeconds(countdown));
state = SpawnerState.Spawning; // We are spawning enemies into the scene
// Loop through wave count and spawn enemies e.g. If wave number is 5, spawn 13 enemies
for (int i = 0; i < count * 2.5f; i++)
{
yield return(StartCoroutine(Spawn(zombie, zombieFast))); // Spawn an enemy
if (i < count - 1)
{
yield return(new WaitForSeconds(spawnDelay)); // Wait before spawning next enemy
}
}
state = SpawnerState.Waiting; // We are waiting for the player to kill the enemies
countdown = waveInterval; // Reset the wave countdown
yield break;
}
public void Reset()
{
m_WavesCounter = 0;
m_TimeUntilNextEnemy = 0.0f;
m_NumEnemies = 0;
m_LastFibonacciIndex = 1;
m_State = SpawnerState.WAITING;
}
private void StartSpawning()
{
State = SpawnerState.Spawning;
_startTimer = 0;
_spawnTimer = 0;
WaveUiContainer.transform.DOScale(0, 1)
.SetEase(Ease.InCubic);
}
// Use this for initialization
void Start()
{
if (ConnectionManager.IsOwner)
{
enemyMaxId = GameManager.Instance.MaxPlayerNum;
isOwner = true;
State = SpawnerState.Update;
}
}
public void SpawnEnemies()
{
if (spawerState == SpawnerState.Spawning)
{
return;
}
spawerState = SpawnerState.Spawning;
Observable.FromCoroutine(KeepSpawning).Subscribe(_ => spawerState = SpawnerState.Idle);
}
// Start is called before the first frame update
void Start()
{
EnemiesAlive = new List <GameObject>();
numberOfEnemiesAlive = 0;
//pool
PoolEnemies();
waveCountdown = timeBetweenWaves;
state = SpawnerState.counting;
//WavesLeft();
}
// Use this for initialization
void Start()
{
m_Transform = transform;
m_LastFibonacciIndex = 1;
m_TimeUntilNextOrder = m_TimeBetweenOrders;
MAX_FIBONAZZI = 7;
m_NextTargetPosition = GetNextTargetPoint();
m_State = SpawnerState.WAITING;
m_NumEnemies = 0;
m_TimeUntilNextEnemy = 0.0f;
}
// Use this for initialization
void Start()
{
m_Transform = transform;
m_LastFibonacciIndex = 1;
m_TimeUntilNextOrder = GenerateTimeForNextOrder();
MAX_FIBONAZZI = 7;
m_NextTargetPosition = GetNextTargetPoint();
m_State = SpawnerState.WAITING;
m_NumEnemies = 0;
m_TimeUntilNextEnemy = 0.0f;
m_WavesCounter = 0;
}
// Update is called once per frame
void Update()
{
m_TimeUntilNextOrder -= Time.deltaTime;
switch (m_State)
{
case SpawnerState.WAITING:
if (m_TimeUntilNextOrder <= 0)
{
m_State = SpawnerState.STARTING_SPAWN;
}
break;
case SpawnerState.STARTING_SPAWN:
m_NumEnemies = Fibonacci(m_LastFibonacciIndex);
m_NumEnemies = Mathf.Min(m_NumEnemies, m_MaxEnemiesOrder);
if (m_NumEnemies != -1)
{
m_State = SpawnerState.SPAWNING;
}
break;
case SpawnerState.SPAWNING:
m_TimeUntilNextEnemy -= Time.deltaTime;
if (m_TimeUntilNextEnemy <= 0.0f)
{
CreateEnemy();
m_NumEnemies--;
if (m_NumEnemies <= 0)
{
m_State = SpawnerState.SPAWNING_END;
}
m_TimeUntilNextEnemy = 1.0f;
}
break;
case SpawnerState.SPAWNING_END:
m_WavesCounter++;
if (m_LastFibonacciIndex < MAX_FIBONAZZI)
{
m_LastFibonacciIndex++;
}
ResetTimeUntilNextOrder();
m_NextTargetPosition = GetNextTargetPoint();
m_State = SpawnerState.WAITING;
break;
default:
break;
}
}
// spawner
IEnumerator SpawnWave(int _enemyCount)
{ // change state
state = SpawnerState.SPAWING;
// spawn enemies till the requered amount is spawned
for (int i = 0; i < _enemyCount; i++)
{
SpawnEnemy();
yield return(new WaitForSeconds(enemySpawnDelay));
}
// when all enemeis spawned change to wait state
state = SpawnerState.WAITING;
yield break;
}
// Update is called once per frame
void Update()
{
if (isOwner)
{
if (State == SpawnerState.Update)
{
Spawn();
State = SpawnerState.Standby;
}
}
}
public void WaveCountDown()
{
if (spawnerState == SpawnerState.Counting)
{
if (currentWaveDelayTime < WaveDelayTime)
{
currentWaveDelayTime += Time.deltaTime;
}
else
{
spawnerState = SpawnerState.Spawning;
}
}
}
//spawns next wave of enemies
IEnumerator SpawnWave(Wave _wave)
{
Debug.Log("Spawning Wave " + _wave.name);
state = SpawnerState.Spawning;
for (int i = 0; i < _wave.count; i++)
{
//spawns enemies
SpawnEnemy(_wave.enemy);
yield return(new WaitForSeconds(1f / _wave.rate));
}
//once all enemies spawn state changes to waiting
state = SpawnerState.Waiting;
yield break;
}
/// <summary>
/// Changes the spawners internal state (active, rest, etc.) to a new value.
/// </summary>
/// <param name="newState">The new state</param>
private void SwitchToState(SpawnerState newState)
{
state = newState;
if (state == SpawnerState.Active)
{
stateDuration = duration.X + (duration.Y - duration.X) * NextFloat();
}
else
if (state == SpawnerState.Rest)
{
stateDuration = delay.X + (delay.Y - delay.X) * NextFloat();
}
else
{
stateDuration = 10f;
}
}
IEnumerator SpawnWave(EnemyWave wave)
{
Debug.Log("Spawning Wave" + wave.name);
state = SpawnerState.SPAWNING;
foreach (EnemyType enemyToSpawn in wave.enemiesInTheWave)
{
for (int i = 1; i <= enemyToSpawn.count; i++)
{
SpawnEnemy(enemyToSpawn.enemyPrefab.GetComponent <EnemyAI>());
yield return(new WaitForSeconds(wave.spawnDelay));
}
}
timeAtWhichWaveSpawned = Time.time;
state = SpawnerState.WAITING; // wait until all the enemies die
yield break;
}
public void SetSpawnerState(SpawnerState state)
{
switch (state)
{
case SpawnerState.ON:
if (spawningCoroutine == null)
{
spawningCoroutine = StartCoroutine(SpawnObjects());
}
break;
case SpawnerState.OFF:
if (spawningCoroutine != null)
{
StopCoroutine(spawningCoroutine);
}
break;
}
}
void WaveFinished()
{
Debug.Log("Wave done");
state = SpawnerState.Counting;
waveCountdown = timeBetween;
//if next wave is at the end of the array
if (nextWave + 1 > waves.Length - 1)
{
nextWave = 0;// try remove this and see if it stops waves from looping
Debug.Log("All waves complete");
//add endstate
}
else
{
//increments nextWave to the next wave in the array
nextWave++;
}
}
void WaveCompleted()
{
Debug.Log("Wave Completed!");
if (nextWave + 1 > waves.Length - 1)
{
enabled = false;
if (!GameManager.GameIsOver)
{
Debug.Log("currently disabled");
GameManager.instance.Winning();
}
}
else
{
state = SpawnerState.counting;
waveCountdown = timeBetweenWaves;
nextWave++;
//WavesLeft();
}
}
private void Update()
{ // if waiting for player to kill all enemies
if (state == SpawnerState.WAITING)
{ // check if there is alive enemies..
if (!IsEnemyAlive())
{ // ..and if is change state to next wave countdown
state = SpawnerState.COUNTING;
waveCountDown = waveSpawnDelay;
} // .. if enemies still alive exit code
else
{
return;
}
}
// if it is time to spawn ne wave
if (waveCountDown <= 0)
{
// if spawner isn`t spawning already
if (state != SpawnerState.SPAWING)
{
if (waveCounter == 0)
{
GameMaster.ui.SetWaveClearText("WAVE CLEAR");
}
waveCounter++; // inc wave number
enemyCount += waveCounter; // increase enemy count in wave
GameMaster.ui.SetWaveNumber(waveCounter); // update wave number in ui
StartCoroutine(SpawnWave(enemyCount)); // start spawning
}
}
else
{// do countdown
waveCountDown -= Time.deltaTime;
if (waveCounter == 0)
{
GameMaster.ui.SetWaveClearText("WAVE INCOMING");
}
GameMaster.ui.SetWaveClearOpacity(Mathf.Clamp((waveCountDown / waveSpawnDelay), 0, 1));
}
}
public override void Update()
{
_spawnTimer.Update();
_stayOpenTimer.Update();
_timeChecker.Update();
if (_timeChecker.IsReady() && ReadyToSpawn())
{
//Try to spawn
var roll = rng.NextDouble();
if (roll < _spawnRate)
{
_spawnerState = SpawnerState.Opening;
_animation.play(Animations.Open);
_stayOpenTimer.Start();
SpawnItem();
}
else
{
_timeChecker.Start();
}
}
if (_stayOpenTimer.IsReady() && _spawnerState == SpawnerState.Opening)
{
_spawnerState = SpawnerState.Closing;
_animation.play(Animations.Close);
}
if (_animation.isAnimationPlaying(Animations.Close) && !_animation.isPlaying)
{
// TODO Don't start unless current spawned item is picked up
_animation.play(Animations.Idle);
_spawnerState = SpawnerState.Closed;
_spawnTimer.Start();
}
}
IEnumerator SpawnWave(int ind)
{
state = SpawnerState.spawn;
List <GroupOfUnits> spawnGroups = slist.waves[ind].GetGroupsOfUnits();
for (int i = 0; i < spawnGroups.Count; i++)
{
yield return(StartCoroutine(spawnPlacer.SpawnGroup(spawnGroups[i].squads)));
waveSpawnProgress = (float)(i + 1) / spawnGroups.Count;
if (slist.waves[ind].groupsInWave > 1)
{
if (i == spawnGroups.Count - 1)
{
break;
}
yield return(new WaitForSeconds(slist.waves[ind].groupsDelay));
}
}
yield break;
}
/// <summary>
/// Will be called when the state changes. Override if you need to set/reset variables based on state changes
/// </summary>
/// <param name="newState">The new state</param>
protected virtual void NotifyStateSwitch(SpawnerState newState)
{
}
/// <summary>
/// Changes the spawners internal state (active, rest, etc.) to a new value.
/// </summary>
/// <param name="newState">The new state</param>
private void SwitchToState(SpawnerState newState)
{
state = newState;
if (state == SpawnerState.Active)
{
stateDuration = duration.X + (duration.Y - duration.X) * NextFloat();
}
else
if (state == SpawnerState.Rest)
{
stateDuration = delay.X + (delay.Y - delay.X) * NextFloat();
}
else
{
stateDuration = 10f;
}
NotifyStateSwitch(newState);
}
/// <summary>
/// Restarts the spawner setting it to inactive state and elapsed time = 0
/// </summary>
internal virtual void ResetSimulation()
{
state = SpawnerState.Inactive;
stateDuration = 0f;
}
