Esempio n. 1
0
        /// <summary>
        /// Parse directory/file nodes.
        /// </summary>
        /// <param name="fs">Filestream of U8 file.</param>
        public void ParseNodes(FileStream fs)
        {
            u8Node node = new u8Node();
            uint   maxNodeId;

            // read first node
            node.NodeType   = ParseFile.ReadByte(fs, this.RootNodeOffset);
            node.NameOffset = ParseFile.ReadUint24BE(fs, this.RootNodeOffset + 1);
            node.DataOffset = ParseFile.ReadUintBE(fs, this.RootNodeOffset + 4);
            node.DataSize   = ParseFile.ReadUintBE(fs, this.RootNodeOffset + 8);
            this.NodeArray.Add(node);

            maxNodeId = node.DataSize;

            // parse each node
            for (int i = 1; i < maxNodeId; i++)
            {
                node            = new u8Node();
                node.NodeType   = ParseFile.ReadByte(fs, this.RootNodeOffset + (i * 0xC));
                node.NameOffset = ParseFile.ReadUint24BE(fs, this.RootNodeOffset + (i * 0xC) + 1);
                node.DataOffset = ParseFile.ReadUintBE(fs, this.RootNodeOffset + (i * 0xC) + 4);
                node.DataSize   = ParseFile.ReadUintBE(fs, this.RootNodeOffset + (i * 0xC) + 8);
                this.NodeArray.Add(node);
            }
        }
Esempio n. 2
0
        private NintendoU8File getFileNode(FileStream fs, int nodeIndex, string parentDirectory)
        {
            // get node
            u8Node node = this.NodeList[nodeIndex];

            // get directory name
            string fileName = ParseFile.ReadAsciiString(fs, this.NameTableOffset + node.NameOffset);

            // create file item
            NintendoU8File newFile = new NintendoU8File(parentDirectory, this.SourceFileName,
                                                        fileName, node.DataOffset, this.VolumeBaseOffset, node.DataOffset, node.DataSize);

            return(newFile);
        }
Esempio n. 3
0
        private NintendoU8Directory getDirectoryNode(FileStream fs, int nodeIndex,
                                                     string parentDirectory, out int lastIndexProcessed)
        {
            string newParentDirectoryName;
            uint   maxNodeIndex;
            NintendoU8Directory newSubDirectory;

            lastIndexProcessed = nodeIndex;

            // get node
            u8Node node = this.NodeList[nodeIndex];

            // get directory name
            string directoryName = ParseFile.ReadAsciiString(fs, this.NameTableOffset + node.NameOffset);

            // create directory item
            NintendoU8Directory newDirectory = new NintendoU8Directory(this.SourceFileName, directoryName, parentDirectory);

            // parse other items
            maxNodeIndex = node.DataSize;


            for (int i = (nodeIndex + 1); i < maxNodeIndex; i = (lastIndexProcessed + 1))
            {
                node = this.NodeList[i];
                newParentDirectoryName = Path.Combine(parentDirectory, directoryName);

                if (node.IsDirectory())
                {
                    newSubDirectory = this.getDirectoryNode(fs, i, newParentDirectoryName, out lastIndexProcessed);

                    if (!newSubDirectory.DirectoryName.Equals("."))
                    {
                        newDirectory.SubDirectoryArray.Add(newSubDirectory);
                    }
                    else // in current folder "."
                    {
                        // move folders to this folder
                        foreach (NintendoU8Directory d in newSubDirectory.SubDirectories)
                        {
                            newDirectory.SubDirectoryArray.Add(d);
                        }

                        // move files to this folder
                        foreach (NintendoU8File f in newSubDirectory.Files)
                        {
                            newDirectory.FileArray.Add(f);
                        }
                    }
                }
                else
                {
                    newDirectory.FileArray.Add(this.getFileNode(fs, i, newParentDirectoryName));
                    lastIndexProcessed = i;
                }
            }



            return(newDirectory);
        }