/// <summary>
/// Scan the registry for games, add new games to memory and export into JSON document
/// </summary>
public static void ScanGames()
{
CGameData.CTempGameSet tempGameSet = new CGameData.CTempGameSet();
List <CRegScanner.RegistryGameData> gameDataList = CRegScanner.GetGames();
foreach (CRegScanner.RegistryGameData data in gameDataList)
{
tempGameSet.InsertGame(data.m_strTitle, data.m_strLaunch, false, data.m_strPlatform);
}
CGameFinder.ImportFromFolder(ref tempGameSet);
CGameData.MergeGameSets(tempGameSet);
CJsonWrapper.Export(CGameData.GetPlatformGameList(CGameData.GamePlatform.All).ToList());
}
/// <summary>
/// Find installed Uplay games
/// </summary>
/// <param name="gameDataList">List of game data objects</param>
private static void GetUplayGames(List <RegistryGameData> gameDataList)
{
List <RegistryKey> keyList = new List <RegistryKey>();
using (RegistryKey key = Registry.LocalMachine.OpenSubKey(NODE64_REG, RegistryKeyPermissionCheck.ReadSubTree))
{
keyList = FindGameFolders(key, UPLAY_INSTALL);
foreach (var data in keyList)
{
string strTitle = data.GetValue(GAME_DISPLAY_NAME).ToString();
string strLaunch = UPLAY_LAUNCH + Path.GetFileNameWithoutExtension(data.Name).Substring(10) + "/0";
string strIcon = CGameFinder.FindGameBinaryFile(data.GetValue(GAME_INSTALL_LOCATION).ToString(), data.GetValue(GAME_DISPLAY_NAME).ToString());
gameDataList.Add(new RegistryGameData(strTitle, strLaunch, strIcon, UPLAY_NAME));
}
}
}
/// <summary>
/// Find installed Steam games
/// </summary>
/// <param name="gameDataList">List of game data objects</param>
private static void GetSteamGames(List <RegistryGameData> gameDataList)
{
List <RegistryKey> keyList = new List <RegistryKey>();
using (RegistryKey key = Registry.LocalMachine.OpenSubKey(STEAM_REG, RegistryKeyPermissionCheck.ReadSubTree))
{
if (key == null)
{
Logger.CLogger.LogInfo("Steam games not found in registry.");
return;
}
keyList = FindGameFolders(key, STEAM_GAME_FOLDER);
foreach (var data in keyList)
{
string strTitle = data.GetValue(GAME_DISPLAY_NAME).ToString();
string strLaunch = STEAM_LAUNCH + Path.GetFileNameWithoutExtension(data.Name).Substring(10);
string strIcon = CGameFinder.FindGameBinaryFile(data.GetValue(GAME_INSTALL_LOCATION).ToString(), data.GetValue(GAME_DISPLAY_NAME).ToString());
gameDataList.Add(new RegistryGameData(strTitle, strLaunch, strIcon, "Steam"));
}
}
}
public void GetGames(List <ImportGameData> gameDataList, bool expensiveIcons = false)
{
List <RegistryKey> keyList;
using (RegistryKey key = Registry.LocalMachine.OpenSubKey(BIGFISH_GAMES, RegistryKeyPermissionCheck.ReadSubTree)) // HKLM32
{
if (key == null)
{
CLogger.LogInfo("{0} client not found in the registry.", _name.ToUpper());
return;
}
keyList = FindGameFolders(key, "");
CLogger.LogInfo("{0} {1} games found", keyList.Count > 1 ? keyList.Count - 1 : keyList.Count, _name.ToUpper());
foreach (var data in keyList)
{
string wrap = Path.GetFileName(data.Name);
if (wrap.Equals(BIGFISH_CASINO_ID)) // hide Big Fish Casino Activator
{
continue;
}
string strID = "bfg_" + wrap;
string strTitle = "";
string strLaunch = "";
string strIconPath = "";
string strUninstall = "";
string strAlias = "";
string strPlatform = GetPlatformString(ENUM);
try
{
//found = true;
bool isInstalled = false;
strTitle = GetRegStrVal(data, "Name");
// If this is an expired trial, count it as not-installed
int activated = (int)GetRegDWORDVal(data, "Activated");
int daysLeft = (int)GetRegDWORDVal(data, "DaysLeft");
int timeLeft = (int)GetRegDWORDVal(data, "TimeLeft");
if (activated > 0 || timeLeft > 0 || daysLeft > 0)
{
isInstalled = true;
CLogger.LogDebug($"- {strTitle}");
}
else
{
CLogger.LogDebug($"- *{strTitle}");
}
strLaunch = GetRegStrVal(data, BIGFISH_PATH);
strAlias = GetAlias(strTitle);
if (strAlias.Equals(strTitle, CDock.IGNORE_CASE))
{
strAlias = "";
}
//strIconPath = GetRegStrVal(data, "Thumbnail"); // 80x80
strIconPath = GetRegStrVal(data, "feature"); // 175x150
//ushort userRating = (ushort)GetRegDWORDVal(data, "Rating"); // Not used?
uint numberRuns = (uint)GetRegDWORDVal(data, "PlayCount");
byte[] dateData = GetRegBinaryVal(data, "LastActionTime");
DateTime lastRun = BFRegToDateTime(dateData);
//CLogger.LogDebug(" LastActionTime: " + BitConverter.ToString(dateData) + " -> " + lastRun.ToShortDateString());
List <RegistryKey> unKeyList;
using (RegistryKey key2 = Registry.LocalMachine.OpenSubKey(NODE32_REG, RegistryKeyPermissionCheck.ReadSubTree)) // HKLM32
{
if (key2 != null)
{
unKeyList = FindGameFolders(key2, BIGFISH_PREFIX);
foreach (var data2 in unKeyList)
{
if (GetRegStrVal(data2, BIGFISH_ID).Equals(wrap))
{
if (string.IsNullOrEmpty(strIconPath))
{
strIconPath = GetRegStrVal(data2, GAME_DISPLAY_ICON).Trim(new char[] { ' ', '"' });
}
strUninstall = GetRegStrVal(data2, GAME_UNINSTALL_STRING).Trim(new char[] { ' ', '"' });
}
}
}
}
if (string.IsNullOrEmpty(strIconPath) && expensiveIcons)
{
bool success = false;
string dir = Path.GetDirectoryName(strLaunch);
string xmlPath = Path.Combine(dir, "bfgstate.xml");
try
{
if (File.Exists(xmlPath))
{
XmlDocument doc = new();
doc.Load(xmlPath);
//XmlNode node = doc.DocumentElement.SelectSingleNode("thumbnail"); // 80x80
XmlNode node = doc.DocumentElement.SelectSingleNode("feature"); // 175x150
if (node != null)
{
strIconPath = node.InnerText;
if (File.Exists(strIconPath))
{
success = true;
}
else
{
// Use website to download missing icons
if (!(bool)(CConfig.GetConfigBool(CConfig.CFG_IMGDOWN)))
{
if (CDock.DownloadCustomImage(strTitle, GetIconUrl(GetGameID(strID), strTitle)))
{
success = true;
}
}
}
}
}
}
catch (Exception e)
{
CLogger.LogError(e);
}
if (!success)
{
strIconPath = CGameFinder.FindGameBinaryFile(dir, strTitle);
}
}
if (!(string.IsNullOrEmpty(strLaunch)))
{
gameDataList.Add(
new ImportGameData(strID, strTitle, strLaunch, strIconPath, strUninstall, strAlias, isInstalled, strPlatform, dateLastRun: lastRun, numRuns: numberRuns));
}
}
catch (Exception e)
{
CLogger.LogError(e);
}
}
}
CLogger.LogDebug("------------------------");
}
public void GetGames(List <ImportGameData> gameDataList, bool expensiveIcons = false)
{
List <string> igcIds = new();
string strPlatform = GetPlatformString(ENUM);
// Get installed games
string file = Path.Combine(GetFolderPath(SpecialFolder.ApplicationData), IG_JSON);
if (!File.Exists(file))
{
CLogger.LogInfo("{0} installed games not found in AppData", _name.ToUpper());
return;
}
else
{
string strDocumentData = File.ReadAllText(file);
if (string.IsNullOrEmpty(strDocumentData))
{
CLogger.LogWarn(string.Format("Malformed {0} file: {1}", _name.ToUpper(), file));
}
else
{
try
{
using JsonDocument document = JsonDocument.Parse(@strDocumentData, jsonTrailingCommas);
foreach (JsonElement element in document.RootElement.EnumerateArray())
{
string strID = "";
string strTitle = "";
string strLaunch = "";
string strAlias = "";
element.TryGetProperty("target", out JsonElement target);
if (!target.Equals(null))
{
target.TryGetProperty("item_data", out JsonElement item);
if (!item.Equals(null))
{
strID = GetStringProperty(item, "id_key_name");
igcIds.Add(strID);
strTitle = GetStringProperty(item, "name");
}
}
element.TryGetProperty("path", out JsonElement paths);
if (!paths.Equals(null))
{
foreach (JsonElement path in paths.EnumerateArray())
{
strLaunch = CGameFinder.FindGameBinaryFile(path.ToString(), strTitle);
}
}
CLogger.LogDebug($"- {strTitle}");
if (!string.IsNullOrEmpty(strLaunch))
{
strAlias = GetAlias(Path.GetFileNameWithoutExtension(strLaunch));
if (strAlias.Length > strTitle.Length)
{
strAlias = GetAlias(strTitle);
}
if (strAlias.Equals(strTitle, CDock.IGNORE_CASE))
{
strAlias = "";
}
gameDataList.Add(new ImportGameData(strID, strTitle, strLaunch, strLaunch, "", strAlias, true, strPlatform));
}
}
}
catch (Exception e)
{
CLogger.LogError(e, string.Format("Malformed {0} file: {1}", _name.ToUpper(), file));
}
}
}
// Get not-installed games
if (!(bool)CConfig.GetConfigBool(CConfig.CFG_INSTONLY))
{
file = Path.Combine(GetFolderPath(SpecialFolder.ApplicationData), IG_OWN_JSON);
if (!File.Exists(file))
{
CLogger.LogInfo("{0} not-installed games not found in AppData", _name.ToUpper());
}
else
{
CLogger.LogDebug("{0} not-installed games:", _name.ToUpper());
string strDocumentData = File.ReadAllText(file);
if (string.IsNullOrEmpty(strDocumentData))
{
CLogger.LogWarn(string.Format("Malformed {0} file: {1}", _name.ToUpper(), file));
}
else
{
try
{
using JsonDocument document = JsonDocument.Parse(@strDocumentData, jsonTrailingCommas);
bool exists = false;
bool found = false;
JsonElement coll = new();
document.RootElement.TryGetProperty("gala_data", out JsonElement gData);
if (!gData.Equals(null))
{
gData.TryGetProperty("data", out JsonElement data);
if (!data.Equals(null))
{
data.TryGetProperty("showcase_content", out JsonElement sContent);
if (!sContent.Equals(null))
{
sContent.TryGetProperty("content", out JsonElement content);
if (!content.Equals(null))
{
content.TryGetProperty("user_collection", out coll);
if (!coll.Equals(null))
{
exists = true;
}
}
}
}
}
if (exists)
{
foreach (JsonElement prod in coll.EnumerateArray())
{
string strID = GetStringProperty(prod, "prod_id_key_name");
if (!string.IsNullOrEmpty(strID))
{
foreach (string id in igcIds)
{
if (id.Equals(strID))
{
found = true;
}
}
if (!found)
{
string strTitle = GetStringProperty(prod, "prod_name");
CLogger.LogDebug($"- *{strTitle}");
gameDataList.Add(new ImportGameData(strID, strTitle, "", "", "", "", false, strPlatform));
// Use prod_dev_image to download not-installed icons
if (!(bool)(CConfig.GetConfigBool(CConfig.CFG_IMGDOWN)))
{
string devName = GetStringProperty(prod, "prod_dev_namespace");
string image = GetStringProperty(prod, "prod_dev_image");
if (!string.IsNullOrEmpty(devName) && !string.IsNullOrEmpty(image))
{
string iconUrl = $"https://www.indiegalacdn.com/imgs/devs/{devName}/products/{strID}/prodmain/{image}";
CDock.DownloadCustomImage(strTitle, iconUrl);
}
}
}
}
}
}
}
catch (Exception e)
{
CLogger.LogError(e, string.Format("Malformed {0} file: {1}", _name.ToUpper(), file));
}
}
}
}
CLogger.LogDebug("--------------------");
}
public void GetGames(List <ImportGameData> gameDataList, bool expensiveIcons = false)
{
List <string> azIds = new();
string strPlatform = GetPlatformString(ENUM);
// Get installed games
string db = Path.Combine(GetFolderPath(SpecialFolder.LocalApplicationData), AMAZON_DB);
if (!File.Exists(db))
{
CLogger.LogInfo("{0} installed game database not found.", _name.ToUpper());
//return;
}
try
{
using SQLiteConnection con = new($"Data Source={db}");
con.Open();
using SQLiteCommand cmd = new("SELECT Id, InstallDirectory, ProductTitle FROM DbSet;", con);
using SQLiteDataReader rdr = cmd.ExecuteReader();
while (rdr.Read())
{
string dir = rdr.GetString(1);
string strID = rdr.GetString(0);
azIds.Add(strID);
string strTitle = rdr.GetString(2);
CLogger.LogDebug($"- {strTitle}");
string strLaunch = START_GAME + strID;
string strIconPath = "";
string strUninstall = "";
using (RegistryKey key = Registry.CurrentUser.OpenSubKey(Path.Combine(NODE64_REG, "AmazonGames", strTitle), RegistryKeyPermissionCheck.ReadSubTree))
{
if (key != null)
{
strIconPath = GetRegStrVal(key, "DisplayIcon");
strUninstall = GetRegStrVal(key, "UninstallString");
}
}
if (string.IsNullOrEmpty(strIconPath))
{
if (expensiveIcons)
{
bool success = false;
string fuelPath = Path.Combine(dir, "fuel.json");
if (File.Exists(fuelPath))
{
string strDocumentData = File.ReadAllText(fuelPath);
if (!string.IsNullOrEmpty(strDocumentData))
{
using JsonDocument document = JsonDocument.Parse(@strDocumentData, jsonTrailingCommas);
document.RootElement.TryGetProperty("Main", out JsonElement main);
if (!main.Equals(null))
{
string iconFile = GetStringProperty(main, "Command");
if (!string.IsNullOrEmpty(strIconPath))
{
strIconPath = Path.Combine(dir, iconFile);
success = true;
}
}
}
}
if (!success)
{
strIconPath = CGameFinder.FindGameBinaryFile(dir, strTitle);
}
}
}
if (string.IsNullOrEmpty(strUninstall))
{
strUninstall = Path.Combine(Directory.GetParent(dir).FullName, UNINST_GAME) + " " + UNINST_GAME_ARGS + " " + strID;
}
string strAlias = GetAlias(strTitle);
if (!string.IsNullOrEmpty(strLaunch))
{
if (strAlias.Equals(strTitle, CDock.IGNORE_CASE))
{
strAlias = "";
}
gameDataList.Add(new ImportGameData(strID, strTitle, strLaunch, strIconPath, strUninstall, strAlias, true, strPlatform));
}
}
con.Close();
}
catch (Exception e)
{
CLogger.LogError(e, string.Format("Malformed {0} database output!", _name.ToUpper()));
}
// Get not-installed games
if (!(bool)CConfig.GetConfigBool(CConfig.CFG_INSTONLY))
{
db = Path.Combine(GetFolderPath(SpecialFolder.LocalApplicationData), AMAZON_OWN_DB);
if (!File.Exists(db))
{
CLogger.LogInfo("{0} not-installed game database not found.", _name.ToUpper());
}
else
{
CLogger.LogDebug("{0} not-installed games:", _name.ToUpper());
try
{
using SQLiteConnection con = new($"Data Source={db}");
con.Open();
using SQLiteCommand cmd = new("SELECT Id, ProductIconUrl, ProductIdStr, ProductTitle FROM DbSet;", con);
using SQLiteDataReader rdr = cmd.ExecuteReader();
while (rdr.Read())
{
bool found = false;
string strID = rdr.GetString(2); // TODO: Should I use Id or ProductIdStr?
foreach (string id in azIds)
{
if (id.Equals(strID))
{
found = true;
}
}
if (!found)
{
string strTitle = rdr.GetString(3);
CLogger.LogDebug($"- *{strTitle}");
gameDataList.Add(new ImportGameData(strID, strTitle, "", "", "", "", false, strPlatform));
// Use ProductIconUrl to download not-installed icons
if (!(bool)(CConfig.GetConfigBool(CConfig.CFG_IMGDOWN)))
{
string iconUrl = rdr.GetString(1);
CDock.DownloadCustomImage(strTitle, iconUrl);
}
}
}
con.Close();
}
catch (Exception e)
{
CLogger.LogError(e, string.Format("Malformed {0} database output!", _name.ToUpper()));
}
}
}
CLogger.LogDebug("-------------------");
}
public void GetGames(List <ImportGameData> gameDataList, bool expensiveIcons = false)
{
string strInstallPath = "";
string strClientPath = "";
using (RegistryKey key = Registry.LocalMachine.OpenSubKey(STEAM_REG, RegistryKeyPermissionCheck.ReadSubTree)) // HKLM32
{
if (key == null)
{
CLogger.LogInfo("{0} client not found in the registry.", _name.ToUpper());
return;
}
strInstallPath = GetRegStrVal(key, GAME_INSTALL_PATH);
strClientPath = Path.Combine(strInstallPath, STEAM_PATH);
}
if (!Directory.Exists(strClientPath))
{
CLogger.LogInfo("{0} library not found: {1}", _name.ToUpper(), strClientPath);
return;
}
string libFile = Path.Combine(strClientPath, STEAM_LIBFILE);
List <string> libs = new()
{
strClientPath
};
int nLibs = 1;
try
{
if (File.Exists(libFile))
{
SteamWrapper document = new(libFile);
ACF_Struct documentData = document.ACFFileToStruct();
ACF_Struct folders = new();
if (documentData.SubACF.ContainsKey(STEAM_LIBARR))
{
folders = documentData.SubACF[STEAM_LIBARR];
}
else if (documentData.SubACF.ContainsKey(STEAM_LIBARR.ToLower()))
{
folders = documentData.SubACF[STEAM_LIBARR.ToLower()];
}
for (; nLibs <= STEAM_MAX_LIBS; ++nLibs)
{
folders.SubItems.TryGetValue(nLibs.ToString(), out string library);
if (string.IsNullOrEmpty(library))
{
if (folders.SubACF.ContainsKey(nLibs.ToString()))
{
folders.SubACF[nLibs.ToString()].SubItems.TryGetValue("path", out library);
}
if (string.IsNullOrEmpty(library))
{
nLibs--;
break;
}
}
library = Path.Combine(library, STEAM_PATH);
if (!library.Equals(strClientPath) && Directory.Exists(library))
{
libs.Add(library);
}
}
}
}
catch (Exception e)
{
CLogger.LogError(e, string.Format("Malformed {0} file: {1}", _name.ToUpper(), libFile));
nLibs--;
}
int i = 0;
List <string> allFiles = new();
foreach (string lib in libs)
{
List <string> libFiles = new();
try
{
libFiles = Directory.GetFiles(lib, "appmanifest_*.acf", SearchOption.TopDirectoryOnly).ToList();
allFiles.AddRange(libFiles);
CLogger.LogInfo("{0} {1} games found in library {2}", libFiles.Count, _name.ToUpper(), lib);
}
catch (Exception e)
{
CLogger.LogError(e, string.Format("{0} directory read error: {1}", _name.ToUpper(), lib));
continue;
}
foreach (string file in libFiles)
{
try
{
SteamWrapper document = new(file);
ACF_Struct documentData = document.ACFFileToStruct();
ACF_Struct app = documentData.SubACF["AppState"];
string id = app.SubItems["appid"];
if (id.Equals("228980")) // Steamworks Common Redistributables
{
continue;
}
string strID = Path.GetFileName(file);
string strTitle = app.SubItems["name"];
CLogger.LogDebug($"- {strTitle}");
string strLaunch = START_GAME + "/" + id;
string strIconPath = "";
string strUninstall = "";
string strAlias = "";
string strPlatform = GetPlatformString(ENUM);
strAlias = GetAlias(strTitle);
if (!string.IsNullOrEmpty(strLaunch))
{
using (RegistryKey key = Registry.LocalMachine.OpenSubKey(Path.Combine(NODE64_REG, STEAM_GAME_PREFIX + id), RegistryKeyPermissionCheck.ReadSubTree), // HKLM64
key2 = Registry.LocalMachine.OpenSubKey(Path.Combine(NODE32_REG, STEAM_GAME_PREFIX + id), RegistryKeyPermissionCheck.ReadSubTree)) // HKLM32
{
if (key != null)
{
strIconPath = GetRegStrVal(key, GAME_DISPLAY_ICON).Trim(new char[] { ' ', '"' });
}
else if (key2 != null)
{
strIconPath = GetRegStrVal(key2, GAME_DISPLAY_ICON).Trim(new char[] { ' ', '"' });
}
}
if (string.IsNullOrEmpty(strIconPath) && expensiveIcons)
{
bool success = false;
// Search for an .exe to use as icon
strIconPath = CGameFinder.FindGameBinaryFile(Path.Combine(lib, "common", app.SubItems["installdir"]), strTitle);
if (!string.IsNullOrEmpty(strIconPath))
{
success = true;
strAlias = GetAlias(Path.GetFileNameWithoutExtension(strIconPath));
if (strAlias.Length > strTitle.Length)
{
strAlias = GetAlias(strTitle);
}
}
if (!success && !(bool)(CConfig.GetConfigBool(CConfig.CFG_IMGDOWN)))
{
// Download missing icons
string iconUrl = $"https://cdn.cloudflare.steamstatic.com/steam/apps/{id}/capsule_184x69.jpg";
if (CDock.DownloadCustomImage(strTitle, iconUrl))
{
success = true;
}
}
}
if (strAlias.Equals(strTitle, CDock.IGNORE_CASE))
{
strAlias = "";
}
strUninstall = UNINST_GAME + "/" + id;
gameDataList.Add(new ImportGameData(strID, strTitle, strLaunch, strIconPath, strUninstall, strAlias, true, strPlatform));
}
}
catch (Exception e)
{
CLogger.LogError(e, string.Format("Malformed {0} file: {1}", _name.ToUpper(), file));
}
}
i++;
/*
* if (i > nLibs)
* CLogger.LogDebug("---------------------");
*/
}
// Get not-installed games
if (!(bool)CConfig.GetConfigBool(CConfig.CFG_INSTONLY))
{
// First get Steam user ID
ulong userId = (ulong)CConfig.GetConfigULong(CConfig.CFG_STEAMID);
if (userId < 1)
{
try
{
ulong userIdTmp = 0;
string userName = "";
string userNameTmp = "";
string strConfigPath = Path.Combine(strInstallPath, "config");
string appFile = Path.Combine(strConfigPath, STEAM_APPFILE);
if (File.Exists(appFile))
{
SteamWrapper appDoc = new(appFile);
ACF_Struct appDocData = appDoc.ACFFileToStruct();
ACF_Struct appData = appDocData.SubACF["SteamAppData"];
appData.SubItems.TryGetValue("AutoLoginUser", out userName);
SteamWrapper usrDoc = new(Path.Combine(strConfigPath, STEAM_USRFILE));
ACF_Struct usrDocData = usrDoc.ACFFileToStruct();
ACF_Struct usrData = usrDocData.SubACF["users"];
foreach (KeyValuePair <string, ACF_Struct> user in usrData.SubACF)
{
if (!ulong.TryParse(user.Key, out userIdTmp))
{
userIdTmp = 0;
}
foreach (KeyValuePair <string, string> userVal in user.Value.SubItems)
{
if (userVal.Key.Equals("AccountName"))
{
userNameTmp = userVal.Value;
if (userNameTmp.Equals(userName))
{
if (!ulong.TryParse(user.Key, out userId))
{
userId = 0;
}
}
}
if (userVal.Key.Equals("MostRecent") && userVal.Value.Equals("1") && string.IsNullOrEmpty(userName))
{
userId = userIdTmp;
userName = userNameTmp;
break;
}
}
}
if (userId < 1)
{
userId = userIdTmp;
userName = userNameTmp;
}
}
if (userId > 0)
{
CLogger.LogInfo("Setting default {0} user to {1} #{2}", _name.ToUpper(), userName, userId);
CConfig.SetConfigValue(CConfig.CFG_STEAMID, userId);
ExportConfig();
}
}
catch (Exception e)
{
CLogger.LogError(e, string.Format("Malformed {0} file: {1} or {2}", _name.ToUpper(), STEAM_APPFILE, STEAM_USRFILE));
}
}
if (userId > 0)
{
// Download game list from public user profile
try
{
string url = string.Format("https://steamcommunity.com/profiles/{0}/games/?tab=all", userId);
/*
#if DEBUG
* // Don't re-download if file exists
* string tmpfile = $"tmp_{NAME}.html";
* if (!File.Exists(tmpfile))
* {
* using (var client = new WebClient());
* client.DownloadFile(url, tmpfile);
* }
* HtmlDocument doc = new HtmlDocument
* {
* OptionUseIdAttribute = true
* };
* doc.Load(tmpfile);
#else
*/
HtmlWeb web = new()
{
UseCookies = true
};
HtmlDocument doc = web.Load(url);
doc.OptionUseIdAttribute = true;
//#endif
HtmlNode gameList = doc.DocumentNode.SelectSingleNode("//script[@language='javascript']");
if (gameList != null)
{
CLogger.LogDebug("{0} not-installed games (user #{1}):", _name.ToUpper(), userId);
var options = new JsonDocumentOptions
{
AllowTrailingCommas = true
};
string rgGames = gameList.InnerText.Remove(0, gameList.InnerText.IndexOf('['));
rgGames = rgGames.Remove(rgGames.IndexOf(';'));
using JsonDocument document = JsonDocument.Parse(@rgGames, options);
foreach (JsonElement game in document.RootElement.EnumerateArray())
{
ulong id = GetULongProperty(game, "appid");
if (id > 0)
{
// Check if game is already installed
string strID = $"appmanifest_{id}.acf";
bool found = false;
foreach (string file in allFiles)
{
if (file.EndsWith(strID))
{
found = true;
}
}
if (!found)
{
string strTitle = GetStringProperty(game, "name");
string strPlatform = GetPlatformString(ENUM);
// Add not-installed games
CLogger.LogDebug($"- *{strTitle}");
gameDataList.Add(new ImportGameData(strID, strTitle, "", "", "", "", false, strPlatform));
// Use logo to download not-installed icons
if (!(bool)(CConfig.GetConfigBool(CConfig.CFG_IMGDOWN)))
{
string iconUrl = GetStringProperty(game, "logo");
CDock.DownloadCustomImage(strTitle, iconUrl);
}
}
}
}
}
else
{
CLogger.LogInfo("Can't get not-installed {0} games. Profile may not be public.\n" +
"To change this, go to <https://steamcommunity.com/my/edit/settings>.",
_name.ToUpper());
}
/*
#if DEBUG
* File.Delete(tmpfile);
#endif
*/
}
catch (Exception e)
{
CLogger.LogError(e);
}
CLogger.LogDebug("---------------------");
}
}
}
public void GetGames(List <ImportGameData> gameDataList, bool expensiveIcons = false)
{
List <RegistryKey> keyList;
List <string> uplayIds = new();
List <string> uplayIcons = new();
string launcherPath = "";
string strPlatform = GetPlatformString(ENUM);
using (RegistryKey launcherKey = Registry.LocalMachine.OpenSubKey(Path.Combine(NODE32_REG, UPLAY_UNREG), RegistryKeyPermissionCheck.ReadSubTree)) // HKLM32
{
if (launcherKey == null)
{
CLogger.LogInfo("{0} client not found in the registry.", _name.ToUpper());
return;
}
launcherPath = GetRegStrVal(launcherKey, GAME_INSTALL_LOCATION);
}
using (RegistryKey key = Registry.LocalMachine.OpenSubKey(NODE32_REG, RegistryKeyPermissionCheck.ReadSubTree)) // HKLM32
{
keyList = FindGameFolders(key, UPLAY_PREFIX);
CLogger.LogInfo("{0} {1} games found", keyList.Count, _name.ToUpper());
foreach (var data in keyList)
{
string loc = GetRegStrVal(data, GAME_INSTALL_LOCATION);
string strID = "";
string strTitle = "";
string strLaunch = "";
string strIconPath = "";
string strUninstall = "";
string strAlias = "";
try
{
strID = Path.GetFileName(data.Name);
uplayIds.Add(strID);
strTitle = GetRegStrVal(data, GAME_DISPLAY_NAME);
CLogger.LogDebug($"- {strTitle}");
strLaunch = START_GAME + GetGameID(strID);
strIconPath = GetRegStrVal(data, GAME_DISPLAY_ICON).Trim(new char[] { ' ', '"' });
uplayIcons.Add(strIconPath);
if (string.IsNullOrEmpty(strIconPath) && expensiveIcons)
{
strIconPath = CGameFinder.FindGameBinaryFile(loc, strTitle);
}
strUninstall = GetRegStrVal(data, GAME_UNINSTALL_STRING); //.Trim(new char[] { ' ', '"' });
strAlias = GetAlias(Path.GetFileNameWithoutExtension(loc.Trim(new char[] { ' ', '\'', '"' }).Trim(new char[] { '/', '\\' })));
if (strAlias.Length > strTitle.Length)
{
strAlias = GetAlias(strTitle);
}
if (strAlias.Equals(strTitle, CDock.IGNORE_CASE))
{
strAlias = "";
}
}
catch (Exception e)
{
CLogger.LogError(e);
}
if (!(string.IsNullOrEmpty(strLaunch)))
{
gameDataList.Add(
new ImportGameData(strID, strTitle, strLaunch, strIconPath, strUninstall, strAlias, true, strPlatform));
}
}
}
// Get not-installed games
if (!(bool)CConfig.GetConfigBool(CConfig.CFG_INSTONLY) && !(string.IsNullOrEmpty(launcherPath)))
{
string uplayCfgFile = Path.Combine(launcherPath, @"cache\configuration\configurations");
try
{
if (File.Exists(uplayCfgFile))
{
char[] trimChars = { ' ', '\'', '"' };
List <string> uplayCfg = new();
int nGames = 0;
bool dlc = false;
string strID = "";
string strTitle = "";
string strIconPath = "";
CLogger.LogDebug("{0} not-installed games:", _name.ToUpper());
uplayCfg.AddRange(File.ReadAllLines(uplayCfgFile));
foreach (string line in uplayCfg) // Note if the last game is valid, this method won't catch it; but that appears very unlikely
{
if (line.Trim().StartsWith("root:"))
{
if (nGames > 0 && !(string.IsNullOrEmpty(strID)) && dlc == false)
{
bool found = false;
foreach (string id in uplayIds)
{
if (id.Equals(strID))
{
found = true;
}
}
if (!found)
{
// The Uplay ID is not always available, so this is an alternative test
// However, if user has e.g., a demo and the full game installed, this might get a false negative
foreach (string icon in uplayIcons)
{
if (Path.GetFileName(icon).Equals(Path.GetFileName(strIconPath)))
{
found = true;
}
}
}
if (!found)
{
strTitle = strTitle.Replace("''", "'");
CLogger.LogDebug($"- *{strTitle}");
gameDataList.Add(
new ImportGameData(strID, strTitle, "", strIconPath, "", "", false, strPlatform));
}
}
nGames++;
dlc = false;
strID = "";
strTitle = "";
strIconPath = "";
}
if (dlc == true)
{
continue;
}
else if (line.Trim().StartsWith("is_dlc: yes"))
{
dlc = true;
continue;
}
else if (string.IsNullOrEmpty(strTitle) && line.Trim().StartsWith("name: "))
{
strTitle = line[(line.IndexOf("name:") + 6)..].Trim(trimChars);
public void GetGames(List <ImportGameData> gameDataList, bool expensiveIcons = false)
{
List <string> dirs = new();
// Get installed games
if (OperatingSystem.IsWindows())
{
using RegistryKey key = Registry.LocalMachine.OpenSubKey(PARADOX_REG, RegistryKeyPermissionCheck.ReadSubTree); // HKLM32
if (key == null)
{
CLogger.LogInfo("{0} client not found in the registry.", _name.ToUpper());
}
else
{
string path = GetRegStrVal(key, PARADOX_PATH);
try
{
if (!path.Equals(null) && Directory.Exists(path))
{
dirs.AddRange(Directory.GetDirectories(Path.Combine(Directory.GetParent(Directory.GetParent(path).ToString()).ToString(), "games"), "*.*", SearchOption.TopDirectoryOnly));
foreach (string dir in dirs)
{
CultureInfo ci = new("en-GB");
TextInfo ti = ci.TextInfo;
string strID = Path.GetFileName(dir);
string strTitle = "";
string strLaunch = "";
string strAlias = "";
string strPlatform = GetPlatformString(ENUM);
strTitle = ti.ToTitleCase(strID.Replace('_', ' '));
CLogger.LogDebug($"- {strTitle}");
strLaunch = CGameFinder.FindGameBinaryFile(dir, strTitle);
strAlias = GetAlias(Path.GetFileNameWithoutExtension(strLaunch));
if (strAlias.Length > strTitle.Length)
{
strAlias = GetAlias(strTitle);
}
if (strAlias.Equals(strTitle, CDock.IGNORE_CASE))
{
strAlias = "";
}
if (!(string.IsNullOrEmpty(strLaunch)))
{
gameDataList.Add(
new ImportGameData(strID, strTitle, strLaunch, strLaunch, "", strAlias, true, strPlatform));
}
}
}
}
catch (Exception e)
{
CLogger.LogError(e);
}
}
}
// Get not-installed games
if (!(bool)CConfig.GetConfigBool(CConfig.CFG_INSTONLY))
{
string folder = Path.Combine(GetFolderPath(SpecialFolder.LocalApplicationData), PARADOX_JSON);
if (!Directory.Exists(folder))
{
CLogger.LogInfo("{0} games not found in Local AppData.", _name.ToUpper());
}
else
{
CLogger.LogDebug("{0} not-installed games:", _name.ToUpper());
string[] files = Directory.GetFiles(folder, "*.json", SearchOption.TopDirectoryOnly);
foreach (string file in files)
{
if (file.EndsWith("_installableGames.json") && !(file.StartsWith("_noUser")))
{
string strDocumentData = File.ReadAllText(file);
if (string.IsNullOrEmpty(strDocumentData))
{
continue;
}
try
{
using JsonDocument document = JsonDocument.Parse(@strDocumentData, jsonTrailingCommas);
document.RootElement.TryGetProperty("content", out JsonElement content);
if (!content.Equals(null))
{
foreach (JsonElement game in content.EnumerateArray())
{
game.TryGetProperty("_name", out JsonElement id);
// Check if game is already installed
bool found = false;
foreach (string dir in dirs)
{
if (id.ToString().Equals(Path.GetFileName(dir)))
{
found = true;
}
}
if (!found)
{
game.TryGetProperty("_displayName", out JsonElement title);
game.TryGetProperty("_owned", out JsonElement owned);
if (!id.Equals(null) && !title.Equals(null) && owned.ToString().ToLower().Equals("true"))
{
string strID = id.ToString();
string strTitle = title.ToString();
CLogger.LogDebug($"- *{strTitle}");
string strPlatform = GetPlatformString(ENUM);
gameDataList.Add(new ImportGameData(strID, strTitle, "", "", "", "", false, strPlatform));
}
}
}
}
}
catch (Exception e)
{
CLogger.LogError(e, string.Format("Malformed {0} file: {1}", _name.ToUpper(), file));
}
}
}
}
}
CLogger.LogDebug("--------------------");
}
/// <summary>
/// Run the main program loop.
/// Return when game is launched or the user decided to exit.
/// </summary>
public void MainLoop()
{
CJsonWrapper.ImportFromJSON();
CGameFinder.CheckCustomFolder();
int nSelectionCode, nSelectionIndex;
for (; ;)
{
MenuSwitchboard(out nSelectionCode, out nSelectionIndex);
switch ((DockSelection)nSelectionCode)
{
case DockSelection.cSel_Help:
DisplayHelp();
continue;
case DockSelection.cSel_Exit: // Exit application
return;
case DockSelection.cSel_Back: // Go back to first menu
m_nFirstSelection = -1;
continue;
case DockSelection.cSel_Fav: // Toggle game favourite
if (m_nFirstSelection > -1)
{
CGameData.ToggleFavourite((CGameData.GamePlatform)m_nFirstSelection, nSelectionIndex);
CJsonWrapper.Export(CGameData.GetPlatformGameList(CGameData.GamePlatform.All).ToList());
}
continue;
case DockSelection.cSel_Rescan: // Rescan the game list
if (m_nFirstSelection < 0)
{
Console.Clear();
Console.Write("Scanning for games...");
Logger.CLogger.LogInfo("Scanning for games...");
CRegScanner.ScanGames();
}
continue;
case DockSelection.cSel_Default: // Possible valid platform/game selection
default:
break;
}
if (nSelectionIndex > -1)
{
if (m_nFirstSelection < 0)
{
m_nFirstSelection = nSelectionIndex;
}
else if (m_nSecondSelection < 0)
{
m_nSecondSelection = nSelectionIndex;
}
}
if (m_nSecondSelection > -1)
{
CGameData.CGame selectedGame = CGameData.GetPlatformGame((CGameData.GamePlatform)m_nFirstSelection, m_nSecondSelection);
if (StartGame(selectedGame))
{
return;
}
else
{
CGameData.RemoveGame(selectedGame);
CJsonWrapper.Export(CGameData.GetPlatformGameList(CGameData.GamePlatform.All).ToList());
}
}
}
}
public void GetGames(List <ImportGameData> gameDataList, bool expensiveIcons = false)
{
List <RegistryKey> keyList = new();
// Get installed games
using (RegistryKey key = Registry.CurrentUser.OpenSubKey(LEG_REG, RegistryKeyPermissionCheck.ReadSubTree)) // HKLM64
{
keyList = FindGameFolders(key, "");
CLogger.LogInfo("{0} {1} games found", keyList.Count, _name.ToUpper());
foreach (var data in keyList)
{
string strID = "";
string strTitle = "";
string strLaunch = "";
string strIconPath = "";
string strUninstall = "";
string strAlias = "";
string strPlatform = GetPlatformString(ENUM);
try
{
strID = GetRegStrVal(data, "InstallerUUID");
if (string.IsNullOrEmpty(strID))
{
strID = data.Name;
}
strTitle = GetRegStrVal(data, "ProductName");
if (string.IsNullOrEmpty(strTitle))
{
strTitle = data.Name;
}
CLogger.LogDebug($"- {strTitle}");
string exeFile = GetRegStrVal(data, "GameExe");
strLaunch = Path.Combine(GetRegStrVal(data, "InstDir").Trim(new char[] { ' ', '"' }), exeFile);
if (expensiveIcons)
{
using RegistryKey key2 = Registry.LocalMachine.OpenSubKey(NODE32_REG, RegistryKeyPermissionCheck.ReadSubTree), // HKLM32
key3 = Registry.LocalMachine.OpenSubKey(NODE64_REG, RegistryKeyPermissionCheck.ReadSubTree); // HKLM64
List <RegistryKey> unList = FindGameKeys(key2, GAME_DISPLAY_NAME, strTitle, new string[] { "Legacy Games Launcher" });
if (unList.Count <= 0)
{
unList = FindGameKeys(key3, GAME_DISPLAY_NAME, strTitle, new string[] { "Legacy Games Launcher" });
}
foreach (RegistryKey unKey in unList)
{
strUninstall = GetRegStrVal(unKey, GAME_UNINSTALL_STRING); //.Trim(new char[] { ' ', '"' });
strIconPath = GetRegStrVal(unKey, GAME_DISPLAY_ICON); //.Trim(new char[] { ' ', '"' });
break;
}
}
if (string.IsNullOrEmpty(strIconPath))
{
strIconPath = strLaunch;
}
strAlias = GetAlias(Path.GetFileNameWithoutExtension(exeFile));
if (strAlias.Length > strTitle.Length)
{
strAlias = GetAlias(strTitle);
}
if (strAlias.Equals(strTitle, CDock.IGNORE_CASE))
{
strAlias = "";
}
}
catch (Exception e)
{
CLogger.LogError(e);
}
if (!(string.IsNullOrEmpty(strLaunch)))
{
gameDataList.Add(
new ImportGameData(strID, strTitle, strLaunch, strIconPath, strUninstall, strAlias, true, strPlatform));
}
}
}
if (expensiveIcons && keyList.Count <= 0)
{
// if no games found in registry, check manually
List <string> libPaths = new();
string file = Path.Combine(GetFolderPath(SpecialFolder.ApplicationData), LEG_JSON);
if (!File.Exists(file))
{
CLogger.LogInfo("{0} installed games not found in AppData", _name.ToUpper());
return;
}
else
{
string strDocumentData = File.ReadAllText(file);
if (string.IsNullOrEmpty(strDocumentData))
{
CLogger.LogWarn(string.Format("Malformed {0} file: {1}", _name.ToUpper(), file));
}
else
{
try
{
using JsonDocument document = JsonDocument.Parse(@strDocumentData, jsonTrailingCommas);
foreach (JsonElement element in document.RootElement.EnumerateArray())
{
element.TryGetProperty("settings", out JsonElement settings);
if (!settings.Equals(null))
{
settings.TryGetProperty("gameLibraryPath", out JsonElement paths);
if (!paths.Equals(null))
{
foreach (JsonElement path in paths.EnumerateArray())
{
if (!path.Equals(null))
{
libPaths.Add(path.ToString());
}
}
}
}
}
}
catch (Exception e)
{
CLogger.LogError(e, string.Format("Malformed {0} file: {1}", _name.ToUpper(), file));
}
}
}
foreach (string path in libPaths)
{
List <string> dirs = new();
try
{
if (!path.Equals(null) && Directory.Exists(path))
{
dirs.AddRange(Directory.GetDirectories(path, "*.*", SearchOption.TopDirectoryOnly));
foreach (string dir in dirs)
{
string strID = Path.GetFileName(dir);
string strLaunch = "";
string strAlias = "";
string strPlatform = GetPlatformString(ENUM);
CLogger.LogDebug($"- {strID}");
strLaunch = CGameFinder.FindGameBinaryFile(dir, strID);
strAlias = GetAlias(Path.GetFileNameWithoutExtension(strLaunch));
if (strAlias.Length > strID.Length)
{
strAlias = GetAlias(strID);
}
if (strAlias.Equals(strID, CDock.IGNORE_CASE))
{
strAlias = "";
}
if (!(string.IsNullOrEmpty(strLaunch)))
{
gameDataList.Add(
new ImportGameData(strID, strID, strLaunch, strLaunch, "", strAlias, true, strPlatform));
}
}
}
}
catch (Exception e)
{
CLogger.LogError(e);
}
}
}
CLogger.LogDebug("--------------------");
}
