Exemple #1
0
 public IEnumerable <uint> ClassicHashes()
 {
     foreach (var filename in Directory.GetFiles(path, "*", SearchOption.TopDirectoryOnly))
     {
         yield return(PackageEntry.HashFilename(Path.GetFileName(filename), PackageHashType.Classic));
     }
 }
Exemple #2
0
 public IEnumerable <uint> ClassicHashes()
 {
     foreach (ZipEntry entry in pkg)
     {
         yield return(PackageEntry.HashFilename(entry.Name, PackageHashType.Classic));
     }
 }
Exemple #3
0
 public IEnumerable <uint> ClassicHashes()
 {
     foreach (var filename in index.Keys)
     {
         yield return(PackageEntry.HashFilename(filename, PackageHashType.Classic));
     }
 }
        public D2kSoundResources(string filename, int priority)
        {
            this.filename = filename;
            this.priority = priority;

            s = FileSystem.Open(filename);
            s.Seek(0, SeekOrigin.Begin);

            filenames = new List <string>();

            var headerLength = s.ReadUInt32();

            while (s.Position < headerLength + 4)
            {
                var name   = s.ReadASCIIZ();
                var offset = s.ReadUInt32();
                var length = s.ReadUInt32();

                var hash = PackageEntry.HashFilename(name, PackageHashType.Classic);
                if (!index.ContainsKey(hash))
                {
                    index.Add(hash, new PackageEntry(hash, offset, length));
                }

                filenames.Add(name);
            }
        }
Exemple #5
0
        public IEnumerable <string> AllFileNames()
        {
            var lookup = new Dictionary <uint, string>();

            if (Exists("local mix database.dat"))
            {
                var db = new XccLocalDatabase(GetContent("local mix database.dat"));
                foreach (var e in db.Entries)
                {
                    var hash = PackageEntry.HashFilename(e, type);
                    if (!lookup.ContainsKey(hash))
                    {
                        lookup.Add(hash, e);
                    }
                }
            }

            if (FileSystem.Exists("global mix database.dat"))
            {
                var db = new XccGlobalDatabase(FileSystem.Open("global mix database.dat"));
                foreach (var e in db.Entries)
                {
                    var hash = PackageEntry.HashFilename(e, type);
                    if (!lookup.ContainsKey(hash))
                    {
                        lookup.Add(hash, e);
                    }
                }
            }

            return(index.Keys.Select(k => lookup.ContainsKey(k) ? lookup[k] : "{0:X}".F(k)));
        }
Exemple #6
0
 public IEnumerable <uint> AllFileHashes()
 {
     foreach (ZipEntry entry in pkg)
     {
         yield return(PackageEntry.HashFilename(entry.Name));
     }
 }
Exemple #7
0
        static Stream GetFromCache(Cache <uint, List <IFolder> > index, string filename)
        {
            var folder = index[PackageEntry.HashFilename(filename)]
                         .Where(x => x.Exists(filename))
                         .OrderBy(x => x.Priority)
                         .FirstOrDefault();

            if (folder != null)
            {
                return(folder.GetContent(filename));
            }

            return(null);
        }
Exemple #8
0
        static Stream GetFromCache(PackageHashType type, string filename)
        {
            var index  = type == PackageHashType.CRC32 ? crcHashIndex : classicHashIndex;
            var folder = index[PackageEntry.HashFilename(filename, type)]
                         .Where(x => x.Exists(filename))
                         .OrderBy(x => x.Priority)
                         .FirstOrDefault();

            if (folder != null)
            {
                return(folder.GetContent(filename));
            }

            return(null);
        }
Exemple #9
0
        public void Write(Dictionary <string, byte[]> contents)
        {
            // Cannot modify existing mixfile - rename existing file and
            // create a new one with original content plus modifications
            FileSystem.Unmount(this);

            // TODO: Add existing data to the contents list
            if (index.Count > 0)
            {
                throw new NotImplementedException("Updating mix files unfinished");
            }

            // Construct a list of entries for the file header
            uint dataSize = 0;
            var  items    = new List <PackageEntry>();

            foreach (var kv in contents)
            {
                uint length = (uint)kv.Value.Length;
                uint hash   = PackageEntry.HashFilename(Path.GetFileName(kv.Key));
                items.Add(new PackageEntry(hash, dataSize, length));
                dataSize += length;
            }

            // Write the new file
            s.Seek(0, SeekOrigin.Begin);
            using (var writer = new BinaryWriter(s))
            {
                // Write file header
                writer.Write((ushort)items.Count);
                writer.Write(dataSize);
                foreach (var item in items)
                {
                    item.Write(writer);
                }

                writer.Flush();

                // Copy file data
                foreach (var file in contents)
                {
                    s.Write(file.Value);
                }
            }
        }
        void ParseFile(BinaryReader reader)
        {
            reader.ReadBytes(7);
            var CompressedSize = reader.ReadUInt32();

            reader.ReadBytes(12);
            var ChunkSize = reader.ReadUInt16();

            reader.ReadBytes(4);
            var NameLength = reader.ReadByte();
            var FileName   = new String(reader.ReadChars(NameLength));

            var hash = PackageEntry.HashFilename(FileName);

            index.Add(hash, new PackageEntry(hash, AccumulatedData, CompressedSize));
            AccumulatedData += CompressedSize;

            // Skip to the end of the chunk
            reader.ReadBytes(ChunkSize - NameLength - 30);
        }
Exemple #11
0
        uint?FindMatchingHash(string filename)
        {
            var hash = PackageEntry.HashFilename(filename, type);

            if (index.ContainsKey(hash))
            {
                return(hash);
            }

            // Maybe we were given a raw hash?
            uint raw;

            if (!uint.TryParse(filename, NumberStyles.AllowHexSpecifier, CultureInfo.InvariantCulture, out raw))
            {
                return(null);
            }

            if ("{0:X}".F(raw) == filename && index.ContainsKey(raw))
            {
                return(raw);
            }

            return(null);
        }
Exemple #12
0
 public bool Exists(string filename)
 {
     return(index.ContainsKey(PackageEntry.HashFilename(filename)));
 }
Exemple #13
0
 public Stream GetContent(string filename)
 {
     return(GetContent(PackageEntry.HashFilename(filename)));
 }
Exemple #14
0
 public Stream GetContent(string filename)
 {
     return(GetContent(PackageEntry.HashFilename(filename, PackageHashType.Classic)));
 }