private void CheckBox_Changed(object sender, RoutedEventArgs e)
{
if (refreshing)
{
return;
}
var checkBox = (CheckBox)sender;
byte[] checkedBytes = checkBox.IsChecked == true ? new byte[] { 1 } : new byte[] { 0 };
if ((string)checkBox.Tag == "FirstAttack")
{
checkedBytes = checkBox.IsChecked == true ? new byte[] { 0x00 }
}
: new byte[] { 0xFF };
try
{
var offset = Enum.Parse(typeof(Offsets.DebugFlags), (string)checkBox.Tag);
LegacyMemoryReader.WriteBytes((int)offset, checkedBytes);
}
catch { }
}
}
private void WriteAbility(int index, int abilityId)
{
LegacyMemoryReader.WriteBytes(
_abilityOffset + (_creatureIndex * 0xE38) + (index * 2),
BitConverter.GetBytes((ushort)abilityId));
Refresh();
}
private void GarmentGridChanged(object sender, RoutedEventArgs routedEventArgs)
{
if (_refreshing)
{
return;
}
var checkBox = sender as CheckBox;
if (checkBox == null)
{
return;
}
var gridIndex = int.Parse(checkBox.Name.Substring(4));
var byteIndex = gridIndex / 8;
var bitIndex = gridIndex % 8;
var garmentGridBytes = LegacyMemoryReader.ReadBytes(_offsetGarmentGrids, 8);
var gByte = garmentGridBytes[byteIndex];
var mask = (1 << bitIndex);
var newByte = gByte ^ (byte)mask;
LegacyMemoryReader.WriteBytes(_offsetGarmentGrids + byteIndex, new byte[] { (byte)newByte });
Refresh();
}
private void CreatureSize_OnSelectionChanged(object sender, SelectionChangedEventArgs e)
{
if (_refreshing)
{
return;
}
LegacyMemoryReader.WriteBytes(_statsOffset + (int)Offsets.StatOffsets.Size,
new byte[] { (byte)(CreatureSize.SelectedIndex + 1) });
}
private void CreatureName_OnKeyDown(object sender, KeyEventArgs e)
{
if (e.Key != Key.Enter)
{
return;
}
var nameBytes = StringConverter.ToFFX(CreatureName.Text);
var writeBytes = new byte[18];
nameBytes.CopyTo(writeBytes, 0);
LegacyMemoryReader.WriteBytes(_offsetCreatureName + _creatureIndex * 40, writeBytes);
Refresh();
}
public static void WriteAccessory(int slot, int item, byte count)
{
var typeOffset = (int)OffsetType.AccessoryType + (slot * 2);
var countOffset = (int)OffsetType.AccessoryCount + slot;
if (item == -1) // No item selected
{
LegacyMemoryReader.WriteBytes(typeOffset, BitConverter.GetBytes((ushort)0xFF));
LegacyMemoryReader.WriteBytes(countOffset, new byte[] { (byte)0 });
}
else
{
LegacyMemoryReader.WriteBytes(typeOffset, BitConverter.GetBytes((ushort)(item + 0x9000)));
LegacyMemoryReader.WriteBytes(countOffset, new byte[] { (byte)count });
}
}
private void NumGil_OnKeyDown(object sender, KeyEventArgs e)
{
if (e.Key != Key.Enter)
{
return;
}
var gil = 0;
var parsed = int.TryParse(NumGil.Text, out gil);
if (!parsed)
{
// error parsing gil
MessageBox.Show("The value you entered was invalid.", "Error parsing gil", MessageBoxButton.OK,
MessageBoxImage.Error);
return;
}
LegacyMemoryReader.WriteBytes(_offsetCurrentGil, BitConverter.GetBytes((uint)gil));
}
public void DeletePod(int podIndex)
{
var count = _podBytes[0];
var outBytes = new byte[9];
for (int i = 1; i < podIndex + 1; i++)
{
outBytes[i] = _podBytes[i];
}
for (int i = podIndex + 1; i < count; i++)
{
if (i + 1 < 9)
{
outBytes[i] = _podBytes[i + 1];
}
}
count--;
outBytes[0] = count;
LegacyMemoryReader.WriteBytes(_offsetCreaturePods, outBytes);
}
public static void LearnAllAbilities()
{
var partyOffset = OffsetScanner.GetOffset(GameOffset.FFX_PartyStatBase);
for (var i = 0; i < 18; i++)
{
int characterAbilityOffset = partyOffset + Marshal.SizeOf <PartyMember>() * i + StructHelper.GetFieldOffset <PartyMember>("SkillFlags");;
var currentAbilities = LegacyMemoryReader.ReadBytes(characterAbilityOffset, 13);
// Flip all normal ability bits
currentAbilities[1] |= 0xF0;
for (int b = 2; b < 11; b++)
{
currentAbilities[b] |= 0xFF;
}
currentAbilities[11] |= 0x0F;
currentAbilities[12] |= 0xFF;
LegacyMemoryReader.WriteBytes(characterAbilityOffset, currentAbilities);
}
}
private void MasterAll_Click(object sender, RoutedEventArgs e)
{
if (Dressphere.SelectedIndex == 0 || _baseOffset == 0)
{
return;
}
var dressInfo = Dresspheres.GetDresspheres().FirstOrDefault(ds => ds.ID == Dressphere.SelectedIndex);
if (dressInfo == null)
{
return;
}
var abilities = dressInfo.Abilities;
for (int a = 0; a < 16; a++)
{
if (a >= abilities.Length)
{
continue;
}
var abil = abilities[a];
int currentAP = 0;
if (abil.Offset == -1 || abil.ReadOnly)
{
continue;
}
LegacyMemoryReader.WriteBytes(_baseOffset + abil.Offset, BitConverter.GetBytes((ushort)abil.MasteredAP));
}
RefreshAbilities(_char);
}
private void AbilityButton_Click(object sender, RoutedEventArgs e)
{
if (Dressphere.SelectedIndex == 0 || _baseOffset == 0)
{
return;
}
var abilityNum = int.Parse((sender as Button).Name.Substring(7));
var dressInfo = Dresspheres.GetDresspheres().FirstOrDefault(ds => ds.ID == Dressphere.SelectedIndex);
var ability = dressInfo.Abilities[abilityNum];
var apDialog = new AbilitySlider(ability.MasteredAP, values[abilityNum]);
var setAp = apDialog.ShowDialog();
if (!setAp.HasValue || setAp.Value != true)
{
return;
}
var newAp = apDialog.AP;
LegacyMemoryReader.WriteBytes(_baseOffset + ability.Offset, BitConverter.GetBytes((ushort)newAp));
RefreshAbilities(_char);
}
private void DressBox_KeyDown(object sender, KeyEventArgs e)
{
var dressBox = (TextBox)sender;
if (dressBox == null)
{
return;
}
switch (e.Key)
{
case Key.Enter:
var dressIndex = int.Parse(dressBox.Name.Substring(10));
var quantity = 0;
var parsed = int.TryParse(dressBox.Text, out quantity);
if (parsed && quantity <= 127 && quantity >= 0)
{
LegacyMemoryReader.WriteBytes(_offsetDresspheres + dressIndex,
new byte[] { (byte)quantity });
Refresh();
}
else
{
MessageBox.Show("Please enter a number between 0 and 127.", "Value input error", MessageBoxButton.OK, MessageBoxImage.Error);
}
break;
case Key.Escape:
Refresh();
dressBox.SelectionStart = 0;
dressBox.SelectionLength = dressBox.Text.Length;
break;
default:
break;
}
}
public static void GiveAllGrids()
{
var allGridBytes = new byte[8].Select(gb => gb = (byte)0xFF).ToArray();
LegacyMemoryReader.WriteBytes((int)OffsetType.KnownGarmentGrids, allGridBytes);
}
private void TextBox_KeyDown(object sender, KeyEventArgs e)
{
if (e.Key != Key.Enter)
{
return;
}
if (sender.GetType() != typeof(TextBox))
{
return;
}
var senderTextBox = sender as TextBox;
if (senderTextBox == null)
{
return;
}
try
{
switch (senderTextBox.Name)
{
case "TextCurrentExperience":
LegacyMemoryReader.WriteBytes(_statsOffset + (int)Offsets.StatOffsets.CurrentExperience,
BitConverter.GetBytes(uint.Parse(senderTextBox.Text)));
break;
case "ModHP":
LegacyMemoryReader.WriteBytes(_statsOffset + (int)Offsets.StatOffsets.HPModifier,
BitConverter.GetBytes(uint.Parse(senderTextBox.Text)));
break;
case "ModMP":
LegacyMemoryReader.WriteBytes(_statsOffset + (int)Offsets.StatOffsets.MPModifier,
BitConverter.GetBytes(uint.Parse(senderTextBox.Text)));
break;
case "TextStrength":
LegacyMemoryReader.WriteBytes(_statsOffset + (int)Offsets.StatOffsets.ModStrength,
new byte[] { byte.Parse(senderTextBox.Text) });
break;
case "TextDefense":
LegacyMemoryReader.WriteBytes(_statsOffset + (int)Offsets.StatOffsets.ModDefense,
new byte[] { byte.Parse(senderTextBox.Text) });
break;
case "TextMagic":
LegacyMemoryReader.WriteBytes(_statsOffset + (int)Offsets.StatOffsets.ModMagic,
new byte[] { byte.Parse(senderTextBox.Text) });
break;
case "TextMagicDefense":
LegacyMemoryReader.WriteBytes(_statsOffset + (int)Offsets.StatOffsets.ModMagicDefense,
new byte[] { byte.Parse(senderTextBox.Text) });
break;
case "TextAgility":
LegacyMemoryReader.WriteBytes(_statsOffset + (int)Offsets.StatOffsets.ModAgility,
new byte[] { byte.Parse(senderTextBox.Text) });
break;
case "TextAccuracy":
LegacyMemoryReader.WriteBytes(_statsOffset + (int)Offsets.StatOffsets.ModAccuracy,
new byte[] { byte.Parse(senderTextBox.Text) });
break;
case "TextEvasion":
LegacyMemoryReader.WriteBytes(_statsOffset + (int)Offsets.StatOffsets.ModEvasion,
new byte[] { byte.Parse(senderTextBox.Text) });
break;
case "TextLuck":
LegacyMemoryReader.WriteBytes(_statsOffset + (int)Offsets.StatOffsets.ModLuck,
new byte[] { byte.Parse(senderTextBox.Text) });
break;
case "TextName":
break;
}
}
catch (Exception ex)
{
MessageBox.Show($"An error occurred:\n{ex.Message}", "Error updating value", MessageBoxButton.OK, MessageBoxImage.Error);
}
Refresh(_partyIndex);
}
private void ShowTrapCombo(Button button)
{
_comboShowing = true;
var trapCombo = new ComboBox
{
ItemsSource = new string[]
{
"S",
"M",
"L",
"SP"
},
Width = 48,
SelectedIndex = 0
};
trapCombo.KeyDown += (sender, args) =>
{
switch (args.Key)
{
case Key.Enter:
if (trapCombo.SelectedIndex >= 0)
{
int trapID = 0;
switch (trapCombo.SelectedIndex)
{
case 0:
trapID = 20;
break;
case 1:
trapID = 30;
break;
case 2:
trapID = 50;
break;
case 3:
trapID = 80;
break;
}
_podBytes[_podBytes[0] + 1] = (byte)trapID;
_podBytes[0]++;
LegacyMemoryReader.WriteBytes(_offsetCreaturePods, _podBytes);
}
Refresh();
var nextButtonIndex = TrapPanel.Children.IndexOf(button) + 1;
if (nextButtonIndex < TrapPanel.Children.Count)
{
var nb = TrapPanel.Children[nextButtonIndex];
nb?.Focus();
}
else
{
button.Focus();
}
return;
case Key.Escape:
Refresh();
break;
default:
break;
}
};
button.Content = trapCombo;
button.Width = 60;
button.UpdateLayout();
trapCombo.Focus();
}
private void SetTrap(int trapIndex, int creatureId)
{
LegacyMemoryReader.WriteBytes(_offsetCreatureTrap + (trapIndex * 4),
BitConverter.GetBytes((ushort)creatureId));
Refresh();
}
