private static void HandleEntries(IEnumerable <ulong> entries,
HashList <ulong> knownHashes,
Tracking tracking,
Breakdown breakdown,
string outputPath)
{
var localBreakdown = new Breakdown();
var localNames = new List <string>();
var localHashes = entries.ToArray();
foreach (var hash in localHashes)
{
var name = knownHashes[hash];
if (name != null)
{
localNames.Add(name);
}
localBreakdown.Total++;
}
tracking.Hashes.AddRange(localHashes);
tracking.Names.AddRange(localNames);
var distinctLocalNames = localNames.Distinct().ToArray();
localBreakdown.Known += distinctLocalNames.Length;
breakdown.Known += localBreakdown.Known;
breakdown.Total += localBreakdown.Total;
var outputParent = Path.GetDirectoryName(outputPath);
if (string.IsNullOrEmpty(outputParent) == false)
{
Directory.CreateDirectory(outputParent);
}
using (var writer = new StringWriter())
{
writer.WriteLine("; {0}", localBreakdown);
foreach (string name in distinctLocalNames.OrderBy(dn => dn))
{
writer.WriteLine(name);
}
writer.Flush();
using (var output = new StreamWriter(outputPath))
{
output.Write(writer.GetStringBuilder());
}
}
}
public static void Main(string[] args)
{
bool showHelp = false;
string currentProject = null;
var options = new OptionSet()
{
{ "h|help", "show this message and exit", v => showHelp = v != null },
{ "p|project=", "override current project", v => currentProject = v },
};
List <string> extras;
try
{
extras = options.Parse(args);
}
catch (OptionException e)
{
Console.Write("{0}: ", GetExecutableName());
Console.WriteLine(e.Message);
Console.WriteLine("Try `{0} --help' for more information.", GetExecutableName());
return;
}
if (extras.Count != 0 || showHelp == true)
{
Console.WriteLine("Usage: {0} [OPTIONS]+", GetExecutableName());
Console.WriteLine();
Console.WriteLine("Options:");
options.WriteOptionDescriptions(Console.Out);
return;
}
Console.WriteLine("Loading project...");
var manager = Manager.Load(currentProject);
if (manager.ActiveProject == null)
{
Console.WriteLine("Nothing to do: no active project loaded.");
return;
}
var project = manager.ActiveProject;
HashList <ulong> knownHashes = null;
var installPath = project.InstallPath;
var listsPath = project.ListsPath;
if (installPath == null)
{
Console.WriteLine("Could not detect install path.");
return;
}
if (listsPath == null)
{
Console.WriteLine("Could not detect lists path.");
return;
}
Console.WriteLine("Searching for archives...");
var archivePaths = new List <string>();
archivePaths.AddRange(Directory.GetFiles(installPath, "*.a", SearchOption.AllDirectories));
archivePaths.RemoveAll(p => p.Contains("_unpack") == true);
var outputPaths = new List <string>();
var breakdown = new Breakdown();
var tracking = new Tracking();
Console.WriteLine("Processing...");
for (int i = 0; i < archivePaths.Count; i++)
{
var archivePath = archivePaths[i];
var outputPath = GetListPath(installPath, archivePath);
if (outputPath == null)
{
throw new InvalidOperationException();
}
Console.WriteLine(outputPath);
outputPath = Path.Combine(listsPath, outputPath);
if (outputPaths.Contains(outputPath) == true)
{
throw new InvalidOperationException();
}
outputPaths.Add(outputPath);
if (File.Exists(archivePath + ".bak") == true)
{
archivePath += ".bak";
}
using (var input = File.OpenRead(archivePath))
{
IArchiveFile archive;
if (ArchiveFile.IsValid(input) == true)
{
archive = new ArchiveFile();
}
else if (Gibbed.Antibirth.FileFormats.ArchiveFile.IsValid(input) == true)
{
archive = new Gibbed.Antibirth.FileFormats.ArchiveFile();
}
else
{
throw new NotSupportedException();
}
archive.Deserialize(input);
knownHashes = manager.LoadListsFileNames();
if (knownHashes == null)
{
throw new InvalidOperationException();
}
HandleEntries(archive.Entries.Select(e => e.NameHash).Distinct(),
knownHashes,
tracking,
breakdown,
outputPath);
}
}
using (var output = new StreamWriter(Path.Combine(Path.Combine(listsPath, "files"), "status.txt")))
{
output.WriteLine(
"{0}",
new Breakdown()
{
Known = tracking.Names.Distinct().Count(),
Total = tracking.Hashes.Distinct().Count(),
});
}
}
public static void Main(string[] args)
{
bool showHelp = false;
string currentProject = null;
var options = new OptionSet()
{
{ "h|help", "show this message and exit", v => showHelp = v != null },
{ "p|project=", "override current project", v => currentProject = v },
};
List <string> extras;
try
{
extras = options.Parse(args);
}
catch (OptionException e)
{
Console.Write("{0}: ", GetExecutableName());
Console.WriteLine(e.Message);
Console.WriteLine("Try `{0} --help' for more information.", GetExecutableName());
return;
}
if (extras.Count != 0 || showHelp == true)
{
Console.WriteLine("Usage: {0} [OPTIONS]+", GetExecutableName());
Console.WriteLine();
Console.WriteLine("Options:");
options.WriteOptionDescriptions(Console.Out);
return;
}
Console.WriteLine("Loading project...");
var manager = Gibbed.ProjectData.Manager.Load(currentProject);
if (manager.ActiveProject == null)
{
Console.WriteLine("Nothing to do: no active project loaded.");
return;
}
var project = manager.ActiveProject;
var hashes = manager.LoadFileLists(null);
var installPath = project.InstallPath;
var listsPath = project.ListsPath;
if (installPath == null)
{
Console.WriteLine("Could not detect install path.");
return;
}
if (listsPath == null)
{
Console.WriteLine("Could not detect lists path.");
return;
}
Console.WriteLine("Searching for archives...");
var inputPaths = new List <string>();
var locations = new Dictionary <string, string>()
{
{ "archives_win64", "game*.tab" },
{ "dlc_win64", "*.tab" },
{ "patch_win64", "*.tab" },
};
foreach (var kv in locations)
{
var locationPath = Path.Combine(installPath, kv.Key);
if (Directory.Exists(locationPath) == true)
{
inputPaths.AddRange(Directory.GetFiles(locationPath, kv.Value, SearchOption.AllDirectories));
}
}
var outputPaths = new List <string>();
var breakdown = new Breakdown();
var allNames = new List <string>();
Console.WriteLine("Processing...");
foreach (var inputPath in inputPaths)
{
var outputPath = GetListPath(installPath, inputPath);
if (outputPath == null)
{
throw new InvalidOperationException();
}
Console.WriteLine(outputPath);
outputPath = Path.Combine(listsPath, outputPath);
if (outputPaths.Contains(outputPath) == true)
{
throw new InvalidOperationException();
}
outputPaths.Add(outputPath);
var tab = new ArchiveTableFile();
if (File.Exists(inputPath + ".bak") == true)
{
using (var input = File.OpenRead(inputPath + ".bak"))
{
tab.Deserialize(input);
}
}
else
{
using (var input = File.OpenRead(inputPath))
{
tab.Deserialize(input);
}
}
var localBreakdown = new Breakdown();
var names = new List <string>();
foreach (var nameHash in tab.Entries.Select(kv => kv.NameHash).Distinct())
{
var name = hashes[nameHash];
if (name != null)
{
if (names.Contains(name) == false)
{
names.Add(name);
localBreakdown.Known++;
}
if (allNames.Contains(name) == false)
{
allNames.Add(name);
}
}
localBreakdown.Total++;
}
breakdown.Known += localBreakdown.Known;
breakdown.Total += localBreakdown.Total;
names.Sort();
Directory.CreateDirectory(Path.GetDirectoryName(outputPath));
using (var output = new StreamWriter(outputPath))
{
output.WriteLine("; {0}", localBreakdown);
foreach (string name in names)
{
output.WriteLine(name);
}
}
}
allNames.Sort();
using (var output = File.Create(Path.Combine(listsPath, "files", "status.txt")))
using (var writer = new StreamWriter(output))
{
writer.WriteLine("{0}", breakdown);
}
}
public static void Main(string[] args)
{
bool showHelp = false;
string currentProject = null;
var options = new OptionSet()
{
{ "h|help", "show this message and exit", v => showHelp = v != null },
{ "p|project=", "override current project", v => currentProject = v },
};
List <string> extras;
try
{
extras = options.Parse(args);
}
catch (OptionException e)
{
Console.Write("{0}: ", GetExecutableName());
Console.WriteLine(e.Message);
Console.WriteLine("Try `{0} --help' for more information.", GetExecutableName());
return;
}
if (extras.Count != 0 || showHelp == true)
{
Console.WriteLine("Usage: {0} [OPTIONS]+", GetExecutableName());
Console.WriteLine();
Console.WriteLine("Options:");
options.WriteOptionDescriptions(Console.Out);
return;
}
Console.WriteLine("Loading project...");
var manager = Manager.Load(currentProject);
if (manager.ActiveProject == null)
{
Console.WriteLine("Nothing to do: no active project loaded.");
return;
}
var project = manager.ActiveProject;
var version = -1;
HashList <ulong> knownHashes = null;
HashList <ulong> subFatHashes = null;
var installPath = project.InstallPath;
var listsPath = project.ListsPath;
if (installPath == null)
{
Console.WriteLine("Could not detect install path.");
return;
}
if (listsPath == null)
{
Console.WriteLine("Could not detect lists path.");
return;
}
Console.WriteLine("Searching for archives...");
var fatPaths = new List <string>();
fatPaths.AddRange(Directory.GetFiles(installPath, "*.fat", SearchOption.AllDirectories));
var outputPaths = new List <string>();
var breakdown = new Breakdown();
var tracking = new Tracking();
Console.WriteLine("Processing...");
for (int i = 0; i < fatPaths.Count; i++)
{
var fatPath = fatPaths[i];
var datPath = Path.ChangeExtension(fatPath, ".dat");
var outputPath = GetListPath(installPath, fatPath);
if (outputPath == null)
{
throw new InvalidOperationException();
}
Console.WriteLine(outputPath);
outputPath = Path.Combine(listsPath, outputPath);
if (outputPaths.Contains(outputPath) == true)
{
throw new InvalidOperationException();
}
outputPaths.Add(outputPath);
if (File.Exists(fatPath + ".bak") == true)
{
fatPath += ".bak";
datPath += ".bak";
}
var fat = new BigFile();
using (var input = File.OpenRead(fatPath))
{
fat.Deserialize(input);
}
if (version == -1)
{
version = fat.Version;
knownHashes = manager.LoadListsFileNames(fat.Version);
subFatHashes = manager.LoadListsSubFatNames(fat.Version);
}
else if (version != fat.Version)
{
throw new InvalidOperationException();
}
if (knownHashes == null ||
subFatHashes == null)
{
throw new InvalidOperationException();
}
HandleEntries(fat.Entries.Select(e => e.NameHash).Distinct(),
knownHashes,
tracking,
breakdown,
outputPath);
using (var input = File.OpenRead(datPath))
{
foreach (var headerEntry in fat.Entries.Where(e => subFatHashes.Contains(e.NameHash) == true))
{
var subFat = new SubFatFile();
using (var temp = new MemoryStream())
{
Big.EntryDecompression.Decompress(headerEntry, input, temp);
temp.Position = 0;
subFat.Deserialize(temp, fat);
}
var matchingSubFats = fat.SubFats
.Where(sf => subFat.Entries.SequenceEqual(sf.Entries))
.ToArray();
if (matchingSubFats.Length == 0)
{
continue;
}
if (matchingSubFats.Length > 1)
{
throw new InvalidOperationException();
}
var subfatPath = GetListPath(installPath,
fatPath,
FilterEntryName(subFatHashes[headerEntry.NameHash]));
if (subfatPath == null)
{
throw new InvalidOperationException();
}
Console.WriteLine(subfatPath);
subfatPath = Path.Combine(listsPath, subfatPath);
HandleEntries(subFat.Entries.Select(e => e.NameHash),
knownHashes,
tracking,
breakdown,
subfatPath);
}
}
}
using (var output = new StreamWriter(Path.Combine(Path.Combine(listsPath, "files"), "status.txt")))
{
output.WriteLine("{0}",
new Breakdown()
{
Known = tracking.Names.Distinct().Count(),
Total = tracking.Hashes.Distinct().Count(),
});
}
}
public static void Main(string[] args)
{
bool showHelp = false;
var options = new OptionSet()
{
{
"h|help",
"show this message and exit",
v => showHelp = v != null
},
};
List <string> extras;
try
{
extras = options.Parse(args);
}
catch (OptionException e)
{
Console.Write("{0}: ", GetExecutableName());
Console.WriteLine(e.Message);
Console.WriteLine("Try `{0} --help' for more information.", GetExecutableName());
return;
}
if (extras.Count != 0 || showHelp == true)
{
Console.WriteLine("Usage: {0} [OPTIONS]+", GetExecutableName());
Console.WriteLine();
Console.WriteLine("Options:");
options.WriteOptionDescriptions(Console.Out);
return;
}
Console.WriteLine("Loading project...");
var manager = ProjectData.Manager.Load();
if (manager.ActiveProject == null)
{
Console.WriteLine("Nothing to do: no active project loaded.");
return;
}
var project = manager.ActiveProject;
var hashes = project.LoadLists(
"*.filelist",
s => s.HashFileNameCRC32(),
s => s.ToLowerInvariant());
var installPath = project.InstallPath;
var listsPath = project.ListsPath;
if (installPath == null)
{
Console.WriteLine("Could not detect install path.");
return;
}
else if (listsPath == null)
{
Console.WriteLine("Could not detect lists path.");
return;
}
Console.WriteLine("Searching for archives...");
var inputPaths = new List <string>();
inputPaths.AddRange(Directory.GetFiles(installPath, "*.fat", SearchOption.AllDirectories));
var outputPaths = new List <string>();
Console.WriteLine("Processing...");
foreach (var inputPath in inputPaths)
{
// f**k you, colliding fat *g*
if (Path.GetFileNameWithoutExtension(inputPath).ToLowerInvariant()
== "shadersobj")
{
continue;
}
var outputPath = GetListPath(installPath, inputPath);
if (outputPath == null)
{
throw new InvalidOperationException();
}
Console.WriteLine(outputPath);
outputPath = Path.Combine(listsPath, outputPath);
if (outputPaths.Contains(outputPath) == true)
{
throw new InvalidOperationException();
}
outputPaths.Add(outputPath);
var big = new BigFile();
if (File.Exists(inputPath + ".bak") == true)
{
using (var input = File.OpenRead(inputPath + ".bak"))
{
big.Deserialize(input);
}
}
else
{
using (var input = File.OpenRead(inputPath))
{
big.Deserialize(input);
}
}
var localBreakdown = new Breakdown();
var names = new List <string>();
foreach (var entry in big.Entries)
{
if (entry.UncompressedSize == 4680308)
{
}
var name = hashes[entry.NameHash];
if (name != null)
{
if (names.Contains(name) == false)
{
names.Add(name);
localBreakdown.Known++;
}
}
localBreakdown.Total++;
}
names.Sort();
Directory.CreateDirectory(Path.GetDirectoryName(outputPath));
using (var output = new StreamWriter(outputPath))
{
output.WriteLine("; {0}", localBreakdown);
foreach (string name in names)
{
output.WriteLine(name);
}
}
}
}
public static void Main(string[] args)
{
bool showHelp = false;
OptionSet options = new OptionSet()
{
{
"h|help",
"show this message and exit",
v => showHelp = v != null
},
};
List <string> extras;
try
{
extras = options.Parse(args);
}
catch (OptionException e)
{
Console.Write("{0}: ", GetExecutableName());
Console.WriteLine(e.Message);
Console.WriteLine("Try `{0} --help' for more information.", GetExecutableName());
return;
}
if (extras.Count != 0 || showHelp == true)
{
Console.WriteLine("Usage: {0} [OPTIONS]+", GetExecutableName());
Console.WriteLine();
Console.WriteLine("Options:");
options.WriteOptionDescriptions(Console.Out);
return;
}
Console.WriteLine("Loading project...");
var manager = Setup.Manager.Load();
if (manager.ActiveProject == null)
{
Console.WriteLine("Nothing to do: no active project loaded.");
return;
}
var project = manager.ActiveProject;
var installPath = project.InstallPath;
var listsPath = project.ListsPath;
if (installPath == null)
{
Console.WriteLine("Could not detect install path.");
return;
}
else if (listsPath == null)
{
Console.WriteLine("Could not detect lists path.");
return;
}
Console.WriteLine("Searching for packages...");
var inputPaths = new List <string>();
inputPaths.AddRange(Directory.GetFiles(installPath, "*.sdpk2", SearchOption.AllDirectories));
var outputPaths = new List <string>();
Console.WriteLine("Processing...");
foreach (var inputpath in inputPaths)
{
var outputPath = GetListPath(installPath, inputpath);
if (outputPath == null)
{
throw new InvalidOperationException();
}
Console.WriteLine(outputPath);
outputPath = Path.Combine(listsPath, outputPath);
if (outputPaths.Contains(outputPath) == true)
{
throw new InvalidOperationException();
}
outputPaths.Add(outputPath);
var pkg = new PackageFile();
using (var input = File.OpenRead(inputpath))
{
pkg.Deserialize(input);
}
var localBreakdown = new Breakdown();
var names = new List <string>();
foreach (var entry in pkg.Entries)
{
var name = project.GetFileName(entry.NameHash);
if (name != null)
{
if (names.Contains(name) == false)
{
names.Add(name);
localBreakdown.Known++;
}
}
localBreakdown.Total++;
}
names.Sort();
Directory.CreateDirectory(Path.GetDirectoryName(outputPath));
using (var output = new StreamWriter(outputPath))
{
output.WriteLine("; {0}", localBreakdown);
foreach (string name in names)
{
output.WriteLine(name);
}
}
}
}
