protected override bool TickCore(realm.RealmTime time)
{
object obj;
SpawnState state = null;
if (!Host.StateStorage.TryGetValue(Key, out obj) ||
(state = (SpawnState)obj).remainingTick <= 0)
{
Entity[] originalChildren = null;
if (state != null)
originalChildren = state.children;
state = new SpawnState()
{
remainingTick = 10000,
children = new Entity[5]
};
double angleInc = (2 * Math.PI) / 5;
for (int i = 0; i < 5; i++)
{
Entity entity = Entity.Resolve(0x0951);
entity.Move(
Host.Self.X + (float)Math.Cos(angleInc * i) * 4,
Host.Self.Y + (float)Math.Sin(angleInc * i) * 4);
state.children[i] = entity;
Host.Self.Owner.BroadcastPacket(new ShowEffectPacket()
{
EffectType = EffectType.Throw,
Color = new ARGB(0xffffbf00),
TargetId = Host.Self.Id,
PosA = new Position()
{
X = entity.X,
Y = entity.Y
}
}, null);
}
Host.StateStorage[Key] = state;
Host.Self.Owner.Timers.Add(new WorldTimer(1500, (world, t) =>
{
if (originalChildren != null)
foreach (var i in originalChildren)
{
if (i.Owner != null)
i.Owner.LeaveWorld(i);
}
foreach (var i in state.children)
world.EnterWorld(i);
}));
return false;
}
else
{
state.remainingTick -= time.thisTickTimes;
if (state.remainingTick <= 0 ||
(state.remainingTick < 8000 && state.children.Sum(_ => _.Owner == null ? 0 : 1) < 3))
state.remainingTick = 0;
}
return false;
}
private IEnumerator SpawnWave(Wave _wave)
{
state = SpawnState.Spawning;
for (int i = 0; i < _wave.count; i++)
{
SpawnEnemy(_wave.enemy);
yield return new WaitForSeconds(1f / _wave.rate);
}
state = SpawnState.Waiting;
yield break;
}
IEnumerator SpawnWave(Wave _wave)
{
Debug.Log("Spawning Wave: " + _wave.name);
state = SpawnState.SPAWNING;
if (NormalSpawnCount.GetComponent<WaveSpawner> ().totalwaves % 5 == 0) {
SpawnEnemy (_wave.enemy);
yield return new WaitForSeconds( 1f/_wave.rate);
}
state = SpawnState.WAITING;
yield break;
}
IEnumerator SpawnWave(Wave w)
{
Debug.Log("Spawning Wave: " + w.name);
spawnState = SpawnState.SPAWNING;
for (int i = 0; i < w.amount; i++) {
SpawnEnemy(w.enemyPrefab);
yield return new WaitForSeconds (1f / w.spawnRate);
}
spawnState = SpawnState.WAITING;
yield break;
}
IEnumerator SpawnWave(Wave _wave)
{
Debug.Log("Spawning Wave: " + _wave.Name);
state = SpawnState.Spawning;
for (int i = 0; i < _wave.enemyCount; i++)
{
SpawnEnemy(_wave.enemys[Random.Range(0,_wave.enemys.Length)]);
yield return new WaitForSeconds(1.0f / _wave.spawnRate);
}
state = SpawnState.Waiting;
yield break;
}
IEnumerator SpawnWave(Wave wave)
{
print("Spawing Wave: " + wave.name);
state = SpawnState.SPAWNING;
//Spawn
for (int i = 0; i < wave.count; i++)
{
//Spawn an enemy, wait and then spawn another
SpawnEnemy(wave.enemy);
yield return(new WaitForSeconds(1f / wave.rate));
}
state = SpawnState.WAITING;
}
private void WaveCompleted()
{
state = SpawnState.counting;
waveCountDown = timeBetweenWaves;
if (nextWave >= waves.Length)
{
nextWave = 0;
print("Completed all waves. Loop");
}
else
{
nextWave++;
}
}
void waveCompletion()
{
state = SpawnState.COUNTING;
waveCountdownTimer = timeBetweenWaves;
if (nextWave + 1 > waves.Length - 1)
{
nextWave = 0;
Debug.Log("All Waves Complete! looping");
}
else
{
nextWave++;
}
}
// Use this for initialization
void Start()
{
ssm.Add(SpawnState.QUADRANT_TOPLEFT, StateQuadTopLeft);
ssm.Add(SpawnState.QUADRANT_TOPRIGHT, StateQuadTopRight);
ssm.Add(SpawnState.QUADRANT_BOTTOMLEFT, StateQuadBottomLeft);
ssm.Add(SpawnState.QUADRANT_BOTTOMRIGHT, StateQuadBottomRight);
ssm.Add(SpawnState.PUSH_TO_TOP, StatePushToTop);
ssm.Add(SpawnState.PUSH_TO_RIGHT, StatePushToRight);
ssm.Add(SpawnState.PUSH_TO_BOTTOM, StatePushToBottom);
ssm.Add(SpawnState.PUSH_TO_LEFT, StatePushToLeft);
ssm.Add(SpawnState.WALL, StateWall);
ssm.Add(SpawnState.EMPTY, StateEmpty);
curState = SpawnState.EMPTY;
}
IEnumerator SpawnWave(Wave wave)
{
//Debug.Log("Spawning wave: " + wave.name);
state = SpawnState.Spawning;
for (int i = 0; i < wave.count; i++)
{
SpawnEnemy(wave.enemy);
yield return(new WaitForSeconds(1f / wave.rate));
}
state = SpawnState.Waiting;
yield break;
}
IEnumerator SpawnWave(Wave _wave)
{
Debug.Log("Spawning Wave: " + _wave.waveName);
state = SpawnState.Spawning; //sets state to spawning.
for (int i = 0; i < _wave.amount; i++) //Loops through amount of enemies to spawn.
{
SpawnEnemy(_wave.enemyAI); //For each enemy to spawn, call spawnEnemy method.
yield return(new WaitForSeconds(1f / _wave.spawnRate)); //We continue spawn loop until max enemies have been spawned for specific wave.
}
state = SpawnState.Waiting;
yield break;
}
IEnumerator SpawnWave(Wave _wave) // allows a break between enemy spawning (This is a Coroutine)
{
state = SpawnState.Spawning;
//Spawn
for (int i = 0; i < _wave.count; i++)
{
SpawnEnemy(_wave.enemyPrefab);
yield return(new WaitForSeconds(1f / _wave.SpawnRate));
}
state = SpawnState.Waiting;
yield break;
}
void WaveCompleted()
{
state = SpawnState.Counting;
waveCountdown = timeBetweenWaves;
//Game state complete...edit to make harder ect
if (nextWave + 1 > waves.Length - 1)
{
nextWave = 0;
}
else
{
nextWave++;
}
}
IEnumerator SpawnWave(Wave _wave)
{
Debug.Log("Spawn wave" + _wave.name);
state = SpawnState.SPAWNING;
for (int i = 0; i < _wave.count; i++)
{
SpawnEnemy(_wave.enemy);
yield return(new WaitForSeconds(1f / _wave.spawnRate));
}
state = SpawnState.WAITING;
yield break;
}
IEnumerator SpawnWave(Wave wave)
{
state = SpawnState.Spawning;
for (int i = 0; i < wave.enemy.Count; i++)
{
for (int j = 0; j < wave.enemyAmmount[i]; j++)
{
SpawnEnemy(wave.enemy[i], spawnPoints[Random.Range(0, spawnPoints.Length)]);
yield return(new WaitForSeconds(1 / wave.enemiesPerSecond));
}
}
state = SpawnState.ActiveWave;
}
void WaveCompleted()
{
Debug.Log("Wave completed.");
state = SpawnState.Counting;
waveCountdown = timeBetweenWaves;
if (nextWave + 1 > waves.Length - 1) //Checks to see if waves are completed so error isn't thrown once max waves are reached.
{
nextWave = 0;
Debug.Log("Completed all waves. Looping..");
}
nextWave++;
}
public IEnumerator SpawnWave(Wave _wave)
{
state = SpawnState.SPAWNING;
Debug.Log("Wave Starting" + _wave.name);
for (int i = 0; i < _wave.count; i++)
{
SpawnEnemy(_wave.enemy);
yield return(new WaitForSeconds(1f / _wave.rate));
}
state = SpawnState.WAITING;
yield break;
}
IEnumerator SpawnWave(WaveProperties wave)
{
Debug.Log("Spawning Wave: " + wave.name);
state = SpawnState.SPAWNING;
for (int i = 0; i < wave.Amount; i++)
{
SpawnEnemy(wave.Enemy);
yield return(new WaitForSeconds(1.0f / wave.Rate));
}
state = SpawnState.WAITING;
yield break;
}
IEnumerator SpawnWave(Wave waveToSpawn)
{
Debug.Log("Spawning wave: " + waveToSpawn.name);
state = SpawnState.SPAWNING;
// Spawn
for (int i = 0; i < waveToSpawn.count; i++)
{
SpawnEnemy(waveToSpawn.enemy);
yield return(new WaitForSeconds(1f / waveToSpawn.rate));
}
state = SpawnState.WAITING;
yield break;
}
private void WaveCompleted()
{
// Stop tanks from moving.
// DisableTankControl();
state = SpawnState.COUNTING;
waveCountdown = timeBetweenWaves;
nextWave++;
totalwavescompleted++;
gameplay.text = "Wave" + totalwavescompleted + " Completed!";
if (nextWave == waves.Count())
{
nextWave = 0;
}
}
// Used to spawn the Abductors
IEnumerator SpawnWave()
{
state = SpawnState.SPAWNING; // Spawnstate is Spawning A Enemy Wave Will Spawn
for (int i = 0; i < int_Enemies; i++) // Let Computer Calculate how many Enemies it will spawn
{
GameObject GO_Spawn = Instantiate(s_GM.GO_spawning_effect, RandomScreenPosition, Quaternion.identity); // Start by Spawning a Spawn effect so player knows where to NPC is going to spawn
Destroy(GO_Spawn, 3); // Destroy this effect after 3 seconds
yield return(new WaitForSeconds(1 / fl_spawnDelay)); // Wait For Seconds and Divid 1 by spawnDelay
Instantiate(s_GM.GO_abducter_Prefab, GO_Spawn.transform.position, Quaternion.identity); int_enemy_Count++; // Allow NPC Abductor to spawn on the spawn Effect postion before its recyled
yield return(new WaitForSeconds(fl_waveWait));
}
state = SpawnState.WAITING; // Spawnstate is now Waiting for countdown or Spawning to start
yield break;
}
IEnumerator SpawnWave(Wave _wave)
{
state = SpawnState.SPAWNING;
theWaveName = "Wave " + nextWave;
// spawn
for (int i = 0; i < _wave.enemyAmount; i++)
{
SpawnEnemy(_wave.enemy);
yield return(new WaitForSeconds(1 / _wave.spawnRate));
}
state = SpawnState.WAITING;
yield break;
}
void Start()
{
//Add to spawn state
SpawnState.addSpawner(this);
takingDamage = false;
timeDamage = 3f;
groupSpawn = 5;
healthBar.minValue = 0;
healthBar.maxValue = 100;
shieldUp = true;
}
IEnumerator spawnWave(Wave _wave)
{
state = SpawnState.SPAWNING; //enemies spawning
for (int i = 0; i < _wave.enemyCount; i++) //spawn enemies required per wave
{
SpawnEnemy(_wave.enemy);
yield return(new WaitForSeconds(1f / _wave.rate));
}
state = SpawnState.WAITING;//wave in progress
yield break;
}
IEnumerator SpawnWave(Wave _wave)
{
//Debug.Log("Spawning Wave: " + _wave.name);
state = SpawnState.SPAWNING;
for (int i = 0; i < _wave.count; i++)
{
SpawnEnemy(_wave.enemy[Random.Range(0, _wave.enemy.Length)]);
yield return(new WaitForSeconds(1f / _wave.rate));
}
state = SpawnState.WAITING;
yield break;
}
void OnWaveCompleted()
{
estado = SpawnState.CONTANDO;
contadorDaWave = tempoEntreWaves;
tempo.FreezeFrame();
WaveCount.Instance.waveClear.gameObject.SetActive(true);
if (proximaWave + 1 > waves.Length - 1)
{
proximaWave = 0;
}
else
{
proximaWave++;
}
}
IEnumerator SpawnWave(Wave _wave)
{
// Spawn the next wave
state = SpawnState.SPAWING;
for (int i = 0; i < _wave.count; i++)
{
SpawnEnemy(_wave.enemy);
yield return(new WaitForSeconds(1f / _wave.rate));
}
state = SpawnState.WAITING;
yield break;
}
/*
* Is called when a wave is completed
*/
void WaveCompleted()
{
Debug.Log("Wave Completed");
state = SpawnState.COUNTING;
waveCountDown = timeBetweenWaves;
if (currentWave + 1 > waves.Length - 1)
{
SceneManager.LoadScene("Win");
}
else
{
currentWave++;
}
}
void waveCompleted()
{
state = SpawnState.Counting;
waveCountDown = timeBetweenWaves;
if (nextWave + 1 > _waves.Length - 1)
{
nextWave = 0;
}
else
{
nextWave++;
}
}
void WaveCompleted()
{
state = SpawnState.COUNTING;
waveCountdown = timeBetweenWaves;
if (nextWave + 1 > waves.Length - 1)
{
//End the game
UnityEngine.SceneManagement.SceneManager.LoadScene(4);
}
else
{
nextWave++;
}
}
void WaveCompleted()
{
state = SpawnState.COUNTING;
waveCountdown = timeBetweenWaves;
if (nextWave + 1 > waves.Length - 1)
{
nextWave = 0;
Debug.Log("All waves complete, now looping");
}
else
{
nextWave++;
}
}
IEnumerator CanSpawn(Wave wave)
{
estado = SpawnState.SPAWNANDO;
//O Spawn
for (int i = 0; i < wave.quantidade; i++)
{
SpawnEnemy();
yield return(new WaitForSeconds(1f / wave.ritmo));
}
//Fim do Spawn
estado = SpawnState.ESPERANDO;
yield break;
}
void WaveDone()
{
Debug.Log("Wave Completed");
_state = SpawnState.counting;
waveCountdown = timeBetweenWaves;
if (_nextWave + 1 > waves.Length - 1)
{
_nextWave = 0;
Debug.Log("No more Waves. Starts 1st Wave");
}
else
{
_nextWave++;
}
}
IEnumerator SpawnWave(Wave _wave)
{
Debug.Log("Spawning Wave: " + _wave.name);
state = SpawnState.SPAWNING;
for (int i = 0; i < _wave.count; i++)
{
SpawnEnemy(_wave.enemy);
yield return new WaitForSeconds( 1f/_wave.rate );
}
state = SpawnState.WAITING;
yield break;
}
IEnumerator SpawnWave(Wave _wave)
{
state = SpawnState.SPAWNING;
// Spawn
for (int i = 0; i < _wave.count; i++)
{
SpawnEnemy(_wave.enemy);
yield return(new WaitForSeconds(rand));
}
state = SpawnState.WAITING;
yield break;
}
IEnumerator SpawnWave(Wave _wave)
{
Debug.Log("Spawning Wave: " + _wave.name);
state = SpawnState.Spawning;
//SPAWN
for (int i = 0; i < _wave.count; i++)
{
SpawnEnemy(_wave.enemy);
yield return(new WaitForSeconds(1f / _wave.rate));
}
state = SpawnState.Waiting;
yield break;
}
// Update is called once per frame
void Update()
{
switch (waveSpawner.State) {
case SpawnState.COUNTING:
{
updateCountingUI();
break;
}
case SpawnState.SPAWNING:
{
updateSpawningUI();
break;
}
}
previousState = waveSpawner.State;
}
/*Constructor*/
public Spawner(Vector2 center, float width = 15f, float height = 30f,
float rotation = 0f, float static_friction = 0f,
float bounciness = 0f, int spawns = 0, int frequency = 20, float rand_angle = 60f,
bool shouldMove = false, float leftBound = 0.0f, float rightBound = 0.0f)
: base(center, width, height, rotation, static_friction, bounciness)
{
num_spawns = spawns;
this.spawn_freq = frequency;
num_spawned = 0;
num_active = 0;
this.theta = MathHelper.Clamp(rand_angle, 0f, 90f);
this.state = SpawnState.Idle;
this.ticks_to_spawn = this.spawn_freq;
/*Set up list*/
this.coins = new LinkedList<Money>();
this.SetTextureSpriteSheet("Spawner", 3, 1, 0);
this.UseSpriteSheet = true;
this.SetTextureSpriteAnimationFrames(0, 0, 0, 0, 40, SpriteSheetAnimationMode.AnimateForward);
this.UseSpriteSheetAnimation = true;
if (!shouldMove)
{
this.movingSpawner = false;
}
else
{
// set up moving spawner. starts at right bound and moves left.
this.movingSpawner = true;
this.movingArt = new XNACS1Rectangle();
this.movingArt.SetTextureSpriteSheet("spawnerHelicopter", 1, 3, 0);
this.movingArt.UseSpriteSheet = true;
this.movingArt.SetTextureSpriteAnimationFrames(0, 0, 0, 2, 7, SpriteSheetAnimationMode.AnimateForward);
this.movingArt.UseSpriteSheetAnimation = true;
this.movingArt.Width = 120f;
this.movingArt.Height = 60f;
this.TopOfAutoDrawSet();
this.travelTicks = XNACS1Base.World.TicksInASecond * 10;
this.unitsMovedPerTick = (rightBound - leftBound) / travelTicks;
this.VelocityDirection = new Vector2(-1, 0);
this.CenterX = rightBound;
this.movingArt.Center = this.Center;
}
}
void WaveCompleted()
{
Debug.Log("Wave Completed!");
state = SpawnState.COUNTING;
waveCountdown = timeBetweenWaves;
if (nextWave + 1 > waves.Length - 1)
{
nextWave = 0;
Debug.Log("ALL WAVES COMPLETE! Looping...");
}
else
{
nextWave++;
}
}
protected override void OnStateEntry(Entity host, RealmTime time, ref object state)
{
state = new SpawnState
{
CurrentNumber = initialSpawn,
RemainingTime = coolDown.Next(Random)
};
for (int i = 0; i < initialSpawn; i++)
{
Entity entity = Entity.Resolve(host.Manager, children[Random.Next(children.Length)]);
entity.Move(
host.X + (float)(Random.NextDouble() * 0.5),
host.Y + (float)(Random.NextDouble() * 0.5));
(entity as Enemy).Terrain = (host as Enemy).Terrain;
host.Owner.EnterWorld(entity);
}
}
IEnumerator SpawnWave(Wave _wave)
{
Debug.Log("Spawning Wave: " + _wave.name);
state = SpawnState.SPAWNING;
/*for (int i = 0; i < _wave.count; i++) {
SpawnEnemy (_wave.enemy);
//yield return new WaitForSeconds( 1f/_wave.rate );
yield return new WaitForSeconds( 5f/(Random.Range(1,_wave.rate)) );
}*/
for (int i = 0; i < Random.Range(_wave.count,maxcount); i++) {
SpawnEnemy (_wave.enemy);
//yield return new WaitForSeconds( 1f/_wave.rate );
yield return new WaitForSeconds( 5f/(Random.Range(1,_wave.rate)) );
}
state = SpawnState.WAITING;
yield break;
}
IEnumerator SpawnWave(Wave _wave)
{
Debug.Log("Spawning Wave: " + _wave.name);
state = SpawnState.SPAWNING;
for (int i = 0; i < _wave.count; i++) {
//SpawnEnemy(_wave.enemy);
randomenemy = Random.Range (0, 60);
if (randomenemy <= 36)
SpawnEnemy (_wave.enemy);
if (randomenemy >= 37 && randomenemy <= 51)
SpawnEnemy (_wave.enemy2);
if (randomenemy >= 52 && randomenemy <= 60)
SpawnEnemy (_wave.enemy3);
//yield return new WaitForSeconds( 1f/_wave.rate );
yield return new WaitForSeconds( 1f/(Random.Range(1,_wave.rate)) );
}
state = SpawnState.WAITING;
yield break;
}
void Awake()
{
int counter = 1;
for (int i = 0; i < 5; i++)
{
for (int j = 0; j < 5; j++)
{
mArray.Array[i][j] = counter++;
}
}
mSpawnData = this.gameObject.GetComponent<SpawnData>();
mSpawnState = SpawnState.Countdown;
SpawnCounter = SpawnTime;
AlienArray = new ArrayList();
//for (int i = 0; i < 5; i++)
//{
// CreateAlien(0, i, 1);
// CreateAlien(0, i, 2);
//}
//CreateAlien(0, 3, 4);
}
/*Constructor*/
public Spawner(Vector2 center, float width = 5f, float height = 5f,
float rotation = 0f, float static_friction = 0f,
float bounciness = 0f, int spawns = 100, int frequency = 20, float rand_angle = 0f)
: base(center, width, height, rotation, static_friction, bounciness)
{
num_spawns = spawns;
this.spawn_freq = frequency;
num_spawned = 0;
this.theta = MathHelper.Clamp(rand_angle, 0f, 90f);
this.state = SpawnState.Idle;
this.ticks_to_spawn = this.spawn_freq;
/*Set up list*/
this.coins = new List<Money>(num_spawns);
for (int i = 0; i < num_spawns; ++i)
{
this.coins.Add(new Money(this.Center, 5f, 5.0f));
this.coins[i].RemoveFromAutoDrawSet();
}
/*Get coins ready for spawn*/
foreach (Money dinero in this.coins)
{
#region Vector Calculations
Vector2 T = this.FrontDirection;
Vector2 N = this.NormalDirection;
/*Find a random velocity vector between (-theta, theta)*/
float angle_offset = XNACS1Base.RandomFloat(-this.theta, this.theta);
float vT = (float)(Math.Cos(angle_offset));
float vN = (float)(Math.Sin(angle_offset));
Vector2 V_hat = (vT * T) + (vN * N);
dinero.Velocity = kLaunchSpeed * V_hat;
#endregion
}
}
/**Spawns enemies and waits a short time in between spawning
* should be expanded to use different spwan points so we can make
* different shapes and what not with the spawn pattern.
* @param _wave: The wave object that is used for spawning
*/
IEnumerator SpawnWave(Wave curWave)
{
//now we are actually spawning
curState = SpawnState.SPAWNING;
//spawn things based on number of enemies we want to spawn
for(int i = 0; i < curWave.count; i++)
{
int picker = i % curWave.enemies.Length;
SpawnEnemy (curWave.enemies[picker]);
yield return new WaitForSeconds(curWave.indivSpawnDelay);
}
//Switch to wait for character to kill enemies
curState = SpawnState.WAITING;
yield break;
}
//Update spawn state as time progresses to make the game more difficult
public void UpdateSpawnState()
{
if (Score <= 10)
currentSpawnState = SpawnState.SpawnOne;
else if (Score > 10 && Score <= 40)
{
IntervalSpawnTime = 500;
}
else if (Score > 40 && Score <= 60)
{
IntervalSpawnTime = 400;
}
else if (Score > 60 && Score <= 80)
{
currentSpawnState = SpawnState.SpawnTwo;
IntervalSpawnTime = 1500;
}
else if (Score > 80 && Score <= 100)
{
IntervalSpawnTime = 1000;
}
else if (Score > 100 && Score <= 140)
{
currentSpawnState = SpawnState.SpawnThree;
IntervalSpawnTime = 1800;
}
else if (Score > 140 && Score <= 180)
{
IntervalSpawnTime = 1500;
}
else if (Score > 180 && Score <= 230)
{
IntervalSpawnTime = 1200;
}
else if(Score > 230 && Score <= 280)
{
IntervalSpawnTime = 1000;
}
else if (Score > 280 && Score <= 320)
{
currentSpawnState = SpawnState.SpawnOne;
IntervalSpawnTime = 390;
}
else if (Score > 320)
{
currentSpawnState = SpawnState.SpawnThree;
IntervalSpawnTime = 1000;
}
else if (Score > 500)
{
IntervalSpawnTime = 900;
}
}
private void select(object sender, EventArgs e)
{
SpawnState[] states;
#region Levels
switch (selectedEntry)
{
case 0:
states = new SpawnState[]
{
SpawnState.Wave,
SpawnState.Peace,
SpawnState.Wave,
SpawnState.Boss,
SpawnState.Peace,
SpawnState.Wave,
SpawnState.Boss,
SpawnState.Peace,
SpawnState.Wave,
SpawnState.Boss,
SpawnState.Victory
};
break;
case 1:
bossStart = 3;
states = new SpawnState[]
{
SpawnState.Wave,
SpawnState.Boss,
SpawnState.Peace,
SpawnState.Wave,
SpawnState.Peace,
SpawnState.Surge,
SpawnState.Boss,
SpawnState.Peace,
SpawnState.Wave,
SpawnState.Boss,
SpawnState.Victory
};
break;
case 2:
bossStart = 6;
states = new SpawnState[]
{
SpawnState.Surge,
SpawnState.Boss,
SpawnState.Peace,
SpawnState.Wave,
SpawnState.Peace,
SpawnState.Wave,
SpawnState.Boss,
SpawnState.Peace,
SpawnState.Wave,
SpawnState.Peace,
SpawnState.Surge,
SpawnState.Boss,
SpawnState.Peace,
SpawnState.Wave,
SpawnState.Peace,
SpawnState.Surge,
SpawnState.Boss,
SpawnState.Victory
};
break;
case 3:
bossStart = 0;
states = new SpawnState[]
{
SpawnState.Boss,
SpawnState.Boss,
SpawnState.Boss,
SpawnState.Peace,
SpawnState.Boss,
SpawnState.Boss,
SpawnState.Boss,
SpawnState.Peace,
SpawnState.Boss,
SpawnState.Boss,
SpawnState.Boss,
SpawnState.Boss,
SpawnState.Victory
};
break;
case 4:
states = new SpawnState[]
{
SpawnState.Endless
};
break;
default:
states = new SpawnState[]
{
SpawnState.Victory
};
break;
}
#endregion Levels
ExitScreen();
Manager.AddScreen(new GameplayScreen(font, bossStart, indices, selectedEntry, states), null);
}
/// <summary>
/// Start spawning Money. Spawns one coin and only if there are coins
/// left to spawn.
/// </summary>
public virtual void SpawnMoney()
{
/*If it's time to spawn again*/
if (this.ticks_to_spawn <= 0)
{
/*Reset spawn clock*/
this.ticks_to_spawn = this.spawn_freq;
/*If coins are still left*/
if (num_spawned < num_spawns)
{
/*Draw and get coin moving*/
this.coins[num_spawned].GetMoving();
++num_spawned;
}
else
{
/*Out of coins; go idle*/
this.state = SpawnState.Idle;
}
}
else
{
/*Countdown*/
--this.ticks_to_spawn;
}
}
void Start()
{
if (objPool == null)
objPool = GameObject.FindGameObjectWithTag ("Pool").GetComponent<ObjectPool> ();
startingCountDown = startingPeaceTime;
peaceCountDown = peaceTime;
waveCountDown = timeBetweenWaves;
displayTime.text = "Next Wave in: ";
indicators = new GameObject[wavesInGroup];
// create initial indicators
CreateSpawnPointIndicators ();
maxWaves = waves.Length;
groupCount = maxWaves / wavesInGroup;
// Debug.Log ("WAVE SPAWNER: Group count = " + groupCount);
state = SpawnState.COUNTING;
}
public void WaveCompleted()
{
Debug.Log("Wave " + nextWave + "Completed!");
state = SpawnState.COUNTING;
waveCountdown = timeBetweenWaves;
if (nextWave + 1 > 99 /*waves.Length - 1*/)
{
nextWave = 0;
CurrentWaveSetUp();
Debug.Log("ALL WAVES COMPLETE! Looping...");
}
else
{
//Wave completed and moving on to next wave.
//nextWave++;
//NewWave();
}
}
// FOR TESTING, This resets the wave spawner
public void Reset()
{
startingCountDown = startingPeaceTime;
nextWave = 0;
nextWaveInGroup = 0;
nextGroup = 1;
peaceCountDown = peaceTime;
waveCountDown = timeBetweenWaves;
displayTime.text = "Next Wave in: ";
indicators = new GameObject[wavesInGroup];
// create initial indicators
CreateSpawnPointIndicators ();
state = SpawnState.COUNTING;
maxWaves = waves.Length;
groupCount = maxWaves / wavesInGroup;
}
public void AddWall(SpawnState spawnState)
{
WallSpawns.Add(spawnState);
}
public void AddEverynian(SpawnState spawnState)
{
EverynianSpawns.Add(spawnState);
}
// Resets the wave spawner and all counters
public void Reset()
{
groupFinished = false;
peaceCountDown = peaceTime;
waveCountDown = timeBetweenWaves;
displayTime.text = "Next Wave in: ";
// create initial indicators
CreateSpawnPointIndicators ();
state = SpawnState.COUNTING;
}
private void WaveCompleted()
{
state = SpawnState.Counting;
waveCountdown = timeBetween;
if (nextWave + 1 > waves.Length - 1)
nextWave = 0;
else
nextWave++;
}
/**
* Executes when player finishes killing the whole round of enemies
* Resets appropriate states and starts the spawning over at the first wave
* */
void WaveCompleted()
{
//reset appropriate variables to correct numbers
curState = SpawnState.COUNTING;
waveCountdown = timeBetweenWaves;
//If the final wave is done then you win!
if(finalDone)
{
//This should be expanded to go to a dif win screen.
Application.LoadLevel(2);
}
//If you run out of waves, start the final wave!
if(nextWave + 1 > waves.Length -1)
{
StartCoroutine(SpawnFinalWave());
}
else
{
nextWave ++;
}
}
/**
* Spawns epic final wave. Currently spwans a mix of all enemy types from the waves available but
* could easily be modified.
* */
IEnumerator SpawnFinalWave()
{
curState = SpawnState.SPAWNING;
for(int i = 0; i < finalWaveCount; i++)
{
int picker = i % waves.Length;
SpawnEnemy(waves[picker].enemies[0]);
yield return new WaitForSeconds(finalSpawnDelay);
}
curState = SpawnState.WAITING;
finalDone = true;
yield break;
}
IEnumerator SpawnWave(Wave _wave)
{
// Debug.Log ("WAVE: Spawning wave " + nextWave + ", group member: " + nextWaveInGroup);
state = SpawnState.SPAWNING;
// Spawn
// Loop through members in a wave
for (int x = 0; x < _wave.members.Length; x++) {
// each member has a name and a count, loop through this count too
for (int y = 0; y < _wave.members[x].enemyCount; y++){
// spawn this enemy name
SpawnEnemy(_wave.members[x].enemyName, _wave.spawnPosIndex);
yield return new WaitForSeconds (1f / _wave.members[x].spawnRate);
}
}
nextWave ++;
// Debug.Log ("WAVE SPAWNER: Next Wave = " + nextWave);
// Check if there are any groups
if (groupCount > 0)
{
// There are groups, so check if there are still waves to spawn inside this group
if (nextWaveInGroup < wavesInGroup - 1)
{
// // Get the next wave in this group
nextWaveInGroup ++;
// Spawn the next wave in this group
waveCountDown = timeBetweenWaves;
// Set state to waiting while wavecountdown counts down and switches this back to Spawning
state = SpawnState.WAITING;
}
else
{ // In this case, there ARE groups but no more waves to spawn in this group
// Reset next wave in group
nextWaveInGroup = 0;
// This GROUP is done spawning, so we must go to the NEXT group
nextGroup++;
// NOTE: This NEXT GROUP of waves CANNOT spawn until the terraformer has started its cycle again
// Make sure we haven't already spawned the last group
if (nextGroup <= groupCount)
{
//
// start peace time and keep nextwave with its current value
peaceCountDown = peaceTime;
waveCountDown = timeBetweenWaves;
// set state to counting to begin countdown
state = SpawnState.COUNTING;
}
else
{ // The last group has already been spawned
// Check that there are no more waves left, in case there's any left that are not in group
if (nextWave <= maxWaves - 1){
// if there are we spawn
peaceCountDown = peaceTime;
waveCountDown = timeBetweenWaves;
state = SpawnState.COUNTING;
// we need to tell the spawner we won't be doing groups for this wave
wavesInGroup = 1;
groupCount = 0;
}else{
// No more groups/waves left, so STOP spawning
state = SpawnState.STOP;
displayTime.gameObject.SetActive(false);
}
}
}
}
else
{ // THERE ARE NO GROUPS
if (nextWave <= maxWaves - 1)
{
waveCountDown = timeBetweenWaves;
state = SpawnState.WAITING;
}
else
{
// No more Waves left, STOP Spawning
state = SpawnState.STOP;
displayTime.gameObject.SetActive(false);
}
}
yield break;
}
public void AddDrill(SpawnState spawnState)
{
DrillSpawns.Add(spawnState);
}
// Use this for initialization
void Start()
{
// Get the spawn positions from Spawn Point Handler
if (spwnPtHandler) {
InitializeSpawnPositions ();
} else {
spwnPtHandler = GetComponent<SpawnPoint_Handler>();
InitializeSpawnPositions();
}
if (objPool == null)
objPool = GameObject.FindGameObjectWithTag ("Pool").GetComponent<ObjectPool> ();
if (camShake == null)
camShake = GameObject.FindGameObjectWithTag ("GameController").GetComponent<CameraShake> ();
if (resourceGrid == null)
resourceGrid = GameObject.FindGameObjectWithTag ("Map").GetComponent<ResourceGrid> ();
peaceCountDown = peaceTime;
waveCountDown = timeBetweenWaves;
displayTime.text = "Next Wave in: ";
indicators = new GameObject[wavesInGroup];
// create initial indicators
CreateSpawnPointIndicators ();
maxWaves = waves.Length;
groupCount = maxWaves / wavesInGroup;
// Debug.Log ("WAVE SPAWNER: Group count = " + groupCount);
state = SpawnState.COUNTING;
}
