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);
}
}
}
/// <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 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.File.GetData());
}
}
catch (Exception ex)
{
Console.WriteLine("Caught exception while trying to write file {0}: {1}", filePath, ex.ToString());
}
}
}
}
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
{
ID = reader.ReadUInt16(),
NameHashcode = reader.ReadUInt16(),
Type = reader.ReadByte(),
Padding = reader.ReadByte(),
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);
}
node.Entries[i].ZeroPadding = reader.ReadUInt32();
}
}
// 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);
}
}
}
