private IEnumerator SpawnAllBEATzInWave(WaveConfiguration waveConfig)
{
// For each number of BEATz that we will spawn in the scene, we will increment the BEAT count by 1.
for (int BEATCount = 0; BEATCount < waveConfig.GetSpawnNumber(); BEATCount++)
{
// Local Variables
// 1.) The BEAT that we will be spawning
var BEAT = waveConfig.GetBEATPrefab();
// 2.) The BEAT position on spawn
var BEATPosition = waveConfig.GetWaypoints()[0].transform.position;
// 3.) Spawn BEAT
var newBEAT = Instantiate(BEAT, BEATPosition, Quaternion.identity);
// 4.) The starting time of a spawn pattern.
int startingSpawnDuration = 0;
// 5.) The duration time of spawning BEATz
float endingSpawnDuration = waveConfig.GetSpawnDuration();
SpawnBEATz(waveConfig, BEAT, newBEAT);
// Wait before spawning another BEAT.
yield return(new WaitForSeconds(waveConfig.GetSpawnRate()));
BEATCount = SpawnAnotherBEAT(waveConfig, BEATCount, startingSpawnDuration, endingSpawnDuration);
// If delay is ON, then wait a second.
if (waveConfig.GetDelay() && endingSpawnDuration == startingSpawnDuration)
{
yield return(new WaitForSeconds(waveConfig.GetDelayInterval()));
}
}
}
private void ConfigWave()
{
if (roomConfig.waves.Count > actualWave)
{
Debug.Log("config wave " + actualWave);
actualConfiguration = roomConfig.waves[actualWave].Clone(); //clone the scriptable
enemiesLeft = 0;
//get the total of enemies
foreach (EnemyConfig enemyConfig in actualConfiguration.enemies)
{
enemiesLeft += enemyConfig.ammount;
}
maxEnemiesWave = enemiesLeft;
Debug.Log("Ready to spawn " + maxEnemiesWave);
StartCoroutine(SpawnWave());
}
else
{
// now waves left, open the room
// FINISH ROOM
activeRoom = false;
OpenRoom();
}
}
public void SetCurrentWave(WaveConfiguration wave, int currentWaveNumber)
{
this.currentWave = wave;
this.enemiesLeft = wave.MaxEnemies;
this.currentWaveNumber = currentWaveNumber;
this.CalculateNextGenerationTime();
}
protected override IEnumerator SpawnEnemySequence(WaveConfiguration waveConfiguration)
{
yield return(base.SpawnEnemySequence(waveConfiguration));
DestructGate();
yield return(null);
}
IEnumerator SpawnAllEnemiesInWave(WaveConfiguration waveConfig)
{
for (int i = 0; i < waveConfig.getNumberOfEnemies(); i++)
{
var newEnemy = Instantiate(waveConfig.getEnemyPrefab(), waveConfig.getWayPoints()[0].position, Quaternion.identity);
newEnemy.GetComponent <EnemyPath>().SetWaveConfig(waveConfig);
yield return(new WaitForSeconds(waveConfig.getTimeBetweenSpawns()));
}
}
private IEnumerator SpawnAllEnemiesInWave(WaveConfiguration waveConfiguration)
{
for (int enemyCount = 0; enemyCount < waveConfiguration.GetNumberEnemies(); enemyCount++)
{
GameObject newEnemy = Instantiate(waveConfiguration.GetEnemyPrefab(),
waveConfiguration.GetWayPoints()[0].transform.position, Quaternion.identity);
newEnemy.GetComponent <EnemyFollowPath>().SetWaveConfig(waveConfiguration);
yield return(new WaitForSeconds(waveConfiguration.GetTimeBeetweenSpaws()));
}
}
private void SpawnEnemy(WaveConfiguration waveConfiguration)
{
List <Transform> waypoints = waveConfiguration.GetWaypoints();
GameObject enemy = Instantiate(waveConfiguration.GetEnemyPrefab(), waypoints[1].position, Quaternion.identity);
EnemyPathing enemyController = enemy.GetComponent <EnemyPathing>();
enemyController.SetWaypoints(waypoints);
enemyController.SetMovementSpeed(waveConfiguration.GetMovementSpeed());
}
protected override void SpawnWave(object currentWaveIndex)
{
base.SpawnWave(currentWaveIndex);
WaveConfiguration currentWavePacks = waveConfig.waves[base.currentWaveIndex];
foreach (var pack in currentWavePacks.packs)
{
StartCoroutine("SpawnPack", pack);
}
}
private IEnumerator SpawnAllEnemiesInWave(WaveConfiguration waveConfig)
{
for (int enemyCounter = 0; enemyCounter < waveConfig.getNumberOfEnemies(); enemyCounter++)
{
GameObject SpawnedEnemy = Instantiate(waveConfig.GetEnemyPrefab() as GameObject, waveConfig.GetWaypoints()[0].position, Quaternion.identity);
SpawnedEnemy.GetComponent <EnemyPathing>().SetWaveConfig(waveConfig);
yield return(new WaitForSeconds(waveConfig.getTimeBetweenSpawns()));
}
}
public WaveConfiguration Clone()
{
WaveConfiguration wave = new WaveConfiguration();
wave.enemies = new List <EnemyConfig>();
foreach (EnemyConfig enemy in enemies)
{
wave.enemies.Add(enemy.Clone());
}
return(wave);
}
private int SpawnAnotherBEAT(WaveConfiguration waveConfig, int BEATCount, int startingSpawnDuration, float endingSpawnDuration)
{
// If BEAT count is greater than the spawn number and the endingSpawnDuration is less than the starting spawn duration..
if (BEATCount > waveConfig.GetSpawnNumber() && endingSpawnDuration < startingSpawnDuration)
{
// Decrement the BEAT Count.
BEATCount--;
}
return(BEATCount);
}
private IEnumerator spawnEnemiesInWave(WaveConfiguration wave)
{
for (int enemyCount = 0; enemyCount < wave.getNumberOfEnemies(); enemyCount++)
{
var newEnemy = Instantiate(
wave.getEnemyPreab(),
wave.getWaypoints()[0].transform.position,
Quaternion.identity);
newEnemy.GetComponent <EnemyMovement>().setWaveConfig(wave);
yield return(new WaitForSeconds(wave.getTimeBetweenSpawns()));
}
}
private IEnumerator SpawnAllEnemies(WaveConfiguration waveConfig) /* coroutine
* that spawns enemies in a wave configuration */
{
for (int enemyCount = 0; enemyCount < waveConfig.GetNumberOfEnemies(); enemyCount++)
{
var newEnemy = Instantiate(
waveConfig.GetEnemyPrefab(),
waveConfig.GetWaypoints()[0].position,
Quaternion.identity);
newEnemy.GetComponent <EnemyPathing>().SetWaveConfiguration(waveConfig);
yield return(new WaitForSeconds(waveConfig.GetSpawnTime()));
}
}
private IEnumerator SpawnAllEnemiesInWave(WaveConfiguration waveConfiguration)
{
for (int enemyCount = 0; enemyCount < waveConfiguration.GetNumberOfEnemies(); enemyCount++)
{
var newEnemy = Instantiate(
waveConfiguration.GetEnemyPrefab(),
waveConfiguration.GetWaypoints()[0].transform.position,
Quaternion.identity
);
newEnemy.GetComponent <EnemyPathing>().SetWaveConfiguration(waveConfiguration);
yield return(new WaitForSeconds(waveConfiguration.GetSpawnIntervalTime()));
}
}
private WaveConfiguration GetRandomWave()
{
var waveConfig = new WaveConfiguration();
var random = new System.Random();
waveConfig.title = "wave config";
waveConfig.enemyPrefab = enemyPrefabs[random.Next(enemyPrefabs.Count)];
waveConfig.pathPrefab = pathPrefabs[random.Next(pathPrefabs.Count)];
waveConfig.timeBetweenEnemySpawns = UnityEngine.Random.Range(0.4f, 1.6f);
waveConfig.randomFactor = UnityEngine.Random.Range(0.05f, 0.2f);
waveConfig.movementSpeed = UnityEngine.Random.Range(4f, 7f);
waveConfig.numberOfEnemiesToSpawn = UnityEngine.Random.Range(3, 10);
return(waveConfig);
}
protected override IEnumerator SpawnEnemySequence(WaveConfiguration waveConfiguration)
{
yield return(base.SpawnEnemySequence(waveConfiguration));
if (enemyPool.Count - 1 > _currentWaveConfigurationIndex)
{
_currentWaveConfigurationIndex += 1;
StartCoroutine(SpawnEnemySequence(enemyPool[_currentWaveConfigurationIndex]));
}
else
{
TriggerMotherShipMove();
}
yield return(null);
}
public static Configuration Wave(Options options, Configuration inConfig = null)
{
WaveConfiguration config = inConfig as WaveConfiguration ?? new WaveConfiguration();
switch (options.OutFormat)
{
case AudioFormat.GcAdpcm:
throw new InvalidDataException("Can't use format GcAdpcm with Wave files");
case AudioFormat.Pcm16:
config.Codec = WaveCodec.Pcm16Bit;
break;
case AudioFormat.Pcm8:
config.Codec = WaveCodec.Pcm8Bit;
break;
}
return(config);
}
protected virtual IEnumerator SpawnEnemySequence(WaveConfiguration waveConfiguration)
{
yield return(new WaitForSeconds(waveConfiguration.initialDelay));
foreach (var sequence in waveConfiguration.EnemiesToSpawn)
{
var enemyToSpawn = sequence.enemyPrefab.gameObject;
for (int i = 0; i < sequence.spawnTimes; i++)
{
var spawnedEnemy = pool.GetFromPool(enemyToSpawn, spawnPoint.position, quaternion.identity);
var enemyComponent = spawnedEnemy.GetComponent <Enemy>();
if (enemyComponent)
{
enemyComponent.InitializeMoving(positionsManager);
}
yield return(new WaitForSeconds(waveConfiguration.timeBetweenSpawns));
}
}
}
IEnumerator SpawnBEATz(WaveConfiguration waveConfig, GameObject BEAT, GameObject newBEAT)
{
if (!waveConfig.GetRandomSpawn())
{
// We instantiate BEATz based on the data that the Spawn Pattern is holding.
newBEAT.GetComponent <SpawnPattern>().SetWaveConfiguration(waveConfig);
// Cooldown before spawning another BEAT
yield return(new WaitForSeconds(waveConfig.GetBEATzPerSecond()));
}
else
{
Vector2 randomBEATPosition = new Vector2(Random.Range(-8, 8), Random.Range(-4, 4));
// Spawn BEATz in randon position
Instantiate(BEAT, randomBEATPosition, Quaternion.identity);
// Cooldown before spawning another BEAT
yield return(new WaitForSeconds(waveConfig.GetBEATzPerSecond()));
}
}
private void CreateEnemiesByWave(WaveConfiguration waveConfiguration)
{
_observers.Clear();
for (var i = 0; i < waveConfiguration.numberOfEnemies; i++)
{
var lootObjects = waveConfiguration.enemiesLoot;
var totalLoot = CalculateTotalLoot(lootObjects);
var index = GetLootIndex(lootObjects, totalLoot);
var obj = waveConfiguration.enemiesLoot[index];
var prefab = obj.prefab;
var point = GetRandomPoint();
var position = point.Trans.position;
var rotation = point.Trans.rotation;
var enemy = Instantiate(prefab, position, rotation, parentOfEnemies);
enemy.Initialization(this, obj.force);
enemy.gameObject.SetActive(false);
Subscribe(enemy);
}
}
public void SetWaveConfiguration(WaveConfiguration waveConfig)
{
// We assign the wave configuration into the waveConfig
this.waveConfiguration = waveConfig;
}
public void SetWaveConfig(WaveConfiguration rWaveConfig)
{
waveConfig = rWaveConfig;
}
public ActiveWave(WaveConfiguration waveConfiguration)
{
this.waveConfiguration = waveConfiguration;
this.enemiesToSpawn = waveConfiguration.GetNumberOfEnemiesToSpawn();
this.lastSpawnTime = 0;
}
protected virtual IEnumerator SpawnEnemySequenceRandom(WaveConfiguration waveConfiguration)
{
//TODO: write this method
yield return(null);
}
private ActiveWave MakeActiveWave(WaveConfiguration waveConfiguration)
{
return(new ActiveWave(waveConfiguration));
}
public void SetWaveConfiguration(WaveConfiguration waveConfig) /* each
enemy will be linked to a wave configuration in Unity, so this method
will allow us to refer to the linked wave configuration in this class */
{
this.waveConfig = waveConfig;
}
public void SetWaveConfig(WaveConfiguration waveConfiguration)
{
this._waveConfiguration = waveConfiguration;
}
public void setWaveConfig(WaveConfiguration waveConfig)
{
this.waveConfig = waveConfig;
}
protected override IEnumerator SpawnEnemySequenceRandom(WaveConfiguration waveConfiguration)
{
yield return(base.SpawnEnemySequenceRandom(waveConfiguration));
}
