public GfxManager(Control tabControl, WatchVariableFlowLayoutPanel watchVariablePanel)
: base(null, watchVariablePanel)
{
SplitContainer left = tabControl.Controls["splitContainerGfxLeft"] as SplitContainer;
SplitContainer right = left.Panel2.Controls["splitContainerGfxright"] as SplitContainer;
SplitContainer middle = right.Panel1.Controls["splitContainerGfxmiddle"] as SplitContainer;
Button refreshButtonRoot = middle.Panel1.Controls["buttonGfxRefresh"] as Button;
Button refreshButtonObject = middle.Panel1.Controls["buttonGfxRefreshObject"] as Button;
Button dumpButton = middle.Panel1.Controls["buttonGfxDumpDisplayList"] as Button;
Button hitboxViewButton = middle.Panel1.Controls["buttonGfxHitboxHack"] as Button;
_outputTextBox = right.Panel2.Controls["richTextBoxGfx"] as RichTextBox;
_outputTextBox.Font = new System.Drawing.Font("Courier New", 8);
_outputTextBox.ForeColor = System.Drawing.Color.Black;
_watchVariablePanel = watchVariablePanel;
_treeView = left.Panel1.Controls["treeViewGfx"] as TreeView;
_treeView.AfterSelect += _treeView_AfterSelect;
refreshButtonRoot.Click += RefreshButton_Click;
refreshButtonObject.Click += RefreshButtonObject_Click;
dumpButton.Click += DumpButton_Click;
hitboxViewButton.Click += (sender, e) => InjectHitboxViewCode();
_tabControl = tabControl;
foreach (WatchVariableControlPrecursor precursor in GfxNode.GetCommonVariables())
{
watchVariablePanel.AddVariable(precursor.CreateWatchVariableControl());
}
SpecificVariables = new List <WatchVariableControl>();
}
public MiscManager(string varFilePath, WatchVariableFlowLayoutPanel variableTable, Control miscControl)
: base(varFilePath, variableTable, ALL_VAR_GROUPS, VISIBLE_VAR_GROUPS)
{
SplitContainer splitContainerMisc = miscControl.Controls["splitContainerMisc"] as SplitContainer;
_checkBoxTurnOffMusic = splitContainerMisc.Panel1.Controls["checkBoxTurnOffMusic"] as CheckBox;
GroupBox groupBoxRNGIndexTester = splitContainerMisc.Panel1.Controls["groupBoxRNGIndexTester"] as GroupBox;
TextBox textBoxRNGIndexTester = groupBoxRNGIndexTester.Controls["textBoxRNGIndexTester"] as TextBox;
Button buttonRNGIndexTester = groupBoxRNGIndexTester.Controls["buttonRNGIndexTester"] as Button;
buttonRNGIndexTester.Click += (sender, e) =>
{
int?rngIndexNullable = ParsingUtilities.ParseIntNullable(textBoxRNGIndexTester.Text);
if (!rngIndexNullable.HasValue)
{
return;
}
int rngIndex = rngIndexNullable.Value;
ushort rngValue = RngIndexer.GetRngValue(rngIndex);
Config.Stream.SetValue(rngValue, MiscConfig.RngAddress);
int nextRngIndex = rngIndex + 1;
textBoxRNGIndexTester.Text = nextRngIndex.ToString();
};
}
public void Initialize(WatchVariableFlowLayoutPanel varPanel)
{
buttonAddVariable.Click += (sender, e) =>
{
WatchVariableControl control = CreateWatchVariableControl();
varPanel.AddVariable(control);
};
}
public ScriptManager(string varFilePath, TabPage tabPage, WatchVariableFlowLayoutPanel watchVariablePanel)
: base(varFilePath, watchVariablePanel)
{
SplitContainer splitContainer = tabPage.Controls["splitContainerScript"] as SplitContainer;
SplitContainer splitContainerLeft = splitContainer.Panel1.Controls["splitContainerScriptLeft"] as SplitContainer;
_checkBoxScriptRunContinuously = splitContainerLeft.Panel1.Controls["checkBoxScriptRunContinuously"] as CheckBox;
_buttonScriptRunOnce = splitContainerLeft.Panel1.Controls["buttonScriptRunOnce"] as Button;
_buttonScriptInstructions = splitContainerLeft.Panel1.Controls["buttonScriptInstructions"] as Button;
_buttonScriptExamples = splitContainerLeft.Panel1.Controls["buttonScriptExamples"] as Button;
SplitContainer splitContainerLeft2 = splitContainerLeft.Panel2.Controls["splitContainerScriptLeft2"] as SplitContainer;
_richTextBoxScript = splitContainerLeft2.Panel1.Controls["richTextBoxScript"] as RichTextBoxEx;
_richTextBoxConsole = splitContainerLeft2.Panel2.Controls["richTextBoxConsole"] as RichTextBoxEx;
_consoleStrings = new List <string>();
_script = new TokenScript(_consoleStrings);
_checkBoxScriptRunContinuously.Click += (sender, e) =>
{
_richTextBoxScript.ReadOnly = _checkBoxScriptRunContinuously.Checked;
};
_buttonScriptRunOnce.Click += (sender, e) =>
{
RunScript();
};
_buttonScriptInstructions.Click += (sender, e) =>
{
InfoForm.ShowValue(
string.Join("\r\n", _instructions),
"Instructions",
"Instructions");
};
_buttonScriptExamples.ContextMenuStrip = new ContextMenuStrip();
for (int i = 0; i < _exampleNames.Count; i++)
{
ToolStripMenuItem item = new ToolStripMenuItem(_exampleNames[i]);
string text = string.Join("\r\n", _exampleLines[i]);
item.Click += (sender, e) => _richTextBoxScript.Text = text;
_buttonScriptExamples.ContextMenuStrip.Items.Add(item);
}
_buttonScriptExamples.Click += (sender, e) =>
_buttonScriptExamples.ContextMenuStrip.Show(Cursor.Position);
ToolStripMenuItem itemClearConsole = new ToolStripMenuItem("Clear Console");
itemClearConsole.Click += (sender, e) =>
{
_consoleStrings.Clear();
_richTextBoxConsole.Clear();
};
_richTextBoxConsole.ContextMenuStrip = new ContextMenuStrip();
_richTextBoxConsole.ContextMenuStrip.Items.Add(itemClearConsole);
}
public MusicManager(string varFilePath, WatchVariableFlowLayoutPanel variables, TabPage tabPage)
: base(varFilePath, variables)
{
SplitContainer splitContainer = tabPage.Controls["splitContainerMusic"] as SplitContainer;
_listBoxMusic = splitContainer.Panel1.Controls["listBoxMusic"] as ListBox;
for (int i = 0; i < 3; i++)
{
_listBoxMusic.Items.Add(i);
}
}
public PaintingManager(string varFilePath, WatchVariableFlowLayoutPanel variables, TabPage tabPage)
: base(varFilePath, variables)
{
SplitContainer splitContainer = tabPage.Controls["splitContainerPainting"] as SplitContainer;
_listBoxPainting = splitContainer.Panel1.Controls["listBoxPainting"] as ListBox;
foreach (PaintingData paintingData in paintingDataList)
{
_listBoxPainting.Items.Add(paintingData);
}
}
public DataManager(
string varFilePath,
WatchVariableFlowLayoutPanel variablePanel,
List <VariableGroup> allVariableGroups = null,
List <VariableGroup> visibleVariableGroups = null) : base(variablePanel)
{
_variablePanel = variablePanel;
_variablePanel.Initialize(
varFilePath,
allVariableGroups,
visibleVariableGroups);
}
public DataManager(
string varFilePath,
WatchVariableFlowLayoutPanel variablePanel,
List <VariableGroup> allVariableGroups = null,
List <VariableGroup> visibleVariableGroups = null) : base(variablePanel)
{
_variablePanel = variablePanel;
_initializeAction = () => _variablePanel.Initialize(varFilePath, allVariableGroups, visibleVariableGroups);
if (!SavedSettingsConfig.DoQuickStartup)
{
_initializeAction();
}
}
public InputManager(
string varFilePath, Control inputControl, WatchVariableFlowLayoutPanel variableTable,
List <InputImageGui> guiList)
: base(varFilePath, variableTable)
{
_guiList = guiList;
SplitContainer splitContainerInput = inputControl.Controls["splitContainerInput"] as SplitContainer;
_inputDisplayPanel = splitContainerInput.Panel1.Controls["inputDisplayPanel"] as InputDisplayPanel;
_inputDisplayPanel.SetInputDisplayGui(_guiList);
}
public CellsManager(string varFilePath, TabPage tabControl, WatchVariableFlowLayoutPanel watchVariablePanel)
: base(varFilePath, watchVariablePanel)
{
TriangleAddress = 0;
SplitContainer splitContainerCells = tabControl.Controls["splitContainerCells"] as SplitContainer;
SplitContainer splitContainerCellsControls = splitContainerCells.Panel1.Controls["splitContainerCellsControls"] as SplitContainer;
_buttonCellsBuildTree = splitContainerCellsControls.Panel1.Controls["buttonCellsBuildTree"] as Button;
_buttonCellsBuildTree.Click += (sender, e) => BuildTree();
_treeViewCells = splitContainerCellsControls.Panel2.Controls["treeViewCells"] as TreeView;
_treeViewCells.AfterSelect += (sender, e) => SetTriangleAddress();
}
public DataManager(
string varFilePath,
WatchVariableFlowLayoutPanel variablePanel,
List <VariableGroup> allVariableGroups = null,
List <VariableGroup> visibleVariableGroups = null)
{
_variablePanel = variablePanel;
_variablePanel.Initialize(
varFilePath,
allVariableGroups,
visibleVariableGroups);
TabName = ControlUtilities.GetTabName(_variablePanel);
TabIndex = ControlUtilities.GetTabIndex(_variablePanel);
}
public PuManager(string varFilePath, TabPage tabControl, WatchVariableFlowLayoutPanel watchVariablePanel)
: base(varFilePath, watchVariablePanel, ALL_VAR_GROUPS, VISIBLE_VAR_GROUPS)
{
SplitContainer splitContainerFile = tabControl.Controls["splitContainerPu"] as SplitContainer;
_puController = splitContainerFile.Panel1.Controls["groupBoxPuController"] as GroupBox;
// Pu Controller initialize and register click events
_puController.Controls["buttonPuConHome"].Click += (sender, e) => PuUtilities.SetMarioPu(0, 0, 0);
_puController.Controls["buttonPuConZnQpu"].Click += (sender, e) => PuUtilities.TranslateMarioPu(0, 0, -4);
_puController.Controls["buttonPuConZpQpu"].Click += (sender, e) => PuUtilities.TranslateMarioPu(0, 0, 4);
_puController.Controls["buttonPuConXnQpu"].Click += (sender, e) => PuUtilities.TranslateMarioPu(-4, 0, 0);
_puController.Controls["buttonPuConXpQpu"].Click += (sender, e) => PuUtilities.TranslateMarioPu(4, 0, 0);
_puController.Controls["buttonPuConZnPu"].Click += (sender, e) => PuUtilities.TranslateMarioPu(0, 0, -1);
_puController.Controls["buttonPuConZpPu"].Click += (sender, e) => PuUtilities.TranslateMarioPu(0, 0, 1);
_puController.Controls["buttonPuConXnPu"].Click += (sender, e) => PuUtilities.TranslateMarioPu(-1, 0, 0);
_puController.Controls["buttonPuConXpPu"].Click += (sender, e) => PuUtilities.TranslateMarioPu(1, 0, 0);
GroupBox groupBoxMarioPu = splitContainerFile.Panel1.Controls["groupBoxMarioPu"] as GroupBox;
ControlUtilities.InitializeThreeDimensionController(
CoordinateSystem.Euler,
false,
groupBoxMarioPu,
groupBoxMarioPu.Controls["buttonMarioPuXn"] as Button,
groupBoxMarioPu.Controls["buttonMarioPuXp"] as Button,
groupBoxMarioPu.Controls["buttonMarioPuZn"] as Button,
groupBoxMarioPu.Controls["buttonMarioPuZp"] as Button,
groupBoxMarioPu.Controls["buttonMarioPuXnZn"] as Button,
groupBoxMarioPu.Controls["buttonMarioPuXnZp"] as Button,
groupBoxMarioPu.Controls["buttonMarioPuXpZn"] as Button,
groupBoxMarioPu.Controls["buttonMarioPuXpZp"] as Button,
groupBoxMarioPu.Controls["buttonMarioPuYp"] as Button,
groupBoxMarioPu.Controls["buttonMarioPuYn"] as Button,
groupBoxMarioPu.Controls["textBoxMarioPuXZ"] as TextBox,
groupBoxMarioPu.Controls["textBoxMarioPuY"] as TextBox,
groupBoxMarioPu.Controls["checkBoxMarioPuQpu"] as CheckBox,
(float hOffset, float vOffset, float nOffset, bool useQpu) =>
{
int hOffsetInt = ParsingUtilities.ParseInt(hOffset);
int vOffsetInt = ParsingUtilities.ParseInt(vOffset);
int nOffsetInt = ParsingUtilities.ParseInt(nOffset);
int multiplier = useQpu ? 4 : 1;
PuUtilities.TranslateMarioPu(
hOffsetInt * multiplier,
nOffsetInt * multiplier,
-1 * vOffsetInt * multiplier);
});
}
public ActionsManager(string varFilePath, WatchVariableFlowLayoutPanel variableTable, Control actionsControl)
: base(varFilePath, variableTable)
{
textBoxActionDescription = actionsControl.Controls["textBoxActionDescription"] as BetterTextbox;
textBoxAnimationDescription = actionsControl.Controls["textBoxAnimationDescription"] as BetterTextbox;
textBoxActionDescription.DoubleClick += (sender, e) => SelectionForm.ShowActionDescriptionSelectionForm();
textBoxAnimationDescription.DoubleClick += (sender, e) => SelectionForm.ShowAnimationDescriptionSelectionForm();
ControlUtilities.AddContextMenuStripFunctions(
textBoxActionDescription,
new List <string>()
{
"Select Action", "Free Movement Action", "Open Action Form"
},
new List <Action>()
{
() => SelectionForm.ShowActionDescriptionSelectionForm(),
() => Config.Stream.SetValue(MarioConfig.FreeMovementAction, MarioConfig.StructAddress + MarioConfig.ActionOffset),
() => new ActionForm().Show(),
});
ControlUtilities.AddContextMenuStripFunctions(
textBoxAnimationDescription,
new List <string>()
{
"Select Animation", "Replace Animation"
},
new List <Action>()
{
() => SelectionForm.ShowAnimationDescriptionSelectionForm(),
() =>
{
int?animationToBeReplaced = SelectionForm.GetAnimation("Choose Animation to Be Replaced", "Select Animation");
int?animationToReplaceIt = SelectionForm.GetAnimation("Choose Animation to Replace It", "Select Animation");
if (animationToBeReplaced == null || animationToReplaceIt == null)
{
return;
}
AnimationUtilities.ReplaceAnimation(animationToBeReplaced.Value, animationToReplaceIt.Value);
},
});
}
public WarpManager(string varFilePath, TabPage tabPage, WatchVariableFlowLayoutPanel watchVariablePanel)
: base(varFilePath, watchVariablePanel, ALL_VAR_GROUPS, VISIBLE_VAR_GROUPS)
{
_warpNodeAddresses = new List <uint>();
SplitContainer splitContainerWarp = tabPage.Controls["splitContainerWarp"] as SplitContainer;
SplitContainer splitContainerWarpLeft = splitContainerWarp.Panel1.Controls["splitContainerWarpLeft"] as SplitContainer;
Button buttonWarpInstructions = splitContainerWarpLeft.Panel1.Controls["buttonWarpInstructions"] as Button;
Button buttonWarpHookUpTeleporters = splitContainerWarpLeft.Panel2.Controls["buttonWarpHookUpTeleporters"] as Button;
buttonWarpInstructions.Click += (sender, e) =>
{
InfoForm.ShowValue(
string.Join("\r\n", _instructions),
"Instructions",
"Instructions");
};
buttonWarpHookUpTeleporters.Click += (sender, e) => HookUpTeleporters();
}
public HudManager(string varFilePath, Control tabControl, WatchVariableFlowLayoutPanel watchVariablePanelHud)
: base(varFilePath, watchVariablePanelHud)
{
_tabControl = tabControl;
SplitContainer splitContainerHud = tabControl.Controls["splitContainerHud"] as SplitContainer;
(splitContainerHud.Panel1.Controls["buttonFullHp"] as Button).Click += (sender, e) => ButtonUtilities.FullHp();
(splitContainerHud.Panel1.Controls["buttonDie"] as Button).Click += (sender, e) => ButtonUtilities.Die();
(splitContainerHud.Panel1.Controls["buttonGameOver"] as Button).Click += (sender, e) => ButtonUtilities.GameOver();
(splitContainerHud.Panel1.Controls["button99Coins"] as Button).Click += (sender, e) => ButtonUtilities.Coins99();
(splitContainerHud.Panel1.Controls["button100CoinStar"] as Button).Click += (sender, e) => ButtonUtilities.CoinStar100();
(splitContainerHud.Panel1.Controls["button100Lives"] as Button).Click += (sender, e) => ButtonUtilities.Lives100();
(splitContainerHud.Panel1.Controls["buttonStandardHud"] as Button).Click += (sender, e) => ButtonUtilities.StandardHud();
_turnOnOffHudButton = splitContainerHud.Panel1.Controls["buttonTurnOnOffHud"] as BinaryButton;
_turnOnOffHudButton.Initialize(
"Turn Off HUD",
"Turn On HUD",
() => ButtonUtilities.SetHudVisibility(false),
() => ButtonUtilities.SetHudVisibility(true),
() => (Config.Stream.GetByte(MarioConfig.StructAddress + HudConfig.VisibilityOffset) & HudConfig.VisibilityMask) == 0);
ControlUtilities.AddContextMenuStripFunctions(
_turnOnOffHudButton,
new List <string>()
{
"Disable HUD by Changing Level Index",
"Enable HUD by Changing Level Index",
"Disable HUD by Removing Function",
"Enable HUD by Removing Function",
},
new List <Action>()
{
() => ButtonUtilities.SetHudVisibility(false, true),
() => ButtonUtilities.SetHudVisibility(true, true),
() => ButtonUtilities.SetHudVisibility(false, false),
() => ButtonUtilities.SetHudVisibility(true, false),
});
_checkBoxFullHP = splitContainerHud.Panel1.Controls["checkBoxFullHP"] as CheckBox;
}
public TasManager(string varFilePath, TabPage tabControl, WatchVariableFlowLayoutPanel watchVariablePanel)
: base(varFilePath, watchVariablePanel, ALL_VAR_GROUPS, VISIBLE_VAR_GROUPS)
{
SplitContainer splitContainerTas = tabControl.Controls["splitContainerTas"] as SplitContainer;
SplitContainer splitContainerTasTable = splitContainerTas.Panel1.Controls["splitContainerTasTable"] as SplitContainer;
_dataGridViewTas = splitContainerTasTable.Panel2.Controls["dataGridViewTas"] as DataGridView;
_checkBoxTasRecordData = splitContainerTasTable.Panel1.Controls["checkBoxTasRecordData"] as CheckBox;
_buttonTasClearData = splitContainerTasTable.Panel1.Controls["buttonTasClearData"] as Button;
_buttonTasClearData.Click += (sender, e) => ClearData();
_richTextBoxTasInstructions = splitContainerTasTable.Panel1.Controls["richTextBoxTasInstructions"] as RichTextBox;
Button buttonTasStoreMarioPosition = splitContainerTasTable.Panel1.Controls["buttonTasStoreMarioPosition"] as Button;
buttonTasStoreMarioPosition.Click += (sender, e) => StoreMarioInfo(x: true, y: true, z: true);
ControlUtilities.AddContextMenuStripFunctions(
buttonTasStoreMarioPosition,
new List <string>()
{
"Store Position", "Store Lateral Position", "Store X", "Store Y", "Store Z"
},
new List <Action>()
{
() => StoreMarioInfo(x: true, y: true, z: true),
() => StoreMarioInfo(x: true, z: true),
() => StoreMarioInfo(x: true),
() => StoreMarioInfo(y: true),
() => StoreMarioInfo(z: true),
});
Button buttonTasStoreMarioAngle = splitContainerTasTable.Panel1.Controls["buttonTasStoreMarioAngle"] as Button;
buttonTasStoreMarioAngle.Click += (sender, e) => StoreMarioInfo(angle: true);
_waitingGlobalTimer = 0;
_waitingDateTime = DateTime.Now;
_lastUpdatedGlobalTimer = 0;
_dataDictionary = new Dictionary <uint, TasDataStruct>();
_rowDictionary = new Dictionary <uint, DataGridViewRow>();
}
public ActionsManager(string varFilePath, WatchVariableFlowLayoutPanel variableTable, Control actionsControl)
: base(varFilePath, variableTable)
{
textBoxActionDescription = actionsControl.Controls["textBoxActionDescription"] as BetterTextbox;
textBoxAnimationDescription = actionsControl.Controls["textBoxAnimationDescription"] as BetterTextbox;
textBoxActionDescription.DoubleClick += (sender, e) => SelectionForm.ShowActionSelectionForm();
textBoxAnimationDescription.DoubleClick += (sender, e) => SelectionForm.ShowAnimationSelectionForm();
ControlUtilities.AddContextMenuStripFunctions(
textBoxActionDescription,
new List <string>()
{
"Select Action", "Free Movement Action", "Open Action Form"
},
new List <Action>()
{
() => SelectionForm.ShowActionSelectionForm(),
() => Config.Stream.SetValue(MarioConfig.FreeMovementAction, MarioConfig.StructAddress + MarioConfig.ActionOffset),
() => new ActionForm().Show(),
});
}
public MiscManager(string varFilePath, WatchVariableFlowLayoutPanel variableTable, Control miscControl)
: base(varFilePath, variableTable, ALL_VAR_GROUPS, VISIBLE_VAR_GROUPS)
{
SplitContainer splitContainerMisc = miscControl.Controls["splitContainerMisc"] as SplitContainer;
_checkBoxTurnOffMusic = splitContainerMisc.Panel1.Controls["checkBoxTurnOffMusic"] as CheckBox;
GroupBox groupBoxRNGIndexTester = splitContainerMisc.Panel1.Controls["groupBoxRNGIndexTester"] as GroupBox;
TextBox textBoxRNGIndexTester = groupBoxRNGIndexTester.Controls["textBoxRNGIndexTester"] as TextBox;
Button buttonRNGIndexTester = groupBoxRNGIndexTester.Controls["buttonRNGIndexTester"] as Button;
buttonRNGIndexTester.Click += (sender, e) =>
{
int?rngIndexNullable = ParsingUtilities.ParseIntNullable(textBoxRNGIndexTester.Text);
if (!rngIndexNullable.HasValue)
{
return;
}
int rngIndex = rngIndexNullable.Value;
ushort rngValue = RngIndexer.GetRngValue(rngIndex);
Config.Stream.SetValue(rngValue, MiscConfig.RngAddress);
int nextRngIndex = rngIndex + 1;
textBoxRNGIndexTester.Text = nextRngIndex.ToString();
};
Button buttonMiscGoToCourse = splitContainerMisc.Panel1.Controls["buttonMiscGoToCourse"] as Button;
buttonMiscGoToCourse.ContextMenuStrip = new ContextMenuStrip();
foreach (CourseToGoTo courseToGoTo in _coursesToGoTo)
{
ToolStripMenuItem item = new ToolStripMenuItem(courseToGoTo.Name);
item.Click += (sender, e) => InGameFunctionCall.WriteInGameFunctionCall(
RomVersionConfig.SwitchMap(0x8024978C, 0x8024975C), (uint)courseToGoTo.Index);
buttonMiscGoToCourse.ContextMenuStrip.Items.Add(item);
}
buttonMiscGoToCourse.Click += (sender, e) => buttonMiscGoToCourse.ContextMenuStrip.Show(Cursor.Position);
}
public AreaManager(Control tabControl, string varFilePath, WatchVariableFlowLayoutPanel watchVariableLayoutPanel)
: base(varFilePath, watchVariableLayoutPanel)
{
_selectedAreaAddress = AreaUtilities.GetAreaAddress(0);
SplitContainer splitContainerArea = tabControl.Controls["splitContainerArea"] as SplitContainer;
_selectedAreaRadioButtons = new List <RadioButton>();
for (int i = 0; i < 8; i++)
{
_selectedAreaRadioButtons.Add(splitContainerArea.Panel1.Controls["radioButtonArea" + i] as RadioButton);
}
_selectCurrentAreaCheckbox = splitContainerArea.Panel1.Controls["checkBoxSelectCurrentArea"] as CheckBox;
for (int i = 0; i < _selectedAreaRadioButtons.Count; i++)
{
int index = i;
_selectedAreaRadioButtons[i].Click += (sender, e) =>
{
_selectCurrentAreaCheckbox.Checked = false;
_selectedAreaAddress = AreaUtilities.GetAreaAddress(index);
};
}
}
public static List<ToolStripItem> CreateSelectionToolStripItems(
Func<List<WatchVariableControl>> getVars,
WatchVariableFlowLayoutPanel panel)
{
Action<WatchVariableControlSettings> apply = (WatchVariableControlSettings settings) =>
{
if (KeyboardUtilities.IsCtrlHeld())
WatchVariableControlSettingsManager.AddSettings(settings);
else
getVars().ForEach(control => control.ApplySettings(settings));
};
ToolStripMenuItem itemHighlight = new ToolStripMenuItem("Highlight...");
ControlUtilities.AddDropDownItems(
itemHighlight,
new List<string>() { "Highlight", "Don't Highlight" },
new List<Action>()
{
() => apply(new WatchVariableControlSettings(changeHighlighted: true, newHighlighted: true)),
() => apply(new WatchVariableControlSettings(changeHighlighted: true, newHighlighted: false)),
});
ToolStripMenuItem itemLock = new ToolStripMenuItem("Lock...");
ControlUtilities.AddDropDownItems(
itemLock,
new List<string>() { "Lock", "Don't Lock" },
new List<Action>()
{
() => apply(new WatchVariableControlSettings(changeLocked: true, newLocked: true)),
() => apply(new WatchVariableControlSettings(changeLocked: true, newLocked: false)),
});
ToolStripMenuItem itemCopy = new ToolStripMenuItem("Copy...");
Action<List<WatchVariableControl>, string> copyValues =
(List<WatchVariableControl> controls, string separator) =>
{
Clipboard.SetText(
String.Join(separator, controls.ConvertAll(
control => control.GetValue(false))));
};
ControlUtilities.AddDropDownItems(
itemCopy,
new List<string>() {
"Copy with Commas",
"Copy with Tabs",
"Copy with Line Breaks",
"Copy for Code",
},
new List<Action>()
{
() => copyValues(getVars(), ","),
() => copyValues(getVars(), "\t"),
() => copyValues(getVars(), "\r\n"),
() =>
{
List<WatchVariableControl> watchVars = getVars();
string prefix = KeyboardUtilities.IsCtrlHeld() ? DialogUtilities.GetStringFromDialog() : "";
List<string> lines = new List<string>();
foreach (WatchVariableControl watchVar in watchVars)
{
Type type = watchVar.GetMemoryType();
string line = String.Format(
"{0} {1}{2} = {3}{4};",
type != null ? TypeUtilities.TypeToString[watchVar.GetMemoryType()] : "double",
prefix,
watchVar.VarName.Replace(" ", ""),
watchVar.GetValue(false),
type == typeof(float) ? "f" : "");
lines.Add(line);
}
if (lines.Count > 0)
{
Clipboard.SetText(String.Join("\r\n", lines));
}
},
});
ToolStripMenuItem itemPaste = new ToolStripMenuItem("Paste");
itemPaste.Click += (sender, e) =>
{
List<string> stringList = ParsingUtilities.ParseStringList(Clipboard.GetText());
List<WatchVariableControl> varList = getVars();
if (stringList.Count != varList.Count) return;
Config.Stream.Suspend();
for (int i = 0; i < stringList.Count; i++)
{
varList[i].SetValue(stringList[i]);
}
Config.Stream.Resume();
};
ToolStripMenuItem itemRoundTo = new ToolStripMenuItem("Round to...");
ToolStripMenuItem itemRoundToDefault = new ToolStripMenuItem("Default");
itemRoundToDefault.Click += (sender, e) =>
apply(new WatchVariableControlSettings(
changeRoundingLimit: true, changeRoundingLimitToDefault: true));
ToolStripMenuItem itemRoundToNoRounding = new ToolStripMenuItem("No Rounding");
itemRoundToNoRounding.Click += (sender, e) =>
apply(new WatchVariableControlSettings(
changeRoundingLimit: true, newRoundingLimit: -1));
List<ToolStripMenuItem> itemsRoundToNumDecimalPlaces = new List<ToolStripMenuItem>();
for (int i = 0; i <= 10; i++)
{
int index = i;
itemsRoundToNumDecimalPlaces.Add(new ToolStripMenuItem(index + " decimal place(s)"));
itemsRoundToNumDecimalPlaces[index].Click += (sender, e) =>
apply(new WatchVariableControlSettings(
changeRoundingLimit: true, newRoundingLimit: index));
}
itemRoundTo.DropDownItems.Add(itemRoundToDefault);
itemRoundTo.DropDownItems.Add(itemRoundToNoRounding);
itemsRoundToNumDecimalPlaces.ForEach(setAllRoundingLimitsNumberItem =>
{
itemRoundTo.DropDownItems.Add(setAllRoundingLimitsNumberItem);
});
ToolStripMenuItem itemDisplayAsHex = new ToolStripMenuItem("Display as Hex...");
ControlUtilities.AddDropDownItems(
itemDisplayAsHex,
new List<string>() { "Default", "Hex", "Decimal" },
new List<Action>()
{
() => apply(new WatchVariableControlSettings(changeDisplayAsHex: true, changeDisplayAsHexToDefault: true)),
() => apply(new WatchVariableControlSettings(changeDisplayAsHex: true, newDisplayAsHex: true)),
() => apply(new WatchVariableControlSettings(changeDisplayAsHex: true, newDisplayAsHex: false)),
});
ToolStripMenuItem itemAngleSigned = new ToolStripMenuItem("Angle: Signed...");
ControlUtilities.AddDropDownItems(
itemAngleSigned,
new List<string>() { "Default", "Unsigned", "Signed" },
new List<Action>()
{
() => apply(new WatchVariableControlSettings(changeAngleSigned: true, changeAngleSignedToDefault: true)),
() => apply(new WatchVariableControlSettings(changeAngleSigned: true, newAngleSigned: false)),
() => apply(new WatchVariableControlSettings(changeAngleSigned: true, newAngleSigned: true)),
});
ToolStripMenuItem itemAngleUnits = new ToolStripMenuItem("Angle: Units...");
ToolStripMenuItem itemAngleUnitsDefault = new ToolStripMenuItem("Default");
itemAngleUnitsDefault.Click += (sender, e) =>
apply(new WatchVariableControlSettings(
changeAngleUnits: true, changeAngleUnitsToDefault: true));
List<ToolStripMenuItem> itemsAngleUnitsValue = new List<ToolStripMenuItem>();
foreach (AngleUnitType angleUnitType in Enum.GetValues(typeof(AngleUnitType)))
{
AngleUnitType angleUnitTypeFixed = angleUnitType;
ToolStripMenuItem itemAngleUnitsValue = new ToolStripMenuItem(angleUnitTypeFixed.ToString());
itemAngleUnitsValue.Click += (sender, e) =>
apply(new WatchVariableControlSettings(
changeAngleUnits: true, newAngleUnits: angleUnitTypeFixed));
itemsAngleUnitsValue.Add(itemAngleUnitsValue);
}
itemAngleUnits.DropDownItems.Add(itemAngleUnitsDefault);
itemsAngleUnitsValue.ForEach(setAllAngleUnitsValuesItem =>
{
itemAngleUnits.DropDownItems.Add(setAllAngleUnitsValuesItem);
});
ToolStripMenuItem itemAngleTruncateToMultipleOf16 = new ToolStripMenuItem("Angle: Truncate to Multiple of 16...");
ControlUtilities.AddDropDownItems(
itemAngleTruncateToMultipleOf16,
new List<string>() { "Default", "Truncate to Multiple of 16", "Don't Truncate to Multiple of 16" },
new List<Action>()
{
() => apply(new WatchVariableControlSettings(changeAngleTruncateToMultipleOf16: true, changeAngleTruncateToMultipleOf16ToDefault: true)),
() => apply(new WatchVariableControlSettings(changeAngleTruncateToMultipleOf16: true, newAngleTruncateToMultipleOf16: true)),
() => apply(new WatchVariableControlSettings(changeAngleTruncateToMultipleOf16: true, newAngleTruncateToMultipleOf16: false)),
});
ToolStripMenuItem itemAngleConstrainToOneRevolution = new ToolStripMenuItem("Angle: Constrain to One Revolution...");
ControlUtilities.AddDropDownItems(
itemAngleConstrainToOneRevolution,
new List<string>() { "Default", "Constrain to One Revolution", "Don't Constrain to One Revolution" },
new List<Action>()
{
() => apply(new WatchVariableControlSettings(changeAngleConstrainToOneRevolution: true, changeAngleConstrainToOneRevolutionToDefault: true)),
() => apply(new WatchVariableControlSettings(changeAngleConstrainToOneRevolution: true, newAngleConstrainToOneRevolution: true)),
() => apply(new WatchVariableControlSettings(changeAngleConstrainToOneRevolution: true, newAngleConstrainToOneRevolution: false)),
});
ToolStripMenuItem itemAngleDisplayAsHex = new ToolStripMenuItem("Angle: Display as Hex...");
ControlUtilities.AddDropDownItems(
itemAngleDisplayAsHex,
new List<string>() { "Default", "Hex", "Decimal" },
new List<Action>()
{
() => apply(new WatchVariableControlSettings(changeAngleDisplayAsHex: true, changeAngleDisplayAsHexToDefault: true)),
() => apply(new WatchVariableControlSettings(changeAngleDisplayAsHex: true, newAngleDisplayAsHex: true)),
() => apply(new WatchVariableControlSettings(changeAngleDisplayAsHex: true, newAngleDisplayAsHex: false)),
});
ToolStripMenuItem itemShowVariableXml = new ToolStripMenuItem("Show Variable XML");
itemShowVariableXml.Click += (sender, e) =>
{
InfoForm infoForm = new InfoForm();
infoForm.SetText(
"Variable Info",
"Variable XML",
String.Join("\r\n", getVars().ConvertAll(control => control.ToXml(true))));
infoForm.Show();
};
ToolStripMenuItem itemShowVariableInfo = new ToolStripMenuItem("Show Variable Info");
itemShowVariableInfo.Click += (sender, e) =>
{
InfoForm infoForm = new InfoForm();
infoForm.SetText(
"Variable Info",
"Variable Info",
String.Join("\t",
WatchVariableWrapper.GetVarInfoLabels()) +
"\r\n" +
String.Join(
"\r\n",
getVars().ConvertAll(control => control.GetVarInfo())
.ConvertAll(infoList => String.Join("\t", infoList))));
infoForm.Show();
};
ToolStripMenuItem itemMove = new ToolStripMenuItem("Move...");
ControlUtilities.AddDropDownItems(
itemMove,
new List<string>() { "Start Move", "End Move", "Clear Move" },
new List<Action>()
{
() => panel.NotifyOfReorderingStart(getVars()),
() => panel.NotifyOfReorderingEnd(getVars()),
() => panel.NotifyOfReorderingClear(),
});
ToolStripMenuItem itemRemove = new ToolStripMenuItem("Remove");
itemRemove.Click += (sender, e) => panel.RemoveVariables(getVars());
ToolStripMenuItem itemEnableCustomization = new ToolStripMenuItem("Enable Customization");
itemEnableCustomization.Click += (sender, e) => apply(new WatchVariableControlSettings(enableCustomization: true));
ToolStripMenuItem itemOpenController = new ToolStripMenuItem("Open Controller");
itemOpenController.Click += (sender, e) =>
{
List<WatchVariableControl> vars = getVars();
VariableControllerForm varController =
new VariableControllerForm(
vars.ConvertAll(control => control.VarName),
vars.ConvertAll(control => control.WatchVarWrapper),
vars.ConvertAll(control => control.FixedAddressList));
varController.Show();
};
ToolStripMenuItem itemOpenPopOut = new ToolStripMenuItem("Open Pop Out");
itemOpenPopOut.Click += (sender, e) =>
{
VariablePopOutForm form = new VariablePopOutForm();
form.Initialize(getVars().ConvertAll(control => control.CreateCopy()));
form.ShowForm();
};
ToolStripMenuItem itemAddToTab = new ToolStripMenuItem("Add to Tab...");
itemAddToTab.Click += (sender, e) => SelectionForm.ShowDataManagerSelectionForm(getVars());
ToolStripMenuItem itemAddToCustomTab = new ToolStripMenuItem("Add to Custom Tab");
itemAddToCustomTab.Click += (sender, e) => WatchVariableControl.AddVarsToTab(getVars(), Config.CustomManager);
return new List<ToolStripItem>
{
itemHighlight,
itemLock,
itemCopy,
itemPaste,
new ToolStripSeparator(),
itemRoundTo,
itemDisplayAsHex,
new ToolStripSeparator(),
itemAngleSigned,
itemAngleUnits,
itemAngleTruncateToMultipleOf16,
itemAngleConstrainToOneRevolution,
itemAngleDisplayAsHex,
new ToolStripSeparator(),
itemShowVariableXml,
itemShowVariableInfo,
new ToolStripSeparator(),
itemMove,
itemRemove,
itemEnableCustomization,
itemOpenController,
itemOpenPopOut,
itemAddToTab,
itemAddToCustomTab,
};
}
public MarioManager(string varFilePath, Control marioControl, WatchVariableFlowLayoutPanel variableTable)
: base(varFilePath, variableTable, ALL_VAR_GROUPS, VISIBLE_VAR_GROUPS)
{
SplitContainer splitContainerMario = marioControl.Controls["splitContainerMario"] as SplitContainer;
Button toggleHandsfree = splitContainerMario.Panel1.Controls["buttonMarioToggleHandsfree"] as Button;
toggleHandsfree.Click += (sender, e) => ButtonUtilities.ToggleHandsfree();
Button toggleVisibility = splitContainerMario.Panel1.Controls["buttonMarioVisibility"] as Button;
toggleVisibility.Click += (sender, e) => ButtonUtilities.ToggleVisibility();
var marioPosGroupBox = splitContainerMario.Panel1.Controls["groupBoxMarioPos"] as GroupBox;
ControlUtilities.InitializeThreeDimensionController(
CoordinateSystem.Euler,
true,
marioPosGroupBox,
marioPosGroupBox.Controls["buttonMarioPosXn"] as Button,
marioPosGroupBox.Controls["buttonMarioPosXp"] as Button,
marioPosGroupBox.Controls["buttonMarioPosZn"] as Button,
marioPosGroupBox.Controls["buttonMarioPosZp"] as Button,
marioPosGroupBox.Controls["buttonMarioPosXnZn"] as Button,
marioPosGroupBox.Controls["buttonMarioPosXnZp"] as Button,
marioPosGroupBox.Controls["buttonMarioPosXpZn"] as Button,
marioPosGroupBox.Controls["buttonMarioPosXpZp"] as Button,
marioPosGroupBox.Controls["buttonMarioPosYp"] as Button,
marioPosGroupBox.Controls["buttonMarioPosYn"] as Button,
marioPosGroupBox.Controls["textBoxMarioPosXZ"] as TextBox,
marioPosGroupBox.Controls["textBoxMarioPosY"] as TextBox,
marioPosGroupBox.Controls["checkBoxMarioPosRelative"] as CheckBox,
(float hOffset, float vOffset, float nOffset, bool useRelative) =>
{
ButtonUtilities.TranslateMario(
hOffset,
nOffset,
-1 * vOffset,
useRelative);
});
var marioStatsGroupBox = splitContainerMario.Panel1.Controls["groupBoxMarioStats"] as GroupBox;
ControlUtilities.InitializeScalarController(
marioStatsGroupBox.Controls["buttonMarioStatsYawN"] as Button,
marioStatsGroupBox.Controls["buttonMarioStatsYawP"] as Button,
marioStatsGroupBox.Controls["textBoxMarioStatsYaw"] as TextBox,
(float value) =>
{
ButtonUtilities.MarioChangeYaw((int)Math.Round(value));
});
ControlUtilities.InitializeScalarController(
marioStatsGroupBox.Controls["buttonMarioStatsHspdN"] as Button,
marioStatsGroupBox.Controls["buttonMarioStatsHspdP"] as Button,
marioStatsGroupBox.Controls["textBoxMarioStatsHspd"] as TextBox,
(float value) =>
{
ButtonUtilities.MarioChangeHspd(value);
});
ControlUtilities.InitializeScalarController(
marioStatsGroupBox.Controls["buttonMarioStatsVspdN"] as Button,
marioStatsGroupBox.Controls["buttonMarioStatsVspdP"] as Button,
marioStatsGroupBox.Controls["textBoxMarioStatsVspd"] as TextBox,
(float value) =>
{
ButtonUtilities.MarioChangeVspd(value);
});
var marioSlidingSpeedGroupBox = splitContainerMario.Panel1.Controls["groupBoxMarioSlidingSpeed"] as GroupBox;
ControlUtilities.InitializeScalarController(
marioSlidingSpeedGroupBox.Controls["buttonMarioSlidingSpeedXn"] as Button,
marioSlidingSpeedGroupBox.Controls["buttonMarioSlidingSpeedXp"] as Button,
marioSlidingSpeedGroupBox.Controls["textBoxMarioSlidingSpeedX"] as TextBox,
(float value) =>
{
ButtonUtilities.MarioChangeSlidingSpeedX(value);
});
ControlUtilities.InitializeScalarController(
marioSlidingSpeedGroupBox.Controls["buttonMarioSlidingSpeedZn"] as Button,
marioSlidingSpeedGroupBox.Controls["buttonMarioSlidingSpeedZp"] as Button,
marioSlidingSpeedGroupBox.Controls["textBoxMarioSlidingSpeedZ"] as TextBox,
(float value) =>
{
ButtonUtilities.MarioChangeSlidingSpeedZ(value);
});
ControlUtilities.InitializeScalarController(
marioSlidingSpeedGroupBox.Controls["buttonMarioSlidingSpeedHn"] as Button,
marioSlidingSpeedGroupBox.Controls["buttonMarioSlidingSpeedHp"] as Button,
marioSlidingSpeedGroupBox.Controls["textBoxMarioSlidingSpeedH"] as TextBox,
(float value) =>
{
ButtonUtilities.MarioChangeSlidingSpeedH(value);
});
ControlUtilities.InitializeScalarController(
marioSlidingSpeedGroupBox.Controls["buttonMarioSlidingSpeedYawN"] as Button,
marioSlidingSpeedGroupBox.Controls["buttonMarioSlidingSpeedYawP"] as Button,
marioSlidingSpeedGroupBox.Controls["textBoxMarioSlidingSpeedYaw"] as TextBox,
(float value) =>
{
ButtonUtilities.MarioChangeSlidingSpeedYaw(value);
});
Button buttonMarioHOLPGoto = splitContainerMario.Panel1.Controls["buttonMarioHOLPGoto"] as Button;
buttonMarioHOLPGoto.Click += (sender, e) => ButtonUtilities.GotoHOLP();
ControlUtilities.AddContextMenuStripFunctions(
buttonMarioHOLPGoto,
new List <string>()
{
"Goto HOLP", "Goto HOLP Laterally", "Goto HOLP X", "Goto HOLP Y", "Goto HOLP Z"
},
new List <Action>()
{
() => ButtonUtilities.GotoHOLP((true, true, true)),
() => ButtonUtilities.GotoHOLP((true, false, true)),
() => ButtonUtilities.GotoHOLP((true, false, false)),
() => ButtonUtilities.GotoHOLP((false, true, false)),
() => ButtonUtilities.GotoHOLP((false, false, true)),
});
public QuarterFrameManager(string varFilePath, WatchVariableFlowLayoutPanel variableTable)
: base(varFilePath, variableTable, ALL_VAR_GROUPS, VISIBLE_VAR_GROUPS)
{
}
public CameraManager(string varFilePath, Control tabControl, WatchVariableFlowLayoutPanel variableTable)
: base(varFilePath, variableTable)
{
var splitContainer = tabControl.Controls["splitContainerCamera"] as SplitContainer;
var cameraPosGroupBox = splitContainer.Panel1.Controls["groupBoxCameraPos"] as GroupBox;
ControlUtilities.InitializeThreeDimensionController(
CoordinateSystem.Euler,
true,
cameraPosGroupBox,
cameraPosGroupBox.Controls["buttonCameraPosXn"] as Button,
cameraPosGroupBox.Controls["buttonCameraPosXp"] as Button,
cameraPosGroupBox.Controls["buttonCameraPosZn"] as Button,
cameraPosGroupBox.Controls["buttonCameraPosZp"] as Button,
cameraPosGroupBox.Controls["buttonCameraPosXnZn"] as Button,
cameraPosGroupBox.Controls["buttonCameraPosXnZp"] as Button,
cameraPosGroupBox.Controls["buttonCameraPosXpZn"] as Button,
cameraPosGroupBox.Controls["buttonCameraPosXpZp"] as Button,
cameraPosGroupBox.Controls["buttonCameraPosYp"] as Button,
cameraPosGroupBox.Controls["buttonCameraPosYn"] as Button,
cameraPosGroupBox.Controls["textBoxCameraPosXZ"] as TextBox,
cameraPosGroupBox.Controls["textBoxCameraPosY"] as TextBox,
cameraPosGroupBox.Controls["checkBoxCameraPosRelative"] as CheckBox,
(float hOffset, float vOffset, float nOffset, bool useRelative) =>
{
ButtonUtilities.TranslateCamera(
hOffset,
nOffset,
-1 * vOffset,
useRelative);
});
var cameraSphericalPosGroupBox = splitContainer.Panel1.Controls["groupBoxCameraSphericalPos"] as GroupBox;
ControlUtilities.InitializeThreeDimensionController(
CoordinateSystem.Spherical,
false,
cameraSphericalPosGroupBox,
cameraSphericalPosGroupBox.Controls["buttonCameraSphericalPosTn"] as Button,
cameraSphericalPosGroupBox.Controls["buttonCameraSphericalPosTp"] as Button,
cameraSphericalPosGroupBox.Controls["buttonCameraSphericalPosPn"] as Button,
cameraSphericalPosGroupBox.Controls["buttonCameraSphericalPosPp"] as Button,
cameraSphericalPosGroupBox.Controls["buttonCameraSphericalPosTnPn"] as Button,
cameraSphericalPosGroupBox.Controls["buttonCameraSphericalPosTnPp"] as Button,
cameraSphericalPosGroupBox.Controls["buttonCameraSphericalPosTpPn"] as Button,
cameraSphericalPosGroupBox.Controls["buttonCameraSphericalPosTpPp"] as Button,
cameraSphericalPosGroupBox.Controls["buttonCameraSphericalPosRn"] as Button,
cameraSphericalPosGroupBox.Controls["buttonCameraSphericalPosRp"] as Button,
cameraSphericalPosGroupBox.Controls["textBoxCameraSphericalPosTP"] as TextBox,
cameraSphericalPosGroupBox.Controls["textBoxCameraSphericalPosR"] as TextBox,
cameraSphericalPosGroupBox.Controls["checkBoxCameraSphericalPosPivotOnFocus"] as CheckBox,
(float hOffset, float vOffset, float nOffset, bool pivotOnFocus) =>
{
ButtonUtilities.TranslateCameraSpherically(
-1 * nOffset,
hOffset,
-1 * vOffset,
getSphericalPivotPoint(pivotOnFocus));
});
_buttonDisableFOVFunctions = splitContainer.Panel1.Controls["buttonDisableFOVFunctions"] as BinaryButton;
_buttonDisableFOVFunctions.Initialize(
"Disable FOV Functions",
"Enable FOV Functions",
() =>
{
List <uint> addresses = CameraConfig.FovFunctionAddresses;
for (int i = 0; i < addresses.Count; i++)
{
Config.Stream.SetValue(0, addresses[i]);
}
},
() =>
{
List <uint> addresses = CameraConfig.FovFunctionAddresses;
List <uint> values = CameraConfig.FovFunctionValues;
for (int i = 0; i < addresses.Count; i++)
{
Config.Stream.SetValue(values[i], addresses[i]);
}
},
() =>
{
return(CameraConfig.FovFunctionAddresses.All(
address => Config.Stream.GetUInt32(address) == 0));
});
}
public CustomManager(string varFilePath, Control customControl, WatchVariableFlowLayoutPanel variableTable)
: base(varFilePath, variableTable)
{
SplitContainer splitContainerCustom = customControl.Controls["splitContainerCustom"] as SplitContainer;
SplitContainer splitContainerCustomControls = splitContainerCustom.Panel1.Controls["splitContainerCustomControls"] as SplitContainer;
// Panel 1 controls
Button buttonOpenVars = splitContainerCustomControls.Panel1.Controls["buttonOpenVars"] as Button;
buttonOpenVars.Click += (sender, e) => _variablePanel.OpenVariables();
ControlUtilities.AddContextMenuStripFunctions(
buttonOpenVars,
new List <string>()
{
"Open Mario State Data",
},
new List <Action>()
{
() => _variablePanel.OpenVariables(@"Config/MarioStateData.xml"),
});
Button buttonSaveVars = splitContainerCustomControls.Panel1.Controls["buttonSaveVars"] as Button;
buttonSaveVars.Click += (sender, e) => _variablePanel.SaveVariables();
ControlUtilities.AddContextMenuStripFunctions(
buttonSaveVars,
new List <string>()
{
"Save Pop Outs"
},
new List <Action>()
{
() => FormManager.SavePopOuts()
});
Button buttonCopyVars = splitContainerCustomControls.Panel1.Controls["buttonCopyVars"] as Button;
buttonCopyVars.Click += (sender, e) => CopyUtilities.Copy(_variablePanel.GetCurrentVariableControls(), _copyType);
buttonCopyVars.ContextMenuStrip = new ContextMenuStrip();
CopyUtilities.AddContextMenuStripFunctions(
buttonCopyVars, _variablePanel.GetCurrentVariableControls);
buttonCopyVars.ContextMenuStrip.Items.Add(new ToolStripSeparator());
ToolStripMenuItem itemSetDefaultCopyType = new ToolStripMenuItem("Set Default Copy Type");
buttonCopyVars.ContextMenuStrip.Items.Add(itemSetDefaultCopyType);
ControlUtilities.AddCheckableDropDownItems(
itemSetDefaultCopyType,
CopyUtilities.GetCopyNames(),
EnumUtilities.GetEnumValues <CopyTypeEnum>(typeof(CopyTypeEnum)),
copyType => _copyType = copyType,
_copyType);
Button buttonPasteVars = splitContainerCustomControls.Panel1.Controls["buttonPasteVars"] as Button;
buttonPasteVars.Click += (sender, e) => PasteUtilities.Paste(_variablePanel.GetCurrentVariableControls());
Button buttonClearVars = splitContainerCustomControls.Panel1.Controls["buttonClearVars"] as Button;
buttonClearVars.Click += (sender, e) => _variablePanel.ClearVariables();
ControlUtilities.AddContextMenuStripFunctions(
buttonClearVars,
new List <string>()
{
"Clear All Vars", "Clear Default Vars"
},
new List <Action>()
{
() => _variablePanel.ClearVariables(),
() => _variablePanel.RemoveVariableGroup(VariableGroup.NoGroup),
});
_checkBoxCustomRecordValues = splitContainerCustomControls.Panel1.Controls["checkBoxCustomRecordValues"] as CheckBox;
_checkBoxCustomRecordValues.Click += (sender, e) => ToggleRecording();
_labelRecordValuesCount = splitContainerCustomControls.Panel1.Controls["labelRecordValuesCount"] as Label;
_buttonCustomShowValues = splitContainerCustomControls.Panel1.Controls["buttonCustomShowValues"] as Button;
_buttonCustomShowValues.Click += (sender, e) => ShowRecordedValues();
_buttonCustomClearValues = splitContainerCustomControls.Panel1.Controls["buttonCustomClearValues"] as Button;
_buttonCustomClearValues.Click += (sender, e) => ClearRecordedValues();
_checkBoxUseValueAtStartOfGlobalTimer = splitContainerCustomControls.Panel1.Controls["checkBoxUseValueAtStartOfGlobalTimer"] as CheckBox;
_labelCustomRecordingFrequencyValue = splitContainerCustomControls.Panel1.Controls["labelCustomRecordingFrequencyValue"] as Label;
_labelCustomRecordingGapsValue = splitContainerCustomControls.Panel1.Controls["labelCustomRecordingGapsValue"] as Label;
_recordedValues = new Dictionary <int, List <object> >();
_lastTimer = null;
_numGaps = 0;
_recordFreq = 1;
// Panel 2 controls
Button buttonResetVariableSizeToDefault = splitContainerCustomControls.Panel2.Controls["buttonResetVariableSizeToDefault"] as Button;
buttonResetVariableSizeToDefault.Click += (sender, e) =>
{
WatchVariableControl.VariableNameWidth = WatchVariableControl.DEFAULT_VARIABLE_NAME_WIDTH;
WatchVariableControl.VariableValueWidth = WatchVariableControl.DEFAULT_VARIABLE_VALUE_WIDTH;
WatchVariableControl.VariableHeight = WatchVariableControl.DEFAULT_VARIABLE_HEIGHT;
WatchVariableControl.VariableTextSize = WatchVariableControl.DEFAULT_VARIABLE_TEXT_SIZE;
WatchVariableControl.VariableOffset = WatchVariableControl.DEFAULT_VARIABLE_OFFSET;
};
GroupBox groupBoxVarNameWidth = splitContainerCustomControls.Panel2.Controls["groupBoxVarNameWidth"] as GroupBox;
InitializeAddSubtractGetSetFuncionality(
groupBoxVarNameWidth.Controls["buttonVarNameWidthSubtract"] as Button,
groupBoxVarNameWidth.Controls["buttonVarNameWidthAdd"] as Button,
groupBoxVarNameWidth.Controls["buttonVarNameWidthGet"] as Button,
groupBoxVarNameWidth.Controls["buttonVarNameWidthSet"] as Button,
groupBoxVarNameWidth.Controls["betterTextboxVarNameWidthAddSubtract"] as TextBox,
groupBoxVarNameWidth.Controls["betterTextboxVarNameWidthGetSet"] as TextBox,
(int value) => { WatchVariableControl.VariableNameWidth = value; },
() => WatchVariableControl.VariableNameWidth);
GroupBox groupBoxVarValueWidth = splitContainerCustomControls.Panel2.Controls["groupBoxVarValueWidth"] as GroupBox;
InitializeAddSubtractGetSetFuncionality(
groupBoxVarValueWidth.Controls["buttonVarValueWidthSubtract"] as Button,
groupBoxVarValueWidth.Controls["buttonVarValueWidthAdd"] as Button,
groupBoxVarValueWidth.Controls["buttonVarValueWidthGet"] as Button,
groupBoxVarValueWidth.Controls["buttonVarValueWidthSet"] as Button,
groupBoxVarValueWidth.Controls["betterTextboxVarValueWidthAddSubtract"] as TextBox,
groupBoxVarValueWidth.Controls["betterTextboxVarValueWidthGetSet"] as TextBox,
(int value) => { WatchVariableControl.VariableValueWidth = value; },
() => WatchVariableControl.VariableValueWidth);
GroupBox groupBoxVarHeight = splitContainerCustomControls.Panel2.Controls["groupBoxVarHeight"] as GroupBox;
InitializeAddSubtractGetSetFuncionality(
groupBoxVarHeight.Controls["buttonVarHeightSubtract"] as Button,
groupBoxVarHeight.Controls["buttonVarHeightAdd"] as Button,
groupBoxVarHeight.Controls["buttonVarHeightGet"] as Button,
groupBoxVarHeight.Controls["buttonVarHeightSet"] as Button,
groupBoxVarHeight.Controls["betterTextboxVarHeightAddSubtract"] as TextBox,
groupBoxVarHeight.Controls["betterTextboxVarHeightGetSet"] as TextBox,
(int value) => { WatchVariableControl.VariableHeight = value; },
() => WatchVariableControl.VariableHeight);
GroupBox groupBoxVarTextSize = splitContainerCustomControls.Panel2.Controls["groupBoxVarTextSize"] as GroupBox;
InitializeAddSubtractGetSetFuncionality(
groupBoxVarTextSize.Controls["buttonVarTextSizeSubtract"] as Button,
groupBoxVarTextSize.Controls["buttonVarTextSizeAdd"] as Button,
groupBoxVarTextSize.Controls["buttonVarTextSizeGet"] as Button,
groupBoxVarTextSize.Controls["buttonVarTextSizeSet"] as Button,
groupBoxVarTextSize.Controls["betterTextboxVarTextSizeAddSubtract"] as TextBox,
groupBoxVarTextSize.Controls["betterTextboxVarTextSizeGetSet"] as TextBox,
(int value) => { WatchVariableControl.VariableTextSize = value; },
() => WatchVariableControl.VariableTextSize);
GroupBox groupBoxVarOffset = splitContainerCustomControls.Panel2.Controls["groupBoxVarOffset"] as GroupBox;
InitializeAddSubtractGetSetFuncionality(
groupBoxVarOffset.Controls["buttonVarOffsetSubtract"] as Button,
groupBoxVarOffset.Controls["buttonVarOffsetAdd"] as Button,
groupBoxVarOffset.Controls["buttonVarOffsetGet"] as Button,
groupBoxVarOffset.Controls["buttonVarOffsetSet"] as Button,
groupBoxVarOffset.Controls["betterTextboxVarOffsetAddSubtract"] as TextBox,
groupBoxVarOffset.Controls["betterTextboxVarOffsetGetSet"] as TextBox,
(int value) => { WatchVariableControl.VariableOffset = value; },
() => WatchVariableControl.VariableOffset);
}
public WaterManager(string varFilePath, WatchVariableFlowLayoutPanel variableTable)
: base(varFilePath, variableTable)
{
}
public TriangleManager(Control tabControl, string varFilePath, WatchVariableFlowLayoutPanel watchVariablePanel)
: base(varFilePath, watchVariablePanel, ALL_VAR_GROUPS, VISIBLE_VAR_GROUPS)
{
_recordedTriangleAddresses = new List <uint>();
SplitContainer splitContainerTriangles = tabControl.Controls["splitContainerTriangles"] as SplitContainer;
_addressBox = splitContainerTriangles.Panel1.Controls["textBoxCustomTriangle"] as BetterTextbox;
_useMisalignmentOffsetCheckbox = splitContainerTriangles.Panel1.Controls["checkBoxVertexMisalignment"] as CheckBox;
_addressBox.AddEnterAction(() => AddressBoxEnter());
_radioButtonTriFloor = splitContainerTriangles.Panel1.Controls["radioButtonTriFloor"] as RadioButton;
_radioButtonTriFloor.Click += (sender, e) => Mode_Click(sender, e, TriangleMode.Floor);
_radioButtonTriWall = splitContainerTriangles.Panel1.Controls["radioButtonTriWall"] as RadioButton;
_radioButtonTriWall.Click += (sender, e) => Mode_Click(sender, e, TriangleMode.Wall);
_radioButtonTriCeiling = splitContainerTriangles.Panel1.Controls["radioButtonTriCeiling"] as RadioButton;
_radioButtonTriCeiling.Click += (sender, e) => Mode_Click(sender, e, TriangleMode.Ceiling);
_radioButtonTriCustom = splitContainerTriangles.Panel1.Controls["radioButtonTriCustom"] as RadioButton;
_radioButtonTriCustom.Click += (sender, e) => Mode_Click(sender, e, TriangleMode.Custom);
ControlUtilities.AddContextMenuStripFunctions(
_radioButtonTriCustom,
new List <string>()
{
"Paste Addresses",
},
new List <Action>()
{
() => EnterCustomText(Clipboard.GetText()),
});
Label labelTriangleSelection = splitContainerTriangles.Panel1.Controls["labelTriangleSelection"] as Label;
ControlUtilities.AddContextMenuStripFunctions(
labelTriangleSelection,
new List <string>()
{
"Update Based on Coordinates",
"Paste Triangles",
},
new List <Action>()
{
() => UpdateBasedOnCoordinates(),
() => PasteTriangles(),
});
(splitContainerTriangles.Panel1.Controls["buttonGotoV1"] as Button).Click
+= (sender, e) => ButtonUtilities.GotoTriangleVertex(TriangleAddresses[0], 1, _useMisalignmentOffsetCheckbox.Checked);
(splitContainerTriangles.Panel1.Controls["buttonGotoV2"] as Button).Click
+= (sender, e) => ButtonUtilities.GotoTriangleVertex(TriangleAddresses[0], 2, _useMisalignmentOffsetCheckbox.Checked);
(splitContainerTriangles.Panel1.Controls["buttonGotoV3"] as Button).Click
+= (sender, e) => ButtonUtilities.GotoTriangleVertex(TriangleAddresses[0], 3, _useMisalignmentOffsetCheckbox.Checked);
(splitContainerTriangles.Panel1.Controls["buttonGotoVClosest"] as Button).Click += (sender, e) =>
ButtonUtilities.GotoTriangleVertexClosest(TriangleAddresses[0], _useMisalignmentOffsetCheckbox.Checked);
(splitContainerTriangles.Panel1.Controls["buttonRetrieveTriangle"] as Button).Click
+= (sender, e) => ButtonUtilities.RetrieveTriangle(TriangleAddresses);
Button buttonNeutralizeTriangle = splitContainerTriangles.Panel1.Controls["buttonNeutralizeTriangle"] as Button;
buttonNeutralizeTriangle.Click += (sender, e) => ButtonUtilities.NeutralizeTriangle(TriangleAddresses);
ControlUtilities.AddContextMenuStripFunctions(
buttonNeutralizeTriangle,
new List <string>()
{
"Neutralize", "Neutralize with 0", "Neutralize with 0x15"
},
new List <Action>()
{
() => ButtonUtilities.NeutralizeTriangle(TriangleAddresses),
() => ButtonUtilities.NeutralizeTriangle(TriangleAddresses, false),
() => ButtonUtilities.NeutralizeTriangle(TriangleAddresses, true),
});
Button buttonAnnihilateTriangle = splitContainerTriangles.Panel1.Controls["buttonAnnihilateTriangle"] as Button;
buttonAnnihilateTriangle.Click += (sender, e) => ButtonUtilities.AnnihilateTriangle(TriangleAddresses);
ControlUtilities.AddContextMenuStripFunctions(
buttonAnnihilateTriangle,
new List <string>()
{
"Annihilate All Tri But Death Barriers",
"Annihilate All Ceilings",
},
new List <Action>()
{
() => TriangleUtilities.AnnihilateAllTrianglesButDeathBarriers(),
() => TriangleUtilities.AnnihilateAllCeilings(),
});
var trianglePosGroupBox = splitContainerTriangles.Panel1.Controls["groupBoxTrianglePos"] as GroupBox;
ControlUtilities.InitializeThreeDimensionController(
CoordinateSystem.Euler,
true,
trianglePosGroupBox,
trianglePosGroupBox.Controls["buttonTrianglePosXn"] as Button,
trianglePosGroupBox.Controls["buttonTrianglePosXp"] as Button,
trianglePosGroupBox.Controls["buttonTrianglePosZn"] as Button,
trianglePosGroupBox.Controls["buttonTrianglePosZp"] as Button,
trianglePosGroupBox.Controls["buttonTrianglePosXnZn"] as Button,
trianglePosGroupBox.Controls["buttonTrianglePosXnZp"] as Button,
trianglePosGroupBox.Controls["buttonTrianglePosXpZn"] as Button,
trianglePosGroupBox.Controls["buttonTrianglePosXpZp"] as Button,
trianglePosGroupBox.Controls["buttonTrianglePosYp"] as Button,
trianglePosGroupBox.Controls["buttonTrianglePosYn"] as Button,
trianglePosGroupBox.Controls["textBoxTrianglePosXZ"] as TextBox,
trianglePosGroupBox.Controls["textBoxTrianglePosY"] as TextBox,
trianglePosGroupBox.Controls["checkBoxTrianglePosRelative"] as CheckBox,
(float hOffset, float vOffset, float nOffset, bool useRelative) =>
{
ButtonUtilities.MoveTriangle(
TriangleAddresses,
hOffset,
nOffset,
-1 * vOffset,
useRelative);
});
var triangleNormalGroupBox = splitContainerTriangles.Panel1.Controls["groupBoxTriangleNormal"] as GroupBox;
ControlUtilities.InitializeScalarController(
triangleNormalGroupBox.Controls["buttontriangleNormalN"] as Button,
triangleNormalGroupBox.Controls["buttontriangleNormalP"] as Button,
triangleNormalGroupBox.Controls["textBoxTriangleNormal"] as TextBox,
(float normalValue) =>
{
ButtonUtilities.MoveTriangleNormal(TriangleAddresses, normalValue);
});
_checkBoxNeutralizeTriangle = splitContainerTriangles.Panel1.Controls["checkBoxNeutralizeTriangle"] as CheckBox;
(splitContainerTriangles.Panel1.Controls["buttonTriangleShowCoords"] as Button).Click
+= (sender, e) => ShowTriangleCoordinates();
(splitContainerTriangles.Panel1.Controls["buttonTriangleShowEquation"] as Button).Click
+= (sender, e) => ShowTriangleEquation();
_recordTriangleDataCheckbox = splitContainerTriangles.Panel1.Controls["checkBoxRecordTriangleData"] as CheckBox;
_recordTriangleCountLabel = splitContainerTriangles.Panel1.Controls["labelRecordTriangleCount"] as Label;
(splitContainerTriangles.Panel1.Controls["buttonTriangleShowData"] as Button).Click
+= (sender, e) => ShowTriangleData();
(splitContainerTriangles.Panel1.Controls["buttonTriangleShowVertices"] as Button).Click
+= (sender, e) => ShowTriangleVertices();
(splitContainerTriangles.Panel1.Controls["buttonTriangleShowAddresses"] as Button).Click
+= (sender, e) => ShowTriangleAddresses();
(splitContainerTriangles.Panel1.Controls["buttonTriangleClearData"] as Button).Click
+= (sender, e) => ClearTriangleData();
_repeatFirstVertexCheckbox = splitContainerTriangles.Panel1.Controls["checkBoxRepeatFirstVertex"] as CheckBox;
(splitContainerTriangles.Panel1.Controls["buttonTriangleShowLevelTris"] as Button).Click
+= (sender, e) => TriangleUtilities.ShowTriangles(TriangleUtilities.GetLevelTriangles());
Button buttonTriangleShowObjTris = splitContainerTriangles.Panel1.Controls["buttonTriangleShowObjTris"] as Button;
buttonTriangleShowObjTris.Click += (sender, e) => TriangleUtilities.ShowTriangles(TriangleUtilities.GetObjectTriangles());
ControlUtilities.AddContextMenuStripFunctions(
buttonTriangleShowObjTris,
new List <string>()
{
"Show All Object Tris", "Show Selected Object Tris"
},
new List <Action>()
{
() => TriangleUtilities.ShowTriangles(TriangleUtilities.GetObjectTriangles()),
() => TriangleUtilities.ShowTriangles(TriangleUtilities.GetSelectedObjectTriangles()),
});
(splitContainerTriangles.Panel1.Controls["buttonTriangleShowAllTris"] as Button).Click
+= (sender, e) => TriangleUtilities.ShowTriangles(TriangleUtilities.GetAllTriangles());
var buttonTriangleNeutralizeAllTriangles = splitContainerTriangles.Panel1.Controls["buttonTriangleNeutralizeAllTriangles"] as Button;
buttonTriangleNeutralizeAllTriangles.Click += (sender, e) => TriangleUtilities.NeutralizeTriangles();
ControlUtilities.AddContextMenuStripFunctions(
buttonTriangleNeutralizeAllTriangles,
new List <string>()
{
"Neutralize All Triangles",
"Neutralize Wall Triangles",
"Neutralize Floor Triangles",
"Neutralize Ceiling Triangles",
"Neutralize Death Barriers",
"Neutralize Lava",
"Neutralize Sleeping",
"Neutralize Loading Zones"
},
new List <Action>()
{
() => TriangleUtilities.NeutralizeTriangles(),
() => TriangleUtilities.NeutralizeTriangles(TriangleClassification.Wall),
() => TriangleUtilities.NeutralizeTriangles(TriangleClassification.Floor),
() => TriangleUtilities.NeutralizeTriangles(TriangleClassification.Ceiling),
() => TriangleUtilities.NeutralizeTriangles(0x0A),
() => TriangleUtilities.NeutralizeTriangles(0x01),
() => TriangleUtilities.NeutralizeSleeping(),
() => {
TriangleUtilities.NeutralizeTriangles(0x1B);
TriangleUtilities.NeutralizeTriangles(0x1C);
TriangleUtilities.NeutralizeTriangles(0x1D);
TriangleUtilities.NeutralizeTriangles(0x1E);
},
});
var buttonTriangleDisableAllCamCollision = splitContainerTriangles.Panel1.Controls["buttonTriangleDisableAllCamCollision"] as Button;
buttonTriangleDisableAllCamCollision.Click += (sender, e) => TriangleUtilities.DisableCamCollision();
ControlUtilities.AddContextMenuStripFunctions(
buttonTriangleDisableAllCamCollision,
new List <string>()
{
"Disable Cam Collision for All Triangles",
"Disable Cam Collision for Wall Triangles",
"Disable Cam Collision for Floor Triangles",
"Disable Cam Collision for Ceiling Triangles",
},
new List <Action>()
{
() => TriangleUtilities.DisableCamCollision(),
() => TriangleUtilities.DisableCamCollision(TriangleClassification.Wall),
() => TriangleUtilities.DisableCamCollision(TriangleClassification.Floor),
() => TriangleUtilities.DisableCamCollision(TriangleClassification.Ceiling),
});
GroupBox groupBoxTriangleTypeConversion = splitContainerTriangles.Panel1.Controls["groupBoxTriangleTypeConversion"] as GroupBox;
ComboBox comboBoxTriangleTypeConversionConvert = groupBoxTriangleTypeConversion.Controls["comboBoxTriangleTypeConversionConvert"] as ComboBox;
TextBox textBoxTriangleTypeConversionFromType = groupBoxTriangleTypeConversion.Controls["textBoxTriangleTypeConversionFromType"] as TextBox;
TextBox textBoxTriangleTypeConversionToType = groupBoxTriangleTypeConversion.Controls["textBoxTriangleTypeConversionToType"] as TextBox;
Button buttonTriangleTypeConversionConvert = groupBoxTriangleTypeConversion.Controls["buttonTriangleTypeConversionConvert"] as Button;
comboBoxTriangleTypeConversionConvert.DataSource = EnumUtilities.GetEnumValues <TriangleClassificationExtended>(typeof(TriangleClassificationExtended));
buttonTriangleTypeConversionConvert.Click += (sender, e) =>
{
TriangleClassificationExtended classification = (TriangleClassificationExtended)comboBoxTriangleTypeConversionConvert.SelectedItem;
short?fromType = (short?)ParsingUtilities.ParseHexNullable(textBoxTriangleTypeConversionFromType.Text);
short?toType = (short?)ParsingUtilities.ParseHexNullable(textBoxTriangleTypeConversionToType.Text);
if (!fromType.HasValue || !toType.HasValue)
{
return;
}
TriangleUtilities.ConvertSurfaceTypes(classification, fromType.Value, toType.Value);
};
}
public SnowManager(string varFilePath, WatchVariableFlowLayoutPanel variableTable, TabPage tabPageSnow)
: base(varFilePath, variableTable, ALL_VAR_GROUPS, VISIBLE_VAR_GROUPS)
{
_numSnowParticles = 0;
_snowParticleControls = new List <List <WatchVariableControl> >();
SplitContainer splitContainerSnow = tabPageSnow.Controls["splitContainerSnow"] as SplitContainer;
TextBox textBoxSnowIndex = splitContainerSnow.Panel1.Controls["textBoxSnowIndex"] as TextBox;
Button buttonSnowRetrieve = splitContainerSnow.Panel1.Controls["buttonSnowRetrieve"] as Button;
buttonSnowRetrieve.Click += (sender, e) =>
{
int?snowIndexNullable = ParsingUtilities.ParseIntNullable(textBoxSnowIndex.Text);
if (!snowIndexNullable.HasValue)
{
return;
}
int snowIndex = snowIndexNullable.Value;
if (snowIndex < 0 || snowIndex > _numSnowParticles)
{
return;
}
ButtonUtilities.RetrieveSnow(snowIndex);
};
GroupBox groupBoxSnowPosition = splitContainerSnow.Panel1.Controls["groupBoxSnowPosition"] as GroupBox;
ControlUtilities.InitializeThreeDimensionController(
CoordinateSystem.Euler,
true,
groupBoxSnowPosition,
groupBoxSnowPosition.Controls["buttonSnowPositionXn"] as Button,
groupBoxSnowPosition.Controls["buttonSnowPositionXp"] as Button,
groupBoxSnowPosition.Controls["buttonSnowPositionZn"] as Button,
groupBoxSnowPosition.Controls["buttonSnowPositionZp"] as Button,
groupBoxSnowPosition.Controls["buttonSnowPositionXnZn"] as Button,
groupBoxSnowPosition.Controls["buttonSnowPositionXnZp"] as Button,
groupBoxSnowPosition.Controls["buttonSnowPositionXpZn"] as Button,
groupBoxSnowPosition.Controls["buttonSnowPositionXpZp"] as Button,
groupBoxSnowPosition.Controls["buttonSnowPositionYp"] as Button,
groupBoxSnowPosition.Controls["buttonSnowPositionYn"] as Button,
groupBoxSnowPosition.Controls["textBoxSnowPositionXZ"] as TextBox,
groupBoxSnowPosition.Controls["textBoxSnowPositionY"] as TextBox,
groupBoxSnowPosition.Controls["checkBoxSnowPositionRelative"] as CheckBox,
(float hOffset, float vOffset, float nOffset, bool useRelative) =>
{
int?snowIndexNullable = ParsingUtilities.ParseIntNullable(textBoxSnowIndex.Text);
if (!snowIndexNullable.HasValue)
{
return;
}
int snowIndex = snowIndexNullable.Value;
if (snowIndex < 0 || snowIndex > _numSnowParticles)
{
return;
}
ButtonUtilities.TranslateSnow(
snowIndex,
hOffset,
nOffset,
-1 * vOffset,
useRelative);
});
}
public TasManager(string varFilePath, TabPage tabControl, WatchVariableFlowLayoutPanel watchVariablePanel)
: base(varFilePath, watchVariablePanel, ALL_VAR_GROUPS, VISIBLE_VAR_GROUPS)
{
SplitContainer splitContainerTas = tabControl.Controls["splitContainerTas"] as SplitContainer;
Button buttonTasStorePosition = splitContainerTas.Panel1.Controls["buttonTasStorePosition"] as Button;
buttonTasStorePosition.Click += (sender, e) => StoreInfo(x: true, y: true, z: true);
ControlUtilities.AddContextMenuStripFunctions(
buttonTasStorePosition,
new List <string>()
{
"Store Position",
"Store Lateral Position",
"Store X",
"Store Y",
"Store Z",
},
new List <Action>()
{
() => StoreInfo(x: true, y: true, z: true),
() => StoreInfo(x: true, z: true),
() => StoreInfo(x: true),
() => StoreInfo(y: true),
() => StoreInfo(z: true),
});
Button buttonTasStoreAngle = splitContainerTas.Panel1.Controls["buttonTasStoreAngle"] as Button;
buttonTasStoreAngle.Click += (sender, e) => StoreInfo(angle: true);
Button buttonTasTakePosition = splitContainerTas.Panel1.Controls["buttonTasTakePosition"] as Button;
buttonTasTakePosition.Click += (sender, e) => TakeInfo(x: true, y: true, z: true);
ControlUtilities.AddContextMenuStripFunctions(
buttonTasTakePosition,
new List <string>()
{
"Take Position",
"Take Lateral Position",
"Take X",
"Take Y",
"Take Z"
},
new List <Action>()
{
() => TakeInfo(x: true, y: true, z: true),
() => TakeInfo(x: true, z: true),
() => TakeInfo(x: true),
() => TakeInfo(y: true),
() => TakeInfo(z: true),
});
Button buttonTasTakeMarioAngle = splitContainerTas.Panel1.Controls["buttonTasTakeAngle"] as Button;
buttonTasTakeMarioAngle.Click += (sender, e) => TakeInfo(angle: true);
Button buttonTasGotoVertex = splitContainerTas.Panel1.Controls["buttonTasGotoVertex"] as Button;
buttonTasGotoVertex.Click += (sender, e) =>
ButtonUtilities.GotoTriangleVertexClosest(
Config.Stream.GetUInt(MarioConfig.StructAddress + MarioConfig.FloorTriangleOffset),
TriangleVertexOffset.NONE);
Button buttonTasPasteSchedule = splitContainerTas.Panel1.Controls["buttonTasPasteSchedule"] as Button;
buttonTasPasteSchedule.Click += (sender, e) => SetScheduler(Clipboard.GetText(), false);
ControlUtilities.AddContextMenuStripFunctions(
buttonTasPasteSchedule,
new List <string>()
{
"Paste Schedule as Floats"
},
new List <Action>()
{
() => SetScheduler(Clipboard.GetText(), true)
});
GroupBox groupBoxTasSelf = splitContainerTas.Panel1.Controls["groupBoxTasSelf"] as GroupBox;
ControlUtilities.InitializeThreeDimensionController(
CoordinateSystem.Euler,
true,
groupBoxTasSelf,
groupBoxTasSelf.Controls["buttonTasSelfXn"] as Button,
groupBoxTasSelf.Controls["buttonTasSelfXp"] as Button,
groupBoxTasSelf.Controls["buttonTasSelfZn"] as Button,
groupBoxTasSelf.Controls["buttonTasSelfZp"] as Button,
groupBoxTasSelf.Controls["buttonTasSelfXnZn"] as Button,
groupBoxTasSelf.Controls["buttonTasSelfXnZp"] as Button,
groupBoxTasSelf.Controls["buttonTasSelfXpZn"] as Button,
groupBoxTasSelf.Controls["buttonTasSelfXpZp"] as Button,
groupBoxTasSelf.Controls["buttonTasSelfYp"] as Button,
groupBoxTasSelf.Controls["buttonTasSelfYn"] as Button,
groupBoxTasSelf.Controls["textBoxTasSelfXZ"] as TextBox,
groupBoxTasSelf.Controls["textBoxTasSelfY"] as TextBox,
groupBoxTasSelf.Controls["checkBoxTasSelfRelative"] as CheckBox,
(float hOffset, float vOffset, float nOffset, bool useRelative) =>
{
ButtonUtilities.TranslatePosAngle(
new List <PositionAngle>()
{
PositionAngle.Self
},
hOffset,
nOffset,
-1 * vOffset,
useRelative);
});
GroupBox groupBoxTasPoint = splitContainerTas.Panel1.Controls["groupBoxTasPoint"] as GroupBox;
ControlUtilities.InitializeThreeDimensionController(
CoordinateSystem.Euler,
true,
groupBoxTasPoint,
groupBoxTasPoint.Controls["buttonTasPointXn"] as Button,
groupBoxTasPoint.Controls["buttonTasPointXp"] as Button,
groupBoxTasPoint.Controls["buttonTasPointZn"] as Button,
groupBoxTasPoint.Controls["buttonTasPointZp"] as Button,
groupBoxTasPoint.Controls["buttonTasPointXnZn"] as Button,
groupBoxTasPoint.Controls["buttonTasPointXnZp"] as Button,
groupBoxTasPoint.Controls["buttonTasPointXpZn"] as Button,
groupBoxTasPoint.Controls["buttonTasPointXpZp"] as Button,
groupBoxTasPoint.Controls["buttonTasPointYp"] as Button,
groupBoxTasPoint.Controls["buttonTasPointYn"] as Button,
groupBoxTasPoint.Controls["textBoxTasPointXZ"] as TextBox,
groupBoxTasPoint.Controls["textBoxTasPointY"] as TextBox,
groupBoxTasPoint.Controls["checkBoxTasPointRelative"] as CheckBox,
(float hOffset, float vOffset, float nOffset, bool useRelative) =>
{
ButtonUtilities.TranslatePosAngle(
new List <PositionAngle>()
{
PositionAngle.Point
},
hOffset,
nOffset,
-1 * vOffset,
useRelative);
});
}
public VariablePopOutFormHelper(WatchVariableFlowLayoutPanel watchVariablePanel, string text)
{
_watchVariablePanel = watchVariablePanel;
_text = text;
}
public CamHackManager(string varFilePath, TabPage camHackControl, WatchVariableFlowLayoutPanel variableTable)
: base(varFilePath, variableTable)
{
CurrentCamHackMode = CamHackMode.REGULAR;
var splitContainer = camHackControl.Controls["splitContainerCamHack"] as SplitContainer;
Label labelCamHackMode = splitContainer.Panel1.Controls["labelCamHackMode"] as Label;
ControlUtilities.AddContextMenuStripFunctions(
labelCamHackMode,
new List <string>()
{
"Download Camera Hack ROM"
},
new List <Action>()
{
() => System.Diagnostics.Process.Start("http://download1436.mediafire.com/t3unklq170ag/hdd377v5794u319/Camera+Hack+ROM.z64"),
});
_mode0RadioButton = splitContainer.Panel1.Controls["radioButtonCamHackMode0"] as RadioButton;
_mode1RadioButtonRelativeAngle = splitContainer.Panel1.Controls["radioButtonCamHackMode1RelativeAngle"] as RadioButton;
_mode1RadioButtonAbsoluteAngle = splitContainer.Panel1.Controls["radioButtonCamHackMode1AbsoluteAngle"] as RadioButton;
_mode2RadioButton = splitContainer.Panel1.Controls["radioButtonCamHackMode2"] as RadioButton;
_mode3RadioButton = splitContainer.Panel1.Controls["radioButtonCamHackMode3"] as RadioButton;
_mode0RadioButton.Click += (sender, e) => Config.Stream.SetValue(0, CamHackConfig.StructAddress + CamHackConfig.CameraModeOffset);
_mode1RadioButtonRelativeAngle.Click += (sender, e) =>
{
Config.Stream.SetValue(1, CamHackConfig.StructAddress + CamHackConfig.CameraModeOffset);
Config.Stream.SetValue((ushort)0, CamHackConfig.StructAddress + CamHackConfig.AbsoluteAngleOffset);
};
_mode1RadioButtonAbsoluteAngle.Click += (sender, e) =>
{
Config.Stream.SetValue(1, CamHackConfig.StructAddress + CamHackConfig.CameraModeOffset);
Config.Stream.SetValue((ushort)1, CamHackConfig.StructAddress + CamHackConfig.AbsoluteAngleOffset);
};
_mode2RadioButton.Click += (sender, e) => Config.Stream.SetValue(2, CamHackConfig.StructAddress + CamHackConfig.CameraModeOffset);
_mode3RadioButton.Click += (sender, e) => Config.Stream.SetValue(3, CamHackConfig.StructAddress + CamHackConfig.CameraModeOffset);
var cameraHackPosGroupBox = splitContainer.Panel1.Controls["groupBoxCameraHackPos"] as GroupBox;
ControlUtilities.InitializeThreeDimensionController(
CoordinateSystem.Euler,
true,
cameraHackPosGroupBox,
cameraHackPosGroupBox.Controls["buttonCameraHackPosXn"] as Button,
cameraHackPosGroupBox.Controls["buttonCameraHackPosXp"] as Button,
cameraHackPosGroupBox.Controls["buttonCameraHackPosZn"] as Button,
cameraHackPosGroupBox.Controls["buttonCameraHackPosZp"] as Button,
cameraHackPosGroupBox.Controls["buttonCameraHackPosXnZn"] as Button,
cameraHackPosGroupBox.Controls["buttonCameraHackPosXnZp"] as Button,
cameraHackPosGroupBox.Controls["buttonCameraHackPosXpZn"] as Button,
cameraHackPosGroupBox.Controls["buttonCameraHackPosXpZp"] as Button,
cameraHackPosGroupBox.Controls["buttonCameraHackPosYp"] as Button,
cameraHackPosGroupBox.Controls["buttonCameraHackPosYn"] as Button,
cameraHackPosGroupBox.Controls["textBoxCameraHackPosXZ"] as TextBox,
cameraHackPosGroupBox.Controls["textBoxCameraHackPosY"] as TextBox,
cameraHackPosGroupBox.Controls["checkBoxCameraHackPosRelative"] as CheckBox,
(float hOffset, float vOffset, float nOffset, bool useRelative) =>
{
ButtonUtilities.TranslateCameraHack(
CurrentCamHackMode,
hOffset,
nOffset,
-1 * vOffset,
useRelative);
});
var cameraHackSphericalPosGroupBox = splitContainer.Panel1.Controls["groupBoxCameraHackSphericalPos"] as GroupBox;
ControlUtilities.InitializeThreeDimensionController(
CoordinateSystem.Spherical,
false,
cameraHackSphericalPosGroupBox,
cameraHackSphericalPosGroupBox.Controls["buttonCameraHackSphericalPosTn"] as Button,
cameraHackSphericalPosGroupBox.Controls["buttonCameraHackSphericalPosTp"] as Button,
cameraHackSphericalPosGroupBox.Controls["buttonCameraHackSphericalPosPn"] as Button,
cameraHackSphericalPosGroupBox.Controls["buttonCameraHackSphericalPosPp"] as Button,
cameraHackSphericalPosGroupBox.Controls["buttonCameraHackSphericalPosTnPn"] as Button,
cameraHackSphericalPosGroupBox.Controls["buttonCameraHackSphericalPosTnPp"] as Button,
cameraHackSphericalPosGroupBox.Controls["buttonCameraHackSphericalPosTpPn"] as Button,
cameraHackSphericalPosGroupBox.Controls["buttonCameraHackSphericalPosTpPp"] as Button,
cameraHackSphericalPosGroupBox.Controls["buttonCameraHackSphericalPosRn"] as Button,
cameraHackSphericalPosGroupBox.Controls["buttonCameraHackSphericalPosRp"] as Button,
cameraHackSphericalPosGroupBox.Controls["textBoxCameraHackSphericalPosTP"] as TextBox,
cameraHackSphericalPosGroupBox.Controls["textBoxCameraHackSphericalPosR"] as TextBox,
null /* checkbox */,
(float hOffset, float vOffset, float nOffset, bool _) =>
{
ButtonUtilities.TranslateCameraHackSpherically(
CurrentCamHackMode,
-1 * nOffset,
hOffset,
-1 * vOffset);
});
var cameraHackFocusPosGroupBox = splitContainer.Panel1.Controls["groupBoxCameraHackFocusPos"] as GroupBox;
ControlUtilities.InitializeThreeDimensionController(
CoordinateSystem.Euler,
true,
cameraHackFocusPosGroupBox,
cameraHackFocusPosGroupBox.Controls["buttonCameraHackFocusPosXn"] as Button,
cameraHackFocusPosGroupBox.Controls["buttonCameraHackFocusPosXp"] as Button,
cameraHackFocusPosGroupBox.Controls["buttonCameraHackFocusPosZn"] as Button,
cameraHackFocusPosGroupBox.Controls["buttonCameraHackFocusPosZp"] as Button,
cameraHackFocusPosGroupBox.Controls["buttonCameraHackFocusPosXnZn"] as Button,
cameraHackFocusPosGroupBox.Controls["buttonCameraHackFocusPosXnZp"] as Button,
cameraHackFocusPosGroupBox.Controls["buttonCameraHackFocusPosXpZn"] as Button,
cameraHackFocusPosGroupBox.Controls["buttonCameraHackFocusPosXpZp"] as Button,
cameraHackFocusPosGroupBox.Controls["buttonCameraHackFocusPosYp"] as Button,
cameraHackFocusPosGroupBox.Controls["buttonCameraHackFocusPosYn"] as Button,
cameraHackFocusPosGroupBox.Controls["textBoxCameraHackFocusPosXZ"] as TextBox,
cameraHackFocusPosGroupBox.Controls["textBoxCameraHackFocusPosY"] as TextBox,
cameraHackFocusPosGroupBox.Controls["checkBoxCameraHackFocusPosRelative"] as CheckBox,
(float hOffset, float vOffset, float nOffset, bool useRelative) =>
{
ButtonUtilities.TranslateCameraHackFocus(
CurrentCamHackMode,
hOffset,
nOffset,
-1 * vOffset,
useRelative);
});
var cameraHackSphericalFocusPosGroupBox = splitContainer.Panel1.Controls["groupBoxCameraHackSphericalFocusPos"] as GroupBox;
ControlUtilities.InitializeThreeDimensionController(
CoordinateSystem.Spherical,
false,
cameraHackSphericalFocusPosGroupBox,
cameraHackSphericalFocusPosGroupBox.Controls["buttonCameraHackSphericalFocusPosTn"] as Button,
cameraHackSphericalFocusPosGroupBox.Controls["buttonCameraHackSphericalFocusPosTp"] as Button,
cameraHackSphericalFocusPosGroupBox.Controls["buttonCameraHackSphericalFocusPosPn"] as Button,
cameraHackSphericalFocusPosGroupBox.Controls["buttonCameraHackSphericalFocusPosPp"] as Button,
cameraHackSphericalFocusPosGroupBox.Controls["buttonCameraHackSphericalFocusPosTnPn"] as Button,
cameraHackSphericalFocusPosGroupBox.Controls["buttonCameraHackSphericalFocusPosTnPp"] as Button,
cameraHackSphericalFocusPosGroupBox.Controls["buttonCameraHackSphericalFocusPosTpPn"] as Button,
cameraHackSphericalFocusPosGroupBox.Controls["buttonCameraHackSphericalFocusPosTpPp"] as Button,
cameraHackSphericalFocusPosGroupBox.Controls["buttonCameraHackSphericalFocusPosRp"] as Button,
cameraHackSphericalFocusPosGroupBox.Controls["buttonCameraHackSphericalFocusPosRn"] as Button,
cameraHackSphericalFocusPosGroupBox.Controls["textBoxCameraHackSphericalFocusPosTP"] as TextBox,
cameraHackSphericalFocusPosGroupBox.Controls["textBoxCameraHackSphericalFocusPosR"] as TextBox,
null /* checkbox */,
(float hOffset, float vOffset, float nOffset, bool _) =>
{
ButtonUtilities.TranslateCameraHackFocusSpherically(
CurrentCamHackMode,
nOffset,
hOffset,
-1 * vOffset);
});
var cameraHackBothPosGroupBox = splitContainer.Panel1.Controls["groupBoxCameraHackBothPos"] as GroupBox;
ControlUtilities.InitializeThreeDimensionController(
CoordinateSystem.Euler,
true,
cameraHackBothPosGroupBox,
cameraHackBothPosGroupBox.Controls["buttonCameraHackBothPosXn"] as Button,
cameraHackBothPosGroupBox.Controls["buttonCameraHackBothPosXp"] as Button,
cameraHackBothPosGroupBox.Controls["buttonCameraHackBothPosZn"] as Button,
cameraHackBothPosGroupBox.Controls["buttonCameraHackBothPosZp"] as Button,
cameraHackBothPosGroupBox.Controls["buttonCameraHackBothPosXnZn"] as Button,
cameraHackBothPosGroupBox.Controls["buttonCameraHackBothPosXnZp"] as Button,
cameraHackBothPosGroupBox.Controls["buttonCameraHackBothPosXpZn"] as Button,
cameraHackBothPosGroupBox.Controls["buttonCameraHackBothPosXpZp"] as Button,
cameraHackBothPosGroupBox.Controls["buttonCameraHackBothPosYp"] as Button,
cameraHackBothPosGroupBox.Controls["buttonCameraHackBothPosYn"] as Button,
cameraHackBothPosGroupBox.Controls["textBoxCameraHackBothPosXZ"] as TextBox,
cameraHackBothPosGroupBox.Controls["textBoxCameraHackBothPosY"] as TextBox,
cameraHackBothPosGroupBox.Controls["checkBoxCameraHackBothPosRelative"] as CheckBox,
(float hOffset, float vOffset, float nOffset, bool useRelative) =>
{
ButtonUtilities.TranslateCameraHackBoth(
CurrentCamHackMode,
hOffset,
nOffset,
-1 * vOffset,
useRelative);
});
}
