claunia/SabreTools
1
0
Fork 0
mirror of https://github.com/claunia/SabreTools.git synced 2025-12-16 19:14:27 +00:00
Code Issues Packages Projects Releases Wiki Activity
Files
b01217cffbc69fa8c75787ea3e35359a49f42387
SabreTools/SabreTools.Library/DatFiles/Json.cs

2145 lines
84 KiB
C#
Raw Normal View History

Add JSON write
2020-06-15 22:31:46 -07:00
using System;
using System.Collections.Generic;
using System.IO;
using System.Text;
using SabreTools.Library.Data;
using SabreTools.Library.DatItems;
IO extensions to IO namespace
2020-08-01 23:04:11 -07:00
using SabreTools.Library.IO;
Add JSON write
2020-06-15 22:31:46 -07:00
using SabreTools.Library.Tools;
using Newtonsoft.Json;
namespace SabreTools.Library.DatFiles
{
/// <summary>
/// Represents parsing and writing of a JSON DAT
/// </summary>
internal class Json : DatFile
{
/// <summary>
/// Constructor designed for casting a base DatFile
/// </summary>
/// <param name="datFile">Parent DatFile to copy from</param>
public Json(DatFile datFile)
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
: base(datFile)
Add JSON write
2020-06-15 22:31:46 -07:00
{
}
Implement JSON reading
2020-06-16 11:27:36 -07:00
/// <summary>
/// Parse a Logiqx XML DAT and return all found games and roms within
/// </summary>
/// <param name="filename">Name of the file to be parsed</param>
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
/// <param name="indexId">Index ID for the DAT</param>
Implement JSON reading
2020-06-16 11:27:36 -07:00
/// <param name="keep">True if full pathnames are to be kept, false otherwise (default)</param>
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
protected override void ParseFile(
Implement JSON reading
2020-06-16 11:27:36 -07:00
// Standard Dat parsing
string filename,
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
int indexId,
Implement JSON reading
2020-06-16 11:27:36 -07:00
// Miscellaneous
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
bool keep)
Implement JSON reading
2020-06-16 11:27:36 -07:00
{
// Prepare all internal variables
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
StreamReader sr = new StreamReader(FileExtensions.TryOpenRead(filename), new UTF8Encoding(false));
Implement JSON reading
2020-06-16 11:27:36 -07:00
JsonTextReader jtr = new JsonTextReader(sr);
// If we got a null reader, just return
if (jtr == null)
return;
// Otherwise, read the file to the end
try
{
jtr.Read();
while (!sr.EndOfStream)
{
// Skip everything not a property name
if (jtr.TokenType != JsonToken.PropertyName)
{
jtr.Read();
continue;
}
switch (jtr.Value)
{
// Header value
case "header":
ReadHeader(sr, jtr, keep);
jtr.Read();
break;
// Machine array
case "machines":
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
ReadMachines(sr, jtr, filename, indexId);
Implement JSON reading
2020-06-16 11:27:36 -07:00
jtr.Read();
break;
default:
jtr.Read();
break;
}
}
}
catch (Exception ex)
{
Globals.Logger.Warning($"Exception found while parsing '{filename}': {ex}");
}
jtr.Close();
}
/// <summary>
/// Read header information
/// </summary>
/// <param name="sr">StreamReader to use to parse the header</param>
/// <param name="jtr">JsonTextReader to use to parse the header</param>
/// <param name="keep">True if full pathnames are to be kept, false otherwise (default)</param>
private void ReadHeader(StreamReader sr, JsonTextReader jtr, bool keep)
{
bool superdat = false;
// If the reader is invalid, skip
if (jtr == null)
return;
jtr.Read();
while (!sr.EndOfStream)
{
// If we hit the end of the header, return
if (jtr.TokenType == JsonToken.EndObject)
return;
// We don't care about anything except property names
if (jtr.TokenType != JsonToken.PropertyName)
{
jtr.Read();
continue;
}
// Get all header items (ONLY OVERWRITE IF THERE'S NO DATA)
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
string content;
Implement JSON reading
2020-06-16 11:27:36 -07:00
switch (jtr.Value)
{
Add ListXML header fields
2020-08-20 15:13:57 -07:00
#region Common
Implement JSON reading
2020-06-16 11:27:36 -07:00
case "name":
content = jtr.ReadAsString();
Allow for blank overrides of header values
2020-08-08 14:06:05 -07:00
Header.Name = (Header.Name == null ? content : Header.Name);
Implement JSON reading
2020-06-16 11:27:36 -07:00
superdat = superdat || content.Contains(" - SuperDAT");
if (keep && superdat)
{
Allow for blank overrides of header values
2020-08-08 14:06:05 -07:00
Header.Type = (Header.Type == null ? "SuperDAT" : Header.Type);
Implement JSON reading
2020-06-16 11:27:36 -07:00
}
break;
case "description":
content = jtr.ReadAsString();
Allow for blank overrides of header values
2020-08-08 14:06:05 -07:00
Header.Description = (Header.Description == null ? content : Header.Description);
Implement JSON reading
2020-06-16 11:27:36 -07:00
break;
case "rootdir": // This is exclusive to TruRip XML
content = jtr.ReadAsString();
Allow for blank overrides of header values
2020-08-08 14:06:05 -07:00
Header.RootDir = (Header.RootDir == null ? content : Header.RootDir);
Implement JSON reading
2020-06-16 11:27:36 -07:00
break;
case "category":
content = jtr.ReadAsString();
Allow for blank overrides of header values
2020-08-08 14:06:05 -07:00
Header.Category = (Header.Category == null ? content : Header.Category);
Implement JSON reading
2020-06-16 11:27:36 -07:00
break;
case "version":
content = jtr.ReadAsString();
Allow for blank overrides of header values
2020-08-08 14:06:05 -07:00
Header.Version = (Header.Version == null ? content : Header.Version);
Implement JSON reading
2020-06-16 11:27:36 -07:00
break;
case "date":
content = jtr.ReadAsString();
Allow for blank overrides of header values
2020-08-08 14:06:05 -07:00
Header.Date = (Header.Date == null ? content.Replace(".", "/") : Header.Date);
Implement JSON reading
2020-06-16 11:27:36 -07:00
break;
case "author":
content = jtr.ReadAsString();
Allow for blank overrides of header values
2020-08-08 14:06:05 -07:00
Header.Author = (Header.Author == null ? content : Header.Author);
Implement JSON reading
2020-06-16 11:27:36 -07:00
break;
case "email":
content = jtr.ReadAsString();
Allow for blank overrides of header values
2020-08-08 14:06:05 -07:00
Header.Email = (Header.Email == null ? content : Header.Email);
Implement JSON reading
2020-06-16 11:27:36 -07:00
break;
case "homepage":
content = jtr.ReadAsString();
Allow for blank overrides of header values
2020-08-08 14:06:05 -07:00
Header.Homepage = (Header.Homepage == null ? content : Header.Homepage);
Implement JSON reading
2020-06-16 11:27:36 -07:00
break;
case "url":
content = jtr.ReadAsString();
Allow for blank overrides of header values
2020-08-08 14:06:05 -07:00
Header.Url = (Header.Url == null ? content : Header.Url);
Implement JSON reading
2020-06-16 11:27:36 -07:00
break;
case "comment":
content = jtr.ReadAsString();
Allow for blank overrides of header values
2020-08-08 14:06:05 -07:00
Header.Comment = (Header.Comment == null ? content : Header.Comment);
Implement JSON reading
2020-06-16 11:27:36 -07:00
break;
Add ListXML header fields
2020-08-20 15:13:57 -07:00
case "header":
content = jtr.ReadAsString();
Header.HeaderSkipper = (Header.HeaderSkipper == null ? content : Header.HeaderSkipper);
break;
Implement JSON reading
2020-06-16 11:27:36 -07:00
case "type": // This is exclusive to TruRip XML
content = jtr.ReadAsString();
Allow for blank overrides of header values
2020-08-08 14:06:05 -07:00
Header.Type = (Header.Type == null ? content : Header.Type);
Implement JSON reading
2020-06-16 11:27:36 -07:00
superdat = superdat || content.Contains("SuperDAT");
break;
case "forcemerging":
Move to MergingFlag
2020-08-20 20:38:29 -07:00
if (Header.ForceMerging == MergingFlag.None)
Header.ForceMerging = jtr.ReadAsString().AsMergingFlag();
Implement JSON reading
2020-06-16 11:27:36 -07:00
break;
Add ListXML header fields
2020-08-20 15:13:57 -07:00
case "forcenodump":
Move to MergingFlag
2020-08-20 20:38:29 -07:00
if (Header.ForceNodump == NodumpFlag.None)
Header.ForceNodump = jtr.ReadAsString().AsNodumpFlag();
Add ListXML header fields
2020-08-20 15:13:57 -07:00
break;
Implement JSON reading
2020-06-16 11:27:36 -07:00
case "forcepacking":
Move to MergingFlag
2020-08-20 20:38:29 -07:00
if (Header.ForcePacking == PackingFlag.None)
Header.ForcePacking = jtr.ReadAsString().AsPackingFlag();
Implement JSON reading
2020-06-16 11:27:36 -07:00
break;
Add ListXML header fields
2020-08-20 15:13:57 -07:00
#endregion
Implement JSON reading
2020-06-16 11:27:36 -07:00
Add ListXML header fields
2020-08-20 15:13:57 -07:00
#region ListXML
case "debug":
content = jtr.ReadAsString();
Header.Debug = (Header.Debug == null ? content.AsYesNo() : Header.Debug);
Implement JSON reading
2020-06-16 11:27:36 -07:00
break;
Add ListXML header fields
2020-08-20 15:13:57 -07:00
case "mameconfig":
Implement JSON reading
2020-06-16 11:27:36 -07:00
content = jtr.ReadAsString();
Add ListXML header fields
2020-08-20 15:13:57 -07:00
Header.MameConfig = (Header.MameConfig == null ? content : Header.MameConfig);
Implement JSON reading
2020-06-16 11:27:36 -07:00
break;
Add ListXML header fields
2020-08-20 15:13:57 -07:00
#endregion
MachineType is common, add Logiqx header values
2020-08-20 15:39:32 -07:00
#region Logiqx
case "build":
content = jtr.ReadAsString();
Header.Build = (Header.Build == null ? content : Header.Build);
break;
Wire up remaining Logiqx header values
2020-08-20 17:23:19 -07:00
case "rommode":
content = jtr.ReadAsString();
Move to MergingFlag
2020-08-20 20:38:29 -07:00
Header.RomMode = (Header.RomMode == MergingFlag.None ? content.AsMergingFlag() : Header.RomMode);
Wire up remaining Logiqx header values
2020-08-20 17:23:19 -07:00
break;
case "biosmode":
content = jtr.ReadAsString();
Move to MergingFlag
2020-08-20 20:38:29 -07:00
Header.BiosMode = (Header.BiosMode == MergingFlag.None ? content.AsMergingFlag() : Header.BiosMode);
Wire up remaining Logiqx header values
2020-08-20 17:23:19 -07:00
break;
case "samplemode":
content = jtr.ReadAsString();
Move to MergingFlag
2020-08-20 20:38:29 -07:00
Header.SampleMode = (Header.SampleMode == MergingFlag.None ? content.AsMergingFlag() : Header.SampleMode);
Wire up remaining Logiqx header values
2020-08-20 17:23:19 -07:00
break;
case "lockrommode":
content = jtr.ReadAsString();
Header.LockRomMode = (Header.LockRomMode == null ? content.AsYesNo() : Header.LockRomMode);
break;
case "lockbiosmode":
content = jtr.ReadAsString();
Header.LockBiosMode = (Header.LockBiosMode == null ? content.AsYesNo() : Header.LockBiosMode);
break;
case "locksamplemode":
content = jtr.ReadAsString();
Header.LockSampleMode = (Header.LockSampleMode == null ? content.AsYesNo() : Header.LockSampleMode);
break;
MachineType is common, add Logiqx header values
2020-08-20 15:39:32 -07:00
#endregion
Add some OfflineList headers
2020-08-20 15:51:13 -07:00
#region OfflineList
case "system":
content = jtr.ReadAsString();
Header.System = (Header.System == null ? content : Header.System);
break;
case "screenshotswidth":
content = jtr.ReadAsString();
Header.ScreenshotsWidth = (Header.ScreenshotsWidth == null ? content : Header.ScreenshotsWidth);
break;
case "screenshotsheight":
content = jtr.ReadAsString();
Header.ScreenshotsHeight = (Header.ScreenshotsHeight == null ? content : Header.ScreenshotsHeight);
break;
Wire up infos for OfflineList
2020-08-20 16:20:22 -07:00
case "infos":
Header.Infos = new List<Tuple<string, bool?, bool?, bool?>>();
jtr.Read(); // Start Array
while (!sr.EndOfStream)
{
jtr.Read(); // Start object (or end array)
if (jtr.TokenType == JsonToken.EndArray)
break;
// Get default values
string nameValue = string.Empty;
bool? visibleValue = null;
bool? inNamingOptionValue = null;
bool? defaultValue = null;
jtr.Read();
while (!sr.EndOfStream)
{
// If we hit the end of the machine, return
if (jtr.TokenType == JsonToken.EndObject)
return;
// We don't care about anything except properties
if (jtr.TokenType != JsonToken.PropertyName)
{
jtr.Read();
continue;
}
switch (jtr.Value)
{
case "name":
nameValue = jtr.ReadAsString();
break;
case "visible":
visibleValue = jtr.ReadAsString().AsYesNo();
break;
case "inNamingOption":
inNamingOptionValue = jtr.ReadAsString().AsYesNo();
break;
case "default":
defaultValue = jtr.ReadAsString().AsYesNo();
break;
}
jtr.Read(); // End object
}
// Add the new info tuple
Header.Infos.Add(new Tuple<string, bool?, bool?, bool?>(
nameValue,
visibleValue,
inNamingOptionValue,
defaultValue));
}
break;
Wire up OfflineList canOpen
2020-08-20 16:30:16 -07:00
case "canopen":
Header.CanOpen = new List<string>();
jtr.Read(); // Start Array
while (!sr.EndOfStream && jtr.TokenType != JsonToken.EndArray)
{
Header.CanOpen.Add(jtr.ReadAsString());
}
break;
Add some OfflineList headers
2020-08-20 15:51:13 -07:00
case "romtitle":
content = jtr.ReadAsString();
Header.RomTitle = (Header.MameConfig == null ? content : Header.RomTitle);
break;
#endregion
Missing header notes, wire up RC Version
2020-08-20 16:49:21 -07:00
#region RomCenter
case "rcversion":
content = jtr.ReadAsString();
Header.RomCenterVersion = (Header.RomCenterVersion == null ? content : Header.RomCenterVersion);
break;
#endregion
Implement JSON reading
2020-06-16 11:27:36 -07:00
default:
break;
}
jtr.Read();
}
}
/// <summary>
/// Read machine array information
/// </summary>
/// <param name="sr">StreamReader to use to parse the header</param>
/// <param name="itr">JsonTextReader to use to parse the machine</param>
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
/// <param name="filename">Name of the file to be parsed</param>
/// <param name="indexId">Index ID for the DAT</param>
Implement JSON reading
2020-06-16 11:27:36 -07:00
private void ReadMachines(
StreamReader sr,
JsonTextReader jtr,
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
// Standard Dat parsing
string filename,
int indexId)
Implement JSON reading
2020-06-16 11:27:36 -07:00
{
// If the reader is invalid, skip
if (jtr == null)
return;
jtr.Read();
while (!sr.EndOfStream)
{
// If we hit the end of an array, we want to return
if (jtr.TokenType == JsonToken.EndArray)
return;
// We don't care about anything except start object
if (jtr.TokenType != JsonToken.StartObject)
{
jtr.Read();
continue;
}
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
ReadMachine(sr, jtr, filename, indexId);
Implement JSON reading
2020-06-16 11:27:36 -07:00
jtr.Read();
}
}
/// <summary>
/// Read machine information
/// </summary>
/// <param name="sr">StreamReader to use to parse the header</param>
/// <param name="itr">JsonTextReader to use to parse the machine</param>
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
/// <param name="filename">Name of the file to be parsed</param>
/// <param name="indexId">Index ID for the DAT</param>
Implement JSON reading
2020-06-16 11:27:36 -07:00
private void ReadMachine(
StreamReader sr,
JsonTextReader jtr,
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
// Standard Dat parsing
string filename,
int indexId)
Implement JSON reading
2020-06-16 11:27:36 -07:00
{
// If we have an empty machine, skip it
if (jtr == null)
return;
// Prepare internal variables
Machine machine = new Machine();
jtr.Read();
while (!sr.EndOfStream)
{
// If we hit the end of the machine, return
if (jtr.TokenType == JsonToken.EndObject)
return;
// We don't care about anything except properties
if (jtr.TokenType != JsonToken.PropertyName)
{
jtr.Read();
continue;
}
switch (jtr.Value)
{
Wire up Logiqx TruRip/EmuArc fields
2020-08-20 22:42:04 -07:00
#region Common
Implement JSON reading
2020-06-16 11:27:36 -07:00
case "name":
machine.Name = jtr.ReadAsString();
break;
case "comment":
machine.Comment = jtr.ReadAsString();
break;
case "description":
machine.Description = jtr.ReadAsString();
break;
case "year":
machine.Year = jtr.ReadAsString();
break;
case "manufacturer":
machine.Manufacturer = jtr.ReadAsString();
break;
case "publisher":
machine.Publisher = jtr.ReadAsString();
break;
Filter Abstraction (#25) * Add category, back filters by dictionary * Complete internal filter set * Fix AreaSize filter * Populate filter object the hard way * Manipulation flags should not be filters * None of them need to be public * Convert to partial helper method * Better method use * Field, not string; no dictionary * Add FilterTo method for later * More naming options (easier conversion) * Update README
2020-07-18 21:35:17 -07:00
case "category":
machine.Category = jtr.ReadAsString();
break;
Implement JSON reading
2020-06-16 11:27:36 -07:00
case "romof":
machine.RomOf = jtr.ReadAsString();
break;
case "cloneof":
machine.CloneOf = jtr.ReadAsString();
break;
case "sampleof":
machine.SampleOf = jtr.ReadAsString();
MachineType is common, add Logiqx header values
2020-08-20 15:39:32 -07:00
break;
case "isbios":
string isbios = jtr.ReadAsString();
if (string.Equals(isbios, "yes", StringComparison.OrdinalIgnoreCase))
machine.MachineType &= MachineType.Bios;
break;
case "isdevice":
string isdevice = jtr.ReadAsString();
if (string.Equals(isdevice, "yes", StringComparison.OrdinalIgnoreCase))
machine.MachineType &= MachineType.Device;
break;
case "ismechanical":
string ismechanical = jtr.ReadAsString();
if (string.Equals(ismechanical, "yes", StringComparison.OrdinalIgnoreCase))
machine.MachineType &= MachineType.Mechanical;
Implement JSON reading
2020-06-16 11:27:36 -07:00
break;
Support more AttractMode fields
2020-08-20 14:36:36 -07:00
case "items":
ReadItems(sr, jtr, filename, indexId, machine);
break;
Implement JSON reading
2020-06-16 11:27:36 -07:00
Wire up Logiqx TruRip/EmuArc fields
2020-08-20 22:42:04 -07:00
#endregion
#region AttractMode
Support more AttractMode fields
2020-08-20 14:36:36 -07:00
case "players":
machine.Players = jtr.ReadAsString();
break;
case "rotation":
machine.Rotation = jtr.ReadAsString();
break;
case "control":
machine.Control = jtr.ReadAsString();
break;
case "status":
machine.Status = jtr.ReadAsString();
break;
case "displaycount":
machine.DisplayCount = jtr.ReadAsString();
break;
case "displaytype":
machine.DisplayType = jtr.ReadAsString();
break;
case "buttons":
machine.Buttons = jtr.ReadAsString();
Implement JSON reading
2020-06-16 11:27:36 -07:00
break;
Wire up Logiqx TruRip/EmuArc fields
2020-08-20 22:42:04 -07:00
#endregion
#region ListXML
Implement JSON reading
2020-06-16 11:27:36 -07:00
case "sourcefile":
machine.SourceFile = jtr.ReadAsString();
break;
case "runnable":
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
machine.Runnable = jtr.ReadAsString().AsYesNo();
Implement JSON reading
2020-06-16 11:27:36 -07:00
break;
case "devices":
machine.Devices = new List<string>();
jtr.Read(); // Start Array
while (!sr.EndOfStream && jtr.TokenType != JsonToken.EndArray)
{
machine.Devices.Add(jtr.ReadAsString());
}
break;
case "slotoptions":
machine.SlotOptions = new List<string>();
jtr.Read(); // Start Array
while (!sr.EndOfStream && jtr.TokenType != JsonToken.EndArray)
{
machine.SlotOptions.Add(jtr.ReadAsString());
}
break;
case "infos":
machine.Infos = new List<KeyValuePair<string, string>>();
jtr.Read(); // Start Array
while (!sr.EndOfStream)
{
jtr.Read(); // Start object (or end array)
if (jtr.TokenType == JsonToken.EndArray)
break;
jtr.Read(); // Key
string key = jtr.Value as string;
string value = jtr.ReadAsString();
jtr.Read(); // End object
machine.Infos.Add(new KeyValuePair<string, string>(key, value));
}
break;
Wire up Logiqx TruRip/EmuArc fields
2020-08-20 22:42:04 -07:00
#endregion
#region Logiqx
Support more AttractMode fields
2020-08-20 14:36:36 -07:00
case "board":
machine.Board = jtr.ReadAsString();
break;
case "rebuildto":
machine.RebuildTo = jtr.ReadAsString();
break;
Wire up Logiqx TruRip/EmuArc fields
2020-08-20 22:42:04 -07:00
#endregion
#region Logiqx EmuArc
case "titleid":
machine.TitleID = jtr.ReadAsString();
break;
case "developer":
machine.Developer = jtr.ReadAsString();
break;
case "genre":
machine.Genre = jtr.ReadAsString();
break;
case "subgenre":
machine.Subgenre = jtr.ReadAsString();
break;
case "ratings":
machine.Ratings = jtr.ReadAsString();
break;
case "score":
machine.Score = jtr.ReadAsString();
break;
case "enabled":
machine.Enabled = jtr.ReadAsString();
break;
case "hascrc":
machine.HasCrc = jtr.ReadAsString().AsYesNo();
break;
case "relatedto":
machine.RelatedTo = jtr.ReadAsString();
break;
#endregion
#region SoftwareList
Support more AttractMode fields
2020-08-20 14:36:36 -07:00
case "supported":
machine.Supported = jtr.ReadAsString().AsYesNo();
Implement JSON reading
2020-06-16 11:27:36 -07:00
break;
Wire up SoftwareList sharedfeat
2020-08-21 13:03:38 -07:00
case "sharedfeat":
machine.SharedFeatures = new List<KeyValuePair<string, string>>();
jtr.Read(); // Start Array
while (!sr.EndOfStream)
{
jtr.Read(); // Start object (or end array)
if (jtr.TokenType == JsonToken.EndArray)
break;
jtr.Read(); // Key
string key = jtr.Value as string;
string value = jtr.ReadAsString();
jtr.Read(); // End object
machine.SharedFeatures.Add(new KeyValuePair<string, string>(key, value));
}
break;
Wire up Logiqx TruRip/EmuArc fields
2020-08-20 22:42:04 -07:00
#endregion
Implement JSON reading
2020-06-16 11:27:36 -07:00
default:
break;
}
jtr.Read();
}
}
/// <summary>
/// Read item array information
/// </summary>
/// <param name="sr">StreamReader to use to parse the header</param>
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
/// <param name="jtr">JsonTextReader to use to parse the machine</param>
/// <param name="filename">Name of the file to be parsed</param>
/// <param name="indexId">Index ID for the DAT</param>
/// <param name="machine">Machine information to add to the parsed items</param>
Implement JSON reading
2020-06-16 11:27:36 -07:00
private void ReadItems(
StreamReader sr,
JsonTextReader jtr,
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
// Standard Dat parsing
string filename,
int indexId,
Implement JSON reading
2020-06-16 11:27:36 -07:00
// Miscellaneous
Machine machine)
{
// If the reader is invalid, skip
if (jtr == null)
return;
jtr.Read();
while (!sr.EndOfStream)
{
// If we hit the end of an array, we want to return
if (jtr.TokenType == JsonToken.EndArray)
return;
// We don't care about anything except start object
if (jtr.TokenType != JsonToken.StartObject)
{
jtr.Read();
continue;
}
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
ReadItem(sr, jtr, filename, indexId, machine);
Implement JSON reading
2020-06-16 11:27:36 -07:00
jtr.Read();
}
}
/// <summary>
/// Read item information
/// </summary>
/// <param name="sr">StreamReader to use to parse the header</param>
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
/// <param name="jtr">JsonTextReader to use to parse the machine</param>
/// <param name="filename">Name of the file to be parsed</param>
/// <param name="indexId">Index ID for the DAT</param>
/// <param name="machine">Machine information to add to the parsed items</param>
Implement JSON reading
2020-06-16 11:27:36 -07:00
private void ReadItem(
StreamReader sr,
JsonTextReader jtr,
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
// Standard Dat parsing
string filename,
int indexId,
Implement JSON reading
2020-06-16 11:27:36 -07:00
// Miscellaneous
Machine machine)
{
// If we have an empty machine, skip it
if (jtr == null)
return;
// Prepare internal variables
bool? def = null,
writable = null,
Add support for inverted CRC flag
2020-07-28 17:00:19 -07:00
optional = null,
inverted = null;
Implement JSON reading
2020-06-16 11:27:36 -07:00
long size = -1;
long? areaSize = null;
string name = null,
Wire up remaining AttractMode fields
2020-08-20 21:15:37 -07:00
altName = null,
altTitle = null,
Implement JSON reading
2020-06-16 11:27:36 -07:00
partName = null,
partInterface = null,
areaName = null,
Wire up area width, endianness for SL
2020-08-21 13:31:22 -07:00
areaWidth = null,
areaEndianness = null,
Wire up value and loadflag for SL
2020-08-21 14:20:17 -07:00
value = null,
loadFlag = null,
Implement JSON reading
2020-06-16 11:27:36 -07:00
biosDescription = null,
region = null,
language = null,
date = null,
crc = null,
md5 = null,
ripemd160 = null,
sha1 = null,
sha256 = null,
sha384 = null,
sha512 = null,
merge = null,
index = null,
offset = null,
bios = null;
ItemStatus? itemStatus = null;
ItemType? itemType = null;
List<KeyValuePair<string, string>> features = null;
jtr.Read();
while (!sr.EndOfStream)
{
// If we hit the end of the machine - create, add, and return
if (jtr.TokenType == JsonToken.EndObject)
{
// If we didn't read something valid, just return
if (itemType == null)
return;
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
DatItem datItem = DatItem.Create(itemType.Value);
Implement JSON reading
2020-06-16 11:27:36 -07:00
datItem.CopyMachineInformation(machine);
Machine stands alone
2020-08-20 13:17:14 -07:00
datItem.Source = new Source { Index = indexId, Name = filename };
Implement JSON reading
2020-06-16 11:27:36 -07:00
datItem.Name = name;
Wire up remaining AttractMode fields
2020-08-20 21:15:37 -07:00
datItem.AltName = altName;
datItem.AltTitle = altTitle;
Implement JSON reading
2020-06-16 11:27:36 -07:00
datItem.PartName = partName;
datItem.PartInterface = partInterface;
datItem.Features = features;
datItem.AreaName = areaName;
datItem.AreaSize = areaSize;
Wire up area width, endianness for SL
2020-08-21 13:31:22 -07:00
datItem.AreaWidth = areaWidth;
datItem.AreaEndianness = areaEndianness;
Wire up value and loadflag for SL
2020-08-21 14:20:17 -07:00
datItem.Value = value;
datItem.LoadFlag = loadFlag;
Implement JSON reading
2020-06-16 11:27:36 -07:00
if (itemType == ItemType.BiosSet)
{
(datItem as BiosSet).Description = biosDescription;
(datItem as BiosSet).Default = def;
}
else if (itemType == ItemType.Disk)
{
(datItem as Disk).MD5 = md5;
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
#if NET_FRAMEWORK
Implement JSON reading
2020-06-16 11:27:36 -07:00
(datItem as Disk).RIPEMD160 = ripemd160;
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
#endif
Implement JSON reading
2020-06-16 11:27:36 -07:00
(datItem as Disk).SHA1 = sha1;
(datItem as Disk).SHA256 = sha256;
(datItem as Disk).SHA384 = sha384;
(datItem as Disk).SHA512 = sha512;
(datItem as Disk).MergeTag = merge;
(datItem as Disk).Region = region;
(datItem as Disk).Index = index;
(datItem as Disk).Writable = writable;
(datItem as Disk).ItemStatus = itemStatus ?? ItemStatus.None;
(datItem as Disk).Optional = optional;
}
else if (itemType == ItemType.Release)
{
(datItem as Release).Region = region;
(datItem as Release).Language = language;
(datItem as Release).Date = date;
(datItem as Release).Default = def;
}
else if (itemType == ItemType.Rom)
{
(datItem as Rom).Bios = bios;
(datItem as Rom).Size = size;
(datItem as Rom).CRC = crc;
(datItem as Rom).MD5 = md5;
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
#if NET_FRAMEWORK
Implement JSON reading
2020-06-16 11:27:36 -07:00
(datItem as Rom).RIPEMD160 = ripemd160;
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
#endif
Implement JSON reading
2020-06-16 11:27:36 -07:00
(datItem as Rom).SHA1 = sha1;
(datItem as Rom).SHA256 = sha256;
(datItem as Rom).SHA384 = sha384;
(datItem as Rom).SHA512 = sha512;
(datItem as Rom).MergeTag = merge;
(datItem as Rom).Region = region;
(datItem as Rom).Offset = offset;
(datItem as Rom).Date = date;
(datItem as Rom).ItemStatus = itemStatus ?? ItemStatus.None;
(datItem as Rom).Optional = optional;
Add support for inverted CRC flag
2020-07-28 17:00:19 -07:00
(datItem as Rom).Inverted = inverted;
Implement JSON reading
2020-06-16 11:27:36 -07:00
}
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
ParseAddHelper(datItem);
Implement JSON reading
2020-06-16 11:27:36 -07:00
return;
}
// We don't care about anything except properties
if (jtr.TokenType != JsonToken.PropertyName)
{
jtr.Read();
continue;
}
switch (jtr.Value)
{
case "type":
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
itemType = jtr.ReadAsString().AsItemType();
Implement JSON reading
2020-06-16 11:27:36 -07:00
break;
case "name":
name = jtr.ReadAsString();
break;
Wire up remaining AttractMode fields
2020-08-20 21:15:37 -07:00
case "alt_romname":
altName = jtr.ReadAsString();
break;
case "alt_title":
altTitle = jtr.ReadAsString();
break;
Implement JSON reading
2020-06-16 11:27:36 -07:00
case "partname":
partName = jtr.ReadAsString();
break;
case "partinterface":
partInterface = jtr.ReadAsString();
break;
case "features":
features = new List<KeyValuePair<string, string>>();
jtr.Read(); // Start Array
while (!sr.EndOfStream)
{
jtr.Read(); // Start object (or end array)
if (jtr.TokenType == JsonToken.EndArray)
break;
jtr.Read(); // Key
string key = jtr.Value as string;
Wire up value and loadflag for SL
2020-08-21 14:20:17 -07:00
string featureValue = jtr.ReadAsString();
Implement JSON reading
2020-06-16 11:27:36 -07:00
jtr.Read(); // End object
Wire up value and loadflag for SL
2020-08-21 14:20:17 -07:00
features.Add(new KeyValuePair<string, string>(key, featureValue));
Implement JSON reading
2020-06-16 11:27:36 -07:00
}
break;
case "areaname":
areaName = jtr.ReadAsString();
break;
case "areasize":
if (Int64.TryParse(jtr.ReadAsString(), out long tempAreaSize))
areaSize = tempAreaSize;
else
areaSize = null;
break;
Wire up area width, endianness for SL
2020-08-21 13:31:22 -07:00
case "areawidth":
areaWidth = jtr.ReadAsString();
break;
case "areaendianness":
areaEndianness = jtr.ReadAsString();
break;
Wire up value and loadflag for SL
2020-08-21 14:20:17 -07:00
case "value":
value = jtr.ReadAsString();
break;
case "loadflag":
loadFlag = jtr.ReadAsString();
break;
Implement JSON reading
2020-06-16 11:27:36 -07:00
case "description":
biosDescription = jtr.ReadAsString();
break;
case "default":
def = jtr.ReadAsBoolean();
break;
case "region":
region = jtr.ReadAsString();
break;
case "language":
language = jtr.ReadAsString();
break;
case "date":
date = jtr.ReadAsString();
break;
case "size":
if (!Int64.TryParse(jtr.ReadAsString(), out size))
size = -1;
break;
case "crc":
crc = jtr.ReadAsString();
break;
case "md5":
md5 = jtr.ReadAsString();
break;
case "ripemd160":
ripemd160 = jtr.ReadAsString();
break;
case "sha1":
sha1 = jtr.ReadAsString();
break;
case "sha256":
sha256 = jtr.ReadAsString();
break;
case "sha384":
sha384 = jtr.ReadAsString();
break;
case "sha512":
sha512 = jtr.ReadAsString();
break;
case "merge":
merge = jtr.ReadAsString();
break;
case "index":
index = jtr.ReadAsString();
break;
case "writable":
writable = jtr.ReadAsBoolean();
break;
case "status":
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
itemStatus = jtr.ReadAsString().AsItemStatus();
Implement JSON reading
2020-06-16 11:27:36 -07:00
break;
case "optional":
optional = jtr.ReadAsBoolean();
break;
case "offset":
offset = jtr.ReadAsString();
break;
case "bios":
bios = jtr.ReadAsString();
break;
Add support for inverted CRC flag
2020-07-28 17:00:19 -07:00
case "inverted":
inverted = jtr.ReadAsBoolean();
break;
Implement JSON reading
2020-06-16 11:27:36 -07:00
default:
break;
}
jtr.Read();
}
}
Add JSON write
2020-06-15 22:31:46 -07:00
/// <summary>
/// Create and open an output file for writing direct from a dictionary
/// </summary>
/// <param name="outfile">Name of the file to write to</param>
/// <param name="ignoreblanks">True if blank roms should be skipped on output, false otherwise (default)</param>
/// <returns>True if the DAT was written correctly, false otherwise</returns>
public override bool WriteToFile(string outfile, bool ignoreblanks = false)
{
try
{
Globals.Logger.User($"Opening file for writing: {outfile}");
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
FileStream fs = FileExtensions.TryCreate(outfile);
Add JSON write
2020-06-15 22:31:46 -07:00
// If we get back null for some reason, just log and return
if (fs == null)
{
Globals.Logger.Warning($"File '{outfile}' could not be created for writing! Please check to see if the file is writable");
return false;
}
StreamWriter sw = new StreamWriter(fs, new UTF8Encoding(false));
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
JsonTextWriter jtw = new JsonTextWriter(sw)
{
Formatting = Formatting.Indented,
IndentChar = '\t',
Indentation = 1
};
Add JSON write
2020-06-15 22:31:46 -07:00
// Write out the header
WriteHeader(jtw);
// Write out each of the machines and roms
string lastgame = null;
Create and use SortedKeys
2020-07-26 21:00:30 -07:00
// Use a sorted list of games to output
Add and use ItemDictionary class
2020-07-26 22:34:45 -07:00
foreach (string key in Items.SortedKeys)
Add JSON write
2020-06-15 22:31:46 -07:00
{
Add and use ItemDictionary class
2020-07-26 22:34:45 -07:00
List<DatItem> roms = Items[key];
Add JSON write
2020-06-15 22:31:46 -07:00
// Resolve the names in the block
roms = DatItem.ResolveNames(roms);
for (int index = 0; index < roms.Count; index++)
{
DatItem rom = roms[index];
// There are apparently times when a null rom can skip by, skip them
Machine stands alone
2020-08-20 13:17:14 -07:00
if (rom.Name == null || rom.Machine.Name == null)
Add JSON write
2020-06-15 22:31:46 -07:00
{
Globals.Logger.Warning("Null rom found!");
continue;
}
// If we have a different game and we're not at the start of the list, output the end of last item
Machine stands alone
2020-08-20 13:17:14 -07:00
if (lastgame != null && lastgame.ToLowerInvariant() != rom.Machine.Name.ToLowerInvariant())
Add JSON write
2020-06-15 22:31:46 -07:00
WriteEndGame(jtw);
// If we have a new game, output the beginning of the new item
Machine stands alone
2020-08-20 13:17:14 -07:00
if (lastgame == null || lastgame.ToLowerInvariant() != rom.Machine.Name.ToLowerInvariant())
Add JSON write
2020-06-15 22:31:46 -07:00
WriteStartGame(jtw, rom);
// If we have a "null" game (created by DATFromDir or something similar), log it to file
if (rom.ItemType == ItemType.Rom
&& ((Rom)rom).Size == -1
&& ((Rom)rom).CRC == "null")
{
Machine stands alone
2020-08-20 13:17:14 -07:00
Globals.Logger.Verbose($"Empty folder found: {rom.Machine.Name}");
Add JSON write
2020-06-15 22:31:46 -07:00
rom.Name = (rom.Name == "null" ? "-" : rom.Name);
((Rom)rom).Size = Constants.SizeZero;
((Rom)rom).CRC = ((Rom)rom).CRC == "null" ? Constants.CRCZero : null;
((Rom)rom).MD5 = ((Rom)rom).MD5 == "null" ? Constants.MD5Zero : null;
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
#if NET_FRAMEWORK
Add JSON write
2020-06-15 22:31:46 -07:00
((Rom)rom).RIPEMD160 = ((Rom)rom).RIPEMD160 == "null" ? Constants.RIPEMD160Zero : null;
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
#endif
Add JSON write
2020-06-15 22:31:46 -07:00
((Rom)rom).SHA1 = ((Rom)rom).SHA1 == "null" ? Constants.SHA1Zero : null;
((Rom)rom).SHA256 = ((Rom)rom).SHA256 == "null" ? Constants.SHA256Zero : null;
((Rom)rom).SHA384 = ((Rom)rom).SHA384 == "null" ? Constants.SHA384Zero : null;
((Rom)rom).SHA512 = ((Rom)rom).SHA512 == "null" ? Constants.SHA512Zero : null;
}
// Now, output the rom data
WriteDatItem(jtw, rom, ignoreblanks);
// Set the new data to compare against
Machine stands alone
2020-08-20 13:17:14 -07:00
lastgame = rom.Machine.Name;
Add JSON write
2020-06-15 22:31:46 -07:00
}
}
// Write the file footer out
WriteFooter(jtw);
Globals.Logger.Verbose("File written!" + Environment.NewLine);
jtw.Close();
fs.Dispose();
}
catch (Exception ex)
{
Globals.Logger.Error(ex.ToString());
return false;
}
return true;
}
/// <summary>
/// Write out DAT header using the supplied StreamWriter
/// </summary>
/// <param name="jtw">JsonTextWriter to output to</param>
/// <returns>True if the data was written, false on error</returns>
private bool WriteHeader(JsonTextWriter jtw)
{
try
{
jtw.WriteStartObject();
jtw.WritePropertyName("header");
jtw.WriteStartObject();
Add ListXML header fields
2020-08-20 15:13:57 -07:00
#region Common
Add JSON write
2020-06-15 22:31:46 -07:00
jtw.WritePropertyName("name");
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
jtw.WriteValue(Header.Name);
Add JSON write
2020-06-15 22:31:46 -07:00
jtw.WritePropertyName("description");
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
jtw.WriteValue(Header.Description);
if (!string.IsNullOrWhiteSpace(Header.RootDir))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("rootdir");
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
jtw.WriteValue(Header.RootDir);
Add JSON write
2020-06-15 22:31:46 -07:00
}
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
if (!string.IsNullOrWhiteSpace(Header.Category))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("category");
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
jtw.WriteValue(Header.Category);
Add JSON write
2020-06-15 22:31:46 -07:00
}
jtw.WritePropertyName("version");
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
jtw.WriteValue(Header.Version);
if (!string.IsNullOrWhiteSpace(Header.Date))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("date");
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
jtw.WriteValue(Header.Date);
Add JSON write
2020-06-15 22:31:46 -07:00
}
jtw.WritePropertyName("author");
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
jtw.WriteValue(Header.Author);
if (!string.IsNullOrWhiteSpace(Header.Email))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("email");
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
jtw.WriteValue(Header.Email);
Add JSON write
2020-06-15 22:31:46 -07:00
}
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
if (!string.IsNullOrWhiteSpace(Header.Homepage))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("homepage");
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
jtw.WriteValue(Header.Homepage);
Add JSON write
2020-06-15 22:31:46 -07:00
}
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
if (!string.IsNullOrWhiteSpace(Header.Url))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("date");
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
jtw.WriteValue(Header.Url);
Add JSON write
2020-06-15 22:31:46 -07:00
}
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
if (!string.IsNullOrWhiteSpace(Header.Comment))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("comment");
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
jtw.WriteValue(Header.Comment);
Add JSON write
2020-06-15 22:31:46 -07:00
}
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
if (!string.IsNullOrWhiteSpace(Header.Type))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("type");
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
jtw.WriteValue(Header.Type);
Add JSON write
2020-06-15 22:31:46 -07:00
}
Move to MergingFlag
2020-08-20 20:38:29 -07:00
if (Header.ForceMerging != MergingFlag.None)
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("forcemerging");
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
switch (Header.ForceMerging)
Add JSON write
2020-06-15 22:31:46 -07:00
{
Move to MergingFlag
2020-08-20 20:38:29 -07:00
case MergingFlag.Full:
Add JSON write
2020-06-15 22:31:46 -07:00
jtw.WriteValue("full");
break;
Move to MergingFlag
2020-08-20 20:38:29 -07:00
case MergingFlag.Split:
Add JSON write
2020-06-15 22:31:46 -07:00
jtw.WriteValue("split");
break;
Move to MergingFlag
2020-08-20 20:38:29 -07:00
case MergingFlag.Merged:
Add JSON write
2020-06-15 22:31:46 -07:00
jtw.WriteValue("merged");
break;
Move to MergingFlag
2020-08-20 20:38:29 -07:00
case MergingFlag.NonMerged:
Add JSON write
2020-06-15 22:31:46 -07:00
jtw.WriteValue("nonmerged");
break;
}
}
Move to MergingFlag
2020-08-20 20:38:29 -07:00
if (Header.ForcePacking != PackingFlag.None)
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("forcepacking");
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
switch (Header.ForcePacking)
Add JSON write
2020-06-15 22:31:46 -07:00
{
Move to MergingFlag
2020-08-20 20:38:29 -07:00
case PackingFlag.Unzip:
Add JSON write
2020-06-15 22:31:46 -07:00
jtw.WriteValue("unzip");
break;
Move to MergingFlag
2020-08-20 20:38:29 -07:00
case PackingFlag.Zip:
Add JSON write
2020-06-15 22:31:46 -07:00
jtw.WriteValue("zip");
break;
}
}
Move to MergingFlag
2020-08-20 20:38:29 -07:00
if (Header.ForceNodump != NodumpFlag.None)
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("forcenodump");
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
switch (Header.ForceNodump)
Add JSON write
2020-06-15 22:31:46 -07:00
{
Move to MergingFlag
2020-08-20 20:38:29 -07:00
case NodumpFlag.Ignore:
Add JSON write
2020-06-15 22:31:46 -07:00
jtw.WriteValue("ignore");
break;
Move to MergingFlag
2020-08-20 20:38:29 -07:00
case NodumpFlag.Obsolete:
Add JSON write
2020-06-15 22:31:46 -07:00
jtw.WriteValue("obsolete");
break;
Move to MergingFlag
2020-08-20 20:38:29 -07:00
case NodumpFlag.Required:
Add JSON write
2020-06-15 22:31:46 -07:00
jtw.WriteValue("required");
break;
}
}
HeaderSkipper cleanup
2020-08-02 12:54:27 -07:00
if (!string.IsNullOrWhiteSpace(Header.HeaderSkipper))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("header");
HeaderSkipper cleanup
2020-08-02 12:54:27 -07:00
jtw.WriteValue(Header.HeaderSkipper);
Add JSON write
2020-06-15 22:31:46 -07:00
}
Add ListXML header fields
2020-08-20 15:13:57 -07:00
#endregion
#region ListXML
if (Header.Debug != null)
{
jtw.WritePropertyName("debug");
switch (Header.Debug)
{
case true:
Fix build
2020-08-20 15:15:40 -07:00
jtw.WriteValue("yes");
Add ListXML header fields
2020-08-20 15:13:57 -07:00
break;
case false:
jtw.WriteValue("no");
break;
}
}
if (!string.IsNullOrWhiteSpace(Header.MameConfig))
{
jtw.WritePropertyName("mameconfig");
jtw.WriteValue(Header.MameConfig);
}
#endregion
MachineType is common, add Logiqx header values
2020-08-20 15:39:32 -07:00
#region Logiqx
if (!string.IsNullOrWhiteSpace(Header.Build))
{
jtw.WritePropertyName("build");
jtw.WriteValue(Header.Build);
}
Move to MergingFlag
2020-08-20 20:38:29 -07:00
if (Header.RomMode != MergingFlag.None)
Wire up remaining Logiqx header values
2020-08-20 17:23:19 -07:00
{
jtw.WritePropertyName("rommode");
Move to MergingFlag
2020-08-20 20:38:29 -07:00
switch (Header.RomMode)
{
case MergingFlag.Split:
jtw.WriteValue("split");
break;
case MergingFlag.Merged:
jtw.WriteValue("merged");
break;
case MergingFlag.NonMerged:
jtw.WriteValue("unmerged");
break;
}
Wire up remaining Logiqx header values
2020-08-20 17:23:19 -07:00
}
Move to MergingFlag
2020-08-20 20:38:29 -07:00
if (Header.BiosMode != MergingFlag.None)
Wire up remaining Logiqx header values
2020-08-20 17:23:19 -07:00
{
jtw.WritePropertyName("biosmode");
Move to MergingFlag
2020-08-20 20:38:29 -07:00
switch (Header.BiosMode)
{
case MergingFlag.Split:
jtw.WriteValue("split");
break;
case MergingFlag.Merged:
jtw.WriteValue("merged");
break;
case MergingFlag.NonMerged:
jtw.WriteValue("unmerged");
break;
}
Wire up remaining Logiqx header values
2020-08-20 17:23:19 -07:00
}
Move to MergingFlag
2020-08-20 20:38:29 -07:00
if (Header.SampleMode != MergingFlag.None)
Wire up remaining Logiqx header values
2020-08-20 17:23:19 -07:00
{
jtw.WritePropertyName("samplemode");
Move to MergingFlag
2020-08-20 20:38:29 -07:00
switch (Header.SampleMode)
{
case MergingFlag.Merged:
jtw.WriteValue("merged");
break;
case MergingFlag.NonMerged:
jtw.WriteValue("unmerged");
break;
}
Wire up remaining Logiqx header values
2020-08-20 17:23:19 -07:00
}
if (Header.LockRomMode != null)
{
switch (Header.LockRomMode)
{
case true:
jtw.WritePropertyName("lockrommode");
jtw.WriteValue("yes");
break;
case false:
jtw.WritePropertyName("lockrommode");
jtw.WriteValue("no");
break;
}
}
if (Header.LockBiosMode != null)
{
switch (Header.LockBiosMode)
{
case true:
jtw.WritePropertyName("lockbiosmode");
jtw.WriteValue("yes");
break;
case false:
jtw.WritePropertyName("lockbiosmode");
jtw.WriteValue("no");
break;
}
}
if (Header.LockSampleMode != null)
{
switch (Header.LockSampleMode)
{
case true:
jtw.WritePropertyName("locksamplemode");
jtw.WriteValue("yes");
break;
case false:
jtw.WritePropertyName("locksamplemode");
jtw.WriteValue("no");
break;
}
}
MachineType is common, add Logiqx header values
2020-08-20 15:39:32 -07:00
#endregion
Add some OfflineList headers
2020-08-20 15:51:13 -07:00
#region OfflineList
if (!string.IsNullOrWhiteSpace(Header.System))
{
jtw.WritePropertyName("system");
jtw.WriteValue(Header.System);
}
if (!string.IsNullOrWhiteSpace(Header.ScreenshotsWidth))
{
jtw.WritePropertyName("screenshotswidth");
jtw.WriteValue(Header.ScreenshotsWidth);
}
if (!string.IsNullOrWhiteSpace(Header.ScreenshotsHeight))
{
jtw.WritePropertyName("screenshotsheight");
jtw.WriteValue(Header.ScreenshotsHeight);
}
Wire up infos for OfflineList
2020-08-20 16:20:22 -07:00
if (Header.Infos != null)
{
jtw.WritePropertyName("infos");
jtw.WriteStartArray();
foreach (var info in Header.Infos)
{
jtw.WriteStartObject();
jtw.WritePropertyName("name");
jtw.WriteValue(info.Item1);
jtw.WritePropertyName("visible");
jtw.WriteValue(info.Item2.ToString());
jtw.WritePropertyName("inNamingOption");
jtw.WriteValue(info.Item3.ToString());
jtw.WritePropertyName("default");
jtw.WriteValue(info.Item4.ToString());
jtw.WriteEndObject();
}
jtw.WriteEndArray();
}
Wire up OfflineList canOpen
2020-08-20 16:30:16 -07:00
if (Header.CanOpen != null)
{
jtw.WritePropertyName("canopen");
jtw.WriteStartArray();
foreach (string extension in Header.CanOpen)
{
jtw.WriteValue(extension);
}
jtw.WriteEndArray();
}
Add some OfflineList headers
2020-08-20 15:51:13 -07:00
if (!string.IsNullOrWhiteSpace(Header.RomTitle))
{
jtw.WritePropertyName("romtitle");
jtw.WriteValue(Header.RomTitle);
}
#endregion
Missing header notes, wire up RC Version
2020-08-20 16:49:21 -07:00
#region RomCenter
if (!string.IsNullOrWhiteSpace(Header.RomCenterVersion))
{
jtw.WritePropertyName("rcversion");
jtw.WriteValue(Header.RomCenterVersion);
}
#endregion
Add JSON write
2020-06-15 22:31:46 -07:00
// End header
jtw.WriteEndObject();
jtw.WritePropertyName("machines");
jtw.WriteStartArray();
jtw.Flush();
}
catch (Exception ex)
{
Globals.Logger.Error(ex.ToString());
return false;
}
return true;
}
/// <summary>
/// Write out Game start using the supplied StreamWriter
/// </summary>
/// <param name="jtw">JsonTextWriter to output to</param>
/// <param name="datItem">DatItem object to be output</param>
/// <returns>True if the data was written, false on error</returns>
private bool WriteStartGame(JsonTextWriter jtw, DatItem datItem)
{
try
{
// No game should start with a path separator
Machine stands alone
2020-08-20 13:17:14 -07:00
datItem.Machine.Name = datItem.Machine.Name.TrimStart(Path.DirectorySeparatorChar);
Add JSON write
2020-06-15 22:31:46 -07:00
// Build the state based on excluded fields
jtw.WriteStartObject();
Wire up Logiqx TruRip/EmuArc fields
2020-08-20 22:42:04 -07:00
#region Common
Add JSON write
2020-06-15 22:31:46 -07:00
jtw.WritePropertyName("name");
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
jtw.WriteValue(datItem.GetField(Field.MachineName, Header.ExcludeFields));
Add JSON write
2020-06-15 22:31:46 -07:00
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.Comment, Header.ExcludeFields)))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("comment");
Machine stands alone
2020-08-20 13:17:14 -07:00
jtw.WriteValue(datItem.Machine.Comment);
Add JSON write
2020-06-15 22:31:46 -07:00
}
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.Description, Header.ExcludeFields)))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("description");
Machine stands alone
2020-08-20 13:17:14 -07:00
jtw.WriteValue(datItem.Machine.Description);
Add JSON write
2020-06-15 22:31:46 -07:00
}
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.Year, Header.ExcludeFields)))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("year");
Machine stands alone
2020-08-20 13:17:14 -07:00
jtw.WriteValue(datItem.Machine.Year);
Add JSON write
2020-06-15 22:31:46 -07:00
}
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.Manufacturer, Header.ExcludeFields)))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("manufacturer");
Machine stands alone
2020-08-20 13:17:14 -07:00
jtw.WriteValue(datItem.Machine.Manufacturer);
Add JSON write
2020-06-15 22:31:46 -07:00
}
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.Publisher, Header.ExcludeFields)))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("publisher");
Machine stands alone
2020-08-20 13:17:14 -07:00
jtw.WriteValue(datItem.Machine.Publisher);
Add JSON write
2020-06-15 22:31:46 -07:00
}
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.Category, Header.ExcludeFields)))
Filter Abstraction (#25) * Add category, back filters by dictionary * Complete internal filter set * Fix AreaSize filter * Populate filter object the hard way * Manipulation flags should not be filters * None of them need to be public * Convert to partial helper method * Better method use * Field, not string; no dictionary * Add FilterTo method for later * More naming options (easier conversion) * Update README
2020-07-18 21:35:17 -07:00
{
jtw.WritePropertyName("category");
Machine stands alone
2020-08-20 13:17:14 -07:00
jtw.WriteValue(datItem.Machine.Category);
Filter Abstraction (#25) * Add category, back filters by dictionary * Complete internal filter set * Fix AreaSize filter * Populate filter object the hard way * Manipulation flags should not be filters * None of them need to be public * Convert to partial helper method * Better method use * Field, not string; no dictionary * Add FilterTo method for later * More naming options (easier conversion) * Update README
2020-07-18 21:35:17 -07:00
}
Machine stands alone
2020-08-20 13:17:14 -07:00
if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.RomOf, Header.ExcludeFields)) && !string.Equals(datItem.Machine.Name, datItem.Machine.RomOf, StringComparison.OrdinalIgnoreCase))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("romof");
Machine stands alone
2020-08-20 13:17:14 -07:00
jtw.WriteValue(datItem.Machine.RomOf);
Add JSON write
2020-06-15 22:31:46 -07:00
}
Machine stands alone
2020-08-20 13:17:14 -07:00
if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.CloneOf, Header.ExcludeFields)) && !string.Equals(datItem.Machine.Name, datItem.Machine.CloneOf, StringComparison.OrdinalIgnoreCase))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("cloneof");
Machine stands alone
2020-08-20 13:17:14 -07:00
jtw.WriteValue(datItem.Machine.CloneOf);
Add JSON write
2020-06-15 22:31:46 -07:00
}
Machine stands alone
2020-08-20 13:17:14 -07:00
if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.SampleOf, Header.ExcludeFields)) && !string.Equals(datItem.Machine.Name, datItem.Machine.SampleOf, StringComparison.OrdinalIgnoreCase))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("sampleof");
Machine stands alone
2020-08-20 13:17:14 -07:00
jtw.WriteValue(datItem.Machine.SampleOf);
Add JSON write
2020-06-15 22:31:46 -07:00
}
MachineType is common, add Logiqx header values
2020-08-20 15:39:32 -07:00
if (!Header.ExcludeFields.Contains(Field.MachineType))
{
if (datItem.Machine.MachineType.HasFlag(MachineType.Bios))
{
jtw.WritePropertyName("isbios");
jtw.WriteValue("yes");
}
if (datItem.Machine.MachineType.HasFlag(MachineType.Device))
{
jtw.WritePropertyName("isdevice");
jtw.WriteValue("yes");
}
if (datItem.Machine.MachineType.HasFlag(MachineType.Mechanical))
{
jtw.WritePropertyName("ismechanical");
jtw.WriteValue("yes");
}
}
Support more AttractMode fields
2020-08-20 14:36:36 -07:00
Wire up Logiqx TruRip/EmuArc fields
2020-08-20 22:42:04 -07:00
#endregion
#region AttractMode
Support more AttractMode fields
2020-08-20 14:36:36 -07:00
if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.Players, Header.ExcludeFields)))
Add JSON write
2020-06-15 22:31:46 -07:00
{
Support more AttractMode fields
2020-08-20 14:36:36 -07:00
jtw.WritePropertyName("players");
jtw.WriteValue(datItem.Machine.Players);
}
if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.Rotation, Header.ExcludeFields)))
{
jtw.WritePropertyName("rotation");
jtw.WriteValue(datItem.Machine.Rotation);
Add JSON write
2020-06-15 22:31:46 -07:00
}
Support more AttractMode fields
2020-08-20 14:36:36 -07:00
if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.Control, Header.ExcludeFields)))
{
jtw.WritePropertyName("control");
jtw.WriteValue(datItem.Machine.Control);
}
if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.SupportStatus, Header.ExcludeFields)))
{
jtw.WritePropertyName("status");
jtw.WriteValue(datItem.Machine.Status);
}
if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.DisplayCount, Header.ExcludeFields)))
{
jtw.WritePropertyName("displaycount");
jtw.WriteValue(datItem.Machine.DisplayCount);
}
if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.DisplayType, Header.ExcludeFields)))
{
jtw.WritePropertyName("displaytype");
jtw.WriteValue(datItem.Machine.DisplayType);
}
if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.Buttons, Header.ExcludeFields)))
{
jtw.WritePropertyName("buttons");
jtw.WriteValue(datItem.Machine.Buttons);
}
Wire up Logiqx TruRip/EmuArc fields
2020-08-20 22:42:04 -07:00
#endregion
#region ListXML
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.SourceFile, Header.ExcludeFields)))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("sourcefile");
Machine stands alone
2020-08-20 13:17:14 -07:00
jtw.WriteValue(datItem.Machine.SourceFile);
Add JSON write
2020-06-15 22:31:46 -07:00
}
Machine stands alone
2020-08-20 13:17:14 -07:00
if (!Header.ExcludeFields.Contains(Field.Runnable) && datItem.Machine.Runnable != null)
Add JSON write
2020-06-15 22:31:46 -07:00
{
Machine stands alone
2020-08-20 13:17:14 -07:00
if (datItem.Machine.Runnable == true)
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("runnable");
jtw.WriteValue("yes");
}
Machine stands alone
2020-08-20 13:17:14 -07:00
else if (datItem.Machine.Runnable == false)
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("runnable");
jtw.WriteValue("no");
}
}
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.Devices, Header.ExcludeFields)))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("devices");
jtw.WriteStartArray();
Machine stands alone
2020-08-20 13:17:14 -07:00
foreach (string device in datItem.Machine.Devices)
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WriteValue(device);
}
jtw.WriteEndArray();
}
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.SlotOptions, Header.ExcludeFields)))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("slotoptions");
jtw.WriteStartArray();
Machine stands alone
2020-08-20 13:17:14 -07:00
foreach (string slotoption in datItem.Machine.SlotOptions)
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WriteValue(slotoption);
}
jtw.WriteEndArray();
}
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.Infos, Header.ExcludeFields)))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("infos");
jtw.WriteStartArray();
Machine stands alone
2020-08-20 13:17:14 -07:00
foreach (var info in datItem.Machine.Infos)
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WriteStartObject();
jtw.WritePropertyName(info.Key);
jtw.WriteValue(info.Value);
jtw.WriteEndObject();
}
jtw.WriteEndArray();
}
Wire up Logiqx TruRip/EmuArc fields
2020-08-20 22:42:04 -07:00
#endregion
#region Logiqx
Support more AttractMode fields
2020-08-20 14:36:36 -07:00
if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.Board, Header.ExcludeFields)))
{
jtw.WritePropertyName("board");
jtw.WriteValue(datItem.Machine.Board);
}
if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.RebuildTo, Header.ExcludeFields)))
{
jtw.WritePropertyName("rebuildto");
jtw.WriteValue(datItem.Machine.RebuildTo);
}
Wire up Logiqx TruRip/EmuArc fields
2020-08-20 22:42:04 -07:00
#endregion
#region Logiqx EmuArc
if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.TitleID, Header.ExcludeFields)))
{
jtw.WritePropertyName("titleid");
jtw.WriteValue(datItem.Machine.TitleID);
}
if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.Developer, Header.ExcludeFields)))
{
jtw.WritePropertyName("developer");
jtw.WriteValue(datItem.Machine.Developer);
}
if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.Genre, Header.ExcludeFields)))
{
jtw.WritePropertyName("genre");
jtw.WriteValue(datItem.Machine.Genre);
}
if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.Subgenre, Header.ExcludeFields)))
{
jtw.WritePropertyName("subgenre");
jtw.WriteValue(datItem.Machine.Subgenre);
}
if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.Ratings, Header.ExcludeFields)))
{
jtw.WritePropertyName("ratings");
jtw.WriteValue(datItem.Machine.Ratings);
}
if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.Score, Header.ExcludeFields)))
{
jtw.WritePropertyName("score");
jtw.WriteValue(datItem.Machine.Score);
}
if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.Enabled, Header.ExcludeFields)))
{
jtw.WritePropertyName("enabled");
jtw.WriteValue(datItem.Machine.Enabled);
}
if (!Header.ExcludeFields.Contains(Field.HasCrc) && datItem.Machine.HasCrc != null)
{
if (datItem.Machine.HasCrc == true)
{
jtw.WritePropertyName("hascrc");
jtw.WriteValue("yes");
}
else if (datItem.Machine.HasCrc == false)
{
jtw.WritePropertyName("hascrc");
jtw.WriteValue("no");
}
}
if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.RelatedTo, Header.ExcludeFields)))
{
jtw.WritePropertyName("relatedto");
jtw.WriteValue(datItem.Machine.RelatedTo);
}
#endregion
#region SoftwareList
Support more AttractMode fields
2020-08-20 14:36:36 -07:00
if (!Header.ExcludeFields.Contains(Field.Supported) && datItem.Machine.Supported != null)
{
if (datItem.Machine.Supported == true)
{
jtw.WritePropertyName("supported");
jtw.WriteValue("yes");
}
else if (datItem.Machine.Supported == false)
{
jtw.WritePropertyName("supported");
jtw.WriteValue("no");
}
}
Wire up SoftwareList sharedfeat
2020-08-21 13:03:38 -07:00
if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.SharedFeatures, Header.ExcludeFields)))
{
jtw.WritePropertyName("sharedfeat");
jtw.WriteStartArray();
foreach (var feature in datItem.Machine.SharedFeatures)
{
jtw.WriteStartObject();
jtw.WritePropertyName(feature.Key);
jtw.WriteValue(feature.Value);
jtw.WriteEndObject();
}
jtw.WriteEndArray();
}
Support more AttractMode fields
2020-08-20 14:36:36 -07:00
Wire up Logiqx TruRip/EmuArc fields
2020-08-20 22:42:04 -07:00
#endregion
Add JSON write
2020-06-15 22:31:46 -07:00
jtw.WritePropertyName("items");
jtw.WriteStartArray();
jtw.Flush();
}
catch (Exception ex)
{
Globals.Logger.Error(ex.ToString());
return false;
}
return true;
}
/// <summary>
/// Write out Game end using the supplied StreamWriter
/// </summary>
/// <param name="jtw">JsonTextWriter to output to</param>
/// <returns>True if the data was written, false on error</returns>
private bool WriteEndGame(JsonTextWriter jtw)
{
try
{
// End items
jtw.WriteEndArray();
// End machine
jtw.WriteEndObject();
jtw.Flush();
}
catch (Exception ex)
{
Globals.Logger.Error(ex.ToString());
return false;
}
return true;
}
/// <summary>
/// Write out DatItem using the supplied StreamWriter
/// </summary>
/// <param name="jtw">JsonTextWriter to output to</param>
/// <param name="datItem">DatItem object to be output</param>
/// <param name="ignoreblanks">True if blank roms should be skipped on output, false otherwise (default)</param>
/// <returns>True if the data was written, false on error</returns>
private bool WriteDatItem(JsonTextWriter jtw, DatItem datItem, bool ignoreblanks = false)
{
// If we are in ignore blanks mode AND we have a blank (0-size) rom, skip
if (ignoreblanks && (datItem.ItemType == ItemType.Rom && ((datItem as Rom).Size == 0 || (datItem as Rom).Size == -1)))
return true;
// If we have the blank item type somehow, skip
if (datItem.ItemType == ItemType.Blank)
return true;
try
{
// Pre-process the item name
ProcessItemName(datItem, true);
// Build the state based on excluded fields
jtw.WriteStartObject();
jtw.WritePropertyName("type");
switch (datItem.ItemType)
{
case ItemType.Archive:
jtw.WriteValue("archive");
jtw.WritePropertyName("name");
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
jtw.WriteValue(datItem.GetField(Field.Name, Header.ExcludeFields));
Add JSON write
2020-06-15 22:31:46 -07:00
break;
case ItemType.BiosSet:
var biosSet = datItem as BiosSet;
jtw.WriteValue("biosset");
jtw.WritePropertyName("name");
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
jtw.WriteValue(biosSet.GetField(Field.Name, Header.ExcludeFields));
if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.BiosDescription, Header.ExcludeFields)))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("description");
jtw.WriteValue(biosSet.Description);
}
Remove unnecessary complexity
2020-07-27 15:21:59 -07:00
if (!Header.ExcludeFields.Contains(Field.Default) && biosSet.Default != null)
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("default");
jtw.WriteValue(biosSet.Default);
}
break;
case ItemType.Disk:
var disk = datItem as Disk;
jtw.WriteValue("disk");
jtw.WritePropertyName("name");
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
jtw.WriteValue(disk.GetField(Field.Name, Header.ExcludeFields));
if (!string.IsNullOrWhiteSpace(disk.GetField(Field.MD5, Header.ExcludeFields)))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("md5");
jtw.WriteValue(disk.MD5.ToLowerInvariant());
}
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
#if NET_FRAMEWORK
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
if (!string.IsNullOrWhiteSpace(disk.GetField(Field.RIPEMD160, Header.ExcludeFields)))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("ripemd160");
jtw.WriteValue(disk.RIPEMD160.ToLowerInvariant());
}
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
#endif
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
if (!string.IsNullOrWhiteSpace(disk.GetField(Field.SHA1, Header.ExcludeFields)))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("sha1");
jtw.WriteValue(disk.SHA1.ToLowerInvariant());
}
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
if (!string.IsNullOrWhiteSpace(disk.GetField(Field.SHA256, Header.ExcludeFields)))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("sha256");
jtw.WriteValue(disk.SHA256.ToLowerInvariant());
}
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
if (!string.IsNullOrWhiteSpace(disk.GetField(Field.SHA384, Header.ExcludeFields)))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("sha384");
jtw.WriteValue(disk.SHA384.ToLowerInvariant());
}
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
if (!string.IsNullOrWhiteSpace(disk.GetField(Field.SHA512, Header.ExcludeFields)))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("sha512");
jtw.WriteValue(disk.SHA512.ToLowerInvariant());
}
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
if (!string.IsNullOrWhiteSpace(disk.GetField(Field.Merge, Header.ExcludeFields)))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("merge");
jtw.WriteValue(disk.MergeTag);
}
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
if (!string.IsNullOrWhiteSpace(disk.GetField(Field.Region, Header.ExcludeFields)))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("region");
jtw.WriteValue(disk.Region);
}
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
if (!string.IsNullOrWhiteSpace(disk.GetField(Field.Index, Header.ExcludeFields)))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("index");
jtw.WriteValue(disk.Index);
}
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
if (!string.IsNullOrWhiteSpace(disk.GetField(Field.Writable, Header.ExcludeFields)))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("writable");
jtw.WriteValue(disk.Writable);
}
Remove unnecessary complexity
2020-07-27 15:21:59 -07:00
if (!Header.ExcludeFields.Contains(Field.Status) && disk.ItemStatus != ItemStatus.None)
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("status");
jtw.WriteValue(disk.ItemStatus.ToString().ToLowerInvariant());
}
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
if (!string.IsNullOrWhiteSpace(disk.GetField(Field.Optional, Header.ExcludeFields)))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("optional");
jtw.WriteValue(disk.Optional);
}
break;
case ItemType.Release:
var release = datItem as Release;
jtw.WriteValue("release");
jtw.WritePropertyName("name");
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
jtw.WriteValue(release.GetField(Field.Name, Header.ExcludeFields));
if (!string.IsNullOrWhiteSpace(release.GetField(Field.Region, Header.ExcludeFields)))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("region");
jtw.WriteValue(release.Region);
}
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
if (!string.IsNullOrWhiteSpace(release.GetField(Field.Language, Header.ExcludeFields)))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("language");
jtw.WriteValue(release.Language);
}
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
if (!string.IsNullOrWhiteSpace(release.GetField(Field.Date, Header.ExcludeFields)))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("date");
jtw.WriteValue(release.Date);
}
Remove unnecessary complexity
2020-07-27 15:21:59 -07:00
if (!Header.ExcludeFields.Contains(Field.Default) && release.Default != null)
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("default");
jtw.WriteValue(release.Default);
}
break;
case ItemType.Rom:
var rom = datItem as Rom;
jtw.WriteValue("rom");
jtw.WritePropertyName("name");
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
jtw.WriteValue(rom.GetField(Field.Name, Header.ExcludeFields));
Remove unnecessary complexity
2020-07-27 15:21:59 -07:00
if (!Header.ExcludeFields.Contains(Field.Size) && rom.Size != -1)
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("size");
jtw.WriteValue(rom.Size);
}
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
if (!string.IsNullOrWhiteSpace(rom.GetField(Field.Offset, Header.ExcludeFields)))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("offset");
jtw.WriteValue(rom.Offset);
}
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
if (!string.IsNullOrWhiteSpace(rom.GetField(Field.CRC, Header.ExcludeFields)))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("crc");
jtw.WriteValue(rom.CRC.ToLowerInvariant());
}
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
if (!string.IsNullOrWhiteSpace(rom.GetField(Field.MD5, Header.ExcludeFields)))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("md5");
jtw.WriteValue(rom.MD5.ToLowerInvariant());
}
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
#if NET_FRAMEWORK
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
if (!string.IsNullOrWhiteSpace(rom.GetField(Field.RIPEMD160, Header.ExcludeFields)))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("ripemd160");
jtw.WriteValue(rom.RIPEMD160.ToLowerInvariant());
}
Remove .NET Framework 4.6.2/4.7.2 (#24) * Remove < .NET 4.8, general cleanup * Abstract * Tango * Banner * Scan no more * Common * Application * Access * Filter-feeder * Graffiti * Paint-over * Law and Order * XOR-o * Unused staircase * Maybe * Maybe not * Delete this * The word is "no" * Emit * Improper * Aye aye * Fence * Barrier * Monkey * Pail * Lines
2020-07-15 09:41:59 -07:00
#endif
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
if (!string.IsNullOrWhiteSpace(rom.GetField(Field.SHA1, Header.ExcludeFields)))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("sha1");
jtw.WriteValue(rom.SHA1.ToLowerInvariant());
}
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
if (!string.IsNullOrWhiteSpace(rom.GetField(Field.SHA256, Header.ExcludeFields)))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("sha256");
jtw.WriteValue(rom.SHA256.ToLowerInvariant());
}
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
if (!string.IsNullOrWhiteSpace(rom.GetField(Field.SHA384, Header.ExcludeFields)))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("sha384");
jtw.WriteValue(rom.SHA384.ToLowerInvariant());
}
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
if (!string.IsNullOrWhiteSpace(rom.GetField(Field.SHA512, Header.ExcludeFields)))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("sha512");
jtw.WriteValue(rom.SHA512.ToLowerInvariant());
}
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
if (!string.IsNullOrWhiteSpace(rom.GetField(Field.Bios, Header.ExcludeFields)))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("bios");
jtw.WriteValue(rom.Bios);
}
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
if (!string.IsNullOrWhiteSpace(rom.GetField(Field.Merge, Header.ExcludeFields)))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("merge");
jtw.WriteValue(rom.MergeTag);
}
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
if (!string.IsNullOrWhiteSpace(rom.GetField(Field.Region, Header.ExcludeFields)))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("region");
jtw.WriteValue(rom.Region);
}
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
if (!string.IsNullOrWhiteSpace(rom.GetField(Field.Date, Header.ExcludeFields)))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("date");
jtw.WriteValue(rom.Date);
}
Remove unnecessary complexity
2020-07-27 15:21:59 -07:00
if (!Header.ExcludeFields.Contains(Field.Status) && rom.ItemStatus != ItemStatus.None)
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("status");
jtw.WriteValue(rom.ItemStatus.ToString().ToLowerInvariant());
}
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
if (!string.IsNullOrWhiteSpace(rom.GetField(Field.Optional, Header.ExcludeFields)))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("optional");
jtw.WriteValue(rom.Optional);
}
Add support for inverted CRC flag
2020-07-28 17:00:19 -07:00
if (!string.IsNullOrWhiteSpace(rom.GetField(Field.Inverted, Header.ExcludeFields)))
{
jtw.WritePropertyName("inverted");
jtw.WriteValue(rom.Inverted);
}
Add JSON write
2020-06-15 22:31:46 -07:00
break;
case ItemType.Sample:
jtw.WriteValue("sample");
jtw.WritePropertyName("name");
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
jtw.WriteValue(datItem.GetField(Field.Name, Header.ExcludeFields));
Add JSON write
2020-06-15 22:31:46 -07:00
break;
}
Wire up remaining AttractMode fields
2020-08-20 21:15:37 -07:00
if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.AltName, Header.ExcludeFields)))
{
jtw.WritePropertyName("alt_romname");
jtw.WriteValue(datItem.AltName);
}
if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.AltTitle, Header.ExcludeFields)))
{
jtw.WritePropertyName("alt_title");
jtw.WriteValue(datItem.AltTitle);
}
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.PartName, Header.ExcludeFields)))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("partname");
jtw.WriteValue(datItem.PartName);
}
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.PartInterface, Header.ExcludeFields)))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("partinterface");
jtw.WriteValue(datItem.PartInterface);
}
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.Features, Header.ExcludeFields)))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("features");
jtw.WriteStartArray();
foreach (var feature in datItem.Features)
{
jtw.WriteStartObject();
jtw.WritePropertyName(feature.Key);
jtw.WriteValue(feature.Value);
jtw.WriteEndObject();
}
jtw.WriteEndArray();
}
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.AreaName, Header.ExcludeFields)))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("areaname");
jtw.WriteValue(datItem.AreaName);
}
Rename Header, remove redundant setters
2020-07-27 10:26:08 -07:00
if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.AreaSize, Header.ExcludeFields)))
Add JSON write
2020-06-15 22:31:46 -07:00
{
jtw.WritePropertyName("areasize");
jtw.WriteValue(datItem.AreaSize);
}
Wire up area width, endianness for SL
2020-08-21 13:31:22 -07:00
if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.AreaWidth, Header.ExcludeFields)))
{
jtw.WritePropertyName("areawidth");
jtw.WriteValue(datItem.AreaWidth);
}
if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.AreaEndianness, Header.ExcludeFields)))
{
jtw.WritePropertyName("areaendianness");
jtw.WriteValue(datItem.AreaEndianness);
}
Wire up value and loadflag for SL
2020-08-21 14:20:17 -07:00
if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.Value, Header.ExcludeFields)))
{
jtw.WritePropertyName("value");
jtw.WriteValue(datItem.Value);
}
if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.LoadFlag, Header.ExcludeFields)))
{
jtw.WritePropertyName("loadflag");
jtw.WriteValue(datItem.LoadFlag);
}
Add JSON write
2020-06-15 22:31:46 -07:00
// End item
jtw.WriteEndObject();
jtw.Flush();
}
catch (Exception ex)
{
Globals.Logger.Error(ex.ToString());
return false;
}
return true;
}
/// <summary>
/// Write out DAT footer using the supplied StreamWriter
/// </summary>
/// <param name="jtw">JsonTextWriter to output to</param>
/// <returns>True if the data was written, false on error</returns>
private bool WriteFooter(JsonTextWriter jtw)
{
try
{
// End items
jtw.WriteEndArray();
// End machine
jtw.WriteEndObject();
// End machines
jtw.WriteEndArray();
// End file
jtw.WriteEndObject();
jtw.Flush();
}
catch (Exception ex)
{
Globals.Logger.Error(ex.ToString());
return false;
}
return true;
}
}
}
Reference in New Issue Copy Permalink