Dialogue Manager: Update to v3.10.2 (#2052)

Resolves #1825

Author: wjt

addons/dialogue_manager/DialogueManager.cs

@@ -9,6 +9,14 @@
 
 namespace DialogueManagerRuntime
 {
+
+    public enum MutationBehaviour
+    {
+        Wait,
+        DoNotWait,
+        Skip
+    }
+
     public enum TranslationSource
     {
         None,
@@ -33,6 +41,8 @@ public partial class DialogueManager : RefCounted
 
         [Signal] public delegate void ResolvedEventHandler(Variant value);
 
+        private static Random random = new Random();
+
         private static GodotObject? instance;
         public static GodotObject Instance
         {
@@ -41,7 +51,11 @@ public static GodotObject Instance
                 if (instance == null)
                 {
                     instance = Engine.GetSingleton("DialogueManager");
-                    instance.Connect("bridge_dialogue_started", Callable.From((Resource dialogueResource) => DialogueStarted?.Invoke(dialogueResource)));
+                    instance.Connect("dialogue_started", Callable.From((Resource dialogueResource) => DialogueStarted?.Invoke(dialogueResource)));
+                    instance.Connect("passed_title", Callable.From((string title) => PassedTitle?.Invoke(title)));
+                    instance.Connect("got_dialogue", Callable.From((RefCounted line) => GotDialogue?.Invoke(new DialogueLine(line))));
+                    instance.Connect("mutated", Callable.From((Dictionary mutation) => Mutated?.Invoke(mutation)));
+                    instance.Connect("dialogue_ended", Callable.From((Resource dialogueResource) => DialogueEnded?.Invoke(dialogueResource)));
                 }
                 return instance;
             }
@@ -81,56 +95,37 @@ public static Func<Node> GetCurrentScene
             set => Instance.Set("get_current_scene", Callable.From(value));
         }
 
-
-        public static void Prepare(GodotObject instance)
+        public static Resource CreateResourceFromText(string text)
         {
-            instance.Connect("passed_title", Callable.From((string title) => PassedTitle?.Invoke(title)));
-            instance.Connect("got_dialogue", Callable.From((RefCounted line) => GotDialogue?.Invoke(new DialogueLine(line))));
-            instance.Connect("mutated", Callable.From((Dictionary mutation) => Mutated?.Invoke(mutation)));
-            instance.Connect("dialogue_ended", Callable.From((Resource dialogueResource) => DialogueEnded?.Invoke(dialogueResource)));
+            return (Resource)Instance.Call("create_resource_from_text", text);
         }
 
-
-        public static async Task<GodotObject> GetSingleton()
+        public static async Task<DialogueLine?> GetNextDialogueLine(Resource dialogueResource, string key = "", Array<Variant>? extraGameStates = null, MutationBehaviour mutation_behaviour = MutationBehaviour.Wait)
         {
-            if (instance != null) return instance;
-
-            var tree = Engine.GetMainLoop();
-            int x = 0;
-
-            // Try and find the singleton for a few seconds
-            while (!Engine.HasSingleton("DialogueManager") && x < 300)
+            int id = random.Next();
+            Instance.Call("_bridge_get_next_dialogue_line", id, dialogueResource, key, extraGameStates ?? new Array<Variant>(), (int)mutation_behaviour);
+            while (true)
             {
-                await tree.ToSignal(tree, SceneTree.SignalName.ProcessFrame);
-                x++;
-            }
-
-            // If it times out something is wrong
-            if (x >= 300)
-            {
-                throw new Exception("The DialogueManager singleton is missing.");
+                var result = await Instance.ToSignal(Instance, "bridge_get_next_dialogue_line_completed");
+                if ((int)result[0] == id)
+                {
+                    return ((RefCounted)result[1] == null) ? null : new DialogueLine((RefCounted)result[1]);
+                }
             }
-
-            instance = Engine.GetSingleton("DialogueManager");
-            return instance;
-        }
-
-        public static Resource CreateResourceFromText(string text)
-        {
-            return (Resource)Instance.Call("create_resource_from_text", text);
         }
 
-        public static async Task<DialogueLine?> GetNextDialogueLine(Resource dialogueResource, string key = "", Array<Variant>? extraGameStates = null)
+        public static async Task<DialogueLine?> GetLine(Resource dialogueResource, string key = "", Array<Variant>? extraGameStates = null)
         {
-            var instance = (Node)Instance.Call("_bridge_get_new_instance");
-            Prepare(instance);
-            instance.Call("_bridge_get_next_dialogue_line", dialogueResource, key, extraGameStates ?? new Array<Variant>());
-            var result = await instance.ToSignal(instance, "bridge_get_next_dialogue_line_completed");
-            instance.QueueFree();
-
-            if ((RefCounted)result[0] == null) return null;
-
-            return new DialogueLine((RefCounted)result[0]);
+            int id = random.Next();
+            Instance.Call("_bridge_get_line", id, dialogueResource, key, extraGameStates ?? new Array<Variant>());
+            while (true)
+            {
+                var result = await Instance.ToSignal(Instance, "bridge_get_line_completed");
+                if ((int)result[0] == id)
+                {
+                    return ((RefCounted)result[0] == null) ? null : new DialogueLine((RefCounted)result[0]);
+                }
+            }
         }
 
 
@@ -176,12 +171,20 @@ public static string StaticIdToLineId(Resource dialogueResource, string staticId
 
         public static async void Mutate(Dictionary mutation, Array<Variant>? extraGameStates = null, bool isInlineMutation = false)
         {
-            Instance.Call("_bridge_mutate", mutation, extraGameStates ?? new Array<Variant>(), isInlineMutation);
-            await Instance.ToSignal(Instance, "bridge_mutated");
+            int id = random.Next();
+            Instance.Call("_bridge_mutate", id, mutation, extraGameStates ?? new Array<Variant>(), isInlineMutation);
+            while (true)
+            {
+                var result = await Instance.ToSignal(Instance, "bridge_mutated");
+                if ((int)result[0] == id)
+                {
+                    return;
+                }
+            }
         }
 
 
-        public static Array<Dictionary> GetMembersForAutoload(Script script)
+        public static Array<Dictionary> GetMembersForScript(Script script)
         {
             Array<Dictionary> members = new Array<Dictionary>();
 
@@ -215,6 +218,10 @@ public static Array<Dictionary> GetMembersForAutoload(Script script)
                             type = "method";
                             break;
 
+                        case MemberTypes.NestedType:
+                            type = "constant";
+                            break;
+
                         default:
                             continue;
                     }
@@ -232,40 +239,43 @@ public static Array<Dictionary> GetMembersForAutoload(Script script)
 
         public bool ThingHasConstant(GodotObject thing, string property)
         {
-            var fieldInfos = thing.GetType().GetFields(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.DeclaredOnly);
-            foreach (var fieldInfo in fieldInfos)
-            {
-                if (fieldInfo.Name == property && fieldInfo.IsLiteral)
-                {
-                    return true;
-                }
-            }
-
-            return false;
+            var memberInfos = thing.GetType().GetMember(property, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.DeclaredOnly);
+            return memberInfos.Length > 0;
         }
 
 
         public Variant ResolveThingConstant(GodotObject thing, string property)
         {
-            var fieldInfos = thing.GetType().GetFields(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.DeclaredOnly);
-            foreach (var fieldInfo in fieldInfos)
+            var memberInfos = thing.GetType().GetMember(property, BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.DeclaredOnly);
+            foreach (var memberInfo in memberInfos)
             {
-                if (fieldInfo.Name == property && fieldInfo.IsLiteral)
+                if (memberInfo != null)
                 {
                     try
                     {
-                        Variant value = fieldInfo.GetValue(thing) switch
+                        switch (memberInfo.MemberType)
                         {
-                            int v => Variant.From((long)v),
-                            float v => Variant.From((double)v),
-                            System.String v => Variant.From((string)v),
-                            _ => Variant.From(fieldInfo.GetValue(thing))
-                        };
-                        return value;
+                            case MemberTypes.Field:
+                                return ConvertValueToVariant((memberInfo as FieldInfo).GetValue(thing));
+
+                            case MemberTypes.Property:
+                                return ConvertValueToVariant((memberInfo as PropertyInfo).GetValue(thing));
+
+                            case MemberTypes.NestedType:
+                                var type = thing.GetType().GetNestedType(property);
+                                if (type.IsEnum)
+                                {
+                                    return GetEnumAsDictionary(type);
+                                }
+                                break;
+
+                            default:
+                                continue;
+                        }
                     }
-                    catch (Exception)
+                    catch (Exception e)
                     {
-                        throw new Exception($"Constant {property} of type ${fieldInfo.GetValue(thing).GetType()} is not supported by Variant.");
+                        throw new Exception($"{property} is not supported by Variant.");
                     }
                 }
             }
@@ -274,6 +284,53 @@ public Variant ResolveThingConstant(GodotObject thing, string property)
         }
 
 
+        Dictionary GetEnumAsDictionary(Type enumType)
+        {
+            Dictionary dictionary = new Dictionary();
+            foreach (var value in enumType.GetEnumValuesAsUnderlyingType())
+            {
+                var key = enumType.GetEnumName(value);
+                if (key != null)
+                {
+                    dictionary.Add(key, ConvertValueToVariant(value));
+                }
+            }
+            return dictionary;
+        }
+
+
+        Variant ConvertValueToVariant(object value)
+        {
+            if (value == null) return default;
+
+            Type rawType = value.GetType();
+            if (rawType.IsEnum)
+            {
+                var values = GetEnumAsDictionary(rawType);
+                value = values[value.ToString()];
+            }
+
+            return value switch
+            {
+                Variant v => v,
+                bool v => Variant.From(v),
+                byte v => Variant.From((long)v),
+                sbyte v => Variant.From((long)v),
+                short v => Variant.From((long)v),
+                ushort v => Variant.From((long)v),
+                int v => Variant.From((long)v),
+                uint v => Variant.From((long)v),
+                long v => Variant.From(v),
+                ulong v => Variant.From((long)v),
+                float v => Variant.From((double)v),
+                double v => Variant.From(v),
+                string v => Variant.From(v),
+                GodotObject godotObj => Variant.From(godotObj),
+                _ => default
+            };
+        }
+
+
         public bool ThingHasMethod(GodotObject thing, string method, Array<Variant> args)
         {
             var methodInfos = thing.GetType().GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.DeclaredOnly);
@@ -289,19 +346,22 @@ public bool ThingHasMethod(GodotObject thing, string method, Array<Variant> args
         }
 
 
-        public async void ResolveThingMethod(GodotObject thing, string method, Array<Variant> args)
+        public async void ResolveThingMethod(float id, GodotObject thing, string method, Array<Variant> args)
         {
             MethodInfo? info = null;
             var methodInfos = thing.GetType().GetMethods(BindingFlags.Instance | BindingFlags.Static | BindingFlags.Public | BindingFlags.DeclaredOnly);
             foreach (var methodInfo in methodInfos)
             {
-                if (methodInfo.Name == method && args.Count >= methodInfo.GetParameters().Where(p => !p.HasDefaultValue).Count())
+                if (methodInfo.Name == method && args.Count >= methodInfo.GetParameters().Count(p => !p.HasDefaultValue))
                 {
                     info = methodInfo;
                 }
             }
 
-            if (info == null) return;
+            if (info == null) {
+                EmitSignal(SignalName.Resolved, id);
+                return;
+            }
 
 #nullable disable
             // Convert the method args to something reflection can handle
@@ -339,20 +399,26 @@ public async void ResolveThingMethod(GodotObject thing, string method, Array<Var
                 await taskResult;
                 try
                 {
-                    Variant value = (Variant)taskResult.GetType().GetProperty("Result").GetValue(taskResult);
-                    EmitSignal(SignalName.Resolved, value);
+                    object value = taskResult.GetType().GetProperty("Result").GetValue(taskResult);
+                    EmitSignal(SignalName.Resolved, id, ConvertValueToVariant(value));
                 }
                 catch (Exception)
                 {
-                    EmitSignal(SignalName.Resolved);
+                    EmitSignal(SignalName.Resolved, id);
                 }
             }
             else
             {
-                EmitSignal(SignalName.Resolved, (Variant)result);
+                EmitSignal(SignalName.Resolved, id, ConvertValueToVariant(result));
             }
         }
 #nullable enable
+
+
+        public static string GetErrorMessage(int error)
+        {
+            return (string)Instance.Call("_bridge_get_error_message", error);
+        }
     }
 
 
@@ -412,12 +478,6 @@ public string? Time
             get => time;
         }
 
-        private Dictionary pauses = new Dictionary();
-        public Dictionary Pauses
-        {
-            get => pauses;
-        }
-
         private Dictionary speeds = new Dictionary();
         public Dictionary Speeds
         {
@@ -456,7 +516,6 @@ public DialogueLine(RefCounted data)
             character = (string)data.Get("character");
             text = (string)data.Get("text");
             translation_key = (string)data.Get("translation_key");
-            pauses = (Dictionary)data.Get("pauses");
             speeds = (Dictionary)data.Get("speeds");
             inline_mutations = (Array<Godot.Collections.Array>)data.Get("inline_mutations");
             time = (string)data.Get("time");
@@ -474,6 +533,20 @@ public DialogueLine(RefCounted data)
         }
 
 
+        public bool HasTag(string tagName)
+        {
+            string wrapped = $"{tagName}=";
+            foreach (var tag in tags)
+            {
+                if (tag.StartsWith(wrapped))
+                {
+                    return true;
+                }
+            }
+            return false;
+        }
+
+
         public string GetTagValue(string tagName)
         {
             string wrapped = $"{tagName}=";