claunia/SabreTools
1
0
Fork 0
mirror of https://github.com/claunia/SabreTools.git synced 2025-12-16 19:14:27 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
d379ef59ab4b454e52a691517b4fb772de818c86
SabreTools/SabreTools/SabreTools.Help.cs
Matt Nadareski d379ef59ab [FIleTypes/] Migrate to individual input/output types 
Similar to the migration of splitting DatFile into ifferent subtypes, this makes sure that logic that petains to each "type" of file that's used by SabreTools, be it an input/output archive format or a specialty file format that is treated by itself like CHDs, is in tis own namespace. ArchiveTools has been pared down accordingly and all "factory" logic should make it easier to add more formats in the future with little fuss.
2017-11-02 00:29:20 -07:00

1544 lines
49 KiB
C#
Raw Blame History

using System.Collections.Generic;
using SabreTools.Library.Data;
using SabreTools.Library.Help;
namespace SabreTools
{
public partial class SabreTools
{
// TODO: Add 1G1R to the flags for update
public static Help RetrieveHelp()
{
// Create and add the header to the Help object
string barrier = "-----------------------------------------";
List<string> helpHeader = new List<string>()
{
"SabreTools - Manipulate, convert, and use DAT files",
barrier,
"Usage: SabreTools [option] [flags] [filename|dirname] ...",
""
};
Help help = new Help(helpHeader);
// Create the Help feature
Feature helpFeature = new Feature(
new List<string>() { "-?", "-h", "--help" },
"Show this help",
FeatureType.Flag,
null);
// Create the Script feature
Feature script = new Feature(
"--script",
"Enable script mode (no clear screen)",
FeatureType.Flag,
null);
// Create the DATFromDir feature
Feature datFromDir = new Feature(
new List<string>() { "-d", "--d2d", "--dfd" },
"Create DAT(s) from an input directory",
FeatureType.Flag,
null);
datFromDir.AddFeature("noMD5", new Feature(
new List<string>() { "-nm", "--noMD5" },
"Don't include MD5 in output",
FeatureType.Flag,
null));
datFromDir.AddFeature("noSHA1", new Feature(
new List<string>() { "-ns", "--noSHA1" },
"Don't include SHA1 in output",
FeatureType.Flag,
null));
datFromDir.AddFeature("noSHA256", new Feature(
new List<string>() { "-ns256", "--noSHA256" },
"Include SHA-256 in output", // TODO: Invert this later
FeatureType.Flag,
null));
datFromDir.AddFeature("noSHA384", new Feature(
new List<string>() { "-ns384", "--noSHA384" },
"Include SHA-384 in output", // TODO: Invert this later
FeatureType.Flag,
null));
datFromDir.AddFeature("noSHA512", new Feature(
new List<string>() { "-ns512", "--noSHA512" },
"Include SHA-512 in output", // TODO: Invert this later
FeatureType.Flag,
null));
datFromDir.AddFeature("bare", new Feature(
new List<string>() { "-b", "--bare" },
"Don't include date in file name",
FeatureType.Flag,
null));
datFromDir.AddFeature("forcepack", new Feature(
new List<string>() { "-fp", "--forcepack" },
"Set force packing",
FeatureType.String,
new List<string>()
{
"Supported values are:",
" None, Zip, Unzip",
}));
datFromDir.AddFeature("files", new Feature(
new List<string>() { "-f", "--files" },
"Treat archives as files",
FeatureType.Flag,
null));
datFromDir.AddFeature("output-all", new Feature(
new List<string>() { "-oa", "--output-all" },
"Output in all formats",
FeatureType.Flag,
null));
datFromDir.AddFeature("output-am", new Feature(
new List<string>() { "-oam", "--output-am" },
"Output in AttractMode format",
FeatureType.Flag,
null));
datFromDir.AddFeature("output-cmp", new Feature(
new List<string>() { "-oc", "--output-cmp" },
"Output in CMP format",
FeatureType.Flag,
null));
datFromDir.AddFeature("output-csv", new Feature(
new List<string>() { "-ocsv", "--output-csv" },
"Output in CSV format",
FeatureType.Flag,
null));
datFromDir.AddFeature("output-dc", new Feature(
new List<string>() { "-od", "--output-dc" },
"Output in DOSCenter format",
FeatureType.Flag,
null));
datFromDir.AddFeature("output-lr", new Feature(
new List<string>() { "-olr", "--output-lr" },
"Output in MAME Listrom format",
FeatureType.Flag,
null));
datFromDir.AddFeature("output-miss", new Feature(
new List<string>() { "-om", "--output-miss" },
"Output in Missfile format",
FeatureType.Flag,
null));
datFromDir.AddFeature("output-md5", new Feature(
new List<string>() { "-omd5", "--output-md5" },
"Output in MD5 format",
FeatureType.Flag,
null));
datFromDir.AddFeature("output-ol", new Feature(
new List<string>() { "-ool", "--output-ol" },
"Output in OfflineList format",
FeatureType.Flag,
null));
datFromDir.AddFeature("output-rc", new Feature(
new List<string>() { "-or", "--output-rc" },
"Output in RomCenter format",
FeatureType.Flag,
null));
datFromDir.AddFeature("output-sd", new Feature(
new List<string>() { "-os", "--output-sd" },
"Output in SabreDat format",
FeatureType.Flag,
null));
datFromDir.AddFeature("output-sfv", new Feature(
new List<string>() { "-osfv", "--output-sfv" },
"Output in SFV format",
FeatureType.Flag,
null));
datFromDir.AddFeature("output-sha1", new Feature(
new List<string>() { "-osha1", "--output-sha1" },
"Output in SHA-1 format",
FeatureType.Flag,
null));
datFromDir.AddFeature("output-sha256", new Feature(
new List<string>() { "-osha256", "--output-sha256" },
"Output in SHA-256 format",
FeatureType.Flag,
null));
datFromDir.AddFeature("output-sha384", new Feature(
new List<string>() { "-osha384", "--output-sha384" },
"Output in SHA-256 format",
FeatureType.Flag,
null));
datFromDir.AddFeature("output-sha512", new Feature(
new List<string>() { "-osha512", "--output-sha512" },
"Output in SHA-256 format",
FeatureType.Flag,
null));
datFromDir.AddFeature("output-sl", new Feature(
new List<string>() { "-osl", "--output-sl" },
"Output in Softwarelist format",
FeatureType.Flag,
null));
datFromDir.AddFeature("output-tsv", new Feature(
new List<string>() { "-otsv", "--output-tsv" },
"Output in TSV format",
FeatureType.Flag,
null));
datFromDir.AddFeature("output-xml", new Feature(
new List<string>() { "-ox", "--output-xml" },
"Output in Logiqx XML format [default]",
FeatureType.Flag,
null));
datFromDir.AddFeature("romba", new Feature(
new List<string>() { "-ro", "--romba" },
"Read files from a Romba input",
FeatureType.Flag,
null));
datFromDir.AddFeature("skiparc", new Feature(
new List<string>() { "-ska", "--skiparc" },
"Skip any files that are treated like archives",
FeatureType.Flag,
null));
datFromDir.AddFeature("skipfile", new Feature(
new List<string>() { "-skf", "--skipfile" },
"Skip any files that are not treated like archives",
FeatureType.Flag,
null));
datFromDir.AddFeature("filename", new Feature(
new List<string>() { "-f", "--filename" },
"Set the external name of the DAT",
FeatureType.String,
null));
datFromDir.AddFeature("name", new Feature(
new List<string>() { "-n", "--name" },
"Set the internal name of the DAT",
FeatureType.String,
null));
datFromDir.AddFeature("desc", new Feature(
new List<string>() { "-de", "--desc" },
"Set the description of the DAT",
FeatureType.String,
null));
datFromDir.AddFeature("cat", new Feature(
new List<string>() { "-c", "--cat" },
"Set the category of the DAT",
FeatureType.String,
null));
datFromDir.AddFeature("version", new Feature(
new List<string>() { "-v", "--version" },
"Set the version of the DAT",
FeatureType.String,
null));
datFromDir.AddFeature("author", new Feature(
new List<string>() { "-au", "--author" },
"Set the author of the DAT",
FeatureType.String,
null));
datFromDir.AddFeature("email", new Feature(
new List<string>() { "-em", "--email" },
"Set a new email of the DAT",
FeatureType.String,
null));
datFromDir.AddFeature("homepage", new Feature(
new List<string>() { "-hp", "--homepage" },
"Set a new homepage of the DAT",
FeatureType.String,
null));
datFromDir.AddFeature("url", new Feature(
new List<string>() { "-u", "--url" },
"Set a new URL of the DAT",
FeatureType.String,
null));
datFromDir.AddFeature("comment", new Feature(
new List<string>() { "-co", "--comment" },
"Set a new comment of the DAT",
FeatureType.String,
null));
datFromDir.AddFeature("superdat", new Feature(
new List<string>() { "-sd", "--superdat" },
"Enable SuperDAT creation",
FeatureType.Flag,
null));
datFromDir.AddFeature("exclude-of", new Feature(
new List<string>() { "-xof", "--exclude-of" },
"Exclude romof, cloneof, sampleof tags",
FeatureType.Flag,
null));
datFromDir.AddFeature("scene-date-strip", new Feature(
new List<string>() { "-sds", "--scene-date-strip" },
"Remove date from scene-named sets",
FeatureType.Flag,
null));
datFromDir.AddFeature("add-blank", new Feature(
new List<string>() { "-ab", "--add-blank" },
"Output blank files for folders",
FeatureType.Flag,
null));
datFromDir.AddFeature("add-date", new Feature(
new List<string>() { "-ad", "--add-date" },
"Output dates for each file parsed",
FeatureType.Flag,
null));
datFromDir.AddFeature("copy-files", new Feature(
new List<string>() { "-cf", "--copy-files" },
"Copy files to the temp directory before parsing",
FeatureType.Flag,
null));
datFromDir.AddFeature("header", new Feature(
new List<string>() { "-h", "--header" },
"Set a header skipper to use, blank means all",
FeatureType.Flag,
null));
datFromDir.AddFeature("ignore-chd", new Feature(
new List<string>() { "-ic", "--ignore-chd" },
"Treat CHDs as regular files",
FeatureType.Flag,
null));
datFromDir.AddFeature("temp", new Feature(
new List<string>() { "-t", "--temp" },
"Set the temporary directory to use",
FeatureType.String,
null));
datFromDir.AddFeature("out", new Feature(
new List<string>() { "-out", "--out" },
"Output directory",
FeatureType.String,
null));
datFromDir.AddFeature("mt", new Feature(
new List<string>() { "-mt", "--mt" },
"Amount of threads to use (default 4, -1 unlimted)",
FeatureType.String,
null));
// Create the Extract feature
Feature extract = new Feature(
new List<string>() { "-ex", "--extract" },
"Extract and remove copier headers",
FeatureType.Flag,
null);
extract.AddFeature("out", new Feature(
new List<string>() { "-out", "--out" },
"Output directory",
FeatureType.String,
null));
extract.AddFeature("no-store-header", new Feature(
new List<string>() { "-nsh", "--no-store-header" },
"Don't store the extracted header",
FeatureType.Flag,
null));
// Create the Extension Split feature
Feature extSplit = new Feature(
new List<string>() { "-es", "--ext-split" },
"Split DAT(s) by two file extensions",
FeatureType.Flag,
null);
extSplit.AddFeature("exta", new Feature(
new List<string>() { "-exta", "--exta" },
"First extension (multiple allowed)",
FeatureType.List,
null));
extSplit.AddFeature("extb", new Feature(
new List<string>() { "-extb", "--extb" },
"Second extension (multiple allowed)",
FeatureType.List,
null));
extSplit.AddFeature("out", new Feature(
new List<string>() { "-out", "--out" },
"Output directory",
FeatureType.String,
null));
// Create the Hash Split feature
Feature hashSplit = new Feature(
new List<string>() { "-hs", "--hash-split" },
"Split DAT(s) or folder by best-available hashes",
FeatureType.Flag,
null);
hashSplit.AddFeature("out", new Feature(
new List<string>() { "-out", "--out" },
"Output directory",
FeatureType.String,
null));
// Create the Level Split feature
Feature levelSplit = new Feature(
new List<string>() { "-ls", "--lvl-split" },
"Split a SuperDAT or folder by internal path",
FeatureType.Flag,
null);
levelSplit.AddFeature("out", new Feature(
new List<string>() { "-out", "--out" },
"Output directory",
FeatureType.String,
null));
levelSplit.AddFeature("short", new Feature(
new List<string>() { "-s", "--short" },
"Use short output names",
FeatureType.Flag,
null));
levelSplit.AddFeature("base", new Feature(
new List<string>() { "-ba", "--base" },
"Use source DAT as base name for outputs",
FeatureType.Flag,
null));
// Create the Restore feature
Feature restore = new Feature(
new List<string>() { "-re", "--restore" },
"Restore header to file based on SHA-1",
FeatureType.Flag,
null);
restore.AddFeature("out", new Feature(
new List<string>() { "-out", "--out" },
"Output directory",
FeatureType.String,
null));
// Create the Sort feature
Feature sort = new Feature(
new List<string>() { "-ss", "--sort" },
"Sort inputs by a set of DATs",
FeatureType.Flag,
new List<string>()
{
"",
"Archive scanning levels:",
" 0 Hash archive and contents",
" 1 Only hash contents",
" 2 Only hash archive",
});
sort.AddFeature("dat", new Feature(
new List<string>() { "-dat", "--dat" },
"Input DAT to rebuild against",
FeatureType.List,
null));
sort.AddFeature("out", new Feature(
new List<string>() { "-out", "--out" },
"Output directory",
FeatureType.String,
null));
sort.AddFeature("delete", new Feature(
new List<string>() { "-del", "--delete" },
"Delete fully rebuilt input files",
FeatureType.Flag,
null));
sort.AddFeature("inverse", new Feature(
new List<string>() { "-in", "--inverse" },
"Rebuild only files not in DAT",
FeatureType.Flag,
null));
sort.AddFeature("quick", new Feature(
new List<string>() { "-qs", "--quick" },
"Enable quick scanning of archives",
FeatureType.Flag,
null));
sort.AddFeature("ignore-chd", new Feature(
new List<string>() { "-ic", "--ignore-chd" },
"Treat CHDs as regular files",
FeatureType.Flag,
null));
sort.AddFeature("add-date", new Feature(
new List<string>() { "-ad", "--add-date" },
"Add original dates from DAT, if possible",
FeatureType.Flag,
null));
sort.AddFeature("t7z", new Feature(
new List<string>() { "-t7z", "--t7z" },
"Enable Torrent7z output",
FeatureType.Flag,
null));
sort.AddFeature("tar", new Feature(
new List<string>() { "-tar", "--tar" },
"Enable TAR output",
FeatureType.Flag,
null));
sort.AddFeature("tgz", new Feature(
new List<string>() { "-tgz", "--tgz" },
"Enable TorrentGZ output",
FeatureType.Flag,
null));
sort["tgz"].AddFeature("romba", new Feature(
new List<string>() { "-r", "--romba" },
"Enable Romba depot dir output",
FeatureType.Flag,
null));
/*
sort.AddFeature("tlrz", new Feature(
new List<string>() { "-tlrz", "--tlrz" },
"Enable TorrentLRZ output",
FeatureType.Flag,
null));
*/
/*
sort.AddFeature("trar", new Feature(
new List<string>() { "-trar", "--trar" },
"Enable TorrentRAR output",
FeatureType.Flag,
null));
*/
/*
sort.AddFeature("txz", new Feature(
new List<string>() { "-txz", "--txz" },
"Enable TorrentXZ output",
FeatureType.Flag,
null));
*/
sort.AddFeature("tzip", new Feature(
new List<string>() { "-tzip", "--tzip" },
"Enable TorrentZip output",
FeatureType.Flag,
null));
sort.AddFeature("header", new Feature(
new List<string>() { "-h", "--header" },
"Set a header skipper to use, blank means all",
FeatureType.String,
null));
sort.AddFeature("7z", new Feature(
new List<string>() { "-7z", "--7z" },
"Set scanning level for 7z archives (default 1)",
FeatureType.String,
null));
sort.AddFeature("gz", new Feature(
new List<string>() { "-gz", "--gz" },
"Set scanning level for GZip archives (default 1)",
FeatureType.String,
null));
sort.AddFeature("rar", new Feature(
new List<string>() { "-rar", "--rar" },
"Set scanning level for RAR archives (default 1)",
FeatureType.String,
null));
sort.AddFeature("zip", new Feature(
new List<string>() { "-zip", "--zip" },
"Set scanning level for ZIP archives (default 1)",
FeatureType.String,
null));
sort.AddFeature("scan-all", new Feature(
new List<string>() { "-sa", "--scan-all" },
"Set scanning levels for all archives to 0",
FeatureType.Flag,
null));
sort.AddFeature("dat-merged", new Feature(
new List<string>() { "-dm", "--dat-merged" },
"Force creating merged sets",
FeatureType.Flag,
null));
sort.AddFeature("dat-split", new Feature(
new List<string>() { "-ds", "--dat-split" },
"Force creating split sets",
FeatureType.Flag,
null));
sort.AddFeature("dat-nonmerged", new Feature(
new List<string>() { "-dnm", "--dat-nonmerged" },
"Force creating non-merged sets",
FeatureType.Flag,
null));
sort.AddFeature("dat-fullnonmerged", new Feature(
new List<string>() { "-df", "--dat-fullnonmerged" },
"Force creating fully non-merged sets",
FeatureType.Flag,
null));
sort.AddFeature("update-dat", new Feature(
new List<string>() { "-ud", "--update-dat" },
"Output updated DAT to output directory",
FeatureType.Flag,
null));
sort.AddFeature("mt", new Feature(
new List<string>() { "-mt", "--mt" },
"Amount of threads to use (default 4, -1 unlimted)",
FeatureType.String,
null));
// Create the Sort Depot feature
Feature sortDepot = new Feature(
new List<string>() { "-ssd", "--sort-depot" },
"Sort romba depots by a set of DATs",
FeatureType.Flag,
null);
sortDepot.AddFeature("dat", new Feature(
new List<string>() { "-dat", "--dat" },
"Input DAT to rebuild against",
FeatureType.List,
null));
sortDepot.AddFeature("out", new Feature(
new List<string>() { "-out", "--out" },
"Output directory",
FeatureType.String,
null));
sortDepot.AddFeature("delete", new Feature(
new List<string>() { "-del", "--delete" },
"Delete fully rebuilt input files",
FeatureType.Flag,
null));
sortDepot.AddFeature("inverse", new Feature(
new List<string>() { "-in", "--inverse" },
"Rebuild only files not in DAT",
FeatureType.Flag,
null));
sortDepot.AddFeature("add-date", new Feature(
new List<string>() { "-ad", "--add-date" },
"Add original dates from DAT, if possible",
FeatureType.Flag,
null));
sortDepot.AddFeature("t7z", new Feature(
new List<string>() { "-t7z", "--t7z" },
"Enable Torrent7z output",
FeatureType.Flag,
null));
sortDepot.AddFeature("tar", new Feature(
new List<string>() { "-tar", "--tar" },
"Enable TAR output",
FeatureType.Flag,
null));
sortDepot.AddFeature("tgz", new Feature(
new List<string>() { "-tgz", "--tgz" },
"Enable TorrentGZ output",
FeatureType.Flag,
null));
sortDepot["tgz"].AddFeature("romba", new Feature(
new List<string>() { "-r", "--romba" },
"Enable Romba depot dir output",
FeatureType.Flag,
null));
/*
sortDepot.AddFeature("tlrz", new Feature(
new List<string>() { "-tlrz", "--tlrz" },
"Enable TorrentLRZ output",
FeatureType.Flag,
null));
*/
/*
sortDepot.AddFeature("trar", new Feature(
new List<string>() { "-trar", "--trar" },
"Enable TorrentRAR output",
FeatureType.Flag,
null));
*/
/*
sortDepot.AddFeature("txz", new Feature(
new List<string>() { "-txz", "--txz" },
"Enable TorrentXZ output",
FeatureType.Flag,
null));
*/
sortDepot.AddFeature("tzip", new Feature(
new List<string>() { "-tzip", "--tzip" },
"Enable TorrentZip output",
FeatureType.Flag,
null));
sortDepot.AddFeature("header", new Feature(
new List<string>() { "-h", "--header" },
"Set a header skipper to use, blank means all",
FeatureType.String,
null));
sortDepot.AddFeature("dat-merged", new Feature(
new List<string>() { "-dm", "--dat-merged" },
"Force creating merged sets",
FeatureType.Flag,
null));
sortDepot.AddFeature("dat-split", new Feature(
new List<string>() { "-ds", "--dat-split" },
"Force creating split sets",
FeatureType.Flag,
null));
sortDepot.AddFeature("dat-nonmerged", new Feature(
new List<string>() { "-dnm", "--dat-nonmerged" },
"Force creating non-merged sets",
FeatureType.Flag,
null));
sortDepot.AddFeature("dat-fullnonmerged", new Feature(
new List<string>() { "-df", "--dat-fullnonmerged" },
"Force creating fully non-merged sets",
FeatureType.Flag,
null));
sortDepot.AddFeature("update-dat", new Feature(
new List<string>() { "-ud", "--update-dat" },
"Output updated DAT to output directory",
FeatureType.Flag,
null));
sortDepot.AddFeature("mt", new Feature(
new List<string>() { "-mt", "--mt" },
"Amount of threads to use (default 4, -1 unlimted)",
FeatureType.String,
null));
// Create the Stats feature
Feature stats = new Feature(
new List<string>() { "-st", "--stats" },
"Get statistics on all input DATs",
FeatureType.Flag,
null);
stats.AddFeature("baddump-col", new Feature(
new List<string>() { "-bc", "--baddump-col" },
"Add baddump stats to output",
FeatureType.Flag,
null));
stats.AddFeature("csv", new Feature(
new List<string>() { "-csv", "--csv" },
"Output in Comma-Separated Value format",
FeatureType.Flag,
null));
stats.AddFeature("filename", new Feature(
new List<string>() { "-f", "--filename" },
"Set the filename for the output",
FeatureType.String,
null));
stats.AddFeature("out", new Feature(
new List<string>() { "-out", "--out" },
"Output directory",
FeatureType.String,
null));
stats.AddFeature("html", new Feature(
new List<string>() { "-html", "--html" },
"Output in HTML format",
FeatureType.Flag,
null));
stats.AddFeature("nodump-col", new Feature(
new List<string>() { "-nc", "--nodump-col" },
"Add nodump stats to output",
FeatureType.Flag,
null));
stats.AddFeature("single", new Feature(
new List<string>() { "-si", "--single" },
"Show individual statistics",
FeatureType.Flag,
null));
stats.AddFeature("tsv", new Feature(
new List<string>() { "-tsv", "--csv" },
"Output in Tab-Separated Value format",
FeatureType.Flag,
null));
// Create the Type Split feature
Feature typeSplit = new Feature(
new List<string>() { "-ts", "--type-split" },
"Split DAT(s) or folder by file types (rom/disk)",
FeatureType.Flag,
null);
typeSplit.AddFeature("out", new Feature(
new List<string>() { "-out", "--out" },
"Output directory",
FeatureType.String,
null));
// Create the Update feature
Feature update = new Feature(
new List<string>() { "-ud", "--update" },
"Update and manipulate DAT file(s)",
FeatureType.Flag,
new List<string>()
{
"",
"All -diX, --diff-XX flags can be used with each other",
"",
"Filter parameters game name, rom name, all hashes can",
"be matched using full C#-style regex.",
"",
"Filter parameters for size can use postfixes for inputs:",
" e.g. 8kb => 8000 or 8kib => 8192",
"",
"Most of the filter parameters allow for multiple inputs:",
" e.g. --game-name=foo --game-name=bar",
});
update.AddFeature("output-all", new Feature(
new List<string>() { "-oa", "--output-all" },
"Output in all formats",
FeatureType.Flag,
null));
update.AddFeature("output-am", new Feature(
new List<string>() { "-oam", "--output-am" },
"Output in AttractMode format",
FeatureType.Flag,
null));
update.AddFeature("output-cmp", new Feature(
new List<string>() { "-oc", "--output-cmp" },
"Output in CMP format",
FeatureType.Flag,
null));
update.AddFeature("output-csv", new Feature(
new List<string>() { "-ocsv", "--output-csv" },
"Output in CSV format",
FeatureType.Flag,
null));
update["output-csv"].AddFeature("prefix", new Feature(
new List<string>() { "-pre", "--prefix" },
"Set prefix for all lines",
FeatureType.String,
null));
update["output-csv"].AddFeature("postfix", new Feature(
new List<string>() { "-post", "--postfix" },
"Set postfix for all lines",
FeatureType.String,
null));
update["output-csv"].AddFeature("quotes", new Feature(
new List<string>() { "-q", "--quotes" },
"Put double-quotes around each item",
FeatureType.Flag,
null));
update.AddFeature("output-dc", new Feature(
new List<string>() { "-od", "--output-dc" },
"Output in DOSCenter format",
FeatureType.Flag,
null));
update.AddFeature("output-lr", new Feature(
new List<string>() { "-olr", "--output-lr" },
"Output in MAME Listrom format",
FeatureType.Flag,
null));
update.AddFeature("output-miss", new Feature(
new List<string>() { "-om", "--output-miss" },
"Output in Missfile format",
FeatureType.Flag,
new List<string>()
{
"",
"Prefix and postfix can include certain fields from the",
"items by including %blah% in the input.",
"A list of features that can be used are:",
" game, name, crc, md5, sha1, sha256, sha384, sha512, size",
}));
update["output-miss"].AddFeature("roms", new Feature(
new List<string>() { "-r", "--roms" },
"Output roms to miss instead of sets",
FeatureType.Flag,
null));
update["output-miss"].AddFeature("game-prefix", new Feature(
new List<string>() { "-gp", "--game-prefix" },
"Add game name as a prefix",
FeatureType.Flag,
null));
update["output-miss"].AddFeature("prefix", new Feature(
new List<string>() { "-pre", "--prefix" },
"Set prefix for all lines",
FeatureType.String,
null));
update["output-miss"].AddFeature("postfix", new Feature(
new List<string>() { "-post", "--postfix" },
"Set postfix for all lines",
FeatureType.String,
null));
update["output-miss"].AddFeature("quotes", new Feature(
new List<string>() { "-q", "--quotes" },
"Put double-quotes around each item",
FeatureType.Flag,
null));
update["output-miss"].AddFeature("add-ext", new Feature(
new List<string>() { "-ae", "--add-ext" },
"Add an extension to each item",
FeatureType.String,
null));
update["output-miss"].AddFeature("rep-ext", new Feature(
new List<string>() { "-rep", "--rep-ext" },
"Replace all extensions with specified",
FeatureType.String,
null));
update["output-miss"].AddFeature("rem-ext", new Feature(
new List<string>() { "-rme", "--rem-ext" },
"Remove all extensions from each item",
FeatureType.String,
null));
update["output-miss"].AddFeature("romba", new Feature(
new List<string>() { "-ro", "--romba" },
"Output in Romba format (requires SHA-1)",
FeatureType.Flag,
null));
update["output-miss"].AddFeature("tsv", new Feature(
new List<string>() { "-tsv", "--tsv" },
"Output in Tab-Separated Value format",
FeatureType.Flag,
null));
update["output-miss"].AddFeature("csv", new Feature(
new List<string>() { "-csv", "--csv" },
"Output in Comma-Separated Value format",
FeatureType.Flag,
null));
update.AddFeature("output-md5", new Feature(
new List<string>() { "-omd5", "--output-md5" },
"Output in MD5 format",
FeatureType.Flag,
null));
update["output-md5"].AddFeature("game-prefix", new Feature(
new List<string>() { "-gp", "--game-prefix" },
"Add game name as a prefix",
FeatureType.Flag,
null));
update.AddFeature("output-ol", new Feature(
new List<string>() { "-ool", "--output-ol" },
"Output in OfflineList format",
FeatureType.Flag,
null));
update.AddFeature("output-rc", new Feature(
new List<string>() { "-or", "--output-rc" },
"Output in RomCenter format",
FeatureType.Flag,
null));
update.AddFeature("output-sd", new Feature(
new List<string>() { "-os", "--output-sd" },
"Output in SabreDat format",
FeatureType.Flag,
null));
update.AddFeature("output-sfv", new Feature(
new List<string>() { "-osfv", "--output-sfv" },
"Output in SFV format",
FeatureType.Flag,
null));
update["output-sfv"].AddFeature("game-prefix", new Feature(
new List<string>() { "-gp", "--game-prefix" },
"Add game name as a prefix",
FeatureType.Flag,
null));
update.AddFeature("output-sha1", new Feature(
new List<string>() { "-osha1", "--output-sha1" },
"Output in SHA-1 format",
FeatureType.Flag,
null));
update["output-sha1"].AddFeature("game-prefix", new Feature(
new List<string>() { "-gp", "--game-prefix" },
"Add game name as a prefix",
FeatureType.Flag,
null));
update.AddFeature("output-sha256", new Feature(
new List<string>() { "-osha256", "--output-sha256" },
"Output in SHA-256 format",
FeatureType.Flag,
null));
update["output-sha256"].AddFeature("game-prefix", new Feature(
new List<string>() { "-gp", "--game-prefix" },
"Add game name as a prefix",
FeatureType.Flag,
null));
update.AddFeature("output-sha384", new Feature(
new List<string>() { "-osha384", "--output-sha384" },
"Output in SHA-384 format",
FeatureType.Flag,
null));
update["output-sha384"].AddFeature("game-prefix", new Feature(
new List<string>() { "-gp", "--game-prefix" },
"Add game name as a prefix",
FeatureType.Flag,
null));
update.AddFeature("output-sha512", new Feature(
new List<string>() { "-osha512", "--output-sha512" },
"Output in SHA-512 format",
FeatureType.Flag,
null));
update["output-sha512"].AddFeature("game-prefix", new Feature(
new List<string>() { "-gp", "--game-prefix" },
"Add game name as a prefix",
FeatureType.Flag,
null));
update.AddFeature("output-sl", new Feature(
new List<string>() { "-osl", "--output-sl" },
"Output in Softwarelist format",
FeatureType.Flag,
null));
update.AddFeature("output-tsv", new Feature(
new List<string>() { "-otsv", "--output-tsv" },
"Output in TSV format",
FeatureType.Flag,
null));
update["output-tsv"].AddFeature("prefix", new Feature(
new List<string>() { "-pre", "--prefix" },
"Set prefix for all lines",
FeatureType.String,
null));
update["output-tsv"].AddFeature("postfix", new Feature(
new List<string>() { "-post", "--postfix" },
"Set postfix for all lines",
FeatureType.String,
null));
update["output-tsv"].AddFeature("quotes", new Feature(
new List<string>() { "-q", "--quotes" },
"Put double-quotes around each item",
FeatureType.Flag,
null));
update.AddFeature("output-xml", new Feature(
new List<string>() { "-ox", "--output-xml" },
"Output in Logiqx XML format",
FeatureType.Flag,
null));
update.AddFeature("filename", new Feature(
new List<string>() { "-f", "--filename" },
"Set a new filename",
FeatureType.String,
null));
update.AddFeature("name", new Feature(
new List<string>() { "-n", "--name" },
"Set a new internal name",
FeatureType.String,
null));
update.AddFeature("desc", new Feature(
new List<string>() { "-de", "--desc" },
"Set a new description",
FeatureType.String,
null));
update.AddFeature("rootdir", new Feature(
new List<string>() { "-r", "--root" },
"Set a new rootdir",
FeatureType.String,
null));
update.AddFeature("category", new Feature(
new List<string>() { "-ca", "--category" },
"Set a new category",
FeatureType.String,
null));
update.AddFeature("version", new Feature(
new List<string>() { "-v", "--version" },
"Set a new version",
FeatureType.String,
null));
update.AddFeature("date", new Feature(
new List<string>() { "-da", "--date" },
"Set a new date",
FeatureType.String,
null));
update.AddFeature("author", new Feature(
new List<string>() { "-au", "--author" },
"Set a new author",
FeatureType.String,
null));
update.AddFeature("email", new Feature(
new List<string>() { "-em", "--email" },
"Set a new email",
FeatureType.String,
null));
update.AddFeature("homepage", new Feature(
new List<string>() { "-hp", "--homepage" },
"Set a new homepage",
FeatureType.String,
null));
update.AddFeature("url", new Feature(
new List<string>() { "-u", "--url" },
"Set a new URL",
FeatureType.String,
null));
update.AddFeature("comment", new Feature(
new List<string>() { "-co", "--comment" },
"Set a new comment",
FeatureType.String,
null));
update.AddFeature("header", new Feature(
new List<string>() { "-h", "--header" },
"Set a new header skipper",
FeatureType.String,
null));
update.AddFeature("superdat", new Feature(
new List<string>() { "-sd", "--superdat" },
"Set SuperDAT type",
FeatureType.Flag,
null));
update.AddFeature("forcemerge", new Feature(
new List<string>() { "-fm", "--forcemerge" },
"Set force merging",
FeatureType.String,
new List<string>()
{
" Supported values are:",
" None, Split, Full",
}));
update.AddFeature("forcend", new Feature(
new List<string>() { "-fn", "--forcend" },
"Set force nodump",
FeatureType.String,
new List<string>()
{
" Supported values are:",
" None, Obsolete, Required, Ignore",
}));
update.AddFeature("forcepack", new Feature(
new List<string>() { "-fp", "--forcepack" },
"Set force packing",
FeatureType.String,
new List<string>()
{
" Supported values are:",
" None, Zip, Unzip",
}));
update.AddFeature("exclude-of", new Feature(
new List<string>() { "-xof", "--exclude-of" },
"Exclude romof, cloneof, sampleof tags",
FeatureType.Flag,
null));
update.AddFeature("scene-date-strip", new Feature(
new List<string>() { "-sds", "--scene-date-strip" },
"Remove date from scene-named sets",
FeatureType.Flag,
null));
update.AddFeature("clean", new Feature(
new List<string>() { "-clean", "--clean" },
"Clean game names according to WoD standards",
FeatureType.Flag,
null));
update.AddFeature("rem-uni", new Feature(
new List<string>() { "-ru", "--rem-uni" },
"Remove unicode characters from names",
FeatureType.Flag,
null));
update.AddFeature("rem-md5", new Feature(
new List<string>() { "-rmd5", "--rem-md5" },
"Remove MD5 hashes from the output",
FeatureType.Flag,
null));
update.AddFeature("rem-sha1", new Feature(
new List<string>() { "-rsha1", "--rem-sha1" },
"Remove SHA-1 hashes from the output",
FeatureType.Flag,
null));
update.AddFeature("rem-sha256", new Feature(
new List<string>() { "-rsha256", "--rem-sha256" },
"Remove SHA-256 hashes from the output",
FeatureType.Flag,
null));
update.AddFeature("rem-sha384", new Feature(
new List<string>() { "-rsha384", "--rem-sha384" },
"Remove SHA-384 hashes from the output",
FeatureType.Flag,
null));
update.AddFeature("rem-sha512", new Feature(
new List<string>() { "-rsha512", "--rem-sha512" },
"Remove SHA-512 hashes from the output",
FeatureType.Flag,
null));
update.AddFeature("desc-name", new Feature(
new List<string>() { "-dan", "--desc-name" },
"Use description instead of machine name",
FeatureType.Flag,
null));
update.AddFeature("dat-merged", new Feature(
new List<string>() { "-dm", "--dat-merged" },
"Create merged sets",
FeatureType.Flag,
null));
update.AddFeature("dat-split", new Feature(
new List<string>() { "-ds", "--dat-split" },
"Create split sets",
FeatureType.Flag,
null));
update.AddFeature("dat-nonmerged", new Feature(
new List<string>() { "-dnm", "--dat-nonmerged" },
"Create non-merged sets",
FeatureType.Flag,
null));
update.AddFeature("dat-devnonmerged", new Feature(
new List<string>() { "-dnd", "--dat-devnonmerged" },
"Create device non-merged sets",
FeatureType.Flag,
null));
update.AddFeature("dat-fullnonmerged", new Feature(
new List<string>() { "-df", "--dat-fullnonmerged" },
"Create fully non-merged sets",
FeatureType.Flag,
null));
update.AddFeature("trim", new Feature(
new List<string>() { "-trim", "--trim" },
"Trim file names to fit NTFS length",
FeatureType.Flag,
null));
update["trim"].AddFeature("root-dir", new Feature(
new List<string>() { "-rd", "--root-dir" },
"Set the root directory for calc",
FeatureType.String,
null));
update.AddFeature("single", new Feature(
new List<string>() { "-si", "--single" },
"All game names replaced by '!'",
FeatureType.Flag,
null));
update.AddFeature("dedup", new Feature(
new List<string>() { "-dd", "--dedup" },
"Enable deduping in the created DAT",
FeatureType.Flag,
null));
update.AddFeature("game-dedup", new Feature(
new List<string>() { "-gdd", "--game-dedup" },
"Enable in-game deduping in the created DAT",
FeatureType.Flag,
null));
update.AddFeature("merge", new Feature(
new List<string>() { "-m", "--merge" },
"Merge the input DATs",
FeatureType.Flag,
null));
update["merge"].AddFeature("bare", new Feature(
new List<string>() { "-b", "--bare" },
"Don't include the date in automatic name",
FeatureType.Flag,
null));
update.AddFeature("diff", new Feature(
new List<string>() { "-di", "--diff" },
"Create diffdats from inputs (all outputs)",
FeatureType.Flag,
null));
update["diff"].AddFeature("against", new Feature(
new List<string>() { "-ag", "--against" },
"Diff all inputs against a set of base DATs",
FeatureType.Flag,
null));
update["diff"]["against"].AddFeature("base-dat", new Feature(
new List<string>() { "-bd", "--base-dat" },
"Add a base DAT for diffing",
FeatureType.List,
null));
update["diff"].AddFeature("bare", new Feature(
new List<string>() { "-b", "--bare" },
"Don't include the date in automatic name",
FeatureType.Flag,
null));
update["diff"].AddFeature("cascade", new Feature(
new List<string>() { "-c", "--cascade" },
"Enable cascaded diffing",
FeatureType.Flag,
null));
update["diff"]["cascade"].AddFeature("skip", new Feature(
new List<string>() { "-sf", "--skip" },
"Skip output of first DAT",
FeatureType.Flag,
null));
update["diff"].AddFeature("rev-cascade", new Feature(
new List<string>() { "-rc", "--rev-cascade" },
"Enable reverse cascaded diffing",
FeatureType.Flag,
null));
update["diff"]["rev-cascade"].AddFeature("skip", new Feature(
new List<string>() { "-sf", "--skip" },
"Skip output of first DAT",
FeatureType.Flag,
null));
update.AddFeature("diff-du", new Feature(
new List<string>() { "-did", "--diff-du" },
"Create diffdat containing just duplicates",
FeatureType.Flag,
null));
update["diff-du"].AddFeature("bare", new Feature(
new List<string>() { "-b", "--bare" },
"Don't include the date in automatic name",
FeatureType.Flag,
null));
update.AddFeature("diff-in", new Feature(
new List<string>() { "-dii", "--diff-in" },
"Create diffdats for individual DATs",
FeatureType.Flag,
null));
update["diff-in"].AddFeature("bare", new Feature(
new List<string>() { "-b", "--bare" },
"Don't include the date in automatic name",
FeatureType.Flag,
null));
update.AddFeature("diff-nd", new Feature(
new List<string>() { "-din", "--diff-nd" },
"Create diffdat containing no duplicates",
FeatureType.Flag,
null));
update["diff-nd"].AddFeature("bare", new Feature(
new List<string>() { "-b", "--bare" },
"Don't include the date in automatic name",
FeatureType.Flag,
null));
update.AddFeature("base-name", new Feature(
new List<string>() { "-bn", "--base-name" },
"Replace item names from base DATs in order",
FeatureType.Flag,
null));
update["base-name"].AddFeature("base-dat", new Feature(
new List<string>() { "-bd", "--base-dat" },
"Add a base DAT for replacing",
FeatureType.List,
null));
update.AddFeature("reverse-base-name", new Feature(
new List<string>() { "-rbn", "--reverse-base-name" },
"Replace item names from base DATs in reverse",
FeatureType.Flag,
null));
update["reverse-base-name"].AddFeature("base-dat", new Feature(
new List<string>() { "-bd", "--base-dat" },
"Add a base DAT for replacing",
FeatureType.List,
null));
update.AddFeature("game-name", new Feature(
new List<string>() { "-gn", "--game-name" },
"Filter by game name",
FeatureType.List,
null));
update.AddFeature("not-game", new Feature(
new List<string>() { "-ngn", "--not-game" },
"Filter by not game name",
FeatureType.List,
null));
update.AddFeature("of-as-game", new Feature(
new List<string>() { "-ofg", "--of-as-game" },
"Allow cloneof and romof tags to match game name filters",
FeatureType.Flag,
null));
update.AddFeature("rom-name", new Feature(
new List<string>() { "-rn", "--rom-name" },
"Filter by rom name",
FeatureType.List,
null));
update.AddFeature("not-rom", new Feature(
new List<string>() { "-nrn", "--not-rom" },
"Filter by not rom name",
FeatureType.List,
null));
update.AddFeature("rom-type", new Feature(
new List<string>() { "-rt", "--rom-type" },
"Filter by rom type",
FeatureType.List,
null));
update.AddFeature("not-type", new Feature(
new List<string>() { "-nrt", "--not-type" },
"Filter by not rom type",
FeatureType.List,
null));
update.AddFeature("greater", new Feature(
new List<string>() { "-sgt", "--greater" },
"Filter by size >=",
FeatureType.String,
null));
update.AddFeature("less", new Feature(
new List<string>() { "-slt", "--less" },
"Filter by size =<",
FeatureType.String,
null));
update.AddFeature("equal", new Feature(
new List<string>() { "-seq", "--equal" },
"Filter by size ==",
FeatureType.String,
null));
update.AddFeature("crc", new Feature(
new List<string>() { "-crc", "--crc" },
"Filter by CRC hash",
FeatureType.List,
null));
update.AddFeature("not-crc", new Feature(
new List<string>() { "-ncrc", "--not-crc" },
"Filter by not CRC hash",
FeatureType.List,
null));
update.AddFeature("md5", new Feature(
new List<string>() { "-md5", "--md5" },
"Filter by MD5 hash",
FeatureType.List,
null));
update.AddFeature("not-md5", new Feature(
new List<string>() { "-nmd5", "--not-md5" },
"Filter by not MD5 hash",
FeatureType.List,
null));
update.AddFeature("sha1", new Feature(
new List<string>() { "-sha1", "--sha1" },
"Filter by SHA-1 hash",
FeatureType.List,
null));
update.AddFeature("not-sha1", new Feature(
new List<string>() { "-nsha1", "--not-sha1" },
"Filter by not SHA-1 hash",
FeatureType.List,
null));
update.AddFeature("sha256", new Feature(
new List<string>() { "-sha256", "--sha256" },
"Filter by SHA-256 hash",
FeatureType.List,
null));
update.AddFeature("not-sha256", new Feature(
new List<string>() { "-nsha256", "--not-sha256" },
"Filter by not SHA-256 hash",
FeatureType.List,
null));
update.AddFeature("sha384", new Feature(
new List<string>() { "-sha384", "--sha384" },
"Filter by SHA-384 hash",
FeatureType.List,
null));
update.AddFeature("not-sha384", new Feature(
new List<string>() { "-nsha384", "--not-sha384" },
"Filter by not SHA-384 hash",
FeatureType.List,
null));
update.AddFeature("sha512", new Feature(
new List<string>() { "-sha512", "--sha512" },
"Filter by SHA-512 hash",
FeatureType.List,
null));
update.AddFeature("not-sha512", new Feature(
new List<string>() { "-nsha512", "--not-sha512" },
"Filter by not SHA-512 hash",
FeatureType.List,
null));
update.AddFeature("status", new Feature(
new List<string>() { "-is", "--status" },
"Include only items with a given status",
FeatureType.List,
new List<string>()
{
" Supported values are:",
" None, Good, BadDump, Nodump, Verified",
}));
update.AddFeature("not-status", new Feature(
new List<string>() { "-nis", "--not-status" },
"Exclude only items with a given status",
FeatureType.List,
new List<string>()
{
" Supported values are:",
" None, Good, BadDump, Nodump, Verified",
}));
update.AddFeature("game-type", new Feature(
new List<string>() { "-gt", "--game-type" },
"Include only games with a given type",
FeatureType.List,
new List<string>()
{
" Supported values are:",
" None, Bios, Device, Mechanical",
}));
update.AddFeature("not-gtype", new Feature(
new List<string>() { "-ngt", "--not-gtype" },
"Exclude only games with a given type",
FeatureType.List,
new List<string>()
{
" Supported values are:",
" None, Bios, Device, Mechanical",
}));
update.AddFeature("runnable", new Feature(
new List<string>() { "-run", "--runnable" },
"Include only items that are marked runnable",
FeatureType.Flag,
null));
update.AddFeature("not-run", new Feature(
new List<string>() { "-nrun", "--not-run" },
"Include only items that are marked unrunnable",
FeatureType.Flag,
null));
update.AddFeature("out", new Feature(
new List<string>() { "-out", "--out" },
"Output directory (overridden by --inplace)",
FeatureType.String,
null));
update.AddFeature("inplace", new Feature(
new List<string>() { "-ip", "--inplace" },
"Enable overwriting of source files (update, cascade only)",
FeatureType.Flag,
null));
update.AddFeature("mt", new Feature(
new List<string>() { "-mt", "--mt" },
"Amount of threads to use (default 4, -1 unlimited)",
FeatureType.String,
null));
// Create the Verify feature
Feature verify = new Feature(
new List<string>() { "-ve", "--verify" },
"Verify a folder against DATs",
FeatureType.Flag,
null);
verify.AddFeature("dat", new Feature(
new List<string>() { "-dat", "--dat" },
"Input DAT to verify against",
FeatureType.List,
null));
verify.AddFeature("temp", new Feature(
new List<string>() { "-t", "--temp" },
"Set the temporary directory to use",
FeatureType.String,
null));
verify.AddFeature("hash-only", new Feature(
new List<string>() { "-ho", "--hash-only" },
"Check files by hash only",
FeatureType.Flag,
null));
verify.AddFeature("quick", new Feature(
new List<string>() { "-qs", "--quick" },
"Enable quick scanning of archives",
FeatureType.Flag,
null));
verify.AddFeature("header", new Feature(
new List<string>() { "-h", "--header" },
"Set a header skipper to use, blank means all",
FeatureType.String,
null));
verify.AddFeature("ignore-chd", new Feature(
new List<string>() { "-ic", "--ignore-chd" },
"Treat CHDs as regular files",
FeatureType.Flag,
null));
verify.AddFeature("dat-merged", new Feature(
new List<string>() { "-dm", "--dat-merged" },
"Force checking merged sets",
FeatureType.Flag,
null));
verify.AddFeature("dat-split", new Feature(
new List<string>() { "-ds", "--dat-split" },
"Force checking split sets",
FeatureType.Flag,
null));
verify.AddFeature("dat-nonmerged", new Feature(
new List<string>() { "-dnm", "--dat-nonmerged" },
"Force checking non-merged sets",
FeatureType.Flag,
null));
verify.AddFeature("dat-fullnonmerged", new Feature(
new List<string>() { "-df", "--dat-fullnonmerged" },
"Force checking fully non-merged sets",
FeatureType.Flag,
null));
// Create the Verify Depot feature
Feature verifyDepot = new Feature(
new List<string>() { "-ved", "--verify-depot" },
"Verify a depot against DATs",
FeatureType.Flag,
null);
verifyDepot.AddFeature("dat", new Feature(
new List<string>() { "-dat", "--dat" },
"Input DAT to verify against",
FeatureType.List,
null));
verifyDepot.AddFeature("temp", new Feature(
new List<string>() { "-t", "--temp" },
"Set the temporary directory to use",
FeatureType.String,
null));
verifyDepot.AddFeature("header", new Feature(
new List<string>() { "-h", "--header" },
"Set a header skipper to use, blank means all",
FeatureType.String,
null));
verifyDepot.AddFeature("dat-merged", new Feature(
new List<string>() { "-dm", "--dat-merged" },
"Force checking merged sets",
FeatureType.Flag,
null));
verifyDepot.AddFeature("dat-split", new Feature(
new List<string>() { "-ds", "--dat-split" },
"Force checking split sets",
FeatureType.Flag,
null));
verifyDepot.AddFeature("dat-nonmerged", new Feature(
new List<string>() { "-dnm", "--dat-nonmerged" },
"Force checking non-merged sets",
FeatureType.Flag,
null));
verifyDepot.AddFeature("dat-fullnonmerged", new Feature(
new List<string>() { "-df", "--dat-fullnonmerged" },
"Force checking fully non-merged sets",
FeatureType.Flag,
null));
// Now, add all of the main features to the Help object
help.Add("Help", helpFeature);
help.Add("Script", script);
help.Add("DATFromDir", datFromDir);
help.Add("Extract", extract);
help.Add("Extension Split", extSplit);
help.Add("Hash Split", hashSplit);
help.Add("Level Split", levelSplit);
help.Add("Restore", restore);
help.Add("Sort", sort);
help.Add("Sort Depot", sortDepot);
help.Add("Stats", stats);
help.Add("Type Split", typeSplit);
help.Add("Update", update);
help.Add("Verify", verify);
help.Add("Verify Depot", verifyDepot);
return help;
}
}
}
Reference in New Issue View Git Blame Copy Permalink