That-One-Nerd/SrcMod
1
0
Fork 0
Code Issues 30 Pull Requests Actions Packages Projects Releases 9 Wiki Activity

Compare commits

base: That-One-Nerd:main
Branches Tags
That-One-Nerd:main
That-One-Nerd:vdf-format
That-One-Nerd:interop
That-One-Nerd:main-canary
That-One-Nerd:misc-commands
That-One-Nerd:source-connections
That-One-Nerd:shell-configuration
That-One-Nerd:steam-connections
That-One-Nerd:shell-systems
That-One-Nerd:more-compression-options
That-One-Nerd:clipboard-module
That-One-Nerd:v0.5.0-beta
That-One-Nerd:v0.4.0-alpha
That-One-Nerd:v0.3.3-alpha
That-One-Nerd:v0.3.2-alpha
That-One-Nerd:v0.3.1-alpha
That-One-Nerd:v0.3.0-alpha
That-One-Nerd:v0.2.2-alpha
That-One-Nerd:v0.2.0-alpha
That-One-Nerd:0.1.0
..
compare: That-One-Nerd:v0.3.3-alpha
Branches Tags
That-One-Nerd:vdf-format
That-One-Nerd:interop
That-One-Nerd:main-canary
That-One-Nerd:main
That-One-Nerd:misc-commands
That-One-Nerd:source-connections
That-One-Nerd:shell-configuration
That-One-Nerd:steam-connections
That-One-Nerd:shell-systems
That-One-Nerd:more-compression-options
That-One-Nerd:clipboard-module
That-One-Nerd:v0.5.0-beta
That-One-Nerd:v0.4.0-alpha
That-One-Nerd:v0.3.3-alpha
That-One-Nerd:v0.3.2-alpha
That-One-Nerd:v0.3.1-alpha
That-One-Nerd:v0.3.0-alpha
That-One-Nerd:v0.2.2-alpha
That-One-Nerd:v0.2.0-alpha
That-One-Nerd:0.1.0

No commits in common. "main" and "v0.3.3-alpha" have entirely different histories.
main ... v0.3.3-alp

30 changed files with 246 additions and 1583 deletions
Show Stats Expand all files Collapse all files

4
.gitignore vendored
View File

@ -1,13 +1,11 @@
# Visual Studio stuff
.vs/
SrcMod/.vs/
*.sln
# Compiled Files
SrcMod/Compiled
SrcMod/Shell/obj/
SrcMod/Valve.NET/obj
# Personal Stuff
SrcMod/Shell/Modules/TestingModule.cs
TODO.md

33
SrcMod/Shell/Extensions/ConversionExtension.cs
View File

@ -1,33 +0,0 @@
namespace SrcMod.Shell.Extensions;
public static class ConversionExtension
{
public static T Cast<T>(this object obj) => (T)Cast(obj, typeof(T));
public static object Cast(this object obj, Type newType) => Convert.ChangeType(obj, newType);
public static object CastArray(this object[] obj, Type newElementType)
{
Array result = Array.CreateInstance(newElementType, obj.Length);
for (int i = 0; i < obj.Length; i++) result.SetValue(obj[i].Cast(newElementType), i);
return result;
}
public static T[] CastArray<T>(this object[] obj)
{
Array result = Array.CreateInstance(typeof(T), obj.Length);
for (int i = 0; i < obj.Length; i++) result.SetValue(obj[i].Cast<T>(), i);
return (T[])result;
}
public static object CastArray(this Array obj, Type newElementType)
{
Array result = Array.CreateInstance(newElementType, obj.Length);
for (int i = 0; i < obj.Length; i++) result.SetValue(obj.GetValue(i)!.Cast(newElementType), i);
return result;
}
public static T[] CastArray<T>(this Array obj)
{
Array result = Array.CreateInstance(typeof(T), obj.Length);
for (int i = 0; i < obj.Length; i++) result.SetValue(obj.GetValue(i)!.Cast<T>(), i);
return (T[])result;
}
}

46
SrcMod/Shell/Game.cs
View File

@ -1,6 +1,6 @@
namespace SrcMod.Shell;
public class Game : IEquatable<Game>
public class Game
{
public static readonly Game Portal2 = new()
{
@ -8,48 +8,12 @@ public class Game : IEquatable<Game>
NameId = "portal2",
SteamId = 620
};
public static readonly Game Unknown = new()
{
Name = "Unknown Game",
NameId = "unknown",
SteamId = -1,
IsUnknown = true
};
public string Name { get; private set; }
public string NameId { get; private set; }
public int SteamId { get; private set; }
public required string Name { get; init; }
public required string NameId { get; init; }
public required int SteamId { get; init; }
public bool IsUnknown { get; private set; }
private Game()
{
IsUnknown = false;
Name = string.Empty;
NameId = string.Empty;
}
public static Game FromSteamId(int id)
{
if (id == Portal2.SteamId) return Portal2;
else
{
Game game = (Game)Unknown.MemberwiseClone();
game.SteamId = id;
return game;
}
}
public override bool Equals(object? obj)
{
if (obj is Game game) return Equals(game);
return false;
}
public bool Equals(Game? other) => other is not null && SteamId == other.SteamId;
public override int GetHashCode() => base.GetHashCode();
private Game() { }
public override string ToString() => Name;
public static bool operator ==(Game a, Game b) => a.Equals(b);
public static bool operator !=(Game a, Game b) => !a.Equals(b);
}

9
SrcMod/Shell/Miscellaneous/GlobalUsings.cs → SrcMod/Shell/GlobalUsings.cs
View File

@ -1,18 +1,12 @@
global using Microsoft.Win32;
global using Nerd_STF.Mathematics;
global using Nerd_STF.Mathematics;
global using Newtonsoft.Json;
global using SharpCompress.Archives.Rar;
global using SharpCompress.Archives.SevenZip;
global using SharpCompress.Readers;
global using SrcMod.Shell.Extensions;
global using SrcMod.Shell.Interop;
global using SrcMod.Shell.Modules;
global using SrcMod.Shell.Modules.ObjectModels;
global using SrcMod.Shell.ObjectModels;
global using SrcMod.Shell.ObjectModels.Source;
global using SrcMod.Shell.ObjectModels.Steam;
global using System;
global using System.Collections;
global using System.Collections.Generic;
global using System.ComponentModel;
global using System.Diagnostics;
@ -24,5 +18,4 @@ global using System.Reflection;
global using System.Runtime.InteropServices;
global using System.Text;
global using System.Threading;
global using Valve.Vkv;
global using static SrcMod.Shell.Tools;

2
SrcMod/Shell/LoadingBar.cs
View File

@ -1,6 +1,6 @@
namespace SrcMod.Shell;
public static class LoadingBar
internal static class LoadingBar
{
public static int position = -1;
public static int bufferSize = 0;

169
SrcMod/Shell/Mod.cs
View File

@ -2,183 +2,24 @@
public class Mod
{
public Game BaseGame { get; set; }
public string? Developer { get; set; }
public string? DeveloperUrl { get; set; }
public Dictionary<SearchPathType, string> SearchPaths { get; set; }
public string? ManualUrl { get; set; }
public string? FgdDataPath { get; set; }
public string? IconPath { get; set; }
public string? InstancePath { get; set; }
public PlayerType PlayerMode { get; set; }
public CrosshairFlags CrosshairMenuFlags { get; set; }
public bool ShowDifficultyMenu { get; set; }
public bool ShowModelMenu { get; set; }
public bool ShowPortalMenu { get; set; }
public SupportFlags SupportingFlags { get; set; }
public bool HiResModels { get; set; }
public string[] HiddenMaps { get; set; }
public string Name { get; set; }
public string? Motto { get; set; }
public TitleDisplay TitleDisplayMode { get; set; }
public bool BuildMapNodegraphs { get; set; }
public Dictionary<string, string>? MapbaseLaunchOptions { get; set; }
public string RootDirectory { get; set; }
private Mod()
{
BaseGame = Game.Unknown;
SearchPaths = new();
HiddenMaps = Array.Empty<string>();
Name = string.Empty;
RootDirectory = string.Empty;
}
public static Mod FromInfo(string root, GameInfo info)
{
Mod curMod = new()
{
BaseGame = Game.FromSteamId(info.FileSystem.SteamAppID),
BuildMapNodegraphs = info.Nodegraph is not null && info.Nodegraph.Value,
CrosshairMenuFlags = CrosshairFlags.None,
Developer = info.Developer,
DeveloperUrl = info.Developer_URL,
FgdDataPath = info.GameData,
HiddenMaps = info.Hidden_Maps is null ? Array.Empty<string>() : info.Hidden_Maps.Keys.ToArray(),
HiResModels = info.NoHIModel is null || !info.NoHIModel.Value,
IconPath = info.Icon is null ? null : info.Icon.Trim().Replace('/', '\\') + ".tga",
InstancePath = info.InstancePath,
MapbaseLaunchOptions = info.CommandLine,
ManualUrl = info.Manual,
Motto = info.Title2,
Name = string.IsNullOrEmpty(info.Title) ? "Default Mod" : info.Title,
PlayerMode = info.Type is null ? PlayerType.Both : info.Type.Trim().ToLower() switch
{
"singleplayer_only" => PlayerType.Singleplayer,
"multiplayer_only" => PlayerType.Multiplayer,
_ => throw new ArgumentException($"Unknown type \"{info.Type}\"")
},
RootDirectory = root,
SearchPaths = new(),
ShowDifficultyMenu = info.NoDifficulty is null || !info.NoDifficulty.Value,
ShowModelMenu = info.NoModels is null || !info.NoModels.Value,
ShowPortalMenu = info.HasPortals is not null && info.HasPortals.Value,
SupportingFlags = SupportFlags.None,
TitleDisplayMode = info.GameLogo is null ? TitleDisplay.Title :
(info.GameLogo.Value ? TitleDisplay.Logo : TitleDisplay.Title)
};
if (curMod.PlayerMode == PlayerType.Multiplayer && info.NoDifficulty is null)
curMod.ShowDifficultyMenu = false;
if (info.NoCrosshair is null || !info.NoCrosshair.Value)
curMod.CrosshairMenuFlags |= CrosshairFlags.ShowMultiplayer;
if (info.AdvCrosshair is not null && info.AdvCrosshair.Value)
curMod.CrosshairMenuFlags |= CrosshairFlags.AdvancedMenu;
if (info.SupportsDX8 is not null && info.SupportsDX8.Value)
curMod.SupportingFlags |= SupportFlags.DirectX8;
if (info.SupportsVR is not null && info.SupportsVR.Value)
curMod.SupportingFlags |= SupportFlags.VirtualReality;
if (info.SupportsXBox360 is not null && info.SupportsXBox360.Value)
curMod.SupportingFlags |= SupportFlags.XBox360;
foreach (KeyValuePair<string, string> pair in info.FileSystem.SearchPaths)
{
SearchPathType type = SearchPathType.Unknown;
string[] parts = pair.Key.Trim().ToLower().Split('+');
foreach (string part in parts) type |= part switch
{
"game" => SearchPathType.Game,
"game_write" => SearchPathType.GameWrite,
"gamebin" => SearchPathType.GameBinaries,
"platform" => SearchPathType.Platform,
"mod" => SearchPathType.Mod,
"mod_write" => SearchPathType.ModWrite,
"default_write_path" => SearchPathType.DefaultWritePath,
"vpk" => SearchPathType.Vpk,
_ => SearchPathType.Unknown
};
}
return curMod;
}
public static Mod? ReadDirectory(string dir)
{
dir = dir.Trim().Replace('/', '\\');
string check = dir;
if (!File.Exists(dir + "\\GameInfo.txt")) return null;
while (!string.IsNullOrEmpty(check))
Mod mod = new()
{
string gameInfoPath = Path.Combine(check, "GameInfo.txt");
if (File.Exists(gameInfoPath))
{
// Root mod directory found, go from here.
Name = dir.Split("\\").Last()
};
FileStream fs = new(gameInfoPath, FileMode.Open);
GameInfo? modInfo = SerializeVkv.Deserialize<GameInfo>(fs);
if (modInfo is null) continue;
return FromInfo(check, modInfo);
}
check = Path.GetDirectoryName(check) ?? string.Empty; // Go to parent folder.
}
return null;
return mod;
}
public override string ToString() => Name;
[Flags]
public enum CrosshairFlags
{
None = 0,
ShowMultiplayer = 1,
AdvancedMenu = 2
}
[Flags]
public enum SupportFlags
{
None,
DirectX8 = 1,
VirtualReality = 2,
XBox360 = 4
}
[Flags]
public enum SearchPathType
{
Unknown = 0,
Game = 1,
GameWrite = 2,
GameBinaries = 4,
Platform = 8,
Mod = 16,
ModWrite = 32,
DefaultWritePath = 64,
Vpk = 128
}
public enum PlayerType
{
Singleplayer = 1,
Multiplayer = 2,
Both = Singleplayer | Multiplayer
}
public enum TitleDisplay
{
Title,
Logo
}
}

273
SrcMod/Shell/Modules/ConfigModule.cs
View File

@ -1,26 +1,28 @@
using SharpCompress;
namespace SrcMod.Shell.Modules;
namespace SrcMod.Shell.Modules;
[Module("config")]
public static class ConfigModule
{
[Command("display")]
[Command("list")]
public static void DisplayConfig(string display = "all")
public static void DisplayConfig(ConfigDisplayMode mode = ConfigDisplayMode.All)
{
switch (display.Trim().ToLower())
switch (mode)
{
case "all":
DisplayConfigAll();
break;
case "raw":
case ConfigDisplayMode.Raw:
DisplayConfigRaw();
break;
default:
DisplayConfigName(display);
case ConfigDisplayMode.All:
DisplayConfigAll();
break;
case ConfigDisplayMode.GameDirectories:
DisplayConfigGameDirectories();
break;
case ConfigDisplayMode.RunUnsafeCommands:
DisplayConfigUnsafeCommands();
break;
}
}
@ -29,197 +31,164 @@ public static class ConfigModule
[Command("append")]
public static void AppendConfigVariable(string name, string value)
{
FieldInfo[] validFields = (from field in typeof(Config).GetFields()
let isPublic = field.IsPublic
let isStatic = field.IsStatic
where isPublic && !isStatic
select field).ToArray();
Config config = Config.LoadedConfig;
FieldInfo? chosenField = validFields.FirstOrDefault(x => x.Name.Trim().ToLower() == name.Trim().ToLower());
if (chosenField is null) throw new($"No valid config variable named \"{name}\".");
else if (!chosenField.FieldType.IsArray) throw new($"The variable \"{chosenField.Name}\" is not an array" +
" and cannot have data added or removed from it." +
" Instead, set or reset the variable.");
switch (name.Trim().ToLower())
{
case "gamedirectories":
config.GameDirectories = config.GameDirectories.Append(value).ToArray();
break;
object parsed = TypeParsers.ParseAll(value);
if (parsed is string parsedStr
&& chosenField.FieldType.IsEnum
&& Enum.TryParse(chosenField.FieldType, parsedStr, true, out object? obj)) parsed = obj;
case "rununsafecommands":
throw new($"The config variable \"{name}\" is a single variable and cannot be appended to.");
Type arrayType = chosenField.FieldType.GetElementType()!;
default: throw new($"Unknown config variable \"{name}\"");
}
Array arrayValue = (Array)chosenField.GetValue(Config.LoadedConfig)!;
ArrayList collection = new(arrayValue) { parsed };
chosenField.SetValue(Config.LoadedConfig, collection.ToArray()!.CastArray(arrayType));
Config.UpdateChanges();
DisplayConfigItem(chosenField.GetValue(Config.LoadedConfig), name: chosenField.Name);
Config.LoadedConfig = config;
}
[Command("delete")]
[Command("remove")]
public static void RemoveConfigVariable(string name, string value)
{
FieldInfo[] validFields = (from field in typeof(Config).GetFields()
let isPublic = field.IsPublic
let isStatic = field.IsStatic
where isPublic && !isStatic
select field).ToArray();
Config config = Config.LoadedConfig;
FieldInfo? chosenField = validFields.FirstOrDefault(x => x.Name.Trim().ToLower() == name.Trim().ToLower());
if (chosenField is null) throw new($"No valid config variable named \"{name}\".");
else if (!chosenField.FieldType.IsArray) throw new($"The variable \"{chosenField.Name}\" is not an array" +
" and cannot have data added or removed from it." +
" Instead, set or reset the variable.");
switch (name.Trim().ToLower())
{
case "gamedirectories":
config.GameDirectories = config.GameDirectories
.Where(x => x.Trim().ToLower() != value.Trim().ToLower())
.ToArray();
break;
object parsed = TypeParsers.ParseAll(value);
if (parsed is string parsedStr
&& chosenField.FieldType.IsEnum
&& Enum.TryParse(chosenField.FieldType, parsedStr, true, out object? obj)) parsed = obj;
case "rununsafecommands":
throw new($"The config variable \"{name}\" is a single variable and cannot be appended to.");
Type arrayType = chosenField.FieldType.GetElementType()!;
default: throw new($"Unknown config variable \"{name}\"");
}
Array arrayValue = (Array)chosenField.GetValue(Config.LoadedConfig)!;
ArrayList collection = new(arrayValue);
if (!collection.Contains(parsed)) throw new($"The value \"{value}\" is not contained in this variable.");
collection.Remove(parsed);
chosenField.SetValue(Config.LoadedConfig, collection.ToArray()!.CastArray(arrayType));
Config.UpdateChanges();
DisplayConfigItem(chosenField.GetValue(Config.LoadedConfig), name: chosenField.Name);
Config.LoadedConfig = config;
}
[Command("reset")]
public static void ResetConfig(string name = "all")
{
Config config = Config.LoadedConfig;
switch (name.Trim().ToLower())
{
case "all":
Config.LoadedConfig = Config.Defaults;
DisplayConfig("all");
case "gamedirectories":
config.GameDirectories = Config.Defaults.GameDirectories;
break;
default:
ResetConfigVar(name);
case "rununsafecommands":
config.RunUnsafeCommands = Config.Defaults.RunUnsafeCommands;
break;
case "all":
config = Config.Defaults;
break;
default: throw new($"Unknown config variable \"{name}\"");
}
Config.LoadedConfig = config;
}
[Command("set")]
public static void SetConfigVariable(string name, string value)
{
FieldInfo[] validFields = (from field in typeof(Config).GetFields()
let isPublic = field.IsPublic
let isStatic = field.IsStatic
where isPublic && !isStatic
select field).ToArray();
Config config = Config.LoadedConfig;
FieldInfo? chosenField = validFields.FirstOrDefault(x => x.Name.Trim().ToLower() == name.Trim().ToLower());
if (chosenField is null) throw new($"No valid config variable named \"{name}\".");
else if (chosenField.FieldType.IsArray) throw new($"The variable \"{chosenField.Name}\" is an array and" +
" cannot be directly set. Instead, add or remove items" +
" from it.");
switch (name.Trim().ToLower())
{
case "gamedirectories":
throw new($"The config variable \"{name}\" is a list and must be added or removed to.");
object parsed = TypeParsers.ParseAll(value);
if (parsed is string parsedStr
&& chosenField.FieldType.IsEnum
&& Enum.TryParse(chosenField.FieldType, parsedStr, true, out object? obj)) parsed = obj;
case "rununsafecommands":
if (int.TryParse(value, out int intRes))
{
AskMode mode = (AskMode)intRes;
if (!Enum.IsDefined(mode)) throw new($"(AskMode){value} is not a valid AskMode.");
config.RunUnsafeCommands = mode;
}
else if (Enum.TryParse(value, true, out AskMode modeRes))
{
if (!Enum.IsDefined(modeRes)) throw new($"\"{value}\" is not a valid AskMode.");
config.RunUnsafeCommands = modeRes;
}
else throw new($"\"{value}\" is not a valid AskMode.");
break;
chosenField.SetValue(Config.LoadedConfig, parsed);
Config.UpdateChanges();
DisplayConfigItem(chosenField.GetValue(Config.LoadedConfig), name: chosenField.Name);
default: throw new($"Unknown config variable \"{name}\"");
}
Config.LoadedConfig = config;
}
private static void DisplayConfigAll()
{
FieldInfo[] validFields = (from field in typeof(Config).GetFields()
let isPublic = field.IsPublic
let isStatic = field.IsStatic
where isPublic && !isStatic
select field).ToArray();
foreach (FieldInfo field in validFields)
DisplayConfigItem(field.GetValue(Config.LoadedConfig), name: field.Name);
DisplayConfigGameDirectories();
DisplayConfigUnsafeCommands();
}
private static void DisplayConfigItem<T>(T item, int indents = 0, string name = "", bool newLine = true)
private static void DisplayConfigRaw()
{
Write(new string(' ', indents * 4), newLine: false);
if (!string.IsNullOrWhiteSpace(name)) Write($"{name}: ", newLine: false);
// This is definitely a bit inefficient, but shouldn't be too much of an issue.
if (item is null) Write("null", ConsoleColor.DarkRed, newLine);
else if (item is Array itemArray)
MemoryStream ms = new();
StreamWriter writer = new(ms, leaveOpen: true);
JsonTextWriter jsonWriter = new(writer);
Serializer.Serialize(jsonWriter, Config.LoadedConfig);
jsonWriter.Close();
writer.Close();
ms.Position = 0;
StreamReader reader = new(ms);
string msg = reader.ReadToEnd();
Write(msg);
reader.Close();
ms.Close();
}
private static void DisplayConfigGameDirectories()
{
Write("Steam Game Directories: ", null, false);
if (Config.LoadedConfig.GameDirectories is null || Config.LoadedConfig.GameDirectories.Length <= 0)
Write("None", ConsoleColor.DarkGray);
else
{
if (itemArray.Length < 1)
{
Write("[]", ConsoleColor.DarkGray, newLine);
return;
}
Write("[", ConsoleColor.DarkGray);
for (int i = 0; i < itemArray.Length; i++)
for (int i = 0; i < Config.LoadedConfig.GameDirectories.Length; i++)
{
DisplayConfigItem(itemArray.GetValue(i), indents + 1, newLine: false);
if (i < itemArray.Length - 1) Write(',', newLine: false);
Write('\n', newLine: false);
Write(" \"", ConsoleColor.DarkGray, false);
Write(Config.LoadedConfig.GameDirectories[i], ConsoleColor.White, false);
if (i < Config.LoadedConfig.GameDirectories.Length - 1) Write("\",", ConsoleColor.DarkGray);
else Write("\"", ConsoleColor.DarkGray);
}
Write(new string(' ', indents * 4) + "]", ConsoleColor.DarkGray, newLine);
Write("]", ConsoleColor.DarkGray);
}
else if (item is byte itemByte) Write($"0x{itemByte:X2}", ConsoleColor.Yellow, newLine);
else if (item is sbyte or short or ushort or int or uint or long or ulong or float or double or decimal)
Write(item, ConsoleColor.Yellow, newLine);
else if (item is bool itemBool) Write(item, itemBool ? ConsoleColor.Green : ConsoleColor.Red, newLine);
else if (item is char)
{
Write("\'", ConsoleColor.DarkGray, false);
Write(item, ConsoleColor.Blue, false);
Write("\'", ConsoleColor.DarkGray, newLine);
}
else if (item is string)
{
Write("\"", ConsoleColor.DarkGray, false);
Write(item, ConsoleColor.DarkCyan, false);
Write("\"", ConsoleColor.DarkGray, newLine);
}
else if (item is AskMode) Write(item, item switch
}
private static void DisplayConfigUnsafeCommands()
{
Write("Run Unsafe Commands: ", null, false);
ConsoleColor color = Config.LoadedConfig.RunUnsafeCommands switch
{
AskMode.Never => ConsoleColor.Red,
AskMode.Always => ConsoleColor.Green,
AskMode.Ask or _ => ConsoleColor.DarkGray
}, newLine);
else Write(item, newLine: newLine);
}
private static void DisplayConfigName(string name)
{
FieldInfo[] validFields = (from field in typeof(Config).GetFields()
let isPublic = field.IsPublic
let isStatic = field.IsStatic
where isPublic && !isStatic
select field).ToArray();
FieldInfo? chosenField = validFields.FirstOrDefault(x => x.Name.Trim().ToLower() == name.Trim().ToLower());
if (chosenField is null) throw new($"No config variable named \"{name}\".");
DisplayConfigItem(chosenField.GetValue(Config.LoadedConfig), name: chosenField.Name);
}
private static void DisplayConfigRaw()
{
string json = JsonConvert.SerializeObject(Config.LoadedConfig, Formatting.Indented);
Write(json);
};
Write(Config.LoadedConfig.RunUnsafeCommands, color);
}
private static void ResetConfigVar(string name)
public enum ConfigDisplayMode
{
FieldInfo[] validFields = (from field in typeof(Config).GetFields()
let isPublic = field.IsPublic
let isStatic = field.IsStatic
where isPublic && !isStatic
select field).ToArray();
FieldInfo? chosenField = validFields.FirstOrDefault(x => x.Name.Trim().ToLower() == name.Trim().ToLower());
if (chosenField is null) throw new($"No valid config variable named \"{name}\".");
chosenField.SetValue(Config.LoadedConfig, chosenField.GetValue(Config.Defaults));
Config.UpdateChanges();
DisplayConfigItem(chosenField.GetValue(Config.LoadedConfig), name: chosenField.Name);
Raw,
All,
GameDirectories,
RunUnsafeCommands
}
}

88
SrcMod/Shell/Modules/ObjectModels/TypeParsers.cs
View File

@ -2,73 +2,35 @@
public static class TypeParsers
{
public static bool CanParse(object? obj) => obj is not null && obj is bool or sbyte or byte or short or ushort
or int or uint or long or ulong or Int128 or UInt128 or nint or nuint or Half or float or double or decimal
or char or DateOnly or DateTime or DateTimeOffset or Guid or TimeOnly or TimeSpan;
public static object ParseAll(string msg)
{
if (TryParseBool(msg, out bool resBool)) return resBool;
else if (TryParse(msg, out sbyte int8)) return int8;
else if (TryParse(msg, out byte uInt8)) return uInt8;
else if (TryParse(msg, out short int16)) return int16;
else if (TryParse(msg, out ushort uInt16)) return uInt16;
else if (TryParse(msg, out int int32)) return int32;
else if (TryParse(msg, out uint uInt32)) return uInt32;
else if (TryParse(msg, out long int64)) return int64;
else if (TryParse(msg, out ulong uInt64)) return uInt64;
else if (TryParse(msg, out Int128 int128)) return int128;
else if (TryParse(msg, out UInt128 uInt128)) return uInt128;
else if (TryParse(msg, out nint intPtr)) return intPtr;
else if (TryParse(msg, out nuint uIntPtr)) return uIntPtr;
else if (TryParse(msg, out Half float16)) return float16;
else if (TryParse(msg, out float float32)) return float32;
else if (TryParse(msg, out double float64)) return float64;
else if (TryParse(msg, out decimal float128)) return float128;
else if (TryParse(msg, out char resChar)) return resChar;
else if (TryParse(msg, out DateOnly dateOnly)) return dateOnly;
else if (TryParse(msg, out DateTime dateTime)) return dateTime;
else if (TryParse(msg, out DateTimeOffset dateTimeOffset)) return dateTimeOffset;
else if (TryParse(msg, out Guid guid)) return guid;
else if (TryParse(msg, out TimeOnly timeOnly)) return timeOnly;
else if (TryParse(msg, out TimeSpan timeSpan)) return timeSpan;
else return msg;
if (TryParse(msg, out sbyte int8)) return int8;
if (TryParse(msg, out byte uInt8)) return uInt8;
if (TryParse(msg, out short int16)) return int16;
if (TryParse(msg, out ushort uInt16)) return uInt16;
if (TryParse(msg, out int int32)) return int32;
if (TryParse(msg, out uint uInt32)) return uInt32;
if (TryParse(msg, out long int64)) return int64;
if (TryParse(msg, out ulong uInt64)) return uInt64;
if (TryParse(msg, out Int128 int128)) return int128;
if (TryParse(msg, out UInt128 uInt128)) return uInt128;
if (TryParse(msg, out nint intPtr)) return intPtr;
if (TryParse(msg, out nuint uIntPtr)) return uIntPtr;
if (TryParse(msg, out Half float16)) return float16;
if (TryParse(msg, out float float32)) return float32;
if (TryParse(msg, out double float64)) return float64;
if (TryParse(msg, out decimal float128)) return float128;
if (TryParse(msg, out char resChar)) return resChar;
if (TryParse(msg, out DateOnly dateOnly)) return dateOnly;
if (TryParse(msg, out DateTime dateTime)) return dateTime;
if (TryParse(msg, out DateTimeOffset dateTimeOffset)) return dateTimeOffset;
if (TryParse(msg, out Guid guid)) return guid;
if (TryParse(msg, out TimeOnly timeOnly)) return timeOnly;
if (TryParse(msg, out TimeSpan timeSpan)) return timeSpan;
return msg;
}
public static bool TryParseBool(string msg, out bool result)
{
string trimmed = msg.Trim().ToLower();
string[] trues = new string[]
{
"t",
"true",
"1",
"y",
"yes"
},
falses = new string[]
{
"f",
"false",
"0",
"n",
"no"
};
foreach (string t in trues) if (trimmed == t)
{
result = true;
return true;
}
foreach (string f in falses) if (trimmed == f)
{
result = false;
return true;
}
result = false;
return false;
}
public static bool TryParse<T>(string msg, out T? result) where T : IParsable<T>
=> T.TryParse(msg, null, out result);
}

201
SrcMod/Shell/ObjectModels/Config.cs
View File

@ -1,16 +1,10 @@
namespace SrcMod.Shell.ObjectModels;
public class Config
public struct Config
{
public const string FilePath = "config.json";
public static bool HasDisplayableError => false;
public static bool HasDisplayableWarning => p_printedLastSteamWarning;
public static Config Defaults => new();
private static readonly FieldInfo[] p_configSharedFields;
private static readonly FieldInfo[] p_changeSharedFields;
public static readonly Config Defaults;
public static Config LoadedConfig
{
@ -18,169 +12,39 @@ public class Config
set
{
p_applied = value;
UpdateChanges();
p_changes = p_applied.GetChanges(Defaults);
}
}
private static Config p_applied;
private static Changes? p_changes;
private static bool p_printedLastSteamWarning;
// These variables should only exist in the Config class so they aren't marked as shared.
private readonly string p_steamLocation;
private static ConfigChanges? p_changes;
static Config()
{
// Generate shared fields between the config class and its changes equivalent.
p_applied = Defaults;
FieldInfo[] configFields = (from field in typeof(Config).GetFields()
let isPublic = field.IsPublic
let isStatic = field.IsStatic
where isPublic && !isStatic
select field).ToArray(),
changeFields = (from field in typeof(Changes).GetFields()
let isPublic = field.IsPublic
let isStatic = field.IsStatic
where isPublic && !isStatic
select field).ToArray();
List<FieldInfo> sharedConfigFields = new(),
sharedChangeFields = new();
foreach (FieldInfo field in configFields)
Defaults = new()
{
FieldInfo? changeEquivalent = changeFields.FirstOrDefault(
x => x.Name == field.Name &&
(x.FieldType == field.FieldType || Nullable.GetUnderlyingType(x.FieldType) == field.FieldType));
if (changeEquivalent is null) continue;
sharedConfigFields.Add(field);
sharedChangeFields.Add(changeEquivalent);
}
static int sortByName(FieldInfo a, FieldInfo b) => a.Name.CompareTo(b.Name);
sharedConfigFields.Sort(sortByName);
sharedChangeFields.Sort(sortByName);
p_configSharedFields = sharedConfigFields.ToArray();
p_changeSharedFields = sharedChangeFields.ToArray();
GameDirectories = Array.Empty<string>(),
RunUnsafeCommands = AskMode.Ask
};
}
public string[] GameDirectories;
public AskMode RunUnsafeCommands;
public bool UseLocalModDirectories;
internal Config()
public Config ApplyChanges(ConfigChanges changes) => this with
{
// Locate some steam stuff.
const string steamLocationKey = @"Software\Valve\Steam";
RegistryKey? key = Registry.CurrentUser.OpenSubKey(steamLocationKey);
if (key is null)
{
Write("[FATAL] Cannot locate Steam installation. Do you have Steam installed?",
ConsoleColor.DarkRed);
Thread.Sleep(1000);
BaseModule.QuitShell(-1);
// This should never run, and is just here to supress
// a couple compiler warnings.
p_steamLocation = string.Empty;
GameDirectories = Array.Empty<string>();
RunUnsafeCommands = AskMode.Ask;
return;
}
p_steamLocation = (string)key.GetValue("SteamPath")!;
// Assign config variables.
string gameDirDataPath = Path.Combine(p_steamLocation, @"steamapps\libraryfolders.vdf");
FileStream gameDirData = new(gameDirDataPath, FileMode.Open);
try
{
LibraryFolder[]? folders = SerializeVkv.Deserialize<LibraryFolder[]>(gameDirData);
if (folders is null)
{
if (!p_printedLastSteamWarning)
Write("[WARNING] Error parsing Steam game directories.", ConsoleColor.DarkYellow);
GameDirectories = Array.Empty<string>();
p_printedLastSteamWarning = true;
}
else
{
GameDirectories = new string[folders.Length];
for (int i = 0; i < folders.Length; i++) GameDirectories[i] = folders[i].path;
p_printedLastSteamWarning = false;
}
}
catch (Exception ex)
{
if (!p_printedLastSteamWarning)
{
#if RELEASE
Write("[WARNING] Error parsing Steam game directories.", ConsoleColor.DarkYellow);
#else
Write(ex, ConsoleColor.DarkYellow);
#endif
}
GameDirectories = Array.Empty<string>();
p_printedLastSteamWarning = true;
}
RunUnsafeCommands = AskMode.Ask;
UseLocalModDirectories = true;
}
public Config ApplyChanges(Changes changes)
GameDirectories = GameDirectories.Union(changes.GameDirectories ?? Array.Empty<string>()).ToArray(),
RunUnsafeCommands = changes.RunUnsafeCommands ?? RunUnsafeCommands
};
public ConfigChanges GetChanges(Config? baseConfig = null)
{
for (int i = 0; i < p_configSharedFields.Length; i++)
Config reference = baseConfig ?? Defaults;
ConfigChanges changes = new()
{
FieldInfo configField = p_configSharedFields[i],
changeField = p_changeSharedFields[i];
object? toChange = changeField.GetValue(changes);
if (toChange is null) continue;
if (configField.FieldType.IsArray)
{
object[] currentArray = ((Array)configField.GetValue(this)!).CastArray<object>(),
changeArray = ((Array)toChange).CastArray<object>();
currentArray = currentArray.Union(changeArray).ToArray();
configField.SetValue(this, currentArray.CastArray(configField.FieldType.GetElementType()!));
}
else configField.SetValue(this, toChange);
}
return this;
}
public Changes GetChanges(Config? reference = null)
{
reference ??= Defaults;
Changes changes = new();
for (int i = 0; i < p_configSharedFields.Length; i++)
{
FieldInfo configField = p_configSharedFields[i],
changeField = p_changeSharedFields[i];
object? toSet = configField.GetValue(this);
if (toSet is null) continue;
if (configField.FieldType.IsArray)
{
object[] configArray = ((Array)toSet).CastArray<object>(),
referenceArray = ((Array)configField.GetValue(Defaults)!).CastArray<object>(),
changesArray = configArray.Where(x => !referenceArray.Contains(x)).ToArray();
changeField.SetValue(changes, changesArray.CastArray(configField.FieldType.GetElementType()!));
}
else changeField.SetValue(changes, toSet);
}
GameDirectories = reference.GameDirectories == GameDirectories ? null :
GameDirectories.Where(x => !reference.GameDirectories.Contains(x)).ToArray(),
RunUnsafeCommands = reference.RunUnsafeCommands == RunUnsafeCommands ? null : RunUnsafeCommands
};
return changes;
}
@ -197,43 +61,26 @@ public class Config
}
StreamReader reader = new(fullPath);
JsonTextReader jsonReader = new(reader);
p_changes = Tools.SerializerJson.Deserialize<Changes?>(jsonReader);
p_changes = Serializer.Deserialize<ConfigChanges?>(jsonReader);
jsonReader.Close();
reader.Close();
p_applied = p_changes is null ? Defaults : Defaults.ApplyChanges(p_changes);
p_applied = p_changes is null ? Defaults : Defaults.ApplyChanges(p_changes.Value);
}
public static void SaveConfig(string basePath)
{
string fullPath = Path.Combine(basePath, FilePath);
if (p_changes is null || !p_changes.Any())
if (p_changes is null || !p_changes.Value.HasChange)
{
if (File.Exists(fullPath)) File.Delete(fullPath);
return;
}
StreamWriter writer = new(fullPath);
JsonTextWriter jsonWriter = new(writer)
{
Indentation = 4
};
Tools.SerializerJson.Serialize(jsonWriter, p_changes);
JsonTextWriter jsonWriter = new(writer);
Serializer.Serialize(jsonWriter, p_changes);
jsonWriter.Close();
writer.Close();
}
public static void UpdateChanges()
{
p_changes = p_applied.GetChanges(Defaults);
}
public class Changes
{
public string[]? GameDirectories;
public AskMode? RunUnsafeCommands;
public bool? UseLocalModDirectories;
public bool Any() => typeof(Changes).GetFields().Any(x => x.GetValue(this) is not null);
}
}

10
SrcMod/Shell/ObjectModels/ConfigChanges.cs Normal file
View File

@ -0,0 +1,10 @@
namespace SrcMod.Shell.ObjectModels;
public record struct ConfigChanges
{
[JsonIgnore]
public bool HasChange => GameDirectories is not null || RunUnsafeCommands is not null;
public string[]? GameDirectories;
public AskMode? RunUnsafeCommands;
}

59
SrcMod/Shell/ObjectModels/Source/GameInfo.cs
View File

@ -1,59 +0,0 @@
namespace SrcMod.Shell.ObjectModels.Source;
// Referencing https://developer.valvesoftware.com/wiki/Gameinfo.txt.
public class GameInfo
{
// Name
public string Game;
public string Title;
public string? Title2;
public bool? GameLogo;
// Options
public string? Type;
public bool? NoDifficulty;
public bool? HasPortals;
public bool? NoCrosshair;
public bool? AdvCrosshair;
public bool? NoModels;
public bool? NoHIModel;
public Dictionary<string, int>? Hidden_Maps;
public Dictionary<string, string>? CommandLine;
// Steam games list
public string? Developer;
public string? Developer_URL;
public string? Manual;
public string? Icon;
// Engine and tools
public bool? Nodegraph;
public string? GameData;
public string? InstancePath;
public bool? SupportsDX8;
public bool? SupportsVR;
public bool? SupportsXBox360;
public FileSystemData FileSystem;
public GameInfo()
{
Game = string.Empty;
Title = string.Empty;
FileSystem = new();
}
public class FileSystemData
{
public int SteamAppID;
public int? AdditionalContentId;
public int? ToolsAppId;
public Dictionary<string, string> SearchPaths;
public FileSystemData()
{
SearchPaths = new();
}
}
}

13
SrcMod/Shell/ObjectModels/Steam/LibraryFolder.cs
View File

@ -1,13 +0,0 @@
namespace SrcMod.Shell.ObjectModels.Steam;
public class LibraryFolder
{
public string path;
public Dictionary<int, ulong> apps;
public LibraryFolder()
{
path = string.Empty;
apps = new();
}
}

122
SrcMod/Shell/Shell.cs
View File

@ -4,13 +4,7 @@ public class Shell
{
public const string Author = "That_One_Nerd";
public const string Name = "SrcMod";
public const string Version = "Beta 0.5.0";
public bool HasAnyDisplayableError => HasDisplayableError || Config.HasDisplayableError;
public bool HasAnyDisplayableWarning => HasDisplayableWarning || Config.HasDisplayableWarning;
public bool HasDisplayableError => p_printedLastReloadError;
public bool HasDisplayableWarning => false;
public const string Version = "Alpha 0.3.3";
public readonly string? ShellDirectory;
@ -22,12 +16,10 @@ public class Shell
public List<HistoryItem> History;
public string WorkingDirectory;
private bool p_lastCancel;
private bool p_printedCancel;
private bool lastCancel;
private bool printedCancel;
private bool p_printedLastReloadError;
private BackgroundWorker? p_activeCommand;
private BackgroundWorker? activeCommand;
public Shell()
{
@ -96,8 +88,8 @@ public class Shell
Write(" by ", ConsoleColor.White, false);
Write($"{Author}", ConsoleColor.DarkYellow);
p_lastCancel = false;
p_activeCommand = null;
lastCancel = false;
activeCommand = null;
Console.CancelKeyPress += HandleCancel;
ActiveGame = null;
@ -147,21 +139,9 @@ public class Shell
public string ReadLine()
{
Write("\n", newLine: false);
if (HasAnyDisplayableError) Write($"(Error) ", ConsoleColor.DarkRed, false);
else if (HasAnyDisplayableWarning) Write($"(Warning) ", ConsoleColor.DarkYellow, false);
if (ActiveMod is not null) Write($"{ActiveMod} ", ConsoleColor.Magenta, false);
if (ActiveMod is not null && Config.LoadedConfig.UseLocalModDirectories)
{
string directory = Path.GetRelativePath(ActiveMod.RootDirectory, WorkingDirectory);
if (directory == ".") directory = string.Empty;
Write($"~\\{directory}", ConsoleColor.DarkGreen, false);
}
else Write($"{WorkingDirectory}", ConsoleColor.DarkGreen, false);
if (ActiveGame is not null) Write($" ({ActiveGame})", ConsoleColor.Blue, false);
Write($"\n{WorkingDirectory}", ConsoleColor.DarkGreen, false);
if (ActiveGame is not null) Write($" {ActiveGame}", ConsoleColor.DarkYellow, false);
if (ActiveMod is not null) Write($" {ActiveMod}", ConsoleColor.Magenta, false);
Write(null);
Write($" {Name}", ConsoleColor.DarkCyan, false);
@ -169,7 +149,7 @@ public class Shell
bool printed = false;
if (p_lastCancel && !p_printedCancel)
if (lastCancel && !printedCancel)
{
// Print the warning. A little bit of mess because execution must
// continue without funny printing errors but it's alright I guess.
@ -180,7 +160,7 @@ public class Shell
Write("Press ^C again to exit the shell.", ConsoleColor.Red);
PlayWarningSound();
p_printedCancel = true;
printedCancel = true;
Console.CursorTop += 2;
Console.CursorLeft = originalLeft;
@ -195,8 +175,8 @@ public class Shell
if (!printed)
{
p_lastCancel = false;
p_printedCancel = false;
lastCancel = false;
printedCancel = false;
}
return message;
@ -259,41 +239,38 @@ public class Shell
void runCommand(object? sender, DoWorkEventArgs e)
{
#if RELEASE
try
{
#endif
command.Invoke(args);
}
#if RELEASE
}
catch (TargetInvocationException ex)
{
Write($"[ERROR] {ex.InnerException!.Message}", ConsoleColor.Red);
if (LoadingBar.Enabled) LoadingBar.End();
}
#endif
catch (Exception ex)
{
#if RELEASE
Write($"[ERROR] {ex.Message}", ConsoleColor.Red);
if (LoadingBar.Enabled) LoadingBar.End();
#else
Write($"[ERROR] {ex}", ConsoleColor.Red);
if (LoadingBar.Enabled) LoadingBar.End();
#endif
}
#endif
}
p_activeCommand = new();
p_activeCommand.DoWork += runCommand;
p_activeCommand.RunWorkerAsync();
activeCommand = new();
activeCommand.DoWork += runCommand;
activeCommand.RunWorkerAsync();
p_activeCommand.WorkerSupportsCancellation = command.CanBeCancelled;
activeCommand.WorkerSupportsCancellation = command.CanBeCancelled;
while (p_activeCommand is not null && p_activeCommand.IsBusy) Thread.Yield();
while (activeCommand is not null && activeCommand.IsBusy) Thread.Yield();
if (p_activeCommand is not null)
if (activeCommand is not null)
{
p_activeCommand.Dispose();
p_activeCommand = null;
activeCommand.Dispose();
activeCommand = null;
}
if (ShellDirectory is null) Write("[WARNING] Could not save config to shell location. Any changes will be ignored.");
@ -320,45 +297,24 @@ public class Shell
public void ReloadDirectoryInfo()
{
try
{
ActiveMod = Mod.ReadDirectory(WorkingDirectory);
ActiveGame = ActiveMod?.BaseGame;
ActiveMod = Mod.ReadDirectory(WorkingDirectory);
// Update title.
string title = "SrcMod";
if (ActiveMod is not null) title += $" - {ActiveMod.Name}";
Console.Title = title;
p_printedLastReloadError = false;
}
catch (Exception ex)
{
if (!p_printedLastReloadError)
{
#if RELEASE
Write("[ERROR] Error reloading directory information. Some data may not update.",
ConsoleColor.Red);
#else
Write(ex, ConsoleColor.Red);
#endif
}
p_printedLastReloadError = true;
Console.Title = "SrcMod (Error)";
}
// Update title.
string title = "SrcMod";
if (ActiveMod is not null) title += $" - {ActiveMod.Name}";
Console.Title = title;
}
private void HandleCancel(object? sender, ConsoleCancelEventArgs args)
{
if (p_activeCommand is not null && p_activeCommand.IsBusy)
if (activeCommand is not null && activeCommand.IsBusy)
{
if (p_activeCommand.WorkerSupportsCancellation)
if (activeCommand.WorkerSupportsCancellation)
{
// Kill the active command.
p_activeCommand.CancelAsync();
p_activeCommand.Dispose();
p_activeCommand = null;
activeCommand.CancelAsync();
activeCommand.Dispose();
activeCommand = null;
}
else
{
@ -367,18 +323,18 @@ public class Shell
PlayErrorSound();
}
p_lastCancel = false;
p_printedCancel = false;
lastCancel = false;
printedCancel = false;
args.Cancel = true;
return;
}
// Due to some funny multithreading issues, we want to make the warning label
// single-threaded on the shell.
if (!p_lastCancel)
if (!lastCancel)
{
// Enable the warning. The "ReadLine" method will do the rest.
p_lastCancel = true;
lastCancel = true;
args.Cancel = true; // "Cancel" referring to the cancellation of the cancel operation.
return;
}

16
SrcMod/Shell/Shell.csproj
View File

@ -2,7 +2,7 @@
<PropertyGroup>
<OutputType>Exe</OutputType>
<TargetFramework>net7.0-windows</TargetFramework>
<TargetFramework>net7.0</TargetFramework>
<ImplicitUsings>disable</ImplicitUsings>
<Nullable>enable</Nullable>
<AssemblyName>srcmod</AssemblyName>
@ -16,6 +16,16 @@
<NoWin32Manifest>true</NoWin32Manifest>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Debug|AnyCPU'">
<DebugType>embedded</DebugType>
<WarningLevel>9999</WarningLevel>
</PropertyGroup>
<PropertyGroup Condition="'$(Configuration)|$(Platform)'=='Release|AnyCPU'">
<DebugType>embedded</DebugType>
<WarningLevel>9999</WarningLevel>
</PropertyGroup>
<ItemGroup>
<Content Include="Logo.ico" />
</ItemGroup>
@ -26,8 +36,4 @@
<PackageReference Include="SharpCompress" Version="0.33.0" />
</ItemGroup>
<ItemGroup>
<ProjectReference Include="..\Valve.NET\Valve.NET.csproj" />
</ItemGroup>
</Project>

18
SrcMod/Shell/Tools.cs
View File

@ -1,28 +1,16 @@
namespace SrcMod.Shell;
public static class Tools
internal static class Tools
{
public static JsonSerializer SerializerJson { get; private set; }
public static VkvSerializer SerializeVkv { get; private set; }
public static JsonSerializer Serializer { get; private set; }
static Tools()
{
SerializerJson = JsonSerializer.Create(new()
Serializer = JsonSerializer.Create(new()
{
Formatting = Formatting.Indented,
NullValueHandling = NullValueHandling.Ignore
});
SerializeVkv = new VkvSerializer(new()
{
closeWhenFinished = true,
indentSize = 4,
resetStreamPosition = false,
serializeProperties = true,
spacing = SpacingMode.DoubleTab,
useEscapeCodes = true,
useQuotes = true
});
}
public static void DisplayWithPages(IEnumerable<string> lines, ConsoleColor? color = null)

31
SrcMod/SrcMod.sln
View File

@ -1,31 +0,0 @@

Microsoft Visual Studio Solution File, Format Version 12.00
# Visual Studio Version 17
VisualStudioVersion = 17.4.33213.308
MinimumVisualStudioVersion = 10.0.40219.1
Project("{9A19103F-16F7-4668-BE54-9A1E7A4F7556}") = "Shell", "Shell\Shell.csproj", "{6EC87235-F2A5-4313-A6DE-A4EE7CB7B341}"
EndProject
Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Valve.NET", "Valve.NET\Valve.NET.csproj", "{8FC96202-2F7E-4FBE-B08E-FCC38AA62D96}"
EndProject
Global
GlobalSection(SolutionConfigurationPlatforms) = preSolution
Debug|Any CPU = Debug|Any CPU
Release|Any CPU = Release|Any CPU
EndGlobalSection
GlobalSection(ProjectConfigurationPlatforms) = postSolution
{6EC87235-F2A5-4313-A6DE-A4EE7CB7B341}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{6EC87235-F2A5-4313-A6DE-A4EE7CB7B341}.Debug|Any CPU.Build.0 = Debug|Any CPU
{6EC87235-F2A5-4313-A6DE-A4EE7CB7B341}.Release|Any CPU.ActiveCfg = Release|Any CPU
{6EC87235-F2A5-4313-A6DE-A4EE7CB7B341}.Release|Any CPU.Build.0 = Release|Any CPU
{8FC96202-2F7E-4FBE-B08E-FCC38AA62D96}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
{8FC96202-2F7E-4FBE-B08E-FCC38AA62D96}.Debug|Any CPU.Build.0 = Debug|Any CPU
{8FC96202-2F7E-4FBE-B08E-FCC38AA62D96}.Release|Any CPU.ActiveCfg = Release|Any CPU
{8FC96202-2F7E-4FBE-B08E-FCC38AA62D96}.Release|Any CPU.Build.0 = Release|Any CPU
EndGlobalSection
GlobalSection(SolutionProperties) = preSolution
HideSolutionNode = FALSE
EndGlobalSection
GlobalSection(ExtensibilityGlobals) = postSolution
SolutionGuid = {4E25AC28-DD70-4BB6-9083-07D6371DECCF}
EndGlobalSection
EndGlobal

17
SrcMod/Valve.NET/Miscellaneous/GlobalUsings.cs
View File

@ -1,17 +0,0 @@
global using System;
global using System.Collections;
global using System.Collections.Generic;
global using System.ComponentModel;
global using System.Diagnostics;
global using System.Formats.Tar;
global using System.IO;
global using System.IO.Compression;
global using System.Linq;
global using System.Reflection;
global using System.Runtime.InteropServices;
global using System.Text;
global using System.Threading;
global using Valve;
global using Valve.Miscellaneous;
global using Valve.Vkv;
global using Valve.Vkv.ObjectModels;

74
SrcMod/Valve.NET/Miscellaneous/TypeParsers.cs
View File

@ -1,74 +0,0 @@
namespace Valve.Miscellaneous;
public static class TypeParsers
{
public static bool CanParse(object? obj) => obj is not null && obj is bool or sbyte or byte or short or ushort
or int or uint or long or ulong or Int128 or UInt128 or nint or nuint or Half or float or double or decimal
or char or DateOnly or DateTime or DateTimeOffset or Guid or TimeOnly or TimeSpan;
public static object ParseAll(string msg)
{
if (TryParseBool(msg, out bool resBool)) return resBool;
else if (TryParse(msg, out sbyte int8)) return int8;
else if (TryParse(msg, out byte uInt8)) return uInt8;
else if (TryParse(msg, out short int16)) return int16;
else if (TryParse(msg, out ushort uInt16)) return uInt16;
else if (TryParse(msg, out int int32)) return int32;
else if (TryParse(msg, out uint uInt32)) return uInt32;
else if (TryParse(msg, out long int64)) return int64;
else if (TryParse(msg, out ulong uInt64)) return uInt64;
else if (TryParse(msg, out Int128 int128)) return int128;
else if (TryParse(msg, out UInt128 uInt128)) return uInt128;
else if (TryParse(msg, out nint intPtr)) return intPtr;
else if (TryParse(msg, out nuint uIntPtr)) return uIntPtr;
else if (TryParse(msg, out Half float16)) return float16;
else if (TryParse(msg, out float float32)) return float32;
else if (TryParse(msg, out double float64)) return float64;
else if (TryParse(msg, out decimal float128)) return float128;
else if (TryParse(msg, out char resChar)) return resChar;
else if (TryParse(msg, out DateOnly dateOnly)) return dateOnly;
else if (TryParse(msg, out DateTime dateTime)) return dateTime;
else if (TryParse(msg, out DateTimeOffset dateTimeOffset)) return dateTimeOffset;
else if (TryParse(msg, out Guid guid)) return guid;
else if (TryParse(msg, out TimeOnly timeOnly)) return timeOnly;
else if (TryParse(msg, out TimeSpan timeSpan)) return timeSpan;
else return msg;
}
public static bool TryParseBool(string msg, out bool result)
{
string trimmed = msg.Trim().ToLower();
string[] trues = new string[]
{
"t",
"true",
"1",
"y",
"yes"
},
falses = new string[]
{
"f",
"false",
"0",
"n",
"no"
};
foreach (string t in trues) if (trimmed == t)
{
result = true;
return true;
}
foreach (string f in falses) if (trimmed == f)
{
result = false;
return true;
}
result = false;
return false;
}
public static bool TryParse<T>(string msg, out T? result) where T : IParsable<T>
=> T.TryParse(msg, null, out result);
}

17
SrcMod/Valve.NET/Valve.NET.csproj
View File

@ -1,17 +0,0 @@
<Project Sdk="Microsoft.NET.Sdk">
<PropertyGroup>
<OutputType>Library</OutputType>
<TargetFramework>net7.0</TargetFramework>
<ImplicitUsings>disable</ImplicitUsings>
<Nullable>enable</Nullable>
<AssemblyName>valve.net</AssemblyName>
<RootNamespace>Valve</RootNamespace>
<OutputPath>../Compiled/Valve.NET</OutputPath>
<Title>Valve.NET</Title>
<Authors>That_One_Nerd</Authors>
<AppendTargetFrameworkToOutputPath>false</AppendTargetFrameworkToOutputPath>
<NoWin32Manifest>true</NoWin32Manifest>
</PropertyGroup>
</Project>

6
SrcMod/Valve.NET/Vkv/ObjectModels/IVkvConvertible.cs
View File

@ -1,6 +0,0 @@
namespace Valve.Vkv.ObjectModels;
public interface IVkvConvertible
{
public VkvNode ToNodeTree();
}

4
SrcMod/Valve.NET/Vkv/ObjectModels/VkvIgnoreAttribute.cs
View File

@ -1,4 +0,0 @@
namespace Valve.Vkv.ObjectModels;
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false, Inherited = true)]
public class VkvIgnoreAttribute : Attribute { }

9
SrcMod/Valve.NET/Vkv/ObjectModels/VkvKeyNameAttribute.cs
View File

@ -1,9 +0,0 @@
namespace Valve.Vkv.ObjectModels;
[AttributeUsage(AttributeTargets.Property | AttributeTargets.Field, AllowMultiple = false, Inherited = false)]
public class VkvKeyNameAttribute : Attribute
{
public readonly string name;
public VkvKeyNameAttribute(string name) => this.name = name;
}

8
SrcMod/Valve.NET/Vkv/ObjectModels/VkvSerializationException.cs
View File

@ -1,8 +0,0 @@
namespace Valve.Vkv.ObjectModels;
public class VkvSerializationException : Exception
{
public VkvSerializationException() : base() { }
public VkvSerializationException(string message) : base(message) { }
public VkvSerializationException(string message, Exception inner) : base(message, inner) { }
}

8
SrcMod/Valve.NET/Vkv/SpacingMode.cs
View File

@ -1,8 +0,0 @@
namespace Valve.Vkv;
public enum SpacingMode
{
SingleSpace = 0,
IndentSizeSpacing,
DoubleTab,
}

449
SrcMod/Valve.NET/Vkv/VkvConvert.cs
View File

@ -1,449 +0,0 @@
namespace Valve.Vkv;
public static class VkvConvert
{
private static readonly Dictionary<string, string> p_escapeCodes = new()
{
{ "\\", @"\\" }, // This must be first.
{ "\'", @"\'" },
{ "\"", @"\""" },
{ "\0", @"\0" },
{ "\a", @"\a" },
{ "\b", @"\b" },
{ "\f", @"\f" },
{ "\n", @"\n" },
{ "\r", @"\r" },
{ "\t", @"\t" },
{ "\v", @"\v" }
};
#region DeserializeNode
public static VkvNode? DeserializeNode(StreamReader reader) =>
DeserializeNode(reader, VkvOptions.Default);
public static VkvNode? DeserializeNode(StreamReader reader, VkvOptions options)
{
try
{
return DeserializeNode(reader, options, out _, null);
}
catch
{
if (!options.noExceptions) throw;
return null;
}
}
private static VkvNode? DeserializeNode(StreamReader reader, VkvOptions options, out string name,
string? first)
{
string? header = first ?? (reader.ReadLine()?.Trim());
if (header is null || string.IsNullOrEmpty(header))
{
name = string.Empty;
return null;
}
string[] parts = SplitContent(header, options);
if (parts.Length > 2) throw new VkvSerializationException("Too many values in node.");
VkvNode node;
name = DeserializeString(parts[0], options);
if (parts.Length == 2)
{
string value = DeserializeString(parts[1], options);
node = new VkvSingleNode(value);
}
else
{
string? next = reader.ReadLine()?.Trim();
if (next is null) throw new VkvSerializationException("Expected starting '{', found end-of-file.");
else if (next != "{") throw new VkvSerializationException($"Expected starting '{{', found \"{next}\".");
VkvTreeNode tree = new();
string? current;
while ((current = reader.ReadLine()?.Trim()) is not null)
{
if (current == "}") break;
VkvNode? output = DeserializeNode(reader, options, out string subName, current);
tree[subName] = output;
}
if (current is null) throw new VkvSerializationException("Reached end-of-file while deserializing group.");
node = tree;
}
return node;
}
private static string DeserializeString(string content, VkvOptions options)
{
if (options.useQuotes)
{
if (!content.StartsWith('\"') || !content.EndsWith('\"'))
throw new VkvSerializationException("No quotes found around content.");
content = content[1..^1];
}
if (options.useEscapeCodes)
{
foreach (KeyValuePair<string, string> escapeCode in p_escapeCodes.Reverse())
content = content.Replace(escapeCode.Value, escapeCode.Key);
}
return content;
}
private static string[] SplitContent(string content, VkvOptions options)
{
content = content.Replace('\t', ' ');
if (options.useQuotes)
{
List<string> values = new();
string current = string.Empty;
bool inQuote = false;
for (int i = 0; i < content.Length; i++)
{
char c = content[i];
if (c == '\"' && !(i > 0 && content[i - 1] == '\\')) inQuote = !inQuote;
if (c == ' ' && !inQuote)
{
if (!string.IsNullOrEmpty(current)) values.Add(current);
current = string.Empty;
}
else current += c;
}
if (inQuote) throw new VkvSerializationException("Reached end-of-line while inside quotations.");
if (!string.IsNullOrEmpty(current)) values.Add(current);
return values.ToArray();
}
else return content.Split(' ', StringSplitOptions.TrimEntries | StringSplitOptions.RemoveEmptyEntries);
}
#endregion
#region FromNodeTree
public static T? FromNodeTree<T>(VkvNode? node, VkvOptions options) => (T?)FromNodeTree(typeof(T), node, options);
public static object? FromNodeTree(Type outputType, VkvNode? node, VkvOptions options)
{
try
{
if (node is null) return null;
if (node is VkvSingleNode single) return FromSingleNode(outputType, single);
else if (node is VkvTreeNode tree) return FromTreeNode(outputType, tree, options);
else throw new VkvSerializationException("Unknown VKV node type.");
}
catch
{
if (!options.noExceptions) throw;
return null;
}
}
private static object? FromSingleNode(Type outputType, VkvSingleNode node)
{
object? value = node.value;
if (value is null) return null;
else if (value is string str)
{
value = TypeParsers.ParseAll(str);
if (value is string still && outputType.IsEnum)
{
if (Enum.TryParse(outputType, still, true, out object? res) && res is not null)
value = res;
}
}
return Convert.ChangeType(value, outputType);
}
private static object? FromTreeNode(Type outputType, VkvTreeNode node, VkvOptions options)
{
if (outputType.IsArray)
return FromTreeNodeArray(outputType, node, options);
else if (outputType.GetInterface("IList") is not null)
return FromTreeNodeList(outputType, node, options);
else if (outputType.GetInterface("IDictionary") is not null)
return FromTreeNodeDictionary(outputType, node, options);
object? instance = Activator.CreateInstance(outputType);
if (instance is null) return null;
IEnumerable<FieldInfo> validFields = from field in outputType.GetFields()
let isPublic = field.IsPublic
let isStatic = field.IsStatic
let isIgnored = field.CustomAttributes.Any(x =>
x.AttributeType == typeof(VkvIgnoreAttribute))
let isConst = field.IsLiteral
where isPublic && !isStatic && !isIgnored && !isConst
select field;
IEnumerable<PropertyInfo> validProperties;
if (options.serializeProperties)
{
validProperties = from prop in outputType.GetProperties()
let canSet = prop.SetMethod is not null
let isPublic = canSet && prop.SetMethod!.IsPublic
let isStatic = canSet && prop.SetMethod!.IsStatic
let isIgnored = prop.CustomAttributes.Any(x =>
x.AttributeType == typeof(VkvIgnoreAttribute))
where canSet && isPublic && !isStatic && !isIgnored
select prop;
}
else validProperties = Array.Empty<PropertyInfo>();
foreach (FieldInfo field in validFields)
{
VkvKeyNameAttribute? namingAttribute = field.GetCustomAttribute<VkvKeyNameAttribute>();
VkvNode? subNode = node[namingAttribute?.name ?? field.Name];
if (subNode is null) continue;
object? result = FromNodeTree(field.FieldType, subNode, options);
if (result is null) continue;
field.SetValue(instance, result);
}
foreach (PropertyInfo prop in validProperties)
{
VkvKeyNameAttribute? namingAttribute = prop.GetCustomAttribute<VkvKeyNameAttribute>();
VkvNode? subNode = node[namingAttribute?.name ?? prop.Name];
if (subNode is null) continue;
object? result = FromNodeTree(prop.PropertyType, subNode, options);
if (result is null) continue;
prop.SetValue(instance, result);
}
return instance;
}
private static object? FromTreeNodeArray(Type outputType, VkvTreeNode node, VkvOptions options)
{
Type elementType = outputType.GetElementType()!;
Array array = Array.CreateInstance(elementType, node.SubNodeCount);
int index = 0;
foreach (KeyValuePair<string, VkvNode?> subNode in node)
{
string indexStr = index.ToString();
if (subNode.Key != indexStr) throw new VkvSerializationException($"Cannot convert node tree to array.");
array.SetValue(FromNodeTree(elementType, subNode.Value, options), index);
index++;
}
return array;
}
private static object? FromTreeNodeList(Type outputType, VkvTreeNode node, VkvOptions options)
{
IList? instance = (IList?)Activator.CreateInstance(outputType);
if (instance is null) return null;
// There is no guarentee that the first type argument corresponds to the element type,
// but as far as I know there isn't a better way.
Type elementType = outputType.IsGenericType ? outputType.GenericTypeArguments[0] : typeof(object);
int index = 0;
foreach (KeyValuePair<string, VkvNode?> subNode in node)
{
string indexStr = index.ToString();
if (subNode.Key != indexStr) throw new VkvSerializationException($"Cannot convert node tree to array.");
instance.Add(FromNodeTree(elementType, subNode.Value, options));
index++;
}
return instance;
}
private static object? FromTreeNodeDictionary(Type outputType, VkvTreeNode node, VkvOptions options)
{
IDictionary? instance = (IDictionary?)Activator.CreateInstance(outputType);
if (instance is null) return null;
// There is no guarentee that the first and second type arguments represent the
// key and value types, but as far as I know there isn't a better way.
bool canUseGenerics = outputType.GenericTypeArguments.Length >= 2;
Type keyType = canUseGenerics ? outputType.GenericTypeArguments[0] : typeof(object),
valueType = canUseGenerics ? outputType.GenericTypeArguments[1] : typeof(object);
foreach (KeyValuePair<string, VkvNode?> subNode in node)
{
object key = TypeParsers.ParseAll(subNode.Key);
if (key is string still && keyType.IsEnum)
{
if (Enum.TryParse(keyType, still, true, out object? res) && res is not null)
key = res;
}
key = Convert.ChangeType(key, keyType);
object? value = FromNodeTree(valueType, subNode.Value, options);
instance.Add(key, value);
}
return instance;
}
#endregion
#region SerializeNode
public static void SerializeNode(StreamWriter writer, VkvNode? node, string name,
VkvOptions options)
{
try
{
SerializeNode(writer, node, name, options, 0);
}
catch
{
if (!options.noExceptions) throw;
}
}
public static void SerializeNode(StreamWriter writer, VkvNode? node, string name) =>
SerializeNode(writer, node, name, VkvOptions.Default);
private static void SerializeNode(StreamWriter writer, VkvNode? node, string name,
VkvOptions options, int indentLevel)
{
if (node is null) return;
else if (node is VkvSingleNode single) SerializeSingleNode(writer, single, name, options, indentLevel);
else if (node is VkvTreeNode tree) SerializeTreeNode(writer, tree, name, options, indentLevel);
else throw new("Unknown node type.");
}
private static void SerializeSingleNode(StreamWriter writer, VkvSingleNode node, string name,
VkvOptions options, int indentLevel)
{
string? serializedValue = SerializeObject(node.value);
if (serializedValue is null) return;
writer.Write(new string(' ', indentLevel));
writer.Write(SerializeString(name, options));
switch (options.spacing)
{
case SpacingMode.SingleSpace: writer.Write(' ');
break;
case SpacingMode.IndentSizeSpacing: writer.Write(new string(' ', options.indentSize));
break;
case SpacingMode.DoubleTab: writer.Write("\t\t");
break;
default: throw new VkvSerializationException($"Unknown spacing mode \"{options.spacing}\".");
}
serializedValue = SerializeString(serializedValue, options);
writer.WriteLine(serializedValue);
}
private static void SerializeTreeNode(StreamWriter writer, VkvTreeNode node, string name,
VkvOptions options, int indentLevel)
{
if (node.SubNodeCount <= 0) return;
writer.Write(new string(' ', indentLevel));
writer.WriteLine(SerializeString(name, options));
writer.WriteLine(new string(' ', indentLevel) + '{');
foreach (KeyValuePair<string, VkvNode?> subNode in node)
SerializeNode(writer, subNode.Value, subNode.Key, options, indentLevel + options.indentSize);
writer.WriteLine(new string(' ', indentLevel) + '}');
}
private static string? SerializeObject(object? obj)
{
if (obj is null) return null;
return obj.ToString() ?? string.Empty;
}
private static string SerializeString(string content, VkvOptions options)
{
if (options.useEscapeCodes)
{
foreach (KeyValuePair<string, string> escapeCode in p_escapeCodes)
content = content.Replace(escapeCode.Key, escapeCode.Value);
}
if (options.useQuotes) content = $"\"{content}\"";
return content;
}
#endregion
#region ToNodeTree
public static VkvNode? ToNodeTree(object? obj) => ToNodeTree(obj, VkvOptions.Default);
public static VkvNode? ToNodeTree(object? obj, VkvOptions options)
{
try
{
if (obj is null) return null;
Type type = obj.GetType();
if (type.IsPrimitive || TypeParsers.CanParse(obj)) return new VkvSingleNode(obj);
else if (type.IsPointer) throw new("Cannot serialize a pointer.");
VkvTreeNode tree = new();
if (obj is IVkvConvertible vkv) return vkv.ToNodeTree();
else if (obj is IDictionary dictionary)
{
object[] keys = new object[dictionary.Count],
values = new object[dictionary.Count];
dictionary.Keys.CopyTo(keys, 0);
dictionary.Values.CopyTo(values, 0);
for (int i = 0; i < dictionary.Count; i++)
{
tree[SerializeObject(keys.GetValue(i))!] = ToNodeTree(values.GetValue(i), options);
}
return tree;
}
else if (obj is ICollection enumerable)
{
int index = 0;
foreach (object item in enumerable)
{
tree[SerializeObject(index)!] = ToNodeTree(item, options);
index++;
}
return tree;
}
IEnumerable<FieldInfo> validFields = from field in type.GetFields()
let isPublic = field.IsPublic
let isStatic = field.IsStatic
let isIgnored = field.CustomAttributes.Any(x =>
x.AttributeType == typeof(VkvIgnoreAttribute))
let isConst = field.IsLiteral
where isPublic && !isStatic && !isIgnored && !isConst
select field;
IEnumerable<PropertyInfo> validProperties;
if (options.serializeProperties)
{
validProperties = from prop in type.GetProperties()
let canGet = prop.GetMethod is not null
let isPublic = canGet && prop.GetMethod!.IsPublic
let isStatic = canGet && prop.GetMethod!.IsStatic
let isIgnored = prop.CustomAttributes.Any(x =>
x.AttributeType == typeof(VkvIgnoreAttribute))
where canGet && isPublic && !isStatic && !isIgnored
select prop;
}
else validProperties = Array.Empty<PropertyInfo>();
foreach (FieldInfo field in validFields)
{
VkvKeyNameAttribute? namingAttribute = field.GetCustomAttribute<VkvKeyNameAttribute>();
tree[namingAttribute?.name ?? field.Name] = ToNodeTree(field.GetValue(obj), options);
}
foreach (PropertyInfo prop in validProperties)
{
VkvKeyNameAttribute? namingAttribute = prop.GetCustomAttribute<VkvKeyNameAttribute>();
tree[namingAttribute?.name ?? prop.Name] = ToNodeTree(prop.GetValue(obj), options);
}
return tree;
}
catch
{
if (!options.noExceptions) throw;
return null;
}
}
#endregion
}

3
SrcMod/Valve.NET/Vkv/VkvNode.cs
View File

@ -1,3 +0,0 @@
namespace Valve.Vkv;
public abstract class VkvNode { }

27
SrcMod/Valve.NET/Vkv/VkvOptions.cs
View File

@ -1,27 +0,0 @@
namespace Valve.Vkv;
public record class VkvOptions
{
public static VkvOptions Default => new();
public bool closeWhenFinished;
public int indentSize;
public bool noExceptions;
public bool resetStreamPosition;
public bool serializeProperties;
public SpacingMode spacing;
public bool useEscapeCodes;
public bool useQuotes;
public VkvOptions()
{
closeWhenFinished = true;
indentSize = 4;
noExceptions = false;
resetStreamPosition = false;
serializeProperties = true;
spacing = SpacingMode.DoubleTab;
useEscapeCodes = false;
useQuotes = false;
}
}

57
SrcMod/Valve.NET/Vkv/VkvSerializer.cs
View File

@ -1,57 +0,0 @@
namespace Valve.Vkv;
public class VkvSerializer
{
public VkvOptions Options => p_options;
private readonly VkvOptions p_options;
public VkvSerializer() : this(VkvOptions.Default) { }
public VkvSerializer(VkvOptions options)
{
p_options = options;
}
public VkvNode? Deserialize(Stream stream)
{
long pos = stream.Position;
StreamReader reader = new(stream, leaveOpen: !p_options.closeWhenFinished);
try
{
VkvNode? result = VkvConvert.DeserializeNode(reader, p_options);
reader.Close();
if (!p_options.closeWhenFinished && p_options.resetStreamPosition) stream.Seek(pos, SeekOrigin.Begin);
return result;
}
finally
{
reader.Close();
if (!p_options.closeWhenFinished && p_options.resetStreamPosition) stream.Seek(pos, SeekOrigin.Begin);
}
}
public T? Deserialize<T>(Stream stream)
{
VkvNode? result = Deserialize(stream);
return VkvConvert.FromNodeTree<T>(result, p_options);
}
public object? Deserialize(Type outputType, Stream stream)
{
VkvNode? result = Deserialize(stream);
return VkvConvert.FromNodeTree(outputType, result, p_options);
}
public void Serialize(Stream stream, object? value, string parentNodeName)
{
VkvNode? nodeTree = VkvConvert.ToNodeTree(value, p_options);
Serialize(stream, nodeTree, parentNodeName);
}
public void Serialize(Stream stream, VkvNode? parentNode, string parentNodeName)
{
long pos = stream.Position;
StreamWriter writer = new(stream, leaveOpen: !p_options.closeWhenFinished);
VkvConvert.SerializeNode(writer, parentNode, parentNodeName, p_options);
writer.Close();
if (!p_options.closeWhenFinished && p_options.resetStreamPosition) stream.Seek(pos, SeekOrigin.Begin);
}
}

11
SrcMod/Valve.NET/Vkv/VkvSingleNode.cs
View File

@ -1,11 +0,0 @@
namespace Valve.Vkv;
public class VkvSingleNode : VkvNode
{
public object? value;
public VkvSingleNode(object? value = null) : base()
{
this.value = value;
}
}

45
SrcMod/Valve.NET/Vkv/VkvTreeNode.cs
View File

@ -1,45 +0,0 @@
namespace Valve.Vkv;
public class VkvTreeNode : VkvNode, IEnumerable<KeyValuePair<string, VkvNode?>>
{
public int SubNodeCount => p_subNodes.Count;
private readonly Dictionary<string, VkvNode?> p_subNodes;
public VkvTreeNode(Dictionary<string, VkvNode?>? subNodes = null) : base()
{
p_subNodes = subNodes ?? new();
}
public VkvNode? this[string key]
{
get
{
if (p_subNodes.TryGetValue(key, out VkvNode? value)) return value;
else return null;
}
set
{
if (p_subNodes.ContainsKey(key)) p_subNodes[key] = value;
else p_subNodes.Add(key, value);
}
}
public VkvNode? this[int index]
{
get
{
if (p_subNodes.Count >= index || index < 0) return null;
return p_subNodes.Values.ElementAt(index);
}
set
{
if (p_subNodes.Count >= index || index < 0) throw new IndexOutOfRangeException();
p_subNodes[p_subNodes.Keys.ElementAt(index)] = value;
}
}
public void Add(string key, VkvNode? value) => this[key] = value;
IEnumerator IEnumerable.GetEnumerator() => GetEnumerator();
public IEnumerator<KeyValuePair<string, VkvNode?>> GetEnumerator() => p_subNodes.GetEnumerator();
}