private void StartTimer(TimeName timeName, string timeValue)
{
// Get human readable version of time name
string timeNameDescription = EnumDescription.Get <TimeName>(timeName);
// Stop colour annimation, if it is currently going
StopAnimation();
try
{
countdownTime = TimeSpan.Parse(timeValue);
countdownTimer.Start();
if (timeName == TimeName.WORK)
{
this.WindowState = FormWindowState.Minimized;
}
}
catch (OverflowException)
{
MessageBox.Show("One value in " + timeNameDescription + " time is too large or has incorrect number of digits");
}
catch (FormatException)
{
MessageBox.Show(timeNameDescription + " time value is not in correct format (hh:mm:ss)");
}
catch (Exception ex)
{
var t = ex.GetType();
MessageBox.Show("Exception in " + timeNameDescription + " time : " + ex.Message);
}
}
public static float GetTimeBonus(RuneType rune_type, ToyType toytype)
{
//if (Central.Instance.state != GameState.InGame) return 0f;
//if (toytype == ToyType.Hero) return 0f; //meh this makes things confusing cuz the hero towers are identical to regular towers but somehow do less damage during the day??
//if (rune_type == Rune)
TimeName now = Sun.Instance.GetCurrentTime();
float default_time_bonus = 0.33f;
float ghost_time_bonus = 0.33f;
switch (rune_type)
{
case RuneType.Sensible:
return((now == TimeName.Dawn || now == TimeName.Day) ? default_time_bonus : 0f);
case RuneType.Airy:
return((now == TimeName.Dawn || now == TimeName.Day) ? default_time_bonus : 0f);
case RuneType.Vexing:
return((now == TimeName.Dawn || now == TimeName.Day) ? default_time_bonus : 0f);
case RuneType.Slow:
return((now == TimeName.Night || now == TimeName.Dusk) ? ghost_time_bonus : 0f);
case RuneType.Time:
return((now == TimeName.Night || now == TimeName.Dusk) ? ghost_time_bonus : 0f);
case RuneType.Fast:
return((now == TimeName.Night || now == TimeName.Dusk) ? ghost_time_bonus : 0f);
}
return(0f);
}
public void OnDayTimeChange(TimeName name)
{
if (parent == null || !parent.active)
{
return;
}
SetTimeBonus(name);
}
public TimeOfDay(TimeName _name, Color islandColor, Color _bg_color, Color _glowy_color, EnvType _envType)
{
name = _name;
island_color = islandColor;
bg_color = _bg_color;
glowy_color = _glowy_color;
envType = _envType;
}
public InitWave(TimeName time_start, TimeName time_end, float timeChangePercent, int points, int wait_time, InitWavelet[] wavelets)
{
this.time_start = time_start.ToString();
this.time_end = time_end.ToString();
this.time_change_percent = timeChangePercent;
this.points = points;
this.wait_time = wait_time;
this.wavelets = wavelets;
}
public InitStats(int dreams, int health, TimeName time_of_day, int level_duration, int map_size_x, int map_size_y, LevelMod[] level_mod, EnvType env)
{
this.dreams = dreams;
this.health = health;
this.time_of_day = time_of_day.ToString();
this.level_duration = level_duration;
this.map_size_x = map_size_x;
this.map_size_y = map_size_y;
this.level_mod = level_mod;
this.env = env.ToString();
}
//%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%%% 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();
}
}
void SetTimeBonus(TimeName name)
{
if (time_bonus == null)
{
return;
}
if (StaticRune.GetTimeBonus(parent.rune.runetype, parent.rune.toy_type) > 0)
{
time_bonus.gameObject.SetActive(false);
}
else
{
time_bonus.gameObject.SetActive(false);
}
}
public static TimeOfDay getTimeOfDay(EnvType envType, TimeName timeName)
{
if (times.Length == 0)
{
initSettings();
}
foreach (TimeOfDay t in times)
{
if (t.equals(timeName, envType))
{
return(t);
}
}
Debug.LogError($"Could not find a time of day for {envType} {timeName}\n!!");
return(new TimeOfDay(TimeName.Day, Color.white, Color.white, Color.white, EnvType.Forest));
}
public void SetTime(TimeName n)
{
for (int i = 0; i < times.Count; i++)
{
if (times[i].name == n)
{
if (current_image.image != null && current_image.image.enabled)
{
// current_image.tweener.StopMeNow();
current_image.image.enabled = false;
}
current_image = times[i];
current_image.image.enabled = true;
// current_image.tweener.Init();
}
}
}
void ChangeTime()
{
LocationTime += Time.deltaTime;
if (LocationTime >= 0f && LocationTime <= 20f)
{
NameOfTime = TimeName.Morning;
}
else
{
if (LocationTime >= 20f && LocationTime <= 40f)
{
NameOfTime = TimeName.Day;
}
else
{
if (LocationTime >= 40f && LocationTime <= 60f)
{
NameOfTime = TimeName.Evening;
}
else
{
if (LocationTime >= 60f && LocationTime <= 80f)
{
NameOfTime = TimeName.Night;
}
else
{
if (LocationTime >= 80f)
{
DayOfYear++;
if (DayOfYear == 5)
{
DayOfYear = 0;
}
LocationTime = 0f;
ChangeSeason();
}
}
}
}
}
}
public RegularTrigger(Condition c, TimeName t)
{
condition = c;
my_timename = t;
Init();
}
public void SetTime(TimeName _tstart, TimeName _tend, float _tchange)
{
time_name_start = _tstart;
time_name_end = _tend;
time_change_percent = _tchange;
}
public bool equals(TimeName timeOfDay, EnvType envType)
{
return(timeNameEqual(name, timeOfDay) && this.envType == envType);
}
bool timeNameEqual(TimeName a, TimeName b)
{
return(a == b || (a == TimeName.Dawn && b == TimeName.Dusk) || (a == TimeName.Dusk && b == TimeName.Dawn));
}
public TimeOfDay(TimeName _name)
{
name = _name;
}
void setCurrentDayTime(TimeName daytime)
{
indicator.SetTime(daytime);
OnDayTimeChange?.Invoke(daytime);
currentTimeName = daytime; //just for reference
}
public void OnDayTimeChange(TimeName name)
{
// Debug.Log(ID + " registered a time change " + name + "\n");
UpdateStats();
}
public TimeBonus(TimeName _name, float _percent)
{
time = _name;
percent = _percent;
}
public void SetStartTime(TimeName _tstart)
{
time_name_start = _tstart;
time_name_end = TimeName.Null;
time_change_percent = 9999999999;
}
public void Init()
{
m_curLocation = LocationName.City;
m_curWeather = WeatherName.Sunny;
m_curTime = TimeName.Day;
}
