inkcpp_rb 0.1.0

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

@@ -0,0 +1,77 @@
+/* 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 "TagList.generated.h"
+
+/**
+ * Helpful tag list
+ * @ingroup unreal
+ */
+UCLASS()
+class INKCPP_API UTagList : public UObject
+{
+	GENERATED_BODY()
+
+public:
+	UTagList();
+
+	/** Initializes the tag list from an array
+	 * @private
+	 */
+	void Initialize(const TArray<FString>& tags);
+
+	UFUNCTION(BlueprintPure, Category = "Ink")
+	/** Checks if the tag is present in the array.
+	 *
+	 * @blueprint
+	 */
+	bool Has(const FString& tag) const;
+
+	UFUNCTION(BlueprintPure, Category = "Ink")
+	/** Check if tag list contains enum flag.
+	 * Check if one of the enum flag string represntations is equal
+	 * to one flag in the list.
+	 * @param Enum the enum class to check flags from
+	 * @param value of the flag iff one was found
+	 * @retval true if a flag was found
+	 * @attention if multiple flags are present in the list, only the first will be returned
+	 * @see #GetEnum()
+	 *
+	 * @blueprint
+	 */
+	bool HasEnum(const UEnum* Enum, uint8& value) const;
+
+	UFUNCTION(BlueprintPure, Category = "Ink")
+	/** Searches for a tag that begins with 'name:' and returns the string after the colon
+	 * @retval "" if no value was found, or if there are nothing behind ':'
+	 *
+	 * @blueprint
+	 */
+	FString GetValue(const FString& name) const;
+
+	UFUNCTION(BlueprintPure, Category = "Ink")
+	/** Searches for a tag thats begins with 'EnumName:' and returns the enum value corresponding to
+	 * the text after the ':'
+	 * @attention If the enum appears multiple times, the first instance will be used
+	 * @retval true if a tag in the form "EnumName:FlagName" was found
+	 *
+	 * @blueprint
+	 */
+	bool GetEnum(const UEnum* Enum, uint8& value) const;
+
+	UFUNCTION(BlueprintPure, Category = "Ink")
+	/** Get all tags as array.
+	 *
+	 * @blueprint
+	 */
+	const TArray<FString>& GetTags() const;
+
+private:
+	TArray<FString> Tags;
+};

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

@@ -0,0 +1,217 @@
+/* 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 "Logging/LogMacros.h"
+
+/**
+ * @defgroup unreal Unreal Blueprints
+ * Blueprint Classes usable in Unreal. An example can be found
+ * [here](unreal/InkCPP_DEMO.zip), do not forgett to install the plugin via the
+ * [marketplace](https://www.unrealengine.com/marketplace/product/inkcpp) or unzipping the
+ * `unreal.zip` from the [release page](https://github.com/JBenda/inkcpp/releases/latest) to
+ * `/YOUR_UNREAL_PROJECT/Plugins/`. <br/> And eitherway activating the plugin.
+ *
+ * The C++ API will be available soon([Issue](https://github.com/JBenda/inkcpp/issues/60)).
+ *
+ * + @ref ue_setup "General setup"
+ * + @ref ue_components "UE5 Blueprits"
+ * + @ref ue_example "Demo project & setup"
+ *
+ * @section ue_setup Setup
+ *
+ * After installing the plugin (see above) you need to activate it via `Plugins->...`.
+ * Then to run your Ink script you need a instance of @ref AInkRuntime. The story will
+ * only proceed if this actor is active.
+ *
+ * On this instance set the `Ink|InkAsset` property to the story that you will run.
+ * To create this InkAsset you need to import a `.ink` file or `.ink.json` file.
+ *
+ * With the @ref AInkRuntime you can then create a @ref UInkThread with @ref AInkRuntime::Start().
+ * In addition does the runtime allows you access to the global variables via @ref
+ * AInkRuntime::ObserverVariableChange() "observer" or directly @ref
+ * AInkRuntime::SetGlobalVariable() "setter" und @ref AInkRuntime::GetGlobalVariable() "getter".
+ *
+ * Notice that all threads spawned in the
+ * same runtime will share a global state. So if you want to play the same story with different
+ * states, you need multiple runtimes.
+ *
+ * The @ref UInkThread class provides will fire events when new context is available. The easiest
+ * way to implement then is to create a custom Blueprint based on @ref UInkThread. For a overview
+ * see @ref ue_thread.
+ *
+ * Below you can find the blueprints of a  @ref ue_example_minimal "minimal example". Which is
+ * included for further inspection inside the @ref ue_example "Example project" (in the map
+ * `Minimal`).
+ *
+ * @section ue_components Components
+ *
+ * @subsection ue_runtime Runtime
+ * The @ref AInkRuntime handles the runtime as actor.
+ * At every Tick all @ref UInkThread of the runtime will be further executed if appropiate.
+ *
+ * The asset containing the story to run can be set via the Ink|InkAsset attribute.
+ *
+ * The runtime is the position to set observer (e.g. @ref AInkRuntime::ObserverVariableChange() )
+ * and create new threads  (@ref AInkRuntime::Start() & @ref AInkRuntime::StartExisting() ).
+ *
+ * It is adviced to create you own Blueprint which inherites @ref AInkRuntime to overwrite the
+ * events as necessary.
+ *
+ * @subsection ue_thread Thread
+ * A @ref UInkThread is like a pointer inside the story. It contains informations can advance and
+ * will therby output the context it encounters.
+ *
+ * All threads inside the same runtime will share the same variables but can be at different points
+ * in the story.
+ *
+ * The most importent events/functions are:
+ * + @ref UInkThread::OnLineWritten() which is called by each new line of output
+ * + @ref UInkThread::OnChoice() which is called if a choice is encounterd and must be handled
+ * + @ref UInkThread::PickChoice()  to pick a choice and continue the thread.
+ *
+ * @subsection ue_choice Choice
+ * A @ref UInkChoice contains all data relevant for a branch at a choice point.
+ * + @ref UInkChoice::GetText() the text of the choice
+ * + @ref UInkChoice::GetIndex() the index used in @ref UInkThread::PickChoice()
+ * + @ref UInkChoice::GetTags() tags assoziated with this branch/choice
+ *
+ * @subsection ue_taglist TagList
+ * A @ref UTagList is a wrapper for the array of tags each line of context and each choice can have.
+ *
+ * @subsection ue_ivar InkVar
+ * A wrapper for variables of the ink runtime.
+ * To get/set variables you need access to the runtime:
+ * @ref AInkRuntime::GetGlobalVariable(), @ref AInkRuntime::SetGlobalVariable()
+ *
+ * please note that get returns a copy of the variables value and to change it you need to call set.
+ *
+ * @subsection ue_list InkList
+ * @ref UInkList is a wrapper for the list type inside ink.
+ * A ink list is like a set for enum values. For a in depth explenation please refer to the [offical
+ * guide](https://blueprintue.com/blueprint/hdybtdjp/)
+ *
+ * If you define Enums simular to the Lists in the ink script you can use them for an easier access.
+ *
+ * @section ue_example The Example project
+ *
+ * [Download](../unreal/InkCPP_DEMO.zip)
+ *
+ * @subsection ue_example_setup Setup
+ *
+ * To setup the [example project](../unreal/InkCPP_DEMO.zip) install the Plugin via the [UE
+ * marketplace](https://www.unrealengine.com/product/inkcpp) place unpack
+ * the `unreal.zip` from the [release page](https://github.com/JBenda/inkcpp/releases/latest) inside
+ * `/PATH/InkCPP_DEMO/Plugins/`.
+ *
+ * Next open the project via the `InkCPP_DEMO/InkCPP_DEMO.uproject` flie.
+ *
+ * Than you can hit play to run the demo.
+ *
+ * The example contains two maps:
+ * + @ref ue_example_demo "`Demo`": An extensive example demonstrating many but not all features
+ * provided by inkCPP like:
+ *   + snapshots: for creating save games
+ *   + observers: to easily refelct a variable of the ink story in the game.
+ *   + external function + yield: to stop playing the story while the game plays a transition
+ *   + a second runner: for a inventory menu
+ *   + interopariblity between UE Enums and Lists in Ink
+ *   + Tag attributes: use tags to modify showed text
+ *   + Tag attributes as enums: use tags to modify choices
+ * + @ref ue_example_minimal "`Minimal`": An example for a minimal, still sensible usage example of
+ * InkCPP in UE5.
+ *
+ * @subsection ue_example_demo  Demo
+ *
+ * The Demo map contains the Actor `DemoThread` which is a child of `InkRuntime`.
+ * All UI elements and other used components are created on the `BeginPlay` event in the following
+ * order.
+ * 1. The UI components are created and configured
+ * 2. Load an existing save game if its exists (the Save game is stored at
+ * `InkCPP_DEMO/Saved/SaveGames`).
+ * 3. Create the main thread of class `DemoThread` and register the external function.
+ * 4. Create menu thread(`InfoThread`), set path to `Wait` to avoid any output in the beginging.
+ * 5. Set observer for the variable `Heath` to update the healthbar.
+ * 6. Set observer for the variable `Inventory` to update the inventory columns.
+ *
+ * @subsubsection ue_example_ui UI
+ *
+ * + `DialogHUD` contains all static UI elements.
+ *   + `Context`: text box containing thelines of the ink story.
+ *   + `Choices`: A container which should be populated with the choice buttons
+ *   + `Clues` & `Potions`: container which should be populated with inventory buttons
+ *   + `SC_Button`: Button to triggern save and close action
+ *   + `Health`: health bar showing current health
+ *   + `DMG_Numbers`: container which should be populated with damage numbers
+ *   + `Popup`/`PopupContext`/`PopopChoices`: elements needed for the Info/"Item interaction thread"
+ *   + `TransitionBlob`: A animated entity used to simulate a transition.
+ * + `DMG_Number` animated text block used to display damage numbers
+ * + `InventoryButton`/`ChoiceButton`: Wrapper for buttons, primarly for attaching data
+ *    to a button for a parametrized clicked event.
+ *
+ * @subsubsection ue_example_demo_DemoRunner DemoRunner
+ *
+ * @htmlonly
+ * <a href="https://blueprintue.com/blueprint/owj83khu/">
+ * <img
+ * alt="Thread Creation Blueprint"
+ * src="../unreal/imgs/CreateThread.png"
+ * width="80%"/></a>
+ * @endhtmlonly
+ *
+ * @htmlonly
+ * <a href="https://blueprintue.com/blueprint/7bjjjb6u/">
+ * <img
+ * alt="Observe Change of variable Blueprint"
+ * src="../unreal/imgs/ObseverChange.png"
+ * width="80%"/></a>
+ * @endhtmlonly
+ *
+ * @htmlonly
+ * <a href="https://blueprintue.com/blueprint/hdybtdjp/">
+ * <img
+ * alt="Usage example for InkList::ElementOf in a Blueprint"
+ * src="../unreal/imgs/ListElementOf.png"
+ * width="80%"/></a>
+ * @endhtmlonly
+ *
+ * <a href="https://blueprintue.com/blueprint/mf-hwyg5/">
+ * <img
+ * alt="A InkThread Yield Resume example Blueprint"
+ * src="../unreal/imgs/YieldResume.png"
+ * width="80%"/></a>
+ *
+ * @subsubsection ue_example_demo_DemoThread DemoThread
+ *
+ * <a href="https://blueprintue.com/blueprint/q8wep7r6/">
+ * <img
+ * alt="Example of the ussage of TagList::GetValue inside processing a new context line."
+ * src="../unreal/imgs/TagListGetValue.png"
+ * width="80%"/></a>
+ *
+ * <a href="https://blueprintue.com/blueprint/r5jbthpn/">
+ * <img
+ * alt="Example for choice handling."
+ * src="../unreal/imgs/HandleChoice.png"
+ * width="80%"/></a>
+ *
+ * @subsection ue_example_minimal Minimal
+ *
+ * <a href="https://blueprintue.com/blueprint/712hsqyl/">
+ * <img
+ * alt="Minmal InkRuntime Blueprint"
+ * src="../unreal/imgs/MinimalRuntime.png"
+ * width="80%"/></a>
+ *
+ * <a href="https://blueprintue.com/blueprint/-da0bqy5/">
+ * <img
+ * alt="Minimal InkThread Blueprint"
+ * src="../unreal/imgs/MinimalThread.png"
+ * width="80%"/></a>
+ *
+ */
+
+DECLARE_LOG_CATEGORY_EXTERN(InkCpp, Log, All);

data/ext/inkcpp_rb/inkcpp/unreal/inkcpp/Source/inkcpp/inkcpp.Build.cs

@@ -0,0 +1,62 @@
+// Copyright 1998-2019 Epic Games, Inc. All Rights Reserved.
+
+using System.IO;
+using UnrealBuildTool;
+
+public class inkcpp : ModuleRules
+{
+	public inkcpp(ReadOnlyTargetRules Target) : base(Target)
+	{
+        // Enable C++20 support
+		PCHUsage = ModuleRules.PCHUsageMode.NoSharedPCHs;
+        PrivatePCHHeaderFile = "Public/inkcpp.h";
+        CppStandard = CppStandardVersion.Cpp20;
+
+        PublicIncludePaths.AddRange(
+			new string[] {
+				Path.Combine(ModuleDirectory, "../shared/Public")
+			}
+			);
+				
+		
+		PrivateIncludePaths.AddRange(
+			new string[] {
+                Path.Combine(ModuleDirectory, "../shared/Private"),
+				Path.Combine(ModuleDirectory, "Private/ink"),
+				Path.Combine(ModuleDirectory, "Public/ink"),
+				Path.Combine(ModuleDirectory, "../ThirdParty/Private"),
+            }
+			);
+			
+		
+		PublicDependencyModuleNames.AddRange(
+			new string[]
+			{
+				"Core",
+				// ... add other public dependencies that you statically link with here ...
+			}
+			);
+			
+		
+		PrivateDependencyModuleNames.AddRange(
+			new string[]
+			{
+				"CoreUObject",
+				"Engine",
+				"Slate",
+				"SlateCore",
+				// ... add private dependencies that you statically link with here ...	
+			}
+			);
+		
+		
+		DynamicallyLoadedModuleNames.AddRange(
+			new string[]
+			{
+				// ... add any modules that your module loads dynamically here ...
+			}
+			);
+
+
+    }
+}

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

@@ -0,0 +1,237 @@
+/* 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 "InkAssetFactory.h"
+
+#include "EditorFramework/AssetImportData.h"
+#include "Misc/FileHelper.h"
+#include "Misc/Paths.h"
+#include "Interfaces/IPluginManager.h"
+#include "Internationalization/Regex.h"
+
+#include "InkAsset.h"
+#include "ink/compiler.h"
+#include "inklecate_cmd.cpp"
+
+#include <sstream>
+#include <cstdlib>
+#include <filesystem>
+#include <fstream>
+#include <unordered_set>
+#include <cstdio>
+
+UInkAssetFactory::UInkAssetFactory(const FObjectInitializer& ObjectInitializer)
+	: UFactory(ObjectInitializer), FReimportHandler(), object_ptr(this)
+{
+	// Add ink format
+	Formats.Add(FString(TEXT("json;")) + NSLOCTEXT("UInkAssetFactory", "FormatInkJSON", "Ink JSON File").ToString());
+	Formats.Add(FString(TEXT("ink;")) + NSLOCTEXT("UInkAssetFactory", "FormatInk", "Ink File").ToString());
+
+	// Set class
+	SupportedClass = UInkAsset::StaticClass();
+	bCreateNew = false;
+	bEditorImport = true;
+
+	// Fuck data tables TODO - some criteria?
+	ImportPriority = 99999;
+	FReimportManager::Instance()->RegisterHandler(*this);
+}
+
+UInkAssetFactory::~UInkAssetFactory() { FReimportManager::Instance()->UnregisterHandler(*this); }
+
+/// @todo only finds first include match?
+void TraversImports(
+    UAssetImportData& AssetImportData, std::unordered_set<std::filesystem::path>& visited,
+    std::filesystem::path filepath
+)
+{
+	UE_LOG(
+	    InkCpp, Display, TEXT("InkAsset Import: Traverse '%s'"), *FString(filepath.string().c_str())
+	);
+	if (visited.find(filepath) != visited.end()) {
+		return;
+	}
+	int id = visited.size();
+	visited.insert(filepath);
+	AssetImportData.AddFileName(
+	    FString(filepath.string().c_str()), id, id == 0 ? TEXT("MainFile") : TEXT("Include")
+	);
+
+	std::ifstream file(filepath);
+	if (! file) {
+		UE_LOG(
+		    InkCpp, Warning, TEXT("Failed to open story file: %s"), *FString(filepath.string().c_str())
+		);
+		return;
+	}
+	std::stringstream file_data;
+	file_data << file.rdbuf();
+	FRegexMatcher matcher(
+	    FRegexPattern(FString("(^|\n)[ \t]*INCLUDE[ \t]+(.*)"), ERegexPatternFlags{0}),
+	    FString(file_data.str().c_str())
+	);
+	while (matcher.FindNext()) {
+		std::filesystem::path match_file_path = filepath;
+		match_file_path.replace_filename(TCHAR_TO_ANSI(*matcher.GetCaptureGroup(2)));
+		TraversImports(AssetImportData, visited, match_file_path);
+	}
+}
+
+UObject* UInkAssetFactory::FactoryCreateFile(UClass* InClass, UObject* InParent, FName InName, EObjectFlags Flags, const FString& Filename, const TCHAR* Parms, FFeedbackContext* Warn, bool& bOutOperationCanceled)
+{
+	std::stringstream output;
+	std::stringstream cmd{};
+	const std::string        inklecate_cmd = get_inklecate_cmd();
+	static const std::string ink_suffix{".ink"};
+	try
+	{
+		using path            = std::filesystem::path;
+		std::string cFilename = TCHAR_TO_ANSI(*Filename);
+		path        story_path(cFilename, path::format::generic_format);
+		story_path.make_preferred();
+		bool use_temp_file = false;
+		if (cFilename.size() > ink_suffix.size()
+				&& std::equal(ink_suffix.rbegin(), ink_suffix.rend(), cFilename.rbegin()))
+		{
+			use_temp_file = true;
+			if(inklecate_cmd.size() == 0) {
+				UE_LOG(InkCpp, Warning, TEXT("Inklecate provided with the plugin, please import ink.json files"));
+				return nullptr;
+			}
+			path path_bin(TCHAR_TO_ANSI(*IPluginManager::Get().FindPlugin(TEXT("InkCPP"))->GetBaseDir()), path::format::generic_format);
+			path_bin.make_preferred();
+			path_bin /= path(inklecate_cmd, path::format::generic_format).make_preferred();
+			const char* filename = std::tmpnam(nullptr);
+			if(filename == nullptr) {
+				UE_LOG(InkCpp, Error, TEXT("Failed to create temporary file"));
+				return nullptr;
+			}
+			cFilename = filename;
+			path json_path(cFilename, path::format::generic_format);
+			json_path.make_preferred();
+			cmd 
+				// if std::system start with a quote, the pair of qoute is removed, which leads to errors with pathes with spaces
+				// but if the quote is not the first symbol it works fine (a"b" is glued to ab from bash)
+				<< path_bin.string()[0] << "\"" << (path_bin.string().c_str() + 1) << "\""
+				<< " -o \"" << json_path.string() << "\" "
+				<< '"' << story_path.string() << "\" 2>&1";
+			auto cmd_str = cmd.str();
+			int result = std::system(cmd_str.c_str());
+			if (result != 0) {
+				UE_LOG(InkCpp, Warning, TEXT("Inklecate failed with exit code %i, executed was: '%s'"), result, *FString(cmd_str.c_str()));
+				return nullptr;
+			}
+		}
+		ink::compiler::run(cFilename.c_str(), output);
+		if(use_temp_file) {
+			std::filesystem::remove(cFilename);
+		}
+
+		// Create ink asset
+		UInkAsset* asset = NewObject<UInkAsset>(InParent, InClass, InName, Flags);
+
+		// Load it up
+		std::string data = output.str();
+		asset->CompiledStory.SetNum(data.length());
+		FMemory::Memcpy(asset->CompiledStory.GetData(), data.c_str(), data.length());
+
+		// Paths
+		std::unordered_set<std::filesystem::path> visited{};
+		TraversImports(*asset->AssetImportData, visited, story_path);
+
+		// Not cancelled
+		bOutOperationCanceled = false;
+
+		// Return
+		return asset;
+	}
+	catch (...)
+	{
+		// some kind of error?
+		return nullptr;
+	}
+
+	return nullptr;
+}
+
+bool UInkAssetFactory::FactoryCanImport(const FString& Filename)
+{
+	return true; // Fuck you Unreal
+}
+
+bool UInkAssetFactory::CanReimport(UObject* Obj, TArray<FString>& OutFilenames)
+{
+	// Can reimport story assets
+	UInkAsset* InkAsset = Cast<UInkAsset>(Obj);
+	if (InkAsset != nullptr && InkAsset->AssetImportData)
+	{
+		UE_LOG(InkCpp, Warning, TEXT("Can Reimport"));
+		InkAsset->AssetImportData->ExtractFilenames(OutFilenames);
+		return true;
+	}
+	UE_LOG(InkCpp, Warning, TEXT("Failed to reimport"));
+	return false;
+}
+
+void UInkAssetFactory::SetReimportPaths(UObject* Obj, const TArray<FString>& NewReimportPaths)
+{
+	UE_LOG(InkCpp, Warning, TEXT("SetReimportPaths"));
+	UInkAsset* InkAsset = Cast<UInkAsset>(Obj);
+	if (InkAsset != nullptr && NewReimportPaths.Num() > 0) {
+		InkAsset->AssetImportData->UpdateFilenameOnly(NewReimportPaths[0]);
+	}
+}
+
+int32 UInkAssetFactory::GetPriority() const
+{
+	return ImportPriority;
+}
+
+TObjectPtr<UObject>* UInkAssetFactory::GetFactoryObject() const
+{
+	return const_cast<TObjectPtr<UObject>*>(&object_ptr);
+}
+
+EReimportResult::Type UInkAssetFactory::Reimport(UObject* Obj, int SourceID)
+{
+	UE_LOG(InkCpp, Warning, TEXT("Reimport started"));
+	UInkAsset* InkAsset = Cast<UInkAsset>(Obj);
+	if (!InkAsset)
+		return EReimportResult::Failed;
+
+	const FString Filename = InkAsset->AssetImportData->GetFirstFilename();
+	if (!Filename.Len() || IFileManager::Get().FileSize(*Filename) == INDEX_NONE)
+	{
+		return EReimportResult::Failed;
+	}
+
+	// Run the import again
+	EReimportResult::Type Result = EReimportResult::Failed;
+	bool OutCanceled = false;
+
+	if (ImportObject(InkAsset->GetClass(), InkAsset->GetOuter(), *InkAsset->GetName(), RF_Public | RF_Standalone, Filename, nullptr, OutCanceled) != nullptr)
+	{
+		/// TODO: add aditional pathes
+		InkAsset->AssetImportData->Update(Filename);
+
+		// Try to find the outer package so we can dirty it up
+		if (InkAsset->GetOuter())
+		{
+			InkAsset->GetOuter()->MarkPackageDirty();
+		}
+		else
+		{
+			InkAsset->MarkPackageDirty();
+		}
+		Result = EReimportResult::Succeeded;
+	}
+	else
+	{
+		Result = EReimportResult::Failed;
+	}
+
+	return Result;
+}

data/ext/inkcpp_rb/inkcpp/unreal/inkcpp/Source/inkcpp_editor/Private/InkAssetFactory.h

@@ -0,0 +1,43 @@
+/* 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 "EditorReimportHandler.h"
+#include "Factories/Factory.h"
+#include "UObject/ObjectMacros.h"
+
+#include "InkAssetFactory.generated.h"
+
+UCLASS(hidecategories=Object)
+class UInkAssetFactory : public UFactory, public FReimportHandler
+{
+	GENERATED_BODY()
+	
+public:
+	UInkAssetFactory(const FObjectInitializer& ObjectInitializer);
+	~UInkAssetFactory();
+
+	// Begin UFactory
+	virtual UObject* FactoryCreateFile(UClass* InClass, UObject* InParent, FName InName, 
+		EObjectFlags Flags, const FString& Filename, const TCHAR* Parms,
+		FFeedbackContext* Warn, bool& bOutOperationCanceled) override;
+	virtual bool FactoryCanImport(const FString& Filename) override;
+	// End UFactory
+
+	// Begin FReimportHandler
+	virtual bool                  CanReimport(UObject* Obj, TArray<FString>& OutFilenames) override;
+	virtual TObjectPtr<UObject>*  GetFactoryObject() const override;
+	virtual EReimportResult::Type Reimport(UObject* Obj, int SourceID) override;
+
+	virtual EReimportResult::Type Reimport(UObject* Obj) override { return Reimport(Obj, 0); }
+
+	virtual void  SetReimportPaths(UObject* Obj, const TArray<FString>& NewReimportPaths) override;
+	virtual int32 GetPriority() const override;
+	// End FReimportHandle
+private:
+	TObjectPtr<UObject> object_ptr;
+};

data/ext/inkcpp_rb/inkcpp/unreal/inkcpp/Source/inkcpp_editor/Private/inkcpp_editor.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_editor.h"
+
+#include "CoreMinimal.h"
+#include "Modules/ModuleManager.h"
+
+IMPLEMENT_MODULE(FDefaultGameModuleImpl, inkcpp_editor)
+DEFINE_LOG_CATEGORY(InkCpp);

data/ext/inkcpp_rb/inkcpp/unreal/inkcpp/Source/inkcpp_editor/Private/inklecate_cmd.cpp.in

@@ -0,0 +1,24 @@
+/* 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 "Kismet/GameplayStatics.h"
+#include "string"
+
+inline std::string get_inklecate_cmd() {
+	FString platform = UGameplayStatics::GetPlatformName();
+	if (platform == TEXT("Windows")) {
+		return std::string("@INKLECATE_CMD_WIN@");
+	} else if (platform == TEXT("Mac")) {
+		return std::string("@INKLECATE_CMD_MAC@");
+	} else if (platform == TEXT("Linux")) {
+		return std::string("@INKLECATE_CMD_LINUX@");
+	} else {
+		// UE_LOG(InkCpp, Warning, TEXT("Platform: '%s' is not know. For compiling a .ink file a system wide 'inklecate' executable wil be tried to use."), platform);
+		return std::string("inklecate");
+	}
+}

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

@@ -0,0 +1,9 @@
+/* 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 "Logging/LogMacros.h"
+DECLARE_LOG_CATEGORY_EXTERN(InkCpp, Log, All);