public static void RemoveDevices(DatDir tDat)
{
DatBase[] children = tDat.ToArray();
tDat.ChildrenClear();
foreach (DatBase child in children)
{
DatDir mGame = (DatDir)child;
if (mGame.DGame == null)
{
RemoveDevices(mGame);
tDat.ChildAdd(mGame);
}
else
{
DatGame dGame = mGame.DGame;
if (dGame != null && dGame.IsDevice == "yes" && dGame.Runnable == "no")
{
continue;
}
tDat.ChildAdd(mGame);
}
}
}
public static bool RemoveEmptySets(DatBase inDat)
{
if (inDat is DatFile)
{
return(true);
}
DatDir dDir = inDat as DatDir;
DatBase[] children = dDir?.ToArray();
if (children == null || children.Length == 0)
{
return(false);
}
dDir.ChildrenClear();
bool found = false;
foreach (DatBase child in children)
{
bool keep = RemoveEmptySets(child);
if (keep)
{
found = true;
dDir.ChildAdd(child);
}
}
return(found);
}
public static bool RemoveNotCollected(DatBase inDat)
{
if (inDat is DatFile dFile)
{
return(dFile.DatStatus == DatFileStatus.InDatCollect || dFile.DatStatus == DatFileStatus.InDatBad);
}
DatDir dDir = inDat as DatDir;
DatBase[] children = dDir?.ToArray();
if (children == null || children.Length == 0)
{
return(false);
}
dDir.ChildrenClear();
bool found = false;
foreach (DatBase child in children)
{
bool keep = RemoveNotCollected(child);
if (keep)
{
found = true;
dDir.ChildAdd(child);
}
}
return(found);
}
private static void ProcessDir(DirectoryInfo di, DatDir thisDir)
{
DirectoryInfo[] dia = di.GetDirectories();
foreach (DirectoryInfo d in dia)
{
DatDir nextDir = new DatDir(DatFileType.Dir)
{
Name = d.Name
};
thisDir.ChildAdd(nextDir);
ProcessDir(d, nextDir);
}
FileInfo[] fia = di.GetFiles();
foreach (FileInfo f in fia)
{
Console.WriteLine(f.FullName);
string ext = Path.GetExtension(f.Name).ToLower();
switch (ext)
{
case ".zip":
AddZip(f, thisDir);
break;
case ".7z":
Add7Zip(f, thisDir);
break;
default:
AddFile(f, thisDir);
break;
}
}
}
private static void Add7Zip(FileInfo f, DatDir thisDir)
{
DatDir ZipDir = new DatDir(DatFileType.Dir7Zip)
{
Name = Path.GetFileNameWithoutExtension(f.Name),
DGame = new DatGame()
};
ZipDir.DGame.Description = ZipDir.Name;
thisDir.ChildAdd(ZipDir);
SevenZ zf1 = new SevenZ();
zf1.ZipFileOpen(f.FullName, -1, true);
FileScan fs = new FileScan();
List <FileScan.FileResults> fr = fs.Scan(zf1, true, true);
for (int i = 0; i < fr.Count; i++)
{
if (zf1.IsDirectory(i))
{
continue;
}
DatFile df = new DatFile(DatFileType.File7Zip)
{
Name = zf1.Filename(i),
Size = fr[i].Size,
CRC = fr[i].CRC,
SHA1 = fr[i].SHA1
//df.MD5 = zf.MD5(i)
};
ZipDir.ChildAdd(df);
}
zf1.ZipFileClose();
}
private bool LoadDirFromDat(DatFileLoader dfl, DatDir parentDir)
{
dfl.Gn();
if (dfl.Next != "(")
{
_errorReport?.Invoke(dfl.Filename, "( not found after game, on line " + dfl.LineNumber);
return(false);
}
dfl.Gn();
if (dfl.Next.ToLower() != "name")
{
_errorReport?.Invoke(dfl.Filename, "Name not found as first object in ( ), on line " + dfl.LineNumber);
return(false);
}
DatDir dir = new DatDir(DatFileType.UnSet)
{
Name = dfl.GnRest()
};
dfl.Gn();
parentDir.ChildAdd(dir);
while (dfl.Next != ")")
{
bool res = ReadNextBlock(dfl, dir);
if (!res)
{
return(false);
}
}
return(true);
}
private static void AddDirAsGame(DirectoryInfo di, DatDir thisDir)
{
DatDir fDir = new DatDir(DatFileType.Dir)
{
Name = Path.GetFileNameWithoutExtension(di.Name),
DGame = new DatGame()
};
fDir.DGame.Description = fDir.Name;
thisDir.ChildAdd(fDir);
FileInfo[] fia = di.GetFiles();
int fCount = 0;
foreach (FileInfo f in fia)
{
Console.WriteLine(f.FullName);
AddFile(f, fDir);
//fCount++;
if (fCount > 10)
{
break;
}
}
}
private void LoadRomFromDat(DatDir parentDir, XmlNode romNode)
{
if (romNode.Attributes == null)
{
return;
}
XmlNode name = romNode.Attributes.GetNamedItem("name");
string loadflag = VarFix.String(romNode.Attributes.GetNamedItem("loadflag"));
if (name != null)
{
DatFile dRom = new DatFile(DatFileType.UnSet)
{
Name = VarFix.String(name),
Size = VarFix.ULong(romNode.Attributes.GetNamedItem("size")),
CRC = VarFix.CleanMD5SHA1(romNode.Attributes.GetNamedItem("crc"), 8),
SHA1 = VarFix.CleanMD5SHA1(romNode.Attributes.GetNamedItem("sha1"), 40),
Status = VarFix.ToLower(romNode.Attributes.GetNamedItem("status"))
};
_indexContinue = parentDir.ChildAdd(dRom);
}
else if (loadflag.ToLower() == "continue")
{
DatFile tRom = (DatFile)parentDir.Child(_indexContinue);
tRom.Size += VarFix.ULong(romNode.Attributes.GetNamedItem("size"));
}
}
public static void MakeDatSingleLevel(DatHeader tDatHeader)
{
DatBase[] db = tDatHeader.BaseDir.ToArray();
tDatHeader.Dir = "noautodir";
tDatHeader.BaseDir.ChildrenClear();
DatDir root = new DatDir(DatFileType.UnSet)
{
Name = tDatHeader.Name,
DGame = new DatGame {
Description = tDatHeader.Description
}
};
tDatHeader.BaseDir.ChildAdd(root);
foreach (DatBase set in db)
{
string dirName = set.Name;
if (!(set is DatDir romSet))
{
continue;
}
DatBase[] dbr = romSet.ToArray();
foreach (DatBase rom in dbr)
{
rom.Name = dirName + "\\" + rom.Name;
root.ChildAdd(rom);
}
}
}
private bool LoadGameFromDat(DatFileLoader dfl, DatDir parentDir)
{
if (dfl.Next != "(")
{
_errorReport?.Invoke(dfl.Filename, "( not found after game, on line " + dfl.LineNumber);
return(false);
}
dfl.Gn();
string snext = dfl.Next.ToLower();
if (snext != "name")
{
_errorReport?.Invoke(dfl.Filename, "Name not found as first object in ( ), on line " + dfl.LineNumber);
return(false);
}
string name = dfl.GnRest();
dfl.Gn();
DatDir dDir = new DatDir(DatFileType.UnSet)
{
Name = name, DGame = new DatGame()
};
DatGame dGame = dDir.DGame;
while (dfl.Next != ")")
{
switch (dfl.Next.ToLower())
{
case "file":
dfl.Gn();
if (!LoadFileFromDat(dfl, dDir))
{
return(false);
}
dfl.Gn();
break;
case "rom":
dfl.Gn();
if (!LoadFileFromDat(dfl, dDir))
{
return(false);
}
dfl.Gn();
break;
default:
_errorReport?.Invoke(dfl.Filename, "Error: key word '" + dfl.Next + "' not known in game, on line " + dfl.LineNumber);
dfl.Gn();
break;
}
}
parentDir.ChildAdd(dDir);
return(true);
}
private static void AddZip(FileInfo f, DatDir thisDir)
{
ZipFile zf1 = new ZipFile();
zf1.ZipFileOpen(f.FullName, -1, true);
zf1.ZipStatus = ZipStatus.TrrntZip;
DatDir ZipDir = new DatDir(zf1.ZipStatus == ZipStatus.TrrntZip ? DatFileType.DirTorrentZip : DatFileType.DirRVZip)
{
Name = Path.GetFileNameWithoutExtension(f.Name),
DGame = new DatGame()
};
ZipDir.DGame.Description = ZipDir.Name;
thisDir.ChildAdd(ZipDir);
FileScan fs = new FileScan();
List <FileScan.FileResults> fr = fs.Scan(zf1, true, true);
bool isTorrentZipDate = true;
for (int i = 0; i < fr.Count; i++)
{
if (fr[i].FileStatus != Compress.ZipReturn.ZipGood)
{
Console.WriteLine("File Error :" + zf1.Filename(i) + " : " + fr[i].FileStatus);
continue;
}
DatFile df = new DatFile(DatFileType.FileTorrentZip)
{
Name = zf1.Filename(i),
Size = fr[i].Size,
CRC = fr[i].CRC,
SHA1 = fr[i].SHA1,
Date = zf1.LastModified(i).ToString("yyyy/MM/dd HH:mm:ss")
//df.MD5 = zf.MD5(i)
};
if (zf1.LastModified(i).Ticks != 629870671200000000)
{
isTorrentZipDate = false;
}
ZipDir.ChildAdd(df);
}
zf1.ZipFileClose();
if (isTorrentZipDate && ZipDir.DatFileType == DatFileType.DirRVZip)
{
ZipDir.DatFileType = DatFileType.DirTorrentZip;
}
if (ZipDir.DatFileType == DatFileType.DirTorrentZip)
{
DatSetCompressionType.SetZip(ZipDir);
DatClean.RemoveUnNeededDirectoriesFromZip(ZipDir);
}
}
private static void ProcessDir(DirectoryInfo di, DatDir thisDir, bool newStyle)
{
DirectoryInfo[] dia = di.GetDirectories();
foreach (DirectoryInfo d in dia)
{
bool procAsGame = CheckAddDir(d);
if (procAsGame)
{
Console.WriteLine(d.FullName + "\\ need to add as game");
AddDirAsGame(d, thisDir);
}
else
{
DatDir nextDir = new DatDir(DatFileType.Dir)
{
Name = d.Name
};
thisDir.ChildAdd(nextDir);
ProcessDir(d, nextDir, newStyle);
}
}
FileInfo[] fia = di.GetFiles();
int fCount = 0;
foreach (FileInfo f in fia)
{
//Console.WriteLine(f.FullName);
string ext = Path.GetExtension(f.Name).ToLower();
switch (ext)
{
case ".zip":
AddZip(f, thisDir);
break;
case ".7z":
Add7Zip(f, thisDir);
break;
default:
if (newStyle)
{
AddFile(f, thisDir);
}
break;
}
if (testMode)
{
fCount++;
if (fCount > 10)
{
break;
}
}
}
}
public static void DatSetMakeNonMergeSet(DatDir tDat)
{
// look for merged roms, check if a rom exists in a parent set where the Name,Size and CRC all match.
for (int g = 0; g < tDat.ChildCount; g++)
{
DatDir mGame = (DatDir)tDat.Child(g);
if (mGame.DGame == null)
{
DatSetMakeNonMergeSet(mGame);
}
else
{
DatGame dGame = mGame.DGame;
if (dGame?.device_ref == null)
{
continue;
}
List <DatDir> devices = new List <DatDir> {
mGame
};
foreach (string device in dGame.device_ref)
{
AddDevice(device, devices, tDat);
}
devices.RemoveAt(0);
foreach (DatDir device in devices)
{
for (int i = 0; i < device.ChildCount; i++)
{
DatFile df0 = (DatFile)device.Child(i);
bool crcFound = false;
for (int j = 0; j < mGame.ChildCount; j++)
{
DatFile df1 = (DatFile)mGame.Child(j);
if (ArrByte.bCompare(df0.SHA1, df1.SHA1))
{
crcFound = true;
break;
}
}
if (!crcFound)
{
mGame.ChildAdd(device.Child(i));
}
}
}
}
}
}
private bool LoadFileFromDat(DatFileLoader dfl, DatDir parentDir)
{
if (dfl.Next != "(")
{
_errorReport?.Invoke(dfl.Filename, "( not found after file, on line " + dfl.LineNumber);
return(false);
}
dfl.Gn();
if (dfl.Next.ToLower() != "name")
{
_errorReport?.Invoke(dfl.Filename, "Name not found as first object in ( ), on line " + dfl.LineNumber);
return(false);
}
DatFile dRom = new DatFile(DatFileType.UnSet)
{
Name = dfl.GnNameToSize()
};
dfl.Gn();
while (dfl.Next != ")")
{
switch (dfl.Next.ToLower())
{
case "size":
dRom.Size = VarFix.ULong(dfl.Gn());
dfl.Gn();
break;
case "crc":
dRom.CRC = VarFix.CleanMD5SHA1(dfl.Gn(), 8);
dfl.Gn();
break;
case "date":
dRom.Date = dfl.Gn() + " " + dfl.Gn();
dfl.Gn();
break;
default:
_errorReport?.Invoke(dfl.Filename, "Error: key word '" + dfl.Next + "' not known in rom, on line " + dfl.LineNumber);
dfl.Gn();
break;
}
}
parentDir.ChildAdd(dRom);
return(true);
}
private static void LoadDiskFromDat(DatDir parentDir, XmlNode romNode)
{
if (romNode.Attributes == null)
{
return;
}
DatFile dRom = new DatFile(DatFileType.UnSet)
{
Name = VarFix.CleanCHD(romNode.Attributes.GetNamedItem("name")),
SHA1 = VarFix.CleanMD5SHA1(romNode.Attributes.GetNamedItem("sha1"), 40),
Status = VarFix.ToLower(romNode.Attributes.GetNamedItem("status")),
isDisk = true
};
parentDir.ChildAdd(dRom);
}
public static void MakeDatSingleLevel(DatHeader tDatHeader, bool useDescription, bool removeSubDir)
{
DatBase[] db = tDatHeader.BaseDir.ToArray();
tDatHeader.Dir = "noautodir";
string rootDirName = "";
if (string.IsNullOrEmpty(rootDirName) && useDescription && !string.IsNullOrWhiteSpace(tDatHeader.Description))
{
rootDirName = tDatHeader.Description;
}
if (string.IsNullOrEmpty(rootDirName))
{
rootDirName = tDatHeader.Name;
}
tDatHeader.BaseDir.ChildrenClear();
DatDir root = new DatDir(DatFileType.UnSet)
{
Name = rootDirName,
DGame = new DatGame {
Description = tDatHeader.Description
}
};
tDatHeader.BaseDir.ChildAdd(root);
foreach (DatBase set in db)
{
string dirName = set.Name;
if (!(set is DatDir romSet))
{
continue;
}
DatBase[] dbr = romSet.ToArray();
foreach (DatBase rom in dbr)
{
if (!removeSubDir)
{
rom.Name = dirName + "\\" + rom.Name;
}
root.ChildAdd(rom);
}
}
}
private static void AddFile(FileInfo f, DatDir thisDir)
{
Compress.File.File zf1 = new Compress.File.File();
zf1.ZipFileOpen(f.FullName, -1, true);
FileScan fs = new FileScan();
List <FileScan.FileResults> fr = fs.Scan(zf1, true, true);
DatFile df = new DatFile(DatFileType.File)
{
Name = f.Name,
Size = fr[0].Size,
CRC = fr[0].CRC,
SHA1 = fr[0].SHA1
};
thisDir.ChildAdd(df);
zf1.ZipFileClose();
}
public static void MakeDatSingleLevel(DatHeader tDatHeader, bool useDescription)
{
DatBase[] db = tDatHeader.BaseDir.ToArray();
tDatHeader.Dir = "noautodir";
// if we are auto adding extra directories then create a new directory.
string extraDirName = "";
if (string.IsNullOrEmpty(extraDirName) && useDescription && !string.IsNullOrWhiteSpace(tDatHeader.Description))
{
extraDirName = tDatHeader.Description;
}
if (string.IsNullOrEmpty(extraDirName))
{
extraDirName = tDatHeader.Name;
}
tDatHeader.BaseDir.ChildrenClear();
DatDir root = new DatDir(DatFileType.UnSet)
{
Name = extraDirName,
DGame = new DatGame {
Description = tDatHeader.Description
}
};
tDatHeader.BaseDir.ChildAdd(root);
foreach (DatBase set in db)
{
string dirName = set.Name;
if (!(set is DatDir romSet))
{
continue;
}
DatBase[] dbr = romSet.ToArray();
foreach (DatBase rom in dbr)
{
rom.Name = dirName + "\\" + rom.Name;
root.ChildAdd(rom);
}
}
}
private static void LoadRomFromDat(DatDir parentDir, XmlNode romNode)
{
if (romNode.Attributes == null)
{
return;
}
DatFile rvRom = new DatFile(DatFileType.UnSet)
{
Name = VarFix.String(romNode.Attributes.GetNamedItem("name")),
Size = VarFix.ULong(romNode.Attributes.GetNamedItem("size")),
CRC = VarFix.CleanMD5SHA1(romNode.Attributes.GetNamedItem("crc"), 8),
SHA1 = VarFix.CleanMD5SHA1(romNode.Attributes.GetNamedItem("sha1"), 40),
MD5 = VarFix.CleanMD5SHA1(romNode.Attributes.GetNamedItem("md5"), 32),
Merge = VarFix.String(romNode.Attributes.GetNamedItem("merge")),
Status = VarFix.ToLower(romNode.Attributes.GetNamedItem("status")),
Region = VarFix.ToLower(romNode.Attributes.GetNamedItem("region"))
};
parentDir.ChildAdd(rvRom);
}
private static void AddZip(FileInfo f, DatDir thisDir)
{
DatDir ZipDir = new DatDir(DatFileType.DirTorrentZip)
{
Name = Path.GetFileNameWithoutExtension(f.Name),
DGame = new DatGame()
};
ZipDir.DGame.Description = ZipDir.Name;
thisDir.ChildAdd(ZipDir);
ZipFile zf1 = new ZipFile();
zf1.ZipFileOpen(f.FullName, -1, true);
FileScan fs = new FileScan();
List <FileScan.FileResults> fr = fs.Scan(zf1, true, true);
for (int i = 0; i < fr.Count; i++)
{
if (fr[i].FileStatus != Compress.ZipReturn.ZipGood)
{
Console.WriteLine("File Error :" + zf1.Filename(i) + " : " + fr[i].FileStatus);
continue;
}
DatFile df = new DatFile(DatFileType.FileTorrentZip)
{
Name = Path.GetFileNameWithoutExtension(f.Name) + Path.GetExtension(zf1.Filename(i)),
Size = fr[i].Size,
CRC = fr[i].CRC,
SHA1 = fr[i].SHA1
//df.MD5 = zf.MD5(i)
};
ZipDir.ChildAdd(df);
}
zf1.ZipFileClose();
}
private static void LoadDiskFromDat(DatDir parentDir, XmlNode romNode)
{
if (romNode.Attributes == null)
{
return;
}
DatFile rvRom = new DatFile(DatFileType.UnSet)
{
Name = VarFix.String(romNode.Attributes.GetNamedItem("name")) + ".chd",
SHA1 = VarFix.CleanMD5SHA1(romNode.Attributes.GetNamedItem("sha1"), 40),
MD5 = VarFix.CleanMD5SHA1(romNode.Attributes.GetNamedItem("md5"), 32),
Merge = VarFix.String(romNode.Attributes.GetNamedItem("merge")),
Status = VarFix.ToLower(romNode.Attributes.GetNamedItem("status")),
isDisk = true
};
if (!string.IsNullOrWhiteSpace(rvRom.Merge))
{
rvRom.Merge += ".chd";
}
parentDir.ChildAdd(rvRom);
}
private static void LoadDirFromDat(DatDir parentDir, XmlNode dirNode)
{
if (dirNode.Attributes == null)
{
return;
}
string name = VarFix.String(dirNode.Attributes.GetNamedItem("name"));
DatDir dir = new DatDir(DatFileType.UnSet)
{
Name = name
};
parentDir.ChildAdd(dir);
XmlNodeList dirNodeList = dirNode.SelectNodes("dir");
if (dirNodeList != null)
{
for (int i = 0; i < dirNodeList.Count; i++)
{
LoadDirFromDat(dir, dirNodeList[i]);
}
}
XmlNodeList gameNodeList = dirNode.SelectNodes("game");
if (gameNodeList != null)
{
for (int i = 0; i < gameNodeList.Count; i++)
{
LoadGameFromDat(dir, gameNodeList[i]);
}
}
}
public static void DatSetMakeMergeSet(DatDir tDat, bool mergeWithGameName = true)
{
// look for merged roms, check if a rom exists in a parent set where the Name,Size and CRC all match.
for (int g = 0; g < tDat.ChildCount; g++)
{
DatDir mGame = (DatDir)tDat.Child(g);
if (mGame.DGame == null)
{
DatSetMakeMergeSet(mGame, mergeWithGameName);
continue;
}
// find all parents of this game
List <DatDir> lstParentGames = new List <DatDir>();
DatFindParentSets.FindParentSet(mGame, tDat, true, ref lstParentGames);
// if no parents are found then just set all children as kept
if (lstParentGames.Count == 0)
{
for (int r = 0; r < mGame.ChildCount; r++)
{
if (mGame.Child(r) is DatFile dfGame)
{
RomCheckCollect(dfGame, false);
}
}
continue;
}
List <DatDir> pGames = new List <DatDir>();
List <DatDir> pBios = new List <DatDir>();
foreach (DatDir dd in lstParentGames)
{
if (dd.DGame.IsBios?.ToLower() == "yes")
{
pBios.Add(dd);
}
else
{
pGames.Add(dd);
}
}
DatBase[] mGameTest = mGame.ToArray();
List <DatBase> mGameKeep = new List <DatBase>();
foreach (DatBase tGame in mGameTest)
{
if (((DatFile)tGame).Status == "nodump")
{
mGame.ChildAdd(tGame);
continue;
}
// first remove any file that is in a parent BIOS set
bool found = false;
foreach (DatDir romofGame in pBios)
{
for (int r1 = 0; r1 < romofGame.ChildCount; r1++)
{
// size/checksum compare, so name does not need to match
// if (!string.Equals(mGame[r].Name, romofGame.Child(r1).Name, StringComparison.OrdinalIgnoreCase))
// {
// continue;
// }
ulong?size0 = ((DatFile)tGame).Size;
ulong?size1 = ((DatFile)romofGame.Child(r1)).Size;
if ((size0 != null) && (size1 != null) && (size0 != size1))
{
continue;
}
byte[] crc0 = ((DatFile)tGame).CRC;
byte[] crc1 = ((DatFile)romofGame.Child(r1)).CRC;
if ((crc0 != null) && (crc1 != null) && !ArrByte.bCompare(crc0, crc1))
{
continue;
}
byte[] sha0 = ((DatFile)tGame).SHA1;
byte[] sha1 = ((DatFile)romofGame.Child(r1)).SHA1;
if ((sha0 != null) && (sha1 != null) && !ArrByte.bCompare(sha0, sha1))
{
continue;
}
byte[] md50 = ((DatFile)tGame).MD5;
byte[] md51 = ((DatFile)romofGame.Child(r1)).MD5;
if ((md50 != null) && (md51 != null) && !ArrByte.bCompare(md50, md51))
{
continue;
}
if (((DatFile)tGame).isDisk != ((DatFile)romofGame.Child(r1)).isDisk)
{
continue;
}
// not needed as we are now checking for nodumps at the top of this code
// don't merge if only one of the ROM is nodump
//if (((DatFile)romofGame.Child(r1)).Status == "nodump" != (((DatFile)mGame[r]).Status == "nodump"))
//{
// continue;
//}
found = true;
break;
}
if (found)
{
break;
}
}
if (!found)
{
mGameKeep.Add(tGame);
}
}
mGame.ChildrenClear();
if (pGames.Count == 0)
{
foreach (DatBase tGame in mGameKeep)
{
mGame.ChildAdd(tGame);
}
continue;
}
DatDir romOfTopParent = pGames[pGames.Count - 1];
foreach (DatBase tGame in mGameKeep)
{
if (mergeWithGameName && !((DatFile)tGame).isDisk)
{
tGame.Name = mGame.Name + "\\" + tGame.Name;
}
romOfTopParent.ChildAdd(tGame);
}
}
}
public static void DirectoryExpand(DatDir dDir)
{
DatBase[] arrDir = dDir.ToArray();
bool foundSubDir = false;
foreach (DatBase db in arrDir)
{
if (CheckDir(db))
{
if (db.Name.Contains("\\"))
{
foundSubDir = true;
break;
}
}
}
if (foundSubDir)
{
dDir.ChildrenClear();
foreach (DatBase db in arrDir)
{
if (CheckDir(db))
{
if (db.Name.Contains("\\"))
{
string dirName = db.Name;
int split = dirName.IndexOf("\\", StringComparison.Ordinal);
string part0 = dirName.Substring(0, split);
string part1 = dirName.Substring(split + 1);
db.Name = part1;
DatDir dirFind = new DatDir(DatFileType.Dir)
{
Name = part0
};
if (dDir.ChildNameSearch(dirFind, out int index) != 0)
{
dDir.ChildAdd(dirFind);
}
else
{
dirFind = (DatDir)dDir.Child(index);
}
if (part1.Length > 0)
{
dirFind.ChildAdd(db);
}
continue;
}
}
dDir.ChildAdd(db);
}
arrDir = dDir.ToArray();
}
foreach (DatBase db in arrDir)
{
if (db is DatDir dbDir)
{
DirectoryExpand(dbDir);
}
}
}
private void LoadGameFromDat(DatDir parentDir, XmlNode gameNode)
{
if (gameNode.Attributes == null)
{
return;
}
DatDir dDir = new DatDir(DatFileType.UnSet)
{
Name = VarFix.String(gameNode.Attributes.GetNamedItem("name")),
DGame = new DatGame()
};
DatGame dGame = dDir.DGame;
dGame.Description = VarFix.String(gameNode.SelectSingleNode("description"));
dGame.RomOf = VarFix.String(gameNode.Attributes?.GetNamedItem("romof"));
dGame.CloneOf = VarFix.String(gameNode.Attributes?.GetNamedItem("cloneof"));
dGame.Year = VarFix.String(gameNode.SelectSingleNode("year"));
dGame.Manufacturer = VarFix.String(gameNode.SelectSingleNode("publisher"));
XmlNodeList partNodeList = gameNode.SelectNodes("part");
if (partNodeList == null)
{
return;
}
for (int iP = 0; iP < partNodeList.Count; iP++)
{
_indexContinue = -1;
XmlNodeList dataAreaNodeList = partNodeList[iP].SelectNodes("dataarea");
if (dataAreaNodeList == null)
{
continue;
}
for (int iD = 0; iD < dataAreaNodeList.Count; iD++)
{
XmlNodeList romNodeList = dataAreaNodeList[iD].SelectNodes("rom");
if (romNodeList == null)
{
continue;
}
for (int iR = 0; iR < romNodeList.Count; iR++)
{
LoadRomFromDat(dDir, romNodeList[iR]);
}
}
}
/*
* for (int iP = 0; iP < partNodeList.Count; iP++)
* {
* XmlNodeList diskAreaNodeList = partNodeList[iP].SelectNodes("diskarea");
* if (diskAreaNodeList != null)
* for (int iD = 0; iD < diskAreaNodeList.Count; iD++)
* {
* XmlNodeList romNodeList = diskAreaNodeList[iD].SelectNodes("disk");
* if (romNodeList != null)
* for (int iR = 0; iR < romNodeList.Count; iR++)
* {
* LoadDiskFromDat(dDirCHD, romNodeList[iR]);
* }
* }
* }
*/
if (dDir.ChildCount > 0)
{
parentDir.ChildAdd(dDir);
}
/*
* if (tDirCHD.ChildCount > 0)
* parentDir.ChildAdd(rvGameCHD, index1);
*/
}
private static bool LoadGameFromDat(DatFileLoader dfl, DatDir parentDir, ReportError errorReport)
{
if (dfl.Next != "(")
{
errorReport?.Invoke(dfl.Filename, "( not found after game, on line " + dfl.LineNumber);
return(false);
}
dfl.Gn();
string sNext = dfl.Next.ToLower();
if (sNext != "name")
{
errorReport?.Invoke(dfl.Filename, "Name not found as first object in ( ), on line " + dfl.LineNumber);
return(false);
}
string name = dfl.GnRest();
int nameLength = name.Length;
if (nameLength > 4 && name.ToLower().Substring(nameLength - 4, 4) == ".zip")
{
name = name.Substring(0, nameLength - 4);
}
dfl.Gn();
DatDir dDir = new DatDir(DatFileType.UnSet)
{
Name = name, DGame = new DatGame()
};
while (dfl.Next != ")")
{
switch (dfl.Next.ToLower())
{
case "file":
dfl.Gn();
if (!LoadFileFromDat(dfl, dDir, errorReport))
{
return(false);
}
dfl.Gn();
break;
case "rom":
dfl.Gn();
if (!LoadFileFromDat(dfl, dDir, errorReport))
{
return(false);
}
dfl.Gn();
break;
default:
errorReport?.Invoke(dfl.Filename, "Error: key word '" + dfl.Next + "' not known in game, on line " + dfl.LineNumber);
dfl.Gn();
break;
}
}
parentDir.ChildAdd(dDir);
return(true);
}
private bool LoadDiskFromDat(DatFileLoader dfl, DatDir parentDir)
{
dfl.Gn();
if (dfl.Next != "(")
{
_errorReport?.Invoke(dfl.Filename, "( not found after rom, on line " + dfl.LineNumber);
return(false);
}
dfl.Gn();
if (dfl.Next.ToLower() != "name")
{
_errorReport?.Invoke(dfl.Filename, "Name not found as first object in ( ), on line " + dfl.LineNumber);
return(false);
}
DatFile dRom = new DatFile(DatFileType.UnSet)
{
Name = VarFix.String(dfl.Gn()) + ".chd",
isDisk = true
};
dfl.Gn();
while (dfl.Next != ")")
{
switch (dfl.Next.ToLower())
{
case "sha1":
dRom.SHA1 = VarFix.CleanMD5SHA1(dfl.Gn(), 40);
break;
case "md5":
dRom.MD5 = VarFix.CleanMD5SHA1(dfl.Gn(), 32);
break;
case "region":
dRom.Region = VarFix.String(dfl.Gn());
break;
case "merge":
dRom.Merge = VarFix.String(dfl.Gn());
break;
case "index":
dfl.Gn();
break;
case "flags":
dRom.Status = VarFix.ToLower(dfl.Gn());
break;
case "nodump":
dRom.Status = "nodump";
break;
default:
_errorReport?.Invoke(dfl.Filename, "Error: key word '" + dfl.Next + "' not known in rom, on line " + dfl.LineNumber);
break;
}
dfl.Gn();
}
parentDir.ChildAdd(dRom);
return(true);
}
private bool LoadGameFromDat(DatFileLoader dfl, DatDir parentDir)
{
dfl.Gn();
if (dfl.Next != "(")
{
_errorReport?.Invoke(dfl.Filename, "( not found after game, on line " + dfl.LineNumber);
return(false);
}
dfl.Gn();
string snext = dfl.Next.ToLower();
string pathextra = "";
if (snext == "rebuildto")
{
pathextra = dfl.Gn();
dfl.Gn();
snext = dfl.Next.ToLower();
}
if (snext != "name")
{
_errorReport?.Invoke(dfl.Filename, "Name not found as first object in ( ), on line " + dfl.LineNumber);
return(false);
}
string name = dfl.GnRest();
name = Path.Combine(pathextra, name);
dfl.Gn();
DatDir dDir = new DatDir(DatFileType.UnSet)
{
Name = name, DGame = new DatGame()
};
DatGame dGame = dDir.DGame;
while (dfl.Next != ")" && !dfl.EndOfStream())
{
switch (dfl.Next.ToLower())
{
case "romof":
dGame.RomOf = dfl.GnRest();
break;
case "description":
dGame.Description = dfl.GnRest();
break;
case "sourcefile":
dGame.SourceFile = dfl.GnRest();
break;
case "cloneof":
dGame.CloneOf = dfl.GnRest();
break;
case "sampleof":
dGame.SampleOf = dfl.GnRest();
break;
case "board":
dGame.Board = dfl.GnRest();
break;
case "year":
dGame.Year = dfl.GnRest();
break;
case "manufacturer":
dGame.Manufacturer = dfl.GnRest();
break;
case "history":
dGame.History = dfl.GnRest();
break;
case "serial":
dfl.GnRest();
break;
case "rebuildto":
dfl.GnRest();
break;
case "sample":
dfl.GnRest();
break;
case "biosset":
dfl.GnRest();
break;
case "chip":
dfl.GnRest();
break;
case "video":
dfl.GnRest();
break;
case "sound":
dfl.GnRest();
break;
case "input":
dfl.GnRest();
break;
case "dipswitch":
dfl.GnRest();
break;
case "driver":
dfl.GnRest();
break;
case "display":
dfl.GnRest();
break;
case "comment":
case "releaseyear":
case "releasemonth":
case "releaseday":
case "genre":
case "developer":
case "publisher":
case "homepage":
case "users":
case "version":
case "license":
dfl.GnRest();
break;
case "name":
string tmpName = dfl.GnRest();
_errorReport?.Invoke(dfl.Filename, "Error: multiple names found in one game '" + tmpName + "' will be ignored, on line " + dfl.LineNumber);
break;
case "rom":
if (!LoadRomFromDat(dfl, dDir))
{
return(false);
}
break;
case "disk":
if (!LoadDiskFromDat(dfl, dDir))
{
return(false);
}
break;
case "archive":
if (!LoadArchiveFromDat(dfl))
{
return(false);
}
break;
default:
_errorReport?.Invoke(dfl.Filename, "Error: key word '" + dfl.Next + "' not known in game, on line " + dfl.LineNumber);
break;
}
dfl.Gn();
}
parentDir.ChildAdd(dDir);
return(true);
}
public static void MakeDatSingleLevel(DatHeader tDatHeader, bool useDescription, RemoveSubType subDirType, bool isFiles)
{
// KeepAllSubDirs, just does what it says
// RemoveAllSubDirs, just does what it says
// RemoveallIfNoConflicts, does the conflict precheck and if a conflict is found switches to KeepAllSubDirs
// RemoveSubIfNameMatches, will remove the subdir if the rom and game name match (without extentions) and there is only one rom in the game
DatBase[] db = tDatHeader.BaseDir.ToArray();
tDatHeader.Dir = "noautodir";
string rootDirName = "";
if (string.IsNullOrEmpty(rootDirName) && useDescription &&
!string.IsNullOrWhiteSpace(tDatHeader.Description))
{
rootDirName = tDatHeader.Description;
}
if (string.IsNullOrEmpty(rootDirName))
{
rootDirName = tDatHeader.Name;
}
// do a pre check to see if removing all the sub-dirs will give any name conflicts
if (subDirType == RemoveSubType.RemoveAllIfNoConflicts)
{
bool foundRepeatFilename = false;
DatDir rootTest = new DatDir(DatFileType.UnSet)
{
Name = rootDirName,
DGame = new DatGame {
Description = tDatHeader.Description
}
};
foreach (DatBase set in db)
{
string dirName = set.Name;
if (!(set is DatDir romSet))
{
continue;
}
DatBase[] dbr = romSet.ToArray();
foreach (DatBase rom in dbr)
{
int f = rootTest.ChildNameSearch(rom, out int _);
if (f == 0)
{
foundRepeatFilename = true;
subDirType = RemoveSubType.KeepAllSubDirs;
break;
}
rootTest.ChildAdd(rom);
}
if (foundRepeatFilename)
{
break;
}
}
}
tDatHeader.BaseDir.ChildrenClear();
DatDir root;
if (isFiles)
{
root = tDatHeader.BaseDir;
}
else
{
root = new DatDir(DatFileType.UnSet)
{
Name = rootDirName,
DGame = new DatGame {
Description = tDatHeader.Description
}
};
tDatHeader.BaseDir.ChildAdd(root);
}
foreach (DatBase set in db)
{
string dirName = set.Name;
if (!(set is DatDir romSet))
{
continue;
}
DatBase[] dbr = romSet.ToArray();
foreach (DatBase rom in dbr)
{
if (subDirType == RemoveSubType.RemoveSubIfNameMatches)
{
if (dbr.Length != 1 || Path.GetFileNameWithoutExtension(rom.Name) != dirName)
{
rom.Name = dirName + "\\" + rom.Name;
}
}
else if (subDirType == RemoveSubType.KeepAllSubDirs)
{
rom.Name = dirName + "\\" + rom.Name;
}
root.ChildAdd(rom);
}
}
}
private static void LoadGameFromDat(DatDir parentDir, XmlNode gameNode)
{
if (gameNode.Attributes == null)
{
return;
}
DatGame dGame = new DatGame();
DatDir dDir = new DatDir(DatFileType.UnSet)
{
Name = VarFix.String(gameNode.Attributes.GetNamedItem("name")),
DGame = dGame
};
dGame.RomOf = VarFix.String(gameNode.Attributes.GetNamedItem("romof"));
dGame.CloneOf = VarFix.String(gameNode.Attributes.GetNamedItem("cloneof"));
dGame.SampleOf = VarFix.String(gameNode.Attributes.GetNamedItem("sampleof"));
dGame.Description = VarFix.String(gameNode.SelectSingleNode("description"));
dGame.SourceFile = VarFix.String(gameNode.Attributes?.GetNamedItem("sourcefile"));
dGame.IsBios = VarFix.String(gameNode.Attributes?.GetNamedItem("isbios"));
dGame.IsDevice = VarFix.String(gameNode.Attributes?.GetNamedItem("isdevice"));
dGame.Board = VarFix.String(gameNode.Attributes?.GetNamedItem("board"));
dGame.Year = VarFix.String(gameNode.SelectSingleNode("year"));
dGame.Manufacturer = VarFix.String(gameNode.SelectSingleNode("manufacturer"));
dGame.Runnable = VarFix.String(gameNode.Attributes?.GetNamedItem("runnable"));
XmlNode tea = gameNode.SelectSingleNode("tea") ?? gameNode.SelectSingleNode("trurip");
if (tea != null)
{
dGame.IsTea = true;
dGame.TitleId = VarFix.String(tea.SelectSingleNode("titleid"));
dGame.Publisher = VarFix.String(tea.SelectSingleNode("publisher"));
dGame.Developer = VarFix.String(tea.SelectSingleNode("developer"));
dGame.Year = VarFix.String(gameNode.SelectSingleNode("year"));
dGame.Genre = VarFix.String(tea.SelectSingleNode("genre"));
dGame.SubGenre = VarFix.String(tea.SelectSingleNode("subgenre"));
dGame.Ratings = VarFix.String(tea.SelectSingleNode("ratings"));
dGame.Score = VarFix.String(tea.SelectSingleNode("score"));
dGame.Players = VarFix.String(tea.SelectSingleNode("players"));
dGame.Enabled = VarFix.String(tea.SelectSingleNode("enabled"));
dGame.CRC = VarFix.String(tea.SelectSingleNode("crc"));
dGame.CloneOf = VarFix.String(tea.SelectSingleNode("cloneof"));
dGame.RelatedTo = VarFix.String(tea.SelectSingleNode("relatedto"));
dGame.Source = VarFix.String(tea.SelectSingleNode("source"));
}
parentDir.ChildAdd(dDir);
XmlNodeList romNodeList = gameNode.SelectNodes("rom");
if (romNodeList != null)
{
for (int i = 0; i < romNodeList.Count; i++)
{
LoadRomFromDat(dDir, romNodeList[i]);
}
}
XmlNodeList diskNodeList = gameNode.SelectNodes("disk");
if (diskNodeList != null)
{
for (int i = 0; i < diskNodeList.Count; i++)
{
LoadDiskFromDat(dDir, diskNodeList[i]);
}
}
XmlNodeList deviceRef = gameNode.SelectNodes("device_ref");
if (deviceRef != null)
{
for (int i = 0; i < deviceRef.Count; i++)
{
LoadDeviceRef(dGame, deviceRef[i]);
}
}
XmlNodeList slotList = gameNode.SelectNodes("slot");
if (slotList != null)
{
for (int i = 0; i < slotList.Count; i++)
{
LoadSlot(dGame, slotList[i]);
}
}
}
