inkcpp_rb 0.1.0

data/ext/inkcpp_rb/inkcpp/inkcpp_c/inkcpp.cpp

@@ -0,0 +1,344 @@
+#include "inkcpp.h"
+#include "list.h"
+#include "system.h"
+#include "types.h"
+
+#include <cstring>
+
+#include <story.h>
+#include <snapshot.h>
+#include <globals.h>
+#include <runner.h>
+#include <choice.h>
+#include <compiler.h>
+
+using namespace ink::runtime;
+
+InkValue inkvar_to_c(value& val)
+{
+	switch (val.type) {
+		case value::Type::Bool:
+			return InkValue{
+			    .bool_v = val.get<value::Type::Bool>(),
+			    .type   = InkValue::ValueTypeBool,
+			};
+		case value::Type::Uint32:
+			return InkValue{
+			    .uint32_v = val.get<value::Type::Uint32>(),
+			    .type     = InkValue::ValueTypeUint32,
+			};
+		case value::Type::Int32:
+			return InkValue{
+			    .int32_v = val.get<value::Type::Int32>(),
+			    .type    = InkValue::ValueTypeInt32,
+			};
+		case value::Type::String:
+			return InkValue{
+			    .string_v = val.get<value::Type::String>(),
+			    .type     = InkValue::ValueTypeString,
+			};
+		case value::Type::Float:
+			return InkValue{
+			    .float_v = val.get<value::Type::Float>(),
+			    .type    = InkValue::ValueTypeFloat,
+			};
+		case value::Type::List:
+			return InkValue{
+			    .list_v = reinterpret_cast<HInkList*>(val.get<value::Type::List>()),
+			    .type   = InkValue::ValueTypeList,
+			};
+	}
+	inkFail("Undefined value type can not be translated");
+	return InkValue{};
+}
+
+value inkvar_from_c(InkValue& val)
+{
+	switch (val.type) {
+		case InkValue::ValueTypeBool: return value(val.bool_v);
+		case InkValue::ValueTypeUint32: return value(val.uint32_v);
+		case InkValue::ValueTypeInt32: return value(val.int32_v);
+		case InkValue::ValueTypeString: return value(val.string_v);
+		case InkValue::ValueTypeFloat: return value(val.float_v);
+		case InkValue::ValueTypeList: return value(reinterpret_cast<list_interface*>(val.list_v));
+		case InkValue::ValueTypeNone: break;
+	}
+	inkFail("Undefined value type can not be translated");
+	return value{};
+}
+
+extern "C" {
+	HInkSnapshot* ink_snapshot_from_file(const char* filename)
+	{
+		return reinterpret_cast<HInkSnapshot*>(snapshot::from_file(filename));
+	}
+
+	int ink_snapshot_num_runners(const HInkSnapshot* self)
+	{
+		return reinterpret_cast<const snapshot*>(self)->num_runners();
+	}
+
+	void ink_snapshot_write_to_file(const HInkSnapshot* self, const char* filename)
+	{
+		reinterpret_cast<const snapshot*>(self)->write_to_file(filename);
+	}
+
+	const char* ink_choice_text(const HInkChoice* self)
+	{
+		return reinterpret_cast<const choice*>(self)->text();
+	}
+
+	int ink_choice_num_tags(const HInkChoice* self)
+	{
+		return reinterpret_cast<const choice*>(self)->num_tags();
+	}
+
+	const char* ink_choice_get_tag(const HInkChoice* self, int tag_id)
+	{
+		return reinterpret_cast<const choice*>(self)->get_tag(tag_id);
+	}
+
+	void ink_list_add(HInkList* self, const char* flag_name)
+	{
+		reinterpret_cast<list>(self)->add(flag_name);
+	}
+
+	void ink_list_remove(HInkList* self, const char* flag_name)
+	{
+		reinterpret_cast<list>(self)->remove(flag_name);
+	}
+
+	int ink_list_contains(const HInkList* self, const char* flag_name)
+	{
+		return reinterpret_cast<const list_interface*>(self)->contains(flag_name);
+	}
+
+	int ink_list_flags(const HInkList* self, InkListIter* iter)
+	{
+		list_interface::iterator itr = reinterpret_cast<const list_interface*>(self)->begin();
+		*iter                        = InkListIter{
+		                           ._data        = &itr._list,
+		                           ._i           = itr._i,
+		                           ._single_list = itr._one_list_iterator,
+		                           .flag_name    = itr._flag_name,
+		                           .list_name    = itr._list_name,
+    };
+		return itr != reinterpret_cast<const list_interface*>(self)->end();
+	}
+
+	int ink_list_flags_from(const HInkList* self, const char* list_name, InkListIter* iter)
+	{
+		list_interface::iterator itr = reinterpret_cast<const list_interface*>(self)->begin(list_name);
+		*iter                        = InkListIter{
+		                           ._data        = &itr._list,
+		                           ._i           = itr._i,
+		                           ._single_list = itr._one_list_iterator,
+		                           .flag_name    = itr._flag_name,
+		                           .list_name    = itr._list_name,
+    };
+		return itr != reinterpret_cast<const list_interface*>(self)->end();
+	}
+
+	int ink_list_iter_next(InkListIter* self)
+	{
+		list_interface::iterator itr(
+		    self->flag_name, *reinterpret_cast<const list_interface*>(self->_data), self->_i,
+		    self->_single_list
+		);
+		++itr;
+		self->flag_name = itr._flag_name;
+		self->list_name = itr._list_name;
+		self->_i        = itr._i;
+		return itr != itr._list.end();
+	}
+
+	void ink_runner_delete(HInkRunner* self) { delete reinterpret_cast<const runner*>(self); }
+
+	HInkSnapshot* ink_runner_create_snapshot(const HInkRunner* self)
+	{
+		return reinterpret_cast<HInkSnapshot*>(
+		    reinterpret_cast<const runner*>(self)->get()->create_snapshot()
+		);
+	}
+
+	int ink_runner_can_continue(const HInkRunner* self)
+	{
+		return reinterpret_cast<const runner*>(self)->get()->can_continue();
+	}
+
+	const char* ink_runner_get_line(HInkRunner* self)
+	{
+		return reinterpret_cast<runner*>(self)->get()->getline_alloc();
+	}
+
+	int ink_runner_get_num_tags(const HInkRunner* self)
+	{
+		return reinterpret_cast<const runner*>(self)->get()->num_tags();
+	}
+
+	const char* ink_runner_tag(const HInkRunner* self, int tag_id)
+	{
+		return reinterpret_cast<const runner*>(self)->get()->get_tag(tag_id);
+	}
+
+	int ink_runner_num_choices(const HInkRunner* self)
+	{
+		return reinterpret_cast<const runner*>(self)->get()->num_choices();
+	}
+
+	const HInkChoice* ink_runner_get_choice(const HInkRunner* self, int choice_id)
+	{
+		return reinterpret_cast<const HInkChoice*>(
+		    reinterpret_cast<const runner*>(self)->get()->get_choice(choice_id)
+		);
+	}
+
+	void ink_runner_choose(HInkRunner* self, int choice_id)
+	{
+		return reinterpret_cast<runner*>(self)->get()->choose(choice_id);
+	}
+
+	void ink_runner_bind_void(
+	    HInkRunner* self, const char* function_name, InkExternalFunctionVoid callback,
+	    int lookaheadSafe
+	)
+	{
+		static_assert(sizeof(ink::runtime::value) >= sizeof(InkValue));
+		return reinterpret_cast<runner*>(self)->get()->bind(
+		    function_name,
+		    [callback](size_t len, const value* vals) {
+			    InkValue* c_vals = reinterpret_cast<InkValue*>(const_cast<value*>(vals));
+			    int       c_len  = len;
+			    for (int i = 0; i < c_len; ++i) {
+				    c_vals[i] = inkvar_to_c(const_cast<value&>(vals[i]));
+			    }
+			    callback(c_len, c_vals);
+		    },
+		    lookaheadSafe
+		);
+	}
+
+	void ink_runner_bind(
+	    HInkRunner* self, const char* function_name, InkExternalFunction callback, int lookaheadSafe
+	)
+	{
+		static_assert(sizeof(ink::runtime::value) >= sizeof(InkValue));
+		return reinterpret_cast<runner*>(self)->get()->bind(
+		    function_name,
+		    [callback](size_t len, const value* vals) -> value {
+			    InkValue* c_vals = reinterpret_cast<InkValue*>(const_cast<value*>(vals));
+			    int       c_len  = len;
+			    for (int i = 0; i < c_len; ++i) {
+				    c_vals[i] = inkvar_to_c(const_cast<value&>(vals[i]));
+			    }
+			    InkValue res = callback(c_len, c_vals);
+			    return inkvar_from_c(res);
+		    },
+		    lookaheadSafe
+		);
+	}
+
+	void ink_globals_delete(HInkGlobals* self) { delete reinterpret_cast<globals*>(self); }
+
+	HInkSnapshot* ink_globals_create_snapshot(const HInkGlobals* self)
+	{
+		return reinterpret_cast<HInkSnapshot*>(
+		    reinterpret_cast<const globals*>(self)->get()->create_snapshot()
+		);
+	}
+
+	void ink_globals_observe(HInkGlobals* self, const char* variable_name, InkObserver observer)
+	{
+		reinterpret_cast<globals*>(self)->get()->observe(
+		    variable_name,
+		    [observer](value new_value, ink::optional<value> old_value) {
+			    observer(
+			        inkvar_to_c(new_value), old_value.has_value()
+			                                    ? inkvar_to_c(old_value.value())
+			                                    : InkValue{.type = InkValue::Type::ValueTypeNone}
+			    );
+		    }
+		);
+	}
+
+	InkValue ink_globals_get(const HInkGlobals* self, const char* variable_name)
+	{
+		ink::optional<value> o_val
+		    = reinterpret_cast<const globals*>(self)->get()->get<value>(variable_name);
+		if (! o_val.has_value()) {
+			return InkValue{
+			    .type = InkValue::ValueTypeNone,
+			};
+		} else {
+			return inkvar_to_c(o_val.value());
+		}
+	}
+
+	int ink_globals_set(HInkGlobals* self, const char* variable_name, InkValue val)
+	{
+		return reinterpret_cast<globals*>(self)->get()->set(variable_name, inkvar_from_c(val));
+	}
+
+	HInkStory* ink_story_from_file(const char* filename)
+	{
+		return reinterpret_cast<HInkStory*>(story::from_file(filename));
+	}
+
+	void ink_story_delete(HInkStory* self) { delete reinterpret_cast<story*>(self); }
+
+	HInkRunner* ink_story_new_runner(HInkStory* self, HInkGlobals* global_store)
+	{
+		runner* res = new runner(
+		    global_store
+		        ? reinterpret_cast<story*>(self)->new_runner(*reinterpret_cast<globals*>(global_store))
+		        : reinterpret_cast<story*>(self)->new_runner()
+		);
+		return reinterpret_cast<HInkRunner*>(res);
+	}
+
+	HInkRunner* ink_story_new_runner_from_snapshot(
+	    HInkStory* self, const HInkSnapshot* snapshot, HInkGlobals* global_store, int runner_id
+	)
+	{
+		const ink::runtime::snapshot& snap = *reinterpret_cast<const ink::runtime::snapshot*>(snapshot);
+		runner*                       res  = new runner(
+		                           global_store
+		                               ? reinterpret_cast<story*>(self)->new_runner_from_snapshot(
+		                                   snap, *reinterpret_cast<globals*>(global_store), runner_id
+		                               )
+		                               : reinterpret_cast<story*>(self)->new_runner_from_snapshot(snap, nullptr, runner_id)
+		);
+		return reinterpret_cast<HInkRunner*>(res);
+	}
+
+	HInkGlobals* ink_story_new_globals(HInkStory* self)
+	{
+		return reinterpret_cast<HInkGlobals*>(new globals(reinterpret_cast<story*>(self)->new_globals())
+		);
+	}
+
+	HInkGlobals* ink_story_new_globals_from_snapshot(HInkStory* self, const HInkSnapshot* snap)
+	{
+		return reinterpret_cast<HInkGlobals*>(
+		    new globals(reinterpret_cast<story*>(self)->new_globals_from_snapshot(
+		        *reinterpret_cast<const snapshot*>(snap)
+		    ))
+		);
+	}
+
+	void ink_compile_json(const char* input_filename, const char* output_filename, const char** error)
+	{
+		ink::compiler::compilation_results result;
+		ink::compiler::run(input_filename, output_filename, &result);
+		if (error != nullptr && ! result.errors.empty() || ! result.warnings.empty()) {
+			std::string str{};
+			for (auto& warn : result.warnings) {
+				str += "WARNING: " + warn + '\n';
+			}
+			for (auto& err : result.errors) {
+				str += "ERROR: " + err + '\n';
+			}
+			*error = strdup(str.c_str());
+		}
+	}
+}

data/ext/inkcpp_rb/inkcpp/inkcpp_c/inkcpp_c.pc.in

@@ -0,0 +1,10 @@
+prefix=@PREFIX@
+exec_prefix=${prefix}
+libdir=${prefix}/lib/ink
+includedir=${prefix}/include
+
+Name: inkcpp
+Description: C Bindnigs for inkpp. @CMAKE_PROJECT_DESCRIPTION@
+Version: @PROJECT_VERSION@
+CFlags: -I${includedir}
+Libs: -L${libdir} -linkcpp_c

data/ext/inkcpp_rb/inkcpp/inkcpp_c/tests/ExternalFunction.c

@@ -0,0 +1,56 @@
+#include <string.h>
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <inkcpp.h>
+
+#undef NDEBUG
+#include <assert.h>
+
+int cnt_my_sqrt = 0;
+
+InkValue my_sqrt(int argc, const InkValue argv[])
+{
+	cnt_my_sqrt += 1;
+	assert(argc == 1);
+	InkValue v = argv[0];
+	switch (v.type) {
+		case ValueTypeFloat: v.float_v = sqrtf(v.float_v); break;
+		case ValueTypeInt32: v.int32_v = sqrt(v.int32_v); break;
+		case ValueTypeUint32: v.uint32_v = sqrtf(v.uint32_v); break;
+		default: assert(0);
+	}
+	return v;
+}
+
+int cnt_greeting = 0;
+
+InkValue greeting(int argc, const InkValue argv[])
+{
+	cnt_greeting += 1;
+	assert(argc == 0);
+	InkValue v;
+	v.type     = ValueTypeString;
+	v.string_v = "Hohooh";
+	return v;
+}
+
+int main(int argc, const char* argv[])
+{
+	HInkStory*  story  = ink_story_from_file(INK_TEST_RESOURCE_DIR "FallBack.bin");
+	HInkRunner* runner = ink_story_new_runner(story, NULL);
+	ink_runner_bind(runner, "greeting", greeting, 0);
+	ink_runner_bind(runner, "sqrt", my_sqrt, 0);
+
+	const char* res = ink_runner_get_line(runner);
+	assert(strcmp(res, "Hohooh ! A small demonstration of my power:\n") == 0);
+	assert(ink_runner_can_continue(runner));
+
+	assert(strcmp(ink_runner_get_line(runner), "Math 4 * 4 = 16, stunning i would say\n") == 0);
+	assert(ink_runner_can_continue(runner) == 0);
+
+	assert(cnt_my_sqrt == 2);
+	assert(cnt_greeting == 1);
+	return 0;
+}

data/ext/inkcpp_rb/inkcpp/inkcpp_c/tests/Globals.c

@@ -0,0 +1,98 @@
+#include <string.h>
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <inkcpp.h>
+
+#undef NDEBUG
+#include <assert.h>
+
+HInkStory*   story  = NULL;
+HInkGlobals* store  = NULL;
+HInkRunner*  thread = NULL;
+
+void setup()
+{
+	if (! story) {
+		story = ink_story_from_file(INK_TEST_RESOURCE_DIR "GlobalStory.bin");
+	}
+	if (store) {
+		ink_globals_delete(store);
+	}
+	store = ink_story_new_globals(story);
+	if (thread) {
+		ink_runner_delete(thread);
+	}
+	thread = ink_story_new_runner(story, store);
+}
+
+int main()
+{
+	//====== Just reading Globals =====
+	setup();
+
+	// check story
+	assert(
+	    strcmp(
+	        ink_runner_get_line(thread),
+	        "My name is Jean Passepartout, but my friend's call me Jackie. I'm 23 years old.\n"
+	    )
+	    == 0
+	);
+	assert(strcmp(ink_runner_get_line(thread), "Foo:23\n") == 0);
+
+	// check values in store
+	InkValue val = ink_globals_get(store, "age");
+	assert(val.type == ValueTypeInt32 && val.int32_v == 23);
+	val = ink_globals_get(store, "friendly_name_of_player");
+	assert(val.type == ValueTypeString && strcmp(val.string_v, "Jackie") == 0);
+
+
+	//===== Modifing Globals =====
+	setup();
+
+	// set value of 'age'
+	val.type    = ValueTypeInt32;
+	val.int32_v = 30;
+	assert(ink_globals_set(store, "age", val));
+
+	// set value of 'friendl_name_of_player'
+	val.type     = ValueTypeString;
+	val.string_v = "Freddy";
+	assert(ink_globals_set(store, "friendly_name_of_player", val));
+
+
+	// check story output
+	assert(
+	    strcmp(
+	        ink_runner_get_line(thread),
+	        "My name is Jean Passepartout, but my friend's call me Freddy. I'm 30 years old.\n"
+	    )
+	    == 0
+	);
+	assert(strcmp(ink_runner_get_line(thread), "Foo:30\n") == 0);
+
+	// check variable content
+	val = ink_globals_get(store, "age");
+	assert(val.type == ValueTypeInt32 && val.int32_v == 30);
+	val = ink_globals_get(store, "friendly_name_of_player");
+	assert(val.type == ValueTypeString && strcmp(val.string_v, "Freddy") == 0);
+	val = ink_globals_get(store, "concat");
+	assert(val.type == ValueTypeString && strcmp(val.string_v, "Foo:30") == 0);
+
+	//===== Fail to set variables with invalid types or non existing variables =====
+	setup();
+	val = ink_globals_get(store, "foo");
+	assert(val.type == ValueTypeNone);
+	// not existing variable
+	val.type     = ValueTypeString;
+	val.string_v = "o";
+	assert(! ink_globals_set(store, "foo", val));
+	val.type     = ValueTypeString;
+	val.string_v = "o";
+	// wrong type
+	assert(! ink_globals_set(store, "age", val));
+
+	return 0;
+}

data/ext/inkcpp_rb/inkcpp/inkcpp_c/tests/Lists.c

@@ -0,0 +1,73 @@
+#include <string.h>
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <inkcpp.h>
+
+#undef NDEBUG
+#include <assert.h>
+
+int main()
+{
+	HInkStory*   story  = ink_story_from_file(INK_TEST_RESOURCE_DIR "ListStory.bin");
+	HInkGlobals* store  = ink_story_new_globals(story);
+	HInkRunner*  runner = ink_story_new_runner(story, store);
+
+	InkValue val = ink_globals_get(store, "list");
+	assert(val.type == ValueTypeList);
+	HInkList* list = val.list_v;
+
+	InkListIter iter;
+
+	// iterate through all flags
+	{
+		int hits[3] = {0};
+		if (ink_list_flags(list, &iter)) {
+			do {
+				if (strcmp(iter.flag_name, "bird") == 0 && strcmp(iter.list_name, "animals") == 0) {
+					hits[0] = 1;
+				} else if (strcmp(iter.flag_name, "red") == 0 && strcmp(iter.list_name, "colors") == 0) {
+					hits[1] = 1;
+				} else if (strcmp(iter.flag_name, "yellow") == 0 && strcmp(iter.list_name, "colors") == 0) {
+					hits[2] = 1;
+				} else {
+					assert(0);
+				}
+			} while (ink_list_iter_next(&iter));
+			assert(hits[0] && hits[1] && hits[2]);
+		}
+	}
+	// through all animals in list
+	{
+		int hits[2] = {0};
+		if (ink_list_flags_from(list, "colors", &iter)) {
+			do {
+				if (strcmp(iter.flag_name, "red") == 0 && strcmp(iter.list_name, "colors") == 0) {
+					hits[0] = 1;
+				} else if (strcmp(iter.flag_name, "yellow") == 0 && strcmp(iter.list_name, "colors") == 0) {
+					hits[1] = 1;
+				} else {
+					assert(0);
+				}
+			} while (ink_list_iter_next(&iter));
+		}
+		assert(hits[0] && hits[1]);
+	}
+
+	assert(ink_list_contains(list, "yellow"));
+	assert(ink_list_contains(list, "white") == 0);
+
+	ink_list_add(list, "white");
+	ink_list_remove(list, "yellow");
+	assert(ink_list_contains(list, "yellow") == 0);
+	assert(ink_list_contains(list, "white"));
+
+	assert(ink_globals_set(store, "list", val));
+
+	assert(strcmp(ink_runner_get_line(runner), "cat, snake\n") == 0);
+	assert(ink_runner_num_choices(runner) == 2);
+	const HInkChoice* choice = ink_runner_get_choice(runner, 0);
+	assert(strcmp(ink_choice_text(choice), "list: bird, white, red") == 0);
+	return 0;
+}

data/ext/inkcpp_rb/inkcpp/inkcpp_c/tests/Observer.c

@@ -0,0 +1,36 @@
+#include <string.h>
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <inkcpp.h>
+
+#undef NDEBUG
+#include <assert.h>
+
+int cnt = 0;
+
+void observer(InkValue new_value, InkValue old_value)
+{
+	if (cnt++ == 0) {
+		assert(new_value.type == ValueTypeInt32 && new_value.int32_v == 1);
+		assert(old_value.type == ValueTypeNone);
+	} else {
+		assert(new_value.type == ValueTypeInt32 && new_value.int32_v == 5);
+		assert(old_value.type == ValueTypeInt32 && old_value.int32_v == 1);
+	}
+}
+
+int main()
+{
+	HInkStory*   story  = ink_story_from_file(INK_TEST_RESOURCE_DIR "ObserverStory.bin");
+	HInkGlobals* store  = ink_story_new_globals(story);
+	HInkRunner*  thread = ink_story_new_runner(story, store);
+
+	ink_globals_observe(store, "var1", observer);
+
+	assert(strcmp(ink_runner_get_line(thread), "hello line 1 1 hello line 2 5 test line 3 5\n") == 0);
+	assert(cnt == 2);
+
+	return 0;
+}

data/ext/inkcpp_rb/inkcpp/inkcpp_c/tests/Snapshot.c

@@ -0,0 +1,65 @@
+#include <string.h>
+#include <math.h>
+#include <stdlib.h>
+#include <stdio.h>
+
+#include <inkcpp.h>
+
+#undef NDEBUG
+#include <assert.h>
+
+void check_end(HInkRunner* runner)
+{
+	assert(ink_runner_num_choices(runner) == 3);
+	ink_runner_choose(runner, 2);
+	while (ink_runner_can_continue(runner)) {
+		ink_runner_get_line(runner);
+	}
+	assert(ink_runner_num_choices(runner) == 2);
+}
+
+int main()
+{
+	HInkStory*  story  = ink_story_from_file(INK_TEST_RESOURCE_DIR "SimpleStoryFlow.bin");
+	HInkRunner* runner = ink_story_new_runner(story, NULL);
+
+	ink_runner_get_line(runner);
+	assert(ink_runner_num_choices(runner) == 3);
+	ink_runner_choose(runner, 2);
+
+	// snapshot after choose -> snapshot will print text after loading
+	HInkSnapshot* snap1 = ink_runner_create_snapshot(runner);
+
+	int cnt = 0;
+	while (ink_runner_can_continue(runner)) {
+		ink_runner_get_line(runner);
+		++cnt;
+	}
+
+	// snapshot befroe choose, context (last output lines) can not bet optained at loading
+	HInkSnapshot* snap2 = ink_runner_create_snapshot(runner);
+
+	check_end(runner);
+
+
+	ink_runner_delete(runner);
+	runner = ink_story_new_runner_from_snapshot(story, snap1, NULL, 0);
+
+	// same amount at output then before
+	while (ink_runner_can_continue(runner)) {
+		ink_runner_get_line(runner);
+		--cnt;
+	}
+	assert(cnt == 0);
+
+	check_end(runner);
+
+
+	ink_runner_delete(runner);
+	runner = ink_story_new_runner_from_snapshot(story, snap2, NULL, 0);
+
+	assert(ink_runner_can_continue(runner) == 0);
+	check_end(runner);
+
+	return 0;
+}