private List <WatchVariableControl> CreatePanVars(int index)
{
WatchVariableSpecialUtilities.AddPanEntriesToDictionary(index);
return(new List <WatchVariableControl>
{
CreatePanVar("Global Timer", String.Format("Pan{0}GlobalTimer", index), "Orange"),
CreatePanVar(String.Format("Pan{0} Start Time", index), String.Format("Pan{0}StartTime", index), "Orange"),
CreatePanVar(String.Format("Pan{0} End Time", index), String.Format("Pan{0}EndTime", index), "Orange"),
CreatePanVar(String.Format("Pan{0} Duration", index), String.Format("Pan{0}Duration", index), "Orange"),
CreatePanVar(String.Format("Pan{0} Ease Start", index), String.Format("Pan{0}EaseStart", index), "LightBlue", subclass: "Boolean"),
CreatePanVar(String.Format("Pan{0} Ease End", index), String.Format("Pan{0}EaseEnd", index), "LightBlue", subclass: "Boolean"),
CreatePanVar(String.Format("Pan{0} Ease Degree", index), String.Format("Pan{0}EaseDegree", index), "LightBlue"),
CreatePanVar(String.Format("Pan{0} Rotate CW", index), String.Format("Pan{0}RotateCW", index), "Yellow", subclass: "Boolean"),
CreatePanVar(String.Format("Pan{0} Cam Start X", index), String.Format("Pan{0}CamStartX", index), "Green", coord: "X"),
CreatePanVar(String.Format("Pan{0} Cam Start Y", index), String.Format("Pan{0}CamStartY", index), "Green", coord: "Y"),
CreatePanVar(String.Format("Pan{0} Cam Start Z", index), String.Format("Pan{0}CamStartZ", index), "Green", coord: "Z"),
CreatePanVar(String.Format("Pan{0} Cam Start Yaw", index), String.Format("Pan{0}CamStartYaw", index), "Green", subclass: "Angle", display: "ushort", yaw: "true"),
CreatePanVar(String.Format("Pan{0} Cam Start Pitch", index), String.Format("Pan{0}CamStartPitch", index), "Green", subclass: "Angle", display: "short"),
CreatePanVar(String.Format("Pan{0} Cam End X", index), String.Format("Pan{0}CamEndX", index), "Red", coord: "X"),
CreatePanVar(String.Format("Pan{0} Cam End Y", index), String.Format("Pan{0}CamEndY", index), "Red", coord: "Y"),
CreatePanVar(String.Format("Pan{0} Cam End Z", index), String.Format("Pan{0}CamEndZ", index), "Red", coord: "Z"),
CreatePanVar(String.Format("Pan{0} Cam End Yaw", index), String.Format("Pan{0}CamEndYaw", index), "Red", subclass: "Angle", display: "ushort", yaw: "true"),
CreatePanVar(String.Format("Pan{0} Cam End Pitch", index), String.Format("Pan{0}CamEndPitch", index), "Red", subclass: "Angle", display: "short"),
CreatePanVar(String.Format("Pan{0} Cam Radius Start", index), String.Format("Pan{0}RadiusStart", index), "Blue"),
CreatePanVar(String.Format("Pan{0} Cam Radius End", index), String.Format("Pan{0}RadiusEnd", index), "Blue"),
CreatePanVar(String.Format("Pan{0} FOV Start", index), String.Format("Pan{0}FOVStart", index), "Pink"),
CreatePanVar(String.Format("Pan{0} FOV End", index), String.Format("Pan{0}FOVEnd", index), "Pink"),
});
}
public List <PendulumSwing> GetSuccessors()
{
return(new List <PendulumSwing>()
{
new PendulumSwing((int)WatchVariableSpecialUtilities.GetPendulumAmplitude(Amplitude, 13), 13, this, PrimaryIndex, SecondaryIndex + 1),
new PendulumSwing((int)WatchVariableSpecialUtilities.GetPendulumAmplitude(Amplitude, 42), 42, this, PrimaryIndex, SecondaryIndex + 1),
});
}
protected override List <(float xMin, float zMin, float xMax, float zMax)> GetQuadList()
{
(int cellX, int cellZ) = WatchVariableSpecialUtilities.GetMarioCell();
int xMin = (cellX - 8) * 1024;
int xMax = xMin + 1024;
int zMin = (cellZ - 8) * 1024;
int zMax = zMin + 1024;
return(new List <(float, float, float, float)>(new[] { ((float)xMin, (float)xMax, (float)zMin, (float)zMax) }));
public TasDataStruct(uint?globalTimer = null)
{
GlobalTimer = globalTimer ?? Config.Stream.GetUInt32(MiscConfig.GlobalTimerAddress);
MarioFacingAngle = Config.Stream.GetUInt16(MarioConfig.StructAddress + MarioConfig.FacingYawOffset);
MarioIntendAngle = Config.Stream.GetUInt16(MarioConfig.StructAddress + MarioConfig.IntendedYawOffset);
DAngle = WatchVariableSpecialUtilities.GetDeltaYawIntendedFacing();
CameraAngle = Config.Stream.GetUInt16(CameraConfig.StructAddress + CameraConfig.CentripetalAngleOffset);
BufferedXInput = Config.Stream.GetSByte(InputConfig.BufferedInputAddress + InputConfig.ControlStickXOffset);
BufferedYInput = Config.Stream.GetSByte(InputConfig.BufferedInputAddress + InputConfig.ControlStickYOffset);
CurrentXInput = Config.Stream.GetSByte(InputConfig.CurrentInputAddress + InputConfig.ControlStickXOffset);
CurrentYInput = Config.Stream.GetSByte(InputConfig.CurrentInputAddress + InputConfig.ControlStickYOffset);
}
public void HookUpTeleporters()
{
uint mainSegmentEnd = 0x80367460;
//uint engineSegmentStart = 0x80378800;
uint lastWarpNodeAddress = WatchVariableSpecialUtilities.GetWarpNodeAddresses().LastOrDefault();
if (lastWarpNodeAddress == 0)
{
return;
}
List <uint> objAddresses = Config.ObjectSlotsManager.SelectedObjects.ConvertAll(obj => obj.Address);
if (objAddresses.Count < 2)
{
return;
}
uint teleporter1Address = objAddresses[0];
uint teleporter2Address = objAddresses[1];
short teleporter1Id = Config.Stream.GetInt16(teleporter1Address + 0x188);
short teleporter2Id = Config.Stream.GetInt16(teleporter2Address + 0x188);
uint warpNode1Address = mainSegmentEnd;
uint warpNode2Address = mainSegmentEnd + 0xC;
byte level = Config.Stream.GetByte(MiscConfig.WarpDestinationAddress + MiscConfig.LevelOffset);
byte area = Config.Stream.GetByte(MiscConfig.WarpDestinationAddress + MiscConfig.AreaOffset);
Config.Stream.SetValue((byte)teleporter1Id, warpNode1Address + 0x0);
Config.Stream.SetValue(level, warpNode1Address + 0x1);
Config.Stream.SetValue(area, warpNode1Address + 0x2);
Config.Stream.SetValue((byte)teleporter2Id, warpNode1Address + 0x3);
Config.Stream.SetValue(teleporter1Address, warpNode1Address + 0x4);
Config.Stream.SetValue(warpNode2Address, warpNode1Address + 0x8);
Config.Stream.SetValue((byte)teleporter2Id, warpNode2Address + 0x0);
Config.Stream.SetValue(level, warpNode2Address + 0x1);
Config.Stream.SetValue(area, warpNode2Address + 0x2);
Config.Stream.SetValue((byte)teleporter1Id, warpNode2Address + 0x3);
Config.Stream.SetValue(teleporter2Address, warpNode2Address + 0x4);
Config.Stream.SetValue(0x00000000U, warpNode2Address + 0x8);
Config.Stream.SetValue(warpNode1Address, lastWarpNodeAddress + 0x8);
}
public override void Update(bool updateView)
{
if (!updateView)
{
return;
}
List <uint> warpNodeAddresses = WatchVariableSpecialUtilities.GetWarpNodeAddresses();
if (!Enumerable.SequenceEqual(warpNodeAddresses, _warpNodeAddresses))
{
watchVariablePanelWarp.RemoveVariableGroup(VariableGroup.WarpNode);
watchVariablePanelWarp.AddVariables(GetWarpNodeVariables(warpNodeAddresses));
_warpNodeAddresses = warpNodeAddresses;
}
base.Update(updateView);
}
protected (List <(float x, float y, float z)> vertices, float lineWidth, Color color) GetData(bool whichLine)
{
float marioX = Config.Stream.GetFloat(MarioConfig.StructAddress + MarioConfig.XOffset);
float marioY = Config.Stream.GetFloat(MarioConfig.StructAddress + MarioConfig.YOffset);
float marioZ = Config.Stream.GetFloat(MarioConfig.StructAddress + MarioConfig.ZOffset);
List <(float x, float y, float z)> vertices = new List <(float x, float y, float z)>();
float lineWidth;
Color color;
if (whichLine)
{
uint wallTriangle = _customWallTri ?? Config.Stream.GetUInt(MarioConfig.StructAddress + MarioConfig.WallTriangleOffset);
if (wallTriangle != 0)
{
double wallUphillAngle = WatchVariableSpecialUtilities.GetTriangleUphillAngle(wallTriangle);
(float x2, float z2) = ((float, float))MoreMath.AddVectorToPoint(60, wallUphillAngle, marioX, marioZ);
vertices.Add((x2, marioY + 100, z2));
vertices.Add((x2, marioY + 238, z2));
}
else
{
vertices.Add((marioX, marioY + 100, marioZ));
vertices.Add((marioX, marioY + 238, marioZ));
}
lineWidth = Size;
color = Color;
}
else
{
vertices.Add((marioX, marioY + 30, marioZ));
vertices.Add((marioX, marioY + 150, marioZ));
lineWidth = LineWidth;
color = LineColor;
}
return(vertices, lineWidth, color);
}
public WatchVariable(string memoryTypeName, string specialType, BaseAddressTypeEnum baseAddress,
uint?offsetUS, uint?offsetJP, uint?offsetPAL, uint?offsetDefault, uint?mask)
{
BaseAddressType = baseAddress;
OffsetUS = offsetUS;
OffsetJP = offsetJP;
OffsetPAL = offsetPAL;
OffsetDefault = offsetDefault;
SpecialType = specialType;
MemoryTypeName = memoryTypeName;
MemoryType = memoryTypeName == null ? null : WatchVariableUtilities.StringToType[MemoryTypeName];
ByteCount = memoryTypeName == null ? (int?)null : WatchVariableUtilities.TypeSize[MemoryType];
NibbleCount = memoryTypeName == null ? (int?)null : WatchVariableUtilities.TypeSize[MemoryType] * 2;
SignedType = memoryTypeName == null ? (bool?)null : WatchVariableUtilities.TypeSign[MemoryType];
Mask = mask;
// Created getter/setter functions
if (IsSpecial)
{
(_getterFunction, _setterFunction) = WatchVariableSpecialUtilities.CreateGetterSetterFunctions(SpecialType);
}
else
{
_getterFunction = (uint address) =>
{
return(Config.Stream.GetValue(MemoryType, address, UseAbsoluteAddressing, Mask).ToString());
};
_setterFunction = (string value, uint address) =>
{
return(Config.Stream.SetValueRoundingWrapping(
MemoryType, value, address, UseAbsoluteAddressing, Mask));
};
}
}
protected override List <List <(float x, float y, float z)> > GetQuadList()
{
float marioY = Config.Stream.GetSingle(MarioConfig.StructAddress + MarioConfig.YOffset);
(int cellX, int cellZ) = WatchVariableSpecialUtilities.GetMarioCell();
int xMin = (cellX - 8) * 1024;
int xMax = xMin + 1024;
int zMin = (cellZ - 8) * 1024;
int zMax = zMin + 1024;
List <(float x, float y, float z)> quad =
new List <(float x, float y, float z)>()
{
(xMin, marioY, zMin),
(xMin, marioY, zMax),
(xMax, marioY, zMax),
(xMax, marioY, zMin),
};
return(new List <List <(float x, float y, float z)> >()
{
quad
});
}
public override void SetDragPositionTopDownView(double?x = null, double?y = null, double?z = null)
{
if (!x.HasValue || !z.HasValue)
{
return;
}
PositionAngle posAngle = GetPositionAngle();
double dist = MoreMath.GetDistanceBetween(posAngle.X, posAngle.Z, x.Value, z.Value);
double angle = MoreMath.AngleTo_AngleUnits(posAngle.X, posAngle.Z, x.Value, z.Value);
double xDiff = x.Value - posAngle.X;
double zDiff = z.Value - posAngle.Z;
if (_useRecommendedArrowLength)
{
Config.Stream.SetValue((float)xDiff, MarioConfig.StructAddress + MarioConfig.SlidingSpeedXOffset);
Config.Stream.SetValue((float)zDiff, MarioConfig.StructAddress + MarioConfig.SlidingSpeedZOffset);
}
else
{
GetParentMapTracker().SetSize((float)(Scales ? dist : dist *Config.CurrentMapGraphics.MapViewScaleValue));
WatchVariableSpecialUtilities.SetMarioSlidingAngle(angle);
}
}
public (bool success, TtcSaveState saveState, int endFrame) FindIdealPendulumManipulation(uint pendulumAddress)
{
int?objectIndexNullable = ObjectUtilities.GetObjectIndex(pendulumAddress);
if (!objectIndexNullable.HasValue)
{
return(false, null, 0);
}
int objectIndex = objectIndexNullable.Value;
TtcPendulum pendulum = _rngObjects[objectIndex] as TtcPendulum;
int pendulumAmplitudeStart = (int)WatchVariableSpecialUtilities.GetPendulumAmplitude(
pendulum._accelerationDirection, pendulum._accelerationMagnitude, pendulum._angularVelocity, pendulum._angle);
int?pendulumSwingIndexStartNullable = TableConfig.PendulumSwings.GetPendulumSwingIndex(pendulumAmplitudeStart);
if (!pendulumSwingIndexStartNullable.HasValue)
{
return(false, null, 0);
}
int pendulumSwingIndexStart = pendulumSwingIndexStartNullable.Value;
//iterate through frames to update objects
int frame = _startingFrame;
int counter = 0;
while (frame < _startingFrame + 300)
{
frame++;
counter++;
foreach (TtcObject rngObject in _rngObjects)
{
rngObject.SetFrame(frame);
rngObject.Update();
}
int pendulumAmplitude = (int)WatchVariableSpecialUtilities.GetPendulumAmplitude(
pendulum._accelerationDirection, pendulum._accelerationMagnitude, pendulum._angularVelocity, pendulum._angle);
int?pendulumSwingIndexNullable = TableConfig.PendulumSwings.GetPendulumSwingIndex(pendulumAmplitude);
if (!pendulumSwingIndexNullable.HasValue)
{
return(false, null, 0);
}
int pendulumSwingIndex = pendulumSwingIndexNullable.Value;
if (pendulumSwingIndex > pendulumSwingIndexStart)
{
if (pendulum._waitingTimer == 0)
{
return(true, GetSaveState(), frame);
}
else
{
return(false, null, 0);
}
}
else if (pendulumSwingIndex < pendulumSwingIndexStart)
{
return(false, null, 0);
}
}
return(false, null, 0);
}
public int GetCountdown()
{
return(WatchVariableSpecialUtilities.GetPendulumCountdown(
_accelerationDirection, _accelerationMagnitude, _angularVelocity, _angle, _waitingTimer));
}
public int GetAmplitude()
{
return((int)WatchVariableSpecialUtilities.GetPendulumAmplitude(
_accelerationDirection, _accelerationMagnitude, _angularVelocity, _angle));
}
public TriangleManager(Control tabControl, List <WatchVariableControlPrecursor> variables, WatchVariablePanel watchVariablePanel)
: base(variables, watchVariablePanel, ALL_VAR_GROUPS, VISIBLE_VAR_GROUPS)
{
_triangleCache = new Dictionary <uint, TriangleStruct>();
_triangleData = new List <short[]>();
SplitContainer splitContainerTriangles = tabControl.Controls["splitContainerTriangles"] as SplitContainer;
_addressBox = splitContainerTriangles.Panel1.Controls["maskedTextBoxOtherTriangle"] as MaskedTextBox;
_useMisalignmentOffsetCheckbox = splitContainerTriangles.Panel1.Controls["checkBoxVertexMisalignment"] as CheckBox;
_addressBox.KeyDown += AddressBox_KeyDown;
(splitContainerTriangles.Panel1.Controls["radioButtonTriFloor"] as RadioButton).Click
+= (sender, e) => Mode_Click(sender, e, TriangleMode.Floor);
(splitContainerTriangles.Panel1.Controls["radioButtonTriWall"] as RadioButton).Click
+= (sender, e) => Mode_Click(sender, e, TriangleMode.Wall);
(splitContainerTriangles.Panel1.Controls["radioButtonTriCeiling"] as RadioButton).Click
+= (sender, e) => Mode_Click(sender, e, TriangleMode.Ceiling);
(splitContainerTriangles.Panel1.Controls["radioButtonTriOther"] as RadioButton).Click
+= (sender, e) => Mode_Click(sender, e, TriangleMode.Other);
(splitContainerTriangles.Panel1.Controls["labelTriangleSelection"] as Label).Click
+= (sender, e) => ShowTriangleCoordinates();
(splitContainerTriangles.Panel1.Controls["buttonGotoV1"] as Button).Click
+= (sender, e) => ButtonUtilities.GotoTriangle(_triangleAddress, 1, _useMisalignmentOffsetCheckbox.Checked);
(splitContainerTriangles.Panel1.Controls["buttonGotoV2"] as Button).Click
+= (sender, e) => ButtonUtilities.GotoTriangle(_triangleAddress, 2, _useMisalignmentOffsetCheckbox.Checked);
(splitContainerTriangles.Panel1.Controls["buttonGotoV3"] as Button).Click
+= (sender, e) => ButtonUtilities.GotoTriangle(_triangleAddress, 3, _useMisalignmentOffsetCheckbox.Checked);
(splitContainerTriangles.Panel1.Controls["buttonGotoVClosest"] as Button).Click += (sender, e) =>
{
int closestVertex = WatchVariableSpecialUtilities.GetClosestTriangleVertexIndex(_triangleAddress);
ButtonUtilities.GotoTriangle(_triangleAddress, closestVertex, _useMisalignmentOffsetCheckbox.Checked);
};
(splitContainerTriangles.Panel1.Controls["buttonRetrieveTriangle"] as Button).Click
+= (sender, e) => ButtonUtilities.RetrieveTriangle(_triangleAddress);
Button buttonNeutralizeTriangle = splitContainerTriangles.Panel1.Controls["buttonNeutralizeTriangle"] as Button;
buttonNeutralizeTriangle.Click += (sender, e) => ButtonUtilities.NeutralizeTriangle(_triangleAddress);
ControlUtilities.AddContextMenuStripFunctions(
buttonNeutralizeTriangle,
new List <string>()
{
"Neutralize", "Neutralize with 0", "Neutralize with 21"
},
new List <Action>()
{
() => ButtonUtilities.NeutralizeTriangle(_triangleAddress),
() => ButtonUtilities.NeutralizeTriangle(_triangleAddress, false),
() => ButtonUtilities.NeutralizeTriangle(_triangleAddress, true),
});
(splitContainerTriangles.Panel1.Controls["buttonAnnihilateTriangle"] as Button).Click
+= (sender, e) => ButtonUtilities.AnnihilateTriangle(_triangleAddress);
var trianglePosGroupBox = splitContainerTriangles.Panel1.Controls["groupBoxTrianglePos"] as GroupBox;
ControlUtilities.InitializeThreeDimensionController(
CoordinateSystem.Euler,
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(
_triangleAddress,
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(_triangleAddress, 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["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());
(splitContainerTriangles.Panel1.Controls["buttonTriangleShowObjTris"] as Button).Click
+= (sender, e) => TriangleUtilities.ShowTriangles(TriangleUtilities.GetObjectTriangles());
(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",
},
new List <Action>()
{
() => TriangleUtilities.NeutralizeTriangles(),
() => TriangleUtilities.NeutralizeTriangles(TriangleClassification.Wall),
() => TriangleUtilities.NeutralizeTriangles(TriangleClassification.Floor),
() => TriangleUtilities.NeutralizeTriangles(TriangleClassification.Ceiling),
});
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),
});
}
protected override void SetRecommendedSize(double size)
{
WatchVariableSpecialUtilities.SetMarioSlidingSpeed(size);
}
protected override void SetYaw(double yaw)
{
WatchVariableSpecialUtilities.SetMarioSlidingAngle(yaw);
}
public static (string, Func <string>) CreateGetterFunction(string specialType)
{
string name = DEFAULT_NAME;
Func <string> getterFunction = DEFAULT_GETTER;
switch (specialType)
{
case "RngIndex":
name = "Index " + VarHackConfig.EscapeChar;
getterFunction = () =>
{
return(RngIndexer.GetRngIndex().ToString());
};
break;
case "FloorYNorm":
name = "YNorm " + VarHackConfig.EscapeChar;
getterFunction = () =>
{
uint triFloorAddress = Config.Stream.GetUInt(MarioConfig.StructAddress + MarioConfig.FloorTriangleOffset);
float yNorm = Config.Stream.GetFloat(triFloorAddress + TriangleOffsetsConfig.NormY);
return(FormatDouble(yNorm, 4, true));
};
break;
case "DefactoSpeed":
name = "Defacto " + VarHackConfig.EscapeChar;
getterFunction = () =>
{
return(FormatInteger(WatchVariableSpecialUtilities.GetMarioDeFactoSpeed()));
};
break;
case "SlidingSpeed":
name = "Spd " + VarHackConfig.EscapeChar;
getterFunction = () =>
{
return(FormatInteger(WatchVariableSpecialUtilities.GetMarioSlidingSpeed()));
};
break;
case "MarioAction":
name = "Action " + VarHackConfig.EscapeChar;
getterFunction = () =>
{
return(TableConfig.MarioActions.GetActionName());
};
break;
case "MarioAnimation":
name = "Animation " + VarHackConfig.EscapeChar;
getterFunction = () =>
{
return(TableConfig.MarioAnimations.GetAnimationName());
};
break;
case "DYawIntendFacing":
name = "DYaw " + VarHackConfig.EscapeChar;
getterFunction = () =>
{
return(FormatInteger(WatchVariableSpecialUtilities.GetDeltaYawIntendedFacing()));
};
break;
case "DYawIntendFacingHau":
name = "DYaw " + VarHackConfig.EscapeChar;
getterFunction = () =>
{
return(FormatInteger(WatchVariableSpecialUtilities.GetDeltaYawIntendedFacing() / 16));
};
break;
default:
break;
}
return(name, getterFunction);
}
private void AddItemsToContextMenuStrip()
{
ToolStripMenuItem resetVariablesItem = new ToolStripMenuItem("Reset Variables");
resetVariablesItem.Click += (sender, e) => ResetVariables();
ToolStripMenuItem clearAllButHighlightedItem = new ToolStripMenuItem("Clear All But Highlighted");
clearAllButHighlightedItem.Click += (sender, e) => ClearAllButHighlightedVariables();
ToolStripMenuItem fixVerticalScrollItem = new ToolStripMenuItem("Fix Vertical Scroll");
fixVerticalScrollItem.Click += (sender, e) => FixVerticalScroll();
ToolStripMenuItem addCustomVariablesItem = new ToolStripMenuItem("Add Custom Variables");
addCustomVariablesItem.Click += (sender, e) =>
{
VariableCreationForm form = new VariableCreationForm();
form.Initialize(this);
form.Show();
};
ToolStripMenuItem addMappingVariablesItem = new ToolStripMenuItem("Add Mapping Variables");
addMappingVariablesItem.Click += (sender, e) => AddVariables(MappingConfig.GetVariables());
ToolStripMenuItem addDummyVariableItem = new ToolStripMenuItem("Add Dummy Variable...");
List <string> types = new List <string>(TypeUtilities.InGameTypeList);
types.Add("string");
foreach (string typeString in types)
{
ToolStripMenuItem typeItem = new ToolStripMenuItem(typeString);
addDummyVariableItem.DropDownItems.Add(typeItem);
typeItem.Click += (sender, e) =>
{
int numEntries = 1;
if (KeyboardUtilities.IsCtrlHeld())
{
string numEntriesString = DialogUtilities.GetStringFromDialog(labelText: "Enter Num Vars:");
if (numEntriesString == null)
{
return;
}
int parsed = ParsingUtilities.ParseInt(numEntriesString);
parsed = Math.Max(parsed, 0);
numEntries = parsed;
}
List <WatchVariableControl> controls = new List <WatchVariableControl>();
for (int i = 0; i < numEntries; i++)
{
string specialType = WatchVariableSpecialUtilities.AddDummyEntry(typeString);
WatchVariable watchVariable =
new WatchVariable(
name: specialType,
memoryTypeName: null,
specialType: specialType,
baseAddressType: BaseAddressTypeEnum.None,
offsetUS: null,
offsetJP: null,
offsetSH: null,
offsetEU: null,
offsetDefault: null,
mask: null,
shift: null,
handleMapping: true);
WatchVariableControlPrecursor precursor =
new WatchVariableControlPrecursor(
name: specialType,
watchVar: watchVariable,
subclass: typeString == "string" ? WatchVariableSubclass.String : WatchVariableSubclass.Number,
backgroundColor: null,
displayType: null,
roundingLimit: null,
useHex: null,
invertBool: null,
isYaw: null,
coordinate: null,
groupList: new List <VariableGroup>()
{
VariableGroup.Custom
});
WatchVariableControl control = precursor.CreateWatchVariableControl();
controls.Add(control);
}
AddVariables(controls);
};
}
ToolStripMenuItem openSaveClearItem = new ToolStripMenuItem("Open / Save / Clear ...");
ControlUtilities.AddDropDownItems(
openSaveClearItem,
new List <string>()
{
"Open", "Open as Pop Out", "Save in Place", "Save As", "Clear"
},
new List <Action>()
{
() => OpenVariables(),
() => OpenVariablesAsPopOut(),
() => SaveVariablesInPlace(),
() => SaveVariables(),
() => ClearVariables(),
});
ToolStripMenuItem doToAllVariablesItem = new ToolStripMenuItem("Do to all variables...");
WatchVariableSelectionUtilities.CreateSelectionToolStripItems(
() => GetCurrentVariableControls(), this)
.ForEach(item => doToAllVariablesItem.DropDownItems.Add(item));
ToolStripMenuItem filterVariablesItem = new ToolStripMenuItem("Filter Variables...");
_filteringDropDownItems = _allGroups.ConvertAll(varGroup => CreateFilterItem(varGroup));
UpdateFilterItemCheckedStatuses();
_filteringDropDownItems.ForEach(item => filterVariablesItem.DropDownItems.Add(item));
filterVariablesItem.DropDown.MouseEnter += (sender, e) =>
{
filterVariablesItem.DropDown.AutoClose = false;
};
filterVariablesItem.DropDown.MouseLeave += (sender, e) =>
{
filterVariablesItem.DropDown.AutoClose = true;
filterVariablesItem.DropDown.Close();
};
ContextMenuStrip.Items.Add(resetVariablesItem);
ContextMenuStrip.Items.Add(clearAllButHighlightedItem);
ContextMenuStrip.Items.Add(fixVerticalScrollItem);
ContextMenuStrip.Items.Add(addCustomVariablesItem);
ContextMenuStrip.Items.Add(addMappingVariablesItem);
ContextMenuStrip.Items.Add(addDummyVariableItem);
ContextMenuStrip.Items.Add(openSaveClearItem);
ContextMenuStrip.Items.Add(doToAllVariablesItem);
ContextMenuStrip.Items.Add(filterVariablesItem);
}
protected override double GetRecommendedSize()
{
return(WatchVariableSpecialUtilities.GetMarioSlidingSpeed());
}
protected override double GetYaw()
{
return(WatchVariableSpecialUtilities.GetMarioSlidingAngle());
}
public WatchVariable(string memoryTypeName, string specialType, BaseAddressTypeEnum baseAddressType,
uint?offsetUS, uint?offsetJP, uint?offsetPAL, uint?offsetDefault, uint?mask, int?shift)
{
if (offsetDefault.HasValue && (offsetUS.HasValue || offsetJP.HasValue || offsetPAL.HasValue))
{
throw new ArgumentOutOfRangeException("Can't have both a default offset value and a rom-specific offset value");
}
if (specialType != null)
{
if (baseAddressType != BaseAddressTypeEnum.None &&
baseAddressType != BaseAddressTypeEnum.Object &&
baseAddressType != BaseAddressTypeEnum.ProcessGroup &&
baseAddressType != BaseAddressTypeEnum.Ghost &&
baseAddressType != BaseAddressTypeEnum.LastCoin &&
baseAddressType != BaseAddressTypeEnum.File &&
baseAddressType != BaseAddressTypeEnum.MainSave &&
baseAddressType != BaseAddressTypeEnum.Triangle)
{
throw new ArgumentOutOfRangeException("Special var cannot have base address type " + baseAddressType);
}
if (offsetDefault.HasValue || offsetUS.HasValue || offsetJP.HasValue || offsetPAL.HasValue)
{
throw new ArgumentOutOfRangeException("Special var cannot have any type of offset");
}
if (mask != null)
{
throw new ArgumentOutOfRangeException("Special var cannot have mask");
}
}
BaseAddressType = baseAddressType;
OffsetUS = offsetUS;
OffsetJP = offsetJP;
OffsetPAL = offsetPAL;
OffsetDefault = offsetDefault;
SpecialType = specialType;
MemoryTypeName = memoryTypeName;
MemoryType = memoryTypeName == null ? null : TypeUtilities.StringToType[MemoryTypeName];
ByteCount = memoryTypeName == null ? (int?)null : TypeUtilities.TypeSize[MemoryType];
NibbleCount = memoryTypeName == null ? (int?)null : TypeUtilities.TypeSize[MemoryType] * 2;
SignedType = memoryTypeName == null ? (bool?)null : TypeUtilities.TypeSign[MemoryType];
Mask = mask;
Shift = shift;
// Created getter/setter functions
if (IsSpecial)
{
(_getterFunction, _setterFunction) = WatchVariableSpecialUtilities.CreateGetterSetterFunctions(SpecialType);
}
else
{
_getterFunction = (uint address) =>
{
return(Config.Stream.GetValue(
MemoryType, address, UseAbsoluteAddressing, Mask, Shift));
};
_setterFunction = (object value, uint address) =>
{
return(Config.Stream.SetValueRoundingWrapping(
MemoryType, value, address, UseAbsoluteAddressing, Mask, Shift));
};
}
}
public VarHackManager(Control varHackControlControl, VarHackPanel varHackPanel)
{
_varHackPanel = varHackPanel;
// Top buttons
SplitContainer splitContainerVarHack =
varHackControlControl.Controls["splitContainerVarHack"] as SplitContainer;
Button buttonVarHackAddNewVariable =
splitContainerVarHack.Panel1.Controls["buttonVarHackAddNewVariable"] as Button;
buttonVarHackAddNewVariable.Click +=
(sender, e) => _varHackPanel.AddNewControl();
ControlUtilities.AddContextMenuStripFunctions(
buttonVarHackAddNewVariable,
new List <string>()
{
"RNG Index",
"Floor YNorm",
"Defacto Speed",
"Mario Action",
"Mario Animation",
},
new List <Action>()
{
() => AddVariable(() => "Index " + RngIndexer.GetRngIndex()),
() => AddVariable(() =>
{
uint triFloorAddress = Config.Stream.GetUInt32(MarioConfig.StructAddress + MarioConfig.FloorTriangleOffset);
float yNorm = Config.Stream.GetSingle(triFloorAddress + TriangleOffsetsConfig.NormY);
return("YNorm " + FormatDouble(yNorm, 4, true));
}),
() => AddVariable(() => "Defacto " + FormatInteger(WatchVariableSpecialUtilities.GetMarioDeFactoSpeed())),
() => AddVariable(() => "Action " + TableConfig.MarioActions.GetActionName()),
() => AddVariable(() => "Animation " + TableConfig.MarioAnimations.GetAnimationName()),
});
Button buttonVarHackClearVariables =
splitContainerVarHack.Panel1.Controls["buttonVarHackClearVariables"] as Button;
buttonVarHackClearVariables.Click +=
(sender, e) => _varHackPanel.ClearControls();
Button buttonVarHackShowVariableBytesInLittleEndian =
splitContainerVarHack.Panel1.Controls["buttonVarHackShowVariableBytesInLittleEndian"] as Button;
buttonVarHackShowVariableBytesInLittleEndian.Click +=
(sender, e) => _varHackPanel.ShowVariableBytesInLittleEndian();
Button buttonVarHackShowVariableBytesInBigEndian =
splitContainerVarHack.Panel1.Controls["buttonVarHackShowVariableBytesInBigEndian"] as Button;
buttonVarHackShowVariableBytesInBigEndian.Click +=
(sender, e) => _varHackPanel.ShowVariableBytesInBigEndian();
// Bottom buttons
Button buttonVarHackApplyVariablesToMemory =
splitContainerVarHack.Panel1.Controls["buttonVarHackApplyVariablesToMemory"] as Button;
buttonVarHackApplyVariablesToMemory.Click +=
(sender, e) => _varHackPanel.ApplyVariablesToMemory();
Button buttonVarHackClearVariablesInMemory =
splitContainerVarHack.Panel1.Controls["buttonVarHackClearVariablesInMemory"] as Button;
buttonVarHackClearVariablesInMemory.Click +=
(sender, e) => _varHackPanel.ClearVariablesInMemory();
_buttonEnableDisableRomHack =
splitContainerVarHack.Panel1.Controls["buttonEnableDisableRomHack"] as BinaryButton;
_buttonEnableDisableRomHack.Initialize(
"Enable ROM Hack",
"Disable ROM Hack",
() => VarHackConfig.ShowVarRomHack.LoadPayload(),
() => VarHackConfig.ShowVarRomHack.ClearPayload(),
() => VarHackConfig.ShowVarRomHack.Enabled);
// Middle buttons
_textBoxXPosValue = splitContainerVarHack.Panel1.Controls["textBoxXPosValue"] as BetterTextbox;
_textBoxXPosValue.AddEnterAction(() => SetPositionsAndApplyVariablesToMemory());
_textBoxXPosValue.Text = VarHackConfig.DefaultXPos.ToString();
InitializePositionControls(
_textBoxXPosValue,
splitContainerVarHack.Panel1.Controls["textBoxXPosChange"] as TextBox,
splitContainerVarHack.Panel1.Controls["buttonXPosSubtract"] as Button,
splitContainerVarHack.Panel1.Controls["buttonXPosAdd"] as Button);
_textBoxYPosValue = splitContainerVarHack.Panel1.Controls["textBoxYPosValue"] as BetterTextbox;
_textBoxYPosValue.AddEnterAction(() => SetPositionsAndApplyVariablesToMemory());
_textBoxYPosValue.Text = VarHackConfig.DefaultYPos.ToString();
InitializePositionControls(
_textBoxYPosValue,
splitContainerVarHack.Panel1.Controls["textBoxYPosChange"] as TextBox,
splitContainerVarHack.Panel1.Controls["buttonYPosSubtract"] as Button,
splitContainerVarHack.Panel1.Controls["buttonYPosAdd"] as Button);
_textBoxYDeltaValue = splitContainerVarHack.Panel1.Controls["textBoxYDeltaValue"] as BetterTextbox;
_textBoxYDeltaValue.AddEnterAction(() => SetPositionsAndApplyVariablesToMemory());
_textBoxYDeltaValue.Text = VarHackConfig.DefaultYDelta.ToString();
InitializePositionControls(
_textBoxYDeltaValue,
splitContainerVarHack.Panel1.Controls["textBoxYDeltaChange"] as TextBox,
splitContainerVarHack.Panel1.Controls["buttonYDeltaSubtract"] as Button,
splitContainerVarHack.Panel1.Controls["buttonYDeltaAdd"] as Button);
Button buttonSetPositionsAndApplyVariablesToMemory =
splitContainerVarHack.Panel1.Controls["buttonSetPositionsAndApplyVariablesToMemory"] as Button;
buttonSetPositionsAndApplyVariablesToMemory.Click +=
(sender, e) => SetPositionsAndApplyVariablesToMemory();
}
public static List <ToolStripItem> CreateSelectionToolStripItems(
Func <List <WatchVariableControl> > getVars,
WatchVariableFlowLayoutPanel panel)
{
Action <WatchVariableControlSettings, List <WatchVariableControl> > apply2 =
(WatchVariableControlSettings settings, List <WatchVariableControl> vars) =>
{
if (KeyboardUtilities.IsCtrlHeld())
{
WatchVariableControlSettingsManager.AddSettings(settings);
}
else
{
vars.ForEach(control => control.ApplySettings(settings));
}
};
Action <WatchVariableControlSettings> apply = (WatchVariableControlSettings settings) => apply2(settings, getVars());
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 itemHighlightColor = new ToolStripMenuItem("Color...");
ControlUtilities.AddDropDownItems(
itemHighlightColor,
new List <string>()
{
"Red",
"Orange",
"Yellow",
"Green",
"Blue",
"Purple",
"Pink",
"Brown",
"Black",
"White",
},
new List <Action>()
{
() => apply(new WatchVariableControlSettings(changeHighlightColor: true, newHighlightColor: Color.Red)),
() => apply(new WatchVariableControlSettings(changeHighlightColor: true, newHighlightColor: Color.Orange)),
() => apply(new WatchVariableControlSettings(changeHighlightColor: true, newHighlightColor: Color.Yellow)),
() => apply(new WatchVariableControlSettings(changeHighlightColor: true, newHighlightColor: Color.Green)),
() => apply(new WatchVariableControlSettings(changeHighlightColor: true, newHighlightColor: Color.Blue)),
() => apply(new WatchVariableControlSettings(changeHighlightColor: true, newHighlightColor: Color.Purple)),
() => apply(new WatchVariableControlSettings(changeHighlightColor: true, newHighlightColor: Color.Pink)),
() => apply(new WatchVariableControlSettings(changeHighlightColor: true, newHighlightColor: Color.Brown)),
() => apply(new WatchVariableControlSettings(changeHighlightColor: true, newHighlightColor: Color.Black)),
() => apply(new WatchVariableControlSettings(changeHighlightColor: true, newHighlightColor: Color.White)),
});
itemHighlight.DropDownItems.Add(itemHighlightColor);
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 itemFixAddress = new ToolStripMenuItem("Fix Address...");
ControlUtilities.AddDropDownItems(
itemFixAddress,
new List <string>()
{
"Default", "Fix Address", "Don't Fix Address"
},
new List <Action>()
{
() => apply(new WatchVariableControlSettings(changeFixedAddress: true, changeFixedAddressToDefault: true)),
() => apply(new WatchVariableControlSettings(changeFixedAddress: true, newFixedAddress: true)),
() => apply(new WatchVariableControlSettings(changeFixedAddress: true, newFixedAddress: false)),
});
ToolStripMenuItem itemCopy = new ToolStripMenuItem("Copy...");
CopyUtilities.AddDropDownItems(itemCopy, getVars);
ToolStripMenuItem itemPaste = new ToolStripMenuItem("Paste");
itemPaste.Click += (sender, e) =>
{
List <WatchVariableControl> varList = getVars();
List <string> stringList = ParsingUtilities.ParseStringList(Clipboard.GetText());
if (stringList.Count == 0)
{
return;
}
Config.Stream.Suspend();
for (int i = 0; i < varList.Count; i++)
{
varList[i].SetValue(stringList[i % stringList.Count]);
}
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;
string stringValue = angleUnitTypeFixed.ToString();
if (stringValue == AngleUnitType.InGameUnits.ToString())
{
stringValue = "In-Game Units";
}
ToolStripMenuItem itemAngleUnitsValue = new ToolStripMenuItem(stringValue);
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 itemAngleReverse = new ToolStripMenuItem("Angle: Reverse...");
ControlUtilities.AddDropDownItems(
itemAngleReverse,
new List <string>()
{
"Default", "Reverse", "Don't Reverse"
},
new List <Action>()
{
() => apply(new WatchVariableControlSettings(changeAngleReverse: true, changeAngleReverseToDefault: true)),
() => apply(new WatchVariableControlSettings(changeAngleReverse: true, newAngleReverse: true)),
() => apply(new WatchVariableControlSettings(changeAngleReverse: true, newAngleReverse: 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();
};
void createBinaryMathOperationVariable(BinaryMathOperation operation)
{
List <WatchVariableControl> controls = getVars();
if (controls.Count % 2 == 1)
{
controls.RemoveAt(controls.Count - 1);
}
for (int i = 0; i < controls.Count / 2; i++)
{
WatchVariableControl control1 = controls[i];
WatchVariableControl control2 = controls[i + controls.Count / 2];
string specialType = WatchVariableSpecialUtilities.AddBinaryMathOperationEntry(control1, control2, operation);
WatchVariable watchVariable =
new WatchVariable(
memoryTypeName: null,
specialType: specialType,
baseAddressType: BaseAddressTypeEnum.None,
offsetUS: null,
offsetJP: null,
offsetSH: null,
offsetEU: null,
offsetDefault: null,
mask: null,
shift: null,
handleMapping: true);
WatchVariableControlPrecursor precursor =
new WatchVariableControlPrecursor(
name: string.Format("{0} {1} {2}", control1.VarName, MathOperationUtilities.GetSymbol(operation), control2.VarName),
watchVar: watchVariable,
subclass: WatchVariableSubclass.Number,
backgroundColor: null,
displayType: null,
roundingLimit: null,
useHex: null,
invertBool: null,
isYaw: null,
coordinate: null,
groupList: new List <VariableGroup>()
{
VariableGroup.Custom
});
WatchVariableControl control = precursor.CreateWatchVariableControl();
panel.AddVariable(control);
}
}
void createAggregateMathOperationVariable(AggregateMathOperation operation)
{
List <WatchVariableControl> controls = getVars();
if (controls.Count == 0)
{
return;
}
string specialType = WatchVariableSpecialUtilities.AddAggregateMathOperationEntry(controls, operation);
WatchVariable watchVariable =
new WatchVariable(
memoryTypeName: null,
specialType: specialType,
baseAddressType: BaseAddressTypeEnum.None,
offsetUS: null,
offsetJP: null,
offsetSH: null,
offsetEU: null,
offsetDefault: null,
mask: null,
shift: null,
handleMapping: true);
WatchVariableControlPrecursor precursor =
new WatchVariableControlPrecursor(
name: operation.ToString(),
watchVar: watchVariable,
subclass: WatchVariableSubclass.Number,
backgroundColor: null,
displayType: null,
roundingLimit: null,
useHex: null,
invertBool: null,
isYaw: null,
coordinate: null,
groupList: new List <VariableGroup>()
{
VariableGroup.Custom
});
WatchVariableControl control = precursor.CreateWatchVariableControl();
panel.AddVariable(control);
}
void createDistanceMathOperationVariable(bool use3D)
{
List <WatchVariableControl> controls = getVars();
bool satisfies2D = !use3D && controls.Count >= 4;
bool satisfies3D = use3D && controls.Count >= 6;
if (!satisfies2D && !satisfies3D)
{
return;
}
string specialType = WatchVariableSpecialUtilities.AddDistanceMathOperationEntry(controls, use3D);
string name = use3D ?
string.Format(
"({0},{1},{2}) to ({3},{4},{5})",
controls[0].VarName,
controls[1].VarName,
controls[2].VarName,
controls[3].VarName,
controls[4].VarName,
controls[5].VarName) :
string.Format(
"({0},{1}) to ({2},{3})",
controls[0].VarName,
controls[1].VarName,
controls[2].VarName,
controls[3].VarName);
WatchVariable watchVariable =
new WatchVariable(
memoryTypeName: null,
specialType: specialType,
baseAddressType: BaseAddressTypeEnum.None,
offsetUS: null,
offsetJP: null,
offsetSH: null,
offsetEU: null,
offsetDefault: null,
mask: null,
shift: null,
handleMapping: true);
WatchVariableControlPrecursor precursor =
new WatchVariableControlPrecursor(
name: name,
watchVar: watchVariable,
subclass: WatchVariableSubclass.Number,
backgroundColor: null,
displayType: null,
roundingLimit: null,
useHex: null,
invertBool: null,
isYaw: null,
coordinate: null,
groupList: new List <VariableGroup>()
{
VariableGroup.Custom
});
WatchVariableControl control = precursor.CreateWatchVariableControl();
panel.AddVariable(control);
}
void createRealTimeVariable()
{
List <WatchVariableControl> controls = getVars();
for (int i = 0; i < controls.Count; i++)
{
WatchVariableControl control = controls[i];
string specialType = WatchVariableSpecialUtilities.AddRealTimeEntry(control);
WatchVariable watchVariable =
new WatchVariable(
memoryTypeName: null,
specialType: specialType,
baseAddressType: BaseAddressTypeEnum.None,
offsetUS: null,
offsetJP: null,
offsetSH: null,
offsetEU: null,
offsetDefault: null,
mask: null,
shift: null,
handleMapping: true);
WatchVariableControlPrecursor precursor =
new WatchVariableControlPrecursor(
name: string.Format("{0} Real Time", control.VarName),
watchVar: watchVariable,
subclass: WatchVariableSubclass.String,
backgroundColor: null,
displayType: null,
roundingLimit: null,
useHex: null,
invertBool: null,
isYaw: null,
coordinate: null,
groupList: new List <VariableGroup>()
{
VariableGroup.Custom
});
WatchVariableControl control2 = precursor.CreateWatchVariableControl();
panel.AddVariable(control2);
}
}
ToolStripMenuItem itemAddVariables = new ToolStripMenuItem("Add Variable(s)...");
ControlUtilities.AddDropDownItems(
itemAddVariables,
new List <string>()
{
"Addition",
"Subtraction",
"Multiplication",
"Division",
"Modulo",
"Non-Negative Modulo",
"Exponent",
null,
"Mean",
"Median",
"Min",
"Max",
null,
"2D Distance",
"3D Distance",
null,
"Real Time",
},
new List <Action>()
{
() => createBinaryMathOperationVariable(BinaryMathOperation.Add),
() => createBinaryMathOperationVariable(BinaryMathOperation.Subtract),
() => createBinaryMathOperationVariable(BinaryMathOperation.Multiply),
() => createBinaryMathOperationVariable(BinaryMathOperation.Divide),
() => createBinaryMathOperationVariable(BinaryMathOperation.Modulo),
() => createBinaryMathOperationVariable(BinaryMathOperation.NonNegativeModulo),
() => createBinaryMathOperationVariable(BinaryMathOperation.Exponent),
() => { },
() => createAggregateMathOperationVariable(AggregateMathOperation.Mean),
() => createAggregateMathOperationVariable(AggregateMathOperation.Median),
() => createAggregateMathOperationVariable(AggregateMathOperation.Min),
() => createAggregateMathOperationVariable(AggregateMathOperation.Max),
() => { },
() => createDistanceMathOperationVariable(use3D: false),
() => createDistanceMathOperationVariable(use3D: true),
() => { },
() => createRealTimeVariable(),
});
ToolStripMenuItem itemSetCascadingValues = new ToolStripMenuItem("Set Cascading Values");
itemSetCascadingValues.Click += (sender, e) =>
{
List <WatchVariableControl> controls = getVars();
object value1 = DialogUtilities.GetStringFromDialog(labelText: "Base Value:");
object value2 = DialogUtilities.GetStringFromDialog(labelText: "Offset Value:");
if (value1 == null || value2 == null)
{
return;
}
double?number1 = ParsingUtilities.ParseDoubleNullable(value1);
double?number2 = ParsingUtilities.ParseDoubleNullable(value2);
if (!number1.HasValue || !number2.HasValue)
{
return;
}
List <Func <object, bool> > setters = controls.SelectMany(control => control.GetSetters()).ToList();
for (int i = 0; i < setters.Count; i++)
{
setters[i](number1.Value + i * number2.Value);
}
};
List <string> backgroundColorStringList = new List <string>();
List <Action> backgroundColorActionList = new List <Action>();
backgroundColorStringList.Add("Default");
backgroundColorActionList.Add(
() => apply(new WatchVariableControlSettings(changeBackgroundColor: true, changeBackgroundColorToDefault: true)));
foreach (KeyValuePair <string, string> pair in ColorUtilities.ColorToParamsDictionary)
{
Color color = ColorTranslator.FromHtml(pair.Value);
string colorString = pair.Key;
if (colorString == "LightBlue")
{
colorString = "Light Blue";
}
backgroundColorStringList.Add(colorString);
backgroundColorActionList.Add(
() => apply(new WatchVariableControlSettings(changeBackgroundColor: true, newBackgroundColor: color)));
}
backgroundColorStringList.Add("Control (No Color)");
backgroundColorActionList.Add(
() => apply(new WatchVariableControlSettings(changeBackgroundColor: true, newBackgroundColor: SystemColors.Control)));
backgroundColorStringList.Add("Custom Color");
backgroundColorActionList.Add(
() =>
{
List <WatchVariableControl> vars = getVars();
Color?newColor = ColorUtilities.GetColorFromDialog(SystemColors.Control);
if (newColor.HasValue)
{
apply2(new WatchVariableControlSettings(changeBackgroundColor: true, newBackgroundColor: newColor.Value), vars);
ColorUtilities.LastCustomColor = newColor.Value;
}
});
backgroundColorStringList.Add("Last Custom Color");
backgroundColorActionList.Add(
() => apply(new WatchVariableControlSettings(changeBackgroundColor: true, newBackgroundColor: ColorUtilities.LastCustomColor)));
ToolStripMenuItem itemBackgroundColor = new ToolStripMenuItem("Background Color...");
ControlUtilities.AddDropDownItems(
itemBackgroundColor,
backgroundColorStringList,
backgroundColorActionList);
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 itemRename = new ToolStripMenuItem("Rename...");
itemRename.Click += (sender, e) =>
{
List <WatchVariableControl> watchVars = getVars();
string template = DialogUtilities.GetStringFromDialog("$");
if (template == null)
{
return;
}
foreach (WatchVariableControl control in watchVars)
{
control.VarName = template.Replace("$", control.VarName);
}
};
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 itemOpenTripletController = new ToolStripMenuItem("Open Triplet Controller");
itemOpenTripletController.Click += (sender, e) =>
{
VariableTripletControllerForm form = new VariableTripletControllerForm();
form.Initialize(getVars().ConvertAll(control => control.CreateCopy()));
form.ShowForm();
};
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...");
ControlUtilities.AddDropDownItems(
itemAddToTab,
new List <string>()
{
"Regular", "Fixed", "Grouped by Base Address", "Grouped by Variable"
},
new List <Action>()
{
() => SelectionForm.ShowDataManagerSelectionForm(getVars(), AddToTabTypeEnum.Regular),
() => SelectionForm.ShowDataManagerSelectionForm(getVars(), AddToTabTypeEnum.Fixed),
() => SelectionForm.ShowDataManagerSelectionForm(getVars(), AddToTabTypeEnum.GroupedByBaseAddress),
() => SelectionForm.ShowDataManagerSelectionForm(getVars(), AddToTabTypeEnum.GroupedByVariable),
});
ToolStripMenuItem itemAddToCustomTab = new ToolStripMenuItem("Add to Custom Tab...");
ControlUtilities.AddDropDownItems(
itemAddToCustomTab,
new List <string>()
{
"Regular", "Fixed", "Grouped by Base Address", "Grouped by Variable"
},
new List <Action>()
{
() => WatchVariableControl.AddVarsToTab(getVars(), Config.CustomManager, AddToTabTypeEnum.Regular),
() => WatchVariableControl.AddVarsToTab(getVars(), Config.CustomManager, AddToTabTypeEnum.Fixed),
() => WatchVariableControl.AddVarsToTab(getVars(), Config.CustomManager, AddToTabTypeEnum.GroupedByBaseAddress),
() => WatchVariableControl.AddVarsToTab(getVars(), Config.CustomManager, AddToTabTypeEnum.GroupedByVariable),
});
return(new List <ToolStripItem>()
{
itemHighlight,
itemLock,
itemFixAddress,
itemCopy,
itemPaste,
new ToolStripSeparator(),
itemRoundTo,
itemDisplayAsHex,
new ToolStripSeparator(),
itemAngleSigned,
itemAngleUnits,
itemAngleTruncateToMultipleOf16,
itemAngleConstrainToOneRevolution,
itemAngleReverse,
itemAngleDisplayAsHex,
new ToolStripSeparator(),
itemShowVariableXml,
itemShowVariableInfo,
new ToolStripSeparator(),
itemAddVariables,
itemSetCascadingValues,
new ToolStripSeparator(),
itemBackgroundColor,
itemMove,
itemRemove,
itemRename,
itemOpenController,
itemOpenTripletController,
itemOpenPopOut,
itemAddToTab,
itemAddToCustomTab,
});
}
