public static byte[] GetTeamSizes()
{
var bdPointer1 = OffsetScanner.GetOffset(GameOffset.FFX_BlitzballTeamData);
var bdPointer2 = GameMemory.Read <int>(bdPointer1, false);
var bdPointer = GameMemory.Read <int>(bdPointer2 + 0x2C, false);
return(GameMemory.Read <byte>(bdPointer + 0xA88, 6, false));
}
public static void SetTeamSize(int teamIndex, byte teamSize)
{
var bdPointer1 = OffsetScanner.GetOffset(GameOffset.FFX_BlitzballTeamData);
var bdPointer2 = GameMemory.Read <int>(bdPointer1, false);
var bdPointer = GameMemory.Read <int>(bdPointer2 + 0x2C, false);
GameMemory.Write(bdPointer + 0xA88 + teamIndex, teamSize, false);
}
private void ButtonMax_Click(object sender, RoutedEventArgs e)
{
var charOffset = _offsetPartyStats + _characterIndex * _sizePartyMember;
var levelOffset = (int)Marshal.OffsetOf <PartyMember>("OverdriveLevel") + charOffset;
var currentMax = GameMemory.Read <byte>(levelOffset, 2, false);
GameMemory.Write <byte>(levelOffset, currentMax[1], false);
Refresh(_characterIndex);
}
private void UpdateSharedAPState()
{
var gainedAp = GameMemory.Read <byte>(_offsetGainedAp, 8);
for (int i = 0; i < 8; i++)
{
var box = (CheckBox)ShareBoxes.Children[i];
_sharedApState[i] = box.IsChecked.Value ? (byte)1 : gainedAp[i];
}
}
private void KeyItemButtonsOnButtonClicked(int buttonIndex)
{
var keyItemData = GameMemory.Read <byte>(_offsetKeyItem, 8, false);
var bitIndex = KeyItem.KeyItems[buttonIndex].BitIndex;
var keyByteIndex = bitIndex / 8;
var keyBitIndex = bitIndex % 8;
keyItemData[keyByteIndex] = BitHelper.ToggleBit(keyItemData[keyByteIndex], keyBitIndex);
GameMemory.Write(_offsetKeyItem, keyItemData, false);
Refresh();
}
public static string GetName(int partyIndex)
{
if (partyIndex < 8)
{
return(null);
}
var offset = _offsetAeonNames + 0xA0 + AeonNames[partyIndex - 8];
var nameBytes = GameMemory.Read <byte>(offset, 8, false);
return(StringConverter.ToString(nameBytes));
}
public static int GetEntityOffset(EntityType entityType, int entityIndex)
{
var pointerOffset = entityType == EntityType.Party ? OffsetPtrParty : OffsetPtrEnemy;
var ptrEntityList = GameMemory.Read <IntPtr>(pointerOffset, false);
if (ptrEntityList == IntPtr.Zero)
{
return(0);
}
return((int)ptrEntityList + (int)Battle.BlockLengthEntity * entityIndex);
}
public void Refresh()
{
_refreshing = true;
var nameBytes = LegacyMemoryReader.ReadBytes(_offsetCreatureName + (_creatureIndex * 40), 18);
var name = StringConverter.ToASCII(nameBytes);
CreatureName.Text = name;
CreatureSize.SelectedIndex = GameMemory.Read <byte>(_statsOffset + (int)Offsets.StatOffsets.Size) - 1;
_statsPanel.Refresh(_creatureIndex + 15);
_creatureAbilities.Refresh();
_refreshing = false;
}
public void Refresh()
{
_refreshing = true;
_editingItem = -1;
_currentItems = Item.ReadItems();
// Refresh inventory items
for (int i = 0; i < _currentItems.Length; i++)
{
if (_currentItems[i].ID == 0xFF)
{
// Empty slot
_itemButtons.SetContent(i, "< EMPTY >");
}
else
{
// Show item name and count
_itemButtons.SetContent(i, _currentItems[i].Name + " x" + _currentItems[i].Count);
}
}
// Refresh key items and al bhed dictionaries
var keyItemData = GameMemory.Read <byte>(_offsetKeyItem, 8, false);
var alBhedData = GameMemory.Read <byte>(_offsetAlBhed, 4, false);
_keyItemState = BitHelper.GetBitArray(keyItemData, 58);
_alBhedState = BitHelper.GetBitArray(alBhedData, 26);
// Key Items
for (int i = 0; i < KeyItem.KeyItems.Length - 1; i++)
{
if (_keyItemState[KeyItem.KeyItems[i].BitIndex])
{
// Key item owned
_keyItemButtons.Buttons[i].Foreground = _trueKeyItemBrush;
_keyItemButtons.SetContent(i, $"{KeyItem.KeyItems[i].Name}");
}
else
{
// Key item not owned
_keyItemButtons.Buttons[i].Foreground = _falseKeyItemBrush;
_keyItemButtons.SetContent(i, $"{KeyItem.KeyItems[i].Name}");
}
}
// Al Bhed Dictionaries
for (int i = 0; i < 26; i++)
{
(PanelAlBhed.Children[i] as CheckBox).IsChecked = _alBhedState[i];
}
_refreshing = false;
}
public static void ToggleOverdriveMode(int charIndex, int overdriveId)
{
var odOffset = StructHelper.GetFieldOffset <PartyMember>("OverdriveModes",
_offsetParty + Marshal.SizeOf <PartyMember>() * charIndex);
var odBytes = GameMemory.Read <byte>(odOffset, 3, false);
var odMode = OverdriveModes.First(od => od.ID == overdriveId);
var bitIndex = odMode.BitIndex % 8;
var byteIndex = odMode.BitIndex / 8;
odBytes[byteIndex] = BitHelper.ToggleBit(odBytes[byteIndex], bitIndex);
GameMemory.Write(odOffset, odBytes, false);
}
public static bool ValidateBytes()
{
var codeBytes1 = GameMemory.Read <byte>(_offsetModBytes1, _originalBytes1.Length);
var codeBytes2 = GameMemory.Read <byte>(_offsetModBytes2, _originalBytes2.Length);
if ((codeBytes1.SequenceEqual(_originalBytes1) &&
codeBytes2.SequenceEqual(_originalBytes2)) ||
(codeBytes1.SequenceEqual(_modBytes) &&
codeBytes2.SequenceEqual(_modBytes)))
{
return(true);
}
ModLogger.WriteLine("Unexpected assembly code, aborting code write.");
return(false);
}
public void Refresh(int characterIndex)
{
_refreshing = true;
_characterIndex = characterIndex;
var totalOverdrives = OverdriveMode.OverdriveModes.Length;
var charOffset = _offsetPartyStats + _characterIndex * _sizePartyMember;
var offsetLevels = (int)Marshal.OffsetOf <PartyMember>("OverdriveMode") + charOffset;
var offsetFlags = (int)Marshal.OffsetOf <PartyMember>("OverdriveModes") + charOffset;
var offsetCounters = (int)Marshal.OffsetOf <PartyMember>("OverdriveWarrior") + charOffset;
var odLevels = GameMemory.Read <byte>(offsetLevels, 3, false);
var odBytes = GameMemory.Read <byte>(offsetFlags, 3, false);
var odCounters = GameMemory.Read <byte>(offsetCounters, totalOverdrives * 2, false);
ComboCurrentOverdrive.SelectedIndex = odLevels[0];
TextOverdriveCurrent.Text = odLevels[1].ToString();
TextOverdriveMax.Text = odLevels[2].ToString();
var learnedOverdrives = BitHelper.GetBitArray(odBytes, totalOverdrives);
for (int i = 0; i < totalOverdrives; i++)
{
var dockPanel = GridOverdrive.Children[i] as DockPanel;
if (dockPanel == null)
{
continue;
}
var checkLearned = (dockPanel.Children[0] as CheckBox);
var textCount = (dockPanel.Children[1] as TextBox);
if (checkLearned != null)
{
checkLearned.IsChecked = learnedOverdrives[OverdriveMode.OverdriveModes[i].BitIndex];
}
if (textCount != null)
{
textCount.Text =
BitConverter.ToUInt16(odCounters, OverdriveMode.OverdriveModes[i].BitIndex * 2).ToString();
}
}
_refreshing = false;
}
public static Character[] GetActiveParty()
{
var party = GameMemory.Read <byte>(_offsetPartyList, 8, false);
if (party == null)
{
return(new Character[8]);
}
var outArray = new Character[8];
for (int i = 0; i < 8; i++)
{
outArray[i] = (Character)party[i];
}
return(outArray);
}
public static EquipmentItem[] ReadItems()
{
var dataLength = MaxItems * BlockLength;
var dataBytes = GameMemory.Read <byte>(Offset, dataLength, false);
var readItems = new EquipmentItem[MaxItems];
for (int i = 0; i < MaxItems; i++)
{
IntPtr ptrEquipmentData = Marshal.AllocHGlobal(dataLength);
Marshal.Copy(dataBytes, i * BlockLength, ptrEquipmentData, BlockLength);
readItems[i] = (EquipmentItem)Marshal.PtrToStructure(ptrEquipmentData, typeof(EquipmentItem));
Marshal.FreeHGlobal(ptrEquipmentData);
}
return(readItems);
}
public void Update()
{
if (!_modActive)
{
return;
}
updateTicks++;
if (updateTicks < 50)
{
return; // tick every ~400ms, faster and the game misses the flag on room change
}
updateTicks = 0;
var battlePointer = GameMemory.Read <int>(offsetBattlePointer);
if (battlePointer == 0) // Not in battle, enable camera
{
// Check current room
var currentRoom = GameMemory.Read <ushort>(offsetCurrentRoom);
// Check if room is on banned rooms list
if (Array.IndexOf(bannedRooms, currentRoom) != -1)
{
GameMemory.Write <byte>(offsetCameraFlag, 0);
lastRoom = currentRoom;
return;
}
// If we have changed rooms, reset flag this tick
if (currentRoom != lastRoom)
{
ModLogger.WriteLine("Room change detected: {0}", currentRoom.ToString("X2"));
GameMemory.Write <byte>(offsetCameraFlag, 0);
lastRoom = currentRoom;
return;
}
// Enable camera flag
GameMemory.Write <byte>(offsetCameraFlag, 1);
}
else // In battle, disable camera
{
GameMemory.Write <byte>(offsetCameraFlag, 0);
}
}
private void AlBhedDictionary_CheckedChanged(object sender, RoutedEventArgs e)
{
if (_refreshing)
{
return;
}
var checkBox = sender as CheckBox;
var alBhedData = GameMemory.Read <byte>(_offsetAlBhed, 4, false);
var boxIndex = PanelAlBhed.Children.IndexOf(checkBox);
var byteIndex = boxIndex / 8;
var bitIndex = boxIndex % 8;
alBhedData[byteIndex] = BitHelper.ToggleBit(alBhedData[byteIndex], bitIndex);
GameMemory.Write(_offsetAlBhed, alBhedData, false);
Refresh();
}
public static SphereGridNode ReadNode(int nodeIndex)
{
var offset = _offsetSphereGrid + 0x818 + nodeIndex * _sizeSphereGridNode;
var nodeBytes = GameMemory.Read <byte>(offset, _sizeSphereGridNode, false);
var nodePtr = Marshal.AllocHGlobal(_sizeSphereGridNode);
try
{
Marshal.Copy(nodeBytes, 0, nodePtr, _sizeSphereGridNode);
var node = Marshal.PtrToStructure <SphereGridNode>(nodePtr);
return(node);
}
finally
{
Marshal.FreeHGlobal(nodePtr);
}
}
public static PartyMember ReadPartyMember(int partyIndex)
{
// Read an item from the game's memory into struct
var offset = _offsetParty + partyIndex * _blockLength;
var bytes = GameMemory.Read <byte>(offset, _blockLength, false);
IntPtr ptrEquipmentItem = Marshal.AllocHGlobal(_blockLength);
try
{
// Attempt to copy memory bytes into struct and return
Marshal.Copy(bytes, 0, ptrEquipmentItem, _blockLength);
return((PartyMember)Marshal.PtrToStructure(ptrEquipmentItem, typeof(PartyMember)));
}
finally
{
Marshal.FreeHGlobal(ptrEquipmentItem);
}
}
public static EquipmentItem ReadItem(int itemIndex)
{
// Read an item from the game's memory into struct
var offset = Offset + itemIndex * BlockLength;
var bytes = GameMemory.Read <byte>(offset, BlockLength, false);
IntPtr ptrEquipmentItem = Marshal.AllocHGlobal(BlockLength);
try
{
// Attempt to copy memory bytes into struct and return
Marshal.Copy(bytes, 0, ptrEquipmentItem, BlockLength);
return((EquipmentItem)Marshal.PtrToStructure(ptrEquipmentItem, typeof(EquipmentItem)));
}
finally
{
Marshal.FreeHGlobal(ptrEquipmentItem);
}
}
public static BlitzballData ReadBlitzballData(bool dumpBytes = false)
{
var offsetOfPrizes = (int)Marshal.OffsetOf <BlitzballData>("BlitzballPrizes");
var blitzBytes = GameMemory.Read <byte>(_dataPointer, _blitzDataSize, false);
if (dumpBytes)
{
File.WriteAllBytes($"blitzdata_{DateTime.Now.Millisecond.ToString()}.bin", blitzBytes);
}
var blitzPtr = Marshal.AllocHGlobal(blitzBytes.Length);
try
{
Marshal.Copy(blitzBytes, 0, blitzPtr, blitzBytes.Length);
return((BlitzballData)Marshal.PtrToStructure(blitzPtr, typeof(BlitzballData)));
}
finally
{
Marshal.FreeHGlobal(blitzPtr);
}
}
public static Item[] ReadItems()
{
var itemData = GameMemory.Read <byte>(_offsetItemTypes, TotalItems * 2, false);
var countData = GameMemory.Read <byte>(_offsetItemCounts, TotalItems, false);
var itemList = new List <Item>();
for (int i = 0; i < TotalItems; i++)
{
var itemID = BitConverter.ToInt16(itemData, i * 2);
var itemCount = countData[i];
var item = FromID(itemID);
itemList.Add(new Item()
{
ID = itemID,
Name = item == null ? string.Empty : item.Name,
Count = itemCount
});
}
return(itemList.ToArray());
}
public KernelTable(int startOffset)
{
// Read kernel header
_kernelHeader = GameMemory.Read <KernelFileHeader>(startOffset, false);
// Read block data
_dataBlock = GameMemory.Read <byte>(startOffset + 0x10, _kernelHeader.DataLength, false);
// Calculate string table length
var stringTableLength = 0;
// Find the last referenced string offset
for (int i = 0; i < BlockCount; i++)
{
var blockOffset = i * _kernelHeader.BlockLength;
var string1 = BitConverter.ToInt16(_dataBlock, blockOffset + stringOffset1);
var string2 = BitConverter.ToInt16(_dataBlock, blockOffset + stringOffset2);
if (string1 > stringTableLength)
{
stringTableLength = string1;
}
if (string2 > stringTableLength)
{
stringTableLength = string2;
}
}
// Add length of last string to table length
var lastString = GameMemory.Read <byte>(startOffset + _kernelHeader.DataLength + 0x14 + stringTableLength, 512, false);
var lastStringLength = Array.IndexOf(lastString, (byte)0) + 3; // for 0x004700 end string marker
stringTableLength += lastStringLength;
// Read string table
_stringTable = GameMemory.Read <byte>(startOffset + _kernelHeader.DataLength + 0x14, stringTableLength, false);
}
public static int GetSelectedNode()
{
var selectedNode = GameMemory.Read <int>(_offsetCurrentNode, false);
return(selectedNode);
}
public static bool CheckBattleState()
{
var ptrParty = GameMemory.Read <IntPtr>(OffsetPtrParty, false);
return(ptrParty != IntPtr.Zero);
}
public void Update()
{
if (!_modActive)
{
return;
}
// Read battle pointer from memory
var battlePointer = GameMemory.Read <IntPtr>(_offsetEnemyPointer);
// Check if we need to reset battle
if (battlePointer == IntPtr.Zero && changedCreature != null)
{
changedThisBattle = false;
changedCreature = null;
}
if (battlePointer != IntPtr.Zero && !changedThisBattle)
{
ModLogger.WriteLine("Battle detected, modifying enemies");
changedCreature = new bool[8];
// Loop until all creatures are modified or limit is hit
var loopLimit = 2000; // maximum times to attempt modification before giving up
while (changedCreature.Contains(false) && loopLimit > 0)
{
loopLimit--;
for (int i = 0; i < 8; i++)
{
if (changedCreature[i])
{
continue; // Enemy already modified
}
var entityData = Battle.GetEnemyEntity(i);
var entityName = StringConverter.ToString(entityData.text_name);
int entityOffset = (int)battlePointer + _sizeBattleEntity * i;
if (entityData.guid == 0) // No enemy in this slot
{
continue;
}
ModLogger.WriteLine("Modifying creature: {0}", entityName);
var newHP = entityData.hp_max * m_HpMpMultiplier;
newHP = newHP > int.MaxValue ? int.MaxValue : newHP;
var newMP = entityData.mp_max * m_HpMpMultiplier;
newMP = newMP > int.MaxValue ? int.MaxValue : newMP;
var newStrength = entityData.strength * m_StatMultiplier;
newStrength = newStrength > byte.MaxValue ? byte.MaxValue : newStrength;
var newDefense = entityData.defense * m_StatMultiplier;
newDefense = newDefense > byte.MaxValue ? byte.MaxValue : newDefense;
var newMagic = entityData.magic * m_StatMultiplier;
newMagic = newMagic > byte.MaxValue ? byte.MaxValue : newMagic;
var newMagicDef = entityData.magic_defense * m_StatMultiplier;
newMagicDef = newMagicDef > byte.MaxValue ? byte.MaxValue : newMagicDef;
var newAgility = entityData.agility * m_StatMultiplier;
newAgility = newAgility > byte.MaxValue ? byte.MaxValue : newAgility;
var newLuck = entityData.luck * m_StatMultiplier;
newLuck = newLuck > byte.MaxValue ? byte.MaxValue : newLuck;
var newAccuracy = entityData.accuracy * m_StatMultiplier;
newAccuracy = newAccuracy > byte.MaxValue ? byte.MaxValue : newAccuracy;
var newEvasion = entityData.evasion * m_StatMultiplier;
newEvasion = newEvasion > byte.MaxValue ? byte.MaxValue : newEvasion;
// update entity values
GameMemory.Write <int>(entityOffset + StructHelper.GetFieldOffset <BattleEntityData>("hp_current"),
newHP, false);
GameMemory.Write <int>(entityOffset + StructHelper.GetFieldOffset <BattleEntityData>("hp_max"),
newHP, false);
GameMemory.Write <int>(entityOffset + StructHelper.GetFieldOffset <BattleEntityData>("hp_max2"),
newHP, false);
GameMemory.Write <int>(entityOffset + StructHelper.GetFieldOffset <BattleEntityData>("mp_current"),
newMP, false);
GameMemory.Write <int>(entityOffset + StructHelper.GetFieldOffset <BattleEntityData>("mp_max"),
newMP, false);
GameMemory.Write <int>(entityOffset + StructHelper.GetFieldOffset <BattleEntityData>("mp_max2"),
newMP, false);
GameMemory.Write <byte>(entityOffset + StructHelper.GetFieldOffset <BattleEntityData>("strength"),
(byte)newStrength, false);
GameMemory.Write <byte>(entityOffset + StructHelper.GetFieldOffset <BattleEntityData>("defense"),
(byte)newDefense, false);
GameMemory.Write <byte>(entityOffset + StructHelper.GetFieldOffset <BattleEntityData>("magic"),
(byte)newMagic, false);
GameMemory.Write <byte>(entityOffset + StructHelper.GetFieldOffset <BattleEntityData>("magic_defense"),
(byte)newMagicDef, false);
GameMemory.Write <byte>(entityOffset + StructHelper.GetFieldOffset <BattleEntityData>("agility"),
(byte)newAgility, false);
GameMemory.Write <byte>(entityOffset + StructHelper.GetFieldOffset <BattleEntityData>("luck"),
(byte)newLuck, false);
GameMemory.Write <byte>(entityOffset + StructHelper.GetFieldOffset <BattleEntityData>("accuracy"),
(byte)newAccuracy, false);
GameMemory.Write <byte>(entityOffset + StructHelper.GetFieldOffset <BattleEntityData>("evasion"),
(byte)newEvasion, false);
changedCreature[i] = true;
}
}
changedThisBattle = true;
}
}
private static void UpdateOffset()
{
var skillTablePointer = OffsetScanner.GetOffset(GameOffset.FFX_SkillTablePointer);
_offsetSkillTable = GameMemory.Read <int>(skillTablePointer, false);
}
public static byte[] GetCaptureCounts()
{
return(GameMemory.Read <byte>(_offsetMonstersCaptured, 139, false));
}