public static void Apply(Stream input, Func <Stream> openPatchStream, Stream output)
{
using var deltaStream = openPatchStream();
var deltaApplier = new DeltaApplier();
deltaApplier.Apply(input, new BinaryDeltaReader(deltaStream, reporter), output);
}
public static void ApplyDelta(string filePath, string signaturePath, string deltaPath)
{
var deltaApplier = new DeltaApplier {
SkipHashCheck = false
};
using (var basisStream = new FileStream(signaturePath, FileMode.Open, FileAccess.Read, FileShare.Read))
using (var deltaStream = new FileStream(deltaPath, FileMode.Open, FileAccess.Read, FileShare.Read))
using (var newFileStream = new FileStream(filePath, FileMode.Create, FileAccess.ReadWrite, FileShare.Read))
{
deltaApplier.Apply(basisStream, new BinaryDeltaReader(deltaStream, new ConsoleProgressReporter()), newFileStream);
}
}
public static void CreateNewFileFromDelta(string newFilePath, string oldFilePath, string deltaFilePath)
{
var deltaApplier = new DeltaApplier {
SkipHashCheck = false
};
using (var basisStream = new FileStream(oldFilePath, FileMode.Open, FileAccess.Read, FileShare.Read))
using (var deltaStream = new FileStream(deltaFilePath, FileMode.Open, FileAccess.Read, FileShare.Read))
using (var newFileStream = new FileStream(newFilePath, FileMode.Create, FileAccess.ReadWrite, FileShare.Read))
{
deltaApplier.Apply(basisStream, new BinaryDeltaReader(deltaStream, new ProgReport()), newFileStream);
}
}
public int Execute(string[] commandLineArguments)
{
options.Parse(commandLineArguments);
if (StringOperators.IsNullOrWhiteSpace(basisFilePath))
{
throw new OptionException("No basis file was specified", "basis-file");
}
if (StringOperators.IsNullOrWhiteSpace(deltaFilePath))
{
throw new OptionException("No delta file was specified", "delta-file");
}
if (StringOperators.IsNullOrWhiteSpace(newFilePath))
{
throw new OptionException("No new file was specified", "new-file");
}
basisFilePath = Path.GetFullPath(basisFilePath);
deltaFilePath = Path.GetFullPath(deltaFilePath);
newFilePath = Path.GetFullPath(newFilePath);
if (!File.Exists(basisFilePath))
{
throw new FileNotFoundException("File not found: " + basisFilePath, basisFilePath);
}
if (!File.Exists(deltaFilePath))
{
throw new FileNotFoundException("File not found: " + deltaFilePath, deltaFilePath);
}
var directory = Path.GetDirectoryName(newFilePath);
if (directory != null && !Directory.Exists(directory))
{
Directory.CreateDirectory(directory);
}
var delta = new DeltaApplier
{
SkipHashCheck = skipHashCheck
};
using (var basisStream = new FileStream(basisFilePath, FileMode.Open, FileAccess.Read, FileShare.Read))
using (var deltaStream = new FileStream(deltaFilePath, FileMode.Open, FileAccess.Read, FileShare.Read))
using (var newFileStream = new FileStream(newFilePath, FileMode.Create, FileAccess.ReadWrite, FileShare.Read))
{
delta.Apply(basisStream, new BinaryDeltaReader(deltaStream, progressReporter), newFileStream);
}
return(0);
}
private void button2_Click(object sender, EventArgs e)
{
try
{
// Apply delta file to create new file
var patcherPath = System.AppDomain.CurrentDomain.BaseDirectory;
var exePath = Path.GetDirectoryName(textBox1.Text); // get the folder of Roguelands.exe
var assemblyDirectory = Path.Combine(exePath, @"Roguelands_Data\Managed");
if (!Directory.Exists(assemblyDirectory))
{
textBox2.AppendText("Unable to find directory: " + assemblyDirectory);
return;
}
var assemblyPath = Path.Combine(assemblyDirectory, "Assembly-CSharp.dll");
if (!File.Exists(assemblyPath))
{
textBox2.AppendText("Unable to find file: " + assemblyPath);
return;
}
var cleanPath = Path.Combine(assemblyDirectory, "Original_Assembly-CSharp.dll");
if (File.Exists(cleanPath))
{
textBox2.AppendText("Warning: Original_Assembly-CSharp.dll already exists. This indicates the assembly may have already been patched. A new Original_Assembly-CSharp.dll will not be created, and the Assembly-CSharp.dll will be replaced with a patched version of the Original_Assembly-CSharp.dll\r\n");
}
else
{
File.Copy(assemblyPath, cleanPath, true);
}
var deltaApplier = new DeltaApplier {
SkipHashCheck = false
};
using (var basisStream = new FileStream(cleanPath, FileMode.Open, FileAccess.Read, FileShare.Read))
using (var deltaStream = new FileStream(Path.Combine(patcherPath, "patch"), FileMode.Open, FileAccess.Read, FileShare.Read))
using (var newFileStream = new FileStream(assemblyPath, FileMode.Create, FileAccess.ReadWrite, FileShare.Read))
{
deltaApplier.Apply(basisStream, new BinaryDeltaReader(deltaStream, new ConsoleProgressReporter()), newFileStream);
textBox2.AppendText("Successfully patched.\r\n");
}
}
catch (Exception err)
{
textBox2.AppendText(err.Message + "\r\n");
}
//"octodiff patch vanillaFile modDelta.octodelta newFile --progress"
}
public UpdateManager(Uri updateUri, string updateDirectory = null, ILogger log = null)
{
UpdateUri = updateUri;
Logger = log ?? NullLogger.Instance;
updateDirectory = updateDirectory ?? Path.Combine(BaseDirectory, "update");
DownloadDirectory = Path.Combine(updateDirectory, "download");
PatchDirectory = Path.Combine(updateDirectory, "patch");
CurrentPlatform = GetPlatform();
UpdaterFilePath = Path.Combine(updateDirectory, GetPlatformUpdaterFileName(CurrentPlatform));
CurrentVersion = Assembly.GetEntryAssembly().GetName().Version;
State = (CurrentPlatform == Platform.unknown) ? UpdateState.UnknownPlatform : UpdateState.NoUpdateAvailable;
DeltaApplier = new DeltaApplier
{
SkipHashCheck = true
};
}
public static void DoDeltaUpdate()
{
var test = File.ReadAllBytes(
$@"C:\Users\Peter\Desktop\Octodiff test\TestProject\UserClient\Game\SwaggerGame.txt");
var deltaApplier = new DeltaApplier {
SkipHashCheck = false
};
using (var basisStream = new MemoryStream(test))
using (var newFileStream = new MemoryStream())
using (var deltaStream = new MemoryStream(Server.Program.GetDeltaFile()))
using (FileStream fs = new FileStream($@"C:\Users\Peter\Desktop\Octodiff test\TestProject\UserClient\Game\SwaggerGame.txt", FileMode.OpenOrCreate, FileAccess.Write, FileShare.Read))
{
deltaApplier.Apply(basisStream, new BinaryDeltaReader(deltaStream, new ConsoleProgressReporter()), newFileStream);
newFileStream.WriteTo(fs);
}
}
public Byte[] Patch(Byte[] content, Byte[] delta)
{
Byte[] result = null;
var deltaApplier = new DeltaApplier();
using (var contentStream = new MemoryStream(content))
using (var deltaStream = new MemoryStream(delta))
using (var resultStream = new MemoryStream())
{
deltaApplier.Apply(contentStream, new BinaryDeltaReader(deltaStream, null), resultStream);
resultStream.Position = 0;
result = resultStream.ToArray();
}
return(result);
}
private async Task <Stream> AttemptDeltaDownload(string packageId, string version, FileStream basisStream)
{
try
{
var builder = new SignatureBuilder();
using (var signatureStream = new MemoryStream())
{
builder.Build(basisStream, new SignatureWriter(signatureStream));
signatureStream.Seek(0, SeekOrigin.Begin);
basisStream.Seek(0, SeekOrigin.Begin);
using (var delta = await _client.FeedClientWrapper.Create <Stream>(
UrlTemplate.Resolve(_feedRootUri + "/packages/{packageId}/{version}/download-delta", new { packageId, version }),
signatureStream,
"delta",
new Dictionary <string, string>()
))
{
var tempFile = Path.GetTempFileName();
Stream fs = null;
try
{
var deltaApplier = new DeltaApplier {
SkipHashCheck = false
};
fs = new TemporaryFileStream(tempFile, File.Open(tempFile, FileMode.OpenOrCreate, FileAccess.ReadWrite));
deltaApplier.Apply(basisStream, new BinaryDeltaReader(delta, new NullProgressReporter()), fs);
return(fs);
}
catch
{
fs?.Dispose();
throw;
}
}
}
}
catch (Exception ex)
{
_client.Log.Info("Failed delta download: " + ex.Message);
return(null);
}
}
public static void DeltaUploadFile(string fileName, byte[] deltaBytes)
{
Console.WriteLine("new file to upload");
Console.WriteLine($"DeltaStream Length: {deltaBytes.Length}");
var signatureBaseFilePath = File.ReadAllBytes(
$@"C:\Users\Peter\Desktop\Octodiff test\Octodiff\Octodiff-test\Game\{fileName}");
var deltaApplier = new DeltaApplier {
SkipHashCheck = false
};
using (var basisStream = new MemoryStream(signatureBaseFilePath))
using (var newFileStream = new MemoryStream())
using (var deltaStream = new MemoryStream(deltaBytes))
using (FileStream fs = new FileStream($@"C:\Users\Peter\Desktop\Octodiff test\Octodiff\Octodiff-test\Game\{fileName}", FileMode.Create, FileAccess.Write, FileShare.Read))
{
deltaApplier.Apply(basisStream, new BinaryDeltaReader(deltaStream, new ConsoleProgressReporter()), newFileStream);
newFileStream.WriteTo(fs);
}
}
public async Task PatchingAsyncXXHash_ForOctodiffSignature_PatchesFile(int baseNumberOfBytes, int newDataNumberOfBytes, short chunkSize)
{
// Arrange
var(baseDataStream, baseSignatureStream, newData, newDataStream) = PrepareTestDataWithOctodiffSignature(baseNumberOfBytes, newDataNumberOfBytes, chunkSize);
var progressReporter = Substitute.For <IProgress <ProgressReport> >();
// Act
var deltaStream = new MemoryStream();
var deltaBuilder = new DeltaBuilder();
await deltaBuilder.BuildDeltaAsync(newDataStream, new SignatureReader(baseSignatureStream, null), new AggregateCopyOperationsDecorator(new BinaryDeltaWriter(deltaStream))).ConfigureAwait(false);
deltaStream.Seek(0, SeekOrigin.Begin);
var patchedDataStream = new MemoryStream();
var deltaApplier = new DeltaApplier();
await deltaApplier.ApplyAsync(baseDataStream, new BinaryDeltaReader(deltaStream, progressReporter), patchedDataStream).ConfigureAwait(false);
// Assert
CollectionAssert.AreEqual(newData, patchedDataStream.ToArray());
progressReporter.Received().Report(Arg.Any <ProgressReport>());
}
public void PatchingSyncXXHash_BigFile(string originalFileName, string newFileName)
{
try
{
// Arrange
var(baseDataStream, baseSignatureStream) = PrepareTestData(originalFileName);
var progressReporter = Substitute.For <IProgress <ProgressReport> >();
var deltaFileName = Path.GetTempFileName();
var patchedFileName = Path.GetTempFileName();
// Act
using (var deltaStream = new FileStream(deltaFileName, FileMode.OpenOrCreate))
using (var patchedDataStream = new FileStream(patchedFileName, FileMode.OpenOrCreate))
using (var newDataStream = new FileStream(newFileName, FileMode.Open))
{
var deltaBuilder = new DeltaBuilder();
deltaBuilder.BuildDelta(newDataStream, new SignatureReader(baseSignatureStream, null),
new AggregateCopyOperationsDecorator(new BinaryDeltaWriter(deltaStream)));
deltaStream.Seek(0, SeekOrigin.Begin);
var deltaApplier = new DeltaApplier();
deltaApplier.Apply(baseDataStream, new BinaryDeltaReader(deltaStream, progressReporter),
patchedDataStream);
}
// Assert
Assert.AreEqual(new FileInfo(newFileName).Length, new FileInfo(patchedFileName).Length);
Assert.True(CompareFilesByHash(newFileName, patchedFileName));
progressReporter.Received().Report(Arg.Any <ProgressReport>());
}
catch (Exception e)
{
Assert.Fail();
}
}
public async Task PatchingAsyncXXHash_ForTheSameData_PatchesFile(int numberOfBytes, short chunkSize)
{
// Arrange
var baseData = new byte[numberOfBytes];
new Random().NextBytes(baseData);
var baseDataStream = new MemoryStream(baseData);
var baseSignatureStream = new MemoryStream();
var signatureBuilder = new SignatureBuilder
{
ChunkSize = chunkSize
};
signatureBuilder.Build(baseDataStream, new SignatureWriter(baseSignatureStream));
baseSignatureStream.Seek(0, SeekOrigin.Begin);
var newDataStream = new MemoryStream(baseData);
var progressReporter = Substitute.For <IProgress <ProgressReport> >();
// Act
var deltaStream = new MemoryStream();
var deltaBuilder = new DeltaBuilder();
await deltaBuilder.BuildDeltaAsync(newDataStream, new SignatureReader(baseSignatureStream, null), new AggregateCopyOperationsDecorator(new BinaryDeltaWriter(deltaStream))).ConfigureAwait(false);
deltaStream.Seek(0, SeekOrigin.Begin);
var patchedDataStream = new MemoryStream();
var deltaApplier = new DeltaApplier();
await deltaApplier.ApplyAsync(baseDataStream, new BinaryDeltaReader(deltaStream, progressReporter), patchedDataStream).ConfigureAwait(false);
// Assert
CollectionAssert.AreEqual(baseData, patchedDataStream.ToArray());
progressReporter.Received().Report(Arg.Any <ProgressReport>());
}
public static void Apply(FileStream input, FileStream patchStream, FileStream output)
{
var deltaApplier = new DeltaApplier();
deltaApplier.Apply(input, new BinaryDeltaReader(patchStream, reporter), output);
}
public void Load(string path, UltimaData data, IWorldMap worldMap, Flags flags)
{
var file = Path.Combine(path, filename);
if (flags.VGAPatch && HashHelper.BytesToString(HashHelper.GetHashSha256(file)) == upgradeFileHash)
{
DowngradeVGAPatch(file);
}
FileHelper.TryBackupOriginalFile(file);
// Apply delta file to create new file
var newFilePath2 = file;
var newFileOutputDirectory = Path.GetDirectoryName(newFilePath2);
if (!Directory.Exists(newFileOutputDirectory))
{
Directory.CreateDirectory(newFileOutputDirectory);
}
var deltaApplier = new DeltaApplier {
SkipHashCheck = false
};
using (var basisStream = new FileStream($"{file}.orig", FileMode.Open, FileAccess.Read, FileShare.Read))
{
using (var deltaStream = new MemoryStream(Patches.AVATAR_EXE))
{
using (var newFileStream = new FileStream(newFilePath2, FileMode.Create, FileAccess.ReadWrite, FileShare.Read))
{
deltaApplier.Apply(basisStream, new BinaryDeltaReader(deltaStream, new ConsoleProgressReporter()), newFileStream);
}
}
}
using (var avatarStream = new System.IO.FileStream(file, System.IO.FileMode.Open))
{
avatarBytes = avatarStream.ReadAllBytes();
}
AvatarOffset = new AvatarOffsetsNew(avatarBytes, $"{file}.orig");
// Items
var items = new List <Item>();
for (int offset = 0; offset < 23; offset++)
{
items.Add(new Item(avatarBytes[AvatarOffset.ITEM_LOCATIONS_OFFSET + offset * 5],
avatarBytes[AvatarOffset.ITEM_LOCATIONS_OFFSET + offset * 5 + 1],
avatarBytes[AvatarOffset.ITEM_LOCATIONS_OFFSET + offset * 5 + 2]));
}
data.SetItems(items);
// Moongates
var moongates = new List <Tile>();
for (byte offset = 0; offset < 8; offset++)
{
moongates.Add(worldMap.GetCoordinate(avatarBytes[AvatarOffset.MOONGATE_X_OFFSET + offset], avatarBytes[AvatarOffset.MOONGATE_Y_OFFSET + offset]));
}
data.SetMoongates(moongates);
// LCB
var lcb = new List <Tile>();
var lcbLoc = worldMap.GetCoordinate(avatarBytes[AvatarOffset.AREA_X_OFFSET + data.LOC_LCB - 1], avatarBytes[AvatarOffset.AREA_Y_OFFSET + data.LOC_LCB - 1]);
lcb.Add(lcbLoc);
lcb.Add(worldMap.GetCoordinate(lcbLoc.X - 1, lcbLoc.Y));
lcb.Add(worldMap.GetCoordinate(lcbLoc.X + 1, lcbLoc.Y));
data.SetLCB(lcb);
// Castles
var castles = new List <TileDirtyWrapper>();
for (byte offset = 0; offset < 3; offset++)
{
castles.Add(new TileDirtyWrapper(worldMap.GetCoordinate(avatarBytes[AvatarOffset.AREA_X_OFFSET + data.LOC_CASTLES + offset], avatarBytes[AvatarOffset.AREA_Y_OFFSET + data.LOC_CASTLES + offset]), worldMap));
}
data.SetCastles(castles);
// Towns
var towns = new List <TileDirtyWrapper>();
for (byte offset = 0; offset < 8 + 4; offset++)
{
towns.Add(new TileDirtyWrapper(worldMap.GetCoordinate(avatarBytes[AvatarOffset.AREA_X_OFFSET + data.LOC_TOWNS + offset - 1], avatarBytes[AvatarOffset.AREA_Y_OFFSET + data.LOC_TOWNS + offset - 1]), worldMap));
}
data.SetTowns(towns);
// Shrines
var shrines = new List <TileDirtyWrapper>();
for (byte offset = 0; offset < 8; offset++)
{
shrines.Add(new TileDirtyWrapper(worldMap.GetCoordinate(avatarBytes[AvatarOffset.AREA_X_OFFSET + data.LOC_SHRINES + offset - 1], avatarBytes[AvatarOffset.AREA_Y_OFFSET + data.LOC_SHRINES + offset - 1]), worldMap));
}
data.SetShrines(shrines);
// Dungeons
var dungeons = new List <Tile>();
for (byte offset = 0; offset < 8; offset++)
{
dungeons.Add(worldMap.GetCoordinate(avatarBytes[AvatarOffset.AREA_X_OFFSET + data.LOC_DUNGEONS + offset - 1], avatarBytes[AvatarOffset.AREA_Y_OFFSET + data.LOC_DUNGEONS + offset - 1]));
}
data.SetDungeons(dungeons);
// Balloon Spawn
data.BalloonSpawn = worldMap.GetCoordinate(avatarBytes[AvatarOffset.BALLOON_SPAWN_LOCATION_X_OFFSET], avatarBytes[AvatarOffset.BALLOON_SPAWN_LOCATION_Y_OFFSET]);
OriginalShrineText = new List <string>();
OriginalShrineTextStartOffset = new List <int>();
var shrineTextBytes = new List <byte>();
var textOffset = AvatarOffset.SHRINE_TEXT_OFFSET;
for (int i = 0; i < 24; i++)
{
OriginalShrineTextStartOffset.Add(textOffset);
for (; avatarBytes[textOffset] != 0x0A && avatarBytes[textOffset] != 0x00; textOffset++)
{
shrineTextBytes.Add(avatarBytes[textOffset]);
}
OriginalShrineText.Add(System.Text.Encoding.Default.GetString(shrineTextBytes.ToArray()));
shrineTextBytes.Clear();
if (avatarBytes[textOffset] == 0x0A)
{
textOffset++;
}
textOffset++;
}
data.ShrineText.Clear();
data.ShrineText.AddRange(OriginalShrineText);
OriginalLBText = new List <string>();
OriginalLBTextStartOffset = new List <int>();
var lbTextBytes = new List <byte>();
textOffset = AvatarOffset.LB_TEXT_OFFSET;
// He has more text than 19 but there is some weird stuff after 19 that doesn't get turned into text well. And as far as I can tell we won't need any text after 19
for (int i = 0; i < 19; i++)
{
OriginalLBTextStartOffset.Add(textOffset);
for (; avatarBytes[textOffset] != 0x00 && avatarBytes[textOffset] != 0xAB; textOffset++)
{
lbTextBytes.Add(avatarBytes[textOffset]);
}
OriginalLBText.Add(System.Text.Encoding.Default.GetString(lbTextBytes.ToArray()));
lbTextBytes.Clear();
if (avatarBytes[textOffset] == 0x0A || avatarBytes[textOffset] == 0xAB)
{
textOffset++;
}
textOffset++;
}
data.LBText.Clear();
data.LBText.AddRange(OriginalLBText);
OriginalLBHelpText = new List <string>();
OriginalLBHelpTextStartOffset = new List <int>();
lbTextBytes = new List <byte>();
textOffset = AvatarOffset.LB_HELP_TEXT_OFFSET;
for (int i = 0; i < 21; i++)
{
OriginalLBHelpTextStartOffset.Add(textOffset);
for (; avatarBytes[textOffset] != 0x00 && avatarBytes[textOffset] != 0xAB; textOffset++)
{
lbTextBytes.Add(avatarBytes[textOffset]);
}
OriginalLBHelpText.Add(System.Text.Encoding.Default.GetString(lbTextBytes.ToArray()));
lbTextBytes.Clear();
if (avatarBytes[textOffset] == 0x0A || avatarBytes[textOffset] == 0xAB)
{
textOffset++;
}
textOffset++;
}
data.LBHelpText.Clear();
data.LBHelpText.AddRange(OriginalLBHelpText);
var mantraTextBytes = new List <byte>();
textOffset = AvatarOffset.MANTRA_OFFSET;
MantraMaxSize = 0;
for (int i = 0; i < 8; i++)
{
for (; avatarBytes[textOffset] != 0x00; textOffset++)
{
mantraTextBytes.Add(avatarBytes[textOffset]);
}
data.Mantras.Add(System.Text.Encoding.Default.GetString(mantraTextBytes.ToArray()));
MantraMaxSize += data.Mantras[i].Length + 1;
mantraTextBytes.Clear();
textOffset++;
}
var wordOfPassageTextBytes = new List <byte>();
for (int offSet = 0; offSet < 9; offSet++)
{
wordOfPassageTextBytes.Add(avatarBytes[AvatarOffset.WORD_OF_PASSAGE + offSet]);
}
data.WordOfPassage = System.Text.Encoding.Default.GetString(wordOfPassageTextBytes.ToArray());
data.DaemonSpawnX1 = avatarBytes[AvatarOffset.DEMON_SPAWN_TRIGGER_X1_OFFSET];
data.DaemonSpawnX2 = avatarBytes[AvatarOffset.DEMON_SPAWN_TRIGGER_X2_OFFSET];
data.DaemonSpawnY1 = avatarBytes[AvatarOffset.DEMON_SPAWN_TRIGGER_Y1_OFFSET];
data.DaemonSpawnY2 = avatarBytes[AvatarOffset.DEMON_SPAWN_TRIGGER_Y2_OFFSET];
data.DaemonSpawnLocationX = avatarBytes[AvatarOffset.DEMON_SPAWN_LOCATION_X_OFFSET];
for (int i = 0; i < 8; i++)
{
data.PirateCove.Add(new Coordinate(avatarBytes[i + AvatarOffset.PIRATE_COVE_X_OFFSET], avatarBytes[i + AvatarOffset.PIRATE_COVE_Y_OFFSET]));
}
data.PirateCoveSpawnTrigger = new Coordinate(avatarBytes[AvatarOffset.PIRATE_COVE_SPAWN_TRIGGER_X_OFFSET1], avatarBytes[AvatarOffset.PIRATE_COVE_SPAWN_TRIGGER_Y_OFFSET1]);
data.WhirlpoolExit = new Coordinate(avatarBytes[AvatarOffset.WHIRLPOOL_EXIT_X_OFFSET], avatarBytes[AvatarOffset.WHIRLPOOL_EXIT_Y_OFFSET]);
data.SpellsRecipes = new List <ByteDirtyWrapper>();
for (int i = 0; i < 26; i++)
{
data.SpellsRecipes.Add(new ByteDirtyWrapper(avatarBytes[AvatarOffset.SPELL_RECIPE_OFFSET + i]));
}
data.BlinkCastExclusionX1 = avatarBytes[AvatarOffset.BLINK_CAST_EXCLUSION_X1_OFFSET];
data.BlinkCastExclusionX2 = avatarBytes[AvatarOffset.BLINK_CAST_EXCLUSION_X2_OFFSET];
data.BlinkCastExclusionY1 = avatarBytes[AvatarOffset.BLINK_CAST_EXCLUSION_Y1_OFFSET];
data.BlinkCastExclusionY2 = avatarBytes[AvatarOffset.BLINK_CAST_EXCLUSION_Y2_OFFSET];
data.BlinkDestinationExclusionX1 = avatarBytes[AvatarOffset.BLINK_DESTINATION_EXCLUSION_X1_OFFSET];
data.BlinkDestinationExclusionX2 = avatarBytes[AvatarOffset.BLINK_DESTINATION_EXCLUSION_X2_OFFSET];
data.BlinkDestinationExclusionY1 = avatarBytes[AvatarOffset.BLINK_DESTINATION_EXCLUSION_Y1_OFFSET];
data.BlinkDestinationExclusionY2 = avatarBytes[AvatarOffset.BLINK_DESTINATION_EXCLUSION_Y2_OFFSET];
data.BlinkDestinationExclusion2X1 = avatarBytes[AvatarOffset.BLINK_DESTINATION2_EXCLUSION_X1_OFFSET];
data.BlinkDestinationExclusion2X2 = avatarBytes[AvatarOffset.BLINK_DESTINATION2_EXCLUSION_X2_OFFSET];
data.BlinkDestinationExclusion2Y1 = avatarBytes[AvatarOffset.BLINK_DESTINATION2_EXCLUSION_Y1_OFFSET];
data.BlinkDestinationExclusion2Y2 = avatarBytes[AvatarOffset.BLINK_DESTINATION2_EXCLUSION_Y2_OFFSET];
for (int i = 0; i < 13; i++)
{
data.AbyssEjectionLocations.Add(new Coordinate(avatarBytes[i + AvatarOffset.ABYSS_EJECTION_LOCATIONS_X], avatarBytes[i + AvatarOffset.ABYSS_EJECTION_LOCATIONS_Y]));
}
for (int townIdx = 0; townIdx < 16; townIdx++)
{
data.ShopLocations.Add(new List <byte>());
for (int shopIdx = 0; shopIdx < 8; shopIdx++)
{
data.ShopLocations[townIdx].Add(avatarBytes[townIdx * 8 + shopIdx + AvatarOffset.SHOP_LOCATION_OFFSET]);
}
}
}
public void Load(string path, UltimaData data)
{
var file = Path.Combine(path, filename);
FileHelper.TryBackupOriginalFile(file);
// Apply delta file to create new file
var newFilePath2 = file;
var newFileOutputDirectory = Path.GetDirectoryName(newFilePath2);
if (!Directory.Exists(newFileOutputDirectory))
{
Directory.CreateDirectory(newFileOutputDirectory);
}
var deltaApplier = new DeltaApplier {
SkipHashCheck = false
};
using (var basisStream = new FileStream($"{file}.orig", FileMode.Open, FileAccess.Read, FileShare.Read))
{
using (var deltaStream = new MemoryStream(Patches.TITLE_EXE))
{
using (var newFileStream = new FileStream(newFilePath2, FileMode.Create, FileAccess.ReadWrite, FileShare.Read))
{
deltaApplier.Apply(basisStream, new BinaryDeltaReader(deltaStream, new ConsoleProgressReporter()), newFileStream);
}
}
}
using (var titleStream = new System.IO.FileStream(file, System.IO.FileMode.Open))
{
titleBytes = titleStream.ReadAllBytes();
}
if (titleBytes[START_X_OFFSET] != 0xE7)
{
throw new Exception($"Offset START_X_OFFSET appears to be wrong.");
}
if (titleBytes[START_Y_OFFSET] != 0x88)
{
throw new Exception($"Offset START_Y_OFFSET appears to be wrong.");
}
if (titleBytes[FLAG_ENCODE_OFFSET] != 0x43)
{
throw new Exception($"Offset FLAG_ENCODE_OFFSET appears to be wrong.");
}
if (titleBytes[ENABLE_KARMA_OVERRIDE_OFFSET] != 0x09)
{
throw new Exception($"Offset ENABLE_KARMA_OVERRIDE_OFFSET appears to be wrong.");
}
if (titleBytes[KARMA_OVERRIDE_VALUES_OFFSET] != 0xFF)
{
throw new Exception($"Offset KARMA_OVERRIDE_VALUES_OFFSET appears to be wrong.");
}
for (int offset = 0; offset < 8; offset++)
{
data.StartingPositions.Add(new Coordinate(titleBytes[START_X_OFFSET + offset], titleBytes[START_Y_OFFSET + offset]));
}
for (int offset = 0; offset < 8; offset++)
{
data.StartingKarma.Add(titleBytes[KARMA_OVERRIDE_VALUES_OFFSET + offset]);
}
}
public void GZip_CompressData_RsyncSignatureAndPatch(int dataLength)
{
// Arrange
var dataBasis = new byte[dataLength];
new Random().NextBytes(dataBasis);
var basisStream = new MemoryStream(dataBasis);
var basisStreamCompressed = new MemoryStream();
var basisStreamCompressedSignature = new MemoryStream();
var newFileStream = new MemoryStream();
newFileStream.Write(dataBasis, 10, dataLength * 4 / 5);
var newRandomData = new byte[dataLength * 2 / 5];
new Random().NextBytes(newRandomData);
newFileStream.Write(newRandomData, 0, newRandomData.Length);
newFileStream.Seek(0, SeekOrigin.Begin);
var newFileStreamCompressed = new MemoryStream();
var deltaStream = new MemoryStream();
var patchedCompressedStream = new MemoryStream();
// Act
GZip.Compress(basisStream, basisStreamCompressed);
basisStreamCompressed.Seek(0, SeekOrigin.Begin);
var signatureBuilder = new SignatureBuilder();
signatureBuilder.Build(basisStreamCompressed, new SignatureWriter(basisStreamCompressedSignature));
basisStreamCompressedSignature.Seek(0, SeekOrigin.Begin);
GZip.Compress(newFileStream, newFileStreamCompressed);
newFileStreamCompressed.Seek(0, SeekOrigin.Begin);
var deltaBuilder = new DeltaBuilder();
deltaBuilder.BuildDelta(newFileStreamCompressed, new SignatureReader(basisStreamCompressedSignature, null),
new AggregateCopyOperationsDecorator(new BinaryDeltaWriter(deltaStream)));
deltaStream.Seek(0, SeekOrigin.Begin);
var deltaApplier = new DeltaApplier
{
SkipHashCheck = true
};
var deltaReader = new BinaryDeltaReader(deltaStream, null);
deltaApplier.Apply(basisStreamCompressed, deltaReader, patchedCompressedStream);
deltaApplier.HashCheck(deltaReader, patchedCompressedStream);
// Assert
Assert.AreEqual(newFileStreamCompressed.ToArray(), patchedCompressedStream.ToArray());
patchedCompressedStream.Seek(0, SeekOrigin.Begin);
var decompressedStream = new MemoryStream();
using (var gz = new GZipStream(patchedCompressedStream, CompressionMode.Decompress))
{
gz.CopyTo(decompressedStream);
}
var dataOutput = decompressedStream.ToArray();
Assert.AreEqual(newFileStream.ToArray(), dataOutput);
}
