diff --git a/.gitignore b/.gitignore
index fe6e067a08..f1a58f605a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -30,6 +30,7 @@ __pycache__
 /.bin
 /build
 /deps
+/.ccls-cache
 
 # root dir run script
 /run
@@ -56,7 +57,7 @@ perf.data*
 .gdb_history
 
 # code search
-/.agignore
+/.ignore
 /.globalrc
 /GPATH
 /GRTAGS
diff --git a/CMakeLists.txt b/CMakeLists.txt
index 1238df25e8..84f943a75b 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -45,6 +45,7 @@ set(CYTHON_MIN_VERSION 0.25)
 
 # CMake policies
 foreach(pol
+        CMP0074  # use <pkg>_ROOT vars in find_package()
         CMP0067  # honor language standard in try_compile()
         CMP0071  # enable automoc for generated files
         CMP0072  # prefers GLVND by default FindOpenGL
diff --git a/assets/nyan/pong.nyan b/assets/nyan/pong.nyan
new file mode 100644
index 0000000000..e2a0f1dc7a
--- /dev/null
+++ b/assets/nyan/pong.nyan
@@ -0,0 +1,30 @@
+PongGame():
+    ball : Ball
+    player1 : Player
+    player2 : Player
+
+Ball():
+    Color():
+        r : int = 0
+        g : int = 200
+        b : int = 0
+    color : Color = Color
+
+Player():
+    lifes : int = 3
+    size : int = 200
+
+GameTest(PongGame):
+    ball = Ball
+    player1 = Player
+    player2 = Player
+
+LeftColor<Ball.Color>():
+    r = 0
+    g = 20
+    b = 230
+
+RightColor<Ball.Color>():
+    r = 180
+    g = 40
+    b = 0
diff --git a/buildsystem/codecompliance/headerguards.py b/buildsystem/codecompliance/headerguards.py
index c35090ed83..30427d3f65 100644
--- a/buildsystem/codecompliance/headerguards.py
+++ b/buildsystem/codecompliance/headerguards.py
@@ -1,4 +1,4 @@
-# Copyright 2014-2020 the openage authors. See copying.md for legal info.
+# Copyright 2014-2021 the openage authors. See copying.md for legal info.
 
 """
 Verifies the guard macros of all C++ header files.
@@ -45,7 +45,7 @@ def find_issues(dirname):
 
             match = GUARD_RE.match(data)
             if not match:
-                raise HeaderIssue("No valid header guard found")
+                raise HeaderIssue("No valid header guard found (e.g. #pragma once)")
 
         except HeaderIssue as exc:
             yield (f"header guard issue in {fname}", exc.args[0], None)
diff --git a/buildsystem/pxdgen.py b/buildsystem/pxdgen.py
index 68dc981c67..70d3cfaded 100644
--- a/buildsystem/pxdgen.py
+++ b/buildsystem/pxdgen.py
@@ -1,4 +1,4 @@
-# Copyright 2015-2020 the openage authors. See copying.md for legal info.
+# Copyright 2015-2021 the openage authors. See copying.md for legal info.
 
 """
 Auto-generates PXD files from annotated C++ headers.
@@ -334,7 +334,7 @@ def postprocess_annotation_line(self, annotation):
         Post-processes each individual annotation line, applying hacks and
         testing it, etc.
 
-        See openage/pyinterface/hacks.h for documentation on the individual
+        See libopenage/pyinterface/hacks.h for documentation on the individual
         hacks.
         """
         annotation = annotation.rstrip()
@@ -383,7 +383,7 @@ def generate(self, pxdfile, ignore_timestamps=False, print_warnings=True):
             outfile.write(result)
 
         if print_warnings and self.warnings:
-            print("\x1b[33;1mWARNING\x1b[m pxdgen[" + self.filename + "]:")
+            print("\x1b[33;1mWARNING\x1b[m pxdgen[%s]:" % self.filename)
             for warning in self.warnings:
                 print(warning)
 
diff --git a/configure b/configure
index a0e6c0341a..d3f2ff520a 100755
--- a/configure
+++ b/configure
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 
-# Copyright 2013-2020 the openage authors. See copying.md for legal info.
+# Copyright 2013-2021 the openage authors. See copying.md for legal info.
 
 """
 openage autocancer-like cmake frontend.
@@ -290,7 +290,6 @@ def invoke_cmake(args, bindir, defines, options):
 
         invocation.append(raw_cmake_arg)
 
-    invocation.append('--')
     invocation.append(project_root)
 
     # look for traces of an in-source build
diff --git a/etc/valgrind-python.supp b/etc/valgrind-python.supp
index 392c1a9061..c723f91da4 100644
--- a/etc/valgrind-python.supp
+++ b/etc/valgrind-python.supp
@@ -1,39 +1,49 @@
 #
-# This is a valgrind suppression file that should be used
-# when running Python with valgrind.
+# This is a valgrind suppression file that should be used when using valgrind.
+#
+# It was taken from the cpython project and adapted for openage.
+# Upstream URL is: https://raw.githubusercontent.com/python/cpython/master/Misc/valgrind-python.supp
+#
 #
 #  Here's an example of running valgrind:
 #
-#	cd python/dist/src
-#	valgrind --tool=memcheck --suppressions=Misc/valgrind-python.supp \
+#	cd openage/bin/
+#	PYTHONMALLOC=malloc valgrind --tool=memcheck --suppressions=../etc/valgrind-python.supp \
 #		python3 -m openage test -a
 #
-# python can be compiled with --with-valgrind to enhance the experience
+# Python can be compiled with --with-valgrind to enhance the valgrind experience:
+# valgrind presence is detected and python memory is allocated more valgrind-friendly then.
+#
 # Python 3.6 supports PYTHONMALLOC=malloc environment var to force malloc()
-
+#
+# Disable the suppressions for _PyObject_Free and _PyObject_Realloc below by comment
+# if valgrind shall complain about python memory leaks.
+#
+# See cpython/Misc/README.valgrind for more information
+#
 # all tool names: Addrcheck,Memcheck,cachegrind,helgrind,massif
 {
    ADDRESS_IN_RANGE/Invalid read of size 4
    Memcheck:Addr4
-   fun:Py_ADDRESS_IN_RANGE
+   fun:address_in_range
 }
 
 {
    ADDRESS_IN_RANGE/Invalid read of size 4
    Memcheck:Value4
-   fun:Py_ADDRESS_IN_RANGE
+   fun:address_in_range
 }
 
 {
    ADDRESS_IN_RANGE/Invalid read of size 8 (x86_64 aka amd64)
    Memcheck:Value8
-   fun:Py_ADDRESS_IN_RANGE
+   fun:address_in_range
 }
 
 {
    ADDRESS_IN_RANGE/Conditional jump or move depends on uninitialised value
    Memcheck:Cond
-   fun:Py_ADDRESS_IN_RANGE
+   fun:address_in_range
 }
 
 #
@@ -123,61 +133,61 @@
 {
    ADDRESS_IN_RANGE/Invalid read of size 4
    Memcheck:Addr4
-   fun:PyObject_Free
+   fun:_PyObject_Free
 }
 
 {
    ADDRESS_IN_RANGE/Invalid read of size 4
    Memcheck:Value4
-   fun:PyObject_Free
+   fun:_PyObject_Free
 }
 
 {
    ADDRESS_IN_RANGE/Use of uninitialised value of size 8
    Memcheck:Addr8
-   fun:PyObject_Free
+   fun:_PyObject_Free
 }
 
 {
    ADDRESS_IN_RANGE/Use of uninitialised value of size 8
    Memcheck:Value8
-   fun:PyObject_Free
+   fun:_PyObject_Free
 }
 
 {
    ADDRESS_IN_RANGE/Conditional jump or move depends on uninitialised value
    Memcheck:Cond
-   fun:PyObject_Free
+   fun:_PyObject_Free
 }
 
 {
    ADDRESS_IN_RANGE/Invalid read of size 4
    Memcheck:Addr4
-   fun:PyObject_Realloc
+   fun:_PyObject_Realloc
 }
 
 {
    ADDRESS_IN_RANGE/Invalid read of size 4
    Memcheck:Value4
-   fun:PyObject_Realloc
+   fun:_PyObject_Realloc
 }
 
 {
    ADDRESS_IN_RANGE/Use of uninitialised value of size 8
    Memcheck:Addr8
-   fun:PyObject_Realloc
+   fun:_PyObject_Realloc
 }
 
 {
    ADDRESS_IN_RANGE/Use of uninitialised value of size 8
    Memcheck:Value8
-   fun:PyObject_Realloc
+   fun:_PyObject_Realloc
 }
 
 {
    ADDRESS_IN_RANGE/Conditional jump or move depends on uninitialised value
    Memcheck:Cond
-   fun:PyObject_Realloc
+   fun:_PyObject_Realloc
 }
 
 ###
diff --git a/libopenage/CMakeLists.txt b/libopenage/CMakeLists.txt
index c99c0506af..40cf7ad403 100644
--- a/libopenage/CMakeLists.txt
+++ b/libopenage/CMakeLists.txt
@@ -190,12 +190,13 @@ endif()
 # ncurses support
 if(WANT_NCURSES)
 	set(CURSES_NEED_NCURSES TRUE)
+	set(CURSES_NEED_WIDE TRUE)
 	find_package(Curses)
 endif()
 
 if(WANT_NCURSES AND CURSES_FOUND)
 	have_config_option(ncurses NCURSES true)
-	target_include_directories(libopenage PRIVATE ${Curses_INCLUDE_DIRS})
+	target_include_directories(libopenage PRIVATE ${CURSES_INCLUDE_DIRS})
 	target_link_libraries(libopenage PRIVATE ${CURSES_LIBRARIES})
 else()
 	have_config_option(ncurses NCURSES false)
@@ -235,6 +236,8 @@ get_config_option_string()
 
 configure_file(config.h.in config.h)
 configure_file(config.cpp.in config.cpp)
+configure_file(version.h.in version.h)
+configure_file(version.cpp.in version.cpp)
 
 configure_file(
 	"${CMAKE_SOURCE_DIR}/openage/config.py.in"
@@ -325,6 +328,7 @@ add_sources(libopenage
 	screenshot.cpp
 	texture.cpp
 	${CMAKE_CURRENT_BINARY_DIR}/config.cpp
+	${CMAKE_CURRENT_BINARY_DIR}/version.cpp
 	${CODEGEN_SCU_FILE}
 )
 
@@ -340,19 +344,21 @@ add_subdirectory("coord")
 add_subdirectory("curve")
 add_subdirectory("cvar")
 add_subdirectory("datastructure")
-add_subdirectory("event")
-add_subdirectory("gui")
 add_subdirectory("error")
+add_subdirectory("event")
 add_subdirectory("gamestate")
+add_subdirectory("gui")
 add_subdirectory("input")
-add_subdirectory("log")
 add_subdirectory("job")
+add_subdirectory("log")
+add_subdirectory("main")
 add_subdirectory("pathfinding")
+add_subdirectory("presenter")
 add_subdirectory("pyinterface")
 add_subdirectory("renderer")
 add_subdirectory("rng")
-add_subdirectory("simulation")
 add_subdirectory("shader")
+add_subdirectory("simulation")
 add_subdirectory("terrain")
 add_subdirectory("testing")
 add_subdirectory("unit")
diff --git a/libopenage/curve/CMakeLists.txt b/libopenage/curve/CMakeLists.txt
index fd797510ab..5a74be80e7 100644
--- a/libopenage/curve/CMakeLists.txt
+++ b/libopenage/curve/CMakeLists.txt
@@ -1,14 +1,17 @@
 add_sources(libopenage
+	base_curve.cpp
 	continuous.cpp
 	curve.cpp
 	discrete.cpp
+	interpolated.cpp
 	iterator.cpp
+	keyframe.cpp
 	keyframe_container.cpp
 	map.cpp
 	map_filter_iterator.cpp
 	queue.cpp
 	queue_filter_iterator.cpp
-	value_container.cpp
+	segmented.cpp
 )
 
 add_subdirectory("tests")
diff --git a/libopenage/curve/base_curve.cpp b/libopenage/curve/base_curve.cpp
new file mode 100644
index 0000000000..4fd47917cc
--- /dev/null
+++ b/libopenage/curve/base_curve.cpp
@@ -0,0 +1,7 @@
+// Copyright 2017-2019 the openage authors. See copying.md for legal info.
+
+#include "base_curve.h"
+
+namespace openage::curve {
+
+} // openage::curve
diff --git a/libopenage/curve/base_curve.h b/libopenage/curve/base_curve.h
new file mode 100644
index 0000000000..e1d7b0d289
--- /dev/null
+++ b/libopenage/curve/base_curve.h
@@ -0,0 +1,193 @@
+// Copyright 2017-2019 the openage authors. See copying.md for legal info.
+
+#pragma once
+
+#include <sstream>
+
+#include "keyframe_container.h"
+#include "../event/evententity.h"
+#include "../event/loop.h"
+
+
+namespace openage::curve {
+
+template<typename T>
+class BaseCurve : public event::EventEntity {
+public:
+	BaseCurve(const std::shared_ptr<event::Loop> &loop,
+	          size_t id,
+	          const std::string &idstr="",
+	          const EventEntity::single_change_notifier &notifier=nullptr)
+		:
+		EventEntity(loop, notifier),
+		_id{id},
+		_idstr{idstr},
+		loop{loop},
+		last_element{this->container.begin()} {}
+
+	virtual ~BaseCurve() = default;
+
+	virtual T get(const time_t &t) const = 0;
+
+	virtual T operator ()(const time_t &now) {
+		return get(now);
+	}
+
+	virtual std::pair<time_t, const T &> frame(const time_t &) const;
+	virtual std::pair<time_t, const T &> next_frame(const time_t &) const;
+
+	/**
+	 * Insert/overwrite given value at given time and erase all elements
+	 * that follow at a later time.
+	 * If multiple elements exist at the given time,
+	 * overwrite the last one.
+	 */
+	virtual void set_last(const time_t &at, const T &value);
+
+	/**
+	 * Insert a value at the given time.
+	 * If there already is a value at this time,
+	 * the value is inserted directly after the existing one.
+	 */
+	virtual void set_insert(const time_t &at, const T &value);
+
+	/**
+	 * Insert a value at the given time.
+	 * If there already is a value at this time,
+	 * the given value will replace the first value with the same time.
+	 */
+	virtual void set_replace(const time_t &at, const T &value);
+
+	/**
+	 * Remove all values that have the given time.
+	 */
+	virtual void erase(const time_t &at);
+
+	/**
+	 * Integrity check, for debugging/testing reasons only.
+	 */
+	void check_integrity() const;
+
+	size_t id() const override {
+		return this->_id;
+	}
+
+	std::string idstr() const override {
+		if (this->_idstr.size() == 0) {
+			return std::to_string(this->id());
+		}
+		return this->_idstr;
+	}
+
+	/**
+	 * Get a string representation of the curve.
+	 */
+	std::string str() const;
+
+protected:
+	/**
+	 * Stores all the keyframes
+	 */
+	KeyframeContainer<T> container;
+
+	/**
+	 * Identifier for the container
+	 */
+	const size_t _id;
+
+	/**
+	 * Human-readable identifier for the container
+	 */
+	const std::string _idstr;
+
+	/**
+	 * The eventloop this curve was registered to
+	 */
+	const std::shared_ptr<event::Loop> loop;
+
+	/**
+	 * Cache the iterator for quickly finding the end
+	 */
+	mutable typename KeyframeContainer<T>::iterator last_element;
+};
+
+
+template <typename T>
+void BaseCurve<T>::set_last(const time_t &at, const T &value) {
+	auto hint = this->container.last(at, this->last_element);
+
+	// erase max one same-time value
+	if (hint->time == at) {
+		hint--;
+	}
+
+	hint = this->container.erase_after(hint);
+
+	this->container.insert_before(at, value, hint);
+	this->last_element = hint;
+
+	this->changes(at);
+}
+
+
+template <typename T>
+void BaseCurve<T>::set_insert(const time_t &at, const T &value) {
+	this->container.insert_after(at, value, this->last_element);
+	// TODO: check if this is now the last element, then remember it
+	this->changes(at);
+}
+
+
+template <typename T>
+void BaseCurve<T>::set_replace(const time_t &at, const T &value) {
+	this->container.insert_overwrite(at, value, this->last_element);
+	this->changes(at);
+}
+
+
+template <typename T>
+void BaseCurve<T>::erase(const time_t &at) {
+	this->last_element = this->container.erase(at, this->last_element);
+	this->changes(at);
+}
+
+
+template <typename T>
+std::pair<time_t, const T&> BaseCurve<T>::frame(const time_t &time) const {
+	auto e = this->container.last(time, this->container.end());
+	return std::make_pair(e->time, e->value);
+}
+
+
+template <typename T>
+std::pair<time_t, const T&> BaseCurve<T>::next_frame(const time_t &time) const {
+	auto e = this->container.last(time, this->container.end());
+	e++;
+	return std::make_pair(e->time, e->value);
+}
+
+template <typename T>
+std::string BaseCurve<T>::str() const {
+	std::stringstream ss;
+	ss << "Curve[" << this->idstr() << "]{" << std::endl;
+	for (const auto &keyframe : this->container) {
+		ss << "    " << keyframe.time << ": " << keyframe.value << "," << std::endl;
+	}
+	ss << "}";
+
+	return ss.str();
+}
+
+template <typename T>
+void BaseCurve<T>::check_integrity() const {
+	time_t last_time = std::numeric_limits<time_t>::min();
+	for (const auto &keyframe : this->container) {
+		if (keyframe.time < last_time) {
+			throw Error{ERR << "curve is broken after t=" << last_time << ": " << this->str()};
+		}
+		last_time = keyframe.time;
+	}
+}
+
+
+} // openage::curve
diff --git a/libopenage/curve/continuous.h b/libopenage/curve/continuous.h
index 77aa5dac59..0d32f14629 100644
--- a/libopenage/curve/continuous.h
+++ b/libopenage/curve/continuous.h
@@ -1,63 +1,84 @@
-// Copyright 2017-2018 the openage authors. See copying.md for legal info.
+// Copyright 2017-2019 the openage authors. See copying.md for legal info.
 
 #pragma once
 
 #include <type_traits>
+#include <sstream>
 
-#include "value_container.h"
+#include "interpolated.h"
 #include "../log/log.h"
 
 namespace openage::curve {
 
 
 /**
- * Continuous Datatype.
- * Stores a value container with continuous access.
+ * Continuous linear curve.
+ *
+ * At one point in time, there can be only one value,
+ * thus, there can't be jumps. All values are connected through linear
+ * interpolation.
+ *
  * The bound template type T has to implement `operator+(T)` and
  * `operator*(time_t)`.
  */
 template<typename T>
-class Continuous : public ValueContainer<T> {
+class Continuous : public Interpolated<T> {
 public:
-	using ValueContainer<T>::ValueContainer;
+	using Interpolated<T>::Interpolated;
+
 	/**
-	 * will interpolate between the keyframes linearly based on the time.
+	 * Insert/overwrite given value at given time and erase all elements
+	 * that follow at a later time.
+	 * If multiple elements exist at the given time,
+	 * overwrite all of them.
 	 */
-	T get(const time_t &) const override;
-};
+	void set_last(const time_t &t, const T &value) override;
 
+	/** This just calls set_replace in order to guarantee the continuity. */
+	void set_insert(const time_t &t, const T &value) override;
+
+	/** human readable identifier */
+	std::string idstr() const override;
+};
 
 
 template <typename T>
-T Continuous<T>::get(const time_t &time) const {
-	const auto &e = this->container.last(time, this->last_element);
-	this->last_element = e;
+void Continuous<T>::set_last(const time_t &at, const T &value) {
+	auto hint = this->container.last(at, this->last_element);
 
-	auto nxt = e;
-	++nxt;
+	// erase all same-time entries
+	while (hint->time == at) {
+		hint--;
+	}
 
-	time_t diff_time = 0;
+	hint = this->container.erase_after(hint);
 
-	auto offset = time - e->time;
+	this->container.insert_before(at, value, hint);
+	this->last_element = hint;
 
-	// If we do not have a next (buffer underrun!!) we assign values
-	if (nxt == this->container.end()) {
-		// log::log(WARN << "Continuous buffer underrun. This might be bad! Assuming constant.");
-	} else {
-		diff_time = nxt->time - e->time;
-	}
+	this->changes(at);
+}
 
-	if (nxt == this->container.end() // use the last curve value
-	    || offset == 0               // values equal -> don't need to interpolate
-	    || diff_time == 0) {         // values at the same time -> division-by-zero-error
 
-		return e->value;
-	} else {
-		// Interpolation between time(now) and time(next) that has elapsed
-		double elapsed_frac = offset.to_double() / diff_time.to_double();
+template <typename T>
+void Continuous<T>::set_insert(const time_t &t, const T &value) {
+	this->set_replace(t, value);
+}
+
 
-		return e->value + (nxt->value - e->value) * elapsed_frac;
+template <typename T>
+std::string Continuous<T>::idstr() const {
+	std::stringstream ss;
+	ss << "ContinuousCurve[";
+	if (this->_idstr.size()) {
+		ss << this->_idstr;
+	}
+	else {
+		ss << this->id();
 	}
+	ss << "]";
+	return ss.str();
 }
 
+
 } // openage::curve
diff --git a/libopenage/curve/discrete.h b/libopenage/curve/discrete.h
index 63abf65638..2d95a17b78 100644
--- a/libopenage/curve/discrete.h
+++ b/libopenage/curve/discrete.h
@@ -1,11 +1,12 @@
-// Copyright 2017-2018 the openage authors. See copying.md for legal info.
+// Copyright 2017-2019 the openage authors. See copying.md for legal info.
 
 #pragma once
 
 #include <optional>
 #include <utility>
+#include <sstream>
 
-#include "value_container.h"
+#include "base_curve.h"
 
 
 namespace openage::curve {
@@ -15,13 +16,13 @@ namespace openage::curve {
  * implement `operator=` and copy ctor.
  */
 template<typename T>
-class Discrete : public ValueContainer<T> {
+class Discrete : public BaseCurve<T> {
 	static_assert(std::is_copy_assignable<T>::value,
 	              "Template type is not copy assignable");
 	static_assert(std::is_copy_constructible<T>::value,
 	              "Template type is not copy constructible");
 public:
-	using ValueContainer<T>::ValueContainer;
+	using BaseCurve<T>::BaseCurve;
 
 	/**
 	 * Does not interpolate anything,
@@ -29,6 +30,9 @@ class Discrete : public ValueContainer<T> {
 	 */
 	T get(const time_t &t) const override;
 
+	/** human readable id string */
+	std::string idstr() const override;
+
 	/**
 	 * Return the last time and keyframe with time <= t.
 	 */
@@ -49,6 +53,21 @@ T Discrete<T>::get(const time_t &time) const {
 }
 
 
+template <typename T>
+std::string Discrete<T>::idstr() const {
+	std::stringstream ss;
+	ss << "DiscreteCurve[";
+	if (this->_idstr.size()) {
+		ss << this->_idstr;
+	}
+	else {
+		ss << this->id();
+	}
+	ss << "]";
+	return ss.str();
+}
+
+
 template <typename T>
 std::pair<time_t, T> Discrete<T>::get_time(const time_t &time) const {
 	auto e = this->container.last(time, this->last_element);
diff --git a/libopenage/curve/interpolated.cpp b/libopenage/curve/interpolated.cpp
new file mode 100644
index 0000000000..e1dc1fccbc
--- /dev/null
+++ b/libopenage/curve/interpolated.cpp
@@ -0,0 +1,3 @@
+// Copyright 2019-2019 the openage authors. See copying.md for legal info.
+
+#include "interpolated.h"
diff --git a/libopenage/curve/interpolated.h b/libopenage/curve/interpolated.h
new file mode 100644
index 0000000000..0a6ef9b45f
--- /dev/null
+++ b/libopenage/curve/interpolated.h
@@ -0,0 +1,76 @@
+// Copyright 2019-2019 the openage authors. See copying.md for legal info.
+
+#pragma once
+
+#include <type_traits>
+
+#include "base_curve.h"
+#include "../log/log.h"
+
+namespace openage::curve {
+
+/**
+ * Interpolation base class.
+ *
+ * Extends the value container to support interpolation between values.
+ *
+ * The bound template type T has to implement `operator +(T)` and
+ * `operator *(time_t)`.
+ */
+template<typename T>
+class Interpolated : public BaseCurve<T> {
+public:
+	using BaseCurve<T>::BaseCurve;
+
+	/**
+	 * Will interpolate between the keyframes linearly based on the time.
+	 * Picks two adjacent keyframes for interpolation.
+	 * Uses the leftmost element of the right keyframe group with same times
+	 * and the rightmost element of the left keyframe group with same times.
+	 * A curve of [0:0, 1:5, 1:10, 2:20] evaluated at t=0.5 is 2.5, t=1 is 10,
+	 * at t=1.5 is 15.
+	 *
+	 * example for a <= t <= b:
+	 * val([a:x, b:y], t) = x + (y - x)/(b - a) * (t - a)
+	 */
+
+	T get(const time_t &) const override;
+};
+
+
+
+template <typename T>
+T Interpolated<T>::get(const time_t &time) const {
+	const auto &e = this->container.last(time, this->last_element);
+	this->last_element = e;
+
+	auto nxt = e;
+	++nxt;
+
+	time_t interval = 0;
+
+	auto offset = time - e->time;
+
+	if (nxt != this->container.end()) {
+		interval = nxt->time - e->time;
+	}
+
+	// here, offset > interval will never hold.
+	// otherwise the underlying storage is broken.
+
+	// If the next element is at the same time, just return the value of this one.
+	if (nxt == this->container.end() // use the last curve value
+	    || offset == 0               // values equal -> don't need to interpolate
+	    || interval == 0) {          // values at the same time -> division-by-zero-error
+
+		return e->value;
+	}
+	else {
+		// Interpolation between time(now) and time(next) that has elapsed
+		double elapsed_frac = offset.to_double() / interval.to_double();
+		return e->value + (nxt->value - e->value) * elapsed_frac;
+	}
+}
+
+
+} // openage::curve
diff --git a/libopenage/curve/keyframe.cpp b/libopenage/curve/keyframe.cpp
new file mode 100644
index 0000000000..c497e7d869
--- /dev/null
+++ b/libopenage/curve/keyframe.cpp
@@ -0,0 +1,3 @@
+// Copyright 2019-2019 the openage authors. See copying.md for legal info.
+
+#include "keyframe.h"
diff --git a/libopenage/curve/keyframe.h b/libopenage/curve/keyframe.h
new file mode 100644
index 0000000000..a0fc39d1e6
--- /dev/null
+++ b/libopenage/curve/keyframe.h
@@ -0,0 +1,40 @@
+// Copyright 2019-2019 the openage authors. See copying.md for legal info.
+
+#pragma once
+
+#include <limits>
+
+#include "curve.h"
+
+namespace openage::curve {
+
+/**
+ * A element of the curvecontainer. This is especially used to keep track of
+ * the value-timing.
+ */
+template <typename T>
+class Keyframe {
+public:
+	/**
+	 * New default object at numericlimits<time>::min.
+	 */
+	Keyframe() {}
+
+	/**
+	 * New, default-constructed element at the given time
+	 */
+	Keyframe(const time_t &time) :
+		time{time} {}
+
+	/**
+	 * New element fron time and value
+	 */
+	Keyframe(const time_t &time, const T &value) :
+		time{time},
+		value{value} {}
+
+	const time_t time = std::numeric_limits<time_t>::min();
+	T value = T{};
+};
+
+} // openage::curve
diff --git a/libopenage/curve/keyframe_container.h b/libopenage/curve/keyframe_container.h
index 9aed77717b..7df7433907 100644
--- a/libopenage/curve/keyframe_container.h
+++ b/libopenage/curve/keyframe_container.h
@@ -1,4 +1,4 @@
-// Copyright 2017-2018 the openage authors. See copying.md for legal info.
+// Copyright 2017-2019 the openage authors. See copying.md for legal info.
 
 #pragma once
 
@@ -7,8 +7,9 @@
 #include <list>
 
 #include "curve.h"
-#include "../event/loop.h"
+#include "keyframe.h"
 #include "../error/error.h"
+#include "../util/compiler.h"
 
 namespace openage::curve {
 
@@ -28,29 +29,7 @@ class KeyframeContainer {
 	 * A element of the curvecontainer. This is especially used to keep track of
 	 * the value-timing.
 	 */
-	class Keyframe {
-	public:
-		/**
-		 * New default object at numericlimits<time>::min.
-		 */
-		Keyframe() {}
-
-		/**
-		 * New, default-constructed element at the given time
-		 */
-		Keyframe(const time_t &time) :
-			time{time} {}
-
-		/**
-		 * New element fron time and value
-		 */
-		Keyframe(const time_t &time, const T &value) :
-			time{time},
-			value{value} {}
-
-		const time_t time = std::numeric_limits<time_t>::min();
-		T value = T();
-	};
+	using keyframe_t = Keyframe<T>;
 
 	/**
 	 * The underlaying container type.
@@ -58,194 +37,345 @@ class KeyframeContainer {
 	 * The most important property of this container is the iterator validity on
 	 * insert and remove.
 	 */
-	using curvecontainer = std::list<Keyframe>;
+	using container_t = std::list<keyframe_t>;
 
 	/**
 	 * The iterator type to access elements in the container
 	 */
-	using KeyframeIterator = typename curvecontainer::const_iterator;
+	using iterator = typename container_t::const_iterator;
+	using const_iterator = typename container_t::const_iterator;
 
 	/** need the datamanger for change management **/
-	KeyframeContainer(const std::shared_ptr<event::Loop> &loop);
-	~KeyframeContainer();
+	KeyframeContainer();
 
 	/**
-	 * Get the last element with e->time <= time, given a hint where to
-	 * start the search.
+	 * Return the number of elements in this container.
+	 * One element is always added at -Inf by default,
+	 * so this is usually your_added_elements + 1.
 	 */
-	KeyframeIterator last(const time_t &time,
-	                      const KeyframeIterator & hint) const;
+	size_t size() const;
 
 	/**
-	 * Get the last element with e->time <= time, without a hint where to start
+	 * Get the last element in the curve which is before the given time.
+	 * (i.e. elem->time <= time). Given a hint where to start the search.
+	 */
+	iterator last(const time_t &time,
+	              const iterator & hint) const;
+
+	/**
+	 * Get the last element with elem->time <= time, without a hint where to start
 	 * searching.
 	 *
 	 * The usage of this method is discouraged - except if there is absolutely
 	 * no chance for you to have a hint (or the container is known to be nearly
 	 * empty)
 	 */
-	KeyframeIterator last(const time_t &time) const {
-		return this->last(time, this->container.begin());
+	iterator last(const time_t &time) const {
+		return this->last(time, std::end(this->container));
 	}
 
-	// TODO: add something like `previous` that returns element with e->time < time
-	//       probably just calls `last` and walks back one element
-	//       if that is not at begin() already
-
 	/**
 	 * Insert a new element without a hint.
 	 *
+	 * Starts the search for insertion at the end of the data.
 	 * This function is not recommended for use, whenever possible, keep a hint
 	 * to insert the data.
 	 */
-	KeyframeIterator insert(const Keyframe &value) {
-		return this->insert(value, this->container.begin());
+	iterator insert_before(const keyframe_t &value) {
+		return this->insert_before(value, std::end(this->container));
 	}
 
 	/**
 	 * Insert a new element. The hint shall give an approximate location, where
 	 * the inserter will start to look for a insertion point. If a good hint is
 	 * given, the runtime of this function will not be affected by the current
-	 * history size.
+	 * history size. If there is a keyframe with identical time, this will
+	 * insert the new keyframe before the old one.
 	 */
-	KeyframeIterator insert(const Keyframe &value, const KeyframeIterator &hint);
+	iterator insert_before(const keyframe_t &value, const iterator &hint);
 
 	/**
-	 * Create and insert a new element without submitting a hint.
-	 * The use of this function is discouraged, use it only, if your really do not
-	 * have the possibility to get a hint
+	 * Create and insert a new element without submitting a hint. The search is
+	 * started from the end of the data. The use of this function is
+	 * discouraged, use it only, if your really do not have the possibility to
+	 * get a hint.
 	 */
-	KeyframeIterator insert(const time_t &time, const T &value) {
-		return this->insert(Keyframe(time, value), this->container.begin());
+	iterator insert_before(const time_t &time, const T &value) {
+		return this->insert_before(keyframe_t(time, value), std::end(this->container));
 	}
 
 	/**
 	 * Create and insert a new element. The hint gives an approximate location.
+	 * If there is a value with identical time, this will insert the new value
+	 * before the old one.
+	 */
+	iterator insert_before(const time_t &time, const T &value,
+	                       const iterator &hint) {
+		return this->insert_before(keyframe_t(time, value), hint);
+	}
+
+	/**
+	 * Insert a new element, overwriting elements that have a
+	 * time conflict. Give an approximate insertion location to minimize runtime
+	 * on big-history curves.
+	 * `overwrite_all` == true -> overwrite all same-time elements.
+	 * `overwrite_all` == false -> overwrite the last of the time-conflict elements.
+	 */
+	iterator insert_overwrite(const keyframe_t &value,
+	                          const iterator &hint,
+	                          bool overwrite_all=false);
+
+	/**
+	 * Insert a new value at given time which will overwrite the last of the
+	 * elements with the same time. This function will start to search the time
+	 * from the end of the data. The use of this function is discouraged, use it
+	 * only, if your really do not have the possibility to get a hint.
+	 */
+	iterator insert_overwrite(const time_t &time, const T &value) {
+		return this->insert_overwrite(keyframe_t(time, value),
+		                              std::end(this->container));
+	}
+
+	/**
+	 * Insert a new value at given time, which overwrites element(s) with
+	 * identical time. If `overwrite_all` is false, overwrite the last same-time
+	 * element. If `overwrite_all` is true, overwrite all elements with same-time.
+	 * Provide a insertion hint to abbreviate the search for the
+	 * insertion point.
+	 */
+	iterator insert_overwrite(const time_t &time,
+	                          const T &value,
+	                          const iterator &hint,
+	                          bool overwrite_all=false) {
+		return this->insert_overwrite(keyframe_t(time, value), hint, overwrite_all);
+	}
+
+	/**
+	 * Insert a new element, after a previous element when there's a time
+	 * conflict. Give an approximate insertion location to minimize runtime on
+	 * big-history curves.
+	 */
+	iterator insert_after(const keyframe_t &value, const iterator &hint);
+
+	/**
+	 * Insert a new value at given time which will be prepended to the block of
+	 * elements that have the same time. This function will start to search the
+	 * time from the end of the data. The use of this function is discouraged,
+	 * use it only, if your really do not have the possibility to get a hint.
 	 */
-	KeyframeIterator insert(const time_t &time, const T &value, const KeyframeIterator &hint) {
-		return this->insert(Keyframe(time, value), hint);
+	iterator insert_after(const time_t &time, const T &value) {
+		return this->insert_after(keyframe_t(time, value),
+		                          std::end(this->container));
+	}
+
+	/**
+	 * Create and insert a new element, which is added after a previous element with
+	 * identical time. Provide a insertion hint to abbreviate the search for the insertion point.
+	 */
+	iterator insert_after(const time_t &time, const T &value, const iterator &hint) {
+		return this->insert_after(keyframe_t(time, value), hint);
 	}
 
 	/**
 	 * Erase all elements that come after this last valid element.
 	 */
-	KeyframeIterator erase_after(KeyframeIterator last_valid);
+	iterator erase_after(iterator last_valid);
 
 	/**
 	 * Erase a single element from the curve.
+	 * Returns the element after the deleted one.
+	 */
+	iterator erase(iterator it);
+
+	/**
+	 * Erase all elements with given time.
+	 * Variant without hint, starts the search at the end of the container.
+	 * Returns the iterator after the deleted elements.
+	 */
+	iterator erase(const time_t &time) {
+		return this->erase(time, std::end(this->container));
+	}
+
+	/**
+	 * Erase all element with given time.
+	 * `hint` is an iterator pointing hopefully close to the searched
+	 * elements.
+	 *
+	 * Returns the iterator after the deleted elements.
+	 * Or, if no elements with this time exist,
+	 * the iterator to the first element after the requested time is returned
 	 */
-	KeyframeIterator erase(KeyframeIterator it);
+	iterator erase(const time_t &time,
+	               const iterator &hint) {
+		return this->erase_group(time, this->last(time, hint));
+	}
 
 	/**
 	 * Obtain an iterator to the first value with the smallest timestamp.
 	 */
-	KeyframeIterator begin() const {
-		return container.begin();
+	iterator begin() const {
+		return this->container.begin();
 	}
 
 	/**
 	 * Obtain an iterator to the position after the last value.
 	 */
-	KeyframeIterator end() const {
-		return container.end();
+	iterator end() const {
+		return this->container.end();
 	}
 
 	/**
 	 * Debugging method to be used from gdb to understand bugs better.
 	 */
-	void dump() {
-		for (auto e : container) {
+	void dump() const {
+		for (auto &e : container) {
 			std::cout << "Element: time: " << e.time << " v: " << e.value << std::endl;
 		}
 	}
 private:
+
 	/**
-	 * The data store.
+	 * Erase elements with this time.
+	 * The iterator has to point to the last element of the same-time group.
 	 */
-	const std::shared_ptr<event::Loop> loop;
+	iterator erase_group(const time_t &time,
+	                     const iterator &last_elem);
 
-	curvecontainer container;
+	/**
+	 * The data store.
+	 */
+	container_t container;
 };
 
 
 template<typename T>
-KeyframeContainer<T>::KeyframeContainer(const std::shared_ptr<event::Loop> &loop)
-	:
-	loop(loop) {
+KeyframeContainer<T>::KeyframeContainer() {
 
 	// Create a default element at -Inf, that can always be dereferenced - so
 	// there will by definition never be a element that cannot be dereferenced
-	this->container.push_back(Keyframe(std::numeric_limits<time_t>::min(), T()));
+	this->container.push_back(keyframe_t(std::numeric_limits<time_t>::min(), T()));
 }
 
-template<typename T>
-KeyframeContainer<T>::~KeyframeContainer() {
-	// We rely on std::list to destroy all elements.
+
+template <typename T>
+size_t KeyframeContainer<T>::size() const {
+	return this->container.size();
 }
 
-/**
- * Select the element that directly preceedes the given timestamp.
+
+/*
+ * Select the last element that is <= a given time.
+ * If there is multiple elements with the same time, return the last of them.
+ * If there is no element with such time, return the next element before the time.
  *
  * Without a hint, start to iterate at the beginning of the buffer, and return
  * the element last element before e->time > time.
- * This method returns nullptr, if begin->time > time.
+ *
+ * Intuitively, this function returns the element that set the last value
+ * that determines the curve value for a searched time.
  */
 template <typename T>
-typename KeyframeContainer<T>::KeyframeIterator KeyframeContainer<T>::last(const time_t &time,
-                                                                           const KeyframeIterator &hint) const {
-	KeyframeIterator e = (hint == this->container.end()) ? this->container.begin() : hint;
+typename KeyframeContainer<T>::iterator KeyframeContainer<T>::last(const time_t &time,
+                                                                   const iterator &hint) const {
 
-	if (this->container.front().time > time) {
-		// This will never happen due to the container.front->time == -Inf magic!
-		throw Error(ERR << "rupture in spacetime detected, curve container is broken");
-	}
+	iterator e = hint;
+	auto end = std::end(this->container);
 
-	// Search in the queue
-	if (time > e->time) { // the searched element is supposed to be AFTER the hint
-		// perform the search via ->next
-		while (e != this->container.end() && time >= e->time) {
+	if (e != end and e->time <= time) {
+		// walk to the right until the time is larget than the searched
+		// then go one to the left to get the last item with <= requested time
+		while (e != end && e->time <= time) {
 			e++;
 		}
 		e--;
-		// e is now one of two options:
-		// 1. e == end: The last element of the queue was smaller than `time`
-		// 2. e != end: There was a element with `e->time` > `time`
-
-	} else if (time < e->time) {
-		// the searched element is supposed to be BEFORE the hint
-		// perform the search via ->prev
-		while (e != this->container.begin() && time < e->time) {
+	}
+	else { // e == end or e->time > time
+		// walk to the left until the element time is smaller or equal the searched time
+		auto begin = std::begin(this->container);
+		while (e != begin and (e == end or e->time > time)) {
 			e--;
 		}
-		// e is now one of two options:
-		// 1. e == begin: The time was before every element in the queue
-		// 2. e != begin: There was an element with `e->time` > `time`
-
-	} else {
-		// perform <= search - and return e, whose time is == time.
 	}
 
 	return e;
 }
 
-/**
- * Determine where to insert based on time, and insert
+
+/*
+ * Determine where to insert based on time, and insert.
  */
 template <typename T>
-typename KeyframeContainer<T>::KeyframeIterator
-KeyframeContainer<T>::insert(const KeyframeContainer<T>::Keyframe &e,
-                             const KeyframeContainer<T>::KeyframeIterator &hint) {
-	KeyframeIterator at = this->last(e.time, hint);
-	++at;
+typename KeyframeContainer<T>::iterator
+KeyframeContainer<T>::insert_before(const KeyframeContainer<T>::keyframe_t &e,
+                                    const KeyframeContainer<T>::iterator &hint) {
+	iterator at = this->last(e.time, hint);
+	// seek over all same-time elements, so we can insert before the first one
+	while (at != std::begin(this->container) and at->time == e.time) {
+		--at;
+	}
+
+	// the above while-loop overshoots and selects the first non-equal element.
+	// set iterator one to the right, i.e. on the first same-value
+	if (at != std::end(this->container)) {
+		++at;
+	}
 	return this->container.insert(at, e);
 }
 
-/**
+
+/*
+ * Determine where to insert based on time, and insert, overwriting value(s) with same time.
+ */
+template <typename T>
+typename KeyframeContainer<T>::iterator
+KeyframeContainer<T>::insert_overwrite(
+	const KeyframeContainer<T>::keyframe_t &e,
+	const KeyframeContainer<T>::iterator &hint,
+	bool overwrite_all) {
+
+	iterator at = this->last(e.time, hint);
+
+	if (overwrite_all) {
+		at = this->erase_group(e.time, at);
+	}
+	else if (at != std::end(this->container)) {
+		// overwrite the same-time element
+		if (at->time == e.time) {
+			at = this->container.erase(at);
+		}
+		else {
+			++at;
+		}
+	}
+	return this->container.insert(at, e);
+}
+
+
+/*
+ * Determine where to insert based on time, and insert.
+ * If there is a time conflict, insert after the existing element.
+ */
+template <typename T>
+typename KeyframeContainer<T>::iterator
+KeyframeContainer<T>::insert_after(
+	const KeyframeContainer<T>::keyframe_t &e,
+	const KeyframeContainer<T>::iterator &hint) {
+
+	iterator at = this->last(e.time, hint);
+
+	if (at != std::end(this->container)) {
+		++at;
+	}
+	return this->container.insert(at, e);
+}
+
+
+/*
  * Go from the end to the last_valid element, and call erase on all of them
  */
 template <typename T>
-typename KeyframeContainer<T>::KeyframeIterator
-KeyframeContainer<T>::erase_after(KeyframeContainer<T>::KeyframeIterator last_valid) {
+typename KeyframeContainer<T>::iterator
+KeyframeContainer<T>::erase_after(KeyframeContainer<T>::iterator last_valid) {
 
 	// exclude the last_valid element from deletion
 	if (last_valid != this->container.end()) {
@@ -259,13 +389,40 @@ KeyframeContainer<T>::erase_after(KeyframeContainer<T>::KeyframeIterator last_va
 	return last_valid;
 }
 
-/**
+
+/*
  * Delete the element from the list and call delete on it.
  */
 template <typename T>
-typename KeyframeContainer<T>::KeyframeIterator
-KeyframeContainer<T>::erase(KeyframeContainer<T>::KeyframeIterator e) {
+typename KeyframeContainer<T>::iterator
+KeyframeContainer<T>::erase(KeyframeContainer<T>::iterator e) {
 	return this->container.erase(e);
 }
 
+
+template <typename T>
+typename KeyframeContainer<T>::iterator
+KeyframeContainer<T>::erase_group(const time_t &time,
+                                  const iterator &last_elem) {
+
+	iterator at = last_elem;
+
+	// if the time what we're looking for
+	// erase elements until all element with that time are purged
+	while (at != std::end(this->container) and at->time == time) {
+		at = this->container.erase(at);
+		if (likely(at != std::begin(this->container))) {
+			--at;
+		}
+	}
+
+	// we have to cancel one --at in order to return
+	// the element after the group we deleted.
+	if (at != std::end(this->container)) {
+		++at;
+	}
+
+	return at;
+}
+
 } // openage::curve
diff --git a/libopenage/curve/segmented.cpp b/libopenage/curve/segmented.cpp
new file mode 100644
index 0000000000..3431a3dc15
--- /dev/null
+++ b/libopenage/curve/segmented.cpp
@@ -0,0 +1,9 @@
+// Copyright 2019-2021 the openage authors. See copying.md for legal info.
+
+#include "continuous.h"
+
+namespace openage::curve {
+
+// This file is intended to be empty
+
+}  // namespace openage::curve
diff --git a/libopenage/curve/segmented.h b/libopenage/curve/segmented.h
new file mode 100644
index 0000000000..8e6c3dbd0b
--- /dev/null
+++ b/libopenage/curve/segmented.h
@@ -0,0 +1,93 @@
+// Copyright 2019-2019 the openage authors. See copying.md for legal info.
+
+#pragma once
+
+#include <type_traits>
+#include <sstream>
+
+#include "interpolated.h"
+#include "../log/log.h"
+
+namespace openage::curve {
+
+
+/**
+ * Linear curve type.
+ *
+ * Stores linearly interpolated line segments.
+ * In contrast to `curve::Continuous`, it is not continuous and there can be jumps.
+ * At one point in time, there can be multiple values. For interpolations between set values,
+ * the left and rightmost one of a group of values at the same time are evaluated as fix points.
+ *
+ * Use the insertion operators of `ValueContainer`: `set_last`, `set_insert` and `set_replace`.
+ *
+ * The bound template type T has to implement `operator +(T)` and
+ * `operator *(time_t)`.
+ */
+template<typename T>
+class Segmented : public Interpolated<T> {
+public:
+	using Interpolated<T>::Interpolated;
+
+	/**
+	 * Insert/replace a value jump with the left and right values into the curve.
+	 * The right value is used for queries at >= time,
+	 * the left value for queries at < time.
+	 */
+	void set_insert_jump(const time_t &, const T &leftval, const T &rightval);
+
+	/**
+	 * Insert/replace a value jump with given left and right values.
+	 * All following curve keyframes will be deleted, so the
+	 * last two values of the curve will be `leftval` and `rightval`.
+	 */
+	void set_last_jump(const time_t &, const T &leftval, const T &rightval);
+
+	/** human readable identifier */
+	std::string idstr() const override;
+};
+
+
+template <typename T>
+void Segmented<T>::set_insert_jump(const time_t &at, const T &leftval, const T &rightval) {
+	auto hint = this->container.insert_overwrite(at, leftval, this->last_element, true);
+	this->container.insert_after(at, rightval, hint);
+	this->changes(at);
+}
+
+
+template <typename T>
+void Segmented<T>::set_last_jump(const time_t &at, const T &leftval, const T &rightval) {
+	auto hint = this->container.last(at, this->last_element);
+
+	// erase all one same-time values
+	while (hint->time == at) {
+		hint--;
+	}
+
+	hint = this->container.erase_after(hint);
+
+	this->container.insert_before(at, rightval, hint);
+	this->container.insert_before(at, leftval, hint);
+	this->last_element = hint;
+
+	this->changes(at);
+}
+
+
+template <typename T>
+std::string Segmented<T>::idstr() const {
+	std::stringstream ss;
+	ss << "SegmentedCurve[";
+	if (this->_idstr.size()) {
+		ss << this->_idstr;
+	}
+	else {
+		ss << this->id();
+	}
+	ss << "]";
+	return ss.str();
+}
+
+
+} // openage::curve
diff --git a/libopenage/curve/tests/curve_types.cpp b/libopenage/curve/tests/curve_types.cpp
index c2ea4c39a6..87c0fedbc0 100644
--- a/libopenage/curve/tests/curve_types.cpp
+++ b/libopenage/curve/tests/curve_types.cpp
@@ -1,4 +1,4 @@
-// Copyright 2017-2018 the openage authors. See copying.md for legal info.
+// Copyright 2017-2019 the openage authors. See copying.md for legal info.
 
 #include "../../event/loop.h"
 #include "../../log/log.h"
@@ -7,7 +7,9 @@
 #include "../curve.h"
 #include "../discrete.h"
 #include "../keyframe_container.h"
+#include "../segmented.h"
 
+#include "../../util/compiler.h"
 
 namespace openage::curve::tests {
 
@@ -15,41 +17,70 @@ void curve_types() {
 	// Check the base container type
 	{
 		auto loop = std::make_shared<event::Loop>();
-		KeyframeContainer<int> c{loop};
-
-		auto p0 = c.insert(0, 0);
-		auto p1 = c.insert(1, 1);
-		auto p2 = c.insert(10, 2);
+		KeyframeContainer<int> c;
+
+		auto p0 = c.insert_before(0, 0);
+		auto p1 = c.insert_before(1, 1);
+		auto p2 = c.insert_before(10, 2);
+		auto pa = std::begin(c);
+		auto pe = std::end(c);
+
+		// now contains: [-inf: 0, 0:0, 1:1, 10:2]
+
+		TESTEQUALS(c.size(), 4);
+
+		{
+			auto it = c.begin();
+			TESTEQUALS(it->value, 0);
+			TESTEQUALS(it->time, std::numeric_limits<curve::time_t>::min());
+			TESTEQUALS((++it)->time, 0);
+			TESTEQUALS(it->value, 0);
+			TESTEQUALS((++it)->time, 1);
+			TESTEQUALS(it->value, 1);
+			TESTEQUALS((++it)->time, 10);
+			TESTEQUALS(it->value, 2);
+		}
 
 		// last function tests without hints
 		TESTEQUALS(c.last(0)->value, 0);
-		TESTEQUALS(c.last(1)->value, 1); // last shall give >= not only > !
+		TESTEQUALS(c.last(1)->value, 1);
 		TESTEQUALS(c.last(5)->value, 1);
 		TESTEQUALS(c.last(10)->value, 2);
 		TESTEQUALS(c.last(47)->value, 2);
 
-		// last() with hints. Yes this can make a difference. we want to be
-		// absolutely sure!
+		// last() with hints.
+		TESTEQUALS(c.last(0, pa)->value, 0);
+		TESTEQUALS(c.last(1, pa)->value, 1);
+		TESTEQUALS(c.last(5, pa)->value, 1);
+		TESTEQUALS(c.last(10, pa)->value, 2);
+		TESTEQUALS(c.last(47, pa)->value, 2);
+
 		TESTEQUALS(c.last(0, p0)->value, 0);
-		TESTEQUALS(c.last(1, p0)->value, 1); // last shall give >= not only > !
+		TESTEQUALS(c.last(1, p0)->value, 1);
 		TESTEQUALS(c.last(5, p0)->value, 1);
 		TESTEQUALS(c.last(10, p0)->value, 2);
 		TESTEQUALS(c.last(47, p0)->value, 2);
 
 		TESTEQUALS(c.last(0, p1)->value, 0);
-		TESTEQUALS(c.last(1, p1)->value, 1); // last shall give >= not only > !
+		TESTEQUALS(c.last(1, p1)->value, 1);
 		TESTEQUALS(c.last(5, p1)->value, 1);
 		TESTEQUALS(c.last(10, p1)->value, 2);
 		TESTEQUALS(c.last(47, p1)->value, 2);
 
 		TESTEQUALS(c.last(0, p2)->value, 0);
-		TESTEQUALS(c.last(1, p2)->value, 1); // last shall give >= not only > !
+		TESTEQUALS(c.last(1, p2)->value, 1);
 		TESTEQUALS(c.last(5, p2)->value, 1);
 		TESTEQUALS(c.last(10, p2)->value, 2);
 		TESTEQUALS(c.last(47, p2)->value, 2);
 
+		TESTEQUALS(c.last(0, pe)->value, 0);
+		TESTEQUALS(c.last(1, pe)->value, 1);
+		TESTEQUALS(c.last(5, pe)->value, 1);
+		TESTEQUALS(c.last(10, pe)->value, 2);
+		TESTEQUALS(c.last(47, pe)->value, 2);
+
 		// Now test the basic erase() function
-		// Delete the 1-element, new values should be [0, 2]
+		// Delete the 1-element, new values should be [-inf:0, 0:0, 10:2]
 		c.erase(c.last(1));
 
 		TESTEQUALS(c.last(1)->value, 0);
@@ -57,13 +88,79 @@ void curve_types() {
 		TESTEQUALS(c.last(47)->value, 2);
 
 		// should do nothing, since we delete all at > 99,
-		// but the last element is at 10.
+		// but the last element is at 10. should still be [-inf:0, 0:0, 10:2]
 		c.erase_after(c.last(99));
 		TESTEQUALS(c.last(47)->value, 2);
 
 		// now since 5 < 10, element with value 2 has to be gone
+		// result should be [-inf:0, 0:0]
 		c.erase_after(c.last(5));
 		TESTEQUALS(c.last(47)->value, 0);
+
+		c.insert_overwrite(0, 42);
+		TESTEQUALS(c.last(100)->value, 42);
+		TESTEQUALS(c.last(100)->time, 0);
+
+		// the curve now contains [-inf:0, 0:42]
+		// let's change/add some more elements
+		c.insert_overwrite(0, 10);
+		TESTEQUALS(c.last(100)->value, 10);
+
+		c.insert_after(0, 11);
+		c.insert_after(0, 12);
+		// now: [-inf:0, 0:10, 0:11, 0:12]
+		TESTEQUALS(c.last(0)->value, 12);
+		TESTEQUALS(c.last(10)->value, 12);
+
+		c.insert_before(0, 2);
+		// all the values at t=0 should be 2, 10, 11, 12
+
+		c.insert_after(1, 15);
+		TESTEQUALS(c.last(1)->value, 15);
+		TESTEQUALS(c.last(10)->value, 15);
+
+		c.insert_overwrite(2, 20);
+		TESTEQUALS(c.last(1)->value, 15);
+		TESTEQUALS(c.last(2)->value, 20);
+		TESTEQUALS(c.last(10)->value, 20);
+
+		c.insert_before(3, 25);
+		TESTEQUALS(c.last(1)->value, 15);
+		TESTEQUALS(c.last(2)->value, 20);
+		TESTEQUALS(c.last(3)->value, 25);
+		TESTEQUALS(c.last(10)->value, 25);
+
+		// now it should be [-inf: 0, 0: 2, 0: 10, 0: 11, 0: 12, 1: 15, 2: 20,
+		// 3: 25]
+
+		{
+			auto it = c.begin();
+			TESTEQUALS(it->time, std::numeric_limits<time_t>::min());
+			TESTEQUALS(it->value, 0);
+
+			TESTEQUALS((++it)->time, 0);
+			TESTEQUALS(it->value, 2);
+
+			TESTEQUALS((++it)->time, 0);
+			TESTEQUALS(it->value, 10);
+
+			TESTEQUALS((++it)->time, 0);
+			TESTEQUALS(it->value, 11);
+
+			TESTEQUALS((++it)->time, 0);
+			TESTEQUALS(it->value, 12);
+
+			TESTEQUALS((++it)->time, 1);
+			TESTEQUALS(it->value, 15);
+
+			TESTEQUALS((++it)->time, 2);
+			TESTEQUALS(it->value, 20);
+
+			TESTEQUALS((++it)->time, 3);
+			TESTEQUALS(it->value, 25);
+		}
+
+		// TODO test c.insert_overwrite and c.insert_after
 	}
 
 	// Check the Simple Continuous type
@@ -82,9 +179,7 @@ void curve_types() {
 	{
 		auto f = std::make_shared<event::Loop>();
 		Continuous<float> c(f, 0);
-		log::log(DBG << "Testing Continuous float");
 		c.set_insert(0, 0);
-		log::log(DBG << "Inserting t:20, v:20");
 		c.set_insert(20, 20);
 
 		TESTEQUALS(c.get(0), 0);
@@ -92,7 +187,6 @@ void curve_types() {
 		TESTEQUALS(c.get(7), 7);
 
 		c.set_last(20, 10);
-		log::log(DBG << "Inserting t:20, v:10. This should overwrite the old values!");
 		TESTEQUALS(c.get(0), 0);
 		TESTEQUALS(c.get(2), 1);
 		TESTEQUALS(c.get(8), 4);
@@ -108,6 +202,10 @@ void curve_types() {
 		TESTEQUALS(c.get(0), 0);
 		TESTEQUALS(c.get(1), 0);
 		TESTEQUALS(c.get(10), 10);
+		TESTEQUALS(c.get(15), 10);
+
+		c.erase(10);
+		TESTEQUALS(c.get(15), 0);
 
 		Discrete<std::string> complex(f, 0);
 
@@ -117,7 +215,6 @@ void curve_types() {
 		TESTEQUALS(complex.get(0), "Test 0");
 		TESTEQUALS(complex.get(1), "Test 0");
 		TESTEQUALS(complex.get(10), "Test 10");
-
 	}
 
 	//check set_last
@@ -138,10 +235,83 @@ void curve_types() {
 	{
 		auto f = std::make_shared<event::Loop>();
 		Continuous<int> c(f, 0);
+		c.set_insert(0, 1);
 		c.set_insert(1, 1);
 		c.set_last(1, -5);
 
+		// [0:1, 1:-5]
 		TESTEQUALS(c.get(1), -5);
+
+		c.set_replace(1, 10);
+		// [0:1, 1:10]
+		TESTEQUALS(c.get(1), 10);
+
+		c.set_insert(20, 20);
+		c.set_insert(1, 1);
+		c.set_insert(2, 2);
+
+		// [0:1, 1:1, 2:2, 20:20]
+		TESTEQUALS(c.get(0.5), 1);
+		TESTEQUALS(c.get(1), 1);
+
+		TESTEQUALS(c.get(5), 5);
+		TESTEQUALS(c.get(20), 20);
+		TESTEQUALS(c.get(25), 20);
+
+		c.set_insert(0, 0);
+		c.set_insert(1, 10);
+		c.set_insert(20, 21);
+		c.erase(2);
+		// [0:0, 1:10, 20:21]
+		TESTEQUALS(c.get(0), 0);
+		TESTEQUALS(c.get(1), 10);
+		// 10 + (20 - 10)/(21 - 1) * (5 - 1) = 12
+		TESTEQUALS(c.get(5), 12);
+		TESTEQUALS(c.get(0.5), 5);
+	}
+
+	// check jumps of Segmented
+	{
+		auto f = std::make_shared<event::Loop>();
+		Segmented<int> c(f, 0);
+
+		c.set_insert(0, 0);
+		c.set_insert(2, 2);
+		c.set_insert(10, 10);
+
+		// [0:0, 2:2, 10:10]
+		TESTEQUALS(c.get(5), 5);
+		TESTEQUALS(c.get(1), 1);
+
+		c.set_insert(1, 10);
+		// [0:0, 1:10, 2:2, 10:10]
+		TESTNOEXCEPT(c.check_integrity());
+		TESTEQUALS(c.get(1), 10);
+		TESTEQUALS(c.get(5), 5);
+
+		c.set_insert_jump(1, 0, 20);
+		// [0:0, 1:0, 1:20, 2:2, 10:10]
+		TESTNOEXCEPT(c.check_integrity());
+		TESTEQUALS(c.get(0.5), 0);
+		TESTEQUALS(c.get(1), 20);
+
+		c.erase(2);
+		// [0:0, 1:0, 1:20, 10:10]
+		TESTNOEXCEPT(c.check_integrity());
+		c.str();
+		TESTEQUALS(c.get(5), 15);
+
+		c.set_last_jump(1, 4, 10);
+		// [0:0, 1:4, 1:10]
+		TESTNOEXCEPT(c.check_integrity());
+		TESTEQUALS(c.get(0.5), 2);
+		TESTEQUALS(c.get(1), 10);
+		TESTEQUALS(c.get(5), 10);
+
+		c.erase(1);
+		// [0:0]
+		TESTEQUALS(c.get(1), 0);
+		TESTEQUALS(c.get(5), 0);
 	}
 }
 
diff --git a/libopenage/curve/value_container.cpp b/libopenage/curve/value_container.cpp
deleted file mode 100644
index a8764386f5..0000000000
--- a/libopenage/curve/value_container.cpp
+++ /dev/null
@@ -1,7 +0,0 @@
-// Copyright 2017-2018 the openage authors. See copying.md for legal info.
-
-#include "value_container.h"
-
-namespace openage::curve {
-
-} // openage::curve
diff --git a/libopenage/curve/value_container.h b/libopenage/curve/value_container.h
deleted file mode 100644
index cd9b511bc6..0000000000
--- a/libopenage/curve/value_container.h
+++ /dev/null
@@ -1,104 +0,0 @@
-// Copyright 2017-2018 the openage authors. See copying.md for legal info.
-
-#pragma once
-
-#include "../event/eventtarget.h"
-#include "keyframe_container.h"
-
-#include <cmath>
-
-
-namespace openage::curve {
-
-template<typename T>
-class ValueContainer : public event::EventTarget {
-public:
-	ValueContainer(const std::shared_ptr<event::Loop> &mgr,
-	               size_t id,
-	               const EventTarget::single_change_notifier &notifier=nullptr)
-		:
-		EventTarget(mgr, notifier),
-		container{mgr},
-		_id{id},
-		last_element{this->container.begin()} {}
-
-	virtual ~ValueContainer() = default;
-
-	virtual T get(const time_t &t) const = 0;
-
-	virtual T operator ()(const time_t &now) {
-		return get(now);
-	}
-
-	virtual std::pair<time_t, const T &> frame(const time_t &) const;
-	virtual std::pair<time_t, const T &> next_frame(const time_t &) const;
-
-	// Inserter mode
-	virtual void set_last(const time_t &at, const T &value);
-	virtual void set_insert(const time_t &at, const T &value);
-
-	virtual size_t id() const override {
-		return _id;
-	}
-
-protected:
-	/**
-	 * Stores all the keyframes
-	 */
-	KeyframeContainer<T> container;
-
-	/**
-	 * Identifier for the container
-	 */
-	const size_t _id;
-
-	/**
-	 * Cache the iterator for quickly finding the end
-	 */
-	mutable typename KeyframeContainer<T>::KeyframeIterator last_element;
-};
-
-
-template <typename T>
-void ValueContainer<T>::set_last(const time_t &at, const T &value) {
-	auto hint = this->container.last(at, this->last_element);
-
-	// We want to remove a possible equal timed element from the container
-	// to do fabs(x-y) < min is only necessary when time_t is floating point!
-	//if (std::abs(hint->time - at) < std::numeric_limits<time_t>::min()) {
-
-	if (hint->time == at) {
-		hint--;
-	}
-
-	hint = this->container.erase_after(hint);
-
-	container.insert(at, value, hint);
-	this->last_element = hint;
-
-	this->changes(at);
-}
-
-
-template <typename T>
-void ValueContainer<T>::set_insert(const time_t &at, const T &value) {
-	this->container.insert(at, value, this->last_element);
-	this->changes(at);
-}
-
-
-template <typename T>
-std::pair<time_t, const T&> ValueContainer<T>::frame(const time_t &time) const {
-	auto e = this->container.last(time, this->container.end());
-	return std::make_pair(e->time, e->value);
-}
-
-
-template <typename T>
-std::pair<time_t, const T&> ValueContainer<T>::next_frame(const time_t &time) const {
-	auto e = this->container.last(time, this->container.end());
-	e++;
-	return std::make_pair(e->time, e->value);
-}
-
-} // openage::curve
diff --git a/libopenage/engine.cpp b/libopenage/engine.cpp
index 220cd313ee..cbfe19c91b 100644
--- a/libopenage/engine.cpp
+++ b/libopenage/engine.cpp
@@ -1,4 +1,4 @@
-// Copyright 2013-2020 the openage authors. See copying.md for legal info.
+// Copyright 2013-2021 the openage authors. See copying.md for legal info.
 
 #include "engine.h"
 
@@ -13,8 +13,8 @@
 #include "config.h"
 #include "error/error.h"
 #include "error/gl_debug.h"
-#include "gamestate/game_main.h"
-#include "gamestate/generator.h"
+#include "gamestate/old/game_main.h"
+#include "gamestate/old/generator.h"
 #include "gui/gui.h"
 #include "log/log.h"
 #include "renderer/font/font.h"
@@ -26,8 +26,10 @@
 #include "util/opengl.h"
 #include "util/strings.h"
 #include "util/timer.h"
+#include "version.h"
 #include "versions/compiletime.h"
 
+
 /**
  * Main openage namespace to store all things that make the have to do with the game.
  *
diff --git a/libopenage/event/CMakeLists.txt b/libopenage/event/CMakeLists.txt
index b4231385ff..114d5bab1b 100644
--- a/libopenage/event/CMakeLists.txt
+++ b/libopenage/event/CMakeLists.txt
@@ -1,10 +1,9 @@
 add_sources(libopenage
 	event.cpp
-	eventclass.cpp
-	eventfilter.cpp
+	evententity.cpp
+	eventhandler.cpp
 	eventqueue.cpp
 	eventstore.cpp
-	eventtarget.cpp
 	loop.cpp
 	state.cpp
 	tests.cpp
diff --git a/libopenage/event/demo/aicontroller.cpp b/libopenage/event/demo/aicontroller.cpp
index cb052d01be..dbfcda1a14 100644
--- a/libopenage/event/demo/aicontroller.cpp
+++ b/libopenage/event/demo/aicontroller.cpp
@@ -4,10 +4,10 @@
 
 namespace openage::event::demo {
 
-const std::vector<PongEvent> &AIInput::get_inputs(const std::shared_ptr<PongPlayer> &player,
-                                                  const std::shared_ptr<PongBall> &ball,
-                                                  const curve::time_t &now) {
-	this->commands.clear();
+std::vector<PongEvent> get_ai_inputs(const std::shared_ptr<PongPlayer> &player,
+                                     const std::shared_ptr<PongBall> &ball,
+                                     const curve::time_t &now) {
+	std::vector<PongEvent> ret;
 
 	auto position = player->position->get(now);
 
@@ -16,14 +16,17 @@ const std::vector<PongEvent> &AIInput::get_inputs(const std::shared_ptr<PongPlay
 
 	// Ball is below position
 	if (ball->position->get(now)[1] > position + player->size->get(now) / 3) {
-		this->commands.emplace_back(player->id(), PongEvent::DOWN);
+		ret.emplace_back(player->id(), PongEvent::DOWN);
 	}
 	// Ball is above position
 	else if (ball->position->get(now)[1] < position - player->size->get(now) / 3) {
-		this->commands.emplace_back(player->id(), PongEvent::UP);
+		ret.emplace_back(player->id(), PongEvent::UP);
+	}
+	else {
+		ret.emplace_back(player->id(), PongEvent::IDLE);
 	}
 
-	return this->commands;
+	return ret;
 }
 
 } // openage::event::demo
diff --git a/libopenage/event/demo/aicontroller.h b/libopenage/event/demo/aicontroller.h
index d42e9b4462..892cef3610 100644
--- a/libopenage/event/demo/aicontroller.h
+++ b/libopenage/event/demo/aicontroller.h
@@ -1,4 +1,4 @@
-// Copyright 2017-2018 the openage authors. See copying.md for legal info.
+// Copyright 2017-2019 the openage authors. See copying.md for legal info.
 
 #pragma once
 
@@ -8,16 +8,8 @@
 
 namespace openage::event::demo {
 
-class AIInput {
-public:
-	const std::vector<PongEvent> &get_inputs(
-		const std::shared_ptr<PongPlayer> &player,
-		const std::shared_ptr<PongBall> &ball,
-		const curve::time_t &now
-	);
+std::vector<PongEvent> get_ai_inputs(const std::shared_ptr<PongPlayer> &player,
+                                     const std::shared_ptr<PongBall> &ball,
+                                     const curve::time_t &now);
 
-private:
-	std::vector<PongEvent> commands;
-};
-
-} // openage::event::demo
+}  // openage::event::demo
diff --git a/libopenage/event/demo/gamestate.h b/libopenage/event/demo/gamestate.h
index c43b48d2ea..f61a17887a 100644
--- a/libopenage/event/demo/gamestate.h
+++ b/libopenage/event/demo/gamestate.h
@@ -1,17 +1,20 @@
-// Copyright 2017-2018 the openage authors. See copying.md for legal info.
+// Copyright 2017-2019 the openage authors. See copying.md for legal info.
 
 #pragma once
 
 #include <functional>
+#include <sstream>
 
 #include "config.h"
 #include "../state.h"
 #include "../loop.h"
-#include "../eventtarget.h"
+#include "../evententity.h"
 #include "../../curve/continuous.h"
 #include "../../curve/discrete.h"
+#include "../../util/strings.h"
 #include "../../util/vector.h"
 
+
 namespace openage::event::demo {
 
 #if WITH_NCURSES
@@ -36,30 +39,35 @@ class PongEvent {
 
 
 using namespace std::placeholders;
-class PongPlayer : public EventTarget {
+class PongPlayer : public EventEntity {
 public:
 	PongPlayer(const std::shared_ptr<Loop> &mgr, size_t id)
 		:
-		EventTarget{mgr},
+		EventEntity{mgr},
 		speed(std::make_shared<curve::Discrete<float>>(
 			      mgr,
 			      (id << 4) + 1,
+			      util::sformat("PongPlayer(%zd).speed", id),
 			      std::bind(&PongPlayer::child_changes, this, _1))),
 		position(std::make_shared<curve::Continuous<float>>(
 			         mgr,
 			         (id << 4) + 2,
+			         util::sformat("PongPlayer(%zd).position", id),
 			         std::bind(&PongPlayer::child_changes, this, _1))),
 		lives(std::make_shared<curve::Discrete<int>>(
 			      mgr,
 			      (id << 4) + 3,
+			      util::sformat("PongPlayer(%zd).lives", id),
 			      std::bind(&PongPlayer::child_changes, this, _1))),
 		state(std::make_shared<curve::Discrete<PongEvent>>(
 			      mgr,
 			      (id << 4) + 4,
+			      util::sformat("PongPlayer(%zd).state", id),
 			      std::bind(&PongPlayer::child_changes, this, _1))),
 		size(std::make_shared<curve::Discrete<float>>(
 			     mgr,
 			     (id << 4) + 5,
+			     util::sformat("PongPlayer(%zd).size", id),
 			     std::bind(&PongPlayer::child_changes, this, _1))),
 		_id{id},
 		paddle_x{0} {}
@@ -77,6 +85,12 @@ class PongPlayer : public EventTarget {
 		return _id;
 	}
 
+	std::string idstr() const override {
+		std::stringstream ss;
+		ss << "PongPlayer[" << this->id() << "]";
+		return ss.str();
+	}
+
 private:
 	void child_changes(const curve::time_t &time) {
 		this->changes(time);
@@ -84,18 +98,20 @@ class PongPlayer : public EventTarget {
 };
 
 
-class PongBall : public EventTarget {
+class PongBall : public EventEntity {
 public:
 	PongBall(const std::shared_ptr<Loop> &mgr, size_t id)
 		:
-		EventTarget{mgr},
+		EventEntity{mgr},
 		speed(std::make_shared<curve::Discrete<util::Vector2d>>(
 			      mgr,
 			      (id << 2) + 1,
+			      util::sformat("PongBall(%zd).speed", id),
 			      std::bind(&PongBall::child_changes, this, _1))),
 		position(std::make_shared<curve::Continuous<util::Vector2d>>(
 			         mgr,
 			         (id << 2) + 2,
+			         util::sformat("PongBall(%zd).position", id),
 			         std::bind(&PongBall::child_changes, this, _1))),
 		_id{id} {}
 
@@ -105,6 +121,13 @@ class PongBall : public EventTarget {
 	size_t id() const override {
 		return _id;
 	}
+
+	std::string idstr() const override {
+		std::stringstream ss;
+		ss << "PongBall[" << this->id() << "]";
+		return ss.str();
+	}
+
 private:
 	void child_changes(const curve::time_t &time) {
 		this->changes(time);
diff --git a/libopenage/event/demo/main.cpp b/libopenage/event/demo/main.cpp
index 74df060402..d1350a126b 100644
--- a/libopenage/event/demo/main.cpp
+++ b/libopenage/event/demo/main.cpp
@@ -61,7 +61,6 @@ void curvepong(bool disable_gui, bool no_human) {
 		auto loop = std::make_shared<Loop>();
 		curve::time_t now = 1;
 		Physics phys;
-		AIInput ai;
 
 		auto state = std::make_shared<PongState>(loop, enable_gui
 #if WITH_NCURSES
@@ -118,12 +117,12 @@ void curvepong(bool disable_gui, bool no_human) {
 			else {
 
 				phys.process_input(state, state->p1,
-				                   ai.get_inputs(state->p1, state->ball, now),
+				                   get_ai_inputs(state->p1, state->ball, now),
 				                   loop, now);
 			}
 
 			phys.process_input(state, state->p2,
-			                   ai.get_inputs(state->p2, state->ball, now),
+			                   get_ai_inputs(state->p2, state->ball, now),
 			                   loop, now);
 
 			// paddle x positions
@@ -143,7 +142,7 @@ void curvepong(bool disable_gui, bool no_human) {
 					mvprintw(pos++, state->display_boundary[0]/2 + 10,
 					         "%f: %s",
 					         e->get_time().to_double(),
-					         e->get_eventclass()->id().c_str());
+					         e->get_eventhandler()->id().c_str());
 				}
 
 				gui->update_screen();
diff --git a/libopenage/event/demo/physics.cpp b/libopenage/event/demo/physics.cpp
index 51c314026f..e230b2601a 100644
--- a/libopenage/event/demo/physics.cpp
+++ b/libopenage/event/demo/physics.cpp
@@ -24,9 +24,9 @@
 namespace openage::event::demo {
 
 
-class BallReflectWall : public DependencyEventClass {
+class BallReflectWall : public DependencyEventHandler {
 public:
-	BallReflectWall() : DependencyEventClass("demo.ball.reflect_wall") {}
+	BallReflectWall() : DependencyEventHandler("demo.ball.reflect_wall") {}
 
 	void setup_event(const std::shared_ptr<Event> &evnt,
 	                 const std::shared_ptr<State> &gstate) override {
@@ -39,15 +39,15 @@ class BallReflectWall : public DependencyEventClass {
 		evnt->depend_on(state->ball->speed);
 		// TODO add dependency to size of game area
 
-		// FIXME: warn if it's not a dependency eventclass
+		// FIXME: warn if it's not a dependency eventhandler
 	}
 
-	// FIXME we REALLY need dependencies to objects i.e. Ball : public EventTarget()
+	// FIXME we REALLY need dependencies to objects i.e. Ball : public EventEntity()
 	void invoke(Loop &,
-	            const std::shared_ptr<EventTarget> &target,
+	            const std::shared_ptr<EventEntity> &target,
 	            const std::shared_ptr<State> &gstate,
 	            const curve::time_t &now,
-	            const EventClass::param_map &/*param*/) override {
+	            const EventHandler::param_map &/*param*/) override {
 
 		auto positioncurve = std::dynamic_pointer_cast<curve::Continuous<util::Vector2d>>(target);
 		auto state = std::dynamic_pointer_cast<PongState>(gstate);
@@ -79,7 +79,7 @@ class BallReflectWall : public DependencyEventClass {
 		state->ball->position->set_last(now + ty, pos + (speed * ty.to_double()));
 	}
 
-	curve::time_t predict_invoke_time(const std::shared_ptr<EventTarget> &target,
+	curve::time_t predict_invoke_time(const std::shared_ptr<EventEntity> &target,
 	                                  const std::shared_ptr<State> &gstate,
 	                                  const curve::time_t &now) override {
 
@@ -114,11 +114,11 @@ class BallReflectWall : public DependencyEventClass {
 };
 
 
-class BallReflectPanel : public DependencyEventClass {
+class BallReflectPanel : public DependencyEventHandler {
 public:
 	BallReflectPanel ()
 		:
-		DependencyEventClass("demo.ball.reflect_panel") {}
+		DependencyEventHandler("demo.ball.reflect_panel") {}
 
 	void setup_event(const std::shared_ptr<Event> &target,
 	                 const std::shared_ptr<State> &gstate) override {
@@ -136,10 +136,10 @@ class BallReflectPanel : public DependencyEventClass {
 
 	// FIXME we REALLY need dependencies to objects
 	void invoke(Loop &mgr,
-	            const std::shared_ptr<EventTarget> &/*target*/,
+	            const std::shared_ptr<EventEntity> &/*target*/,
 	            const std::shared_ptr<State> &gstate,
 	            const curve::time_t &now,
-	            const EventClass::param_map &/*param*/) override {
+	            const EventHandler::param_map &/*param*/) override {
 
 		auto state = std::dynamic_pointer_cast<PongState>(gstate);
 
@@ -212,7 +212,7 @@ class BallReflectPanel : public DependencyEventClass {
 		state->ball->position->set_last(now + ty, hit_pos);
 	}
 
-	curve::time_t predict_invoke_time(const std::shared_ptr<EventTarget> &target,
+	curve::time_t predict_invoke_time(const std::shared_ptr<EventEntity> &target,
 	                                  const std::shared_ptr<State> &gstate,
 	                                  const curve::time_t &now) override {
 
@@ -263,20 +263,20 @@ class BallReflectPanel : public DependencyEventClass {
 };
 
 
-class ResetGame : public OnceEventClass {
+class ResetGame : public OnceEventHandler {
 public:
 	ResetGame ()
 		:
-		OnceEventClass("demo.reset") {}
+		OnceEventHandler("demo.reset") {}
 
 	void setup_event(const std::shared_ptr<Event> &/*target*/,
 	                 const std::shared_ptr<State> &/*state*/) override {}
 
 	void invoke(Loop &/*mgr*/,
-	            const std::shared_ptr<EventTarget> &/*target*/,
+	            const std::shared_ptr<EventEntity> &/*target*/,
 	            const std::shared_ptr<State> &gstate,
 	            const curve::time_t &now,
-	            const EventClass::param_map &/*param*/) override {
+	            const EventHandler::param_map &/*param*/) override {
 
 		auto state = std::dynamic_pointer_cast<PongState>(gstate);
 
@@ -351,7 +351,7 @@ class ResetGame : public OnceEventClass {
 		state->ball->position->set_last(now + ty, pos + init_speed * ty.to_double());
 	}
 
-	curve::time_t predict_invoke_time(const std::shared_ptr<EventTarget> &/*target*/,
+	curve::time_t predict_invoke_time(const std::shared_ptr<EventEntity> &/*target*/,
 	                                  const std::shared_ptr<State> &/*state*/,
 	                                  const curve::time_t &old_time) override {
 		return old_time;
diff --git a/libopenage/event/event.cpp b/libopenage/event/event.cpp
index e7bb09de98..8d3a1d3178 100644
--- a/libopenage/event/event.cpp
+++ b/libopenage/event/event.cpp
@@ -4,33 +4,34 @@
 
 #include <utility>
 
-#include "eventtarget.h"
-#include "eventclass.h"
+#include "evententity.h"
+#include "eventhandler.h"
 
 #include "../log/log.h"
 #include "../util/hash.h"
 
 namespace openage::event {
 
-Event::Event(const std::shared_ptr<EventTarget> &target,
-             const std::shared_ptr<EventClass> &eventclass,
-             EventClass::param_map params)
+Event::Event(const std::shared_ptr<EventEntity> &entity,
+             const std::shared_ptr<EventHandler> &eventhandler,
+             const EventHandler::param_map &params)
 	:
-	params(std::move(params)),
-	target{target},
-	eventclass{eventclass},
+	params(params),
+	entity{entity},
+	eventhandler{eventhandler},
 	myhash{
-		util::hash_combine(std::hash<size_t>()(target->id()),
-		                   std::hash<std::string>()(eventclass->id()))
+		util::hash_combine(std::hash<size_t>()(entity->id()),
+		                   std::hash<std::string>()(eventhandler->id()))
 	} {}
 
 
-void Event::depend_on(const std::shared_ptr<EventTarget> &dependency) {
+void Event::depend_on(const std::shared_ptr<EventEntity> &dependency) {
 	// TODO: do REPEAT and TRIGGER listen to changes (i.e. have dependents)?
 	// if not, exclude them here and return early.
 
-	log::log(DBG << "Adding change listener for: " << this->get_eventclass()->id()
-	         << " to dependency with id=" << dependency->id());
+	log::log(DBG << "Registering dependency event from EventHandler "
+	         << this->get_eventhandler()->id()
+	         << " to EventEntity " << dependency->idstr());
 
 	dependency->add_dependent(this->shared_from_this());
 }
diff --git a/libopenage/event/event.h b/libopenage/event/event.h
index 0df3771e43..d3e2b90888 100644
--- a/libopenage/event/event.h
+++ b/libopenage/event/event.h
@@ -4,13 +4,13 @@
 
 #include <memory>
 
-#include "eventclass.h"
+#include "eventhandler.h"
 #include "../curve/curve.h"
 
 namespace openage::event {
 
 class EventQueue;
-class EventTarget;
+class EventEntity;
 
 /**
  * The actual one event that may be called - it is used to manage the event itself.
@@ -18,16 +18,16 @@ class EventTarget;
  */
 class Event : public std::enable_shared_from_this<Event> {
 public:
-	Event(const std::shared_ptr<EventTarget> &trgt,
-	      const std::shared_ptr<EventClass> &eventclass,
-	      EventClass::param_map params);
+	Event(const std::shared_ptr<EventEntity> &trgt,
+	      const std::shared_ptr<EventHandler> &eventhandler,
+	      const EventHandler::param_map &params);
 
-	const std::weak_ptr<EventTarget> &get_target() const {
-		return this->target;
+	const std::weak_ptr<EventEntity> &get_entity() const {
+		return this->entity;
 	}
 
-	const std::shared_ptr<EventClass> &get_eventclass() const {
-		return this->eventclass;
+	const std::shared_ptr<EventHandler> &get_eventhandler() const {
+		return this->eventhandler;
 	}
 
 	/**
@@ -48,40 +48,63 @@ class Event : public std::enable_shared_from_this<Event> {
 		this->time = t;
 	}
 
-	const EventClass::param_map &get_params() const {
+	const EventHandler::param_map &get_params() const {
 		return this->params;
 	}
 
 	/**
-	 * Let this event depend on another an event target.
-	 * When this target is changes, the event is reevaluated.
+	 * Let this event depend on another an event entity.
+	 * When this entity is changes, the event is reevaluated.
 	 *
-	 * To be called in the EventClass::setup function.
+	 * To be called in the EventHandler::setup function.
 	 */
-	void depend_on(const std::shared_ptr<EventTarget> &dependency);
+	void depend_on(const std::shared_ptr<EventEntity> &dependency);
 
 	/**
 	 * For sorting events by their trigger time.
 	 */
 	bool operator <(const Event &other) const;
 
-	curve::time_t last_triggered = 0;
+	/**
+	 * When a change happens on an EventEntity (this->entity),
+	 * it needs to be processed and all depending events need reevaluation as well.
+	 * This registers the time so we know the point in time that we
+	 * need to go back to and handle the change.
+	 * When changes happen after `last_change_time` in the same time-reaching-round,
+	 * they can be ignored since the earlies point in time determines all implications.
+	 */
+	void set_last_changed(const curve::time_t &t) {
+		this->last_change_time = t;
+	}
+
+	/**
+	 * Get the time the  event was changed the last time.
+	 */
+	const curve::time_t &get_last_changed() const {
+		return this->last_change_time;
+	}
 
 private:
 	/**
-	 * Parameters for the event (determined by its EventClass)
+	 * Parameters for the event (determined by its EventHandler)
 	 */
-	EventClass::param_map params;
+	EventHandler::param_map params;
 
-	/** The actor that has the event */
-	std::weak_ptr<EventTarget> target;
+	/** The actor that this event refers to. */
+	std::weak_ptr<EventEntity> entity;
 
 	/** Type of this event. */
-	std::shared_ptr<EventClass> eventclass;
+	std::shared_ptr<EventHandler> eventhandler;
 
-	/** Time this event occurs/occured */
+	/**
+	 * Time this event occurs/occured.
+	 * It establishes the order of events in the EventQueue.
+	 */
 	curve::time_t time;
 
+	/** Time this event was registered to be changed last. */
+	curve::time_t last_change_time = curve::time_t::min_value();
+
 	/** Precalculated std::hash for the event */
 	size_t myhash;
 };
diff --git a/libopenage/event/eventclass.cpp b/libopenage/event/eventclass.cpp
deleted file mode 100644
index fcc48cb8dd..0000000000
--- a/libopenage/event/eventclass.cpp
+++ /dev/null
@@ -1,50 +0,0 @@
-// Copyright 2017-2019 the openage authors. See copying.md for legal info.
-
-#include "eventclass.h"
-
-#include <utility>
-
-#include "event.h"
-#include "eventtarget.h"
-
-#include "../log/log.h"
-
-namespace openage::event {
-
-
-EventClass::EventClass(std::string name, const EventClass::trigger_type &type) :
-	type{type},
-	_id{std::move(name)} {}
-
-
-const std::string &EventClass::id() {
-	return _id;
-}
-
-
-DependencyEventClass::DependencyEventClass(const std::string &name)
-	:
-	EventClass(name, EventClass::trigger_type::DEPENDENCY) {}
-
-
-DependencyImmediatelyEventClass::DependencyImmediatelyEventClass(const std::string &name)
-	:
-	EventClass(name, EventClass::trigger_type::DEPENDENCY_IMMEDIATELY) {}
-
-
-TriggerEventClass::TriggerEventClass(const std::string &name)
-	:
-	EventClass(name, EventClass::trigger_type::TRIGGER) {}
-
-
-RepeatEventClass::RepeatEventClass(const std::string &name)
-	:
-	EventClass(name, EventClass::trigger_type::REPEAT) {}
-
-
-OnceEventClass::OnceEventClass(const std::string &name)
-	:
-	EventClass(name, EventClass::trigger_type::ONCE) {}
-
-
-} // openage::event
diff --git a/libopenage/event/evententity.cpp b/libopenage/event/evententity.cpp
new file mode 100644
index 0000000000..c721eee237
--- /dev/null
+++ b/libopenage/event/evententity.cpp
@@ -0,0 +1,118 @@
+// Copyright 2017-2019 the openage authors. See copying.md for legal info.
+
+#include "evententity.h"
+
+#include <string>
+
+#include "event.h"
+#include "eventhandler.h"
+#include "loop.h"
+
+#include "../log/log.h"
+
+
+namespace openage::event {
+
+
+void EventEntity::changes(const curve::time_t &time) {
+	// This target has some change, so we have to notify all dependents
+	// that subscribed on this entity.
+
+	if (this->parent_notifier or this->dependents.size()) {
+		log::log(DBG << "Target: processing change request at t=" << time
+		         << " for EventEntity " << this->idstr() << "...");
+	}
+
+	if (this->parent_notifier != nullptr) {
+		this->parent_notifier(time);
+	}
+
+	// This is a maybe-erase construct so obsolete dependents are cleaned up.
+	for (auto it = this->dependents.begin(); it != this->dependents.end(); ) {
+		auto dependent = it->lock();
+		if (dependent) {
+			switch (dependent->get_eventhandler()->type) {
+			case EventHandler::trigger_type::DEPENDENCY_IMMEDIATELY:
+			case EventHandler::trigger_type::DEPENDENCY:
+				// Enqueue a change so that change events,
+				// which depend on this target, will be retriggered
+
+				log::log(DBG << "Target: change at t=" << time
+				         << " for EventEntity " << this->idstr() << " registered");
+				this->loop->create_change(dependent, time);
+				++it;
+				break;
+
+			case EventHandler::trigger_type::ONCE:
+				// If the dependent is a ONCE-event
+				// forget the change if the once event has been notified already.
+				if (dependent->get_last_changed() > curve::time_t::min_value()) {
+					it = this->dependents.erase(it);
+				} else {
+					this->loop->create_change(dependent, time);
+					++it;
+				}
+				break;
+
+			case EventHandler::trigger_type::TRIGGER:
+			case EventHandler::trigger_type::REPEAT:
+				// Ignore announced changes for triggered or repeated events
+				// for that there is the 'DEPENDENCY' events.
+
+				// TRIGGER events are only triggered when this entity's
+				// trigger() function is called
+				++it;
+				break;
+			}
+		}
+		else {
+			// The dependent is no more, so we can safely forget him
+			it = this->dependents.erase(it);
+		}
+	}
+}
+
+
+void EventEntity::trigger(const curve::time_t &last_valid_time) {
+	// notify all dependent events that are triggered `on_keyframe`
+	// that the this target changed.
+	// the only events that is "notified" by are TRIGGER.
+
+	for (auto it = this->dependents.begin(); it != this->dependents.end(); ) {
+		auto dependent = it->lock();
+		if (dependent) {
+			if (dependent->get_eventhandler()->type == EventHandler::trigger_type::TRIGGER) {
+				log::log(DBG << "Target: trigger creates a change for "
+				         << dependent->get_eventhandler()->id()
+				         << " at t=" << last_valid_time);
+
+				loop->create_change(dependent, last_valid_time);
+			}
+
+			++it;
+		}
+		else {
+			it = this->dependents.erase(it);
+		}
+	}
+}
+
+
+void EventEntity::add_dependent(const std::shared_ptr<Event> &event) {
+	this->dependents.emplace_back(event);
+}
+
+void EventEntity::show_dependents() const {
+	log::log(DBG << "Dependent list:");
+	for (auto &dep : this->dependents) {
+		auto dependent = dep.lock();
+		if (dependent) {
+			log::log(DBG << " - " << dependent->get_eventhandler()->id());
+		}
+		else {
+			log::log(DBG << " - ** outdated old reference **");
+		}
+	}
+}
+
+} // openage::event
diff --git a/libopenage/event/eventtarget.h b/libopenage/event/evententity.h
similarity index 67%
rename from libopenage/event/eventtarget.h
rename to libopenage/event/evententity.h
index e633427434..1102ba6e06 100644
--- a/libopenage/event/eventtarget.h
+++ b/libopenage/event/evententity.h
@@ -1,4 +1,4 @@
-// Copyright 2017-2018 the openage authors. See copying.md for legal info.
+// Copyright 2017-2019 the openage authors. See copying.md for legal info.
 
 #pragma once
 
@@ -12,42 +12,46 @@ namespace openage::event {
 
 class Event;
 class Loop;
-class EventClass;
+class EventHandler;
 
 /**
  * Every Object in the gameworld that wants to be targeted by events or as
  * dependency for events, has to implement this class.
  */
-class EventTarget {
+class EventEntity {
 public:
 	/** Give a unique event system identifier for the entity */
 	virtual size_t id() const = 0;
 
+	/** Give a human-readable identifier for this target */
+	virtual std::string idstr() const = 0;
+
 	using single_change_notifier = std::function<void(const curve::time_t &)>;
 
 protected:
 	/**
 	 * For children to be able to initialize us.
 	 *
-	 * The notifier is used by hierarchical structures to be able to traverse a
+	 * The notifier is used by hierarchical structures to be able to propagate a
 	 * change up in the tree, this is necessary to make containers with event
 	 * targets inside and listen to any changes on the full.
 	 */
-	EventTarget(const std::shared_ptr<Loop> &loop,
+	EventEntity(const std::shared_ptr<Loop> &loop,
 	            single_change_notifier parent_notifier=nullptr)
 		:
 		loop{loop},
 		parent_notifier{parent_notifier} {}
 public:
-	virtual ~EventTarget() = default;
+	virtual ~EventEntity() = default;
 
 	/**
-	 * Add a dependent class, that should be notified when dependency is called
+	 * Add a dependent event that is notified whenever this entity changes.
+	 * Does not support TRIGGER and REPEAT event types.
 	 */
-	void add_dependent(const std::weak_ptr<Event> &event);
+	void add_dependent(const std::shared_ptr<Event> &event);
 
 	/**
-	 * For debugging: print the dependent eventclass ids as log messages.
+	 * For debugging: print the dependent eventhandler ids as log messages.
 	 */
 	void show_dependents() const;
 
@@ -59,9 +63,9 @@ class EventTarget {
 	void changes(const curve::time_t &change_time);
 
 	/**
-	 * Call this when a keyframe in the underlying container was passed by in time.
+	 * Call this when depending TriggerEventHandleres should be invoked.
 	 */
-	void trigger(const curve::time_t &last_valid_time);
+	void trigger(const curve::time_t &invoke_time);
 
 private:
 	/** Event loop this target is registered to */
diff --git a/libopenage/event/eventfilter.cpp b/libopenage/event/eventfilter.cpp
deleted file mode 100644
index 9b4727f79d..0000000000
--- a/libopenage/event/eventfilter.cpp
+++ /dev/null
@@ -1,19 +0,0 @@
-// Copyright 2018-2019 the openage authors. See copying.md for legal info.
-
-
-#include "eventfilter.h"
-
-#include <utility>
-
-namespace openage::event {
-
-EventFilter::EventFilter(std::function<bool(const std::shared_ptr<EventTarget> &)> filter)
-	:
-	filter{std::move(filter)} {}
-
-
-bool EventFilter::apply(const std::shared_ptr<EventTarget> &target) const {
-	return this->filter(target);
-}
-
-} // openage::event
diff --git a/libopenage/event/eventfilter.h b/libopenage/event/eventfilter.h
deleted file mode 100644
index 4cfaf6f658..0000000000
--- a/libopenage/event/eventfilter.h
+++ /dev/null
@@ -1,27 +0,0 @@
-// Copyright 2017-2019 the openage authors. See copying.md for legal info.
-
-#pragma once
-
-#include <memory>
-#include <functional>
-
-#include "eventtarget.h"
-
-
-namespace openage::event {
-
-/**
- * Store a filter function that can then be applied on an event target.
- */
-class EventFilter {
-public:
-	EventFilter(std::function<bool(const std::shared_ptr<EventTarget> &)> filter);
-
-	bool apply(const std::shared_ptr<EventTarget> &target) const;
-
-private:
-	std::function<bool(const std::shared_ptr<EventTarget>&)> filter;
-};
-
-
-} // namespace openage::event
diff --git a/libopenage/event/eventhandler.cpp b/libopenage/event/eventhandler.cpp
new file mode 100644
index 0000000000..1e7575e3b1
--- /dev/null
+++ b/libopenage/event/eventhandler.cpp
@@ -0,0 +1,48 @@
+// Copyright 2017-2019 the openage authors. See copying.md for legal info.
+
+#include "eventhandler.h"
+
+#include "event.h"
+#include "evententity.h"
+
+#include "../log/log.h"
+
+namespace openage::event {
+
+
+EventHandler::EventHandler(const std::string &name, const EventHandler::trigger_type &type) :
+	type{type},
+	_id{name} {}
+
+
+const std::string &EventHandler::id() {
+	return _id;
+}
+
+
+DependencyEventHandler::DependencyEventHandler(const std::string &name)
+	:
+	EventHandler(name, EventHandler::trigger_type::DEPENDENCY) {}
+
+
+DependencyImmediatelyEventHandler::DependencyImmediatelyEventHandler(const std::string &name)
+	:
+	EventHandler(name, EventHandler::trigger_type::DEPENDENCY_IMMEDIATELY) {}
+
+
+TriggerEventHandler::TriggerEventHandler(const std::string &name)
+	:
+	EventHandler(name, EventHandler::trigger_type::TRIGGER) {}
+
+
+RepeatEventHandler::RepeatEventHandler(const std::string &name)
+	:
+	EventHandler(name, EventHandler::trigger_type::REPEAT) {}
+
+
+OnceEventHandler::OnceEventHandler(const std::string &name)
+	:
+	EventHandler(name, EventHandler::trigger_type::ONCE) {}
+
+
+} // openage::event
diff --git a/libopenage/event/eventclass.h b/libopenage/event/eventhandler.h
similarity index 79%
rename from libopenage/event/eventclass.h
rename to libopenage/event/eventhandler.h
index ffcfe469f6..cebbd84454 100644
--- a/libopenage/event/eventclass.h
+++ b/libopenage/event/eventhandler.h
@@ -15,19 +15,19 @@ namespace openage::event {
 
 class Event;
 class Loop;
-class EventTarget;
+class EventEntity;
 class State;
 
 
 /**
- * A eventclass has to be implemented for every type of event that exists.
+ * A eventhandler.has to be implemented for every type of event that exists.
  * It determines what the event means and how it is handled.
  */
-class EventClass {
+class EventHandler {
 public:
 	/**
-	 * Available types for the event class:
-	 * These decide when an event of this event class will be executed.
+	 * Available types for the event handler:
+	 * These decide when an event of this event handler will be executed.
 	 */
 	enum class trigger_type {
 		/**
@@ -67,7 +67,7 @@ class EventClass {
 	};
 
 	/**
-	 * Storage for parameters for an event class.
+	 * Storage for parameters for an event handler.
 	 */
 	class param_map {
 	public:
@@ -125,12 +125,12 @@ class EventClass {
 	/**
 	 * Constructor to be constructed with the unique identifier
 	 */
-	EventClass(std::string name, const trigger_type &type);
+	EventHandler(const std::string &name, const trigger_type &type);
 
-	virtual ~EventClass() = default;
+	virtual ~EventHandler() = default;
 
 	/**
-	 * The event type this event class represents.
+	 * The event type this event handler represents.
 	 */
 	const trigger_type type;
 
@@ -140,7 +140,7 @@ class EventClass {
 	const std::string &id();
 
 	/**
-	 * Called for each event that is created for this EventClass.
+	 * Called for each event that is created for this EventHandler.
 	 * The job of the setup function is to add all dependencies with other event
 	 * targets found in state.
 	 */
@@ -154,13 +154,13 @@ class EventClass {
 	 * Called from the Loop.
 	 */
 	virtual void invoke(Loop &loop,
-	                    const std::shared_ptr<EventTarget> &target,
+	                    const std::shared_ptr<EventEntity> &target,
 	                    const std::shared_ptr<State> &state,
 	                    const curve::time_t &time,
 	                    const param_map &params) = 0;
 
 	/**
-	 * Is called to calculate the execution time for an event of this eventclass.
+	 * Is called to calculate the execution time for an event of this eventhandler.
 	 * This is called whenever one of the set up dependencies was changed,
 	 * or when a REPEAT event was executed.
 	 *
@@ -175,13 +175,13 @@ class EventClass {
 	 * then dependencies may not be resolved perfectly anymore
 	 * (if other events have already been calculated before that).
 	 */
-	virtual curve::time_t predict_invoke_time(const std::shared_ptr<EventTarget> &target,
+	virtual curve::time_t predict_invoke_time(const std::shared_ptr<EventEntity> &target,
 	                                          const std::shared_ptr<State> &state,
 	                                          const curve::time_t &at) = 0;
 
 private:
 	/**
-	 * String identifier for this event class.
+	 * String identifier for this event handler.
 	 */
 	std::string _id;
 };
@@ -189,29 +189,29 @@ class EventClass {
 
 // helper classes
 
-class DependencyEventClass : public EventClass {
+class DependencyEventHandler : public EventHandler {
 public:
-	DependencyEventClass(const std::string &name);
+	DependencyEventHandler(const std::string &name);
 };
 
-class DependencyImmediatelyEventClass : public EventClass {
+class DependencyImmediatelyEventHandler : public EventHandler {
 public:
-	DependencyImmediatelyEventClass(const std::string &name);
+	DependencyImmediatelyEventHandler(const std::string &name);
 };
 
-class TriggerEventClass : public EventClass {
+class TriggerEventHandler : public EventHandler {
 public:
-	TriggerEventClass(const std::string &name);
+	TriggerEventHandler(const std::string &name);
 };
 
-class RepeatEventClass : public EventClass {
+class RepeatEventHandler : public EventHandler {
 public:
-	RepeatEventClass(const std::string &name);
+	RepeatEventHandler(const std::string &name);
 };
 
-class OnceEventClass : public EventClass {
+class OnceEventHandler : public EventHandler {
 public:
-	OnceEventClass(const std::string &name);
+	OnceEventHandler(const std::string &name);
 };
 
 
diff --git a/libopenage/event/eventqueue.cpp b/libopenage/event/eventqueue.cpp
index 392bc86306..67437b2b70 100644
--- a/libopenage/event/eventqueue.cpp
+++ b/libopenage/event/eventqueue.cpp
@@ -6,66 +6,66 @@
 #include <utility>
 
 #include "event.h"
-#include "eventclass.h"
-#include "eventtarget.h"
+#include "eventhandler.h"
+#include "evententity.h"
 #include "../log/log.h"
 #include "../util/compiler.h"
 
 
 namespace openage::event {
 
-std::shared_ptr<Event> EventQueue::create_event(const std::shared_ptr<EventTarget> &trgt,
-                                                const std::shared_ptr<EventClass> &cls,
+std::shared_ptr<Event> EventQueue::create_event(const std::shared_ptr<EventEntity> &trgt,
+                                                const std::shared_ptr<EventHandler> &cls,
                                                 const std::shared_ptr<State> &state,
                                                 const curve::time_t &reference_time,
-                                                const EventClass::param_map &params) {
+                                                const EventHandler::param_map &params) {
 
 	auto event = std::make_shared<Event>(trgt, cls, params);
 
 	cls->setup_event(event, state);
 
 	switch(cls->type) {
-	case EventClass::trigger_type::DEPENDENCY:
-	case EventClass::trigger_type::REPEAT:
-	case EventClass::trigger_type::ONCE:
-		event->set_time(event->get_eventclass()
+	case EventHandler::trigger_type::DEPENDENCY:
+	case EventHandler::trigger_type::REPEAT:
+	case EventHandler::trigger_type::ONCE:
+		event->set_time(event->get_eventhandler()
 		                     ->predict_invoke_time(trgt, state, reference_time));
 
 		if (event->get_time() == std::numeric_limits<curve::time_t>::min()) {
 			log::log(DBG << "Queue: ignoring insertion of event "
-			         << event->get_eventclass()->id() <<
+			         << event->get_eventhandler()->id() <<
 			         " because no execution was scheduled.");
 
 			return {};
 		}
 		break;
 
-	case EventClass::trigger_type::DEPENDENCY_IMMEDIATELY:
-	case EventClass::trigger_type::TRIGGER:
+	case EventHandler::trigger_type::DEPENDENCY_IMMEDIATELY:
+	case EventHandler::trigger_type::TRIGGER:
 		event->set_time(reference_time);
 		break;
 	}
 
-	log::log(DBG << "Queue: inserting event " << event->get_eventclass()->id() <<
+	log::log(DBG << "Queue: inserting event " << event->get_eventhandler()->id() <<
 	         " into queue to be executed at t=" << event->get_time());
 
 	// store the event
 	// or enqueue it for execution
-	switch(event->get_eventclass()->type) {
-	case EventClass::trigger_type::DEPENDENCY:
+	switch(event->get_eventhandler()->type) {
+	case EventHandler::trigger_type::DEPENDENCY:
 		this->dependency_events.insert(event);
 		break;
 
-	case EventClass::trigger_type::DEPENDENCY_IMMEDIATELY:
+	case EventHandler::trigger_type::DEPENDENCY_IMMEDIATELY:
 		this->dependency_immediately_events.insert(event);
 		break;
 
-	case EventClass::trigger_type::TRIGGER:
+	case EventHandler::trigger_type::TRIGGER:
 		this->trigger_events.insert(event);
 		break;
 
-	case EventClass::trigger_type::REPEAT:
-	case EventClass::trigger_type::ONCE:
+	case EventHandler::trigger_type::REPEAT:
+	case EventHandler::trigger_type::ONCE:
 	default:
 		this->event_queue.push(event);
 	}
@@ -83,47 +83,53 @@ EventQueue::EventQueue()
 void EventQueue::add_change(const std::shared_ptr<Event> &event,
                             const curve::time_t &changed_at) {
 
-	auto it = this->changes->find(OnChangeElement(event, changed_at));
+	const curve::time_t event_previous_changed = event->get_last_changed();
+
+	// Has the event already been fired in this round?
+	if (event_previous_changed < changed_at) {
+		auto it = this->changes->find(Change{event, changed_at});
 
-	// Has the event been triggered in this round?
-	if (event->last_triggered < changed_at) {
 		// Is the change already in the queue?
 		if (it != changes->end()) {
 			// Is the new change dated _before_ the old one?
-			if (it->time > changed_at) {
-				log::log(DBG << "Queue: adjusting time in change queue");
+			if (changed_at < it->time) {
+				log::log(DBG << "Queue: adjusting time in change queue: moving event of "
+				         << event->get_eventhandler()->id()
+				         << " to earlier time");
 
 				// Save the element
-				OnChangeElement e = *it;
-				e.time = changed_at;
+				Change change = *it;
+				change.time = changed_at;
 
 				// delete it from the container and readd it
+				// with the updated time
 				it = this->changes->erase(it);
-				it = this->changes->insert(it, e);
+				it = this->changes->insert(it, change);
 			}
 			else {
 				// this change is to be ignored
-				log::log(DBG << "Queue: skipping change for " << event->get_eventclass()->id()
+				log::log(DBG << "Queue: skipping change for " << event->get_eventhandler()->id()
 				         << " at " << changed_at
-				         << " because there was already a better one at t=" << it->time);
+				         << " because there was already an earlier one at t=" << it->time);
 			}
 		}
 		else {
 			// the change was not in the to be changed list
 			this->changes->emplace(event, changed_at);
-			log::log(DBG << "Queue: inserting change for " << event->get_eventclass()->id()
+			log::log(DBG << "Queue: inserting change for event from "
+			         << event->get_eventhandler()->id()
 			         << " to be applied at t=" << changed_at);
 		}
 	}
 	else {
 		// the event has been triggered in this round already, so skip it this time
 		this->future_changes->emplace(event, changed_at);
-		log::log(DBG << "Queue: putting change for "
-		         << event->get_eventclass()->id() << " into the future, "
-		         << "applied at t=" << changed_at);
+		log::log(DBG << "Queue: ignoring change at t=" << changed_at
+		         << " for event for handler " << event->get_eventhandler()->id()
+		         << " because it's already processed as change at t=" << event_previous_changed);
 	}
 
-	event->last_triggered = changed_at;
+	event->set_last_changed(changed_at);
 }
 
 
@@ -135,7 +141,7 @@ void EventQueue::remove(const std::shared_ptr<Event> &evnt) {
 }
 
 
-void EventQueue::enqueue_change(const std::shared_ptr<Event> &evnt) {
+void EventQueue::enqueue(const std::shared_ptr<Event> &evnt) {
 	if (this->event_queue.contains(evnt)) {
 		this->event_queue.update(evnt);
 	}
@@ -191,31 +197,36 @@ void EventQueue::swap_changesets() {
 }
 
 
-EventQueue::OnChangeElement::OnChangeElement(const std::shared_ptr<Event> &evnt,
-                                             curve::time_t time)
+EventQueue::Change::Change(const std::shared_ptr<Event> &evnt,
+                           curve::time_t time)
 	:
 	time{std::move(time)},
 	evnt{evnt},
 	hash{evnt->hash()} {}
 
 
-size_t EventQueue::OnChangeElement::Equal::operator()(const OnChangeElement& left,
-                                                      const OnChangeElement& right) const {
+size_t EventQueue::Change::Equal::operator()(const Change& left,
+                                             const Change& right) const {
 	auto left_evnt = left.evnt.lock();
 	auto right_evnt = right.evnt.lock();
 	if (left_evnt && right_evnt) {
-		if (left_evnt->get_eventclass()->id() == right_evnt->get_eventclass()->id()) {
+		if (left_evnt->get_eventhandler()->id() == right_evnt->get_eventhandler()->id()) {
 			return true;
 		}
 	} else {
 		return false;
 	}
 
-	auto left_trgt = left_evnt->get_target().lock();
-	auto right_trgt = right_evnt->get_target().lock();
+	auto left_entity = left_evnt->get_entity().lock();
+	auto right_entity = right_evnt->get_entity().lock();
+
+	if (left_entity && right_entity) {
+		if (left_entity->id() == right_entity->id()) {
+			return true;
+		}
+	}
 
-	return left_trgt && right_trgt &&
-	left_trgt->id() == right_trgt->id();
+	return false;
 }
 
 } // namespace openage::event
diff --git a/libopenage/event/eventqueue.h b/libopenage/event/eventqueue.h
index 990547760d..f9d99cf674 100644
--- a/libopenage/event/eventqueue.h
+++ b/libopenage/event/eventqueue.h
@@ -5,7 +5,7 @@
 #include <memory>
 #include <unordered_set>
 
-#include "eventclass.h"
+#include "eventhandler.h"
 #include "eventstore.h"
 #include "../curve/curve.h"
 
@@ -14,18 +14,18 @@ namespace openage::event {
 
 class Event;
 class Loop;
-class EventTarget;
+class EventEntity;
 
 /**
- * The core event class for execution and execution dependencies.
+ * The core event handler for execution and execution dependencies.
  */
 class EventQueue final {
 public:
 
-	class OnChangeElement {
+	class Change {
 	public:
-		OnChangeElement(const std::shared_ptr<Event> &evnt,
-		                curve::time_t time);
+		Change(const std::shared_ptr<Event> &evnt,
+		       curve::time_t time);
 
 		curve::time_t time;
 		std::weak_ptr<Event> evnt;
@@ -33,24 +33,24 @@ class EventQueue final {
 
 		class Hasher {
 		public:
-			size_t operator ()(const OnChangeElement& e) const {
+			size_t operator ()(const Change& e) const {
 				return e.hash;
 			}
 		};
 
 		class Equal {
 		public:
-			size_t operator ()(const OnChangeElement& left,
-			                   const OnChangeElement& right) const;
+			size_t operator ()(const Change& left,
+			                   const Change& right) const;
 		};
 	};
 
 	/**
 	 * Type for the set to store changes to track.
 	 */
-	using change_set = std::unordered_set<OnChangeElement,
-	                                      OnChangeElement::Hasher,
-	                                      OnChangeElement::Equal>;
+	using change_set = std::unordered_set<Change,
+	                                      Change::Hasher,
+	                                      Change::Equal>;
 
 
 	EventQueue();
@@ -61,14 +61,14 @@ class EventQueue final {
 	 * A target is every single unit in the game world - so best add these events
 	 * in the constructor of the game objects.
 	 *
-	 * The `insertion_time` is the time used to calculate when
-	 * the actual event time will happen!
+	 * The `reference_time` is the time used to calculate when
+	 * the actual event time will happen by calling `eventhandler->predict_invoke_time()`!
 	 */
-	std::shared_ptr<Event> create_event(const std::shared_ptr<EventTarget> &eventtarget,
-	                                    const std::shared_ptr<EventClass> &eventclass,
+	std::shared_ptr<Event> create_event(const std::shared_ptr<EventEntity> &evententity,
+	                                    const std::shared_ptr<EventHandler> &eventhandler,
 	                                    const std::shared_ptr<State> &state,
 	                                    const curve::time_t &reference_time,
-	                                    const EventClass::param_map &params);
+	                                    const EventHandler::param_map &params);
 
 	/**
 	 * Remove the given event from the queue.
@@ -81,7 +81,7 @@ class EventQueue final {
 	 * is newly created. This updates/inserts the given event
 	 * in the main queue.
 	 */
-	void enqueue_change(const std::shared_ptr<Event> &event);
+	void enqueue(const std::shared_ptr<Event> &event);
 
 	/**
 	 * The event was just removed, add it again.
@@ -150,7 +150,6 @@ class EventQueue final {
 
 	/**
 	 * The universe timeline processes through this queue.
-	 * Type::ONCE is only inserted into the queue.
 	 */
 	EventStore event_queue;
 };
diff --git a/libopenage/event/eventtarget.cpp b/libopenage/event/eventtarget.cpp
deleted file mode 100644
index 3555292c5e..0000000000
--- a/libopenage/event/eventtarget.cpp
+++ /dev/null
@@ -1,107 +0,0 @@
-// Copyright 2017-2018 the openage authors. See copying.md for legal info.
-
-#include "eventtarget.h"
-
-#include "event.h"
-#include "eventclass.h"
-#include "loop.h"
-
-#include "../log/log.h"
-
-
-namespace openage::event {
-
-void EventTarget::changes(const curve::time_t &time) {
-	// This target has some change, so we have to notify all dependents
-	// that subscribed on this target.
-
-	log::log(DBG << "Target: change happens on " << this->id() << " at t=" << time);
-	if (this->parent_notifier != nullptr) {
-		this->parent_notifier(time);
-	}
-
-	// This is a maybe-erase construct so obsolete dependents are cleaned up.
-	for (auto it = this->dependents.begin(); it != this->dependents.end(); ) {
-		auto dependent = it->lock();
-		if (dependent) {
-			switch (dependent->get_eventclass()->type) {
-			case EventClass::trigger_type::DEPENDENCY_IMMEDIATELY:
-			case EventClass::trigger_type::DEPENDENCY:
-				// Enqueue a change so that change events will be retriggered
-				// (that depend on this target)
-				// FIXME: Traverse the changed value
-				this->loop->create_change(dependent, time, 0);
-				++it;
-				break;
-
-			case EventClass::trigger_type::ONCE:
-				// If the dependent is a ONCE-event
-				// Has it been triggered? If so - forget it.
-				if (dependent->last_triggered > 0) {
-					it = this->dependents.erase(it);
-				} else {
-					// FIXME: Traverse the changed value
-					this->loop->create_change(dependent, time, 0);
-					++it;
-				}
-				break;
-
-			case EventClass::trigger_type::TRIGGER:
-			case EventClass::trigger_type::REPEAT:
-				// Ignore announced changes for execute/keyframe events
-				++it;
-				break;
-			}
-		}
-		else {
-			// The dependent is no more, so we can safely forget him
-			it = this->dependents.erase(it);
-		}
-	}
-}
-
-
-void EventTarget::trigger(const curve::time_t &last_valid_time) {
-	// notify all dependent events that are triggered `on_keyframe`
-	// that the this target changed.
-	// the only events that is "notified" by are TRIGGER.
-
-	for (auto it = this->dependents.begin(); it != this->dependents.end(); ) {
-		auto dependent = it->lock();
-		if (dependent) {
-			if (dependent->get_eventclass()->type == EventClass::trigger_type::TRIGGER) {
-				log::log(DBG << "Target: trigger creates a change for "
-				         << dependent->get_eventclass()->id()
-				         << " at t=" << last_valid_time);
-
-				// FIXME: Traverse the changed value
-				loop->create_change(dependent, last_valid_time, 0);
-			}
-
-			++it;
-		}
-		else {
-			it = this->dependents.erase(it);
-		}
-	}
-}
-
-
-void EventTarget::add_dependent(const std::weak_ptr<Event> &event) {
-	this->dependents.emplace_back(event);
-}
-
-void EventTarget::show_dependents() const {
-	log::log(DBG << "Dependent list:");
-	for (auto &dep : this->dependents) {
-		auto dependent = dep.lock();
-		if (dependent) {
-			log::log(DBG << " - " << dependent->get_eventclass()->id());
-		}
-		else {
-			log::log(DBG << " - ** outdated old reference **");
-		}
-	}
-}
-
-} // openage::event
diff --git a/libopenage/event/loop.cpp b/libopenage/event/loop.cpp
index e02bb727b3..70666b8044 100644
--- a/libopenage/event/loop.cpp
+++ b/libopenage/event/loop.cpp
@@ -1,11 +1,11 @@
-// Copyright 2017-2018 the openage authors. See copying.md for legal info.
+// Copyright 2017-2019 the openage authors. See copying.md for legal info.
 
 #include "loop.h"
 
 #include "event.h"
-#include "eventclass.h"
+#include "eventhandler.h"
 #include "eventqueue.h"
-#include "eventtarget.h"
+#include "evententity.h"
 
 #include "../log/log.h"
 
@@ -13,19 +13,19 @@
 namespace openage::event {
 
 
-void Loop::add_event_class(const std::shared_ptr<EventClass> &cls) {
+void Loop::add_event_class(const std::shared_ptr<EventHandler> &cls) {
 	classstore.insert(std::make_pair(cls->id(), cls));
 }
 
 
-std::weak_ptr<Event> Loop::create_event(const std::string &name,
-                                        const std::shared_ptr<EventTarget> &target,
-                                        const std::shared_ptr<State> &state,
-                                        const curve::time_t &reference_time,
-                                        const EventClass::param_map &params) {
+std::shared_ptr<Event> Loop::create_event(const std::string &name,
+                                          const std::shared_ptr<EventEntity> &target,
+                                          const std::shared_ptr<State> &state,
+                                          const curve::time_t &reference_time,
+                                          const EventHandler::param_map &params) {
 	auto it = classstore.find(name);
 	if (it == classstore.end()) {
-		throw Error{MSG(err) << "Trying to subscribe to eventclass "
+		throw Error{MSG(err) << "Trying to subscribe to eventhandler "
 		                     << name << ", which does not exist."};
 	}
 
@@ -33,19 +33,19 @@ std::weak_ptr<Event> Loop::create_event(const std::string &name,
 }
 
 
-std::weak_ptr<Event> Loop::create_event(const std::shared_ptr<EventClass> &eventclass,
-                                        const std::shared_ptr<EventTarget> &target,
-                                        const std::shared_ptr<State> &state,
-                                        const curve::time_t &reference_time,
-                                        const EventClass::param_map &params) {
+std::shared_ptr<Event> Loop::create_event(const std::shared_ptr<EventHandler> &eventhandler,
+                                          const std::shared_ptr<EventEntity> &target,
+                                          const std::shared_ptr<State> &state,
+                                          const curve::time_t &reference_time,
+                                          const EventHandler::param_map &params) {
 
-	auto it = this->classstore.find(eventclass->id());
+	auto it = this->classstore.find(eventhandler->id());
 	if (it == this->classstore.end()) {
-		auto res = this->classstore.insert(std::make_pair(eventclass->id(), eventclass));
+		auto res = this->classstore.insert(std::make_pair(eventhandler->id(), eventhandler));
 		if (res.second) {
 			it = res.first;
 		} else {
-			throw Error{ERR << "could not insert eventclass into class store"};
+			throw Error{ERR << "could not insert eventhandler into class store"};
 		}
 	}
 
@@ -61,10 +61,18 @@ void Loop::reach_time(const curve::time_t &max_time,
 	// at least one processed event adds another event so
 	// the queue never stops adding changes
 	// simple "solution": abort after over 9000 attempts.
+	int max_attempts = 10;
 
 	int cnt = 0;
 	int attempts = 0;
+
 	do {
+		if (attempts > max_attempts) {
+			throw Error(ERR << "Loop: reached event settling threshold of "
+			            << max_attempts << ", giving up.");
+			break;
+		}
+
 		log::log(DBG << "Loop: Attempt " << attempts << " to reach t=" << max_time);
 		this->update_changes(state);
 		cnt = this->execute_events(max_time, state);
@@ -72,11 +80,6 @@ void Loop::reach_time(const curve::time_t &max_time,
 		log::log(DBG << "Loop: to reach t=" << max_time
 		         << ", n=" << cnt << " events were executed");
 
-		if (attempts > 9000) {
-			log::log(WARN << "Loop: reached event settling threshold, giving up.");
-			break;
-		}
-
 		attempts += 1;
 	} while (cnt != 0);
 
@@ -97,7 +100,7 @@ int Loop::execute_events(const curve::time_t &time_until,
 		size_t i = 0;
 		for (const auto &e : this->queue.get_event_queue().get_sorted_events()) {
 			log::log(DBG << "  event "
-			         << i << ": t=" << e->get_time() << ": " << e->get_eventclass()->id());
+			         << i << ": t=" << e->get_time() << ": " << e->get_eventhandler()->id());
 			i++;
 		}
 	}
@@ -111,17 +114,17 @@ int Loop::execute_events(const curve::time_t &time_until,
 			break;
 		}
 
-		auto target = event->get_target().lock();
+		auto target = event->get_entity().lock();
 
 		if (target) {
-			log::log(DBG << "Loop: invoking event \"" << event->get_eventclass()->id()
-			         << "\" on target \"" << target->id()
+			log::log(DBG << "Loop: invoking event \"" << event->get_eventhandler()->id()
+			         << "\" on target \"" << target->idstr()
 			         << "\" for time t=" << event->get_time());
 
 			this->active_event = event;
 
 			// apply the event effects
-			event->get_eventclass()->invoke(
+			event->get_eventhandler()->invoke(
 				*this, target, state,
 				event->get_time(), event->get_params()
 			);
@@ -130,16 +133,16 @@ int Loop::execute_events(const curve::time_t &time_until,
 			cnt += 1;
 
 			// if the event is REPEAT, readd the event.
-			if (event->get_eventclass()->type == EventClass::trigger_type::REPEAT) {
-				curve::time_t new_time = event->get_eventclass()->predict_invoke_time(
+			if (event->get_eventhandler()->type == EventHandler::trigger_type::REPEAT) {
+				curve::time_t new_time = event->get_eventhandler()->predict_invoke_time(
 					target, state, event->get_time()
 				);
 
 				if (new_time != std::numeric_limits<curve::time_t>::min()) {
 					event->set_time(new_time);
 
-					log::log(DBG << "Loop: repeating event \"" << event->get_eventclass()->id()
-					         << "\" on target \"" << target->id()
+					log::log(DBG << "Loop: repeating event \"" << event->get_eventhandler()->id()
+					         << "\" on target \"" << target->idstr()
 					         << "\" will be reenqueued for time t=" << event->get_time());
 
 					this->queue.reenqueue(event);
@@ -155,6 +158,12 @@ int Loop::execute_events(const curve::time_t &time_until,
 }
 
 
+void Loop::create_change(const std::shared_ptr<Event> &evnt,
+                         const curve::time_t &changes_at) {
+	this->queue.add_change(evnt, changes_at);
+}
+
+
 void Loop::update_changes(const std::shared_ptr<State> &state) {
 
 	log::log(DBG << "Loop: " << this->queue.get_changes().size()
@@ -162,50 +171,56 @@ void Loop::update_changes(const std::shared_ptr<State> &state) {
 
 	size_t i = 0;
 
-	// reevaluate depending events beecause of the change
+	// Some EventEntity has changed, so all depending events were
+	// added to the EventQueue as changes.
+	// These changes need to be reevaluated.
 	for (const auto &change : this->queue.get_changes()) {
 		auto evnt = change.evnt.lock();
 		if (evnt) {
-			log::log(DBG << "  change " << i++ << ": " << evnt->get_eventclass()->id());
-			switch(evnt->get_eventclass()->type) {
-			case EventClass::trigger_type::ONCE:
-			case EventClass::trigger_type::DEPENDENCY: {
-				auto target = evnt->get_target().lock();
-				// TODO what happens when the target is degraded?
+			log::log(DBG << "  change " << i++ << ": " << evnt->get_eventhandler()->id());
+			switch(evnt->get_eventhandler()->type) {
+			case EventHandler::trigger_type::ONCE:
+			case EventHandler::trigger_type::DEPENDENCY: {
+				auto entity = evnt->get_entity().lock();
 
-				if (target) {
-					curve::time_t new_time = evnt->get_eventclass()
-					                             ->predict_invoke_time(target, state, change.time);
+				if (entity) {
+					curve::time_t new_time = evnt->get_eventhandler()
+					                             ->predict_invoke_time(entity, state, change.time);
 
 					if (new_time != std::numeric_limits<curve::time_t>::min()) {
 						log::log(DBG << "Loop: due to a change, rescheduling event of '"
-						         << evnt->get_eventclass()->id()
-						         << "' on target '" << target->id()
+						         << evnt->get_eventhandler()->id()
+						         << "' on entity '" << entity->idstr()
 						         << "' at time t=" << change.time
 						         << " to NEW TIME t=" << new_time);
 
 						evnt->set_time(new_time);
 
-						this->queue.enqueue_change(evnt);
+						this->queue.enqueue(evnt);
 					}
 					else {
 						log::log(DBG << "Loop: due to a change, canceled execution of '"
-						         << evnt->get_eventclass()->id()
-						         << "' on target '" << target->id()
+						         << evnt->get_eventhandler()->id()
+						         << "' on entity '" << entity->idstr()
 						         << "' at time t=" << change.time);
 
 						this->queue.remove(evnt);
 					}
 				}
+				else {
+					// the event is for a no-longer-existing entity,
+					// so we can remove it from the queue.
+					this->queue.remove(evnt);
+				}
 			} break;
 
-			case EventClass::trigger_type::TRIGGER:
-			case EventClass::trigger_type::DEPENDENCY_IMMEDIATELY:
+			case EventHandler::trigger_type::TRIGGER:
+			case EventHandler::trigger_type::DEPENDENCY_IMMEDIATELY:
 				evnt->set_time(change.time);
-				this->queue.enqueue_change(evnt);
+				this->queue.enqueue(evnt);
 				break;
 
-			case EventClass::trigger_type::REPEAT:
+			case EventHandler::trigger_type::REPEAT:
 				break;
 			}
 		}
diff --git a/libopenage/event/loop.h b/libopenage/event/loop.h
index d0630f4ed4..5818171350 100644
--- a/libopenage/event/loop.h
+++ b/libopenage/event/loop.h
@@ -1,4 +1,4 @@
-// Copyright 2017-2018 the openage authors. See copying.md for legal info.
+// Copyright 2017-2019 the openage authors. See copying.md for legal info.
 
 #pragma once
 
@@ -9,7 +9,6 @@
 
 #include "../curve/curve.h"
 #include "eventqueue.h"
-#include "eventfilter.h"
 #include "event.h"
 #include "../log/log.h"
 
@@ -21,13 +20,13 @@ int curvepong();
 }
 
 class Event;
-class EventTarget;
+class EventEntity;
 class State;
 
 
 
 /**
- * The core class to manage event class and targets.
+ * The core class to manage event handler and targets.
  */
 class Loop {
 
@@ -35,8 +34,8 @@ class Loop {
 	friend int demo::curvepong();
 
 public:
-	/** register a new event class */
-	void add_event_class(const std::shared_ptr<EventClass> &cls);
+	/** register a new event handler */
+	void add_event_class(const std::shared_ptr<EventHandler> &cls);
 
 	/**
 	 * Add a new Event to the queue.
@@ -45,31 +44,22 @@ class Loop {
 	 *
 	 * The `reference_time` is used to calculate the actual event time.
 	 */
-	std::weak_ptr<Event> create_event(const std::string &name,
-	                                  const std::shared_ptr<EventTarget> &target,
-	                                  const std::shared_ptr<State> &state,
-	                                  const curve::time_t &reference_time,
-	                                  const EventClass::param_map &params=EventClass::param_map({}));
+	std::shared_ptr<Event> create_event(const std::string &name,
+	                                    const std::shared_ptr<EventEntity> &target,
+	                                    const std::shared_ptr<State> &state,
+	                                    const curve::time_t &reference_time,
+	                                    const EventHandler::param_map &params=EventHandler::param_map({}));
 
 	/**
-	 * This will generate a new randomly named eventclass for this specific element
+	 * This will generate a new randomly named eventhandler for this specific element
 	 *
 	 * The `reference_time` is used to determine the actual event trigger time.
 	 */
-	std::weak_ptr<Event> create_event(const std::shared_ptr<EventClass> &eventclass,
-	                                  const std::shared_ptr<EventTarget> &target,
-	                                  const std::shared_ptr<State> &state,
-	                                  const curve::time_t &reference_time,
-	                                  const EventClass::param_map &params=EventClass::param_map({}));
-
-	void onfilter(const std::shared_ptr<EventClass> &eventclass, const EventFilter &);
-
-	template <class evntclass_t>
-	void onfilter(const EventFilter &filter) {
-		this->onfilter(std::make_shared<evntclass_t>(), filter);
-	}
-
-	void register_object(const std::shared_ptr<EventTarget> &);
+	std::shared_ptr<Event> create_event(const std::shared_ptr<EventHandler> &eventhandler,
+	                                    const std::shared_ptr<EventEntity> &target,
+	                                    const std::shared_ptr<State> &state,
+	                                    const curve::time_t &reference_time,
+	                                    const EventHandler::param_map &params=EventHandler::param_map({}));
 
 	/**
 	 * Execute all events that are registered until a certain point in time.
@@ -79,15 +69,13 @@ class Loop {
 
 	/**
 	 * Register that a given event must be reevaluated at a time,
-	 * this usually happens because this event depended on an eventtarget
+	 * this usually happens because this event depended on an evententity
 	 * that got changed at this time.
 	 * This inserts the event into the changes queue
 	 * so it will be evaluated in the next loop iteration.
 	 */
-	template<class T>
 	void create_change(const std::shared_ptr<Event> &event,
-	                   const curve::time_t &changes_at,
-	                   const T &new_value);
+	                   const curve::time_t &changes_at);
 
 	const EventQueue &get_queue() const {
 		return this->queue;
@@ -108,15 +96,9 @@ class Loop {
 	void update_changes(const std::shared_ptr<State> &state);
 
 	/**
-	 * Here we do the bookkeeping of registered event classes.
-	 */
-	std::unordered_map<std::string, std::shared_ptr<EventClass>> classstore;
-
-	/**
-	 * Here we store all running filters that shall be applied whenever a new
-	 * obejct is added to our objectstore
+	 * Here we do the bookkeeping of registered event handleres.
 	 */
-	std::list<EventFilter> filters;
+	std::unordered_map<std::string, std::shared_ptr<EventHandler>> classstore;
 
 	/**
 	 * All events are enqueued here.
@@ -128,20 +110,6 @@ class Loop {
 	 * This is useful for event cancelations (so one can't cancel itself).
 	 */
 	std::shared_ptr<Event> active_event;
-
-	std::unordered_map<uint64_t, std::weak_ptr<EventTarget>> curveindex;
 };
 
-
-template <typename T>
-void Loop::create_change(const std::shared_ptr<Event> &evnt,
-                         const curve::time_t &changes_at,
-                         const T &new_value) {
-
-	log::log(DBG << "Loop: registering change of " << evnt->get_eventclass()->id()
-	         << " at t=" << changes_at << " to " << new_value);
-	this->queue.add_change(evnt, changes_at);
-}
-
-
 } // openage::event
diff --git a/libopenage/event/tests.cpp b/libopenage/event/tests.cpp
index 99e483a4eb..c6c0642fe4 100644
--- a/libopenage/event/tests.cpp
+++ b/libopenage/event/tests.cpp
@@ -1,15 +1,16 @@
 // Copyright 2017-2019 the openage authors. See copying.md for legal info.
 
-#include <cstring> // for strcmp
+#include <cstring>
 #include <iostream>
 #include <utility>
+#include <sstream>
 
 #include "../testing/testing.h"
 #include "../log/log.h"
 
 #include "loop.h"
 #include "event.h"
-#include "eventtarget.h"
+#include "evententity.h"
 #include "state.h"
 
 
@@ -18,12 +19,12 @@ namespace openage::event::tests {
 // We have to create a temporary State due to the magic of C++
 class TestState : public State {
 public:
-	class TestObject : public EventTarget {
+	class TestObject : public EventEntity {
 		const int _id;
 	public:
 		TestObject(const std::shared_ptr<Loop> &loop, int id)
 			:
-			EventTarget(loop),
+			EventEntity(loop),
 			_id{id},
 			number(0) {}
 
@@ -36,6 +37,12 @@ class TestState : public State {
 			return _id;
 		}
 
+		std::string idstr() const override {
+			std::stringstream ss;
+			ss << "TestObject[" << this->id() << "]";
+			return ss.str();
+		}
+
 		void test_trigger(const curve::time_t &time) {
 			this->trigger(time);
 		}
@@ -73,12 +80,12 @@ class TestState : public State {
 };
 
 
-class TestEventClass : public EventClass {
+class TestEventHandler : public EventHandler {
 	int idx;
 public:
-	TestEventClass(const std::string &name, int idx)
+	TestEventHandler(const std::string &name, int idx)
 		:
-		EventClass(name, EventClass::trigger_type::DEPENDENCY),
+		EventHandler(name, EventHandler::trigger_type::DEPENDENCY),
 		idx{idx} {}
 
 	void setup_event(const std::shared_ptr<Event> &event,
@@ -99,10 +106,10 @@ class TestEventClass : public EventClass {
 	}
 
 	void invoke(Loop &/*loop*/,
-	            const std::shared_ptr<EventTarget> &target,
+	            const std::shared_ptr<EventEntity> &target,
 	            const std::shared_ptr<State> &gstate,
 	            const curve::time_t &time,
-	            const EventClass::param_map &/*param*/) override {
+	            const EventHandler::param_map &/*param*/) override {
 
 		auto state = std::dynamic_pointer_cast<TestState>(gstate);
 
@@ -123,7 +130,7 @@ class TestEventClass : public EventClass {
 		}
 	}
 
-	curve::time_t predict_invoke_time(const std::shared_ptr<EventTarget> &/*target*/,
+	curve::time_t predict_invoke_time(const std::shared_ptr<EventEntity> &/*target*/,
 	                                  const std::shared_ptr<State> &/*state*/,
 	                                  const curve::time_t &at) override {
 		return at + curve::time_t::from_double(2);
@@ -131,11 +138,11 @@ class TestEventClass : public EventClass {
 };
 
 
-class TestEventClassTwo : public EventClass {
+class TestEventHandlerTwo : public EventHandler {
 public:
-	explicit TestEventClassTwo(const std::string &name)
+	explicit TestEventHandlerTwo(const std::string &name)
 		:
-		EventClass(name, EventClass::trigger_type::DEPENDENCY) {}
+		EventHandler(name, EventHandler::trigger_type::DEPENDENCY) {}
 
 	void setup_event(const std::shared_ptr<Event> &target,
 	                 const std::shared_ptr<State> &gstate) override {
@@ -145,20 +152,20 @@ class TestEventClassTwo : public EventClass {
 	}
 
 	void invoke(Loop &/*loop*/,
-	            const std::shared_ptr<EventTarget> &gtarget,
+	            const std::shared_ptr<EventEntity> &gtarget,
 	            const std::shared_ptr<State> &gstate,
 	            const curve::time_t &time,
-	            const EventClass::param_map &/*param*/) override {
+	            const EventHandler::param_map &/*param*/) override {
 
 		auto state = std::dynamic_pointer_cast<TestState>(gstate);
 		auto target = std::dynamic_pointer_cast<TestState::TestObject>(gtarget);
 		state->objectB->set_number(target->number + 1, time);
 
-		log::log(DBG << "I am EventClassTwo. Setting B.number to " << state->objectB->number);
+		log::log(DBG << "I am EventHandlerTwo. Setting B.number to " << state->objectB->number);
 		state->trace.emplace_back("B", time);
 	}
 
-	curve::time_t predict_invoke_time(const std::shared_ptr<EventTarget> &/*target*/,
+	curve::time_t predict_invoke_time(const std::shared_ptr<EventEntity> &/*target*/,
 	                                  const std::shared_ptr<State> &/*state*/,
 	                                  const curve::time_t &at) override {
 		// TODO recalculate a hit time
@@ -167,11 +174,11 @@ class TestEventClassTwo : public EventClass {
 };
 
 
-class EventTypeTestClass : public EventClass {
+class EventTypeTestClass : public EventHandler {
 public:
-	EventTypeTestClass(const std::string &name, EventClass::trigger_type type)
+	EventTypeTestClass(const std::string &name, EventHandler::trigger_type type)
 		:
-		EventClass(name, type) {}
+		EventHandler(name, type) {}
 
 	void setup_event(const std::shared_ptr<Event> &event,
 	                 const std::shared_ptr<State> &gstate) override {
@@ -184,10 +191,10 @@ class EventTypeTestClass : public EventClass {
 	}
 
 	void invoke(Loop &/*loop*/,
-	            const std::shared_ptr<EventTarget> &target,
+	            const std::shared_ptr<EventEntity> &target,
 	            const std::shared_ptr<State> &gstate,
 	            const curve::time_t &time,
-	            const EventClass::param_map &/*param*/) override {
+	            const EventHandler::param_map &/*param*/) override {
 
 		auto state = std::dynamic_pointer_cast<TestState>(gstate);
 
@@ -198,27 +205,27 @@ class EventTypeTestClass : public EventClass {
 		state->trace.emplace_back(this->id(), time);
 	}
 
-	curve::time_t predict_invoke_time(const std::shared_ptr<EventTarget> &/*target*/,
+	curve::time_t predict_invoke_time(const std::shared_ptr<EventEntity> &/*target*/,
 	                                  const std::shared_ptr<State> &/*state*/,
 	                                  const curve::time_t &at) override {
 		switch(this->type) {
-		case EventClass::trigger_type::DEPENDENCY:
+		case EventHandler::trigger_type::DEPENDENCY:
 			// Execute 1 after the change (usually it is neccessary to recalculate a collision
 			return at + curve::time_t::from_double(1);
 
-		case EventClass::trigger_type::DEPENDENCY_IMMEDIATELY:
+		case EventHandler::trigger_type::DEPENDENCY_IMMEDIATELY:
 			TESTFAILMSG("DEPENDENCY_IMMEDIATELY does not recalculate time!");
 			return 0;
 
-		case EventClass::trigger_type::TRIGGER:
+		case EventHandler::trigger_type::TRIGGER:
 			TESTFAILMSG("TRIGGER does not recalculate time!");
 			return 0;
 
-		case EventClass::trigger_type::REPEAT:
+		case EventHandler::trigger_type::REPEAT:
 			// This will force the execution every 5ms
 			return at + curve::time_t::from_double(5);
 
-		case EventClass::trigger_type::ONCE:
+		case EventHandler::trigger_type::ONCE:
 			return 10;  // even if data changed it will happen at the given time!
 		}
 		return at;
@@ -233,11 +240,11 @@ void eventtrigger() {
 	std::weak_ptr<TestState> destruction_test_state;
 
 	{
-		// Test with one event class
+		// Test with one event handler
 		auto loop = std::make_shared<Loop>();
 
-		loop->add_event_class(std::make_shared<TestEventClass>("test_on_A", 0));
-		loop->add_event_class(std::make_shared<TestEventClass>("test_on_B", 1));
+		loop->add_event_class(std::make_shared<TestEventHandler>("test_on_A", 0));
+		loop->add_event_class(std::make_shared<TestEventHandler>("test_on_B", 1));
 
 		auto state = std::make_shared<TestState>(loop);
 		auto gstate = std::static_pointer_cast<State>(state);
@@ -292,11 +299,11 @@ void eventtrigger() {
 
 	log::log(DBG << "------------- [ Starting Test: Two Event Ping Pong ] ------------");
 	{
-		// Test with two event classes to check interplay
+		// Test with two event handleres to check interplay
 		auto loop = std::make_shared<Loop>();
 
-		loop->add_event_class(std::make_shared<TestEventClass>("test_on_A", 0));
-		loop->add_event_class(std::make_shared<TestEventClassTwo>("test_on_B"));
+		loop->add_event_class(std::make_shared<TestEventHandler>("test_on_A", 0));
+		loop->add_event_class(std::make_shared<TestEventHandlerTwo>("test_on_B"));
 
 		auto state = std::make_shared<TestState>(loop);
 		auto gstate = std::static_pointer_cast<State>(state);
@@ -350,19 +357,19 @@ void eventtrigger() {
 
 		loop->add_event_class(std::make_shared<EventTypeTestClass>(
 			                         "object_modify",
-			                         EventClass::trigger_type::DEPENDENCY));
+			                         EventHandler::trigger_type::DEPENDENCY));
 		loop->add_event_class(std::make_shared<EventTypeTestClass>(
 			                         "object_modify_immediately",
-			                         EventClass::trigger_type::DEPENDENCY_IMMEDIATELY));
+			                         EventHandler::trigger_type::DEPENDENCY_IMMEDIATELY));
 		loop->add_event_class(std::make_shared<EventTypeTestClass>(
 			                         "object_trigger",
-			                         EventClass::trigger_type::TRIGGER));
+			                         EventHandler::trigger_type::TRIGGER));
 		loop->add_event_class(std::make_shared<EventTypeTestClass>(
 			                         "repeat_exec",
-			                         EventClass::trigger_type::REPEAT));
+			                         EventHandler::trigger_type::REPEAT));
 		loop->add_event_class(std::make_shared<EventTypeTestClass>(
 			                         "once",
-			                         EventClass::trigger_type::ONCE));
+			                         EventHandler::trigger_type::ONCE));
 
 		auto state = std::make_shared<TestState>(loop);
 		auto gstate = std::static_pointer_cast<State>(state);
@@ -489,20 +496,20 @@ void eventtrigger() {
 
 	log::log(DBG << "------------- [ Starting Test: Event parameter Mapping ] ------------");
 	{
-		class EventParameterMapTestClass : public EventClass {
+		class EventParameterMapTestClass : public EventHandler {
 		public:
 			EventParameterMapTestClass()
 				:
-				EventClass("EventParameterMap", EventClass::trigger_type::ONCE) {}
+				EventHandler("EventParameterMap", EventHandler::trigger_type::ONCE) {}
 
 			void setup_event(const std::shared_ptr<Event> &/*target*/,
 			                 const std::shared_ptr<State> &/*state*/) override {}
 
 			void invoke(Loop &/*loop*/,
-			            const std::shared_ptr<EventTarget> &/*target*/,
+			            const std::shared_ptr<EventEntity> &/*target*/,
 			            const std::shared_ptr<State> &/*state*/,
 			            const curve::time_t &/*time*/,
-			            const EventClass::param_map &param) override {
+			            const EventHandler::param_map &param) override {
 
 				log::log(DBG << "Testing unknown parameter");
 				TESTEQUALS(param.contains("tomato"), false);
@@ -516,7 +523,6 @@ void eventtrigger() {
 				TESTEQUALS(param.contains("testInt"), true);
 				TESTEQUALS(param.check_type<int>("testInt"), true);
 				TESTEQUALS(param.get<int>("testInt"), 1);
-				// FIXME: This should hurt you!!!
 				TESTEQUALS(param.get<std::string>("testInt", "int"), "int");
 
 				log::log(DBG << "Testing char* parameter");
@@ -530,7 +536,7 @@ void eventtrigger() {
 				TESTEQUALS(param.get<std::string>("testStdString"), "stdstring");
 			}
 
-			curve::time_t predict_invoke_time(const std::shared_ptr<EventTarget> &/*target*/,
+			curve::time_t predict_invoke_time(const std::shared_ptr<EventEntity> &/*target*/,
 			                                  const std::shared_ptr<State> &/*state*/,
 			                                  const curve::time_t &at) override {
 				return at;
diff --git a/libopenage/game_control.cpp b/libopenage/game_control.cpp
index eb230b4dfb..af83cb60e4 100644
--- a/libopenage/game_control.cpp
+++ b/libopenage/game_control.cpp
@@ -1,10 +1,10 @@
-// Copyright 2015-2019 the openage authors. See copying.md for legal info.
+// Copyright 2015-2021 the openage authors. See copying.md for legal info.
 
 #include "game_control.h"
 
 #include "engine.h"
 #include "error/error.h"
-#include "gamestate/game_spec.h"
+#include "gamestate/old/game_spec.h"
 #include "log/log.h"
 #include "renderer/color.h"
 #include "terrain/terrain_chunk.h"
diff --git a/libopenage/game_control.h b/libopenage/game_control.h
index b6e54f5063..8419b5b304 100644
--- a/libopenage/game_control.h
+++ b/libopenage/game_control.h
@@ -1,4 +1,4 @@
-// Copyright 2015-2019 the openage authors. See copying.md for legal info.
+// Copyright 2015-2021 the openage authors. See copying.md for legal info.
 
 #pragma once
 
@@ -9,7 +9,7 @@
 #include "coord/pixel.h"
 #include "input/input_context.h"
 #include "rng/rng.h"
-#include "gamestate/game_main.h"
+#include "gamestate/old/game_main.h"
 #include "unit/command.h"
 #include "unit/selection.h"
 #include "unit/unit_type.h"
diff --git a/libopenage/game_renderer.cpp b/libopenage/game_renderer.cpp
index 0ec11be194..45a694ecee 100644
--- a/libopenage/game_renderer.cpp
+++ b/libopenage/game_renderer.cpp
@@ -1,4 +1,4 @@
-// Copyright 2015-2019 the openage authors. See copying.md for legal info.
+// Copyright 2015-2021 the openage authors. See copying.md for legal info.
 
 #include <epoxy/gl.h>
 #include <SDL2/SDL.h>
@@ -9,8 +9,8 @@
 #include "console/console.h"
 #include "engine.h"
 #include "gamedata/color.gen.h"
-#include "gamestate/game_main.h"
-#include "gamestate/game_spec.h"
+#include "gamestate/old/game_main.h"
+#include "gamestate/old/game_spec.h"
 #include "input/input_manager.h"
 #include "log/log.h"
 #include "terrain/terrain.h"
diff --git a/libopenage/gamestate/CMakeLists.txt b/libopenage/gamestate/CMakeLists.txt
index 87dffe21d7..c6b1116d01 100644
--- a/libopenage/gamestate/CMakeLists.txt
+++ b/libopenage/gamestate/CMakeLists.txt
@@ -1,14 +1,11 @@
 add_sources(libopenage
-	civilisation.cpp
-	cost.cpp
-	game_main.cpp
-	game_save.cpp
-	game_spec.cpp
-	generator.cpp
-	market.cpp
+	game.cpp
 	player.cpp
-	population_tracker.cpp
-	score.cpp
-	team.cpp
-	resource.cpp
+	terrain.cpp
+	terrain_chunk.cpp
+	types.cpp
+	world.cpp
 )
+
+# TODO: remove once migration is done.
+add_subdirectory(old/)
diff --git a/libopenage/gamestate/game.cpp b/libopenage/gamestate/game.cpp
new file mode 100644
index 0000000000..bf55d0b962
--- /dev/null
+++ b/libopenage/gamestate/game.cpp
@@ -0,0 +1,8 @@
+// Copyright 2018-2018 the openage authors. See copying.md for legal info.
+
+#include "game.h"
+
+namespace openage::gamestate {
+
+
+} // openage::gamestate
diff --git a/libopenage/gamestate/game.h b/libopenage/gamestate/game.h
new file mode 100644
index 0000000000..dfc0088feb
--- /dev/null
+++ b/libopenage/gamestate/game.h
@@ -0,0 +1,14 @@
+// Copyright 2018-2018 the openage authors. See copying.md for legal info.
+
+#pragma once
+
+#include "world.h"
+
+namespace openage::gamestate {
+
+class Game {
+public:
+	World world;
+};
+
+} // openage
diff --git a/libopenage/gamestate/old/CMakeLists.txt b/libopenage/gamestate/old/CMakeLists.txt
new file mode 100644
index 0000000000..87dffe21d7
--- /dev/null
+++ b/libopenage/gamestate/old/CMakeLists.txt
@@ -0,0 +1,14 @@
+add_sources(libopenage
+	civilisation.cpp
+	cost.cpp
+	game_main.cpp
+	game_save.cpp
+	game_spec.cpp
+	generator.cpp
+	market.cpp
+	player.cpp
+	population_tracker.cpp
+	score.cpp
+	team.cpp
+	resource.cpp
+)
diff --git a/libopenage/gamestate/civilisation.cpp b/libopenage/gamestate/old/civilisation.cpp
similarity index 91%
rename from libopenage/gamestate/civilisation.cpp
rename to libopenage/gamestate/old/civilisation.cpp
index 8c92b802ee..6139ed23fe 100644
--- a/libopenage/gamestate/civilisation.cpp
+++ b/libopenage/gamestate/old/civilisation.cpp
@@ -1,9 +1,9 @@
-// Copyright 2015-2017 the openage authors. See copying.md for legal info.
+// Copyright 2015-2018 the openage authors. See copying.md for legal info.
 
 #include "civilisation.h"
 
-#include "../log/log.h"
-#include "../unit/unit_type.h"
+#include "../../log/log.h"
+#include "../../unit/unit_type.h"
 
 
 namespace openage {
diff --git a/libopenage/gamestate/civilisation.h b/libopenage/gamestate/old/civilisation.h
similarity index 95%
rename from libopenage/gamestate/civilisation.h
rename to libopenage/gamestate/old/civilisation.h
index 2e88a1a8fd..97045031ea 100644
--- a/libopenage/gamestate/civilisation.h
+++ b/libopenage/gamestate/old/civilisation.h
@@ -1,4 +1,4 @@
-// Copyright 2015-2017 the openage authors. See copying.md for legal info.
+// Copyright 2015-2019 the openage authors. See copying.md for legal info.
 
 #pragma once
 
diff --git a/libopenage/gamestate/cost.cpp b/libopenage/gamestate/old/cost.cpp
similarity index 93%
rename from libopenage/gamestate/cost.cpp
rename to libopenage/gamestate/old/cost.cpp
index 39c535e4d4..089cb6da4b 100644
--- a/libopenage/gamestate/cost.cpp
+++ b/libopenage/gamestate/old/cost.cpp
@@ -1,4 +1,4 @@
-// Copyright 2017-2019 the openage authors. See copying.md for legal info.
+// Copyright 2017-2021 the openage authors. See copying.md for legal info.
 
 #include "cost.h"
 #include "player.h"
diff --git a/libopenage/gamestate/cost.h b/libopenage/gamestate/old/cost.h
similarity index 93%
rename from libopenage/gamestate/cost.h
rename to libopenage/gamestate/old/cost.h
index 648dffbead..749aa50986 100644
--- a/libopenage/gamestate/cost.h
+++ b/libopenage/gamestate/old/cost.h
@@ -1,4 +1,4 @@
-// Copyright 2017-2017 the openage authors. See copying.md for legal info.
+// Copyright 2017-2019 the openage authors. See copying.md for legal info.
 
 #pragma once
 
diff --git a/libopenage/gamestate/game_main.cpp b/libopenage/gamestate/old/game_main.cpp
similarity index 92%
rename from libopenage/gamestate/game_main.cpp
rename to libopenage/gamestate/old/game_main.cpp
index fe275e60b3..80f0dcf534 100644
--- a/libopenage/gamestate/game_main.cpp
+++ b/libopenage/gamestate/old/game_main.cpp
@@ -1,11 +1,11 @@
-// Copyright 2014-2019 the openage authors. See copying.md for legal info.
+// Copyright 2014-2021 the openage authors. See copying.md for legal info.
 
 #include "game_main.h"
 
-#include "../engine.h"
-#include "../log/log.h"
-#include "../terrain/terrain.h"
-#include "../unit/unit_type.h"
+#include "../../engine.h"
+#include "../../log/log.h"
+#include "../../terrain/terrain.h"
+#include "../../unit/unit_type.h"
 #include "game_spec.h"
 #include "generator.h"
 
diff --git a/libopenage/gamestate/game_main.h b/libopenage/gamestate/old/game_main.h
similarity index 95%
rename from libopenage/gamestate/game_main.h
rename to libopenage/gamestate/old/game_main.h
index 29580eaa03..56d803f52f 100644
--- a/libopenage/gamestate/game_main.h
+++ b/libopenage/gamestate/old/game_main.h
@@ -11,10 +11,10 @@
 #include "market.h"
 #include "player.h"
 #include "team.h"
-#include "../options.h"
-#include "../terrain/terrain.h"
-#include "../unit/unit_container.h"
-#include "../util/timing.h"
+#include "../../options.h"
+#include "../../terrain/terrain.h"
+#include "../../unit/unit_container.h"
+#include "../../util/timing.h"
 
 
 namespace openage {
diff --git a/libopenage/gamestate/game_save.cpp b/libopenage/gamestate/old/game_save.cpp
similarity index 92%
rename from libopenage/gamestate/game_save.cpp
rename to libopenage/gamestate/old/game_save.cpp
index 68d8b7015e..47d598530b 100644
--- a/libopenage/gamestate/game_save.cpp
+++ b/libopenage/gamestate/old/game_save.cpp
@@ -1,16 +1,17 @@
-// Copyright 2015-2020 the openage authors. See copying.md for legal info.
+// Copyright 2015-2021 the openage authors. See copying.md for legal info.
 
 #include "game_save.h"
 
 #include <fstream>
 #include <vector>
 
-#include "../log/log.h"
-#include "../terrain/terrain_chunk.h"
-#include "../unit/producer.h"
-#include "../unit/unit.h"
-#include "../unit/unit_type.h"
-#include "../versions/compiletime.h"
+#include "version.h"
+#include "../../log/log.h"
+#include "../../terrain/terrain_chunk.h"
+#include "../../unit/producer.h"
+#include "../../unit/unit.h"
+#include "../../unit/unit_type.h"
+#include "../../versions/compiletime.h"
 #include "game_main.h"
 #include "game_save.h"
 #include "game_spec.h"
diff --git a/libopenage/gamestate/game_save.h b/libopenage/gamestate/old/game_save.h
similarity index 87%
rename from libopenage/gamestate/game_save.h
rename to libopenage/gamestate/old/game_save.h
index 86fdd50c0c..36ddb49b82 100644
--- a/libopenage/gamestate/game_save.h
+++ b/libopenage/gamestate/old/game_save.h
@@ -1,4 +1,4 @@
-// Copyright 2015-2019 the openage authors. See copying.md for legal info.
+// Copyright 2015-2021 the openage authors. See copying.md for legal info.
 
 #pragma once
 
diff --git a/libopenage/gamestate/game_spec.cpp b/libopenage/gamestate/old/game_spec.cpp
similarity index 96%
rename from libopenage/gamestate/game_spec.cpp
rename to libopenage/gamestate/old/game_spec.cpp
index fd06086ab2..644aa985e8 100644
--- a/libopenage/gamestate/game_spec.cpp
+++ b/libopenage/gamestate/old/game_spec.cpp
@@ -1,22 +1,22 @@
-// Copyright 2015-2020 the openage authors. See copying.md for legal info.
+// Copyright 2015-2021 the openage authors. See copying.md for legal info.
 
 #include "game_spec.h"
 
 #include <tuple>
 
-#include "../assetmanager.h"
-#include "../audio/error.h"
-#include "../audio/resource_def.h"
-#include "../engine.h"
-#include "../gamedata/blending_mode.gen.h"
-#include "../gamedata/string_resource.gen.h"
-#include "../gamedata/terrain.gen.h"
-#include "../log/log.h"
-#include "../rng/global_rng.h"
-#include "../unit/producer.h"
-#include "../util/compiler.h"
-#include "../util/strings.h"
-#include "../util/timer.h"
+#include "../../assetmanager.h"
+#include "../../audio/error.h"
+#include "../../audio/resource_def.h"
+#include "../../engine.h"
+#include "../../gamedata/blending_mode.gen.h"
+#include "../../gamedata/string_resource.gen.h"
+#include "../../gamedata/terrain.gen.h"
+#include "../../log/log.h"
+#include "../../rng/global_rng.h"
+#include "../../unit/producer.h"
+#include "../../util/compiler.h"
+#include "../../util/strings.h"
+#include "../../util/timer.h"
 #include "civilisation.h"
 
 
diff --git a/libopenage/gamestate/game_spec.h b/libopenage/gamestate/old/game_spec.h
similarity index 95%
rename from libopenage/gamestate/game_spec.h
rename to libopenage/gamestate/old/game_spec.h
index 566c693fd8..1ddadd1c7b 100644
--- a/libopenage/gamestate/game_spec.h
+++ b/libopenage/gamestate/old/game_spec.h
@@ -1,13 +1,14 @@
-// Copyright 2015-2017 the openage authors. See copying.md for legal info.
+// Copyright 2015-2018 the openage authors. See copying.md for legal info.
 
 #pragma once
 
-#include "../job/job.h"
-#include "../gamedata/gamedata.gen.h"
-#include "../gamedata/graphic.gen.h"
-#include "../terrain/terrain.h"
-#include "../unit/unit_texture.h"
-#include "../util/csv.h"
+#include "../types.h"
+#include "../../job/job.h"
+#include "../../gamedata/gamedata.gen.h"
+#include "../../gamedata/graphic.gen.h"
+#include "../../terrain/terrain.h"
+#include "../../unit/unit_texture.h"
+#include "../../util/csv.h"
 
 #include <unordered_map>
 #include <memory>
@@ -23,12 +24,6 @@ class UnitTypeMeta;
 class Player;
 
 
-/**
- * the key type mapped to data objects
- */
-using index_t = int;
-
-
 /**
  * could use unique ptr
  */
diff --git a/libopenage/gamestate/generator.cpp b/libopenage/gamestate/old/generator.cpp
similarity index 97%
rename from libopenage/gamestate/generator.cpp
rename to libopenage/gamestate/old/generator.cpp
index 084ee5604c..b60ce1ffd7 100644
--- a/libopenage/gamestate/generator.cpp
+++ b/libopenage/gamestate/old/generator.cpp
@@ -1,12 +1,12 @@
-// Copyright 2015-2019 the openage authors. See copying.md for legal info.
+// Copyright 2015-2021 the openage authors. See copying.md for legal info.
 
 #include "generator.h"
 
-#include "../log/log.h"
-#include "../rng/rng.h"
-#include "../terrain/terrain_chunk.h"
-#include "../unit/unit.h"
-#include "../util/math_constants.h"
+#include "../../log/log.h"
+#include "../../rng/rng.h"
+#include "../../terrain/terrain_chunk.h"
+#include "../../unit/unit.h"
+#include "../../util/math_constants.h"
 #include "game_main.h"
 #include "game_save.h"
 #include "game_spec.h"
diff --git a/libopenage/gamestate/generator.h b/libopenage/gamestate/old/generator.h
similarity index 95%
rename from libopenage/gamestate/generator.h
rename to libopenage/gamestate/old/generator.h
index f4cee94183..a2d4bf58b7 100644
--- a/libopenage/gamestate/generator.h
+++ b/libopenage/gamestate/old/generator.h
@@ -1,11 +1,11 @@
-// Copyright 2015-2016 the openage authors. See copying.md for legal info.
+// Copyright 2015-2019 the openage authors. See copying.md for legal info.
 
 #pragma once
 
 #include <unordered_set>
 
-#include "../coord/tile.h"
-#include "../gui/guisys/public/gui_property_map.h"
+#include "../../coord/tile.h"
+#include "../../gui/guisys/public/gui_property_map.h"
 
 namespace qtsdl {
 class GuiItemLink;
diff --git a/libopenage/gamestate/market.cpp b/libopenage/gamestate/old/market.cpp
similarity index 97%
rename from libopenage/gamestate/market.cpp
rename to libopenage/gamestate/old/market.cpp
index 4d580bcd88..4b1d50bc24 100644
--- a/libopenage/gamestate/market.cpp
+++ b/libopenage/gamestate/old/market.cpp
@@ -1,4 +1,4 @@
-// Copyright 2017-2017 the openage authors. See copying.md for legal info.
+// Copyright 2017-2019 the openage authors. See copying.md for legal info.
 
 #include "player.h"
 #include "market.h"
diff --git a/libopenage/gamestate/market.h b/libopenage/gamestate/old/market.h
similarity index 95%
rename from libopenage/gamestate/market.h
rename to libopenage/gamestate/old/market.h
index 93b997eaa3..643668fe59 100644
--- a/libopenage/gamestate/market.h
+++ b/libopenage/gamestate/old/market.h
@@ -1,4 +1,4 @@
-// Copyright 2017-2017 the openage authors. See copying.md for legal info.
+// Copyright 2017-2019 the openage authors. See copying.md for legal info.
 
 #pragma once
 
diff --git a/libopenage/gamestate/old/player.cpp b/libopenage/gamestate/old/player.cpp
new file mode 100644
index 0000000000..ed6bd9e8b9
--- /dev/null
+++ b/libopenage/gamestate/old/player.cpp
@@ -0,0 +1,291 @@
+// Copyright 2015-2018 the openage authors. See copying.md for legal info.
+
+#include "player.h"
+
+#include <utility>
+
+#include "../../log/log.h"
+#include "../../unit/unit.h"
+#include "../../unit/unit_type.h"
+#include "../../util/math_constants.h"
+#include "team.h"
+
+
+namespace openage {
+
+Player::Player(Civilisation *civ, unsigned int number, std::string name)
+	:
+	player_number{number},
+	color{number},
+	civ{civ},
+	name{std::move(name)},
+	team{nullptr},
+	population{0, 200}, // TODO change, get population cap max from game options
+	score{this},
+	age{1} { // TODO change, get starting age from game options
+	// starting resources
+	// TODO change, get starting resources from game options
+	this->resources.set_all(1000);
+	// TODO change, get starting resources capacity from game options or nyan
+	this->resources_capacity.set_all(math::DOUBLE_INF / 2); // half to avoid overflows
+	this->on_resources_change();
+}
+
+bool Player::operator ==(const Player &other) const {
+	return this->player_number == other.player_number;
+}
+
+bool Player::is_enemy(const Player &other) const {
+
+	return !this->is_ally(other);
+}
+
+bool Player::is_ally(const Player &other) const {
+
+	if (this->player_number == other.player_number) {
+		return true; // same player
+	}
+
+	if (this->team && this->team->is_member(other)) {
+		return true; // same team
+	}
+
+	// everyone else is enemy
+	return false;
+}
+
+bool Player::owns(Unit &unit) const {
+	if (unit.has_attribute(attr_type::owner)) {
+		return this == &unit.get_attribute<attr_type::owner>().player;
+	}
+	return false;
+}
+
+void Player::receive(const ResourceBundle& amount) {
+	this->resources += amount;
+	this->on_resources_change();
+}
+
+void Player::receive(const game_resource resource, double amount) {
+	this->resources[resource] += amount;
+	this->on_resources_change();
+}
+
+bool Player::can_receive(const ResourceBundle& amount) const {
+	return this->resources_capacity.has(this->resources, amount);
+}
+
+bool Player::can_receive(const game_resource resource, double amount) const {
+	return this->resources_capacity.get(resource) >= this->resources.get(resource) + amount;
+}
+
+bool Player::deduct(const ResourceBundle& amount) {
+	if (this->resources.deduct(amount)) {
+		this->on_resources_change();
+		return true;
+	}
+	return false;
+}
+
+bool Player::deduct(const game_resource resource, double amount) {
+	if (this->resources[resource] >= amount) {
+		this->resources[resource] -= amount;
+		this->on_resources_change();
+		return true;
+	}
+	return false;
+}
+
+bool Player::can_deduct(const ResourceBundle& amount) const {
+	return this->resources.has(amount);
+}
+
+bool Player::can_deduct(const game_resource resource, double amount) const {
+	return this->resources.get(resource) >= amount;
+}
+
+double Player::amount(const game_resource resource) const {
+	return this->resources.get(resource);
+}
+
+bool Player::can_make(const UnitType &type) const {
+	return this->can_deduct(type.cost.get(*this)) &&
+	       this->get_units_have(type.id()) + this->get_units_pending(type.id()) < type.have_limit &&
+	       this->get_units_had(type.id()) + this->get_units_pending(type.id()) < type.had_limit;
+}
+
+size_t Player::type_count() {
+	return this->available_ids.size();
+}
+
+UnitType *Player::get_type(index_t type_id) const {
+	if (this->available_ids.count(type_id) == 0) {
+		if (type_id > 0) {
+			log::log(MSG(info) << "  -> ignoring type_id: " << type_id);
+		}
+		return nullptr;
+	}
+	return this->available_ids.at(type_id);
+}
+
+UnitType *Player::get_type_index(size_t type_index) const {
+	if (type_index < available_objects.size()) {
+		return available_objects.at(type_index).get();
+	}
+	log::log(MSG(info) << "  -> ignoring type_index: " << type_index);
+	return nullptr;
+}
+
+
+void Player::initialise_unit_types() {
+	log::log(MSG(info) << name << " has civilisation " << this->civ->civ_name);
+	for (auto &type : this->civ->object_meta()) {
+		auto shared_type = type->init(*this);
+		index_t id = shared_type->id();
+		this->available_objects.emplace_back(shared_type);
+		this->available_ids[id] = shared_type.get();
+	}
+}
+
+void Player::active_unit_added(Unit *unit, bool from_pending) {
+	// check if unit is actually active
+	if (this->is_unit_pending(unit)) {
+		this->units_pending[unit->unit_type->id()] += 1;
+		return;
+	}
+
+	if (from_pending) {
+		this->units_pending[unit->unit_type->id()] -= 1;
+	}
+
+	this->units_have[unit->unit_type->id()] += 1;
+	this->units_had[unit->unit_type->id()] += 1;
+	// TODO handle here building dependencies
+
+	// population
+	if (unit->has_attribute(attr_type::population)) {
+		auto popul = unit->get_attribute<attr_type::population>();
+		if (popul.demand > 0) {
+			this->population.demand_population(popul.demand);
+		}
+		if (popul.capacity > 0) {
+			this->population.add_capacity(popul.capacity);
+		}
+	}
+
+	// resources capacity
+	if (unit->has_attribute(attr_type::storage)) {
+		auto storage = unit->get_attribute<attr_type::storage>();
+		this->resources_capacity += storage.capacity;
+		this->on_resources_change();
+	}
+
+	// score
+	// TODO improve selectors
+	if (unit->unit_type->id() == 82 || unit->unit_type->id() == 276) { // Castle, Wonder
+		this->score.add_score(score_category::society, unit->unit_type->cost.get(*this).sum() * 0.2);
+	} else if (unit->has_attribute(attr_type::building) || unit->has_attribute(attr_type::population)) { // building, living
+		this->score.add_score(score_category::economy, unit->unit_type->cost.get(*this).sum() * 0.2);
+	}
+
+	// TODO handle here on create unit triggers
+	// TODO check for unit based win conditions
+}
+
+void Player::active_unit_removed(Unit *unit) {
+	// check if unit is actually active
+	if (this->is_unit_pending(unit)) {
+		this->units_pending[unit->unit_type->id()] -= 1;
+		return;
+	}
+
+	this->units_have[unit->unit_type->id()] -= 1;
+	// TODO handle here building dependencies
+
+	// population
+	if (unit->has_attribute(attr_type::population)) {
+		auto popul = unit->get_attribute<attr_type::population>();
+		if (popul.demand > 0) {
+			this->population.free_population(popul.demand);
+		}
+		if (popul.capacity > 0) {
+			this->population.remove_capacity(popul.capacity);
+		}
+	}
+
+	// resources capacity
+	if (unit->has_attribute(attr_type::storage)) {
+		auto storage = unit->get_attribute<attr_type::storage>();
+		this->resources_capacity -= storage.capacity;
+		this->on_resources_change();
+	}
+
+	// score
+	// TODO improve selectors
+	if (unit->unit_type->id() == 82 || unit->unit_type->id() == 276) { // Castle, Wonder
+		// nothing
+	} else if (unit->has_attribute(attr_type::building) || unit->has_attribute(attr_type::population)) { // building, living
+		this->score.remove_score(score_category::economy, unit->unit_type->cost.get(*this).sum() * 0.2);
+	}
+
+	// TODO handle here on death unit triggers
+	// TODO check for unit based win conditions
+}
+
+void Player::killed_unit(const Unit & unit) {
+	// score
+	this->score.add_score(score_category::military, unit.unit_type->cost.get(*this).sum() * 0.2);
+}
+
+void Player::advance_age() {
+	this->age += 1;
+}
+
+void Player::on_resources_change() {
+
+	// capacity overflow
+	if (! (this->resources_capacity >= this->resources_capacity)) {
+		this->resources.limit(this->resources_capacity);
+	}
+
+	// score
+	this->score.update_resources(this->resources);
+
+	// TODO check for resource based win conditions
+}
+
+int Player::get_units_have(int type_id) const {
+	if (this->units_have.count(type_id)) {
+		return this->units_have.at(type_id);
+	}
+	return 0;
+}
+
+int Player::get_units_had(int type_id) const {
+	if (this->units_had.count(type_id)) {
+		return this->units_had.at(type_id);
+	}
+	return 0;
+}
+
+int Player::get_units_pending(int type_id) const {
+	if (this->units_pending.count(type_id)) {
+		return this->units_pending.at(type_id);
+	}
+	return 0;
+}
+
+bool Player::is_unit_pending(Unit *unit) const {
+	// TODO check aslo if unit is training
+	return unit->has_attribute(attr_type::building) && unit->get_attribute<attr_type::building>().completed < 1.0f;
+}
+
+int Player::get_workforce_count() const {
+	// TODO get all units tagged as work force
+	return this->units_have.at(83) + this->units_have.at(293) + // villagers
+	       this->units_have.at(13) + // fishing ship
+	       this->units_have.at(128) + // trade cart
+	       this->units_have.at(545); // transport ship
+}
+
+} // openage
diff --git a/libopenage/gamestate/old/player.h b/libopenage/gamestate/old/player.h
new file mode 100644
index 0000000000..469a6c1f98
--- /dev/null
+++ b/libopenage/gamestate/old/player.h
@@ -0,0 +1,244 @@
+// Copyright 2015-2019 the openage authors. See copying.md for legal info.
+
+#pragma once
+
+#include <string>
+#include <unordered_map>
+
+#include "civilisation.h"
+#include "population_tracker.h"
+#include "resource.h"
+#include "score.h"
+
+
+namespace openage {
+
+class Unit;
+class Team;
+
+class Player {
+public:
+	Player(Civilisation *civ, unsigned int number, std::string name);
+
+	/**
+	 * values 0 .. player count - 1
+	 */
+	const unsigned int player_number;
+
+	/**
+	 * values 1 .. player count
+	 * would be better to have rgb color value
+	 */
+	const unsigned int color;
+
+	/**
+	 * civilisation and techs of this player
+	 */
+	const Civilisation *civ;
+
+	/**
+	 * visible name of this player
+	 */
+	const std::string name;
+
+	/**
+	 * the team of this player
+	 * nullptr if member of no team
+	 */
+	Team *team;
+
+	/**
+	 * checks if two players are the same
+	 */
+	bool operator ==(const Player &other) const;
+
+	/**
+	 * the specified player is an enemy of this player
+	 */
+	bool is_enemy(const Player &) const;
+
+	/**
+	 * the specified player is an ally of this player
+	 */
+	bool is_ally(const Player &) const;
+
+	/**
+	 * this player owns the specified unit
+	 */
+	bool owns(Unit &) const;
+
+	/**
+	 * add to stockpile
+	 */
+	void receive(const ResourceBundle& amount);
+	void receive(const game_resource resource, double amount);
+
+	/**
+	 * Check if can add to stockpile
+	 */
+	bool can_receive(const ResourceBundle& amount) const;
+	bool can_receive(const game_resource resource, double amount) const;
+
+	/**
+	 * remove from stockpile if available
+	 */
+	bool deduct(const ResourceBundle& amount);
+	bool deduct(const game_resource resource, double amount);
+
+	/**
+	 * Check if the player has enough resources to deduct the given amount.
+	 */
+	bool can_deduct(const ResourceBundle& amount) const;
+	bool can_deduct(const game_resource resource, double amount) const;
+
+	/**
+	 * current stockpile amount
+	 */
+	double amount(const game_resource resource) const;
+
+	/**
+	 * Check if the player can make a new unit of the given type
+	 */
+	bool can_make(const UnitType &type) const;
+
+	/**
+	 * total number of unit types available
+	 */
+	size_t type_count();
+
+	/**
+	 * unit types by aoe gamedata unit ids -- the unit type which corresponds to an aoe unit id
+	 */
+	UnitType *get_type(index_t type_id) const;
+
+	/**
+	 * unit types by list index -- a continuous array of all types
+	 * probably not a useful function / can be removed
+	 */
+	UnitType *get_type_index(size_t type_index) const;
+
+	/**
+	 * initialise with the base tech level
+	 */
+	void initialise_unit_types();
+
+	/**
+	 * Keeps track of the population information.
+	 */
+	PopulationTracker population;
+
+	/**
+	 * The score of the player.
+	 */
+	PlayerScore score;
+
+	/**
+	 * Called when a unit is created and active.
+	 *
+	 * If the unit was pending when create (constuction site, training) the method must be
+	 * called again when the unit activates (with the from_penging param set to true)
+	 */
+	void active_unit_added(Unit *unit, bool from_pending=false);
+
+	/**
+	 * Called when a unit is destroyed.
+	 */
+	void active_unit_removed(Unit *unit);
+
+	/**
+	 * Called when a unit is killed by this player.
+	 */
+	void killed_unit(const Unit & unit);
+
+	/**
+	 * Advance to next age;
+	 */
+	void advance_age();
+
+	// Getters
+
+	/**
+	 * Get the number of units the player has for each unit type id.
+	 */
+	int get_units_have(int type_id) const;
+
+	/**
+	 * Get the number of units the player ever had for each unit type id.
+	 */
+	int get_units_had(int type_id) const;
+
+	/**
+	 * Get the number of units the player has being made for each unit type id.
+	 */
+	int get_units_pending(int type_id) const;
+
+	/**
+	 * Get the current age.
+	 * The first age has the value 1.
+	 */
+	int get_age() const { return age; }
+
+	/**
+	 * The number of units considered part of the workforce.
+	 */
+	int get_workforce_count() const;
+
+
+private:
+
+	bool is_unit_pending(Unit *unit) const;
+
+	/**
+	 * The resources this player currently has
+	 */
+	ResourceBundle resources;
+
+	/**
+	 * The resources capacities this player currently has
+	 */
+	ResourceBundle resources_capacity;
+
+	/**
+	 * Called when the resources amounts change.
+	 */
+	void on_resources_change();
+
+	/**
+	 * unit types which can be produced by this player.
+	 * TODO revisit, can be simplified?
+	 */
+	unit_type_list available_objects;
+
+	/**
+	 * available objects mapped using type id
+	 * unit ids -> unit type for that id
+	 * TODO revisit, can be simplified?
+	 */
+	std::unordered_map<index_t, UnitType *> available_ids;
+
+	/**
+	 * The number of units the player has for each unit type id.
+	 * Used for and event triggers.
+	 */
+	std::unordered_map<int, int> units_have;
+
+	/**
+	 * The number of units the player ever had for each unit type id.
+	 * Used for unit dependencies (eg. Farm).
+	 */
+	std::unordered_map<int, int> units_had;
+
+	/*
+	 * The number of units the player has being made for each unit type id.
+	 * Used for unit limits (eg. Town Center).
+	 */
+	std::unordered_map<int, int> units_pending;
+
+	/**
+	 * The current age.
+	 */
+	int age;
+
+};
+
+} // openage
diff --git a/libopenage/gamestate/population_tracker.cpp b/libopenage/gamestate/old/population_tracker.cpp
similarity index 96%
rename from libopenage/gamestate/population_tracker.cpp
rename to libopenage/gamestate/old/population_tracker.cpp
index cb7a708362..fdb79590f6 100644
--- a/libopenage/gamestate/population_tracker.cpp
+++ b/libopenage/gamestate/old/population_tracker.cpp
@@ -1,4 +1,4 @@
-// Copyright 2017-2017 the openage authors. See copying.md for legal info.
+// Copyright 2017-2019 the openage authors. See copying.md for legal info.
 
 #include "population_tracker.h"
 
diff --git a/libopenage/gamestate/population_tracker.h b/libopenage/gamestate/old/population_tracker.h
similarity index 96%
rename from libopenage/gamestate/population_tracker.h
rename to libopenage/gamestate/old/population_tracker.h
index 59371aaaa1..431c0f28ea 100644
--- a/libopenage/gamestate/population_tracker.h
+++ b/libopenage/gamestate/old/population_tracker.h
@@ -1,4 +1,4 @@
-// Copyright 2017-2017 the openage authors. See copying.md for legal info.
+// Copyright 2017-2019 the openage authors. See copying.md for legal info.
 
 #pragma once
 
diff --git a/libopenage/gamestate/resource.cpp b/libopenage/gamestate/old/resource.cpp
similarity index 98%
rename from libopenage/gamestate/resource.cpp
rename to libopenage/gamestate/old/resource.cpp
index c4621ec109..2c3acdda19 100644
--- a/libopenage/gamestate/resource.cpp
+++ b/libopenage/gamestate/old/resource.cpp
@@ -1,4 +1,4 @@
-// Copyright 2015-2019 the openage authors. See copying.md for legal info.
+// Copyright 2015-2021 the openage authors. See copying.md for legal info.
 
 #include <string>
 #include <cmath>
diff --git a/libopenage/gamestate/resource.h b/libopenage/gamestate/old/resource.h
similarity index 100%
rename from libopenage/gamestate/resource.h
rename to libopenage/gamestate/old/resource.h
diff --git a/libopenage/gamestate/score.cpp b/libopenage/gamestate/old/score.cpp
similarity index 96%
rename from libopenage/gamestate/score.cpp
rename to libopenage/gamestate/old/score.cpp
index d6c8ed15d9..9d26d9c9f0 100644
--- a/libopenage/gamestate/score.cpp
+++ b/libopenage/gamestate/old/score.cpp
@@ -1,11 +1,11 @@
-// Copyright 2017-2019 the openage authors. See copying.md for legal info.
+// Copyright 2017-2021 the openage authors. See copying.md for legal info.
 
 #include <cmath>
 
 #include "player.h"
 #include "score.h"
 #include "team.h"
-#include "../log/log.h"
+#include "../../log/log.h"
 
 namespace openage {
 
diff --git a/libopenage/gamestate/score.h b/libopenage/gamestate/old/score.h
similarity index 100%
rename from libopenage/gamestate/score.h
rename to libopenage/gamestate/old/score.h
diff --git a/libopenage/gamestate/team.cpp b/libopenage/gamestate/old/team.cpp
similarity index 96%
rename from libopenage/gamestate/team.cpp
rename to libopenage/gamestate/old/team.cpp
index 57fd5af2a6..92e556437f 100644
--- a/libopenage/gamestate/team.cpp
+++ b/libopenage/gamestate/old/team.cpp
@@ -1,4 +1,4 @@
-// Copyright 2016-2019 the openage authors. See copying.md for legal info.
+// Copyright 2016-2021 the openage authors. See copying.md for legal info.
 
 #include "team.h"
 
diff --git a/libopenage/gamestate/team.h b/libopenage/gamestate/old/team.h
similarity index 94%
rename from libopenage/gamestate/team.h
rename to libopenage/gamestate/old/team.h
index c29d5b6542..657909df9e 100644
--- a/libopenage/gamestate/team.h
+++ b/libopenage/gamestate/old/team.h
@@ -1,4 +1,4 @@
-// Copyright 2016-2017 the openage authors. See copying.md for legal info.
+// Copyright 2016-2019 the openage authors. See copying.md for legal info.
 
 #pragma once
 
diff --git a/libopenage/gamestate/player.cpp b/libopenage/gamestate/player.cpp
index acbf70a12f..ab8d0d3d52 100644
--- a/libopenage/gamestate/player.cpp
+++ b/libopenage/gamestate/player.cpp
@@ -1,291 +1,8 @@
-// Copyright 2015-2019 the openage authors. See copying.md for legal info.
+// Copyright 2018-2021 the openage authors. See copying.md for legal info.
 
 #include "player.h"
 
-#include <utility>
+namespace openage::gamestate {
 
-#include "../log/log.h"
-#include "../unit/unit.h"
-#include "../unit/unit_type.h"
-#include "../util/math_constants.h"
-#include "team.h"
 
-
-namespace openage {
-
-Player::Player(Civilisation *civ, unsigned int number, std::string name)
-	:
-	player_number{number},
-	color{number},
-	civ{civ},
-	name{std::move(name)},
-	team{nullptr},
-	population{0, 200}, // TODO change, get population cap max from game options
-	score{this},
-	age{1} { // TODO change, get starting age from game options
-	// starting resources
-	// TODO change, get starting resources from game options
-	this->resources.set_all(1000);
-	// TODO change, get starting resources capacity from game options or nyan
-	this->resources_capacity.set_all(math::DOUBLE_INF / 2); // half to avoid overflows
-	this->on_resources_change();
-}
-
-bool Player::operator ==(const Player &other) const {
-	return this->player_number == other.player_number;
-}
-
-bool Player::is_enemy(const Player &other) const {
-
-	return !this->is_ally(other);
-}
-
-bool Player::is_ally(const Player &other) const {
-
-	if (this->player_number == other.player_number) {
-		return true; // same player
-	}
-
-	if (this->team && this->team->is_member(other)) {
-		return true; // same team
-	}
-
-	// everyone else is enemy
-	return false;
-}
-
-bool Player::owns(Unit &unit) const {
-	if (unit.has_attribute(attr_type::owner)) {
-		return this == &unit.get_attribute<attr_type::owner>().player;
-	}
-	return false;
-}
-
-void Player::receive(const ResourceBundle& amount) {
-	this->resources += amount;
-	this->on_resources_change();
-}
-
-void Player::receive(const game_resource resource, double amount) {
-	this->resources[resource] += amount;
-	this->on_resources_change();
-}
-
-bool Player::can_receive(const ResourceBundle& amount) const {
-	return this->resources_capacity.has(this->resources, amount);
-}
-
-bool Player::can_receive(const game_resource resource, double amount) const {
-	return this->resources_capacity.get(resource) >= this->resources.get(resource) + amount;
-}
-
-bool Player::deduct(const ResourceBundle& amount) {
-	if (this->resources.deduct(amount)) {
-		this->on_resources_change();
-		return true;
-	}
-	return false;
-}
-
-bool Player::deduct(const game_resource resource, double amount) {
-	if (this->resources[resource] >= amount) {
-		this->resources[resource] -= amount;
-		this->on_resources_change();
-		return true;
-	}
-	return false;
-}
-
-bool Player::can_deduct(const ResourceBundle& amount) const {
-	return this->resources.has(amount);
-}
-
-bool Player::can_deduct(const game_resource resource, double amount) const {
-	return this->resources.get(resource) >= amount;
-}
-
-double Player::amount(const game_resource resource) const {
-	return this->resources.get(resource);
-}
-
-bool Player::can_make(const UnitType &type) const {
-	return this->can_deduct(type.cost.get(*this)) &&
-	       this->get_units_have(type.id()) + this->get_units_pending(type.id()) < type.have_limit &&
-	       this->get_units_had(type.id()) + this->get_units_pending(type.id()) < type.had_limit;
-}
-
-size_t Player::type_count() {
-	return this->available_ids.size();
-}
-
-UnitType *Player::get_type(index_t type_id) const {
-	if (this->available_ids.count(type_id) == 0) {
-		if (type_id > 0) {
-			log::log(MSG(info) << "  -> ignoring type_id: " << type_id);
-		}
-		return nullptr;
-	}
-	return this->available_ids.at(type_id);
-}
-
-UnitType *Player::get_type_index(size_t type_index) const {
-	if (type_index < available_objects.size()) {
-		return available_objects.at(type_index).get();
-	}
-	log::log(MSG(info) << "  -> ignoring type_index: " << type_index);
-	return nullptr;
-}
-
-
-void Player::initialise_unit_types() {
-	log::log(MSG(info) << name << " has civilisation " << this->civ->civ_name);
-	for (auto &type : this->civ->object_meta()) {
-		auto shared_type = type->init(*this);
-		index_t id = shared_type->id();
-		this->available_objects.emplace_back(shared_type);
-		this->available_ids[id] = shared_type.get();
-	}
-}
-
-void Player::active_unit_added(Unit *unit, bool from_pending) {
-	// check if unit is actually active
-	if (this->is_unit_pending(unit)) {
-		this->units_pending[unit->unit_type->id()] += 1;
-		return;
-	}
-
-	if (from_pending) {
-		this->units_pending[unit->unit_type->id()] -= 1;
-	}
-
-	this->units_have[unit->unit_type->id()] += 1;
-	this->units_had[unit->unit_type->id()] += 1;
-	// TODO handle here building dependencies
-
-	// population
-	if (unit->has_attribute(attr_type::population)) {
-		auto popul = unit->get_attribute<attr_type::population>();
-		if (popul.demand > 0) {
-			this->population.demand_population(popul.demand);
-		}
-		if (popul.capacity > 0) {
-			this->population.add_capacity(popul.capacity);
-		}
-	}
-
-	// resources capacity
-	if (unit->has_attribute(attr_type::storage)) {
-		auto storage = unit->get_attribute<attr_type::storage>();
-		this->resources_capacity += storage.capacity;
-		this->on_resources_change();
-	}
-
-	// score
-	// TODO improve selectors
-	if (unit->unit_type->id() == 82 || unit->unit_type->id() == 276) { // Castle, Wonder
-		this->score.add_score(score_category::society, unit->unit_type->cost.get(*this).sum() * 0.2);
-	} else if (unit->has_attribute(attr_type::building) || unit->has_attribute(attr_type::population)) { // building, living
-		this->score.add_score(score_category::economy, unit->unit_type->cost.get(*this).sum() * 0.2);
-	}
-
-	// TODO handle here on create unit triggers
-	// TODO check for unit based win conditions
-}
-
-void Player::active_unit_removed(Unit *unit) {
-	// check if unit is actually active
-	if (this->is_unit_pending(unit)) {
-		this->units_pending[unit->unit_type->id()] -= 1;
-		return;
-	}
-
-	this->units_have[unit->unit_type->id()] -= 1;
-	// TODO handle here building dependencies
-
-	// population
-	if (unit->has_attribute(attr_type::population)) {
-		auto popul = unit->get_attribute<attr_type::population>();
-		if (popul.demand > 0) {
-			this->population.free_population(popul.demand);
-		}
-		if (popul.capacity > 0) {
-			this->population.remove_capacity(popul.capacity);
-		}
-	}
-
-	// resources capacity
-	if (unit->has_attribute(attr_type::storage)) {
-		auto storage = unit->get_attribute<attr_type::storage>();
-		this->resources_capacity -= storage.capacity;
-		this->on_resources_change();
-	}
-
-	// score
-	// TODO improve selectors
-	if (unit->unit_type->id() == 82 || unit->unit_type->id() == 276) { // Castle, Wonder
-		// nothing
-	} else if (unit->has_attribute(attr_type::building) || unit->has_attribute(attr_type::population)) { // building, living
-		this->score.remove_score(score_category::economy, unit->unit_type->cost.get(*this).sum() * 0.2);
-	}
-
-	// TODO handle here on death unit triggers
-	// TODO check for unit based win conditions
-}
-
-void Player::killed_unit(const Unit & unit) {
-	// score
-	this->score.add_score(score_category::military, unit.unit_type->cost.get(*this).sum() * 0.2);
-}
-
-void Player::advance_age() {
-	this->age += 1;
-}
-
-void Player::on_resources_change() {
-
-	// capacity overflow
-	if (! (this->resources_capacity >= this->resources_capacity)) {
-		this->resources.limit(this->resources_capacity);
-	}
-
-	// score
-	this->score.update_resources(this->resources);
-
-	// TODO check for resource based win conditions
-}
-
-int Player::get_units_have(int type_id) const {
-	if (this->units_have.count(type_id)) {
-		return this->units_have.at(type_id);
-	}
-	return 0;
-}
-
-int Player::get_units_had(int type_id) const {
-	if (this->units_had.count(type_id)) {
-		return this->units_had.at(type_id);
-	}
-	return 0;
-}
-
-int Player::get_units_pending(int type_id) const {
-	if (this->units_pending.count(type_id)) {
-		return this->units_pending.at(type_id);
-	}
-	return 0;
-}
-
-bool Player::is_unit_pending(Unit *unit) const {
-	// TODO check aslo if unit is training
-	return unit->has_attribute(attr_type::building) && unit->get_attribute<attr_type::building>().completed < 1.0f;
-}
-
-int Player::get_workforce_count() const {
-	// TODO get all units tagged as work force
-	return this->units_have.at(83) + this->units_have.at(293) + // villagers
-	       this->units_have.at(13) + // fishing ship
-	       this->units_have.at(128) + // trade cart
-	       this->units_have.at(545); // transport ship
-}
-
-} // openage
+} // openage::gamestate
diff --git a/libopenage/gamestate/player.h b/libopenage/gamestate/player.h
index 5267421b71..5ff1e45bb2 100644
--- a/libopenage/gamestate/player.h
+++ b/libopenage/gamestate/player.h
@@ -1,243 +1,11 @@
-// Copyright 2015-2017 the openage authors. See copying.md for legal info.
+// Copyright 2018-2018 the openage authors. See copying.md for legal info.
 
 #pragma once
 
-#include <string>
-#include <unordered_map>
 
-#include "civilisation.h"
-#include "population_tracker.h"
-#include "resource.h"
-#include "score.h"
-
-
-namespace openage {
-
-class Unit;
-class Team;
+namespace openage::gamestate {
 
 class Player {
-public:
-	Player(Civilisation *civ, unsigned int number, std::string name);
-
-	/**
-	 * values 0 .. player count - 1
-	 */
-	const unsigned int player_number;
-
-	/**
-	 * values 1 .. player count
-	 * would be better to have rgb color value
-	 */
-	const unsigned int color;
-
-	/**
-	 * civilisation and techs of this player
-	 */
-	const Civilisation *civ;
-
-	/**
-	 * visible name of this player
-	 */
-	const std::string name;
-
-	/**
-	 * the team of this player
-	 * nullptr if member of no team
-	 */
-	Team *team;
-
-	/**
-	 * checks if two players are the same
-	 */
-	bool operator ==(const Player &other) const;
-
-	/**
-	 * the specified player is an enemy of this player
-	 */
-	bool is_enemy(const Player &) const;
-
-	/**
-	 * the specified player is an ally of this player
-	 */
-	bool is_ally(const Player &) const;
-
-	/**
-	 * this player owns the specified unit
-	 */
-	bool owns(Unit &) const;
-
-	/**
-	 * add to stockpile
-	 */
-	void receive(const ResourceBundle& amount);
-	void receive(const game_resource resource, double amount);
-
-	/**
-	 * Check if can add to stockpile
-	 */
-	bool can_receive(const ResourceBundle& amount) const;
-	bool can_receive(const game_resource resource, double amount) const;
-
-	/**
-	 * remove from stockpile if available
-	 */
-	bool deduct(const ResourceBundle& amount);
-	bool deduct(const game_resource resource, double amount);
-
-	/**
-	 * Check if the player has enough resources to deduct the given amount.
-	 */
-	bool can_deduct(const ResourceBundle& amount) const;
-	bool can_deduct(const game_resource resource, double amount) const;
-
-	/**
-	 * current stockpile amount
-	 */
-	double amount(const game_resource resource) const;
-
-	/**
-	 * Check if the player can make a new unit of the given type
-	 */
-	bool can_make(const UnitType &type) const;
-
-	/**
-	 * total number of unit types available
-	 */
-	size_t type_count();
-
-	/**
-	 * unit types by aoe gamedata unit ids -- the unit type which corresponds to an aoe unit id
-	 */
-	UnitType *get_type(index_t type_id) const;
-
-	/**
-	 * unit types by list index -- a continuous array of all types
-	 * probably not a useful function / can be removed
-	 */
-	UnitType *get_type_index(size_t type_index) const;
-
-	/**
-	 * initialise with the base tech level
-	 */
-	void initialise_unit_types();
-
-	/**
-	 * Keeps track of the population information.
-	 */
-	PopulationTracker population;
-
-	/**
-	 * The score of the player.
-	 */
-	PlayerScore score;
-
-	/**
-	 * Called when a unit is created and active.
-	 *
-	 * If the unit was pending when create (constuction site, training) the method must be
-	 * called again when the unit activates (with the from_penging param set to true)
-	 */
-	void active_unit_added(Unit *unit, bool from_pending=false);
-
-	/**
-	 * Called when a unit is destroyed.
-	 */
-	void active_unit_removed(Unit *unit);
-
-	/**
-	 * Called when a unit is killed by this player.
-	 */
-	void killed_unit(const Unit & unit);
-
-	/**
-	 * Advance to next age;
-	 */
-	void advance_age();
-
-	// Getters
-
-	/**
-	 * Get the number of units the player has for each unit type id.
-	 */
-	int get_units_have(int type_id) const;
-
-	/**
-	 * Get the number of units the player ever had for each unit type id.
-	 */
-	int get_units_had(int type_id) const;
-
-	/**
-	 * Get the number of units the player has being made for each unit type id.
-	 */
-	int get_units_pending(int type_id) const;
-
-	/**
-	 * Get the current age.
-	 * The first age has the value 1.
-	 */
-	int get_age() const { return age; }
-
-	/**
-	 * The number of units considered part of the workforce.
-	 */
-	int get_workforce_count() const;
-
-
-private:
-
-	bool is_unit_pending(Unit *unit) const;
-
-	/**
-	 * The resources this player currently has
-	 */
-	ResourceBundle resources;
-
-	/**
-	 * The resources capacities this player currently has
-	 */
-	ResourceBundle resources_capacity;
-
-	/**
-	 * Called when the resources amounts change.
-	 */
-	void on_resources_change();
-
-	/**
-	 * unit types which can be produced by this player.
-	 * TODO revisit, can be simplified?
-	 */
-	unit_type_list available_objects;
-
-	/**
-	 * available objects mapped using type id
-	 * unit ids -> unit type for that id
-	 * TODO revisit, can be simplified?
-	 */
-	std::unordered_map<index_t, UnitType *> available_ids;
-
-	/**
-	 * The number of units the player has for each unit type id.
-	 * Used for and event triggers.
-	 */
-	std::unordered_map<int, int> units_have;
-
-	/**
-	 * The number of units the player ever had for each unit type id.
-	 * Used for unit dependencies (eg. Farm).
-	 */
-	std::unordered_map<int, int> units_had;
-
-	/*
-	 * The number of units the player has being made for each unit type id.
-	 * Used for unit limits (eg. Town Center).
-	 */
-	std::unordered_map<int, int> units_pending;
-
-	/**
-	 * The current age.
-	 */
-	int age;
 
 };
 
diff --git a/libopenage/gamestate/terrain.cpp b/libopenage/gamestate/terrain.cpp
new file mode 100644
index 0000000000..9a07542b39
--- /dev/null
+++ b/libopenage/gamestate/terrain.cpp
@@ -0,0 +1,8 @@
+// Copyright 2018-2018 the openage authors. See copying.md for legal info.
+
+#include "terrain.h"
+
+
+namespace openage::gamestate {
+
+} // openage::gamestate
diff --git a/libopenage/gamestate/terrain.h b/libopenage/gamestate/terrain.h
new file mode 100644
index 0000000000..266bb3ee05
--- /dev/null
+++ b/libopenage/gamestate/terrain.h
@@ -0,0 +1,12 @@
+// Copyright 2018-2018 the openage authors. See copying.md for legal info.
+
+#pragma once
+
+
+namespace openage::gamestate {
+
+class Terrain {
+
+};
+
+} // openage::gamestate
diff --git a/libopenage/gamestate/terrain_chunk.cpp b/libopenage/gamestate/terrain_chunk.cpp
new file mode 100644
index 0000000000..d434a7a921
--- /dev/null
+++ b/libopenage/gamestate/terrain_chunk.cpp
@@ -0,0 +1,8 @@
+// Copyright 2018-2018 the openage authors. See copying.md for legal info.
+
+#include "terrain_chunk.h"
+
+
+namespace openage::gamestate {
+
+} // openage::gamestate
diff --git a/libopenage/gamestate/terrain_chunk.h b/libopenage/gamestate/terrain_chunk.h
new file mode 100644
index 0000000000..068bb1b3bf
--- /dev/null
+++ b/libopenage/gamestate/terrain_chunk.h
@@ -0,0 +1,12 @@
+// Copyright 2018-2018 the openage authors. See copying.md for legal info.
+
+#pragma once
+
+
+namespace openage::gamestate {
+
+class TerrainChunk {
+
+};
+
+} // openage::gamestate
diff --git a/libopenage/gamestate/types.cpp b/libopenage/gamestate/types.cpp
new file mode 100644
index 0000000000..92ffe234f7
--- /dev/null
+++ b/libopenage/gamestate/types.cpp
@@ -0,0 +1,8 @@
+// Copyright 2018-2018 the openage authors. See copying.md for legal info.
+
+#include "types.h"
+
+
+namespace openage {
+
+} // openage
diff --git a/libopenage/gamestate/types.h b/libopenage/gamestate/types.h
new file mode 100644
index 0000000000..0afeedb220
--- /dev/null
+++ b/libopenage/gamestate/types.h
@@ -0,0 +1,16 @@
+// Copyright 2018-2018 the openage authors. See copying.md for legal info.
+
+#pragma once
+
+
+namespace openage {
+
+/**
+ * The key type mapped to data objects.
+ * Used for graphics indices, sounds, ...
+ * TODO: get rid of this.
+ */
+using index_t = int;
+
+
+} // openage
diff --git a/libopenage/gamestate/world.cpp b/libopenage/gamestate/world.cpp
new file mode 100644
index 0000000000..765229d629
--- /dev/null
+++ b/libopenage/gamestate/world.cpp
@@ -0,0 +1,8 @@
+// Copyright 2018-2018 the openage authors. See copying.md for legal info.
+
+#include "world.h"
+
+namespace openage::gamestate {
+
+
+} // openage::gamestate
diff --git a/libopenage/gamestate/world.h b/libopenage/gamestate/world.h
new file mode 100644
index 0000000000..eedaf725d2
--- /dev/null
+++ b/libopenage/gamestate/world.h
@@ -0,0 +1,11 @@
+// Copyright 2018-2018 the openage authors. See copying.md for legal info.
+
+#pragma once
+
+namespace openage::gamestate {
+
+class World {
+
+};
+
+} // openage
diff --git a/libopenage/gui/category_contents_list_model.h b/libopenage/gui/category_contents_list_model.h
index e644b5ac15..529f8f99d5 100644
--- a/libopenage/gui/category_contents_list_model.h
+++ b/libopenage/gui/category_contents_list_model.h
@@ -1,4 +1,4 @@
-// Copyright 2015-2016 the openage authors. See copying.md for legal info.
+// Copyright 2015-2018 the openage authors. See copying.md for legal info.
 
 #pragma once
 
@@ -7,7 +7,7 @@
 #include <tuple>
 #include <memory>
 
-#include "../gamestate/game_spec.h"
+#include "../gamestate/types.h"
 
 #include <QAbstractListModel>
 
diff --git a/libopenage/gui/game_creator.cpp b/libopenage/gui/game_creator.cpp
index d3b0a30c7f..f187ab5ef2 100644
--- a/libopenage/gui/game_creator.cpp
+++ b/libopenage/gui/game_creator.cpp
@@ -1,12 +1,12 @@
-// Copyright 2015-2019 the openage authors. See copying.md for legal info.
+// Copyright 2015-2021 the openage authors. See copying.md for legal info.
 
 #include "game_creator.h"
 
 #include <QtQml>
 
-#include "../gamestate/game_main.h"
-#include "../gamestate/game_spec.h"
-#include "../gamestate/generator.h"
+#include "../gamestate/old/game_main.h"
+#include "../gamestate/old/game_spec.h"
+#include "../gamestate/old/generator.h"
 
 #include "game_main_link.h"
 #include "game_spec_link.h"
diff --git a/libopenage/gui/game_main_link.h b/libopenage/gui/game_main_link.h
index 9836dc2b61..0277cab6b8 100644
--- a/libopenage/gui/game_main_link.h
+++ b/libopenage/gui/game_main_link.h
@@ -1,4 +1,4 @@
-// Copyright 2015-2016 the openage authors. See copying.md for legal info.
+// Copyright 2015-2018 the openage authors. See copying.md for legal info.
 
 #pragma once
 
@@ -6,7 +6,7 @@
 
 #include "guisys/link/gui_item.h"
 
-#include "../gamestate/game_main.h"
+#include "../gamestate/old/game_main.h"
 
 namespace openage {
 namespace gui {
diff --git a/libopenage/gui/game_saver.cpp b/libopenage/gui/game_saver.cpp
index 1d71ee8aa1..f6793207ca 100644
--- a/libopenage/gui/game_saver.cpp
+++ b/libopenage/gui/game_saver.cpp
@@ -1,12 +1,12 @@
-// Copyright 2016-2019 the openage authors. See copying.md for legal info.
+// Copyright 2016-2021 the openage authors. See copying.md for legal info.
 
 #include "game_saver.h"
 
 #include <QtQml>
 
-#include "../gamestate/game_save.h"
-#include "../gamestate/game_main.h"
-#include "../gamestate/generator.h"
+#include "../gamestate/old/game_save.h"
+#include "../gamestate/old/game_main.h"
+#include "../gamestate/old/generator.h"
 
 #include "game_main_link.h"
 #include "generator_link.h"
diff --git a/libopenage/gui/game_spec_link.h b/libopenage/gui/game_spec_link.h
index a1bbe138ca..73284b8ec3 100644
--- a/libopenage/gui/game_spec_link.h
+++ b/libopenage/gui/game_spec_link.h
@@ -1,4 +1,4 @@
-// Copyright 2015-2016 the openage authors. See copying.md for legal info.
+// Copyright 2015-2018 the openage authors. See copying.md for legal info.
 
 #pragma once
 
@@ -9,7 +9,7 @@
 
 #include "guisys/link/gui_item.h"
 
-#include "../gamestate/game_spec.h"
+#include "../gamestate/old/game_spec.h"
 
 namespace openage {
 
diff --git a/libopenage/gui/generator_link.h b/libopenage/gui/generator_link.h
index 2bb86e59d5..804f75e80e 100644
--- a/libopenage/gui/generator_link.h
+++ b/libopenage/gui/generator_link.h
@@ -1,8 +1,8 @@
-// Copyright 2015-2016 the openage authors. See copying.md for legal info.
+// Copyright 2015-2018 the openage authors. See copying.md for legal info.
 
 #pragma once
 
-#include "../gamestate/generator.h"
+#include "../gamestate/old/generator.h"
 
 #include "guisys/link/gui_list_model.h"
 #include "guisys/link/gui_item_list_model.h"
diff --git a/libopenage/gui/integration/private/gui_game_spec_image_provider_by_filename_impl.cpp b/libopenage/gui/integration/private/gui_game_spec_image_provider_by_filename_impl.cpp
index 4effac65de..216422e5ba 100644
--- a/libopenage/gui/integration/private/gui_game_spec_image_provider_by_filename_impl.cpp
+++ b/libopenage/gui/integration/private/gui_game_spec_image_provider_by_filename_impl.cpp
@@ -1,10 +1,10 @@
-// Copyright 2015-2019 the openage authors. See copying.md for legal info.
+// Copyright 2015-2021 the openage authors. See copying.md for legal info.
 
 #include "gui_game_spec_image_provider_by_filename_impl.h"
 
 #include "../../../error/error.h"
 
-#include "../../../gamestate/game_spec.h"
+#include "../../../gamestate/old/game_spec.h"
 
 namespace openage::gui {
 
diff --git a/libopenage/gui/integration/private/gui_game_spec_image_provider_by_graphic_id_impl.cpp b/libopenage/gui/integration/private/gui_game_spec_image_provider_by_graphic_id_impl.cpp
index dad94c0c69..ede6e5ef21 100644
--- a/libopenage/gui/integration/private/gui_game_spec_image_provider_by_graphic_id_impl.cpp
+++ b/libopenage/gui/integration/private/gui_game_spec_image_provider_by_graphic_id_impl.cpp
@@ -1,10 +1,10 @@
-// Copyright 2015-2019 the openage authors. See copying.md for legal info.
+// Copyright 2015-2021 the openage authors. See copying.md for legal info.
 
 #include "gui_game_spec_image_provider_by_graphic_id_impl.h"
 
 #include "../../../error/error.h"
 
-#include "../../../gamestate/game_spec.h"
+#include "../../../gamestate/old/game_spec.h"
 
 namespace openage::gui {
 
diff --git a/libopenage/gui/integration/private/gui_game_spec_image_provider_by_id_impl.cpp b/libopenage/gui/integration/private/gui_game_spec_image_provider_by_id_impl.cpp
index 1c17f6b9cb..c5aeab3174 100644
--- a/libopenage/gui/integration/private/gui_game_spec_image_provider_by_id_impl.cpp
+++ b/libopenage/gui/integration/private/gui_game_spec_image_provider_by_id_impl.cpp
@@ -1,10 +1,10 @@
-// Copyright 2015-2019 the openage authors. See copying.md for legal info.
+// Copyright 2015-2021 the openage authors. See copying.md for legal info.
 
 #include "gui_game_spec_image_provider_by_id_impl.h"
 
 #include "../../../error/error.h"
 
-#include "../../../gamestate/game_spec.h"
+#include "../../../gamestate/old/game_spec.h"
 #include "gui_texture_factory.h"
 
 namespace openage::gui {
diff --git a/libopenage/gui/integration/private/gui_game_spec_image_provider_by_terrain_id_impl.cpp b/libopenage/gui/integration/private/gui_game_spec_image_provider_by_terrain_id_impl.cpp
index 740e874735..f875118636 100644
--- a/libopenage/gui/integration/private/gui_game_spec_image_provider_by_terrain_id_impl.cpp
+++ b/libopenage/gui/integration/private/gui_game_spec_image_provider_by_terrain_id_impl.cpp
@@ -1,10 +1,10 @@
-// Copyright 2015-2019 the openage authors. See copying.md for legal info.
+// Copyright 2015-2021 the openage authors. See copying.md for legal info.
 
 #include "gui_game_spec_image_provider_by_terrain_id_impl.h"
 
 #include "../../../error/error.h"
 
-#include "../../../gamestate/game_spec.h"
+#include "../../../gamestate/old/game_spec.h"
 
 namespace openage::gui {
 
diff --git a/libopenage/gui/integration/private/gui_game_spec_image_provider_impl.cpp b/libopenage/gui/integration/private/gui_game_spec_image_provider_impl.cpp
index abf159bb9b..4be3693854 100644
--- a/libopenage/gui/integration/private/gui_game_spec_image_provider_impl.cpp
+++ b/libopenage/gui/integration/private/gui_game_spec_image_provider_impl.cpp
@@ -1,4 +1,4 @@
-// Copyright 2015-2019 the openage authors. See copying.md for legal info.
+// Copyright 2015-2021 the openage authors. See copying.md for legal info.
 
 #include "gui_game_spec_image_provider_impl.h"
 
@@ -8,7 +8,7 @@
 
 #include "../../../error/error.h"
 
-#include "../../../gamestate/game_spec.h"
+#include "../../../gamestate/old/game_spec.h"
 #include "../../guisys/private/gui_event_queue_impl.h"
 
 #include "gui_texture_factory.h"
diff --git a/libopenage/gui/resources_list_model.h b/libopenage/gui/resources_list_model.h
index 8cfdc20832..574618fb78 100644
--- a/libopenage/gui/resources_list_model.h
+++ b/libopenage/gui/resources_list_model.h
@@ -1,4 +1,4 @@
-// Copyright 2016-2016 the openage authors. See copying.md for legal info.
+// Copyright 2016-2018 the openage authors. See copying.md for legal info.
 
 #pragma once
 
@@ -7,7 +7,7 @@
 
 #include <QAbstractListModel>
 
-#include "../gamestate/resource.h"
+#include "../gamestate/old/resource.h"
 
 namespace openage {
 namespace gui {
diff --git a/libopenage/input/event.h b/libopenage/input/event.h
index f062a103ee..91dbf20a3a 100644
--- a/libopenage/input/event.h
+++ b/libopenage/input/event.h
@@ -80,7 +80,7 @@ using modset_t = std::unordered_set<modifier, modifier_hash>;
 
 
 /**
- * base event type containing event class and event code
+ * base event type containing event handler and event code
  */
 class ClassCode {
 public:
diff --git a/libopenage/main.cpp b/libopenage/main.cpp
index 2e4e12b115..34538d68f6 100644
--- a/libopenage/main.cpp
+++ b/libopenage/main.cpp
@@ -1,4 +1,4 @@
-// Copyright 2015-2017 the openage authors. See copying.md for legal info.
+// Copyright 2015-2018 the openage authors. See copying.md for legal info.
 
 #include "main.h"
 
@@ -7,7 +7,6 @@
 #include "game_control.h"
 #include "game_renderer.h"
 #include "gamedata/color.gen.h"
-#include "gamestate/generator.h"
 #include "log/log.h"
 #include "shader/program.h"
 #include "shader/shader.h"
diff --git a/libopenage/main/CMakeLists.txt b/libopenage/main/CMakeLists.txt
new file mode 100644
index 0000000000..0883a024ae
--- /dev/null
+++ b/libopenage/main/CMakeLists.txt
@@ -0,0 +1,9 @@
+add_subdirectory("tests")
+
+add_sources(libopenage
+	tests.cpp
+)
+
+pxdgen(
+	tests.h
+)
diff --git a/libopenage/main/tests.cpp b/libopenage/main/tests.cpp
new file mode 100644
index 0000000000..27236e3635
--- /dev/null
+++ b/libopenage/main/tests.cpp
@@ -0,0 +1,20 @@
+// Copyright 2018-2019 the openage authors. See copying.md for legal info.
+
+#include "tests/pong.h"
+
+
+namespace openage::main::tests {
+
+
+void engine_demo(int demo_id, const util::Path &path) {
+	switch (demo_id) {
+	case 0:
+		pong::main(path);
+		break;
+
+	default:
+		throw Error(ERR << "unknown engine demo " << demo_id << " requested.");
+	}
+}
+
+} // namespace openage::main::tests
diff --git a/libopenage/main/tests.h b/libopenage/main/tests.h
new file mode 100644
index 0000000000..ca027593e4
--- /dev/null
+++ b/libopenage/main/tests.h
@@ -0,0 +1,15 @@
+// Copyright 2018-2019 the openage authors. See copying.md for legal info.
+
+#pragma once
+
+// pxd: from libopenage.util.path cimport Path
+#include "../util/path.h"
+
+
+namespace openage::main::tests {
+
+// pxd: void engine_demo(int demo_id, Path path)
+// except +
+void engine_demo(int demo_id, const util::Path &path);
+
+} // openage::main::tests
diff --git a/libopenage/main/tests/CMakeLists.txt b/libopenage/main/tests/CMakeLists.txt
new file mode 100644
index 0000000000..aeeaaf48d0
--- /dev/null
+++ b/libopenage/main/tests/CMakeLists.txt
@@ -0,0 +1,7 @@
+add_sources(libopenage
+	aicontroller.cpp
+	gamestate.cpp
+	gui.cpp
+	physics.cpp
+	pong.cpp
+)
diff --git a/libopenage/main/tests/aicontroller.cpp b/libopenage/main/tests/aicontroller.cpp
new file mode 100644
index 0000000000..046669e478
--- /dev/null
+++ b/libopenage/main/tests/aicontroller.cpp
@@ -0,0 +1,93 @@
+// Copyright 2019-2019 the openage authors. See copying.md for legal info.
+
+#include "aicontroller.h"
+
+
+namespace openage::main::tests::pong {
+
+
+std::vector<PongEvent> get_ai_inputs(const std::shared_ptr<PongPlayer> &player,
+                                     const std::shared_ptr<PongBall> &ball,
+                                     const std::shared_ptr<curve::Discrete<util::Vector2s>> &area_size_curve,
+                                     const curve::time_t &now,
+                                     bool right_player) {
+	std::vector<PongEvent> ret;
+
+	auto player_pos = player->position->get(now);
+	auto player_size = player->size->get(now);
+	auto ball_pos = ball->position->get(now);
+	auto speed = ball->speed->get(now);
+
+	auto area_size = area_size_curve->get(now);
+	double area_width = area_size[0];
+	double area_height = area_size[1];
+
+	curve::time_t hit_time;
+	util::Vector2d hit_pos;
+
+	// calculate ball trajectory
+	// extrapolate trajectory to player's panel wall
+	// follow reflections at walls
+	// move panel to predicted hit position of panel wall
+
+	while (true) {
+		curve::time_t ty_hit = 0, tx_hit = 0;
+
+		if (speed[0] == 0) {
+			tx_hit = std::numeric_limits<curve::time_t>::max();
+		} else if (speed[0] > 0) {
+			tx_hit = curve::time_t::from_double((area_width - ball_pos[0]) / speed[0]);
+		} else if (speed[0] < 0) {
+			tx_hit = curve::time_t::from_double(ball_pos[0] / -speed[0]);
+		}
+
+		if (speed[1] == 0) {
+			ty_hit = std::numeric_limits<curve::time_t>::max();
+		} else if (speed[1] > 0) {
+			ty_hit = curve::time_t::from_double((area_height - ball_pos[1]) / speed[1]);
+		} else if (speed[1] < 0) {
+			ty_hit = curve::time_t::from_double(ball_pos[1] / -speed[1]);
+		}
+
+		// actual hit has lowest time:
+		hit_time = std::min(ty_hit, tx_hit);
+		hit_pos = ball_pos + (speed * hit_time.to_double());
+
+		// continue calculating until panel hit
+		if (ty_hit < tx_hit) {
+			speed[1] *= -1;
+			ball_pos = hit_pos;
+			continue;
+		}
+		else {
+			// stop the iteration if the ball is moving towards us
+			// i.e. it is not hitting the panel on the oposite wall.
+			if (right_player and speed[0] > 0) {
+				break;
+			}
+			else if (not right_player and speed[0] < 0) {
+				break;
+			}
+
+			speed[0] *= -1;
+			ball_pos = hit_pos;
+			continue;
+		}
+	}
+
+	// move the panel towards the ball hit pos, but only
+	// if the ball does not hit the middle piece of the 3-divided panel
+	if (hit_pos[1] > player_pos + (player_size / 3)) {
+		ret.push_back(PongEvent{player->id(), PongEvent::DOWN});
+	}
+	else if (hit_pos[1] < player_pos - (player_size / 3)) {
+		ret.push_back(PongEvent{player->id(), PongEvent::UP});
+	}
+	else {
+		ret.push_back(PongEvent{player->id(), PongEvent::IDLE});
+	}
+
+	return ret;
+}
+
+} // openage::main::tests::pong
diff --git a/libopenage/main/tests/aicontroller.h b/libopenage/main/tests/aicontroller.h
new file mode 100644
index 0000000000..ea8376fd2e
--- /dev/null
+++ b/libopenage/main/tests/aicontroller.h
@@ -0,0 +1,18 @@
+// Copyright 2019-2019 the openage authors. See copying.md for legal info.
+
+#pragma once
+
+#include "gamestate.h"
+
+
+namespace openage::main::tests::pong {
+
+std::vector<PongEvent> get_ai_inputs(
+	const std::shared_ptr<PongPlayer> &player,
+	const std::shared_ptr<PongBall> &ball,
+	const std::shared_ptr<curve::Discrete<util::Vector2s>> &area_size,
+	const curve::time_t &now,
+	bool right_player
+);
+
+} // openage::main::tests::pong
diff --git a/libopenage/main/tests/gamestate.cpp b/libopenage/main/tests/gamestate.cpp
new file mode 100644
index 0000000000..b336ee51da
--- /dev/null
+++ b/libopenage/main/tests/gamestate.cpp
@@ -0,0 +1,135 @@
+// Copyright 2019-2019 the openage authors. See copying.md for legal info.
+
+#include "gamestate.h"
+
+#include <sstream>
+
+#include "gui.h"
+#include "../../log/log.h"
+#include "../../util/strings.h"
+
+namespace openage::main::tests::pong {
+
+
+using namespace std::placeholders;
+PongPlayer::PongPlayer(const std::shared_ptr<event::Loop> &mgr, size_t id)
+	:
+	EventEntity{mgr},
+	speed(std::make_shared<curve::Discrete<float>>(
+		      mgr,
+		      (id << 4) + 1,
+		      util::sformat("PongPlayer(%zu).speed", id),
+		      std::bind(&PongPlayer::child_changes, this, _1))),
+	position(std::make_shared<curve::Continuous<float>>(
+		         mgr,
+		         (id << 4) + 2,
+		         util::sformat("PongPlayer(%zu).position", id),
+		         std::bind(&PongPlayer::child_changes, this, _1))),
+	lives(std::make_shared<curve::Discrete<int>>(
+		      mgr,
+		      (id << 4) + 3,
+		      util::sformat("PongPlayer(%zu).lives", id),
+		      std::bind(&PongPlayer::child_changes, this, _1))),
+	state(std::make_shared<curve::Discrete<PongEvent>>(
+		      mgr,
+		      (id << 4) + 4,
+		      util::sformat("PongPlayer(%zu).state", id),
+		      std::bind(&PongPlayer::child_changes, this, _1))),
+	size(std::make_shared<curve::Discrete<float>>(
+		     mgr,
+		     (id << 4) + 5,
+		     util::sformat("PongPlayer(%zu).size", id),
+		     std::bind(&PongPlayer::child_changes, this, _1))),
+	_id{id} {}
+
+
+size_t PongPlayer::id() const {
+	return _id;
+}
+
+std::string PongPlayer::idstr() const {
+	std::stringstream ss;
+	ss << "PongPlayer(" << this->id() << ")";
+	return ss.str();
+}
+
+
+void PongPlayer::child_changes(const curve::time_t &time) {
+	this->changes(time);
+}
+
+
+PongBall::PongBall(const std::shared_ptr<event::Loop> &mgr, size_t id)
+	:
+	EventEntity{mgr},
+	speed(std::make_shared<curve::Discrete<util::Vector2d>>(
+		      mgr,
+		      (id << 2) + 1,
+		      util::sformat("PongBall(%zu).speed", id),
+		      std::bind(&PongBall::child_changes, this, _1))),
+	position(std::make_shared<curve::Segmented<util::Vector2d>>(
+		         mgr,
+		         (id << 2) + 2,
+		         util::sformat("PongBall(%zu).position", id),
+		         std::bind(&PongBall::child_changes, this, _1))),
+	_id{id} {}
+
+
+size_t PongBall::id() const {
+	return _id;
+}
+
+
+std::string PongBall::idstr() const {
+	std::stringstream ss;
+	ss << "PongBall(" << this->id() << ")";
+	return ss.str();
+}
+
+
+void PongBall::child_changes(const curve::time_t &time) {
+	this->changes(time);
+}
+
+
+PongState::PongState(const std::shared_ptr<event::Loop> &mgr,
+                     const std::shared_ptr<Gui> &gui,
+                     const std::shared_ptr<nyan::View> &dbroot)
+	:
+	State{mgr},
+	p1(std::make_shared<PongPlayer>(mgr, 0)),
+	p2(std::make_shared<PongPlayer>(mgr, 1)),
+	ball(std::make_shared<PongBall>(mgr, 2)),
+	area_size(
+		std::make_shared<curve::Discrete<util::Vector2s>>(
+			mgr,
+			1001,
+			"area_size")),
+	gui{gui},
+	dbroot{dbroot} {
+
+		auto size = gui->get_window_size();
+
+		log::log(INFO << "initializing pong state with area_size="
+		         << size << "...");
+
+		// initialize display size with real window size
+		this->area_size->set_last(0, size);
+
+		// nyan initialization
+		nyan::Object gamecfg = this->dbroot->get_object("pong.GameTest");
+		if (not gamecfg.extends("pong.PongGame")) {
+			throw Error{ERR << "GameTest is not a PongGame"};
+		}
+
+		this->ballcfg = *gamecfg.get<nyan::Object>("ball");
+
+		nyan::Object ballcolor = this->ballcfg.get_object("color");
+		log::log(INFO << "initial ball color: (r, g, b) = ("
+		         << ballcolor.get_int("r")
+		         << ", " << ballcolor.get_int("g")
+		         << ", " << ballcolor.get_int("b")
+		         << ")");
+	}
+
+} // openage::main::tests::pong
diff --git a/libopenage/main/tests/gamestate.h b/libopenage/main/tests/gamestate.h
new file mode 100644
index 0000000000..278f662418
--- /dev/null
+++ b/libopenage/main/tests/gamestate.h
@@ -0,0 +1,92 @@
+// Copyright 2019-2019 the openage authors. See copying.md for legal info.
+
+#pragma once
+
+#include <functional>
+
+#include <nyan/nyan.h>
+
+#include "config.h"
+#include "../../curve/continuous.h"
+#include "../../curve/discrete.h"
+#include "../../curve/segmented.h"
+#include "../../event/evententity.h"
+#include "../../event/loop.h"
+#include "../../event/state.h"
+#include "../../util/vector.h"
+
+
+namespace openage::main::tests::pong {
+
+class Gui;
+
+
+class PongEvent {
+public:
+	enum state_e {
+		UP, DOWN, START, IDLE, LOST
+	};
+
+	PongEvent(size_t id, state_e s) : player(id), state(s) {}
+	PongEvent() : player(0), state(IDLE) {}
+
+	size_t player;
+	state_e state;
+};
+
+
+class PongPlayer : public event::EventEntity {
+public:
+	PongPlayer(const std::shared_ptr<event::Loop> &mgr, size_t id);
+
+	size_t id() const override;
+	std::string idstr() const override;
+
+	std::shared_ptr<curve::Discrete<float>> speed;
+	std::shared_ptr<curve::Continuous<float>> position;
+	std::shared_ptr<curve::Discrete<int>> lives;
+	std::shared_ptr<curve::Discrete<PongEvent>> state;
+	std::shared_ptr<curve::Discrete<float>> size;
+
+	size_t _id;
+
+private:
+	void child_changes(const curve::time_t &time);
+};
+
+
+class PongBall : public event::EventEntity {
+public:
+	PongBall(const std::shared_ptr<event::Loop> &mgr, size_t id);
+
+	size_t id() const override;
+	std::string idstr() const override;
+
+	std::shared_ptr<curve::Discrete<util::Vector2d>> speed;
+	std::shared_ptr<curve::Segmented<util::Vector2d>> position;
+
+private:
+	void child_changes(const curve::time_t &time);
+	size_t _id;
+};
+
+
+class PongState : public event::State {
+public:
+	PongState(const std::shared_ptr<event::Loop> &mgr,
+	          const std::shared_ptr<Gui> &gui,
+	          const std::shared_ptr<nyan::View> &dbroot);
+
+	std::shared_ptr<PongPlayer> p1;
+	std::shared_ptr<PongPlayer> p2;
+	std::shared_ptr<PongBall> ball;
+	std::shared_ptr<curve::Discrete<util::Vector2s>> area_size;
+
+	std::shared_ptr<Gui> gui;
+
+	std::shared_ptr<nyan::View> dbroot;
+	nyan::Object ballcfg;
+};
+
+
+} // openage::main::tests::pong
diff --git a/libopenage/main/tests/gui.cpp b/libopenage/main/tests/gui.cpp
new file mode 100644
index 0000000000..3807da75a9
--- /dev/null
+++ b/libopenage/main/tests/gui.cpp
@@ -0,0 +1,275 @@
+// Copyright 2019-2019 the openage authors. See copying.md for legal info.
+
+#include "gui.h"
+
+#include <algorithm>
+#include <vector>
+#include <eigen3/Eigen/Dense>
+
+#include "gamestate.h"
+#include "../../log/log.h"
+#include "../../renderer/opengl/shader.h"
+#include "../../renderer/resources/shader_source.h"
+#include "../../renderer/resources/texture_data.h"
+#include "../../renderer/resources/mesh_data.h"
+#include "../../renderer/texture.h"
+#include "../../renderer/shader_program.h"
+#include "../../renderer/util.h"
+#include "../../renderer/geometry.h"
+#include "../../renderer/opengl/window.h"
+
+
+namespace openage::main::tests::pong {
+
+
+const std::vector<PongEvent> &Gui::get_inputs(const std::shared_ptr<PongPlayer> &player) {
+	this->input_cache.clear();
+
+	PongEvent evnt;
+	evnt.player = player->id();
+	evnt.state = PongEvent::IDLE;
+
+	std::vector<int> inputs;
+
+	/*
+	for (all inputs from SDL) {
+		add key to inputs vector;
+	}
+	*/
+
+	for (auto input : inputs) {
+		switch (input) {
+		case 0:
+			evnt.state = PongEvent::DOWN;
+			break;
+
+		case 1:
+			evnt.state = PongEvent::UP;
+			break;
+
+		case 27:
+			exit(0);
+			break;
+
+		case 'r':
+		case ' ':
+			evnt.state = PongEvent::START;
+			break;
+
+		default:
+			evnt.state = PongEvent::IDLE;
+			break;
+		}
+
+		this->input_cache.push_back(evnt);
+	}
+
+	if (this->input_cache.empty()) {
+		// store 'idle' input to cancel movement
+		this->input_cache.push_back(evnt);
+	}
+
+	return this->input_cache;
+}
+
+
+constexpr const int max_log_msgs = 10;
+
+
+Gui::Gui()
+	:
+	window{"openage engine test", 800, 600},
+	renderer{window.make_renderer()} {
+
+	auto vshader_src = renderer::resources::ShaderSource(
+		renderer::resources::shader_lang_t::glsl,
+		renderer::resources::shader_stage_t::vertex,
+		R"s(
+#version 330
+
+layout(location=0) in vec2 position;
+uniform mat4 pos;
+uniform mat4 proj;
+
+void main() {
+	gl_Position = proj * pos * vec4(position, 0.0, 1.0);
+}
+)s");
+
+	auto fshader_src = renderer::resources::ShaderSource(
+		renderer::resources::shader_lang_t::glsl,
+		renderer::resources::shader_stage_t::fragment,
+		R"s(
+#version 330
+
+uniform vec3 col;
+out vec4 frag;
+
+void main() {
+	frag = vec4(col.r, col.g, col.b, 1.0);
+}
+)s");
+
+	auto shader = renderer->add_shader( { vshader_src, fshader_src } );
+
+	auto proj_in = shader->new_uniform_input(
+		"proj", Eigen::Affine3f::Identity().matrix()
+	);
+
+	auto col_in = shader->new_uniform_input(
+		"col", Eigen::Vector3f()
+	);
+	auto col_red_in = shader->new_uniform_input(
+		"col", Eigen::Vector3f(1, 0, 0)
+	);
+
+	auto quad = renderer->add_mesh_geometry(renderer::resources::MeshData::make_quad());
+
+	this->ball = renderer::Renderable{
+		shader->new_uniform_input(
+			"pos", Eigen::Affine3f::Identity().matrix()
+		),
+		quad,
+		true,
+		true,
+	};
+
+	this->p1paddle = renderer::Renderable{
+		shader->new_uniform_input(
+			"pos", Eigen::Affine3f::Identity().matrix()
+		),
+		quad,
+		true,
+		true,
+	};
+
+	this->p2paddle = renderer::Renderable{
+		shader->new_uniform_input(
+			"pos", Eigen::Affine3f::Identity().matrix()
+		),
+		quad,
+		true,
+		true,
+	};
+
+	auto set_projmatrix = renderer::ShaderUpdate{proj_in};
+	auto set_col = renderer::ShaderUpdate{col_in};
+	auto set_col_red = renderer::ShaderUpdate{col_red_in};
+
+	this->render_pass = this->renderer->add_render_pass(
+		std::vector<renderer::Renderable>{
+			std::move(set_projmatrix),
+			std::move(set_col),
+			this->ball,
+			std::move(set_col_red),
+			this->p1paddle,
+			this->p2paddle
+		},
+		this->renderer->get_display_target()
+	);
+
+	glDepthFunc(GL_LEQUAL);
+	glDepthRange(0.0, 1.0);
+	glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+	this->window.add_resize_callback(
+		[=] (size_t w, size_t h) {
+			Eigen::Matrix4f proj_matrix = renderer::util::ortho_matrix_f(
+				0.0f, w, 0.0f, h, 0.0f, 1.0f
+			);
+
+			proj_in->update("proj", proj_matrix);
+
+			for (auto &cb : this->resize_callbacks) {
+				cb(w, h);
+			}
+		}
+	);
+}
+
+
+void Gui::draw(const std::shared_ptr<PongState> &state, const curve::time_t &now) {
+
+	constexpr float ball_size = 50.0f;
+	constexpr float paddle_width = 20.0f;
+
+	auto screen_size = state->area_size->get(now);
+
+	// TODO draw score
+	// TODO: draw middle line
+	// TODO: draw debug info
+
+	// draw the ball
+	// TODO: use "⚽"
+	auto ball_pos = state->ball->position->get(now);
+	auto ball_pos_matrix = Eigen::Affine3f::Identity();
+	ball_pos_matrix.prescale(Eigen::Vector3f(ball_size, ball_size, 1.0f));
+	//ball_pos_matrix.prerotate(Eigen::AngleAxisf(45.0f * math::PI / 180.0f, Eigen::Vector3f::UnitZ()));
+	ball_pos_matrix.pretranslate(Eigen::Vector3f(ball_pos[0], ball_pos[1], 0.0f));
+	this->ball.uniform->update("pos", ball_pos_matrix.matrix());
+
+	nyan::Object ballcolor = state->ballcfg.get_object("color");
+	this->ball.uniform->update(
+		"col",
+		Eigen::Vector3f{
+			ballcolor.get_int("r", now.to_int()) / 255.0f,
+			ballcolor.get_int("g", now.to_int()) / 255.0f,
+			ballcolor.get_int("b", now.to_int()) / 255.0f,
+		}
+	);
+
+	auto p1_pos = state->p1->position->get(now);
+	auto p1_size = state->p1->size->get(now);
+	auto p1_pos_matrix = Eigen::Affine3f::Identity();
+	p1_pos_matrix.prescale(Eigen::Vector3f(paddle_width, p1_size, 1.0f));
+	p1_pos_matrix.pretranslate(Eigen::Vector3f(0, p1_pos, 0.0f));
+	this->p1paddle.uniform->update("pos", p1_pos_matrix.matrix());
+
+	auto p2_pos = state->p2->position->get(now);
+	auto p2_size = state->p2->size->get(now);
+	auto p2_pos_matrix = Eigen::Affine3f::Identity();
+	p2_pos_matrix.prescale(Eigen::Vector3f(paddle_width, p2_size, 1.0f));
+	p2_pos_matrix.pretranslate(Eigen::Vector3f(screen_size[0], p2_pos, 0.0f));
+	this->p2paddle.uniform->update("pos", p2_pos_matrix.matrix());
+
+	this->renderer->render(this->render_pass);
+	this->window.update();
+	renderer::opengl::GlContext::check_error();
+
+	this->exit_requested = window.should_close();
+	if (this->exit_requested) {
+		log::log(INFO << "game exit requested due to window close");
+	}
+}
+
+
+const util::Vector2s &Gui::get_window_size() const {
+	return this->window.get_size();
+}
+
+
+void Gui::log(const std::string &msg) {
+
+	log::log(INFO << "Gui::log: " << msg);
+
+	if (this->log_msgs.size() >= max_log_msgs) {
+		this->log_msgs.pop_back();
+	}
+	this->log_msgs.push_front(msg);
+}
+
+
+void Gui::add_resize_callback(const renderer::Window::resize_cb_t& cb) {
+	this->resize_callbacks.push_back(cb);
+}
+
+
+void Gui::clear_resize_callbacks() {
+	this->resize_callbacks.clear();
+}
+
+void Gui::update() {
+	this->window.update();
+}
+
+} // openage::main::tests::pong
diff --git a/libopenage/main/tests/gui.h b/libopenage/main/tests/gui.h
new file mode 100644
index 0000000000..6f06845066
--- /dev/null
+++ b/libopenage/main/tests/gui.h
@@ -0,0 +1,58 @@
+// Copyright 2019-2019 the openage authors. See copying.md for legal info.
+
+#pragma once
+
+
+#include <vector>
+#include <deque>
+
+#include "../../curve/curve.h"
+#include "../../renderer/renderer.h"
+#include "../../renderer/opengl/window.h"
+
+
+namespace openage::main::tests::pong {
+
+class PongEvent;
+class PongState;
+class PongPlayer;
+
+
+class Gui {
+public:
+	Gui();
+
+	const std::vector<PongEvent> &get_inputs(const std::shared_ptr<PongPlayer> &player);
+
+	void draw(const std::shared_ptr<PongState> &state, const curve::time_t &now);
+
+	const util::Vector2s &get_window_size() const;
+
+	void log(const std::string &msg);
+
+	void add_resize_callback(const renderer::Window::resize_cb_t&);
+	void clear_resize_callbacks();
+
+	void update();
+
+	bool exit_requested = false;
+
+private:
+	renderer::opengl::GlWindow window;
+	std::unique_ptr<renderer::Renderer> renderer;
+
+	std::vector<PongEvent> input_cache;
+	std::deque<std::string> log_msgs;
+
+	// rendering objects
+	renderer::Renderable ball;
+	renderer::Renderable p1paddle;
+	renderer::Renderable p2paddle;
+
+	// render pass for the game area
+	std::shared_ptr<renderer::RenderPass> render_pass;
+
+	std::vector<renderer::Window::resize_cb_t> resize_callbacks;
+};
+
+} // openage::main::tests::pong
diff --git a/libopenage/main/tests/physics.cpp b/libopenage/main/tests/physics.cpp
new file mode 100644
index 0000000000..74f20c9128
--- /dev/null
+++ b/libopenage/main/tests/physics.cpp
@@ -0,0 +1,465 @@
+// Copyright 2019-2019 the openage authors. See copying.md for legal info.
+
+#include "physics.h"
+
+#include <cmath>
+
+#include "gui.h"
+#include "../../error/error.h"
+#include "../../rng/global_rng.h"
+#include "../../util/stringformatter.h"
+
+
+namespace openage::main::tests::pong {
+
+
+class BallReflectWall : public event::DependencyEventHandler {
+public:
+	BallReflectWall() : event::DependencyEventHandler("demo.ball.reflect_wall") {}
+
+	void setup_event(const std::shared_ptr<event::Event> &evnt,
+	                 const std::shared_ptr<event::State> &gstate) override {
+
+		auto state = std::dynamic_pointer_cast<PongState>(gstate);
+
+		// FIXME dependency to a full ball object so that any curve
+		// triggers a change
+		evnt->depend_on(state->ball);
+		evnt->depend_on(state->area_size);
+	}
+
+	// FIXME we REALLY need dependencies to objects i.e. Ball : public EventEntity()
+	void invoke(event::Loop &,
+	            const std::shared_ptr<event::EventEntity> &target,
+	            const std::shared_ptr<event::State> &gstate,
+	            const curve::time_t &now,
+	            const event::EventHandler::param_map &/*param*/) override {
+
+		auto positioncurve = std::dynamic_pointer_cast<curve::Segmented<util::Vector2d>>(target);
+		auto state = std::dynamic_pointer_cast<PongState>(gstate);
+		auto speedcurve = state->ball->speed;
+
+		// get speed and position to insert new movement keyframe
+		auto speed = speedcurve->get(now);
+		auto pos = positioncurve->get(now);
+		auto screen_size = state->area_size->get(now);
+
+		speed[1] *= -1.0;
+		state->ball->speed->set_last(now, speed);
+		state->ball->position->set_last(now, pos);
+
+		if (speed[1] == 0) {
+			return;
+		}
+
+		curve::time_t ty = 0;
+		if (speed[1] > 0) {
+			ty = curve::time_t::from_double(
+				(screen_size[1] - pos[1]) / speed[1]
+			);
+		}
+		else if (speed[1] < 0) {
+			ty = curve::time_t::from_double(
+				pos[1] / -speed[1]
+			);
+		}
+
+		state->ball->position->set_last(now + ty, pos + (speed * ty.to_double()));
+	}
+
+	curve::time_t predict_invoke_time(const std::shared_ptr<event::EventEntity> &target,
+	                                  const std::shared_ptr<event::State> &gstate,
+	                                  const curve::time_t &now) override {
+
+		auto positioncurve = std::dynamic_pointer_cast<curve::Segmented<util::Vector2d>>(target);
+		auto state = std::dynamic_pointer_cast<PongState>(gstate);
+
+		auto speed = state->ball->speed->get(now);
+		auto pos = positioncurve->get(now);
+		auto screen_size = state->area_size->get(now);
+
+		if (speed[1] == 0) {
+			return std::numeric_limits<curve::time_t>::max();
+		}
+
+		curve::time_t ty = 0;
+		if (speed[1] > 0) {
+			ty = curve::time_t::from_double((screen_size[1] - pos[1]) / speed[1]);
+		}
+		else if (speed[1] < 0) {
+			ty = curve::time_t::from_double(pos[1] / -speed[1]);
+		}
+
+		util::FString str;
+		str.fmt("WALL TY %f NOW %f, NOWTY %f ",
+		        ty.to_double(), now.to_double(), (now + ty).to_double());
+		state->gui->log(str);
+
+		return now + ty;
+	}
+};
+
+
+class BallReflectPanel : public event::DependencyEventHandler {
+public:
+	BallReflectPanel ()
+		:
+		event::DependencyEventHandler("demo.ball.reflect_panel") {}
+
+	void setup_event(const std::shared_ptr<event::Event> &evnt,
+	                 const std::shared_ptr<event::State> &gstate) override {
+
+		auto state = std::dynamic_pointer_cast<PongState>(gstate);
+
+		evnt->depend_on(state->ball);
+		evnt->depend_on(state->p1->position);
+		evnt->depend_on(state->p2->position);
+		evnt->depend_on(state->area_size);
+	}
+
+	void invoke(event::Loop &mgr,
+	            const std::shared_ptr<event::EventEntity> &/*target*/,
+	            const std::shared_ptr<event::State> &gstate,
+	            const curve::time_t &now,
+	            const event::EventHandler::param_map &/*param*/) override {
+
+		auto state = std::dynamic_pointer_cast<PongState>(gstate);
+
+		auto pos = state->ball->position->get(now);
+		auto speed = state->ball->speed->get(now);
+		auto screen_size = state->area_size->get(now);
+
+		static int cnt = 0;
+		util::FString str;
+		str.fmt("Panel hit [%i]", ++cnt);
+		state->gui->log(str);
+
+		if (pos[0] <= 1 and
+		    speed[0] < 0 and
+		    (pos[1] < state->p1->position->get(now) - state->p1->size->get(now) / 2 or
+		     pos[1] > state->p1->position->get(now) + state->p1->size->get(now) / 2)) {
+
+			// ball missed the paddle of player 1
+			auto l = state->p1->lives->get(now);
+			l--;
+
+			state->p1->lives->set_last(now, l);
+			state->ball->position->set_last(now, pos);
+
+			Physics::reset(state, mgr, now);
+		}
+		else if (pos[0] >= screen_size[0] - 1 and
+		         speed[0] > 0 and
+		         (pos[1] < state->p2->position->get(now) - state->p2->size->get(now) / 2 or
+		          pos[1] > state->p2->position->get(now) + state->p2->size->get(now) / 2)) {
+
+			// ball missed the paddel of player 2
+			auto l = state->p2->lives->get(now);
+			l--;
+			state->p2->lives->set_last(now, l);
+			state->ball->position->set_last(now, pos);
+
+			Physics::reset(state, mgr, now);
+		}
+		else if (pos[0] >= screen_size[0]- 1 || pos[0] <= 1) {
+			speed[0] *= -1;
+			state->ball->speed->set_last(now, speed);
+			state->ball->position->set_last(now, pos);
+		}
+
+		curve::time_t ty = 0;
+		if (speed[0] > 0) {
+			ty = curve::time_t::from_double((screen_size[0] - pos[0]) / speed[0]);
+		}
+		else if (speed[0] < 0) {
+			ty = curve::time_t::from_double(pos[0] / -speed[0]);
+		}
+
+		auto hit_pos = pos + speed * ty.to_double();
+		if (speed[0] > 0) {
+			hit_pos[0] = screen_size[0];
+		}
+		else {
+			hit_pos[0] = 0;
+		}
+
+		state->ball->position->set_last(now + ty, hit_pos);
+
+		// update ball color through nyan transaction (just as a demo...)
+		nyan::Transaction tx = state->dbroot->new_transaction(now.to_int());
+
+		if (speed[0] > 0) {
+			tx.add(state->dbroot->get_object("pong.RightColor"));
+		} else {
+			tx.add(state->dbroot->get_object("pong.LeftColor"));
+		}
+
+		bool txok = tx.commit();
+		if (not txok) {
+			throw Error{ERR << "failed nyan transaction"};
+		}
+	}
+
+	curve::time_t predict_invoke_time(const std::shared_ptr<event::EventEntity> &target,
+	                                  const std::shared_ptr<event::State> &gstate,
+	                                  const curve::time_t &now) override {
+
+		auto positioncurve = std::dynamic_pointer_cast<curve::Segmented<util::Vector2d>>(target);
+		auto state = std::dynamic_pointer_cast<PongState>(gstate);
+
+		auto speed = state->ball->speed->get(now);
+		auto pos = positioncurve->get(now);
+		auto screen_size = state->area_size->get(now);
+
+		if (speed[0] == 0)
+			return std::numeric_limits<curve::time_t>::max();
+
+		curve::time_t ty = 0;
+
+		if (speed[0] > 0) {
+			ty = curve::time_t::from_double((screen_size[0] - pos[0]) / speed[0]);
+		}
+		else if (speed[0] < 0) {
+			ty = curve::time_t::from_double(pos[0] / -speed[0]);
+		}
+
+		{
+			util::FString str;
+			str.fmt("PANEL REFLECT AT %f NEXT %f", now.to_double(), (now + ty).to_double());
+			state->gui->log(str);
+		}
+
+		auto hit_pos = pos + speed * ty.to_double();
+		if (speed[0] > 0) {
+			hit_pos[0] = screen_size[0];
+		}
+		else {
+			hit_pos[0] = 0;
+		}
+
+		ENSURE(hit_pos[0] >= 0, "hit position x must be positive");
+
+		return now + ty;
+	}
+};
+
+
+class ResetGame : public event::OnceEventHandler {
+public:
+	ResetGame ()
+		:
+		event::OnceEventHandler("demo.reset") {}
+
+	void setup_event(const std::shared_ptr<event::Event> &/*target*/,
+	                 const std::shared_ptr<event::State> &/*state*/) override {}
+
+	void invoke(event::Loop &/*mgr*/,
+	            const std::shared_ptr<event::EventEntity> &/*target*/,
+	            const std::shared_ptr<event::State> &gstate,
+	            const curve::time_t &now,
+	            const event::EventHandler::param_map &/*param*/) override {
+
+		auto state = std::dynamic_pointer_cast<PongState>(gstate);
+
+		auto screen_size = state->area_size->get(now);
+
+		// Check if the condition still applies
+		{
+			auto pos = state->ball->position->get(now);
+			if (pos[0] > 0 && pos[0] < screen_size[0]) {
+				// the gamestate is still valid - there is no need to reset
+				throw Error(ERR << "reset invoked even though unnecessary");
+			}
+		}
+
+		// move ball to the center
+		state->ball->position->set_last_jump(now,
+		                                     state->ball->position->get(now),
+		                                     screen_size.casted<double>() / 2);
+
+		// move paddles to center
+		state->p1->position->set_last(now, screen_size[1] / 2);
+		state->p2->position->set_last(now, screen_size[1] / 2);
+
+		// initial speed of the ball:
+		float dirx = (rng::random() % 2) ? 1 : -1;
+		float diry = (rng::random() % 2) ? 1 : -1;
+		auto init_speed = util::Vector2d(
+			dirx * (screen_size[0] / 8.0 + (rng::random() % (screen_size[0]/10))),
+			diry * (screen_size[1] / 10.0 + (rng::random() % (screen_size[1]/10)))
+		);
+
+		state->ball->speed->set_last(now, init_speed);
+		auto pos = state->ball->position->get(now);
+
+		{
+			static int cnt = 0;
+
+			util::FString str;
+			str.fmt("Reset #%i. Speed %f | %f POS %f | %f",
+			        ++cnt,
+			        init_speed[0],
+			        init_speed[1],
+			        pos[0],
+			        pos[1]);
+			state->gui->log(str);
+		}
+
+		curve::time_t ty = 0;
+
+		// calculate the wall-hit-times
+		if (init_speed[1] > 0) {
+			ty = curve::time_t::from_double((screen_size[1] - pos[1]) / init_speed[1]);
+		}
+		else if (init_speed[1] < 0) {
+			ty = curve::time_t::from_double(pos[1] / -init_speed[1]);
+		}
+		else {
+			// currently never happens, but this would be a non-vertically-moving ball
+			// fallback to calculating panel-hit-times
+			if (init_speed[0] > 0) {
+				ty = curve::time_t::from_double((screen_size[0] - pos[0]) / init_speed[0]);
+			}
+			else {
+				ty = curve::time_t::from_double(pos[0] / -init_speed[0]);
+			}
+		}
+
+		state->ball->position->set_last(now + ty, pos + init_speed * ty.to_double());
+	}
+
+	curve::time_t predict_invoke_time(const std::shared_ptr<event::EventEntity> &/*target*/,
+	                                  const std::shared_ptr<event::State> &/*state*/,
+	                                  const curve::time_t &old_time) override {
+		return old_time;
+	}
+};
+
+
+void Physics::init(const std::shared_ptr<PongState> &state,
+                   const std::shared_ptr<event::Loop> &loop,
+                   const curve::time_t &now) {
+
+	loop->add_event_class(std::make_shared<BallReflectPanel>());
+	loop->add_event_class(std::make_shared<BallReflectWall>());
+	loop->add_event_class(std::make_shared<ResetGame>());
+
+	loop->create_event("demo.ball.reflect_wall", state->ball->position, state, now);
+	loop->create_event("demo.ball.reflect_panel", state->ball->position, state, now);
+
+	// FIXME once "reset": deregister
+	//reset(state, mgr, now);
+}
+
+
+void Physics::reset(const std::shared_ptr<event::State> &gstate,
+                    event::Loop &mgr,
+                    const curve::time_t &now) {
+
+	auto state = std::dynamic_pointer_cast<PongState>(gstate);
+	mgr.create_event("demo.reset", state->ball->position, state, now);
+}
+
+
+void Physics::process_input(const std::shared_ptr<PongState> &state,
+                            const std::shared_ptr<PongPlayer> &player,
+                            const std::vector<PongEvent> &events,
+                            const std::shared_ptr<event::Loop> &mgr,
+                            const curve::time_t &now) {
+
+	// seconds into the future
+	constexpr static auto predicted_movement_time = curve::time_t::from_double(5.0);
+
+	// pixels per second for paddle movement
+	constexpr static double movement_speed = 350.0;
+
+	for (auto& evnt : events) {
+
+		// Process only if the future has changed
+		if (player->state->get(now).state != evnt.state) {
+
+			// log the new input in the state curve
+			player->state->set_last(now, evnt);
+
+			auto screen_size = state->area_size->get(now);
+
+			// if the state is active longer than predicted,
+			// we have to extend the prediction!
+			bool extend_previous_prediction = false;
+			auto prev_state = player->state->get_previous(now);
+			if (prev_state and prev_state->second.state == evnt.state) {
+				extend_previous_prediction = true;
+			}
+
+			switch(evnt.state) {
+			case PongEvent::UP:
+			case PongEvent::DOWN: {
+				float current_pos = player->position->get(now);
+
+				if (not extend_previous_prediction) {
+					// create a keyframe for the new movement
+					player->position->set_last(now, current_pos);
+					// TODO: drop the intermediate keyframes
+					//       for position and speed.
+				}
+
+				switch (evnt.state) {
+				case PongEvent::UP:
+					player->speed->set_last(now, -movement_speed);
+					break;
+				case PongEvent::DOWN:
+					player->speed->set_last(now, movement_speed);
+					break;
+				default:
+					// never reached.
+					break;
+				}
+
+				curve::time_t move_stop_guess = now + predicted_movement_time;
+
+				// change the position by integrating the speed curve.
+				// TODO: add native integral to curves.
+				float new_pos = current_pos +
+				                (((player->speed->get(move_stop_guess) +
+				                   player->speed->get(now)) / 2.0) *
+				                 predicted_movement_time.to_double());
+
+				// if paddle will get out-of-bounds, calculate the bound hit time
+
+				// TODO: add native key/value finding in range to curves
+				if (new_pos < 0) {
+					move_stop_guess = now + (current_pos / movement_speed);
+					new_pos = 0;
+				}
+
+				if (new_pos > screen_size[1]) {
+					move_stop_guess = now + ((screen_size[1] - current_pos) / movement_speed);
+					new_pos = screen_size[1];
+				}
+
+				PongEvent set_idle{evnt.player, PongEvent::IDLE};
+				player->state->set_last(move_stop_guess, set_idle);
+				player->speed->set_last(move_stop_guess, 0);
+				player->position->set_last(move_stop_guess, new_pos);
+
+				// TODO: predict_reflect_panel(state, queue, now);
+				break;
+			}
+
+			case PongEvent::IDLE:
+				player->position->set_last(now, player->position->get(now));
+				player->speed->set_last(now, 0);
+				break;
+
+			case PongEvent::START:
+				Physics::reset(state, *mgr, now);
+				break;
+
+			default:
+				break;
+			}
+		}
+	}
+}
+
+} // openage::main::tests::pong
diff --git a/libopenage/main/tests/physics.h b/libopenage/main/tests/physics.h
new file mode 100644
index 0000000000..b7420bbead
--- /dev/null
+++ b/libopenage/main/tests/physics.h
@@ -0,0 +1,36 @@
+// Copyright 2019-2019 the openage authors. See copying.md for legal info.
+
+#pragma once
+
+#include "gamestate.h"
+#include "../../curve/curve.h"
+
+#include <vector>
+
+
+namespace openage::event {
+
+class Loop;
+
+} // openage::event
+
+namespace openage::main::tests::pong {
+
+class Physics {
+public:
+	static void init(const std::shared_ptr<PongState> &,
+	                 const std::shared_ptr<event::Loop> &mgr,
+	                 const curve::time_t &);
+
+	void process_input(const std::shared_ptr<PongState> &,
+	                   const std::shared_ptr<PongPlayer> &,
+	                   const std::vector<PongEvent> &input,
+	                   const std::shared_ptr<event::Loop> &mgr,
+	                   const curve::time_t &now);
+
+	static void reset(const std::shared_ptr<event::State> &,
+	                  event::Loop &mgr,
+	                  const curve::time_t &);
+};
+
+} // openage::main::tests::pong
diff --git a/libopenage/main/tests/pong.cpp b/libopenage/main/tests/pong.cpp
new file mode 100644
index 0000000000..ae7afe538b
--- /dev/null
+++ b/libopenage/main/tests/pong.cpp
@@ -0,0 +1,203 @@
+// Copyright 2018-2019 the openage authors. See copying.md for legal info.
+
+#include <cstdlib>
+#include <epoxy/gl.h>
+#include <functional>
+#include <unordered_map>
+#include <memory>
+
+#include <nyan/nyan.h>
+
+#include "aicontroller.h"
+#include "gui.h"
+#include "physics.h"
+#include "../../error/error.h"
+#include "../../event/loop.h"
+#include "../../log/log.h"
+#include "../../util/math_constants.h"
+#include "../../util/path.h"
+
+
+namespace openage::main::tests::pong {
+
+
+
+using Clock = std::chrono::high_resolution_clock;
+using namespace std::literals::chrono_literals;
+
+
+enum class timescale {
+	NOSLEEP,
+	REALTIME,
+	SLOW,
+	FAST,
+};
+
+void main(const util::Path& path) {
+	bool human_player = false;
+
+	timescale speed = timescale::REALTIME;
+
+	std::shared_ptr<nyan::Database> db = nyan::Database::create();
+
+	db->load(
+		"pong.nyan",
+		[&path] (const std::string &filename) {
+			// TODO: nyan should provide a file api that we can inherit from
+			// then we can natively interface to the openage file abstraction
+			// and do not need to read the whole file here.
+			// ideally, the returned file lazily accesses all data through openage::util::File.
+			return std::make_shared<nyan::File>(
+				filename,
+				(path / ("assets/nyan/" + filename)).open_r().read()
+			);
+		}
+	);
+
+	std::shared_ptr<nyan::View> dbview = db->new_view();
+	std::shared_ptr<Gui> gui = std::make_shared<Gui>();
+
+	bool running = true;
+
+	while (running) {
+		log::log(INFO << "initializing new pong game...");
+
+		auto loop = std::make_shared<event::Loop>();
+		curve::time_t now = 0;
+		Physics phys;
+
+		// the window size is fetched in here already,
+		// so the resize callback doesn't need to be called for
+		// a new state.
+		auto state = std::make_shared<PongState>(loop, gui, dbview);
+
+		gui->clear_resize_callbacks();
+		gui->add_resize_callback(
+			[&] (size_t w, size_t h) {
+				log::log(INFO << "update pong area size=("
+				         << w << "," << h << ")...");
+
+				state->area_size->set_last(now, {w, h});
+			}
+		);
+
+		// process one round of window events, mainly to get the initial screen size.
+		gui->update();
+
+		Physics::init(state, loop, now);
+
+		// initialize player properties
+		state->p1->lives->set_last(now, 3);
+		state->p1->size->set_last(now, 200);
+
+		state->p2->lives->set_last(now, 3);
+		state->p2->size->set_last(now, 200);
+
+		// initialize the game enqueuing a physics reset should happen.
+		log::log(INFO << "initializing the physics state...");
+		std::vector<PongEvent> start_event{PongEvent{0, PongEvent::START}};
+		phys.process_input(state, state->p1, start_event, loop, now);
+		loop->reach_time(now, state);
+
+		std::vector<PongEvent> inputs;
+
+		log::log(INFO << "starting game loop...");
+
+		// this is the game loop, running while both players live!
+		while (running and
+		       state->p1->lives->get(now) > 0 and
+		       state->p2->lives->get(now) > 0) {
+
+			log::log(DBG << "=================== LOOPING ====================");
+
+			auto loop_start = Clock::now();
+
+			// process the input for both players
+			// player 1 can be AI or human.
+
+			if (human_player) {
+				phys.process_input(state, state->p1,
+				                   inputs, loop, now);
+			}
+			else {
+				phys.process_input(state, state->p1,
+				                   get_ai_inputs(state->p1, state->ball,
+				                                 state->area_size, now, false),
+				                   loop, now);
+			}
+
+			phys.process_input(state, state->p2,
+			                   get_ai_inputs(state->p2, state->ball,
+			                                 state->area_size, now, true),
+			                   loop, now);
+
+			// evaluate the event queue to reach the desired game time!
+			loop->reach_time(now, state);
+
+			// draw the new state
+			gui->draw(state, now);
+
+			// TODO: print event queue from loop->get_queue().get_event_queue().get_sorted_events()
+			//       and show event->get_time and event->get_eventhandler()->id()
+
+			// get the input after the current frame, because the get_inputs
+			// implicitly updates the screen. if this is done too early,
+			// the screen will be updated to be empty -> flickering.
+			// TODO: take terminal input without ncurses, if on tty?
+			//       e.g. 'q' to close it?
+			inputs = gui->get_inputs(state->p1);
+
+			if (gui->exit_requested) {
+				running = false;
+			}
+
+			// handle timing for screen refresh and simulation advancement
+			using dt_s_t = std::chrono::duration<double, std::ratio<1>>;
+			using dt_ms_t = std::chrono::duration<double, std::milli>;
+
+			// microseconds per frame
+			// 30fps = 1s/30 = 1000000us/30 per frame
+			constexpr static std::chrono::microseconds per_frame = 33333us;
+			constexpr static curve::time_t per_frame_s = std::chrono::duration_cast<dt_s_t>(per_frame).count();
+
+			if (speed == timescale::NOSLEEP) {
+				// increase the simulation loop time a bit
+				SDL_Delay(5);
+			}
+
+			dt_ms_t dt_us = Clock::now() - loop_start;
+
+			if (speed != timescale::NOSLEEP) {
+				dt_ms_t wait_time = per_frame - dt_us;
+
+				if (wait_time > dt_ms_t::zero()) {
+					SDL_Delay(wait_time.count());
+				}
+			}
+
+			switch (speed) {
+			case timescale::NOSLEEP:
+				// advance the frame calculation time only,
+				// because we didn't sleep
+				now += std::chrono::duration_cast<dt_s_t>(dt_us).count();
+				break;
+
+			case timescale::REALTIME:
+				// advance the game time in seconds
+				now += per_frame_s;
+				break;
+
+			case timescale::SLOW:
+				now += per_frame_s / 10;
+				break;
+
+			case timescale::FAST:
+				now += per_frame_s * 4;
+				break;
+			}
+		}
+	}
+}
+
+
+} // openage::main::tests::pong
diff --git a/libopenage/main/tests/pong.h b/libopenage/main/tests/pong.h
new file mode 100644
index 0000000000..38d234ddee
--- /dev/null
+++ b/libopenage/main/tests/pong.h
@@ -0,0 +1,18 @@
+// Copyright 2018-2019 the openage authors. See copying.md for legal info.
+
+#pragma once
+
+
+#include "../../util/path.h"
+
+
+namespace openage::main::tests::pong {
+
+
+/**
+ * Run pong, the non-terminal variant.
+ */
+void main(const util::Path& path);
+
+
+} // openage::main::tests::pong
diff --git a/libopenage/nyan/db.h b/libopenage/nyan/db.h
new file mode 100644
index 0000000000..23a39980a6
--- /dev/null
+++ b/libopenage/nyan/db.h
@@ -0,0 +1,12 @@
+// Copyright 2018-2019 the openage authors. See copying.md for legal info.
+
+#pragma once
+
+#include <nyan/nyan.h>
+
+#include "../log/log.h"
+#include "../error/error.h"
+
+namespace openage::nyan {
+
+}
diff --git a/libopenage/presenter/CMakeLists.txt b/libopenage/presenter/CMakeLists.txt
new file mode 100644
index 0000000000..ddfe6943a6
--- /dev/null
+++ b/libopenage/presenter/CMakeLists.txt
@@ -0,0 +1,3 @@
+add_sources(libopenage
+	test.cpp
+)
diff --git a/libopenage/presenter/test.cpp b/libopenage/presenter/test.cpp
new file mode 100644
index 0000000000..ed61c52a14
--- /dev/null
+++ b/libopenage/presenter/test.cpp
@@ -0,0 +1,12 @@
+// Copyright 2018-2019 the openage authors. See copying.md for legal info.
+
+#include "../log/log.h"
+
+
+namespace openage::presenter::tests {
+
+void demo() {
+	log::log(INFO << "presenter demo launching...");
+}
+
+} // openage::presenter::tests
diff --git a/libopenage/pyinterface/exctranslate.cpp b/libopenage/pyinterface/exctranslate.cpp
index 9e46889020..04e1a12d68 100644
--- a/libopenage/pyinterface/exctranslate.cpp
+++ b/libopenage/pyinterface/exctranslate.cpp
@@ -1,4 +1,4 @@
-// Copyright 2015-2018 the openage authors. See copying.md for legal info.
+// Copyright 2015-2019 the openage authors. See copying.md for legal info.
 
 #include "exctranslate.h"
 
@@ -49,7 +49,9 @@ void translate_exc_cpp_to_py() {
 		// when we reach this, cython caught an error.
 		// and we're now in the handler.
 
-		// to continue, first rethrow the exception so we can analyze it:
+		// to continue, first rethrow the exception so we can analyze it
+		// and to restore its context in case it's an exception that doesn't
+		// store useful information.
 		throw;
 
 	} catch (PyException &exc) {
@@ -77,28 +79,9 @@ void translate_exc_cpp_to_py() {
 		// = insert it in pythons backtrace
 		raise_cpp_error(&exc);
 	}
-	// we also need to catch std::exception so that rethrown causes are handled
-	// properly. otherwise they just crash everything. not good.
-	catch (const std::exception &exc) {
-		// the std::exception doesn't contain a stack trace...
-		// as we're at a special place we must not generate the current
-		// stack trace either. and we _must not_ store the causing
-		// exception, as the whole point of this code is to get rid
-		// of std::exceptions.
-		Error error{
-			ERR << "std::exception: "
-			    << util::demangle(typeid(exc).name())
-			    << ": "
-			    << exc.what(),
-			false,
-			false
-		};
-
-		raise_cpp_error(&error);
-	}
 
 	/*
-	 * all other exceptions are more than unexpected;
+	 * all other exceptions are more than unexpected; even std::exception.
 	 * they don't contain any useful stack trace information,
 	 * so the safest course of action is not to catch them.
 	 * That way, terminate() is called, where we can analyze the stack
diff --git a/libopenage/renderer/CMakeLists.txt b/libopenage/renderer/CMakeLists.txt
index 037c70c85a..b18edc8077 100644
--- a/libopenage/renderer/CMakeLists.txt
+++ b/libopenage/renderer/CMakeLists.txt
@@ -2,13 +2,14 @@ add_sources(libopenage
 	color.cpp
 	geometry.cpp
 	renderer.cpp
-	shader_program.cpp
 	sdl_global.cpp
+	shader_program.cpp
 	tests.cpp
 	text.cpp
 	texture.cpp
 	texture_array.cpp
 	uniform_input.cpp
+	util.cpp
 	window.cpp
 )
 
diff --git a/libopenage/renderer/opengl/renderer.cpp b/libopenage/renderer/opengl/renderer.cpp
index 1e9cb2eada..f1392bae80 100644
--- a/libopenage/renderer/opengl/renderer.cpp
+++ b/libopenage/renderer/opengl/renderer.cpp
@@ -83,9 +83,9 @@ void GlRenderer::optimise(const std::shared_ptr<GlRenderPass> &pass) {
 		auto renderables = pass->get_renderables();
 		std::stable_sort(renderables.begin(), renderables.end(), [](const Renderable& a, const Renderable& b) {
 			GLuint shader_a = std::dynamic_pointer_cast<GlShaderProgram>(
-				std::dynamic_pointer_cast<GlUniformInput>(a.unif_in)->get_program())->get_handle();
+				std::dynamic_pointer_cast<GlUniformInput>(a.uniform)->get_program())->get_handle();
 			GLuint shader_b = std::dynamic_pointer_cast<GlShaderProgram>(
-				std::dynamic_pointer_cast<GlUniformInput>(b.unif_in)->get_program())->get_handle();
+				std::dynamic_pointer_cast<GlUniformInput>(b.uniform)->get_program())->get_handle();
 			return shader_a < shader_b;
 		});
 
@@ -119,7 +119,7 @@ void GlRenderer::render(const std::shared_ptr<RenderPass> &pass) {
 			glDisable(GL_DEPTH_TEST);
 		}
 
-		auto in = std::dynamic_pointer_cast<GlUniformInput>(obj.unif_in);
+		auto in = std::dynamic_pointer_cast<GlUniformInput>(obj.uniform);
 		auto program = std::static_pointer_cast<GlShaderProgram>(in->get_program());
 
 		// this also calls program->use()
diff --git a/libopenage/renderer/opengl/shader_program.cpp b/libopenage/renderer/opengl/shader_program.cpp
index bcbce8b587..ca460f4ae6 100644
--- a/libopenage/renderer/opengl/shader_program.cpp
+++ b/libopenage/renderer/opengl/shader_program.cpp
@@ -334,6 +334,9 @@ bool GlShaderProgram::in_use() const {
 void GlShaderProgram::update_uniforms(std::shared_ptr<GlUniformInput> const& unif_in) {
 	ENSURE(unif_in->get_program() == this->shared_from_this(), "Uniform input passed to different shader than it was created with.");
 
+	// TODO: use glProgramUniform when we're on OpenGL 4.1
+	// then we don't need to "use" and then call glUniform*
+
 	if (not this->in_use()) {
 		this->use();
 	}
diff --git a/libopenage/renderer/renderer.h b/libopenage/renderer/renderer.h
index af5487e304..2a6aaac964 100644
--- a/libopenage/renderer/renderer.h
+++ b/libopenage/renderer/renderer.h
@@ -21,6 +21,7 @@ class Geometry;
 class Texture2d;
 class UniformInput;
 
+
 /// The abstract base for a render target.
 class RenderTarget : public std::enable_shared_from_this<RenderTarget> {
 protected:
@@ -30,29 +31,57 @@ class RenderTarget : public std::enable_shared_from_this<RenderTarget> {
 	virtual ~RenderTarget() = default;
 };
 
-/// A renderable is a set of shader uniform inputs and a possible draw call.
-/// When a renderable is parsed, the uniform inputs are first passed to the shader they were created with.
-/// Then, if the geometry is not nullptr, the shader is executed with the geometry and the specified settings
-/// and the results are written into the render target. If the geometry is nullptr, the uniform values are
-/// uploaded to the shader but no draw call is performed. This can be used to, for example, first set the values
-/// of uniforms that many objects have in common, and then only upload the uniforms that vary between them in
-/// each draw call. This works because uniform values in any given shader are preserved across a render pass.
+/// A renderable is a set of a shader UniformInput and a possible draw call.
+/// Usually it is one "step" in a RenderPass.
+///
+/// The UniformInput only stores the values the CPU at first. When the renderer
+/// "executes" the Renderable in a pass, the UniformInput values are uploaded to
+/// the shader on the GPU they were created with.
+///
+/// If the geometry is nullptr, the uniform values are uploaded to the shader,
+/// but no draw call is performed. This can be used to, for example, first set
+/// the values of uniforms that many objects have in common, and then only
+/// upload the uniforms that vary between them in each draw call. This works
+/// because uniform values in any given shader are preserved across a render
+/// pass.
+///
+/// If geometry is set (i.e. it is not nullptr), the renderer draws the geometry
+/// with the shader and other settings in the renderable. The result is written
+/// into the render target, defined in the RenderPass.
 struct Renderable {
-	/// Uniform values to be set in the appropriate shader. Contains a reference to the correct shader, and this
-	/// is the shader that will be used for drawing if geometry is present.
-	std::shared_ptr<UniformInput> unif_in;
+	/// Uniform values to be set in the appropriate shader. Contains a reference
+	/// to the correct shader, and this is the shader that will be used for
+	/// drawing if geometry is present.
+	std::shared_ptr<UniformInput> uniform;
 	/// The geometry. It can be a simple primitive or a complex mesh.
 	/// Can be nullptr to only set uniforms but do not perform draw call.
 	std::shared_ptr<Geometry> geometry;
-	/// Whether to perform alpha-based color blending with whatever was in the render target before.
-	bool alpha_blending;
+	/// Whether to perform alpha-based color blending with whatever was in the
+	/// render target before.
+	bool alpha_blending = true;
 	/// Whether to perform depth testing and discard occluded fragments.
-	bool depth_test;
+	bool depth_test = true;
 };
 
+
+/// Simplified form of Renderable, which is just an update for a shader.
+/// When the ShaderUpdate is processed in a RenderPass,
+/// the new uniform values (set on the CPU first with unif_in.update(...))
+/// are uploaded to the GPU.
+struct ShaderUpdate : Renderable {
+	ShaderUpdate(std::shared_ptr<UniformInput> const& uniform)
+		: Renderable{uniform, nullptr} {}
+
+	ShaderUpdate(std::shared_ptr<UniformInput> && uniform)
+		: Renderable{std::move(uniform), nullptr} {}
+};
+
+
 /// A render pass is a series of draw calls represented by renderables that output into the given render target.
 class RenderPass {
 protected:
+	/// Create a new RenderPass. This is called from Renderer::add_render_pass,
+	/// which then creates the proper subclass of RenderPass, depending on the backend.
 	RenderPass(std::vector<Renderable>, const std::shared_ptr<RenderTarget> &);
 	/// The renderables to parse and possibly execute.
 	std::vector<Renderable> renderables;
@@ -66,6 +95,7 @@ class RenderPass {
 	std::shared_ptr<RenderTarget> target;
 };
 
+
 /// The renderer. This class is used for performing all graphics operations. It is abstract and has implementations
 /// for various low-level graphics APIs like OpenGL.
 class Renderer {
diff --git a/libopenage/renderer/resources/mesh_data.cpp b/libopenage/renderer/resources/mesh_data.cpp
index 265ab4e87b..dcd5c3c4e2 100644
--- a/libopenage/renderer/resources/mesh_data.cpp
+++ b/libopenage/renderer/resources/mesh_data.cpp
@@ -1,4 +1,4 @@
-// Copyright 2017-2019 the openage authors. See copying.md for legal info.
+// Copyright 2017-2021 the openage authors. See copying.md for legal info.
 
 #include "mesh_data.h"
 
@@ -111,21 +111,122 @@ VertexInputInfo MeshData::get_info() const {
 
 /// Vertices of a quadrilateral filling the whole screen.
 /// Format: (pos, tex_coords) = (x, y, u, v)
-static constexpr const std::array<float, 16> QUAD_DATA = { {
+static constexpr const std::array<float, 16> QUAD_DATA_CENTERED = {
+	{
 		-1.0f, 1.0f, 0.0f, 1.0f,
 		-1.0f, -1.0f, 0.0f, 0.0f,
 		1.0f, 1.0f, 1.0f, 1.0f,
 		1.0f, -1.0f, 1.0f, 0.0f
-	} };
+	}
+};
+
+/// Vertices of a quad from (0, 0) to (1, 1)
+/// Format: (pos, tex_coords) = (x, y, u, v)
+static constexpr const std::array<float, 16> QUAD_DATA_UNIT = {
+	{
+		0.0f, 1.0f, 0.0f, 1.0f,
+		0.0f, 0.0f, 0.0f, 0.0f,
+		1.0f, 1.0f, 1.0f, 1.0f,
+		1.0f, 0.0f, 1.0f, 0.0f
+	}
+};
+
+
+namespace {
+
+/**
+ * Generate triangle-strip meshdata for a given 4-vertex/uv-coord array.
+ */
+template <size_t size>
+MeshData create_float_mesh(const std::array<float, size> &src) {
+	auto const data_size = size * sizeof(float);
 
-MeshData MeshData::make_quad() {
-	auto const data_size = QUAD_DATA.size() * sizeof(decltype(QUAD_DATA)::value_type);
 	std::vector<uint8_t> verts(data_size);
-	std::memcpy(verts.data(), reinterpret_cast<const uint8_t*>(QUAD_DATA.data()), data_size);
+	std::memcpy(verts.data(), reinterpret_cast<const uint8_t*>(src.data()), data_size);
 
-	VertexInputInfo info { { vertex_input_t::V2F32, vertex_input_t::V2F32 }, vertex_layout_t::AOS, vertex_primitive_t::TRIANGLE_STRIP };
+	VertexInputInfo info {
+		{ vertex_input_t::V2F32, vertex_input_t::V2F32 },
+		vertex_layout_t::AOS,
+		vertex_primitive_t::TRIANGLE_STRIP
+	};
 
 	return MeshData(std::move(verts), info);
 }
 
+} // anon namespace
+
+
+MeshData MeshData::make_quad(bool centered) {
+	if (centered) {
+		return create_float_mesh(QUAD_DATA_CENTERED);
+	}
+	else {
+		return create_float_mesh(QUAD_DATA_UNIT);
+	}
 }
+
+
+MeshData MeshData::make_quad(float sidelength, bool centered) {
+
+	// 8 positions and 8 uv-coords.
+	// store pos and uv as: (x, y, uvx, uvy)
+	std::array<float, 16> positions;
+
+	if (centered) {
+		float halfsidelength = sidelength/2;
+		positions = {
+			{
+				-halfsidelength, halfsidelength, 0.0f, 1.0f,
+				-halfsidelength, -halfsidelength, 0.0f, 0.0f,
+				halfsidelength, halfsidelength, 1.0f, 1.0f,
+				halfsidelength, -halfsidelength, 1.0f, 0.0f
+			}
+		};
+	}
+	else {
+		positions = {
+			{
+				0.0f, sidelength, 0.0f, 1.0f,
+				0.0f, 0.0f, 0.0f, 0.0f,
+				sidelength, sidelength, 1.0f, 1.0f,
+				sidelength, 0.0f, 1.0f, 0.0f
+			}
+		};
+	}
+
+	return create_float_mesh(positions);
+}
+
+
+MeshData MeshData::make_quad(float width, float height, bool centered) {
+	// 8 positions and 8 uv-coords.
+	// store pos and uv as: (x, y, uvx, uvy)
+	std::array<float, 16> positions;
+
+	if (centered) {
+		float halfwidth = width/2;
+		float halfheight = height/2;
+		positions = {
+			{
+				-halfwidth, halfheight, 0.0f, 1.0f,
+				-halfwidth, -halfheight, 0.0f, 0.0f,
+				halfwidth, halfheight, 1.0f, 1.0f,
+				halfwidth, -halfheight, 1.0f, 0.0f
+			}
+		};
+	}
+	else {
+		positions = {
+			{
+				0.0f, height, 0.0f, 1.0f,
+				0.0f, 0.0f, 0.0f, 0.0f,
+				width, height, 1.0f, 1.0f,
+				width, 0.0f, 1.0f, 0.0f
+			}
+		};
+	}
+
+	return create_float_mesh(positions);
+}
+
+} // namespace openage::renderer::resources
diff --git a/libopenage/renderer/resources/mesh_data.h b/libopenage/renderer/resources/mesh_data.h
index 3634b1eee8..5d1ce51f9e 100644
--- a/libopenage/renderer/resources/mesh_data.h
+++ b/libopenage/renderer/resources/mesh_data.h
@@ -133,7 +133,16 @@ class MeshData {
 
 	/// Initializes the mesh data with a simple quadrilateral spanning the whole window space,
 	/// with (vec2 pos, vec2 uv) vertex format.
-	static MeshData make_quad();
+	/// (0, 0) of this quad is at the quad center and it stretches from (-1, -1) to (1, 1)
+	/// and uv=(0, 0) at bottom left (-> (-1, -1)) and uv=(1, 1) top right (at (1, 1)).
+	/// When centered = false, the quad stretches from (0, 0) to (1, 1).
+	static MeshData make_quad(bool centered=true);
+
+	/// Initialize the mesh data with given sidelength. Optionally place (0, 0) bottom left.
+	static MeshData make_quad(float sidelength, bool centered=true);
+
+	/// Initialize the mesh data with given width and height. Optionally place (0, 0) bottom left.
+	static MeshData make_quad(float width, float height, bool centered=true);
 
 private:
 	/// The raw vertex data. The size is an integer multiple of the size of a single vertex.
diff --git a/libopenage/renderer/tests.cpp b/libopenage/renderer/tests.cpp
index 8b958ab852..4d0d57fa17 100644
--- a/libopenage/renderer/tests.cpp
+++ b/libopenage/renderer/tests.cpp
@@ -11,6 +11,7 @@
 
 #include "../log/log.h"
 #include "../error/error.h"
+#include "../util/math_constants.h"
 #include "resources/shader_source.h"
 #include "resources/texture_data.h"
 #include "resources/mesh_data.h"
@@ -118,7 +119,7 @@ void main() {
 
 	auto transform1 = Eigen::Affine3f::Identity();
 	transform1.prescale(Eigen::Vector3f(0.4f, 0.2f, 1.0f));
-	transform1.prerotate(Eigen::AngleAxisf(30.0f * 3.14159f / 180.0f, Eigen::Vector3f::UnitX()));
+	transform1.prerotate(Eigen::AngleAxisf(30.0f * math::PI / 180.0f, Eigen::Vector3f::UnitX()));
 	transform1.pretranslate(Eigen::Vector3f(-0.4f, -0.6f, 0.0f));
 
 	/* Clickable objects on the screen consist of a transform (matrix which places each object
@@ -131,7 +132,7 @@ void main() {
 
 	auto transform2 = Eigen::Affine3f::Identity();
 	transform2.prescale(Eigen::Vector3f(0.3f, 0.1f, 1.0f));
-	transform2.prerotate(Eigen::AngleAxisf(50.0f * 3.14159f / 180.0f, Eigen::Vector3f::UnitZ()));
+	transform2.prerotate(Eigen::AngleAxisf(50.0f * math::PI / 180.0f, Eigen::Vector3f::UnitZ()));
 
 	auto transform3 = transform2;
 
@@ -144,7 +145,7 @@ void main() {
 		"tex", gltex
 	);
 
-	transform3.prerotate(Eigen::AngleAxisf(90.0f * 3.14159f / 180.0f, Eigen::Vector3f::UnitZ()));
+	transform3.prerotate(Eigen::AngleAxisf(90.0f * math::PI / 180.0f, Eigen::Vector3f::UnitZ()));
 	transform3.pretranslate(Eigen::Vector3f(0.3f, 0.1f, 0.5f));
 
 	auto obj3_unifs = obj_shader->new_uniform_input(
diff --git a/libopenage/renderer/util.cpp b/libopenage/renderer/util.cpp
new file mode 100644
index 0000000000..d9c5fcfe1d
--- /dev/null
+++ b/libopenage/renderer/util.cpp
@@ -0,0 +1,22 @@
+// Copyright 2018-2019 the openage authors. See copying.md for legal info.
+
+
+#include "util.h"
+
+
+namespace openage::renderer::util {
+
+Eigen::Matrix4d ortho_matrix_d(double left,   double right,
+                               double bottom, double top,
+                               double near,   double far) {
+	return ortho_matrix<Eigen::Matrix4d, double>(left, right, bottom, top, near, far);
+}
+
+
+Eigen::Matrix4f ortho_matrix_f(float left,   float right,
+                               float bottom, float top,
+                               float near,   float far) {
+	return ortho_matrix<Eigen::Matrix4f, float>(left, right, bottom, top, near, far);
+}
+
+} // openage::renderer::util
diff --git a/libopenage/renderer/util.h b/libopenage/renderer/util.h
new file mode 100644
index 0000000000..6c7609a896
--- /dev/null
+++ b/libopenage/renderer/util.h
@@ -0,0 +1,53 @@
+// Copyright 2018-2019 the openage authors. See copying.md for legal info.
+
+#pragma once
+
+
+#include <eigen3/Eigen/Dense>
+
+
+namespace openage::renderer::util {
+
+/**
+ * Creates a orthographic projection matrix.
+ *
+ * left, right: Left and right vertical clipping plane coordinates.
+ * bottom, top: Horizontal clipping plane coordinates.
+ * near, far: Distances to nearer and farther depth clipping planes.
+ *            Specify as negative if the plane is behind the viewpoint.
+ */
+template <typename matrix_t, typename number_t>
+matrix_t ortho_matrix(number_t left, number_t right,
+                      number_t bottom, number_t top,
+                      number_t near, number_t far) {
+
+	matrix_t ortho;
+	ortho << 2/(right-left),                0,             0, -(right + left)/(right - left),
+	         0,              2/(top - bottom),             0, -(top + bottom)/(top - bottom),
+	         0,                             0, -2/(far-near),     -(far + near)/(far - near),
+	         0,                             0,             0,                              1;
+
+	return ortho;
+}
+
+
+/**
+ * Create a orthographic projection matrix. Double variant.
+ *
+ * @see ortho_matrix
+ */
+Eigen::Matrix4d ortho_matrix_d(double left,   double right,
+                               double bottom, double top,
+                               double near,   double far);
+
+
+/**
+ * Create a orthographic projection matrix. Float variant.
+ *
+ * @see ortho_matrix
+ */
+Eigen::Matrix4f ortho_matrix_f(float left,   float right,
+                               float bottom, float top,
+                               float near,   float far);
+
+} // openage::renderer::util
diff --git a/libopenage/simulation/entity.cpp b/libopenage/simulation/entity.cpp
index 254ce8a451..2c5455d503 100644
--- a/libopenage/simulation/entity.cpp
+++ b/libopenage/simulation/entity.cpp
@@ -1,15 +1,14 @@
-// Copyright 2017-2017 the openage authors. See copying.md for legal info.
+// Copyright 2017-2019 the openage authors. See copying.md for legal info.
 
 #include "entity.h"
 
 #include <nyan/nyan.h>
 
 
-namespace openage {
-namespace simulation {
+namespace openage::simulation {
+
+Entity::Entity() {
 
-void test() {
-	nyan::Database test;
 }
 
-}} // openage::simulation
+} // openage::simulation
diff --git a/libopenage/simulation/entity.h b/libopenage/simulation/entity.h
index 42ab54da19..d46d725f1c 100644
--- a/libopenage/simulation/entity.h
+++ b/libopenage/simulation/entity.h
@@ -1,9 +1,14 @@
-// Copyright 2017-2017 the openage authors. See copying.md for legal info.
+// Copyright 2019-2019 the openage authors. See copying.md for legal info.
 
 #pragma once
 
 
-namespace openage {
-namespace simulation {
+namespace openage::simulation {
 
-}} // openage::simulation
+
+class Entity {
+public:
+	Entity();
+};
+
+} // openage::simulation
diff --git a/libopenage/simulation/gameentity.cpp b/libopenage/simulation/gameentity.cpp
new file mode 100644
index 0000000000..e69de29bb2
diff --git a/libopenage/simulation/gameentity.h b/libopenage/simulation/gameentity.h
new file mode 100644
index 0000000000..7c38e28036
--- /dev/null
+++ b/libopenage/simulation/gameentity.h
@@ -0,0 +1,3 @@
+// Copyright 2019-2019 the openage authors. See copying.md for legal info.
+
+#pragma once
diff --git a/libopenage/unit/ability.cpp b/libopenage/unit/ability.cpp
index 907bf45a6e..0ab1eef175 100644
--- a/libopenage/unit/ability.cpp
+++ b/libopenage/unit/ability.cpp
@@ -1,10 +1,10 @@
-// Copyright 2014-2019 the openage authors. See copying.md for legal info.
+// Copyright 2014-2021 the openage authors. See copying.md for legal info.
 
 #include <memory>
 
 #include "../terrain/terrain_object.h"
-#include "../gamestate/cost.h"
-#include "../gamestate/player.h"
+#include "../gamestate/old/cost.h"
+#include "../gamestate/old/player.h"
 #include "ability.h"
 #include "action.h"
 #include "command.h"
diff --git a/libopenage/unit/ability.h b/libopenage/unit/ability.h
index fd879e1127..71985ebe8c 100644
--- a/libopenage/unit/ability.h
+++ b/libopenage/unit/ability.h
@@ -1,4 +1,4 @@
-// Copyright 2014-2019 the openage authors. See copying.md for legal info.
+// Copyright 2014-2021 the openage authors. See copying.md for legal info.
 
 #pragma once
 
@@ -9,7 +9,6 @@
 #include <vector>
 
 #include "../coord/phys.h"
-#include "../gamestate/resource.h"
 
 namespace openage {
 
diff --git a/libopenage/unit/action.h b/libopenage/unit/action.h
index 727e151bdd..f6e7d0b9eb 100644
--- a/libopenage/unit/action.h
+++ b/libopenage/unit/action.h
@@ -1,4 +1,4 @@
-// Copyright 2014-2019 the openage authors. See copying.md for legal info.
+// Copyright 2014-2021 the openage authors. See copying.md for legal info.
 
 #pragma once
 
@@ -6,7 +6,7 @@
 #include <vector>
 
 #include "../pathfinding/path.h"
-#include "../gamestate/resource.h"
+#include "../gamestate/old/resource.h"
 #include "attribute.h"
 #include "research.h"
 #include "unit.h"
diff --git a/libopenage/unit/attribute.h b/libopenage/unit/attribute.h
index 6cd5c90cbf..9d335dfc7f 100644
--- a/libopenage/unit/attribute.h
+++ b/libopenage/unit/attribute.h
@@ -9,7 +9,7 @@
 #include "../coord/tile.h"
 #include "../gamedata/unit.gen.h"
 #include "../terrain/terrain_object.h"
-#include "../gamestate/resource.h"
+#include "../gamestate/old/resource.h"
 #include "unit_container.h"
 
 namespace std {
diff --git a/libopenage/unit/producer.h b/libopenage/unit/producer.h
index 642ed74c4c..8d87bd3293 100644
--- a/libopenage/unit/producer.h
+++ b/libopenage/unit/producer.h
@@ -1,4 +1,4 @@
-// Copyright 2014-2019 the openage authors. See copying.md for legal info.
+// Copyright 2014-2021 the openage authors. See copying.md for legal info.
 
 #pragma once
 
@@ -9,7 +9,7 @@
 #include "../coord/tile.h"
 #include "../gamedata/gamedata.gen.h"
 #include "../gamedata/graphic.gen.h"
-#include "../gamestate/player.h"
+#include "../gamestate/old/player.h"
 #include "unit.h"
 #include "unit_type.h"
 
diff --git a/libopenage/unit/research.cpp b/libopenage/unit/research.cpp
index eb74b138cc..7161565583 100644
--- a/libopenage/unit/research.cpp
+++ b/libopenage/unit/research.cpp
@@ -1,6 +1,6 @@
-// Copyright 2017-2017 the openage authors. See copying.md for legal info.
+// Copyright 2017-2018 the openage authors. See copying.md for legal info.
 
-#include "../gamestate/player.h"
+#include "../gamestate/old/player.h"
 #include "research.h"
 
 
diff --git a/libopenage/unit/unit_texture.cpp b/libopenage/unit/unit_texture.cpp
index 3604b1c165..a146f471b2 100644
--- a/libopenage/unit/unit_texture.cpp
+++ b/libopenage/unit/unit_texture.cpp
@@ -1,4 +1,4 @@
-// Copyright 2015-2020 the openage authors. See copying.md for legal info.
+// Copyright 2015-2021 the openage authors. See copying.md for legal info.
 
 #include "unit_texture.h"
 
@@ -7,7 +7,7 @@
 
 #include "../coord/phys.h"
 #include "../coord/pixel.h"
-#include "../gamestate/game_spec.h"
+#include "../gamestate/old/game_spec.h"
 #include "../log/log.h"
 #include "../texture.h"
 #include "../util/math.h"
diff --git a/libopenage/unit/unit_type.cpp b/libopenage/unit/unit_type.cpp
index 76feeedaf2..bc760bd955 100644
--- a/libopenage/unit/unit_type.cpp
+++ b/libopenage/unit/unit_type.cpp
@@ -1,6 +1,6 @@
-// Copyright 2015-2019 the openage authors. See copying.md for legal info.
+// Copyright 2015-2021 the openage authors. See copying.md for legal info.
 
-#include "../gamestate/player.h"
+#include "../gamestate/old/player.h"
 #include "../terrain/terrain_object.h"
 #include "../util/math_constants.h"
 #include "action.h"
diff --git a/libopenage/unit/unit_type.h b/libopenage/unit/unit_type.h
index 53099f7aa4..5e960915a3 100644
--- a/libopenage/unit/unit_type.h
+++ b/libopenage/unit/unit_type.h
@@ -1,4 +1,4 @@
-// Copyright 2015-2019 the openage authors. See copying.md for legal info.
+// Copyright 2015-2021 the openage authors. See copying.md for legal info.
 
 #pragma once
 
@@ -8,7 +8,7 @@
 #include <vector>
 
 #include "../coord/phys.h"
-#include "../gamestate/cost.h"
+#include "../gamestate/old/cost.h"
 #include "attributes.h"
 
 namespace openage {
diff --git a/libopenage/util/compiler.h b/libopenage/util/compiler.h
index 1281188a97..1b3ab0a93c 100644
--- a/libopenage/util/compiler.h
+++ b/libopenage/util/compiler.h
@@ -119,4 +119,18 @@ std::string typestring() {
 }
 
 
+/**
+ * Returns the string representation of type pointed to by the given pointer.
+ * Example:
+ * struct A {}; struct B : A {};
+ * std::shared_ptr<A> ptr = std::make_shared<B>();
+ * auto str = typestring(ptr.get());
+ * assert(str == "B"s);
+ */
+template <typename T>
+std::string typestring(const T *ptr) {
+	return demangle(typeid(*ptr).name());
+}
+
+
 }} // openage::util
diff --git a/libopenage/util/fixed_point.h b/libopenage/util/fixed_point.h
index 5c9b2b4880..0658c20ea6 100644
--- a/libopenage/util/fixed_point.h
+++ b/libopenage/util/fixed_point.h
@@ -1,4 +1,4 @@
-// Copyright 2015-2018 the openage authors. See copying.md for legal info.
+// Copyright 2015-2019 the openage authors. See copying.md for legal info.
 
 #pragma once
 
@@ -10,6 +10,7 @@
 #include <ostream>
 #include <type_traits>
 
+#include "compiler.h"
 #include "misc.h"
 
 namespace openage {
@@ -381,6 +382,14 @@ class FixedPoint {
 	// I/O operators
 	friend std::ostream &operator <<(std::ostream &os, const FixedPoint &n) {
 		os << std::fixed << std::setprecision(FixedPoint::approx_decimal_places) << double(n);
+
+		if (unlikely(n == FixedPoint::max_value())) {
+			os << "[MAX]";
+		}
+		else if (unlikely(n != 0 and n == FixedPoint::min_value())) {
+			os << "[MIN]";
+		}
+
 		return os;
 	}
 
diff --git a/libopenage/version.cpp.in b/libopenage/version.cpp.in
new file mode 100644
index 0000000000..9f4139e1a1
--- /dev/null
+++ b/libopenage/version.cpp.in
@@ -0,0 +1,11 @@
+// Copyright 2019-2019 the openage authors. See copying.md for legal info.
+
+// ${AUTOGEN_WARNING}
+
+#include "version.h"
+
+namespace openage::version {
+
+const char *const version = "${VERSION_FULL_STRING}";
+
+} // openage::version
diff --git a/libopenage/version.h.in b/libopenage/version.h.in
new file mode 100644
index 0000000000..44c6b57b3c
--- /dev/null
+++ b/libopenage/version.h.in
@@ -0,0 +1,11 @@
+// Copyright 2019-2019 the openage authors. See copying.md for legal info.
+
+// ${AUTOGEN_WARNING}
+
+#pragma once
+
+namespace openage::version {
+
+extern const char *const version;
+
+} // openage::version
diff --git a/openage/CMakeLists.txt b/openage/CMakeLists.txt
index f5d5f221c4..fb3937b34c 100644
--- a/openage/CMakeLists.txt
+++ b/openage/CMakeLists.txt
@@ -24,8 +24,9 @@ add_subdirectory(cvar)
 add_subdirectory(event)
 add_subdirectory(game)
 add_subdirectory(log)
+add_subdirectory(main)
 add_subdirectory(nyan)
-add_subdirectory(util)
 add_subdirectory(renderer)
 add_subdirectory(testing)
+add_subdirectory(util)
 add_subdirectory(versions)
diff --git a/openage/__main__.py b/openage/__main__.py
index df1dfd5a0e..d60055da9e 100644
--- a/openage/__main__.py
+++ b/openage/__main__.py
@@ -1,4 +1,4 @@
-# Copyright 2015-2020 the openage authors. See copying.md for legal info.
+# Copyright 2015-2021 the openage authors. See copying.md for legal info.
 
 """
 Behold: The central entry point for all of openage.
@@ -75,6 +75,12 @@ def main(argv=None):
     # enable reimports for "init_subparser"
     # pylint: disable=reimported
 
+    from .main.main import init_subparser
+    main_cli = subparsers.add_parser(
+        "main",
+        parents=[global_cli, cfg_cli])
+    init_subparser(main_cli)
+
     from .game.main import init_subparser
     game_cli = subparsers.add_parser(
         "game",
diff --git a/openage/main/CMakeLists.txt b/openage/main/CMakeLists.txt
new file mode 100644
index 0000000000..0e07f909d7
--- /dev/null
+++ b/openage/main/CMakeLists.txt
@@ -0,0 +1,9 @@
+add_cython_modules(
+	main_cpp.pyx
+	tests.pyx
+)
+
+add_py_modules(
+	__init__.py
+	main.py
+)
diff --git a/openage/main/__init__.py b/openage/main/__init__.py
new file mode 100644
index 0000000000..432a0d2d64
--- /dev/null
+++ b/openage/main/__init__.py
@@ -0,0 +1,5 @@
+# Copyright 2018-2018 the openage authors. See copying.md for legal info.
+
+"""
+Main engine entry point.
+"""
diff --git a/openage/main/main.py b/openage/main/main.py
new file mode 100644
index 0000000000..513436623b
--- /dev/null
+++ b/openage/main/main.py
@@ -0,0 +1,78 @@
+# Copyright 2015-2018 the openage authors. See copying.md for legal info.
+
+"""
+Main engine entry point for openage.
+"""
+
+from ..log import err, info
+
+
+def init_subparser(cli):
+    """ Initializes the parser for game-specific args. """
+    cli.set_defaults(entrypoint=main)
+
+    cli.add_argument(
+        "--fps", type=int,
+        help="upper limit for fps. this limit is imposed on top of vsync")
+
+    cli.add_argument(
+        "--gl-debug", action='store_true',
+        help="throw exceptions directly from the OpenGL calls")
+
+
+def main(args, error):
+    """
+    Makes sure that the assets have been converted,
+    and jumps into the C++ main method.
+    """
+    del error  # unused
+
+    # we have to import stuff inside the function
+    # as it depends on generated/compiled code
+    from .main_cpp import run_game
+    from .. import config
+    from ..assets import get_asset_path
+    from ..convert.main import conversion_required, convert_assets
+    from ..cppinterface.setup import setup as cpp_interface_setup
+    from ..cvar.location import get_config_path
+    from ..util.fslike.union import Union
+
+    # initialize libopenage
+    cpp_interface_setup(args)
+
+    info("launching openage %s", config.VERSION)
+    info("compiled by %s", config.COMPILER)
+
+    if config.DEVMODE:
+        info("running in DEVMODE")
+
+    # create virtual file system for data paths
+    root = Union().root
+
+    # mount the assets folder union at "assets/"
+    root["assets"].mount(get_asset_path(args.asset_dir))
+
+    # mount the config folder at "cfg/"
+    root["cfg"].mount(get_config_path(args.cfg_dir))
+
+    # ensure that the assets have been converted
+    if conversion_required(root["assets"], args):
+        # try to get previously used source dir
+        asset_location_path = root["cfg"] / "asset_location"
+        try:
+            with asset_location_path.open("rb") as file_obj:
+                prev_source_dir_path = file_obj.read().strip()
+        except FileNotFoundError:
+            prev_source_dir_path = None
+        used_asset_path = convert_assets(root["assets"], args,
+                                         prev_source_dir_path=prev_source_dir_path)
+        if used_asset_path:
+            # Remember the asset location
+            with asset_location_path.open("wb") as file_obj:
+                file_obj.write(used_asset_path)
+        else:
+            err("game asset conversion failed")
+            return 1
+
+    # start the game, continue in main_cpp.pyx!
+    return run_game(args, root)
diff --git a/openage/main/main_cpp.pyx b/openage/main/main_cpp.pyx
new file mode 100644
index 0000000000..24520be3ed
--- /dev/null
+++ b/openage/main/main_cpp.pyx
@@ -0,0 +1,51 @@
+# Copyright 2015-2018 the openage authors. See copying.md for legal info.
+
+from cpython.ref cimport PyObject
+from libcpp.memory cimport make_unique
+from libcpp.string cimport string
+from libcpp.vector cimport vector
+
+from libopenage.main cimport main_arguments, run_game as run_game_cpp
+from libopenage.util.path cimport Path as Path_cpp
+from libopenage.pyinterface.pyobject cimport PyObj
+from libopenage.error.handlers cimport set_exit_ok
+
+
+cdef extern from "Python.h":
+    void PyEval_InitThreads()
+
+
+def run_game(args, root_path):
+    """
+    Launches the game after arguments were translated.
+    """
+    cdef int result
+
+    # argument translation
+    cdef main_arguments args_cpp
+
+    set_exit_ok(False)
+    try:
+        # root_path is a util.fslike.Path object from python
+        args_cpp.root_path = Path_cpp(PyObj(<PyObject*>root_path.fsobj),
+                                    root_path.parts)
+
+        # frame limiting
+        if args.fps is not None:
+            args_cpp.fps_limit = args.fps
+        else:
+            args_cpp.fps_limit = 0
+
+        # opengl debugging
+        args_cpp.gl_debug = args.gl_debug
+
+        # create the gil, because now starts the multithread part!
+        PyEval_InitThreads()
+
+        # run the game!
+        with nogil:
+            result = run_game_cpp(args_cpp)
+
+        return result
+    finally:
+        set_exit_ok(True)
diff --git a/openage/main/tests.pyx b/openage/main/tests.pyx
new file mode 100644
index 0000000000..2809db80cd
--- /dev/null
+++ b/openage/main/tests.pyx
@@ -0,0 +1,50 @@
+# Copyright 2018-2019 the openage authors. See copying.md for legal info.
+
+"""
+tests for the engine itself.
+"""
+
+import argparse
+
+from libopenage.util.path cimport Path as Path_cpp
+from libopenage.pyinterface.pyobject cimport PyObj
+from cpython.ref cimport PyObject
+from libopenage.main.tests cimport engine_demo as engine_demo_c
+
+
+def engine_demo(list argv):
+    """
+    Invokes the available engine demos.
+    """
+
+    cmd = argparse.ArgumentParser(
+        prog='... engine_demo',
+        description='Demo of the game engine features')
+    cmd.add_argument("test_id", type=int, help="id of the demo to run.")
+    cmd.add_argument("--asset-dir",
+                     help="Use this as an additional asset directory.")
+    cmd.add_argument("--cfg-dir",
+                     help="Use this as an additional config directory.")
+
+    args = cmd.parse_args(argv)
+
+    from ..cvar.location import get_config_path
+    from ..assets import get_asset_path
+    from ..util.fslike.union import Union
+
+    # create virtual file system for data paths
+    root = Union().root
+
+    # mount the assets folder union at "assets/"
+    root["assets"].mount(get_asset_path(args.asset_dir))
+
+    # mount the config folder at "cfg/"
+    root["cfg"].mount(get_config_path(args.cfg_dir))
+
+    cdef int engine_test_id = args.test_id
+
+    cdef Path_cpp root_cpp = Path_cpp(PyObj(<PyObject*>root.fsobj),
+                                      root.parts)
+
+    with nogil:
+        engine_demo_c(engine_test_id, root_cpp)
diff --git a/openage/testing/testlist.py b/openage/testing/testlist.py
index bcec7b31bd..897d93d347 100644
--- a/openage/testing/testlist.py
+++ b/openage/testing/testlist.py
@@ -1,4 +1,4 @@
-# Copyright 2015-2020 the openage authors. See copying.md for legal info.
+# Copyright 2015-2021 the openage authors. See copying.md for legal info.
 
 """ Lists of all possible tests; enter your tests here. """
 
@@ -52,6 +52,8 @@ def demos_py():
            "play pong on steroids through future prediction")
     yield ("openage.renderer.tests.renderer_demo",
            "showcases the new renderer")
+    yield ("openage.main.tests.engine_demo",
+           "showcases the engine features")
 
 
 def benchmark_py():
diff --git a/openage/util/fslike/cpp.pyx b/openage/util/fslike/cpp.pyx
index 21ca0b4f52..9e9f21c544 100644
--- a/openage/util/fslike/cpp.pyx
+++ b/openage/util/fslike/cpp.pyx
@@ -1,4 +1,4 @@
-# Copyright 2017-2020 the openage authors. See copying.md for legal info.
+# Copyright 2017-2021 the openage authors. See copying.md for legal info.
 
 """
 Functions called from C++ to perform method calls on
@@ -246,7 +246,7 @@ cdef bool fs_mkdirs(PyObject *fslike, const vector[string]& parts) except * with
 
 cdef File_cpp fs_open(object path, int mode) except *:
     if path is None:
-        raise FileNotFoundError("file could not be found")
+        raise Exception("fs_open can't open a path that is None")
 
     cdef PyObj ref
 
@@ -277,28 +277,42 @@ cdef File_cpp fs_open(object path, int mode) except *:
         return File_cpp(ref)
 
 
+cdef check_file_exists(object path, object fslike, const vector[string]& parts):
+    if path is None:
+        raise FileNotFoundError("file could not be found in filesystem %s "
+                                "for path '%s'" % (
+                                    fslike,
+                                    b"/".join(parts).decode(errors='ignore')
+                                ))
+
+
 cdef File_cpp fs_open_r(PyObject *fslike, const vector[string]& parts) except * with gil:
     open_path = (<object> fslike).resolve_r(parts)
+    check_file_exists(open_path, <object> fslike, parts)
     return fs_open(open_path, 0)
 
 
 cdef File_cpp fs_open_w(PyObject *fslike, const vector[string]& parts) except * with gil:
     open_path = (<object> fslike).resolve_w(parts)
+    check_file_exists(open_path, <object> fslike, parts)
     return fs_open(open_path, 1)
 
 
 cdef File_cpp fs_open_rw(PyObject *fslike, const vector[string]& parts) except * with gil:
     open_path = (<object> fslike).resolve_w(parts)
+    check_file_exists(open_path, <object> fslike, parts)
     return fs_open(open_path, 2)
 
 
 cdef File_cpp fs_open_a(PyObject *fslike, const vector[string]& parts) except * with gil:
     open_path = (<object> fslike).resolve_w(parts)
+    check_file_exists(open_path, <object> fslike, parts)
     return fs_open(open_path, 3)
 
 
 cdef File_cpp fs_open_ar(PyObject *fslike, const vector[string]& parts) except * with gil:
     open_path = (<object> fslike).resolve_w(parts)
+    check_file_exists(open_path, <object> fslike, parts)
     return fs_open(open_path, 4)