/*
* 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);
}
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);
}
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 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 TestToJson()
{
InitLevel test = new InitLevel();
test.init_stats = new InitStats(90, 10, TimeName.Day, 24, 20, 16, new LevelMod[1], EnvType.Default);
test.toys = new InitToy[2];
test.toys[0] = new InitToy("sensible_tower", 1);
test.toys[1] = new InitToy("airy_tower", 1);
test.waves = new InitWave[2];
InitWavelet[] wavelets = new InitWavelet[2];
InitEnemyCount[] enemies0 = new InitEnemyCount[2];
enemies0[0] = new InitEnemyCount("soldier", 3, 0);
enemies0[1] = new InitEnemyCount("furfly", 3, 1);
wavelets[0] = new InitWavelet(0.5f, 3, enemies0);
//
InitEnemyCount[] enemies1 = new InitEnemyCount[2];
enemies1[0] = new InitEnemyCount("tank", 3, 0);
enemies1[1] = new InitEnemyCount("furfly", 6, 1);
wavelets[1] = new InitWavelet(0.8f, 5, enemies1);
test.waves[0] = new InitWave(TimeName.Night, TimeName.Day, 0.8f, 90, 3, wavelets);
test.waves[1] = new InitWave(TimeName.Day, TimeName.Day, 0.8f, 95, 4, wavelets);
test.wishes = new InitWish[2];
test.wishes[0] = new InitWish(WishType.MoreDamage, 2);
test.wishes[1] = new InitWish(WishType.MoreXP, 8);
Debug.Log(JsonUtility.ToJson(test, true));
}
public InitWavelet generateWavelet()
{
//if more than 1 path is selected, distribute enemies across all paths
InitWavelet wavelet = new InitWavelet();
int sub_count = 0;
foreach (WaveletBuilder wb in waveletBuilders)
{
if (wb.Valid())
{
sub_count++;
}
}
wavelet.enemies = new InitEnemyCount[sub_count * repeatTimes];
int i = 0;
for (int r = 1; r <= repeatTimes; r++)
{
foreach (WaveletBuilder wb in waveletBuilders)
{
if (!wb.Valid())
{
continue;
}
wavelet.enemies[i] = wb.getSubWavelet();
i++;
}
}
wavelet.end_wait = 10;
wavelet.lull = currentLull;
wavelet.interval = currentInterval;
return(wavelet);
}
public WaveletStatDetails calculateStats(InitWavelet wavelet, bool include_end_time)
{
WaveletStatDetails details = new WaveletStatDetails();
details.details = new List <WaveStat>();
WaveStat summary = new WaveStat();
int max = (repeatTimes > 0)? wavelet.enemies.Length / repeatTimes : wavelet.enemies.Length;
for (int x = 0; x < max; x++)
{
InitEnemyCount i = wavelet.enemies[x];
WaveStat subStat = new WaveStat();
float mass = EnemyStore.getEffectiveMass(EnumUtil.EnumFromString(i.name, EnemyType.Null));
float speed = EnemyStore.getSpeed(EnumUtil.EnumFromString(i.name, EnemyType.Null));
// Debug.Log($"BEFORE {i.name} Mass {mass} Speed {speed}\n");
//if (speed == 0) Debug.LogError($"Trying to get speed for an unsupported enemy {i.name}\n");
float time = i.c * wavelet.interval;
if (i.name.Equals("Tank"))
{
mass += EnemyStore.getEffectiveMass(EnemyType.TinyTank);
float speed_adjusted =
EnemyStore.getSpeed(EnemyType.Tank) * EnemyStore.getEffectiveMass(EnemyType.Tank)
+ EnemyStore.getSpeed(EnemyType.TinyTank) * EnemyStore.getEffectiveMass(EnemyType.TinyTank);
speed_adjusted /= mass;
speed = speed_adjusted;
}
if (i.name.Equals("SturdyTank"))
{
mass += EnemyStore.getEffectiveMass(EnemyType.Tank) + EnemyStore.getEffectiveMass(EnemyType.TinyTank);
float speed_adjusted =
EnemyStore.getSpeed(EnemyType.SturdyTank) * EnemyStore.getEffectiveMass(EnemyType.SturdyTank)
+ EnemyStore.getSpeed(EnemyType.Tank) * EnemyStore.getEffectiveMass(EnemyType.Tank)
+ EnemyStore.getSpeed(EnemyType.TinyTank) * EnemyStore.getEffectiveMass(EnemyType.TinyTank);
speed_adjusted /= mass;
speed = speed_adjusted;
}
if (i.name.Equals("ImpossibleTank"))
{
mass += EnemyStore.getEffectiveMass(EnemyType.SturdyTank) + EnemyStore.getEffectiveMass(EnemyType.Tank) + EnemyStore.getEffectiveMass(EnemyType.TinyTank);
float speed_adjusted =
EnemyStore.getSpeed(EnemyType.SturdyTank) * EnemyStore.getEffectiveMass(EnemyType.SturdyTank)
+ EnemyStore.getSpeed(EnemyType.Tank) * EnemyStore.getEffectiveMass(EnemyType.Tank)
+ EnemyStore.getSpeed(EnemyType.TinyTank) * EnemyStore.getEffectiveMass(EnemyType.TinyTank)
+ EnemyStore.getSpeed(EnemyType.ImpossibleTank) * EnemyStore.getEffectiveMass(EnemyType.ImpossibleTank);
speed_adjusted /= mass;
speed = speed_adjusted;
}
if (i.name.Equals("Turtle"))
{
mass += 8 * EnemyStore.getEffectiveMass(EnemyType.TinyPlane);
}
// Debug.Log($"AFTER {i.name} Mass {mass} Speed {speed}\n");
summary.count += i.c * repeatTimes;
summary.total_modified_mass += i.c * mass * repeatTimes;
// Debug.Log($"{i.c - 1} * {wavelet.interval} * {repeatTimes}\n");
summary.time += ((i.c - 1) * wavelet.interval) * repeatTimes;
summary.speed += speed * i.c * repeatTimes;
subStat.speed = speed;
subStat.time = time;
subStat.count = i.c;
subStat.total_modified_mass = mass * i.c;
subStat.name = i.name;
subStat.mass_per_second = speed * i.c * mass / time;
details.details.Add(subStat);
}
float extra = (include_end_time) ? wavelet.end_wait : 0;
summary.speed /= summary.count;
summary.time += (wavelet.enemies.Length - 1) * wavelet.lull + extra;
// Debug.Log($" + {wavelet.enemies.Length - 1} * {wavelet.lull} + {extra}\n");
// Debug.Log($"Speed: {summary.speed} Mass: {summary.total_modified_mass} Time: {summary.time}\n");
summary.mass_per_second = summary.speed * summary.total_modified_mass / summary.time;
details.summary = summary;
return(details);
}
public void abortWave()
{
WaveInProgress = false;
my_wavelet = null;
}
void Update()
{
if (!WaveInProgress)
{
return;
}
Sun.Instance.SetTime();
TIME += Time.deltaTime;
do_xp = true;
if (monsters_transform.childCount == 0 && (wait - TIME) > Get.getSkipForwardGap(Central.Instance.current_lvl))
{
int buffer = 2;
Debug.Log($"!!!!! {current_wave}.{current_wavelet} wavelet defined {my_wavelet!=null} SKIPPED {TIME - wait - buffer} seconds!\n");
Tracker.Log(PlayerEvent.WaveTiming, true,
new Dictionary <string, string> {
{ "attribute_1", $"{current_wave}.{current_wavelet} wavelet defined {my_wavelet!=null}" },
{ "attribute_2", "SKIPPED" }
}, new Dictionary <string, double> {
{ "metric_1", (TIME - wait - buffer) }
});
TIME = wait - buffer; // if we ran out of enemies, let's speed things along
do_xp = false;
}
if (my_wavelet == null)
{
if (monsters_transform.childCount >= 3)
{
extra_end_wait += Time.deltaTime;
return;
}
TIME = wait;
Debug.Log($"!!!!! Extra end wait {current_wave}.{current_wavelet} wavelet defined {my_wavelet != null} was {extra_end_wait}\n");
Tracker.Log(PlayerEvent.WaveTiming, true,
new Dictionary <string, string>
{
{ "attribute_1", $"{current_wave}.{current_wavelet} wavelet defined {my_wavelet != null}" },
{ "attribute_2", "WAITED" }
},
new Dictionary <string, double>()
{
{ "metric_1", extra_end_wait }
});
extra_end_wait = 0f;
do_xp = false;
}
if (!LevelBalancer.Instance.am_enabled)
{
if (do_xp)
{
if (TIME > xp_timer)
{
// Debug.Log($"Wave {current_wave} doing XP assignment {time_based_xp} {Time.realtimeSinceStartup} TIME {TIME} xp_timer {xp_timer}\n");
onTimeBasedXpAssigned?.Invoke(time_based_xp);
xp_timer += xp_grant_interval;
}
}
else
{
xp_timer = TIME + xp_grant_interval;
}
}
if (wait > 0 && TIME < wait)
{
return;
}
if (!done)
{
if (my_wavelet == null || my_wavelet.GetMonsterCount() == 0)
{
if (current_wavelet < my_wave.wavelets.Count)
{
my_wavelet = my_wave.wavelets[current_wavelet];
Noisemaker.Instance.Play("wavelet_start");
//if (!balanceMode())
SetWavelet(current_wavelet + 1);
// Debug.Log("Wavelet start end " + " Duration.time " + Duration.time + " SUN " + Sun.Instance.current_time_of_day + "\n");
m_count = 0;
e_count = 0;
if (current_wavelet == my_wave.wavelets.Count)
{
Peripheral.Instance.level_state = LState.OnLastWavelet;
Peripheral.Instance.Wave_interval = my_wavelet.getEndWait();
if (onLastWavelet != null)
{
onLastWavelet(current_wave);
}
}
}
else
{
done = true;
// Debug.Log("Wave end " + " Duration.time " + Duration.time + "\n");
Noisemaker.Instance.Play("wave_end");
}
}
if (!done)
{
bool reset = (m_count >= my_wavelet.enemies[e_count].c);
bool last = (m_count == my_wavelet.enemies[e_count].c - 1);
if (reset)
{
m_count = 0;
e_count++;
}
if (e_count < my_wavelet.enemies.Length)
{
if (last)
{
incrementWait(my_wavelet.lull);
}
else
{
incrementWait(my_wavelet.interval);
}
StartCoroutine(makeMonster(my_wavelet.enemies[e_count].name, my_wavelet.enemies[e_count].p));
m_count++;
}
else
{
if (current_wavelet != my_wave.wavelets.Count)
{
incrementWait(my_wavelet.end_wait);
}
my_wavelet = null;
}
}
return;
}
else
{
if (Peripheral.Instance.Wave_interval < 0 && monsters_transform.childCount > 0)
{
return;
}
done = true;
Noisemaker.Instance.Play("wave_end");
if (onWaveEnd != null)
{
onWaveEnd(current_wave);
}
if (!balanceMode())
{
SetWave(current_wave + 1, 0);
}
WaveInProgress = false;
Peripheral.Instance.level_state = LState.WaveEnded;
}
}
public void add_wavelet(InitWavelet w, bool old_school)
{
wavelets.Add(w);
monster_count += w.GetMonsterCount();
total_run_time += w.GetTotalRunTime(old_school);
}
