From d647fb2d33ab079ccda8c247fed486c810b1b0d7 Mon Sep 17 00:00:00 2001
From: Johannes Walcher <johannes.walcher@stusta.de>
Date: Wed, 2 May 2018 00:32:51 +0200
Subject: [PATCH 01/18] event: initial implementation of core simulation
 components

Co-authored-by: Jonas Jelten <jj@sft.mx>
---
 libopenage/CMakeLists.txt                  |   6 +
 libopenage/curve/CMakeLists.txt            |  14 +
 libopenage/curve/continuous.cpp            |   9 +
 libopenage/curve/continuous.h              |  63 +++
 libopenage/curve/curve.cpp                 |   9 +
 libopenage/curve/curve.h                   |  18 +
 libopenage/curve/discrete.cpp              |   9 +
 libopenage/curve/discrete.h                |  75 +++
 libopenage/curve/iterator.cpp              |   9 +
 libopenage/curve/iterator.h                | 135 +++++
 libopenage/curve/keyframe_container.cpp    |   9 +
 libopenage/curve/keyframe_container.h      | 271 ++++++++++
 libopenage/curve/map.cpp                   |   9 +
 libopenage/curve/map.h                     | 210 ++++++++
 libopenage/curve/map_filter_iterator.cpp   |   9 +
 libopenage/curve/map_filter_iterator.h     |  64 +++
 libopenage/curve/queue.cpp                 |   7 +
 libopenage/curve/queue.h                   | 172 +++++++
 libopenage/curve/queue_filter_iterator.cpp |   9 +
 libopenage/curve/queue_filter_iterator.h   |  52 ++
 libopenage/curve/tests/CMakeLists.txt      |   4 +
 libopenage/curve/tests/container.cpp       | 212 ++++++++
 libopenage/curve/tests/curve_types.cpp     | 148 ++++++
 libopenage/curve/value_container.cpp       |   7 +
 libopenage/curve/value_container.h         | 104 ++++
 libopenage/event/CMakeLists.txt            |  12 +
 libopenage/event/demo/CMakeLists.txt       |  12 +
 libopenage/event/demo/aicontroller.cpp     |  29 ++
 libopenage/event/demo/aicontroller.h       |  23 +
 libopenage/event/demo/gamestate.cpp        |   9 +
 libopenage/event/demo/gamestate.h          | 129 +++++
 libopenage/event/demo/gui.cpp              | 242 +++++++++
 libopenage/event/demo/gui.h                |  32 ++
 libopenage/event/demo/main.cpp             | 208 ++++++++
 libopenage/event/demo/main.h               |  14 +
 libopenage/event/demo/physics.cpp          | 485 ++++++++++++++++++
 libopenage/event/demo/physics.h            |  34 ++
 libopenage/event/event.cpp                 |  37 ++
 libopenage/event/event.h                   |  85 ++++
 libopenage/event/eventclass.cpp            |  48 ++
 libopenage/event/eventclass.h              | 218 ++++++++
 libopenage/event/eventfilter.cpp           |  17 +
 libopenage/event/eventfilter.h             |  27 +
 libopenage/event/eventqueue.cpp            | 284 +++++++++++
 libopenage/event/eventqueue.h              | 158 ++++++
 libopenage/event/eventtarget.cpp           | 107 ++++
 libopenage/event/eventtarget.h             |  76 +++
 libopenage/event/loop.cpp                  | 198 ++++++++
 libopenage/event/loop.h                    | 147 ++++++
 libopenage/event/state.cpp                 |   7 +
 libopenage/event/state.h                   |  19 +
 libopenage/event/tests.cpp                 | 557 +++++++++++++++++++++
 libopenage/util/fixed_point.h              |  91 +++-
 libopenage/util/matrix.h                   | 109 ++--
 libopenage/util/matrix_test.cpp            |  42 +-
 libopenage/util/quaternion.h               |  25 +-
 libopenage/util/quaternion_test.cpp        | 132 ++---
 libopenage/util/vector.h                   | 101 ++--
 libopenage/util/vector_test.cpp            |  18 +-
 openage/CMakeLists.txt                     |   6 +-
 openage/event/CMakeLists.txt               |   7 +
 openage/event/__init__.py                  |   6 +
 openage/event/demo.pyx                     |  48 ++
 openage/testing/testlist.py                |   5 +
 64 files changed, 5244 insertions(+), 194 deletions(-)
 create mode 100644 libopenage/curve/CMakeLists.txt
 create mode 100644 libopenage/curve/continuous.cpp
 create mode 100644 libopenage/curve/continuous.h
 create mode 100644 libopenage/curve/curve.cpp
 create mode 100644 libopenage/curve/curve.h
 create mode 100644 libopenage/curve/discrete.cpp
 create mode 100644 libopenage/curve/discrete.h
 create mode 100644 libopenage/curve/iterator.cpp
 create mode 100644 libopenage/curve/iterator.h
 create mode 100644 libopenage/curve/keyframe_container.cpp
 create mode 100644 libopenage/curve/keyframe_container.h
 create mode 100644 libopenage/curve/map.cpp
 create mode 100644 libopenage/curve/map.h
 create mode 100644 libopenage/curve/map_filter_iterator.cpp
 create mode 100644 libopenage/curve/map_filter_iterator.h
 create mode 100644 libopenage/curve/queue.cpp
 create mode 100644 libopenage/curve/queue.h
 create mode 100644 libopenage/curve/queue_filter_iterator.cpp
 create mode 100644 libopenage/curve/queue_filter_iterator.h
 create mode 100644 libopenage/curve/tests/CMakeLists.txt
 create mode 100644 libopenage/curve/tests/container.cpp
 create mode 100644 libopenage/curve/tests/curve_types.cpp
 create mode 100644 libopenage/curve/value_container.cpp
 create mode 100644 libopenage/curve/value_container.h
 create mode 100644 libopenage/event/CMakeLists.txt
 create mode 100644 libopenage/event/demo/CMakeLists.txt
 create mode 100644 libopenage/event/demo/aicontroller.cpp
 create mode 100644 libopenage/event/demo/aicontroller.h
 create mode 100644 libopenage/event/demo/gamestate.cpp
 create mode 100644 libopenage/event/demo/gamestate.h
 create mode 100644 libopenage/event/demo/gui.cpp
 create mode 100644 libopenage/event/demo/gui.h
 create mode 100644 libopenage/event/demo/main.cpp
 create mode 100644 libopenage/event/demo/main.h
 create mode 100644 libopenage/event/demo/physics.cpp
 create mode 100644 libopenage/event/demo/physics.h
 create mode 100644 libopenage/event/event.cpp
 create mode 100644 libopenage/event/event.h
 create mode 100644 libopenage/event/eventclass.cpp
 create mode 100644 libopenage/event/eventclass.h
 create mode 100644 libopenage/event/eventfilter.cpp
 create mode 100644 libopenage/event/eventfilter.h
 create mode 100644 libopenage/event/eventqueue.cpp
 create mode 100644 libopenage/event/eventqueue.h
 create mode 100644 libopenage/event/eventtarget.cpp
 create mode 100644 libopenage/event/eventtarget.h
 create mode 100644 libopenage/event/loop.cpp
 create mode 100644 libopenage/event/loop.h
 create mode 100644 libopenage/event/state.cpp
 create mode 100644 libopenage/event/state.h
 create mode 100644 libopenage/event/tests.cpp
 create mode 100644 openage/event/CMakeLists.txt
 create mode 100644 openage/event/__init__.py
 create mode 100644 openage/event/demo.pyx

diff --git a/libopenage/CMakeLists.txt b/libopenage/CMakeLists.txt
index 1caf5e874e..b8b323fa83 100644
--- a/libopenage/CMakeLists.txt
+++ b/libopenage/CMakeLists.txt
@@ -241,6 +241,12 @@ get_config_option_string()
 configure_file(config.h.in ${CMAKE_CURRENT_SOURCE_DIR}/config.h)
 configure_file(config.cpp.in ${CMAKE_CURRENT_SOURCE_DIR}/config.cpp)
 
+configure_file(
+	"${CMAKE_SOURCE_DIR}/openage/config.py.in"
+	"${CMAKE_SOURCE_DIR}/openage/config.py"
+)
+
+
 ##################################################
 # platform specifics
 if(APPLE)
diff --git a/libopenage/curve/CMakeLists.txt b/libopenage/curve/CMakeLists.txt
new file mode 100644
index 0000000000..fd797510ab
--- /dev/null
+++ b/libopenage/curve/CMakeLists.txt
@@ -0,0 +1,14 @@
+add_sources(libopenage
+	continuous.cpp
+	curve.cpp
+	discrete.cpp
+	iterator.cpp
+	keyframe_container.cpp
+	map.cpp
+	map_filter_iterator.cpp
+	queue.cpp
+	queue_filter_iterator.cpp
+	value_container.cpp
+)
+
+add_subdirectory("tests")
diff --git a/libopenage/curve/continuous.cpp b/libopenage/curve/continuous.cpp
new file mode 100644
index 0000000000..73b3920c64
--- /dev/null
+++ b/libopenage/curve/continuous.cpp
@@ -0,0 +1,9 @@
+// Copyright 2017-2018 the openage authors. See copying.md for legal info.
+
+#include "continuous.h"
+
+namespace openage::curve {
+
+// This file is intended to be empty
+
+} // openage::curve
diff --git a/libopenage/curve/continuous.h b/libopenage/curve/continuous.h
new file mode 100644
index 0000000000..77aa5dac59
--- /dev/null
+++ b/libopenage/curve/continuous.h
@@ -0,0 +1,63 @@
+// Copyright 2017-2018 the openage authors. See copying.md for legal info.
+
+#pragma once
+
+#include <type_traits>
+
+#include "value_container.h"
+#include "../log/log.h"
+
+namespace openage::curve {
+
+
+/**
+ * Continuous Datatype.
+ * Stores a value container with continuous access.
+ * The bound template type T has to implement `operator+(T)` and
+ * `operator*(time_t)`.
+ */
+template<typename T>
+class Continuous : public ValueContainer<T> {
+public:
+	using ValueContainer<T>::ValueContainer;
+	/**
+	 * will interpolate between the keyframes linearly based on the time.
+	 */
+	T get(const time_t &) 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;
+
+	auto nxt = e;
+	++nxt;
+
+	time_t diff_time = 0;
+
+	auto offset = time - e->time;
+
+	// 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;
+	}
+
+	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();
+
+		return e->value + (nxt->value - e->value) * elapsed_frac;
+	}
+}
+
+} // openage::curve
diff --git a/libopenage/curve/curve.cpp b/libopenage/curve/curve.cpp
new file mode 100644
index 0000000000..4ec84fe407
--- /dev/null
+++ b/libopenage/curve/curve.cpp
@@ -0,0 +1,9 @@
+// Copyright 2017-2018 the openage authors. See copying.md for legal info.
+
+#include "curve.h"
+
+namespace openage::curve {
+
+// This file is intended to be empty
+
+} // openage::curve
diff --git a/libopenage/curve/curve.h b/libopenage/curve/curve.h
new file mode 100644
index 0000000000..381ce727b3
--- /dev/null
+++ b/libopenage/curve/curve.h
@@ -0,0 +1,18 @@
+// Copyright 2017-2018 the openage authors. See copying.md for legal info.
+
+#pragma once
+
+#include <cstdint>
+
+#include "../util/fixed_point.h"
+
+
+namespace openage::curve {
+
+/**
+ * Defines the type that is used as time index.
+ * it has to implement all basic mathematically operations.
+ */
+using time_t = util::FixedPoint<int64_t, 16>;
+
+} // openage::curve
diff --git a/libopenage/curve/discrete.cpp b/libopenage/curve/discrete.cpp
new file mode 100644
index 0000000000..4bfab12bdd
--- /dev/null
+++ b/libopenage/curve/discrete.cpp
@@ -0,0 +1,9 @@
+// Copyright 2017-2018 the openage authors. See copying.md for legal info.
+
+#include "discrete.h"
+
+namespace openage::curve {
+
+// This file is intended to be empty
+
+} // openage::curve
diff --git a/libopenage/curve/discrete.h b/libopenage/curve/discrete.h
new file mode 100644
index 0000000000..63abf65638
--- /dev/null
+++ b/libopenage/curve/discrete.h
@@ -0,0 +1,75 @@
+// Copyright 2017-2018 the openage authors. See copying.md for legal info.
+
+#pragma once
+
+#include <optional>
+#include <utility>
+
+#include "value_container.h"
+
+
+namespace openage::curve {
+
+/**
+ * Does not interpolate between values. The template type does only need to
+ * implement `operator=` and copy ctor.
+ */
+template<typename T>
+class Discrete : public ValueContainer<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;
+
+	/**
+	 * Does not interpolate anything,
+	 * just returns gives the raw value of the last keyframe with time <= t.
+	 */
+	T get(const time_t &t) const override;
+
+	/**
+	 * Return the last time and keyframe with time <= t.
+	 */
+	std::pair<time_t, T> get_time(const time_t &t) const;
+
+	/**
+	 * Return, if existing, the time and value of keyframe with time < t
+	 */
+	std::optional<std::pair<time_t, T>> get_previous(const time_t &t) const;
+};
+
+
+template <typename T>
+T Discrete<T>::get(const time_t &time) const {
+	auto e = this->container.last(time, this->last_element);
+	this->last_element = e;   // TODO if Caching?
+	return e->value;
+}
+
+
+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);
+	this->last_element = e;
+	return std::make_pair(e->time, e->value);
+}
+
+
+template <typename T>
+std::optional<std::pair<time_t, T>> Discrete<T>::get_previous(const time_t &time) const {
+	auto e = this->container.last(time, this->last_element);
+	this->last_element = e;
+
+	// if we're not at the container head
+	// go back one entry.
+	if (e == std::begin(this->container)) {
+		return {};
+	}
+
+	e--;
+	return std::make_pair(e->time, e->value);
+}
+
+} // openage::curve
diff --git a/libopenage/curve/iterator.cpp b/libopenage/curve/iterator.cpp
new file mode 100644
index 0000000000..b449d93812
--- /dev/null
+++ b/libopenage/curve/iterator.cpp
@@ -0,0 +1,9 @@
+// Copyright 2017-2018 the openage authors. See copying.md for legal info.
+
+#include "iterator.h"
+
+namespace openage::curve {
+
+// This file is intended to be empty
+
+} // namespace openage::curve
diff --git a/libopenage/curve/iterator.h b/libopenage/curve/iterator.h
new file mode 100644
index 0000000000..b965b65640
--- /dev/null
+++ b/libopenage/curve/iterator.h
@@ -0,0 +1,135 @@
+// Copyright 2017-2018 the openage authors. See copying.md for legal info.
+
+#pragma once
+
+#include "curve.h"
+
+namespace openage::curve {
+
+/**
+ * Default interface for curve containers
+ */
+template <typename val_t,
+          typename container_t,
+          typename iterator_t=typename container_t::const_iterator>
+class CurveIterator {
+public:
+	/**
+	 * access the value of the iterator
+	 */
+	virtual const val_t &value() const = 0;
+
+	/**
+	 * Check if the iterator is still valid
+	 * (this breaks from the stl - in the best way)
+	 */
+	virtual bool valid() const = 0;
+
+	/**
+	 * The iterator needs a reference to the container
+	 */
+	explicit CurveIterator(const container_t *c)
+		:
+		base{},
+		container{c},
+		from{-std::numeric_limits<time_t>::max()},
+		to{+std::numeric_limits<time_t>::max()} {}
+
+protected:
+	/**
+	 * Can only be constructed from the referenced container
+	 */
+	CurveIterator(const iterator_t &base,
+	              const container_t *container,
+	              const time_t &from,
+	              const time_t &to)
+		:
+		base{base},
+		container{container},
+		from{from},
+		to{to} {}
+
+public:
+	/** Default copy c'tor */
+	CurveIterator (const CurveIterator &) = default;
+
+	virtual ~CurveIterator() = default;
+
+	/** Default assignment operator */
+	CurveIterator<val_t, container_t, iterator_t> &operator= (
+		const CurveIterator<val_t, container_t, iterator_t> &) = default;
+
+	/** Dereference will call the virtual function */
+	virtual const val_t &operator *() const {
+		return this->value();
+	}
+
+	/** Dereference will call the virutal function */
+	virtual const val_t *operator ->() const {
+		return &this->value();
+	}
+
+	/**
+	 * For equalness only the base iterator will be testet - not the timespans
+	 * this is defined in.
+	 */
+	virtual bool operator ==(const CurveIterator<val_t, container_t> &rhs) const {
+		return this->base == rhs.base;
+	}
+
+	/**
+	 * For unequalness only the base iterator will be testet - not the timespans
+	 * this is defined in.
+	 */
+	virtual bool operator !=(const CurveIterator<val_t, container_t> &rhs) const {
+		return this->base != rhs.base;
+	}
+
+	/**
+	 * Advance to the next valid element.
+	 */
+	virtual CurveIterator<val_t, container_t> &operator ++() {
+		do {
+			++this->base;
+		} while (this->container->end().base != this->base and not this->valid());
+
+		return *this;
+	}
+
+	/**
+	 * Access the underlying
+	 */
+	const iterator_t &get_base() const {
+		return base;
+	}
+
+	/**
+	 * Access the lower end value of the defined time frame
+	 */
+	const time_t &get_from() const {
+		return from;
+	}
+
+	/**
+	 * Access the higher end value of the defined time frame
+	 */
+	const time_t &get_to() const {
+		return to;
+	}
+
+protected:
+	/// The iterator this is currently referring to.
+	iterator_t base;
+
+	/// The base container.
+	const container_t *container;
+
+	/// The time, from where this iterator started to iterate.
+	time_t from;
+
+	/// The time, to where this iterator will iterate.
+	time_t to;
+};
+
+
+} // openage::curve
diff --git a/libopenage/curve/keyframe_container.cpp b/libopenage/curve/keyframe_container.cpp
new file mode 100644
index 0000000000..4fabb77893
--- /dev/null
+++ b/libopenage/curve/keyframe_container.cpp
@@ -0,0 +1,9 @@
+// Copyright 2017-2018 the openage authors. See copying.md for legal info.
+
+#include "keyframe_container.h"
+
+namespace openage::curve {
+
+// nothing to see here, keep walking (to the header)
+
+} // openage::curve
diff --git a/libopenage/curve/keyframe_container.h b/libopenage/curve/keyframe_container.h
new file mode 100644
index 0000000000..9aed77717b
--- /dev/null
+++ b/libopenage/curve/keyframe_container.h
@@ -0,0 +1,271 @@
+// Copyright 2017-2018 the openage authors. See copying.md for legal info.
+
+#pragma once
+
+#include <iostream>
+#include <limits>
+#include <list>
+
+#include "curve.h"
+#include "../event/loop.h"
+#include "../error/error.h"
+
+namespace openage::curve {
+
+/**
+ * A timely ordered list with several management functions
+ *
+ * This class manages different time-based management functions for list
+ * approach that lies underneath. It contains list to be accessed via a
+ * non-accurate timing functionality, this means, that for getting a value, not
+ * the exact timestamp has to be known, it will always return the one closest,
+ * less or equal to the requested one.
+ **/
+template <typename T>
+class KeyframeContainer {
+public:
+	/**
+	 * 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();
+	};
+
+	/**
+	 * The underlaying container type.
+	 *
+	 * The most important property of this container is the iterator validity on
+	 * insert and remove.
+	 */
+	using curvecontainer = std::list<Keyframe>;
+
+	/**
+	 * The iterator type to access elements in the container
+	 */
+	using KeyframeIterator = typename curvecontainer::const_iterator;
+
+	/** need the datamanger for change management **/
+	KeyframeContainer(const std::shared_ptr<event::Loop> &loop);
+	~KeyframeContainer();
+
+	/**
+	 * Get the last element with e->time <= time, given a hint where to
+	 * start the search.
+	 */
+	KeyframeIterator last(const time_t &time,
+	                      const KeyframeIterator & hint) const;
+
+	/**
+	 * Get the last element with e->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());
+	}
+
+	// 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.
+	 *
+	 * 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());
+	}
+
+	/**
+	 * 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.
+	 */
+	KeyframeIterator insert(const Keyframe &value, const KeyframeIterator &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
+	 */
+	KeyframeIterator insert(const time_t &time, const T &value) {
+		return this->insert(Keyframe(time, value), this->container.begin());
+	}
+
+	/**
+	 * Create and insert a new element. The hint gives an approximate location.
+	 */
+	KeyframeIterator insert(const time_t &time, const T &value, const KeyframeIterator &hint) {
+		return this->insert(Keyframe(time, value), hint);
+	}
+
+	/**
+	 * Erase all elements that come after this last valid element.
+	 */
+	KeyframeIterator erase_after(KeyframeIterator last_valid);
+
+	/**
+	 * Erase a single element from the curve.
+	 */
+	KeyframeIterator erase(KeyframeIterator it);
+
+	/**
+	 * Obtain an iterator to the first value with the smallest timestamp.
+	 */
+	KeyframeIterator begin() const {
+		return container.begin();
+	}
+
+	/**
+	 * Obtain an iterator to the position after the last value.
+	 */
+	KeyframeIterator end() const {
+		return container.end();
+	}
+
+	/**
+	 * Debugging method to be used from gdb to understand bugs better.
+	 */
+	void dump() {
+		for (auto e : container) {
+			std::cout << "Element: time: " << e.time << " v: " << e.value << std::endl;
+		}
+	}
+private:
+	/**
+	 * The data store.
+	 */
+	const std::shared_ptr<event::Loop> loop;
+
+	curvecontainer container;
+};
+
+
+template<typename T>
+KeyframeContainer<T>::KeyframeContainer(const std::shared_ptr<event::Loop> &loop)
+	:
+	loop(loop) {
+
+	// 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()));
+}
+
+template<typename T>
+KeyframeContainer<T>::~KeyframeContainer() {
+	// We rely on std::list to destroy all elements.
+}
+
+/**
+ * Select the element that directly preceedes the given timestamp.
+ *
+ * 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.
+ */
+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;
+
+	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");
+	}
+
+	// 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) {
+			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) {
+			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
+ */
+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;
+	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) {
+
+	// exclude the last_valid element from deletion
+	if (last_valid != this->container.end()) {
+		++last_valid;
+	}
+
+	// Delete everything to the end.
+	while (last_valid != this->container.end()) {
+		last_valid = this->container.erase(last_valid);
+	}
+	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) {
+	return this->container.erase(e);
+}
+
+} // openage::curve
diff --git a/libopenage/curve/map.cpp b/libopenage/curve/map.cpp
new file mode 100644
index 0000000000..82b26f9ecc
--- /dev/null
+++ b/libopenage/curve/map.cpp
@@ -0,0 +1,9 @@
+// Copyright 2017-2018 the openage authors. See copying.md for legal info.
+
+#include "map.h"
+
+namespace openage::curve {
+
+// This file is intended to be empty
+
+} // namespace openage::curve
diff --git a/libopenage/curve/map.h b/libopenage/curve/map.h
new file mode 100644
index 0000000000..8fefda4023
--- /dev/null
+++ b/libopenage/curve/map.h
@@ -0,0 +1,210 @@
+// Copyright 2017-2018 the openage authors. See copying.md for legal info.
+
+#pragma once
+
+#include "curve.h"
+#include "map_filter_iterator.h"
+
+#include <optional>
+#include <iostream>
+#include <unordered_map>
+
+
+namespace openage::curve {
+
+/**
+ * Map that keeps track of the lifetime of the contained elements.
+ * Make sure that no key is reused.
+ */
+template <typename key_t, typename val_t>
+class UnorderedMap {
+	/** Internal container to access all data and metadata */
+	struct map_element {
+		map_element (const val_t &v, const time_t &a, const time_t &d)
+			:
+			value(v),
+			alive(a),
+			dead(d) {}
+
+		val_t value;
+		time_t alive;
+		time_t dead;
+	};
+
+	/**
+	 * Data holder. Maps keys to map elements.
+	 * Map elements themselves store when they are valid.
+	 */
+	std::unordered_map<key_t, map_element> container;
+
+public:
+	using const_iterator = typename std::unordered_map<key_t, map_element>::const_iterator;
+
+	std::optional<MapFilterIterator<key_t, val_t, UnorderedMap>>
+	operator ()(const time_t&, const key_t &) const;
+
+	std::optional<MapFilterIterator<key_t, val_t, UnorderedMap>>
+	at(const time_t &, const key_t &) const;
+
+	MapFilterIterator<key_t, val_t, UnorderedMap>
+	begin(const time_t &e = std::numeric_limits<time_t>::max()) const;
+
+	MapFilterIterator<key_t, val_t, UnorderedMap>
+	end(const time_t &e = std::numeric_limits<time_t>::max()) const;
+
+	MapFilterIterator<key_t, val_t, UnorderedMap>
+	insert(const time_t &birth, const key_t &, const val_t &);
+
+	MapFilterIterator<key_t, val_t, UnorderedMap>
+	insert(const time_t &birth, const time_t &death, const key_t &key, const val_t &value);
+
+	MapFilterIterator<key_t, val_t, UnorderedMap>
+	between(const time_t &start, const time_t &to) const;
+
+	void birth(const time_t &, const key_t &);
+	void birth(const time_t &,
+	           const MapFilterIterator<val_t, val_t, UnorderedMap> &);
+
+	void kill(const time_t &, const key_t &);
+	void kill(const time_t &,
+	          const MapFilterIterator<val_t, val_t, UnorderedMap> &);
+
+	// remove all dead elements before that point in time
+	void clean(const time_t &);
+
+	/**
+	 * gdb helper method.
+	 */
+	void dump() {
+		for (auto i : container) {
+			std::cout << "Element: " << i.second.value << std::endl;;
+		}
+	}
+};
+
+template<typename key_t, typename val_t>
+std::optional<MapFilterIterator<key_t, val_t, UnorderedMap<key_t, val_t>>>
+UnorderedMap<key_t, val_t>::operator()(const time_t &time,
+                                       const key_t &key) const {
+	return this->at(time, key);
+}
+
+template<typename key_t, typename val_t>
+std::optional<MapFilterIterator<key_t, val_t, UnorderedMap<key_t, val_t>>>
+UnorderedMap<key_t, val_t>::at(const time_t & time,
+                               const key_t & key) const {
+	auto e = this->container.find(key);
+	if (e != this->container.end() and
+	    e->second.alive <= time and
+	    e->second.dead > time) {
+
+		return MapFilterIterator<key_t, val_t, UnorderedMap<key_t, val_t>>(
+			e,
+			this,
+			time,
+			std::numeric_limits<time_t>::max()
+		);
+	} else {
+		return {};
+	}
+}
+
+template<typename key_t, typename val_t>
+MapFilterIterator<key_t, val_t, UnorderedMap<key_t, val_t>>
+UnorderedMap<key_t, val_t>::begin(const time_t &time) const {
+	return MapFilterIterator<key_t, val_t, UnorderedMap<key_t, val_t>>(
+		this->container.begin(),
+		this,
+		time,
+		std::numeric_limits<time_t>::max());
+}
+
+template<typename key_t, typename val_t>
+MapFilterIterator<key_t, val_t, UnorderedMap<key_t, val_t>>
+UnorderedMap<key_t, val_t>::end(const time_t &time) const {
+	return MapFilterIterator<key_t, val_t, UnorderedMap<key_t, val_t>>(
+		this->container.end(),
+		this,
+		-std::numeric_limits<time_t>::max(),
+		time);
+}
+
+template<typename key_t, typename val_t>
+MapFilterIterator<key_t, val_t, UnorderedMap<key_t, val_t>>
+UnorderedMap<key_t, val_t>::between(const time_t &from, const time_t &to) const {
+	auto it = MapFilterIterator<key_t, val_t, UnorderedMap<key_t, val_t>>(
+		this->container.begin(),
+		this,
+		from,
+		to);
+
+	if (!it.valid()) {
+		++it;
+	}
+	return it;
+}
+
+template<typename key_t, typename val_t>
+MapFilterIterator<key_t, val_t, UnorderedMap<key_t, val_t>>
+UnorderedMap<key_t, val_t>::insert(const time_t &alive,
+                                   const key_t &key,
+                                   const val_t &value) {
+	return this->insert(
+		alive,
+		std::numeric_limits<time_t>::max(),
+		key,
+		value);
+}
+
+template<typename key_t, typename val_t>
+MapFilterIterator<key_t, val_t, UnorderedMap<key_t, val_t>>
+UnorderedMap<key_t, val_t>::insert(const time_t &alive,
+                                   const time_t &dead,
+                                   const key_t &key,
+                                   const val_t &value) {
+	map_element e(value, alive, dead);
+	auto it = this->container.insert(std::make_pair(key, e));
+	return MapFilterIterator<key_t, val_t, UnorderedMap<key_t, val_t>>(
+		it.first,
+		this,
+		alive,
+		dead);
+}
+
+template<typename key_t, typename val_t>
+void UnorderedMap<key_t, val_t>::birth(const time_t &time,
+                                       const key_t &key) {
+	auto it = this->container.find(key);
+	if (it != this->container.end()) {
+		it->second.alive = time;
+	}
+}
+
+template<typename key_t, typename val_t>
+void UnorderedMap<key_t, val_t>::birth(const time_t &time,
+                                       const MapFilterIterator<val_t, val_t,
+                                       UnorderedMap> &it) {
+	it->second.alive = time;
+}
+
+template<typename key_t, typename val_t>
+void UnorderedMap<key_t, val_t>::kill(const time_t &time,
+                                      const key_t &key) {
+	auto it = this->container.find(key);
+	if (it != this->container.end()) {
+		it->second.dead = time;
+	}
+}
+
+template<typename key_t, typename val_t>
+void UnorderedMap<key_t, val_t>::kill(const time_t &time,
+                                      const MapFilterIterator<val_t, val_t, UnorderedMap> &it) {
+	it->second.dead = time;
+}
+
+template<typename key_t, typename val_t>
+void UnorderedMap<key_t, val_t>::clean(const time_t &) {
+	// TODO save everything to a file and be happy.
+}
+
+} // openage::curve
diff --git a/libopenage/curve/map_filter_iterator.cpp b/libopenage/curve/map_filter_iterator.cpp
new file mode 100644
index 0000000000..da10b01774
--- /dev/null
+++ b/libopenage/curve/map_filter_iterator.cpp
@@ -0,0 +1,9 @@
+// Copyright 2017-2018 the openage authors. See copying.md for legal info.
+
+#include "map_filter_iterator.h"
+
+namespace openage::curve {
+
+// This file is intended to be empty
+
+} // namespace openage::curve
diff --git a/libopenage/curve/map_filter_iterator.h b/libopenage/curve/map_filter_iterator.h
new file mode 100644
index 0000000000..97ff70960e
--- /dev/null
+++ b/libopenage/curve/map_filter_iterator.h
@@ -0,0 +1,64 @@
+// Copyright 2017-2018 the openage authors. See copying.md for legal info.
+
+#pragma once
+
+#include "curve.h"
+#include "iterator.h"
+
+#include <iterator>
+#include <limits>
+
+namespace openage::curve {
+
+/**
+ * A filtering operator to iterate over all elements of a map whose elements
+ * exist for a certain livespan. The range where to iterate is given at
+ * construction.
+ *
+ * It depends on key_t and val_t as map-parameters, container_t is the container
+ * to operate on and the function valid_f, that checks if an element is alive.
+ */
+template <typename key_t,
+          typename val_t,
+          typename container_t>
+class MapFilterIterator : public CurveIterator<val_t, container_t> {
+public:
+	using iterator_t = typename container_t::const_iterator;
+
+	/**
+	 * Construct the iterator from its boundary conditions: time and container
+	 */
+	MapFilterIterator(const iterator_t &base,
+	                  const container_t *container,
+	                  const time_t &from,
+	                  const time_t &to)
+		:
+		CurveIterator<val_t, container_t>(base, container, from, to) {}
+
+	MapFilterIterator(const MapFilterIterator &) = default;
+
+	using CurveIterator<val_t, container_t>::operator=;
+
+	virtual bool valid() const override {
+		return (this->get_base()->second.alive >= this->from
+		        and this->get_base()->second.dead < this->to);
+	}
+
+	/**
+	 * Get the value behind the iterator.
+	 * Nicer way of accessing it beside operator *.
+	 */
+	val_t const &value() const override {
+		return this->get_base()->second.value;
+	}
+
+	/**
+	 * Get the key pointed to by this iterator.
+	 */
+	const key_t &key() const {
+		return this->get_base()->first;
+	}
+
+};
+
+} // openage::curve
diff --git a/libopenage/curve/queue.cpp b/libopenage/curve/queue.cpp
new file mode 100644
index 0000000000..d994b6c82e
--- /dev/null
+++ b/libopenage/curve/queue.cpp
@@ -0,0 +1,7 @@
+// Copyright 2017-2018 the openage authors. See copying.md for legal info.
+
+#include "queue.h"
+
+namespace openage::curve {
+
+} // namespace openage::curve
diff --git a/libopenage/curve/queue.h b/libopenage/curve/queue.h
new file mode 100644
index 0000000000..1bb3f644bc
--- /dev/null
+++ b/libopenage/curve/queue.h
@@ -0,0 +1,172 @@
+// Copyright 2017-2018 the openage authors. See copying.md for legal info.
+
+#pragma once
+
+#include "curve.h"
+#include "queue_filter_iterator.h"
+
+#include <deque>
+#include <iostream>
+
+namespace openage::curve {
+
+/**
+ * A container that manages events on a timeline. Every event has exactly one
+ * time it will happen.
+ * This container can be used to store interactions
+ */
+template <class T>
+class Queue {
+	struct queue_wrapper {
+		time_t _time;
+		T value;
+
+		queue_wrapper(const time_t &time, const T &value)
+			:
+			_time{time},
+			value{value} {}
+
+		time_t time() const {
+			return _time;
+		}
+	};
+
+public:
+	using container_t = typename std::deque<queue_wrapper>;
+	using const_iterator = typename container_t::const_iterator;
+	using iterator = typename container_t::const_iterator;
+
+	// Reading Access
+	const T &front(const time_t &) const;
+
+	// Modifying access
+	QueueFilterIterator<T, Queue<T>> begin(
+		const time_t &t = -std::numeric_limits<time_t>::max()) const;
+
+	QueueFilterIterator<T, Queue<T>> end(
+		const time_t &t = std::numeric_limits<time_t>::max()) const;
+
+	QueueFilterIterator<T, Queue<T>> between(
+		const time_t &begin = std::numeric_limits<time_t>::max(),
+		const time_t &end = std::numeric_limits<time_t>::max()) const;
+
+	void erase(const CurveIterator<T, Queue<T>> &);
+
+	QueueFilterIterator<T, Queue<T>> insert(const time_t &, const T &e);
+
+	void clear();
+
+	void clean(const time_t &);
+
+	void dump() {
+		for (auto i : container) {
+			std::cout << i.value << " at " << i.time() << std::endl;
+		}
+	}
+
+private:
+	container_t container;
+};
+
+
+template <typename T>
+const T &Queue<T>::front(const time_t &) const {
+	return container.front();
+}
+
+
+template <typename T>
+QueueFilterIterator<T, Queue<T>> Queue<T>::begin(const time_t &t) const {
+	for (auto it = this->container.begin(); it != this->container.end(); ++it) {
+		if (it->time() >= t) {
+			return QueueFilterIterator<T, Queue<T>>(
+				it,
+				this,
+				t,
+				std::numeric_limits<time_t>::max());
+		}
+	}
+
+	return this->end(t);
+}
+
+
+template <typename T>
+QueueFilterIterator<T, Queue<T>> Queue<T>::end(const time_t &t) const {
+	return QueueFilterIterator<T, Queue<T>>(
+		container.end(),
+		this,
+		t,
+		std::numeric_limits<time_t>::max());
+}
+
+
+template <typename T>
+QueueFilterIterator<T, Queue<T>> Queue<T>::between(
+	const time_t &begin,
+	const time_t &end) const {
+
+	auto it = QueueFilterIterator<T, Queue<T>>(
+		container.begin(),
+		this,
+		begin,
+		end);
+	if (!container.empty() && !it.valid()) {
+		++it;
+	}
+	return it;
+}
+
+
+template <typename T>
+void Queue<T>::erase(const CurveIterator<T, Queue<T>> &t) {
+	auto it = container.erase(t.base());
+	return;
+}
+
+
+template <typename T>
+QueueFilterIterator<T, Queue<T>> Queue<T>::insert(
+	const time_t &time,
+	const T &e) {
+
+	const_iterator insertion_point = this->container.end();
+	for (auto it = this->container.begin(); it != this->container.end(); ++it) {
+		if (time < it->time()) {
+			insertion_point = this->container.insert(it, queue_wrapper(time, e));
+			break;
+		}
+	}
+	if (insertion_point == this->container.end()) {
+		insertion_point = this->container.insert(this->container.end(),
+		                                         queue_wrapper(time, e));
+	}
+
+	auto ct = QueueFilterIterator<T, Queue<T>>(
+		insertion_point,
+		this,
+		time, std::numeric_limits<time_t>::max());
+
+	if (!ct.valid()) {
+		++ct;
+	}
+	return ct;
+}
+
+
+template <typename T>
+void Queue<T>::clear() {
+	this->container.clear();
+}
+
+
+template <typename T>
+void Queue<T>::clean(const time_t &time) {
+	for (auto it = this->container.begin();
+	     it != this->container.end() and it->time() < time;
+	     it = this->container.erase(it))
+	{}
+}
+
+
+} // openage::curve
diff --git a/libopenage/curve/queue_filter_iterator.cpp b/libopenage/curve/queue_filter_iterator.cpp
new file mode 100644
index 0000000000..fa0b3ad15a
--- /dev/null
+++ b/libopenage/curve/queue_filter_iterator.cpp
@@ -0,0 +1,9 @@
+// Copyright 2017-2018 the openage authors. See copying.md for legal info.
+
+#include "queue_filter_iterator.h"
+
+namespace openage::curve {
+
+// This file is intended to be empty
+
+} // namespace openage::curve
diff --git a/libopenage/curve/queue_filter_iterator.h b/libopenage/curve/queue_filter_iterator.h
new file mode 100644
index 0000000000..0c6eaaf18c
--- /dev/null
+++ b/libopenage/curve/queue_filter_iterator.h
@@ -0,0 +1,52 @@
+// Copyright 2017-2018 the openage authors. See copying.md for legal info.
+
+#pragma once
+
+#include "curve.h"
+#include "iterator.h"
+
+#include <iterator>
+#include <limits>
+
+
+namespace openage::curve {
+
+/**
+ * A filtering operator to iterate over all elements of a queue whose elements
+ * exist at exactly one point of time, the range where to iterate is given at
+ * construction.
+ *
+ * It depends on val_t as its value type, container_t is the container
+ * to operate on and the function valid_f, that checks if an element is alive.
+ */
+template<typename val_t,
+         typename container_t>
+class QueueFilterIterator : public CurveIterator<val_t, container_t, typename container_t::const_iterator> {
+public:
+	using const_iterator = typename container_t::const_iterator;
+
+	/**
+	 * Construct the iterator from its boundary conditions: time and container
+	 */
+	QueueFilterIterator(const const_iterator &base,
+	                    const container_t *base_container,
+	                    const time_t &from,
+	                    const time_t &to)
+		:
+		CurveIterator<val_t, container_t>(base, base_container, from, to) {}
+
+	virtual bool valid() const override {
+		if (this->container->end().get_base() != this->get_base()) {
+			return (this->get_base()->time() >= this->from and
+			        this->get_base()->time() < this->to);
+		}
+		return false;
+	}
+
+	const val_t &value() const override {
+		const auto &a = *this->get_base();
+		return a.value;
+	}
+};
+
+} // openage::curve
diff --git a/libopenage/curve/tests/CMakeLists.txt b/libopenage/curve/tests/CMakeLists.txt
new file mode 100644
index 0000000000..62e8a61f86
--- /dev/null
+++ b/libopenage/curve/tests/CMakeLists.txt
@@ -0,0 +1,4 @@
+add_sources(libopenage
+	curve_types.cpp
+	container.cpp
+)
diff --git a/libopenage/curve/tests/container.cpp b/libopenage/curve/tests/container.cpp
new file mode 100644
index 0000000000..3db231858a
--- /dev/null
+++ b/libopenage/curve/tests/container.cpp
@@ -0,0 +1,212 @@
+// Copyright 2017-2018 the openage authors. See copying.md for legal info.
+
+#include "../../testing/testing.h"
+#include "../curve.h"
+#include "../continuous.h"
+#include "../discrete.h"
+#include "../queue.h"
+#include "../map.h"
+
+#include <unordered_map>
+#include <unordered_set>
+
+
+namespace openage::curve::tests {
+
+struct map_test_element {
+	int value;
+
+	map_test_element(int v) :
+		value(v) {}
+
+	bool operator != (int rhs) {
+		return this->value != rhs;
+	}
+
+};
+
+std::ostream &operator <<(std::ostream &o, const map_test_element &e) {
+	o << e.value;
+	return o;
+}
+
+template <typename key_t, typename val_t>
+void dump(const std::unordered_map<key_t, val_t> &map) {
+	for (const auto &i : map) {
+		std::cout << i.first << ": " << i.second << std::endl;
+	}
+}
+
+void test_map() {
+	static_assert(std::is_copy_constructible<MapFilterIterator<int, int, UnorderedMap<int, int>>>::value,
+	              "UnorderedMapIterator not Copy Constructable able");
+	static_assert(std::is_copy_assignable<MapFilterIterator<int, int, UnorderedMap<int, int>>>::value,
+	              "UnorderedMapIterator not Copy Assignable");
+
+	UnorderedMap<int, int> map;
+	map.insert(0, 10, 0, 0);
+	map.insert(5, 10, 5, 1);
+	map.insert(100, 200, 200, 2);
+
+	// Basic tests test lookup in the middle of the range.
+	{
+		auto t = map.at(2, 0); //At timestamp 2 element 0
+		TESTEQUALS(t.has_value(), true);
+		TESTEQUALS(t.value().value(), 0);
+		t = map.at(20, 5);
+		TESTEQUALS(t.has_value(), false);
+	}
+	{
+		auto t = map.at(7, 5);
+		TESTEQUALS(t.has_value(), true);
+		TESTEQUALS(t.value().value(), 1);
+		t = map.at(20, 5);
+		TESTEQUALS(t.has_value(), false);
+		t = map.at(2, 5);
+		TESTEQUALS(t.has_value(), false);
+	}
+	{
+		auto t = map.at(150, 200);
+		TESTEQUALS(t.has_value(), true);
+		TESTEQUALS(t.value().value(), 2);
+		t = map.at(500, 200);
+		TESTEQUALS(t.has_value(), false);
+		t = map.at(5, 200);
+		TESTEQUALS(t.has_value(), false);
+	}
+	// test 2.0: test at the boundaries
+	{
+		auto t = map.at(0, 0);
+		TESTEQUALS(t.has_value(), true);
+		TESTEQUALS(t.value().value(), 0);
+		t = map.at(10, 0);
+		TESTEQUALS(t.has_value(), false);
+	}
+	{
+		auto t = map.at(5, 5);
+		TESTEQUALS(t.has_value(), true);
+		TESTEQUALS(t.value().value(), 1);
+		t = map.at(10, 5);
+		TESTEQUALS(t.has_value(), false);
+	}
+	{
+		auto t = map.at(100, 200);
+		TESTEQUALS(t.has_value(), true);
+		TESTEQUALS(t.value().value(), 2);
+		t = map.at(200, 200);
+		TESTEQUALS(t.has_value(), false);
+	}
+	// Test 3.0 Iterations
+	{
+		// Iteration tests
+		std::unordered_map<int, int> reference;
+		reference[0] = 0;
+		reference[5] = 1;
+		reference[200] = 2;
+		for (auto it = map.begin(0); it != map.end(); ++it) { // Get all
+			auto ri = reference.find(it.key());
+			if (ri != reference.end()) {
+				reference.erase(ri);
+			}
+		}
+		TESTEQUALS(reference.empty(), true);
+
+		reference[5] = 5;
+		for (auto it = map.begin(1); it != map.end(90); ++it) {
+			auto ri = reference.find(it.key());
+			if (ri != reference.end()) {
+				reference.erase(ri);
+			}
+		}
+		TESTEQUALS(reference.empty(), true);
+
+		reference[5] = 5;
+		for (auto it = map.between(1,90); it != map.end(); ++it) {
+			auto ri = reference.find(it.key());
+			if (ri != reference.end()) {
+				reference.erase(ri);
+			}
+		}
+		TESTEQUALS(reference.empty(), true);
+	}
+}
+
+void test_list() {
+
+}
+
+void test_queue() {
+	static_assert(std::is_copy_constructible<QueueFilterIterator<int, Queue<int>>>::value,
+	              "QueueIterator not Copy Constructable able");
+	static_assert(std::is_copy_assignable<QueueFilterIterator<int, Queue<int>>>::value,
+	              "QueueIterator not Copy Assignable");
+
+
+	Queue<int> q;
+	q.insert(0, 1);
+	q.insert(2, 2);
+	q.insert(4, 3);
+	q.insert(10, 4);
+	q.insert(100001, 5);
+	TESTEQUALS(*q.begin(0), 1);
+	TESTEQUALS(*q.begin(1), 2);
+	TESTEQUALS(*q.begin(2), 2);
+	TESTEQUALS(*q.begin(3), 3);
+	TESTEQUALS(*q.begin(4), 3);
+	TESTEQUALS(*q.begin(5), 4);
+	TESTEQUALS(*q.begin(10), 4);
+	TESTEQUALS(*q.begin(12), 5);
+	TESTEQUALS(*q.begin(100000), 5);
+
+	{
+		std::unordered_set<int> reference = {1,2,3};
+		for (auto it = q.between(0,6); it != q.end(); ++it) {
+			auto ri = reference.find(it.value());
+			if (ri != reference.end()) {
+				reference.erase(ri);
+			}
+		}
+		TESTEQUALS(reference.empty(), true);
+	}
+	{
+		std::unordered_set<int> reference = {2,3,4};
+		for (auto it = q.between(1,40); it != q.end(); ++it) {
+			auto ri = reference.find(it.value());
+			if (ri != reference.end()) {
+				reference.erase(ri);
+			}
+		}
+		TESTEQUALS(reference.empty(), true);
+	}
+	{
+		std::unordered_set<int> reference = {};
+		for (auto it = q.between(30,40); it != q.end(); ++it) {
+			auto ri = reference.find(it.value());
+			if (ri != reference.end()) {
+				reference.erase(ri);
+			}
+		}
+		TESTEQUALS(reference.empty(), true);
+	}
+	{
+		std::unordered_set<int> reference = {1,2,3,4};
+		for (auto it = q.between(0,40); it != q.end(); ++it) {
+			auto ri = reference.find(it.value());
+			if (ri != reference.end()) {
+				reference.erase(ri);
+			}
+		}
+		TESTEQUALS(reference.empty(), true);
+	}
+
+}
+
+
+void container() {
+	test_map();
+	test_list();
+	test_queue();
+}
+
+
+} // openage::curve::tests
diff --git a/libopenage/curve/tests/curve_types.cpp b/libopenage/curve/tests/curve_types.cpp
new file mode 100644
index 0000000000..c2ea4c39a6
--- /dev/null
+++ b/libopenage/curve/tests/curve_types.cpp
@@ -0,0 +1,148 @@
+// Copyright 2017-2018 the openage authors. See copying.md for legal info.
+
+#include "../../event/loop.h"
+#include "../../log/log.h"
+#include "../../testing/testing.h"
+#include "../continuous.h"
+#include "../curve.h"
+#include "../discrete.h"
+#include "../keyframe_container.h"
+
+
+namespace openage::curve::tests {
+
+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);
+
+		// 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(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!
+		TESTEQUALS(c.last(0, p0)->value, 0);
+		TESTEQUALS(c.last(1, p0)->value, 1); // last shall give >= not only > !
+		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(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(5, p2)->value, 1);
+		TESTEQUALS(c.last(10, p2)->value, 2);
+		TESTEQUALS(c.last(47, p2)->value, 2);
+
+		// Now test the basic erase() function
+		// Delete the 1-element, new values should be [0, 2]
+		c.erase(c.last(1));
+
+		TESTEQUALS(c.last(1)->value, 0);
+		TESTEQUALS(c.last(5)->value, 0);
+		TESTEQUALS(c.last(47)->value, 2);
+
+		// should do nothing, since we delete all at > 99,
+		// but the last element is at 10.
+		c.erase_after(c.last(99));
+		TESTEQUALS(c.last(47)->value, 2);
+
+		// now since 5 < 10, element with value 2 has to be gone
+		c.erase_after(c.last(5));
+		TESTEQUALS(c.last(47)->value, 0);
+	}
+
+	// Check the Simple Continuous type
+	{
+		auto f = std::make_shared<event::Loop>();
+		Continuous<float> c(f, 0);
+
+		c.set_insert(0, 0);
+		c.set_insert(10, 1);
+
+		TESTEQUALS(c.get(0), 0);
+
+		TESTEQUALS_FLOAT(c.get(1), 0.1, 1e-7);
+	}
+
+	{
+		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);
+		TESTEQUALS(c.get(1), 1);
+		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);
+	}
+
+	//Check the discrete type
+	{
+		auto f = std::make_shared<event::Loop>();
+		Discrete<int> c(f, 0);
+		c.set_insert(0, 0);
+		c.set_insert(10, 10);
+
+		TESTEQUALS(c.get(0), 0);
+		TESTEQUALS(c.get(1), 0);
+		TESTEQUALS(c.get(10), 10);
+
+		Discrete<std::string> complex(f, 0);
+
+		complex.set_insert(0, "Test 0");
+		complex.set_insert(10, "Test 10");
+
+		TESTEQUALS(complex.get(0), "Test 0");
+		TESTEQUALS(complex.get(1), "Test 0");
+		TESTEQUALS(complex.get(10), "Test 10");
+
+	}
+
+	//check set_last
+	{
+		auto f = std::make_shared<event::Loop>();
+		Discrete<int> c(f, 0);
+		c.set_insert(0, 0);
+		c.set_insert(1, 1);
+		c.set_insert(3, 3);
+
+		TESTEQUALS(c.get(3), 3);
+
+		c.set_last(2, 10);
+		TESTEQUALS(c.get(2), 10);
+	}
+
+	// Encountered Errors
+	{
+		auto f = std::make_shared<event::Loop>();
+		Continuous<int> c(f, 0);
+		c.set_insert(1, 1);
+		c.set_last(1, -5);
+
+		TESTEQUALS(c.get(1), -5);
+	}
+}
+
+} // openage::curve::tests
diff --git a/libopenage/curve/value_container.cpp b/libopenage/curve/value_container.cpp
new file mode 100644
index 0000000000..a8764386f5
--- /dev/null
+++ b/libopenage/curve/value_container.cpp
@@ -0,0 +1,7 @@
+// 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
new file mode 100644
index 0000000000..cd9b511bc6
--- /dev/null
+++ b/libopenage/curve/value_container.h
@@ -0,0 +1,104 @@
+// 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/event/CMakeLists.txt b/libopenage/event/CMakeLists.txt
new file mode 100644
index 0000000000..e89a4f8734
--- /dev/null
+++ b/libopenage/event/CMakeLists.txt
@@ -0,0 +1,12 @@
+add_sources(libopenage
+	event.cpp
+	eventclass.cpp
+	eventfilter.cpp
+	eventqueue.cpp
+	eventtarget.cpp
+	loop.cpp
+	state.cpp
+	tests.cpp
+)
+
+add_subdirectory("demo")
diff --git a/libopenage/event/demo/CMakeLists.txt b/libopenage/event/demo/CMakeLists.txt
new file mode 100644
index 0000000000..f685f05470
--- /dev/null
+++ b/libopenage/event/demo/CMakeLists.txt
@@ -0,0 +1,12 @@
+add_sources(libopenage
+	aicontroller.cpp
+	gamestate.cpp
+	gui.cpp
+	main.cpp
+	physics.cpp
+)
+
+
+pxdgen(
+	main.h
+)
diff --git a/libopenage/event/demo/aicontroller.cpp b/libopenage/event/demo/aicontroller.cpp
new file mode 100644
index 0000000000..fe17c7dbbb
--- /dev/null
+++ b/libopenage/event/demo/aicontroller.cpp
@@ -0,0 +1,29 @@
+// Copyright 2017-2018 the openage authors. See copying.md for legal info.
+
+#include "aicontroller.h"
+
+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();
+
+	auto position = player->position->get(now);
+
+	// Yes i know, there is /3 used - instead of the logical /2 - this is to
+	// create a small safety boundary of 1/3 for enhanced fancyness
+
+	// Ball is below position
+	if (ball->position->get(now)[1] > position + player->size->get(now) / 3) {
+		this->commands.push_back(PongEvent{player->id(), PongEvent::DOWN});
+	}
+	// Ball is above position
+	else if (ball->position->get(now)[1] < position - player->size->get(now) / 3) {
+		this->commands.push_back(PongEvent{player->id(), PongEvent::UP});
+	}
+
+	return this->commands;
+}
+
+} // openage::event::demo
diff --git a/libopenage/event/demo/aicontroller.h b/libopenage/event/demo/aicontroller.h
new file mode 100644
index 0000000000..d42e9b4462
--- /dev/null
+++ b/libopenage/event/demo/aicontroller.h
@@ -0,0 +1,23 @@
+// Copyright 2017-2018 the openage authors. See copying.md for legal info.
+
+#pragma once
+
+#include "gamestate.h"
+
+#include <vector>
+
+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
+	);
+
+private:
+	std::vector<PongEvent> commands;
+};
+
+} // openage::event::demo
diff --git a/libopenage/event/demo/gamestate.cpp b/libopenage/event/demo/gamestate.cpp
new file mode 100644
index 0000000000..1de008c722
--- /dev/null
+++ b/libopenage/event/demo/gamestate.cpp
@@ -0,0 +1,9 @@
+// Copyright 2017-2018 the openage authors. See copying.md for legal info.
+
+#include "gamestate.h"
+
+namespace openage::event::demo {
+
+// This file is intentionally left empty
+
+} // openage::event::demo
diff --git a/libopenage/event/demo/gamestate.h b/libopenage/event/demo/gamestate.h
new file mode 100644
index 0000000000..d9b29e6d19
--- /dev/null
+++ b/libopenage/event/demo/gamestate.h
@@ -0,0 +1,129 @@
+// Copyright 2017-2018 the openage authors. See copying.md for legal info.
+
+#pragma once
+
+#include <functional>
+
+#include "../state.h"
+#include "../loop.h"
+#include "../eventtarget.h"
+#include "../../curve/continuous.h"
+#include "../../curve/discrete.h"
+#include "../../util/vector.h"
+
+
+namespace openage::event::demo {
+
+
+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;
+};
+
+
+
+using namespace std::placeholders;
+class PongPlayer : public EventTarget {
+public:
+	PongPlayer(const std::shared_ptr<Loop> &mgr, size_t id)
+		:
+		EventTarget{mgr},
+		speed(std::make_shared<curve::Discrete<float>>(
+			      mgr,
+			      (id << 4) + 1,
+			      std::bind(&PongPlayer::child_changes, this, _1))),
+		position(std::make_shared<curve::Continuous<float>>(
+			         mgr,
+			         (id << 4) + 2,
+			         std::bind(&PongPlayer::child_changes, this, _1))),
+		lives(std::make_shared<curve::Discrete<int>>(
+			      mgr,
+			      (id << 4) + 3,
+			      std::bind(&PongPlayer::child_changes, this, _1))),
+		state(std::make_shared<curve::Discrete<PongEvent>>(
+			      mgr,
+			      (id << 4) + 4,
+			      std::bind(&PongPlayer::child_changes, this, _1))),
+		size(std::make_shared<curve::Discrete<float>>(
+			     mgr,
+			     (id << 4) + 5,
+			     std::bind(&PongPlayer::child_changes, this, _1))),
+		_id{id},
+		paddle_x{0} {}
+
+	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;
+	float paddle_x;
+
+	size_t id() const override {
+		return _id;
+	}
+
+private:
+	void child_changes(const curve::time_t &time) {
+		this->changes(time);
+	}
+};
+
+
+class PongBall : public EventTarget {
+public:
+	PongBall(const std::shared_ptr<Loop> &mgr, size_t id)
+		:
+		EventTarget{mgr},
+		speed(std::make_shared<curve::Discrete<util::Vector2d>>(
+			      mgr,
+			      (id << 2) + 1,
+			      std::bind(&PongBall::child_changes, this, _1))),
+		position(std::make_shared<curve::Continuous<util::Vector2d>>(
+			         mgr,
+			         (id << 2) + 2,
+			         std::bind(&PongBall::child_changes, this, _1))),
+		_id{id} {}
+
+	std::shared_ptr<curve::Discrete<util::Vector2d>> speed;
+	std::shared_ptr<curve::Continuous<util::Vector2d>> position;
+
+	size_t id() const override {
+		return _id;
+	}
+private:
+	void child_changes(const curve::time_t &time) {
+		this->changes(time);
+	}
+	size_t _id;
+};
+
+
+class PongState : public State {
+public:
+	PongState(const std::shared_ptr<Loop> &mgr, bool enable_gui)
+		:
+		State{mgr},
+		p1(std::make_shared<PongPlayer>(mgr, 0)),
+		p2(std::make_shared<PongPlayer>(mgr, 1)),
+		ball(std::make_shared<PongBall>(mgr, 2)),
+		enable_gui{enable_gui} {}
+
+	std::shared_ptr<PongPlayer> p1;
+	std::shared_ptr<PongPlayer> p2;
+	std::shared_ptr<PongBall> ball;
+	util::Vector2d display_boundary;
+
+	bool enable_gui;
+};
+
+} // openage::event::demo
diff --git a/libopenage/event/demo/gui.cpp b/libopenage/event/demo/gui.cpp
new file mode 100644
index 0000000000..d3ee16e9d2
--- /dev/null
+++ b/libopenage/event/demo/gui.cpp
@@ -0,0 +1,242 @@
+// Copyright 2016-2018 the openage authors. See copying.md for legal info.
+
+#include "gui.h"
+
+// the gui requires ncurses.
+#if WITH_NCURSES
+
+#include <algorithm>
+#include <cstdio>
+#include <ncurses.h>
+#include <vector>
+
+#include <unistd.h>
+
+
+namespace openage::event::demo {
+
+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;
+
+	timeout(0);
+
+	std::vector<int> inputs;
+	int c;
+	while ((c = getch()) != ERR) {
+		if (std::find(inputs.begin(), inputs.end(), c) == inputs.end()) {
+			inputs.push_back(c);
+		}
+	}
+
+	for (auto input : inputs) {
+		switch (input) {
+		case KEY_DOWN:
+			evnt.state = PongEvent::DOWN;
+			mvprintw(1, 40, "DOWN");
+			break;
+
+		case KEY_UP:
+			evnt.state = PongEvent::UP;
+			mvprintw(1, 40, "UP");
+			break;
+
+		case 27:  // esc or alt
+			erase();
+			refresh();
+			endwin();
+			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;
+}
+
+
+enum {
+	COLOR_PLAYER1 = 1,
+	COLOR_PLAYER2 = 2,
+	COLOR_BALL    = 3,
+	COLOR_DEBUG   = 4,
+
+	COLOR_0 = 5,
+	COLOR_1 = 6,
+	COLOR_2 = 7,
+	COLOR_3 = 8,
+	COLOR_4 = 9,
+};
+
+
+Gui::Gui() {}
+
+void Gui::init() {
+	initscr();
+	start_color();
+
+	init_pair(COLOR_PLAYER1, COLOR_BLUE, COLOR_BLUE);
+	init_pair(COLOR_PLAYER2, COLOR_RED, COLOR_RED);
+	init_pair(COLOR_BALL, COLOR_BLUE, COLOR_WHITE);
+	init_pair(COLOR_DEBUG, COLOR_WHITE, COLOR_BLACK);
+	init_pair(COLOR_0, COLOR_RED, COLOR_BLACK);
+	init_pair(COLOR_1, COLOR_GREEN, COLOR_BLACK);
+
+	keypad(stdscr, true);
+	noecho();
+	cbreak();
+	curs_set(0);
+	wnoutrefresh(curscr);
+
+	int x, y;
+	getmaxyx(stdscr, y, x);
+
+	attron(COLOR_PAIR(COLOR_DEBUG));
+
+	std::vector<const char*> buffer{
+		"oooooooooo                                   ",
+		" 888    888  ooooooo    ooooooo    oooooooo8 ",
+		" 888oooo88 888     888 888   888  888    88o ",
+		" 888       888     888 888   888   888oo888o ",
+		"o888o        88ooo88  o888o o888o     88 888 ",
+		"                                    888ooo888",
+	};
+
+	size_t colwidth = 0;
+	for (const auto &c : buffer) {
+		colwidth = std::max(colwidth, strlen(c));
+	}
+
+	int row = (y - buffer.size()) / 2;;
+	int col = (x - colwidth) / 2;
+	for (const auto &c : buffer) {
+		mvprintw(row++, col, c);
+	}
+
+	attroff(COLOR_PAIR(COLOR_DEBUG));
+
+	refresh();
+
+	// wait for a keypress to begin game
+	getch();
+}
+
+
+void Gui::clear() {
+	erase();
+}
+
+
+void Gui::draw(std::shared_ptr<PongState> &state, const curve::time_t &now) {
+	attron(COLOR_PAIR(COLOR_DEBUG));
+
+	// record the screen dimensions
+	// TODO: make the display_boundary a curve as well.
+	getmaxyx(stdscr, state->display_boundary[1], state->display_boundary[0]);
+	state->display_boundary[1] -= 1;
+
+	// print the score
+	attron(COLOR_PAIR(COLOR_DEBUG));
+	mvprintw(2,
+	         state->display_boundary[0] / 2 - 5,
+	         "P1 %i | P2 %i",
+	         state->p1->lives->get(now),
+	         state->p2->lives->get(now));
+
+	// draw the middle line
+	mvvline(0, state->display_boundary[0] / 2, ACS_VLINE, state->display_boundary[1]);
+
+	// debug information
+	mvprintw(0, 1, "NOW:  %f", now.to_double());
+	mvprintw(1, 1, "SCR:  %f | %f", state->display_boundary[0], state->display_boundary[1]);
+	mvprintw(2, 1,
+	         "P1:   %f, %f, %i",
+	         state->p1->position->get(now),
+	         state->p1->paddle_x,
+	         state->p1->state->get(now).state);
+	mvprintw(3, 1,
+	         "P2:   %f, %f, %i",
+	         state->p2->position->get(now),
+	         state->p2->paddle_x,
+	         state->p2->state->get(now).state);
+
+	// ball position predictions, 10s into the future
+	for (int i = 0; i < 10; i++) {
+		auto i_as_ctt = curve::time_t::from_int(i);
+		mvprintw((5 + i), 1,
+		         "BALL in %03f: %f | %f; SPEED: %f | %f | PLpos: %f, PRpos: %f | PLst: %d",
+		         i_as_ctt.to_double(),
+		         state->ball->position->get(now + i_as_ctt)[0],
+		         state->ball->position->get(now + i_as_ctt)[1],
+		         state->ball->speed->get(now + i_as_ctt)[0],
+		         state->ball->speed->get(now + i_as_ctt)[1],
+		         state->p1->position->get(now + i_as_ctt),
+		         state->p2->position->get(now + i_as_ctt),
+		         state->p1->state->get(now + i_as_ctt).state
+		);
+	}
+
+	// exit hint message
+	mvprintw(state->display_boundary[1] - 1, 1, "Press ESC to exit");
+	attroff(COLOR_PAIR(COLOR_DEBUG));
+
+	// draw player 1 paddle
+	attron(COLOR_PAIR(COLOR_PLAYER1));
+	for (int i = -state->p1->size->get(now) / 2; i < state->p1->size->get(now) / 2; i++) {
+		mvprintw(state->p1->position->get(now) + i, state->p1->paddle_x, "|");
+	}
+	attroff(COLOR_PAIR(COLOR_PLAYER1));
+
+	// draw player 2 paddle
+	attron(COLOR_PAIR(COLOR_PLAYER2));
+	for (int i = -state->p2->size->get(now) / 2; i < state->p2->size->get(now) / 2; i++) {
+		mvprintw(state->p2->position->get(now) + i, state->p2->paddle_x, "|");
+	}
+	attroff(COLOR_PAIR(COLOR_PLAYER2));
+
+	// ball position prediction 10s into the future
+	attron(COLOR_PAIR(COLOR_1));
+	for (int i = 1; i < 100; ++i) {
+		auto i_as_ctt = curve::time_t::from_double(i/10.0);
+		draw_ball(state->ball->position->get(now + i_as_ctt), "x");
+	}
+
+	// draw the ball
+	attron(COLOR_PAIR(COLOR_BALL));
+	this->draw_ball(state->ball->position->get(now), "M"); // TODO: use "⚽"
+	attroff(COLOR_PAIR(COLOR_BALL));
+}
+
+
+void Gui::update_screen() {
+	// actually show screen output
+	refresh();
+}
+
+
+void Gui::draw_ball(util::Vector2d pos, const char *str) {
+	mvprintw((int)(pos[1]), (int)(pos[0]), "%s", str);
+	standend();
+}
+
+#endif
+
+} // openage::event::demo
diff --git a/libopenage/event/demo/gui.h b/libopenage/event/demo/gui.h
new file mode 100644
index 0000000000..c97f9eb180
--- /dev/null
+++ b/libopenage/event/demo/gui.h
@@ -0,0 +1,32 @@
+// Copyright 2015-2018 the openage authors. See copying.md for legal info.
+
+#pragma once
+
+#include <vector>
+
+#include "gamestate.h"
+
+
+namespace openage::event::demo {
+
+#if WITH_NCURSES
+
+class Gui {
+public:
+	Gui();
+	void init();
+	void clear();
+	void update_screen();
+
+	const std::vector<PongEvent> &get_inputs(const std::shared_ptr<PongPlayer> &player);
+
+	void draw(std::shared_ptr<PongState> &state, const curve::time_t &now);
+	void draw_ball(util::Vector2d ball, const char *str);
+
+private:
+	std::vector<PongEvent> input_cache;
+};
+
+#endif
+
+} // openage::event::demo
diff --git a/libopenage/event/demo/main.cpp b/libopenage/event/demo/main.cpp
new file mode 100644
index 0000000000..174920ba28
--- /dev/null
+++ b/libopenage/event/demo/main.cpp
@@ -0,0 +1,208 @@
+// Copyright 2016-2018 the openage authors. See copying.md for legal info.
+
+#include <chrono>
+#include <ratio>
+#include <unistd.h>
+
+#include "../../config.h"
+#include "../event.h"
+#include "aicontroller.h"
+#include "gamestate.h"
+#include "gui.h"
+#include "physics.h"
+
+#if WITH_NCURSES
+#include <ncurses.h>
+#endif
+
+
+using Clock = std::chrono::high_resolution_clock;
+using namespace std::literals::chrono_literals;
+
+
+namespace openage::event::demo {
+
+/**
+ * Simulation speeds
+ */
+enum class timescale {
+	NOSLEEP,
+	REALTIME,
+	SLOW,
+	FAST,
+};
+
+
+void curvepong(bool disable_gui, bool no_human) {
+
+	bool enable_gui = not disable_gui;
+	bool human_player = not no_human;
+
+	timescale speed = timescale::REALTIME;
+
+
+#if WITH_NCURSES
+	Gui gui;
+	if (enable_gui) {
+		gui.init();
+	}
+#endif
+
+	bool running = true;
+
+	while (running) {
+		auto loop = std::make_shared<Loop>();
+		curve::time_t now = 1;
+		Physics phys;
+		AIInput ai;
+
+		auto state = std::make_shared<PongState>(loop, enable_gui);
+		Physics::init(state, loop, now);
+
+		state->p1->lives->set_last(now, 3);
+		state->p1->size->set_last(now, 4);
+
+		state->p2->lives->set_last(now, 3);
+		state->p2->size->set_last(now, 4);
+
+#if WITH_NCURSES
+		if (state->enable_gui) {
+			gui.clear();
+			gui.draw(state, now);  // update gui related parameters
+		}
+		else {
+#endif
+			state->display_boundary = {100, 40};
+#if WITH_NCURSES
+		}
+#endif
+
+		{
+			std::vector<PongEvent> start_event{PongEvent(0, PongEvent::START)};
+			phys.process_input(state, state->p1, start_event, loop, now);
+		}
+
+#if WITH_NCURSES
+		if (state->enable_gui) {
+			gui.draw(state, now);  // initial drawing with corrected ball
+		}
+#endif
+
+		// this is the game loop, running while both players live!
+		while (state->p1->lives->get(now) > 0 and
+		       state->p2->lives->get(now) > 0) {
+
+			auto loop_start = Clock::now();
+
+#if WITH_NCURSES
+			if (enable_gui) {
+				gui.clear();
+			}
+#endif
+
+			// process the input for both players
+			// player 1 can be AI or human.
+
+			if (human_player) {
+#if WITH_NCURSES
+				auto inputs = gui.get_inputs(state->p1);
+#else
+				// TODO: take terminal input without ncurses, if on tty?
+				//       e.g. 'q' to close it?
+				std::vector<PongEvent> inputs;
+#endif
+				phys.process_input(state, state->p1,
+				                   inputs, loop, now);
+			}
+			else {
+#if WITH_NCURSES
+				// We still need to get the inputs to be able to kill the game
+				if (state->enable_gui) {
+					gui.get_inputs(state->p1);
+				}
+#endif
+
+				phys.process_input(state, state->p1,
+				                   ai.get_inputs(state->p1, state->ball, now),
+				                   loop, now);
+			}
+
+			phys.process_input(state, state->p2,
+			                   ai.get_inputs(state->p2, state->ball, now),
+			                   loop, now);
+
+			// paddle x positions
+			state->p1->paddle_x = 0;
+			state->p2->paddle_x = state->display_boundary[0] - 1;
+
+			// run the event queue!
+			loop->reach_time(now, state);
+
+#if WITH_NCURSES
+			if (state->enable_gui) {
+				gui.draw(state, now);
+
+				int pos = 1;
+				mvprintw(pos++, state->display_boundary[0]/2 + 10, "Enqueued events:");
+				for (const auto &e : loop->get_queue().get_event_queue()) {
+					mvprintw(pos++, state->display_boundary[0]/2 + 10,
+					         "%f: %s",
+					         e->get_time().to_double(),
+					         e->get_eventclass()->id().c_str());
+				}
+
+				gui.update_screen();
+			}
+#endif
+
+			// handle timing for screen refresh and simulation advancement
+
+			using dt_s_t = std::chrono::duration<double, std::ratio<1>>;
+			using dt_us_t = std::chrono::duration<double, std::micro>;
+
+			// 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
+				usleep(5000);
+			}
+
+			dt_us_t dt_us = Clock::now() - loop_start;
+
+			if (speed != timescale::NOSLEEP) {
+				dt_us_t wait_time = per_frame - dt_us;
+
+				if (wait_time > dt_us_t::zero()) {
+					usleep(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::event::demo
diff --git a/libopenage/event/demo/main.h b/libopenage/event/demo/main.h
new file mode 100644
index 0000000000..653d74db94
--- /dev/null
+++ b/libopenage/event/demo/main.h
@@ -0,0 +1,14 @@
+// Copyright 2018-2018 the openage authors. See copying.md for legal info.
+
+#pragma once
+
+// pxd: from libcpp cimport bool
+
+
+namespace openage::event::demo {
+
+// pxd: void curvepong(bool disable_gui, bool no_human) except +
+void curvepong(bool disable_gui, bool no_human);
+
+
+} // openage::event::demo
diff --git a/libopenage/event/demo/physics.cpp b/libopenage/event/demo/physics.cpp
new file mode 100644
index 0000000000..082b65383d
--- /dev/null
+++ b/libopenage/event/demo/physics.cpp
@@ -0,0 +1,485 @@
+// Copyright 2017-2018 the openage authors. See copying.md for legal info.
+
+#include "physics.h"
+
+#include <cassert>
+#include <cmath>
+
+#if WITH_NCURSES
+#include <ncurses.h>
+#endif
+
+#include "../../config.h"
+#include "../../error/error.h"
+#include "../../rng/global_rng.h"
+
+
+namespace openage::event::demo {
+
+
+class BallReflectWall : public DependencyEventClass {
+public:
+	BallReflectWall() : DependencyEventClass("demo.ball.reflect_wall") {}
+
+	void setup_event(const std::shared_ptr<Event> &evnt,
+	                 const std::shared_ptr<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->position);
+		evnt->depend_on(state->ball->speed);
+		// TODO add dependency to size of game area
+
+		// FIXME: warn if it's not a dependency eventclass
+	}
+
+	// FIXME we REALLY need dependencies to objects i.e. Ball : public EventTarget()
+	void invoke(Loop &,
+	            const std::shared_ptr<EventTarget> &target,
+	            const std::shared_ptr<State> &gstate,
+	            const curve::time_t &now,
+	            const EventClass::param_map &/*param*/) override {
+
+		auto positioncurve = std::dynamic_pointer_cast<curve::Continuous<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);
+		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(
+				(state->display_boundary[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<EventTarget> &target,
+	                                  const std::shared_ptr<State> &gstate,
+	                                  const curve::time_t &now) override {
+
+		auto positioncurve = std::dynamic_pointer_cast<curve::Continuous<util::Vector2d>>(target);
+		auto state = std::dynamic_pointer_cast<PongState>(gstate);
+
+		auto speed = state->ball->speed->get(now);
+		auto pos = positioncurve->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((state->display_boundary[1] - pos[1]) / speed[1]);
+		}
+		else if (speed[1] < 0) {
+			ty = curve::time_t::from_double(pos[1] / -speed[1]);
+		}
+
+#if WITH_NCURSES
+		if (state->enable_gui) {
+			mvprintw(22, 40,
+			         "WALL TY %f NOW %f, NOWTY %f ",
+			         ty.to_double(), now.to_double(), (now + ty).to_double());
+		};
+#endif
+		return now + ty;
+	}
+};
+
+
+class BallReflectPanel : public DependencyEventClass {
+public:
+	BallReflectPanel ()
+		:
+		DependencyEventClass("demo.ball.reflect_panel") {}
+
+	void setup_event(const std::shared_ptr<Event> &target,
+	                 const std::shared_ptr<State> &gstate) override {
+
+		auto state = std::dynamic_pointer_cast<PongState>(gstate);
+
+		// FIXME dependency to a full ball object
+		// then a change to any of the curves triggers the update.
+		target->depend_on(state->ball->position);
+		target->depend_on(state->ball->speed);
+		target->depend_on(state->p1->position);
+		target->depend_on(state->p2->position);
+		// TODO add dependency to size of game area
+	}
+
+	// FIXME we REALLY need dependencies to objects
+	void invoke(Loop &mgr,
+	            const std::shared_ptr<EventTarget> &/*target*/,
+	            const std::shared_ptr<State> &gstate,
+	            const curve::time_t &now,
+	            const EventClass::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);
+
+#if WITH_NCURSES
+		if (state->enable_gui) {
+			static int cnt = 0;
+			mvprintw(21, 22, "Panel hit [%i]", ++cnt);
+		}
+		else {
+#endif
+			log::log(INFO << "Panel hit at " << now);
+#if WITH_NCURSES
+		}
+#endif
+
+		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);
+			mvprintw(21, 18, "1");
+		}
+		else if (pos[0] >= state->display_boundary[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);
+			mvprintw(21, 18, "2");
+		}
+		else if (pos[0] >= state->display_boundary[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((state->display_boundary[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] = state->display_boundary[0];
+		}
+		else {
+			hit_pos[0] = 0;
+		}
+
+		state->ball->position->set_last(now + ty, hit_pos);
+	}
+
+	curve::time_t predict_invoke_time(const std::shared_ptr<EventTarget> &target,
+	                                  const std::shared_ptr<State> &gstate,
+	                                  const curve::time_t &now) override {
+
+		auto positioncurve = std::dynamic_pointer_cast<curve::Continuous<util::Vector2d>>(target);
+		auto state = std::dynamic_pointer_cast<PongState>(gstate);
+
+		auto speed = state->ball->speed->get(now);
+		auto pos = positioncurve->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((state->display_boundary[0] - pos[0]) / speed[0]);
+		}
+		else if (speed[0] < 0) {
+			ty = curve::time_t::from_double(pos[0] / -speed[0]);
+		}
+
+#if WITH_NCURSES
+		if (state->enable_gui) {
+			mvprintw(21, 40, "PANEL REFLECT AT %f NEXT %f", now.to_double(), (now + ty).to_double());
+			mvprintw(21, 18, "2");
+		}
+		else {
+#endif
+			log::log(INFO << "predicting panel reflection at t=" << now
+			         << ", next reflection at t=" << (now + ty));
+#if WITH_NCURSES
+		}
+#endif
+
+		auto hit_pos = pos + speed * ty.to_double();
+		if (speed[0] > 0) {
+			hit_pos[0] = state->display_boundary[0];
+		}
+		else {
+			hit_pos[0] = 0;
+		}
+
+		ENSURE(hit_pos[0] >= 0, "hit position x must be positive");
+
+		return now + ty;
+	}
+};
+
+
+class ResetGame : public OnceEventClass {
+public:
+	ResetGame ()
+		:
+		OnceEventClass("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<State> &gstate,
+	            const curve::time_t &now,
+	            const EventClass::param_map &/*param*/) override {
+
+		auto state = std::dynamic_pointer_cast<PongState>(gstate);
+
+		// Check if the condition still applies
+		{
+			auto pos = state->ball->position->get(now);
+			if (pos[0] > 0 && pos[0] < state->display_boundary[0]) {
+				// the gamestate is still valid - there is no need to reset
+				return;
+			}
+		}
+
+		// move ball to the center
+		state->ball->position->set_last(now - curve::time_t::from_double(0.1),
+		                                state->ball->position->get(now));
+		state->ball->position->set_last(now, state->display_boundary * 0.5);
+
+		// move paddles to center
+		state->p1->position->set_last(now, state->display_boundary[1] / 2);
+		state->p2->position->set_last(now, state->display_boundary[1] / 2);
+
+		float dirx = (rng::random() % 2) ? 1 : -1;
+		float diry = (rng::random() % 2) ? 1 : -1;
+		auto init_speed = util::Vector2d(
+			dirx * (1.5 + (rng::random() % 100) / 3.f),
+			diry * (0.3 + (rng::random() % 100) / 18.f)
+		);
+
+		state->ball->speed->set_last(now, init_speed);
+		auto pos = state->ball->position->get(now);
+
+#if WITH_NCURSES
+		if (state->enable_gui) {
+			static int cnt = 0;
+			mvprintw(20, 20, "Reset. Speed %f | %f POS %f | %f [%i]",
+			         init_speed[0],
+			         init_speed[1],
+			         pos[0],
+			         pos[1],
+			         ++cnt);
+		}
+		else {
+#endif
+			log::log(INFO << "Game was reset.");
+#if WITH_NCURSES
+		}
+#endif
+
+		curve::time_t ty = 0;
+
+		// calculate the wall-hit-times
+		if (init_speed[1] > 0) {
+			ty = curve::time_t::from_double((state->display_boundary[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((state->display_boundary[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<EventTarget> &/*target*/,
+	                                  const std::shared_ptr<State> &/*state*/,
+	                                  const curve::time_t &old_time) override {
+		return old_time;
+	}
+};
+
+
+void Physics::init(const std::shared_ptr<PongState> &gstate,
+                   const std::shared_ptr<Loop> &loop,
+                   const curve::time_t &now) {
+
+	auto state = std::dynamic_pointer_cast<PongState>(gstate);
+
+	if (not state->enable_gui) {
+		log::log(INFO << "Physics initialization");
+	}
+
+	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::process_input(const std::shared_ptr<PongState> &state,
+                            const std::shared_ptr<PongPlayer> &player,
+                            const std::vector<PongEvent> &events,
+                            const std::shared_ptr<Loop> &mgr,
+                            const curve::time_t &now) {
+
+	// seconds into the future
+	constexpr static auto predicted_movement_time = curve::time_t::from_double(5.0);
+
+	// lines per second
+	constexpr static double movement_speed = 8.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);
+
+			// 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 > state->display_boundary[1]) {
+					move_stop_guess = now + ((state->display_boundary[1] - current_pos) / movement_speed);
+					new_pos = state->display_boundary[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;
+
+				//if (player->state->get(now).state == PongEvent::LOST) {
+				//	state->ball.position->set_last(now, state.display_boundary * 0.5);
+				//}
+				//update_ball(state, now, init_recursion_limit);
+				//break;
+
+			default:
+				break;
+			}
+		}
+	}
+}
+
+
+void Physics::reset(const std::shared_ptr<State> &gstate,
+                    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);
+}
+
+} // openage::event::demo
diff --git a/libopenage/event/demo/physics.h b/libopenage/event/demo/physics.h
new file mode 100644
index 0000000000..1f64aef50d
--- /dev/null
+++ b/libopenage/event/demo/physics.h
@@ -0,0 +1,34 @@
+// Copyright 2015-2018 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;
+
+namespace demo {
+
+class Physics {
+public:
+	static void init(const std::shared_ptr<PongState> &,
+	                 const std::shared_ptr<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<Loop> &mgr,
+	                   const curve::time_t &now);
+
+	static void reset(const std::shared_ptr<State> &,
+	                  Loop &mgr,
+	                  const curve::time_t &);
+};
+
+}} // openage::event::demo
diff --git a/libopenage/event/event.cpp b/libopenage/event/event.cpp
new file mode 100644
index 0000000000..a670e5c332
--- /dev/null
+++ b/libopenage/event/event.cpp
@@ -0,0 +1,37 @@
+// Copyright 2017-2018 the openage authors. See copying.md for legal info.
+
+#include "event.h"
+
+#include "eventtarget.h"
+#include "eventclass.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,
+             const EventClass::param_map &params)
+	:
+	params(params),
+	target{target},
+	eventclass{eventclass},
+	myhash{
+		util::hash_combine(std::hash<size_t>()(target->id()),
+		                   std::hash<std::string>()(eventclass->id()))
+	} {}
+
+
+void Event::depend_on(const std::shared_ptr<EventTarget> &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());
+
+	dependency->add_dependent(this->shared_from_this());
+}
+
+
+} // openage::event
diff --git a/libopenage/event/event.h b/libopenage/event/event.h
new file mode 100644
index 0000000000..27dbfc031a
--- /dev/null
+++ b/libopenage/event/event.h
@@ -0,0 +1,85 @@
+// Copyright 2017-2018 the openage authors. See copying.md for legal info.
+
+#pragma once
+
+#include <memory>
+
+#include "eventclass.h"
+#include "../curve/curve.h"
+
+namespace openage::event {
+
+class EventQueue;
+class EventTarget;
+
+/**
+ * The actual one event that may be called - it is used to manage the event itself.
+ * It does not need to be stored.
+ */
+class Event : public std::enable_shared_from_this<Event> {
+public:
+	Event(const std::shared_ptr<EventTarget> &trgt,
+	      const std::shared_ptr<EventClass> &eventclass,
+	      const EventClass::param_map &params);
+
+	const std::weak_ptr<EventTarget> &get_target() const {
+		return this->target;
+	}
+
+	const std::shared_ptr<EventClass> &get_eventclass() const {
+		return this->eventclass;
+	}
+
+	/**
+	 * Reschedule will call the predict_invoke_time method to initiate a reschedule
+	 * for the event it uses the reference_time as base for its calculation
+	 */
+	void reschedule(const curve::time_t reference_time);
+
+	size_t hash() const {
+		return this->myhash;
+	}
+
+	const curve::time_t &get_time() const {
+		return this->time;
+	}
+
+	void set_time(const curve::time_t &t) {
+		this->time = t;
+	}
+
+	const EventClass::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.
+	 *
+	 * To be called in the EventClass::setup function.
+	 */
+	void depend_on(const std::shared_ptr<EventTarget> &dependency);
+
+	curve::time_t last_triggered = 0;
+
+private:
+	/**
+	 * Parameters for the event (determined by its EventClass)
+	 */
+	EventClass::param_map params;
+
+	/** The actor that has the event */
+	std::weak_ptr<EventTarget> target;
+
+	/** Type of this event. */
+	std::shared_ptr<EventClass> eventclass;
+
+	/** Time this event occurs/occured */
+	curve::time_t time;
+
+	/** Precalculated std::hash for the event */
+	size_t myhash;
+};
+
+
+} // openage::event
diff --git a/libopenage/event/eventclass.cpp b/libopenage/event/eventclass.cpp
new file mode 100644
index 0000000000..35cbff371f
--- /dev/null
+++ b/libopenage/event/eventclass.cpp
@@ -0,0 +1,48 @@
+// Copyright 2017-2018 the openage authors. See copying.md for legal info.
+
+#include "eventclass.h"
+
+#include "event.h"
+#include "eventtarget.h"
+
+#include "../log/log.h"
+
+namespace openage::event {
+
+
+EventClass::EventClass(const std::string &name, const EventClass::trigger_type &type) :
+	type{type},
+	_id{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/eventclass.h b/libopenage/event/eventclass.h
new file mode 100644
index 0000000000..b203b7b1b3
--- /dev/null
+++ b/libopenage/event/eventclass.h
@@ -0,0 +1,218 @@
+// Copyright 2017-2018 the openage authors. See copying.md for legal info.
+
+#pragma once
+
+#include "../curve/curve.h"
+
+
+#include <any>
+#include <memory>
+#include <string>
+#include <unordered_map>
+
+
+namespace openage::event {
+
+class Event;
+class Loop;
+class EventTarget;
+class State;
+
+
+/**
+ * A eventclass has to be implemented for every type of event that exists.
+ * It determines what the event means and how it is handled.
+ */
+class EventClass {
+public:
+	/**
+	 * Available types for the event class:
+	 * These decide when an event of this event class will be executed.
+	 */
+	enum class trigger_type {
+		/**
+		 * Such events are emitted when a modification is done on a target.
+		 * The execution time is calculated from the modification time and custom code.
+		 */
+		DEPENDENCY,
+
+		/**
+		 * Like DEPENDENCY, but does not use a recalculated time,
+		 * instead uses the change-time only.
+		 * Behaves exactly like DEPENDENCY, if the DEPENDENCY-event is in the same
+		 * execution frame.
+		 */
+		DEPENDENCY_IMMEDIATELY,
+
+		/**
+		 * Will be executed when the target trigger() function is called.
+		 */
+		TRIGGER,
+
+		/**
+		 * Will be triggered unconditionally at the set time, "at" is the
+		 * time that was set as return of predict_invoke_time. This event will
+		 * be issued again until predict_invoke_time returns min(). To execute
+		 * Something only once (i.E. triggered somewhere from the logic and
+		 * not based on time, use ONCE
+		 */
+		REPEAT,
+
+		/**
+		 * Will be triggered only once, but until it is triggered the time,
+		 * when this should happen can be recalculated again and again using
+		 * the predict_invoke_time method.
+		 */
+		ONCE,
+	};
+
+	/**
+	 * Storage for parameters for an event class.
+	 */
+	class param_map {
+	public:
+		using map_t = std::unordered_map<std::string, std::any>;
+
+		param_map() {}
+		param_map(std::initializer_list<map_t::value_type> l) : map(l) {}
+		param_map(const map_t &map) : map{std::move(map)} {}
+
+		/**
+		 * Returns the value, if it exists and is the right type.
+		 * defaultval if not.
+		 */
+		template<typename T>
+		T get(const std::string &key, const T &defaultval=T()) const {
+			auto it = this->map.find(key);
+			if (it != this->map.end() && this->check_type<T>(it)) {
+				return std::any_cast<T>(it->second);
+			} else {
+				return defaultval;
+			}
+		}
+
+		/**
+		 * Check if the map contains the given key.
+		 */
+		bool contains(const std::string &key) const {
+			return map.find(key) != map.end();
+		}
+
+		/**
+		 * Check if the type of a map entry is correct.
+		 */
+		template<typename Type>
+		bool check_type(const std::string &key) const {
+			auto it = map.find(key);
+			if (it != map.end()) {
+				return this->check_type<Type>(it);
+			}
+			return false;
+		}
+
+	private:
+		template<typename T>
+		bool check_type(const map_t::const_iterator &it) const {
+			return it->second.type() == typeid(T);
+		}
+
+		/**
+		 * Data storage.
+		 */
+		const map_t map;
+	};
+
+	/**
+	 * Constructor to be constructed with the unique identifier
+	 */
+	EventClass(const std::string &name, const trigger_type &type);
+
+	virtual ~EventClass() = default;
+
+	/**
+	 * The event type this event class represents.
+	 */
+	const trigger_type type;
+
+	/**
+	 * Return a unique identifier.
+	 */
+	const std::string &id();
+
+	/**
+	 * Called for each event that is created for this EventClass.
+	 * The job of the setup function is to add all dependencies with other event
+	 * targets found in state.
+	 */
+	virtual void setup_event(const std::shared_ptr<Event> &event,
+	                         const std::shared_ptr<State> &state) = 0;
+
+	/**
+	 * This method implements the effects of the event.
+	 * It will be called at the time that was determined by `predict_invoke_time`.
+	 *
+	 * Called from the Loop.
+	 */
+	virtual void invoke(Loop &loop,
+	                    const std::shared_ptr<EventTarget> &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.
+	 * This is called whenever one of the set up dependencies was changed,
+	 * or when a REPEAT event was executed.
+	 *
+	 * @param target: the target the event was created for
+	 * @param state: the state this shall work on
+	 * @param at: the time when the change happened, from there on it shall be
+	 *            calculated onwards
+	 *
+	 * If the event is obsolete, return <time_t>::min().
+	 *
+	 * If the time is lower than the previous time,
+	 * 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,
+	                                          const std::shared_ptr<State> &state,
+	                                          const curve::time_t &at) = 0;
+
+private:
+	/**
+	 * String identifier for this event class.
+	 */
+	std::string _id;
+};
+
+
+// helper classes
+
+class DependencyEventClass : public EventClass {
+public:
+	DependencyEventClass(const std::string &name);
+};
+
+class DependencyImmediatelyEventClass : public EventClass {
+public:
+	DependencyImmediatelyEventClass(const std::string &name);
+};
+
+class TriggerEventClass : public EventClass {
+public:
+	TriggerEventClass(const std::string &name);
+};
+
+class RepeatEventClass : public EventClass {
+public:
+	RepeatEventClass(const std::string &name);
+};
+
+class OnceEventClass : public EventClass {
+public:
+	OnceEventClass(const std::string &name);
+};
+
+
+} // openage::event
diff --git a/libopenage/event/eventfilter.cpp b/libopenage/event/eventfilter.cpp
new file mode 100644
index 0000000000..829519ad36
--- /dev/null
+++ b/libopenage/event/eventfilter.cpp
@@ -0,0 +1,17 @@
+// Copyright 2018-2018 the openage authors. See copying.md for legal info.
+
+
+#include "eventfilter.h"
+
+namespace openage::event {
+
+EventFilter::EventFilter(const std::function<bool(const std::shared_ptr<EventTarget> &)> &filter)
+	:
+	filter{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
new file mode 100644
index 0000000000..6bfb30f7c5
--- /dev/null
+++ b/libopenage/event/eventfilter.h
@@ -0,0 +1,27 @@
+// Copyright 2017-2018 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(const 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/eventqueue.cpp b/libopenage/event/eventqueue.cpp
new file mode 100644
index 0000000000..68a08764d8
--- /dev/null
+++ b/libopenage/event/eventqueue.cpp
@@ -0,0 +1,284 @@
+// Copyright 2017-2018 the openage authors. See copying.md for legal info.
+
+#include "eventqueue.h"
+
+#include <algorithm>
+
+#include "event.h"
+#include "eventclass.h"
+#include "eventtarget.h"
+#include "../log/log.h"
+
+
+namespace openage::event {
+
+std::weak_ptr<Event> EventQueue::create_event(const std::shared_ptr<EventTarget> &trgt,
+                                              const std::shared_ptr<EventClass> &cls,
+                                              const std::shared_ptr<State> &state,
+                                              const curve::time_t &reference_time,
+                                              const EventClass::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()
+		                     ->predict_invoke_time(trgt, state, reference_time));
+
+		if (event->get_time() == std::numeric_limits<curve::time_t>::min()) {
+			return std::weak_ptr<Event>();
+		}
+		break;
+
+	case EventClass::trigger_type::DEPENDENCY_IMMEDIATELY:
+	case EventClass::trigger_type::TRIGGER:
+		event->set_time(reference_time);
+		break;
+	}
+
+	log::log(DBG << "Queue: inserting event " << event->get_eventclass()->id() <<
+	         " into queue to be executed at t=" << event->get_time());
+
+	auto &queue = this->select_queue(event->get_eventclass()->type);
+	queue.emplace_back(event);
+
+	return event;
+}
+
+
+EventQueue::EventQueue()
+	:
+	changes(&changeset_A),
+	future_changes(&changeset_B) {}
+
+
+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));
+
+	// 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");
+
+				// Save the element
+				OnChangeElement e = *it;
+				e.time = changed_at;
+
+				// delete it from the container and readd it
+				it = this->changes->erase(it);
+				it = this->changes->insert(it, e);
+			}
+			else {
+				// this change is to be ignored
+				log::log(DBG << "Queue: skipping change for " << event->get_eventclass()->id()
+				         << " at " << changed_at
+				         << " because there was already a better 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()
+			         << " 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);
+	}
+
+	event->last_triggered = changed_at;
+}
+
+
+void EventQueue::remove(const std::shared_ptr<Event> &evnt) {
+	auto &queue = this->select_queue(evnt->get_eventclass()->type);
+	auto it = std::find(std::begin(queue), std::end(queue), evnt);
+
+	if (it != queue.end()) {
+		queue.erase(it);
+	}
+}
+
+
+std::deque<std::shared_ptr<Event>> &EventQueue::select_queue(EventClass::trigger_type type) {
+	switch(type) {
+	case EventClass::trigger_type::DEPENDENCY:
+		return this->dependency_queue;
+
+	case EventClass::trigger_type::DEPENDENCY_IMMEDIATELY:
+		return this->dependency_immediately_queue;
+
+	case EventClass::trigger_type::TRIGGER:
+		return this->trigger_queue;
+
+	case EventClass::trigger_type::REPEAT:
+	case EventClass::trigger_type::ONCE:
+	default:
+		return this->event_queue;
+	}
+}
+
+
+void EventQueue::update(const std::shared_ptr<Event> &evnt) {
+	decltype(this->event_queue)::iterator it = std::find(std::begin(this->event_queue),
+	                                                     std::end(this->event_queue),
+	                                                     evnt);
+
+	if (it != this->event_queue.end()) { // we only want to update the pending queue
+		int dir = 0;
+
+		{
+			auto nxt = std::next(it);
+			if (nxt != std::end(this->event_queue) and
+			    (*nxt)->get_time() < (*it)->get_time()) {
+				dir -= 1;
+			}
+			auto prv = std::prev(it);
+			if (it != std::begin(this->event_queue) and
+			    (*prv)->get_time() > (*it)->get_time()) {
+				dir += 1;
+			}
+			// dir is now one of these values:
+			// 0: the element is perfectly placed
+			// +: the elements time is too low for its position, move forward
+			// -: the elements time is too high for its position, move backwards
+		}
+
+		if (dir == 0) {
+			// do nothing
+		}
+		else if (dir > 0) {
+			auto e = *it;
+			it = this->event_queue.erase(it);
+			while (it != this->event_queue.begin()
+			       && evnt->get_time() < (*std::prev(it))->get_time()) {
+				it--;
+			}
+			this->event_queue.insert(it, e);
+		}
+		else if (dir < 0) {
+			auto e = *it;
+			it = this->event_queue.erase(it);
+			while (it != this->event_queue.end()
+			       && evnt->get_time() > (*std::prev(it))->get_time()) {
+				it++;
+			}
+			this->event_queue.insert(it, e);
+		}
+
+		log::log(DBG << "Queue: readded Element: " << evnt->get_eventclass()->id()
+		         << " at t=" << evnt->get_time());
+	}
+	else {
+		it = std::find_if(
+			std::begin(this->event_queue),
+			std::end(this->event_queue),
+			[&evnt] (const std::shared_ptr<Event> &e) {
+				return e->get_time() > evnt->get_time();
+			}
+		);
+
+		this->event_queue.insert(it, evnt);
+		log::log(DBG << "Queue: inserted Element: " << evnt->get_eventclass()->id()
+		         << " at t=" << evnt->get_time());
+	}
+}
+
+
+void EventQueue::readd(const std::shared_ptr<Event> &evnt) {
+	auto &container = this->select_queue(evnt->get_eventclass()->type);
+
+	auto it = std::find_if(
+		std::begin(container),
+		std::end(container),
+		[&evnt](const std::shared_ptr<Event> &element) {
+			return element->get_time() < evnt->get_time();
+		}
+	);
+	container.insert(it, evnt);
+}
+
+
+const std::deque<std::shared_ptr<Event>> &EventQueue::get_event_queue() const {
+	return this->event_queue;
+}
+
+
+std::shared_ptr<Event> EventQueue::take_event(const curve::time_t &max_time) {
+	if (this->event_queue.size() == 0) {
+		return nullptr;
+	}
+
+	std::shared_ptr<Event> event = this->event_queue.front();
+
+	// check if this event should be processed
+	// we take any event that happens <= max_time
+	if (event->get_time() <= max_time) {
+		// remove the event from the queue
+		this->event_queue.pop_front();
+
+		return event;
+	}
+	else {
+		return nullptr;
+	}
+}
+
+
+const EventQueue::change_set &EventQueue::get_changes() const {
+	return *this->changes;
+}
+
+
+void EventQueue::clear_changes() {
+	this->changes->clear();
+}
+
+
+void EventQueue::swap_changesets() {
+	std::swap(this->changes, this->future_changes);
+}
+
+
+EventQueue::OnChangeElement::OnChangeElement(const std::shared_ptr<Event> &evnt,
+                                             const curve::time_t &time)
+	:
+	time{time},
+	evnt{evnt},
+	hash{evnt->hash()} {}
+
+
+size_t EventQueue::OnChangeElement::Equal::operator()(const OnChangeElement& left,
+                                                      const OnChangeElement& 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()) {
+			return true;
+		}
+	} else {
+		return false;
+	}
+
+	auto left_trgt = left_evnt->get_target().lock();
+	auto right_trgt = right_evnt->get_target().lock();
+
+	return left_trgt && right_trgt &&
+	left_trgt->id() == right_trgt->id();
+}
+
+
+} // namespace openage::event
diff --git a/libopenage/event/eventqueue.h b/libopenage/event/eventqueue.h
new file mode 100644
index 0000000000..1500c7b1ac
--- /dev/null
+++ b/libopenage/event/eventqueue.h
@@ -0,0 +1,158 @@
+// Copyright 2017-2018 the openage authors. See copying.md for legal info.
+
+#pragma once
+
+#include <deque>
+#include <memory>
+#include <unordered_set>
+
+#include "eventclass.h"
+#include "../curve/curve.h"
+
+namespace openage::event {
+
+class Event;
+class Loop;
+class EventTarget;
+
+/**
+ * The core event class for execution and execution dependencies.
+ */
+class EventQueue {
+public:
+
+	class OnChangeElement {
+	public:
+		OnChangeElement(const std::shared_ptr<Event> &evnt,
+		                const curve::time_t &time);
+
+		curve::time_t time;
+		std::weak_ptr<Event> evnt;
+		const size_t hash;
+
+		class Hasher : public std::unary_function<OnChangeElement, size_t> {
+		public:
+			size_t operator()(const OnChangeElement& e) const {
+				return e.hash;
+			}
+		};
+
+		class Equal : public std::unary_function<OnChangeElement, size_t> {
+		public:
+			size_t operator()(const OnChangeElement& left,
+			                  const OnChangeElement& right) const;
+		};
+	};
+
+	/**
+	 * Type for the set to store changes to track.
+	 */
+	using change_set = std::unordered_set<OnChangeElement,
+	                                      OnChangeElement::Hasher,
+	                                      OnChangeElement::Equal>;
+
+
+	EventQueue();
+
+	/**
+	 * Add an event for a specified target
+	 *
+	 * 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!
+	 */
+	std::weak_ptr<Event> create_event(const std::shared_ptr<EventTarget> &eventtarget,
+	                                  const std::shared_ptr<EventClass> &eventclass,
+	                                  const std::shared_ptr<State> &state,
+	                                  const curve::time_t &reference_time,
+	                                  const EventClass::param_map &params);
+
+	/**
+	 * Remove the given event from the queue.
+	 */
+	void remove(const std::shared_ptr<Event> &evnt);
+
+	/**
+	 * The event may be already part of the execution queue,
+	 * so update it, if it shall be executed in the future.
+	 */
+	void update(const std::shared_ptr<Event> &);
+
+	/**
+	 * The event was just removed.
+	 */
+	void readd(const std::shared_ptr<Event> &);
+
+	/**
+	 * An event target has changed, and the event shall be retriggered
+	 */
+	void add_change(const std::shared_ptr<Event> &event,
+	                const curve::time_t &changed_at);
+
+	/**
+	 * Get an accessor to the running queue for state output purpose.
+	 */
+	const std::deque<std::shared_ptr<Event>> &get_event_queue() const;
+
+	/**
+	 * Obtain the next event from the `event_queue` that happens before `<= max_time`.
+	 */
+	std::shared_ptr<Event> take_event(const curve::time_t &max_time);
+
+	/**
+	 * Get the change_set to process changes.
+	 */
+	const change_set &get_changes() const;
+
+	/**
+	 * All changes (fetched with `get_changes`) have been processed,
+	 * so we can clear the change_set.
+	 */
+	void clear_changes();
+
+	/**
+	 * Swap the `changes` and `future_changes`.
+	 */
+	void swap_changesets();
+
+private:
+
+	// Implement double buffering around changesets, that we do not run into deadlocks
+	// those point to the `changeset_A` and `changeset_B`.
+	change_set *changes;
+	change_set *future_changes;
+
+	// storage for the double buffer in `changes` and `future_changes`.
+	change_set changeset_A;
+	change_set changeset_B;
+
+	/**
+	 * Get a reference to the correct event queue by
+	 * the given trigger type.
+	 */
+	std::deque<std::shared_ptr<Event>> &select_queue(EventClass::trigger_type type);
+
+	/**
+	 * Will trigger itself and add to the queue.
+	 */
+	std::deque<std::shared_ptr<Event>> dependency_queue;
+
+	/**
+	 * Will trigger itself and add to the queue.
+	 */
+	std::deque<std::shared_ptr<Event>> dependency_immediately_queue;
+
+	/**
+	 * Events that fire only when triggered.
+	 */
+	std::deque<std::shared_ptr<Event>> trigger_queue;
+
+	/**
+	 * Type::ONCE is only inserted into the queue.
+	 */
+	std::deque<std::shared_ptr<Event>> event_queue;
+};
+
+} // openage::event
diff --git a/libopenage/event/eventtarget.cpp b/libopenage/event/eventtarget.cpp
new file mode 100644
index 0000000000..3555292c5e
--- /dev/null
+++ b/libopenage/event/eventtarget.cpp
@@ -0,0 +1,107 @@
+// 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/eventtarget.h b/libopenage/event/eventtarget.h
new file mode 100644
index 0000000000..e633427434
--- /dev/null
+++ b/libopenage/event/eventtarget.h
@@ -0,0 +1,76 @@
+// Copyright 2017-2018 the openage authors. See copying.md for legal info.
+
+#pragma once
+
+#include "../curve/curve.h"
+
+#include <functional>
+#include <list>
+#include <memory>
+
+namespace openage::event {
+
+class Event;
+class Loop;
+class EventClass;
+
+/**
+ * Every Object in the gameworld that wants to be targeted by events or as
+ * dependency for events, has to implement this class.
+ */
+class EventTarget {
+public:
+	/** Give a unique event system identifier for the entity */
+	virtual size_t id() 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
+	 * 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,
+	            single_change_notifier parent_notifier=nullptr)
+		:
+		loop{loop},
+		parent_notifier{parent_notifier} {}
+public:
+	virtual ~EventTarget() = default;
+
+	/**
+	 * Add a dependent class, that should be notified when dependency is called
+	 */
+	void add_dependent(const std::weak_ptr<Event> &event);
+
+	/**
+	 * For debugging: print the dependent eventclass ids as log messages.
+	 */
+	void show_dependents() const;
+
+protected:
+	/**
+	 * Call this whenever some data in the target changes.
+	 * This triggers the reevaluation of dependent events.
+	 */
+	void changes(const curve::time_t &change_time);
+
+	/**
+	 * Call this when a keyframe in the underlying container was passed by in time.
+	 */
+	void trigger(const curve::time_t &last_valid_time);
+
+private:
+	/** Event loop this target is registered to */
+	std::shared_ptr<Loop> loop;
+
+	/** List of events that depend on this target */
+	std::list<std::weak_ptr<Event>> dependents;
+
+	single_change_notifier parent_notifier;
+};
+
+} // openage::event
diff --git a/libopenage/event/loop.cpp b/libopenage/event/loop.cpp
new file mode 100644
index 0000000000..c3bcfc2ee8
--- /dev/null
+++ b/libopenage/event/loop.cpp
@@ -0,0 +1,198 @@
+// Copyright 2017-2018 the openage authors. See copying.md for legal info.
+
+#include "loop.h"
+
+#include "event.h"
+#include "eventclass.h"
+#include "eventqueue.h"
+#include "eventtarget.h"
+
+#include "../log/log.h"
+
+
+namespace openage::event {
+
+
+void Loop::add_event_class(const std::shared_ptr<EventClass> &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) {
+	auto it = classstore.find(name);
+	if (it == classstore.end()) {
+		throw Error{MSG(err) << "Trying to subscribe to eventclass "
+		                     << name << ", which does not exist."};
+	}
+	return this->queue.create_event(target, it->second, state, reference_time, params);
+}
+
+
+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) {
+
+	auto it = this->classstore.find(eventclass->id());
+	if (it == this->classstore.end()) {
+		auto res = this->classstore.insert(std::make_pair(eventclass->id(), eventclass));
+		if (res.second) {
+			it = res.first;
+		} else {
+			throw Error{ERR << "could not insert eventclass into class store"};
+		}
+	}
+
+	return this->queue.create_event(target, it->second, state, reference_time, params);
+}
+
+
+void Loop::reach_time(const curve::time_t &max_time,
+                      const std::shared_ptr<State> &state) {
+
+	// TODO detect infinite loops (is this a halting problem?)
+	// this happens when the events don't settle:
+	// at least one processed event adds another event so
+	// the queue never stops adding changes
+	// simple "solution": abort after over 9000 attempts.
+
+	int cnt = 0;
+	int attempts = 0;
+	do {
+		log::log(DBG << "Loop: Attempt " << attempts << " to reach t=" << max_time);
+		this->update_changes(state);
+		cnt = this->execute_events(max_time, state);
+
+		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);
+
+	// Swap in the end of the execution, else we might skip changes that happen
+	// in the main loop for one frame - which is bad btw.
+	this->queue.swap_changesets();
+	log::log(DBG << "Loop: t=" << max_time << " was reached! ========");
+}
+
+
+int Loop::execute_events(const curve::time_t &time_until,
+                         const std::shared_ptr<State> &state) {
+
+	log::log(DBG << "Loop: Pending events in the queue (# = "
+	         << this->queue.get_event_queue().size() << "):");
+
+	{
+		size_t i = 0;
+		for (const auto &e : this->queue.get_event_queue()) {
+			log::log(DBG << "  event "
+			         << i << ": t=" << e->get_time() << ": " << e->get_eventclass()->id());
+			i++;
+		}
+	}
+
+	int cnt = 0;
+
+	while (true) {
+		// fetch an event from the queue that happens before <= time_until
+		std::shared_ptr<Event> event = this->queue.take_event(time_until);
+		if (event == nullptr) {
+			break;
+		}
+
+		auto target = event->get_target().lock();
+
+		if (target) {
+			this->active_event = event;
+
+			log::log(DBG << "Loop: invoking event \"" << event->get_eventclass()->id()
+			         << "\" on target \"" << target->id()
+			         << "\" for time t=" << event->get_time());
+
+			// apply the event effects
+			event->get_eventclass()->invoke(
+				*this, target, state,
+				event->get_time(), event->get_params()
+			);
+
+			this->active_event = nullptr;
+			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(
+					target, state, event->get_time()
+				);
+				if (new_time != std::numeric_limits<curve::time_t>::min()) {
+					event->set_time(new_time);
+					this->queue.readd(event);
+				}
+			}
+		}
+		else {
+			// The element was already removed from the queue, so we can safely
+			// kill it by ignoring it.
+		}
+	}
+	return cnt;
+}
+
+
+void Loop::update_changes(const std::shared_ptr<State> &state) {
+
+	log::log(DBG << "Loop: " << this->queue.get_changes().size()
+	         << " target changes have to be processed");
+
+	size_t i = 0;
+	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?
+
+				if (target) {
+					curve::time_t new_time = evnt->get_eventclass()
+					                             ->predict_invoke_time(target, state, change.time);
+					log::log(DBG << "Loop: rescheduled event of '"
+					         << evnt->get_eventclass()->id()
+					         << "' on target '" << target->id()
+					         << "' at time t=" << change.time
+					         << " to NEW TIME t=" << new_time);
+
+					if (new_time != std::numeric_limits<curve::time_t>::min()) {
+						evnt->set_time(new_time);
+						this->queue.update(evnt);
+					}
+				}
+			} break;
+
+			case EventClass::trigger_type::TRIGGER:
+			case EventClass::trigger_type::DEPENDENCY_IMMEDIATELY:
+				evnt->set_time(change.time);
+				this->queue.update(evnt);
+				break;
+
+			case EventClass::trigger_type::REPEAT:
+				break;
+			}
+		}
+	}
+
+	this->queue.clear_changes();
+}
+
+} // namespace openage::event
diff --git a/libopenage/event/loop.h b/libopenage/event/loop.h
new file mode 100644
index 0000000000..d0630f4ed4
--- /dev/null
+++ b/libopenage/event/loop.h
@@ -0,0 +1,147 @@
+// Copyright 2017-2018 the openage authors. See copying.md for legal info.
+
+#pragma once
+
+#include <functional>
+#include <list>
+#include <memory>
+#include <unordered_map>
+
+#include "../curve/curve.h"
+#include "eventqueue.h"
+#include "eventfilter.h"
+#include "event.h"
+#include "../log/log.h"
+
+namespace openage::event {
+
+// The demo wants to display internal details
+namespace demo {
+int curvepong();
+}
+
+class Event;
+class EventTarget;
+class State;
+
+
+
+/**
+ * The core class to manage event class and targets.
+ */
+class Loop {
+
+	// because the demo function displays internal info.
+	friend int demo::curvepong();
+
+public:
+	/** register a new event class */
+	void add_event_class(const std::shared_ptr<EventClass> &cls);
+
+	/**
+	 * Add a new Event to the queue.
+	 * The event is from the given class (name) and is invoked for a
+	 * target in a state.
+	 *
+	 * 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({}));
+
+	/**
+	 * This will generate a new randomly named eventclass 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> &);
+
+	/**
+	 * Execute all events that are registered until a certain point in time.
+	 */
+	void reach_time(const curve::time_t &max_time,
+	                   const std::shared_ptr<State> &state);
+
+	/**
+	 * Register that a given event must be reevaluated at a time,
+	 * this usually happens because this event depended on an eventtarget
+	 * 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 EventQueue &get_queue() const {
+		return this->queue;
+	}
+
+private:
+	/**
+	 * Execute the events
+	 *
+	 * @returns number of events processed
+	 */
+	int execute_events(const curve::time_t &max_time,
+	                   const std::shared_ptr<State> &state);
+
+	/**
+	 * Call all the time change functions. This is constant on the state!
+	 */
+	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
+	 */
+	std::list<EventFilter> filters;
+
+	/**
+	 * All events are enqueued here.
+	 */
+	EventQueue queue;
+
+	/**
+	 * The currently processed event.
+	 * 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/state.cpp b/libopenage/event/state.cpp
new file mode 100644
index 0000000000..11d3de8aa0
--- /dev/null
+++ b/libopenage/event/state.cpp
@@ -0,0 +1,7 @@
+// Copyright 2018-2018 the openage authors. See copying.md for legal info.
+
+#include "state.h"
+
+namespace openage::event {
+
+} // openage::event
diff --git a/libopenage/event/state.h b/libopenage/event/state.h
new file mode 100644
index 0000000000..ab3acfd0aa
--- /dev/null
+++ b/libopenage/event/state.h
@@ -0,0 +1,19 @@
+// Copyright 2018-2018 the openage authors. See copying.md for legal info.
+
+#pragma once
+
+#include <memory>
+
+
+namespace openage::event {
+
+class Loop;
+
+
+class State {
+public:
+	State(const std::shared_ptr<Loop> &/*mgr*/) {}
+	virtual ~State() = default;
+};
+
+} // openage::event
diff --git a/libopenage/event/tests.cpp b/libopenage/event/tests.cpp
new file mode 100644
index 0000000000..ce6f6752fa
--- /dev/null
+++ b/libopenage/event/tests.cpp
@@ -0,0 +1,557 @@
+// Copyright 2017-2018 the openage authors. See copying.md for legal info.
+
+#include <iostream>
+#include <cstring> // for strcmp
+
+#include "../testing/testing.h"
+#include "../log/log.h"
+
+#include "loop.h"
+#include "event.h"
+#include "eventtarget.h"
+#include "state.h"
+
+
+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 {
+		const int _id;
+	public:
+		TestObject(const std::shared_ptr<Loop> &loop, int id)
+			:
+			EventTarget(loop),
+			_id{id},
+			number(0) {}
+
+		void set_number(int number, const curve::time_t &time) {
+			this->number = number;
+			this->changes(time + curve::time_t::from_double(1));
+		}
+
+		size_t id() const override {
+			return _id;
+		}
+
+		void test_trigger(const curve::time_t &time) {
+			this->trigger(time);
+		}
+
+		int number;
+	};
+
+	TestState(const std::shared_ptr<Loop> &loop)
+		:
+		State(loop),
+		objectA(std::make_shared<TestObject>(loop, 0)) ,
+		objectB(std::make_shared<TestObject>(loop, 1)) {}
+
+	std::shared_ptr<TestObject> objectA;
+	std::shared_ptr<TestObject> objectB;
+
+	struct traceelement {
+		traceelement(const std::string &event, curve::time_t time)
+			:
+			time{time},
+			name{event} {}
+
+		curve::time_t time;
+		std::string name;
+	};
+
+	std::list<traceelement> trace;
+
+	void log_dbg() {
+		log::log(DBG << "Trace: ");
+		for (const auto &e : this->trace) {
+			log::log(DBG << "T: " << e.time << ": " << e.name);
+		}
+	}
+};
+
+
+class TestEventClass : public EventClass {
+	int idx;
+public:
+	TestEventClass(const std::string &name, int idx)
+		:
+		EventClass(name, EventClass::trigger_type::DEPENDENCY),
+		idx{idx} {}
+
+	void setup_event(const std::shared_ptr<Event> &event,
+	                 const std::shared_ptr<State> &gstate) override {
+
+		auto state = std::dynamic_pointer_cast<TestState>(gstate);
+
+		switch(idx) {
+		case 0:
+			// let the modification of objectA depend on objectB
+			event->depend_on(state->objectB);
+			break;
+		case 1:
+			// let the modification of objectB depend on objectA
+			event->depend_on(state->objectA);
+			break;
+		}
+	}
+
+	void invoke(Loop &/*loop*/,
+	            const std::shared_ptr<EventTarget> &target,
+	            const std::shared_ptr<State> &gstate,
+	            const curve::time_t &time,
+	            const EventClass::param_map &/*param*/) override {
+
+		auto state = std::dynamic_pointer_cast<TestState>(gstate);
+
+		switch (idx) {
+		case 0: {
+			auto t = std::dynamic_pointer_cast<TestState::TestObject>(target);
+			state->objectA->set_number(t->number + 1, time);
+			log::log(DBG << "I am Event A. Setting number to " << state->objectA->number);
+			state->trace.emplace_back("A", time);
+		} break;
+
+		case 1: {
+			auto t = std::dynamic_pointer_cast<TestState::TestObject>(target);
+			state->objectB->set_number(t->number + 1, time);
+			log::log(DBG << "I am Event B. Setting number to " << state->objectB->number);
+			state->trace.emplace_back("B", time);
+		} break;
+		}
+	}
+
+	curve::time_t predict_invoke_time(const std::shared_ptr<EventTarget> &/*target*/,
+	                                  const std::shared_ptr<State> &/*state*/,
+	                                  const curve::time_t &at) override {
+		// TODO recalculate a hit time
+		return at + curve::time_t::from_double(2);
+	}
+};
+
+
+class TestEventClassTwo : public EventClass {
+public:
+	TestEventClassTwo(const std::string &name)
+		:
+		EventClass(name, EventClass::trigger_type::DEPENDENCY) {}
+
+	void setup_event(const std::shared_ptr<Event> &target,
+	                 const std::shared_ptr<State> &gstate) override {
+
+		auto state = std::dynamic_pointer_cast<TestState>(gstate);
+		target->depend_on(state->objectA);
+	}
+
+	void invoke(Loop &/*loop*/,
+	            const std::shared_ptr<EventTarget> &gtarget,
+	            const std::shared_ptr<State> &gstate,
+	            const curve::time_t &time,
+	            const EventClass::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);
+		state->trace.emplace_back("B", time);
+	}
+
+	curve::time_t predict_invoke_time(const std::shared_ptr<EventTarget> &/*target*/,
+	                                  const std::shared_ptr<State> &/*state*/,
+	                                  const curve::time_t &at) override {
+		// TODO recalculate a hit time
+		return at + curve::time_t::from_double(1);
+	}
+};
+
+
+class EventTypeTestClass : public EventClass {
+public:
+	EventTypeTestClass(const std::string &name, EventClass::trigger_type type)
+		:
+		EventClass(name, type) {}
+
+	void setup_event(const std::shared_ptr<Event> &event,
+	                 const std::shared_ptr<State> &gstate) override {
+
+		log::log(DBG << "EventTypeTestClass-" << this->id() << " setting up new event");
+
+		// let all events depend on objectA
+		auto state = std::dynamic_pointer_cast<TestState>(gstate);
+		event->depend_on(state->objectA);
+	}
+
+	void invoke(Loop &/*loop*/,
+	            const std::shared_ptr<EventTarget> &target,
+	            const std::shared_ptr<State> &gstate,
+	            const curve::time_t &time,
+	            const EventClass::param_map &/*param*/) override {
+
+		auto state = std::dynamic_pointer_cast<TestState>(gstate);
+
+		auto t = std::dynamic_pointer_cast<TestState::TestObject>(target);
+		log::log(DBG << "EventTypeTestClass-" << this->id() << " got called on " << t->id()
+		         << " with number " << t->number << " at t=" << time);
+
+		state->trace.emplace_back(this->id(), time);
+	}
+
+	curve::time_t predict_invoke_time(const std::shared_ptr<EventTarget> &/*target*/,
+	                                  const std::shared_ptr<State> &/*state*/,
+	                                  const curve::time_t &at) override {
+		switch(this->type) {
+		case EventClass::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:
+			TESTFAILMSG("DEPENDENCY_IMMEDIATELY does not recalculate time!");
+			return 0;
+
+		case EventClass::trigger_type::TRIGGER:
+			TESTFAILMSG("TRIGGER does not recalculate time!");
+			return 0;
+
+		case EventClass::trigger_type::REPEAT:
+			// This will force the execution every 5ms
+			return at + curve::time_t::from_double(5);
+
+		case EventClass::trigger_type::ONCE:
+			return 10;  // even if data changed it will happen at the given time!
+		}
+		return at;
+	}
+};
+
+
+void eventtrigger() {
+	log::log(DBG << "------------- [ Starting Test: Basic Ping Pong ] ------------");
+
+	// test destruction
+	std::weak_ptr<TestState> destruction_test_state;
+
+	{
+		// Test with one event class
+		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));
+
+		auto state = std::make_shared<TestState>(loop);
+		auto gstate = std::static_pointer_cast<State>(state);
+
+		destruction_test_state = state;
+
+		// One must not start the game at 0 - this leads to randomness in execution
+		loop->create_event("test_on_B", state->objectB, gstate, 1);
+		loop->create_event("test_on_A", state->objectA, gstate, 1);
+
+		// It is expected, that A and B hand over the "changed" events between each other
+		state->objectA->set_number(0, 0);
+
+		// run 10 iterations, for times 2, 4, ... 20
+		for (int i = 0; i < 10; ++i) {
+			loop->reach_time((i + 1) * 2, gstate);
+		}
+
+		state->log_dbg();
+
+		if (state->trace.size() < 6) {
+			TESTFAILMSG("not enough items collected");
+		}
+
+		int i = 0;
+
+		curve::time_t last_time = 0;
+		for (const auto &e : state->trace) {
+
+			if (last_time > e.time) {
+				TESTFAILMSG("You broke the time continuum: one shall not execute randomly!");
+			}
+
+			last_time = e.time;
+			switch(i) {
+			case 0: TESTEQUALS(e.name, "B"); TESTEQUALS(e.time, 3); break;
+			case 1: TESTEQUALS(e.name, "A"); TESTEQUALS(e.time, 6); break;
+			case 2: TESTEQUALS(e.name, "B"); TESTEQUALS(e.time, 9); break;
+			case 3: TESTEQUALS(e.name, "A"); TESTEQUALS(e.time, 12); break;
+			case 4: TESTEQUALS(e.name, "B"); TESTEQUALS(e.time, 15); break;
+			case 5: TESTEQUALS(e.name, "A"); TESTEQUALS(e.time, 18); break;
+			default: TESTFAILMSG("Too many elements in stack trace"); break;
+			}
+
+			i += 1;
+		}
+	}
+
+	if (!destruction_test_state.expired()) {
+		TESTFAILMSG("Test Failed because TestState was not automatically destructed");
+	}
+
+	log::log(DBG << "------------- [ Starting Test: Two Event Ping Pong ] ------------");
+	{
+		// Test with two event classes 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"));
+
+		auto state = std::make_shared<TestState>(loop);
+		auto gstate = std::static_pointer_cast<State>(state);
+
+		// One must not start the game at 0 - this leads to randomness in execution
+		loop->create_event("test_on_B", state->objectB, gstate, 1);
+		loop->create_event("test_on_A", state->objectA, gstate, 1);
+
+		// It is expected, that A and B hand over the "changed" events between each other
+		state->objectA->set_number(0, 1);
+
+		// run 10 iterations, for times 2, 4, ... 20
+		for (int i = 0; i < 10; ++i) {
+			loop->reach_time((i + 1) * 2, gstate);
+		}
+
+		state->log_dbg();
+
+		if (state->trace.size() < 7) {
+			TESTFAILMSG("not enough items collected");
+		}
+
+		int i = 0;
+		curve::time_t last_time = 0;
+
+		for (const auto &e : state->trace) {
+			if (last_time > e.time) {
+				TESTFAILMSG("You broke the time continuum: one shall not execute randomly!");
+			}
+
+			last_time = e.time;
+			switch(i) {
+			case 0: TESTEQUALS(e.name, "B"); TESTEQUALS(e.time, 3); break;
+			case 1: TESTEQUALS(e.name, "A"); TESTEQUALS(e.time, 6); break;
+			case 2: TESTEQUALS(e.name, "B"); TESTEQUALS(e.time, 8); break;
+			case 3: TESTEQUALS(e.name, "A"); TESTEQUALS(e.time, 11); break;
+			case 4: TESTEQUALS(e.name, "B"); TESTEQUALS(e.time, 13); break;
+			case 5: TESTEQUALS(e.name, "A"); TESTEQUALS(e.time, 16); break;
+			case 6: TESTEQUALS(e.name, "B"); TESTEQUALS(e.time, 18); break;
+			default: TESTFAILMSG("Too many elements in stack trace"); break;
+			}
+
+			i += 1;
+		}
+	}
+
+	log::log(DBG << "------------- [ Starting Test: Complex Event Types ] ------------");
+	// Now set up a more complex test to test the different event types
+	{
+		auto loop = std::make_shared<Loop>();
+
+		loop->add_event_class(std::make_shared<EventTypeTestClass>(
+			                         "object_modify",
+			                         EventClass::trigger_type::DEPENDENCY));
+		loop->add_event_class(std::make_shared<EventTypeTestClass>(
+			                         "object_modify_immediately",
+			                         EventClass::trigger_type::DEPENDENCY_IMMEDIATELY));
+		loop->add_event_class(std::make_shared<EventTypeTestClass>(
+			                         "object_trigger",
+			                         EventClass::trigger_type::TRIGGER));
+		loop->add_event_class(std::make_shared<EventTypeTestClass>(
+			                         "repeat_exec",
+			                         EventClass::trigger_type::REPEAT));
+		loop->add_event_class(std::make_shared<EventTypeTestClass>(
+			                         "once",
+			                         EventClass::trigger_type::ONCE));
+
+		auto state = std::make_shared<TestState>(loop);
+		auto gstate = std::static_pointer_cast<State>(state);
+
+		// One must not start the game at 0 - this leads to randomness in execution
+
+		// -------------------------------------
+		// Add some events to be invoked:
+
+		// execs whenever objectA is changed + 1
+		loop->create_event("object_modify", state->objectA, gstate, 4);
+
+		// execs whenever objectA is changed + 1,
+		// does not use a newly predicted time as object_modify_immediately
+		loop->create_event("object_modify_immediately", state->objectA, gstate, 1);
+
+		// execs at t=x when test_trigger(x) is invoked on objectA
+		loop->create_event("object_trigger", state->objectA, gstate, 1);
+
+		// execs periodically at t=n*5
+		loop->create_event("repeat_exec", state->objectA, gstate, 0);
+
+		// executes just once at t=10
+		loop->create_event("once", state->objectA, gstate, 10);
+
+		log::log(DBG << "##### SETUP DONE ");
+
+		// Without anything happening and until time 0, nothing will happen
+		{
+			// Expected: object_modify_immediately(t=1) [ we changed data at t=1 ]
+			loop->reach_time(0, gstate);
+			TESTEQUALS(state->trace.empty(), true);
+		}
+
+		state->objectA->set_number(0, 1);
+		{
+			// Evaluate the state until t=2
+			// Expected: object_modify_immediately(t=(1+2)),
+			// because we set the number at t=1,
+			// which then creates a invoke time of t+1 == 2
+			loop->reach_time(2, gstate);
+			TESTEQUALS(state->trace.size(), 1);
+			TESTEQUALS(state->trace.front().name, "object_modify_immediately");
+			TESTEQUALS(state->trace.front().time, 2);
+			state->trace.clear();
+		}
+
+		{
+			// executing to t=2 again should yield nothing,
+			// we reached t=2 in the step before already
+			loop->reach_time(2, gstate);
+			TESTEQUALS(state->trace.empty(), true);
+		}
+
+		log::log(DBG << "##### INIT DONE ");
+		log::log(DBG << "Triggering Keyframe at 1");
+
+		state->objectA->test_trigger(1);
+		{
+			// Expected: object_trigger(1)
+			loop->reach_time(2, gstate);
+			state->log_dbg();
+			TESTEQUALS(state->trace.size(), 1);
+			if (state->trace.front().name != "object_trigger")
+				TESTFAILMSG("Unexpected Event: " << state->trace.front().name
+				            << ", expected object_trigger");
+
+			TESTEQUALS(state->trace.front().time, 1);
+			state->trace.clear();
+		}
+		{
+			// Expected: object_modify(1+1+1=3) and repeat_exec(5)
+			loop->reach_time(5, gstate);
+
+			TESTEQUALS(state->trace.size(), 2);
+			auto it = state->trace.begin();
+			if (it->name != "object_modify")
+				TESTFAILMSG("Unexpected Event: " << it->name << " expected object_modify");
+			TESTEQUALS(it->time, 3);
+			it++;
+			if (it->name != "repeat_exec")
+				TESTFAILMSG("Unexpected Event: " << it->name << " expected repeat_exec");
+			TESTEQUALS(it->time, 5);
+			state->trace.clear();
+		}
+		{
+			// Expected: repeat_exec(10), once(10)
+			loop->reach_time(11, gstate);
+			TESTEQUALS(state->trace.size(), 2);
+			auto it = state->trace.begin();
+			if (it->name != "once")
+				TESTFAILMSG("Unexpected Event: " << it->name << " expected once");
+			TESTEQUALS(it->time, 10);
+			it++;
+			if (it->name != "repeat_exec")
+				TESTFAILMSG("Unexpected Event: " << it->name << " expected repeat_exec");
+			TESTEQUALS(it->time, 10);
+			state->trace.clear();
+		}
+
+		log::log(DBG << "changing the value at t=12");
+		state->objectA->set_number(1, 12);
+		{
+			// Expected: object_modify_immediately(12+1=13), object_modify(12+1+1=14)
+			// object_modify_immediately is executed at the time of change (12+1)
+			// whereas object_modify is executed with a newly predicted time (that is +1)
+			loop->reach_time(15, gstate);
+			TESTEQUALS(state->trace.size(), 3);
+			auto it = state->trace.begin();
+			if (it->name != "object_modify_immediately")
+				TESTFAILMSG("Unexpected Event: " << it->name << " expected object_modify_immediately");
+			TESTEQUALS(it->time, 13);
+			it++;
+			if (it->name != "object_modify")
+				TESTFAILMSG("Unexpected Event: " << it->name << " expected object_modify");
+			TESTEQUALS(it->time, 14);
+			it++;
+			if (it->name != "repeat_exec")
+				TESTFAILMSG("Unexpected Event: " << it->name << " expected repeat_exec");
+			TESTEQUALS(it->time, 15);
+			state->trace.clear();
+		}
+	}
+
+	log::log(DBG << "------------- [ Starting Test: Event parameter Mapping ] ------------");
+	{
+		class EventParameterMapTestClass : public EventClass {
+		public:
+			EventParameterMapTestClass()
+				:
+				EventClass("EventParameterMap", EventClass::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<State> &/*state*/,
+			            const curve::time_t &/*time*/,
+			            const EventClass::param_map &param) override {
+
+				log::log(DBG << "Testing unknown parameter");
+				TESTEQUALS(param.contains("tomato"), false);
+				TESTEQUALS(param.check_type<int>("tomato"), false);
+				TESTEQUALS(param.get<int>("tomato", 1), 1);
+				TESTEQUALS(param.get<int>("tomato"), 0);
+				TESTEQUALS(param.get<std::string>("tomato", "test"), "test");
+				TESTEQUALS(param.get<std::string>("tomato"), "");
+
+				log::log(DBG << "Testing Integer parameter");
+				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");
+				TESTEQUALS(param.contains("testString"), true);
+				TESTEQUALS(param.check_type<const char*>("testString"), true);
+				TESTEQUALS(strcmp(param.get<const char*>("testString"), "string"), 0);
+
+				log::log(DBG << "Testing std::string parameter");
+				TESTEQUALS(param.contains("testStdString"), true);
+				TESTEQUALS(param.check_type<std::string>("testStdString"), true);
+				TESTEQUALS(param.get<std::string>("testStdString"), "stdstring");
+			}
+
+			curve::time_t predict_invoke_time(const std::shared_ptr<EventTarget> &/*target*/,
+			                                  const std::shared_ptr<State> &/*state*/,
+			                                  const curve::time_t &at) override {
+				return at;
+			}
+		};
+
+		using namespace std::literals;
+
+		auto loop = std::make_shared<Loop>();
+		loop->add_event_class(std::make_shared<EventParameterMapTestClass>());
+		auto state = std::make_shared<TestState>(loop);
+		auto gstate = std::dynamic_pointer_cast<State>(state);
+
+		loop->create_event("EventParameterMap", state->objectA, gstate, 1, {
+				{"testInt", 1},
+				{"testStdString", "stdstring"s},
+				{"testString", "string"}
+			}
+		);
+		loop->reach_time(10, gstate);
+	}
+}
+
+} // namespace openage::event::tests
diff --git a/libopenage/util/fixed_point.h b/libopenage/util/fixed_point.h
index 689beae8ee..8ac197f36b 100644
--- a/libopenage/util/fixed_point.h
+++ b/libopenage/util/fixed_point.h
@@ -83,6 +83,13 @@ safe_shift(T value) {
  */
 template<typename int_type, unsigned int fractional_bits>
 class FixedPoint {
+public:
+	using raw_type = int_type;
+	using this_type = FixedPoint<int_type, fractional_bits>;
+	using unsigned_int_type = typename std::make_unsigned<int_type>::type;
+	using same_type_but_unsigned = FixedPoint<typename FixedPoint::unsigned_int_type,
+	                                          fractional_bits>;
+
 private:
 	// Helper function to create the scaling factors that are used below.
 	static constexpr double power_of_two(unsigned int power) {
@@ -93,6 +100,9 @@ class FixedPoint {
 		return result;
 	}
 
+	/**
+	 * Storage of the fixed point data.
+	 */
 	int_type raw_value;
 
 	static constexpr const double from_double_factor = power_of_two(fractional_bits);
@@ -104,10 +114,6 @@ class FixedPoint {
 		static_cast<double>(fractional_bits) * 0.30103 + 1
 	);
 
-	using this_type = FixedPoint<int_type, fractional_bits>;
-	using unsigned_int_type = typename std::make_unsigned<int_type>::type;
-	using same_type_but_unsigned = FixedPoint<typename FixedPoint::unsigned_int_type, fractional_bits>;
-
 	// constexpr helper function for get_fractional_part()
 	static constexpr typename FixedPoint::unsigned_int_type fractional_part_bitmask() {
 		// return ~(MAX_VAL << fractional_bits);
@@ -126,17 +132,30 @@ class FixedPoint {
 
 public:
 	// obligatory copy constructor / assignment operator.
-	constexpr FixedPoint(const FixedPoint &other) : raw_value(other.raw_value) {}
+	constexpr FixedPoint(const FixedPoint &other)
+		:
+		raw_value(other.raw_value) {}
+
+	constexpr FixedPoint(FixedPoint &&other) noexcept
+		:
+		raw_value(std::move(other.raw_value)) {}
 
 	constexpr FixedPoint &operator =(const FixedPoint &other) {
-		raw_value = other.raw_value;
+		this->raw_value = other.raw_value;
+		return *this;
+	}
+
+	constexpr FixedPoint &operator =(FixedPoint &&other) noexcept {
+		this->raw_value = std::move(other.raw_value);
 		return *this;
 	}
 
 	/**
 	 * Empty constructor. Initializes the number to 0.
 	 */
-	constexpr FixedPoint() : raw_value(0) {}
+	constexpr FixedPoint()
+		:
+		raw_value(0) {}
 
 	/**
 	 * floating-point constructor. Initializes the number from a double.
@@ -248,6 +267,18 @@ class FixedPoint {
 		return this->to_double();
 	}
 
+	/**
+	 * Show a string representation.
+	 */
+	constexpr std::string str() const {
+		std::ostringstream builder;
+		builder << "FixedPoint(" << this->to_double()
+		        << ", fracbits=" << fractional_bits
+		        << ", raw=" << this->raw_value
+		        << ")";
+		return builder.str();
+	};
+
 	/**
 	 * Converter to retrieve the fractional (post-decimal) part of the number.
 	 */
@@ -323,6 +354,25 @@ class FixedPoint {
 		return *this;
 	}
 
+	/**
+	 * FixedPoint *= N, where N is not a FixedPoint.
+	 */
+	template<typename N>
+	typename std::enable_if<std::is_arithmetic<N>::value, FixedPoint &>::type
+	constexpr operator *=(const N &rhs) {
+		this->raw_value *= rhs;
+		return *this;
+	}
+
+	/**
+	 * FixedPoint /= N
+	 */
+	template<typename N>
+	constexpr FixedPoint &operator /=(const N &rhs) {
+		this->raw_value = div(this->raw_value, static_cast<int_type>(rhs));
+		return *this;
+	}
+
 	void swap(FixedPoint &rhs) {
 		std::swap(this->raw_value, rhs.raw_value);
 	}
@@ -356,6 +406,14 @@ constexpr FixedPoint<I, F> operator +(const FixedPoint<I, F> &lhs, const FixedPo
 	return FixedPoint<I, F>::from_raw_value(lhs.get_raw_value() + rhs.get_raw_value());
 }
 
+/**
+ * FixedPoint + double
+ */
+template<typename I, unsigned int F>
+constexpr FixedPoint<I, F> operator +(const FixedPoint<I, F> &lhs, const double &rhs) {
+	return FixedPoint<I, F>{lhs} + FixedPoint<I, F>::from_double(rhs);
+}
+
 /**
  * FixedPoint - FixedPoint
  */
@@ -364,6 +422,14 @@ constexpr FixedPoint<I, F> operator -(const FixedPoint<I, F> &lhs, const FixedPo
 	return FixedPoint<I, F>::from_raw_value(lhs.get_raw_value() - rhs.get_raw_value());
 }
 
+/**
+ * FixedPoint - double
+ */
+template<typename I, unsigned int F>
+constexpr FixedPoint<I, F> operator -(const FixedPoint<I, F> &lhs, const double &rhs) {
+	return FixedPoint<I, F>{lhs} - FixedPoint<I, F>::from_double(rhs);
+}
+
 
 /**
  * FixedPoint * N
@@ -439,4 +505,15 @@ struct hash<openage::util::FixedPoint<I, F>> {
 	}
 };
 
+template<typename I, unsigned F>
+struct numeric_limits<openage::util::FixedPoint<I, F>> {
+	constexpr static openage::util::FixedPoint<I, F> min() {
+		return openage::util::FixedPoint<I, F>::min_value();
+	}
+
+	constexpr static openage::util::FixedPoint<I, F> max() {
+		return openage::util::FixedPoint<I, F>::max_value();
+	}
+};
+
 } // namespace std
diff --git a/libopenage/util/matrix.h b/libopenage/util/matrix.h
index 6fdc28ed33..6809899e4e 100644
--- a/libopenage/util/matrix.h
+++ b/libopenage/util/matrix.h
@@ -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.
 
 #pragma once
 
@@ -10,17 +10,19 @@
 
 #include "vector.h"
 
-namespace openage {
-namespace util {
+namespace openage::util {
 
 /**
  * Matrix class with arithmetic. M rows, N columns.
+ * T = underlying single value type (float, double, ...)
  */
-template<size_t M, size_t N>
-class Matrix : public std::array<std::array<float, N>, M> {
+template<size_t M, size_t N, typename T>
+class Matrix : public std::array<std::array<T, N>, M> {
 public:
 	static_assert(M > 0 and N > 0, "0-dimensional matrix not allowed");
 
+	using this_type = Matrix<M, N, T>;
+
 	static constexpr float default_eps = 1e-5;
 
 	static constexpr size_t rows = M;
@@ -47,7 +49,7 @@ class Matrix : public std::array<std::array<float, N>, M> {
 	 */
 	template <bool cond=is_column_vector,
 	          typename=typename std::enable_if<cond>::type>
-	Matrix(const Vector<M> &vec) {
+	Matrix(const Vector<M, T> &vec) {
 		for (size_t i = 0; i < M; i++) {
 			(*this)[i][0] = vec[i];
 		}
@@ -56,11 +58,11 @@ class Matrix : public std::array<std::array<float, N>, M> {
 	/**
 	 * Constructor with N*M values
 	 */
-	template <typename ... T>
-	Matrix(T ... args) {
+	template <typename ... Ts>
+	Matrix(Ts ... args) {
 		static_assert(sizeof...(args) == N*M, "not all values supplied");
 
-		std::array<float, N*M> temp{{static_cast<float>(args)...}};
+		std::array<float, N*M> temp{{static_cast<T>(args)...}};
 		for (size_t i = 0; i < N*M; i++) {
 			(*this)[i / (N*M)][i % (N*M)] = temp[i];
 		}
@@ -71,8 +73,8 @@ class Matrix : public std::array<std::array<float, N>, M> {
 	 */
 	template <bool cond=is_square,
 	          typename=typename std::enable_if<cond>::type>
-	static Matrix<N, M> identity() {
-		Matrix<N, M> res;
+	static this_type identity() {
+		this_type res;
 
 		for (size_t i = 0; i < N; i++) {
 			res[i][i] = 1;
@@ -84,7 +86,7 @@ class Matrix : public std::array<std::array<float, N>, M> {
 	/**
 	 * Test if both matrices contain the same values within epsilon.
 	 */
-	bool equals(const Matrix<N, M> &other, float eps=default_eps) const {
+	bool equals(const this_type &other, float eps=default_eps) const {
 		for (size_t i = 0; i < N; i++) {
 			for (size_t j = 0; j < M; j++) {
 				if (std::abs((*this)[i][j] - other[i][j]) >= eps) {
@@ -99,8 +101,8 @@ class Matrix : public std::array<std::array<float, N>, M> {
 	 * Matrix multiplication
 	 */
 	template <size_t P>
-	Matrix<M, P> operator *(const Matrix<N, P> &other) const {
-		Matrix<M, P> res;
+	Matrix<M, P, T> operator *(const Matrix<N, P, T> &other) const {
+		Matrix<M, P, T> res;
 		for (size_t i = 0; i < M; i++) {
 			for (size_t j = 0; j < P; j++) {
 				res[i][j] = 0;
@@ -115,15 +117,15 @@ class Matrix : public std::array<std::array<float, N>, M> {
 	/**
 	 * Matrix-Vector multiplication
 	 */
-	Matrix <M, 1> operator *(const Vector<M> &vec) const {
-		return (*this) * static_cast<Matrix<M, 1>>(vec);
+	Matrix <M, 1, T> operator *(const Vector<M, T> &vec) const {
+		return (*this) * static_cast<Matrix<M, 1, T>>(vec);
 	}
 
 	/**
 	 * Matrix addition
 	 */
-	Matrix<M, N> operator +(const Matrix<M, N> &other) const {
-		Matrix<M, N> res;
+	this_type operator +(const this_type &other) const {
+		this_type res;
 		for (size_t i = 0; i < M; i++) {
 			for (size_t j = 0; j < N; j++) {
 				res[i][j] = (*this)[i][j] + other[i][j];
@@ -135,8 +137,8 @@ class Matrix : public std::array<std::array<float, N>, M> {
 	/**
 	 * Matrix subtraction
 	 */
-	Matrix<M, N> operator -(const Matrix<M, N> &other) const {
-		Matrix<M, N> res;
+	this_type operator -(const this_type &other) const {
+		this_type res;
 		for (size_t i = 0; i < M; i++) {
 			for (size_t j = 0; j < N; j++) {
 				res[i][j] = (*this)[i][j] - other[i][j];
@@ -148,7 +150,7 @@ class Matrix : public std::array<std::array<float, N>, M> {
 	/**
 	 * Scalar multiplication with assignment
 	 */
-	void operator *=(float other) {
+	void operator *=(T other) {
 		for (size_t i = 0; i < M; i++) {
 			for (size_t j = 0; j < N; j++) {
 				(*this)[i][j] *= other;
@@ -159,8 +161,8 @@ class Matrix : public std::array<std::array<float, N>, M> {
 	/**
 	 * Scalar multiplication
 	 */
-	Matrix<M, N> operator *(float other) const {
-		Matrix<M, N> res(*this);
+	this_type operator *(T other) const {
+		this_type res(*this);
 		res *= other;
 		return res;
 	}
@@ -168,7 +170,7 @@ class Matrix : public std::array<std::array<float, N>, M> {
 	/**
 	 * Scalar division with assignment
 	 */
-	void operator /=(float other) {
+	void operator /=(T other) {
 		for (size_t i = 0; i < M; i++) {
 			for (size_t j = 0; j < N; j++) {
 				(*this)[i][j] /= other;
@@ -179,8 +181,8 @@ class Matrix : public std::array<std::array<float, N>, M> {
 	/**
 	 * Scalar division
 	 */
-	Matrix<M, N> operator /(float other) const {
-		Matrix<M, N> res(*this);
+	this_type operator /(T other) const {
+		this_type res(*this);
 		res /= other;
 		return res;
 	}
@@ -188,8 +190,8 @@ class Matrix : public std::array<std::array<float, N>, M> {
 	/**
 	 * Transposition
 	 */
-	Matrix<N, M> transpose() const {
-		Matrix <N, M> res;
+	Matrix<N, M, T> transpose() const {
+		Matrix <N, M, T> res;
 		for (size_t i = 0; i < M; i++) {
 			for (size_t j = 0; j < N; j++) {
 				res[j][i] = (*this)[i][j];
@@ -203,8 +205,8 @@ class Matrix : public std::array<std::array<float, N>, M> {
 	 */
 	template<bool cond=is_column_vector,
 	         typename=typename std::enable_if<cond>::type>
-	Vector<M> to_vector() const {
-		auto res = Vector<M>();
+	Vector<M, T> to_vector() const {
+		Vector<M, T> res{};
 		for (size_t i = 0; i < M; i++) {
 			res[i] = (*this)[i][0];
 		}
@@ -216,8 +218,8 @@ class Matrix : public std::array<std::array<float, N>, M> {
 	 */
 	template<bool cond=is_square,
 	         typename=typename std::enable_if<cond>::type>
-	float trace() const {
-		float res = 0.0f;
+	T trace() const {
+		T res = 0;
 
 		for (size_t i = 0; i < N; i++) {
 			res += (*this)[i][i];
@@ -230,7 +232,7 @@ class Matrix : public std::array<std::array<float, N>, M> {
 	 * Print to output stream using '<<'
 	 */
 	friend std::ostream &operator <<(std::ostream &o,
-	                                 const Matrix<M, N> &mat) {
+	                                 const this_type &mat) {
 		o << "(";
 		for (size_t j = 0; j < M-1; j++) {
 			o << "(";
@@ -252,13 +254,42 @@ class Matrix : public std::array<std::array<float, N>, M> {
 /**
  * Scalar multiplication with swapped arguments
  */
-template<size_t M, size_t N>
-Matrix<M, N> operator *(float a, const Matrix<M, N> &mat) {
+template<size_t M, size_t N, typename T>
+Matrix<M, N, T> operator *(T a, const Matrix<M, N, T> &mat) {
+	return mat * a;
+}
+
+/**
+ * Scalar multiplication with swapped arguments for int. This was just added
+ * because otherwise the above float-multiplication function might not match to
+ * the template deduction.
+ */
+template<size_t M, size_t N, typename T>
+Matrix<M, N, T> operator *(int64_t a, const Matrix<M, N, T> &mat) {
 	return mat * a;
 }
 
-using Matrix2 = Matrix<2, 2>;
-using Matrix3 = Matrix<3, 3>;
-using Matrix4 = Matrix<4, 4>;
+template<typename T=float>
+using Matrix2t = Matrix<2, 2, T>;
+
+template<typename T=float>
+using Matrix3t = Matrix<3, 3, T>;
+
+template<typename T=float>
+using Matrix4t = Matrix<4, 4, T>;
+
+template<size_t M, size_t N>
+using Matrixf = Matrix<M, N, float>;
+
+template<size_t M, size_t N>
+using Matrixd = Matrix<M, N, double>;
+
+using Matrix2f = Matrix<2, 2, float>;
+using Matrix3f = Matrix<3, 3, float>;
+using Matrix4f = Matrix<4, 4, float>;
+
+using Matrix2d = Matrix<2, 2, double>;
+using Matrix3d = Matrix<3, 3, double>;
+using Matrix4d = Matrix<4, 4, double>;
 
-}} // openage::util
+} // openage::util
diff --git a/libopenage/util/matrix_test.cpp b/libopenage/util/matrix_test.cpp
index 0e82e58576..eca420bce8 100644
--- a/libopenage/util/matrix_test.cpp
+++ b/libopenage/util/matrix_test.cpp
@@ -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.
 
 #include "matrix.h"
 #include "vector.h"
@@ -11,15 +11,15 @@ namespace tests {
 
 void matrix() {
 	{ // matrix multiplication
-		const Matrix<5, 3> a(0.0, 0.5, 1.0,
-		                     1.5, 2.0, 2.5,
-		                     3.0, 3.5, 4.0,
-		                     4.5, 5.0, 5.5,
-		                     6.0, 6.5, 7.0);
-		const Matrix<3, 4> b(1, 0, 0, 0,
-		                     0, 1, 0, 0,
-		                     0, 0, 1, 0);
-		Matrix<5, 4> c = a * b;
+		const Matrix<5, 3, float> a(0.0, 0.5, 1.0,
+		                            1.5, 2.0, 2.5,
+		                            3.0, 3.5, 4.0,
+		                            4.5, 5.0, 5.5,
+		                            6.0, 6.5, 7.0);
+		const Matrix<3, 4, float> b(1, 0, 0, 0,
+		                            0, 1, 0, 0,
+		                            0, 0, 1, 0);
+		Matrix<5, 4, float> c = a * b;
 		TESTEQUALS_FLOAT(c[0][0], 0, 1e-7);
 		TESTEQUALS_FLOAT(c[0][1], 0.5, 1e-7);
 		TESTEQUALS_FLOAT(c[0][2], 1, 1e-7);
@@ -43,9 +43,9 @@ void matrix() {
 	}
 
 	{ // addition and subtraction
-		const Matrix2 a(1, 2, 3, 4);
-		const Matrix2 b(5, 6, 7, 8);
-		Matrix2 c = a + b;
+		const Matrix2f a(1, 2, 3, 4);
+		const Matrix2f b(5, 6, 7, 8);
+		Matrix2f c = a + b;
 		TESTEQUALS_FLOAT(c[0][0], 6, 1e-7);
 		TESTEQUALS_FLOAT(c[0][1], 8, 1e-7);
 		TESTEQUALS_FLOAT(c[1][0], 10, 1e-7);
@@ -59,8 +59,8 @@ void matrix() {
 	}
 
 	{ // scalar multiplication and division
-		const Matrix2 a(0, 1, 2, 3);
-		Matrix2 b = a * 2;
+		const Matrix2f a(0, 1, 2, 3);
+		Matrix2f b = a * 2;
 		TESTEQUALS_FLOAT(b[0][0], 0, 1e-7);
 		TESTEQUALS_FLOAT(b[0][1], 2, 1e-7);
 		TESTEQUALS_FLOAT(b[1][0], 4, 1e-7);
@@ -80,8 +80,8 @@ void matrix() {
 	}
 
 	{ // transposition
-		const Matrix2 a(1, 2, 3, 4);
-		const Matrix2 b = a.transpose();
+		const Matrix2f a(1, 2, 3, 4);
+		const Matrix2f b = a.transpose();
 		TESTEQUALS_FLOAT(b[0][0], 1, 1e-7);
 		TESTEQUALS_FLOAT(b[0][1], 3, 1e-7);
 		TESTEQUALS_FLOAT(b[1][0], 2, 1e-7);
@@ -89,10 +89,10 @@ void matrix() {
 	}
 
 	{ // vector interaction
-		const Matrix3 a(2, 0, 0,
-		                0, 2, 0,
-		                0, 0, 2);
-		const Vector3 v(1, 2, 3);
+		const Matrix3f a(2, 0, 0,
+		                 0, 2, 0,
+		                 0, 0, 2);
+		const Vector3f v(1, 2, 3);
 		auto u = (a * v).to_vector();
 		TESTEQUALS_FLOAT(u[0], 2, 1e-7);
 		TESTEQUALS_FLOAT(u[1], 4, 1e-7);
diff --git a/libopenage/util/quaternion.h b/libopenage/util/quaternion.h
index cd61167bbe..671d2a2410 100644
--- a/libopenage/util/quaternion.h
+++ b/libopenage/util/quaternion.h
@@ -1,4 +1,4 @@
-// Copyright 2017-2017 the openage authors. See copying.md for legal info.
+// Copyright 2017-2018 the openage authors. See copying.md for legal info.
 
 #pragma once
 
@@ -27,7 +27,7 @@ namespace util {
  * From Quaternion to Matrix and Back
  * J.M.P. van Waveren, id Software, 2005
  */
-template <typename T=float>
+template <typename T>
 class Quaternion {
 public:
 	using this_type = Quaternion<T>;
@@ -63,7 +63,7 @@ class Quaternion {
 	 * which is larger than |w| and >= 1/2
 	 */
 	template <size_t N=4>
-	Quaternion(const Matrix<N, N> &mat) {
+	Quaternion(const Matrix<N, N, T> &mat) {
 
 		static_assert(N == 3 or N == 4, "only 3 and 4 dimensional matrices can be converted to a quaternion!");
 
@@ -142,7 +142,7 @@ class Quaternion {
 	/**
 	 * Create a quaternion from a rotation in radians around a given axis.
 	 */
-	static this_type from_rad(T rad, Vector3 axis) {
+	static this_type from_rad(T rad, Vector3t<T> axis) {
 		T rot = rad / 2.0;
 		this_type q{
 			std::cos(rot),
@@ -156,7 +156,7 @@ class Quaternion {
 	/**
 	 * Create a quaternion from a rotation in degree around a given axis.
 	 */
-	static this_type from_deg(T deg, Vector3 axis) {
+	static this_type from_deg(T deg, Vector3t<T> axis) {
 		return this_type::from_rad(deg * math::DEGSPERRAD, axis);
 	}
 
@@ -279,7 +279,7 @@ class Quaternion {
 	/**
 	 * Generate the corresponding rotation matrix.
 	 */
-	Matrix3 to_matrix() const {
+	Matrix3t<T> to_matrix() const {
 		T x2  = this->x * 2;
 		T y2  = this->y * 2;
 		T z2  = this->z * 2;
@@ -296,7 +296,7 @@ class Quaternion {
 		T z2y = z2 * this->y;
 		T z3  = z2 * this->z;
 
-		Matrix3 m{
+		Matrix3t<T> m{
 			1.0 - (y3 + z3), y2x - z2w, z2x + y2w,
 			y2x + z2w, 1.0 - (x3 + z3), z2y - x2w,
 			z2x - y2w, z2y + x2w, 1.0 - (x3 + y3)
@@ -308,11 +308,11 @@ class Quaternion {
 	/**
 	 * Transforms a vector by this quaternion.
 	 */
-	Vector3 operator *(const Vector3 &vec) const {
-		Vector3 axis{this->x, this->y, this->z};
+	Vector3t<T> operator *(const Vector3t<T> &vec) const {
+		Vector3t<T> axis{this->x, this->y, this->z};
 
-		Vector3 axis_vec_normal = axis.cross_product(vec);
-		Vector3 axis_vec_inplane = axis.cross_product(axis_vec_normal);
+		Vector3t<T> axis_vec_normal = axis.cross_product(vec);
+		Vector3t<T> axis_vec_inplane = axis.cross_product(axis_vec_normal);
 
 		axis_vec_normal *= 2.0f * this->w;
 		axis_vec_inplane *= 2.0f;
@@ -432,4 +432,7 @@ class Quaternion {
 	T w, x, y, z;
 };
 
+using Quaternionf = Quaternion<float>;
+using Quaterniond = Quaternion<double>;
+
 }} // openage::util
diff --git a/libopenage/util/quaternion_test.cpp b/libopenage/util/quaternion_test.cpp
index 669cbedf46..5c11377529 100644
--- a/libopenage/util/quaternion_test.cpp
+++ b/libopenage/util/quaternion_test.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 "quaternion.h"
 
@@ -16,90 +16,90 @@ namespace tests {
 void quaternion() {
 	{
 		// Quaternion construction tests
-		const Quaternion<> id{};
-		Quaternion<> id_explicit{1.0, 0.0, 0.0, 0.0};
+		const Quaternionf id{};
+		Quaternionf id_explicit{1.0, 0.0, 0.0, 0.0};
 
 		id.equals(id_explicit) or TESTFAIL;
 		id.equals_deg(id_explicit, 1e-5f) or TESTFAIL;
 
-		Quaternion<> wrong{0.0, 0.0, 1.0, 0.0};
+		Quaternionf wrong{0.0, 0.0, 1.0, 0.0};
 		not id.equals(wrong) or TESTFAIL;
 
-		Matrix3 id_mat3 = Matrix3::identity();
-		Quaternion<> q_id_mat3{id_mat3};
+		Matrix3f id_mat3 = Matrix3f::identity();
+		Quaternionf q_id_mat3{id_mat3};
 		id.equals(q_id_mat3) or TESTFAIL;
 
-		Matrix4 id_mat4 = Matrix4::identity();
-		Quaternion<> q_id_mat4{id_mat4};
+		Matrix4f id_mat4 = Matrix4f::identity();
+		Quaternionf q_id_mat4{id_mat4};
 		id.equals(q_id_mat4) or TESTFAIL;
 
-		Matrix4 neg_mat4{
+		Matrix4f neg_mat4{
 			-1, 0, 0, 0,
 			0, 1, 0, 0,
 			0, 0, -1, 0,
 			0, 0, 0, 1,
 		};
 
-		Quaternion<> q_neg{neg_mat4};
-		Quaternion<> q_nex_exp{0, 0, 1, 0};
+		Quaternionf q_neg{neg_mat4};
+		Quaternionf q_nex_exp{0, 0, 1, 0};
 
 		q_neg.equals(q_nex_exp) or TESTFAIL;
 	}
 	{
 		// member functions
-		Quaternion<> q0{1, 2, 3, 4};
-		Quaternion<> q1{5, 6, 7, 8};
+		Quaternionf q0{1, 2, 3, 4};
+		Quaternionf q1{5, 6, 7, 8};
 
 		TESTEQUALS_FLOAT(q0.dot(q1), 5 + 12 + 21 + 32, 1e-5f);
 		TESTEQUALS_FLOAT(q0.norm(), 5.4772255 /*= sqrt(30) */, 1e-4f);
 
-		Quaternion<> q2{2, 8, 4, 16};
+		Quaternionf q2{2, 8, 4, 16};
 
-		Quaternion<> q2_normd = q2.normalized();
+		Quaternionf q2_normd = q2.normalized();
 		q2_normd.equals(q2) or TESTFAIL;
 
-		Quaternion<> q2conj_exp{2, -8, -4, -16};
+		Quaternionf q2conj_exp{2, -8, -4, -16};
 		q2conj_exp.equals(q2.conjugated()) or TESTFAIL;
 
-		Quaternion<> q2inv_exp{
+		Quaternionf q2inv_exp{
 			0.0058823529411764705f,
 			-0.023529411764705882f,
 			-0.011764705882352941f,
 			-0.047058823529411764f
 		};
 
-		Quaternion<> q2inv = q2.inversed();
+		Quaternionf q2inv = q2.inversed();
 		q2inv.normalized().equals(q2inv_exp.normalized()) or TESTFAIL;
 
 		q2.normalize();
-		Quaternion<> q2norm_exp{
+		Quaternionf q2norm_exp{
 			0.10846522f, 0.433860915f, 0.216930457f, 0.8677218312f
 		};
 		q2norm_exp.equals(q2) or TESTFAIL;
 	}
 	{
 		// Operator tests.
-		Quaternion<> id{};
-		Quaternion<> bla0{13, 37, 42, 235};
+		Quaternionf id{};
+		Quaternionf bla0{13, 37, 42, 235};
 		bla0.equals(id * bla0) or TESTFAIL;
 
-		Quaternion<> bla1{8, 16, 24, 32};
-		Quaternion<> bla0_1_exp{21, 45, 50, 243};
+		Quaternionf bla1{8, 16, 24, 32};
+		Quaternionf bla0_1_exp{21, 45, 50, 243};
 		bla0_1_exp.equals(bla0 + bla1) or TESTFAIL;
 
-		Quaternion<> bla1_2_exp{2, 8, 12, 16};
+		Quaternionf bla1_2_exp{2, 8, 12, 16};
 		bla1_2_exp.equals(bla1 / 4) or TESTFAIL;
 
-		Quaternion<> bla1_3_exp{16, 64, 96, 128};
+		Quaternionf bla1_3_exp{16, 64, 96, 128};
 		bla1_3_exp.equals(bla1 * 8) or TESTFAIL;
 
-		Quaternion<> bla1_4_exp{21, 53, 66, 267};
+		Quaternionf bla1_4_exp{21, 53, 66, 267};
 		bla1_4_exp.equals(bla0 + bla1) or TESTFAIL;
 
-		Quaternion<> bla1_5_exp{5, 21, 18, 203};
+		Quaternionf bla1_5_exp{5, 21, 18, 203};
 		bla1_5_exp.equals(bla0 - bla1) or TESTFAIL;
 
-		Quaternion<> bla2_exp{
+		Quaternionf bla2_exp{
 			13 * 21 - 37 * 45 - 42 * 50 - 235 * 243,
 			13 * 45 + 37 * 21 + 42 * 243 - 235 * 50,
 			13 * 50 - 37 * 243 + 42 * 21 + 235 * 45,
@@ -110,7 +110,7 @@ void quaternion() {
 		(bla2_exp == bla2_exp) or TESTFAIL;
 		(bla2_exp != bla0) or TESTFAIL;
 
-		Quaternion<> bla0_neg_exp{-13, -37, -42, -235};
+		Quaternionf bla0_neg_exp{-13, -37, -42, -235};
 		bla0_neg_exp.equals(-bla0) or TESTFAIL;
 	}
 	{
@@ -119,7 +119,7 @@ void quaternion() {
 		};
 
 		// Rotation tests
-		auto rot_mat = [&](axis a, float am, bool deg=true) -> Matrix3 {
+		auto rot_mat = [&](axis a, float am, bool deg=true) -> Matrix3f {
 			if (deg) {
 				am = (am * math::PI) / 180.0;
 			}
@@ -152,99 +152,99 @@ void quaternion() {
 		};
 
 		// zero rotation = identity.
-		Matrix3 rot = rot_mat(axis::x, 0, false);
-		rot.equals(Matrix3::identity()) or TESTFAIL;
-		Quaternion<> q_rot{rot};
-		Quaternion<> q_rot_deg = Quaternion<>::from_rad(0, {1, 0, 0});
+		Matrix3f rot = rot_mat(axis::x, 0, false);
+		rot.equals(Matrix3f::identity()) or TESTFAIL;
+		Quaternionf q_rot{rot};
+		Quaternionf q_rot_deg = Quaternionf::from_rad(0, {1, 0, 0});
 		q_rot.equals_deg(q_rot_deg) or TESTFAIL;
 
 		// 10 rad rotation
 		rot = rot_mat(axis::x, 10, false);
-		q_rot = Quaternion<>{rot};
-		q_rot_deg = Quaternion<>::from_rad(10, {1, 0, 0});
+		q_rot = Quaternionf{rot};
+		q_rot_deg = Quaternionf::from_rad(10, {1, 0, 0});
 		q_rot.equals_rad(q_rot_deg) or TESTFAIL;
 
 		// wrong 90-rad-rotation:
-		q_rot_deg = Quaternion<>::from_rad(90, {1, 0, 0});
+		q_rot_deg = Quaternionf::from_rad(90, {1, 0, 0});
 		not q_rot.equals_rad(q_rot_deg) or TESTFAIL;
 
 		// 10 deg rotation
 		rot = rot_mat(axis::x, 10);
-		q_rot = Quaternion<>{rot};
-		q_rot_deg = Quaternion<>::from_deg(10, {1, 0, 0});
+		q_rot = Quaternionf{rot};
+		q_rot_deg = Quaternionf::from_deg(10, {1, 0, 0});
 		q_rot.equals_deg(q_rot_deg) or TESTFAIL;
 
 		// 90 deg rotation
 		rot = rot_mat(axis::x, 90);
-		q_rot = Quaternion<>{rot};
-		q_rot_deg = Quaternion<>::from_deg(90, {1, 0, 0});
+		q_rot = Quaternionf{rot};
+		q_rot_deg = Quaternionf::from_deg(90, {1, 0, 0});
 		q_rot.equals_deg(q_rot_deg) or TESTFAIL;
 
 		rot = rot_mat(axis::y, 90);
-		q_rot = Quaternion<>{rot};
-		q_rot_deg = Quaternion<>::from_deg(90, {0, 1, 0});
+		q_rot = Quaternionf{rot};
+		q_rot_deg = Quaternionf::from_deg(90, {0, 1, 0});
 		q_rot.equals_deg(q_rot_deg) or TESTFAIL;
 
 		rot = rot_mat(axis::z, 90);
-		q_rot = Quaternion<>{rot};
-		q_rot_deg = Quaternion<>::from_deg(90, {0, 0, 1});
+		q_rot = Quaternionf{rot};
+		q_rot_deg = Quaternionf::from_deg(90, {0, 0, 1});
 		q_rot.equals_deg(q_rot_deg) or TESTFAIL;
 
 		// -90 deg rotation
 		rot = rot_mat(axis::y, -90);
-		q_rot = Quaternion<>{rot};
-		q_rot_deg = Quaternion<>::from_deg(-90, {0, 1, 0});
+		q_rot = Quaternionf{rot};
+		q_rot_deg = Quaternionf::from_deg(-90, {0, 1, 0});
 		q_rot.equals_deg(q_rot_deg) or TESTFAIL;
 
 		// 45 deg rotation
 		rot = rot_mat(axis::z, 45);
-		q_rot = Quaternion<>{rot};
-		q_rot_deg = Quaternion<>::from_deg(45, {0, 0, 1});
+		q_rot = Quaternionf{rot};
+		q_rot_deg = Quaternionf::from_deg(45, {0, 0, 1});
 		q_rot.equals_deg(q_rot_deg) or TESTFAIL;
 
 		// rotation combination
 		rot = rot_mat(axis::z, 45) * rot_mat(axis::y, 60);
-		q_rot = Quaternion<>{rot};
-		q_rot_deg = (Quaternion<>::from_deg(45, {0, 0, 1}) *
-		             Quaternion<>::from_deg(60, {0, 1, 0}));
+		q_rot = Quaternionf{rot};
+		q_rot_deg = (Quaternionf::from_deg(45, {0, 0, 1}) *
+		             Quaternionf::from_deg(60, {0, 1, 0}));
 		q_rot.equals_deg(q_rot_deg) or TESTFAIL;
 
 		rot = rot_mat(axis::z, 45) *
 		      rot_mat(axis::y, 60) *
 		      rot_mat(axis::x, -200);
-		q_rot = Quaternion<>{rot};
-		q_rot_deg = (Quaternion<>::from_deg(45, {0, 0, 1}) *
-		             Quaternion<>::from_deg(60, {0, 1, 0}) *
-		             Quaternion<>::from_deg(-200, {1, 0, 0}));
+		q_rot = Quaternionf{rot};
+		q_rot_deg = (Quaternionf::from_deg(45, {0, 0, 1}) *
+		             Quaternionf::from_deg(60, {0, 1, 0}) *
+		             Quaternionf::from_deg(-200, {1, 0, 0}));
 		q_rot.equals_deg(q_rot_deg) or TESTFAIL;
 
 		// to_matrix tests
 		rot = rot_mat(axis::x, 235);
-		q_rot = Quaternion<>::from_deg(235, {1, 0, 0});
+		q_rot = Quaternionf::from_deg(235, {1, 0, 0});
 		rot.equals(q_rot.to_matrix()) or TESTFAIL;
 
 		rot = rot_mat(axis::y, -55);
-		q_rot = Quaternion<>::from_deg(-55, {0, 1, 0});
+		q_rot = Quaternionf::from_deg(-55, {0, 1, 0});
 		rot.equals(q_rot.to_matrix()) or TESTFAIL;
 
 		rot = rot_mat(axis::z, 64);
-		q_rot = Quaternion<>::from_deg(64, {0, 0, 1});
+		q_rot = Quaternionf::from_deg(64, {0, 0, 1});
 		rot.equals(q_rot.to_matrix()) or TESTFAIL;
 	}
 	{
-		Vector3 vec{5, 0, 0};
-		Vector3 turned = Quaternion<>::from_deg(180, {0, 0, 1}) * vec;
-		Vector3 turned_exp{-5, 0, 0};
+		Vector3f vec{5, 0, 0};
+		Vector3f turned = Quaternionf::from_deg(180, {0, 0, 1}) * vec;
+		Vector3f turned_exp{-5, 0, 0};
 		turned.equals(turned_exp) or TESTFAIL;
 
 		// intentional fail:
-		turned_exp = Vector3{-42, -42, -42};
+		turned_exp = Vector3f{-42, -42, -42};
 		not turned.equals(turned_exp) or TESTFAIL;
 
 		// another turn
-		vec = Vector3{1337, 42, 235};
-		turned = Quaternion<>::from_deg(90, {1, 0, 0}) * vec;
-		turned_exp = Vector3{1337, -235, 42};
+		vec = Vector3f{1337, 42, 235};
+		turned = Quaternionf::from_deg(90, {1, 0, 0}) * vec;
+		turned_exp = Vector3f{1337, -235, 42};
 		turned.equals(turned_exp) or TESTFAIL;
 	}
 }
diff --git a/libopenage/util/vector.h b/libopenage/util/vector.h
index 051882714f..a75eaefeb6 100644
--- a/libopenage/util/vector.h
+++ b/libopenage/util/vector.h
@@ -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.
 
 #pragma once
 
@@ -8,23 +8,29 @@
 #include <iostream>
 #include <type_traits>
 
+#include "../error/error.h"
 #include "../log/log.h"
 
-namespace openage {
-namespace util {
+
+namespace openage::util {
 
 /**
  * Vector class with arithmetic.
+ *
+ * N = dimensions
+ * T = underlying single value type (double, float, ...)
  */
-template<size_t N>
-class Vector : public std::array<float, N> {
+template<size_t N, typename T>
+class Vector : public std::array<T, N> {
 public:
 	static_assert(N > 0, "0-dimensional vector not allowed");
 
+	using this_type = Vector<N, T>;
+
 	/**
 	 * Default comparison epsilon.
 	 */
-	static constexpr float default_eps = 1e-4;
+	static constexpr T default_eps = 1e-4;
 
 	/**
 	 * Default, random-value constructor.
@@ -38,12 +44,12 @@ class Vector : public std::array<float, N> {
 	~Vector() = default;
 
 	/**
-	 * Constructor for initialisation with N float values
+	 * Constructor for initialisation with N T values
 	 */
-	template<typename ... T>
-	Vector(T ... args)
+	template<typename ... Ts>
+	Vector(Ts ... args)
 		:
-		std::array<float, N> {{static_cast<float>(args)...}} {
+		std::array<T, N>{static_cast<T>(args)...} {
 
 		static_assert(sizeof...(args) == N, "not all values supplied.");
 	}
@@ -51,9 +57,9 @@ class Vector : public std::array<float, N> {
 	/**
 	 * Equality test with given precision.
 	 */
-	bool equals(const Vector<N> &other, float eps=default_eps) {
+	bool equals(const this_type &other, T eps=default_eps) {
 		for (size_t i = 0; i < N; i++) {
-			float diff = std::abs((*this)[i] - other[i]);
+			T diff = std::abs((*this)[i] - other[i]);
 			if (diff >= eps) {
 				return false;
 			}
@@ -64,7 +70,7 @@ class Vector : public std::array<float, N> {
 	/**
 	 * Vector addition with assignment
 	 */
-	Vector<N> &operator +=(const Vector<N> &other) {
+	this_type &operator +=(const this_type &other) {
 		for (size_t i = 0; i < N; i++) {
 			(*this)[i] += other[i];
 		}
@@ -74,8 +80,8 @@ class Vector : public std::array<float, N> {
 	/**
 	 * Vector addition
 	 */
-	Vector<N> operator +(const Vector<N> &other) const {
-		Vector res(*this);
+	this_type operator +(const this_type &other) const {
+		this_type res(*this);
 		res += other;
 		return res;
 	}
@@ -83,7 +89,7 @@ class Vector : public std::array<float, N> {
 	/**
 	 * Vector subtraction with assignment
 	 */
-	Vector<N> &operator -=(const Vector<N> &other) {
+	this_type &operator -=(const this_type &other) {
 		for (size_t i = 0; i < N; i++) {
 			(*this)[i] -= other[i];
 		}
@@ -93,8 +99,8 @@ class Vector : public std::array<float, N> {
 	/**
 	 * Vector subtraction
 	 */
-	Vector<N> operator -(const Vector<N> &other) const {
-		Vector res(*this);
+	this_type operator -(const this_type &other) const {
+		this_type res(*this);
 		res -= other;
 		return res;
 	}
@@ -102,7 +108,7 @@ class Vector : public std::array<float, N> {
 	/**
 	 * Scalar multiplication with assignment
 	 */
-	Vector<N> &operator *=(float a) {
+	this_type &operator *=(T a) {
 		for (size_t i = 0; i < N; i++) {
 			(*this)[i] *= a;
 		}
@@ -112,8 +118,8 @@ class Vector : public std::array<float, N> {
 	/**
 	 * Scalar multiplication
 	 */
-	Vector<N> operator *(float a) const {
-		Vector res(*this);
+	this_type operator *(T a) const {
+		this_type res(*this);
 		res *= a;
 		return res;
 	}
@@ -121,7 +127,7 @@ class Vector : public std::array<float, N> {
 	/**
 	 * Scalar division with assignment
 	 */
-	Vector<N> &operator /=(float a) {
+	this_type &operator /=(T a) {
 		for (size_t i = 0; i < N; i++) {
 			(*this)[i] /= a;
 		}
@@ -131,8 +137,8 @@ class Vector : public std::array<float, N> {
 	/**
 	 * Scalar division
 	 */
-	Vector<N> operator /(float a) const {
-		Vector res(*this);
+	this_type operator /(T a) const {
+		this_type res(*this);
 		res /= a;
 		return res;
 	}
@@ -140,8 +146,8 @@ class Vector : public std::array<float, N> {
 	/**
 	 * Dot product of two Vectors
 	 */
-	float dot(const Vector<N> &other) const {
-		float res = 0;
+	T dot(const this_type &other) const {
+		T res = 0;
 		for (size_t i = 0; i < N; i++) {
 			res += (*this)[i] * other[i];
 		}
@@ -151,14 +157,14 @@ class Vector : public std::array<float, N> {
 	/**
 	 * Euclidian norm aka length
 	 */
-	float norm() const {
+	T norm() const {
 		return std::sqrt(this->dot(*this));
 	}
 
 	/**
 	 * Scales the Vector so that its norm is 1
 	 */
-	Vector<N> &normalize() {
+	this_type &normalize() {
 		*this /= this->norm();
 		return *this;
 	}
@@ -166,10 +172,10 @@ class Vector : public std::array<float, N> {
 	/**
 	 * Cross-product of two 3-dimensional vectors
 	 */
-	template<typename T=Vector<N>>
-	typename std::enable_if<N==3,T>::type
-	/*Vector<N>*/ cross_product(const Vector<N> &other) const {
-		return Vector(
+	template<typename U=this_type>
+	typename std::enable_if<N==3, U>::type
+	/*Vector<N>*/ cross_product(const this_type &other) const {
+		return this_type(
 			((*this)[1] * other[2] - (*this)[2] * other[1]),
 			((*this)[2] * other[0] - (*this)[0] * other[2]),
 			((*this)[0] * other[1] - (*this)[1] * other[0])
@@ -179,14 +185,14 @@ class Vector : public std::array<float, N> {
 	/**
 	 * Scalar multiplication with swapped arguments
 	 */
-	friend Vector<N> operator *(float a, const Vector<N> &v) {
+	friend this_type operator *(T a, const this_type &v) {
 		return v * a;
 	}
 
 	/**
 	 * Print to output stream using '<<'
 	 */
-	friend std::ostream &operator <<(std::ostream &o, const Vector<N> &v) {
+	friend std::ostream &operator <<(std::ostream &o, const this_type &v) {
 		o << "(";
 		for (size_t i = 0; i < N-1; i++) {
 			o << v[i] << ", ";
@@ -197,8 +203,27 @@ class Vector : public std::array<float, N> {
 };
 
 
-using Vector2 = Vector<2>;
-using Vector3 = Vector<3>;
-using Vector4 = Vector<4>;
+template<typename T=float>
+using Vector2t = Vector<2, T>;
+
+template<typename T=float>
+using Vector3t = Vector<3, T>;
+
+template<typename T=float>
+using Vector4t = Vector<4, T>;
+
+template<size_t N>
+using Vectorf = Vector<N, float>;
+
+template<size_t N>
+using Vectord = Vector<N, double>;
+
+using Vector2f = Vector<2, float>;
+using Vector3f = Vector<3, float>;
+using Vector4f = Vector<4, float>;
+
+using Vector2d = Vector<2, double>;
+using Vector3d = Vector<3, double>;
+using Vector4d = Vector<4, double>;
 
-}} // openage::util
+} // openage::util
diff --git a/libopenage/util/vector_test.cpp b/libopenage/util/vector_test.cpp
index 703e374b88..b619434fc9 100644
--- a/libopenage/util/vector_test.cpp
+++ b/libopenage/util/vector_test.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 "vector.h"
 
@@ -11,17 +11,17 @@ namespace tests {
 void vector() {
 	{
 		// zero-initialization test.
-		Vector<5> zero_explicit{0, 0, 0, 0, 0};
-		Vector<5> zero;
+		Vectorf<5> zero_explicit{0, 0, 0, 0, 0};
+		Vectorf<5> zero;
 
 		zero.equals(zero_explicit) or TESTFAIL;
 	}
 	{
 		// tests in 2 dimensions.
 		// we want to be able to reuse the variable names later.
-		const Vector<2> a(1.0, 2.0);
-		const Vector<2> b(3.0, 4.0);
-		Vector<2> c;
+		const Vectorf<2> a(1.0, 2.0);
+		const Vectorf<2> b(3.0, 4.0);
+		Vectorf<2> c;
 
 		// test basic operators.
 		c = a + b;
@@ -50,9 +50,9 @@ void vector() {
 
 	{
 		// test for the cross_product
-		const Vector<3> a(1.0, 2.0, 3.0);
-		const Vector<3> b(4.0, 5.0, 6.0);
-		Vector<3> c = a.cross_product(b);
+		const Vectorf<3> a(1.0, 2.0, 3.0);
+		const Vectorf<3> b(4.0, 5.0, 6.0);
+		Vectorf<3> c = a.cross_product(b);
 
 		c.equals({-3.0, 6.0, -3.0}) or TESTFAIL;
 	}
diff --git a/openage/CMakeLists.txt b/openage/CMakeLists.txt
index 9464b77826..bd99655053 100644
--- a/openage/CMakeLists.txt
+++ b/openage/CMakeLists.txt
@@ -1,8 +1,7 @@
 # python module configurations
 
-# create python config file
-get_config_option_string()
-configure_file(config.py.in "${CMAKE_SOURCE_DIR}/openage/config.py")
+# python config file is created in libopenage
+# in order to get options from libopenage
 
 add_py_modules(
 	__init__.py
@@ -18,6 +17,7 @@ add_subdirectory(codegen)
 add_subdirectory(convert)
 add_subdirectory(cppinterface)
 add_subdirectory(cvar)
+add_subdirectory(event)
 add_subdirectory(game)
 add_subdirectory(log)
 add_subdirectory(util)
diff --git a/openage/event/CMakeLists.txt b/openage/event/CMakeLists.txt
new file mode 100644
index 0000000000..5cbdcb4856
--- /dev/null
+++ b/openage/event/CMakeLists.txt
@@ -0,0 +1,7 @@
+add_cython_modules(
+	demo.pyx
+)
+
+add_py_modules(
+	__init__.py
+)
diff --git a/openage/event/__init__.py b/openage/event/__init__.py
new file mode 100644
index 0000000000..1444e9556c
--- /dev/null
+++ b/openage/event/__init__.py
@@ -0,0 +1,6 @@
+# Copyright 2018-2018 the openage authors. See copying.md for legal info.
+
+"""
+This package contains the python parts of the event simulation submodule.
+It is the game simulation core.
+"""
diff --git a/openage/event/demo.pyx b/openage/event/demo.pyx
new file mode 100644
index 0000000000..40649019f7
--- /dev/null
+++ b/openage/event/demo.pyx
@@ -0,0 +1,48 @@
+# Copyright 2018-2018 the openage authors. See copying.md for legal info.
+
+"""
+demo for the event system.
+"""
+
+import argparse
+from libcpp cimport bool
+
+import openage.config as config
+from openage.util.math import clamp
+from openage.log import set_loglevel
+from libopenage.event.demo.main cimport curvepong as curvepong_c
+
+
+def curvepong(list argv):
+    """
+    starts curvepong, the event prediction demonstration with pong.
+    """
+
+    cmd = argparse.ArgumentParser(
+        prog='... curvepong',
+        description='Curvepong demonstration for the event prediction engine')
+
+    if config.WITH_NCURSES:
+        cmd.add_argument("--disable-gui", action='store_true',
+                         help="Don't show the ncurses GUI")
+
+    cmd.add_argument("--no-human", action='store_true',
+                     help="Don't allow the human to play, use 2 AIs instead")
+    cmd.add_argument("-v", "--verbose", action="count", default=0,
+                     help="increase program verbosity")
+    cmd.add_argument("-q", "--quiet", action="count", default=0,
+                     help="decrease program verbosity")
+
+    args = cmd.parse_args(argv)
+
+    # default = 30 WARNING, the q and v args in/decrease it
+    set_loglevel(clamp(30 - (args.verbose - args.quiet) * 10, 0, 50))
+
+    cdef bool disable_gui = False
+    if config.WITH_NCURSES:
+        disable_gui = args.disable_gui
+
+    cdef bool no_human = args.no_human
+
+    with nogil:
+        curvepong_c(disable_gui, no_human)
diff --git a/openage/testing/testlist.py b/openage/testing/testlist.py
index ad25302f6d..4777a75b3f 100644
--- a/openage/testing/testlist.py
+++ b/openage/testing/testlist.py
@@ -48,6 +48,8 @@ def demos_py():
            "demonstrates the translation of Python log messages")
     yield ("openage.convert.opus.demo.convert",
            "encodes an opus file from a wave file")
+    yield ("openage.event.demo.curvepong",
+           "play pong on steroids through future prediction")
     yield ("openage.renderer.tests.renderer_demo",
            "showcases the new renderer")
 
@@ -91,6 +93,9 @@ def tests_cpp():
     yield "openage::util::tests::siphash"
     yield "openage::util::tests::array_conversion"
     yield "openage::input::tests::parse_event_string", "keybinds parsing"
+    yield "openage::curve::tests::container"
+    yield "openage::curve::tests::curve_types"
+    yield "openage::event::tests::eventtrigger"
 
 
 def demos_cpp():

From 3154cf08033847cd19b26060f3ad48b43dc5c4c7 Mon Sep 17 00:00:00 2001
From: Jonas Jelten <jj@sft.mx>
Date: Sat, 30 Jun 2018 02:35:35 +0200
Subject: [PATCH 02/18] config: export ncurses availability to python

---
 openage/config.py.in | 6 +++++-
 1 file changed, 5 insertions(+), 1 deletion(-)

diff --git a/openage/config.py.in b/openage/config.py.in
index f1372b6a86..76b2b18d2b 100644
--- a/openage/config.py.in
+++ b/openage/config.py.in
@@ -1,4 +1,4 @@
-# Copyright 2014-2017 the openage authors. See copying.md for legal info.
+# Copyright 2014-2018 the openage authors. See copying.md for legal info.
 
 # ${AUTOGEN_WARNING}
 
@@ -25,6 +25,10 @@ COMPILER = "${CMAKE_CXX_COMPILER_ID} ${CMAKE_CXX_COMPILER_VERSION}"
 COMPILERFLAGS = "${CMAKE_CXX_FLAGS}"
 CYTHONVERSION = "${CYTHON_VERSION}"
 
+# features
+WITH_NCURSES = ("${WITH_NCURSES}" == "true")
+
+
 try:
     importlib.import_module("openage.devmode")
     DEVMODE = True

From 4ab602a6242448bb82eac5db9eafa96d758c7199 Mon Sep 17 00:00:00 2001
From: Jonas Jelten <jj@sft.mx>
Date: Thu, 5 Jul 2018 01:41:28 +0200
Subject: [PATCH 03/18] datastructure: implement pairing heap with shared_ptrs

---
 libopenage/datastructure/pairing_heap.h | 188 +++++++++++++-----------
 libopenage/datastructure/tests.cpp      |  58 ++++----
 libopenage/pathfinding/path.h           |   2 +-
 3 files changed, 129 insertions(+), 119 deletions(-)

diff --git a/libopenage/datastructure/pairing_heap.h b/libopenage/datastructure/pairing_heap.h
index 312da5bccd..97aa966723 100644
--- a/libopenage/datastructure/pairing_heap.h
+++ b/libopenage/datastructure/pairing_heap.h
@@ -16,6 +16,7 @@
  * Algorithmica 1, no. 1-4 (1986): 111-129.
  */
 
+#include <memory>
 #include <functional>
 #include <type_traits>
 #include <unordered_set>
@@ -23,54 +24,56 @@
 #include "../util/compiler.h"
 #include "../error/error.h"
 
-namespace openage {
-namespace datastructure {
+namespace openage::datastructure {
 
-template<class T, class compare=std::less<T>>
-class PairingHeapNode {
+
+template<typename T, typename compare=std::less<T>>
+class PairingHeapNode final : public std::enable_shared_from_this<PairingHeapNode<T, compare>> {
 public:
 	using this_type = PairingHeapNode<T, compare>;
 
-	PairingHeapNode *first_child;
-	PairingHeapNode *prev_sibling;
-	PairingHeapNode *next_sibling;
-	PairingHeapNode *parent;       // for decrease-key and delete
+	std::shared_ptr<this_type> first_child;
+	std::shared_ptr<this_type> prev_sibling;
+	std::shared_ptr<this_type> next_sibling;
+	std::shared_ptr<this_type> parent;       // for decrease-key and delete
 
 	T data;
 	compare cmp;
 
 	PairingHeapNode(const T &data)
 		:
-		first_child{nullptr},
-		prev_sibling{nullptr},
-		next_sibling{nullptr},
-		parent{nullptr},
-		data(data) {
-	}
+		data(data) {}
+
+	PairingHeapNode(T &&data)
+		:
+		data(std::move(data)) {}
+
+	~PairingHeapNode() = default;
 
-	~PairingHeapNode() {}
 
 	/**
 	 * Let this node become a child of the given one.
 	 */
-	void become_child_of(this_type *node) {
-		node->add_child(this);
+	void become_child_of(const std::shared_ptr<this_type> &node) {
+		node->add_child(this->shared_from_this());
 	}
 
 	/**
 	 * Add the given node as a child to this one.
 	 */
-	void add_child(this_type *node) {
+	void add_child(const std::shared_ptr<this_type> &node) {
 		// first child is the most recently attached one
 		// it must not have siblings as they will get lost.
 
 		node->prev_sibling = nullptr;
 		node->next_sibling = this->first_child;
+
 		if (this->first_child != nullptr) {
 			this->first_child->prev_sibling = node;
 		}
+
 		this->first_child = node;
-		node->parent = this;
+		node->parent = this->shared_from_this();
 	}
 
 	/**
@@ -78,16 +81,17 @@ class PairingHeapNode {
 	 * Returns the resulting subtree root node after both
 	 * nodes were compared and linked.
 	 */
-	this_type *link_with(this_type *node) {
-		this_type *linked_root, *linked_child;
+	std::shared_ptr<this_type> link_with(const std::shared_ptr<this_type> &node) {
+		std::shared_ptr<this_type> linked_root;
+		std::shared_ptr<this_type> linked_child;
 
 		if (this->cmp(this->data, node->data)) {
-			linked_root  = this;
+			linked_root  = this->shared_from_this();
 			linked_child = node;
 		}
 		else {
 			linked_root  = node;
-			linked_child = this;
+			linked_child = this->shared_from_this();
 		}
 
 		linked_root->add_child(linked_child);
@@ -99,22 +103,22 @@ class PairingHeapNode {
 	 * Recursive call, one stage for each all childs of the root node.
 	 * This results in the computation of the new subtree root.
 	 */
-	this_type *link_backwards() {
+	std::shared_ptr<this_type> link_backwards() {
 		if (this->next_sibling == nullptr) {
 			// reached end, return this as current root,
 			// the previous siblings will be linked to it.
-			return this;
+			return this->shared_from_this();
 		}
 
 		// recurse to last sibling,
-		this_type *root = this->next_sibling->link_backwards();
+		std::shared_ptr<this_type> node = this->next_sibling->link_backwards();
 
 		// then link ourself to the new root.
 		this->next_sibling = nullptr;
 		this->prev_sibling = nullptr;
-		root->next_sibling = nullptr;
-		root->prev_sibling = nullptr;
-		return root->link_with(this);
+		node->next_sibling = nullptr;
+		node->prev_sibling = nullptr;
+		return node->link_with(this->shared_from_this());
 	}
 
 	/**
@@ -124,7 +128,7 @@ class PairingHeapNode {
 	void loosen() {
 		if (this->parent != nullptr) {
 			// release us from some other node
-			if (this->parent->first_child == this) {
+			if (this->parent->first_child.get() == this) {
 				// we are the first child
 				// make the next sibling the first child
 				this->parent->first_child = this->next_sibling;
@@ -149,12 +153,16 @@ class PairingHeapNode {
 };
 
 
-template<class T,
-         class compare=std::less<T>,
-         class heapnode_t=PairingHeapNode<T, compare>>
-class PairingHeap {
+/**
+ * (Quite) efficient heap implementation.
+ */
+template<typename T,
+         typename compare=std::less<T>,
+         typename heapnode_t=PairingHeapNode<T, compare>>
+class PairingHeap final {
 public:
 	using node_t = heapnode_t;
+	using element_t = std::shared_ptr<node_t>;
 	using this_type = PairingHeap<T, compare, node_t>;
 
 	/**
@@ -166,20 +174,34 @@ class PairingHeap {
 		root_node(nullptr) {
 	}
 
-	~PairingHeap() {
-		this->clear();
-	}
+	~PairingHeap() = default;
 
 	/**
 	 * adds the given item to the heap.
 	 * O(1)
 	 */
-	node_t *push(const T &item) {
-		node_t *new_node = new node_t{item};
+	element_t push(const T &item) {
+		element_t new_node = std::make_shared<node_t>(item);
+		this->push_node(new_node);
+		return new_node;
+	}
+
+	/**
+	 * moves the given item to the heap.
+	 * O(1)
+	 */
+	element_t push(T &&item) {
+		element_t new_node = std::make_shared<node_t>(std::move(item));
 		this->push_node(new_node);
 		return new_node;
 	}
 
+	/**
+	 * returns and removes the smallest item on the heap.
+	 */
+	T pop() {
+		return std::move(this->pop_node()->data);
+	}
 
 	/**
 	 * returns the smallest item on the heap and deletes it.
@@ -187,24 +209,23 @@ class PairingHeap {
 	 *                       _________
 	 * Ω(log log n), O(2^(2*√log log n'))
 	 */
-	T pop() {
+	element_t pop_node() {
 		if (this->root_node == nullptr) {
 			throw Error{MSG(err) << "Can't pop an empty heap!"};
 		}
 
 		// 0. remove tree root, it's the minimum.
-		T ret = this->root_node->data;
-		node_t *current_sibling = this->root_node->first_child;
-		this->delete_node(this->root_node);
+		element_t ret = this->root_node;
+		element_t current_sibling = this->root_node->first_child;
 		this->root_node = nullptr;
 
 		// 1. link root children pairwise, last node may be alone
-		node_t *first_pair = nullptr;
-		node_t *previous_pair = nullptr;
+		element_t first_pair = nullptr;
+		element_t previous_pair = nullptr;
 
 		while (unlikely(current_sibling != nullptr)) {
-			node_t *link0 = current_sibling;
-			node_t *link1 = current_sibling->next_sibling;
+			element_t link0 = current_sibling;
+			element_t link1 = current_sibling->next_sibling;
 
 			// pair link0 and link1
 			if (link1 != nullptr) {
@@ -212,7 +233,7 @@ class PairingHeap {
 				current_sibling = link1->next_sibling;
 
 				// do the link: merges two nodes, smaller one = root.
-				node_t *link_root = link0->link_with(link1);
+				element_t link_root = link0->link_with(link1);
 				link_root->parent = nullptr;
 
 				if (previous_pair == nullptr) {
@@ -250,6 +271,8 @@ class PairingHeap {
 			this->root_node = first_pair->link_backwards();
 		}
 
+		this->node_count -= 1;
+
 		// and it's done!
 		return ret;
 	}
@@ -262,25 +285,24 @@ class PairingHeap {
 	 * and merge these trees.
 	 * O(1)
 	 */
-	T pop_node(node_t *node) {
+	void erase_node(const element_t &node) {
 		if (node == this->root_node) {
-			return this->pop();
-		} else {
-			T ret = node->data;
+			this->pop();
+		}
+		else {
 			node->loosen();
-			node_t *child = node->first_child;
+			element_t child = node->first_child;
 
 			// merge all children of the node to pop
 			while (child != nullptr) {
-				node_t *next = child->next_sibling;
+				element_t next = child->next_sibling;
 				child->parent = nullptr;
 				child->loosen();
 				this->root_node = this->root_node->link_with(child);
 				child = next;
 			}
 
-			this->delete_node(node);
-			return ret;
+			this->node_count -= 1;
 		}
 	}
 
@@ -288,17 +310,25 @@ class PairingHeap {
 	 * Returns the smallest item on the heap.
 	 * O(1)
 	 */
-	T top() const {
+	const T &top() const {
 		return this->root_node->data;
 	}
 
+	/**
+	 * Returns the smallest node on the heap.
+	 * O(1)
+	 */
+	const element_t &top_node() const {
+		return this->root_node;
+	}
+
 	/**
 	 * Update a given node.
 	 * This cuts the subtree and links the subtree again.
 	 * Also known as the decrease_key operation.
 	 * O(1)
 	 */
-	void update(node_t *node) {
+	void update(const element_t &node) {
 		// decreasing the root node won't change it.
 		if (likely(node != this->root_node)) {
 			node->loosen();
@@ -307,20 +337,18 @@ class PairingHeap {
 			// relink node.childs with rootnode. Might be a nice feature
 			// someday.
 		}
+		else {
+			// it's the root node, so we just pop and push it.
+			this->push_node(this->pop_node());
+		}
 	}
 
 	/**
 	 * erase all elements on the heap.
 	 */
 	void clear() {
-		for (auto it = this->nodes.begin(); it != this->nodes.end();) {
-			// srsly fak u c++ why you so broken pls
-			auto to_erase = it;
-			delete *to_erase;
-			++it;
-			this->nodes.erase(to_erase);
-			this->node_count -= 1;
-		}
+		this->root_node = nullptr;
+		this->node_count = 0;
 	}
 
 	/**
@@ -334,7 +362,7 @@ class PairingHeap {
 	 * @returns whether there are no nodes stored on the heap.
 	 */
 	bool empty() const {
-		return (this->node_count == 0);
+		return this->node_count == 0;
 	}
 
 protected:
@@ -342,38 +370,20 @@ class PairingHeap {
 	 * adds the given node to the heap.
 	 * O(1)
 	 */
-	void push_node(node_t *node) {
+	void push_node(const element_t &node) {
 		if (unlikely(this->root_node == nullptr)) {
 			this->root_node = node;
 		} else {
 			this->root_node = this->root_node->link_with(node);
 		}
 
-		this->nodes.insert(node);
 		this->node_count += 1;
 	}
 
-	/**
-	 * Erase a node from the heap freeing its memory.
-	 */
-	void delete_node(node_t *node) {
-		auto it = this->nodes.find(node);
-		if (likely(it != this->nodes.end())) {
-			this->nodes.erase(it);
-			delete node;
-			this->node_count -= 1;
-		} else {
-			throw Error{MSG(err) << "Specified node not found for deletion!"};
-		}
-	}
-
-
 protected:
-	size_t node_count;
 	compare cmp;
-	node_t *root_node;
-
-	std::unordered_set<node_t *> nodes;
+	size_t node_count;
+	element_t root_node;
 };
 
-}} // openage::datastructure
+} // openage::datastructure
diff --git a/libopenage/datastructure/tests.cpp b/libopenage/datastructure/tests.cpp
index c95b792dd7..cb0b61b4fe 100644
--- a/libopenage/datastructure/tests.cpp
+++ b/libopenage/datastructure/tests.cpp
@@ -27,38 +27,38 @@ void pairing_heap_0() {
 	heap.push(4);
 
 	// state: 01234
-	(heap.size() == 5) or TESTFAIL;
-	(heap.top() == 0) or TESTFAIL;
+	TESTEQUALS(heap.size(), 5);
+	TESTEQUALS(heap.top(), 0);
 
-	(0 == heap.pop()) or TESTFAIL;
-	(1 == heap.pop()) or TESTFAIL;
-	(2 == heap.pop()) or TESTFAIL;
-	(3 == heap.pop()) or TESTFAIL;
+	TESTEQUALS(heap.pop(), 0);
+	TESTEQUALS(heap.pop(), 1);
+	TESTEQUALS(heap.pop(), 2);
+	TESTEQUALS(heap.pop(), 3);
 
-	(heap.size() == 1) or TESTFAIL;
+	TESTEQUALS(heap.size(), 1);
 
 	heap.push(0);
 	heap.push(10);
 
 	// state: 0 4 10
 
-	(0 == heap.pop()) or TESTFAIL;
-	(4 == heap.pop()) or TESTFAIL;
-	(10 == heap.pop()) or TESTFAIL;
-	(heap.size() == 0) or TESTFAIL;
+	TESTEQUALS(heap.pop(), 0);
+	TESTEQUALS(heap.pop(), 4);
+	TESTEQUALS(heap.pop(), 10);
+	TESTEQUALS(heap.size(), 0);
 
 	heap.push(5);
 	heap.push(5);
 	heap.push(0);
 	heap.push(5);
 	heap.push(5);
-	(0 == heap.pop()) or TESTFAIL;
-	(5 == heap.pop()) or TESTFAIL;
-	(5 == heap.pop()) or TESTFAIL;
-	(5 == heap.pop()) or TESTFAIL;
-	(5 == heap.pop()) or TESTFAIL;
+	TESTEQUALS(heap.pop(), 0);
+	TESTEQUALS(heap.pop(), 5);
+	TESTEQUALS(heap.pop(), 5);
+	TESTEQUALS(heap.pop(), 5);
+	TESTEQUALS(heap.pop(), 5);
 
-	(heap.size() == 0) or TESTFAIL;
+	TESTEQUALS(heap.size(), 0);
 }
 
 
@@ -73,9 +73,9 @@ void pairing_heap_1() {
 	heap.update(node);
 
 	// 0 1 3
-	(0 == heap.pop().data) or TESTFAIL;
-	(1 == heap.pop().data) or TESTFAIL;
-	(3 == heap.pop().data) or TESTFAIL;
+	TESTEQUALS(heap.pop().data, 0);
+	TESTEQUALS(heap.pop().data, 1);
+	TESTEQUALS(heap.pop().data, 3);
 }
 
 
@@ -85,12 +85,12 @@ void pairing_heap_2() {
 	auto node = heap.push(heap_elem{2});
 	heap.push(heap_elem{3});
 
-	// state: 1 2 3
-	(heap.pop_node(node).data == 2) or TESTFAIL;
+	// state: 1 2 3, now remove 2
+	heap.erase_node(node);
 
 	// state: 1 3
-	(1 == heap.pop().data) or TESTFAIL;
-	(3 == heap.pop().data) or TESTFAIL;
+	TESTEQUALS(heap.pop().data, 1);
+	TESTEQUALS(heap.pop().data, 3);
 }
 
 
@@ -106,8 +106,8 @@ void pairing_heap_3() {
 
 	heap.clear();
 
-	(heap.size() == 0) or TESTFAIL;
-	(heap.empty() == true) or TESTFAIL;
+	TESTEQUALS(heap.size(), 0);
+	TESTEQUALS(heap.empty(), true);
 }
 
 
@@ -157,9 +157,9 @@ void constexpr_map() {
 	cmap.contains(0) or TESTFAIL;
 	not cmap.contains(18) or TESTFAIL;
 
-	cmap.size() == 3 or TESTFAIL;
-	cmap.get(13) == 37 or TESTFAIL;
-	cmap.get(42) == 9001 or TESTFAIL;
+	TESTEQUALS(cmap.size(), 3);
+	TESTEQUALS(cmap.get(13), 37);
+	TESTEQUALS(cmap.get(42), 9001);
 }
 
 }}} // openage::datastructure::tests
diff --git a/libopenage/pathfinding/path.h b/libopenage/pathfinding/path.h
index 9b131b3c82..388d8259ec 100644
--- a/libopenage/pathfinding/path.h
+++ b/libopenage/pathfinding/path.h
@@ -169,7 +169,7 @@ class Node: public std::enable_shared_from_this<Node> {
 	/**
 	 * Priority queue node that contains this path node.
 	 */
-	heap_t::node_t* heap_node;
+	heap_t::element_t heap_node;
 };
 
 

From 4e5b8814797ca8f20490c9425f04715c9def2603 Mon Sep 17 00:00:00 2001
From: Jonas Jelten <jj@sft.mx>
Date: Sat, 7 Jul 2018 14:10:38 +0200
Subject: [PATCH 04/18] datastructure: add move constructor for constexpr_map

---
 libopenage/datastructure/constexpr_map.h | 9 +++++++--
 1 file changed, 7 insertions(+), 2 deletions(-)

diff --git a/libopenage/datastructure/constexpr_map.h b/libopenage/datastructure/constexpr_map.h
index 37325fbf4b..04a23570d1 100644
--- a/libopenage/datastructure/constexpr_map.h
+++ b/libopenage/datastructure/constexpr_map.h
@@ -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.
 
 #pragma once
 
@@ -22,11 +22,16 @@ class ConstMapEntry {
 		key{key},
 		value{value} {}
 
-	constexpr ConstMapEntry(std::pair<K, V> pair)
+	constexpr ConstMapEntry(const std::pair<K, V> &pair)
 		:
 		key{pair.first},
 		value{pair.second} {}
 
+	constexpr ConstMapEntry(std::pair<K, V> &&pair)
+		:
+		key{std::move(pair.first)},
+		value{std::move(pair.second)} {}
+
 	/**
 	 * Map entry key.
 	 */

From dbcd0c69e3d16783974620d6e6e853efa63b4c60 Mon Sep 17 00:00:00 2001
From: Jonas Jelten <jj@sft.mx>
Date: Sat, 7 Jul 2018 14:14:19 +0200
Subject: [PATCH 05/18] datastructure: fix heap corruption bugs

---
 libopenage/datastructure/pairing_heap.h | 179 ++++++++++++++++--------
 libopenage/datastructure/tests.cpp      |  38 ++++-
 2 files changed, 151 insertions(+), 66 deletions(-)

diff --git a/libopenage/datastructure/pairing_heap.h b/libopenage/datastructure/pairing_heap.h
index 97aa966723..bc351250a0 100644
--- a/libopenage/datastructure/pairing_heap.h
+++ b/libopenage/datastructure/pairing_heap.h
@@ -27,29 +27,40 @@
 namespace openage::datastructure {
 
 
+template<typename T,
+         typename compare,
+         typename heapnode_t>
+class PairingHeap;
+
+
+
 template<typename T, typename compare=std::less<T>>
-class PairingHeapNode final : public std::enable_shared_from_this<PairingHeapNode<T, compare>> {
+class PairingHeapNode : public std::enable_shared_from_this<PairingHeapNode<T, compare>> {
 public:
 	using this_type = PairingHeapNode<T, compare>;
 
-	std::shared_ptr<this_type> first_child;
-	std::shared_ptr<this_type> prev_sibling;
-	std::shared_ptr<this_type> next_sibling;
-	std::shared_ptr<this_type> parent;       // for decrease-key and delete
+	friend PairingHeap<T, compare, this_type>;
 
 	T data;
 	compare cmp;
 
+public:
 	PairingHeapNode(const T &data)
 		:
-		data(data) {}
+		data{data} {}
 
 	PairingHeapNode(T &&data)
 		:
-		data(std::move(data)) {}
+		data{std::move(data)} {}
 
 	~PairingHeapNode() = default;
 
+	/**
+	 * Get contained node data.
+	 */
+	const T &get_data() const {
+		return this->data;
+	}
 
 	/**
 	 * Let this node become a child of the given one.
@@ -61,41 +72,54 @@ class PairingHeapNode final : public std::enable_shared_from_this<PairingHeapNod
 	/**
 	 * Add the given node as a child to this one.
 	 */
-	void add_child(const std::shared_ptr<this_type> &node) {
+	void add_child(const std::shared_ptr<this_type> &new_child) {
 		// first child is the most recently attached one
 		// it must not have siblings as they will get lost.
 
-		node->prev_sibling = nullptr;
-		node->next_sibling = this->first_child;
+		new_child->prev_sibling = nullptr;
+		new_child->next_sibling = this->first_child;
 
 		if (this->first_child != nullptr) {
-			this->first_child->prev_sibling = node;
+			this->first_child->prev_sibling = new_child;
 		}
 
-		this->first_child = node;
-		node->parent = this->shared_from_this();
+		this->first_child = new_child;
+		new_child->parent = this->shared_from_this();
 	}
 
 	/**
-	 * Links the given subtree root node with this one.
-	 * Returns the resulting subtree root node after both
-	 * nodes were compared and linked.
+	 * This method decides which node becomes the new root node
+	 * by comparing `this` with `node`.
+	 * The new root is returned, it has the other node as child.
 	 */
 	std::shared_ptr<this_type> link_with(const std::shared_ptr<this_type> &node) {
-		std::shared_ptr<this_type> linked_root;
-		std::shared_ptr<this_type> linked_child;
+		std::shared_ptr<this_type> new_root;
+		std::shared_ptr<this_type> new_child;
 
 		if (this->cmp(this->data, node->data)) {
-			linked_root  = this->shared_from_this();
-			linked_child = node;
+			new_root  = this->shared_from_this();
+			new_child = node;
 		}
 		else {
-			linked_root  = node;
-			linked_child = this->shared_from_this();
+			new_root  = node;
+			new_child = this->shared_from_this();
 		}
 
-		linked_root->add_child(linked_child);
-		return linked_root;
+		// children of new root become siblings of new new_child
+		// -> parent of new child = new root
+
+		// this whll be set by the add_child method
+		new_child->prev_sibling = nullptr;
+		new_child->next_sibling = nullptr;
+
+		// this is then set to the previous pair root:
+		new_root->prev_sibling = nullptr;
+		new_root->next_sibling = nullptr;
+
+		// set up the child
+		new_root->add_child(new_child);
+
+		return new_root;
 	}
 
 	/**
@@ -118,38 +142,43 @@ class PairingHeapNode final : public std::enable_shared_from_this<PairingHeapNod
 		this->prev_sibling = nullptr;
 		node->next_sibling = nullptr;
 		node->prev_sibling = nullptr;
-		return node->link_with(this->shared_from_this());
+		return this->link_with(node);
 	}
 
 	/**
-	 * Cut this node from all parent and sibling connections.
+	 * Cut this node from all parent and sibling connections,
+	 * but keeps the child pointer.
 	 * This effectively cuts out the subtree.
 	 */
 	void loosen() {
-		if (this->parent != nullptr) {
-			// release us from some other node
-			if (this->parent->first_child.get() == this) {
-				// we are the first child
-				// make the next sibling the first child
-				this->parent->first_child = this->next_sibling;
-			}
-			// if we have a previous sibling
-			if (this->prev_sibling != nullptr) {
-				// set its next sibling to skip us.
-				this->prev_sibling->next_sibling = this->next_sibling;
-			}
-			// if we have a next sibling
-			if (this->next_sibling != nullptr) {
-				// tell its previous sibling to skip us.
-				this->next_sibling->prev_sibling = this->prev_sibling;
-			}
-
-			// reset sibling and parent ptrs.
-			this->prev_sibling = nullptr;
-			this->next_sibling = nullptr;
-			this->parent = nullptr;
+		// release us from some other node
+		if (this->parent and this->parent->first_child == this->shared_from_this()) {
+			// we are the first child
+			// make the next sibling the first child
+			this->parent->first_child = this->next_sibling;
+		}
+		// if we have a previous sibling
+		if (this->prev_sibling != nullptr) {
+			// set its next sibling to skip us.
+			this->prev_sibling->next_sibling = this->next_sibling;
 		}
+		// if we have a next sibling
+		if (this->next_sibling != nullptr) {
+			// tell its previous sibling to skip us.
+			this->next_sibling->prev_sibling = this->prev_sibling;
+		}
+
+		// reset sibling and parent ptrs.
+		this->prev_sibling = nullptr;
+		this->next_sibling = nullptr;
+		this->parent = nullptr;
 	}
+
+private:
+	std::shared_ptr<this_type> first_child;
+	std::shared_ptr<this_type> prev_sibling;
+	std::shared_ptr<this_type> next_sibling;
+	std::shared_ptr<this_type> parent;       // for decrease-key and delete
 };
 
 
@@ -266,6 +295,7 @@ class PairingHeap final {
 			}
 		}
 
+
 		// 2. then link remaining trees to the last one, from right to left
 		if (first_pair != nullptr) {
 			this->root_node = first_pair->link_backwards();
@@ -273,35 +303,43 @@ class PairingHeap final {
 
 		this->node_count -= 1;
 
+		// (to find those two lines, 14h of debugging passed)
+		ret->loosen();
+		ret->first_child = nullptr;
+
 		// and it's done!
 		return ret;
 	}
 
 	/**
-	 * Delete a node from the heap.
+	 * Unlink a node from the heap.
 	 *
 	 * If the item is the current root, just pop().
 	 * else, cut the node from its parent, pop() that subtree
 	 * and merge these trees.
-	 * O(1)
+	 *
+	 * O(1), O(pop) if node is the root
 	 */
-	void erase_node(const element_t &node) {
+	void unlink_node(const element_t &node) {
 		if (node == this->root_node) {
-			this->pop();
+			this->pop_node();
 		}
 		else {
 			node->loosen();
 			element_t child = node->first_child;
 
-			// merge all children of the node to pop
+			// merge all children of the node to unlink
 			while (child != nullptr) {
 				element_t next = child->next_sibling;
-				child->parent = nullptr;
 				child->loosen();
-				this->root_node = this->root_node->link_with(child);
+				this->push_node(child);
+
 				child = next;
 			}
 
+			// to create this line, 13h of debugging were required.
+			node->first_child = nullptr;
+
 			this->node_count -= 1;
 		}
 	}
@@ -311,11 +349,12 @@ class PairingHeap final {
 	 * O(1)
 	 */
 	const T &top() const {
-		return this->root_node->data;
+		return this->root_node->get_data();
 	}
 
 	/**
 	 * Returns the smallest node on the heap.
+	 *
 	 * O(1)
 	 */
 	const element_t &top_node() const {
@@ -323,19 +362,35 @@ class PairingHeap final {
 	}
 
 	/**
-	 * Update a given node.
+	 * You must call this after the node data decreased.
 	 * This cuts the subtree and links the subtree again.
+	 * If the node value _increased_ and you call this,
+	 * the heap is corrupted.
 	 * Also known as the decrease_key operation.
+	 *
 	 * O(1)
 	 */
-	void update(const element_t &node) {
-		// decreasing the root node won't change it.
+	void decrease(const element_t &node) {
 		if (likely(node != this->root_node)) {
+			// cut out the node and its subtree
 			node->loosen();
 			this->root_node = node->link_with(this->root_node);
-			// TODO: if increasing value (=contradicting 'decrease_key'),
-			// relink node.childs with rootnode. Might be a nice feature
-			// someday.
+		}
+		// decreasing the root node won't change it, so we do nothing.
+	}
+
+	/**
+	 * After a change, call this to reorganize the given node.
+	 * Support increase and decrease of values.
+	 *
+	 * Use `decrease` instead when you know the value decreased.
+	 *
+	 * O(1) (but slower than decrease), and O(pop) when node is the root.
+	 */
+	void update(const element_t &node) {
+		if (likely(node != this->root_node)) {
+			this->unlink_node(node);
+			this->push_node(node);
 		}
 		else {
 			// it's the root node, so we just pop and push it.
diff --git a/libopenage/datastructure/tests.cpp b/libopenage/datastructure/tests.cpp
index cb0b61b4fe..526e4e32c0 100644
--- a/libopenage/datastructure/tests.cpp
+++ b/libopenage/datastructure/tests.cpp
@@ -65,17 +65,47 @@ void pairing_heap_0() {
 void pairing_heap_1() {
 	PairingHeap<heap_elem> heap{};
 	heap.push(heap_elem{1});
-	auto node = heap.push(heap_elem{2});
+	auto node_u1 = heap.push(heap_elem{2});
 	heap.push(heap_elem{3});
 
 	// 1 2 3
-	node->data.data = 0;
-	heap.update(node);
+	node_u1->data.data = 0;
+	heap.decrease(node_u1);
 
 	// 0 1 3
 	TESTEQUALS(heap.pop().data, 0);
 	TESTEQUALS(heap.pop().data, 1);
+
+	// 3
+	heap.push(heap_elem{4});
+	heap.push(heap_elem{0});
+	heap.push(heap_elem{2});
+	heap.push(heap_elem{5});
+	heap.push(heap_elem{1});
+	heap.push(heap_elem{6});
+	auto node_u2 = heap.push(heap_elem{7});
+	heap.push(heap_elem{8});
+	heap.push(heap_elem{9});
+	heap.push(heap_elem{10});
+
+	TESTEQUALS(heap.pop().data, 0);
+
+	TESTEQUALS(heap.pop().data, 1);
+
+	// now update the 7-node to 8
+	node_u2->data.data = 8;
+	heap.update(node_u2);
+
+	// 2 3 4 5 6 8 8 9 10
+	TESTEQUALS(heap.pop().data, 2);
 	TESTEQUALS(heap.pop().data, 3);
+	TESTEQUALS(heap.pop().data, 4);
+	TESTEQUALS(heap.pop().data, 5);
+	TESTEQUALS(heap.pop().data, 6);
+	TESTEQUALS(heap.pop().data, 8);
+	TESTEQUALS(heap.pop().data, 8);
+	TESTEQUALS(heap.pop().data, 9);
+	TESTEQUALS(heap.pop().data, 10);
 }
 
 
@@ -86,7 +116,7 @@ void pairing_heap_2() {
 	heap.push(heap_elem{3});
 
 	// state: 1 2 3, now remove 2
-	heap.erase_node(node);
+	heap.unlink_node(node);
 
 	// state: 1 3
 	TESTEQUALS(heap.pop().data, 1);

From bdca6e29eca6283b4ae722b9cb04c693e3535430 Mon Sep 17 00:00:00 2001
From: Jonas Jelten <jj@sft.mx>
Date: Sat, 7 Jul 2018 14:18:39 +0200
Subject: [PATCH 06/18] event: use heap structure for event queuing

---
 libopenage/event/CMakeLists.txt     |   1 +
 libopenage/event/demo/main.cpp      |   2 +-
 libopenage/event/event.cpp          |   4 +
 libopenage/event/event.h            |   5 +
 libopenage/event/eventqueue.cpp     | 152 ++++++++--------------------
 libopenage/event/eventqueue.h       |  56 +++++-----
 libopenage/event/eventstore.cpp     | 124 +++++++++++++++++++++++
 libopenage/event/eventstore.h       |  50 +++++++++
 libopenage/event/loop.cpp           |  41 ++++++--
 libopenage/event/tests.cpp          |  13 ++-
 libopenage/terrain/terrain_object.h |   1 -
 libopenage/util/misc.h              |  28 ++++-
 12 files changed, 317 insertions(+), 160 deletions(-)
 create mode 100644 libopenage/event/eventstore.cpp
 create mode 100644 libopenage/event/eventstore.h

diff --git a/libopenage/event/CMakeLists.txt b/libopenage/event/CMakeLists.txt
index e89a4f8734..b4231385ff 100644
--- a/libopenage/event/CMakeLists.txt
+++ b/libopenage/event/CMakeLists.txt
@@ -3,6 +3,7 @@ add_sources(libopenage
 	eventclass.cpp
 	eventfilter.cpp
 	eventqueue.cpp
+	eventstore.cpp
 	eventtarget.cpp
 	loop.cpp
 	state.cpp
diff --git a/libopenage/event/demo/main.cpp b/libopenage/event/demo/main.cpp
index 174920ba28..033a7d6f4c 100644
--- a/libopenage/event/demo/main.cpp
+++ b/libopenage/event/demo/main.cpp
@@ -144,7 +144,7 @@ void curvepong(bool disable_gui, bool no_human) {
 
 				int pos = 1;
 				mvprintw(pos++, state->display_boundary[0]/2 + 10, "Enqueued events:");
-				for (const auto &e : loop->get_queue().get_event_queue()) {
+				for (const auto &e : loop->get_queue().get_event_queue().get_sorted_events()) {
 					mvprintw(pos++, state->display_boundary[0]/2 + 10,
 					         "%f: %s",
 					         e->get_time().to_double(),
diff --git a/libopenage/event/event.cpp b/libopenage/event/event.cpp
index a670e5c332..c014ed2991 100644
--- a/libopenage/event/event.cpp
+++ b/libopenage/event/event.cpp
@@ -34,4 +34,8 @@ void Event::depend_on(const std::shared_ptr<EventTarget> &dependency) {
 }
 
 
+bool Event::operator <(const Event &other) const {
+	return this->time < other.time;
+}
+
 } // openage::event
diff --git a/libopenage/event/event.h b/libopenage/event/event.h
index 27dbfc031a..431d059016 100644
--- a/libopenage/event/event.h
+++ b/libopenage/event/event.h
@@ -60,6 +60,11 @@ class Event : public std::enable_shared_from_this<Event> {
 	 */
 	void depend_on(const std::shared_ptr<EventTarget> &dependency);
 
+	/**
+	 * For sorting events by their trigger time.
+	 */
+	bool operator <(const Event &other) const;
+
 	curve::time_t last_triggered = 0;
 
 private:
diff --git a/libopenage/event/eventqueue.cpp b/libopenage/event/eventqueue.cpp
index 68a08764d8..a99b3898e4 100644
--- a/libopenage/event/eventqueue.cpp
+++ b/libopenage/event/eventqueue.cpp
@@ -8,15 +8,16 @@
 #include "eventclass.h"
 #include "eventtarget.h"
 #include "../log/log.h"
+#include "../util/compiler.h"
 
 
 namespace openage::event {
 
-std::weak_ptr<Event> EventQueue::create_event(const std::shared_ptr<EventTarget> &trgt,
-                                              const std::shared_ptr<EventClass> &cls,
-                                              const std::shared_ptr<State> &state,
-                                              const curve::time_t &reference_time,
-                                              const EventClass::param_map &params) {
+std::shared_ptr<Event> EventQueue::create_event(const std::shared_ptr<EventTarget> &trgt,
+                                                const std::shared_ptr<EventClass> &cls,
+                                                const std::shared_ptr<State> &state,
+                                                const curve::time_t &reference_time,
+                                                const EventClass::param_map &params) {
 
 	auto event = std::make_shared<Event>(trgt, cls, params);
 
@@ -30,7 +31,11 @@ std::weak_ptr<Event> EventQueue::create_event(const std::shared_ptr<EventTarget>
 		                     ->predict_invoke_time(trgt, state, reference_time));
 
 		if (event->get_time() == std::numeric_limits<curve::time_t>::min()) {
-			return std::weak_ptr<Event>();
+			log::log(DBG << "Queue: ignoring insertion of event "
+			         << event->get_eventclass()->id() <<
+			         " because no execution was scheduled.");
+
+			return {};
 		}
 		break;
 
@@ -43,8 +48,26 @@ std::weak_ptr<Event> EventQueue::create_event(const std::shared_ptr<EventTarget>
 	log::log(DBG << "Queue: inserting event " << event->get_eventclass()->id() <<
 	         " into queue to be executed at t=" << event->get_time());
 
-	auto &queue = this->select_queue(event->get_eventclass()->type);
-	queue.emplace_back(event);
+	// store the event
+	// or enqueue it for execution
+	switch(event->get_eventclass()->type) {
+	case EventClass::trigger_type::DEPENDENCY:
+		this->dependency_events.insert(event);
+		break;
+
+	case EventClass::trigger_type::DEPENDENCY_IMMEDIATELY:
+		this->dependency_immediately_events.insert(event);
+		break;
+
+	case EventClass::trigger_type::TRIGGER:
+		this->trigger_events.insert(event);
+		break;
+
+	case EventClass::trigger_type::REPEAT:
+	case EventClass::trigger_type::ONCE:
+	default:
+		this->event_queue.push(event);
+	}
 
 	return event;
 }
@@ -104,115 +127,29 @@ void EventQueue::add_change(const std::shared_ptr<Event> &event,
 
 
 void EventQueue::remove(const std::shared_ptr<Event> &evnt) {
-	auto &queue = this->select_queue(evnt->get_eventclass()->type);
-	auto it = std::find(std::begin(queue), std::end(queue), evnt);
-
-	if (it != queue.end()) {
-		queue.erase(it);
-	}
-}
-
-
-std::deque<std::shared_ptr<Event>> &EventQueue::select_queue(EventClass::trigger_type type) {
-	switch(type) {
-	case EventClass::trigger_type::DEPENDENCY:
-		return this->dependency_queue;
-
-	case EventClass::trigger_type::DEPENDENCY_IMMEDIATELY:
-		return this->dependency_immediately_queue;
-
-	case EventClass::trigger_type::TRIGGER:
-		return this->trigger_queue;
-
-	case EventClass::trigger_type::REPEAT:
-	case EventClass::trigger_type::ONCE:
-	default:
-		return this->event_queue;
-	}
+	// TODO: remove the event from the other storages.
+	//       this would require changes to dependent events and triggers.
+	//       (to stop being a dependent event or allow being triggered)
+	this->event_queue.erase(evnt);
 }
 
 
-void EventQueue::update(const std::shared_ptr<Event> &evnt) {
-	decltype(this->event_queue)::iterator it = std::find(std::begin(this->event_queue),
-	                                                     std::end(this->event_queue),
-	                                                     evnt);
-
-	if (it != this->event_queue.end()) { // we only want to update the pending queue
-		int dir = 0;
-
-		{
-			auto nxt = std::next(it);
-			if (nxt != std::end(this->event_queue) and
-			    (*nxt)->get_time() < (*it)->get_time()) {
-				dir -= 1;
-			}
-			auto prv = std::prev(it);
-			if (it != std::begin(this->event_queue) and
-			    (*prv)->get_time() > (*it)->get_time()) {
-				dir += 1;
-			}
-			// dir is now one of these values:
-			// 0: the element is perfectly placed
-			// +: the elements time is too low for its position, move forward
-			// -: the elements time is too high for its position, move backwards
-		}
-
-		if (dir == 0) {
-			// do nothing
-		}
-		else if (dir > 0) {
-			auto e = *it;
-			it = this->event_queue.erase(it);
-			while (it != this->event_queue.begin()
-			       && evnt->get_time() < (*std::prev(it))->get_time()) {
-				it--;
-			}
-			this->event_queue.insert(it, e);
-		}
-		else if (dir < 0) {
-			auto e = *it;
-			it = this->event_queue.erase(it);
-			while (it != this->event_queue.end()
-			       && evnt->get_time() > (*std::prev(it))->get_time()) {
-				it++;
-			}
-			this->event_queue.insert(it, e);
-		}
-
-		log::log(DBG << "Queue: readded Element: " << evnt->get_eventclass()->id()
-		         << " at t=" << evnt->get_time());
+void EventQueue::enqueue_change(const std::shared_ptr<Event> &evnt) {
+	if (this->event_queue.contains(evnt)) {
+		this->event_queue.update(evnt);
 	}
 	else {
-		it = std::find_if(
-			std::begin(this->event_queue),
-			std::end(this->event_queue),
-			[&evnt] (const std::shared_ptr<Event> &e) {
-				return e->get_time() > evnt->get_time();
-			}
-		);
-
-		this->event_queue.insert(it, evnt);
-		log::log(DBG << "Queue: inserted Element: " << evnt->get_eventclass()->id()
-		         << " at t=" << evnt->get_time());
+		this->event_queue.push(evnt);
 	}
 }
 
 
-void EventQueue::readd(const std::shared_ptr<Event> &evnt) {
-	auto &container = this->select_queue(evnt->get_eventclass()->type);
-
-	auto it = std::find_if(
-		std::begin(container),
-		std::end(container),
-		[&evnt](const std::shared_ptr<Event> &element) {
-			return element->get_time() < evnt->get_time();
-		}
-	);
-	container.insert(it, evnt);
+void EventQueue::reenqueue(const std::shared_ptr<Event> &evnt) {
+	this->event_queue.push(evnt);
 }
 
 
-const std::deque<std::shared_ptr<Event>> &EventQueue::get_event_queue() const {
+const EventStore &EventQueue::get_event_queue() const {
 	return this->event_queue;
 }
 
@@ -222,13 +159,13 @@ std::shared_ptr<Event> EventQueue::take_event(const curve::time_t &max_time) {
 		return nullptr;
 	}
 
-	std::shared_ptr<Event> event = this->event_queue.front();
+	std::shared_ptr<Event> event = this->event_queue.top();
 
 	// check if this event should be processed
 	// we take any event that happens <= max_time
 	if (event->get_time() <= max_time) {
 		// remove the event from the queue
-		this->event_queue.pop_front();
+		this->event_queue.pop();
 
 		return event;
 	}
@@ -280,5 +217,4 @@ size_t EventQueue::OnChangeElement::Equal::operator()(const OnChangeElement& lef
 	left_trgt->id() == right_trgt->id();
 }
 
-
 } // namespace openage::event
diff --git a/libopenage/event/eventqueue.h b/libopenage/event/eventqueue.h
index 1500c7b1ac..a2ca894f11 100644
--- a/libopenage/event/eventqueue.h
+++ b/libopenage/event/eventqueue.h
@@ -2,13 +2,14 @@
 
 #pragma once
 
-#include <deque>
 #include <memory>
 #include <unordered_set>
 
 #include "eventclass.h"
+#include "eventstore.h"
 #include "../curve/curve.h"
 
+
 namespace openage::event {
 
 class Event;
@@ -18,7 +19,7 @@ class EventTarget;
 /**
  * The core event class for execution and execution dependencies.
  */
-class EventQueue {
+class EventQueue final {
 public:
 
 	class OnChangeElement {
@@ -32,15 +33,15 @@ class EventQueue {
 
 		class Hasher : public std::unary_function<OnChangeElement, size_t> {
 		public:
-			size_t operator()(const OnChangeElement& e) const {
+			size_t operator ()(const OnChangeElement& e) const {
 				return e.hash;
 			}
 		};
 
 		class Equal : public std::unary_function<OnChangeElement, size_t> {
 		public:
-			size_t operator()(const OnChangeElement& left,
-			                  const OnChangeElement& right) const;
+			size_t operator ()(const OnChangeElement& left,
+			                   const OnChangeElement& right) const;
 		};
 	};
 
@@ -63,11 +64,11 @@ class EventQueue {
 	 * The `insertion_time` is the time used to calculate when
 	 * the actual event time will happen!
 	 */
-	std::weak_ptr<Event> create_event(const std::shared_ptr<EventTarget> &eventtarget,
-	                                  const std::shared_ptr<EventClass> &eventclass,
-	                                  const std::shared_ptr<State> &state,
-	                                  const curve::time_t &reference_time,
-	                                  const EventClass::param_map &params);
+	std::shared_ptr<Event> create_event(const std::shared_ptr<EventTarget> &eventtarget,
+	                                    const std::shared_ptr<EventClass> &eventclass,
+	                                    const std::shared_ptr<State> &state,
+	                                    const curve::time_t &reference_time,
+	                                    const EventClass::param_map &params);
 
 	/**
 	 * Remove the given event from the queue.
@@ -75,15 +76,18 @@ class EventQueue {
 	void remove(const std::shared_ptr<Event> &evnt);
 
 	/**
-	 * The event may be already part of the execution queue,
-	 * so update it, if it shall be executed in the future.
+	 * An update to existing events has to be applied.
+	 * The execution time of this event may have changed or it
+	 * is newly created. This updates/inserts the given event
+	 * in the main queue.
 	 */
-	void update(const std::shared_ptr<Event> &);
+	void enqueue_change(const std::shared_ptr<Event> &event);
 
 	/**
-	 * The event was just removed.
+	 * The event was just removed, add it again.
+	 * This is used for REPEAT events so that they are repeated.
 	 */
-	void readd(const std::shared_ptr<Event> &);
+	void reenqueue(const std::shared_ptr<Event> &event);
 
 	/**
 	 * An event target has changed, and the event shall be retriggered
@@ -94,7 +98,7 @@ class EventQueue {
 	/**
 	 * Get an accessor to the running queue for state output purpose.
 	 */
-	const std::deque<std::shared_ptr<Event>> &get_event_queue() const;
+	const EventStore &get_event_queue() const;
 
 	/**
 	 * Obtain the next event from the `event_queue` that happens before `<= max_time`.
@@ -129,30 +133,26 @@ class EventQueue {
 	change_set changeset_B;
 
 	/**
-	 * Get a reference to the correct event queue by
-	 * the given trigger type.
-	 */
-	std::deque<std::shared_ptr<Event>> &select_queue(EventClass::trigger_type type);
-
-	/**
-	 * Will trigger itself and add to the queue.
+	 * Stores events that sleep until their dependency changes.
 	 */
-	std::deque<std::shared_ptr<Event>> dependency_queue;
+	std::unordered_set<std::shared_ptr<Event>> dependency_events;
 
 	/**
-	 * Will trigger itself and add to the queue.
+	 * Stores events that sleep until their dependency changes, but they trigger
+	 * instantly when their dependency changes.
 	 */
-	std::deque<std::shared_ptr<Event>> dependency_immediately_queue;
+	std::unordered_set<std::shared_ptr<Event>> dependency_immediately_events;
 
 	/**
 	 * Events that fire only when triggered.
 	 */
-	std::deque<std::shared_ptr<Event>> trigger_queue;
+	std::unordered_set<std::shared_ptr<Event>> trigger_events;
 
 	/**
+	 * The universe timeline processes through this queue.
 	 * Type::ONCE is only inserted into the queue.
 	 */
-	std::deque<std::shared_ptr<Event>> event_queue;
+	EventStore event_queue;
 };
 
 } // openage::event
diff --git a/libopenage/event/eventstore.cpp b/libopenage/event/eventstore.cpp
new file mode 100644
index 0000000000..807992328c
--- /dev/null
+++ b/libopenage/event/eventstore.cpp
@@ -0,0 +1,124 @@
+// Copyright 2018-2018 the openage authors. See copying.md for legal info.
+
+#include "eventstore.h"
+
+#include <algorithm>
+
+#include "event.h"
+
+#include "../util/compiler.h"
+#include "../error/error.h"
+
+
+namespace openage::event {
+
+void EventStore::push(const std::shared_ptr<Event> &event) {
+	if (unlikely(event == nullptr)) {
+		throw Error{ERR << "inserting nullptr event to queue"};
+	}
+
+	heap_t::element_t order = this->heap.push(event);
+	this->events.emplace(event, order);
+
+	ENSURE(this->heap.size() == this->events.size(),
+	       "heap and event set are inconsistent");
+}
+
+
+std::shared_ptr<Event> EventStore::pop() {
+	ENSURE(this->heap.size() == this->events.size(),
+	       "heap and event set are inconsistent 0");
+
+	size_t heap_s = this->heap.size();
+	size_t evnt_s = this->events.size();
+
+	std::shared_ptr<Event> event = this->heap.pop();
+	this->events.erase(event);
+
+	if (this->heap.size() != this->events.size()) {
+		throw Error{ERR << "inconsistent: prev_heap=" << heap_s
+		                << " prev_map=" << evnt_s};
+	}
+		//ENSURE(this->heap.size() == this->events.size(),
+		//   "heap and event set are inconsistent 1");
+
+	return event;
+}
+
+
+const std::shared_ptr<Event> &EventStore::top() {
+	return this->heap.top();
+}
+
+
+bool EventStore::erase(const std::shared_ptr<Event> &event) {
+	bool erased = false;
+	auto it = this->events.find(event);
+	if (it != std::end(this->events)) {
+		this->heap.unlink_node(it->second);
+		this->events.erase(it);
+		erased = true;
+	}
+
+	return erased;
+}
+
+
+void EventStore::update(const std::shared_ptr<Event> &event) {
+	auto it = this->events.find(event);
+	if (unlikely(it != std::end(this->events))) {
+		this->heap.update(it->second);
+	}
+	else {
+		throw Error{ERR << "event to update not found in store"};
+	}
+}
+
+
+bool EventStore::contains(const std::shared_ptr<Event> &event) const {
+	return (this->events.find(event) != std::end(this->events));
+}
+
+
+void EventStore::clear() {
+	this->heap.clear();
+	this->events.clear();
+}
+
+
+size_t EventStore::size() const {
+	return this->events.size();
+}
+
+
+bool EventStore::empty() const {
+	return this->events.empty();
+}
+
+
+std::vector<std::shared_ptr<Event>> EventStore::get_sorted_events() const {
+	std::vector<std::shared_ptr<Event>> ret;
+
+	ret.reserve(this->events.size());
+
+	std::transform(
+		std::begin(this->events),
+		std::end(this->events),
+		std::back_inserter(ret),
+		[](const auto &elem) {
+			return elem.first;
+		}
+	);
+
+	std::sort(
+		std::begin(ret),
+		std::end(ret),
+		[](const auto &a, const auto &b) {
+			return *a < *b;
+		}
+	);
+
+	return ret;
+}
+
+} // openage::event
diff --git a/libopenage/event/eventstore.h b/libopenage/event/eventstore.h
new file mode 100644
index 0000000000..82f4db2b5b
--- /dev/null
+++ b/libopenage/event/eventstore.h
@@ -0,0 +1,50 @@
+// Copyright 2018-2018 the openage authors. See copying.md for legal info.
+
+#pragma once
+
+#include "../datastructure/pairing_heap.h"
+#include "../util/misc.h"
+
+#include <memory>
+
+
+namespace openage::event {
+
+class Event;
+
+/**
+ * Sorted storage for events.
+ * Implemented through a heap that automatically provides the newest event.
+ */
+class EventStore {
+public:
+
+	// TODO: don't store a double-sharedpointer.
+	//       instead, use the event-sharedpointer directly.
+	using heap_t = datastructure::PairingHeap<std::shared_ptr<Event>,
+	                                          util::SharedPtrLess<Event>>;
+	using elemmap_t = std::unordered_map<std::shared_ptr<Event>, heap_t::element_t>;
+
+	void push(const std::shared_ptr<Event> &event);
+	std::shared_ptr<Event> pop();
+	const std::shared_ptr<Event> &top();
+	bool erase(const std::shared_ptr<Event> &event);
+	void update(const std::shared_ptr<Event> &event);
+	bool contains(const std::shared_ptr<Event> &event) const;
+	void clear();
+	size_t size() const;
+	bool empty() const;
+
+	/**
+	 * Helper function that should not be called 'in production'.
+	 * It returns the events in the store sorted by time.
+	 * Use the pop() method instead (but with that you can't iterate).
+	 */
+	std::vector<std::shared_ptr<Event>> get_sorted_events() const;
+
+	heap_t heap;
+	elemmap_t events;
+};
+
+
+} // openage::event
diff --git a/libopenage/event/loop.cpp b/libopenage/event/loop.cpp
index c3bcfc2ee8..e02bb727b3 100644
--- a/libopenage/event/loop.cpp
+++ b/libopenage/event/loop.cpp
@@ -28,6 +28,7 @@ std::weak_ptr<Event> Loop::create_event(const std::string &name,
 		throw Error{MSG(err) << "Trying to subscribe to eventclass "
 		                     << name << ", which does not exist."};
 	}
+
 	return this->queue.create_event(target, it->second, state, reference_time, params);
 }
 
@@ -94,7 +95,7 @@ int Loop::execute_events(const curve::time_t &time_until,
 
 	{
 		size_t i = 0;
-		for (const auto &e : this->queue.get_event_queue()) {
+		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++;
@@ -113,12 +114,12 @@ int Loop::execute_events(const curve::time_t &time_until,
 		auto target = event->get_target().lock();
 
 		if (target) {
-			this->active_event = event;
-
 			log::log(DBG << "Loop: invoking event \"" << event->get_eventclass()->id()
 			         << "\" on target \"" << target->id()
 			         << "\" for time t=" << event->get_time());
 
+			this->active_event = event;
+
 			// apply the event effects
 			event->get_eventclass()->invoke(
 				*this, target, state,
@@ -133,9 +134,15 @@ int Loop::execute_events(const curve::time_t &time_until,
 				curve::time_t new_time = event->get_eventclass()->predict_invoke_time(
 					target, state, event->get_time()
 				);
+
 				if (new_time != std::numeric_limits<curve::time_t>::min()) {
 					event->set_time(new_time);
-					this->queue.readd(event);
+
+					log::log(DBG << "Loop: repeating event \"" << event->get_eventclass()->id()
+					         << "\" on target \"" << target->id()
+					         << "\" will be reenqueued for time t=" << event->get_time());
+
+					this->queue.reenqueue(event);
 				}
 			}
 		}
@@ -154,6 +161,8 @@ void Loop::update_changes(const std::shared_ptr<State> &state) {
 	         << " target changes have to be processed");
 
 	size_t i = 0;
+
+	// reevaluate depending events beecause of the change
 	for (const auto &change : this->queue.get_changes()) {
 		auto evnt = change.evnt.lock();
 		if (evnt) {
@@ -167,15 +176,25 @@ void Loop::update_changes(const std::shared_ptr<State> &state) {
 				if (target) {
 					curve::time_t new_time = evnt->get_eventclass()
 					                             ->predict_invoke_time(target, state, change.time);
-					log::log(DBG << "Loop: rescheduled event of '"
-					         << evnt->get_eventclass()->id()
-					         << "' on target '" << target->id()
-					         << "' at time t=" << change.time
-					         << " to NEW TIME t=" << new_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()
+						         << "' at time t=" << change.time
+						         << " to NEW TIME t=" << new_time);
+
 						evnt->set_time(new_time);
-						this->queue.update(evnt);
+
+						this->queue.enqueue_change(evnt);
+					}
+					else {
+						log::log(DBG << "Loop: due to a change, canceled execution of '"
+						         << evnt->get_eventclass()->id()
+						         << "' on target '" << target->id()
+						         << "' at time t=" << change.time);
+
+						this->queue.remove(evnt);
 					}
 				}
 			} break;
@@ -183,7 +202,7 @@ void Loop::update_changes(const std::shared_ptr<State> &state) {
 			case EventClass::trigger_type::TRIGGER:
 			case EventClass::trigger_type::DEPENDENCY_IMMEDIATELY:
 				evnt->set_time(change.time);
-				this->queue.update(evnt);
+				this->queue.enqueue_change(evnt);
 				break;
 
 			case EventClass::trigger_type::REPEAT:
diff --git a/libopenage/event/tests.cpp b/libopenage/event/tests.cpp
index ce6f6752fa..9c59c0f672 100644
--- a/libopenage/event/tests.cpp
+++ b/libopenage/event/tests.cpp
@@ -85,7 +85,7 @@ class TestEventClass : public EventClass {
 
 		auto state = std::dynamic_pointer_cast<TestState>(gstate);
 
-		switch(idx) {
+		switch(this->idx) {
 		case 0:
 			// let the modification of objectA depend on objectB
 			event->depend_on(state->objectB);
@@ -105,7 +105,7 @@ class TestEventClass : public EventClass {
 
 		auto state = std::dynamic_pointer_cast<TestState>(gstate);
 
-		switch (idx) {
+		switch (this->idx) {
 		case 0: {
 			auto t = std::dynamic_pointer_cast<TestState::TestObject>(target);
 			state->objectA->set_number(t->number + 1, time);
@@ -125,7 +125,6 @@ class TestEventClass : public EventClass {
 	curve::time_t predict_invoke_time(const std::shared_ptr<EventTarget> &/*target*/,
 	                                  const std::shared_ptr<State> &/*state*/,
 	                                  const curve::time_t &at) override {
-		// TODO recalculate a hit time
 		return at + curve::time_t::from_double(2);
 	}
 };
@@ -453,13 +452,13 @@ void eventtrigger() {
 			loop->reach_time(11, gstate);
 			TESTEQUALS(state->trace.size(), 2);
 			auto it = state->trace.begin();
-			if (it->name != "once")
-				TESTFAILMSG("Unexpected Event: " << it->name << " expected once");
-			TESTEQUALS(it->time, 10);
-			it++;
 			if (it->name != "repeat_exec")
 				TESTFAILMSG("Unexpected Event: " << it->name << " expected repeat_exec");
 			TESTEQUALS(it->time, 10);
+			it++;
+			if (it->name != "once")
+				TESTFAILMSG("Unexpected Event: " << it->name << " expected once");
+			TESTEQUALS(it->time, 10);
 			state->trace.clear();
 		}
 
diff --git a/libopenage/terrain/terrain_object.h b/libopenage/terrain/terrain_object.h
index 3fad12dc45..369d96c8d0 100644
--- a/libopenage/terrain/terrain_object.h
+++ b/libopenage/terrain/terrain_object.h
@@ -5,7 +5,6 @@
 #include <memory>
 #include <stddef.h>
 
-#include "../pathfinding/path.h"
 #include "../coord/tile.h"
 #include "../coord/phys.h"
 
diff --git a/libopenage/util/misc.h b/libopenage/util/misc.h
index 23874b05f9..b3eb9738d7 100644
--- a/libopenage/util/misc.h
+++ b/libopenage/util/misc.h
@@ -8,12 +8,14 @@
 #include <cstring>
 #include <string>
 #include <vector>
+#include <memory>
 
 #include "../error/error.h"
+#include "compiler.h"
 
 
-namespace openage {
-namespace util {
+namespace openage::util {
+
 
 /**
  * global empty string, sometimes needed
@@ -278,5 +280,23 @@ void vector_remove_swap_end(std::vector<T> &vec, size_t idx) {
 }
 
 
-} // namespace util
-} // namespace openage
+/**
+ * Comparator that returns true
+ * if the contained value of the left sharedptr is `<`
+ * than the value contained in the right sharedptr.
+ */
+template <typename T>
+struct SharedPtrLess {
+	bool operator ()(const std::shared_ptr<T> &left,
+	                 const std::shared_ptr<T> &right) {
+
+		if (unlikely(not left or not right)) {
+			return false;
+		}
+
+		return *left < *right;
+	}
+};
+
+
+} // namespace openage::util

From ecbdd09dabb79018480725ab263dd0ec41f10d82 Mon Sep 17 00:00:00 2001
From: Jonas Jelten <jj@sft.mx>
Date: Sat, 7 Jul 2018 16:16:08 +0200
Subject: [PATCH 07/18] pong: fix flickering by getting input after draw is
 completed

---
 libopenage/event/demo/gamestate.h | 23 ++++++++++--
 libopenage/event/demo/gui.cpp     | 11 ++++--
 libopenage/event/demo/gui.h       | 14 +++++++-
 libopenage/event/demo/main.cpp    | 59 ++++++++++++++-----------------
 libopenage/event/demo/physics.cpp |  3 +-
 5 files changed, 69 insertions(+), 41 deletions(-)

diff --git a/libopenage/event/demo/gamestate.h b/libopenage/event/demo/gamestate.h
index d9b29e6d19..f3bb0d8392 100644
--- a/libopenage/event/demo/gamestate.h
+++ b/libopenage/event/demo/gamestate.h
@@ -4,6 +4,7 @@
 
 #include <functional>
 
+#include "../../config.h"
 #include "../state.h"
 #include "../loop.h"
 #include "../eventtarget.h"
@@ -11,9 +12,13 @@
 #include "../../curve/discrete.h"
 #include "../../util/vector.h"
 
-
 namespace openage::event::demo {
 
+#if WITH_NCURSES
+class Gui;
+#endif
+
+
 
 class PongEvent {
 public:
@@ -110,13 +115,21 @@ class PongBall : public EventTarget {
 
 class PongState : public State {
 public:
-	PongState(const std::shared_ptr<Loop> &mgr, bool enable_gui)
+	PongState(const std::shared_ptr<Loop> &mgr, bool enable_gui
+#if WITH_NCURSES
+	          , const std::shared_ptr<Gui> &gui
+#endif
+	)
 		:
 		State{mgr},
 		p1(std::make_shared<PongPlayer>(mgr, 0)),
 		p2(std::make_shared<PongPlayer>(mgr, 1)),
 		ball(std::make_shared<PongBall>(mgr, 2)),
-		enable_gui{enable_gui} {}
+		enable_gui{enable_gui}
+#if WITH_NCURSES
+		, gui{gui}
+#endif
+		{}
 
 	std::shared_ptr<PongPlayer> p1;
 	std::shared_ptr<PongPlayer> p2;
@@ -124,6 +137,10 @@ class PongState : public State {
 	util::Vector2d display_boundary;
 
 	bool enable_gui;
+
+#if WITH_NCURSES
+	std::shared_ptr<Gui> gui;
+#endif
 };
 
 } // openage::event::demo
diff --git a/libopenage/event/demo/gui.cpp b/libopenage/event/demo/gui.cpp
index d3ee16e9d2..820bdb0cc6 100644
--- a/libopenage/event/demo/gui.cpp
+++ b/libopenage/event/demo/gui.cpp
@@ -145,13 +145,18 @@ void Gui::clear() {
 }
 
 
-void Gui::draw(std::shared_ptr<PongState> &state, const curve::time_t &now) {
-	attron(COLOR_PAIR(COLOR_DEBUG));
+void Gui::get_display_size(const std::shared_ptr<PongState> &state,
+                           const curve::time_t &/*now*/) {
+	// record the screen dimensions in the game state
 
-	// record the screen dimensions
 	// TODO: make the display_boundary a curve as well.
 	getmaxyx(stdscr, state->display_boundary[1], state->display_boundary[0]);
 	state->display_boundary[1] -= 1;
+}
+
+
+void Gui::draw(const std::shared_ptr<PongState> &state, const curve::time_t &now) {
+	attron(COLOR_PAIR(COLOR_DEBUG));
 
 	// print the score
 	attron(COLOR_PAIR(COLOR_DEBUG));
diff --git a/libopenage/event/demo/gui.h b/libopenage/event/demo/gui.h
index c97f9eb180..883797ffe5 100644
--- a/libopenage/event/demo/gui.h
+++ b/libopenage/event/demo/gui.h
@@ -2,15 +2,25 @@
 
 #pragma once
 
+
+#include "../../config.h"
+
+#if WITH_NCURSES
 #include <vector>
 
 #include "gamestate.h"
+#endif
 
 
 namespace openage::event::demo {
 
 #if WITH_NCURSES
 
+class PongEvent;
+class PongState;
+class PongPlayer;
+
+
 class Gui {
 public:
 	Gui();
@@ -19,8 +29,10 @@ class Gui {
 	void update_screen();
 
 	const std::vector<PongEvent> &get_inputs(const std::shared_ptr<PongPlayer> &player);
+	void get_display_size(const std::shared_ptr<PongState> &state,
+	                      const curve::time_t &now);
 
-	void draw(std::shared_ptr<PongState> &state, const curve::time_t &now);
+	void draw(const std::shared_ptr<PongState> &state, const curve::time_t &now);
 	void draw_ball(util::Vector2d ball, const char *str);
 
 private:
diff --git a/libopenage/event/demo/main.cpp b/libopenage/event/demo/main.cpp
index 033a7d6f4c..779985525b 100644
--- a/libopenage/event/demo/main.cpp
+++ b/libopenage/event/demo/main.cpp
@@ -42,9 +42,10 @@ void curvepong(bool disable_gui, bool no_human) {
 
 
 #if WITH_NCURSES
-	Gui gui;
+	std::shared_ptr<Gui> gui = std::make_shared<Gui>();
+
 	if (enable_gui) {
-		gui.init();
+		gui->init();
 	}
 #endif
 
@@ -56,7 +57,11 @@ void curvepong(bool disable_gui, bool no_human) {
 		Physics phys;
 		AIInput ai;
 
-		auto state = std::make_shared<PongState>(loop, enable_gui);
+		auto state = std::make_shared<PongState>(loop, enable_gui
+#if WITH_NCURSES
+		                                         , gui
+#endif
+		);
 		Physics::init(state, loop, now);
 
 		state->p1->lives->set_last(now, 3);
@@ -67,8 +72,8 @@ void curvepong(bool disable_gui, bool no_human) {
 
 #if WITH_NCURSES
 		if (state->enable_gui) {
-			gui.clear();
-			gui.draw(state, now);  // update gui related parameters
+			gui->clear();
+			gui->get_display_size(state, now);  // update gui related parameters
 		}
 		else {
 #endif
@@ -77,16 +82,12 @@ void curvepong(bool disable_gui, bool no_human) {
 		}
 #endif
 
-		{
-			std::vector<PongEvent> start_event{PongEvent(0, PongEvent::START)};
-			phys.process_input(state, state->p1, start_event, loop, now);
-		}
+		// initialize the game by resetting physics
+		std::vector<PongEvent> start_event{PongEvent{0, PongEvent::START}};
+		phys.process_input(state, state->p1, start_event, loop, now);
 
-#if WITH_NCURSES
-		if (state->enable_gui) {
-			gui.draw(state, now);  // initial drawing with corrected ball
-		}
-#endif
+
+		std::vector<PongEvent> inputs;
 
 		// this is the game loop, running while both players live!
 		while (state->p1->lives->get(now) > 0 and
@@ -96,7 +97,8 @@ void curvepong(bool disable_gui, bool no_human) {
 
 #if WITH_NCURSES
 			if (enable_gui) {
-				gui.clear();
+				gui->clear();
+				gui->get_display_size(state, now);
 			}
 #endif
 
@@ -104,23 +106,10 @@ void curvepong(bool disable_gui, bool no_human) {
 			// player 1 can be AI or human.
 
 			if (human_player) {
-#if WITH_NCURSES
-				auto inputs = gui.get_inputs(state->p1);
-#else
-				// TODO: take terminal input without ncurses, if on tty?
-				//       e.g. 'q' to close it?
-				std::vector<PongEvent> inputs;
-#endif
 				phys.process_input(state, state->p1,
 				                   inputs, loop, now);
 			}
 			else {
-#if WITH_NCURSES
-				// We still need to get the inputs to be able to kill the game
-				if (state->enable_gui) {
-					gui.get_inputs(state->p1);
-				}
-#endif
 
 				phys.process_input(state, state->p1,
 				                   ai.get_inputs(state->p1, state->ball, now),
@@ -135,12 +124,12 @@ void curvepong(bool disable_gui, bool no_human) {
 			state->p1->paddle_x = 0;
 			state->p2->paddle_x = state->display_boundary[0] - 1;
 
-			// run the event queue!
+			// evaluate the event queue to reach the desired game time!
 			loop->reach_time(now, state);
 
 #if WITH_NCURSES
 			if (state->enable_gui) {
-				gui.draw(state, now);
+				gui->draw(state, now);
 
 				int pos = 1;
 				mvprintw(pos++, state->display_boundary[0]/2 + 10, "Enqueued events:");
@@ -151,12 +140,18 @@ void curvepong(bool disable_gui, bool no_human) {
 					         e->get_eventclass()->id().c_str());
 				}
 
-				gui.update_screen();
+				gui->update_screen();
+
+				// 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);
 			}
 #endif
 
 			// handle timing for screen refresh and simulation advancement
-
 			using dt_s_t = std::chrono::duration<double, std::ratio<1>>;
 			using dt_us_t = std::chrono::duration<double, std::micro>;
 
diff --git a/libopenage/event/demo/physics.cpp b/libopenage/event/demo/physics.cpp
index 082b65383d..605257ce8d 100644
--- a/libopenage/event/demo/physics.cpp
+++ b/libopenage/event/demo/physics.cpp
@@ -229,7 +229,6 @@ class BallReflectPanel : public DependencyEventClass {
 #if WITH_NCURSES
 		if (state->enable_gui) {
 			mvprintw(21, 40, "PANEL REFLECT AT %f NEXT %f", now.to_double(), (now + ty).to_double());
-			mvprintw(21, 18, "2");
 		}
 		else {
 #endif
@@ -292,7 +291,7 @@ class ResetGame : public OnceEventClass {
 		float dirx = (rng::random() % 2) ? 1 : -1;
 		float diry = (rng::random() % 2) ? 1 : -1;
 		auto init_speed = util::Vector2d(
-			dirx * (1.5 + (rng::random() % 100) / 3.f),
+			dirx * (10 + (rng::random() % 100) / 4.f),
 			diry * (0.3 + (rng::random() % 100) / 18.f)
 		);
 

From 21688f5629d463d1139bbd7062179765f22a88b3 Mon Sep 17 00:00:00 2001
From: Jonas Jelten <jj@sft.mx>
Date: Sat, 7 Jul 2018 16:17:07 +0200
Subject: [PATCH 08/18] fixed_point: fix str function as std::string is not
 constexpr

---
 libopenage/util/fixed_point.h | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/libopenage/util/fixed_point.h b/libopenage/util/fixed_point.h
index 8ac197f36b..a838e9d1b4 100644
--- a/libopenage/util/fixed_point.h
+++ b/libopenage/util/fixed_point.h
@@ -268,9 +268,9 @@ class FixedPoint {
 	}
 
 	/**
-	 * Show a string representation.
+	 * Show a string representation. Useful for debugging in gdb.
 	 */
-	constexpr std::string str() const {
+	std::string str() const {
 		std::ostringstream builder;
 		builder << "FixedPoint(" << this->to_double()
 		        << ", fracbits=" << fractional_bits

From 76668027dbea3cebd6f2d2dd12605b88823364cf Mon Sep 17 00:00:00 2001
From: Jonas Jelten <jj@sft.mx>
Date: Sat, 7 Jul 2018 16:54:50 +0200
Subject: [PATCH 09/18] pong: implement simple log for ncurses gui

---
 libopenage/event/demo/gui.cpp     | 25 +++++++++++++++++++---
 libopenage/event/demo/gui.h       | 11 +++++-----
 libopenage/event/demo/physics.cpp | 35 +++++++++++++++++++------------
 3 files changed, 50 insertions(+), 21 deletions(-)

diff --git a/libopenage/event/demo/gui.cpp b/libopenage/event/demo/gui.cpp
index 820bdb0cc6..cca796f745 100644
--- a/libopenage/event/demo/gui.cpp
+++ b/libopenage/event/demo/gui.cpp
@@ -87,8 +87,11 @@ enum {
 };
 
 
+constexpr const int max_log_msgs = 10;
+
 Gui::Gui() {}
 
+
 void Gui::init() {
 	initscr();
 	start_color();
@@ -187,18 +190,25 @@ void Gui::draw(const std::shared_ptr<PongState> &state, const curve::time_t &now
 	for (int i = 0; i < 10; i++) {
 		auto i_as_ctt = curve::time_t::from_int(i);
 		mvprintw((5 + i), 1,
-		         "BALL in %03f: %f | %f; SPEED: %f | %f | PLpos: %f, PRpos: %f | PLst: %d",
+		         "BALL in %03f: %f | %f; SPEED: %f | %f | PLpos: %f, PRpos: %f",
 		         i_as_ctt.to_double(),
 		         state->ball->position->get(now + i_as_ctt)[0],
 		         state->ball->position->get(now + i_as_ctt)[1],
 		         state->ball->speed->get(now + i_as_ctt)[0],
 		         state->ball->speed->get(now + i_as_ctt)[1],
 		         state->p1->position->get(now + i_as_ctt),
-		         state->p2->position->get(now + i_as_ctt),
-		         state->p1->state->get(now + i_as_ctt).state
+		         state->p2->position->get(now + i_as_ctt)
 		);
 	}
 
+	// show log
+	int msg_i = 0;
+	for (auto & msg : this->log_msgs) {
+		mvprintw((6 + msg_i), state->display_boundary[0]/2 + 10, msg.c_str());
+		msg_i += 1;
+	}
+
+
 	// exit hint message
 	mvprintw(state->display_boundary[1] - 1, 1, "Press ESC to exit");
 	attroff(COLOR_PAIR(COLOR_DEBUG));
@@ -242,6 +252,15 @@ void Gui::draw_ball(util::Vector2d pos, const char *str) {
 	standend();
 }
 
+
+void Gui::log(const std::string &msg) {
+	if (this->log_msgs.size() >= max_log_msgs) {
+		this->log_msgs.pop_back();
+	}
+	this->log_msgs.push_front(msg);
+}
+
+
 #endif
 
 } // openage::event::demo
diff --git a/libopenage/event/demo/gui.h b/libopenage/event/demo/gui.h
index 883797ffe5..bba37f048f 100644
--- a/libopenage/event/demo/gui.h
+++ b/libopenage/event/demo/gui.h
@@ -7,15 +7,13 @@
 
 #if WITH_NCURSES
 #include <vector>
+#include <deque>
 
 #include "gamestate.h"
-#endif
 
 
 namespace openage::event::demo {
 
-#if WITH_NCURSES
-
 class PongEvent;
 class PongState;
 class PongPlayer;
@@ -35,10 +33,13 @@ class Gui {
 	void draw(const std::shared_ptr<PongState> &state, const curve::time_t &now);
 	void draw_ball(util::Vector2d ball, const char *str);
 
+	void log(const std::string &msg);
+
 private:
 	std::vector<PongEvent> input_cache;
+	std::deque<std::string> log_msgs;
 };
 
-#endif
-
 } // openage::event::demo
+
+#endif
diff --git a/libopenage/event/demo/physics.cpp b/libopenage/event/demo/physics.cpp
index 605257ce8d..bb931be001 100644
--- a/libopenage/event/demo/physics.cpp
+++ b/libopenage/event/demo/physics.cpp
@@ -7,11 +7,14 @@
 
 #if WITH_NCURSES
 #include <ncurses.h>
+
+#include "gui.h"
 #endif
 
 #include "../../config.h"
 #include "../../error/error.h"
 #include "../../rng/global_rng.h"
+#include "../../util/stringformatter.h"
 
 
 namespace openage::event::demo {
@@ -96,9 +99,10 @@ class BallReflectWall : public DependencyEventClass {
 
 #if WITH_NCURSES
 		if (state->enable_gui) {
-			mvprintw(22, 40,
-			         "WALL TY %f NOW %f, NOWTY %f ",
-			         ty.to_double(), now.to_double(), (now + ty).to_double());
+			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);
 		};
 #endif
 		return now + ty;
@@ -141,7 +145,9 @@ class BallReflectPanel : public DependencyEventClass {
 #if WITH_NCURSES
 		if (state->enable_gui) {
 			static int cnt = 0;
-			mvprintw(21, 22, "Panel hit [%i]", ++cnt);
+			util::FString str;
+			str.fmt("Panel hit [%i]", ++cnt);
+			state->gui->log(str);
 		}
 		else {
 #endif
@@ -163,7 +169,6 @@ class BallReflectPanel : public DependencyEventClass {
 			state->ball->position->set_last(now, pos);
 
 			Physics::reset(state, mgr, now);
-			mvprintw(21, 18, "1");
 		}
 		else if (pos[0] >= state->display_boundary[0] - 1 and
 		         speed[0] > 0 and
@@ -177,7 +182,6 @@ class BallReflectPanel : public DependencyEventClass {
 			state->ball->position->set_last(now, pos);
 
 			Physics::reset(state, mgr, now);
-			mvprintw(21, 18, "2");
 		}
 		else if (pos[0] >= state->display_boundary[0]- 1 || pos[0] <= 1) {
 			speed[0] *= -1;
@@ -228,7 +232,9 @@ class BallReflectPanel : public DependencyEventClass {
 
 #if WITH_NCURSES
 		if (state->enable_gui) {
-			mvprintw(21, 40, "PANEL REFLECT AT %f NEXT %f", now.to_double(), (now + ty).to_double());
+			util::FString str;
+			str.fmt("PANEL REFLECT AT %f NEXT %f", now.to_double(), (now + ty).to_double());
+			state->gui->log(str);
 		}
 		else {
 #endif
@@ -301,12 +307,15 @@ class ResetGame : public OnceEventClass {
 #if WITH_NCURSES
 		if (state->enable_gui) {
 			static int cnt = 0;
-			mvprintw(20, 20, "Reset. Speed %f | %f POS %f | %f [%i]",
-			         init_speed[0],
-			         init_speed[1],
-			         pos[0],
-			         pos[1],
-			         ++cnt);
+
+			util::FString str;
+			str.fmt("Reset. Speed %f | %f POS %f | %f [%i]",
+			        init_speed[0],
+			        init_speed[1],
+			        pos[0],
+			        pos[1],
+			        ++cnt);
+			state->gui->log(str);
 		}
 		else {
 #endif

From e774314ec528b1145c73347c833cb7fd6ed48fdc Mon Sep 17 00:00:00 2001
From: Jonas Jelten <jj@sft.mx>
Date: Thu, 12 Jul 2018 00:37:18 +0200
Subject: [PATCH 10/18] filelike: add missing function get_py_fileobj
 implementation

---
 libopenage/util/filelike/python.cpp | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/libopenage/util/filelike/python.cpp b/libopenage/util/filelike/python.cpp
index 605fd547e6..4167df48cf 100644
--- a/libopenage/util/filelike/python.cpp
+++ b/libopenage/util/filelike/python.cpp
@@ -1,4 +1,4 @@
-// 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 "python.h"
 
@@ -77,6 +77,11 @@ bool Python::is_python_native() const noexcept {
 }
 
 
+py::Obj &Python::get_py_fileobj() const {
+	return *this->fileobj.get();
+}
+
+
 std::ostream &Python::repr(std::ostream &stream) {
 	stream << this->fileobj->repr();
 	return stream;

From f82daad8739ac8cbf2a272e5a078bb83d13f6478 Mon Sep 17 00:00:00 2001
From: Jonas Jelten <jj@sft.mx>
Date: Fri, 13 Jul 2018 00:28:53 +0200
Subject: [PATCH 11/18] pathfinding: optimizations for heap usage

---
 libopenage/pathfinding/a_star.cpp | 2 +-
 libopenage/pathfinding/path.cpp   | 2 +-
 libopenage/pathfinding/path.h     | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/libopenage/pathfinding/a_star.cpp b/libopenage/pathfinding/a_star.cpp
index e40e4424c4..093a42bf2e 100644
--- a/libopenage/pathfinding/a_star.cpp
+++ b/libopenage/pathfinding/a_star.cpp
@@ -136,7 +136,7 @@ Path a_star(coord::phys3 start,
 					neighbor->heap_node = node_candidates.push(neighbor);
 					visited_tiles[neighbor->position] = neighbor;
 				} else {
-					node_candidates.update(neighbor->heap_node);
+					node_candidates.decrease(neighbor->heap_node);
 				}
 			}
 		}
diff --git a/libopenage/pathfinding/path.cpp b/libopenage/pathfinding/path.cpp
index cc6638f34e..ae6b898d6d 100644
--- a/libopenage/pathfinding/path.cpp
+++ b/libopenage/pathfinding/path.cpp
@@ -9,7 +9,7 @@ namespace openage {
 namespace path {
 
 
-bool compare_node_cost::operator ()(const node_pt lhs, const node_pt rhs) const {
+bool compare_node_cost::operator ()(const node_pt &lhs, const node_pt &rhs) const {
 	// TODO: use node operator <
 	return lhs->future_cost < rhs->future_cost;
 }
diff --git a/libopenage/pathfinding/path.h b/libopenage/pathfinding/path.h
index 388d8259ec..1d5fa8bb04 100644
--- a/libopenage/pathfinding/path.h
+++ b/libopenage/pathfinding/path.h
@@ -46,7 +46,7 @@ using nodemap_t = std::unordered_map<coord::phys3, node_pt>;
  * Calls operator < on Node.
  */
 struct compare_node_cost {
-	bool operator ()(const node_pt lhs, const node_pt rhs) const;
+	bool operator ()(const node_pt &lhs, const node_pt &rhs) const;
 };
 
 /**

From aa81037c8c1b47cb80a47f940effbbd8fa222c2b Mon Sep 17 00:00:00 2001
From: Jonas Jelten <jj@sft.mx>
Date: Fri, 13 Jul 2018 00:33:11 +0200
Subject: [PATCH 12/18] pairing_heap: add consistency checking function

---
 libopenage/datastructure/pairing_heap.h | 235 ++++++++++++++++++++++--
 libopenage/datastructure/tests.cpp      |   2 +-
 2 files changed, 220 insertions(+), 17 deletions(-)

diff --git a/libopenage/datastructure/pairing_heap.h b/libopenage/datastructure/pairing_heap.h
index bc351250a0..28bd9a53de 100644
--- a/libopenage/datastructure/pairing_heap.h
+++ b/libopenage/datastructure/pairing_heap.h
@@ -1,4 +1,4 @@
-// Copyright 2014-2016 the openage authors. See copying.md for legal info.
+// Copyright 2014-2018 the openage authors. See copying.md for legal info.
 
 #pragma once
 
@@ -24,6 +24,10 @@
 #include "../util/compiler.h"
 #include "../error/error.h"
 
+
+#define OPENAGE_PAIRINGHEAP_DEBUG false
+
+
 namespace openage::datastructure {
 
 
@@ -193,6 +197,7 @@ class PairingHeap final {
 	using node_t = heapnode_t;
 	using element_t = std::shared_ptr<node_t>;
 	using this_type = PairingHeap<T, compare, node_t>;
+	using cmp_t = compare;
 
 	/**
 	 * create a empty heap.
@@ -303,6 +308,12 @@ class PairingHeap final {
 
 		this->node_count -= 1;
 
+#if OPENAGE_PAIRINGHEAP_DEBUG
+		if (1 != this->nodes.erase(ret)) {
+			throw Error{ERR << "didn't remove node"};
+		}
+#endif
+
 		// (to find those two lines, 14h of debugging passed)
 		ret->loosen();
 		ret->first_child = nullptr;
@@ -318,7 +329,7 @@ class PairingHeap final {
 	 * else, cut the node from its parent, pop() that subtree
 	 * and merge these trees.
 	 *
-	 * O(1), O(pop) if node is the root
+	 * O(pop_node)
 	 */
 	void unlink_node(const element_t &node) {
 		if (node == this->root_node) {
@@ -326,21 +337,17 @@ class PairingHeap final {
 		}
 		else {
 			node->loosen();
-			element_t child = node->first_child;
-
-			// merge all children of the node to unlink
-			while (child != nullptr) {
-				element_t next = child->next_sibling;
-				child->loosen();
-				this->push_node(child);
 
-				child = next;
-			}
+			element_t real_root = this->root_node;
+			this->root_node = node;
+			this->pop_node();
 
-			// to create this line, 13h of debugging were required.
-			node->first_child = nullptr;
+			element_t new_root = this->root_node;
+			this->root_node = real_root;
 
-			this->node_count -= 1;
+			if (new_root != nullptr) {
+				this->root_insert(new_root);
+			}
 		}
 	}
 
@@ -404,6 +411,9 @@ class PairingHeap final {
 	void clear() {
 		this->root_node = nullptr;
 		this->node_count = 0;
+#if OPENAGE_PAIRINGHEAP_DEBUG
+		this->nodes.clear();
+#endif
 	}
 
 	/**
@@ -420,25 +430,218 @@ class PairingHeap final {
 		return this->node_count == 0;
 	}
 
+#if OPENAGE_PAIRINGHEAP_DEBUG
+	/**
+	 * verify the consistency of the heap.
+	 * - check if each node is only present once.
+	 * - check if the nodes are referenced at their correct place only
+	 */
+	std::unordered_set<element_t> check_consistency() const {
+		std::unordered_set<element_t> found_nodes;
+
+		auto func = [&](const element_t &root) {
+			if (not root) {
+				throw Error{ERR << "test function called with nullptr node"};
+			}
+
+			if (found_nodes.find(root) == std::end(found_nodes)) {
+				found_nodes.insert(root);
+			}
+			else {
+				throw Error{ERR << "encountered node twice"};
+			}
+
+			if (this->node_count != this->nodes.size()) {
+				throw Error{ERR << "node count fail"};
+			}
+
+			if (root->next_sibling) {
+				if (not root->next_sibling->prev_sibling) {
+					throw Error{ERR << "node has next sibling, which has no prev sibling"};
+				}
+				if (root->next_sibling->prev_sibling != root) {
+					throw Error{ERR << "node not referenced by next.prev"};
+				}
+			}
+
+			if (root->prev_sibling) {
+				if (not root->prev_sibling->next_sibling) {
+					throw Error{ERR << "node has prev sibling, which has no next sibling"};
+				}
+				if (root->prev_sibling->next_sibling != root) {
+					throw Error{ERR << "node not referenced by prev.next"};
+				}
+			}
+
+			if (root->first_child) {
+				if (root->first_child == root->next_sibling) {
+					throw Error{ERR << "first_child is next_sibling"};
+				}
+				if (root->first_child == root->prev_sibling) {
+					throw Error{ERR << "first_child is prev_sibling"};
+				}
+				if (root->first_child == root->parent) {
+					throw Error{ERR << "first_child is parent"};
+				}
+			}
+
+			if (root->parent) {
+				if (found_nodes.find(root->parent) == std::end(found_nodes)) {
+					throw Error{ERR << "parent node is not known"};
+				}
+				element_t child = root->parent->first_child;
+				element_t lastchild;
+
+				bool foundvianext = false, foundviaprev = false;
+				std::unordered_set<element_t> loopprotect;
+				while (true) {
+					if (not child) {
+						break;
+					}
+
+					if (loopprotect.find(child) == std::end(loopprotect)) {
+						loopprotect.insert(child);
+					}
+					else {
+						throw Error{ERR << "child reencountered when walking forward"};
+					}
+
+					if (child == root) {
+						foundvianext = true;
+					}
+
+					// if both are equal, cmp will still be false.
+					if (this->cmp(child->data, root->parent->data)) {
+						throw Error{ERR << "tree invariant violated"};
+					}
+
+					lastchild = child;
+					child = child->next_sibling;
+				}
+
+				loopprotect.clear();
+				while (true) {
+					if (not lastchild) {
+						break;
+					}
+
+					if (loopprotect.find(lastchild) == std::end(loopprotect)) {
+						loopprotect.insert(lastchild);
+					}
+					else {
+						throw Error{ERR << "child reencountered when walking back"};
+					}
+
+					if (lastchild == root) {
+						foundviaprev = true;
+					}
+
+					lastchild = lastchild->prev_sibling;
+				}
+
+				if (not foundvianext and not foundviaprev) {
+					throw Error{ERR << "node not found as parent's child at all"};
+				}
+				else if (not foundvianext) {
+					throw Error{ERR << "node not found via parent's next childs"};
+				}
+				else if (not foundviaprev) {
+					throw Error{ERR << "node not found via parent's prev childs"};
+				}
+			}
+		};
+
+		if (this->root_node) {
+			this->walk_tree(this->root_node, func);
+
+			if (found_nodes.size() != this->size()) {
+				for (auto &it : found_nodes) {
+					const element_t &elem = it;
+					if (this->nodes.find(elem) == std::end(this->nodes)) {
+						throw Error{ERR << "node not recorded but found"};
+					}
+				}
+
+				for (auto &it : this->nodes) {
+					const element_t &elem = it;
+					if (found_nodes.find(elem) == std::end(found_nodes)) {
+						throw Error{ERR << "node recorded but not found"};
+					}
+				}
+
+				throw Error{ERR << "node count inconsistent"};
+			}
+		}
+		else {
+			if (not this->empty()) {
+				throw Error{ERR << "root missing but heap not empty"};
+			}
+		}
+
+		return found_nodes;
+	}
+#endif
+
+	void iter_all(const std::function<void(const element_t &)> &func) const {
+		this->walk_tree(this->root_node, func);
+	}
+
 protected:
+	void walk_tree(const element_t &root,
+	               const std::function<void(const element_t &)> &func) const {
+
+		func(root);
+
+		if (root) {
+			auto node = root->first_child;
+			while (true) {
+				if (not node) {
+					break;
+				}
+
+				this->walk_tree(node, func);
+				node = node->next_sibling;
+			}
+		}
+	}
+
 	/**
 	 * adds the given node to the heap.
+	 * use this if the node was not in the heap before.
 	 * O(1)
 	 */
 	void push_node(const element_t &node) {
+		this->root_insert(node);
+
+#if OPENAGE_PAIRINGHEAP_DEBUG
+		auto ins = this->nodes.insert(node);
+		if (not ins.second) {
+			throw Error{ERR << "node already known"};
+		}
+#endif
+
+		this->node_count += 1;
+	}
+
+	/**
+	 * insert a node into the heap.
+	 */
+	void root_insert(const element_t &node) {
 		if (unlikely(this->root_node == nullptr)) {
 			this->root_node = node;
 		} else {
 			this->root_node = this->root_node->link_with(node);
 		}
-
-		this->node_count += 1;
 	}
 
 protected:
 	compare cmp;
 	size_t node_count;
 	element_t root_node;
+
+#if OPENAGE_PAIRINGHEAP_DEBUG
+	std::unordered_set<element_t> nodes;
+#endif
 };
 
 } // openage::datastructure
diff --git a/libopenage/datastructure/tests.cpp b/libopenage/datastructure/tests.cpp
index 526e4e32c0..7c92472687 100644
--- a/libopenage/datastructure/tests.cpp
+++ b/libopenage/datastructure/tests.cpp
@@ -1,4 +1,4 @@
-// Copyright 2014-2017 the openage authors. See copying.md for legal info.
+// Copyright 2014-2018 the openage authors. See copying.md for legal info.
 
 #include "tests.h"
 

From 9c22501c6d4098e5ec77bc857b1b95a740e22cba Mon Sep 17 00:00:00 2001
From: Jonas Jelten <jj@sft.mx>
Date: Mon, 23 Jul 2018 14:48:46 +0200
Subject: [PATCH 13/18] buildsystem: add curve and event subdirectories

---
 libopenage/CMakeLists.txt | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/libopenage/CMakeLists.txt b/libopenage/CMakeLists.txt
index b8b323fa83..0d6654da7f 100644
--- a/libopenage/CMakeLists.txt
+++ b/libopenage/CMakeLists.txt
@@ -333,8 +333,10 @@ pxdgen(
 add_subdirectory("audio")
 add_subdirectory("console")
 add_subdirectory("coord")
+add_subdirectory("curve")
 add_subdirectory("cvar")
 add_subdirectory("datastructure")
+add_subdirectory("event")
 add_subdirectory("gui")
 add_subdirectory("error")
 add_subdirectory("gamestate")

From 27d6ee0ae4df7a47151613b29e5a33056c613e22 Mon Sep 17 00:00:00 2001
From: Jonas Jelten <jj@sft.mx>
Date: Mon, 23 Jul 2018 14:52:13 +0200
Subject: [PATCH 14/18] dist: gaben is no longer the desktop icon

---
 dist/README.md | 7 -------
 1 file changed, 7 deletions(-)

diff --git a/dist/README.md b/dist/README.md
index 988035fec7..8f99be9aaf 100644
--- a/dist/README.md
+++ b/dist/README.md
@@ -6,10 +6,3 @@ Contains files useful for package distribution.
 
 The [openage.desktop](openage.desktop) file can be found in this directory and will be installed at
 `/usr/share/applications/openage.desktop`.
-
-## Desktop icon
-
-In lieu of a logo/icon for openage a cropped version of [assets/gaben.png](/assets/gaben.png) is
-created instead. See [assets/CMakeLists.txt](/assets/CMakeLists.txt) for details on how the icon
-is generated. The final icon will be installed at `/usr/share/pixmaps/openage.png` via
-`make install`.

From d0227f98c8722ee4e9b2dfbc5bc29fb5b15ab6e4 Mon Sep 17 00:00:00 2001
From: Jonas Jelten <jj@sft.mx>
Date: Tue, 24 Jul 2018 15:51:12 +0200
Subject: [PATCH 15/18] buildsystem: use import modules for vulkan and opengl

---
 CMakeLists.txt            | 1 +
 libopenage/CMakeLists.txt | 6 ++----
 2 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/CMakeLists.txt b/CMakeLists.txt
index 2d6ff2b2cb..3c3cba67b4 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -45,6 +45,7 @@ set(CYTHON_MIN_VERSION 0.25)
 foreach(pol
         CMP0067  # honor language standard in try_compile()
         CMP0071  # enable automoc for generated files
+        CMP0072  # prefers GLVND by default FindOpenGL
        )
 	if (POLICY ${pol})
 		cmake_policy(SET ${pol} NEW)
diff --git a/libopenage/CMakeLists.txt b/libopenage/CMakeLists.txt
index 0d6654da7f..674306e406 100644
--- a/libopenage/CMakeLists.txt
+++ b/libopenage/CMakeLists.txt
@@ -216,16 +216,14 @@ endif()
 
 if(WANT_OPENGL AND OPENGL_FOUND)
 	have_config_option(opengl OPENGL true)
-	include_directories(${OPENGL_INCLUDE_DIR})
-	target_link_libraries(libopenage PRIVATE ${OPENGL_LIBRARY})
+	target_link_libraries(libopenage PRIVATE OpenGL::GL)
 else()
 	have_config_option(opengl OPENGL false)
 endif()
 
 if(WANT_VULKAN AND VULKAN_FOUND)
 	have_config_option(vulkan VULKAN true)
-	include_directories(${Vulkan_INCLUDE_DIRS})
-	target_link_libraries(libopenage PRIVATE ${Vulkan_LIBRARIES})
+	target_link_libraries(libopenage PRIVATE Vulkan::Vulkan)
 else()
 	have_config_option(vulkan VULKAN false)
 endif()

From 691d4bea9247f44310149884da304dac8e5ea093 Mon Sep 17 00:00:00 2001
From: Jonas Jelten <jj@sft.mx>
Date: Sun, 29 Jul 2018 12:23:04 +0200
Subject: [PATCH 16/18] copying: remove bogus characters

---
 copying.md | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/copying.md b/copying.md
index 517613526c..cf7cff74a6 100644
--- a/copying.md
+++ b/copying.md
@@ -110,7 +110,7 @@ _the openage authors_ are:
 | Rafael X. Morales Georgi    | chocoladisco                | chocoladisco à gmail dawt com                     |
 | Marcel Schneider            | schnema123                  | marcelschneider5 à outlook dawt de                |
 | Samuel Grigolato            | samuelgrigolato             | samuel dawt grigolato à gmail dawt com            |
-| Andrew Thompson             | mrwerdo331@me.com           | mrwerdo331 à me dawt com                          |
+| Andrew Thompson             | mrwerdo                     | mrwerdo331 à me dawt com                          |
 | Benedikt Freisen            | roybaer                     | b dawt freisen à gmx dawt net                     |
 | Finn Günther                | Kawzeg                      | kawzeg à gmail dawt com                           |
 | Akshit Sharma               | akshit-sharma               | akshit9sharma à gmail dawt com                    |

From 79f3420710a6f0b104db699ae5d7ffd57488e11d Mon Sep 17 00:00:00 2001
From: Jonas Jelten <jj@sft.mx>
Date: Sun, 29 Jul 2018 13:08:12 +0200
Subject: [PATCH 17/18] buildsystem: fix empty optimization level crash

---
 buildsystem/HandleCXXOptions.cmake | 38 +++++++++++++++---------------
 1 file changed, 19 insertions(+), 19 deletions(-)

diff --git a/buildsystem/HandleCXXOptions.cmake b/buildsystem/HandleCXXOptions.cmake
index 35c105d07e..4721a65fc7 100644
--- a/buildsystem/HandleCXXOptions.cmake
+++ b/buildsystem/HandleCXXOptions.cmake
@@ -90,36 +90,36 @@ set(CMAKE_CXX_FLAGS_DEBUG "-g")
 set(CMAKE_CXX_FLAGS_RELEASE "-DNDEBUG")
 
 # If CXX_OPTIMIZATION_LEVEL was not provided, default to auto
-if(${CXX_OPTIMIZATION_LEVEL} STREQUAL "")
+if("${CXX_OPTIMIZATION_LEVEL}" STREQUAL "")
 	set(CXX_OPTIMIZATION_LEVEL "auto")
 endif()
 
-if(${CXX_OPTIMIZATION_LEVEL} STREQUAL "auto")
+if("${CXX_OPTIMIZATION_LEVEL}" STREQUAL "auto")
 	if(${CMAKE_BUILD_TYPE} STREQUAL "Debug")
-		set(${CXX_OPTIMIZATION_LEVEL} "g")
+		set(CXX_OPTIMIZATION_LEVEL "g")
 	else()
-		set(${CXX_OPTIMIZATION_LEVEL} "3")
+		set(CXX_OPTIMIZATION_LEVEL "3")
 	endif()
 endif()
 
-if(${CXX_OPTIMIZATION_LEVEL} STREQUAL "0")
+if("${CXX_OPTIMIZATION_LEVEL}" STREQUAL "0")
 	set_cxx_optimize_flags("-O0")
-elseif(${CXX_OPTIMIZATION_LEVEL} STREQUAL "1")
+elseif("${CXX_OPTIMIZATION_LEVEL}" STREQUAL "1")
 	set_cxx_optimize_flags("-O1")
-elseif(${CXX_OPTIMIZATION_LEVEL} STREQUAL "2")
+elseif("${CXX_OPTIMIZATION_LEVEL}" STREQUAL "2")
 	set_cxx_optimize_flags("-O2")
-elseif(${CXX_OPTIMIZATION_LEVEL} STREQUAL "3")
+elseif("${CXX_OPTIMIZATION_LEVEL}" STREQUAL "3")
 	set_cxx_optimize_flags("-O3")
-elseif(${CXX_OPTIMIZATION_LEVEL} STREQUAL "g")
-	if(${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU")
+elseif("${CXX_OPTIMIZATION_LEVEL}" STREQUAL "g")
+	if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
 		set_cxx_optimize_flags("-Og")
 	else()
 		set_cxx_optimize_flags("-O0")
 	endif()
-elseif(${CXX_OPTIMIZATION_LEVEL} STREQUAL "max")
+elseif("${CXX_OPTIMIZATION_LEVEL}" STREQUAL "max")
 	set_cxx_optimize_flags("-O3 -march=native")
 
-	if(${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU")
+	if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
 		include(ProcessorCount)
 		ProcessorCount(N)
 		if(NOT N EQUAL 0)
@@ -136,29 +136,29 @@ if(NOT CXX_SANITIZE_MODE)
 	set(CXX_SANITIZE_MODE "none")
 endif()
 
-if (${CXX_SANITIZE_MODE} STREQUAL "none")
+if("${CXX_SANITIZE_MODE}" STREQUAL "none")
 	# Do nothing
-	if(${CXX_SANITIZE_FATAL})
+	if("${CXX_SANITIZE_FATAL}")
 		message(WARNING "CXX_SANITIZE_FATAL is only valid when CXX_SANITIZE_MODE is not none")
 	endif()
 else()
 	set_compiler_flags("CXX" "-fno-omit-frame-pointer")
-	if(${CXX_SANITIZE_FATAL} AND ${CMAKE_CXX_COMPILER_ID} MATCHES "Clang")
+	if("${CXX_SANITIZE_FATAL}" AND "${CMAKE_CXX_COMPILER_ID}" MATCHES "Clang")
 		set_compiler_flags("CXX" "-fno-sanitize-recover")
 	endif()
 
-	if (${CXX_SANITIZE_MODE} STREQUAL "yes")
+	if("${CXX_SANITIZE_MODE}" STREQUAL "yes")
 		set_compiler_flags("CXX" "-fsanitize=address")
 		set_compiler_flags("CXX" "-fsanitize=undefined")
-	elseif(${CXX_SANITIZE_MODE} STREQUAL "mem")
+	elseif("${CXX_SANITIZE_MODE}" STREQUAL "mem")
 		if(NOT APPLE)
 			set_compiler_flags("CXX" "-fsanitize=memory")
 		endif()
-	elseif(${CXX_SANITIZE_MODE} STREQUAL "thread")
+	elseif("${CXX_SANITIZE_MODE}" STREQUAL "thread")
 		if(NOT APPLE)
 			set_compiler_flags("CXX" "-fsanitize=thread")
 		endif()
-		if(${CMAKE_CXX_COMPILER_ID} STREQUAL "GNU")
+		if("${CMAKE_CXX_COMPILER_ID}" STREQUAL "GNU")
 			set_compiler_flags("CXX" "-fPIC")
 			set_compiler_flags("CXX" "-pie")
 		endif()

From fdc3307e39fc280f65692f5362497ffdce73cb1c Mon Sep 17 00:00:00 2001
From: Jonas Jelten <jj@sft.mx>
Date: Sun, 29 Jul 2018 22:39:06 +0200
Subject: [PATCH 18/18] doc: update build instructions and include eigen3

---
 doc/build_instructions/arch_linux.md          |  6 ++++--
 doc/build_instructions/debian.md              |  2 +-
 doc/build_instructions/fedora.md              |  2 +-
 doc/build_instructions/freebsd.md             |  6 +++---
 doc/build_instructions/gentoo.md              |  2 +-
 doc/build_instructions/opensuse_13.2.md       |  2 +-
 doc/build_instructions/opensuse_tumbleweed.md |  2 +-
 doc/build_instructions/ubuntu.md              |  3 +--
 doc/build_instructions/windows_msvc.md        |  2 +-
 doc/building.md                               | 14 ++++++++------
 10 files changed, 22 insertions(+), 19 deletions(-)

diff --git a/doc/build_instructions/arch_linux.md b/doc/build_instructions/arch_linux.md
index 5046c6116b..dc4972ce38 100644
--- a/doc/build_instructions/arch_linux.md
+++ b/doc/build_instructions/arch_linux.md
@@ -1,13 +1,15 @@
 # Prerequisite steps for Arch Linux users
 
-> NOTE: [aur](https://aur.archlinux.org/packages/openage-git/) exists, to install via **yaourt** run `yaourt -S openage-git`.
+> NOTE: `openage` is packaged in the [AUR](https://aur.archlinux.org/packages/openage-git/)!
 
 This command should provide required packages for Arch Linux installation:
 
-`sudo pacman -S --needed python python-jinja python-pillow python-numpy python-pygments cython libepoxy libogg libpng ttf-dejavu freetype2 fontconfig harfbuzz cmake sdl2 sdl2_image opusfile opus python-pylint qt5-declarative qt5-quickcontrols`
+`sudo pacman -S --needed eigen python python-jinja python-pillow python-numpy python-pygments cython libepoxy libogg libpng ttf-dejavu freetype2 fontconfig harfbuzz cmake sdl2 sdl2_image opusfile opus python-pylint qt5-declarative qt5-quickcontrols`
 
 If you don't have a compiler installed, you can select between these commands to install it:
  - `sudo pacman -S --needed gcc`
  - `sudo pacman -S --needed clang`
 
 You can install both compilers and select the one to be used by `./configure`.
+
+You will also need [nyan](https://github.com/SFTtech/nyan/blob/master/doc/building.md) and its dependencies.
diff --git a/doc/build_instructions/debian.md b/doc/build_instructions/debian.md
index a6b3edfaa8..e693dcf7d5 100644
--- a/doc/build_instructions/debian.md
+++ b/doc/build_instructions/debian.md
@@ -1,6 +1,6 @@
 # Prerequisite steps for Debian Sid users
 
  - `sudo apt-get update`
- - `sudo apt-get install cmake libfreetype6-dev python3-dev python3-pip libepoxy-dev libsdl2-dev libsdl2-image-dev libopusfile-dev libfontconfig1-dev libharfbuzz-dev libpng-dev opus-tools python3-pil python3-numpy python3-pygments qtdeclarative5-dev qml-module-qtquick-controls cython3 python3-jinja2`
+ - `sudo apt-get install cmake cython3 libeigen3-dev libepoxy-dev libfontconfig1-dev libfreetype6-dev libharfbuzz-dev libogg-dev libopus-dev libopusfile-dev libpng-dev libsdl2-dev libsdl2-image-dev python3-dev python3-jinja2 python3-numpy python3-pil python3-pip python3-pygments qml-module-qtquick-controls qtdeclarative5-dev`
 
 You will also need [nyan](https://github.com/SFTtech/nyan/blob/master/doc/building.md) and its dependencies.
diff --git a/doc/build_instructions/fedora.md b/doc/build_instructions/fedora.md
index 8254eee322..a8b9b1af9e 100644
--- a/doc/build_instructions/fedora.md
+++ b/doc/build_instructions/fedora.md
@@ -2,6 +2,6 @@
 
 Run the following command:
 
-`sudo dnf install cmake gcc-c++ clang SDL2-devel SDL2_image-devel python3-Cython python3-devel python3-numpy python3-pillow python3-pygments libepoxy-devel libogg-devel libopusenc-devel python3-jinja2 libpng-devel opusfile-devel fontconfig-devel harfbuzz-devel qt5-qtdeclarative-devel qt5-qtquickcontrols`
+`sudo dnf install clang cmake eigen3-devel fontconfig-devel gcc-c harfbuzz-devel libepoxy-devel libogg-devel libopusenc-devel libpng-devel opusfile-devel python3-Cython python3-devel python3-jinja2 python3-numpy python3-pillow python3-pygments SDL2-devel SDL2_image-devel++ qt5-qtdeclarative-devel qt5-qtquickcontrols`
 
 You will also need [nyan](https://github.com/SFTtech/nyan/blob/master/doc/building.md) and its dependencies.
diff --git a/doc/build_instructions/freebsd.md b/doc/build_instructions/freebsd.md
index 5328aa13e0..c59970af06 100644
--- a/doc/build_instructions/freebsd.md
+++ b/doc/build_instructions/freebsd.md
@@ -2,11 +2,11 @@
 
 This command should provide required packages for FreeBSD installation:
 
-`sudo pkg install python py-pillow py-numpy py-pygments cython harfbuzz cmake sdl2 sdl2_image opusfile opus-tools png pylint qt5`
+`sudo pkg install cmake cython eigen3 harfbuzz opus-tools opusfile png py-numpy py-pillow py-pygments pylint python qt5 sdl2 sdl2_image`
 
 You will also need [nyan](https://github.com/SFTtech/nyan/blob/master/doc/building.md) and its dependencies.
 
-clang is the base compiler however, it is possible to use either any version of gcc>=7 or any other version of clang present in pkg:
+`clang` is the base compiler however, it is possible to use either any version of `gcc>=7` or any other version of `clang` present in `pkg`:
  - `sudo pkg install gcc`
 
-Select the one to be used by `./configure`.
+Select the one to be used by `./configure --help`.
diff --git a/doc/build_instructions/gentoo.md b/doc/build_instructions/gentoo.md
index e25a77a663..cbbf75db73 100644
--- a/doc/build_instructions/gentoo.md
+++ b/doc/build_instructions/gentoo.md
@@ -31,5 +31,5 @@ If you want to install the latest git version:
 =games-strategy/openage-9999::sft **
 ```
 
-Beware, the git version does not do automatic updates.
+Beware, the git version does **not** do automatic updates.
 You have to explicitly "reinstall" openage or use `app-portage/smart-live-rebuild`.
diff --git a/doc/build_instructions/opensuse_13.2.md b/doc/build_instructions/opensuse_13.2.md
index 48b6ead569..d044b93a40 100644
--- a/doc/build_instructions/opensuse_13.2.md
+++ b/doc/build_instructions/opensuse_13.2.md
@@ -6,6 +6,6 @@ if all packages can be installed.
 
 - `zypper addrepo http://download.opensuse.org/repositories/devel:languages:python3/openSUSE_13.2/devel:languages:python3.repo`
 - `zypper refresh`
-- `zypper install --no-recommends cmake doxygen fontconfig-devel harfbuzz-devel gcc49-c++ graphviz libpng-devel libSDL2-devel libSDL2_image-devel libfreetype6 libepoxy-devel libogg-devel libopus-devel opusfile-devel pkgconfig python3-Cython python3-Jinja2 python3-Pillow python3-Pygments python3-devel libqt5-qtdeclarative-devel libqt5-qtquickcontrols`
+- `zypper install --no-recommends cmake doxygen eigen3-devel fontconfig-devel gcc49-c graphviz++ harfbuzz-devel libSDL2-devel libSDL2_image-devel libepoxy-devel libfreetype6 libogg-devel libopus-devel libpng-devel libqt5-qtdeclarative-devel libqt5-qtquickcontrols opusfile-devel pkgconfig python3-Cython python3-Jinja2 python3-Pillow python3-Pygments python3-devel`
 
 You will also need [nyan](https://github.com/SFTtech/nyan/blob/master/doc/building.md) and its dependencies.
diff --git a/doc/build_instructions/opensuse_tumbleweed.md b/doc/build_instructions/opensuse_tumbleweed.md
index 57bbf83d13..a85de0177f 100644
--- a/doc/build_instructions/opensuse_tumbleweed.md
+++ b/doc/build_instructions/opensuse_tumbleweed.md
@@ -1,5 +1,5 @@
 # Prerequisite steps for openSUSE users (openSUSE Tumbleweed)
 
- - `zypper install --no-recommends cmake doxygen fontconfig-devel harfbuzz-devel gcc-c++ graphviz libpng-devel libSDL2-devel libSDL2_image-devel libfreetype6 libepoxy-devel libogg-devel libopus-devel opusfile-devel pkgconfig python3-Cython python3-Jinja2 python3-Pillow python3-Pygments python3-devel libqt5-qtdeclarative-devel libqt5-qtquickcontrols`
+ - `zypper install --no-recommends cmake doxygen eigen3-devel fontconfig-devel gcc-c graphviz++ harfbuzz-devel libSDL2-devel libSDL2_image-devel libepoxy-devel libfreetype6 libogg-devel libopus-devel libpng-devel libqt5-qtdeclarative-devel libqt5-qtquickcontrols opusfile-devel pkgconfig python3-Cython python3-Jinja2 python3-Pillow python3-Pygments python3-devel`
 
 You will also need [nyan](https://github.com/SFTtech/nyan/blob/master/doc/building.md) and its dependencies.
diff --git a/doc/build_instructions/ubuntu.md b/doc/build_instructions/ubuntu.md
index de2465b3f4..c1855f505f 100644
--- a/doc/build_instructions/ubuntu.md
+++ b/doc/build_instructions/ubuntu.md
@@ -1,7 +1,6 @@
 # Prerequisite steps for Ubuntu users (Ubuntu 18.04)
 
  - `sudo apt-get update`
- - `sudo apt-get install cmake libfreetype6-dev python3-dev python3-pip libepoxy-dev libsdl2-dev libsdl2-image-dev libopusfile-dev libfontconfig1-dev libharfbuzz-dev libogg-dev libopus-dev libpng-dev python3-pil python3-numpy python3-pygments python3-jinja2 qtdeclarative5-dev qml-module-qtquick-controls`
- - `pip3 install cython`
+ - `sudo apt-get install cmake cython3 libeigen3-dev libepoxy-dev libfontconfig1-dev libfreetype6-dev libharfbuzz-dev libogg-dev libopus-dev libopusfile-dev libpng-dev libsdl2-dev libsdl2-image-dev python3-dev python3-jinja2 python3-numpy python3-pil python3-pip python3-pygments qml-module-qtquick-controls qtdeclarative5-dev`
 
 You will also need [nyan](https://github.com/SFTtech/nyan/blob/master/doc/building.md) and its dependencies.
diff --git a/doc/build_instructions/windows_msvc.md b/doc/build_instructions/windows_msvc.md
index f6e6aa6693..dd380c7eec 100644
--- a/doc/build_instructions/windows_msvc.md
+++ b/doc/build_instructions/windows_msvc.md
@@ -25,7 +25,7 @@
 ### vcpkg packages
  Set up [vcpkg](https://github.com/Microsoft/vcpkg#quick-start). Open a command prompt at `<vcpkg directory>`
 
-    vcpkg install dirent libepoxy fontconfig freetype harfbuzz libogg opus opusfile qt5-base qt5-declarative qt5-quickcontrols sdl2 sdl2-image libpng
+    vcpkg install dirent eigen3 fontconfig freetype harfbuzz libepoxy libogg libpng opus opusfile qt5-base qt5-declarative qt5-quickcontrols sdl2 sdl2-image
 
  _Note:_ The `qt5` port in vcpkg has been split into multiple packages, build times are acceptable now.
  If you want, you can still use [the prebuilt version](https://www.qt.io/download-open-source/) instead.
diff --git a/doc/building.md b/doc/building.md
index f66fb093d6..bb1af0dafb 100644
--- a/doc/building.md
+++ b/doc/building.md
@@ -33,28 +33,30 @@ Dependency list:
     C     cmake >=3.1.0
       A   numpy
       A   python imaging library (PIL) -> pillow
-    CR    opengl >=2.1
+    CR    opengl >=3.3
     CR    libepoxy
     CR    libpng
      R    dejavu font
+    CR    eigen >=3
     CR    freetype2
     CR    fontconfig
-    CR    harfbuzz >= 1.0.0
+    CR    harfbuzz >=1.0.0
     CR    nyan  (https://github.com/SFTtech/nyan)
     CR  O ncurses
     C     jinja2
     CR    sdl2
     CR    sdl2_image
     CR    opusfile
-    CRA   libopus
-    CRA   libogg
-       S  pycodestyle (or pep8 (deprecated))
+    CRA   opus
+    CRA   ogg
+       S  pycodestyle
     C     pygments
        S  pylint
     CR    qt5 >=5.5 (Core, Quick, QuickControls modules)
+    CR  O vulkan
 
       A   An installed version of any of the following (wine is your friend).
-          Other versions _might_ work; setup disk support will be added soon:
+          Other versions _might_ work:
 
      - Age of Empires II: The Conquerors Patch 1.0c
      - Age of Empires II: Forgotten Empires