IEnumerator SpawnWave(wave _wave)
{
state = SpawnManagerState.SPAWNING;
if (_wave.count != 0)
{
//Finds a random spawner that is not occupied
if (availableSpawnPoints.Count != 0 || enemyAliveList.Count >= maxEnemyAllowed)
{
int randomSpawnerNumber = ran.Next(0, availableSpawnPoints.Count - 1);
int randomSpawnID = availableSpawnPoints[randomSpawnerNumber];
SpawnEnemy(_wave.enemy, spawnPoints[randomSpawnID].GetComponent <Enemy_Spawner>().SpawnVector2);
_wave.count--;
yield return(new WaitForSeconds(1f / _wave.rate));
}
else
{
Debug.Log("No Available SpawnPoint");
yield return(new WaitUntil(() => availableSpawnPoints.Count != 0));
}
}
state = SpawnManagerState.WAITING;
yield break;
}
/*
* public void InitMonsterStat(string name, float mass, float defense, float speed)
* {
* MonsterStat stat = new MonsterStat();
* stat.defense = defense;
* stat.speed = speed;
* stat.mass = mass;
*
* if (!monster_list.ContainsKey(name)) monster_list.Add(name, stat);
*
* }
*/
public void CalcStatsByWavelet(bool summary)
{
List <wave> waves = Moon.Instance.Waves;
stats = new List <WaveStat>();
for (int wave_number = 0; wave_number < waves.Count; wave_number++)
{
wave w = waves[wave_number];
for (int wavelet_number = 0; wavelet_number < w.wavelets.Count; wavelet_number++)
{
InitWavelet wlet = w.wavelets[wavelet_number];
Dictionary <string, IntFloat> wavelet_count = new Dictionary <string, IntFloat>();
foreach (InitEnemyCount e in wlet.enemies)
{
IntFloat count = null;
wavelet_count.TryGetValue(e.name, out count);
if (count == null)
{
wavelet_count.Add(e.name, new IntFloat(e.c, wlet.interval * e.c));
}
else
{
count.myInt += e.c;
count.myFloat += wlet.interval * e.c;
}
}
AssignWaveStat(wavelet_count, wave_number, wavelet_number);
}
}
PrintStats(summary, true);
}
public void InitWave(int i)
{
if (i == 0)
{
TIME = 0f;
}
wait = TIME;
my_wave = Waves[i];
my_wavelet = null;
LevelMod mod = Peripheral.Instance.getLevelMod();
point_factor = (mod.dream_uplift + 1f) * my_wave.point_factor();
//dmg_xp_factor = (mod.xp_uplift + 1f) * my_wave.xp_factor();
// Debug.Log($"INITIALIZING WAVE {i} point_factor {point_factor} mod.dream_uplift {mod.dream_uplift} + {Central.Instance.getCurrentDifficultyLevel().ToString()}\n");
my_wave.enemies_left = (int)my_wave.monster_count;
done = false;
m_count = 0;
WaveInProgress = true;
SetWave(i, 0);
}
void Update()
{
if (!start)
{
return;
}
wave nowWave = waves[waveIndex];
for (int i = 0; i < nowWave.waveList.Count; i++)
{
if (spawnNum[i] < nowWave.waveList[i].count)
{
coolTime[i] += Time.deltaTime;
if (coolTime[i] >= nowWave.waveList[i].delay)
{
Instantiate(nowWave.waveList[i].Enemy);
spawnNum[i]++;
coolTime[i] -= nowWave.waveList[i].delay;
}
}
}
if (isAllSpawn())
{
if (GameObject.FindGameObjectsWithTag("Enemy").Length == 0)
{
button.SetActive(true);
start = false;
waveIndex++;
text.GetComponent <Text>().text = "Wave " + (waveIndex + 1).ToString();
}
}
}
IEnumerator SpawnWave(wave _wave)
{
int chance;
Debug.Log("Spawning wave");
state = SpawnState.SPAWNING;
//Spawn
for (int i = 0; i < _wave.count; i++)
{
chance = Random.Range(1, 101);
if (state != SpawnState.WAITING)
{
if (chance < attackerChance)
{
SpawnAttacker(_wave.attackers[Random.Range(0, 4)]);
}
else
{
SpawnCitizen(_wave.citizen);
}
}
yield return(new WaitForSeconds(1f / _wave.rate));
}
state = SpawnState.WAITING;
yield break;
}
public void waveAcqState(wave cmd)
{
int i = 0;
switch (cmd)
{
case wave._NOSIGNAL:
for (i = 0; i < 4; i++)
{
ananlogCounter = ananlogCounter + checkAnalog(cmd, i);
}
break;
case wave._100MHZ:
for (i = 0; i < 4; i++)
{
ananlogCounter = ananlogCounter + checkAnalog(cmd, i);
}
break;
case wave._500MHZ:
for (i = 0; i < 4; i++)
{
ananlogCounter = ananlogCounter + checkAnalog(cmd, i);
}
break;
case wave._1HZ:
for (i = 0; i < 4; i++)
{
ananlogCounter = ananlogCounter + checkAnalog(cmd, i);
}
break;
}
}
IEnumerator spawnWave(int index)
{
CurrentWave = waves[index];
for (int i = 0; i < CurrentWave.count; i++)
{
if (player == null)
{
yield break;
}
inimigo inimigoR = CurrentWave.inimigos[Random.Range(0, CurrentWave.inimigos.Length)];
Transform randomSpot = spawnPoints[Random.Range(0, spawnPoints.Length)];
Instantiate(inimigoR, randomSpot.position, randomSpot.rotation);
if (i == CurrentWave.count - 1)
{
finished = true;
}
else
{
finished = false;
}
yield return(new WaitForSeconds(CurrentWave.timer));
}
}
public IEnumerator waveSpawn(wave waveOn)
{
int count = 0;
float addition = 0;
foreach (wavePart wavePartOn in waveOn.wavePart)
{
while (count < wavePartOn.numEnemies)
{
addition = Random.Range(-7, 7);
GameObject newEnemy = Instantiate(wavePartOn.enemy);
newEnemy.transform.position = new Vector3((transform.position.x + addition), transform.position.y - 3, (transform.position.z + Random.Range(-3, 3)));
Creep creepyBoy = newEnemy.gameObject.GetComponent <Creep>();
creepyBoy.player = gameManager.acplayer;
creepyBoy.Nexus = gameManager.Nexus;
creepyBoy.canvas1 = gameManager.canvas1;
creepyBoy.gameManager = gameManager;
gameManager.creeps.Add(creepyBoy);
GameObject healthbar = Instantiate(basicHealthbar);
healthbar.gameObject.GetComponent <AnchorUI>().objectToFollow = newEnemy.transform;
creepyBoy.healthbar = healthbar.gameObject.GetComponent <AnchorUI>();
healthbar.gameObject.transform.SetParent(gameManager.canvas1.transform);
creepyBoy.gameObject.SetActive(true);
count += 1;
yield return(new WaitForSeconds(delaySpawn));
}
count = 0;
}
//StartCoroutine(roundDelay());
}
IEnumerator spawnwave(int index)
{
currentwave = waves[index];
for (int i = 0; i < currentwave.count; i++)
{
if (player == null)
{
yield break;
}
enemy randomenamy = currentwave.enemies[Random.Range(0, currentwave.enemies.Length)];
Transform randomspot = spawnpoints[Random.Range(0, spawnpoints.Length)];
Instantiate(randomenamy, randomspot.position, randomspot.rotation);
//Debug.Log(randomspot.rotation);
if (i == currentwave.count - 1)
{
finished = true;
}
else
{
finished = false;
}
yield return(new WaitForSeconds(currentwave.timebtwspawn));
}
}
public void AddWave(wave w)
{
if (Waves == null)
{
Waves = new List <wave>();
}
// Debug.Log("Adding a wave\n");
Waves.Add(w);
}
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;
}
wave getWave()
{
wave new_wave = new wave();
InitWavelet wavelet = generateWavelet();
new_wave.add_wavelet(wavelet, false);
new_wave.monster_count = wavelet.GetMonsterCount();
new_wave.time_name_start = (day) ? TimeName.Day : TimeName.Night;
new_wave.time_name_end = (day) ? TimeName.Day : TimeName.Night;
return(new_wave);
}
bool isAllSpawn()
{
wave nowWave = waves[waveIndex];
for (int i = 0; i < nowWave.waveList.Count; i++)
{
if (spawnNum[i] < nowWave.waveList[i].count)
{
return(false);
}
}
return(true);
}
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% LOAD WAVES
public void LoadWaves(InitLevel level)
{
//random wave mode is not supported!!!
List <int> pathlist = new List <int>();
LevelMod level_mod = Peripheral.Instance.getLevelMod();
Moon.Instance.Waves = new List <wave>();
for (int x = 0; x < level.waves.Length; x++)
{
InitWave init_wave = level.waves[x];
int i = 1;
wave mywave = new wave();
mywave.points = init_wave.points;
mywave.xp = 5f;
for (int y = 0; y < init_wave.wavelets.Length; y++)
{
InitWavelet init_wavelet = init_wave.wavelets[y];
init_wavelet.Modify(level_mod.wave_time_multiplier);
mywave.add_wavelet(init_wavelet, false);
i++;
}
mywave.wait = init_wave.wait_time;
TimeName time_start = EnumUtil.EnumFromString <TimeName>(init_wave.time_start, TimeName.Null);
TimeName time_end = EnumUtil.EnumFromString <TimeName>(init_wave.time_end, TimeName.Null);
if (time_start != TimeName.Null && time_end != TimeName.Null)
{
mywave.SetTime(time_start, time_end, init_wave.time_change_percent);
}
else if (time_start != TimeName.Null)
{
mywave.SetStartTime(time_start);
}
else
{
mywave.SetStartTime(TimeName.Day);
// Debug.Log("WAVE missing start time! Assuming Day\n");
}
//mywave.adjust_total_run_time();
Moon.Instance.AddWave(mywave);
}
if (LevelBalancer.Instance.am_enabled)
{
LevelBalancer.Instance.original_waves = CloneUtil.copyList <wave>(Moon.Instance.Waves);
LevelBalancer.Instance.AutoSetPaths();
}
}
public void waveAcquisition(wave cmd)
{
int[] temp;
int i = 0;
int[,] signals;
int sleeper = 20000;
this.Refresh();
flush();
Thread.Sleep(500);
sendCommand(cmd);
Thread.Sleep(sleeper);
int totalBytes = (int)wave._BYTESAMPLES;
int jointByte = totalBytes / 2;
if (serialPort1.BytesToRead == totalBytes)
{
temp = new int[totalBytes];
while (serialPort1.BytesToRead > 0)
{
temp[i] = serialPort1.ReadByte();
i++;
}
data = new int[jointByte];
signals = new int[4, (int)wave._CHANNELSAMPLES];
int s = 0;
int _s = 0;
for (i = 0; i < jointByte; i++)
{
data[i] = ((temp[i * 2] * 256) + temp[i * 2 + 1]);
_s = i / (int)wave._CHANNELSAMPLES;
s = i % (int)wave._CHANNELSAMPLES;
signals[_s, s] = data[i];
}
for (i = 0; i < 4; i++)
{
_dataProcessing(signals, i, cmd);
__dataCaputure(signals, i, cmd);
}
//ResultsPrint(cmd);
}
else
{
flush();
}
}
private void pictureBox1_MouseDown(object sender, MouseEventArgs e)
{
lock (threadLock)
{
wave w = new wave();
Rectangle r = new Rectangle();
r.Location = new Point(pictureBox1.Width + e.X, pictureBox1.Height + e.Y);
r.Size = new Size(1, 1);
w.r = r;
w.lifeTime = 300;
w.color = Color.DarkBlue;
waves.Add(w);
}
}
void NextWave()
{
currentWaveNumber++;
if (currentWaveNumber - 1 < waves.Length)
{
currentWave = waves[currentWaveNumber - 1];
enemiesRemainingToSpawn = currentWave.enemyCount;
spawned = currentWave.enemyCount;
}
if (currentWaveNumber == 4)
{
SceneManager.LoadScene(SceneManager.GetActiveScene().buildIndex - 1);
}
}
IEnumerator SpawnWave()
{
PlayerHealth.Rounds++;
wave wave = waves[waveIndex];
EnemiesAlive = wave.count;
Debug.Log("Wave Is Coming!");
for (int i = 0; i < wave.count; i++)
{
SpawnEnemy(wave.enemy);
yield return(new WaitForSeconds(1f / wave.rate));
}
waveIndex++;
}
public void addToWaveInProgress()
{
wave part = getWave();
waveStore += JsonUtility.ToJson(part, true) + "\n";
if (waveInProgress == null)
{
waveInProgress = new wave();
}
foreach (InitWavelet wlet in part.wavelets)
{
waveInProgress.add_wavelet(wlet, false);
}
waveInProgress.xp = original_waves[currentWave].xp;
waveInProgress.points = original_waves[currentWave].points;
}
//Per separar les waves empram la llibreria del System.Collections
IEnumerator WaveSpawn()
{
Jugador.gold = Jugador.gold + 50;
//numeroDeWaves++;
Jugador.RoundSurvived++;
wave wave = waves[numeroDeWaves];
EnemicsEnPantalla = wave.comptador;
Debug.Log("Inicio próxima wave!");
for (int i = 0; i < wave.comptador; i++)
{
CrearEnemic(wave.enemyPrefab);
yield return(new WaitForSeconds(1f / wave.rate));
}
numeroDeWaves++;
}
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));
waveCount++;
Debug.Log(waveCount);
}
state = SpawnState.WAITING;
yield break;
}
IEnumerator SpawnWave(wave wave)
{
Debug.Log("spawning wave" + wave.name);
state = SpawnState.SPAWNING;
GameSystem.rounds++;
//Enemey spawn
for (int i = 0; i < wave.count; i++)
{
SpawnEnemy(wave.enemy);
yield return(new WaitForSeconds(1f / wave.spawnRate));
enemiesSpawned++;
}
state = SpawnState.WAITING;
yield break;
}
public void sendCommand(wave cmd)
{
flush();
Thread.Sleep(200);
switch (cmd)
{
case wave._NOSIGNAL: serialPort1.Write("N"); break;
case wave._100MHZ: serialPort1.Write("X"); break;
case wave._500MHZ: serialPort1.Write("Y"); break;
case wave._1HZ: serialPort1.Write("Z"); break;
case wave._TESTCOMMS: serialPort1.Write("A"); break;
case wave._LEDSTATUS: serialPort1.Write("C"); break;
}
}
IEnumerator ContinueWave(wave cur_wave)
{
foreach (enemy en in cur_wave.enemy_list)
{
if (en == null)
{
Debug.Log("WaveManager ContinueWave(): null found!");
}
else
{
enemy en_instance;
enemies_alive.Add(en_instance = Instantiate(en, spawn_location.position, Quaternion.identity));
en_instance.AttachEventManager(this);
yield return(new WaitForSeconds(en.spawn_cooldown));
}
}
cur_wave_index++;
}
public void OnCollisionEnter2D(Collision2D collision)
{
GlobalGameState state = GameObject.Find("GlobalState").GetComponent <GlobalGameState>();
if (collision.gameObject.name.Equals("wave(Clone)"))
{
wave w = collision.gameObject.GetComponent <wave>();
if (state.colorId != w.waveID)
{
GameObject.Find("Miss").GetComponent <AudioSource>().Play();
state.hits++;
if (state.hits == 1)
{
GameObject.Find("lose4").GetComponent <RectTransform>().localScale = new Vector3(0.10463f, 0.10463f, 0.10463f);
}
else if (state.hits == 2)
{
GameObject.Find("lose3").GetComponent <RectTransform>().localScale = new Vector3(0.10463f, 0.10463f, 0.10463f);
}
else if (state.hits == 3)
{
GameObject.Find("lose2").GetComponent <RectTransform>().localScale = new Vector3(0.10463f, 0.10463f, 0.10463f);
}
else if (state.hits == 4)
{
GameObject.Find("lose1").GetComponent <RectTransform>().localScale = new Vector3(0.10463f, 0.10463f, 0.10463f);
}
}
else
{
state.score += 100 + (int)((10 * state.getSpeed()) / state.getSpawnTime());
}
Destroy(collision.gameObject);
if (state.hits == 4)
{
state.gameOver = true;
GameObject.Find("Sounds").GetComponent <AudioSource>().Pause();
GameObject.Find("Boo").GetComponent <AudioSource>().Play();
Invoke("gameOver", 0.1f);
}
}
}
public void startWave()
{
currentWave = Moon.Instance.current_wave;
if (!AnyValid())
{
Noisemaker.Instance.Click(ClickType.Error);
return;
}
wave my_wave = getWave();
my_wave.points = original_waves[currentWave].points * currentPointPercent;
my_wave.xp = original_waves[currentWave].xp * currentPointPercent;
Debug.Log(JsonUtility.ToJson(my_wave.wavelets[0], false));
Debug.Log(JsonUtility.ToJson(my_wave, false));
Moon.Instance.Waves[currentWave] = my_wave;
Peripheral.Instance.StartWave();
ShowStats();
}
public void __dataCaputure(int[,] dat, int num, wave cmd)
{
string path = Directory.GetCurrentDirectory();
string filename = path + "\\" + DUT.sn + "_data.txt";
string filename2 = path + "\\";
string s = dat[num, 0].ToString();
string _s = "";
for (int i = 1; i < (int)wave._CHANNELSAMPLES; i++)
{
s = s + "," + dat[num, i].ToString();
}
switch (cmd)
{
case wave._NOSIGNAL: _s = "_NOSIGNAL"; break;
case wave._100MHZ: _s = "_100mHz"; break;
case wave._500MHZ: _s = "_500mHz"; break;
case wave._1HZ: _s = "_1Hz"; break;
}
filename2 = filename2 + _s + ".txt";
_s = num.ToString() + _s;
StreamWriter writer = new StreamWriter(File.Open(filename, FileMode.Append));
writer.WriteLine("{0},{1},{2}", DateTime.Now.ToString(), _s, s);
writer.Close();
//StreamWriter writer2 = new StreamWriter(File.Open(filename2, FileMode.Append));
//writer2.WriteLine("{0},{1}", DateTime.Now.ToString(), s);
//writer2.Close();
}
public void updateMyWave()
{
my_wave = Waves[current_wave];
}
public void _dataProcessing(int[,] dat, int chan, wave cmd)
{
long info = 0;
int _info = 0;
int min = 512;
int max = 512;
double avg;
double rms;
double vpk;
for (int i = 0; i < (int)wave._CHANNELSAMPLES; i++)
{
info = info + (long)(Math.Pow(dat[chan, i], 2));
_info = _info + dat[chan, i];
if (min > dat[chan, i])
{
min = dat[chan, i];
}
if (max < dat[chan, i])
{
max = dat[chan, i];
}
}
info = info / (int)wave._CHANNELSAMPLES;
avg = Math.Round(((_info / (double)wave._CHANNELSAMPLES) / 1024) * 2.2, 3);
rms = Math.Round(((Math.Sqrt(info)) / 1024) * 2.2, 3);
vpk = Math.Round((((double)max - (double)min) / 1024) * 2.2, 3);
switch (cmd)
{
case wave._NOSIGNAL:
DUT.channels[chan].avgOffset = avg;
DUT.channels[chan].rmsOffset = rms;
DUT.channels[chan].pkOffset = vpk;
break;
case wave._100MHZ:
DUT.channels[chan].avg100mHz = avg;
DUT.channels[chan].rms100mHz = rms;
DUT.channels[chan].pk100mHz = vpk;
break;
case wave._500MHZ:
DUT.channels[chan].avg500mHz = avg;
DUT.channels[chan].rms500mHz = rms;
DUT.channels[chan].pk500mHz = vpk;
break;
case wave._1HZ:
DUT.channels[chan].avg1Hz = avg;
DUT.channels[chan].rms1Hz = rms;
DUT.channels[chan].pk1Hz = vpk;
break;
}
}
public void ResetWaveInProgress() => waveInProgress = new wave();
void XMLStimLoad()
{
string Name = "";
int TS=-1;
int St=-1;
int WaveNode = -1;
bool StimVal = true;
int Tm = -1;
WaveList = new List<wave>();
XmlTextReader reader = new XmlTextReader(StimFile);
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.Element) // The node is not an element.
{
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.EndElement)
break;
if (reader.NodeType == XmlNodeType.Element) // The node is not an element.
{
while (reader.MoveToNextAttribute())
{
switch (reader.Name)
{
case "comp":
Name = reader.Value;
break;
case "TimeStep":
TS = Convert.ToInt32(reader.Value);
break;
case "Start":
St = Convert.ToInt32(reader.Value);
break;
}
}
foreach(Node N in Net)
{
if(String.Compare(Name, N.Name) == 0)
{
WaveNode = N.NodeNb;
}
}
if(WaveNode == -1)
{
Console.WriteLine("The Waveform is not associated to a valid component");
Environment.Exit(1);
}
wave CurrWave = new wave(Name, St, TS);
bool StartState = true;
if (St == 0)
StartState = false;
WaveList.Add(CurrWave);
CurrWave.WaveForm.Add(new Stim(StartState, 0, WaveNode));
while (reader.Read())
{
if (reader.NodeType == XmlNodeType.EndElement)
break;
if (reader.NodeType != XmlNodeType.Element)
continue;
while (reader.MoveToNextAttribute())
{
switch (reader.Name)
{
case "type":
if(String.Compare(reader.Value, "1") == 0)
StimVal = true;
else
StimVal = false;
break;
case "time":
Tm = Convert.ToInt32(reader.Value);
break;
}
}
CurrWave.WaveForm.Add(new Stim(StimVal, Tm, WaveNode));
}
}
}
}
}
Tm = -1;
}
