mirror of
https://github.com/claunia/SabreTools.git
synced 2025-12-16 19:14:27 +00:00
653 lines
23 KiB
C#
653 lines
23 KiB
C#
using System;
|
|
using System.Collections.Generic;
|
|
|
|
using SabreTools.Library.Data;
|
|
using SabreTools.Library.DatFiles;
|
|
using SabreTools.Library.Tools;
|
|
|
|
#if MONO
|
|
using System.IO;
|
|
#else
|
|
using Alphaleonis.Win32.Filesystem;
|
|
|
|
using SearchOption = System.IO.SearchOption;
|
|
#endif
|
|
|
|
namespace SabreTools
|
|
{
|
|
public partial class SabreTools
|
|
{
|
|
#region Init Methods
|
|
|
|
/// <summary>
|
|
/// Wrap creating a DAT file from files or a directory in parallel
|
|
/// </summary>
|
|
/// <param name="inputs">List of input filenames</param>
|
|
/// /* Normal DAT header info */
|
|
/// <param name="filename">New filename</param>
|
|
/// <param name="name">New name</param>
|
|
/// <param name="description">New description</param>
|
|
/// <param name="category">New category</param>
|
|
/// <param name="version">New version</param>
|
|
/// <param name="author">New author</param>
|
|
/// <param name="email">New email</param>
|
|
/// <param name="homepage">New homepage</param>
|
|
/// <param name="url">New URL</param>
|
|
/// <param name="comment">New comment</param>
|
|
/// <param name="forcepack">String representing the forcepacking flag</param>
|
|
/// <param name="excludeOf">True if cloneof, romof, and sampleof fields should be omitted from output, false otherwise</param>
|
|
/// <param name="sceneDateStrip">True if scene-named sets have the date stripped from the beginning, false otherwise</param>
|
|
/// <param name="datFormat">DatFormat to be used for outputting the DAT</param>
|
|
/// /* Standard DFD info */
|
|
/// <param name="romba">True to enable reading a directory like a Romba depot, false otherwise</param>
|
|
/// <param name="superdat">True to enable SuperDAT-style reading, false otherwise</param>
|
|
/// <param name="omitFromScan">Hash flag saying what hashes should not be calculated</param>
|
|
/// <param name="removeDateFromAutomaticName">True if the date should be omitted from the DAT, false otherwise</param>
|
|
/// <param name="archivesAsFiles">True if archives should be treated as files, false otherwise</param>
|
|
/// <param name="skipFileType">Type of files that should be skipped on scan</param>
|
|
/// <param name="addBlankFilesForEmptyFolder">True if blank items should be created for empty folders, false otherwise</param>
|
|
/// <param name="addFileDates">True if dates should be archived for all files, false otherwise</param>
|
|
/// /* Output DAT info */
|
|
/// <param name="tempDir">Name of the directory to create a temp folder in (blank is default temp directory)</param>
|
|
/// <param name="outDir">Name of the directory to output the DAT to (blank is the current directory)</param>
|
|
/// <param name="copyFiles">True if files should be copied to the temp directory before hashing, false otherwise</param>
|
|
/// <param name="headerToCheckAgainst">Populated string representing the name of the skipper to use, a blank string to use the first available checker, null otherwise</param>
|
|
/// <param name="chdsAsFiles">True if CHDs should be treated like regular files, false otherwise</param>
|
|
private static void InitDatFromDir(List<string> inputs,
|
|
/* Normal DAT header info */
|
|
string filename,
|
|
string name,
|
|
string description,
|
|
string category,
|
|
string version,
|
|
string author,
|
|
string email,
|
|
string homepage,
|
|
string url,
|
|
string comment,
|
|
string forcepack,
|
|
bool excludeOf,
|
|
bool sceneDateStrip,
|
|
DatFormat datFormat,
|
|
|
|
/* Standard DFD info */
|
|
bool romba,
|
|
bool superdat,
|
|
Hash omitFromScan,
|
|
bool removeDateFromAutomaticName,
|
|
bool archivesAsFiles,
|
|
SkipFileType skipFileType,
|
|
bool addBlankFilesForEmptyFolder,
|
|
bool addFileDates,
|
|
|
|
/* Output DAT info */
|
|
string tempDir,
|
|
string outDir,
|
|
bool copyFiles,
|
|
string headerToCheckAgainst,
|
|
bool chdsAsFiles)
|
|
{
|
|
ForcePacking fp = ForcePacking.None;
|
|
switch (forcepack?.ToLowerInvariant())
|
|
{
|
|
case "none":
|
|
default:
|
|
fp = ForcePacking.None;
|
|
break;
|
|
case "zip":
|
|
fp = ForcePacking.Zip;
|
|
break;
|
|
case "unzip":
|
|
fp = ForcePacking.Unzip;
|
|
break;
|
|
}
|
|
|
|
// Create a new DATFromDir object and process the inputs
|
|
DatFile basedat = new DatFile
|
|
{
|
|
FileName = filename,
|
|
Name = name,
|
|
Description = description,
|
|
Category = category,
|
|
Version = version,
|
|
Date = DateTime.Now.ToString("yyyy-MM-dd"),
|
|
Author = author,
|
|
Email = email,
|
|
Homepage = homepage,
|
|
Url = url,
|
|
Comment = comment,
|
|
ForcePacking = fp,
|
|
DatFormat = (datFormat == 0 ? DatFormat.Logiqx : datFormat),
|
|
Romba = romba,
|
|
ExcludeOf = excludeOf,
|
|
SceneDateStrip = sceneDateStrip,
|
|
Type = (superdat ? "SuperDAT" : ""),
|
|
};
|
|
|
|
// Clean the temp directory
|
|
tempDir = (String.IsNullOrWhiteSpace(tempDir) ? Path.GetTempPath() : tempDir);
|
|
|
|
// For each input directory, create a DAT
|
|
foreach (string path in inputs)
|
|
{
|
|
if (Directory.Exists(path) || File.Exists(path))
|
|
{
|
|
// Clone the base Dat for information
|
|
DatFile datdata = new DatFile(basedat);
|
|
|
|
string basePath = Path.GetFullPath(path);
|
|
bool success = datdata.PopulateFromDir(basePath, omitFromScan, removeDateFromAutomaticName, archivesAsFiles,
|
|
skipFileType, addBlankFilesForEmptyFolder, addFileDates, tempDir, copyFiles, headerToCheckAgainst, chdsAsFiles);
|
|
|
|
// If it was a success, write the DAT out
|
|
if (success)
|
|
{
|
|
datdata.WriteToFile(outDir);
|
|
}
|
|
|
|
// Otherwise, show the help
|
|
else
|
|
{
|
|
Console.WriteLine();
|
|
_help.OutputIndividualFeature("DATFromDir");
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Wrap extracting headers
|
|
/// </summary>
|
|
/// <param name="inputs">Input file or folder names</param>
|
|
/// <param name="outDir">Output directory to write new files to, blank defaults to rom folder</param>
|
|
/// <param name="nostore">True if headers should not be stored in the database, false otherwise</param>
|
|
private static void InitExtractRemoveHeader(List<string> inputs, string outDir, bool nostore)
|
|
{
|
|
// Get only files from the inputs
|
|
List<string> files = Utilities.GetOnlyFilesFromInputs(inputs);
|
|
|
|
foreach (string file in files)
|
|
{
|
|
Utilities.DetectSkipperAndTransform(file, outDir, nostore);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Wrap replacing headers
|
|
/// </summary>
|
|
/// <param name="inputs">Input file or folder names</param>
|
|
/// <param name="outDir">Output directory to write new files to, blank defaults to rom folder</param>
|
|
private static void InitReplaceHeader(List<string> inputs, string outDir)
|
|
{
|
|
// Get only files from the inputs
|
|
List<string> files = Utilities.GetOnlyFilesFromInputs(inputs);
|
|
|
|
foreach (string file in files)
|
|
{
|
|
Utilities.RestoreHeader(file, outDir);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Wrap sorting files using an input DAT
|
|
/// </summary>
|
|
/// <param name="datfiles">Names of the DATs to compare against</param>
|
|
/// <param name="inputs">List of input files/folders to check</param>
|
|
/// <param name="outDir">Output directory to use to build to</param>
|
|
/// <param name="depot">True if the input direcories are treated as romba depots, false otherwise</param>
|
|
/// <param name="quickScan">True to enable external scanning of archives, false otherwise</param>
|
|
/// <param name="date">True if the date from the DAT should be used if available, false otherwise</param>
|
|
/// <param name="delete">True if input files should be deleted, false otherwise</param>
|
|
/// <param name="inverse">True if the DAT should be used as a filter instead of a template, false otherwise</param>
|
|
/// <param name="outputFormat">Output format that files should be written to</param>
|
|
/// <param name="romba">True if files should be output in Romba depot folders, false otherwise</param>
|
|
/// <param name="sevenzip">Integer representing the archive handling level for 7z</param>
|
|
/// <param name="gz">Integer representing the archive handling level for GZip</param>
|
|
/// <param name="rar">Integer representing the archive handling level for RAR</param>
|
|
/// <param name="zip">Integer representing the archive handling level for Zip</param>
|
|
/// <param name="updateDat">True if the updated DAT should be output, false otherwise</param>
|
|
/// <param name="headerToCheckAgainst">Populated string representing the name of the skipper to use, a blank string to use the first available checker, null otherwise</param>
|
|
/// <param name="splitType">Type of the split that should be performed (split, merged, fully merged)</param>
|
|
/// <param name="chdsAsFiles">True if CHDs should be treated like regular files, false otherwise</param>
|
|
private static void InitSort(List<string> datfiles, List<string> inputs, string outDir, bool depot, bool quickScan, bool date, bool delete,
|
|
bool inverse, OutputFormat outputFormat, bool romba, int sevenzip, int gz, int rar, int zip, bool updateDat, string headerToCheckAgainst,
|
|
SplitType splitType, bool chdsAsFiles)
|
|
{
|
|
// Get the archive scanning level
|
|
ArchiveScanLevel asl = Utilities.GetArchiveScanLevelFromNumbers(sevenzip, gz, rar, zip);
|
|
|
|
// Get a list of files from the input datfiles
|
|
datfiles = Utilities.GetOnlyFilesFromInputs(datfiles);
|
|
|
|
InternalStopwatch watch = new InternalStopwatch("Populating internal DAT");
|
|
|
|
// Add all of the input DATs into one huge internal DAT
|
|
DatFile datdata = new DatFile();
|
|
foreach (string datfile in datfiles)
|
|
{
|
|
datdata.Parse(datfile, 99, 99, splitType, keep: true, useTags: true);
|
|
}
|
|
|
|
watch.Stop();
|
|
|
|
// If we have the depot flag, repsect it
|
|
if (depot)
|
|
{
|
|
datdata.RebuildDepot(inputs, outDir, date, delete, inverse, outputFormat, romba,
|
|
updateDat, headerToCheckAgainst);
|
|
}
|
|
else
|
|
{
|
|
datdata.RebuildGeneric(inputs, outDir, quickScan, date, delete, inverse, outputFormat, romba, asl,
|
|
updateDat, headerToCheckAgainst, chdsAsFiles);
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Wrap splitting a DAT by any known type
|
|
/// </summary>
|
|
/// <param name="inputs">List of inputs to be used</param>
|
|
/// <param name="outDir">Output directory for the split files</param>
|
|
/// <param name="inplace">True if files should be written to the source folders, false otherwise</param>
|
|
/// <param name="splitType">Type of split to perform, if any</param>
|
|
/// <param name="exta">First extension to split on (Extension Split only)</param>
|
|
/// <param name="extb">Second extension to split on (Extension Split only)</param>
|
|
/// <param name="shortname">True if short filenames should be used, false otherwise (Level Split only)</param>
|
|
/// <param name="basedat">True if original filenames should be used as the base for output filename, false otherwise (Level Split only)</param>
|
|
private static void InitSplit(List<string> inputs, string outDir, bool inplace, ExternalSplitType splitType,
|
|
List<string> exta, List<string> extb, bool shortname, bool basedat)
|
|
{
|
|
// If we somehow have the "none" split type, return
|
|
if (splitType == ExternalSplitType.None)
|
|
{
|
|
return;
|
|
}
|
|
|
|
// Get only files from the inputs
|
|
List<string> files = Utilities.GetOnlyFilesFromInputs(inputs, appendparent: true);
|
|
|
|
// Loop over the input files
|
|
foreach (string file in files)
|
|
{
|
|
// Split the input filename
|
|
string[] splitpath = file.Split('¬');
|
|
|
|
// Create and fill the new DAT
|
|
DatFile datFile = new DatFile();
|
|
datFile.Parse(splitpath[0], 0, 0);
|
|
|
|
// Get the output directory
|
|
outDir = Utilities.GetOutputPath(outDir, file, inplace, splitpath: true);
|
|
|
|
// Split and write the DAT
|
|
switch (splitType)
|
|
{
|
|
case ExternalSplitType.Extension:
|
|
datFile.SplitByExtension(outDir, inplace, exta, extb);
|
|
break;
|
|
case ExternalSplitType.Hash:
|
|
datFile.SplitByHash(outDir, inplace);
|
|
break;
|
|
case ExternalSplitType.Level:
|
|
datFile.SplitByLevel(outDir, inplace, shortname, basedat);
|
|
break;
|
|
case ExternalSplitType.Type:
|
|
datFile.SplitByType(outDir, inplace);
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary>
|
|
/// Wrap getting statistics on a DAT or folder of DATs
|
|
/// </summary>
|
|
/// <param name="inputs">List of inputs to be used</param>
|
|
/// <param name="filename">Name of the file to output to, blank for default</param>
|
|
/// <param name="outDir">Output directory for the report files</param>
|
|
/// <param name="single">True to show individual DAT statistics, false otherwise</param>
|
|
/// <param name="baddumpCol">True if baddumps should be included in output, false otherwise</param>
|
|
/// <param name="nodumpCol">True if nodumps should be included in output, false otherwise</param>
|
|
/// <param name="statDatFormat">Set the statistics output format to use</param>
|
|
private static void InitStats(List<string> inputs, string filename, string outDir, bool single, bool baddumpCol, bool nodumpCol,
|
|
StatReportFormat statDatFormat)
|
|
{
|
|
DatFile.OutputStats(inputs, filename, outDir, single, baddumpCol, nodumpCol, statDatFormat);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Wrap converting and updating DAT file from any format to any format
|
|
/// </summary>
|
|
/// <param name="inputPaths">List of input filenames</param>
|
|
/// <param name="basePaths">List of base filenames</param>
|
|
/// /* Normal DAT header info */
|
|
/// <param name="filename">New filename</param>
|
|
/// <param name="name">New name</param>
|
|
/// <param name="description">New description</param>
|
|
/// <param name="rootdir">New rootdir</param>
|
|
/// <param name="category">New category</param>
|
|
/// <param name="version">New version</param>
|
|
/// <param name="date">New date</param>
|
|
/// <param name="author">New author</param>
|
|
/// <param name="email">New email</param>
|
|
/// <param name="homepage">New homepage</param>
|
|
/// <param name="url">New URL</param>
|
|
/// <param name="comment">New comment</param>
|
|
/// <param name="header">New header</param>
|
|
/// <param name="superdat">True to set SuperDAT type, false otherwise</param>
|
|
/// <param name="forcemerge">None, Split, Full</param>
|
|
/// <param name="forcend">None, Obsolete, Required, Ignore</param>
|
|
/// <param name="forcepack">None, Zip, Unzip</param>
|
|
/// <param name="excludeOf">True if cloneof, romof, and sampleof fields should be omitted from output, false otherwise</param>
|
|
/// <param name="sceneDateStrip">True if scene-named sets have the date stripped from the beginning, false otherwise</param>
|
|
/// <param name="datFormat">Non-zero flag for output format, zero otherwise for default</param>
|
|
/// /* Missfile-specific DAT info */
|
|
/// <param name="usegame">True if games are to be used in output, false if roms are</param>
|
|
/// <param name="prefix">Generic prefix to be added to each line</param>
|
|
/// <param name="postfix">Generic postfix to be added to each line</param>
|
|
/// <param name="quotes">Add quotes to each item</param>
|
|
/// <param name="repext">Replace all extensions with another</param>
|
|
/// <param name="addext">Add an extension to all items</param>
|
|
/// <param name="remext">Remove all extensions</param>
|
|
/// <param name="datprefix">Add the dat name as a directory prefix</param>
|
|
/// <param name="romba">Output files in romba format</param>
|
|
/// /* Merging and Diffing info */
|
|
/// <param name="merge">True if input files should be merged into a single file, false otherwise</param>
|
|
/// <param name="diffMode">Non-zero flag for diffing mode, zero otherwise</param>
|
|
/// <param name="inplace">True if the cascade-diffed files should overwrite their inputs, false otherwise</param>
|
|
/// <param name="skip">True if the first cascaded diff file should be skipped on output, false otherwise</param>
|
|
/// <param name="bare">True if the date should not be appended to the default name, false otherwise [OBSOLETE]</param>
|
|
/// /* Filtering info */
|
|
/// <param name="filter">Pre-populated filter object for DAT filtering</param>
|
|
/// <param name="oneGameOneRegion">True if the outputs should be created in 1G1R mode, false otherwise</param>
|
|
/// <param name="regions">List of regions in the order they should be used, blank for default</param>
|
|
/// /* Trimming info */
|
|
/// <param name="splitType">Type of the split that should be performed (split, merged, fully merged)</param>
|
|
/// <param name="trim">True if we are supposed to trim names to NTFS length, false otherwise</param>
|
|
/// <param name="single">True if all games should be replaced by '!', false otherwise</param>
|
|
/// <param name="root">String representing root directory to compare against for length calculation</param>
|
|
/// /* Output DAT info */
|
|
/// <param name="outDir">Optional param for output directory</param>
|
|
/// <param name="clean">True to clean the game names to WoD standard, false otherwise (default)</param>
|
|
/// <param name="remUnicode">True if we should remove non-ASCII characters from output, false otherwise (default)</param>
|
|
/// <param name="descAsName">True if descriptions should be used as names, false otherwise (default)</param>
|
|
/// <param name="dedup">Dedupe type to use for DAT processing</param>
|
|
/// <param name="stripHash">StripHash that represents the hash(es) that you want to remove from the output</param>
|
|
private static void InitUpdate(
|
|
List<string> inputPaths,
|
|
List<string> basePaths,
|
|
|
|
/* Normal DAT header info */
|
|
string filename,
|
|
string name,
|
|
string description,
|
|
string rootdir,
|
|
string category,
|
|
string version,
|
|
string date,
|
|
string author,
|
|
string email,
|
|
string homepage,
|
|
string url,
|
|
string comment,
|
|
string header,
|
|
bool superdat,
|
|
string forcemerge,
|
|
string forcend,
|
|
string forcepack,
|
|
bool excludeOf,
|
|
bool sceneDateStrip,
|
|
DatFormat datFormat,
|
|
|
|
/* Missfile-specific DAT info */
|
|
bool usegame,
|
|
string prefix,
|
|
string postfix,
|
|
bool quotes,
|
|
string repext,
|
|
string addext,
|
|
bool remext,
|
|
bool datprefix,
|
|
bool romba,
|
|
|
|
/* Merging and Diffing info */
|
|
bool merge,
|
|
UpdateMode diffMode,
|
|
bool inplace,
|
|
bool skip,
|
|
bool bare,
|
|
|
|
/* Filtering info */
|
|
Filter filter,
|
|
bool oneGameOneRegion,
|
|
List<string> regions,
|
|
|
|
/* Trimming info */
|
|
SplitType splitType,
|
|
bool trim,
|
|
bool single,
|
|
string root,
|
|
|
|
/* Output DAT info */
|
|
string outDir,
|
|
bool clean,
|
|
bool remUnicode,
|
|
bool descAsName,
|
|
DedupeType dedup,
|
|
Hash stripHash)
|
|
{
|
|
// Set the special flags
|
|
ForceMerging fm = ForceMerging.None;
|
|
if (!String.IsNullOrWhiteSpace(forcemerge))
|
|
{
|
|
switch (forcemerge.ToLowerInvariant())
|
|
{
|
|
case "none":
|
|
fm = ForceMerging.None;
|
|
break;
|
|
case "split":
|
|
fm = ForceMerging.Split;
|
|
break;
|
|
case "full":
|
|
fm = ForceMerging.Full;
|
|
break;
|
|
default:
|
|
Globals.Logger.Warning("{0} is not a valid merge flag", forcemerge);
|
|
break;
|
|
}
|
|
}
|
|
|
|
ForceNodump fn = ForceNodump.None;
|
|
if (!String.IsNullOrWhiteSpace(forcend))
|
|
{
|
|
switch (forcend.ToLowerInvariant())
|
|
{
|
|
case "none":
|
|
fn = ForceNodump.None;
|
|
break;
|
|
case "obsolete":
|
|
fn = ForceNodump.Obsolete;
|
|
break;
|
|
case "required":
|
|
fn = ForceNodump.Required;
|
|
break;
|
|
case "ignore":
|
|
fn = ForceNodump.Ignore;
|
|
break;
|
|
default:
|
|
Globals.Logger.Warning("{0} is not a valid nodump flag", forcend);
|
|
break;
|
|
}
|
|
}
|
|
|
|
ForcePacking fp = ForcePacking.None;
|
|
if (!String.IsNullOrWhiteSpace(forcepack))
|
|
{
|
|
switch (forcepack.ToLowerInvariant())
|
|
{
|
|
case "none":
|
|
fp = ForcePacking.None;
|
|
break;
|
|
case "zip":
|
|
fp = ForcePacking.Zip;
|
|
break;
|
|
case "unzip":
|
|
fp = ForcePacking.Unzip;
|
|
break;
|
|
default:
|
|
Globals.Logger.Warning("{0} is not a valid packing flag", forcepack);
|
|
break;
|
|
}
|
|
}
|
|
|
|
// Set the 1G1R regions alphabetically if not already set
|
|
if (regions == null || regions.Count == 0)
|
|
{
|
|
regions = new List<string>()
|
|
{
|
|
"australia",
|
|
"canada",
|
|
"china",
|
|
"denmark",
|
|
"europe",
|
|
"finland",
|
|
"france",
|
|
"germany",
|
|
"greece",
|
|
"italy",
|
|
"japan",
|
|
"korea",
|
|
"netherlands",
|
|
"norway",
|
|
"russia",
|
|
"spain",
|
|
"sweden",
|
|
"usa",
|
|
"usa, australia",
|
|
"usa, europe",
|
|
"world",
|
|
};
|
|
}
|
|
|
|
// Normalize the extensions
|
|
addext = (addext == "" || addext.StartsWith(".") ? addext : "." + addext);
|
|
repext = (repext == "" || repext.StartsWith(".") ? repext : "." + repext);
|
|
|
|
// If we're in merge or diff mode and the names aren't set, set defaults
|
|
if (merge || diffMode != 0)
|
|
{
|
|
// Get the values that will be used
|
|
if (date == "")
|
|
{
|
|
date = DateTime.Now.ToString("yyyy-MM-dd");
|
|
}
|
|
if (name == "")
|
|
{
|
|
name = (diffMode != 0 ? "DiffDAT" : "MergeDAT") + (superdat ? "-SuperDAT" : "") + (dedup != DedupeType.None ? "-deduped" : "");
|
|
}
|
|
if (description == "")
|
|
{
|
|
description = (diffMode != 0 ? "DiffDAT" : "MergeDAT") + (superdat ? "-SuperDAT" : "") + (dedup != DedupeType.None ? " - deduped" : "");
|
|
if (!bare)
|
|
{
|
|
description += " (" + date + ")";
|
|
}
|
|
}
|
|
if (category == "" && diffMode != 0)
|
|
{
|
|
category = "DiffDAT";
|
|
}
|
|
if (author == "")
|
|
{
|
|
author = "SabreTools";
|
|
}
|
|
}
|
|
|
|
// Populate the DatData object
|
|
DatFile userInputDat = new DatFile
|
|
{
|
|
FileName = filename,
|
|
Name = name,
|
|
Description = description,
|
|
RootDir = rootdir,
|
|
Category = category,
|
|
Version = version,
|
|
Date = date,
|
|
Author = author,
|
|
Email = email,
|
|
Homepage = homepage,
|
|
Url = url,
|
|
Comment = comment,
|
|
Header = header,
|
|
Type = (superdat ? "SuperDAT" : null),
|
|
ForceMerging = fm,
|
|
ForceNodump = fn,
|
|
ForcePacking = fp,
|
|
DedupeRoms = dedup,
|
|
ExcludeOf = excludeOf,
|
|
SceneDateStrip = sceneDateStrip,
|
|
DatFormat = datFormat,
|
|
StripHash = stripHash,
|
|
OneGameOneRegion = oneGameOneRegion,
|
|
Regions = regions,
|
|
|
|
UseGame = usegame,
|
|
Prefix = prefix,
|
|
Postfix = postfix,
|
|
Quotes = quotes,
|
|
RepExt = repext,
|
|
AddExt = addext,
|
|
RemExt = remext,
|
|
GameName = datprefix,
|
|
Romba = romba,
|
|
};
|
|
|
|
userInputDat.DetermineUpdateType(inputPaths, basePaths, outDir, merge, diffMode, inplace, skip, bare, clean,
|
|
remUnicode, descAsName, filter, splitType, trim, single, root);
|
|
}
|
|
|
|
/// <summary>
|
|
/// Wrap verifying files using an input DAT
|
|
/// </summary>
|
|
/// <param name="datfiles">Names of the DATs to compare against</param>
|
|
/// <param name="inputs">Input directories to compare against</param>
|
|
/// <param name="depot">True if the input direcories are treated as romba depots, false otherwise</param>
|
|
/// <param name="hashOnly">True if only hashes should be checked, false for full file information</param>
|
|
/// <param name="quickScan">True to enable external scanning of archives, false otherwise</param>
|
|
/// <param name="headerToCheckAgainst">Populated string representing the name of the skipper to use, a blank string to use the first available checker, null otherwise</param>
|
|
/// <param name="splitType">Type of the split that should be performed (split, merged, fully merged)</param>
|
|
/// <param name="chdsAsFiles">True if CHDs should be treated like regular files, false otherwise</param>
|
|
private static void InitVerify(List<string> datfiles, List<string> inputs, bool depot, bool hashOnly, bool quickScan,
|
|
string headerToCheckAgainst, SplitType splitType, bool chdsAsFiles)
|
|
{
|
|
// Get the archive scanning level
|
|
ArchiveScanLevel asl = Utilities.GetArchiveScanLevelFromNumbers(1, 1, 1, 1);
|
|
|
|
// Get a list of files from the input datfiles
|
|
datfiles = Utilities.GetOnlyFilesFromInputs(datfiles);
|
|
|
|
InternalStopwatch watch = new InternalStopwatch("Populating internal DAT");
|
|
|
|
// Add all of the input DATs into one huge internal DAT
|
|
DatFile datdata = new DatFile();
|
|
foreach (string datfile in datfiles)
|
|
{
|
|
datdata.Parse(datfile, 99, 99, splitType, keep: true, useTags: true);
|
|
}
|
|
|
|
watch.Stop();
|
|
|
|
// If we have the depot flag, repsect it
|
|
if (depot)
|
|
{
|
|
datdata.VerifyDepot(inputs, headerToCheckAgainst);
|
|
}
|
|
else
|
|
{
|
|
datdata.VerifyGeneric(inputs, hashOnly, quickScan, headerToCheckAgainst, chdsAsFiles);
|
|
}
|
|
}
|
|
|
|
#endregion
|
|
}
|
|
}
|