Example #1
0
        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);
        }
Example #2
0
        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);
                    }
        }
Example #3
0
        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);
                    }
        }
Example #4
0
        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);
        }
Example #5
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"
        }
Example #6
0
 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
     };
 }
Example #7
0
        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);
                        }
        }
Example #8
0
        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);
        }
Example #9
0
        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);
            }
        }
Example #10
0
        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);
                        }
        }
Example #11
0
        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>());
        }
Example #12
0
        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();
            }
        }
Example #13
0
        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>());
        }
Example #14
0
        public static void Apply(FileStream input, FileStream patchStream, FileStream output)
        {
            var deltaApplier = new DeltaApplier();

            deltaApplier.Apply(input, new BinaryDeltaReader(patchStream, reporter), output);
        }
Example #15
0
        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]);
                }
            }
        }
Example #16
0
        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]);
            }
        }
Example #17
0
        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);
        }