private byte[] HandlePacket_GetRankingIdByName(byte[] RequestContent)
{
var RankingName = Encoding.UTF8.GetString(RequestContent, 0, RequestContent.Length - 1);
int RankingIndex = ServerManager.ServerIndices[RankingName].IndexId;
return(StructUtils.StructToBytes((int)RankingIndex));
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="stream"></param>
/// <param name="Struct"></param>
/// <returns></returns>
public static Stream WriteStruct <T>(this Stream stream, T Struct) where T : struct
{
var bytes = StructUtils.StructToBytes(Struct);
stream.Write(bytes, 0, bytes.Length);
return(stream);
}
/// <summary>
/// </summary>
/// <typeparam name="T"></typeparam>
/// <typeparam name="TStream"></typeparam>
/// <param name="stream"></param>
/// <param name="structs"></param>
/// <param name="count"></param>
/// <returns></returns>
public static TStream WriteStructVector <T, TStream>(this TStream stream, T[] structs, int count = -1)
where T : struct
where TStream : Stream
{
stream.WriteBytes(StructUtils.StructArrayToBytes(structs, count));
return(stream);
}
private byte[] HandlePacket_GetRankingInfo(byte[] RequestContent)
{
var Request = StructUtils.BytesToStruct <GetRankingInfo_RequestStruct>(RequestContent);
var Index = ServerManager.ServerIndices[Request.RankingIndex];
var Response = default(GetRankingInfo_ResponseStruct);
Response = new GetRankingInfo_ResponseStruct()
{
Result = 0,
Length = Index.Tree.Count,
Direction = Index.SortingDirection,
TopScore = 0,
BottomScore = 0,
MaxElements = -1,
TreeHeight = -1
//TreeHeight = Index.Tree.height
};
if (Index.Tree.Count > 0)
{
Response.TopScore = Index.Tree.FrontElement.ScoreValue;
Response.BottomScore = Index.Tree.BackElement.ScoreValue;
}
return(StructUtils.StructToBytes(Response));
}
public static T ReadStruct <T>(this Stream Stream) where T : struct
{
var Size = Marshal.SizeOf(typeof(T));
var Buffer = Stream.ReadBytes(Size);
return(StructUtils.BytesToStruct <T>(Buffer));
}
public static bool IsValid(byte[] MagicData)
{
try
{
var ImageVersion = StructUtils.BytesToStruct <ImageVersionStruct>(MagicData);
switch (ImageVersion.Version)
{
case 1:
break;
case 2:
var ImageHeader = StructUtils.BytesToStruct <ImageHeaderStructV2>(MagicData);
if (ImageHeader.Surface2DCount > 10000)
{
return(false);
}
if (ImageHeader.Surface3DCount > 10000)
{
return(false);
}
break;
default:
return(false);
}
return(true);
}
catch
{
//Console.WriteLine(Exception);
}
return(false);
}
private byte[] HandlePacket_ListElements(byte[] RequestContent)
{
List <ListElements_ResponseEntryStruct> ResponseEntries = new List <ListElements_ResponseEntryStruct>();
var Request = StructUtils.BytesToStruct <ListElements_RequestStruct>(RequestContent);
// http://stackoverflow.com/questions/7032290/what-happens-to-an-awaiting-thread-in-c-sharp-async-ctp
{
var RankingIndex = ServerManager.ServerIndices[Request.RankingIndexId];
int CurrentEntryOffset = Request.Offset;
if (Request.Offset >= 0)
{
foreach (var UserScore in RankingIndex.GetRange(Request.Offset, Request.Count))
{
ResponseEntries.Add(new ListElements_ResponseEntryStruct()
{
Position = CurrentEntryOffset,
UserId = UserScore.UserId,
ScoreValue = UserScore.ScoreValue,
ScoreTimeStamp = UserScore.ScoreTimeStamp,
});
CurrentEntryOffset++;
}
}
}
return(StructUtils.StructArrayToBytes(ResponseEntries.ToArray()));
}
protected void ProcessDirectoryRecord(IsoNode parentIsoNode)
{
var directoryStart = parentIsoNode.DirectoryRecord.Extent * SectorSize;
var directoryLength = parentIsoNode.DirectoryRecord.Size;
var directoryStream = Stream.SliceWithLength(directoryStart, directoryLength);
while (!directoryStream.Eof())
{
//writefln("%08X : %08X : %08X", directoryStream.position, directoryStart, directoryLength);
var directoryRecordSize = (byte)directoryStream.ReadByte();
// Even if a directory spans multiple sectors, the directory entries are not permitted to cross the sector boundary (unlike the path table).
// Where there is not enough space to record an entire directory entry at the end of a sector, that sector is zero-padded and the next
// consecutive sector is used.
if (directoryRecordSize == 0)
{
directoryStream.Position = MathUtils.NextAligned(directoryStream.Position, SectorSize);
//Console.WriteLine("AlignedTo: {0:X}", DirectoryStream.Position);
continue;
}
directoryStream.Position = directoryStream.Position - 1;
//Console.WriteLine("[{0}:{1:X}-{2:X}]", DirectoryRecordSize, DirectoryStream.Position, DirectoryStream.Position + DirectoryRecordSize);
var directoryRecordBytes = new byte[directoryRecordSize];
directoryStream.Read(directoryRecordBytes, 0, directoryRecordSize);
var directoryRecord = StructUtils.BytesToStruct <DirectoryRecord>(directoryRecordBytes);
var name =
Encoding.UTF8.GetString(directoryRecordBytes.Slice(sizeof(DirectoryRecord),
directoryRecord.NameLength));
//Console.WriteLine("{0}", name); Console.ReadKey();
if (name == "\x00" || name == "\x01")
{
continue;
}
//writefln(" %s", name);
var childIsoNode = new IsoNode(this, directoryRecord, name, parentIsoNode);
parentIsoNode.Childs2.Add(childIsoNode);
parentIsoNode.ChildsByName[childIsoNode.Name] = childIsoNode;
parentIsoNode.ChildsByNameUpperCase[childIsoNode.Name.ToUpper()] = childIsoNode;
}
foreach (var child in parentIsoNode.Childs2)
{
if (child.IsDirectory)
{
ProcessDirectoryRecord(child);
}
}
}
public void BytesToStructArrayTest()
{
var Data = new byte[] {
0x01, 0x00, 0x02, 0x00, 0x03, 0x00,
0x01, 0x01, 0x02, 0x01, 0x03, 0x01,
0x01, 0x02, 0x02, 0x02, 0x03, 0x02,
};
var TestShorts = StructUtils.BytesToStructArray <TestShorts>(Data);
Assert.AreEqual("TestShorts(0x0001, 0x0002, 0x0003)", TestShorts[0].ToString());
Assert.AreEqual("TestShorts(0x0101, 0x0102, 0x0103)", TestShorts[1].ToString());
Assert.AreEqual("TestShorts(0x0201, 0x0202, 0x0203)", TestShorts[2].ToString());
}
static public bool IsValid(byte[] Data)
{
try
{
var Header = StructUtils.BytesToStruct <HeaderStruct>(Data);
if (Header.Magic != "TO8CHTX")
{
return(false);
}
return(true);
}
catch
{
}
return(false);
}
public void TestCompressDXT5()
{
var Colors1 = new ARGB_Rev[16]
{
"#E0D6A973",
"#E0D6A900",
"#E0D6A900",
"#E0D6A900",
"#E0D6A9BC",
"#E0D6A95B",
"#E0D6A95B",
"#E0D6A95B",
"#E3DAAED5",
"#E0D6A9D5",
"#E0D6A9D5",
"#E0D6A9D5",
"#E3DAAE8B",
"#E6DEB4FF",
"#E6DEB4FF",
"#E6DEB4FF",
};
var Colors2 = new ARGB_Rev[16];
var Block = default(DXT5.AlphaColorBlock);
//var Color1 = default(ARGB_Rev);
//var Color2 = default(ARGB_Rev);
CompressDXT.CompressBlockDXT5(Colors1, out Block, CompressDXT.CompressionMode.Normal);
Console.WriteLine(StructUtils.StructToBytes(Block).ToHexString().ToUpper());
Block.Decode(ref Colors2);
Assert.AreEqual(
"#E0D6A973,#E0D6A900,#E0D6A900,#E0D6A900,#E0D6A9BC,#E0D6A95B,#E0D6A95B,#E0D6A95B,#E3DAAED5,#E0D6A9D5,#E0D6A9D5,#E0D6A9D5,#E3DAAE8B,#E6DEB4FF,#E6DEB4FF,#E6DEB4FF",
Colors1.ToStringArray(",")
);
Assert.AreEqual(
"#DED6AC6D,#DED6AC00,#DED6AC00,#DED6AC00,#DED6ACB6,#DED6AC6D,#DED6AC6D,#DED6AC6D,#E0D8AEDA,#DED6ACDA,#DED6ACDA,#DED6ACDA,#E0D8AE91,#E6DEB4FF,#E6DEB4FF,#E6DEB4FF",
Colors2.ToStringArray(",")
);
//CompressionSimpleDXT5.FindColorPair(Colors1, out Color1, out Color2);
//CompressYCoCgDXT5.CompressBlock(Colors1, ref Block);
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="stream"></param>
/// <returns></returns>
public static T ReadStructPartially <T>(this Stream stream) where T : struct
{
var size = Marshal.SizeOf(typeof(T));
var bufferPartial = stream.ReadBytes(Math.Min((int)stream.Available(), size));
byte[] buffer;
if (bufferPartial.Length < size)
{
buffer = new byte[size];
bufferPartial.CopyTo(buffer, 0);
}
else
{
buffer = bufferPartial;
}
return(StructUtils.BytesToStruct <T>(buffer));
}
/// <summary>
///
/// </summary>
/// <typeparam name="T"></typeparam>
/// <param name="Stream"></param>
/// <returns></returns>
public static T ReadStructPartially <T>(this Stream Stream) where T : struct
{
var Size = Marshal.SizeOf(typeof(T));
var BufferPartial = Stream.ReadBytes(Math.Min((int)Stream.Available(), Size));
byte[] Buffer;
if (BufferPartial.Length < Size)
{
Buffer = new byte[Size];
BufferPartial.CopyTo(Buffer, 0);
}
else
{
Buffer = BufferPartial;
}
return(StructUtils.BytesToStruct <T>(Buffer));
}
private byte[] HandlePacket_RemoveAllElements(byte[] RequestContent)
{
var Request = StructUtils.BytesToStruct <RemoveAllElements_RequestStruct>(RequestContent);
uint Count = 0;
{
var RankingIndex = ServerManager.ServerIndices[Request.RankingIndexId];
Count = (uint)RankingIndex.Tree.Count;
RankingIndex.RemoveAllItems();
}
return(StructUtils.StructToBytes(new RemoveAllElements_ResponseStruct()
{
Result = 0,
Count = Count,
}));
}
async private Task <byte[]> HandlePacketAsync_RemoveAllElements(byte[] RequestContent)
{
var Request = StructUtils.BytesToStruct <RemoveAllElements_RequestStruct>(RequestContent);
uint Count = 0;
await EnqueueTaskAsync((uint)Request.RankingIndexId, () =>
{
var RankingIndex = ServerManager.ServerIndices[Request.RankingIndexId];
Count = (uint)RankingIndex.Tree.Count;
RankingIndex.RemoveAllItems();
});
return(StructUtils.StructToBytes(new RemoveAllElements_ResponseStruct()
{
Result = 0,
Count = Count,
}));
}
public static bool IsValid(byte[] MagicData)
{
try
{
var Header = StructUtils.BytesToStruct <HeaderStruct>(MagicData);
var Magic = Encoding.ASCII.GetString(Header.Magic);
if (Magic != "FPS4")
{
return(false);
}
if (Header.ListCount > 10000)
{
return(false);
}
return(true);
}
catch
{
return(false);
}
}
private async Task <byte[]> HandlePacketAsync_GetElement(byte[] RequestContent)
{
var Request = StructUtils.BytesToStruct <GetElement_RequestStruct>(RequestContent);
int IndexPosition = -1;
var UserScore = default(ServerIndices.UserScore);
await EnqueueTaskAsync((uint)Request.RankingIndex, () =>
{
var Ranking = ServerManager.ServerIndices[Request.RankingIndex];
try
{
UserScore = Ranking.GetUserScore(Request.UserId);
IndexPosition = Ranking.Tree.GetItemPosition(UserScore);
}
catch
{
}
});
if (IndexPosition == -1 || UserScore == null)
{
return(StructUtils.StructToBytes(new GetElement_ResponseStruct()
{
Position = -1,
UserId = 0,
ScoreValue = 0,
ScoreTimeStamp = 0,
}));
}
else
{
return(StructUtils.StructToBytes(new GetElement_ResponseStruct()
{
Position = IndexPosition,
UserId = UserScore.UserId,
ScoreValue = UserScore.ScoreValue,
ScoreTimeStamp = UserScore.ScoreTimeStamp,
}));
}
}
/// <summary>
///
/// </summary>
/// <typeparam name="TType"></typeparam>
/// <param name="Stream"></param>
/// <param name="Count"></param>
/// <param name="EntrySize"></param>
/// <param name="AllowReadLess"></param>
/// <returns></returns>
public static TType[] ReadStructVector <TType>(this Stream Stream, uint Count, int EntrySize = -1, bool AllowReadLess = false) where TType : struct
{
if (Count == 0)
{
return(new TType[0]);
}
var ItemSize = Marshal.SizeOf(typeof(TType));
var SkipSize = (EntrySize == -1) ? (0) : (EntrySize - ItemSize);
var MaxCount = (uint)(Stream.Length / (ItemSize + SkipSize));
if (AllowReadLess)
{
Count = Math.Min(MaxCount, Count);
}
if (SkipSize < 0)
{
throw (new Exception("Invalid Size"));
}
else if (SkipSize == 0)
{
return(StructUtils.BytesToStructArray <TType>(Stream.ReadBytes((int)(ItemSize * Count))));
}
else
{
TType[] Vector = new TType[Count];
for (int n = 0; n < Count; n++)
{
Vector[n] = ReadStruct <TType>(Stream);
Stream.Skip(SkipSize);
}
return(Vector);
}
}
private void LoadSave(string saveFileName)
{
_sav = StructUtils.RawDeserialize <XYSav>(saveFileName);
//_sav = StructUtils.RawDeserialize<ORASSav>(saveFileName);
_sav.PCStorageSystem.Boxes.SelectMany(box => box.Pokemon).ToList().ForEach(pokemon => pokemon.Decrypt());
_boxenamesBindingSource.DataSource = _sav.PCStorageBoxNames.Boxes;
_boxenamesBindingSource.DataSource = _sav.PCStorageBoxNames.Boxes;
_boxesBindingSource.DataSource = _sav.PCStorageSystem.Boxes;
_boxenamesCurrencyManager = _boxenamesBindingSource.CurrencyManager;
_boxesCurrencyManager = _boxesBindingSource.CurrencyManager;
_pokemonBindingSource.DataSource = _boxesCurrencyManager.Current;
for (var slot = 0; slot < 30; slot++)
{
pbSlots[slot].DataBindings.Clear();
pbSlots[slot].DataBindings.Add("Image", _pokemonBindingSource[slot], "BoxIconEgg", true, DataSourceUpdateMode.Never, null);
}
comboBoxes.DataBindings.Clear();
textBoxName.DataBindings.Clear();
comboBoxes.DataSource = _boxenamesBindingSource;
comboBoxes.DataBindings.Add("SelectedIndex", _sav, "CurrentBox", false, DataSourceUpdateMode.OnPropertyChanged, -1);
textBoxName.DataBindings.Add("Text", _boxenamesBindingSource, "Name", false, DataSourceUpdateMode.OnValidation, "");
dgPokemon.DataSource = _sav.PCStorageSystem.Boxes.SelectMany(box => box.Pokemon).Where(pokemon => pokemon.Species != Species.NoSpecies).ToArray();
}
/// <summary>
///
/// </summary>
/// <typeparam name="TType"></typeparam>
/// <param name="stream"></param>
/// <param name="count"></param>
/// <param name="entrySize"></param>
/// <param name="allowReadLess"></param>
/// <returns></returns>
public static TType[] ReadStructVector <TType>(this Stream stream, uint count, int entrySize = -1,
bool allowReadLess = false) where TType : struct
{
if (count == 0)
{
return(new TType[0]);
}
var itemSize = Marshal.SizeOf(typeof(TType));
var skipSize = (entrySize == -1) ? (0) : (entrySize - itemSize);
var maxCount = (uint)(stream.Length / (itemSize + skipSize));
if (allowReadLess)
{
count = Math.Min(maxCount, count);
}
if (skipSize < 0)
{
throw (new Exception("Invalid Size"));
}
if (skipSize == 0)
{
return(StructUtils.BytesToStructArray <TType>(stream.ReadBytes((int)(itemSize * count))));
}
var vector = new TType[count];
for (var n = 0; n < count; n++)
{
vector[n] = ReadStruct <TType>(stream);
stream.Skip(skipSize);
}
return(vector);
}
private Vector2 GetModulatedIndex(int i)
{
return(StructUtils.ModulateMatrixPosition(i, copyLayout, center, alternate));
}
private void Randomize(object sender, RoutedEventArgs e)
{
if (file == null)
{
ShowNotification("Error!", "Please select a ROM before applying.");
return;
}
//////////////////////////////////////////////////////
/// SETUP RANDOMIZER AND SEED
//////////////////////////////////////////////////////
string seedtext = (seed_input.Text != "") ? seed_input.Text : Utils.RandomString(12);
MD5 md5Hasher = MD5.Create();
byte[] hashed = md5Hasher.ComputeHash(Encoding.UTF8.GetBytes(seedtext));
int ivalue = BitConverter.ToInt32(hashed, 0);
Random rng = new Random(ivalue);
randomizer = new Randomizer(allBattles, allEncounters, allParts, rng);
if (chk_enable_randomizer.IsOn)
{
//////////////////////////////////////////////////////
/// RANDOMIZE CHARACTERS
//////////////////////////////////////////////////////
if (chk_randomize_characters.IsOn)
{
randomizer.RandomizeCharacters(chk_character_continuity.IsOn);
}
//////////////////////////////////////////////////////
/// RANDOMIZE BATTLES
//////////////////////////////////////////////////////
if (chk_randomize_battles.IsOn)
{
float mixedchance = chk_allow_mixed_bots.IsOn ? (float)(sl_mixed_bots.Value / 100) : 0;
bool keep_team_structure = chk_keep_battle_structure.IsOn;
bool balanced_medal_level = chk_balanced_bot_levels.IsOn;
bool keep_battle_continuity = chk_battle_continuity.IsOn;
randomizer.RandomizeBattles(keep_team_structure, balanced_medal_level, mixedchance, keep_battle_continuity);
}
randomizer.fixSoftlock();
int amount_of_battles = 0xf5;
int battle_size = 0x28;
for (int i = 0; i <= amount_of_battles; i++)
{
int battle_address = Utils.GetAdressAtPosition(file, memory_offsets[game_id]["Battles"] + 4 * i);
byte[] battle = StructUtils.getBytes(allBattles[i].content);
Array.Copy(battle, 0, file, battle_address, battle_size);
}
//////////////////////////////////////////////////////
/// RANDOM SHOPS
//////////////////////////////////////////////////////
if (chk_random_shops.IsOn)
{
for (int i = 0; i <= 0x3B; i++)
{
if (file[memory_offsets[game_id]["ShopContents"] + i] != 0xff)
{
file[memory_offsets[game_id]["ShopContents"] + i] = (byte)rng.Next(0, 0x78);
}
}
}
//////////////////////////////////////////////////////
/// RANDOM STARTER
//////////////////////////////////////////////////////
byte[] blacklist = new byte[] { 1, 3, 6, 7, 8,
14, 15, 17, 18,
19, 20, 22, 23,
25, 26, 27, 28,
39, 40, 45, 50,
57, 66, 72, 75,
77, 80, 81, 82,
84, 90, 91, 92,
96, 100, 101, 104,
110, 115, 117, 118 };
if (chk_randomize_starter.IsOn)
{
byte part;
if ((string)cmb_starter.SelectedItem == "Random")
{
part = (byte)rng.Next(0, 0x78);
while (blacklist.Contains(part))
{
part = (byte)rng.Next(0, 0x78);
}
}
else
{
part = (byte)(cmb_starter.SelectedIndex - 1);
}
byte medal = IdTranslator.botMedal(part);
randomizer.starterMedal = medal;
int offset = memory_offsets[game_id]["Starter"];
uint funcOffset = 0x044b58;
for (int i = 0; i < 4; i++)
{
file[offset + 4 * i] = part;
}
if (IdTranslator.isFemale(part))
{
file[offset + 16] = 1;
}
file[memory_offsets[game_id]["StartMedal"]] = medal;
ushort[] replacedFunction = new ushort[]
{
//Equip_parts
0x4a0e, //ldr r2,[PTR_DAT_]
0x7811, //ldrb r1,[r2,#0x0 ]=>DAT_03000be0
0x20c0, //mov r0,#0xc0
(ushort)(0x2300 + medal), //mov r3,#medal
0x4308, //orr r0, r1
0x7010, //strb r0,[r2,#0x0 ]=>DAT_03000be0
0x490c, //ldr r1,[PTR_DAT_]
0x2003, //mov r0,#0x3
0x7008, //strb r0,[r1,#0x0 ]=>DAT_030017a0
0x708b, //strb r3,[r1,#0x2 ]=>DAT_030017a2
(ushort)(0x2000 + part), //mov r0,#part
0x70c8, //strb r0,[r1,#0x3 ]=>DAT_030017a3
0x7108, //strb r0,[r1,#0x4 ]=>DAT_030017a4
0x7148, //strb r0,[r1,#0x5 ]=>DAT_030017a5
0x7188, //strb r0,[r1,#0x6 ]=>DAT_030017a6
0x4909, //ldr r1,[->parts_in_inventory]
0x1c08, //add r0, r1,#0x0
(ushort)(0x3000 + part * 2 + 1), //add r0,#part_offset
0x2201, //mov r2,#0x1
0x7002, //strb r2,[r0,#0x0 ]=>DAT_03004c95
0x4b07, //ldr r3,[DAT_]
0x18c8, //add r0, r1, r3
0x7002, //strb r2,[r0,#0x0 ]=>DAT_03004d85
0x33f0, //add r3,#0xf0
0x18c8, //add r0, r1, r3
0x7002, //strb r2,[r0,#0x0 ]=>DAT_03004e75
0x4805, //ldr r0,[DAT_]
0x1809, //add r1, r1, r0
0x700a, //strb r2,[r1,#0x0 ]=>DAT_03004f65
0x4770, //bx lr
// Data and pointers
0x0be0,
0x0300,
0x17a0,
0x0300,
0x4c40,
0x0300,
(ushort)(part * 2 + 1 + 0xf0),
0x0000,
(ushort)(part * 2 + 1 + 3 * 0xf0),
0x0000
};
Utils.WritePayload(file, funcOffset, replacedFunction);
}
//////////////////////////////////////////////////////
/// RANDOM MEDALS
//////////////////////////////////////////////////////
if (chk_random_medal.IsOn)
{
for (int i = memory_offsets[game_id]["Events"]; i < memory_offsets[game_id]["Events"] + 0x18000;)
{
byte op = file[i];
if (op == 0x3C)
{
Trace.WriteLine("Get Medal: " + IdTranslator.IdToMedal(file[i + 1]));
if (i + 1 == memory_offsets[game_id]["StartMedal"])
{
Trace.WriteLine("Is random starter, skipping...");
}
else
{
var randomMedal = randomizer.GetRandomMedal(file[i + 1]);
file[i + 1] = randomMedal;
Trace.WriteLine("Set Medal to: " + IdTranslator.IdToMedal(file[i + 1]));
}
}
if (op == 0x2F)
{
//multiconditional jump
i += file[i + 1] + 1;
}
else
{
i += IdTranslator.operationBytes[op];
}
}
//////////////////////////////////////////////////////
/// FIX MESSAGES
//////////////////////////////////////////////////////
List <byte> origMedals = new List <byte> {
15, 16, 17, 18, 19, 20
};
List <byte> replacedMedals = origMedals.Select(x => randomizer.medalExchanges[x]).ToList();
List <Medal> medals = loadFile <List <Medal> >("./Medals.json");
List <((int, int), (int, int))> messages = new List <((int, int), (int, int))>();
messages.Add(((0x00, 0x6b), (0x00, 0x68)));
messages.Add(((0x00, 0x6f), (0x00, 0x6c)));
messages.Add(((0x00, 0x73), (0x00, 0x70)));
messages.Add(((0x00, 0x77), (0x00, 0x74)));
messages.Add(((0x00, 0x7b), (0x00, 0x78)));
messages.Add(((0x00, 0x7f), (0x00, 0x7c)));
TextParser textParser = new TextParser(file, memory_offsets[game_id]["Text"]);
for (int i = 0; i < replacedMedals.Count; i++)
{
textParser.addMessage(messages[i].Item1, medals[replacedMedals[i]].ikki_text);
textParser.addMessage(messages[i].Item2, medals[replacedMedals[i]].collect_text);
}
}
}
//////////////////////////////////////////////////////
/// CODE PATCHES
//////////////////////////////////////////////////////
if (chk_code_patches.IsOn)
{
uint jumpOffset = 0x104;
uint hookOffset = 0x7f4500;
uint trainerOffset = hookOffset + 0xD0;
uint instr1 = (uint)Utils.GetIntAtPosition(file, (int)jumpOffset);
uint instr2 = (uint)Utils.GetIntAtPosition(file, (int)jumpOffset + 4);
uint instr3 = (uint)Utils.GetIntAtPosition(file, (int)jumpOffset + 8);
uint[] jumpPayload = new uint[]
{
0xE92D8000, // push r15
0xE51FF004, // ldr r15, traineraddr
0x08000000 + hookOffset // hookOffset
};
uint[] hookPayload = new uint[]
{
0xE92D4000, // push r14
0xE3A0E402, // mov r14, #0x2000000
0xE28EE701, // add r14, #40000
0xE24EE004, // sub r14, #28
0xE90E08FF, // stmdb [r14], r0-r7, r11
0xEB00002D, // bl trainerfunc
0xE3A0E402, // mov r14, #0x2000000
0xE28EE701, // add r14, #40000
0xE24EE028, // sub r14, #28
0xE89E08FF, // ldmia [r14], r0-r7, r11
0xE8BD4000, // pop r14
instr1, // --- original instruction #1 ---
instr2, // --- original instruction #2 ---
instr3, // --- original instruction #3 ---
0xE8BD8000 // pop r15
};
List <uint> trainerPayloadList = new List <uint>();
Dictionary <uint, ushort> codePatches = new Dictionary <uint, ushort>();
if (chk_instant_text.IsOn)
{
trainerPayloadList.AddRange(new uint[] {
// Set text_speed to instant
0xE3A01403, // mov r1, #0x3000000
0xE3A000FF, // mov r0, #0xFF
0xE5C1045A, // strb r0, [r1, #0x45A]
});
codePatches = codePatches.Union(new Dictionary <uint, ushort>
{
// Instant Character Popup
{ 0x3F5F6, 0x3008 },
{ 0x3F600, 0xDC08 }
}).ToDictionary(k => k.Key, v => v.Value);
}
if (chk_encounters.IsOn)
{
trainerPayloadList.AddRange(new uint[] {
// Allow encounters
0xE3A01403, // mov r1, #0x3000000
0xE2811B19, // add r1, #0x6400
0xE3A00000, // mov r0, #0x0
0xE5C1000C, // strb r0, [r1, #0xc]
});
}
trainerPayloadList.Add(
// Return
0xE12FFF1E // bx r15
);
uint[] trainerPayload = trainerPayloadList.ToArray();
Utils.WritePayload(file, jumpOffset, jumpPayload);
Utils.WritePayload(file, hookOffset, hookPayload);
Utils.WritePayload(file, trainerOffset, trainerPayload);
Utils.WritePatches(file, codePatches);
}
//////////////////////////////////////////////////////
/// ADD MESSAGES
//////////////////////////////////////////////////////
TextParser textParser2 = new TextParser(file, memory_offsets[game_id]["Text"]);
List <Message> patchedMessages = loadFile <List <Message> >("./Patched_Messages.json");
foreach (Message message in patchedMessages)
{
textParser2.addMessage((message.id[0], message.id[1]), message.message);
}
TextPatcher textPatcher = new TextPatcher(ref file, memory_offsets[game_id]["Text"], 0x7f5500, textParser2.getEncodedMessages());
textPatcher.PatchText();
//////////////////////////////////////////////////////
/// WRITE TO FILE
//////////////////////////////////////////////////////
File.WriteAllBytes(seedtext + ".gba", file);
ShowNotification("Done!", "The ROM has been converted and is saved with seed: \"" + seedtext + "\" as \"" + seedtext + ".gba\"");
}
public TType ReadStruct <TType>(uint Address) where TType : struct
{
return(StructUtils.BytesToStruct <TType>(ReadBytes(Address, Marshal.SizeOf(typeof(TType)))));
}
public TType ReadStruct <TType>(uint Address) where TType : struct => StructUtils.BytesToStruct <TType>(ReadBytes(Address, PointerUtils.Sizeof <TType>()));
public void WriteStruct <TType>(uint Address, TType Value) where TType : struct => WriteBytes(Address, StructUtils.StructToBytes(Value));
protected byte[] HandlePacket_GetServerInfo(byte[] RequestContent)
{
return(StructUtils.StructToBytes(ServerManager.ServerInfo));
}
/// <summary>
/// Obtains information about the server:
/// - IndexCount
/// - TotalNumberOfElements
/// - CurrentPrivateMemory
/// - CurrentVirtualMemory
/// - PeakVirtualMemory
/// </summary>
/// <param name="RequestContent">Content of the request.</param>
/// <returns>A ServerManager.ServerInfoStruct as a byte array.</returns>
#if NET_4_5
async protected Task <byte[]> HandlePacketAsync_GetServerInfo(byte[] RequestContent)
{
return(StructUtils.StructToBytes(ServerManager.ServerInfo));
}
public static Stream WriteStruct <T>(this Stream Stream, T Struct) where T : struct
{
byte[] Bytes = StructUtils.StructToBytes(Struct);
Stream.Write(Bytes, 0, Bytes.Length);
return(Stream);
}
protected string handlePacket2(string packet)
{
//string[] parts = std.array.split(";", packet);
char type = packet[0];
if (type != 'm')
{
if (debugMaster)
{
Console.WriteLine("recvData: %s", packet);
}
debugData = true;
}
else
{
debugData = false;
}
switch (type)
{
// A simple reply of "OK" indicates the target will support extended remote debugging.
case '!':
return("OK");
break;
// The detach is acknowledged with a reply packet of "OK" before the client
// connection is closed and rsp.client_fd set to -1. The semantics of detach
// require the target to resume execution, so the processor is unstalled
// using set_stall_state (0).
case 'D':
return("OK");
break;
// This sets the thread number of subsequent operations.
// Since thread numbers are of no relevance to this target,
// a response of "OK" is always acceptable.
case 'H':
return("OK");
break;
// The kill request is used in extended mode before a restart or
// request to run a new program (vRun packet). Since the CPU is
// already stalled, it seems to have no additional semantic meaning.
// Since it requires no reply it can be silently ignored.
case 'k':
return("OK");
break;
// Since this is a bare level target, there is no concept of separate threads.
// The one thread is always active, so a reply of "OK" is always acceptable.
case 'T':
return("OK");
break;
// The response to the ? packet is provided by rsp_report_exception ().
// This is always a S packet. The signal value (as a GDB target signal)
// is held in rsp.sigval, and is presented as two hexadecimal digits.
case '?':
if (running)
{
return(getSigvalPacket());
}
else
{
return("E01");
}
break;
case 'd':
debugFlag = !debugFlag;
return("OK");
break;
// Read all registers
case 'g': {
string o = "";
foreach (var register in registers.ALL)
{
o += hexEncode(StructUtils.StructToBytes(register));
}
return(o);
} break;
// Write all registers
case 'G':
break;
// Read a register
case 'p': {
var regNum = Convert.ToUInt32(packet.Substring(1), 16);
return(hexEncode(StructUtils.StructToBytes(registers.ALL[regNum])));
} break;
// Write a register
case 'P': {
string[] parts = packet.Substring(1).Split('=');
var regNum = Convert.ToUInt32(parts[0], 16);
var value = BitConverter.ToUInt32(hexDecode(parts[1]), 0);
registers.ALL[regNum] = value;
return("OK");
} break;
// http://www.embecosm.com/appnotes/ean4/html/ch04s07s07.html
// Read from memory
case 'm': {
var parts = packet.Substring(1).Split(',');
var addr = Convert.ToUInt32(parts[0], 16);
var size = Convert.ToUInt32(parts[1], 16);
var data = new byte[size];
for (int n = 0; n < data.Length; n++)
{
data[n] = 0xFF;
}
return(hexEncode(data));
} break;
// Write to memory
case 'M':
break;
// The functionality for the R packet is provided in rsp_restart ().
// The start address of the current target is held in rsp.start_addr.
// The program counter is set to this address using set_npc () (see Section 4.6.5).
case 'R':
break;
// Continue
case 'c': {
//scope (exit) lastSigval = Sigval.Ok;
lastSigval = Sigval.DebugException;
return(getSigvalPacket());
/*
* (new Thread({
* Thread.sleep(dur!"msecs"(400));
* lastSigval = Sigval.DebugException;
* sendPacket(getSigvalPacket());
* })).start();
*
* lastSigval = Sigval.DebugException;
* sendPacket(getSigvalPacket());
*
* return "";
*/
//return "";
}
// Step
case 's':
return("T00");
break;
// Extended packets.
case 'v': {
string[] packetParts = packet.Split(';');
switch (packetParts[0])
{
case "vRun": {
var args = new List <string>();
foreach (var argHex in packetParts.Slice(1))
{
args.Add(Encoding.ASCII.GetString(hexDecode(argHex)));
}
Console.WriteLine("%s", args);
try {
return("S00");
} finally {
lastSigval = Sigval.InvalidOpcode;
}
//return getSigvalPacket();
//return "";
} break;
case "vAttach":
break;
case "vCont":
break;
case "vCont?":
return("OK");
break;
case "vFile":
break;
case "vFlashErase":
case "vFlashWrite":
case "vFlashDone":
break;
default:
throw(new Exception(String.Format("Unknown packet '{0}'", packet)));
}
} break;
// Query.
// http://www.manpagez.com/info/gdb/gdb_282.php
case 'q':
{
Func <int, string> getNextThread = (cursor) =>
{
if (threadCursor >= threads.Length)
{
return("l");
}
else
{
return("m%x".Sprintf(threads[threadCursor]));
}
};
switch (packet)
{
case "qfThreadInfo": threadCursor = 0; return(getNextThread(threadCursor++));
case "qsThreadInfo": return(getNextThread(threadCursor++));
case "qC": return("QC%x".Sprintf(threads[0]));
default: throw(new Exception(String.Format("Unknown packet '{0}'", packet)));
}
}
default:
throw(new Exception(String.Format("Unknown packet '{0}'", packet[0])));
}
return("E01");
}
static public int DetectVersion(byte[] MagicData, long FileSize, bool ThrowException = false)
{
var Warnings = new List <String>();
MagicData = MagicData.Take(0x10).ToArray();
if (MagicData.Length < 0x10)
{
if (ThrowException)
{
throw (new Exception("Start to short"));
}
return(-1);
}
// Version type (0, 1, 3, 4)
{
var HeaderStruct = StructUtils.BytesToStruct <TalesCompression1_3.HeaderStruct>(MagicData);
//Console.WriteLine("[1]");
bool Handled = true;
switch (HeaderStruct.Version)
{
#if true
case 0:
if (HeaderStruct.CompressedLength != HeaderStruct.UncompressedLength)
{
Warnings.Add("Compressed/Uncompressed Length must match");
}
if (HeaderStruct.CompressedLength >= 64 * 1024 * 1024)
{
Warnings.Add("Compressed/Uncompressed Length too big");
}
break;
#endif
case 1:
case 3:
case 4:
if (HeaderStruct.CompressedLength >= 64 * 1024 * 1024)
{
Warnings.Add("Compressed Length too big");
}
if (HeaderStruct.UncompressedLength >= 64 * 1024 * 1024)
{
Warnings.Add("Uncompressed Length too big");
}
if (HeaderStruct.CompressedLength > HeaderStruct.UncompressedLength)
{
Warnings.Add("Compressed size is bigger than the uncompressed size");
}
/*
* var DiffSize = Math.Abs((long)HeaderStruct.CompressedLength - FileSize);
* if (DiffSize >= 0x10000)
* {
* Warnings.Add(String.Format("Invalid compressed size {0}", DiffSize));
* }
*/
break;
default:
Handled = false;
break;
}
//Console.WriteLine("[2]");
if (Handled)
{
if (!Warnings.Any())
{
return(HeaderStruct.Version);
}
}
//Console.WriteLine("[3]");
}
//Console.WriteLine("[4]");
// Check other types.
{
if (MagicData.SequenceEqual(TalesCompression15_Lzx.Signature))
{
//Console.WriteLine("[5]");
return(15);
}
}
if (!ThrowException)
{
return(-1);
}
else
{
//Console.WriteLine("[6]");
throw (new NotSupportedException("Version not detected : " + Warnings.Implode(",") + " : " + MagicData.ToHexString()));
//throw (new Exception());
}
}
