inkcpp_rb 0.1.0

data/ext/inkcpp_rb/inkcpp/unreal/inkcpp/Source/inkcpp/Private/InkVar.cpp

@@ -0,0 +1,143 @@
+/* Copyright (c) 2024 Julian Benda
+ *
+ * This file is part of inkCPP which is released under MIT license.
+ * See file LICENSE.txt or go to
+ * https://github.com/JBenda/inkcpp for full license details.
+ */
+#include "InkVar.h"
+#include "ink/types.h"
+
+#include "Misc/AssertionMacros.h"
+
+FInkVar::FInkVar(ink::runtime::value val) : FInkVar() {
+	using v_types = ink::runtime::value::Type;
+	switch(val.type) {
+		case v_types::Bool: value.SetSubtype<bool>(val.get<v_types::Bool>()); break;
+		case v_types::Uint32:
+			UE_LOG(InkCpp, Warning, TEXT("Converting uint to int, this will cause trouble if writing it back to ink (with SetGlobalVariable)!"));
+			value.SetSubtype<int>(val.get<v_types::Uint32>());
+			break;
+		case v_types::Int32: value.SetSubtype<int>(val.get<v_types::Int32>()); break;
+		case v_types::String: value.SetSubtype<FString>(FString(val.get<v_types::String>())); break;
+		case v_types::Float: value.SetSubtype<float>(val.get<v_types::Float>()); break;
+		case v_types::List: {
+			UInkList* list = NewObject<UInkList>();
+			list->SetList(val.get<v_types::List>());
+			value.SetSubtype<UInkList*>(list);
+			break;
+		}
+		default:
+			inkFail("unknown type!, failed to convert ink::value to InkVar");
+	}
+}
+	
+ink::runtime::value FInkVar::to_value() const {
+	switch(type()) {
+		case EInkVarType::Int:
+			return ink::runtime::value(value.GetSubtype<int>());
+		case EInkVarType::Float:
+			return ink::runtime::value(value.GetSubtype<float>());
+		case EInkVarType::String:
+			return ink::runtime::value(reinterpret_cast<const char*>(utf8.GetData()));
+		case EInkVarType::Bool:
+			return ink::runtime::value(value.GetSubtype<bool>());
+		case EInkVarType::UInt:
+			return ink::runtime::value(value.GetSubtype<unsigned>());
+		case EInkVarType::List:
+			return ink::runtime::value(value.GetSubtype<UInkList*>()->GetData());
+		default:
+			inkFail("Unsupported type");
+			return ink::runtime::value();
+	}
+	
+}
+
+EInkVarType UInkVarLibrary::InkVarType(const FInkVar& InkVar) { return InkVar.type(); }
+FString UInkVarLibrary::Conv_InkVarString(const FInkVar& InkVar)
+{
+	if (ensureMsgf(InkVar.type() == EInkVarType::String, TEXT("InkVar is not a String Type!")))
+		return InkVar.value.GetSubtype<FString>();
+	return FString(TEXT(""));
+}
+
+int UInkVarLibrary::Conv_InkVarInt(const FInkVar& InkVar)
+{
+	if (ensureMsgf(InkVar.type() == EInkVarType::Int, TEXT("InkVar is not an Int Type!")))
+		return InkVar.value.GetSubtype<int>();
+	return 0;
+}
+
+float UInkVarLibrary::Conv_InkVarFloat(const FInkVar& InkVar)
+{
+	if (ensureMsgf(InkVar.type() == EInkVarType::Float, TEXT("InkVar is not a Float Type!")))
+		return InkVar.value.GetSubtype<float>();
+	return 0.f;
+}
+
+FName UInkVarLibrary::Conv_InkVarName(const FInkVar& InkVar)
+{
+	if (ensureMsgf(InkVar.type() == EInkVarType::String, TEXT("InkVar is not a String Type!")))
+		return FName(*InkVar.value.GetSubtype<FString>());
+	return NAME_None;
+}
+
+FText UInkVarLibrary::Conv_InkVarText(const FInkVar& InkVar)
+{
+	if (ensureMsgf(InkVar.type() == EInkVarType::String, TEXT("InkVar is not a String Type!")))
+		return FText::FromString(InkVar.value.GetSubtype<FString>());
+	return FText::GetEmpty();
+}
+
+bool UInkVarLibrary::Conv_InkVarBool(const FInkVar& InkVar)
+{
+	if (ensureMsgf(InkVar.type() == EInkVarType::Bool, TEXT("InkVar is not an Bool Type!")))
+		return InkVar.value.GetSubtype<bool>();
+	return false;
+}
+
+const UInkList* UInkVarLibrary::Conv_InkVarInkList(const FInkVar& InkVar)
+{
+	if (ensureMsgf(InkVar.type() == EInkVarType::List, TEXT("InkVar is not an List Type!")))
+		return InkVar.value.GetSubtype<UInkList*>();
+	return nullptr;
+}
+
+
+
+FInkVar UInkVarLibrary::Conv_StringInkVar(const FString& String)
+{
+	return FInkVar(String);
+}
+
+FInkVar UInkVarLibrary::Conv_IntInkVar(int Number)
+{
+	return FInkVar(Number);
+}
+
+FInkVar UInkVarLibrary::Conv_FloatInkVar(float Number)
+{
+	return FInkVar(Number);
+}
+
+FInkVar UInkVarLibrary::Conv_TextInkVar(const FText& Text)
+{
+	return FInkVar(Text.ToString());
+}
+
+FInkVar UInkVarLibrary::Conv_NameInkVar(const FName& Name)
+{
+	return FInkVar(Name.ToString());
+}
+
+FInkVar UInkVarLibrary::Conv_BoolInkVar(bool Boolean)
+{
+	return FInkVar(Boolean);
+}
+
+FInkVar UInkVarLibrary::Conv_ListInkVar(UInkList* List)
+{
+	if (ensureMsgf(List != nullptr, TEXT("Try to set list value from empty object"))) {
+		return FInkVar(*List);
+	}
+	return FInkVar();
+}

data/ext/inkcpp_rb/inkcpp/unreal/inkcpp/Source/inkcpp/Private/TagList.cpp

@@ -0,0 +1,95 @@
+/* Copyright (c) 2024 Julian Benda
+ *
+ * This file is part of inkCPP which is released under MIT license.
+ * See file LICENSE.txt or go to
+ * https://github.com/JBenda/inkcpp for full license details.
+ */
+#include "TagList.h"
+
+UTagList::UTagList()
+{
+}
+
+void UTagList::Initialize(const TArray<FString>& tags)
+{
+	// Copy construct
+	Tags = TArray<FString>(tags);
+}
+
+bool UTagList::Has(const FString& tag) const
+{
+	for (const FString& t : Tags)
+	{
+		if (t.Equals(tag))
+			return true;
+	}
+
+	return false;
+}
+
+bool UTagList::HasEnum(const UEnum* Enum, uint8& value) const
+{
+	if (!Enum)
+	{
+		value = 0;
+		return false;
+	}
+
+	// Iterate tags
+	int num = Enum->NumEnums();
+	for (const FString& tag : Tags)
+	{
+		// Iterate enum values
+		for (int i = 0; i < num; i++)
+		{
+			FString enumStr = Enum->GetDisplayNameTextByIndex(i).ToString();
+
+			// Instead of string comparison, check if they share a suffix (most enums have weird prefixes)
+			if (enumStr.EndsWith(tag))
+			{
+				value = Enum->GetValueByIndex(i);
+				return true;
+			}
+		}
+	}
+
+	value = 0;
+	return false;
+}
+
+FString UTagList::GetValue(const FString& name) const
+{
+	for (const FString& tag : Tags)
+	{
+		if (tag.StartsWith(name + ":"))
+		{
+			return tag.RightChop(name.Len() + 1).TrimStartAndEnd();
+		}
+	}
+
+	return FString();
+}
+
+bool UTagList::GetEnum(const UEnum* Enum, uint8& value) const
+{
+	FString prefix = Enum->GetFName().ToString() + ":";
+	for (const FString& tag : Tags) {
+		if (tag.StartsWith(prefix)) {
+			FString tag_value = tag.RightChop(prefix.Len()).TrimStartAndEnd();
+			for (int i = 0; i < Enum->NumEnums(); ++i) {
+				FString enumStr = Enum->GetDisplayNameTextByIndex(i).ToString();
+				if (enumStr.EndsWith(tag_value)) {
+					value = Enum->GetValueByIndex(i);
+					return true;
+				}
+			}
+
+			value = 0;
+			return false;
+		}
+	}
+	value = 0;
+	return false;
+}
+
+const TArray<FString>& UTagList::GetTags() const { return Tags; }

data/ext/inkcpp_rb/inkcpp/unreal/inkcpp/Source/inkcpp/Private/inkcpp.cpp

@@ -0,0 +1,13 @@
+/* Copyright (c) 2024 Julian Benda
+ *
+ * This file is part of inkCPP which is released under MIT license.
+ * See file LICENSE.txt or go to
+ * https://github.com/JBenda/inkcpp for full license details.
+ */
+#include "inkcpp.h"
+
+#include "CoreMinimal.h"
+#include "Modules/ModuleManager.h"
+
+IMPLEMENT_MODULE(FDefaultGameModuleImpl, inkcpp)
+DEFINE_LOG_CATEGORY(InkCpp);

data/ext/inkcpp_rb/inkcpp/unreal/inkcpp/Source/inkcpp/Public/InkAsset.h

@@ -0,0 +1,50 @@
+/* Copyright (c) 2024 Julian Benda
+ *
+ * This file is part of inkCPP which is released under MIT license.
+ * See file LICENSE.txt or go to
+ * https://github.com/JBenda/inkcpp for full license details.
+ */
+#pragma once
+
+#include "UObject/Object.h"
+
+#include "InkAsset.generated.h"
+
+/** Assets contanining a InkCPP .bin.
+ * Asset can be constructed from a `.ink.json` file outputed from inky or inklecate.
+ * And generall also directly from a `.ink` file (it may fail if the shipped version of inklecate is
+ * incopatible with your system).
+ *
+ * @todo Please note that reimport does not work properly if your ink file has includes.
+ * Since the reimport only watches the main file for changes.
+ * @ingroup unreal
+ */
+UCLASS(hidecategories=Object)
+class INKCPP_API UInkAsset : public UObject
+{
+	GENERATED_BODY()
+	
+public:
+	UInkAsset();
+
+	// Begin UObject
+	/** @private */
+	virtual void Serialize(FStructuredArchive::FRecord Record) override;
+	// End UObject
+
+	/** @private */
+	TArray<char> CompiledStory;
+
+#if WITH_EDITORONLY_DATA
+	/** @private */
+	UPROPERTY(VisibleAnywhere, Instanced, Category = ImportSettings)
+	class UAssetImportData* AssetImportData;
+
+	// Begin UObject
+	/** @private */
+	virtual void PostInitProperties() override;
+	/** @private */
+	virtual void GetAssetRegistryTags(TArray<FAssetRegistryTag>& OutTags) const override;
+	// End UObject
+#endif
+};

data/ext/inkcpp_rb/inkcpp/unreal/inkcpp/Source/inkcpp/Public/InkChoice.h

@@ -0,0 +1,58 @@
+/* Copyright (c) 2024 Julian Benda
+ *
+ * This file is part of inkCPP which is released under MIT license.
+ * See file LICENSE.txt or go to
+ * https://github.com/JBenda/inkcpp for full license details.
+ */
+#pragma once
+#include "TagList.h"
+
+#include "UObject/Object.h"
+
+#include "InkChoice.generated.h"
+
+namespace ink::runtime { class choice; }
+class UTagList;
+
+/** Representing a Ink Choice in the story flow
+ * @ingroup unreal
+ */
+UCLASS(BlueprintType)
+class UInkChoice : public UObject
+{
+	GENERATED_BODY()
+public:
+	UInkChoice();
+
+	UFUNCTION(BlueprintPure, Category="Ink")
+	/** Access context of choice.
+	 * @return text contained in choice
+	 * @blueprint
+	 */
+	FString GetText() const;
+
+	UFUNCTION(BlueprintPure, Category="Ink")
+	/** Get idintifcator for @ref UInkThread::PickChoice()
+	 * @return id used in @ref UInkThread::PickChoice()
+	 *
+	 * @blueprint
+	 */
+	int GetIndex() const;
+
+	UFUNCTION(BlueprintPure, Category="Ink")
+	/** Tags asszoiated with the choice.
+	 * @return with choice assoziated tags
+	 *
+	 * @blueprint
+	 */
+	const UTagList* GetTags() const;
+
+protected:
+	friend class UInkThread;
+	/** @private */
+	void Initialize(const ink::runtime::choice*);
+
+private:
+	const ink::runtime::choice* data;
+	TObjectPtr<UTagList> tags;
+};

data/ext/inkcpp_rb/inkcpp/unreal/inkcpp/Source/inkcpp/Public/InkDelegates.h

@@ -0,0 +1,139 @@
+/* Copyright (c) 2024 Julian Benda
+ *
+ * This file is part of inkCPP which is released under MIT license.
+ * See file LICENSE.txt or go to
+ * https://github.com/JBenda/inkcpp for full license details.
+ */
+#pragma once
+
+#include "CoreMinimal.h"
+#include "Delegates/Delegate.h"
+
+#include "InkVar.h"
+
+#include "InkDelegates.generated.h"
+
+/** @file
+ * collection of Delegates typs used for the UE interface
+ * @ingroup unreal
+ */
+
+#ifdef DOXYGEN
+DOC_UF(BlueprintImplementableEvent, )
+/** Delegate for a tag function
+ * @see @ref TagFunction
+ * @param Caller thread which found encountered this function
+ * @param Params an array containing the arguments depending on the function call
+ *
+ * @blueprint
+ */
+void FTagFunctionDelegate(UInkThread* Caller, const TArray<FString>& Params);
+#endif
+/** @cond */
+DECLARE_DYNAMIC_DELEGATE_TwoParams(FTagFunctionDelegate, UInkThread*, Caller, const TArray<FString>&, Params);
+/** @endcond*/
+
+/** @private */
+DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FTagFunctionMulticastDelegate, UInkThread*, Caller, const TArray<FString>&, Params);
+
+#ifdef DOXYGEN
+DOC_UF(BlueprintImplementableEvent, )
+/** Delegate for external functions.
+ * the number of arugments are defined iside the ink story
+ * @param Arguments array containing all arguments passed to this function
+ * @return value to be put on the stack in the inkruntime
+ * @see @ref UInkThread::RegisterExternalEvent
+ *
+ * @blueprint
+ */
+FInkVar FExternalFunctionDelegate(const TArray<FInkVar>& Arguments);
+#endif
+/** @cond */
+DECLARE_DYNAMIC_DELEGATE_RetVal_OneParam(FInkVar, FExternalFunctionDelegate, const TArray<FInkVar>&, Arguments);
+/** @endcond */
+
+#ifdef DOXYGEN
+DOC_UF(BlueprintImplementableEvent, )
+/** Delegate for external event.
+ * the number of arguments are defined inside the ink story
+ * @param Arguments array containing all arguments passed to this function
+ * @see @ref UInkThread::RegisterExternalFunction
+ *
+ * @blueprint
+ */
+void FExternalFunctionVoidDelegate(const TArray<FInkVar>& Arguments);
+#endif
+/** @cond */
+DECLARE_DYNAMIC_DELEGATE_OneParam(FExternalFunctionVoidDelegate, const TArray<FInkVar>&, Arguments);
+/** @endcond */
+
+/** @private */
+DECLARE_DYNAMIC_DELEGATE_TwoParams(FGlobalTagFunctionDelegate, UInkThread*, Caller, const TArray<FString>&, Params);
+
+/** @private */
+DECLARE_DYNAMIC_MULTICAST_DELEGATE_TwoParams(FGlobalTagFunctionMulticastDelegate, UInkThread*, Caller, const TArray<FString>&, Params);
+
+
+#ifdef DOXYGEN
+DOC_UF(BlueprintImplementableEvent, )
+/** Notification if variable changes.
+ * @see @ref AInkRuntime::ObserverVariable()
+ *
+ * @blueprint
+ */
+void FVariableCallbackDelegate();
+#endif
+/** @cond */
+DECLARE_DYNAMIC_DELEGATE(FVariableCallbackDelegate);
+/** @endcond */
+
+#ifdef DOXYGEN
+DOC_UF(BlueprintImplementableEvent, )
+/** Notification containing the new variable value, send on variable change.
+ * @param value new value of the variable
+ * @see @ref AInkRuntime::ObserverVariableEvent()
+ *
+ * @blueprint
+ */
+void FVariableCallbackDelegateNewValue(const FInkVar& value);
+#endif
+/** @cond */
+DECLARE_DYNAMIC_DELEGATE_OneParam(FVariableCallbackDelegateNewValue, const FInkVar&, value);
+/** @endcond */
+
+#ifdef DOXYGEN
+DOC_UF(BlueprintImplementableEvent, )
+/** Notification containing old and new varible, send on variable change.
+ * @param value new value of the variable
+ * @param old_value previouse value of the variable has value @ref EInkVarType::None "None" if
+ * variable is set for the first time
+ * @see @ref AInkRuntime::ObserverVariableChange()
+ *
+ * @blueprint
+ */
+void FVariableCallbackDelegateNewOldValue(const FInkVar& value, const FInkVar& old_value);
+#endif
+/** @cond */
+DECLARE_DYNAMIC_DELEGATE_TwoParams(FVariableCallbackDelegateNewOldValue, const FInkVar&, value, const FInkVar&, old_value);
+/** @endcond */
+
+UCLASS()
+
+/** @private */
+class UDelegateKeepAlive : public UObject
+{
+	GENERATED_BODY()
+};
+
+/** @page TagFunction TagFunction
+ * "tag functions" allowes converting tags or context lines to function calls
+ * if a tag in the form `functionName_arg1_arg2` is found for a registered tag function
+ * the function will be executed
+ *
+ * Also if a context line starts with a `>>` the normal processing of tags and context
+ * will be ignored the corresponding tag functino will be called
+ * the format for this function call is `>> FunctionName(Arg1[, Arg2]*)`
+ *
+ * @see To bind tag functions use @ref UInkThread::RegisterTagFunction() and @ref
+ * AInkRuntime::RegisterTagFunction()
+ */

data/ext/inkcpp_rb/inkcpp/unreal/inkcpp/Source/inkcpp/Public/InkList.h

@@ -0,0 +1,102 @@
+/* Copyright (c) 2024 Julian Benda
+ *
+ * This file is part of inkCPP which is released under MIT license.
+ * See file LICENSE.txt or go to
+ * https://github.com/JBenda/inkcpp for full license details.
+ */
+#pragma once
+
+#include "InkList.generated.h"
+
+namespace ink::runtime {
+	class list_interface;
+	using list = list_interface*;
+}
+
+/** A single flag of a list.
+ * @ingroup unreal
+ */
+USTRUCT(BlueprintType)
+struct FListFlag {
+	GENERATED_BODY()
+	UPROPERTY(BlueprintReadOnly, Category = "Ink")
+	/** name of the list, the flag is part of */
+	FString list_name;
+	UPROPERTY(BlueprintReadOnly, Category = "Ink")
+	/** name of the flag */
+	FString flag_name;
+};
+
+/**
+ * Allowes reading ink lists.
+ * @ingroup unreal
+ */
+UCLASS(Blueprintable, BlueprintType)
+class INKCPP_API UInkList : public UObject
+{
+	GENERATED_BODY()
+
+public:
+	/** @private */
+	UInkList() {}
+
+	/** @private */
+	UInkList(ink::runtime::list list) { list_data = list; }
+
+	/** @private */
+	void SetList(ink::runtime::list list) { list_data = list; }
+
+	UFUNCTION(BlueprintPure, Category = "Ink")
+	/** Checks if a flag is contained (by name)
+	 * @attention If the flag name is not unique please use the full flag name aka
+	 * `list_name.flag_name`
+	 *
+	 * @blueprint
+	 */
+	bool ContainsFlag(const FString& flag_name) const;
+
+	UFUNCTION(BlueprintPure, Category = "Ink")
+	/** checks if flag with the same spelling then the enum `value` is set in the list
+	 * @retval true if flag is contained in list
+	 *
+	 * @blueprint
+	 */
+	bool ContainsEnum(const UEnum* Enum, const uint8& value) const;
+
+	UFUNCTION(BlueprintPure, Category = "Ink")
+	/** returns all values of a list with the same name as the enum
+	 *
+	 * @blueprint
+	 */
+	TArray<uint8> ElementsOf(const UEnum* Enum) const;
+
+	UFUNCTION(BlueprintPure, Category = "Ink")
+	/** returns all flag as string contained in the list from a list with the same name as the Enum`
+	 *
+	 * @blueprint
+	 */
+	TArray<FString> ElementsOfAsString(const UEnum* Enum) const;
+
+	UFUNCTION(BlueprintPure, Category = "Ink")
+	/** returns all `list_name` `flag_name` tuples
+	 *
+	 * @blueprint
+	 */
+	TArray<FListFlag> Elements() const;
+
+	UFUNCTION(BlueprintPure, Category = "Ink")
+	/** check if at least one value of the given list is included, OR the list is empty
+	 * and assoziatet with the list
+	 *
+	 * @blueprint
+	 */
+	bool ContainsList(const FString& ListName) const;
+
+
+private:
+	friend struct FInkVar;
+
+	ink::runtime::list GetData() const { return list_data; }
+
+	ink::runtime::list list_data;
+};