예제 #1
0
        public HashFile(string filePath, RootFileSystem rfs)
        {
            _path = filePath;
            _rfs  = rfs;

            if (!File.Exists(_path))
            {
                return;
            }

            Fs      = File.OpenRead(_path);
            Entries = new Dictionary <ulong, ScsHashEntry>();

            Header = new ScsHeader
            {
                Magic       = ReadUint(Fs, 0x0),
                Version     = ReadUshort(Fs, 0x04),
                Salt        = ReadUshort(Fs, 0x06),
                HashMethod  = ReadUint(Fs, 0x08),
                EntryCount  = ReadInt(Fs, 0x0C),
                StartOffset = ReadInt(Fs, 0x10)
            };

            if (Header.Magic != Magic)
            {
                Log.Msg("Incorrect File Structure");
                return;
            }

            if (Header.HashMethod != HashMethod)
            {
                Log.Msg("Incorrect Hash Method");
                return;
            }

            if (Header.Version != SupportedHashVersion)
            {
                Log.Msg("Unsupported Hash Version");
                return;
            }

            for (var i = 0; i < Header.EntryCount; i++)
            {
                var offset = Header.StartOffset + i * EntryBlockSize;
                var entry  = new ScsHashEntry
                {
                    Hash           = ReadUlong(Fs, offset),
                    Offset         = ReadLong(Fs, offset + 0x08),
                    Flags          = ReadUint(Fs, offset + 0x10),
                    Crc            = ReadUint(Fs, offset + 0x14),
                    Size           = ReadInt(Fs, offset + 0x18),
                    CompressedSize = ReadInt(Fs, offset + 0x1C),
                    Hf             = this
                };

                Entries.Add(entry.Hash, entry);
            }

            _rfs.AddDirEntry(GetEntry(RootDirHash));
        }
예제 #2
0
        public ScsDirectory(RootFileSystem rfs, string path)
        {
            Directories = new Dictionary <ulong, ScsDirectory>();
            Files       = new Dictionary <ulong, ScsFile>();

            _rfs      = rfs;
            EntryPath = path;
        }
예제 #3
0
        public ScsZipFile(string path, RootFileSystem rfs) : base(path, rfs)
        {
            if (!File.Exists(_path))
            {
                return;
            }

            Br      = new BinaryReader(File.OpenRead(_path));
            Entries = new Dictionary <string, ScsZipEntry>();

            var entryCount = (short)ReadUInt16(Br, -22 + 10, SeekOrigin.End);

            var fileOffset = 0;

            for (var i = 0; i < entryCount; i++)
            {
                var entry = new ScsZipEntry(this)
                {
                    CompressionMethod = ReadUInt16(Br, fileOffset += 8),
                    CompressedSize    = ReadInt32(Br, fileOffset += 10),
                    Size       = ReadInt32(Br, fileOffset += 4),
                    NameLength = (short)ReadUInt16(Br, fileOffset += 4),
                };

                var extraFieldLength = ReadUInt16(Br, fileOffset += 2);
                Br.BaseStream.Seek(fileOffset += 2, SeekOrigin.Begin);
                entry.Name = Encoding.UTF8.GetString(Br.ReadBytes(entry.NameLength));

                fileOffset  += entry.NameLength + extraFieldLength;
                entry.Offset = fileOffset; // Offset to data

                fileOffset += entry.CompressedSize;

                if (entry.CompressedSize != 0) // only files
                {
                    var filePath = entry.Name.Replace('\\', '/');
                    _rfs.AddZipEntry(entry, filePath);
                }

                Entries.Add(entry.Name, entry);
            }
        }
예제 #4
0
 protected ScsRootFile(string path, RootFileSystem rfs)
 {
     _path = path;
     _rfs  = rfs;
 }
예제 #5
0
        public HashFile(string filePath, RootFileSystem rfs) : base(filePath, rfs)
        {
            if (!File.Exists(_path))
            {
                return;
            }

            Br      = new BinaryReader(File.OpenRead(_path));
            Entries = new Dictionary <ulong, ScsHashEntry>();

            Header = new ScsHeader
            {
                Magic       = ReadUInt32(Br, 0x0),
                Version     = ReadUInt16(Br, 0x04),
                Salt        = ReadUInt16(Br, 0x06),
                HashMethod  = ReadUInt32(Br, 0x08),
                EntryCount  = ReadInt32(Br, 0x0C),
                StartOffset = ReadInt32(Br, 0x10)
            };

            if (Header.Magic != Magic)
            {
                Log.Msg("Incorrect File Structure");
                return;
            }

            if (Header.HashMethod != HashMethod)
            {
                Log.Msg("Incorrect Hash Method");
                return;
            }

            if (Header.Version != SupportedHashVersion)
            {
                Log.Msg("Unsupported Hash Version");
                return;
            }

            Br.BaseStream.Seek(Header.StartOffset, SeekOrigin.Begin);
            var entriesRaw = Br.ReadBytes(Header.EntryCount * EntryBlockSize);

            for (var i = 0; i < Header.EntryCount; i++)
            {
                var offset = i * EntryBlockSize;
                var entry  = new ScsHashEntry
                {
                    Hash           = MemoryHelper.ReadUInt64(entriesRaw, offset),
                    Offset         = MemoryHelper.ReadInt64(entriesRaw, offset + 0x08),
                    Flags          = MemoryHelper.ReadUInt32(entriesRaw, offset + 0x10),
                    Crc            = MemoryHelper.ReadUInt32(entriesRaw, offset + 0x14),
                    Size           = MemoryHelper.ReadInt32(entriesRaw, offset + 0x18),
                    CompressedSize = MemoryHelper.ReadInt32(entriesRaw, offset + 0x1C),
                    Hf             = this
                };

                Entries.Add(entry.Hash, entry);
            }

            var rootDir = GetEntry(RootDirHash);

            if (rootDir == null) // Try to add important sub directories directly
            {
                var defEntry = (ScsHashEntry)GetEntry("def");
                if (defEntry != null)
                {
                    var dir = _rfs.GetDirectory("def");

                    dir?.AddHashEntry(defEntry);
                }
                var mapEntry = (ScsHashEntry)GetEntry("map");
                if (mapEntry != null)
                {
                    var dir = _rfs.GetDirectory("map");

                    dir?.AddHashEntry(mapEntry);
                }
                var materialEntry = (ScsHashEntry)GetEntry("material");
                if (materialEntry != null)
                {
                    var dir = _rfs.GetDirectory("material");

                    dir?.AddHashEntry(materialEntry);
                }
                var prefabEntry = (ScsHashEntry)GetEntry("prefab");
                if (prefabEntry != null)
                {
                    var dir = _rfs.GetDirectory("prefab");

                    dir?.AddHashEntry(prefabEntry);
                }
                var prefab2Entry = (ScsHashEntry)GetEntry("prefab2");
                if (prefab2Entry != null)
                {
                    var dir = _rfs.GetDirectory("prefab2");

                    dir?.AddHashEntry(prefab2Entry);
                }
                var modelEntry = (ScsHashEntry)GetEntry("model");
                if (modelEntry != null)
                {
                    var dir = _rfs.GetDirectory("model");

                    dir?.AddHashEntry(modelEntry);
                }
                var model2Entry = (ScsHashEntry)GetEntry("model2");
                if (model2Entry != null)
                {
                    var dir = _rfs.GetDirectory("model2");

                    dir?.AddHashEntry(model2Entry);
                }
                var localeEntry = (ScsHashEntry)GetEntry("locale");
                if (localeEntry != null)
                {
                    var dir = _rfs.GetDirectory("locale");
                    if (dir == null)
                    {
                        _rfs.GetRootDirectory()?.AddDirectoryManually("locale", localeEntry);
                        dir = _rfs.GetDirectory("locale");
                        if (dir == null)
                        {
                            Log.Msg("F**k");
                        }
                    }
                    dir?.AddHashEntry(localeEntry);
                }
            }
            else
            {
                _rfs.AddHashEntry(rootDir);
            }
        }
예제 #6
0
        public HashFile(string filePath, RootFileSystem rfs)
        {
            _path = filePath;
            _rfs  = rfs;

            if (!File.Exists(_path))
            {
                return;
            }

            Br      = new BinaryReader(File.OpenRead(_path));
            Entries = new Dictionary <ulong, ScsHashEntry>();

            Header = new ScsHeader
            {
                Magic       = ReadUInt32(Br, 0x0),
                Version     = ReadUInt16(Br, 0x04),
                Salt        = ReadUInt16(Br, 0x06),
                HashMethod  = ReadUInt32(Br, 0x08),
                EntryCount  = ReadInt32(Br, 0x0C),
                StartOffset = ReadInt32(Br, 0x10)
            };

            if (Header.Magic != Magic)
            {
                Log.Msg("Incorrect File Structure");
                return;
            }

            if (Header.HashMethod != HashMethod)
            {
                Log.Msg("Incorrect Hash Method");
                return;
            }

            if (Header.Version != SupportedHashVersion)
            {
                Log.Msg("Unsupported Hash Version");
                return;
            }

            Br.BaseStream.Seek(Header.StartOffset, SeekOrigin.Begin);
            var entriesRaw = Br.ReadBytes(Header.EntryCount * EntryBlockSize);

            for (var i = 0; i < Header.EntryCount; i++)
            {
                var offset = i * EntryBlockSize;
                var entry  = new ScsHashEntry
                {
                    Hash           = MemoryHelper.ReadUInt64(entriesRaw, offset),
                    Offset         = MemoryHelper.ReadInt64(entriesRaw, offset + 0x08),
                    Flags          = MemoryHelper.ReadUInt32(entriesRaw, offset + 0x10),
                    Crc            = MemoryHelper.ReadUInt32(entriesRaw, offset + 0x14),
                    Size           = MemoryHelper.ReadInt32(entriesRaw, offset + 0x18),
                    CompressedSize = MemoryHelper.ReadInt32(entriesRaw, offset + 0x1C),
                    Hf             = this
                };

                Entries.Add(entry.Hash, entry);
            }

            _rfs.AddDirEntry(GetEntry(RootDirHash));
        }