private static void ExtractZips(uint datId, string outDir)
{
if (buffer == null)
{
buffer = new byte[BufferSize];
}
RvDat tDat = new RvDat();
tDat.DBRead(datId, true);
_bgw.ReportProgress(0, new bgwSetRange(tDat.Games.Count));
for (int gIndex = 0; gIndex < tDat.Games.Count; gIndex++)
{
if (_bgw.CancellationPending)
{
return;
}
RvGame tGame = tDat.Games[gIndex];
_bgw.ReportProgress(gIndex);
_bgw.ReportProgress(0, new bgwText("Creating zip : " + tGame.Name + ".zip"));
ExtractGame(tGame, outDir);
}
}
public static void MakeDatZips(object sender, DoWorkEventArgs e)
{
_bgw = sender as BackgroundWorker;
Program.SyncCont = e.Argument as SynchronizationContext;
if (Program.SyncCont == null)
{
_bgw = null;
return;
}
if (!Directory.Exists(_outputdir))
{
return;
}
if (_treeRow != null)
{
FindDats(_treeRow);
}
else
{
RvGame tGame = new RvGame();
tGame.DBRead((int)_gameId, true);
ExtractGame(tGame, _outputdir);
}
_bgw.ReportProgress(0, new bgwText("Creating Zips Complete"));
_bgw = null;
Program.SyncCont = null;
}
private static void LoadRomFromDat(RvGame rvGame, XmlNode romNode)
{
if (romNode.Attributes == null)
{
return;
}
XmlNode name = romNode.Attributes.GetNamedItem("name");
string loadflag = VarFix.String(romNode.Attributes.GetNamedItem("loadflag"));
if (name != null)
{
RvRom rvRom = new RvRom();
rvRom.Name = VarFix.CleanFullFileName(name);
rvRom.Size = VarFix.ULong(romNode.Attributes.GetNamedItem("size"));
rvRom.CRC = VarFix.CleanMD5SHA1(romNode.Attributes.GetNamedItem("crc"), 8);
rvRom.SHA1 = VarFix.CleanMD5SHA1(romNode.Attributes.GetNamedItem("sha1"), 40);
rvRom.Status = VarFix.ToLower(romNode.Attributes.GetNamedItem("status"));
_indexContinue = rvGame.AddRom(rvRom);
}
else if (loadflag.ToLower() == "continue")
{
RvRom tROM = rvGame.Roms[_indexContinue];
tROM.Size += VarFix.ULong(romNode.Attributes.GetNamedItem("size"));
}
else if (loadflag.ToLower() == "ignore")
{
RvRom tROM = rvGame.Roms[_indexContinue];
tROM.Size += VarFix.ULong(romNode.Attributes.GetNamedItem("size"));
}
}
private static bool LoadRomFromDat(RvGame rvGame)
{
if (DatFileLoader.Next != "(")
{
DatUpdate.SendAndShowDat("( not found after rom", DatFileLoader.Filename);
return(false);
}
DatFileLoader.Gn();
if (DatFileLoader.Next.ToLower() != "name")
{
DatUpdate.SendAndShowDat("Name not found as first object in ( )", DatFileLoader.Filename);
return(false);
}
RvRom rvRom = new RvRom();
rvRom.Name = VarFix.CleanFullFileName(DatFileLoader.Gn());
DatFileLoader.Gn();
while (DatFileLoader.Next != ")")
{
switch (DatFileLoader.Next.ToLower())
{
case "size": rvRom.Size = VarFix.ULong(DatFileLoader.Gn()); DatFileLoader.Gn(); break;
case "crc": rvRom.CRC = VarFix.CleanMD5SHA1(DatFileLoader.Gn(), 8); DatFileLoader.Gn(); break;
case "sha1": rvRom.SHA1 = VarFix.CleanMD5SHA1(DatFileLoader.Gn(), 40); DatFileLoader.Gn(); break;
case "md5": rvRom.MD5 = VarFix.CleanMD5SHA1(DatFileLoader.Gn(), 32); DatFileLoader.Gn(); break;
case "merge": rvRom.Merge = VarFix.CleanFullFileName(DatFileLoader.Gn()); DatFileLoader.Gn(); break;
case "flags": rvRom.Status = VarFix.ToLower(DatFileLoader.Gn()); DatFileLoader.Gn(); break;
case "date": DatFileLoader.Gn(); DatFileLoader.Gn(); break;
case "bios": DatFileLoader.Gn(); DatFileLoader.Gn(); break;
case "region": DatFileLoader.Gn(); DatFileLoader.Gn(); break;
case "offs": DatFileLoader.Gn(); DatFileLoader.Gn(); break;
case "nodump": rvRom.Status = "nodump"; DatFileLoader.Gn(); break;
default:
DatUpdate.SendAndShowDat("Error: key word '" + DatFileLoader.Next + "' not known in rom", DatFileLoader.Filename);
DatFileLoader.Gn();
break;
}
}
rvGame.AddRom(rvRom);
return(true);
}
private static void CheckAttribute(RvGame cGame, string source, RvGame.GameData gParam)
{
if (string.IsNullOrWhiteSpace(source))
{
return;
}
cGame.AddData(gParam, source);
}
private static void LoadDiskFromDat(RvGame rvGame, XmlNode romNode)
{
if (romNode.Attributes == null)
{
return;
}
string Name = VarFix.CleanFullFileName(romNode.Attributes.GetNamedItem("name")) + ".chd";
byte[] SHA1CHD = VarFix.CleanMD5SHA1(romNode.Attributes.GetNamedItem("sha1"), 40);
byte[] MD5CHD = VarFix.CleanMD5SHA1(romNode.Attributes.GetNamedItem("md5"), 32);
string Merge = VarFix.CleanFullFileName(romNode.Attributes.GetNamedItem("merge"));
string Status = VarFix.ToLower(romNode.Attributes.GetNamedItem("status"));
}
private static bool LoadDiskFromDat(RvGame rvGame)
{
if (DatFileLoader.Next != "(")
{
DatUpdate.SendAndShowDat("( not found after rom", DatFileLoader.Filename);
return(false);
}
DatFileLoader.Gn();
if (DatFileLoader.Next.ToLower() != "name")
{
DatUpdate.SendAndShowDat("Name not found as first object in ( )", DatFileLoader.Filename);
return(false);
}
string filename = VarFix.CleanFullFileName(DatFileLoader.Gn());
byte[] sha1;
byte[] md5;
string Merge;
string Status;
DatFileLoader.Gn();
while (DatFileLoader.Next != ")")
{
switch (DatFileLoader.Next.ToLower())
{
case "sha1": sha1 = VarFix.CleanMD5SHA1(DatFileLoader.Gn(), 40); DatFileLoader.Gn(); break;
case "md5": md5 = VarFix.CleanMD5SHA1(DatFileLoader.Gn(), 32); DatFileLoader.Gn(); break;
case "merge": Merge = VarFix.CleanFullFileName(DatFileLoader.Gn()); DatFileLoader.Gn(); break;
case "flags": Status = VarFix.ToLower(DatFileLoader.Gn()); DatFileLoader.Gn(); break;
case "nodump": Status = "nodump"; DatFileLoader.Gn(); break;
default:
DatUpdate.SendAndShowDat("Error: key word '" + DatFileLoader.Next + "' not known in rom", DatFileLoader.Filename);
DatFileLoader.Gn();
break;
}
}
return(true);
}
private static void LoadRomFromDat(RvGame rvGame, XmlNode romNode)
{
if (romNode.Attributes == null)
{
return;
}
RvRom rvRom = new RvRom();
rvRom.Name = VarFix.CleanFullFileName(romNode.Attributes.GetNamedItem("name"));
rvRom.Size = VarFix.ULong(romNode.Attributes.GetNamedItem("size"));
rvRom.CRC = VarFix.CleanMD5SHA1(romNode.Attributes.GetNamedItem("crc"), 8);
rvRom.SHA1 = VarFix.CleanMD5SHA1(romNode.Attributes.GetNamedItem("sha1"), 40);
rvRom.MD5 = VarFix.CleanMD5SHA1(romNode.Attributes.GetNamedItem("md5"), 32);
rvRom.Merge = VarFix.CleanFullFileName(romNode.Attributes.GetNamedItem("merge"));
rvRom.Status = VarFix.ToLower(romNode.Attributes.GetNamedItem("status"));
rvGame.AddRom(rvRom);
}
private static void DatSetRemoveUnneededDirs(RvDat tDat)
{
if (tDat.Games == null)
{
return;
}
for (int g = 0; g < tDat.Games.Count; g++)
{
RvGame tGame = tDat.Games[g];
for (int r = 0; r < tGame.RomCount - 1; r++)
{
// first find any directories, zero length with filename ending in a '/'
// there are RvFiles that are really directories (probably inside a zip file)
RvRom f0 = tGame.Roms[r];
if (f0.Name.Length == 0)
{
continue;
}
if (f0.Name.Substring(f0.Name.Length - 1, 1) != "/")
{
continue;
}
// if the next file contains that found directory, then the directory file can be deleted
RvRom f1 = tGame.Roms[r + 1];
if (f1.Name.Length <= f0.Name.Length)
{
continue;
}
if (f0.Name != f1.Name.Substring(0, f0.Name.Length))
{
continue;
}
tGame.Roms.RemoveAt(r);
r--;
}
}
}
private static void LoadRomFromDat(RvGame rvGame, XmlNode romNode, HeaderFileType datFileType)
{
if (romNode.Attributes == null)
{
return;
}
RvRom rvRom = new RvRom
{
AltType = datFileType,
Name = VarFix.CleanFullFileName(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.CleanFullFileName(romNode.Attributes.GetNamedItem("merge")),
Status = VarFix.ToLower(romNode.Attributes.GetNamedItem("status"))
};
rvGame.AddRom(rvRom);
}
private static void DatSetRenameAndRemoveDups(RvDat tDat)
{
if (tDat.Games == null)
{
return;
}
for (int g = 0; g < tDat.Games.Count; g++)
{
RvGame tGame = tDat.Games[g];
for (int r = 0; r < tGame.RomCount - 1; r++)
{
RvRom f0 = tGame.Roms[r];
RvRom f1 = tGame.Roms[r + 1];
if (f0.Name != f1.Name)
{
continue;
}
if ((f0.Size != f1.Size) || (ArrByte.iCompare(f0.CRC, f1.CRC) != 0))
{
tGame.Roms.RemoveAt(r + 1); // remove F1
f1.Name = f1.Name + "_" + ArrByte.ToString(f1.CRC); // rename F1;
int pos = tGame.AddRom(f1);
// if this rename moved the File back up the list, start checking again from that file.
if (pos < r)
{
r = pos;
}
}
else
{
tGame.Roms.RemoveAt(r + 1);
}
r--;
}
}
}
private static void FindParentSet(RvGame searchGame, RvDat parentDir, ref List <RvGame> lstParentGames)
{
string parentName = searchGame.RomOf;
if (string.IsNullOrEmpty(parentName) || (parentName == searchGame.Name))
{
parentName = searchGame.CloneOf;
}
if (string.IsNullOrEmpty(parentName) || (parentName == searchGame.Name))
{
return;
}
int intResult = parentDir.ChildNameSearch(parentName, out int intIndex);
if (intResult == 0)
{
RvGame parentGame = parentDir.Games[intIndex];
lstParentGames.Add(parentGame);
FindParentSet(parentGame, parentDir, ref lstParentGames);
}
}
public static bool ReadDat(string strFilename, out RvDat rvDat)
{
HeaderFileType datFileType = HeaderFileType.Nothing;
rvDat = new RvDat();
int errorCode = DatFileLoader.LoadDat(strFilename);
if (errorCode != 0)
{
DatUpdate.ShowDat(new Win32Exception(errorCode).Message, strFilename);
return(false);
}
string filename = Path.GetFileName(strFilename);
DatFileLoader.Gn();
if (DatFileLoader.EndOfStream())
{
return(false);
}
if (DatFileLoader.Next.ToLower() == "[credits]")
{
if (!LoadHeaderFromDat(filename, rvDat, out datFileType, DatFileLoader.Next.ToLower()))
{
return(false);
}
DatFileLoader.Gn();
}
else if (DatFileLoader.Next.ToLower() == "[dat]")
{
if (!LoadHeaderFromDat(filename, rvDat, out datFileType, DatFileLoader.Next.ToLower()))
{
return(false);
}
DatFileLoader.Gn();
}
else if (DatFileLoader.Next.ToLower() == "[emulator]")
{
if (!LoadHeaderFromDat(filename, rvDat, out datFileType, DatFileLoader.Next.ToLower()))
{
return(false);
}
DatFileLoader.Gn();
}
// Everything else if a rom/game
string lastgame = "";
bool foundgame = false;
RvGame rvGame = new RvGame();
while (!DatFileLoader.EndOfStream())
{
// Set loop variables
foundgame = true;
string game = "", description = "", romof = "", cloneof = "";
RvRom rvRom = new RvRom();
if (!LoadRomFromDat("", datFileType, out rvRom, out game, out description, out romof, out cloneof))
{
return(false);
}
DatFileLoader.Gn();
// If we have a new game finally, add the last one
if (lastgame != game && lastgame != "")
{
rvDat.AddGame(rvGame);
foundgame = false;
rvGame = new RvGame();
}
// For everything else, add to the new rvGame
rvGame.Name = (String.IsNullOrEmpty(rvGame.Name) ? game : rvGame.Name);
rvGame.Description = (String.IsNullOrEmpty(rvGame.Description) ? description : rvGame.Description);
rvGame.CloneOf = (String.IsNullOrEmpty(rvGame.CloneOf) ? cloneof : rvGame.CloneOf);
rvGame.RomOf = (String.IsNullOrEmpty(rvGame.RomOf) ? romof : rvGame.RomOf);
rvGame.AddRom(rvRom);
lastgame = game;
}
// If we had a lingering game, add it
if (foundgame)
{
rvDat.AddGame(rvGame);
}
DatFileLoader.Close();
return(true);
}
private static void DatSetCheckCollect(RvDat tDat)
{
if (tDat.Games == null)
{
return;
}
// now 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.Games.Count; g++)
{
RvGame mGame = tDat.Games[g];
List <RvGame> lstParentGames = new List <RvGame>();
FindParentSet(mGame, tDat, ref lstParentGames);
if ((lstParentGames.Count == 0) || (mGame.IsBios?.ToLower() == "yes"))
{
for (int r = 0; r < mGame.RomCount; r++)
{
RomCheckCollect(mGame.Roms[r], false);
}
}
else
{
for (int r = 0; r < mGame.RomCount; r++)
{
bool found = false;
foreach (RvGame romofGame in lstParentGames)
{
for (int r1 = 0; r1 < romofGame.RomCount; r1++)
{
if (mGame.Roms[r].Name.ToLower() != romofGame.Roms[r1].Name.ToLower())
{
continue;
}
ulong?Size0 = mGame.Roms[r].Size;
ulong?Size1 = romofGame.Roms[r1].Size;
if ((Size0 != null) && (Size1 != null) && (Size0 != Size1))
{
continue;
}
byte[] CRC0 = mGame.Roms[r].CRC;
byte[] CRC1 = romofGame.Roms[r1].CRC;
if ((CRC0 != null) && (CRC1 != null) && !ArrByte.bCompare(CRC0, CRC1))
{
continue;
}
byte[] SHA0 = mGame.Roms[r].SHA1;
byte[] SHA1 = romofGame.Roms[r1].SHA1;
if ((SHA0 != null) && (SHA1 != null) && !ArrByte.bCompare(SHA0, SHA1))
{
continue;
}
byte[] MD50 = mGame.Roms[r].MD5;
byte[] MD51 = romofGame.Roms[r1].MD5;
if ((MD50 != null) && (MD51 != null) && !ArrByte.bCompare(MD50, MD51))
{
continue;
}
// don't merge if only one of the ROM is nodump
if (romofGame.Roms[r1].Status == "nodump" != (mGame.Roms[r].Status == "nodump"))
{
continue;
}
found = true;
break;
}
if (found)
{
break;
}
}
RomCheckCollect(mGame.Roms[r], found);
}
}
}
}
private static void DatSetMergeSets(RvDat tDat)
{
for (int g = tDat.Games.Count - 1; g >= 0; g--)
{
RvGame mGame = tDat.Games[g];
List <RvGame> lstParentGames = new List <RvGame>();
FindParentSet(mGame, tDat, ref lstParentGames);
while ((lstParentGames.Count > 0) && ((lstParentGames[lstParentGames.Count - 1].IsBios ?? "").ToLower() == "yes"))
{
lstParentGames.RemoveAt(lstParentGames.Count - 1);
}
if (lstParentGames.Count <= 0)
{
continue;
}
RvGame romofGame = lstParentGames[lstParentGames.Count - 1];
bool founderror = false;
for (int r = 0; r < mGame.RomCount; r++)
{
string name = mGame.Roms[r].Name;
string mergename = mGame.Roms[r].Merge;
for (int r1 = 0; r1 < romofGame.RomCount; r1++)
{
if (
((name == romofGame.Roms[r1].Name.ToLower()) || (mergename == romofGame.Roms[r1].Name.ToLower()))
&&
((ArrByte.iCompare(mGame.Roms[r].CRC, romofGame.Roms[r1].CRC) != 0) || (mGame.Roms[r].Size != romofGame.Roms[r1].Size))
)
{
founderror = true;
}
}
}
if (founderror)
{
mGame.RomOf = null;
continue;
}
for (int r = 0; r < mGame.RomCount; r++)
{
string name = mGame.Roms[r].Name;
string mergename = mGame.Roms[r].Merge;
bool found = false;
for (int r1 = 0; r1 < romofGame.RomCount; r1++)
{
if (
((name == romofGame.Roms[r1].Name.ToLower()) || (mergename == romofGame.Roms[r1].Name.ToLower()))
&&
(ArrByte.iCompare(mGame.Roms[r].CRC, romofGame.Roms[r1].CRC) == 0) && (mGame.Roms[r].Size == romofGame.Roms[r1].Size)
)
{
found = true;
break;
}
}
if (!found)
{
romofGame.AddRom(mGame.Roms[r]);
}
}
tDat.Games.RemoveAt(g);
}
}
private static void DatSetCheckParentSets(RvDat tDat)
{
if (tDat.Games == null)
{
return;
}
// First we are going to try and fix any missing CRC information by checking for roms with the same names
// in Parent and Child sets, and if the same named rom is found and one has a CRC and the other does not
// then we will set the missing CRC by using the CRC in the other set.
// we keep trying to find fixes until no more fixes are found.
// this is need as the first time round a fix could be found in a parent set from one child set.
// then the second time around that fixed parent set could fix another of its childs sets.
bool fix = true;
while (fix)
{
fix = false;
// loop around every ROM Set looking for fixes.
for (int g = 0; g < tDat.Games.Count; g++)
{
// get a list of that ROM Sets parents.
RvGame mGame = tDat.Games[g];
List <RvGame> lstParentGames = new List <RvGame>();
FindParentSet(mGame, tDat, ref lstParentGames);
// if this set have parents
if (lstParentGames.Count == 0)
{
continue;
}
if (mGame.Roms == null)
{
continue;
}
// now loop every ROM in the current set.
for (int r = 0; r < mGame.Roms.Count; r++)
{
// and loop every ROM of every parent set of this current set.
// and see if anything can be fixed.
bool found = false;
// loop the parent sets
foreach (RvGame romofGame in lstParentGames)
{
if (romofGame.Roms == null)
{
continue;
}
// loop the ROMs in the parent sets
for (int r1 = 0; r1 < romofGame.Roms.Count; r1++)
{
// don't search fixes for files marked as nodump
if ((mGame.Roms[r].Status == "nodump") || (romofGame.Roms[r1].Status == "nodump"))
{
continue;
}
// only find fixes if the Name and the Size of the ROMs are the same
if ((mGame.Roms[r].Name != romofGame.Roms[r1].Name) || (mGame.Roms[r].Size != romofGame.Roms[r1].Size))
{
continue;
}
// now check if one of the matching roms has missing or incorrect CRC information
bool b1 = mGame.Roms[r].CRC == null;
bool b2 = romofGame.Roms[r1].CRC == null;
// if one has correct information and the other does not, fix the missing one
if (b1 == b2)
{
continue;
}
if (b1)
{
mGame.Roms[r].CRC = ArrByte.Copy(romofGame.Roms[r1].CRC);
mGame.Roms[r].Status = "(CRCFound)";
}
else
{
romofGame.Roms[r1].CRC = ArrByte.Copy(mGame.Roms[r].CRC);
romofGame.Roms[r1].Status = "(CRCFound)";
}
// flag that a fix was found so that we will go all the way around again.
fix = true;
found = true;
break;
}
if (found)
{
break;
}
}
}
}
}
}
private static bool LoadRomFromDat(RvGame rvGame, HeaderFileType datFileType)
{
if (DatFileLoader.Next != "(")
{
DatUpdate.SendAndShowDat("( not found after rom on line " + DatFileLoader.LineNumber, DatFileLoader.Filename);
return(false);
}
DatFileLoader.Gn();
if (DatFileLoader.Next.ToLower() != "name")
{
DatUpdate.SendAndShowDat("Name not found as first object in ( ) on line " + DatFileLoader.LineNumber, DatFileLoader.Filename);
return(false);
}
RvRom rvRom = new RvRom
{
Name = VarFix.CleanFullFileName(DatFileLoader.Gn()),
AltType = datFileType
};
DatFileLoader.Gn();
while (rvRom.CRC == null || rvRom.Size == null || DatFileLoader.Next != ")")
{
switch (DatFileLoader.Next.ToLower())
{
case "size":
rvRom.Size = VarFix.ULong(DatFileLoader.Gn());
DatFileLoader.Gn();
break;
case "crc":
rvRom.CRC = VarFix.CleanMD5SHA1(DatFileLoader.Gn(), 8);
DatFileLoader.Gn();
break;
case "md5":
rvRom.MD5 = VarFix.CleanMD5SHA1(DatFileLoader.Gn(), 32);
DatFileLoader.Gn();
break;
case "sha1":
rvRom.SHA1 = VarFix.CleanMD5SHA1(DatFileLoader.Gn(), 40);
DatFileLoader.Gn();
break;
case "sha256":
// No-op until larger hashes are supported
DatFileLoader.Gn();
DatFileLoader.Gn();
break;
case "sha384":
// No-op until larger hashes are supported
DatFileLoader.Gn();
DatFileLoader.Gn();
break;
case "sha512":
// No-op until larger hashes are supported
DatFileLoader.Gn();
DatFileLoader.Gn();
break;
case "date":
rvRom.Date = DatFileLoader.Gn();
rvRom.Date += " " + DatFileLoader.Gn();
DatFileLoader.Gn();
break;
default:
rvRom.Name += " " + DatFileLoader.Next;
DatFileLoader.Gn();
break;
}
}
rvGame.AddRom(rvRom);
return(true);
}
private static void LoadGameFromDat(RvDat rvDat, XmlNode gameNode)
{
if (gameNode.Attributes == null)
{
return;
}
RvGame rvGame = new RvGame
{
Name = VarFix.CleanFileName(gameNode.Attributes.GetNamedItem("name")),
Description = VarFix.String(gameNode.SelectSingleNode("description")),
RomOf = VarFix.CleanFileName(gameNode.Attributes.GetNamedItem("cloneof")),
CloneOf = VarFix.CleanFileName(gameNode.Attributes.GetNamedItem("cloneof")),
Year = VarFix.CleanFileName(gameNode.SelectSingleNode("year")),
Manufacturer = VarFix.CleanFileName(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(rvGame, 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(rvGameCHD, romNodeList[iR]);
* }
* }
* }
*/
if (rvGame.RomCount > 0)
{
rvDat.AddGame(rvGame);
}
/*
* if (tDirCHD.ChildCount > 0)
* rvDat.AddGame(rvGameCHD, index1);
*/
}
private static void LoadGameFromDat(RvDat rvDat, XmlNode gameNode, string rootDir, HeaderFileType datFileType)
{
if (gameNode.Attributes == null)
{
return;
}
RvGame rvGame = new RvGame
{
Name = VarFix.CleanFullFileName(gameNode.Attributes.GetNamedItem("name")),
RomOf = VarFix.CleanFileName(gameNode.Attributes.GetNamedItem("romof")),
CloneOf = VarFix.CleanFileName(gameNode.Attributes.GetNamedItem("cloneof")),
SampleOf = VarFix.CleanFileName(gameNode.Attributes.GetNamedItem("sampleof")),
Description = VarFix.String(gameNode.SelectSingleNode("description")),
SourceFile = VarFix.String(gameNode.Attributes.GetNamedItem("sourcefile")),
IsBios = VarFix.String(gameNode.Attributes.GetNamedItem("isbios")),
Board = VarFix.String(gameNode.Attributes.GetNamedItem("board")),
Year = VarFix.String(gameNode.SelectSingleNode("year")),
Manufacturer = VarFix.String(gameNode.SelectSingleNode("manufacturer"))
};
XmlNode trurip = gameNode.SelectSingleNode("trurip");
if (trurip != null)
{
rvGame.IsTrurip = true;
rvGame.Publisher = VarFix.String(trurip.SelectSingleNode("publisher"));
rvGame.Developer = VarFix.String(trurip.SelectSingleNode("developer"));
rvGame.Edition = VarFix.String(trurip.SelectSingleNode("edition"));
rvGame.Version = VarFix.String(trurip.SelectSingleNode("version"));
rvGame.Type = VarFix.String(trurip.SelectSingleNode("type"));
rvGame.Media = VarFix.String(trurip.SelectSingleNode("media"));
rvGame.Language = VarFix.String(trurip.SelectSingleNode("language"));
rvGame.Players = VarFix.String(trurip.SelectSingleNode("players"));
rvGame.Ratings = VarFix.String(trurip.SelectSingleNode("ratings"));
rvGame.Peripheral = VarFix.String(trurip.SelectSingleNode("peripheral"));
rvGame.Genre = VarFix.String(trurip.SelectSingleNode("genre"));
rvGame.MediaCatalogNumber = VarFix.String(trurip.SelectSingleNode("mediacatalognumber"));
rvGame.BarCode = VarFix.String(trurip.SelectSingleNode("barcode"));
}
rvGame.Name = Path.Combine(rootDir, rvGame.Name);
rvDat.AddGame(rvGame);
XmlNodeList romNodeList = gameNode.SelectNodes("rom");
if (romNodeList != null)
{
for (int i = 0; i < romNodeList.Count; i++)
{
LoadRomFromDat(rvGame, romNodeList[i], datFileType);
}
}
XmlNodeList diskNodeList = gameNode.SelectNodes("disk");
if (diskNodeList != null)
{
for (int i = 0; i < diskNodeList.Count; i++)
{
LoadDiskFromDat(rvGame, diskNodeList[i]);
}
}
}
private static void CopyDir(DatDir datD, HeaderFileType headerFileType, RvDat retDat = null, RvGame retGame = null)
{
DatBase[] datB = datD.ToArray();
if (datB == null)
{
return;
}
foreach (DatBase b in datB)
{
switch (b)
{
case DatDir nDir:
if (nDir.DGame == null)
{
break;
}
DatGame dGame = nDir.DGame;
RvGame cGame = new RvGame();
cGame.Name = b.Name;
cGame.Description = dGame.Description;
cGame.Manufacturer = dGame.Manufacturer;
cGame.CloneOf = dGame.CloneOf;
cGame.RomOf = dGame.RomOf;
cGame.SampleOf = dGame.SampleOf;
cGame.SourceFile = dGame.SourceFile;
cGame.IsBios = dGame.IsBios;
cGame.Board = dGame.Board;
cGame.Year = dGame.Year;
if (dGame.IsEmuArc)
{
cGame.IsTrurip = true;
cGame.Publisher = dGame.Publisher;
cGame.Developer = dGame.Developer;
//cGame.Edition
//cGame.Version
//cGame.Type
//cGame.Media
//cGame.Language
cGame.Players = dGame.Players;
cGame.Ratings = dGame.Ratings;
cGame.Genre = dGame.Genre;
//cGame.Peripheral
//cGame.BarCode
//cGame.MediaCatalogNumber
}
retDat?.AddGame(cGame);
CopyDir(nDir, headerFileType, null, cGame);
break;
case DatFile nFile:
if (nFile.isDisk)
{
break;
}
RvRom nf = new RvRom()
{
Name = nFile.Name,
Size = nFile.Size,
CRC = nFile.CRC,
SHA1 = nFile.SHA1,
MD5 = nFile.MD5,
Merge = nFile.Merge,
Status = nFile.Status,
AltType = headerFileType
};
retGame?.AddRom(nf);
break;
}
}
}
private static void ExtractGame(RvGame tGame, string outDir)
{
if (buffer == null)
{
buffer = new byte[BufferSize];
}
ZipReturn zr;
bool romGot = false;
for (int rIndex = 0; rIndex < tGame.Roms.Count; rIndex++)
{
if (tGame.Roms[rIndex].FileId != null)
{
romGot = true;
break;
}
}
if (!romGot)
{
return;
}
// export the rom;
ZipFile zipOut = new ZipFile();
string filename = Path.Combine(outDir, tGame.Name + ".zip");
filename = filename.Replace(@"/", @"\");
if (!Directory.Exists(filename))
{
string dir = Path.GetDirectoryName(filename);
Directory.CreateDirectory(dir);
}
zr = zipOut.ZipFileCreate(filename);
if (zr != ZipReturn.ZipGood)
{
MessageBox.Show("Error creating " + Path.Combine(outDir, tGame.Name + ".zip") + " " + zr);
return;
}
for (int rIndex = 0; rIndex < tGame.Roms.Count; rIndex++)
{
RvRom tRom = tGame.Roms[rIndex];
if (tRom.FileId != null)
{
GZip sourceGZip = new GZip();
string sha1 = Getfilename(GetFile.Execute((uint)tRom.FileId));
zr = sourceGZip.ReadGZip(sha1, false);
if (zr != ZipReturn.ZipGood)
{
sourceGZip.Close();
continue;
}
Stream outStream;
zipOut.ZipFileOpenWriteStream(true, true, tRom.Name, sourceGZip.uncompressedSize, 8, out outStream);
Stream gZipStream;
zr = sourceGZip.GetRawStream(out gZipStream);
if (zr == ZipReturn.ZipGood)
{
// write the gzip stream to the zipstream
ulong sizetogo = sourceGZip.compressedSize;
while (sizetogo > 0)
{
int sizenow = sizetogo > BufferSize ? (int)BufferSize : (int)sizetogo;
gZipStream.Read(buffer, 0, sizenow);
outStream.Write(buffer, 0, sizenow);
sizetogo = sizetogo - (ulong)sizenow;
}
}
sourceGZip.Close();
zipOut.ZipFileCloseWriteStream(sourceGZip.crc);
}
}
zipOut.ZipFileClose();
}
private static bool LoadGameFromDat(RvDat rvDat, string rootdir)
{
if (DatFileLoader.Next != "(")
{
DatUpdate.SendAndShowDat("( not found after game", DatFileLoader.Filename);
return(false);
}
DatFileLoader.Gn();
string snext = DatFileLoader.Next.ToLower();
string pathextra = "";
if (snext == "rebuildto")
{
pathextra = VarFix.CleanFullFileName(DatFileLoader.Gn()); DatFileLoader.Gn();
snext = DatFileLoader.Next.ToLower();
}
if (snext != "name")
{
DatUpdate.SendAndShowDat("Name not found as first object in ( )", DatFileLoader.Filename);
return(false);
}
string name = VarFix.CleanFullFileName(DatFileLoader.GnRest());
if (!String.IsNullOrEmpty(pathextra))
{
name = pathextra + "/" + name;
}
DatFileLoader.Gn();
RvGame rvGame = new RvGame();
rvGame.Name = name;
while (DatFileLoader.Next != ")")
{
switch (DatFileLoader.Next.ToLower())
{
case "romof": rvGame.RomOf = VarFix.CleanFileName(DatFileLoader.GnRest()); DatFileLoader.Gn(); break;
case "description": rvGame.Description = DatFileLoader.GnRest(); DatFileLoader.Gn(); break;
case "sourcefile": rvGame.SourceFile = DatFileLoader.GnRest(); DatFileLoader.Gn(); break;
case "cloneof": rvGame.CloneOf = DatFileLoader.GnRest(); DatFileLoader.Gn(); break;
case "sampleof": rvGame.SampleOf = DatFileLoader.GnRest(); DatFileLoader.Gn(); break;
case "board": rvGame.Board = DatFileLoader.GnRest(); DatFileLoader.Gn(); break;
case "year": rvGame.Year = DatFileLoader.GnRest(); DatFileLoader.Gn(); break;
case "manufacturer": rvGame.Manufacturer = DatFileLoader.GnRest(); DatFileLoader.Gn(); break;
case "serial": DatFileLoader.GnRest(); DatFileLoader.Gn(); break;
case "rebuildto": DatFileLoader.GnRest(); DatFileLoader.Gn(); break;
case "sample": DatFileLoader.GnRest(); DatFileLoader.Gn(); break;
case "biosset": DatFileLoader.GnRest(); DatFileLoader.Gn(); break;
case "chip": DatFileLoader.GnRest(); DatFileLoader.Gn(); break;
case "video": DatFileLoader.GnRest(); DatFileLoader.Gn(); break;
case "sound": DatFileLoader.GnRest(); DatFileLoader.Gn(); break;
case "input": DatFileLoader.GnRest(); DatFileLoader.Gn(); break;
case "dipswitch": DatFileLoader.GnRest(); DatFileLoader.Gn(); break;
case "driver": DatFileLoader.GnRest(); DatFileLoader.Gn(); break;
case "rom":
DatFileLoader.Gn();
if (!LoadRomFromDat(rvGame))
{
return(false);
}
DatFileLoader.Gn();
break;
case "disk":
DatFileLoader.Gn();
if (!LoadDiskFromDat(rvGame))
{
return(false);
}
DatFileLoader.Gn();
break;
case "archive":
DatFileLoader.Gn();
if (!LoadArchiveFromDat())
{
return(false);
}
DatFileLoader.Gn();
break;
default:
DatUpdate.SendAndShowDat("Error: key word '" + DatFileLoader.Next + "' not known in game", DatFileLoader.Filename);
DatFileLoader.Gn();
break;
}
}
rvDat.AddGame(rvGame);
return(true);
}
private static void CopyDir(DatDir datD, RvFile rvD, RvDat rvDat, HeaderFileType headerFileType, bool gameFile)
{
DatBase[] datB = datD.ToArray();
if (datB == null)
{
return;
}
foreach (DatBase b in datB)
{
switch (b)
{
case DatDir nDir:
RvFile nd = new RvFile(ConvE(nDir.DatFileType))
{
Name = nDir.Name + GetExt(nDir.DatFileType),
Dat = rvDat,
DatStatus = ConvE(nDir.DatStatus)
};
if (nDir.DGame == null && !gameFile)
{
nd.Tree = new RvTreeRow();
}
rvD.ChildAdd(nd);
if (nDir.DGame != null)
{
DatGame dGame = nDir.DGame;
RvGame cGame = new RvGame();
CheckAttribute(cGame, dGame.Description, RvGame.GameData.Description);
CheckAttribute(cGame, dGame.RomOf, RvGame.GameData.RomOf);
CheckAttribute(cGame, dGame.IsBios, RvGame.GameData.IsBios);
CheckAttribute(cGame, dGame.SourceFile, RvGame.GameData.Sourcefile);
CheckAttribute(cGame, dGame.CloneOf, RvGame.GameData.CloneOf);
CheckAttribute(cGame, dGame.SampleOf, RvGame.GameData.SampleOf);
CheckAttribute(cGame, dGame.Board, RvGame.GameData.Board);
CheckAttribute(cGame, dGame.Year, RvGame.GameData.Year);
CheckAttribute(cGame, dGame.Manufacturer, RvGame.GameData.Manufacturer);
if (nDir.DGame.IsEmuArc)
{
cGame.AddData(RvGame.GameData.EmuArc, "yes");
CheckAttribute(cGame, dGame.TitleId, RvGame.GameData.TitleId);
CheckAttribute(cGame, dGame.Publisher, RvGame.GameData.Publisher);
CheckAttribute(cGame, dGame.Developer, RvGame.GameData.Developer);
CheckAttribute(cGame, dGame.Genre, RvGame.GameData.Genre);
CheckAttribute(cGame, dGame.SubGenre, RvGame.GameData.SubGenre);
CheckAttribute(cGame, dGame.Ratings, RvGame.GameData.Ratings);
CheckAttribute(cGame, dGame.Score, RvGame.GameData.Score);
CheckAttribute(cGame, dGame.Players, RvGame.GameData.Players);
CheckAttribute(cGame, dGame.Enabled, RvGame.GameData.Enabled);
CheckAttribute(cGame, dGame.CRC, RvGame.GameData.CRC);
CheckAttribute(cGame, dGame.RelatedTo, RvGame.GameData.RelatedTo);
CheckAttribute(cGame, dGame.Source, RvGame.GameData.Source);
}
nd.Game = cGame;
}
CopyDir(nDir, nd, rvDat, headerFileType, gameFile || nDir.DGame != null);
break;
case DatFile nFile:
RvFile nf = new RvFile(ConvE(nFile.DatFileType))
{
Name = nFile.Name,
Size = nFile.Size,
CRC = nFile.CRC,
SHA1 = nFile.SHA1,
MD5 = nFile.MD5,
Merge = nFile.Merge,
Status = nFile.Status,
Dat = rvDat,
DatStatus = ConvE(nFile.DatStatus),
HeaderFileType = headerFileType
};
#if dt
DateTime dt;
if (!string.IsNullOrEmpty(nFile.DateModified) && DateTime.TryParseExact(nFile.DateModified, "yyyy/MM/dd HH:mm:ss", enUS, DateTimeStyles.None, out dt))
{
nf.DatModTimeStamp = dt.Ticks;
}
#endif
if (nFile.isDisk)
{
nf.HeaderFileType = HeaderFileType.CHD;
}
if (nf.HeaderFileType != HeaderFileType.Nothing)
{
nf.FileStatusSet(FileStatus.HeaderFileTypeFromDAT);
}
if (nf.Size != null)
{
nf.FileStatusSet(FileStatus.SizeFromDAT);
}
if (nf.CRC != null)
{
nf.FileStatusSet(FileStatus.CRCFromDAT);
}
if (nf.SHA1 != null)
{
nf.FileStatusSet(FileStatus.SHA1FromDAT);
}
if (nf.MD5 != null)
{
nf.FileStatusSet(FileStatus.MD5FromDAT);
}
rvD.ChildAdd(nf);
break;
}
}
}
private void UpdateSelectedGame()
{
RvGame tGame = null;
if (_updatingGameGrid)
{
return;
}
if (GameGrid.SelectedRows.Count == 1)
{
int GameId = (int)GameGrid.SelectedRows[0].Tag;
tGame = new RvGame();
tGame.DBRead(GameId);
}
if (tGame == null)
{
lblSIName.Visible = false;
lblSITName.Visible = false;
lblSIDescription.Visible = false;
lblSITDescription.Visible = false;
lblSIManufacturer.Visible = false;
lblSITManufacturer.Visible = false;
lblSICloneOf.Visible = false;
lblSITCloneOf.Visible = false;
lblSIRomOf.Visible = false;
lblSITRomOf.Visible = false;
lblSIYear.Visible = false;
lblSITYear.Visible = false;
lblSITotalRoms.Visible = false;
lblSITTotalRoms.Visible = false;
// Trurip
lblSIPublisher.Visible = false;
lblSITPublisher.Visible = false;
lblSIDeveloper.Visible = false;
lblSITDeveloper.Visible = false;
lblSIEdition.Visible = false;
lblSITEdition.Visible = false;
lblSIVersion.Visible = false;
lblSITVersion.Visible = false;
lblSIType.Visible = false;
lblSITType.Visible = false;
lblSIMedia.Visible = false;
lblSITMedia.Visible = false;
lblSILanguage.Visible = false;
lblSITLanguage.Visible = false;
lblSIPlayers.Visible = false;
lblSITPlayers.Visible = false;
lblSIRatings.Visible = false;
lblSITRatings.Visible = false;
lblSIGenre.Visible = false;
lblSITGenre.Visible = false;
lblSIPeripheral.Visible = false;
lblSITPeripheral.Visible = false;
lblSIBarCode.Visible = false;
lblSITBarCode.Visible = false;
lblSIMediaCatalogNumber.Visible = false;
lblSITMediaCatalogNumber.Visible = false;
return;
}
lblSIName.Visible = true;
lblSITName.Visible = true;
lblSITName.Text = GameGrid.SelectedRows[0].Cells[1].Value.ToString();
if (tGame.IsTrurip)
{
lblSIDescription.Visible = true;
lblSITDescription.Visible = true;
lblSITDescription.Text = tGame.Description;
lblSIManufacturer.Visible = false;
lblSITManufacturer.Visible = false;
lblSICloneOf.Visible = false;
lblSITCloneOf.Visible = false;
lblSIRomOf.Visible = false;
lblSITRomOf.Visible = false;
lblSIYear.Visible = false;
lblSITYear.Visible = false;
lblSITotalRoms.Visible = false;
lblSITTotalRoms.Visible = false;
lblSIPublisher.Visible = true;
lblSITPublisher.Visible = true;
lblSITPublisher.Text = tGame.Publisher;
lblSIDeveloper.Visible = true;
lblSITDeveloper.Visible = true;
lblSITDeveloper.Text = tGame.Developer;
lblSIEdition.Visible = true;
lblSITEdition.Visible = true;
lblSITEdition.Text = tGame.Edition;
lblSIVersion.Visible = true;
lblSITVersion.Visible = true;
lblSITVersion.Text = tGame.Version;
lblSIType.Visible = true;
lblSITType.Visible = true;
lblSITType.Text = tGame.Type;
lblSIMedia.Visible = true;
lblSITMedia.Visible = true;
lblSITMedia.Text = tGame.Media;
lblSILanguage.Visible = true;
lblSITLanguage.Visible = true;
lblSITLanguage.Text = tGame.Language;
lblSIPlayers.Visible = true;
lblSITPlayers.Visible = true;
lblSITPlayers.Text = tGame.Players;
lblSIRatings.Visible = true;
lblSITRatings.Visible = true;
lblSITRatings.Text = tGame.Ratings;
lblSIGenre.Visible = true;
lblSITGenre.Visible = true;
lblSITGenre.Text = tGame.Genre;
lblSIPeripheral.Visible = true;
lblSITPeripheral.Visible = true;
lblSITPeripheral.Text = tGame.Peripheral;
lblSIBarCode.Visible = true;
lblSITBarCode.Visible = true;
lblSITBarCode.Text = tGame.BarCode;
lblSIMediaCatalogNumber.Visible = true;
lblSITMediaCatalogNumber.Visible = true;
lblSITMediaCatalogNumber.Text = tGame.MediaCatalogNumber;
}
else
{
lblSIDescription.Visible = true;
lblSITDescription.Visible = true;
lblSITDescription.Text = tGame.Description;
lblSIManufacturer.Visible = true;
lblSITManufacturer.Visible = true;
lblSITManufacturer.Text = tGame.Manufacturer;
lblSICloneOf.Visible = true;
lblSITCloneOf.Visible = true;
lblSITCloneOf.Text = tGame.CloneOf;
lblSIRomOf.Visible = true;
lblSITRomOf.Visible = true;
lblSITRomOf.Text = tGame.RomOf;
lblSIYear.Visible = true;
lblSITYear.Visible = true;
lblSITYear.Text = tGame.Year;
lblSITotalRoms.Visible = true;
lblSITTotalRoms.Visible = true;
lblSIPublisher.Visible = false;
lblSITPublisher.Visible = false;
lblSIDeveloper.Visible = false;
lblSITDeveloper.Visible = false;
lblSIEdition.Visible = false;
lblSITEdition.Visible = false;
lblSIVersion.Visible = false;
lblSITVersion.Visible = false;
lblSIType.Visible = false;
lblSITType.Visible = false;
lblSIMedia.Visible = false;
lblSITMedia.Visible = false;
lblSILanguage.Visible = false;
lblSITLanguage.Visible = false;
lblSIPlayers.Visible = false;
lblSITPlayers.Visible = false;
lblSIRatings.Visible = false;
lblSITRatings.Visible = false;
lblSIGenre.Visible = false;
lblSITGenre.Visible = false;
lblSIPeripheral.Visible = false;
lblSITPeripheral.Visible = false;
lblSIBarCode.Visible = false;
lblSITBarCode.Visible = false;
lblSIMediaCatalogNumber.Visible = false;
lblSITMediaCatalogNumber.Visible = false;
}
UpdateRomGrid(tGame.GameId);
}
private static bool LoadGameFromDat(RvDat rvDat, string rootName, HeaderFileType datFileType)
{
if (DatFileLoader.Next != "(")
{
DatUpdate.SendAndShowDat("( not found after game on line " + DatFileLoader.LineNumber, DatFileLoader.Filename);
return(false);
}
DatFileLoader.Gn();
string snext = DatFileLoader.Next.ToLower();
string pathextra = "";
if (snext == "rebuildto")
{
pathextra = VarFix.CleanFullFileName(DatFileLoader.Gn());
DatFileLoader.Gn();
snext = DatFileLoader.Next.ToLower();
}
if (snext != "name")
{
DatUpdate.SendAndShowDat("Name not found as first object in ( ) on line " + DatFileLoader.LineNumber, DatFileLoader.Filename);
return(false);
}
string name = VarFix.CleanFullFileName(DatFileLoader.GnRest());
name = Path.Combine(pathextra, name);
name = Path.Combine(rootName, name);
name = (name.EndsWith(".zip") ? name.Remove(name.Length - 4) : name);
DatFileLoader.Gn();
RvGame rvGame = new RvGame {
Name = name
};
while (DatFileLoader.Next != ")")
{
switch (DatFileLoader.Next.ToLower())
{
case "romof":
rvGame.RomOf = VarFix.CleanFileName(DatFileLoader.GnRest());
DatFileLoader.Gn();
break;
case "description":
rvGame.Description = DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "sourcefile":
rvGame.SourceFile = DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "cloneof":
rvGame.CloneOf = DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "sampleof":
rvGame.SampleOf = DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "board":
rvGame.Board = DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "year":
rvGame.Year = DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "manufacturer":
rvGame.Manufacturer = DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "serial":
DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "rebuildto":
DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "sample":
DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "biosset":
DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "chip":
DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "video":
DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "sound":
DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "input":
DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "dipswitch":
DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "driver":
DatFileLoader.GnRest();
DatFileLoader.Gn();
break;
case "file":
DatFileLoader.Gn();
if (!LoadRomFromDat(rvGame, datFileType))
{
return(false);
}
DatFileLoader.Gn();
break;
default:
DatUpdate.SendAndShowDat("Error on line " + DatFileLoader.LineNumber + ": key word '" + DatFileLoader.Next + "' not known in game", DatFileLoader.Filename);
DatFileLoader.Gn();
break;
}
}
rvDat.AddGame(rvGame);
return(true);
}
