static void CleanMC1File(Iso9660.IsoImage iso, String filepath)
        {
            Assert.IsNotNull(iso, nameof(iso));
            Assert.IsValidString(filepath, nameof(filepath));

            var file   = iso.GetFile(filepath);
            var buffer = file.GetData();

            var count = BitConverter.ToUInt32(buffer, 0);

            for (var i = 0; i != count; ++i)
            {
                var offset = 16 + (i * 32);

                var key = System.Text.Encoding.ASCII.GetString(buffer, offset, 16).Trim('\0');

                if (Path.GetExtension(key) == ".bin")
                {
                    for (var ii = 0; ii != 32; ++ii)
                    {
                        buffer[offset + ii] = 0;
                    }
                }
            }
        }
        public static void Run(CommandLine.BuildArgs args)
        {
            Assert.IsNotNull(args, nameof(args));

            if (ValidateArgs(args) == false)
            {
                return;
            }

            if (args.Format == GameFormat.PSP)
            {
                Console.WriteLine("Building ISO");
                Console.WriteLine($"Source ISO: {args.SourceIsoPath}");
                Console.WriteLine($"Destination ISO: {args.DestinationIsoPath}");
                Console.WriteLine($"Translation Location: {args.TranslationPath}");
                Console.WriteLine();

                using (var iso = new Iso9660.IsoImage(args.SourceIsoPath))
                {
                    var filesystem = new IO.IsoFileSystem(iso, @"PSP_GAME\USRDIR");

                    var datapath_eboot = Path.Combine(args.TranslationPath, "EBOOT.BIN");
                    if (File.Exists(datapath_eboot) == true)
                    {
                        Console.WriteLine(@"EBOOT.BIN");

                        UpdateEboot(iso, datapath_eboot);
                    }

                    Run(GameFormat.PSP, filesystem, Encodings.ShiftJIS, args.TranslationPath);

                    FixFileReferences(iso, filesystem);

                    iso.GetPrimaryVolumeDescriptor().VolumeSpaceSize = iso.GetHighestSectorUsed() + 1;

                    Console.WriteLine();
                    Console.WriteLine("Writing ISO.");

                    iso.Save(args.DestinationIsoPath);
                }
            }

            if (args.Format == GameFormat.PC)
            {
                Console.WriteLine("Injecting Translation");
                Console.WriteLine($"Game Path: {args.GamePath}");
                Console.WriteLine($"Translation Location: {args.TranslationPath}");
                Console.WriteLine();

                var filesystem = new IO.DirectoryFileSystem(args.GamePath);

                Run(GameFormat.PC, filesystem, Encodings.Chinese, args.TranslationPath);
            }
        }
        static void CleanAllMC1Files(Iso9660.IsoImage iso)
        {
            Assert.IsNotNull(iso, nameof(iso));

            var children = iso.GetChildren(IsoFilePaths.DirectoryPath_Map4).Where(x => Path.GetExtension(x.FileIdentifier) == ".mc1").ToList();

            foreach (var child in children)
            {
                CleanMC1File(iso, Path.Combine(IsoFilePaths.DirectoryPath_Map4, child.FileIdentifier));
            }
        }
        static void UpdateFileData(Iso9660.IsoImage iso, Iso9660.FileSector file, Byte[] buffer)
        {
            Assert.IsNotNull(iso, nameof(iso));
            Assert.IsNotNull(file, nameof(file));
            Assert.IsNotNull(buffer, nameof(buffer));

            file.Record.DataLength = (UInt32)buffer.Length;
            file.SetData(buffer);

            var sectorsused = MathUtil.RoundUp(buffer.Length, 2048) / 2048;

            if (iso.CheckForRoom(file.Record, sectorsused) == false)
            {
                iso.ChangeFileSector(file, iso.GetHighestSectorUsed() + 1);
            }
        }
        static void FixFileReferences(Iso9660.IsoImage iso, IO.IFileSystem filesystem)
        {
            Assert.IsNotNull(iso, nameof(iso));
            Assert.IsNotNull(filesystem, nameof(filesystem));

            var data_text = Text.TextFileDescription.GetTextFileData();

            foreach (var item in data_text)
            {
                var textfilepath = Path.Combine(IsoFilePaths.DirectoryPath_Text, item.FileName);

                Update_datalst(iso, textfilepath);
                ClearFileReference(iso, IsoFilePaths.FilePath_sysstartbbc, item.FileName);
                ClearFileReference(iso, IsoFilePaths.FilePath_sysonmembbc, item.FileName);
            }

            foreach (var item in filesystem.GetChildren(@"data\scena", "*.bin"))
            {
                var scenariofilepath = Path.Combine(@"PSP_GAME\USRDIR", item);

                Update_datalst(iso, scenariofilepath);
            }

            foreach (var filepath in filesystem.GetChildren(@"data\battle\dat", "ms*.dat"))
            {
                var filename = Path.GetFileName(filepath);

                var filepath2 = Path.Combine(@"PSP_GAME\USRDIR", filepath);

                Update_datalst(iso, filepath2);
                ClearFileReference(iso, IsoFilePaths.FilePath_btasm1bbc, filename);
            }

            CleanAllMC1Files(iso);

            Update_datalst(iso, IsoFilePaths.FilePath_monsnotedt2);
            ClearFileReference(iso, IsoFilePaths.FilePath_sysonmembbc, "monsnote.dt2");
        }
        static void ClearFileReference(Iso9660.IsoImage iso, String filepath, String key)
        {
            Assert.IsNotNull(iso, nameof(iso));
            Assert.IsValidString(filepath, nameof(filepath));
            Assert.IsValidString(key, nameof(key));

            var file       = iso.GetFile(filepath);
            var filebuffer = file.GetData();

            var keybytes = Encodings.ASCII.GetBytes(key);

            var find_index = FindIndex(filebuffer, 0, keybytes);

            if (find_index == -1)
            {
                return;
            }

            for (var i = 0; i != 32; ++i)
            {
                filebuffer[find_index + i] = 0;
            }
        }
        static void Update_datalst(Iso9660.IsoImage iso, String filepath)
        {
            Assert.IsNotNull(iso, nameof(iso));
            Assert.IsValidString(filepath, nameof(filepath));

            var datalist       = iso.GetFile(IsoFilePaths.FilePath_datalst);
            var datalistbuffer = datalist.GetData();
            var extensionslist = ReadDataLstExtensions(new FileReader(datalistbuffer, Encodings.ASCII));

            var filerecord = iso.GetFile(filepath);

            var index = FindDataLstIndex(filepath, datalistbuffer, extensionslist);

            BinaryIO.WriteIntoBuffer(datalistbuffer, index + 8, filerecord.Record.DataLength, Endian.LittleEndian);

            var sectorbytes = new Byte[4];

            BinaryIO.WriteIntoBuffer(sectorbytes, 0, filerecord.Record.SectorNumber, Endian.LittleEndian);

            for (var i = 0; i != 3; ++i)
            {
                datalistbuffer[index + 12 + i] = sectorbytes[i];
            }
        }
        static void UpdateEboot(Iso9660.IsoImage iso, String ebootpath)
        {
            Assert.IsNotNull(iso, nameof(iso));
            Assert.IsValidString(ebootpath, nameof(ebootpath));

            var patches = BuildEbootPatches();
            var file    = iso.GetFile(@"PSP_GAME\SYSDIR\EBOOT.BIN");
            var buffer  = File.ReadAllBytes(ebootpath);

            foreach (var patch in patches)
            {
                if (patch.Type == BinaryPatchType.Clear)
                {
                    for (var i = 0; i != patch.Count; ++i)
                    {
                        buffer[patch.Offset + i] = 0;
                    }
                }

                if (patch.Type == BinaryPatchType.Overwrite)
                {
                    if (patch.Buffer != null)
                    {
                        Array.Copy(patch.Buffer, 0, buffer, patch.Offset, patch.Buffer.Length);
                    }

                    if (patch.Text != null)
                    {
                        var stringbytes = EncodedStringUtil.GetBytes(patch.Text, Encodings.ShiftJIS);
                        Array.Copy(stringbytes, 0, buffer, patch.Offset, stringbytes.Length);
                    }
                }
            }

            UpdateFileData(iso, file, buffer);
        }
Exemplo n.º 9
0
        public static void Run(CommandLine.ExtractArgs args)
        {
            Assert.IsNotNull(args, nameof(args));

            if (ValidateArgs(args) == false)
            {
                return;
            }

            if (args.Format == GameFormat.PSP)
            {
                Console.WriteLine("Extracting text");
                Console.WriteLine($"Source ISO: {args.SourceIsoPath}");
                Console.WriteLine($"Translation Location: {args.TranslationPath}");
                Console.WriteLine();

                using (var iso = new Iso9660.IsoImage(args.SourceIsoPath))
                {
                    var filesystem = new IO.IsoFileSystem(iso, @"PSP_GAME\USRDIR");

                    Run(filesystem, Encodings.ShiftJIS, args.TranslationPath);
                }
            }

            if (args.Format == GameFormat.PC)
            {
                Console.WriteLine("Extracting text");
                Console.WriteLine($"Game Directory: {args.GamePath}");
                Console.WriteLine($"Translation Location: {args.TranslationPath}");
                Console.WriteLine();

                var filesystem = new IO.DirectoryFileSystem(args.GamePath);

                Run(filesystem, Encodings.Chinese, args.TranslationPath);
            }
        }