init

addons/inkgd/mono/InkBridger.cs

@@ -0,0 +1,182 @@
+// /////////////////////////////////////////////////////////////////////////// /
+// Copyright © 2019-2022 Frédéric Maquin <fred@ephread.com>
+// Licensed under the MIT License.
+// See LICENSE in the project root for license information.
+// /////////////////////////////////////////////////////////////////////////// /
+
+using Godot;
+using System;
+using System.Linq;
+using System.Collections.Generic;
+using System.ComponentModel;
+
+public partial class InkBridger : Node
+{
+	#region Imports
+	private readonly GDScript InkPath =
+		(GDScript) ResourceLoader.Load("res://addons/inkgd/runtime/ink_path.gd");
+
+	private readonly GDScript InkList =
+		(GDScript) ResourceLoader.Load("res://addons/inkgd/runtime/lists/ink_list.gd");
+
+	private readonly GDScript InkListDefinition =
+		(GDScript) ResourceLoader.Load("res://addons/inkgd/runtime/lists/list_definition.gd");
+
+	private readonly GDScript InkListItem =
+		(GDScript) ResourceLoader.Load("res://addons/inkgd/runtime/lists/structs/ink_list_item.gd");
+
+	private readonly GDScript InkFunctionResult =
+		(GDScript) ResourceLoader.Load("res://addons/inkgd/runtime/extra/function_result.gd");
+	#endregion
+
+	#region Methods | Helpers
+	public bool IsInkObjectOfType(Godot.Object inkObject, string name)
+	{
+		return inkObject.HasMethod("is_ink_class") && (bool)inkObject.Call("is_ink_class", new object[] { name });
+	}
+
+	public Godot.Object MakeFunctionResult(string textOutput, object returnValue)
+	{
+		var parameters = new object[] { textOutput ?? "", returnValue };
+		return (Godot.Object) InkFunctionResult.New(parameters);
+	}
+	#endregion
+
+	#region Methods | Conversion -> (GDScript -> C#)
+	public Godot.Object MakeGDInkPath(Ink.Runtime.Path3D path) {
+		var inkPath = (Godot.Object) InkPath.New();
+		inkPath.Call("_init_with_components_string", path.componentsString);
+		return inkPath;
+	}
+
+	public Godot.Object MakeGDInkList(Ink.Runtime.InkList list)
+	{
+		var inkListBase = new Godot.Collections.Dictionary<string, int>();
+
+		foreach(KeyValuePair<Ink.Runtime.InkListItem, int> kv in list) {
+			inkListBase.Add(MakeGDInkListItem(kv.Key).Call("serialized") as string, kv.Value);
+		}
+
+		object[] inkListParams = new object[] {
+			inkListBase,
+			list.originNames.ToArray(),
+			MakeGDInkListOrigins(list.origins)
+		};
+
+		var inkList = (Godot.Object) InkList.New();
+		inkList.Call("_init_from_csharp", inkListParams);
+
+		return inkList;
+	}
+
+	public Ink.Runtime.Path3D MakeSharpInkPath(Godot.Object path) {
+		if (!IsInkObjectOfType(path, "InkPath"))
+		{
+			throw new ArgumentException("Expected a 'Godot.Object' of class 'InkPath'");
+		}
+
+		return new Ink.Runtime.Path3D((string)path.Get("components_string"));
+	}
+	#endregion
+
+	#region Methods | Conversion (GDScript -> C#)
+	public Ink.Runtime.InkList MakeSharpInkList(Godot.Object list, Ink.Runtime.Story story)
+	{
+		if (!IsInkObjectOfType(list, "InkList"))
+		{
+			throw new ArgumentException("Expected a 'Godot.Object' of class 'InkList'");
+		}
+
+		var underlyingDictionary = new Godot.Collections.Dictionary<string, int>(
+			(Godot.Collections.Dictionary)list.Get("_dictionary"));
+
+		var originNames = new Godot.Collections.Array<string>(
+			(Godot.Collections.Array)list.Get("origin_names"));
+
+		var inkList = new Ink.Runtime.InkList();
+		inkList.origins = new List<Ink.Runtime.ListDefinition>();
+
+		inkList.SetInitialOriginNames(originNames.ToList());
+
+		foreach(string originName in originNames)
+		{
+			if (story.listDefinitions.TryListGetDefinition (originName, out Ink.Runtime.ListDefinition definition))
+			{
+				if (!inkList.origins.Contains(definition)) {
+					inkList.origins.Add(definition);
+				}
+			}
+			else
+			{
+				throw new Exception (
+					$"InkList origin could not be found in story when reconstructing list: {originName}"
+				);
+			}
+		}
+
+		foreach(KeyValuePair<string, int> kv in underlyingDictionary)
+		{
+			inkList[MakeSharpInkListItem(kv.Key)] = kv.Value;
+		}
+
+		return inkList;
+	}
+	#endregion
+
+	#region Private Methods | Conversion (C# -> GDScript)
+	private Godot.Collections.Array<Godot.Object> MakeGDInkListOrigins(
+		List<Ink.Runtime.ListDefinition> listDefinitions)
+	{
+		var inkListDefinitions = new Godot.Collections.Array<Godot.Object>();
+
+		foreach(Ink.Runtime.ListDefinition listDefinition in listDefinitions) {
+			var inkListDefinition = MakeGDListDefinition(listDefinition);
+			inkListDefinitions.Add(inkListDefinition);
+		}
+
+		return inkListDefinitions;
+	}
+
+	private Godot.Object MakeGDListDefinition(Ink.Runtime.ListDefinition listDefinition)
+	{
+		var items = new Godot.Collections.Dictionary<Godot.Object, int>();
+
+		foreach(KeyValuePair<Ink.Runtime.InkListItem, int> kv in listDefinition.items) {
+			var inkListItem = MakeGDInkListItem(kv.Key);
+			items.Add(inkListItem, kv.Value);
+		}
+
+		var definitionParams = new object[] { listDefinition.name, items };
+		var inkListDefinition = (Godot.Object) InkListDefinition.New(definitionParams);
+
+		return inkListDefinition;
+	}
+
+	private Godot.Object MakeGDInkListItem(Ink.Runtime.InkListItem listItem)
+	{
+		object[] itemParams = new object[] { listItem.fullName };
+
+		var inkListItem = (Godot.Object) InkListItem.New();
+		inkListItem.Call("_init_with_full_name", itemParams);
+
+		return inkListItem;
+	}
+	#endregion
+
+	#region Private Methods | Conversion (GDScript -> C#)
+	private Ink.Runtime.InkListItem MakeSharpInkListItem(string listItemKey)
+	{
+
+		var listItem = (Godot.Object) InkListItem.Call("from_serialized_key", new object[] { listItemKey });
+
+		if (!IsInkObjectOfType(listItem, "InkListItem")) {
+			throw new ArgumentException("Expected a 'Godot.Object' of class 'InkListItem'");
+		}
+
+		return new Ink.Runtime.InkListItem(
+			listItem.Get("origin_name") as string,
+			listItem.Get("item_name") as string
+		);
+	}
+	#endregion
+}