Fix and Update Unreal Plugin for UE 5

.github/workflows/build.yml

@@ -18,17 +18,17 @@ jobs:
           - os: macos-latest
             artifact: macos
             name: MacOSX
-            inklecate_url: https://github.com/inkle/ink/releases/download/0.9.0/inklecate_mac.zip
+            inklecate_url: https://github.com/inkle/ink/releases/download/v1.1.1/inklecate_mac.zip
             proof: false
           - os: windows-latest
             artifact: win64
             name: Windows x64
-            inklecate_url: https://github.com/inkle/ink/releases/download/v1.0.0/inklecate_windows.zip
+            inklecate_url: https://github.com/inkle/ink/releases/download/v1.1.1/inklecate_windows.zip
             proof: false
           - os: "ubuntu-20.04"
             artifact: linux
             name: Linux x64
-            inklecate_url: https://github.com/inkle/ink/releases/download/v1.0.0/inklecate_linux.zip
+            inklecate_url: https://github.com/inkle/ink/releases/download/v1.1.1/inklecate_linux.zip
             proof: true
 
     steps:

CMakeLists.txt

@@ -5,7 +5,7 @@ enable_testing()
 
 # Project setup
 project(inkcpp VERSION 0.1)
-SET(CMAKE_CXX_STANDARD 17)
+SET(CMAKE_CXX_STANDARD 20)
 SET(CMAKE_CXX_STANDARD_REQUIRED ON)
 SET(CMAKE_INSTALL_LIBRARY_DIR lib)
 SET(CMAKE_INSTALL_INCLUDE_DIR include)
@@ -18,7 +18,6 @@ add_subdirectory(inkcpp_test)
 add_subdirectory(unreal)
 
 
-get_target_property(TEE inkcpp PUBLIC_HEADER)
 install(TARGETS inkcpp inkcpp_compiler inkcpp_shared
 	EXPORT inkcppTarget
 	ARCHIVE DESTINATION "lib/ink"
@@ -57,3 +56,11 @@ set(CPACK_GENERATOR "ZIP")
 set(CPACK_ARCHIVE_COMPONENT_INSTALL ON)
 set(CPACK_COMPONENTS_GROUPING IGNORE)
 include(CPack)
+
+find_package(Doxygen)
+if (DOXYGEN_FOUND)
+	set(DOXYGEN_PROJECT_NAME ${PROJECT_NAME})
+	doxygen_add_docs(doc ${PROJECT_SOURCE_DIR} COMMENT "Generate docs")
+else(DOXYGEN_FOUND)
+	message("Doxygen needed to generate documntation!")
+endif(DOXYGEN_FOUND)

README.md

@@ -49,25 +49,16 @@ thread->choose(0);
 ```
 
 ## Current Status
-Run `inkcpp_cl.exe -p myfile.json` to execute a compiled Ink JSON file in play mode. It can also operate on `.ink` files but `inklecate.exe` must me in the same folder or in the PATH.
+
+Run `inkcpp_cl.exe -p myfile.json` to execute a compiled Ink JSON file in play mode. It can also operate on `.ink` files but `inklecate.exe` must be in the same folder or in the PATH.
+`inklecate` can be downloaded from the official [release page](https://github.com/inkle/ink/releases) and will be downloaded from CMake at  configure time (located at `build/unreal/inkcpp/Resources/inklecate`).
 
 Without the `-p` flag, it'll just compile the JSON/Ink file into InkCPP's binary format (see the Wiki on GitHub).
 
-Many, but not all features of the Ink language are supported (see Glaring Omissions below), but be warned, this runtime is still highly unstable. I am currently working on getting it to pass all the unit tests on [ink-proof](https://github.com/chromy/ink-proof).
-
-* Temporary and global variables
-* Int, String, or Divert values
-* Eval stack (`ev`, `/ev`), String stack (`str`, `/str`)
-* Choices (support for both `*` and `+` and conditional choices)
-* Diverts (variable and fixed, conditional and normal)
-* All mathematical operators (`+`, `<=`, etc.). String equality not supported.
-* Glue
-* Visit and read counts (`visits` and `CNT?` commands).
-* `seq` command and all sequence types (stopping, cycle, shuffle)
-* Global store that can be shared between runners
-* External function binding (no fallback support yet)
-* Tunnels and internal functions
-* Ink threads (probably incredibly unstable though)
+All features of ink 1.1 are supported, and checked with [ink-proof](https://github.com/chromy/ink-proof).
+
+Big features missing compared to the `C#` implementation are:
+* stable Ink Thread support
 
 ## Configuring and Building (CMake)
 
@@ -79,6 +70,8 @@ To configure the project...
 
 CMake will then generate the necessary build files for your environment. By default, it generates Visual Studio projects and solutions on Windows and Makefiles on Mac and Linux. You can change this using CMake's command line options (see `cmake --help`). It supports pretty much anything.
 
+The documentation can be build iff Doxygen is installed with `cmake --build . --target doc`. The documentation can then be found in at `html/index.html`.
+
 To build, either run the generated buildfiles OR you can use `cmake --build . --config <Release|Debug>` from the build folder to automatically execute the relevant toolchain.
 
 For a more in depth installation description please checkout the (wiki)[https://github.com/brwarner/inkcpp/wiki/building].
@@ -130,15 +123,6 @@ Code for the Unreal plugin is located in the `unreal` directory. In order to ins
 
 I am currently working toward a 1.0 release. You can track my progress here: https://github.com/brwarner/inkcpp/projects/1
 
-### Glaring Omissions
-
-The big things we're missing right now are:
-
-* Fallback functions for externals.
-* Variable observers
-* Lists and whatever cool, crazy stuff Ink has been adding recently.
-* Robust tests using ink-proof.
-
 ## Dependencies
 The compiler depends on Nlohmann's JSON library and the C++ STL.
 

inkcpp/CMakeLists.txt

@@ -1,8 +1,6 @@
 set_property(GLOBAL PROPERTY USE_FOLDERS ON)
 
 list(APPEND SOURCES 
-    collections/restorable.h 
-    collections/restorable.cpp
     array.h
     choice.cpp
     functional.cpp
@@ -13,19 +11,33 @@ list(APPEND SOURCES
     runner_impl.h runner_impl.cpp
     simple_restorable_stack.h stack.h stack.cpp
     story_impl.h story_impl.cpp
+	snapshot_impl.h snapshot_impl.cpp snapshot_interface.h
     story_ptr.cpp
     system.cpp
     value.h value.cpp
+	tuple.hpp
     string_table.h string_table.cpp avl_array.h
 	list_table.h list_table.cpp
+  list_impl.h list_impl.cpp
+	operations.h operation_bases.h
 	list_operations.h list_operations.cpp
 	container_operations.h container_operations.cpp
+	numeric_operations.h numeric_operations.cpp
+	string_operations.h string_operations.cpp
 	string_operations.cpp
 	numeric_operations.cpp
+	casting.h
+	executioner.h
+	string_utils.h
 	header.cpp
+	random.h
+)
+list(APPEND COLLECTION_SOURCES
+    collections/restorable.h 
+    collections/restorable.cpp
 )
 source_group(Collections REGULAR_EXPRESSION collections/.*)
-add_library(inkcpp ${SOURCES})
+add_library(inkcpp ${SOURCES} ${COLLECTION_SOURCES})
 target_include_directories(inkcpp PUBLIC
 	$<BUILD_INTERFACE:${CMAKE_CURRENT_SOURCE_DIR}/include>
 	$<INSTALL_INTERFACE:include>
@@ -42,3 +54,4 @@ target_compile_features(inkcpp PUBLIC cxx_std_17)
 # Unreal installation
 install(DIRECTORY "include/" DESTINATION "inkcpp/Source/inkcpp/Public/ink/" COMPONENT unreal EXCLUDE_FROM_ALL)
 install(FILES ${SOURCES} DESTINATION "inkcpp/Source/inkcpp/Private/ink/" COMPONENT unreal EXCLUDE_FROM_ALL)
+install(FILES ${COLLECTION_SOURCES} DESTINATION "inkcpp/Source/inkcpp/Private/ink/collections/" COMPONENT unreal EXCLUDE_FROM_ALL)

inkcpp/array.h

@@ -1,13 +1,15 @@
 #pragma once
 
 #include "system.h"
+#include "traits.h"
+#include "snapshot_interface.h"
 
 namespace ink::runtime::internal
 {
 	template<typename T, bool dynamic, size_t initialCapacity>
-	class managed_array {
+		class managed_array : snapshot_interface {
 	public:
-		managed_array() : _capacity{initialCapacity}, _size{0}{
+		managed_array() : _static_data{}, _capacity{ initialCapacity }, _size{ 0 }{
 			if constexpr (dynamic) {
 				_dynamic_data = new T[initialCapacity];
 			}
@@ -42,17 +44,50 @@ namespace ink::runtime::internal
 			if constexpr (dynamic) {
 				if (_size == _capacity) { extend(); }
 			} else {
-				ink_assert(_size <= _capacity, "Stack Overflow!");
+				inkAssert(_size <= _capacity, "Stack Overflow!");
+				/// FIXME silent fail!!
 			}
 			return data()[_size++];
 		}
 		void clear() { _size = 0; }
 		void resize(size_t size) {
-			ink_assert(size <= _size, "Only allow to reduce size");
+			if constexpr (dynamic) {
+				if (size > _capacity) {
+					extend(size);
+				}
+			} else {
+				inkAssert(size <= _size, "Only allow to reduce size");
+			}
 			_size = size;
 		}
 
-		void extend();
+		void extend(size_t capacity = 0);
+
+		size_t snap(unsigned char* data, const snapper&) const override
+		{
+			inkAssert(!is_pointer<T>{}(), "here is a special case oversight");
+			unsigned char* ptr = data;
+			bool should_write = data != nullptr;
+			ptr = snap_write(ptr, _size, should_write );
+			for(const T& e : *this) {
+				ptr = snap_write(ptr, e, should_write );
+			}
+			return ptr - data;
+		}
+		const unsigned char* snap_load(const unsigned char* ptr, const loader&) override
+{
+			decltype(_size) size;
+			ptr = snap_read(ptr, size);
+			if constexpr (dynamic) {
+				resize(size);
+			} else {
+				inkAssert(size <= initialCapacity, "capacity of non dynamic array is to small vor snapshot!");
+			}
+			for (T& e : *this) {
+				ptr = snap_read(ptr, e);
+			}
+			return ptr;
+		}
 	private:
 
 		if_t<dynamic, char, T> _static_data[dynamic ? 1 : initialCapacity];
@@ -62,10 +97,12 @@ namespace ink::runtime::internal
 	};
 
 	template<typename T, bool dynamic, size_t initialCapacity>
-	void managed_array<T, dynamic, initialCapacity>::extend()
+	void managed_array<T, dynamic, initialCapacity>::extend(size_t capacity)
 	{
 		static_assert(dynamic, "Can only extend if array is dynamic!");
-		size_t new_capacity = 1.5f * _capacity;
+		size_t new_capacity = capacity > _capacity
+			? capacity
+			: 1.5f * _capacity;
 		if (new_capacity < 5) { new_capacity = 5; }
 		T* new_data = new T[new_capacity];
 
@@ -79,7 +116,7 @@ namespace ink::runtime::internal
 	}
 
 	template<typename T>
-	class basic_restorable_array
+	class basic_restorable_array : public snapshot_interface
 	{
 	public:
 		basic_restorable_array(T* array, size_t capacity, T nullValue)
@@ -116,6 +153,10 @@ namespace ink::runtime::internal
 		// Resets all values and clears any save points
 		void clear(const T& value);
 
+		// snapshot interface
+		virtual size_t snap(unsigned char* data, const snapper&) const override;
+		virtual const unsigned char* snap_load(const unsigned char* data, const loader&) override;
+
 	protected:
 		inline T* buffer() { return _array; }
 		void set_new_buffer(T* buffer, size_t capacity) {
@@ -144,6 +185,37 @@ namespace ink::runtime::internal
 		const T _null;
 	};
 
+	template<typename T>
+	inline size_t basic_restorable_array<T>::snap(unsigned char* data, const snapper& snapper) const
+	{
+		unsigned char* ptr = data;
+		bool should_write = data != nullptr;
+		ptr = snap_write(ptr, _saved, should_write );
+		ptr = snap_write(ptr, _capacity, should_write );
+		ptr = snap_write(ptr, _null, should_write );
+		for(size_t i = 0; i < _capacity; ++i) {
+			ptr = snap_write(ptr, _array[i], should_write );
+			ptr = snap_write(ptr, _temp[i], should_write );
+		}
+		return ptr - data;
+	}
+
+	template<typename T>
+	inline const unsigned char* basic_restorable_array<T>::snap_load(const unsigned char* data, const loader& loader)
+	{
+		auto ptr = data;
+		ptr = snap_read(ptr, _saved);
+		ptr = snap_read(ptr, _capacity);
+		T null;
+		ptr = snap_read(ptr, null);
+		inkAssert(null == _null, "null value is different to snapshot!");
+		for(size_t i = 0; i < _capacity; ++i) {
+			ptr = snap_read(ptr, _array[i]);
+			ptr = snap_read(ptr, _temp[i]);
+		}
+		return ptr;
+	}
+
 	template<typename T>
 	inline void basic_restorable_array<T>::set(size_t index, const T& value)
 	{
@@ -238,7 +310,7 @@ namespace ink::runtime::internal
 	};
 
 	template<typename T>
-	class allocated_restorable_array : public basic_restorable_array<T>
+	class allocated_restorable_array final : public basic_restorable_array<T>
 	{
 		using base = basic_restorable_array<T>;
 	public:
@@ -275,7 +347,7 @@ namespace ink::runtime::internal
 			this->set_new_buffer(_buffer, new_capacity);
 		}
 
-		~allocated_restorable_array()
+		virtual ~allocated_restorable_array() 
 		{
 			if(_buffer) {
 				delete[] _buffer;