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()); } }