/// <summary>
/// Returns a list of files with the given extension, or an empty list if no files are found. Searches
/// all child directories recursively to look for files.
/// </summary>
/// <param name="extension">File extension (including period, ie: ".arc")</param>
/// <returns>List of files matching that extension</returns>
public List <VirtualFilesystemFile> FindByExtension(params string[] extensions)
{
if (extensions.Length == 0)
{
throw new ArgumentException("You must specify at least one extension", "extensions");
}
List <VirtualFilesystemFile> validFiles = new List <VirtualFilesystemFile>();
foreach (var child in Children)
{
if (child.Type == NodeType.File)
{
VirtualFilesystemFile file = (VirtualFilesystemFile)child;
for (int i = 0; i < extensions.Length; i++)
{
string extension = extensions[i];
if (string.Compare(file.Extension, extension, System.StringComparison.InvariantCultureIgnoreCase) == 0)
{
validFiles.Add(file);
break;
}
}
}
else if (child.Type == NodeType.Directory)
{
VirtualFilesystemDirectory dir = (VirtualFilesystemDirectory)child;
validFiles.AddRange(dir.FindByExtension(extensions));
}
}
return(validFiles);
}
private void ImportFromDiskRecursive(string folder, VirtualFilesystemDirectory dir)
{
if (!Directory.Exists(folder))
{
throw new ArgumentException("You must specify a directory that exists", "folder");
}
// For each directory that is a child of the specified folder into ourselves, and then import the contents.
DirectoryInfo dirInfo = new DirectoryInfo(folder);
foreach (var diskDir in dirInfo.GetDirectories())
{
VirtualFilesystemDirectory vfDir = new VirtualFilesystemDirectory(diskDir.Name);
dir.Children.Add(vfDir);
ImportFromDiskRecursive(diskDir.FullName, vfDir);
}
foreach (var diskFile in dirInfo.GetFiles())
{
using (BinaryReader reader = new BinaryReader(File.Open(diskFile.FullName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)))
{
string fileName = Path.GetFileNameWithoutExtension(diskFile.Name);
string fileExt = Path.GetExtension(diskFile.Name);
byte[] data = reader.ReadBytes((int)reader.BaseStream.Length);
VirtualFilesystemFile vfFile = new VirtualFilesystemFile(fileName, fileExt, data);
dir.Children.Add(vfFile);
}
}
}
public VirtualFilesystemFile GetFileAtPath(string relativePath)
{
// Search for the next directory indicator (Either '/' or '\') to see if we need to navigate into a subfolder.
int dirIndicator = relativePath.IndexOf("/");
if (dirIndicator < 0)
{
dirIndicator = relativePath.IndexOf("\\");
}
// There is a sub-folder to navigate into. Search our children for this folder.
if (dirIndicator >= 0)
{
string folderName = relativePath.Substring(0, dirIndicator);
foreach (var child in Children)
{
if (child.Type == NodeType.File)
{
continue;
}
if (child.Name == folderName)
{
return(((VirtualFilesystemDirectory)child).GetFileAtPath(relativePath.Substring(dirIndicator + 1)));
}
}
// They requested a directory which doesn't exist as a child of this current directory. Thus, our search ends here.
return(null);
}
else
{
// We're looking for children.
foreach (var child in Children)
{
if (child.Type == NodeType.Directory)
{
continue;
}
VirtualFilesystemFile file = (VirtualFilesystemFile)child;
if (file.NameWithExtension == relativePath)
{
return(file);
}
}
// They requested a file which doesn't exist as a child of this current directory.
return(null);
}
}
private void ExportToDiskRecursive(string folder, VirtualFilesystemDirectory dir)
{
// Create the directory that this node represents.
// If it's a directory, append the directory name to the folder and onwards!
folder = string.Format("{0}{1}/", folder, dir.Name);
try
{
Directory.CreateDirectory(folder);
}
catch (Exception ex)
{
Console.WriteLine("Caught exception while trying to create folder {0}: {1}", folder, ex.ToString());
}
foreach (var node in dir.Children)
{
VirtualFilesystemDirectory vfDir = node as VirtualFilesystemDirectory;
VirtualFilesystemFile vfFile = node as VirtualFilesystemFile;
if (vfDir != null)
{
ExportToDiskRecursive(folder, vfDir);
}
else if (vfFile != null)
{
// However, if it's a file we're going to write it to disk.
string filePath = string.Format("{0}{1}{2}", folder, vfFile.Name, vfFile.Extension);
try
{
using (EndianBinaryWriter writer = new EndianBinaryWriter(File.Create(filePath), Endian.Big))
{
writer.Write(vfFile.Data);
}
}
catch (Exception ex)
{
Console.WriteLine("Caught exception while trying to write file {0}: {1}", filePath, ex.ToString());
}
}
}
}
/// <summary>
/// Returns the file whose node has the given NodeID, or null if there is no such file. Searches
/// all child directories recursively to look for the file.
/// </summary>
/// <param name="id">NodeID</param>
/// <returns>File with a matching NodeID</returns>
public VirtualFilesystemFile FindByID(ushort id)
{
VirtualFilesystemFile foundFile = null;
foreach (VirtualFilesystemNode child in Children)
{
if (child.Type == NodeType.File)
{
if (child.NodeID == id)
{
foundFile = child as VirtualFilesystemFile;
}
}
else if (child.Type == NodeType.Directory)
{
VirtualFilesystemDirectory dir = (VirtualFilesystemDirectory)child;
foundFile = dir.FindByID(id);
}
}
return(foundFile);
}
public VirtualFilesystemDirectory ReadFile(EndianBinaryReader reader)
{
if (reader.ReadUInt32() != 0x52415243) // "RARC"
throw new InvalidDataException("Invalid Magic, not a RARC File");
uint fileSize = reader.ReadUInt32();
reader.SkipUInt32(); // Unknown
uint dataOffset = reader.ReadUInt32() + 0x20;
reader.Skip(16); // Unknown - 4 unsigned ints
uint numNodes = reader.ReadUInt32();
reader.Skip(8); // Unknown - 2 unsigned ints
uint fileEntryOffset = reader.ReadUInt32() + 0x20;
reader.SkipUInt32(); // Unknown
uint stringTableOffset = reader.ReadUInt32() + 0x20;
reader.Skip(8); // Unknown - 2 unsigned ints.
// Read all of the node headers.
Node[] nodes = new Node[numNodes];
for (int i = 0; i < numNodes; i++)
{
nodes[i] = new Node
{
Type = new string(reader.ReadChars(4)),
Name = ReadStringAtOffset(reader, stringTableOffset, reader.ReadUInt32()),
NameHashcode = reader.ReadUInt16(),
Entries = new FileEntry[reader.ReadUInt16()],
FirstFileOffset = reader.ReadUInt32()
};
}
// Create a virtual directory for every folder within the ARC before we process any of them.
List<VirtualFilesystemDirectory> allDirs = new List<VirtualFilesystemDirectory>(nodes.Length);
foreach (Node node in nodes)
{
VirtualFilesystemDirectory vfDir = new VirtualFilesystemDirectory(node.Name);
allDirs.Add(vfDir);
}
for (int k = 0; k < nodes.Length; k++)
{
Node node = nodes[k];
VirtualFilesystemDirectory curDir = allDirs[k];
for (int i = 0; i < node.Entries.Length; i++)
{
// Jump to the entry's offset in the file.
reader.BaseStream.Position = fileEntryOffset + ((node.FirstFileOffset + i) * 0x14); // 0x14 is the size of a File Entry in bytes
node.Entries[i] = new FileEntry();
node.Entries[i].ID = reader.ReadUInt16();
node.Entries[i].NameHashcode = reader.ReadUInt16();
node.Entries[i].Type = reader.ReadByte();
reader.SkipByte(); // Padding
node.Entries[i].Name = ReadStringAtOffset(reader, stringTableOffset, reader.ReadUInt16());
// Skip these ones cause I don't know how computers work.
if (node.Entries[i].Name == "." || node.Entries[i].Name == "..")
continue;
uint entryDataOffset = reader.ReadUInt32();
uint dataSize = reader.ReadUInt32();
// If it's a directory, then entryDataOffset contains the index of the parent node
if (node.Entries[i].IsDirectory)
{
node.Entries[i].SubDirIndex = entryDataOffset;
var newSubDir = allDirs[(int)entryDataOffset];
curDir.Children.Add(newSubDir);
}
else
{
node.Entries[i].Data = reader.ReadBytesAt(dataOffset + entryDataOffset, (int)dataSize);
string fileName = Path.GetFileNameWithoutExtension(node.Entries[i].Name);
string extension = Path.GetExtension(node.Entries[i].Name);
var vfFileContents = new VirtualFileContents(node.Entries[i].Data);
VirtualFilesystemFile vfFile = new VirtualFilesystemFile(fileName, extension, vfFileContents);
curDir.Children.Add(vfFile);
}
reader.SkipInt32(); // Padding
}
}
// The ROOT directory should always be the first node. We don't have access to the node's TYPE anymore
// so we're going to assume its always the first one listed.
return allDirs.Count > 0 ? allDirs[0] : null;
}
private void ImportFromDiskRecursive(string folder, VirtualFilesystemDirectory dir)
{
if (!Directory.Exists(folder))
throw new ArgumentException("You must specify a directory that exists", "folder");
// For each directory that is a child of the specified folder into ourselves, and then import the contents.
DirectoryInfo dirInfo = new DirectoryInfo(folder);
foreach(var diskDir in dirInfo.GetDirectories())
{
VirtualFilesystemDirectory vfDir = new VirtualFilesystemDirectory(diskDir.Name);
dir.Children.Add(vfDir);
ImportFromDiskRecursive(diskDir.FullName, vfDir);
}
foreach(var diskFile in dirInfo.GetFiles())
{
using(BinaryReader reader = new BinaryReader(File.Open(diskFile.FullName, FileMode.Open, FileAccess.Read, FileShare.ReadWrite)))
{
string fileName = Path.GetFileNameWithoutExtension(diskFile.Name);
string fileExt = Path.GetExtension(diskFile.Name);
byte[] data = reader.ReadBytes((int)reader.BaseStream.Length);
VirtualFilesystemFile vfFile = new VirtualFilesystemFile(fileName, fileExt, new VirtualFileContents(data));
dir.Children.Add(vfFile);
}
}
}
