Fixes: Issue #1 and Issue #2

spektor56 · spektor56 · commit 739b913b6e47 · 2020-02-23T01:53:57.000-05:00
diff --git a/RAWGMetadata/Model/GameOption.cs b/RAWGMetadata/Model/GameOption.cs
@@ -0,0 +1,25 @@
+﻿using Playnite.SDK;
+using Rawg.Model;
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace RAWGMetadata.Model
+{
+    public class GameOption : GenericItemOption
+    {
+        public Game Game { get; private set; }
+
+        public GameOption(Game game)
+        {
+            this.Game = game;
+            this.Description = game.Slug;
+            this.Name = game.Name;
+        }
+        
+        
+
+    }
+}
diff --git a/RAWGMetadata/RAWGMetadata.csproj b/RAWGMetadata/RAWGMetadata.csproj
@@ -18,7 +18,7 @@
     <DebugSymbols>true</DebugSymbols>
     <DebugType>full</DebugType>
     <Optimize>false</Optimize>
-    <OutputPath>..\..\..\..\..\AppData\Local\Playnite\Extensions\RAWGMetadata\</OutputPath>
+    <OutputPath>..\..\..\..\AppData\Local\Playnite\Extensions\RawgMetadata\</OutputPath>
     <DefineConstants>DEBUG;TRACE</DefineConstants>
     <ErrorReport>prompt</ErrorReport>
     <WarningLevel>4</WarningLevel>
@@ -62,6 +62,7 @@
       <Generator>MSBuild:Compile</Generator>
     </Page>
     <Compile Include="Extensions\StringExtensions.cs" />
+    <Compile Include="Model\GameOption.cs" />
     <Compile Include="RawgLazyMetadataProvider.cs" />
     <Compile Include="RawgMetadataPlugin.cs" />
     <Compile Include="RawgMetadataSettings.cs" />
diff --git a/RAWGMetadata/RawgLazyMetadataProvider.cs b/RAWGMetadata/RawgLazyMetadataProvider.cs
@@ -1,8 +1,10 @@
-﻿using Playnite.SDK.Metadata;
+﻿using Playnite.SDK;
+using Playnite.SDK.Metadata;
 using Playnite.SDK.Models;
 using Playnite.SDK.Plugins;
 using Rawg.Api;
 using RAWGMetadata.Extensions;
+using RAWGMetadata.Model;
 using System;
 using System.Collections.Generic;
 using System.IO;
@@ -32,22 +34,20 @@ public RawgLazyMetadataProvider(ulong gameId, RawgMetadataPlugin plugin)
             this.plugin = plugin;
         }
 
-        private Rawg.Model.GameSingle GetGameInfo()
+        private void GetGameInfo()
         {
-            var game = GetGame();
-
-            if (!(game is null) && _gameInfo is null)
-            {
-                _gameInfo = _gamesApi.GamesRead(game.Id.ToString());
-                return _gameInfo;
-            }
-            else
+            
+            if (_gameInfo is null)
             {
-                return _gameInfo;
+                GetGame();
+                if (!(_game is null))
+                {
+                    _gameInfo = _gamesApi.GamesRead(_game.Id.ToString());
+                }
             }
         }
 
-        private Rawg.Model.Game GetGame()
+        private void GetGame()
         {
             if (_game is null && !initialized)
             {
@@ -67,29 +67,42 @@ private Rawg.Model.Game GetGame()
 
                 var gameList = _gamesApi.GamesList(null, null, options.GameData.Name, null, platformId);
                 _game = gameList.Results.FirstOrDefault(game => game.Name.Sanitize().Equals(options.GameData.Name.Sanitize()));
-                /*
-                if (_game == null)
+                
+                if (_game == null && !options.IsBackgroundDownload)
                 {
-                    _game = gameList.Results.FirstOrDefault();
+                    var selectedGame = plugin.PlayniteApi.Dialogs.ChooseItemWithSearch(new List<GenericItemOption>(gameList.Results.Select(_game => new GameOption(_game))), (a) =>
+                    {
+                        try
+                        {
+                            return new List<GenericItemOption>(_gamesApi.GamesList(null, null, a, null, platformId).Results.Select(_game => new GameOption(_game)));
+                        }
+                        catch (Exception e)
+                        {
+                            return new List<GenericItemOption>();
+                        }
+                    }, options.GameData.Name, string.Empty);
+
+                    if (selectedGame == null)
+                    {
+                        _game = null;
+                    }
+                    else
+                    {
+                        _game = ((GameOption)selectedGame).Game;
+                    }
                 }
-                */
-                return _game;
-            }
-            else
-            {
-                return _game;
             }
         }
         
         public override string GetName()
         {
-            var game = GetGame();
+            GetGame();
 
-            if (game != null)
+            if (_game != null)
             {
-                if (!string.IsNullOrWhiteSpace(game.Name))
+                if (!string.IsNullOrWhiteSpace(_game.Name))
                 {
-                    return game.Name;
+                    return _game.Name;
                 }
             }
 
@@ -98,13 +111,13 @@ public override string GetName()
         
         public override List<string> GetGenres()
         {
-            var gameInfo = GetGameInfo();
+            GetGameInfo();
 
-            if (gameInfo != null)
+            if (_gameInfo != null)
             {
-                if (gameInfo.Genres != null)
+                if (_gameInfo.Genres != null)
                 {
-                    return gameInfo.Genres.Select(genre => genre.Name).ToList();
+                    return _gameInfo.Genres.Select(genre => genre.Name).ToList();
                 }
             }
 
@@ -114,13 +127,13 @@ public override List<string> GetGenres()
         
         public override DateTime? GetReleaseDate()
         {
-            var game = GetGame();
+            GetGame();
             
-            if (game != null)
+            if (_game != null)
             {
-                if (game.Released != null)
+                if (_game.Released != null)
                 {
-                    return game.Released;
+                    return _game.Released;
                 }
             }
 
@@ -129,13 +142,13 @@ public override List<string> GetGenres()
         
         public override List<string> GetDevelopers()
         {
-            var gameInfo = GetGameInfo();
+            GetGameInfo();
 
-            if (gameInfo != null)
+            if (_gameInfo != null)
             {
-                if (gameInfo.Developers != null)
+                if (_gameInfo.Developers != null)
                 {
-                    return gameInfo.Developers.Select(developer => developer.Name).ToList();
+                    return _gameInfo.Developers.Select(developer => developer.Name).ToList();
                 }
             }
 
@@ -144,13 +157,13 @@ public override List<string> GetDevelopers()
 
         public override List<string> GetPublishers()
         {
-            var gameInfo = GetGameInfo();
+            GetGameInfo();
 
-            if (gameInfo != null)
+            if (_gameInfo != null)
             {
-                if (gameInfo.Publishers != null)
+                if (_gameInfo.Publishers != null)
                 {
-                    return gameInfo.Publishers.Select(publisher => publisher.Name).ToList();
+                    return _gameInfo.Publishers.Select(publisher => publisher.Name).ToList();
                 }
             }
 
@@ -160,13 +173,13 @@ public override List<string> GetPublishers()
 
         public override string GetDescription()
         {
-            var gameInfo = GetGameInfo();
+            GetGameInfo();
             
-            if (gameInfo != null)
+            if (_gameInfo != null)
             {
-                if (!string.IsNullOrWhiteSpace(gameInfo.Description))
+                if (!string.IsNullOrWhiteSpace(_gameInfo.Description))
                 {
-                    return gameInfo.Description;
+                    return _gameInfo.Description;
                 }
             }
 
@@ -175,13 +188,13 @@ public override string GetDescription()
         
         public override int? GetCommunityScore()
         {
-            var game = GetGame();
+            GetGame();
 
-            if (game != null)
+            if (_game != null)
             {
-                if (game.Rating != null)
+                if (_game.Rating != null)
                 {
-                    return (int)(game.Rating*20);
+                    return (int)(_game.Rating*20);
                 }
             }
 
@@ -191,13 +204,13 @@ public override string GetDescription()
         public override MetadataFile GetCoverImage()
         {
             /*
-            var game = GetGame();
+            GetGame();
 
-            if (game != null)
+            if (_game != null)
             {
-                if (!string.IsNullOrWhiteSpace(game.BackgroundImage))
+                if (!string.IsNullOrWhiteSpace(_game.BackgroundImage))
                 {
-                    return new MetadataFile(game.BackgroundImage);
+                    return new MetadataFile(_game.BackgroundImage);
                 }
             }
             */
@@ -206,13 +219,13 @@ public override MetadataFile GetCoverImage()
         
         public override MetadataFile GetBackgroundImage()
         {
-            var game = GetGame();
+            GetGame();
 
-            if (game != null)
+            if (_game != null)
             {
-                if (!string.IsNullOrWhiteSpace(game.BackgroundImage))
+                if (!string.IsNullOrWhiteSpace(_game.BackgroundImage))
                 {
-                    return new MetadataFile(game.BackgroundImage);
+                    return new MetadataFile(_game.BackgroundImage);
                 }
             }
 
@@ -221,25 +234,25 @@ public override MetadataFile GetBackgroundImage()
         
         public override List<Link> GetLinks()
         {
-            var gameInfo = GetGameInfo();
+            GetGameInfo();
 
-            if (gameInfo != null)
+            if (_gameInfo != null)
             {
                 var links = new List<Link>();
 
-                if (!string.IsNullOrWhiteSpace(gameInfo.Website))
+                if (!string.IsNullOrWhiteSpace(_gameInfo.Website))
                 {
-                    links.Add(new Link("Website", gameInfo.Website));
+                    links.Add(new Link("Website", _gameInfo.Website));
                 }
 
-                if (!string.IsNullOrWhiteSpace(gameInfo.MetacriticUrl))
+                if (!string.IsNullOrWhiteSpace(_gameInfo.MetacriticUrl))
                 {
-                    links.Add(new Link("Metacritic", gameInfo.MetacriticUrl));
+                    links.Add(new Link("Metacritic", _gameInfo.MetacriticUrl));
                 }
                 
-                if (!string.IsNullOrWhiteSpace(gameInfo.RedditUrl))
+                if (!string.IsNullOrWhiteSpace(_gameInfo.RedditUrl))
                 {
-                    links.Add(new Link("Reddit", gameInfo.RedditUrl));
+                    links.Add(new Link("Reddit", _gameInfo.RedditUrl));
                 }
 
                 if (links.Count > 0)
@@ -253,22 +266,26 @@ public override List<Link> GetLinks()
 
         public override MetadataFile GetIcon()
         {
+            /*
             using (MemoryStream ms = new MemoryStream())
             {
                 RAWGMetadata.Properties.Resources.rawg.Save(ms);
                 return new MetadataFile("RAWG", ms.ToArray());
             }
+            */
+
+            return base.GetIcon();
         }
         
         public override int? GetCriticScore()
         {
-            var game = GetGame();
+            GetGame();
 
-            if (game != null)
+            if (_game != null)
             {
-                if (game.Metacritic != null)
+                if (_game.Metacritic != null)
                 {
-                    return game.Metacritic;
+                    return _game.Metacritic;
                 }
             }
 
@@ -277,13 +294,13 @@ public override MetadataFile GetIcon()
         
         public override List<string> GetTags()
         {
-            var gameInfo = GetGameInfo();
+            GetGameInfo();
 
-            if (gameInfo != null)
+            if (_gameInfo != null)
             {
-                if (gameInfo.Tags != null)
+                if (_gameInfo.Tags != null)
                 {
-                    return gameInfo.Tags.Select(tag => tag.Name).ToList();
+                    return _gameInfo.Tags.Select(tag => tag.Name).ToList();
                 }
             }
 
diff --git a/RAWGMetadata/RawgMetadataPlugin.cs b/RAWGMetadata/RawgMetadataPlugin.cs
@@ -151,7 +151,7 @@ public override OnDemandMetadataProvider GetMetadataProvider(MetadataRequestOpti
             MetadataField.Links,
             MetadataField.CriticScore,
             MetadataField.CommunityScore,
-            MetadataField.Icon,
+            //MetadataField.Icon,
             //MetadataField.CoverImage,
             MetadataField.BackgroundImage
 

Original file line number	Diff line number	Diff line change
`@@ -1,8 +1,10 @@`
`1`		`-using Playnite.SDK.Metadata;`
	`1`	`+using Playnite.SDK;`
	`2`	`+using Playnite.SDK.Metadata;`
`2`	`3`	`using Playnite.SDK.Models;`
`3`	`4`	`using Playnite.SDK.Plugins;`
`4`	`5`	`using Rawg.Api;`
`5`	`6`	`using RAWGMetadata.Extensions;`
	`7`	`+using RAWGMetadata.Model;`
`6`	`8`	`using System;`
`7`	`9`	`using System.Collections.Generic;`
`8`	`10`	`using System.IO;`
`@@ -32,22 +34,20 @@ public RawgLazyMetadataProvider(ulong gameId, RawgMetadataPlugin plugin)`
`32`	`34`	`this.plugin = plugin;`
`33`	`35`	`}`
`34`	`36`
`35`		`- private Rawg.Model.GameSingle GetGameInfo()`
	`37`	`+ private void GetGameInfo()`
`36`	`38`	`{`
`37`		`- var game = GetGame();`
`38`		`-`
`39`		`- if (!(game is null) && _gameInfo is null)`
`40`		`- {`
`41`		`- _gameInfo = _gamesApi.GamesRead(game.Id.ToString());`
`42`		`- return _gameInfo;`
`43`		`- }`
`44`		`- else`
	`39`	`+`
	`40`	`+ if (_gameInfo is null)`
`45`	`41`	`{`
`46`		`- return _gameInfo;`
	`42`	`+ GetGame();`
	`43`	`+ if (!(_game is null))`
	`44`	`+ {`
	`45`	`+ _gameInfo = _gamesApi.GamesRead(_game.Id.ToString());`
	`46`	`+ }`
`47`	`47`	`}`
`48`	`48`	`}`
`49`	`49`
`50`		`- private Rawg.Model.Game GetGame()`
	`50`	`+ private void GetGame()`
`51`	`51`	`{`
`52`	`52`	`if (_game is null && !initialized)`
`53`	`53`	`{`
`@@ -67,29 +67,42 @@ private Rawg.Model.Game GetGame()`
`67`	`67`
`68`	`68`	`var gameList = _gamesApi.GamesList(null, null, options.GameData.Name, null, platformId);`
`69`	`69`	`_game = gameList.Results.FirstOrDefault(game => game.Name.Sanitize().Equals(options.GameData.Name.Sanitize()));`
`70`		`- /*`
`71`		`- if (_game == null)`
	`70`	`+`
	`71`	`+ if (_game == null && !options.IsBackgroundDownload)`
`72`	`72`	`{`
`73`		`- _game = gameList.Results.FirstOrDefault();`
	`73`	`+ var selectedGame = plugin.PlayniteApi.Dialogs.ChooseItemWithSearch(new List<GenericItemOption>(gameList.Results.Select(_game => new GameOption(_game))), (a) =>`
	`74`	`+ {`
	`75`	`+ try`
	`76`	`+ {`
	`77`	`+ return new List<GenericItemOption>(_gamesApi.GamesList(null, null, a, null, platformId).Results.Select(_game => new GameOption(_game)));`
	`78`	`+ }`
	`79`	`+ catch (Exception e)`
	`80`	`+ {`
	`81`	`+ return new List<GenericItemOption>();`
	`82`	`+ }`
	`83`	`+ }, options.GameData.Name, string.Empty);`
	`84`	`+`
	`85`	`+ if (selectedGame == null)`
	`86`	`+ {`
	`87`	`+ _game = null;`
	`88`	`+ }`
	`89`	`+ else`
	`90`	`+ {`
	`91`	`+ _game = ((GameOption)selectedGame).Game;`
	`92`	`+ }`
`74`	`93`	`}`
`75`		`- */`
`76`		`- return _game;`
`77`		`- }`
`78`		`- else`
`79`		`- {`
`80`		`- return _game;`
`81`	`94`	`}`
`82`	`95`	`}`
`83`	`96`
`84`	`97`	`public override string GetName()`
`85`	`98`	`{`
`86`		`- var game = GetGame();`
	`99`	`+ GetGame();`
`87`	`100`
`88`		`- if (game != null)`
	`101`	`+ if (_game != null)`
`89`	`102`	`{`
`90`		`- if (!string.IsNullOrWhiteSpace(game.Name))`
	`103`	`+ if (!string.IsNullOrWhiteSpace(_game.Name))`
`91`	`104`	`{`
`92`		`- return game.Name;`
	`105`	`+ return _game.Name;`
`93`	`106`	`}`
`94`	`107`	`}`
`95`	`108`
`@@ -98,13 +111,13 @@ public override string GetName()`
`98`	`111`
`99`	`112`	`public override List<string> GetGenres()`
`100`	`113`	`{`
`101`		`- var gameInfo = GetGameInfo();`
	`114`	`+ GetGameInfo();`
`102`	`115`
`103`		`- if (gameInfo != null)`
	`116`	`+ if (_gameInfo != null)`
`104`	`117`	`{`
`105`		`- if (gameInfo.Genres != null)`
	`118`	`+ if (_gameInfo.Genres != null)`
`106`	`119`	`{`
`107`		`- return gameInfo.Genres.Select(genre => genre.Name).ToList();`
	`120`	`+ return _gameInfo.Genres.Select(genre => genre.Name).ToList();`
`108`	`121`	`}`
`109`	`122`	`}`
`110`	`123`
`@@ -114,13 +127,13 @@ public override List<string> GetGenres()`
`114`	`127`
`115`	`128`	`public override DateTime? GetReleaseDate()`
`116`	`129`	`{`
`117`		`- var game = GetGame();`
	`130`	`+ GetGame();`
`118`	`131`
`119`		`- if (game != null)`
	`132`	`+ if (_game != null)`
`120`	`133`	`{`
`121`		`- if (game.Released != null)`
	`134`	`+ if (_game.Released != null)`
`122`	`135`	`{`
`123`		`- return game.Released;`
	`136`	`+ return _game.Released;`
`124`	`137`	`}`
`125`	`138`	`}`
`126`	`139`
`@@ -129,13 +142,13 @@ public override List<string> GetGenres()`
`129`	`142`
`130`	`143`	`public override List<string> GetDevelopers()`
`131`	`144`	`{`
`132`		`- var gameInfo = GetGameInfo();`
	`145`	`+ GetGameInfo();`
`133`	`146`
`134`		`- if (gameInfo != null)`
	`147`	`+ if (_gameInfo != null)`
`135`	`148`	`{`
`136`		`- if (gameInfo.Developers != null)`
	`149`	`+ if (_gameInfo.Developers != null)`
`137`	`150`	`{`
`138`		`- return gameInfo.Developers.Select(developer => developer.Name).ToList();`
	`151`	`+ return _gameInfo.Developers.Select(developer => developer.Name).ToList();`
`139`	`152`	`}`
`140`	`153`	`}`
`141`	`154`
`@@ -144,13 +157,13 @@ public override List<string> GetDevelopers()`
`144`	`157`
`145`	`158`	`public override List<string> GetPublishers()`
`146`	`159`	`{`
`147`		`- var gameInfo = GetGameInfo();`
	`160`	`+ GetGameInfo();`
`148`	`161`
`149`		`- if (gameInfo != null)`
	`162`	`+ if (_gameInfo != null)`
`150`	`163`	`{`
`151`		`- if (gameInfo.Publishers != null)`
	`164`	`+ if (_gameInfo.Publishers != null)`
`152`	`165`	`{`
`153`		`- return gameInfo.Publishers.Select(publisher => publisher.Name).ToList();`
	`166`	`+ return _gameInfo.Publishers.Select(publisher => publisher.Name).ToList();`
`154`	`167`	`}`
`155`	`168`	`}`
`156`	`169`
`@@ -160,13 +173,13 @@ public override List<string> GetPublishers()`
`160`	`173`
`161`	`174`	`public override string GetDescription()`
`162`	`175`	`{`
`163`		`- var gameInfo = GetGameInfo();`
	`176`	`+ GetGameInfo();`
`164`	`177`
`165`		`- if (gameInfo != null)`
	`178`	`+ if (_gameInfo != null)`
`166`	`179`	`{`
`167`		`- if (!string.IsNullOrWhiteSpace(gameInfo.Description))`
	`180`	`+ if (!string.IsNullOrWhiteSpace(_gameInfo.Description))`
`168`	`181`	`{`
`169`		`- return gameInfo.Description;`
	`182`	`+ return _gameInfo.Description;`
`170`	`183`	`}`
`171`	`184`	`}`
`172`	`185`
`@@ -175,13 +188,13 @@ public override string GetDescription()`
`175`	`188`
`176`	`189`	`public override int? GetCommunityScore()`
`177`	`190`	`{`
`178`		`- var game = GetGame();`
	`191`	`+ GetGame();`
`179`	`192`
`180`		`- if (game != null)`
	`193`	`+ if (_game != null)`
`181`	`194`	`{`
`182`		`- if (game.Rating != null)`
	`195`	`+ if (_game.Rating != null)`
`183`	`196`	`{`
`184`		`- return (int)(game.Rating*20);`
	`197`	`+ return (int)(_game.Rating*20);`
`185`	`198`	`}`
`186`	`199`	`}`
`187`	`200`
`@@ -191,13 +204,13 @@ public override string GetDescription()`
`191`	`204`	`public override MetadataFile GetCoverImage()`
`192`	`205`	`{`
`193`	`206`	`/*`
`194`		`- var game = GetGame();`
	`207`	`+ GetGame();`
`195`	`208`
`196`		`- if (game != null)`
	`209`	`+ if (_game != null)`
`197`	`210`	`{`
`198`		`- if (!string.IsNullOrWhiteSpace(game.BackgroundImage))`
	`211`	`+ if (!string.IsNullOrWhiteSpace(_game.BackgroundImage))`
`199`	`212`	`{`
`200`		`- return new MetadataFile(game.BackgroundImage);`
	`213`	`+ return new MetadataFile(_game.BackgroundImage);`
`201`	`214`	`}`
`202`	`215`	`}`
`203`	`216`	`*/`
`@@ -206,13 +219,13 @@ public override MetadataFile GetCoverImage()`
`206`	`219`
`207`	`220`	`public override MetadataFile GetBackgroundImage()`
`208`	`221`	`{`
`209`		`- var game = GetGame();`
	`222`	`+ GetGame();`
`210`	`223`
`211`		`- if (game != null)`
	`224`	`+ if (_game != null)`
`212`	`225`	`{`
`213`		`- if (!string.IsNullOrWhiteSpace(game.BackgroundImage))`
	`226`	`+ if (!string.IsNullOrWhiteSpace(_game.BackgroundImage))`
`214`	`227`	`{`
`215`		`- return new MetadataFile(game.BackgroundImage);`
	`228`	`+ return new MetadataFile(_game.BackgroundImage);`
`216`	`229`	`}`
`217`	`230`	`}`
`218`	`231`
`@@ -221,25 +234,25 @@ public override MetadataFile GetBackgroundImage()`
`221`	`234`
`222`	`235`	`public override List<Link> GetLinks()`
`223`	`236`	`{`
`224`		`- var gameInfo = GetGameInfo();`
	`237`	`+ GetGameInfo();`
`225`	`238`
`226`		`- if (gameInfo != null)`
	`239`	`+ if (_gameInfo != null)`
`227`	`240`	`{`
`228`	`241`	`var links = new List<Link>();`
`229`	`242`
`230`		`- if (!string.IsNullOrWhiteSpace(gameInfo.Website))`
	`243`	`+ if (!string.IsNullOrWhiteSpace(_gameInfo.Website))`
`231`	`244`	`{`
`232`		`- links.Add(new Link("Website", gameInfo.Website));`
	`245`	`+ links.Add(new Link("Website", _gameInfo.Website));`
`233`	`246`	`}`
`234`	`247`
`235`		`- if (!string.IsNullOrWhiteSpace(gameInfo.MetacriticUrl))`
	`248`	`+ if (!string.IsNullOrWhiteSpace(_gameInfo.MetacriticUrl))`
`236`	`249`	`{`
`237`		`- links.Add(new Link("Metacritic", gameInfo.MetacriticUrl));`
	`250`	`+ links.Add(new Link("Metacritic", _gameInfo.MetacriticUrl));`
`238`	`251`	`}`
`239`	`252`
`240`		`- if (!string.IsNullOrWhiteSpace(gameInfo.RedditUrl))`
	`253`	`+ if (!string.IsNullOrWhiteSpace(_gameInfo.RedditUrl))`
`241`	`254`	`{`
`242`		`- links.Add(new Link("Reddit", gameInfo.RedditUrl));`
	`255`	`+ links.Add(new Link("Reddit", _gameInfo.RedditUrl));`
`243`	`256`	`}`
`244`	`257`
`245`	`258`	`if (links.Count > 0)`
`@@ -253,22 +266,26 @@ public override List<Link> GetLinks()`
`253`	`266`
`254`	`267`	`public override MetadataFile GetIcon()`
`255`	`268`	`{`
	`269`	`+ /*`
`256`	`270`	`using (MemoryStream ms = new MemoryStream())`
`257`	`271`	`{`
`258`	`272`	`RAWGMetadata.Properties.Resources.rawg.Save(ms);`
`259`	`273`	`return new MetadataFile("RAWG", ms.ToArray());`
`260`	`274`	`}`
	`275`	`+ */`
	`276`	`+`
	`277`	`+ return base.GetIcon();`
`261`	`278`	`}`
`262`	`279`
`263`	`280`	`public override int? GetCriticScore()`
`264`	`281`	`{`
`265`		`- var game = GetGame();`
	`282`	`+ GetGame();`
`266`	`283`
`267`		`- if (game != null)`
	`284`	`+ if (_game != null)`
`268`	`285`	`{`
`269`		`- if (game.Metacritic != null)`
	`286`	`+ if (_game.Metacritic != null)`
`270`	`287`	`{`
`271`		`- return game.Metacritic;`
	`288`	`+ return _game.Metacritic;`
`272`	`289`	`}`
`273`	`290`	`}`
`274`	`291`
`@@ -277,13 +294,13 @@ public override MetadataFile GetIcon()`
`277`	`294`
`278`	`295`	`public override List<string> GetTags()`
`279`	`296`	`{`
`280`		`- var gameInfo = GetGameInfo();`
	`297`	`+ GetGameInfo();`
`281`	`298`
`282`		`- if (gameInfo != null)`
	`299`	`+ if (_gameInfo != null)`
`283`	`300`	`{`
`284`		`- if (gameInfo.Tags != null)`
	`301`	`+ if (_gameInfo.Tags != null)`
`285`	`302`	`{`
`286`		`- return gameInfo.Tags.Select(tag => tag.Name).ToList();`
	`303`	`+ return _gameInfo.Tags.Select(tag => tag.Name).ToList();`
`287`	`304`	`}`
`288`	`305`	`}`
`289`	`306`