public static int getMaxLevel(int level, Difficulty difficulty, RuneType runeType, ToyType toyType)
{
//this is only relevant for between levels, and this is OK because the Castle doesn't have any level caps.
difficulty = difficulty == Difficulty.Null ? Difficulty.Normal : difficulty;
level = level == -1 ? 1 : level;
LevelMod mod = getLevelMod(level, difficulty);
if (mod.tower_max_level_settings == null && difficulty != Difficulty.Normal)
{
mod = getLevelMod(level, Difficulty.Normal);
}
for (int i = 0; i < mod.tower_max_level_settings.Count; i++)
{
if (mod.tower_max_level_settings[i].runeType == runeType && mod.tower_max_level_settings[i].toyType == toyType)
{
return(mod.tower_max_level_settings[i].maxLevel);
}
}
if (difficulty != Difficulty.Normal)
{
return(getMaxLevel(level, Difficulty.Normal, runeType, toyType));
}
Debug.Log($"LevelStore does not have a difficulty setting for level: {level} {difficulty} toy: {runeType} {toyType}\n");
return(0);
}
// assemblers
private void Disassemble()
{
int pointerOffset = (index * 2) + 0x1D8DB0;
ushort offsetStart = Bits.GetShort(rom, pointerOffset); pointerOffset += 2;
ushort offsetEnd = Bits.GetShort(rom, pointerOffset);
if (index == 0x1FF)
{
offsetEnd = 0;
}
// no exit fields for level
if (offsetStart >= offsetEnd)
{
return;
}
//
int offset = offsetStart + 0x1D0000;
if (index == 84)
{
index = 84;
}
while (offset < offsetEnd + 0x1D0000)
{
LevelMod tMod = new LevelMod();
tMod.Disassemble(ref offset);
mods.Add(tMod);
}
}
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);
}
public void Insert(int index, LevelMod copy)
{
if (index < mods.Count)
{
mods.Insert(index, copy);
}
else
{
mods.Add(copy);
}
}
// spawning
public LevelMod Copy()
{
LevelMod copy = new LevelMod();
copy.Tiles = Bits.Copy(tiles);
copy.Pixels = Bits.Copy(pixels);
copy.Tilemap_Bytes = Bits.Copy(tilemap_Bytes);
copy.Width = width;
copy.Height = height;
copy.X = x;
copy.Y = y;
return(copy);
}
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 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 Insert(int index, Point p)
{
LevelMod m = new LevelMod();
m.X = (byte)p.X;
m.Y = (byte)p.Y;
m.Pixels = Solidity.Instance.GetTilemapPixels(m);
if (index < mods.Count)
{
mods.Insert(index, m);
}
else
{
mods.Add(m);
}
}
