Wire up Logiqx TruRip/EmuArc fields

SabreTools.Library/DatFiles/Json.cs

@@ -451,7 +451,8 @@ namespace SabreTools.Library.DatFiles
 
                 switch (jtr.Value)
                 {
-                    // Common
+                    #region Common
+
                     case "name":
                         machine.Name = jtr.ReadAsString();
                         break;
@@ -504,7 +505,10 @@ namespace SabreTools.Library.DatFiles
                         ReadItems(sr, jtr, filename, indexId, machine);
                         break;
 
-                    // AttractMode
+                    #endregion
+
+                    #region AttractMode
+
                     case "players":
                         machine.Players = jtr.ReadAsString();
                         break;
@@ -527,7 +531,10 @@ namespace SabreTools.Library.DatFiles
                         machine.Buttons = jtr.ReadAsString();
                         break;
 
-                    // ListXML
+                    #endregion
+
+                    #region ListXML
+
                     case "sourcefile":
                         machine.SourceFile = jtr.ReadAsString();
                         break;
@@ -571,7 +578,10 @@ namespace SabreTools.Library.DatFiles
 
                         break;
 
-                    // Logiqx
+                    #endregion
+
+                    #region Logiqx
+
                     case "board":
                         machine.Board = jtr.ReadAsString();
                         break;
@@ -579,11 +589,48 @@ namespace SabreTools.Library.DatFiles
                         machine.RebuildTo = jtr.ReadAsString();
                         break;
 
-                    // SoftwareList
+                    #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
+
                     case "supported":
                         machine.Supported = jtr.ReadAsString().AsYesNo();
                         break;
 
+                    #endregion
+
                     default:
                         break;
                 }
@@ -1382,7 +1429,8 @@ namespace SabreTools.Library.DatFiles
                 // Build the state based on excluded fields
                 jtw.WriteStartObject();
 
-                // Common
+                #region Common
+
                 jtw.WritePropertyName("name");
                 jtw.WriteValue(datItem.GetField(Field.MachineName, Header.ExcludeFields));
 
@@ -1450,7 +1498,10 @@ namespace SabreTools.Library.DatFiles
                     }
                 }
 
-                // AttractMode
+                #endregion
+
+                #region AttractMode
+
                 if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.Players, Header.ExcludeFields)))
                 {
                     jtw.WritePropertyName("players");
@@ -1487,7 +1538,10 @@ namespace SabreTools.Library.DatFiles
                     jtw.WriteValue(datItem.Machine.Buttons);
                 }
 
-                // ListXML
+                #endregion
+
+                #region ListXML
+
                 if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.SourceFile, Header.ExcludeFields)))
                 {
                     jtw.WritePropertyName("sourcefile");
@@ -1543,7 +1597,10 @@ namespace SabreTools.Library.DatFiles
                     jtw.WriteEndArray();
                 }
 
-                // Logiqx
+                #endregion
+
+                #region Logiqx
+
                 if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.Board, Header.ExcludeFields)))
                 {
                     jtw.WritePropertyName("board");
@@ -1555,7 +1612,68 @@ namespace SabreTools.Library.DatFiles
                     jtw.WriteValue(datItem.Machine.RebuildTo);
                 }
 
-                // SoftwareList
+                #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
+
                 if (!Header.ExcludeFields.Contains(Field.Supported) && datItem.Machine.Supported != null)
                 {
                     if (datItem.Machine.Supported == true)
@@ -1570,6 +1688,8 @@ namespace SabreTools.Library.DatFiles
                     }
                 }
 
+                #endregion
+
                 jtw.WritePropertyName("items");
                 jtw.WriteStartArray();
 

SabreTools.Library/DatFiles/Logiqx.cs

@@ -367,7 +367,7 @@ namespace SabreTools.Library.DatFiles
                         machine.Category = reader.ReadElementContentAsString();
                         break;
 
-                    case "trurip": // This is special metadata unique to TruRip
+                    case "trurip": // This is special metadata unique to EmuArc
                         ReadTruRip(reader.ReadSubtree(), machine);
 
                         // Skip the trurip node now that we've processed it
@@ -556,7 +556,7 @@ namespace SabreTools.Library.DatFiles
         }
 
         /// <summary>
-        /// Read TruRip information
+        /// Read EmuArc information
         /// </summary>
         /// <param name="keep">True if full pathnames are to be kept, false otherwise (default)</param>
         /// <param name="machine">Machine information to pass to contained items</param>
@@ -582,15 +582,15 @@ namespace SabreTools.Library.DatFiles
                 switch (reader.Name)
                 {
                     case "titleid":
-                        reader.ReadElementContentAsString();
+                        machine.TitleID = reader.ReadElementContentAsString();
                         break;
 
                     case "publisher":
                         machine.Publisher = reader.ReadElementContentAsString();
                         break;
 
-                    case "developer": // Manufacturer is as close as this gets
+                    case "developer":
-                        machine.Manufacturer = reader.ReadElementContentAsString();
+                        machine.Developer = reader.ReadElementContentAsString();
                         break;
 
                     case "year":
@@ -598,31 +598,31 @@ namespace SabreTools.Library.DatFiles
                         break;
 
                     case "genre":
-                        machine.Category = reader.ReadElementContentAsString();
+                        machine.Genre = reader.ReadElementContentAsString();
                         break;
 
                     case "subgenre":
-                        reader.ReadElementContentAsString();
+                        machine.Subgenre = reader.ReadElementContentAsString();
                         break;
 
                     case "ratings":
-                        reader.ReadElementContentAsString();
+                        machine.Ratings = reader.ReadElementContentAsString();
                         break;
 
                     case "score":
-                        reader.ReadElementContentAsString();
+                        machine.Score = reader.ReadElementContentAsString();
                         break;
 
                     case "players":
-                        reader.ReadElementContentAsString();
+                        machine.Players = reader.ReadElementContentAsString();
                         break;
 
                     case "enabled":
-                        reader.ReadElementContentAsString();
+                        machine.Enabled = reader.ReadElementContentAsString();
                         break;
 
                     case "crc":
-                        reader.ReadElementContentAsString().AsYesNo();
+                        machine.HasCrc = reader.ReadElementContentAsString().AsYesNo();
                         break;
 
                     case "source":
@@ -634,7 +634,7 @@ namespace SabreTools.Library.DatFiles
                         break;
 
                     case "relatedto":
-                        reader.ReadElementContentAsString();
+                        machine.RelatedTo = reader.ReadElementContentAsString();
                         break;
 
                     default:
@@ -1008,6 +1008,58 @@ namespace SabreTools.Library.DatFiles
                 if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.Category, Header.ExcludeFields)))
                     xtw.WriteElementString("category", datItem.Machine.Category);
 
+                if (datItem.Machine.TitleID != null
+                    || datItem.Machine.Developer != null
+                    || datItem.Machine.Genre != null
+                    || datItem.Machine.Subgenre != null
+                    || datItem.Machine.Ratings != null
+                    || datItem.Machine.Score != null
+                    || datItem.Machine.Enabled != null
+                    || datItem.Machine.HasCrc != null
+                    || datItem.Machine.RelatedTo != null)
+                {
+                    xtw.WriteStartElement("trurip");
+
+                    if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.TitleID, Header.ExcludeFields)))
+                        xtw.WriteElementString("titleid", datItem.Machine.TitleID);
+                    if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.Publisher, Header.ExcludeFields)))
+                        xtw.WriteElementString("publisher", datItem.Machine.Publisher);
+                    if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.Developer, Header.ExcludeFields)))
+                        xtw.WriteElementString("developer", datItem.Machine.Developer);
+                    if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.Year, Header.ExcludeFields)))
+                        xtw.WriteElementString("year", datItem.Machine.Year);
+                    if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.Genre, Header.ExcludeFields)))
+                        xtw.WriteElementString("genre", datItem.Machine.Genre);
+                    if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.Subgenre, Header.ExcludeFields)))
+                        xtw.WriteElementString("subgenre", datItem.Machine.Subgenre);
+                    if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.Ratings, Header.ExcludeFields)))
+                        xtw.WriteElementString("ratings", datItem.Machine.Ratings);
+                    if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.Score, Header.ExcludeFields)))
+                        xtw.WriteElementString("score", datItem.Machine.Score);
+                    if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.Players, Header.ExcludeFields)))
+                        xtw.WriteElementString("players", datItem.Machine.Players);
+                    if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.Enabled, Header.ExcludeFields)))
+                        xtw.WriteElementString("enabled", datItem.Machine.Enabled);
+                    if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.TitleID, Header.ExcludeFields)))
+                        xtw.WriteElementString("titleid", datItem.Machine.TitleID);
+                    if (!Header.ExcludeFields.Contains(Field.HasCrc) && datItem.Machine.HasCrc != null)
+                    {
+                        if (datItem.Machine.HasCrc == true)
+                            xtw.WriteElementString("crc", "yes");
+                        else if (datItem.Machine.HasCrc == false)
+                            xtw.WriteElementString("crc", "no");
+                    }
+                    if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.SourceFile, Header.ExcludeFields)))
+                        xtw.WriteElementString("source", datItem.Machine.SourceFile);
+                    if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.CloneOf, Header.ExcludeFields)))
+                        xtw.WriteElementString("cloneof", datItem.Machine.CloneOf);
+                    if (!string.IsNullOrWhiteSpace(datItem.GetField(Field.RelatedTo, Header.ExcludeFields)))
+                        xtw.WriteElementString("relatedto", datItem.Machine.RelatedTo);
+
+                    // End trurip
+                    xtw.WriteEndElement();
+                }
+
                 xtw.Flush();
             }
             catch (Exception ex)

SabreTools.Library/DatFiles/SeparatedValue.cs

@@ -415,6 +415,46 @@ namespace SabreTools.Library.DatFiles
 
                         #endregion
 
+                        #region Logiqx EmuArc
+
+                        case "Machine.TitleID":
+                            machine.TitleID = value;
+                            break;
+
+                        case "Machine.Developer":
+                            machine.Developer = value;
+                            break;
+
+                        case "Machine.Genre":
+                            machine.Genre = value;
+                            break;
+
+                        case "Machine.Subgenre":
+                            machine.Subgenre = value;
+                            break;
+
+                        case "Machine.Ratings":
+                            machine.Ratings = value;
+                            break;
+
+                        case "Machine.Score":
+                            machine.Score = value;
+                            break;
+
+                        case "Machine.Enabled":
+                            machine.Enabled = value;
+                            break;
+
+                        case "Machine.HasCrc":
+                            machine.HasCrc = value.AsYesNo();
+                            break;
+
+                        case "Machine.RelatedTo":
+                            machine.RelatedTo = value;
+                            break;
+
+                        #endregion
+
                         #region SoftwareList
 
                         case "Machine.Supported":
@@ -1089,6 +1129,43 @@ namespace SabreTools.Library.DatFiles
 
                 #endregion
 
+                #region Logiqx EmuArc
+
+                case "titleid":
+                case "title id":
+                case "title-id":
+                    return "Machine.TitleID";
+
+                case "developer":
+                    return "Machine.Developer";
+
+                case "genre":
+                    return "Machine.Genre";
+
+                case "subgenre":
+                    return "Machine.Subgenre";
+
+                case "ratings":
+                    return "Machine.Ratings";
+
+                case "score":
+                    return "Machine.Score";
+
+                case "enabled":
+                    return "Machine.Enabled";
+
+                case "hascrc":
+                case "has crc":
+                case "has-crc":
+                    return "Machine.HasCrc";
+
+                case "relatedto":
+                case "related to":
+                case "related-to":
+                    return "Machine.RelatedTo";
+
+                #endregion
+
                 #region SoftwareList
 
                 case "supported":

SabreTools.Library/DatItems/DatItem.cs

@@ -209,6 +209,17 @@ namespace SabreTools.Library.DatItems
             Field.Board,
             Field.RebuildTo,
 
+            // Logiqx EmuArc
+            Field.TitleID,
+            Field.Developer,
+            Field.Genre,
+            Field.Subgenre,
+            Field.Ratings,
+            Field.Score,
+            Field.Enabled,
+            Field.HasCrc,
+            Field.RelatedTo,
+
             // SoftwareList
             Field.Supported,
         };

SabreTools.Library/DatItems/Enums.cs

@@ -28,7 +28,8 @@ namespace SabreTools.Library.DatItems
 
         #region Machine
 
-        // Common Machine
+        #region Common
+
         MachineName,
         Comment,
         Description,
@@ -41,7 +42,10 @@ namespace SabreTools.Library.DatItems
         SampleOf,
         MachineType,
 
-        // AttractMode Machine
+        #endregion
+
+        #region AttractMode
+
         Players,
         Rotation,
         Control,
@@ -50,39 +54,73 @@ namespace SabreTools.Library.DatItems
         DisplayType,
         Buttons,
 
-        // ListXML Machine
+        #endregion
+
+        #region ListXML
+
         SourceFile,
         Runnable,
         Devices,
         SlotOptions,
         Infos,
 
-        // Logiqx Machine
+        #endregion
+
+        #region Logiqx
+
         Board,
         RebuildTo,
 
-        // SoftwareList Machine
+        #endregion
+
+        #region Logiqx EmuArc
+
+        TitleID,
+        Developer,
+        Genre,
+        Subgenre,
+        Ratings,
+        Score,
+        Enabled,
+        HasCrc,
+        RelatedTo,
+
+        #endregion
+
+        #region SoftwareList
+
         Supported,
 
         #endregion
 
+        #endregion // Machine
+
         #region DatItem
 
-        // Common DatItem
+        #region Common
+
         Name,
         ItemType,
 
-        // AttractMode DatItem
+        #endregion
+
+        #region AttractMode
+
         AltName,
         AltTitle,
 
-        // SoftwareList DatItem
+        #endregion
+
+        #region SoftwareList
+
         PartName,
         PartInterface,
         Features,
         AreaName,
         AreaSize,
 
+        #endregion
+
         // BiosSet
         Default,
         BiosDescription,
@@ -114,7 +152,7 @@ namespace SabreTools.Library.DatItems
         Offset,
         Inverted,
 
-        #endregion
+        #endregion // DatItem
     }
 
     /// <summary>

SabreTools.Library/DatItems/Machine.cs

@@ -90,6 +90,7 @@ namespace SabreTools.Library.DatItems
         /// <summary>
         /// Player count
         /// </summary>
+        /// <remarks>Also in Logiqx EmuArc</remarks>
         [JsonProperty("players")]
         public string Players { get; set; } = null;
 
@@ -184,6 +185,64 @@ namespace SabreTools.Library.DatItems
 
         #endregion
 
+        #region Logiqx EmuArc Fields
+
+        /// <summary>
+        /// Title ID
+        /// </summary>
+        [JsonProperty("titleid")]
+        public string TitleID { get; set; } = null;
+
+        /// <summary>
+        /// Machine developer
+        /// </summary>
+        [JsonProperty("developer")]
+        public string Developer { get; set; } = null;
+
+        /// <summary>
+        /// Game genre
+        /// </summary>
+        [JsonProperty("genre")]
+        public string Genre { get; set; } = null;
+
+        /// <summary>
+        /// Game subgenre
+        /// </summary>
+        [JsonProperty("genre")]
+        public string Subgenre { get; set; } = null;
+
+        /// <summary>
+        /// Game ratings
+        /// </summary>
+        [JsonProperty("ratings")]
+        public string Ratings { get; set; } = null;
+
+        /// <summary>
+        /// Game score
+        /// </summary>
+        [JsonProperty("score")]
+        public string Score { get; set; } = null;
+
+        /// <summary>
+        /// Is the machine enabled
+        /// </summary>
+        [JsonProperty("enabled")]
+        public string Enabled { get; set; } = null; // bool?
+
+        /// <summary>
+        /// Does the game have a CRC check
+        /// </summary>
+        [JsonProperty("hascrc")]
+        public bool? HasCrc { get; set; } = null;
+
+        /// <summary>
+        /// Machine relations
+        /// </summary>
+        [JsonProperty("relatedto")]
+        public string RelatedTo { get; set; } = null;
+
+        #endregion
+
         #region SoftwareList Fields
 
         /// <summary>
@@ -211,7 +270,8 @@ namespace SabreTools.Library.DatItems
             string fieldValue = null;
             switch (field)
             {
-                // Common
+                #region Common
+
                 case Field.MachineName:
                     fieldValue = Name;
                     break;
@@ -246,7 +306,10 @@ namespace SabreTools.Library.DatItems
                     fieldValue = MachineType.ToString();
                     break;
 
-                // AttractMode
+                #endregion
+
+                #region AttractMode
+
                 case Field.Players:
                     fieldValue = Players;
                     break;
@@ -269,7 +332,10 @@ namespace SabreTools.Library.DatItems
                     fieldValue = Buttons;
                     break;
 
-                // ListXML
+                #endregion
+
+                #region ListXML
+
                 case Field.SourceFile:
                     fieldValue = SourceFile;
                     break;
@@ -286,7 +352,10 @@ namespace SabreTools.Library.DatItems
                     fieldValue = string.Join(";", (Infos ?? new List<KeyValuePair<string, string>>()).Select(i => $"{i.Key}={i.Value}"));
                     break;
 
-                // Logiqx
+                #endregion
+
+                #region Logiqx
+
                 case Field.Board:
                     fieldValue = Board;
                     break;
@@ -294,11 +363,48 @@ namespace SabreTools.Library.DatItems
                     fieldValue = RebuildTo;
                     break;
 
-                // SoftwareList
+                #endregion
+
+                #region Logiqx EmuArc
+
+                case Field.TitleID:
+                    fieldValue = TitleID;
+                    break;
+                case Field.Developer:
+                    fieldValue = Developer;
+                    break;
+                case Field.Genre:
+                    fieldValue = Genre;
+                    break;
+                case Field.Subgenre:
+                    fieldValue = Subgenre;
+                    break;
+                case Field.Ratings:
+                    fieldValue = Ratings;
+                    break;
+                case Field.Score:
+                    fieldValue = Score;
+                    break;
+                case Field.Enabled:
+                    fieldValue = Enabled;
+                    break;
+                case Field.HasCrc:
+                    fieldValue = HasCrc.ToString();
+                    break;
+                case Field.RelatedTo:
+                    fieldValue = RelatedTo;
+                    break;
+
+                #endregion
+
+                #region SoftwareList
+
                 case Field.Supported:
                     fieldValue = Supported?.ToString();
                     break;
 
+                #endregion
+
                 default:
                     return null;
             }
@@ -329,24 +435,7 @@ namespace SabreTools.Library.DatItems
         public Machine(string name, string description)
         {
             Name = name;
-            Comment = null;
             Description = description;
-            Year = null;
-            Manufacturer = null;
-            Publisher = null;
-            Category = null;
-            RomOf = null;
-            CloneOf = null;
-            SampleOf = null;
-            Supported = true;
-            SourceFile = null;
-            Runnable = null;
-            Board = null;
-            RebuildTo = null;
-            Devices = null;
-            SlotOptions = null;
-            Infos = null;
-            MachineType = MachineType.NULL;
         }
 
         #endregion
@@ -406,6 +495,20 @@ namespace SabreTools.Library.DatItems
 
                 #endregion
 
+                #region Logiqx EmuArc
+
+                TitleID = this.TitleID,
+                Developer = this.Developer,
+                Genre = this.Genre,
+                Subgenre = this.Subgenre,
+                Ratings = this.Ratings,
+                Score = this.Score,
+                Enabled = this.Enabled,
+                HasCrc = this.HasCrc,
+                RelatedTo = this.RelatedTo,
+
+                #endregion
+
                 #region SoftwareList
 
                 Supported = this.Supported,
@@ -614,6 +717,62 @@ namespace SabreTools.Library.DatItems
 
             #endregion
 
+            #region Logiqx EmuArc
+
+            // Filter on title ID
+            if (filter.TitleID.MatchesPositiveSet(TitleID) == false)
+                return false;
+            if (filter.TitleID.MatchesNegativeSet(TitleID) == true)
+                return false;
+
+            // Filter on developer
+            if (filter.Developer.MatchesPositiveSet(Developer) == false)
+                return false;
+            if (filter.Developer.MatchesNegativeSet(Developer) == true)
+                return false;
+
+            // Filter on genre
+            if (filter.Genre.MatchesPositiveSet(Genre) == false)
+                return false;
+            if (filter.Genre.MatchesNegativeSet(Genre) == true)
+                return false;
+
+            // Filter on rebuildto
+            if (filter.Subgenre.MatchesPositiveSet(Subgenre) == false)
+                return false;
+            if (filter.Subgenre.MatchesNegativeSet(Subgenre) == true)
+                return false;
+
+            // Filter on subgenre
+            if (filter.Ratings.MatchesPositiveSet(Ratings) == false)
+                return false;
+            if (filter.Ratings.MatchesNegativeSet(Ratings) == true)
+                return false;
+
+            // Filter on score
+            if (filter.Score.MatchesPositiveSet(Score) == false)
+                return false;
+            if (filter.Score.MatchesNegativeSet(Score) == true)
+                return false;
+
+            // Filter on enabled
+            if (filter.Enabled.MatchesPositiveSet(Enabled) == false)
+                return false;
+            if (filter.Enabled.MatchesNegativeSet(Enabled) == true)
+                return false;
+
+            // Filter on has CRC flag
+            if (filter.HasCrc.MatchesNeutral(null, HasCrc) == false)
+                return false;
+
+            // Filter on related to
+            if (filter.RelatedTo.MatchesPositiveSet(RelatedTo) == false)
+                return false;
+            if (filter.RelatedTo.MatchesNegativeSet(RelatedTo) == true)
+                return false;
+
+            #endregion
+
             #region SoftwareList
 
             // Filter on supported
@@ -722,6 +881,37 @@ namespace SabreTools.Library.DatItems
 
             #endregion
 
+            #region Logiqx EmuArc
+
+            if (fields.Contains(Field.TitleID))
+                TitleID = null;
+
+            if (fields.Contains(Field.Developer))
+                Developer = null;
+
+            if (fields.Contains(Field.Genre))
+                Genre = null;
+
+            if (fields.Contains(Field.Subgenre))
+                Subgenre = null;
+
+            if (fields.Contains(Field.Ratings))
+                Ratings = null;
+
+            if (fields.Contains(Field.Score))
+                Score = null;
+
+            if (fields.Contains(Field.Enabled))
+                Enabled = null;
+
+            if (fields.Contains(Field.HasCrc))
+                HasCrc = null;
+
+            if (fields.Contains(Field.RelatedTo))
+                RelatedTo = null;
+
+            #endregion
+
             #region SoftwareList
 
             if (fields.Contains(Field.Supported))
@@ -836,6 +1026,37 @@ namespace SabreTools.Library.DatItems
 
             #endregion
 
+            #region Logiqx EmuArc
+
+            if (fields.Contains(Field.TitleID))
+                TitleID = machine.TitleID;
+
+            if (fields.Contains(Field.Developer))
+                Developer = machine.Developer;
+
+            if (fields.Contains(Field.Genre))
+                Genre = machine.Genre;
+
+            if (fields.Contains(Field.Subgenre))
+                Subgenre = machine.Subgenre;
+
+            if (fields.Contains(Field.Ratings))
+                Ratings = machine.Ratings;
+
+            if (fields.Contains(Field.Score))
+                Score = machine.Score;
+
+            if (fields.Contains(Field.Enabled))
+                Enabled = machine.Enabled;
+
+            if (fields.Contains(Field.HasCrc))
+                HasCrc = machine.HasCrc;
+
+            if (fields.Contains(Field.RelatedTo))
+                RelatedTo = machine.RelatedTo;
+
+            #endregion
+
             #region SoftwareList
 
             if (fields.Contains(Field.Supported))

SabreTools.Library/Filtering/Filter.cs

@@ -156,6 +156,55 @@ namespace SabreTools.Library.Filtering
 
         #endregion
 
+        #region Logiqx EmuArc
+
+        /// <summary>
+        /// Include or exclude machine title ID
+        /// </summary>
+        public FilterItem<string> TitleID { get; private set; } = new FilterItem<string>();
+
+        /// <summary>
+        /// Include or exclude machine developer
+        /// </summary>
+        public FilterItem<string> Developer { get; private set; } = new FilterItem<string>();
+
+        /// <summary>
+        /// Include or exclude machine genre
+        /// </summary>
+        public FilterItem<string> Genre { get; private set; } = new FilterItem<string>();
+
+        /// <summary>
+        /// Include or exclude machine subgenre
+        /// </summary>
+        public FilterItem<string> Subgenre { get; private set; } = new FilterItem<string>();
+
+        /// <summary>
+        /// Include or exclude machine ratings
+        /// </summary>
+        public FilterItem<string> Ratings { get; private set; } = new FilterItem<string>();
+
+        /// <summary>
+        /// Include or exclude machine score
+        /// </summary>
+        public FilterItem<string> Score { get; private set; } = new FilterItem<string>();
+
+        /// <summary>
+        /// Include or exclude machine enabled
+        /// </summary>
+        public FilterItem<string> Enabled { get; private set; } = new FilterItem<string>();
+
+        /// <summary>
+        /// Include or exclude items with the "crc" tag
+        /// </summary>
+        public FilterItem<bool?> HasCrc { get; private set; } = new FilterItem<bool?>() { Neutral = null };
+
+        /// <summary>
+        /// Include or exclude machine related to
+        /// </summary>
+        public FilterItem<string> RelatedTo { get; private set; } = new FilterItem<string>();
+
+        #endregion
+
         #region SoftwareList
 
         /// <summary>
@@ -624,6 +673,73 @@ namespace SabreTools.Library.Filtering
 
                 #endregion
 
+                #region Logiqx EmuArc
+
+                case Field.TitleID:
+                    if (negate)
+                        TitleID.NegativeSet.Add(value);
+                    else
+                        TitleID.PositiveSet.Add(value);
+                    break;
+
+                case Field.Developer:
+                    if (negate)
+                        Developer.NegativeSet.Add(value);
+                    else
+                        Developer.PositiveSet.Add(value);
+                    break;
+
+                case Field.Genre:
+                    if (negate)
+                        Genre.NegativeSet.Add(value);
+                    else
+                        Genre.PositiveSet.Add(value);
+                    break;
+
+                case Field.Subgenre:
+                    if (negate)
+                        Subgenre.NegativeSet.Add(value);
+                    else
+                        Subgenre.PositiveSet.Add(value);
+                    break;
+
+                case Field.Ratings:
+                    if (negate)
+                        Ratings.NegativeSet.Add(value);
+                    else
+                        Ratings.PositiveSet.Add(value);
+                    break;
+
+                case Field.Score:
+                    if (negate)
+                        Score.NegativeSet.Add(value);
+                    else
+                        Score.PositiveSet.Add(value);
+                    break;
+
+                case Field.Enabled:
+                    if (negate)
+                        Enabled.NegativeSet.Add(value);
+                    else
+                        Enabled.PositiveSet.Add(value);
+                    break;
+
+                case Field.HasCrc:
+                    if (negate || value.Equals("false", StringComparison.OrdinalIgnoreCase))
+                        HasCrc.Neutral = false;
+                    else
+                        HasCrc.Neutral = true;
+                    break;
+
+                case Field.RelatedTo:
+                    if (negate)
+                        RelatedTo.NegativeSet.Add(value);
+                    else
+                        RelatedTo.PositiveSet.Add(value);
+                    break;
+
+                #endregion
+
                 #region SoftwareList
 
                 case Field.Supported:

SabreTools.Library/Tools/Converters.cs

@@ -256,6 +256,43 @@ namespace SabreTools.Library.Tools
 
                 #endregion
 
+                #region Logiqx EmuArc
+
+                case "titleid":
+                case "title id":
+                case "title-id":
+                    return Field.TitleID;
+
+                case "developer":
+                    return Field.Developer;
+
+                case "genre":
+                    return Field.Genre;
+
+                case "subgenre":
+                    return Field.Subgenre;
+
+                case "ratings":
+                    return Field.Ratings;
+
+                case "score":
+                    return Field.Score;
+
+                case "enabled":
+                    return Field.Enabled;
+
+                case "hascrc":
+                case "has crc":
+                case "has-crc":
+                    return Field.HasCrc;
+
+                case "relatedto":
+                case "related to":
+                case "related-to":
+                    return Field.RelatedTo;
+
+                #endregion
+
                 #region SoftwareList
 
                 case "supported":