public void Subscribe(Godot.Object Target, string MemberName, string Property, SubscriberType Type)
{
if (!ModIDUtil.Validate(Property))
{
return;
}
if (!Properties.ContainsKey(Property))
{
return;
}
if (!Subscribers.ContainsKey(Property))
{
Subscribers[Property] = new List <Subscriber>();
}
Subscriber NewSubscriber = new Subscriber
{
Target = Target,
MemberName = MemberName,
Type = Type
};
Subscribers[Property].Add(NewSubscriber);
if (Type == SubscriberType.Member)
{
Target.Set(MemberName, Get(Property));
}
else
{
Target.Call(MemberName, Get(Property));
}
}
private void LoadLocale(string ModID, string LocaleIndex, bool Selected)
{
string LocaleDir = "res://" + ModID + "/Locales/" + LocaleIndex;
if (!FilesystemUtil.GD.DirExists(LocaleDir))
{
ConsoleSys.Error("Failed to load locale at " + LocaleDir + " because folder does not exist");
return;
}
List <string> LocaleFiles = FilesystemUtil.GD.DirGetFiles(LocaleDir);
for (int i = LocaleFiles.Count - 1; i >= 0; --i)
{
if (!LocaleFiles[i].EndsWith(".json"))
{
LocaleFiles.RemoveAt(i);
}
}
for (int i = LocaleFiles.Count - 1; i >= 0; --i)
{
string LocaleManifest = FilesystemUtil.GD.FileRead(LocaleFiles[i]);
try
{
Dictionary <string, string> LocaleEntries = JsonConvert.DeserializeObject <Dictionary <string, string> >(LocaleManifest);
foreach (var Entry in LocaleEntries)
{
if (!ModIDUtil.Validate(Entry.Key))
{
ConsoleSys.Error("Locale entry " + Entry.Key + " is not a valid ModIDEntry");
continue;
}
if (Selected)
{
SelectedLocaleEntries[Entry.Key] = Entry.Value;
}
else
{
FallbackLocaleEntries[Entry.Key] = Entry.Value;
}
}
}
catch (Exception Exception)
{
ConsoleSys.Error("Failed to parse locale manifest at " + LocaleFiles[i]);
ConsoleSys.Error(Exception.Message);
continue;
}
}
}
private string GetArguments(ParameterInfo[] Parameters)
{
string Result = "Required arguments: \n";
foreach (var Parameter in Parameters)
{
Result += ModIDUtil.FromType(Parameter.ParameterType) + ", ";
}
Result = Result.Substring(0, Result.Length - 2);
return(Result);
}
private void AddModEntry(string ModIDEntry, object Entry)
{
//Entries
Entries.AddModEntry(ModIDEntry, MessagePackSerializer.Typeless.Serialize(Entry));
//Categories
List <string> NewCategories = ModIDUtil.GetCategories(ModIDEntry);
foreach (var Category in NewCategories)
{
Categories.AddModEntry(Category, ModIDEntry);
}
}
public void Subscribe(Godot.Object Target, string MemberName, string VariableName, SubscriberType Type)
{
if (!ModIDUtil.Validate(VariableName))
{
return;
}
string ModID = ModIDUtil.ModID(VariableName);
if (Configs.ContainsKey(ModID))
{
Configs[ModID].Subscribe(Target, MemberName, VariableName, Type);
}
}
public object Get(string Property)
{
if (!ModIDUtil.Validate(Property))
{
return(null);
}
if (Properties.ContainsKey(Property))
{
return(Properties[Property].Value);
}
else
{
return(null);
}
}
public void Set(string Property, object Value)
{
if (!ModIDUtil.Validate(Property))
{
return;
}
string TypeName = ModIDUtil.FromType(Value.GetType());
if (!ModIDUtil.Validate(TypeName))
{
return;
}
Properties[Property] = new Variable
{
Type = TypeName,
Value = Value
};
if (Subscribers.ContainsKey(Property))
{
for (int i = Subscribers[Property].Count - 1; i >= 0; --i)
{
var Target = Subscribers[Property][i];
if (Godot.Object.IsInstanceValid(Target.Target))
{
if (Target.Type == SubscriberType.Member)
{
Target.Target.Set(Target.MemberName, Value);
}
else
{
Target.Target.Call(Target.MemberName, Value);
}
}
else
{
Subscribers[Property].RemoveAt(i);
}
}
}
}
private void AddTypes(Assembly TargetAssembly)
{
foreach (var Type in TargetAssembly.GetTypes())
{
if (Type.Namespace != null && (Type.IsClass || (Type.IsValueType && !Type.IsEnum)))
{
string Key = ModIDUtil.FromType(Type);
if (!NamedTypes.ContainsKey(Key))
{
NamedTypes[Key] = Type;
}
if (!ActualTypes.ContainsKey(Type))
{
ActualTypes[Type] = Key;
}
}
}
}
public SysType GetType <T>() where T : ISysEntry
{
return(GetType(ModIDUtil.FromType(typeof(T))));
}
public bool Contains <T>()
{
return(Contains(ModIDUtil.FromType(typeof(T))));
}
public void ProcessScript(string Command)
{
List <string> CommandParts;
string Arguments = null;
string TargetCommand = default;
if (Command.Contains('(') && Command.Contains(')') && Command[Command.Length - 1] == ')')
{
for (int i = 0; i < Command.Length - 1; ++i)
{
if (Command[i] == '(')
{
TargetCommand = Command.Substring(0, i);
if (i + 1 != Command.Length - 1)
{
Arguments = Command.Substring(i + 1, Command.Length - (i + 2));
}
break;
}
}
// Check for command bind
string ResultCommand = ProcessCommandBinding(TargetCommand);
if (ResultCommand != null)
{
TargetCommand = ResultCommand;
}
CommandParts = TargetCommand.Split('.').ToList();
if (CommandParts.Count != 5)
{
ConsoleSys.Error("Invalid command syntax");
ConsoleSys.Error("Have you tried using \"Help()\"?");
return;
}
if (TargetCommand != "Unary.Common.Shared.ConsoleSys.Message" &&
TargetCommand != "Unary.Common.Shared.ConsoleSys.Warning" &&
TargetCommand != "Unary.Common.Shared.ConsoleSys.Error" &&
TargetCommand != "Unary.Common.Shared.ConsoleSys.Panic")
{
ConsoleSys.Message("> " + Command);
}
}
else
{
ConsoleSys.Error("Invalid command syntax");
ConsoleSys.Error("Have you tried using \"Help()\"?");
return;
}
string ModID = ModIDUtil.ModID(TargetCommand);
if (!RegisteredCommands.ContainsKey(ModID))
{
ConsoleSys.Error(ModID + " is an invalid ModID");
ConsoleSys.Error(GetModIDs());
return;
}
List <string> Systems;
if (CommandParts[2] == "Shared")
{
Systems = Sys.Ref.Shared.Order;
}
else if (CommandParts[2] == "Client")
{
Systems = Sys.Ref.Client.Order;
}
else if (CommandParts[2] == "Server")
{
Systems = Sys.Ref.Server.Order;
}
else
{
ConsoleSys.Error(CommandParts[2] + " is an invalid System type");
ConsoleSys.Error(GetSystemTypes());
return;
}
string ModIDEntry = TargetCommand.GetPartsFromBeginToIndex('.', 3);
SysType Type;
if (!Systems.Contains(ModIDEntry))
{
ConsoleSys.Error(CommandParts[2] + " is an invalid System ModIDEntry");
ConsoleSys.Error(GetSystems(CommandParts[2], Systems));
return;
}
Godot.Object TargetSystem = default;
SysManager TargetManager;
if (CommandParts[2] == "Shared")
{
TargetManager = Sys.Ref.Shared;
}
else if (CommandParts[2] == "Client")
{
TargetManager = Sys.Ref.Client;
}
else
{
TargetManager = Sys.Ref.Server;
}
Type = TargetManager.GetType(ModIDEntry);
switch (Type)
{
case SysType.Object:
TargetSystem = TargetManager.GetObject(ModIDEntry);
break;
case SysType.Node:
TargetSystem = TargetManager.GetNode(ModIDEntry);
break;
case SysType.UI:
TargetSystem = TargetManager.GetUI(ModIDEntry);
break;
}
Type TargetType = TargetSystem.GetType();
MethodInfo[] Methods = TargetType.GetMethods().Where(m => m.DeclaringType == TargetType).ToArray();
MethodInfo TargetMethod = null;
foreach (var Method in Methods)
{
if (Method.Name == CommandParts[4])
{
TargetMethod = Method;
break;
}
}
if (TargetMethod == null)
{
ConsoleSys.Error(CommandParts[4] + " is an invalid method");
ConsoleSys.Error(GetMethods(Methods));
return;
}
ParameterInfo[] ArgumentsInfo = TargetMethod.GetParameters();
string ArgumentValues = '[' + Arguments + ']';
JArray Array;
try
{
Array = JArray.Parse(ArgumentValues);
}
catch (Exception)
{
ConsoleSys.Error(Arguments + " is an invalid set of arguments");
ConsoleSys.Error(GetArguments(ArgumentsInfo));
return;
}
if (Array.Count != ArgumentsInfo.Length)
{
ConsoleSys.Error("Invalid ammount of arguments");
ConsoleSys.Error(GetArguments(ArgumentsInfo));
return;
}
List <object> FinalArguments = new List <object>();
for (int i = 0; i < Array.Count; ++i)
{
try
{
object Argument = JsonConvert.DeserializeObject(Array[i].ToString(Formatting.None), ArgumentsInfo[i].ParameterType);
FinalArguments.Add(Argument);
}
catch (Exception)
{
ConsoleSys.Error(Array[i].ToString() + " is not matching an argument type of " + ArgumentsInfo[i].ParameterType);
ConsoleSys.Error(GetArguments(ArgumentsInfo));
return;
}
}
object CallResult = TargetSystem.Call(CommandParts[4], FinalArguments.ToArray());
if (CallResult != null)
{
ConsoleSys.Message(CallResult.ToString());
}
}
private void LoadEntries(string ModID, bool Core)
{
string EntriesDir = "res://" + ModID + "/Entries";
if (!FilesystemUtil.GD.DirExists(EntriesDir))
{
ConsoleSys.Error("Failed to load entries at " + EntriesDir + " because folder does not exist");
return;
}
List <string> EntriesFiles = FilesystemUtil.GD.DirGetFiles(EntriesDir);
for (int i = EntriesFiles.Count - 1; i >= 0; --i)
{
if (!EntriesFiles[i].EndsWith(".json"))
{
EntriesFiles.RemoveAt(i);
}
}
for (int i = EntriesFiles.Count - 1; i >= 0; --i)
{
string EntryManifest = FilesystemUtil.GD.FileRead(EntriesFiles[i]);
try
{
var Entries = JsonConvert.DeserializeObject <Dictionary <string, Dictionary <string, JObject> > >(EntryManifest);
foreach (var TypeName in Entries)
{
if (!ModIDUtil.Validate(TypeName.Key))
{
ConsoleSys.Error("Entry " + TypeName.Key + " is not a valid ModIDEntry");
continue;
}
string NewModID = ModIDUtil.ModID(TypeName.Key) + ".Entries." + ModIDUtil.ModIDEntry(TypeName.Key);
Type Type = AssemblySys.GetType(NewModID);
if (Type == null)
{
ConsoleSys.Error("Type " + TypeName.Key + " is not a valid type");
continue;
}
foreach (var Entry in TypeName.Value)
{
if (Core)
{
AddCoreEntry(NewModID, JsonConvert.DeserializeObject(Entry.Value.ToString(Formatting.None), Type));
}
else
{
AddModEntry(NewModID, JsonConvert.DeserializeObject(Entry.Value.ToString(Formatting.None), Type));
}
}
}
}
catch (Exception Exception)
{
ConsoleSys.Error("Failed to parse entries manifest at " + EntriesFiles[i]);
ConsoleSys.Error(Exception.Message);
continue;
}
}
}
public T GetEntry <T>(string ModIDEntry)
{
if (!ModIDUtil.Validate(ModIDEntry))
{
return(default);
public string Translate(string ModIDEntry)
{
if (!ModIDUtil.Validate(ModIDEntry))
{
ConsoleSys.Error("Failed to validate " + ModIDEntry);
return(default);
public T Get <T>(string VariableName)
{
if (!ModIDUtil.Validate(VariableName))
{
Sys.Ref.ConsoleSys.Error("Failed to validate " + VariableName);
return(default);
