示例#1
0
        public cDatFileNode buildBtreeStructure(Node node, cDatFileBlockCache blockCache)
        {
            cDatFileNode newFolder = new cDatFileNode(this, blockCache);

            foreach (uint entry in node.Entries)
            {
                cDatFileEntry file = fileCache[entry];
                file.startBlockOffset = 0;
                file.listOfBlocks     = new List <cDatFileBlock>();
                //blockCache.dataToBlocks(file.listOfBlocks, file.fileContent);
                //file.startBlockOffset = file.listOfBlocks[0].blockOffset;
                newFolder.files.Add(file.fileId, file);
            }

            if (!node.IsLeaf)
            {
                foreach (Node child in node.Children)
                {
                    cDatFileNode newSubFolder = buildBtreeStructure(child, blockCache);
                    newFolder.subFolders.Add(newSubFolder);
                }
            }

            //newFolder.updateBlockData(this, blockCache);

            return(newFolder);
        }
示例#2
0
        public static void loadBlocksAndAddToDictionary(cDatFileBlockCache blockCache, StreamReader inputFile, int blockSize)
        {
            inputFile.BaseStream.Seek(1024, SeekOrigin.Begin);

            while (inputFile.BaseStream.Position < inputFile.BaseStream.Length)
            {
                cDatFileBlock newBlock = new cDatFileBlock(inputFile, blockSize);
                blockCache.addBlock(newBlock);
            }
        }
示例#3
0
        public cDatFileNode(StreamReader inputFile, cDatFileBlockCache blockCache, uint startBlockOffset, int blockSize, eDatFormat fileFormat)
        {
            this.startBlockOffset = startBlockOffset;
            this.blockSize        = blockSize;

            int size;

            if (fileFormat == eDatFormat.ToD)
            {
                size = sizeToD;
            }
            else
            {
                size = sizeRetail;
            }

            listOfBlocks = new List <cDatFileBlock>();
            MemoryStream memoryStream = blockCache.blocksToData(startBlockOffset, size, listOfBlocks);

            memoryStream.Position = 0;
            StreamReader reader = new StreamReader(memoryStream);

            files      = new SortedDictionary <uint, cDatFileEntry>(); //max 61
            subFolders = new List <cDatFileNode>();                    //max 62

            List <uint> subFolderOffsets = new List <uint>();

            for (int i = 0; i < 62; i++)
            {
                subFolderOffsets.Add(Utils.readUInt32(reader));
            }
            uint entryCount = Utils.readUInt32(reader);

            // folder is allowed to have (files + 1) subfolders
            if (subFolderOffsets[0] != 0)
            {
                for (int i = 0; i < entryCount + 1; i++)
                {
                    cDatFileNode newDirectory = new cDatFileNode(inputFile, blockCache, subFolderOffsets[i], blockSize, fileFormat);
                    subFolders.Add(newDirectory);
                }
            }

            for (uint i = 0; i < entryCount; i++)
            {
                cDatFileEntry file = new cDatFileEntry(reader, fileFormat);
                files.Add(file.fileId, file);
            }
        }
示例#4
0
        public cDatFileNode(cDatFile datFile, cDatFileBlockCache blockCache)
        {
            blockSize = datFile.blockSize;

            int size;

            if (datFile.fileFormat == eDatFormat.ToD)
            {
                size = sizeToD;
            }
            else
            {
                size = sizeRetail;
            }

            listOfBlocks     = blockCache.getNewListOfBlocks(size);
            startBlockOffset = listOfBlocks[0].blockOffset;

            files      = new SortedDictionary <uint, cDatFileEntry>(); //max 61
            subFolders = new List <cDatFileNode>();
        }
示例#5
0
        public void loadFromDat(string filename)
        {
            StreamReader inputFile = new StreamReader(new FileStream(filename, FileMode.Open, FileAccess.Read));

            if (inputFile.BaseStream.Length < 1024)
            {
                Console.WriteLine("{0} is too small to be a valid dat file", filename);
                return;
            }

            Console.WriteLine("Reading data from {0}...", filename);
            Stopwatch timer = new Stopwatch();

            timer.Start();

            inputFile.BaseStream.Seek(257, SeekOrigin.Begin);
            int format = Utils.readInt32(inputFile);

            if (format == 0x4C50)
            {
                inputFile.BaseStream.Seek(256, SeekOrigin.Begin); //skip acVersionStr which is empty
                acTransactionRecord = Utils.readBytes(inputFile, 64);
                for (int i = 4; i < 64; i++)
                {
                    acTransactionRecord[i] = 0;
                }

                fileType = Utils.readUInt32(inputFile);
                if (fileType == 0x5442)
                {
                    fileFormat = eDatFormat.ToD;
                }
            }
            else
            {
                acTransactionRecord    = new byte[64];
                acTransactionRecord[0] = 0x00;
                acTransactionRecord[1] = 0x50;
                acTransactionRecord[2] = 0x4C;
                acTransactionRecord[3] = 0x00;

                inputFile.BaseStream.Seek(300, SeekOrigin.Begin);
                fileType = Utils.readUInt32(inputFile);
                if (fileType == 0x5442)
                {
                    fileFormat = eDatFormat.retail;
                }
            }

            if (fileFormat == eDatFormat.invalid)
            {
                Console.WriteLine("{0} is not a valid dat file.", filename);
                return;
            }

            blockSize = Utils.readInt32(inputFile);
            fileSize  = Utils.readUInt32(inputFile);
            dataSet   = Utils.readUInt32(inputFile);
            if (fileFormat == eDatFormat.ToD)
            {
                dataSubset = Utils.readUInt32(inputFile);
            }
            else
            {
                //dataSet = 0x00000043 for old cell.dat
                //dataSet = 0x0000082f for old portal.dat
                if (dataSet == 0x00000043)
                {
                    dataSet    = 0x00000002;
                    dataSubset = 0x00000001;
                }
                else
                {
                    dataSet    = 0x00000001;
                    dataSubset = 0x00000000;
                }
            }
            //dataSet = 0x00000001 - dataSubset = 0x00000000 for client_portal.dat
            //dataSet = 0x00000001 - dataSubset = 0x69466948 for client_highres.dat
            //dataSet = 0x00000002 - dataSubset = 0x00000001 for client_cell_1.dat
            //dataSet = 0x00000003 - dataSubset = 0x00000001 for client_local_English.dat

            freeHead            = Utils.readUInt32(inputFile);
            freeTail            = Utils.readUInt32(inputFile);
            freeCount           = Utils.readUInt32(inputFile);
            rootDirectoryOffset = Utils.readUInt32(inputFile);

            if (fileFormat == eDatFormat.ToD)
            {
                youngLRU = Utils.readUInt32(inputFile);
                oldLRU   = Utils.readUInt32(inputFile);
                useLRU   = Utils.readUInt32(inputFile);

                masterMapId = Utils.readUInt32(inputFile);

                enginePackVersion = Utils.readUInt32(inputFile);
                gamePackVersion   = Utils.readUInt32(inputFile);
                versionMajor      = Utils.readBytes(inputFile, 16);//int data1, short data2, short data3, int64 data4
                versionMinor      = Utils.readUInt32(inputFile);
            }
            else
            {
                youngLRU = 0x00000000;
                oldLRU   = 0x00000000;
                useLRU   = 0xcdcdcd00;

                masterMapId = 0x00000000;

                enginePackVersion = 0x00000016;
                gamePackVersion   = 0x00000000;
                versionMajor      = new byte[] { 0xD2, 0xD7, 0xA7, 0x34, 0x2F, 0x72, 0x46, 0x4C, 0x8A, 0xB4, 0xEF, 0x51, 0x4F, 0x85, 0x6F, 0xFD };

                versionMinor = 0x000000de;
            }

            inputBlockCache = new cDatFileBlockCache(fileSize, blockSize, freeHead, freeTail, freeCount);

            cDatFileBlock.loadBlocksAndAddToDictionary(inputBlockCache, inputFile, blockSize);

            rootDirectory = new cDatFileNode(inputFile, inputBlockCache, rootDirectoryOffset, blockSize, fileFormat);
            rootDirectory.loadFilesAndAddToCache(fileCache, inputBlockCache, inputFile, blockSize);

            timer.Stop();
            Console.WriteLine("{0} blocks read in {1} seconds.", inputBlockCache.blocks.Count, timer.ElapsedMilliseconds / 1000f);
        }
示例#6
0
        //we only write to the ToD data format.
        public void writeToDat(string filename)
        {
            fileSize  = inputBlockCache.fileSize;
            freeHead  = inputBlockCache.freeHead;
            freeTail  = inputBlockCache.freeTail;
            freeCount = inputBlockCache.freeCount;

            StreamWriter outputFile = new StreamWriter(new FileStream(filename, FileMode.Create, FileAccess.Write));

            Console.WriteLine("Writing data to {0}...", filename);
            Stopwatch timer = new Stopwatch();

            timer.Start();

            ////keep some free blocks
            //if (inputBlockCache.freeCount < 1000)
            //    inputBlockCache.addNewFreeBlocks(1000 - (int)inputBlockCache.freeCount);

            //rootDirectory.updateBlockData(this, inputBlockCache);

            //foreach (KeyValuePair<uint, cDatFileBlock> entry in inputBlockCache.blocks)
            //{
            //    outputFile.BaseStream.Seek(entry.Key, SeekOrigin.Begin);
            //    entry.Value.writeToDat(outputFile, blockSize);
            //}

            //fileSize = inputBlockCache.fileSize;
            //freeHead = inputBlockCache.fileSize;
            //freeTail = inputBlockCache.fileSize;
            //freeCount = inputBlockCache.fileSize;

            bTree = new cBTree(31);

            foreach (KeyValuePair <uint, cDatFileEntry> entry in fileCache)
            {
                bTree.Insert(entry.Key);
            }

            outputBlockCache = new cDatFileBlockCache(blockSize, 1024);
            rootDirectory    = buildBtreeStructure(bTree.Root, outputBlockCache);
            rootDirectory.updateBlockData(this, outputBlockCache);

            foreach (KeyValuePair <uint, cDatFileBlock> entry in outputBlockCache.blocks)
            {
                outputFile.BaseStream.Seek(entry.Key, SeekOrigin.Begin);
                entry.Value.writeToDat(outputFile, blockSize);
            }

            if (outputBlockCache.freeCount < 1000)
            {
                outputBlockCache.addNewFreeBlocks(1000 - (int)outputBlockCache.freeCount);
            }

            rootDirectoryOffset = rootDirectory.startBlockOffset;
            fileSize            = outputBlockCache.fileSize;
            freeHead            = outputBlockCache.fileSize;
            freeTail            = outputBlockCache.fileSize;
            freeCount           = outputBlockCache.fileSize;

            outputFile.BaseStream.Seek(256, SeekOrigin.Begin); //skip acVersionStr which is empty
            Utils.writeBytes(acTransactionRecord, outputFile);

            Utils.writeUInt32(fileType, outputFile);

            Utils.writeInt32(blockSize, outputFile);
            Utils.writeUInt32(fileSize, outputFile);
            Utils.writeUInt32(dataSet, outputFile);
            Utils.writeUInt32(dataSubset, outputFile);

            Utils.writeUInt32(freeHead, outputFile);
            Utils.writeUInt32(freeTail, outputFile);
            Utils.writeUInt32(freeCount, outputFile);
            Utils.writeUInt32(rootDirectoryOffset, outputFile);

            Utils.writeUInt32(youngLRU, outputFile);
            Utils.writeUInt32(oldLRU, outputFile);
            Utils.writeUInt32(useLRU, outputFile);

            Utils.writeUInt32(masterMapId, outputFile);

            Utils.writeUInt32(enginePackVersion, outputFile);
            Utils.writeUInt32(gamePackVersion, outputFile);
            Utils.writeBytes(versionMajor, outputFile);
            Utils.writeUInt32(versionMinor, outputFile);

            outputFile.Close();
            timer.Stop();
            Console.WriteLine("{0} blocks written in {1} seconds.", outputBlockCache.blocks.Count, timer.ElapsedMilliseconds / 1000f);

            //exportDirTree(rootDirectory);
        }
示例#7
0
        public void loadFilesAndAddToCache(SortedDictionary <uint, cDatFileEntry> fileCache, cDatFileBlockCache blockCache, StreamReader inputFile, int blockSize)
        {
            foreach (cDatFileNode entry in subFolders)
            {
                entry.loadFilesAndAddToCache(fileCache, blockCache, inputFile, blockSize);
            }

            foreach (KeyValuePair <uint, cDatFileEntry> entry in files)
            {
                cDatFileEntry fileEntry = entry.Value;

                fileEntry.listOfBlocks = new List <cDatFileBlock>();
                fileEntry.fileContent  = blockCache.blocksToData(fileEntry.startBlockOffset, fileEntry.fileSize, fileEntry.listOfBlocks);

                fileCache[fileEntry.fileId] = fileEntry;
            }
        }
示例#8
0
        public void updateBlockData(cDatFile datFile, cDatFileBlockCache blockCache)
        {
            MemoryStream memoryStream = new MemoryStream(new byte[sizeToD]);
            StreamWriter writer       = new StreamWriter(memoryStream);

            for (int i = 0; i < 62; i++)
            {
                if (i == 0 && subFolders.Count == 0)
                {
                    Utils.writeUInt32(0, writer);
                }
                else if (i < subFolders.Count && i < files.Count + 1) //directory is allowed to have (files + 1) subdirectories
                {
                    cDatFileNode subFolder = subFolders[i];

                    subFolder.updateBlockData(datFile, blockCache);

                    Utils.writeUInt32(subFolder.startBlockOffset, writer);
                }
                else
                {
                    Utils.writeUInt32(0xcdcdcdcd, writer);
                }
            }

            Utils.writeUInt32((uint)files.Count, writer);

            foreach (KeyValuePair <uint, cDatFileEntry> entry in files)
            {
                cDatFileEntry fileEntry = entry.Value;
                if (fileEntry.fileContent != null)
                {
                    fileEntry.fileSize = (int)fileEntry.fileContent.Length;
                    blockCache.dataToBlocks(fileEntry.listOfBlocks, fileEntry.fileContent);
                    if (fileEntry.listOfBlocks.Count > 0)
                    {
                        fileEntry.startBlockOffset = fileEntry.listOfBlocks[0].blockOffset;
                    }
                }
                else
                {
                    fileEntry.fileSize = 0;
                }
                fileEntry.writeHeader(writer);
            }

            cDatFileEntry emptyFileEntry = new cDatFileEntry(0, datFile.fileFormat);

            for (int i = files.Count; i < 61; i++)
            {
                emptyFileEntry.writeHeader(writer);
            }

            writer.Flush();

            blockCache.dataToBlocks(listOfBlocks, memoryStream);
            if (listOfBlocks.Count > 0)
            {
                startBlockOffset = listOfBlocks[0].blockOffset;
            }
        }