public void SetSettings(XmlNode settings)
{
XmlNode orderedNode = settings.SelectSingleNode(".//Ordered");
XmlNode AutosplitEndRunsNode = settings.SelectSingleNode(".//AutosplitEndRuns");
bool isOrdered = false;
bool isAutosplitEndRuns = false;
if (orderedNode != null)
{
bool.TryParse(orderedNode.InnerText, out isOrdered);
}
if (AutosplitEndRunsNode != null)
{
bool.TryParse(AutosplitEndRunsNode.InnerText, out isAutosplitEndRuns);
}
Ordered = isOrdered;
AutosplitEndRuns = isAutosplitEndRuns;
Splits.Clear();
XmlNodeList splitNodes = settings.SelectNodes(".//Splits/Split");
foreach (XmlNode splitNode in splitNodes)
{
string splitDescription = splitNode.InnerText;
SplitName split = HollowKnightSplitSettings.GetSplitName(splitDescription);
Splits.Add(split);
}
}
private void cboName_SelectedIndexChanged(object sender, EventArgs e)
{
string splitDescription = cboName.SelectedValue.ToString();
SplitName split = GetEnumValue <SplitName>(splitDescription);
Split = split.ToString();
if (splitDescription.IndexOf("(Boss)") < 0 && splitDescription.IndexOf("(Run 'n Gun)") < 0)
{
cboGrade.SelectedItem = "Any";
cboDifficulty.SelectedItem = "Any";
cboGrade.Visible = false;
cboDifficulty.Visible = false;
btnRemove.Location = new System.Drawing.Point(274, 2);
}
else if (splitDescription.IndexOf("(Run 'n Gun)") > 0)
{
cboDifficulty.SelectedItem = "Any";
btnRemove.Location = new System.Drawing.Point(331, 2);
cboGrade.Visible = true;
cboDifficulty.Visible = false;
}
else
{
btnRemove.Location = new System.Drawing.Point(399, 2);
cboGrade.Visible = true;
cboDifficulty.Visible = true;
}
MemberInfo info = typeof(SplitName).GetMember(split.ToString())[0];
DescriptionAttribute description = (DescriptionAttribute)info.GetCustomAttributes(typeof(DescriptionAttribute), false)[0];
ToolTipAttribute tooltip = (ToolTipAttribute)info.GetCustomAttributes(typeof(ToolTipAttribute), false)[0];
ToolTips.SetToolTip(cboName, tooltip.ToolTip);
}
public void LoadSettings()
{
isLoading = true;
this.flowMain.SuspendLayout();
for (int i = flowMain.Controls.Count - 1; i > 0; i--)
{
flowMain.Controls.RemoveAt(i);
}
for (int i = 0; i < Splits.Count; i++)
{
SplitName split = Splits[i];
MemberInfo info = typeof(SplitName).GetMember(split.ToString())[0];
DescriptionAttribute description = (DescriptionAttribute)info.GetCustomAttributes(typeof(DescriptionAttribute), false)[0];
SteamWorldSplitSettings setting = new SteamWorldSplitSettings();
setting.cboName.DataSource = GetAvailableSplits();
setting.cboName.Text = description.Description;
SetSplitDescription(setting, i);
AddHandlers(setting);
flowMain.Controls.Add(setting);
}
isLoading = false;
this.flowMain.ResumeLayout(true);
}
public int GetSettingsHashCode()
{
unchecked {
int res = Delay.GetHashCode();
res = (res * 397) ^ SelectedTimeUnit.GetHashCode();
res = (res * 397) ^ SplitName.GetHashCode();
res += EnableSmart ? 1 : 0;
return(res);
}
}
private void HandleSplits(string scene)
{
bool shouldSplit = false;
bool loading = mem.Loading();
if (currentSplit <= Model.CurrentState.Run.Count && currentSplit < settings.Splits.Count)
{
SplitName split = settings.Splits[currentSplit];
switch (split)
{
case SplitName.StartGame:
string saveName = mem.SaveName();
if (!string.IsNullOrEmpty(saveName))
{
DateTime saveDate = DateTime.MinValue;
try {
saveDate = DateTime.FromBinary(Convert.ToInt64(saveName.Substring(4), 16));
} catch { }
shouldSplit = mem.LastHooked.AddSeconds(5) < DateTime.Now && scene == "_MainMenu" && saveName != lastSaveName && saveDate >= DateTime.Now.AddSeconds(-5);
}
lastSaveName = saveName;
break;
case SplitName.DukeKang: shouldSplit = !loading && scene == "0102" && BossSplit("Bs004"); break;
case SplitName.GeneralWu1: shouldSplit = !loading && scene == "0309" && BossSplit("Bs002"); break;
case SplitName.GeneralWu2: shouldSplit = !loading && scene == "0322" && BossSplit("Bs002_undead"); break;
case SplitName.XiaZhengshu1: shouldSplit = !loading && scene == "0406" && BossSplit("Bs005"); break;
case SplitName.Wen: shouldSplit = !loading && scene == "0420" && BossSplit("Bs001"); break;
case SplitName.Bogu1: shouldSplit = !loading && scene == "0525" && BossSplit("Bs006"); break;
case SplitName.EmperorOfZhou: shouldSplit = !loading && scene == "0610" && BossSplit("Bs007"); break;
case SplitName.TheSerpent: shouldSplit = !loading && scene == "0620" && BossSplit("Bs008"); break;
case SplitName.GeneralWu3: shouldSplit = !loading && scene == "0703" && BossSplit("Bs002_dead"); break;
case SplitName.XiaZhengshu2: shouldSplit = !loading && scene == "0704" && BossSplit("Bs005_dead"); break;
case SplitName.Bogu2: shouldSplit = !loading && scene == "0705" && BossSplit("Bs006_dead"); break;
case SplitName.TianRangju: shouldSplit = !loading && scene == "0707" && BossSplit("Bs009"); break;
}
}
Model.CurrentState.IsGameTimePaused = Model.CurrentState.CurrentPhase != TimerPhase.Running || loading || scene == "_Loading";
HandleSplit(shouldSplit, false);
}
public void SetSettings(XmlNode settings)
{
Splits.Clear();
XmlNodeList splitNodes = settings.SelectNodes(".//Splits/Split");
foreach (XmlNode splitNode in splitNodes)
{
string splitDescription = splitNode.InnerText;
SplitName split = SplitterSplitSettings.GetEnumValue <SplitName>(splitDescription);
Splits.Add(split);
}
}
public void SetSettings(XmlNode settings)
{
Splits.Clear();
XmlNodeList splitNodes = settings.SelectNodes(".//Splits/Split");
foreach (XmlNode splitNode in splitNodes)
{
string splitDescription = splitNode.InnerText;
SplitName split = HollowKnightSplitSettings.GetSplitName(splitDescription);
Splits.Add(split);
}
}
private void cboName_SelectedIndexChanged(object sender, EventArgs e)
{
string splitDescription = cboName.SelectedValue.ToString();
SplitName split = GetSplitName(splitDescription);
Split = split.ToString();
MemberInfo info = typeof(SplitName).GetMember(split.ToString())[0];
DescriptionAttribute description = (DescriptionAttribute)info.GetCustomAttributes(typeof(DescriptionAttribute), false)[0];
ToolTipAttribute tooltip = (ToolTipAttribute)info.GetCustomAttributes(typeof(ToolTipAttribute), false)[0];
ToolTips.SetToolTip(cboName, tooltip.ToolTip);
}
public void SetSettings(XmlNode settings)
{
Splits.Clear();
XmlNodeList splitNodes = settings.SelectNodes(".//Splits/Split");
foreach (XmlNode splitNode in splitNodes)
{
string splitDescription = splitNode.InnerText;
SplitName split = HollowKnightSplitSettings.GetSplitName(splitDescription);
Splits.Add(split);
}
XmlNode gameTime = settings.SelectSingleNode(".//OldGameTime");
OldGameTime = gameTime == null || string.IsNullOrEmpty(gameTime.InnerText) ? false : bool.Parse(gameTime.InnerText);
}
private void cboType_SelectedIndexChanged(object sender, EventArgs e)
{
string splitDescription = cboSplit.SelectedValue.ToString();
SplitName split = GetEnumValue <SplitName>(splitDescription);
MemberInfo[] infos = typeof(SplitName).GetMember(split.ToString());
DescriptionAttribute[] descriptions = null;
if (infos.Length > 0)
{
descriptions = (DescriptionAttribute[])infos[0].GetCustomAttributes(typeof(DescriptionAttribute), false);
}
if (descriptions != null && descriptions.Length > 0)
{
ToolTips.SetToolTip(cboSplit, descriptions[0].Description);
}
else
{
ToolTips.SetToolTip(cboSplit, string.Empty);
}
}
public void UpdateSplits()
{
if (isLoading)
{
return;
}
Splits.Clear();
foreach (Control c in flowMain.Controls)
{
if (c is HollowKnightSplitSettings)
{
HollowKnightSplitSettings setting = (HollowKnightSplitSettings)c;
if (!string.IsNullOrEmpty(setting.cboName.Text))
{
SplitName split = HollowKnightSplitSettings.GetSplitName(setting.cboName.Text);
Splits.Add(split);
}
}
}
}
private void HandleSplits()
{
bool shouldSplit = false;
if (currentSplit == -1)
{
bool hasPointer = mem.HasPointer();
shouldSplit = lastHasPointer != hasPointer && DateTime.Now > mem.LastHooked.AddSeconds(5);
lastHasPointer = hasPointer;
}
else if (Model.CurrentState.CurrentPhase == TimerPhase.Running)
{
int floor = mem.Floor();
int hp = mem.HasPointer(Player.Enemy) ? mem.HP(Player.Enemy) : 1;
SplitName split = currentSplit < Model.CurrentState.Run.Count && currentSplit < settings.Splits.Count ? settings.Splits[currentSplit] : SplitName.Boss;
switch (split)
{
case SplitName.Floor1: shouldSplit = lastFloor == 1 && floor == 2; break;
case SplitName.Floor2: shouldSplit = lastFloor == 2 && floor == 3; break;
case SplitName.Floor3: shouldSplit = lastFloor == 3 && floor == 4; break;
case SplitName.Floor4: shouldSplit = lastFloor == 4 && floor == 5; break;
case SplitName.Floor5: shouldSplit = lastFloor == 5 && floor == 6; break;
case SplitName.Boss: shouldSplit = floor == 6 && hp <= 0 && lastHP > 0; break;
}
lastFloor = floor;
lastHP = hp;
}
HandleSplit(shouldSplit, false);
}
public void UpdateSplits()
{
if (isLoading)
{
return;
}
Splits.Clear();
for (int i = flowMain.Controls.Count - 1; i >= 0; i--)
{
Control c = flowMain.Controls[i];
if (c is SteamWorldSplitSettings)
{
SteamWorldSplitSettings setting = (SteamWorldSplitSettings)c;
if (!string.IsNullOrEmpty(setting.cboName.Text))
{
SplitName split = SteamWorldSplitSettings.GetSplitName(setting.cboName.Text);
Splits.Insert(0, split);
}
SetSplitDescription(setting, i - 1);
}
}
}
private void HandleSplits()
{
bool shouldSplit = false;
string nextScene = mem.NextSceneName();
string sceneName = mem.SceneName();
if (currentSplit == -1)
{
shouldSplit = (nextScene.Equals("Tutorial_01", StringComparison.OrdinalIgnoreCase) && mem.GameState() == GameState.ENTERING_LEVEL) || nextScene == "GG_Vengefly_V" || nextScene == "GG_Boss_Door_Entrance";
}
else if (Model.CurrentState.CurrentPhase == TimerPhase.Running && settings.Splits.Count > 0)
{
GameState gameState = mem.GameState();
SplitName finalSplit = settings.Splits[settings.Splits.Count - 1];
if (currentSplit + 1 < Model.CurrentState.Run.Count || (currentSplit + 1 == Model.CurrentState.Run.Count && (finalSplit == SplitName.ElderbugFlower || finalSplit == SplitName.ZoteKilled || finalSplit == SplitName.HuskMiner || finalSplit == SplitName.KingsPass || finalSplit == SplitName.GreatHopper || finalSplit == SplitName.PathOfPain)))
{
if (!settings.Ordered)
{
foreach (SplitName split in settings.Splits)
{
if (splitsDone.Contains(split) || gameState != GameState.PLAYING)
{
continue;
}
shouldSplit = CheckSplit(split, nextScene, sceneName);
if (shouldSplit)
{
splitsDone.Add(split);
break;
}
}
}
else if (currentSplit < settings.Splits.Count)
{
SplitName split = settings.Splits[currentSplit];
shouldSplit = CheckSplit(split, nextScene, sceneName);
}
}
else
{
shouldSplit = nextScene.StartsWith("Cinematic_Ending", StringComparison.OrdinalIgnoreCase) || nextScene == "GG_End_Sequence";
}
UIState uiState = mem.UIState();
bool loadingMenu = (string.IsNullOrEmpty(nextScene) && sceneName != "Menu_Title") || (nextScene == "Menu_Title" && sceneName != "Menu_Title");
if (gameState == GameState.PLAYING && lastGameState == GameState.MAIN_MENU)
{
lookForTeleporting = true;
}
bool teleporting = mem.CameraTeleporting();
if (lookForTeleporting && (teleporting || (gameState != GameState.PLAYING && gameState != GameState.ENTERING_LEVEL)))
{
lookForTeleporting = false;
}
Model.CurrentState.IsGameTimePaused =
(gameState == GameState.PLAYING && teleporting && !mem.HazardRespawning()) ||
lookForTeleporting ||
((gameState == GameState.PLAYING || gameState == GameState.ENTERING_LEVEL) && uiState != UIState.PLAYING) ||
(gameState != GameState.PLAYING && !mem.AcceptingInput()) ||
gameState == GameState.EXITING_LEVEL ||
gameState == GameState.LOADING ||
mem.HeroTransitionState() == HeroTransitionState.WAITING_TO_ENTER_LEVEL ||
(uiState != UIState.PLAYING &&
(uiState != UIState.PAUSED || loadingMenu) &&
(!string.IsNullOrEmpty(nextScene) || sceneName == "_test_charms" || loadingMenu) &&
nextScene != sceneName) ||
(nextScene != sceneName && mem.TileMapDirty() && !mem.UsesSceneTransitionRoutine());
lastGameState = gameState;
}
HandleSplit(shouldSplit);
}
private bool CheckSplit(SplitName split, string nextScene, string sceneName)
{
bool shouldSplit = false;
switch (split)
{
case SplitName.Abyss: shouldSplit = mem.PlayerData <bool>(Offset.visitedAbyss); break;
case SplitName.AbyssShriek: shouldSplit = mem.PlayerData <int>(Offset.screamLevel) == 2; break;
case SplitName.AspidHunter: shouldSplit = mem.PlayerData <int>(Offset.killsSpitter) == 17; break;
case SplitName.BaldurShell: shouldSplit = mem.PlayerData <bool>(Offset.gotCharm_5); break;
case SplitName.BeastsDenTrapBench: shouldSplit = mem.PlayerData <bool>(Offset.spiderCapture); break;
case SplitName.BlackKnight: shouldSplit = mem.PlayerData <bool>(Offset.killedBlackKnight); break;
case SplitName.BrettaRescued: shouldSplit = mem.PlayerData <bool>(Offset.brettaRescued); break;
case SplitName.BrummFlame: shouldSplit = mem.PlayerData <bool>(Offset.gotBrummsFlame); break;
case SplitName.BrokenVessel: shouldSplit = mem.PlayerData <bool>(Offset.killedInfectedKnight); break;
case SplitName.BroodingMawlek: shouldSplit = mem.PlayerData <bool>(Offset.killedMawlek); break;
case SplitName.CityOfTears: shouldSplit = mem.PlayerData <bool>(Offset.visitedRuins); break;
case SplitName.Collector: shouldSplit = mem.PlayerData <bool>(Offset.collectorDefeated); break;
case SplitName.Colosseum: shouldSplit = mem.PlayerData <bool>(Offset.seenColosseumTitle); break;
case SplitName.ColosseumBronze: shouldSplit = mem.PlayerData <bool>(Offset.colosseumBronzeCompleted); break;
case SplitName.ColosseumGold: shouldSplit = mem.PlayerData <bool>(Offset.colosseumGoldCompleted); break;
case SplitName.ColosseumSilver: shouldSplit = mem.PlayerData <bool>(Offset.colosseumSilverCompleted); break;
case SplitName.CrossroadsStation: shouldSplit = mem.PlayerData <bool>(Offset.openedCrossroads); break;
case SplitName.CrystalGuardian1: shouldSplit = mem.PlayerData <bool>(Offset.defeatedMegaBeamMiner); break;
case SplitName.CrystalGuardian2: shouldSplit = mem.PlayerData <int>(Offset.killsMegaBeamMiner) == 0; break;
case SplitName.CrystalHeart: shouldSplit = mem.PlayerData <bool>(Offset.hasSuperDash); break;
case SplitName.CrystalPeak: shouldSplit = mem.PlayerData <bool>(Offset.visitedMines); break;
case SplitName.CycloneSlash: shouldSplit = mem.PlayerData <bool>(Offset.hasCyclone); break;
case SplitName.Dashmaster: shouldSplit = mem.PlayerData <bool>(Offset.gotCharm_31); break;
case SplitName.DashSlash: shouldSplit = mem.PlayerData <bool>(Offset.hasUpwardSlash); break;
case SplitName.DeepFocus: shouldSplit = mem.PlayerData <bool>(Offset.gotCharm_34); break;
case SplitName.Deepnest: shouldSplit = mem.PlayerData <bool>(Offset.visitedDeepnest); break;
case SplitName.DeepnestSpa: shouldSplit = mem.PlayerData <bool>(Offset.visitedDeepnestSpa); break;
case SplitName.DeepnestStation: shouldSplit = mem.PlayerData <bool>(Offset.openedDeepnest); break;
case SplitName.DefendersCrest: shouldSplit = mem.PlayerData <bool>(Offset.gotCharm_10); break;
case SplitName.DescendingDark: shouldSplit = mem.PlayerData <int>(Offset.quakeLevel) == 2; break;
case SplitName.DesolateDive: shouldSplit = mem.PlayerData <int>(Offset.quakeLevel) == 1; break;
case SplitName.Dirtmouth: shouldSplit = mem.PlayerData <bool>(Offset.visitedDirtmouth); break;
case SplitName.DreamNail: shouldSplit = mem.PlayerData <bool>(Offset.hasDreamNail); break;
case SplitName.DreamNail2: shouldSplit = mem.PlayerData <bool>(Offset.dreamNailUpgraded); break;
case SplitName.DreamGate: shouldSplit = mem.PlayerData <bool>(Offset.hasDreamGate); break;
case SplitName.Dreamshield: shouldSplit = mem.PlayerData <bool>(Offset.gotCharm_38); break;
case SplitName.DreamWielder: shouldSplit = mem.PlayerData <bool>(Offset.gotCharm_30); break;
case SplitName.DungDefender: shouldSplit = mem.PlayerData <bool>(Offset.killedDungDefender); break;
case SplitName.ElderbugFlower: shouldSplit = mem.PlayerData <bool>(Offset.elderbugGaveFlower); break;
case SplitName.ElderHu: shouldSplit = mem.PlayerData <bool>(Offset.killedGhostHu); break;
case SplitName.FailedKnight: shouldSplit = mem.PlayerData <bool>(Offset.falseKnightDreamDefeated); break;
case SplitName.FalseKnight: shouldSplit = mem.PlayerData <bool>(Offset.killedFalseKnight); break;
case SplitName.Flukemarm: shouldSplit = mem.PlayerData <bool>(Offset.killedFlukeMother); break;
case SplitName.Flukenest: shouldSplit = mem.PlayerData <bool>(Offset.gotCharm_11); break;
case SplitName.FogCanyon: shouldSplit = mem.PlayerData <bool>(Offset.visitedFogCanyon); break;
case SplitName.ForgottenCrossroads: shouldSplit = mem.PlayerData <bool>(Offset.visitedCrossroads); break;
case SplitName.FragileGreed: shouldSplit = mem.PlayerData <bool>(Offset.gotCharm_24); break;
case SplitName.FragileHeart: shouldSplit = mem.PlayerData <bool>(Offset.gotCharm_23); break;
case SplitName.FragileStrength: shouldSplit = mem.PlayerData <bool>(Offset.gotCharm_25); break;
case SplitName.FungalWastes: shouldSplit = mem.PlayerData <bool>(Offset.visitedFungus); break;
case SplitName.FuryOfTheFallen: shouldSplit = mem.PlayerData <bool>(Offset.gotCharm_6); break;
case SplitName.Galien: shouldSplit = mem.PlayerData <bool>(Offset.killedGhostGalien); break;
case SplitName.GatheringSwarm: shouldSplit = mem.PlayerData <bool>(Offset.gotCharm_1); break;
case SplitName.GlowingWomb: shouldSplit = mem.PlayerData <bool>(Offset.gotCharm_22); break;
case SplitName.Godhome: shouldSplit = mem.PlayerData <bool>(Offset.visitedGodhome); break;
case SplitName.GodTamer: shouldSplit = mem.PlayerData <bool>(Offset.killedLobsterLancer); break;
case SplitName.GodTuner: shouldSplit = mem.PlayerData <bool>(Offset.hasGodfinder); break;
case SplitName.Gorb: shouldSplit = mem.PlayerData <bool>(Offset.killedGhostAladar); break;
case SplitName.GorgeousHusk: shouldSplit = mem.PlayerData <bool>(Offset.killedGorgeousHusk); break;
case SplitName.GreatSlash: shouldSplit = mem.PlayerData <bool>(Offset.hasDashSlash); break;
case SplitName.Greenpath: shouldSplit = mem.PlayerData <bool>(Offset.visitedGreenpath); break;
case SplitName.Grimmchild: shouldSplit = mem.PlayerData <bool>(Offset.gotCharm_40); break;
case SplitName.Grimmchild2: shouldSplit = mem.PlayerData <int>(Offset.grimmChildLevel) == 2; break;
case SplitName.Grimmchild3: shouldSplit = mem.PlayerData <int>(Offset.grimmChildLevel) == 3; break;
case SplitName.Grimmchild4: shouldSplit = mem.PlayerData <int>(Offset.grimmChildLevel) == 4; break;
case SplitName.GrubberflysElegy: shouldSplit = mem.PlayerData <bool>(Offset.gotCharm_35); break;
case SplitName.Grubsong: shouldSplit = mem.PlayerData <bool>(Offset.gotCharm_3); break;
case SplitName.GreatHopper: shouldSplit = mem.PlayerData <bool>(Offset.killedGiantHopper); break;
case SplitName.GreyPrince: shouldSplit = mem.PlayerData <bool>(Offset.killedGreyPrince); break;
case SplitName.GruzMother: shouldSplit = mem.PlayerData <bool>(Offset.killedBigFly); break;
case SplitName.HeavyBlow: shouldSplit = mem.PlayerData <bool>(Offset.gotCharm_15); break;
case SplitName.Hegemol: shouldSplit = mem.PlayerData <bool>(Offset.hegemolDefeated); break;
case SplitName.Hive: shouldSplit = mem.PlayerData <bool>(Offset.visitedHive); break;
case SplitName.Hiveblood: shouldSplit = mem.PlayerData <bool>(Offset.gotCharm_29); break;
case SplitName.HollowKnight: shouldSplit = nextScene.Equals("Dream_Final_Boss", StringComparison.OrdinalIgnoreCase); break;
case SplitName.Hornet1: shouldSplit = mem.PlayerData <bool>(Offset.killedHornet); break;
case SplitName.Hornet2: shouldSplit = mem.PlayerData <bool>(Offset.hornetOutskirtsDefeated); break;
case SplitName.HowlingWraiths: shouldSplit = mem.PlayerData <int>(Offset.screamLevel) == 1; break;
case SplitName.HuntersMark: shouldSplit = mem.PlayerData <bool>(Offset.killedHunterMark); break;
case SplitName.HuskMiner: shouldSplit = mem.PlayerData <bool>(Offset.killedZombieMiner); break;
case SplitName.InfectedCrossroads: shouldSplit = mem.PlayerData <bool>(Offset.crossroadsInfected) && mem.PlayerData <bool>(Offset.visitedCrossroads); break;
case SplitName.IsmasTear: shouldSplit = mem.PlayerData <bool>(Offset.hasAcidArmour); break;
case SplitName.JonisBlessing: shouldSplit = mem.PlayerData <bool>(Offset.gotCharm_27); break;
case SplitName.KingdomsEdge: shouldSplit = mem.PlayerData <bool>(Offset.visitedOutskirts); break;
case SplitName.KingsBrand: shouldSplit = mem.PlayerData <bool>(Offset.hasKingsBrand); break;
case SplitName.Kingsoul: shouldSplit = mem.PlayerData <int>(Offset.charmCost_36) == 5 && mem.PlayerData <int>(Offset.royalCharmState) == 3; break;
case SplitName.KingsStationStation: shouldSplit = mem.PlayerData <bool>(Offset.openedRuins2); break;
case SplitName.Lemm1: shouldSplit = mem.PlayerData <bool>(Offset.metRelicDealer); break;
case SplitName.Lemm2: shouldSplit = mem.PlayerData <bool>(Offset.metRelicDealerShop); break;
case SplitName.LifebloodCore: shouldSplit = mem.PlayerData <bool>(Offset.gotCharm_9); break;
case SplitName.LifebloodHeart: shouldSplit = mem.PlayerData <bool>(Offset.gotCharm_8); break;
case SplitName.LittleFool: shouldSplit = mem.PlayerData <bool>(Offset.littleFoolMet); break;
case SplitName.Longnail: shouldSplit = mem.PlayerData <bool>(Offset.gotCharm_18); break;
case SplitName.LostKin: shouldSplit = mem.PlayerData <bool>(Offset.infectedKnightDreamDefeated); break;
case SplitName.LoveKey: shouldSplit = mem.PlayerData <bool>(Offset.hasLoveKey); break;
case SplitName.LumaflyLantern: shouldSplit = mem.PlayerData <bool>(Offset.hasLantern); break;
case SplitName.Lurien: shouldSplit = mem.PlayerData <bool>(Offset.lurienDefeated); break;
case SplitName.MantisClaw: shouldSplit = mem.PlayerData <bool>(Offset.hasWallJump); break;
case SplitName.MantisLords: shouldSplit = mem.PlayerData <bool>(Offset.defeatedMantisLords); break;
case SplitName.MarkOfPride: shouldSplit = mem.PlayerData <bool>(Offset.gotCharm_13); break;
case SplitName.Markoth: shouldSplit = mem.PlayerData <bool>(Offset.killedGhostMarkoth); break;
case SplitName.Marmu: shouldSplit = mem.PlayerData <bool>(Offset.killedGhostMarmu); break;
case SplitName.MaskFragment1: shouldSplit = mem.PlayerData <int>(Offset.maxHealthBase) == 5 && mem.PlayerData <int>(Offset.heartPieces) == 1; break;
case SplitName.MaskFragment2: shouldSplit = mem.PlayerData <int>(Offset.maxHealthBase) == 5 && mem.PlayerData <int>(Offset.heartPieces) == 2; break;
case SplitName.MaskFragment3: shouldSplit = mem.PlayerData <int>(Offset.maxHealthBase) == 5 && mem.PlayerData <int>(Offset.heartPieces) == 3; break;
case SplitName.Mask1: shouldSplit = mem.PlayerData <int>(Offset.maxHealthBase) == 6; break;
case SplitName.MaskFragment5: shouldSplit = mem.PlayerData <int>(Offset.heartPieces) == 5 || (mem.PlayerData <int>(Offset.maxHealthBase) == 6 && mem.PlayerData <int>(Offset.heartPieces) == 1); break;
case SplitName.MaskFragment6: shouldSplit = mem.PlayerData <int>(Offset.heartPieces) == 6 || (mem.PlayerData <int>(Offset.maxHealthBase) == 6 && mem.PlayerData <int>(Offset.heartPieces) == 2); break;
case SplitName.MaskFragment7: shouldSplit = mem.PlayerData <int>(Offset.heartPieces) == 7 || (mem.PlayerData <int>(Offset.maxHealthBase) == 6 && mem.PlayerData <int>(Offset.heartPieces) == 3); break;
case SplitName.Mask2: shouldSplit = mem.PlayerData <int>(Offset.maxHealthBase) == 7; break;
case SplitName.MaskFragment9: shouldSplit = mem.PlayerData <int>(Offset.heartPieces) == 9 || (mem.PlayerData <int>(Offset.maxHealthBase) == 7 && mem.PlayerData <int>(Offset.heartPieces) == 1); break;
case SplitName.MaskFragment10: shouldSplit = mem.PlayerData <int>(Offset.heartPieces) == 10 || (mem.PlayerData <int>(Offset.maxHealthBase) == 7 && mem.PlayerData <int>(Offset.heartPieces) == 2); break;
case SplitName.MaskFragment11: shouldSplit = mem.PlayerData <int>(Offset.heartPieces) == 11 || (mem.PlayerData <int>(Offset.maxHealthBase) == 7 && mem.PlayerData <int>(Offset.heartPieces) == 3); break;
case SplitName.Mask3: shouldSplit = mem.PlayerData <int>(Offset.maxHealthBase) == 8; break;
case SplitName.MaskFragment13: shouldSplit = mem.PlayerData <int>(Offset.heartPieces) == 13 || (mem.PlayerData <int>(Offset.maxHealthBase) == 8 && mem.PlayerData <int>(Offset.heartPieces) == 1); break;
case SplitName.MaskFragment14: shouldSplit = mem.PlayerData <int>(Offset.heartPieces) == 14 || (mem.PlayerData <int>(Offset.maxHealthBase) == 8 && mem.PlayerData <int>(Offset.heartPieces) == 2); break;
case SplitName.MaskFragment15: shouldSplit = mem.PlayerData <int>(Offset.heartPieces) == 15 || (mem.PlayerData <int>(Offset.maxHealthBase) == 8 && mem.PlayerData <int>(Offset.heartPieces) == 3); break;
case SplitName.Mask4: shouldSplit = mem.PlayerData <int>(Offset.maxHealthBase) == 9; break;
case SplitName.MatoOroNailBros: shouldSplit = mem.PlayerData <bool>(Offset.killedNailBros); break;
case SplitName.MegaMossCharger: shouldSplit = mem.PlayerData <bool>(Offset.megaMossChargerDefeated); break;
case SplitName.MonarchWings: shouldSplit = mem.PlayerData <bool>(Offset.hasDoubleJump); break;
case SplitName.Monomon: shouldSplit = mem.PlayerData <bool>(Offset.monomonDefeated); break;
case SplitName.MossKnight: shouldSplit = mem.PlayerData <bool>(Offset.killedMossKnight); break;
case SplitName.MothwingCloak: shouldSplit = mem.PlayerData <bool>(Offset.hasDash); break;
case SplitName.MrMushroom1: shouldSplit = mem.PlayerData <int>(Offset.mrMushroomState) == 2; break;
case SplitName.MrMushroom2: shouldSplit = mem.PlayerData <int>(Offset.mrMushroomState) == 3; break;
case SplitName.MrMushroom3: shouldSplit = mem.PlayerData <int>(Offset.mrMushroomState) == 4; break;
case SplitName.MrMushroom4: shouldSplit = mem.PlayerData <int>(Offset.mrMushroomState) == 5; break;
case SplitName.MrMushroom5: shouldSplit = mem.PlayerData <int>(Offset.mrMushroomState) == 6; break;
case SplitName.MrMushroom6: shouldSplit = mem.PlayerData <int>(Offset.mrMushroomState) == 7; break;
case SplitName.MrMushroom7: shouldSplit = mem.PlayerData <int>(Offset.mrMushroomState) == 8; break;
case SplitName.MushroomBrawler: shouldSplit = mem.PlayerData <int>(Offset.killsMushroomBrawler) == 6; break;
case SplitName.NailmastersGlory: shouldSplit = mem.PlayerData <bool>(Offset.gotCharm_26); break;
case SplitName.NailUpgrade1: shouldSplit = mem.PlayerData <int>(Offset.nailSmithUpgrades) == 1; break;
case SplitName.NailUpgrade2: shouldSplit = mem.PlayerData <int>(Offset.nailSmithUpgrades) == 2; break;
case SplitName.NailUpgrade3: shouldSplit = mem.PlayerData <int>(Offset.nailSmithUpgrades) == 3; break;
case SplitName.NailUpgrade4: shouldSplit = mem.PlayerData <int>(Offset.nailSmithUpgrades) == 4; break;
case SplitName.NightmareKingGrimm: shouldSplit = mem.PlayerData <bool>(Offset.killedNightmareGrimm); break;
case SplitName.NightmareLantern: shouldSplit = mem.PlayerData <bool>(Offset.nightmareLanternLit); break;
case SplitName.NightmareLanternDestroyed: shouldSplit = mem.PlayerData <bool>(Offset.destroyedNightmareLantern); break;
case SplitName.NoEyes: shouldSplit = mem.PlayerData <bool>(Offset.killedGhostNoEyes); break;
case SplitName.Nosk: shouldSplit = mem.PlayerData <bool>(Offset.killedMimicSpider); break;
case SplitName.NotchFogCanyon: shouldSplit = mem.PlayerData <bool>(Offset.notchFogCanyon); break;
case SplitName.NotchSalubra1: shouldSplit = mem.PlayerData <bool>(Offset.salubraNotch1); break;
case SplitName.NotchSalubra2: shouldSplit = mem.PlayerData <bool>(Offset.salubraNotch2); break;
case SplitName.NotchSalubra3: shouldSplit = mem.PlayerData <bool>(Offset.salubraNotch3); break;
case SplitName.NotchSalubra4: shouldSplit = mem.PlayerData <bool>(Offset.salubraNotch4); break;
case SplitName.NotchShrumalOgres: shouldSplit = mem.PlayerData <bool>(Offset.notchShroomOgres); break;
case SplitName.PaleLurkerKey: shouldSplit = mem.PlayerData <bool>(Offset.gotLurkerKey); break;
case SplitName.PaleOre: shouldSplit = mem.PlayerData <int>(Offset.ore) > 0; break;
case SplitName.Pantheon1: shouldSplit = mem.PlayerData <bool>(Offset.bossDoorStateTier1); break;
case SplitName.Pantheon2: shouldSplit = mem.PlayerData <bool>(Offset.bossDoorStateTier2); break;
case SplitName.Pantheon3: shouldSplit = mem.PlayerData <bool>(Offset.bossDoorStateTier3); break;
case SplitName.Pantheon4: shouldSplit = mem.PlayerData <bool>(Offset.bossDoorStateTier4); break;
case SplitName.Pantheon5: shouldSplit = mem.PlayerData <bool>(Offset.bossDoorStateTier5); break;
case SplitName.PathOfPain: shouldSplit = mem.PlayerData <bool>(Offset.newDataBindingSeal); break;
case SplitName.PureVessel: shouldSplit = mem.PlayerData <bool>(Offset.killedHollowKnightPrime); break;
case SplitName.QueensGardens: shouldSplit = mem.PlayerData <bool>(Offset.visitedRoyalGardens); break;
case SplitName.QueensStationStation: shouldSplit = mem.PlayerData <bool>(Offset.openedFungalWastes); break;
case SplitName.QuickSlash: shouldSplit = mem.PlayerData <bool>(Offset.gotCharm_32); break;
case SplitName.QuickFocus: shouldSplit = mem.PlayerData <bool>(Offset.gotCharm_7); break;
case SplitName.RestingGrounds: shouldSplit = mem.PlayerData <bool>(Offset.visitedRestingGrounds); break;
case SplitName.RoyalWaterways: shouldSplit = mem.PlayerData <bool>(Offset.visitedWaterways); break;
case SplitName.SalubrasBlessing: shouldSplit = mem.PlayerData <bool>(Offset.salubraBlessing); break;
case SplitName.SeerDeparts: shouldSplit = mem.PlayerData <bool>(Offset.mothDeparted); break;
case SplitName.ShadeCloak: shouldSplit = mem.PlayerData <bool>(Offset.hasShadowDash); break;
case SplitName.ShadeSoul: shouldSplit = mem.PlayerData <int>(Offset.fireballLevel) == 2; break;
case SplitName.ShamanStone: shouldSplit = mem.PlayerData <bool>(Offset.gotCharm_19); break;
case SplitName.ShapeOfUnn: shouldSplit = mem.PlayerData <bool>(Offset.gotCharm_28); break;
case SplitName.SharpShadow: shouldSplit = mem.PlayerData <bool>(Offset.gotCharm_16); break;
case SplitName.SheoPaintmaster: shouldSplit = mem.PlayerData <bool>(Offset.killedPaintmaster); break;
case SplitName.SimpleKey: shouldSplit = mem.PlayerData <int>(Offset.simpleKeys) > 0; break;
case SplitName.SlyKey: shouldSplit = mem.PlayerData <bool>(Offset.hasSlykey); break;
case SplitName.SlyNailsage: shouldSplit = mem.PlayerData <bool>(Offset.killedNailsage); break;
case SplitName.SoulCatcher: shouldSplit = mem.PlayerData <bool>(Offset.gotCharm_20); break;
case SplitName.SoulEater: shouldSplit = mem.PlayerData <bool>(Offset.gotCharm_21); break;
case SplitName.SoulMaster: shouldSplit = mem.PlayerData <bool>(Offset.killedMageLord); break;
case SplitName.SoulTyrant: shouldSplit = mem.PlayerData <bool>(Offset.mageLordDreamDefeated); break;
case SplitName.SpellTwister: shouldSplit = mem.PlayerData <bool>(Offset.gotCharm_33); break;
case SplitName.SporeShroom: shouldSplit = mem.PlayerData <bool>(Offset.gotCharm_17); break;
case SplitName.SpiritGladeOpen: shouldSplit = mem.PlayerData <bool>(Offset.gladeDoorOpened); break;
case SplitName.Sprintmaster: shouldSplit = mem.PlayerData <bool>(Offset.gotCharm_37); break;
case SplitName.StalwartShell: shouldSplit = mem.PlayerData <bool>(Offset.gotCharm_4); break;
case SplitName.SteadyBody: shouldSplit = mem.PlayerData <bool>(Offset.gotCharm_14); break;
case SplitName.TeachersArchive: shouldSplit = sceneName.Equals("Fungus3_archive", StringComparison.OrdinalIgnoreCase); break;
case SplitName.ThornsOfAgony: shouldSplit = mem.PlayerData <bool>(Offset.gotCharm_12); break;
case SplitName.TraitorLord: shouldSplit = mem.PlayerData <bool>(Offset.killedTraitorLord); break;
case SplitName.TramPass: shouldSplit = mem.PlayerData <bool>(Offset.hasTramPass); break;
case SplitName.TroupeMasterGrimm: shouldSplit = mem.PlayerData <bool>(Offset.killedGrimm); break;
case SplitName.UnchainedHollowKnight: shouldSplit = mem.PlayerData <bool>(Offset.unchainedHollowKnight); break;
case SplitName.Uumuu: shouldSplit = mem.PlayerData <bool>(Offset.killedMegaJellyfish); break;
case SplitName.VengefulSpirit: shouldSplit = mem.PlayerData <int>(Offset.fireballLevel) == 1; break;
case SplitName.VesselFragment1: shouldSplit = mem.PlayerData <int>(Offset.MPReserveMax) == 0 && mem.PlayerData <int>(Offset.vesselFragments) == 1; break;
case SplitName.VesselFragment2: shouldSplit = mem.PlayerData <int>(Offset.MPReserveMax) == 0 && mem.PlayerData <int>(Offset.vesselFragments) == 2; break;
case SplitName.Vessel1: shouldSplit = mem.PlayerData <int>(Offset.MPReserveMax) == 33; break;
case SplitName.VesselFragment4: shouldSplit = mem.PlayerData <int>(Offset.vesselFragments) == 4 || (mem.PlayerData <int>(Offset.MPReserveMax) == 33 && mem.PlayerData <int>(Offset.vesselFragments) == 1); break;
case SplitName.VesselFragment5: shouldSplit = mem.PlayerData <int>(Offset.vesselFragments) == 5 || (mem.PlayerData <int>(Offset.MPReserveMax) == 33 && mem.PlayerData <int>(Offset.vesselFragments) == 2); break;
case SplitName.Vessel2: shouldSplit = mem.PlayerData <int>(Offset.MPReserveMax) == 66; break;
case SplitName.VesselFragment7: shouldSplit = mem.PlayerData <int>(Offset.vesselFragments) == 7 || (mem.PlayerData <int>(Offset.MPReserveMax) == 66 && mem.PlayerData <int>(Offset.vesselFragments) == 1); break;
case SplitName.VesselFragment8: shouldSplit = mem.PlayerData <int>(Offset.vesselFragments) == 8 || (mem.PlayerData <int>(Offset.MPReserveMax) == 66 && mem.PlayerData <int>(Offset.vesselFragments) == 2); break;
case SplitName.Vessel3: shouldSplit = mem.PlayerData <int>(Offset.MPReserveMax) == 99; break;
case SplitName.VoidHeart: shouldSplit = mem.PlayerData <bool>(Offset.gotShadeCharm); break;
case SplitName.WatcherChandelier: shouldSplit = mem.PlayerData <bool>(Offset.watcherChandelier); break;
case SplitName.WaywardCompass: shouldSplit = mem.PlayerData <bool>(Offset.gotCharm_2); break;
case SplitName.Weaversong: shouldSplit = mem.PlayerData <bool>(Offset.gotCharm_39); break;
case SplitName.WhiteDefender: shouldSplit = mem.PlayerData <bool>(Offset.killedWhiteDefender); break;
case SplitName.WhitePalace: shouldSplit = mem.PlayerData <bool>(Offset.visitedWhitePalace); break;
case SplitName.Xero: shouldSplit = mem.PlayerData <bool>(Offset.killedGhostXero); break;
case SplitName.Zote1: shouldSplit = mem.PlayerData <bool>(Offset.zoteRescuedBuzzer); break;
case SplitName.Zote2: shouldSplit = mem.PlayerData <bool>(Offset.zoteRescuedDeepnest); break;
case SplitName.ZoteKilled: shouldSplit = mem.PlayerData <bool>(Offset.killedZote); break;
case SplitName.KingsPass: shouldSplit = sceneName.StartsWith("Tutorial_01") && nextScene.StartsWith("Town"); break;
case SplitName.VengeflyKingP: shouldSplit = sceneName.StartsWith("GG_Vengefly") && nextScene.StartsWith("GG_Gruz_Mother"); break;
case SplitName.GruzMotherP: shouldSplit = sceneName.StartsWith("GG_Gruz_Mother") && nextScene.StartsWith("GG_False_Knight"); break;
case SplitName.FalseKnightP: shouldSplit = sceneName.StartsWith("GG_False_Knight") && nextScene.StartsWith("GG_Mega_Moss_Charger"); break;
case SplitName.MassiveMossChargerP: shouldSplit = sceneName.StartsWith("GG_Mega_Moss_Charger") && nextScene.StartsWith("GG_Hornet_1"); break;
case SplitName.Hornet1P: shouldSplit = sceneName.StartsWith("GG_Hornet_1") && (nextScene == "GG_Spa" || nextScene == "GG_Engine"); break;
case SplitName.GorbP: shouldSplit = sceneName.StartsWith("GG_Ghost_Gorb") && nextScene.StartsWith("GG_Dung_Defender"); break;
case SplitName.DungDefenderP: shouldSplit = sceneName.StartsWith("GG_Dung_Defender") && nextScene.StartsWith("GG_Mage_Knight"); break;
case SplitName.SoulWarriorP: shouldSplit = sceneName.StartsWith("GG_Mage_Knight") && nextScene.StartsWith("GG_Brooding_Mawlek"); break;
case SplitName.BroodingMawlekP: shouldSplit = sceneName.StartsWith("GG_Brooding_Mawlek") && (nextScene == "GG_Engine" || nextScene.StartsWith("GG_Nailmasters")); break;
case SplitName.OroMatoNailBrosP: shouldSplit = sceneName.StartsWith("GG_Nailmasters") && (nextScene == "GG_End_Sequence" || nextScene == "GG_Spa"); break;
case SplitName.XeroP: shouldSplit = sceneName.StartsWith("GG_Ghost_Xero") && nextScene.StartsWith("GG_Crystal_Guardian"); break;
case SplitName.CrystalGuardianP: shouldSplit = sceneName.StartsWith("GG_Crystal_Guardian") && nextScene.StartsWith("GG_Soul_Master"); break;
case SplitName.SoulMasterP: shouldSplit = sceneName.StartsWith("GG_Soul_Master") && nextScene.StartsWith("GG_Oblobbles"); break;
case SplitName.OblobblesP: shouldSplit = sceneName.StartsWith("GG_Oblobbles") && nextScene.StartsWith("GG_Mantis_Lords"); break;
case SplitName.MantisLordsP: shouldSplit = sceneName.StartsWith("GG_Mantis_Lords") && nextScene == "GG_Spa"; break;
case SplitName.MarmuP: shouldSplit = sceneName.StartsWith("GG_Ghost_Marmu") && (nextScene.StartsWith("GG_Nosk") || nextScene.StartsWith("GG_Flukemarm")); break;
case SplitName.NoskP: shouldSplit = sceneName.StartsWith("GG_Nosk") && nextScene.StartsWith("GG_Flukemarm"); break;
case SplitName.FlukemarmP: shouldSplit = sceneName.StartsWith("GG_Flukemarm") && nextScene.StartsWith("GG_Broken_Vessel"); break;
case SplitName.BrokenVesselP: shouldSplit = sceneName.StartsWith("GG_Broken_Vessel") && (nextScene == "GG_Engine" || nextScene.StartsWith("GG_Ghost_Galien")); break;
case SplitName.SheoPaintmasterP: shouldSplit = sceneName.StartsWith("GG_Painter") && (nextScene == "GG_End_Sequence" || nextScene == "GG_Spa"); break;
case SplitName.HiveKnightP: shouldSplit = sceneName.StartsWith("GG_Hive_Knight") && nextScene.StartsWith("GG_Ghost_Hu"); break;
case SplitName.ElderHuP: shouldSplit = sceneName.StartsWith("GG_Ghost_Hu") && nextScene.StartsWith("GG_Collector"); break;
case SplitName.CollectorP: shouldSplit = sceneName.StartsWith("GG_Collector") && nextScene.StartsWith("GG_God_Tamer"); break;
case SplitName.GodTamerP: shouldSplit = sceneName.StartsWith("GG_God_Tamer") && nextScene.StartsWith("GG_Grimm"); break;
case SplitName.TroupeMasterGrimmP: shouldSplit = sceneName.StartsWith("GG_Grimm") && nextScene == "GG_Spa"; break;
case SplitName.GalienP: shouldSplit = sceneName.StartsWith("GG_Ghost_Galien") && (nextScene.StartsWith("GG_Grey_Prince_Zote") || nextScene.StartsWith("GG_Painter")); break;
case SplitName.GreyPrinceZoteP: shouldSplit = sceneName.StartsWith("GG_Grey_Prince_Zote") && (nextScene.StartsWith("GG_Uumuu") || nextScene.StartsWith("GG_Failed_Champion")); break;
case SplitName.UumuuP: shouldSplit = sceneName.StartsWith("GG_Uumuu") && (nextScene.StartsWith("GG_Hornet_2") || nextScene.StartsWith("GG_Nosk_Hornet")); break;
case SplitName.Hornet2P: shouldSplit = sceneName.StartsWith("GG_Hornet_2") && (nextScene == "GG_Engine" || nextScene == "GG_Spa"); break;
case SplitName.SlyP: shouldSplit = sceneName.StartsWith("GG_Sly") && (nextScene == "GG_End_Sequence" || nextScene.StartsWith("GG_Hornet_2")); break;
case SplitName.EnragedGuardianP: shouldSplit = sceneName.StartsWith("GG_Crystal_Guardian_2") && nextScene.StartsWith("GG_Lost_Kin"); break;
case SplitName.LostKinP: shouldSplit = sceneName.StartsWith("GG_Lost_Kin") && nextScene.StartsWith("GG_Ghost_No_Eyes"); break;
case SplitName.NoEyesP: shouldSplit = sceneName.StartsWith("GG_Ghost_No_Eyes") && nextScene.StartsWith("GG_Traitor_Lord"); break;
case SplitName.TraitorLordP: shouldSplit = sceneName.StartsWith("GG_Traitor_Lord") && nextScene.StartsWith("GG_White_Defender"); break;
case SplitName.WhiteDefenderP: shouldSplit = sceneName.StartsWith("GG_White_Defender") && nextScene == "GG_Spa"; break;
case SplitName.FailedChampionP: shouldSplit = sceneName.StartsWith("GG_Failed_Champion") && (nextScene.StartsWith("GG_Ghost_Markoth") || nextScene.StartsWith("GG_Grimm_Nightmare")); break;
case SplitName.MarkothP: shouldSplit = sceneName.StartsWith("GG_Ghost_Markoth") && (nextScene.StartsWith("GG_Watcher_Knights") || nextScene.StartsWith("GG_Grey_Prince_Zote")); break;
case SplitName.WatcherKnightsP: shouldSplit = sceneName.StartsWith("GG_Watcher_Knights") && (nextScene.StartsWith("GG_Soul_Tyrant") || nextScene.StartsWith("GG_Uumuu")); break;
case SplitName.SoulTyrantP: shouldSplit = sceneName.StartsWith("GG_Soul_Tyrant") && (nextScene == "GG_Engine_Prime" || nextScene.StartsWith("GG_Ghost_Markoth")); break;
case SplitName.PureVesselP: shouldSplit = sceneName.StartsWith("GG_Hollow_Knight") && (nextScene == "GG_End_Sequence" || nextScene.StartsWith("GG_Radiance") || nextScene == "GG_Door_5_Finale"); break;
case SplitName.NoskHornetP: shouldSplit = sceneName.StartsWith("GG_Nosk_Hornet") && nextScene.StartsWith("GG_Sly"); break;
case SplitName.NightmareKingGrimmP: shouldSplit = sceneName.StartsWith("GG_Grimm_Nightmare") && nextScene == "GG_Spa"; break;
}
return(shouldSplit);
}
public bool HasSplit(SplitName split)
{
return(Splits.Contains(split));
}
private void HandleSplits()
{
bool shouldSplit = false;
if (currentSplit == -1)
{
bool hasStarted = mem.StartedGame();
shouldSplit = mem.LastHooked.AddSeconds(5) < DateTime.Now && mem.CurrentGameState() == GameState.NewGame && hasStarted && !lastStarted;
lastStarted = hasStarted;
}
else if (Model.CurrentState.CurrentPhase == TimerPhase.Running)
{
string scene = mem.ActiveScene();
bool loading = scene == "EndingPrototype" ? !mem.HasControl() : mem.Loading();
bool shrine = mem.HasShrine();
if (currentSplit < Model.CurrentState.Run.Count && currentSplit < settings.Splits.Count)
{
SplitName split = settings.Splits[currentSplit];
if (scene == "0 - Enforce Collectible")
{
hasReachedRoom = true;
}
switch (split)
{
case SplitName.Level_0_1: shouldSplit = scene == "SquishCreationTutorial" && hasReachedRoom && mem.InfectionLevel() == 0 && loading && !lastStarted; break;
case SplitName.World_1: shouldSplit = scene == "World1 - Cuddly" && lastScene == "Overworld Major"; break;
case SplitName.Level_1_1: shouldSplit = scene == "1 - Intro Deform" && mem.InfectionLevel() == 0 && loading && !lastStarted; break;
case SplitName.Level_1_2: shouldSplit = scene == "2 - Deform Puzzles" && mem.InfectionLevel() == 0 && loading && !lastStarted; break;
case SplitName.Level_1_2_Shrine: shouldSplit = scene == "2 - Deform Puzzles" && shrine && !lastShrine; break;
case SplitName.Level_1_3: shouldSplit = scene == "3 - Laser Intro" && mem.InfectionLevel() == 0 && loading && !lastStarted; break;
case SplitName.Level_1_4: shouldSplit = scene == "4 - Wall Jumping" && mem.InfectionLevel() == 0 && loading && !lastStarted; break;
case SplitName.Level_1_4_Shrine: shouldSplit = scene == "4 - Wall Jumping" && shrine && !lastShrine; break;
case SplitName.Level_1_5: shouldSplit = scene == "5 - Lasers 2" && mem.InfectionLevel() == 0 && loading && !lastStarted; break;
case SplitName.Level_1_5_Shrine: shouldSplit = scene == "5 - Lasers 2" && shrine && !lastShrine; break;
case SplitName.Level_1_6: shouldSplit = scene == "6 - No Dash Zones" && mem.InfectionLevel() == 0 && loading && !lastStarted; break;
case SplitName.World_2: shouldSplit = scene == "World2 - Swamp" && lastScene == "Overworld Major"; break;
case SplitName.Level_2_1: shouldSplit = scene == "1 - Intro Reset" && mem.InfectionLevel() == 0 && loading && !lastStarted; break;
case SplitName.Level_2_2: shouldSplit = scene == "2 - Reset Puzzles" && mem.InfectionLevel() == 0 && loading && !lastStarted; break;
case SplitName.Level_2_3: shouldSplit = scene == "3 - Throw up 1" && mem.InfectionLevel() == 0 && loading && !lastStarted; break;
case SplitName.Level_2_3_Shrine: shouldSplit = scene == "3 - Throw up 1" && shrine && !lastShrine; break;
case SplitName.Level_2_4: shouldSplit = scene == "4 - Throw up 2" && mem.InfectionLevel() == 0 && loading && !lastStarted; break;
case SplitName.Level_2_4_Shrine: shouldSplit = scene == "4 - Throw up 2" && shrine && !lastShrine; break;
case SplitName.Level_2_5: shouldSplit = scene == "5 - Throw Side" && mem.InfectionLevel() == 0 && loading && !lastStarted; break;
case SplitName.Level_2_6: shouldSplit = scene == "6 - Moving beams" && mem.InfectionLevel() == 0 && loading && !lastStarted; break;
case SplitName.Level_2_6_Shrine: shouldSplit = scene == "6 - Moving beams" && shrine && !lastShrine; break;
case SplitName.World_3: shouldSplit = scene == "World3 - Snow" && lastScene == "Overworld Major"; break;
case SplitName.Level_3_1: shouldSplit = scene == "1 - Intro hard" && mem.InfectionLevel() == 0 && loading && !lastStarted; break;
case SplitName.Level_3_2: shouldSplit = scene == "2 - Intro Puzzle" && mem.InfectionLevel() == 0 && loading && !lastStarted; break;
case SplitName.Level_3_2_Shrine: shouldSplit = scene == "2 - Intro Puzzle" && shrine && !lastShrine; break;
case SplitName.Level_3_3: shouldSplit = scene == "3 - intro beam" && mem.InfectionLevel() == 0 && loading && !lastStarted; break;
case SplitName.Level_3_4: shouldSplit = scene == "4 - Reset Beam Complex" && mem.InfectionLevel() == 0 && loading && !lastStarted; break;
case SplitName.Level_3_5: shouldSplit = scene == "5 - Reset Beam Throw Up Shape" && mem.InfectionLevel() == 0 && loading && !lastStarted; break;
case SplitName.Level_3_5_Shrine: shouldSplit = scene == "5 - Reset Beam Throw Up Shape" && shrine && !lastShrine; break;
case SplitName.World_4: shouldSplit = scene == "EndingPrototype" && lastScene == "Overworld Major"; break;
case SplitName.Level_4_1: shouldSplit = scene == "EndingPrototype" && mem.XPos() > 42800 && loading && !lastStarted && mem.CurrentGameState() == GameState.Playing && !mem.Dead() && !mem.Loading(); break;
}
}
Model.CurrentState.IsGameTimePaused = Model.CurrentState.CurrentPhase != TimerPhase.Running || (scene == "EndingPrototype" ? mem.Loading() : loading);
lastStarted = loading;
lastScene = scene;
lastShrine = shrine;
}
HandleSplit(shouldSplit, false);
}
private void HandleSplits()
{
bool shouldSplit = false;
string currentArea = mem.Area();
if (string.IsNullOrEmpty(currentArea))
{
currentArea = previousArea;
}
PointF pos = mem.Position();
double gameTime = mem.GameTime();
if (currentSplit == -1)
{
shouldSplit = currentArea == "west_desert" && gameTime > 0 && gameTime < 2 && PositionNear(pos, 2340, 5910);
}
else if (Model.CurrentState.CurrentPhase == TimerPhase.Running)
{
if (currentSplit + 1 < Model.CurrentState.Run.Count && currentSplit < settings.Splits.Count)
{
SplitName split = settings.Splits[currentSplit];
switch (split)
{
case SplitName.Archaea: shouldSplit = currentArea == "archaea_1"; break;
case SplitName.Armor2: shouldSplit = mem.AquiredFlags().Contains("armor2"); break;
case SplitName.Armor3: shouldSplit = mem.AquiredFlags().Contains("armor3"); break;
case SplitName.Armor4: shouldSplit = mem.AquiredFlags().Contains("armor4"); break;
case SplitName.Armor5: shouldSplit = mem.AquiredFlags().Contains("armor5"); break;
case SplitName.Armor6: shouldSplit = mem.AquiredFlags().Contains("armor6"); break;
case SplitName.Armor7: shouldSplit = mem.AquiredFlags().Contains("armor7"); break;
case SplitName.Armor8: shouldSplit = mem.AquiredFlags().Contains("armor8"); break;
case SplitName.Backpack2: shouldSplit = mem.AquiredFlags().Contains("backpack2"); break;
case SplitName.Backpack3: shouldSplit = mem.AquiredFlags().Contains("backpack3"); break;
case SplitName.Backpack4: shouldSplit = mem.AquiredFlags().Contains("backpack4"); break;
case SplitName.Backpack5: shouldSplit = mem.AquiredFlags().Contains("backpack5"); break;
case SplitName.Backpack6: shouldSplit = mem.AquiredFlags().Contains("backpack6"); break;
case SplitName.Backpack7: shouldSplit = mem.AquiredFlags().Contains("backpack7"); break;
case SplitName.Backpack8: shouldSplit = mem.AquiredFlags().Contains("backpack8"); break;
case SplitName.Backpack9: shouldSplit = mem.AquiredFlags().Contains("backpack9"); break;
case SplitName.Backpack10: shouldSplit = mem.AquiredFlags().Contains("backpack10"); break;
case SplitName.Device0: shouldSplit = currentArea == "firetemple_cave_generator"; break;
case SplitName.Device1: shouldSplit = currentArea == "temple_of_guidance_2_cave_generator"; break;
case SplitName.Device2: shouldSplit = currentArea == "yarrow_cave_generator"; break;
case SplitName.Device3: shouldSplit = currentArea == "firetemple_cave_generator2"; break;
case SplitName.EasternTemple: shouldSplit = currentArea == "fire_temple"; break;
case SplitName.ElMachino: shouldSplit = currentArea == "el_machino"; break;
case SplitName.Fen: shouldSplit = mem.AquiredFlags().Contains("buddy"); break;
case SplitName.HookShot: shouldSplit = currentArea == "the_hub_cave_grapplinghook" && PositionNear(pos, 1380, 3630); break;
case SplitName.HookShotLong: shouldSplit = currentArea == "firetemple_cave_treasure_chamber" && PositionNear(pos, 1500, 1110); break;
case SplitName.IgnitionAxe: shouldSplit = currentArea == "firetemple_cave_flamer" && PositionNear(pos, 6540, 3270); break;
case SplitName.Jackhammer: shouldSplit = currentArea == "archaea_cave_jackhammer" && PositionNear(pos, 1380, 3990); break;
case SplitName.Jackhammer2: shouldSplit = mem.AquiredFlags().Contains("jackhammer2"); break;
case SplitName.Jackhammer3: shouldSplit = mem.AquiredFlags().Contains("jackhammer3"); break;
case SplitName.Jackhammer4: shouldSplit = mem.AquiredFlags().Contains("jackhammer4"); break;
case SplitName.JetEngine: shouldSplit = currentArea == "archaea_cave_vectron_entrance" && PositionNear(pos, 4980, 5910); break;
case SplitName.JetEngine2: shouldSplit = mem.AquiredFlags().Contains("steampack2"); break;
case SplitName.JetEngine3: shouldSplit = mem.AquiredFlags().Contains("steampack3"); break;
case SplitName.Lamp2:
HashSet <string> flags = mem.AquiredFlags();
shouldSplit = flags.Contains("lamp2") && flags.Contains("run_boots");
break;
case SplitName.Lamp3: shouldSplit = mem.AquiredFlags().Contains("lamp3"); break;
case SplitName.Lamp4: shouldSplit = mem.AquiredFlags().Contains("lamp4"); break;
case SplitName.Lamp5: shouldSplit = mem.AquiredFlags().Contains("lamp5"); break;
case SplitName.Lamp6: shouldSplit = mem.AquiredFlags().Contains("lamp6"); break;
case SplitName.Lamp7: shouldSplit = mem.AquiredFlags().Contains("lamp7"); break;
case SplitName.Lamp8: shouldSplit = mem.AquiredFlags().Contains("lamp8"); break;
case SplitName.Oasis: shouldSplit = currentArea == "the_hub"; break;
case SplitName.OasisBoss: shouldSplit = currentArea == "the_hub_cave_boss"; break;
case SplitName.OasisBossBeaten: shouldSplit = currentArea == "the_hub_cave_boss_saving_rusty"; break;
case SplitName.Pickaxe2: shouldSplit = mem.AquiredFlags().Contains("pickaxe2"); break;
case SplitName.Pickaxe3: shouldSplit = mem.AquiredFlags().Contains("pickaxe3"); break;
case SplitName.Pickaxe4: shouldSplit = mem.AquiredFlags().Contains("pickaxe4"); break;
case SplitName.Pickaxe5: shouldSplit = mem.AquiredFlags().Contains("pickaxe5"); break;
case SplitName.Pickaxe6: shouldSplit = mem.AquiredFlags().Contains("pickaxe6"); break;
case SplitName.Pickaxe7: shouldSplit = mem.AquiredFlags().Contains("pickaxe7"); break;
case SplitName.Pickaxe8: shouldSplit = mem.AquiredFlags().Contains("pickaxe8"); break;
case SplitName.PressureBomb: shouldSplit = currentArea == "archaea_cave_pressurebomb" && PositionNear(pos, 2580, 4230); break;
case SplitName.PressureBomb2: shouldSplit = mem.AquiredFlags().Contains("pressurebomb2"); break;
case SplitName.PressureBomb3: shouldSplit = mem.AquiredFlags().Contains("pressurebomb3"); break;
case SplitName.PressureBomb4: shouldSplit = mem.AquiredFlags().Contains("pressurebomb4"); break;
case SplitName.PressureGrenade: shouldSplit = currentArea == "temple_of_guidance_2_cave_maze" && PositionNear(pos, 3540, 4590); break;
case SplitName.RamjetVigor: shouldSplit = currentArea == "yarrow_cave_steampack_slayer" && PositionNear(pos, 4620, 6390); break;
case SplitName.SprintHydraulics: shouldSplit = currentArea == "temple_of_guidance" && PositionNear(pos, 1380, 5550); break;
case SplitName.TempleOfGuidance: shouldSplit = currentArea == "temple_of_guidance"; break;
case SplitName.UltraCompositeArmor: shouldSplit = currentArea == "firetemple_cave_armor" && PositionNear(pos, 1800, 2910); break;
case SplitName.Vectron: shouldSplit = currentArea == "vectron_1"; break;
case SplitName.WaterTank2: shouldSplit = mem.AquiredFlags().Contains("watertank2"); break;
case SplitName.WaterTank3: shouldSplit = mem.AquiredFlags().Contains("watertank3"); break;
case SplitName.WaterTank4: shouldSplit = mem.AquiredFlags().Contains("watertank4"); break;
case SplitName.WaterTank5: shouldSplit = mem.AquiredFlags().Contains("watertank5"); break;
case SplitName.WindyPlains: shouldSplit = currentArea == "east_desert"; break;
case SplitName.Yarrow: shouldSplit = currentArea == "yarrow"; break;
}
}
else
{
if (state == 0 && previousArea == "el_machino_aftermath" && currentArea == "el_machino")
{
state = 1;
finalSplitTime = DateTime.Now.AddSeconds(3);
}
else if (state == 1)
{
shouldSplit = DateTime.Now >= finalSplitTime;
}
}
if (gameTime == lastGameTime)
{
sameGameTime++;
}
else
{
sameGameTime = 0;
}
lastGameTime = gameTime;
Model.CurrentState.IsGameTimePaused = sameGameTime > 3;
}
previousArea = currentArea;
HandleSplit(shouldSplit, false);
}
private void HandleSplits()
{
bool shouldSplit = false;
float gameTime = mem.GameTime();
if (currentSplit == -1)
{
int playerEntity = mem.PlayerEntity();
shouldSplit = lastPlayerEntity != playerEntity && gameTime <0.1f && DateTime.Now> mem.LastHooked.AddSeconds(5);
lastPlayerEntity = playerEntity;
}
else if (Model.CurrentState.CurrentPhase == TimerPhase.Running)
{
Screen screen = mem.PlayerScreen();
int timesWon = mem.TimesWon();
if (currentSplit < Model.CurrentState.Run.Count && currentSplit < settings.Splits.Count)
{
SplitName split = settings.Splits[currentSplit];
switch (split)
{
case SplitName.RedcrownWoods: shouldSplit = (lastScreen != Screen.ColossalDrain1 && screen == Screen.ColossalDrain1) || (lastScreen != Screen.PhilosophersForest1 && screen == Screen.PhilosophersForest1); break;
case SplitName.ColossalDrain: shouldSplit = lastScreen != Screen.FalseKingsKeep1 && screen == Screen.FalseKingsKeep1; break;
case SplitName.FalseKingsKeep: shouldSplit = lastScreen != Screen.Bargainburg1 && screen == Screen.Bargainburg1; break;
case SplitName.Bargainburg: shouldSplit = lastScreen != Screen.GreatFrontier1 && screen == Screen.GreatFrontier1; break;
case SplitName.GreatFrontier: shouldSplit = lastScreen != Screen.WindsweptBluff1 && screen == Screen.WindsweptBluff1; break;
case SplitName.StormwallPass: shouldSplit = lastScreen != Screen.ChapelPerilous1 && screen == Screen.ChapelPerilous1; break;
case SplitName.ChapelPerilous: shouldSplit = lastScreen != Screen.BlueRuin1 && screen == Screen.BlueRuin1; break;
case SplitName.BlueRuin: shouldSplit = lastScreen != Screen.TheTower1 && screen == Screen.TheTower1; break;
case SplitName.BrightcrownWoods: shouldSplit = lastScreen != Screen.ColossalDungeon1 && screen == Screen.ColossalDungeon1; break;
case SplitName.ColossalDungeon: shouldSplit = lastScreen != Screen.FalseKingsCastle1 && screen == Screen.FalseKingsCastle1; break;
case SplitName.FalseKingsCastle: shouldSplit = lastScreen != Screen.Underburg1 && screen == Screen.Underburg1; break;
case SplitName.Underburg: shouldSplit = lastScreen != Screen.LostFrontier1 && screen == Screen.LostFrontier1; break;
case SplitName.LostFrontier: shouldSplit = lastScreen != Screen.HiddenKingdom1 && screen == Screen.HiddenKingdom1; break;
case SplitName.HiddenKingdom: shouldSplit = lastScreen != Screen.BlackSanctum1 && screen == Screen.BlackSanctum1; break;
case SplitName.BlackSanctum: shouldSplit = lastScreen != Screen.DeepRuin1 && screen == Screen.DeepRuin1; break;
case SplitName.DeepRuin: shouldSplit = lastScreen != Screen.TheDarkTower1 && screen == Screen.TheDarkTower1; break;
case SplitName.PhilosophersForest: shouldSplit = lastScreen != Screen.Hole2 && screen == Screen.Hole2; break;
case SplitName.Bog: shouldSplit = lastScreen != Screen.MouldingManor1 && screen == Screen.MouldingManor1; break;
case SplitName.MouldingManor: shouldSplit = lastScreen != Screen.Bugstalk1 && screen == Screen.Bugstalk1; break;
case SplitName.Bugstalk: shouldSplit = lastScreen != Screen.HouseOfNineLives1 && screen == Screen.HouseOfNineLives1; break;
case SplitName.HouseOfNineLives: shouldSplit = lastScreen != Screen.PhantomTower1 && screen == Screen.PhantomTower1; break;
case SplitName.PhantomTower: shouldSplit = lastScreen != Screen.HaltedRuin1 && screen == Screen.HaltedRuin1; break;
case SplitName.HaltedRuin: shouldSplit = lastScreen != Screen.TowerOfAntumbra1 && screen == Screen.TowerOfAntumbra1; break;
case SplitName.EndGameMain: shouldSplit = screen == Screen.MainBabe && lastTimesWon < timesWon; break;
case SplitName.EndGameNew: shouldSplit = screen == Screen.NewBabe && lastTimesWon < timesWon; break;
case SplitName.EndGameGhost: shouldSplit = screen == Screen.GhostBabe && lastTimesWon < timesWon; break;
}
}
else
{
shouldSplit = (screen == Screen.MainBabe || screen == Screen.NewBabe || screen == Screen.GhostBabe) && lastTimesWon < timesWon;
}
lastScreen = screen;
lastTimesWon = timesWon;
}
if (gameTime > 0)
{
Model.CurrentState.SetGameTime(TimeSpan.FromSeconds(gameTime));
}
Model.CurrentState.IsGameTimePaused = Model.CurrentState.CurrentPhase != TimerPhase.Running || gameTime == lastGameTime;
lastGameTime = gameTime;
HandleSplit(shouldSplit, false);
}
public void DrawGeneral(Graphics g, LiveSplitState state, float width, float height)
{
Timer.DrawBackground(g, InternalComponent.TimerColor, Settings.BackgroundColor, Settings.BackgroundColor2, width, height, Settings.BackgroundGradient);
var lastSplitOffset = state.CurrentSplitIndex == state.Run.Count ? -1 : 0;
var originalDrawSize = Math.Min(Settings.IconSize, width - 14);
var icon = state.CurrentSplitIndex >= 0 ? state.Run[state.CurrentSplitIndex + lastSplitOffset].Icon : null;
if (Settings.DisplayIcon && icon != null)
{
if (OldImage != icon)
{
ImageAnimator.Animate(icon, (s, o) => { });
OldImage = icon;
}
var drawWidth = originalDrawSize;
var drawHeight = originalDrawSize;
if (icon.Width > icon.Height)
{
var ratio = icon.Height / (float)icon.Width;
drawHeight *= ratio;
}
else
{
var ratio = icon.Width / (float)icon.Height;
drawWidth *= ratio;
}
ImageAnimator.UpdateFrames(icon);
g.DrawImage(
icon,
7 + (originalDrawSize - drawWidth) / 2,
(height - originalDrawSize) / 2.0f + (originalDrawSize - drawHeight) / 2,
drawWidth,
drawHeight);
IconWidth = (int)(originalDrawSize + 7.5f);
}
else
{
IconWidth = 0;
}
InternalComponent.Settings.ShowGradient = Settings.TimerShowGradient;
InternalComponent.Settings.OverrideSplitColors = Settings.OverrideTimerColors;
InternalComponent.Settings.TimerColor = Settings.TimerColor;
InternalComponent.Settings.DigitsFormat = Settings.DigitsFormat;
InternalComponent.Settings.Accuracy = Settings.Accuracy;
InternalComponent.Settings.DecimalsSize = Settings.DecimalsSize;
SegmentTimer.Settings.ShowGradient = Settings.SegmentTimerShowGradient;
SegmentTimer.Settings.OverrideSplitColors = true;
SegmentTimer.Settings.TimerColor = Settings.SegmentTimerColor;
SegmentTimer.Settings.DigitsFormat = Settings.SegmentDigitsFormat;
SegmentTimer.Settings.Accuracy = Settings.SegmentAccuracy;
SegmentTimer.Settings.DecimalsSize = Settings.SegmentTimerDecimalsSize;
if (state.CurrentSplitIndex >= 0)
{
var labelsFont = new Font(Settings.SegmentLabelsFont.FontFamily, Settings.SegmentLabelsFont.Size, Settings.SegmentLabelsFont.Style);
var timesFont = new Font(Settings.SegmentTimesFont.FontFamily, Settings.SegmentTimesFont.Size, Settings.SegmentTimesFont.Style);
LabelSegment.Font = labelsFont;
LabelSegment.X = 5 + IconWidth;
LabelSegment.Y = height * ((100f - Settings.SegmentTimerSizeRatio) / 100f);
LabelSegment.Width = width - SegmentTimer.ActualWidth - 5 - IconWidth;
LabelSegment.Height = height * (Settings.SegmentTimerSizeRatio / 200f) * (!HideComparison ? 1f : 2f);
LabelSegment.HorizontalAlignment = StringAlignment.Near;
LabelSegment.VerticalAlignment = StringAlignment.Center;
LabelSegment.ForeColor = Settings.SegmentLabelsColor;
LabelSegment.HasShadow = state.LayoutSettings.DropShadows;
LabelSegment.ShadowColor = state.LayoutSettings.ShadowsColor;
LabelSegment.OutlineColor = state.LayoutSettings.TextOutlineColor;
if (Comparison != "None")
{
LabelSegment.Draw(g);
}
LabelBest.Font = labelsFont;
LabelBest.X = 5 + IconWidth;
LabelBest.Y = height * ((100f - Settings.SegmentTimerSizeRatio / 2f) / 100f);
LabelBest.Width = width - SegmentTimer.ActualWidth - 5 - IconWidth;
LabelBest.Height = height * (Settings.SegmentTimerSizeRatio / 200f);
LabelBest.HorizontalAlignment = StringAlignment.Near;
LabelBest.VerticalAlignment = StringAlignment.Center;
LabelBest.ForeColor = Settings.SegmentLabelsColor;
LabelBest.HasShadow = state.LayoutSettings.DropShadows;
LabelBest.ShadowColor = state.LayoutSettings.ShadowsColor;
LabelBest.OutlineColor = state.LayoutSettings.TextOutlineColor;
if (!HideComparison)
{
LabelBest.Draw(g);
}
var offset = Math.Max(LabelSegment.ActualWidth, HideComparison ? 0 : LabelBest.ActualWidth) + 10;
if (Comparison != "None")
{
SegmentTime.Font = timesFont;
SegmentTime.X = offset + IconWidth;
SegmentTime.Y = height * ((100f - Settings.SegmentTimerSizeRatio) / 100f);
SegmentTime.Width = width - SegmentTimer.ActualWidth - offset - IconWidth;
SegmentTime.Height = height * (Settings.SegmentTimerSizeRatio / 200f) * (!HideComparison ? 1f : 2f);
SegmentTime.HorizontalAlignment = StringAlignment.Near;
SegmentTime.VerticalAlignment = StringAlignment.Center;
SegmentTime.ForeColor = Settings.SegmentTimesColor;
SegmentTime.HasShadow = state.LayoutSettings.DropShadows;
SegmentTime.ShadowColor = state.LayoutSettings.ShadowsColor;
SegmentTime.OutlineColor = state.LayoutSettings.TextOutlineColor;
SegmentTime.IsMonospaced = true;
SegmentTime.Draw(g);
}
if (!HideComparison)
{
BestSegmentTime.Font = timesFont;
BestSegmentTime.X = offset + IconWidth;
BestSegmentTime.Y = height * ((100f - Settings.SegmentTimerSizeRatio / 2f) / 100f);
BestSegmentTime.Width = width - SegmentTimer.ActualWidth - offset - IconWidth;
BestSegmentTime.Height = height * (Settings.SegmentTimerSizeRatio / 200f);
BestSegmentTime.HorizontalAlignment = StringAlignment.Near;
BestSegmentTime.VerticalAlignment = StringAlignment.Center;
BestSegmentTime.ForeColor = Settings.SegmentTimesColor;
BestSegmentTime.HasShadow = state.LayoutSettings.DropShadows;
BestSegmentTime.ShadowColor = state.LayoutSettings.ShadowsColor;
BestSegmentTime.OutlineColor = state.LayoutSettings.TextOutlineColor;
BestSegmentTime.IsMonospaced = true;
BestSegmentTime.Draw(g);
}
SplitName.Font = Settings.SplitNameFont;
SplitName.X = IconWidth + 5;
SplitName.Y = 0;
SplitName.Width = width - InternalComponent.ActualWidth - IconWidth - 5;
SplitName.Height = height * ((100f - Settings.SegmentTimerSizeRatio) / 100f);
SplitName.HorizontalAlignment = StringAlignment.Near;
SplitName.VerticalAlignment = StringAlignment.Center;
SplitName.ForeColor = Settings.SplitNameColor;
SplitName.HasShadow = state.LayoutSettings.DropShadows;
SplitName.ShadowColor = state.LayoutSettings.ShadowsColor;
SplitName.OutlineColor = state.LayoutSettings.TextOutlineColor;
if (Settings.ShowSplitName)
{
SplitName.Draw(g);
}
}
}
private void HandleSplits()
{
bool shouldSplit = false;
if (currentSplit == -1)
{
if (settings.Splits.Count != 0)
{
long vector = mem.AverageVector();
shouldSplit = mem.NextLevel() == LevelTitle.HubWorldConfigurationIntro && mem.PlayerState() == PlayerState.Sleeping && lastVector != vector;
lastVector = vector;
}
else
{
PlayerState state = mem.PlayerState();
shouldSplit = lastState == PlayerState.BeingDrawn && state != PlayerState.BeingDrawn && InALevel(mem.NextLevel());
lastState = state;
}
}
else if (Model.CurrentState.CurrentPhase == TimerPhase.Running)
{
if (currentSplit < Model.CurrentState.Run.Count && currentSplit < settings.Splits.Count)
{
SplitName split = settings.Splits[currentSplit];
LevelTitle level = mem.NextLevel();
switch (split)
{
case SplitName.Level_1_1_Enter: shouldSplit = lastLevel != LevelTitle.World1Level1 && level == LevelTitle.World1Level1; break;
case SplitName.Level_1_1: shouldSplit = lastLevel == LevelTitle.World1Level1 && level == LevelTitle.World1Level2; break;
case SplitName.Level_1_2: shouldSplit = lastLevel == LevelTitle.World1Level2 && level == LevelTitle.World1Level3; break;
case SplitName.Level_1_3: shouldSplit = lastLevel == LevelTitle.World1Level3 && level == LevelTitle.World1Level4; break;
case SplitName.Level_1_4: shouldSplit = lastLevel == LevelTitle.World1Level4 && level == LevelTitle.World1Level5; break;
case SplitName.Level_1_5: shouldSplit = lastLevel == LevelTitle.World1Level5 && level == LevelTitle.World1Level6; break;
case SplitName.Level_1_6: shouldSplit = lastLevel == LevelTitle.World1Level6 && level == LevelTitle.World1HubDone; break;
case SplitName.Level_2_1_Enter: shouldSplit = lastLevel != LevelTitle.World2Level1 && level == LevelTitle.World2Level1; break;
case SplitName.Level_2_1: shouldSplit = lastLevel == LevelTitle.World2Level1 && level == LevelTitle.World2Level2; break;
case SplitName.Level_2_2: shouldSplit = lastLevel == LevelTitle.World2Level2 && level == LevelTitle.World2Level3; break;
case SplitName.Level_2_3: shouldSplit = lastLevel == LevelTitle.World2Level3 && level == LevelTitle.World2Level4; break;
case SplitName.Level_2_4: shouldSplit = lastLevel == LevelTitle.World2Level4 && level == LevelTitle.World2Level5; break;
case SplitName.Level_2_5: shouldSplit = lastLevel == LevelTitle.World2Level5 && level == LevelTitle.World2Level6; break;
case SplitName.Level_2_6: shouldSplit = lastLevel == LevelTitle.World2Level6 && level == LevelTitle.World2HubDone; break;
case SplitName.Level_3_1_Enter: shouldSplit = lastLevel != LevelTitle.World3Level1 && level == LevelTitle.World3Level1; break;
case SplitName.Level_3_1: shouldSplit = lastLevel == LevelTitle.World3Level1 && level == LevelTitle.World3Level2; break;
case SplitName.Level_3_2: shouldSplit = lastLevel == LevelTitle.World3Level2 && level == LevelTitle.World3Level3; break;
case SplitName.Level_3_3: shouldSplit = lastLevel == LevelTitle.World3Level3 && level == LevelTitle.World3Level4; break;
case SplitName.Level_3_4: shouldSplit = lastLevel == LevelTitle.World3Level4 && level == LevelTitle.World3Level5; break;
case SplitName.Level_3_5: shouldSplit = lastLevel == LevelTitle.World3Level5 && level == LevelTitle.World3Level6; break;
case SplitName.Level_3_6: shouldSplit = lastLevel == LevelTitle.World3Level6 && level == LevelTitle.World3HubDone; break;
case SplitName.Level_4_1_Enter: shouldSplit = lastLevel != LevelTitle.World4Level1 && level == LevelTitle.World4Level1; break;
case SplitName.Level_4_1: shouldSplit = lastLevel == LevelTitle.World4Level1 && level == LevelTitle.World4Level2; break;
case SplitName.Level_4_2: shouldSplit = lastLevel == LevelTitle.World4Level2 && level == LevelTitle.World4Level3; break;
case SplitName.Level_4_3: shouldSplit = lastLevel == LevelTitle.World4Level3 && level == LevelTitle.World4Level4; break;
case SplitName.Level_4_4: shouldSplit = lastLevel == LevelTitle.World4Level4 && level == LevelTitle.World4Level5; break;
case SplitName.Level_4_5: shouldSplit = lastLevel == LevelTitle.World4Level5 && level == LevelTitle.World4Level6; break;
case SplitName.Level_4_6: shouldSplit = lastLevel == LevelTitle.World4Level6 && level == LevelTitle.World4HubDone; break;
case SplitName.Level_End_Normal: shouldSplit = mem.HasWonGame(); break;
case SplitName.Level_End_Mirror: shouldSplit = mem.InHypercube(); break;
}
lastLevel = level;
}
else if (settings.Splits.Count == 0)
{
PlayerState state = mem.PlayerState();
shouldSplit = state == PlayerState.EnteringDoorway && lastState != PlayerState.EnteringDoorway;
lastState = state;
}
Model.CurrentState.IsGameTimePaused = mem.IsLoading();
}
HandleSplit(shouldSplit, settings.Splits.Count == 0 && lastState == PlayerState.WaitingToBeDrawn);
}
