public static IEnumerable <LoginUsers> GetLoginUsers()
{
dynamic volvo = VdfConvert.Deserialize(GetLoginUsersConfig());
VToken v2 = volvo.Value;
return(v2.Children().Select(child => new LoginUsers(child)).Where(user => user.RememberPassword).ToList());
}
private void Parse(string path)
{
VObject vObject = (VObject)VdfConvert.Deserialize(File.ReadAllText(path).Replace(@"\", @"\\")).Value;
DepotId = int.Parse(vObject["DepotID"].ToString());
ContentRoot = vObject["ContentRoot"].ToString();
foreach (VProperty child in vObject.Children())
{
switch (child.Key)
{
case "FileMapping":
VObject mapping = (VObject)child.Value;
FileMappings.Add(new FileMapping {
LocalPath = mapping["LocalPath"].ToString(),
DepotPath = mapping["DepotPath"].ToString(),
Recursive = int.Parse(mapping["recursive"].ToString())
});
break;
case "FileExclusion":
FileExclusions.Add(new FileExclusion(child.Value.ToString()));
break;
default:
continue;
}
}
}
private void FindSteamDirectories()
{
if (File.Exists(Steam.MainSteamDir + "/steamapps/libraryfolders.vdf"))
{
dynamic library =
VdfConvert.Deserialize(File.ReadAllText(Steam.MainSteamDir + "/steamapps/libraryfolders.vdf")).ToJson();
bool addingDirectory = true;
int directoryCount = 1;
Steam.AdditionalSteamDirectories.Clear();
while (addingDirectory)
{
if (library.Value[directoryCount.ToString()] != null)
{
Steam.AdditionalSteamDirectories.Add(library.Value[directoryCount.ToString()].ToString());
directoryCount++;
}
else
{
addingDirectory = false;
}
}
richTextBoxAdditionalSteamDirectory.Lines = Steam.AdditionalSteamDirectories.ToArray();
}
CheckGamesInstalled();
}
public static ConfigSteamData GetSteamConfig() => TryOrDefault(() =>
{
var result = new ConfigSteamData();
var libraryPaths = new List <string>();
var steamPath = new DirectoryInfo(GetSteamData().SteamPath).FullName;
var configPath = Path.Combine(steamPath, "config", "config.vdf");
libraryPaths.Add(Path.Combine(steamPath, "steamapps"));
try {
dynamic configObject = VdfConvert.Deserialize(File.ReadAllText(configPath)).Value;
dynamic valve;
try {
valve = configObject.Software.Valve;
} catch {
valve = configObject.Software.valve;
}
var configLibraryPaths = ((VObject)valve.Steam)
.Children()
.Where(item => item.Key.StartsWith("BaseInstallFolder"))
.Select(item => item.Value.ToString())
.Select(line => new DirectoryInfo(line).FullName)
.Select(line => Path.Combine(line, "steamapps"));
libraryPaths.AddRange(configLibraryPaths);
} catch { }
result.SteamLibraryFolders = libraryPaths.ToArray();
return(result);
});
public static string GetSteamIdFromConfig(string userName)
{
dynamic steamId = null;
try
{
string steamPath = new IniFile(SAMSettings.FILE_NAME).Read(SAMSettings.STEAM_PATH, SAMSettings.SECTION_STEAM);
// Attempt to find Steam Id from steam config.
dynamic config = VdfConvert.Deserialize(File.ReadAllText(steamPath + "config\\config.vdf"));
dynamic accounts = config.Value.Software.Valve.Steam.Accounts;
VObject accountsObj = accounts;
VToken value;
accountsObj.TryGetValue(userName, out value);
dynamic user = value;
VValue userId = user.SteamID;
steamId = userId.Value.ToString();
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
}
return(Convert.ToString(steamId));
}
/// <summary>
/// Gets the library folders in this Steam installation.
/// </summary>
/// <returns>Returns an <see cref="IEnumerable{T}"/> of <see cref="DirectoryInfo"/> instances.</returns>
public async Task <IEnumerable <DirectoryInfo> > GetLibraryFoldersAsync()
{
if (!this.IsInstalled)
{
return(Array.Empty <DirectoryInfo>());
}
List <DirectoryInfo> libraryFolders = new List <DirectoryInfo>
{
// steam install directory is the default library folder
this.InstallDirectory
};
string vdfPath = Path.Combine(this.InstallDirectory.ToString(), @"steamapps", @"libraryfolders.vdf");
using (StreamReader reader = new StreamReader(Path.GetFullPath(vdfPath)))
{
string contents = await reader.ReadToEndAsync().ConfigureAwait(false);
JToken json = VdfConvert.Deserialize(contents).Value.ToJson();
libraryFolders.AddRange(JsonHelpers.IterateStringKeys(json)
.Select(s => new DirectoryInfo(s)));
}
return(libraryFolders);
}
private VProperty GetGameInfo()
{
var fileText = File.ReadAllText(_path, Windows1252);
var info = EnableFormatting ? VdfConvert.Deserialize(fileText, VdfSerializerSettings.Common) : VdfConvert.Deserialize(fileText, VdfSerializerSettings.Default);
return(info);
}
public Dictionary <string, SteamUserInfo> get()
{
FileStream fs = File.OpenRead(Path);
StringBuilder sb = new StringBuilder();
int code = 0;
do
{
byte[] bt = new byte[fs.Length > 1024 ? 1024 : fs.Length];
code = fs.Read(bt, 0, bt.Length);
sb.Append(UTF8Encoding.UTF8.GetString(bt));
} while (code == 1024);
fs.Close();
VProperty v = VdfConvert.Deserialize(sb.ToString());
VToken[] keys = v.Value.ToArray <VToken>();
Dictionary <string, SteamUserInfo> list = new Dictionary <string, SteamUserInfo>();
foreach (VToken vt in keys)
{
dynamic data = vt;
SteamUserInfo user = new SteamUserInfo();
user.user = data.Value.AccountName.ToString();
user.id64 = data.Key;
user.name = data.Value.PersonaName.ToString();
list.Add(data.Key, user);
}
return(list);
}
public static List <string> FindSteamLibraries(string steam)
{
dynamic vdf = VdfConvert.Deserialize(File.ReadAllText(string.Join(Path.DirectorySeparatorChar, new List <string> {
steam, "config", "config.vdf"
})));
List <string> libraries = new List <string>();
if (Directory.Exists(string.Join(Path.DirectorySeparatorChar, new List <string> {
steam, "steamapps"
})))
{
libraries.Add(string.Join(Path.DirectorySeparatorChar, new List <string> {
steam, "steamapps"
}));
}
try {
foreach (VProperty child in ((VObject)vdf.Value.Software.valve.steam).Children())
{
if (child.Key.StartsWith("BaseInstallFolder_"))
{
libraries.Add(string.Join(Path.DirectorySeparatorChar, new List <string> {
child.Value.ToString(), "steamapps"
}));
}
}
} catch (Exception) {
return(null);
}
return(libraries);
}
private void load()
{
String strSteamInstallPath = Registry.LocalMachine.OpenSubKey("SOFTWARE\\Valve\\Steam").GetValue("InstallPath").ToString();
Console.WriteLine(strSteamInstallPath);
VProperty volvo = VdfConvert.Deserialize(File.ReadAllText(strSteamInstallPath + "\\config\\loginusers.vdf"));
foreach (VToken vt in volvo.Value.ToList())
{
dynamic user = VdfConvert.Deserialize(vt.ToString());
Int64 steamId = Convert.ToInt64(user.Key);
String accountName = user.Value.AccountName.ToString();
String personalName = user.Value.PersonaName.ToString();
Console.WriteLine(accountName);
Image picture;
try
{
picture = Image.FromFile(strSteamInstallPath + "\\config\\avatarcache\\" + steamId + ".png");
}
catch (FileNotFoundException E)
{
picture = Easy_switch.Properties.Resources.questionPicture;
}
flPanel.Controls.Add(createPanel(picture, accountName, personalName));
flPanel.Update();
flPanel.Show();
}
}
public static string[] GetSteamLibraryPaths()
{
string[] libraryPaths = Array.Empty <string>();
using (RegistryKey hklm = RegistryKey.OpenBaseKey(RegistryHive.LocalMachine, RegistryView.Registry64))// Doesn't work in 32 bit mode without this
{
using (RegistryKey steamKey = hklm?.OpenSubKey(STEAM_PATH_KEY))
{
string path = (string)steamKey?.GetValue("InstallPath", string.Empty);
if (path != null && path.Length > 0)
{
string configPath = Path.Combine(path, STEAM_CONFIG_PATH);
if (File.Exists(configPath))
{
VProperty v = VdfConvert.Deserialize(File.ReadAllText(configPath));
VToken ics = v?.Value;
VToken soft = ics?["Software"];
VToken valve = soft?["Valve"];
VObject steamSettings = valve?["Steam"] as VObject;
VProperty[] settings = steamSettings?.Children <VProperty>()?.ToArray();
if (settings != null)
{
libraryPaths = settings.Where(p => p.Key.StartsWith("BaseInstallFolder"))
.Select(p => p.Value.ToString()).ToArray();
}
}
}
}
}
return(libraryPaths);
}
public List <string> GetSteamLibraries(string steamInstallationPath)
{
List <string> libraryDirectories = new List <string>
{
System.IO.Path.Combine(steamInstallationPath, "steamapps")
};
string libraryVdfPath = System.IO.Path.Combine(steamInstallationPath, "steamapps", "libraryfolders.vdf");
dynamic vdf = VdfConvert.Deserialize(File.ReadAllText(libraryVdfPath));
for (int i = 1; true; i++)
{
string libraryIndex = i.ToString();
var libraryPath = vdf.Value[libraryIndex];
if (libraryPath != null)
{
string libraryAppsPath = System.IO.Path.Combine(libraryPath.ToString(), "steamapps");
logger.Info("Found Steam library: " + libraryAppsPath);
if (!Directory.Exists(libraryAppsPath))
{
logger.Info("Steam library doesn't exist: " + libraryAppsPath);
continue;
}
libraryDirectories.Add(libraryAppsPath);
}
else
{
break;
}
}
return(libraryDirectories);
}
public void CommentsDeserializeCorrectly()
{
const string vdf = @"
// Comment type A (at the start of the file)
""root""
{
// Comment type B (as a child to an object)
key1 ""value1""
""key2"" // Comment type C (to the right of a property name)
{
""key3"" ""value3"" // Comment type D (to the right of a property value)
}
}
// Comment type E (at the end of the file)
";
VProperty result = VdfConvert.Deserialize(vdf);
VProperty expected = new VProperty("root", new VObject
{
VValue.CreateComment(" Comment type B (as a child to an object)"),
new VProperty("key1", new VValue("value1")),
new VProperty("key2", new VObject
{
new VProperty("key3", new VValue("value3")),
VValue.CreateComment(" Comment type D (to the right of a property value)"),
}),
});
Assert.True(VToken.DeepEquals(result, expected));
}
void GetCraftbotPath()
{
// Get Steam location from registry
SteamInstallPath = (String)Registry.GetValue("HKEY_CURRENT_USER\\Software\\Valve\\Steam", "SteamPath", "NOT FOUND");
Debug.Print("SteamPath: \"{0}\"", SteamInstallPath);
if (!Directory.Exists(SteamInstallPath))
{
SteamError();
}
// Turning VDF into JSON, because it's not possible to select the "1" key with VDF
// Unique case worth fixing:
// TODO: Fix exception when installation on external drive is disconnected
dynamic libraryfoldersjson = new VProperty();
try
{
libraryfoldersjson = VdfConvert.Deserialize(File.ReadAllText(SteamInstallPath + "\\steamapps\\libraryfolders.vdf")).Value.ToJson();
}
catch
{
SteamError();
}
if (File.Exists(SteamInstallPath + "\\steamapps\\appmanifest_387990.acf"))
{
CraftingPath = SteamInstallPath + "\\steamapps\\common\\Scrap Mechanic\\Survival\\CraftingRecipes\\";
}
else
{
CraftingPath = libraryfoldersjson.Value <String>("1") + "\\steamapps\\common\\Scrap Mechanic\\Survival\\CraftingRecipes\\";
}
Debug.Print("Registered steam: " + SteamInstallPath);
Debug.Print("Game Path: " + CraftingPath);
}
private void LoadSteamConfig()
{
Logger.LogInformation("Loading Steam system configuration.");
var steamKey = Registry.CurrentUser.OpenSubKey(@"Software\Valve\Steam");
if (steamKey == null)
{
Logger.LogError("Steam could not be detected from the registry.");
return;
}
var installDir = (string)steamKey.GetValue("SteamPath");
Logger.LogInformation($"Found Steam at {installDir}");
Cache.LibraryPaths.Add(Path.Combine(installDir, @"steamapps\common"));
try
{
_configVdf = VdfConvert.Deserialize(File.ReadAllText($@"{installDir}\config\config.vdf"));
}
catch (Exception e)
{
Logger.LogError(e, "Encountered an exception while reading the VDF. Steam configuration will not be loaded.");
return;
}
Logger.LogInformation("Steam configuration loaded successfully.");
}
private static IObservable <IInstall> FindSteamInstall()
{
return(Observable
.Create <SteamInstall>(obs =>
{
var steamDirectory = "C:/Program Files (x86)/Steam";
if (!Directory.Exists(steamDirectory))
{
throw new Exception("Unable to find steam install");
}
// Find all game libraries steam knows about.
var libraryFoldersVdfPath = "C:/Program Files (x86)/Steam/steamapps/libraryfolders.vdf";
var allLibraryFolders = new List <string> {
steamDirectory
};
if (File.Exists(libraryFoldersVdfPath))
{
var libraries = VdfConvert.Deserialize(File.ReadAllText(libraryFoldersVdfPath));
if (libraries.Key == "LibraryFolders")
{
foreach (var item in libraries.Value.Where(v => v.Type == VTokenType.Property))
{
var prop = item as VProperty;
var value = prop.Value as VValue;
if (Directory.Exists(value.Value as string))
{
allLibraryFolders.Add(value.Value as string);
}
}
}
}
// Check for SMNCs APPID folder in all the linstall directories
foreach (var library in allLibraryFolders)
{
var steamapps = Path.Combine(library, "steamapps");
foreach (var file in Directory.GetFiles(steamapps, "*.acf"))
{
dynamic acf = VdfConvert.Deserialize(File.ReadAllText(file));
VValue appid = acf.Value.appid;
if (appid.Value as string == "104700")
{
VValue installdir = acf.Value.installdir;
obs.OnNext(new SteamInstall(Path.Combine(steamapps, "common", installdir.Value as string)));
obs.OnCompleted();
return Disposable.Empty;
}
}
}
obs.OnError(new DirectoryNotFoundException("Unable to find a steam install of SMNC"));
return Disposable.Empty;
}));
}
/// <summary>
/// Attempts to locate all the steam install folders from the steam VDF config file.
/// Note: This does NOT include the actual steam install folder.
///
/// The result of this operation should be appended along with the "{steamFolder}\steamapps\steamapps" folder.
/// </summary>
/// <param name="vdf"></param>
/// <returns></returns>
public static List <string> ExtractSteamLibraryPaths(string vdf)
{
List <string> paths = new List <string>();
if (File.Exists(vdf))
{
dynamic config = VdfConvert.Deserialize(File.ReadAllText(vdf));
var root = config.Value;
for (int i = 0; i < 8; i++)
{
try {
paths.Add(root[$"{i}"].path.ToString());
}
catch (KeyNotFoundException) {
Logger.Debug($"Key #{i} not found, stopping parse of steam config");
return(paths);
}
catch (RuntimeBinderException) {
Logger.Debug($"Key #{i} not found, stopping parse of steam config");
return(paths);
}
}
}
return(paths);
}
public static void VdfNetDeserializeIterations(string vdf, int numIterations)
{
for (int index = 0; index < numIterations; index++)
{
VdfConvert.Deserialize(vdf);
}
}
private void ParseVDFLibraries(string libraryFile, ref List <string> directories)
{
try
{
VProperty library = VdfConvert.Deserialize(File.ReadAllText(libraryFile));
foreach (var child in library?.Value?.Children())
{
VProperty prop = child as VProperty;
if (prop == null)
{
Logger.Instance.LogMessage(TracingLevel.WARN, $"{this.GetType()} ParseVDFLibraries failed to convert entity to VProperty: {child}");
continue;
}
// Folders have a numeric value
if (!Int32.TryParse(prop.Key, out _))
{
continue;
}
string path = string.Empty;
if (prop.Value.Type == VTokenType.Value)
{
path = prop.Value?.ToString();
if (String.IsNullOrEmpty(path) || !Directory.Exists(path))
{
Logger.Instance.LogMessage(TracingLevel.WARN, $"{this.GetType()} ParseVDFLibraries (Old Format) failed to locate path: {prop}");
continue;
}
}
else if (prop.Value.Type == VTokenType.Object)
{
path = prop.Value?["path"]?.ToString();
if (string.IsNullOrEmpty(path))
{
Logger.Instance.LogMessage(TracingLevel.WARN, $"{this.GetType()} ParseVDFLibraries failed to locate path: {prop}");
continue;
}
string mounted = prop.Value?["mounted"]?.ToString() ?? "1";
if (mounted != "1")
{
Logger.Instance.LogMessage(TracingLevel.WARN, $"{this.GetType()} ParseVDFLibraries skipping unmounted folder: {path}");
continue;
}
}
else
{
Logger.Instance.LogMessage(TracingLevel.WARN, $"{this.GetType()} ParseVDFLibraries invalid property type: {prop.Value.Type} for {prop}");
continue;
}
directories.Add(Path.Combine(path, STEAM_APPS_DIR));
}
}
catch (Exception ex)
{
Logger.Instance.LogMessage(TracingLevel.ERROR, $"{this.GetType()} ParseVDFLibraries Exception: {ex}");
}
}
/// <summary>
/// Attempts to find a Steam game by its app ID across all Steam libraries.
/// </summary>
/// <param name="appId">The app ID of the sought game.</param>
/// <returns>The path to the game, or null if it can't be found.</returns>
public static string FindGame(int appId)
{
var appManifestRegex = new Regex(@"^appmanifest_(\d+).acf$");
foreach (var library in GetLibraries())
{
// Look for appmanifest_###.acf files in the library's steamapps folder
var steamapps = $"{library}\\steamapps\\";
foreach (var filePath in Directory.GetFiles(steamapps))
{
var fileName = Path.GetFileName(filePath);
var match = appManifestRegex.Match(fileName);
if (match.Success)
{
// This is an appmanifest - find its ID
var thisId = int.Parse(match.Groups[1].Value);
if (appId == thisId)
{
// This is the app we were looking for - find the installation path
var configFileText = File.ReadAllText(filePath);
dynamic config = VdfConvert.Deserialize(configFileText);
var installFolder = config.Value.installdir.Value;
return($"{library}\\steamapps\\common\\{installFolder}");
}
}
}
}
return(null);
}
public string GetRelativeInstallDirectory()
{
var manifest = VdfConvert.Deserialize(_manifestFileReader.ReadToEnd());
var children = manifest.Value.Children <VProperty>();
return(children.FirstOrDefault(x => x.Key == "installdir")?.Value?.ToString());
}
public List <GameRom> GetSteamGame(Emulator emu)
{
string steamfolder;
var key64 = @"HKEY_LOCAL_MACHINE\SOFTWARE\Wow6432Node\Valve\Steam";
var key32 = @"HKEY_LOCAL_MACHINE\SOFTWARE\Valve\Steam";
if (Environment.Is64BitOperatingSystem)
{
steamfolder = (string)Microsoft.Win32.Registry.GetValue(key64, "InstallPath", string.Empty);
}
else
{
steamfolder = (string)Microsoft.Win32.Registry.GetValue(key32, "InstallPath", string.Empty);
}
if (steamfolder != null)
{
List <string> foldersTosearch = new List <string>();
foldersTosearch.Add(Path.Combine(steamfolder, "steamapps"));
VProperty volvo = VdfConvert.Deserialize(File.ReadAllText(Path.Combine(steamfolder, "steamapps", "libraryfolders.vdf")));
var childs = volvo.Value.Children();
foreach (var child in childs)
{
var childKV = (VProperty)child;
var childValueKV = childKV.Value;
var pathchildKV = childValueKV.FirstOrDefault();
if (pathchildKV != null)
{
//if (Directory.Exists(((VProperty)child).Value.ToString()))
if (Directory.Exists(((VProperty)pathchildKV).Value.ToString()))
{
foldersTosearch.Add(Path.Combine(((VProperty)pathchildKV).Value.ToString(), "steamapps"));
}
}
}
List <GameRom> gamesfind = new List <GameRom>();
List <String> appmanifestfiles = new List <string>();
foreach (string foldertoSeek in foldersTosearch)
{
appmanifestfiles.AddRange(Directory.GetFiles(foldertoSeek, "appmanifest_*.acf").ToList());
}
foreach (var file in appmanifestfiles)
{
dynamic appfile = VdfConvert.Deserialize(File.ReadAllText(file));
GameRom game = new GameRom();
game.EmulatorID = emu.EmulatorID;
game.SteamID = int.Parse(appfile.Value.appid.Value);
game.Name = appfile.Value.name.Value;
gamesfind.Add(game);
}
return(gamesfind);
}
else
{
return(null);
}
}
public Template GetGameTemplate()
{
var manifest = VdfConvert.Deserialize(_manifestFileReader.ReadToEnd());
var dictionary = manifest.Value.Children <VProperty>()?
.ToDictionary(x => x.Key, x => x.Value);
return(CreateGameTemplate(dictionary));
}
private string FindProtonAppData()
{
string steamApps;
if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
{
steamApps = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), ".steam", "steam", "steamapps");
}
else if (RuntimeInformation.IsOSPlatform(OSPlatform.OSX))
{
steamApps = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.UserProfile), "Library", "Application Support", "Steam", "steamapps");
}
else
{
return(null);
}
if (!Directory.Exists(steamApps))
{
return(null);
}
var libraries = new List <string>
{
steamApps,
};
var vdf = Path.Combine(steamApps, "libraryfolders.vdf");
if (File.Exists(vdf))
{
var libraryFolders = VdfConvert.Deserialize(File.ReadAllText(vdf));
foreach (var libraryFolder in libraryFolders.Value.Children <VProperty>())
{
if (!int.TryParse(libraryFolder.Key, out _))
{
continue;
}
libraries.Add(Path.Combine(libraryFolder.Value.Value <string>(), "steamapps"));
}
}
foreach (var library in libraries)
{
var path = Path.Combine(library, "compatdata", AppId.ToString(), "pfx", "drive_c", "users", "steamuser", "AppData", "LocalLow");
if (Directory.Exists(path))
{
return(path);
}
}
return(null);
}
static void ModMountCfg(string gmod, string cstrike)
{
VProperty prop = VdfConvert.Deserialize(File.ReadAllText(string.Join(Path.DirectorySeparatorChar, new List <string> {
gmod, "garrysmod", "cfg", "mount.cfg"
})));
prop.Value["cstrike"] = new VValue(cstrike);
File.WriteAllText(string.Join(Path.DirectorySeparatorChar, new List <string> {
gmod, "garrysmod", "cfg", "mount.cfg"
}), VdfConvert.Serialize(prop));
}
private void Parse(string path)
{
VObject vObject = (VObject)VdfConvert.Deserialize(File.ReadAllText(path).Replace(@"\", @"\\")).Value;
AppId = int.Parse(vObject["appid"].ToString());
BuildDescription = vObject["desc"].ToString();
BuildOutput = vObject["buildoutput"].ToString();
ContentRoot = vObject["contentroot"].ToString();
SetLive = vObject["setlive"].ToString();
Preview = vObject["preview"].ToString() == "1";
Local = vObject["local"].ToString();
}
public void GrabTexturesFromMaterials()
{
VProperty currentVmt = VdfConvert.Deserialize(File.ReadAllText("graygrid.vmt"));
foreach (VToken token in currentVmt.Value)
{
Console.WriteLine(token.Value <VProperty>().Key);
// Check if the value of this field is a texture in the VPK
}
}
public static IEnumerable <User2Json.SteamLoginUsers> GetLoginUsers()
{
if (SteamPath.SteamLocation == null)
{
SteamPath.Init();
}
dynamic volvo = VdfConvert.Deserialize(File.ReadAllText(SteamPath.SteamLocation + @"\config\loginusers.vdf"));
VToken v2 = volvo.Value;
return(v2.Children().Select(child => new SteamLoginUsers((VProperty)child)).OrderByDescending(user => user.LastLoginTime).ToList());
}
public static string toVdf(BindingList <Mount> Mounts)
{
var mountcfg = new Dictionary <string, string>();
foreach (var mount in Mounts)
{
mountcfg.Add(mount.Name, mount.Path.FullName);
}
return(VdfConvert.Serialize(new VProperty("mountcfg", JToken.FromObject(mountcfg).ToVdf()), new VdfSerializerSettings {
UsesEscapeSequences = false
}));
}
/// <summary>
/// Gets the games folder path.
/// </summary>
public static IEnumerable <string> GetGamesFolderPaths()
{
string SteamPath = SteamHelper.GetSteamAppsPath();
string LibraryPath = SteamHelper.GetLibraryPath();
string LibraryFile = File.ReadAllText(LibraryPath);
if (string.IsNullOrEmpty(LibraryFile) == false)
{
VProperty Library = VdfConvert.Deserialize(LibraryFile);
JProperty Json = Library.ToJson();
if (Json.Value["1"] != null)
{
string GamesPath = Json.Value["1"].ToObject <string>();
if (string.IsNullOrEmpty(GamesPath) == false)
{
if (string.IsNullOrEmpty(GamesPath) == false)
{
string CommonPath = Path.Combine(GamesPath, "steamapps\\common\\");
if (string.IsNullOrEmpty(CommonPath) == false)
{
yield return(CommonPath);
}
else
{
Log.Warning(typeof(SteamHelper), "CommonPath is empty.");
}
}
else
{
Log.Warning(typeof(SteamHelper), "GamesPath is empty.");
}
}
else
{
Log.Warning(typeof(SteamHelper), "GamesPath property is empty.");
}
}
else
{
Log.Warning(typeof(SteamHelper), "LibraryFolders property is empty.");
}
}
else
{
Log.Error(typeof(SteamHelper), "Empty ?");
}
yield return(Path.Combine(SteamPath, "common"));
}
