public static Patch TryReadPatch(string patchFile, bool activeOnly) { try { UserFeedback.Info("Reading the patch file '{0}'", (object)patchFile); return(Patcher.ReadPatch(patchFile, activeOnly)); } catch (Exception ex) { UserFeedback.Error(ex); return(new Patch() { PatchFilepath = patchFile }); } }
private static int FindComparablePos(byte[] correctExe, byte[] otherExe, int pos) { for (int length = 4; length < 25; length += 4) { byte[] window = new byte[length]; int num1 = 0; if (num1 + pos < 0) { num1 = -pos; } if (num1 + length >= correctExe.Length) { num1 = correctExe.Length - (pos + length); } for (int index = 0; index < length; ++index) { window[index] = correctExe[index + pos + num1]; } int[] array1 = Patcher.FindWindow(otherExe, window).ToArray <int>(); if (array1.Length == 1) { return(array1[0] - num1); } if (array1.Length == 0) { if (length == 8 && num1 == 0) { int num2 = -4; for (int index = 0; index < length; ++index) { window[index] = correctExe[index + pos + num2]; } int[] array2 = Patcher.FindWindow(otherExe, window).ToArray <int>(); if (array2.Length == 1) { return(array2[0] - num2); } } UserFeedback.Warning(string.Format("Found no matches for block {0:X8} {1}", (object)pos, (object)length)); return(-pos); } } UserFeedback.Warning("Found too many matches for block {0:X8}", (object)pos); return(-pos); }
internal static void Close() { try { if (!Application.ExecutablePath.Equals(Console.Title, StringComparison.InvariantCultureIgnoreCase)) { return; } UserFeedback.Info("Press any key to quit"); while (!Console.KeyAvailable) { Thread.Sleep(50); } } catch { } }
public static void PatchResolutions( byte[] exe, int oldWidth, int oldHeight, int newWidth, int newHeight, Patch patch, Dictionary <int, int> dictHeigth = null, Dictionary <int, int> dictWidth = null ) { Dictionary <int, int> dictionary1 = new Dictionary <int, int>(); int[] numArray1 = new int[4] { 800, 1024, 1280, 1600 }; if (dictHeigth == null) { int num1 = newWidth; foreach (int index in numArray1) { if (index == oldWidth) { dictionary1[index] = newWidth; } else if (index > oldWidth) { dictionary1[index] = ++num1; } } } else { dictionary1 = dictHeigth; } Dictionary <int, int> dictionary2 = new Dictionary <int, int>(); int[] numArray2 = new int[4] { 600, 768, 1024, 1200 }; if (dictWidth == null) { int num2 = newHeight; foreach (int index in numArray2) { if (index == oldHeight) { dictionary2[index] = newHeight; } else if (index > oldHeight) { dictionary2[index] = ++num2; } } } else { dictionary2 = dictWidth; } foreach (KeyValuePair <int, int> keyValuePair in dictionary1) { UserFeedback.Trace(string.Format("Horizontal {0} => {1}", (object)keyValuePair.Key, (object)keyValuePair.Value)); } foreach (KeyValuePair <int, int> keyValuePair in dictionary2) { UserFeedback.Trace(string.Format("Vertical {0} => {1}", (object)keyValuePair.Key, (object)keyValuePair.Value)); } foreach (Item obj in patch.Items) { if (obj.Pos >= exe.Length) { UserFeedback.Warning("Error in input: Invalid location {0:X8}. [NOT PATCHED]", (object)obj.Pos); } else { int referenceValue = obj.ReferenceValue; bool flag1 = obj.Type.Contains("H"); bool flag2 = obj.Type.Contains("V"); if (flag1 & flag2) { if (oldWidth == referenceValue) { flag2 = false; } else { flag1 = false; } } Trace.Assert(flag1 | flag2); int num3; if (!(flag2 ? dictionary2 : dictionary1).TryGetValue(referenceValue, out num3)) { num3 = referenceValue; } if (obj.Type.Contains("H") && obj.Type.Contains("V")) { UserFeedback.Trace(string.Format("{0} HV: Mapping to {1}", (object)referenceValue, (object)num3)); } int num4 = (int)exe[obj.Pos] | (int)exe[obj.Pos + 1] << 8 | (int)exe[obj.Pos + 2] << 16 | (int)exe[obj.Pos + 3] << 24; if (obj.Type.Equals("dV") || obj.Type.Equals("dH")) { int parameter = obj.Parameter; if (parameter == 0) { UserFeedback.Warning(string.Format("{0} action is safer if you mention the expected orgValue. Encountered {1} @ {2:X8}", (object)obj.Type, (object)num4, (object)obj.Pos)); } else if (parameter != num4) { UserFeedback.Warning(string.Format("{0} action expected value mismatch: {1} expected, {2} encountered @ {3:X8} [NOT PATCHED]", (object)obj.Type, (object)parameter, (object)num4, (object)obj.Pos)); continue; } int num5 = num3 - referenceValue; num3 = num4 + num5; } else if (num4 != referenceValue) { UserFeedback.Warning(string.Format("{0} action expected value mismatch: {1} expected, {2} encountered @ {3:X8} [NOT PATCHED]", (object)obj.Type, (object)referenceValue, (object)num4, (object)obj.Pos)); continue; } byte num6 = (byte)(num3 & (int)byte.MaxValue); byte num7 = (byte)(num3 >> 8 & (int)byte.MaxValue); byte num8 = (byte)(num3 >> 16 & (int)byte.MaxValue); byte num9 = (byte)(num3 >> 24 & (int)byte.MaxValue); exe[obj.Pos] = num6; exe[obj.Pos + 1] = num7; exe[obj.Pos + 2] = num8; exe[obj.Pos + 3] = num9; } } }
public static void Warning(string msg, object param1) { UserFeedback.Warning(string.Format(msg, param1)); }
public static void Trace(string msg, object param1) { UserFeedback.Trace(string.Format(msg, param1)); }
public static void Info(string msg, object param1) { UserFeedback.Info(string.Format(msg, param1)); }
public static byte[] UpdateGuiTable( byte[] data, uint id, int oldWidth, int oldHeight, int newWidth, int newHeight) { int index1; int index2; int index3; int index4; switch (oldWidth) { case 800: index1 = 1; index2 = 2; index3 = 3; index4 = 4; break; case 1024: index1 = 5; index2 = 6; index3 = 7; index4 = 8; break; case 1280: index1 = 9; index2 = 10; index3 = 11; index4 = 12; break; default: return(data); } int num1 = newHeight - oldHeight; int num2 = newWidth - oldWidth; if (data.Length < 10) { return(data); } try { string str = Encoding.ASCII.GetString(data, 0, 10); if (str == null || !str.Equals("Item Name\t")) { return(data); } } catch { return(data); } try { string[][] array = ((IEnumerable <string>)Encoding.ASCII.GetString(data).Split(new char[2] { '\r', '\n' }, StringSplitOptions.RemoveEmptyEntries)).Select <string, string[]>((Func <string, string[]>)(line => line.Split('\t'))).ToArray <string[]>(); foreach (string[] strArray in array) { if (strArray.Length >= 13 && !string.IsNullOrEmpty(strArray[0]) && !string.IsNullOrEmpty(strArray[12])) { int num3 = int.Parse(strArray[index1]); int num4 = int.Parse(strArray[index2]); int num5 = int.Parse(strArray[index3]); int num6 = int.Parse(strArray[index4]); if (num4 < oldHeight / 2 && num4 + num6 > oldHeight / 2) { num6 += num1; } else if (num4 > oldHeight / 2) { num4 += num1; } if (num5 == oldWidth) { num5 = newWidth; } strArray[index1] = num3.ToString(); strArray[index2] = num4.ToString(); strArray[index3] = num5.ToString(); strArray[index4] = num6.ToString(); } } byte[] bytes = Encoding.ASCII.GetBytes(((IEnumerable <string[]>)array).Select <string[], string>((Func <string[], string>)(tableRow => ((IEnumerable <string>)tableRow).Aggregate <string>((Func <string, string, string>)((output, col) => output + "\t" + col)))).Aggregate <string>((Func <string, string, string>)((output, line) => output + "\r\n" + line))); UserFeedback.Info("Patched Gui Table #{0}", (object)id); return(bytes); } catch (Exception ex) { UserFeedback.Warning("Failed to patch Gui Table #{0}; leaving it unchanged.", (object)id); UserFeedback.Error(ex); return(data); } }
public static byte[] Enlarge(uint id, byte[] data, int oldWidth, int oldHeight, int newWidth, int newHeight) { var reader = new BinaryReader(new MemoryStream(data, false)); var duplicated = new byte[newWidth]; var version = reader.ReadUInt32(); if (version != 0x4e302e32) { return(data); } var framecount = reader.ReadUInt32(); if (framecount != 1) { return(data); } if (oldWidth == newWidth) { return(data); } var comment = reader.ReadBytes(24); var linesOffset = reader.ReadUInt32(); var maskOffset = reader.ReadUInt32(); var paletteOffset = reader.ReadUInt32(); var properties = reader.ReadUInt32(); var width = reader.ReadInt32(); if (width != oldWidth) { return(data); } var height = reader.ReadInt32(); var centerX = reader.ReadInt32(); var centerY = reader.ReadInt32(); if (height - centerY != oldHeight)//!= { return(data); } if (centerY != 0) { int higher = newHeight - oldHeight; centerY -= higher; newHeight = oldHeight = height; } var newMaskSize = (uint)(newHeight * 4); var newLinesOffset = maskOffset + newMaskSize; var newLinesSize = (uint)(newHeight * 4); var newLineDataStart = newLinesOffset + newLinesSize; var outStream = new MemoryStream(); var writer = new BinaryWriter(outStream); try { UserFeedback.Info(string.Format("Resizing image #{0} for {1}x{2} to {3}x{4}", id, oldWidth, oldHeight, newWidth, newHeight)); writer.Write(version); writer.Write(framecount); writer.Write(comment); writer.Write(newLinesOffset); writer.Write(maskOffset); writer.Write(paletteOffset); writer.Write(properties); writer.Write(newWidth); writer.Write(newHeight); writer.Write(centerX); writer.Write(centerY); var osp = outStream.Position; Trace.Assert(osp == maskOffset); var orgLineMasks = new UInt32[oldHeight]; for (var inLine = 0; inLine < oldHeight; inLine++) { orgLineMasks[inLine] = reader.ReadUInt32(); } var orgLineStarts = new UInt32[oldHeight + 1]; for (var inLine = 0; inLine < oldHeight; inLine++) { orgLineStarts[inLine] = reader.ReadUInt32(); } orgLineStarts[oldHeight] = (uint)data.Length; var orgLines = new List <byte[]>(oldHeight); for (var inLine = 0; inLine < oldHeight; inLine++) { var orgLineSize = orgLineStarts[inLine + 1] - orgLineStarts[inLine]; orgLines.Add(reader.ReadBytes((int)orgLineSize)); } var newLineMasks = new UInt32[newHeight]; var newLines = new List <byte[]>(newHeight); var extraLines = newHeight - oldHeight; var shrinking = extraLines < 0; var expanding = extraLines > 0; var centreLine = oldHeight / 2; var shrinkSkipStart = centreLine + extraLines; var shrinkSkipEnd = centreLine; // duplication is the amount of times every duplicated line, is duplicated var duplication = 1 + (extraLines + 1) / (oldHeight / 2); // the duplication block size is the block that is being duplicated // the last line of which MIGHT not be duplicated 'duplication' times // eg if duplication is 2, extralines = 501, dbs = 251, the last of which is // duped just once. var duplicationBlockSize = (extraLines + duplication - 1) / duplication; var dupStart = centreLine - duplicationBlockSize / 2; var dupEnd = dupStart + duplicationBlockSize; var newlineold = new byte[newWidth]; var dupedLines = 0; //'UNIT'TEST for (var inLine = 0; inLine < oldHeight; inLine++) { // If shrinking skip 'extralines' lines on the centerline and above if (shrinking && inLine >= shrinkSkipStart && inLine < shrinkSkipEnd) { dupedLines--; continue; } newLineMasks[newLines.Count] = orgLineMasks[inLine]; var newLine = StretchLine(orgLines[inLine], oldWidth, newWidth); newLineMasks[newLines.Count] = orgLineMasks[inLine]; newLines.Add(newLine); // If expanding, duplicate the right amount of lines before centreLine if (!expanding || inLine < dupStart || inLine >= dupEnd) { continue; } for (var rep = 0; rep < duplication && dupedLines < extraLines; rep++) { newLines.Add(newLine); dupedLines++; } } Trace.Assert(newLines.Count == newHeight); Trace.Assert(dupedLines == extraLines); var nextLineStart = newLineDataStart; foreach (var newLineMask in newLineMasks) { writer.Write(newLineMask); } osp = outStream.Position; Trace.Assert(newLinesOffset == osp); foreach (var newLine in newLines) { writer.Write(nextLineStart); nextLineStart += (uint)newLine.Length; } osp = outStream.Position; Trace.Assert(newLineDataStart == osp); foreach (var newLine in newLines) { writer.Write(newLine); } Trace.Assert(outStream.Position == nextLineStart); writer.Close(); } catch (Exception ex) { } var newSlp = outStream.ToArray(); //outStream.ToArray(); //2077858 mirror return(newSlp); }