Add detailed multiplayer features, add settings to control metadata i…

…mport (#18)
sharkusmanch · Mar 20, 2022 · 1ff2eee · 1ff2eee
1 parent e553739
commit 1ff2eee
Show file tree

Hide file tree

Showing 20 changed files with 1,385 additions and 36 deletions.
diff --git a/extension.yaml b/extension.yaml
@@ -1,7 +1,7 @@
 Id: PCGamingWikiMetadata_c038558e-427b-4551-be4c-be7009ce5a8d
 Name: PCGamingWiki Metadata Provider
 Author: sharkusmanch
-Version: 0.4.0
+Version: 0.5.0
 Module: PCGamingWikiMetadata.dll
 Type: MetadataProvider
 Icon: icon.png
diff --git a/manifest.yaml b/manifest.yaml
@@ -1,5 +1,13 @@
 AddonId: PCGamingWikiMetadata_c038558e-427b-4551-be4c-be7009ce5a8d
 Packages:
+- Version: 0.5.0
+  RequiredApiVersion: 6.2.2
+  ReleaseDate: 2022-03-20
+  PackageUrl: https://github.com/sharkusmanch/playnite-pcgamingwiki-metadata-provider/releases/download/v0.5.0/PCGamingWiki_Metadata_Provider_v0.5.0.pext
+  Changelog:
+    - Add Controller Support feature.
+    - Add detailed multiplayer features (LAN, Local, Online, etc)
+    - Add settings to enable/disable importing of multiplayer features, xbox play anywhere tag, and engine tag
 - Version: 0.4.0
   RequiredApiVersion: 6.2.2
   ReleaseDate: 2022-03-01

diff --git a/src/Localization/en_US.xaml b/src/Localization/en_US.xaml
@@ -0,0 +1,8 @@
+<?xml version="1.0"?>
+<ResourceDictionary xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:sys="clr-namespace:System;assembly=mscorlib">
+
+    <sys:String x:Key="LOCPCGWSettingsImportXboxPlayAnywhere">Add Xbox Play Anywhere tag to supported titles</sys:String>
+    <sys:String x:Key="LOCPCGWSettingsImportEngineTags">Add game engine tags</sys:String>
+    <sys:String x:Key="LOCPCGWSettingsImportMultiplayerTypes">Add detailed multiplayer features</sys:String>
+
+</ResourceDictionary>
diff --git a/src/PCGWClient.cs b/src/PCGWClient.cs
@@ -14,11 +14,13 @@ public class PCGWClient
         private readonly string baseUrl = @"https://www.pcgamingwiki.com/w/api.php";
         private RestClient client;
         protected MetadataRequestOptions options;
+        protected PCGamingWikiMetadataSettings settings;
 
-        public PCGWClient(MetadataRequestOptions options)
+        public PCGWClient(MetadataRequestOptions options, PCGamingWikiMetadataSettings settings)
         {
             client = new RestClient(baseUrl);
             this.options = options;
+            this.settings = settings;
         }
 
         public JObject ExecuteRequest(RestRequest request)
@@ -107,8 +109,8 @@ public virtual void FetchGamePageContent(PCGWGame game)
                     logger.Error($"Encountered API error: {error.ToString()}");
                 }
 
-                PCGamingWikiJSONParser jsonParser = new PCGamingWikiJSONParser(content, game);
-                PCGamingWikiHTMLParser parser = new PCGamingWikiHTMLParser(jsonParser.PageHTMLText(), game);
+                PCGamingWikiJSONParser jsonParser = new PCGamingWikiJSONParser(content, game, this.settings);
+                PCGamingWikiHTMLParser parser = new PCGamingWikiHTMLParser(jsonParser.PageHTMLText(), game, this.settings);
 
                 jsonParser.ParseGameDataJson();
                 parser.ApplyGameMetadata();

diff --git a/src/PCGWGame.cs b/src/PCGWGame.cs
@@ -87,14 +87,22 @@ protected bool GetReception(string aggregator, out int? score)
             return this.reception.TryGetValue(aggregator, out score);
         }
 
-        public void AddControllerSupport(string description)
+        public void AddFullControllerSupport(string description)
         {
             if (description == PCGamingWikiType.Rating.NativeSupport)
             {
                 this.AddFeature("Full Controller Support");
             }
         }
 
+        public void AddControllerSupport(string description)
+        {
+            if (description == PCGamingWikiType.Rating.NativeSupport)
+            {
+                this.AddFeature("Controller Support");
+            }
+        }
+
         public void AddCloudSaves(string launcher, string description)
         {
             BuiltinExtension? extension = LauncherNameToPluginID(launcher);
@@ -115,6 +123,41 @@ public void AddCloudSaves(string launcher, string description)
             }
         }
 
+        private void AddMultiplayerFeatures(string featureBaseName, IList<string> types)
+        {
+            foreach (string type in types)
+            {
+                this.AddFeature($"{featureBaseName}: {type}");
+            }
+        }
+
+        public void AddMultiplayerLocal(string rating, IList<string> types)
+        {
+            if (rating == PCGamingWikiType.Rating.NativeSupport)
+            {
+                this.AddFeature("Local Multiplayer");
+                AddMultiplayerFeatures("Local Multiplayer", types);
+            }
+        }
+
+        public void AddMultiplayerLAN(string rating, IList<string> types)
+        {
+            if (rating == PCGamingWikiType.Rating.NativeSupport)
+            {
+                this.AddFeature("LAN Multiplayer");
+                AddMultiplayerFeatures("LAN Multiplayer", types);
+            }
+        }
+
+        public void AddMultiplayerOnline(string rating, IList<string> types)
+        {
+            if (rating == PCGamingWikiType.Rating.NativeSupport)
+            {
+                this.AddFeature("Online Multiplayer");
+                AddMultiplayerFeatures("Online Multiplayer", types);
+            }
+        }
+
         private BuiltinExtension? LauncherNameToPluginID(string launcher)
         {
             switch (launcher)

diff --git a/src/PCGamingWikiHTMLParser.cs b/src/PCGamingWikiHTMLParser.cs
@@ -14,19 +14,26 @@ public class PCGamingWikiHTMLParser
         private readonly ILogger logger = LogManager.GetLogger();
         private HtmlDocument doc;
         private PCGWGame game;
+        private PCGamingWikiMetadataSettings settings;
 
-        public PCGamingWikiHTMLParser(string html, PCGWGame game)
+        public PCGamingWikiHTMLParser(string html, PCGWGame game, PCGamingWikiMetadataSettings settings)
         {
             this.doc = new HtmlDocument();
             this.doc.LoadHtml(html);
             this.game = game;
+            this.settings = settings;
         }
 
         public void ApplyGameMetadata()
         {
             ParseInput();
             ParseCloudSync();
             ParseInfobox();
+
+            if (this.settings.ImportMultiplayerTypes)
+            {
+                ParseMultiplayer();
+            }
         }
 
         private void RemoveCitationsFromHTMLNode(HtmlNode node)
@@ -39,17 +46,85 @@ private void RemoveCitationsFromHTMLNode(HtmlNode node)
             }
         }
 
-        private void ParseInput()
+        private IList<HtmlNode> SelectTableRowsByClass(string tableId, string rowClass)
         {
-            var table = this.doc.DocumentNode.SelectSingleNode("//table[@id='table-settings-input']");
+            var table = this.doc.DocumentNode.SelectSingleNode($"//table[@id='{tableId}']");
 
-            if (table == null)
+            if (table != null)
             {
-                return;
+                return table.SelectNodes($"//tr[@class='{rowClass}']");
             }
 
-            var rows = table.SelectNodes("//tr[@class='template-infotable-body table-settings-input-body-row']");
+            return new List<HtmlNode>();
+        }
+
+        private void ParseMultiplayer()
+        {
+            var rows = SelectTableRowsByClass("table-network-multiplayer", "template-infotable-body table-network-multiplayer-body-row");
+            string networkType = "";
+            string rating = "";
+
+            foreach (HtmlNode row in rows)
+            {
+                foreach (HtmlNode child in row.SelectNodes(".//th|td"))
+                {
+                    switch (child.Attributes["class"].Value)
+                    {
+                        case "table-network-multiplayer-body-parameter":
+                            networkType = child.FirstChild.InnerText;
+                            break;
+                        case "table-network-multiplayer-body-rating":
+                            rating = child.FirstChild.Attributes["title"].Value;
+                            break;
+                        case "table-network-multiplayer-body-notes":
+                            IList<string> notes = ParseMultiplayerNotes(child);
+
+                            switch (networkType)
+                            {
+                                case "Local play":
+                                    this.game.AddMultiplayerLocal(rating, notes);
+                                    break;
+                                case "LAN play":
+                                    this.game.AddMultiplayerLAN(rating, notes);
+                                    break;
+                                case "Online play":
+                                    this.game.AddMultiplayerOnline(rating, notes);
+                                    break;
+                                default:
+                                    break;
 
+                            }
+                            rating = "";
+                            networkType = "";
+                            break;
+                    }
+                }
+            }
+        }
+
+        private IList<string> ParseMultiplayerNotes(HtmlNode notes)
+        {
+            List<string> multiplayerTypes = new List<string>();
+
+            Regex pattern = new Regex(@"class=""table-network-multiplayer-body-notes"">(?<mode1>(Co-op|Versus))?(,)?(&#32;)?(?<mode2>(Co-op|Versus))?<br>");
+            Match match = pattern.Match(notes.OuterHtml);
+
+            if (match.Groups["mode1"].Success)
+            {
+                multiplayerTypes.Add(match.Groups["mode1"].Value);
+            }
+
+            if (match.Groups["mode2"].Success)
+            {
+                multiplayerTypes.Add(match.Groups["mode2"].Value);
+            }
+
+            return multiplayerTypes;
+        }
+
+        private void ParseInput()
+        {
+            var rows = SelectTableRowsByClass("table-settings-input", "template-infotable-body table-settings-input-body-row");
             string param = "";
 
             foreach (HtmlNode row in rows)
@@ -65,6 +140,9 @@ private void ParseInput()
                             switch (param)
                             {
                                 case "Full controller support":
+                                    this.game.AddFullControllerSupport(child.FirstChild.Attributes["title"].Value);
+                                    break;
+                                case "Controller support":
                                     this.game.AddControllerSupport(child.FirstChild.Attributes["title"].Value);
                                     break;
                                 default:
@@ -80,15 +158,7 @@ private void ParseInput()
 
         private void ParseCloudSync()
         {
-            var table = this.doc.DocumentNode.SelectSingleNode("//table[@id='table-cloudsync']");
-
-            if (table == null)
-            {
-                return;
-            }
-
-            var rows = table.SelectNodes("//tr[@class='template-infotable-body table-cloudsync-body-row']");
-
+            var rows = SelectTableRowsByClass("table-cloudsync", "template-infotable-body table-cloudsync-body-row");
             string launcher = "";
 
             foreach (HtmlNode row in rows)
@@ -156,7 +226,10 @@ private void ParseInfobox()
                                             ApplyReleaseDate(key, text);
                                             break;
                                         case "Engines":
-                                            this.game.AddTaxonomy("Engines", text);
+                                            if (this.settings.ImportEngineTags)
+                                            {
+                                                this.game.AddTaxonomy("Engines", text);
+                                            }
                                             break;
                                         case "Developers":
                                             AddCompany(child, this.game.Developers);

diff --git a/src/PCGamingWikiJSONParser.cs b/src/PCGamingWikiJSONParser.cs
@@ -6,10 +6,13 @@ public class PCGamingWikiJSONParser
     {
         private PCGWGame game;
         private JObject content;
-        public PCGamingWikiJSONParser(JObject content, PCGWGame game)
+        private PCGamingWikiMetadataSettings settings;
+
+        public PCGamingWikiJSONParser(JObject content, PCGWGame game, PCGamingWikiMetadataSettings settings)
         {
             this.content = content;
             this.game = game;
+            this.settings = settings;
         }
 
         public void ParseGameDataJson()
@@ -24,7 +27,7 @@ public void ParseGameDataJson()
 
             JToken playAnywhere = this.content.SelectToken("$.parse.links[?(@.* == 'List of Xbox Play Anywhere games')]");
 
-            if (playAnywhere != null)
+            if (playAnywhere != null && this.settings.ImportXboxPlayAnywhere)
             {
                 game.SetXboxPlayAnywhere();
             }

diff --git a/src/PCGamingWikiMetadata.csproj b/src/PCGamingWikiMetadata.csproj
@@ -29,4 +29,12 @@
       <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
     </None>
   </ItemGroup>
+
+  <ItemGroup>
+    <Content Include="Localization/*.xaml">
+      <Generator>MSBuild:Compile</Generator>
+      <SubType>Designer</SubType>
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </Content>
+  </ItemGroup>
 </Project>
diff --git a/src/PCGamingWikiMetadataProvider.cs b/src/PCGamingWikiMetadataProvider.cs
@@ -109,7 +109,7 @@ public PCGamingWikiMetadataProvider(MetadataRequestOptions options, PCGamingWiki
         {
             this.options = options;
             this.plugin = plugin;
-            this.client = new PCGWClient(this.options);
+            this.client = new PCGWClient(this.options, (PCGamingWikiMetadataSettings)this.plugin.GetSettings(false));
         }
 
         public override string GetName(GetMetadataFieldArgs args)

diff --git a/src/PCGamingWikiMetadataSettings.cs b/src/PCGamingWikiMetadataSettings.cs
@@ -5,13 +5,32 @@
 using System.Linq;
 using System.Text;
 using System.Threading.Tasks;
+using System.ComponentModel;
 
 namespace PCGamingWikiMetadata
 {
-    public class PCGamingWikiMetadataSettings : ISettings
+    public class PCGamingWikiMetadataSettings : ISettings, INotifyPropertyChanged
     {
         private readonly PCGamingWikiMetadata plugin;
 
+        public event PropertyChangedEventHandler PropertyChanged;
+        private void NotifyPropertyChanged(string propertyName)
+        {
+            if (PropertyChanged != null)
+            {
+                PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
+            }
+        }
+
+        private bool importEngineTags = true;
+        public bool ImportEngineTags { get { return importEngineTags; } set { importEngineTags = value; ; NotifyPropertyChanged("ImportEngineTags"); } }
+        private bool importXboxPlayAnywhere = true;
+        public bool ImportXboxPlayAnywhere { get { return importXboxPlayAnywhere; } set { importXboxPlayAnywhere = value; ; NotifyPropertyChanged("ImportXboxPlayAnywhere"); } }
+
+        private bool importMultiplayerTypes = false;
+        public bool ImportMultiplayerTypes { get { return importMultiplayerTypes; } set { importMultiplayerTypes = value; ; NotifyPropertyChanged("ImportMultiplayerTypes"); } }
+
+
         // Parameterless constructor must exist if you want to use LoadPluginSettings method.
         public PCGamingWikiMetadataSettings()
         {
@@ -28,7 +47,9 @@ public PCGamingWikiMetadataSettings(PCGamingWikiMetadata plugin)
             // LoadPluginSettings returns null if not saved data is available.
             if (savedSettings != null)
             {
-                // empty for now
+                ImportEngineTags = savedSettings.ImportEngineTags;
+                ImportXboxPlayAnywhere = savedSettings.ImportXboxPlayAnywhere;
+                ImportMultiplayerTypes = savedSettings.ImportMultiplayerTypes;
             }
         }
 

diff --git a/src/PCGamingWikiMetadataSettingsView.xaml b/src/PCGamingWikiMetadataSettingsView.xaml
@@ -6,6 +6,16 @@
              mc:Ignorable="d"
              d:DesignHeight="400" d:DesignWidth="600">
     <StackPanel>
-        <TextBlock Text="No settings currently available"/>
+        <StackPanel Margin="15">
+            <CheckBox IsChecked="{Binding ImportEngineTags}" Content="{DynamicResource LOCPCGWSettingsImportEngineTags}"/>
+        </StackPanel>
+
+        <StackPanel Margin="15">
+            <CheckBox IsChecked="{Binding ImportXboxPlayAnywhere}" Content="{DynamicResource LOCPCGWSettingsImportXboxPlayAnywhere}"/>
+        </StackPanel>
+
+        <StackPanel Margin="15">
+            <CheckBox IsChecked="{Binding ImportMultiplayerTypes}" Content="{DynamicResource LOCPCGWSettingsImportMultiplayerTypes}"/>
+        </StackPanel>
     </StackPanel>
 </UserControl>