private void WriteByteDataToTestFiles() { _entryData = _dataHelper.LoadDefaultEntryData(); System.IO.File.WriteAllBytes("EntryData/TestBattle.bin", _dataHelper.ConditionalSetsToByteArray(CommandType.BattleConditional, _entryData.BattleConditionals)); System.IO.File.WriteAllBytes("EntryData/TestWorld.bin", _dataHelper.ConditionalSetsToByteArray(CommandType.WorldConditional, _entryData.WorldConditionals)); System.IO.File.WriteAllBytes("EntryData/TestEvents.bin", _dataHelper.EventsToByteArray(_entryData.Events)); }
private void menuItem_UseTrimmedDefaults_Click(object sender, EventArgs e) { menuItem_UseTrimmedDefaults.Checked = !menuItem_UseTrimmedDefaults.Checked; SaveFormData(); _entryDataDefault = menuItem_UseTrimmedDefaults.Checked ? _dataHelper.LoadTrimmedEntryData() : _dataHelper.LoadDefaultEntryData(); PopulateTabs(); }
private void SetDefaults() { menuItem_UseTrimmedDefaults.Checked = false; SaveFormData(); _entryDataDefault = _entryData.Copy(); PopulateTabs(); }
private void RestoreDefaults() { menuItem_UseTrimmedDefaults.Checked = false; SaveFormData(); _entryDataDefault = _dataHelper.LoadDefaultEntryData(); PopulateTabs(); }
public static void PatchISO(EntryData entryData, string filepath, Context context, DataHelper dataHelper = null) { if (!string.IsNullOrEmpty(filepath)) { List <PatchedByteArray> patches = GetISOPatches(entryData, context, dataHelper); using (Stream file = File.Open(filepath, FileMode.Open, FileAccess.ReadWrite, FileShare.Read)) { PsxIso.PatchPsxIso(file, patches); } } }
private void WriteLoadedDataToTestFiles() { _entryData = _dataHelper.LoadDefaultEntryData(); _dataHelper.SaveAllConditionalSetScripts(_entryData.BattleConditionals, "./EntryData/scripts/battle/1"); _dataHelper.SaveAllConditionalSetScripts(_entryData.WorldConditionals, "./EntryData/scripts/world/1"); _dataHelper.SaveAllEventScripts(_entryData.Events, "./EntryData/scripts/event/1"); List <ConditionalSet> battleConditionals = _dataHelper.LoadAllConditionalSetScripts(CommandType.BattleConditional, "./EntryData/scripts/battle/1"); List <ConditionalSet> worldConditionals = _dataHelper.LoadAllConditionalSetScripts(CommandType.WorldConditional, "./EntryData/scripts/world/1"); List <Event> events = _dataHelper.LoadAllEventScripts(_entryData.Events, "./EntryData/scripts/event/1"); System.IO.File.WriteAllBytes("EntryData/TestBattle.bin", _dataHelper.ConditionalSetsToByteArray(CommandType.BattleConditional, battleConditionals)); System.IO.File.WriteAllBytes("EntryData/TestWorld.bin", _dataHelper.ConditionalSetsToByteArray(CommandType.WorldConditional, worldConditionals)); System.IO.File.WriteAllBytes("EntryData/TestEvents.bin", _dataHelper.EventsToByteArray(events)); }
private void LoadPatch(string filepath) { byte[] bytesBattleConditionals, bytesWorldConditionals, bytesEvents; EntryBytes defaultEntryBytes = _dataHelper.LoadDefaultEntryBytes(); using (ICSharpCode.SharpZipLib.Zip.ZipFile file = new ICSharpCode.SharpZipLib.Zip.ZipFile(filepath)) { bytesBattleConditionals = PatcherLib.Utilities.Utilities.GetZipEntry(file, DataHelper.EntryNameBattleConditionals, false) ?? defaultEntryBytes.BattleConditionals; bytesWorldConditionals = PatcherLib.Utilities.Utilities.GetZipEntry(file, DataHelper.EntryNameWorldConditionals, false) ?? defaultEntryBytes.WorldConditionals; bytesEvents = PatcherLib.Utilities.Utilities.GetZipEntry(file, DataHelper.EntryNameEvents, false) ?? defaultEntryBytes.Events; } _entryDataDefault = _dataHelper.LoadEntryDataFromBytes(defaultEntryBytes); _entryData = _dataHelper.LoadEntryDataFromBytes(bytesBattleConditionals, bytesWorldConditionals, bytesEvents); PopulateTabs(); }
private void menuItem_LoadISO_Click(object sender, EventArgs e) { EntryData inputEntryData = _entryData ?? new EntryData(null, null, null); if (ISOForm.InitDialog(_dataHelper, inputEntryData, ISOForm.Mode.Load, _context) == DialogResult.OK) { _entryDataDefault = _entryDataDefault ?? _dataHelper.LoadDefaultEntryData(); _entryData = _entryData ?? inputEntryData; _entryData.BattleConditionals = inputEntryData.BattleConditionals ?? _entryData.BattleConditionals ?? CopyableEntry.CopyList <ConditionalSet>(_entryDataDefault.BattleConditionals); _entryData.WorldConditionals = inputEntryData.WorldConditionals ?? _entryData.WorldConditionals ?? CopyableEntry.CopyList <ConditionalSet>(_entryDataDefault.WorldConditionals); _entryData.Events = inputEntryData.Events ?? _entryData.Events ?? CopyableEntry.CopyList <Event>(_entryDataDefault.Events); PopulateTabs(); EnableMenu(); tabControl.Enabled = true; } }
private static bool HandleCommandLinePatch(string[] args) { System.Collections.Generic.KeyValuePair <string, string> patchFilepaths = PatcherLib.Utilities.Utilities.GetPatchFilepaths(args, ".eepatch"); if ((string.IsNullOrEmpty(patchFilepaths.Key)) || (string.IsNullOrEmpty(patchFilepaths.Value))) { return(false); } else { System.IO.Directory.SetCurrentDirectory(System.IO.Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location)); //while (!System.Diagnostics.Debugger.IsAttached) System.Threading.Thread.Sleep(100); try { Context context = Context.US_PSX; DataHelper dataHelper = new DataHelper(context); EntryData patchData = PatchHelper.GetEntryDataFromPatchFile(patchFilepaths.Key, dataHelper); if (patchFilepaths.Value.ToLower().Trim().EndsWith(".psv")) { PatchHelper.PatchPsxSaveState(patchData, patchFilepaths.Value, dataHelper); } else { PatchHelper.PatchISO(patchData, patchFilepaths.Value, context, dataHelper); } } catch (Exception ex) { AttachConsole(ATTACH_PARENT_PROCESS); Console.WriteLine("Error: " + ex.Message); } return(true); } }
public static List <PatchedByteArray> GetISOPatches(EntryData entryData, Context context, DataHelper dataHelper = null) { dataHelper = dataHelper ?? new DataHelper(context); List <PatchedByteArray> patches = new List <PatchedByteArray>(); SettingsData settings = Settings.GetSettings(context); Enum battleSector = settings.BattleConditionalsSector; int battleOffset = settings.BattleConditionalsOffset; byte[] battleBytes = dataHelper.ConditionalSetsToByteArray(CommandType.BattleConditional, entryData.BattleConditionals); patches.Add(new PatchedByteArray(battleSector, battleOffset, battleBytes)); if ((settings.BattleConditionalsApplyLimitPatch) && (DataHelper.GetMaxBlocks(entryData.BattleConditionals) > 10)) { patches.Add(new PatchedByteArray(settings.BattleConditionalsLimitPatchSector, settings.BattleConditionalsLimitPatchOffset, settings.BattleConditionalsLimitPatchBytes)); } Enum worldSector = settings.WorldConditionalsSector; int worldOffset = settings.WorldConditionalsOffset; byte[] worldBytes = dataHelper.ConditionalSetsToByteArray(CommandType.WorldConditional, entryData.WorldConditionals); patches.Add(new PatchedByteArray(worldSector, worldOffset, worldBytes)); if (settings.WorldConditionalsRepoint) { byte[] patchBytes = (((uint)(ISOHelper.GetRamOffsetUnsigned(worldSector, context, true) + worldOffset))).ToBytes(); patches.Add(new PatchedByteArray(settings.WorldConditionalsPointerSector, settings.WorldConditionalsPointerOffset, patchBytes)); } Enum eventSector = settings.EventsSector; int eventOffset = settings.EventsOffset; byte[] eventBytes = dataHelper.EventsToByteArray(entryData.Events); patches.Add(new PatchedByteArray(eventSector, eventOffset, eventBytes)); return(patches); }
private void LoadPatch(string filepath) { byte[] bytesBattleConditionals, bytesWorldConditionals, bytesEvents; EntryBytes defaultEntryBytes = _dataHelper.LoadDefaultEntryBytes(); try { using (ICSharpCode.SharpZipLib.Zip.ZipFile file = new ICSharpCode.SharpZipLib.Zip.ZipFile(filepath)) { bytesBattleConditionals = PatcherLib.Utilities.Utilities.GetZipEntry(file, DataHelper.EntryNameBattleConditionals, false) ?? defaultEntryBytes.BattleConditionals; bytesWorldConditionals = PatcherLib.Utilities.Utilities.GetZipEntry(file, DataHelper.EntryNameWorldConditionals, false) ?? defaultEntryBytes.WorldConditionals; bytesEvents = PatcherLib.Utilities.Utilities.GetZipEntry(file, DataHelper.EntryNameEvents, false) ?? defaultEntryBytes.Events; } _entryDataDefault = _dataHelper.LoadEntryDataFromBytes(defaultEntryBytes); _entryData = _dataHelper.LoadEntryDataFromBytes(bytesBattleConditionals, bytesWorldConditionals, bytesEvents); PopulateTabs(); } catch (Exception ex) { PatcherLib.MyMessageBox.Show(this, ex.Message, "Error", MessageBoxButtons.OK); } }
private void LoadNewPatch() { _entryData = _dataHelper.LoadDefaultEntryData(); _entryDataDefault = _entryData.Copy(); PopulateTabs(); }
private void RestoreDefaults() { SaveFormData(); _entryDataDefault = _dataHelper.LoadDefaultEntryData(); PopulateTabs(); }
private void SetDefaults() { SaveFormData(); _entryDataDefault = _entryData.Copy(); PopulateTabs(); }
public static void SavePatchXML(EntryData entryData, string filepath, Context context, DataHelper dataHelper = null) { File.WriteAllText(filepath, CreatePatchXML(entryData, context, dataHelper), System.Text.Encoding.UTF8); }
public static string CreatePatchXML(EntryData entryData, Context context, DataHelper dataHelper = null) { return(PatcherLib.Utilities.Utilities.CreatePatchXML(GetISOPatches(entryData, context, dataHelper), Context.US_PSX, true, true, "EntryEdit Edits")); }
public static void PatchPsxSaveState(EntryData entryData, string filepath, DataHelper dataHelper) { SettingsData settings = Settings.PSX; Dictionary <uint, byte[]> ramPatches = new Dictionary <uint, byte[]>(); bool isBattleLoaded = false; bool isWorldLoaded = false; bool saveBattleConditionals = false; bool saveWorldConditionals = false; bool saveEvent = false; byte[] worldConditionalsBytes = null; int battleConditionalsIndex = 0; int eventID = 0; int worldConditionalsRamLocation = 0; if (!string.IsNullOrEmpty(filepath)) { using (BinaryReader reader = new BinaryReader(File.Open(filepath, FileMode.Open))) { Stream stream = reader.BaseStream; if (PsxIso.IsSectorInPsxSaveState(stream, PsxIso.Sectors.BATTLE_BIN)) { isBattleLoaded = true; saveBattleConditionals = (PsxIso.LoadFromPsxSaveState(reader, (uint)settings.BattleConditionalBlockOffsetsRAMLocation, 4).ToIntLE() != 0); saveEvent = (PsxIso.LoadFromPsxSaveState(reader, (uint)settings.EventRAMLocation, 1).ToIntLE() != 0); eventID = PsxIso.LoadFromPsxSaveState(reader, (uint)settings.EventIDRAMLocation, 2).ToIntLE(); if (!((eventID >= 0) && (eventID < entryData.Events.Count))) { saveEvent = false; } if (PsxIso.IsSectorInPsxSaveState(stream, (PsxIso.Sectors)settings.ScenariosSector)) { battleConditionalsIndex = PsxIso.LoadFromPsxSaveState(reader, (uint)(settings.ScenariosRAMLocation + (eventID * 24) + 22), 2).ToIntLE(); } else { saveBattleConditionals = false; } } else if (PsxIso.IsSectorInPsxSaveState(stream, PsxIso.Sectors.WORLD_WLDCORE_BIN)) { isWorldLoaded = true; worldConditionalsRamLocation = settings.WorldConditionalsRepoint ? PsxIso.LoadFromPsxSaveState(reader, (uint)settings.WorldConditionalsWorkingPointerRAMLocation, 3).ToIntLE() : settings.WorldConditionalsCalcRAMLocation; worldConditionalsBytes = dataHelper.ConditionalSetsToByteArray(CommandType.WorldConditional, entryData.WorldConditionals); if (worldConditionalsBytes.Length > settings.WorldConditionalsSize) { saveWorldConditionals = false; } } } using (BinaryReader reader = new BinaryReader(File.Open(filepath, FileMode.Open))) { if (isBattleLoaded) { if (saveBattleConditionals) { int setIndex = battleConditionalsIndex; if (setIndex >= 0) { uint blockRamOffset = (uint)settings.BattleConditionalBlockOffsetsRAMLocation; uint commandRamOffset = (uint)settings.BattleConditionalsRAMLocation; List <byte[]> byteArrays = dataHelper.ConditionalSetToActiveByteArrays(CommandType.BattleConditional, entryData.BattleConditionals[setIndex]); ramPatches.Add(blockRamOffset, byteArrays[0]); ramPatches.Add(commandRamOffset, byteArrays[1]); if (settings.BattleConditionalsApplyLimitPatch) { int numBlocks = entryData.BattleConditionals[setIndex].ConditionalBlocks.Count; if (numBlocks > 10) { ramPatches.Add((uint)settings.BattleConditionalsLimitPatchRAMLocation, settings.BattleConditionalsLimitPatchBytes); } } } } if (saveEvent) { int eventIndex = eventID; if (eventIndex >= 0) { uint eventRamOffset = (uint)settings.EventRAMLocation; byte[] eventBytes = dataHelper.EventToByteArray(entryData.Events[eventIndex], true); ramPatches.Add(eventRamOffset, eventBytes); uint eventRamOffsetKSeg0 = eventRamOffset | PsxIso.KSeg0Mask; uint textOffset = eventBytes.SubLength(0, 4).ToUInt32(); if (textOffset != DataHelper.BlankTextOffsetValue) { ramPatches.Add((uint)settings.TextOffsetRAMLocation, (eventRamOffsetKSeg0 + textOffset).ToBytes().ToArray()); } } } } else if (isWorldLoaded) { if (saveWorldConditionals) { uint ramOffset = (uint)worldConditionalsRamLocation; ramPatches.Add(ramOffset, worldConditionalsBytes); uint ramOffsetKSeg0 = ramOffset | PsxIso.KSeg0Mask; if ((settings.WorldConditionalsRepoint) && (ramOffsetKSeg0 != PsxIso.LoadFromPsxSaveState(reader, (uint)settings.WorldConditionalsPointerRAMLocation, 4).ToUInt32())) { ramPatches.Add((uint)settings.WorldConditionalsPointerRAMLocation, ramOffsetKSeg0.ToBytes().ToArray()); ramPatches.Add((uint)settings.WorldConditionalsWorkingPointerRAMLocation, ramOffsetKSeg0.ToBytes().ToArray()); } } } PsxIso.PatchPsxSaveState(reader, ramPatches); } } }