public override void OnGameStarted(OnGameStartedEventArgs args)
{
var game = args.Game;
if (game.IsInstalled == false)
{
return;
}
if (BuiltinExtensions.GetExtensionFromId(game.PluginId) != BuiltinExtension.SteamLibrary)
{
return;
}
string modeFeatureName = GetModeFeatureName();
if (game.Features != null)
{
var matchingFeature = game.Features.Where(f => f.Name == modeFeatureName);
if (settings.Settings.LaunchMode == 0 && matchingFeature.Count() > 0)
{
logger.Info(String.Format("Stopped execution in game \"{0}\". Global mode and game has \"{1}\" feature", game.Name, modeFeatureName));
return;
}
else if (settings.Settings.LaunchMode == 1 && matchingFeature.Count() == 0)
{
logger.Info(String.Format("Stopped execution in game \"{0}\". Selective mode and game doesn't have \"{1}\" feature", game.Name, modeFeatureName));
return;
}
}
LaunchSteam();
}
public string convertPlayniteGamePluginIdToSGDBPlatformEnum(Guid pluginId)
{
//check for platform "steam""origin""egs""bnet""uplay"
switch (BuiltinExtensions.GetExtensionFromId(pluginId))
{
case BuiltinExtension.SteamLibrary:
return("steam");
case BuiltinExtension.OriginLibrary:
return("origin");
case BuiltinExtension.EpicLibrary:
return("egs");
case BuiltinExtension.BattleNetLibrary:
return("bnet");
default:
return(null);
}
}
public void MainMethod(bool showDialogs)
{
string featureName = "NVIDIA GeForce NOW";
GameFeature feature = PlayniteApi.Database.Features.Add(featureName);
var supportedGames = DownloadGameList("https://static.nvidiagrid.net/supported-public-game-list/gfnpc.json", showDialogs);
if (supportedGames.Count() == 0)
{
// In case download failed.
// Also sometimes there are issues with the api and it doesn't return any games in the response
return;
}
var supportedSteamGames = supportedGames.Where(g => g.Store == "Steam");
var supportedEpicGames = supportedGames.Where(g => g.Store == "Epic");
var supportedOriginGames = supportedGames.Where(g => g.Store == "Origin");
var supportedUplayGames = supportedGames.Where(g => g.Store == "Ubisoft Connect");
var supportedGogGames = supportedGames.Where(g => g.Store == "GOG");
int enabledGamesCount = 0;
int featureAddedCount = 0;
int featureRemovedCount = 0;
int playActionAddedCount = 0;
int playActionRemovedCount = 0;
int setAsInstalledCount = 0;
int setAsUninstalledCount = 0;
var progRes = PlayniteApi.Dialogs.ActivateGlobalProgress((a) => {
var gameDatabase = GetGamesSupportedLibraries();
foreach (var game in gameDatabase)
{
var gameName = Regex.Replace(game.Name, @"[^\p{L}\p{Nd}]", "").ToLower();
GeforceGame supportedGame = null;
switch (BuiltinExtensions.GetExtensionFromId(game.PluginId))
{
case BuiltinExtension.SteamLibrary:
var steamUrl = String.Format("https://store.steampowered.com/app/{0}", game.GameId);
supportedGame = supportedSteamGames.Where(g => g.SteamUrl == steamUrl).FirstOrDefault();
break;
case BuiltinExtension.EpicLibrary:
supportedGame = supportedEpicGames.Where(g => g.Title == gameName).FirstOrDefault();
break;
case BuiltinExtension.OriginLibrary:
supportedGame = supportedOriginGames.Where(g => g.Title == gameName).FirstOrDefault();
break;
case BuiltinExtension.UplayLibrary:
supportedGame = supportedUplayGames.Where(g => g.Title == gameName).FirstOrDefault();
break;
case BuiltinExtension.GogLibrary:
supportedGame = supportedGogGames.Where(g => g.Title == gameName).FirstOrDefault();
break;
default:
break;
}
if (supportedGame == null)
{
bool featureRemoved = RemoveFeature(game, feature);
if (featureRemoved == true)
{
featureRemovedCount++;
logger.Info(String.Format("Feature removed from \"{0}\"", game.Name));
if (settings.Settings.SetEnabledGamesAsInstalled == true && game.IsInstalled == true)
{
game.IsInstalled = true;
setAsUninstalledCount++;
PlayniteApi.Database.Games.Update(game);
logger.Info(String.Format("Set \"{0}\" as uninstalled", game.Name));
}
}
}
else
{
enabledGamesCount++;
bool featureAdded = AddFeature(game, feature);
if (featureAdded == true)
{
featureAddedCount++;
logger.Info(String.Format("Feature added to \"{0}\"", game.Name));
}
if (settings.Settings.SetEnabledGamesAsInstalled == true && game.IsInstalled == false)
{
game.IsInstalled = true;
setAsInstalledCount++;
PlayniteApi.Database.Games.Update(game);
logger.Info(String.Format("Set \"{0}\" as installed", game.Name));
}
}
if (settings.Settings.UpdatePlayActions == true)
{
var updatePlayAction = UpdateNvidiaAction(game, supportedGame);
if (updatePlayAction == "ActionAdded")
{
playActionAddedCount++;
logger.Info(String.Format("Play Action added to \"{0}\"", game.Name));
}
else if (updatePlayAction == "ActionRemoved")
{
playActionRemovedCount++;
logger.Info(String.Format("Play Action removed from \"{0}\"", game.Name));
}
}
}
}, new GlobalProgressOptions(ResourceProvider.GetString("LOCNgfn_Enabler_UpdatingProgressMessage")));
if (showDialogs == true)
{
string results = String.Format(ResourceProvider.GetString("LOCNgfn_Enabler_UpdateResults1Message"),
enabledGamesCount, featureName, featureAddedCount, featureName, featureRemovedCount);
if (settings.Settings.UpdatePlayActions == true)
{
results += String.Format(ResourceProvider.GetString("LOCNgfn_Enabler_UpdateResults2Message"),
playActionAddedCount, playActionRemovedCount);
}
if (settings.Settings.SetEnabledGamesAsInstalled == true)
{
results += String.Format(ResourceProvider.GetString("LOCNgfn_Enabler_UpdateResults3Message"), setAsInstalledCount, setAsUninstalledCount);
}
PlayniteApi.Dialogs.ShowMessage(results, "NVIDIA GeForce NOW Enabler");
}
}
private async Task <ulong> TryMatchGame(SdkModels.Game game)
{
if (BuiltinExtensions.GetExtensionFromId(game.PluginId) == BuiltinExtension.SteamLibrary)
{
var igdbId = await GamesBySteamIdController.GetIgdbMatch(ulong.Parse(game.GameId));
if (igdbId != 0)
{
return(igdbId);
}
}
if (game.Name.IsNullOrEmpty())
{
return(0);
}
ulong matchedGame = 0;
var copyGame = game.GetClone();
copyGame.Name = StringExtensions.NormalizeGameName(game.Name);
var name = copyGame.Name;
name = Regex.Replace(name, @"\s+RHCP$", "", RegexOptions.IgnoreCase);
name = Regex.Replace(name, @"\s+RU$", "", RegexOptions.IgnoreCase);
var results = await GamesController.GetSearchResults(name);
results.ForEach(a => a.name = StringExtensions.NormalizeGameName(a.name));
string testName = string.Empty;
// Direct comparison
matchedGame = MatchFun(game, name, results);
if (matchedGame > 0)
{
return(matchedGame);
}
// Try replacing roman numerals: 3 => III
testName = Regex.Replace(name, @"\d+", ReplaceNumsForRomans);
matchedGame = MatchFun(game, testName, results);
if (matchedGame > 0)
{
return(matchedGame);
}
// Try adding The
testName = "The " + name;
matchedGame = MatchFun(game, testName, results);
if (matchedGame > 0)
{
return(matchedGame);
}
// Try chaning & / and
testName = Regex.Replace(name, @"\s+and\s+", " & ", RegexOptions.IgnoreCase);
matchedGame = MatchFun(game, testName, results);
if (matchedGame > 0)
{
return(matchedGame);
}
// Try removing apostrophes
var resCopy = results.GetClone();
resCopy.ForEach(a => a.name = a.name.Replace("'", ""));
matchedGame = MatchFun(game, name, resCopy);
if (matchedGame > 0)
{
return(matchedGame);
}
// Try removing all ":" and "-"
testName = Regex.Replace(name, @"\s*(:|-)\s*", " ");
resCopy = results.GetClone();
foreach (var res in resCopy)
{
res.name = Regex.Replace(res.name, @"\s*(:|-)\s*", " ");
res.alternative_names?.ForEach(a => a.name = Regex.Replace(a.name, @"\s*(:|-)\s*", " "));
}
matchedGame = MatchFun(game, testName, resCopy);
if (matchedGame > 0)
{
return(matchedGame);
}
// Try without subtitle
var testResult = results.OrderBy(a => a.first_release_date).FirstOrDefault(a =>
{
if (a.first_release_date == 0)
{
return(false);
}
if (!string.IsNullOrEmpty(a.name) && a.name.Contains(":"))
{
return(string.Equals(name, a.name.Split(':')[0], StringComparison.InvariantCultureIgnoreCase));
}
return(false);
});
if (testResult != null)
{
return(testResult.id);
}
return(0);
}
private void GetIgdbMetadata()
{
if (IgdbData != null)
{
return;
}
if (gameId != 0)
{
IgdbData = plugin.Client.GetIGDBGameParsed(gameId);
return;
}
if (!options.IsBackgroundDownload)
{
var item = plugin.PlayniteApi.Dialogs.ChooseItemWithSearch(null, (a) =>
{
if (a.StartsWith("http", StringComparison.OrdinalIgnoreCase))
{
try
{
var gameId = GetGameInfoFromUrl(a);
var data = plugin.Client.GetIGDBGameParsed(ulong.Parse(gameId));
return(new List <GenericItemOption> {
new SearchResult(gameId, data.name)
});
}
catch (Exception e)
{
logger.Error(e, $"Failed to get game data from {a}");
return(new List <GenericItemOption>());
}
}
else
{
var res = plugin.GetSearchResults(a);
return(res.Select(b => b as GenericItemOption).ToList());
}
}, options.GameData.Name);
if (item != null)
{
var searchItem = item as SearchResult;
IgdbData = plugin.Client.GetIGDBGameParsed(ulong.Parse(searchItem.Id));
}
else
{
IgdbData = new IgdbServerModels.ExpandedGame()
{
id = 0
};
}
}
else
{
var game = options.GameData;
if (BuiltinExtensions.GetExtensionFromId(game.PluginId) == BuiltinExtension.SteamLibrary)
{
var igdbId = plugin.Client.GetIGDBGameBySteamId(game.GameId);
if (igdbId != 0)
{
IgdbData = plugin.Client.GetIGDBGameParsed(igdbId);
return;
}
}
if (game.Name.IsNullOrEmpty())
{
IgdbData = new IgdbServerModels.ExpandedGame()
{
id = 0
};
return;
}
var copyGame = game.GetClone();
copyGame.Name = StringExtensions.NormalizeGameName(game.Name);
var name = copyGame.Name
.Replace(" RHCP", "", StringComparison.OrdinalIgnoreCase)
.Replace(" RU", "", StringComparison.OrdinalIgnoreCase);
var results = plugin.GetSearchResults(plugin.GetIgdbSearchString(name)).ToList();
results.ForEach(a => a.Name = StringExtensions.NormalizeGameName(a.Name));
string testName = string.Empty;
// Direct comparison
IgdbData = matchFun(game, name, results);
if (IgdbData != null)
{
return;
}
// Try replacing roman numerals: 3 => III
testName = Regex.Replace(name, @"\d+", ReplaceNumsForRomans);
IgdbData = matchFun(game, testName, results);
if (IgdbData != null)
{
return;
}
// Try adding The
testName = "The " + name;
IgdbData = matchFun(game, testName, results);
if (IgdbData != null)
{
return;
}
// Try chaning & / and
testName = Regex.Replace(name, @"\s+and\s+", " & ", RegexOptions.IgnoreCase);
IgdbData = matchFun(game, testName, results);
if (IgdbData != null)
{
return;
}
// Try removing apostrophes
var resCopy = results.GetClone();
resCopy.ForEach(a => a.Name = a.Name.Replace("'", ""));
IgdbData = matchFun(game, name, resCopy);
if (IgdbData != null)
{
return;
}
// Try removing all ":" and "-"
testName = Regex.Replace(name, @"\s*(:|-)\s*", " ");
resCopy = results.GetClone();
resCopy.ForEach(a => a.Name = Regex.Replace(a.Name, @"\s*(:|-)\s*", " "));
IgdbData = matchFun(game, testName, resCopy);
if (IgdbData != null)
{
return;
}
// Try without subtitle
var testResult = results.OrderBy(a => a.ReleaseDate).FirstOrDefault(a =>
{
if (a.ReleaseDate == null)
{
return(false);
}
if (!string.IsNullOrEmpty(a.Name) && a.Name.Contains(":"))
{
return(string.Equals(name, a.Name.Split(':')[0], StringComparison.InvariantCultureIgnoreCase));
}
return(false);
});
if (testResult != null)
{
IgdbData = plugin.Client.GetIGDBGameParsed(ulong.Parse(testResult.Id));
return;
}
// No match found
IgdbData = new IgdbServerModels.ExpandedGame()
{
id = 0
};
}
}
internal void GetGameData()
{
if (currentMetadata != null)
{
return;
}
try
{
var metadataProvider = new MetadataProvider(apiClient);
if (BuiltinExtensions.GetExtensionFromId(options.GameData.PluginId) == BuiltinExtension.SteamLibrary)
{
var appId = uint.Parse(options.GameData.GameId);
currentMetadata = metadataProvider.GetGameMetadata(
appId,
plugin.SettingsViewModel.Settings.BackgroundSource,
plugin.SettingsViewModel.Settings.DownloadVerticalCovers);
}
else
{
if (options.IsBackgroundDownload)
{
var matchedId = GetMatchingGame(options.GameData);
if (matchedId > 0)
{
currentMetadata = metadataProvider.GetGameMetadata(
matchedId,
plugin.SettingsViewModel.Settings.BackgroundSource,
plugin.SettingsViewModel.Settings.DownloadVerticalCovers);
}
else
{
currentMetadata = new SteamGameMetadata();
}
}
else
{
var selectedGame = plugin.PlayniteApi.Dialogs.ChooseItemWithSearch(null, (a) =>
{
if (uint.TryParse(a, out var appId))
{
try
{
var store = WebApiClient.GetStoreAppDetail(appId);
return(new List <GenericItemOption> {
new StoreSearchResult
{
GameId = appId,
Name = store.name
}
});
}
catch (Exception e)
{
logger.Error(e, $"Failed to get Steam app info {appId}");
return(new List <GenericItemOption>());
}
}
else
{
try
{
var name = StringExtensions.NormalizeGameName(a);
return(new List <GenericItemOption>(UniversalSteamMetadata.GetSearchResults(name)));
}
catch (Exception e)
{
logger.Error(e, $"Failed to get Steam search data for {a}");
return(new List <GenericItemOption>());
}
}
}, options.GameData.Name, string.Empty);
if (selectedGame == null)
{
currentMetadata = new SteamGameMetadata();
}
else
{
currentMetadata = metadataProvider.GetGameMetadata(
((StoreSearchResult)selectedGame).GameId,
plugin.SettingsViewModel.Settings.BackgroundSource,
plugin.SettingsViewModel.Settings.DownloadVerticalCovers);
}
}
}
}
catch (Exception e)
{
logger.Error(e, $"Failed to get Steam metadata.");
currentMetadata = new SteamGameMetadata();
}
}
public void MainMethod(bool showDialogs)
{
string featureName = "NVIDIA GeForce NOW";
GameFeature feature = PlayniteApi.Database.Features.Add(featureName);
string localAppData = Environment.GetEnvironmentVariable("LocalAppData");
string geforceNowWorkingPath = Path.Combine(localAppData, "NVIDIA Corporation", "GeForceNOW", "CEF");
string geforceNowExecutablePath = Path.Combine(geforceNowWorkingPath, "GeForceNOWStreamer.exe");
var supportedGames = DownloadGameList("https://static.nvidiagrid.net/supported-public-game-list/gfnpc.json", showDialogs);
if (supportedGames.Count() == 0)
{
return;
}
var supportedSteamGames = supportedGames.Where(g => g.Store == "Steam");
var supportedEpicGames = supportedGames.Where(g => g.Store == "Epic");
var supportedOriginGames = supportedGames.Where(g => g.Store == "Origin");
var supportedUplayGames = supportedGames.Where(g => g.Store == "Ubisoft Connect");
var supportedGogGames = supportedGames.Where(g => g.Store == "GOG");
int enabledGamesCount = 0;
int featureAddedCount = 0;
int featureRemovedCount = 0;
int playActionAddedCount = 0;
int playActionRemovedCount = 0;
int setAsInstalledCount = 0;
int setAsUninstalledCount = 0;
var progRes = PlayniteApi.Dialogs.ActivateGlobalProgress((a) => {
var gameDatabase = GetGamesSupportedLibraries();
foreach (var game in gameDatabase)
{
var gameName = Regex.Replace(game.Name, @"[^\p{L}\p{Nd}]", "").ToLower();
GeforceGame supportedGame = null;
switch (BuiltinExtensions.GetExtensionFromId(game.PluginId))
{
case BuiltinExtension.SteamLibrary:
var steamUrl = String.Format("https://store.steampowered.com/app/{0}", game.GameId);
supportedGame = supportedSteamGames.Where(g => g.SteamUrl == steamUrl).FirstOrDefault();
break;
case BuiltinExtension.EpicLibrary:
supportedGame = supportedEpicGames.Where(g => g.Title == gameName).FirstOrDefault();
break;
case BuiltinExtension.OriginLibrary:
supportedGame = supportedOriginGames.Where(g => g.Title == gameName).FirstOrDefault();
break;
case BuiltinExtension.UplayLibrary:
supportedGame = supportedUplayGames.Where(g => g.Title == gameName).FirstOrDefault();
break;
case BuiltinExtension.GogLibrary:
supportedGame = supportedGogGames.Where(g => g.Title == gameName).FirstOrDefault();
break;
default:
break;
}
if (supportedGame == null)
{
bool featureRemoved = RemoveFeature(game, feature);
if (featureRemoved == true)
{
featureRemovedCount++;
logger.Info(String.Format("Feature removed from \"{0}\"", game.Name));
if (settings.SetEnabledGamesAsInstalled == true && game.IsInstalled == true)
{
game.IsInstalled = true;
setAsUninstalledCount++;
PlayniteApi.Database.Games.Update(game);
logger.Info(String.Format("Set \"{0}\" as uninstalled", game.Name));
}
}
}
else
{
enabledGamesCount++;
bool featureAdded = AddFeature(game, feature);
if (featureAdded == true)
{
featureAddedCount++;
logger.Info(String.Format("Feature added to \"{0}\"", game.Name));
}
if (settings.SetEnabledGamesAsInstalled == true && game.IsInstalled == false)
{
game.IsInstalled = true;
setAsInstalledCount++;
PlayniteApi.Database.Games.Update(game);
logger.Info(String.Format("Set \"{0}\" as installed", game.Name));
}
}
if (settings.UpdatePlayActions == true)
{
string updatePlayAction = UpdateNvidiaAction(game, supportedGame, geforceNowWorkingPath, geforceNowExecutablePath);
if (updatePlayAction == "playActionAdded")
{
playActionAddedCount++;
logger.Info(String.Format("Play Action added to \"{0}\"", game.Name));
}
else if (updatePlayAction == "playActionRemoved")
{
playActionRemovedCount++;
logger.Info(String.Format("Play Action removed from \"{0}\"", game.Name));
}
}
}
}, new GlobalProgressOptions("Updating NVIDIA GeForce NOW Enabled games"));
if (showDialogs == true)
{
string results = String.Format("NVIDIA GeForce NOW enabled games in library: {0}\n\nAdded \"{1}\" feature to {2} games.\nRemoved \"{3}\" feature from {4} games.",
enabledGamesCount, featureName, featureAddedCount, featureName, featureRemovedCount);
if (settings.UpdatePlayActions == true)
{
results += String.Format("\n\nPlay Action added to {0} games.\nPlay Action removed from {1} games.",
playActionAddedCount, playActionRemovedCount);
}
if (settings.SetEnabledGamesAsInstalled == true)
{
results += String.Format("\n\nSet {0} games as Installed.\nSet {1} games as uninstalled.", setAsInstalledCount, setAsUninstalledCount);
}
PlayniteApi.Dialogs.ShowMessage(results, "NVIDIA GeForce NOW Enabler");
}
}
