inkcpp_rb 0.1.0

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

@@ -0,0 +1,47 @@
+/* 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 "InkAsset.h"
+
+#include "Misc/FileHelper.h"
+#if WITH_EDITORONLY_DATA
+#include "EditorFramework/AssetImportData.h"
+#endif
+
+UInkAsset::UInkAsset()
+	: Super()
+{
+}
+
+void UInkAsset::Serialize(FStructuredArchive::FRecord Record)
+{
+	Super::Serialize(Record);
+	
+	// Write to archive?
+	Record.GetUnderlyingArchive() << CompiledStory;
+}
+
+#if WITH_EDITORONLY_DATA
+void UInkAsset::PostInitProperties()
+{
+	if (!HasAnyFlags(RF_ClassDefaultObject))
+	{
+		AssetImportData = NewObject<UAssetImportData>(this, TEXT("AssetImportData"));
+	}
+
+	Super::PostInitProperties();
+}
+
+void UInkAsset::GetAssetRegistryTags(TArray<FAssetRegistryTag>& OutTags) const
+{
+	if (AssetImportData)
+	{
+		OutTags.Add(FAssetRegistryTag(SourceFileTagName(), AssetImportData->GetSourceData().ToJson(), FAssetRegistryTag::TT_Hidden));
+	}
+
+	Super::GetAssetRegistryTags(OutTags);
+}
+#endif

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

@@ -0,0 +1,40 @@
+/* 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 "InkChoice.h"
+
+#include "ink/choice.h"
+
+FString UInkChoice::GetText() const
+{
+	return data->text();
+}
+
+UInkChoice::UInkChoice() {
+	tags = NewObject<UTagList>();
+}
+
+int UInkChoice::GetIndex() const
+{
+	return data->index();
+}
+
+const UTagList* UInkChoice::GetTags() const
+{
+	return tags;
+}
+
+void UInkChoice::Initialize(const ink::runtime::choice* c)
+{
+	data = c;
+	if (c->has_tags()) {
+		TArray<FString> fstring_tags{};
+		for(unsigned i = 0; i < c->num_tags(); ++i) {
+			fstring_tags.Add(FString(ANSI_TO_TCHAR(c->get_tag(i))));
+		}
+		tags->Initialize(fstring_tags);
+	}
+}

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

@@ -0,0 +1,86 @@
+/* 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.h"
+#include <string>
+#include "ink/list.h"
+
+bool UInkList::ContainsFlag(const FString& flag_name) const
+{
+	return list_data->contains(TCHAR_TO_ANSI(*flag_name));
+}
+
+bool UInkList::ContainsEnum(const UEnum* Enum, const uint8& value) const
+{
+	if (! Enum) {
+		UE_LOG(InkCpp, Warning, TEXT("No Enum provided for ContainsEnum, it will fail therfore!"));
+		return false;
+	}
+
+	return list_data->contains(TCHAR_TO_ANSI(*Enum->GetDisplayNameTextByValue(value).ToString()));
+}
+
+TArray<uint8> UInkList::ElementsOf(const UEnum* Enum) const
+{
+	TArray<uint8> ret;
+	if (! Enum) {
+		UE_LOG(InkCpp, Warning, TEXT("Failed to provide enum for elements of!"));
+		return ret;
+	}
+	FString enumName = Enum->GetFName().ToString();
+
+	int         num = Enum->NumEnums();
+	std::string str(TCHAR_TO_ANSI(*enumName));
+	for (auto itr = list_data->begin(str.c_str()); itr != list_data->end(); ++itr) {
+		bool          hit = false;
+		const FString flag(ANSI_TO_TCHAR((*itr).flag_name));
+		for (int i = 0; i < num; ++i) {
+			FString enumStr = Enum->GetDisplayNameTextByIndex(i).ToString();
+			if (enumStr.EndsWith(flag)) {
+				ret.Add(Enum->GetValueByIndex(i));
+				hit = true;
+				break;
+			}
+		}
+		if (! hit) {
+			UE_LOG(
+			    InkCpp, Warning, TEXT("Failed to find list value '%s' in enum '%s'"), *flag, *enumName
+			);
+		}
+	}
+
+	return ret;
+}
+
+TArray<FString> UInkList::ElementsOfAsString(const UEnum* Enum) const
+{
+	TArray<FString> ret;
+
+	FString EnumName = Enum->GetFName().ToString();
+	for (auto itr = list_data->begin(TCHAR_TO_ANSI(*EnumName)); itr != list_data->end(); ++itr) {
+		ret.Add(FString((*itr).flag_name));
+	}
+	return ret;
+}
+
+TArray<FListFlag> UInkList::Elements() const
+{
+	TArray<FListFlag> ret;
+	for (auto itr = list_data->begin(); itr != list_data->end(); ++itr) {
+		ret.Add(FListFlag{
+		    .list_name = FString((*itr).list_name),
+		    .flag_name = FString((*itr).flag_name),
+		});
+	}
+	return ret;
+}
+
+bool UInkList::ContainsList(const FString& name) const
+{
+	return list_data->begin(TCHAR_TO_ANSI(*name)) != list_data->end();
+}

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

@@ -0,0 +1,265 @@
+/* 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 "InkRuntime.h"
+
+// Game includes
+#include "inkcpp.h"
+#include "InkThread.h"
+#include "TagList.h"
+#include "InkAsset.h"
+#include "InkVar.h"
+
+// inkcpp includes
+#include "ink/story.h"
+#include "ink/globals.h"
+#include "ink/snapshot.h"
+#include "system.h"
+#include "types.h"
+
+namespace ink { using value = runtime::value; }
+
+// Sets default values
+AInkRuntime::AInkRuntime() : mpRuntime(nullptr)
+{
+ 	// Set this actor to call Tick() every frame.  You can turn this off to improve performance if you don't need it.
+	PrimaryActorTick.bCanEverTick = true;
+}
+
+AInkRuntime::~AInkRuntime()
+{
+	if(mSnapshot) { delete mpSnapshot; }
+	mSnapshot.Reset();
+}
+
+// Called when the game starts or when spawned
+void AInkRuntime::BeginPlay()
+{
+	// Create the CPU for the story
+	if (InkAsset != nullptr)
+	{
+		// TODO: Better error handling? What if load fails.
+		mpRuntime = ink::runtime::story::from_binary(reinterpret_cast<unsigned char*>(InkAsset->CompiledStory.GetData()), InkAsset->CompiledStory.Num(), false);
+		UE_LOG(InkCpp, Display, TEXT("Loaded Ink asset"));
+
+		// create globals
+		if (mSnapshot) {
+			LoadSnapshot(*mSnapshot);
+		} else {
+			mpGlobals = mpRuntime->new_globals();
+		}
+		// initialize globals
+		mpRuntime->new_runner(mpGlobals);
+	}
+	else
+	{
+		UE_LOG(InkCpp, Warning, TEXT("No story asset assigned."));
+	}
+	
+	Super::BeginPlay();
+}
+
+// Called every frame
+void AInkRuntime::Tick(float DeltaTime)
+{
+	Super::Tick(DeltaTime);
+
+	// Early out: no threads.
+	if (mThreads.Num() == 0)
+		return;
+
+	// Special: If we're in exclusive mode, only execute the thread at the 
+	//  top of the exclusive stack
+	while (mExclusiveStack.Num() > 0)
+	{
+		// Make sure top thread is active
+		UInkThread* top = mExclusiveStack.Top();
+
+		// If it can't execute, we're not doing anything else
+		if (!top->CanExecute())
+			return;
+
+		// Execute it
+		if (top->Execute())
+		{
+			mExclusiveStack.Remove(top);
+			mThreads.Remove(top);
+
+			// execute next exclusive thread
+			continue;
+		}
+		
+		// Nothing more to do
+		return;
+	}
+
+	// Execute other available threads
+	for (auto iter = mThreads.CreateIterator(); iter; iter++)
+	{
+		UInkThread* pNextThread = *iter;
+
+		// Ignore threads that aren't eligable for execution
+		if (!pNextThread->CanExecute())
+			continue;
+
+		// Execute
+		if (pNextThread->Execute())
+		{
+			// If the thread has finished, destroy it
+			iter.RemoveCurrent();
+			mExclusiveStack.Remove(pNextThread);
+		}
+	}
+}
+
+void AInkRuntime::HandleTagFunction(UInkThread* Caller, const TArray<FString>& Params)
+{
+       // Look for method and execute with parameters
+       FGlobalTagFunctionMulticastDelegate* function = mGlobalTagFunctions.Find(FName(*Params[0]));
+       if (function != nullptr)
+       {
+			function->Broadcast(Caller, Params);
+       }
+}
+
+void AInkRuntime::RegisterTagFunction(FName functionName, const FTagFunctionDelegate & function)
+{
+	// Register tag function
+	mGlobalTagFunctions.FindOrAdd(functionName).Add(function);
+}
+
+UInkThread* AInkRuntime::Start(TSubclassOf<class UInkThread> type, FString path, bool startImmediately)
+{
+	UE_LOG(InkCpp, Display, TEXT("Start"));
+	if (mpRuntime == nullptr || type == nullptr)
+	{
+		UE_LOG(InkCpp, Warning, TEXT("failed to start"));
+		return nullptr;
+	}
+
+	// Instantiate the thread
+	UInkThread* pThread = NewObject<UInkThread>(this, type);
+
+	// Startup
+	return StartExisting(pThread, path, startImmediately);
+}
+
+FInkSnapshot AInkRuntime::Snapshot()
+{
+	ink::runtime::snapshot* inkSnapshot = mpGlobals->create_snapshot();
+	FInkSnapshot snapshot(reinterpret_cast<const char*>(inkSnapshot->get_data()), inkSnapshot->get_data_len());
+	delete inkSnapshot;
+	return snapshot;
+}
+
+void AInkRuntime::LoadSnapshot(const FInkSnapshot& snapshot) {
+	mSnapshot = snapshot;
+	mpSnapshot = ink::runtime::snapshot::from_binary(reinterpret_cast<unsigned char*>(mSnapshot->data.GetData()), mSnapshot->data.Num(), false);
+	mpGlobals = mpRuntime->new_globals_from_snapshot(*mpSnapshot);
+}
+
+UInkThread* AInkRuntime::StartExisting(UInkThread* thread, FString path, bool startImmediately /*= true*/)
+{
+	if (mpRuntime == nullptr)
+	{
+		UE_LOG(InkCpp, Warning, TEXT("Failed to start existing"));
+		return nullptr;
+	}
+	
+	// remove handle if it still exists
+	mThreads.Remove(thread);
+	mExclusiveStack.Remove(thread);
+
+	// Initialize thread with new runner
+	ink::runtime::runner runner;
+	if (mSnapshot && path.IsEmpty()) {		
+		if (mpSnapshot->num_runners() == mThreads.Num()) {
+			UE_LOG(InkCpp, Warning, TEXT("Already created all Threads from Snapshot!, will not create more. You can Still create new Threads with entering the starting Path."));
+			return nullptr;
+		}
+		runner = mpRuntime->new_runner_from_snapshot(*mpSnapshot, mpGlobals, mThreads.Num());
+	} else {
+		runner = mpRuntime->new_runner(mpGlobals);
+	}
+	thread->Initialize(path, this, runner);
+
+	// If we're not starting immediately, just queue
+	if (!startImmediately || 
+		// Even if we want to start immediately, don't if there's an exclusive thread and it's not us
+		(mExclusiveStack.Num() > 0 && mExclusiveStack.Top() != thread))
+	{
+		mThreads.Add(thread);
+		return thread;
+	}
+
+	// Execute the newly created thread
+	if (!thread->Execute())
+	{
+		// If it hasn't finished immediately, add it to the threads list
+		mThreads.Add(thread);
+	}
+
+	return thread;
+}
+
+void AInkRuntime::PushExclusiveThread(UInkThread* Thread)
+{
+	// If we're already on the stack, ignore
+	if (mExclusiveStack.Find(Thread) != INDEX_NONE)
+		return;
+
+	// Push
+	mExclusiveStack.Push(Thread);
+}
+
+void AInkRuntime::PopExclusiveThread(UInkThread* Thread)
+{
+	// Remove from the stack
+	mExclusiveStack.Remove(Thread);
+}
+
+FInkVar AInkRuntime::GetGlobalVariable(const FString& name) {
+	ink::optional<ink::value> var = mpGlobals->get<ink::value>(TCHAR_TO_ANSI(*name));
+	if(var) { return FInkVar(*var); }
+	else { UE_LOG(InkCpp, Warning, TEXT("Failed to find global variable with name: %s"), *name); }
+	return FInkVar{};
+}
+
+void AInkRuntime::SetGlobalVariable(const FString& name, const FInkVar& value) {
+	bool success = mpGlobals->set<ink::value>(TCHAR_TO_ANSI(*name), value.to_value());
+	if(!success) {
+		UE_LOG(InkCpp, Warning, TEXT("Filed to set global variable with name: %s"), *name);
+		ink::optional<ink::value> var = mpGlobals->get<ink::value>(TCHAR_TO_ANSI(*name));
+		if(var) {
+			UE_LOG(InkCpp, Warning, 
+				TEXT("Reason: wrong type!, got: %i, expected: %i"),
+				static_cast<int>(value.to_value().type),
+				static_cast<int>(var->type) );
+		} else {
+			UE_LOG(InkCpp, Warning, TEXT("Reason: no variable with this name exists! '%s'"),
+				*name);
+		}
+	}
+}
+void AInkRuntime::ObserverVariable(const FString& name, const FVariableCallbackDelegate& callback) {
+	mpGlobals->observe(TCHAR_TO_ANSI(*name), [callback](){callback.Execute();});
+}
+
+void AInkRuntime::ObserverVariableEvent(const FString& name, const FVariableCallbackDelegateNewValue& callback) {
+	mpGlobals->observe(TCHAR_TO_ANSI(*name), [callback](ink::runtime::value x){callback.Execute(FInkVar(x));});
+}
+
+void AInkRuntime::ObserverVariableChange(const FString& name, const FVariableCallbackDelegateNewOldValue& callback) {
+	mpGlobals->observe(TCHAR_TO_ANSI(*name), 
+		[callback](ink::runtime::value x, ink::optional<ink::runtime::value> y){
+			if (y.has_value()) {
+			  callback.Execute(FInkVar(x), FInkVar(y.value()));
+		  } else {
+			  callback.Execute(FInkVar(x), FInkVar());
+		  }
+		}
+	);
+}

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

@@ -0,0 +1,239 @@
+/* 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 "InkThread.h"
+
+#include "inkcpp.h"
+#include "InkRuntime.h"
+#include "TagList.h"
+#include "InkChoice.h"
+#include "ink/runner.h"
+
+// Unreal includes
+#include "Internationalization/Regex.h"
+
+UInkThread::UInkThread()
+    : mbHasRun(false)
+    , mnChoiceToChoose(-1)
+    , mnYieldCounter(0)
+    , mbKill(false)
+{
+}
+
+UInkThread::~UInkThread() {}
+
+void UInkThread::Yield() { mnYieldCounter++; }
+
+bool UInkThread::IsYielding() { return mnYieldCounter > 0; }
+
+void UInkThread::Resume() { mnYieldCounter--; }
+
+void UInkThread::RegisterTagFunction(FName functionName, const FTagFunctionDelegate& function)
+{
+	// Register tag function
+	mTagFunctions.FindOrAdd(functionName).Add(function);
+}
+
+void UInkThread::RegisterExternalFunction(
+    const FString& functionName, const FExternalFunctionDelegate& function, bool lookaheadSafe
+)
+{
+	mpRunner->bind_delegate(ink::hash_string(TCHAR_TO_ANSI(*functionName)), function, lookaheadSafe);
+}
+
+void UInkThread::RegisterExternalEvent(
+    const FString& functionName, const FExternalFunctionVoidDelegate& function, bool lookaheadSafe
+)
+{
+	mpRunner->bind_delegate(ink::hash_string(TCHAR_TO_ANSI(*functionName)), function, lookaheadSafe);
+}
+
+void UInkThread::Initialize(FString path, AInkRuntime* runtime, ink::runtime::runner thread)
+{
+	inkAssert(
+	    ! thread->has_choices() || path.IsEmpty(),
+	    "Snapshot recovery does not work with starting path if currently at choice."
+	);
+	mStartPath    = path;
+	mpRuntime     = runtime;
+	mbInitialized = true;
+	mpRunner      = thread;
+	mpTags        = NewObject<UTagList>();
+	mTagFunctions.Reset();
+	mCurrentChoices.Reset();
+	mnChoiceToChoose = -1;
+	mbHasRun   = false;
+	mbInChoice       = thread->has_choices();
+
+	OnStartup();
+}
+
+bool UInkThread::ExecuteInternal()
+{
+	// Kill thread
+	if (mbKill)
+		return true;
+
+	// If this is the first time we're running, start us off at our starting path
+	if (! mbHasRun) {
+		if (! ensureMsgf(mbInitialized, TEXT("Thread executing without call to ::Initialize")))
+			return true;
+		mbHasRun = true;
+		if (mStartPath.Len()) {
+			mpRunner->move_to(ink::hash_string(TCHAR_TO_ANSI(*mStartPath)));
+		}
+
+		if (mbInChoice) {
+			for (ink::size_t i = 0; i < mpRunner->num_choices(); i++) {
+				UInkChoice* choice = NewObject<UInkChoice>(this);
+				choice->Initialize(mpRunner->get_choice(i));
+				mCurrentChoices.Add(choice);
+			}
+			OnChoice(mCurrentChoices);
+			return false;
+		}
+	}
+
+	// Execution loop
+	while (true) {
+		// Handle pending choice
+		if (mnChoiceToChoose != -1) {
+			if (ensure(mpRunner->num_choices() > 0)) {
+				mpRunner->choose(mnChoiceToChoose);
+			}
+			mnChoiceToChoose = -1;
+			mCurrentChoices.Empty();
+		}
+
+		// Execute until story yields or finishes
+		while (mnYieldCounter == 0 && mpRunner->can_continue()) {
+			// Handle text
+			FString line = mpRunner->getline();
+			// Special: Line begins with >> marker
+			if (line.StartsWith(TEXT(">>"))) {
+				// This is a special version of the tag function call
+				// Expected: >> MyTagFunction(Arg1, Arg2, Arg3)
+				FRegexPattern pattern
+				    = FRegexPattern(TEXT("^>>\\s*(\\w+)(\\((\\s*(\\w+)\\s*(,\\s*(\\w+)\\s*)*)?\\))?$"));
+				FRegexMatcher matcher = FRegexMatcher(pattern, line);
+				if (matcher.FindNext()) {
+					// Get name of function
+					FString functionName = matcher.GetCaptureGroup(1);
+
+					// Get arguments
+					TArray<FString> Arguments;
+					Arguments.Add(functionName);
+					int groupIndex = 4;
+					while (matcher.GetCaptureGroupBeginning(groupIndex) != -1) {
+						Arguments.Add(matcher.GetCaptureGroup(groupIndex).TrimStartAndEnd());
+						groupIndex += 2;
+					}
+
+					// Call tag method
+					ExecuteTagMethod(Arguments);
+				}
+			} else {
+				// Forward to handler
+				// Get tags
+				TArray<FString> tags;
+				for (size_t i = 0; i < mpRunner->num_tags(); ++i) {
+					tags.Add(FString(mpRunner->get_tag(i)));
+				}
+				mpTags->Initialize(tags);
+				OnLineWritten(line, mpTags);
+
+				// Handle tags/tag methods post-line
+				for (auto it = tags.CreateConstIterator(); it; ++it) {
+					// Generic tag handler
+					OnTag(*it);
+
+					// Tag methods
+					TArray<FString> params;
+					it->ParseIntoArray(params, TEXT("_"));
+					ExecuteTagMethod(params);
+				}
+			}
+		}
+
+		// Handle choice block
+		if (mnYieldCounter == 0 && mpRunner->num_choices() > 0) {
+			mbInChoice = true;
+
+			// Forward to handler
+			for (ink::size_t i = 0; i < mpRunner->num_choices(); i++) {
+				UInkChoice* choice = NewObject<UInkChoice>(this);
+				choice->Initialize(mpRunner->get_choice(i));
+				mCurrentChoices.Add(choice);
+			}
+			OnChoice(mCurrentChoices);
+
+			// If we've chosen a choice already, go back up to handle it.
+			if (mnChoiceToChoose != -1)
+				continue;
+		}
+
+		break;
+	}
+
+	// Have we reached the end? If so, destroy the thread
+	if (! mpRunner->can_continue() && mnYieldCounter == 0 && mpRunner->num_choices() == 0) {
+		UE_LOG(InkCpp, Display, TEXT("Destroying thread"));
+
+		// TODO: Event for ending?
+
+		// TODO: Destroy ourselves?
+		return true;
+	}
+
+	// There's more to go. Return false to put us on the waiting list.
+	return false;
+}
+
+void UInkThread::ExecuteTagMethod(const TArray<FString>& Params)
+{
+	// Look for method and execute with parameters
+	FTagFunctionMulticastDelegate* function = mTagFunctions.Find(FName(*Params[0]));
+	if (function != nullptr) {
+		function->Broadcast(this, Params);
+	}
+
+	// Forward to runtime
+	mpRuntime->HandleTagFunction(this, Params);
+}
+
+bool UInkThread::Execute()
+{
+	// Execute thread
+	bool finished = ExecuteInternal();
+
+	// If we've finished, run callback
+	if (finished) {
+		// Allow outsiders to subscribe
+		// TODO: OnThreadShutdown.Broadcast();
+		OnShutdown();
+	}
+
+	// Return result
+	return finished;
+}
+
+bool UInkThread::PickChoice(int index)
+{
+	if (index >= mCurrentChoices.Num() || index < 0) {
+		UE_LOG(
+		    InkCpp, Warning, TEXT("PickChoice: index(%i) out of range [0-%i)"), index,
+		    mCurrentChoices.Num()
+		);
+		return false;
+	}
+	mnChoiceToChoose = index;
+	mbInChoice       = false;
+	return true;
+}
+
+bool UInkThread::CanExecute() const { return (mnYieldCounter == 0 && ! mbInChoice) || ! mbHasRun; }
+
+void UInkThread::Stop() { mbKill = true; }