Limb animation actually works

16 files changed, 861 insertions, 167 deletions

diff --git a/include/common.hpp b/include/common.hpp
index 71039c7..1244464 100644
--- a/include/common.hpp
+++ b/include/common.hpp
@@ -14,7 +14,6 @@
 #include <algorithm>
 #include <list>
 #include <iterator>
-#include <unordered_map>
 
 // alternative windows thread library
 #ifndef __WIN32__
@@ -45,6 +44,7 @@
 
 // windows stuff
 #ifdef __WIN32__
+using uint = unsigned int;
 #undef near
 #endif
 
@@ -53,77 +53,12 @@
  */
 #define DEBUG_printf(message, ...) DEBUG_prints(__FILE__, __LINE__, message, __VA_ARGS__)
 
-#define BREAKPOINT __asm__("int $3")
-
 #define coalesce(v1, v2) ((v1 != nullptr) ? v1 : v2)
 
-/**
- * Creates a coordinate of integers.
- */
-typedef struct {
-	int x; /**< The x coordinate */
-	int y; /**< The y coordinate */
-} ivec2;
+#include <vector2.hpp>
 
-/**
- * A pair of x and y for dimensions (i.e. width and height).
- */
-typedef ivec2 dim2;
-
-/**
- * Creates a coordinate out of floating point integers.
- */
-struct vec2 {
-	float x;
-	float y;
-
-	vec2(float _x = 0.0f, float _y = 0.0f)
-		: x(_x), y(_y) {}
-
-	bool operator==(const vec2 &v) const {
-		return (x == v.x) && (y == v.y);
-	}
-
-	template<typename T>
-	const vec2 operator=(const T &n) {
-		x = y = n;
-		return *this;
-	}
-
-	template<typename T>
-	vec2 operator+(T n) const {
-		return vec2 (x + n, y + n);
-	}
-
-	vec2 operator+(const vec2 &v) {
-		return vec2 (x + v.x, y + v.y);
-	}
-
-	vec2 operator*(const float&n) const {
-		return vec2 (x * n, y * n);
-	}
-
-	vec2 operator/(const float& n) const {
-		return vec2 (x / n, y / n);
-	}
-
-	// std::swap can't work due to being packed
-
-	inline void swapX(vec2 &v) {
-		float t = x;
-		x = v.x, v.x = t;
-	}
-
-	inline void swapY(vec2 &v) {
-		float t = y;
-		y = v.y, v.y = t;
-	}
-
-	std::string toString(void) const {
-		return "(" + std::to_string(x) + ", " + std::to_string(y) + ")";
-	}
-
-} __attribute__ ((packed));
+using vec2 = vector2<float>;
+using dim2 = vector2<int>;
 
 /**
  * A structure for three-dimensional points.
@@ -135,8 +70,7 @@ struct vec3 {
 
 	vec3(float _x = 0.0f, float _y = 0.0f, float _z = 1.0f)
 		: x(_x), y(_y), z(_z) {}
-
-} __attribute__ ((packed));
+};
 
 /**
  * This structure contains two sets of coordinates for ray drawing.
@@ -157,47 +91,27 @@ public:
 	float blue;  /**< The amount of blue */
 	float alpha; /**< Transparency */
 
-    Color() {
-		red = green = blue = alpha = 0.0f;
-	}
+	Color(float r = 0, float g = 0, float b = 0, float a = 255)
+		: red(r), green(g), blue(b), alpha(a) {}
 
-	Color(float r, float g ,float b) {
-		red = r;
-		green = g;
-		blue = b;
-        alpha = 255;
+	Color operator-(const float& a) {
+		return Color(red - a, green - a, blue - a, alpha);
 	}
 
-    Color(float r, float g, float b, float a) {
-        red = r;
-        green = g;
-        blue = b;
-        alpha = a;
-    }
-
-	Color operator-=(float a) {
-		red -= a;
-		green -= a;
-		blue -= a;
-		return{red+a,green+a,blue+a};
-	}
-	Color operator+=(float a) {
-		return{red+a,green+a,blue+a};
-	}
-	Color operator=(float a) {
-		return{red=a,green=a,blue=a};
+	Color operator+(const float& a) {
+		return Color(red + a, green + a, blue + a, alpha);
 	}
 };
 
 /**
  * The amount of game ticks that should occur each second.
  */
-constexpr const unsigned int TICKS_PER_SEC = 20;
+constexpr unsigned int TICKS_PER_SEC = 20;
 
 /**
  * The amount of milliseconds it takes for a game tick to fire.
  */
-constexpr const float MSEC_PER_TICK = 1000.0f / TICKS_PER_SEC;
+constexpr float MSEC_PER_TICK = 1000.0f / TICKS_PER_SEC;
 
 /**
  * Separates a string into tokens using the given delimiter.
@@ -209,24 +123,6 @@ constexpr const float MSEC_PER_TICK = 1000.0f / TICKS_PER_SEC;
 std::vector<std::string> StringTokenizer(const std::string& str, char delim);
 
 /**
- * Seperates a string like, "23,12" to a vec2.
- * 
- * @param s the string to parse
- * @return the vec2 of the values passed in the string
- */
-vec2 str2coord(std::string s);
-
-/**
- * A function to draw a colored box for OpenGL.
- * To use it, the lower left hand and upper right hand coords are given.
- *
- * @param the lower left coordinate
- * @param the upper right coordinate
- * @param the z coordinate
- */
-void drawRect(vec2 ll, vec2 ur, float z);
-
-/**
  * Returns a measurement in HLINEs
  *
  * @param the number of HLINEs, integer or decimal
@@ -251,7 +147,7 @@ inline T HLINES(const T &n)
 #define randGet rand
 
 // defines pi for calculations that need it.
-constexpr const float PI = 3.1415926535f;
+constexpr float PI = 3.1415926535f;
 
 // references the variable in main.cpp, used for drawing with the player
 extern vec2 offset;
@@ -265,10 +161,7 @@ void DEBUG_prints(const char* file, int line, const char *s,...);
 unsigned int millis(void);
 
 // reads the names of files in a directory into the given string vector
-int getdir(std::string dir, std::vector<std::string> &files);
-
-// sorts a vector of strings alphabetically
-void strVectorSortAlpha(std::vector<std::string> *v);
+int getdir(std::string dir, std::list<std::string>& files);
 
 // reads the given file into a buffer and returns a pointer to the buffer
 std::string readFile(const std::string& path);
diff --git a/include/components.hpp b/include/components.hpp
index 9a83d45..f8eeaf1 100644
--- a/include/components.hpp
+++ b/include/components.hpp
@@ -320,11 +320,6 @@ struct Animate {
 	}
 };
 
-//TODO
-struct Input {
-
-};
-
 /**
  * @struct Visible
  * @brief If an entity is visible we want to be able to draw it.
@@ -391,9 +386,12 @@ class RenderSystem : public entityx::System<RenderSystem> {
 private:
 	std::string loadTexString;
 	Texture loadTexResult;
+
 public:
 	Texture loadTexture(const std::string& file);
-	void update(entityx::EntityManager &en, entityx::EventManager &ev, entityx::TimeDelta dt) override;
+	void update(entityx::EntityManager &en, entityx::EventManager &ev, entityx::TimeDelta dt) override
+	{ (void)en; (void)ev; (void)dt; }
+	void render(void);
 };
 
 class DialogSystem : public entityx::System<DialogSystem>, public entityx::Receiver<DialogSystem> {
diff --git a/include/engine.hpp b/include/engine.hpp
index 2b03696..417522d 100644
--- a/include/engine.hpp
+++ b/include/engine.hpp
@@ -40,13 +40,6 @@ public:
 	void init(void);
 
 	/**
-	 * Updates all rendering systems.
-	 * @param dt the delta time
-	 */
-    void render(entityx::TimeDelta dt);
-	void resetRender(entityx::TimeDelta dt);
-
-	/**
 	 * Updates all logic systems.
 	 * @param dt the delta time
 	 */
@@ -70,6 +63,38 @@ public:
 	}
 };
 
+#include <atomic>
+#include <chrono>
+
+class LockableEntityManager : public entityx::EntityManager {
+private:
+	std::atomic_bool locked;
+	
+public:
+	LockableEntityManager(entityx::EventManager& ev)
+		: EntityManager(ev) {
+		locked.store(false);
+	}
+	
+	void lock(void) {
+		while (locked.load())
+			std::this_thread::sleep_for(std::chrono::milliseconds(10));
+		
+		locked.store(true);
+	}
+	
+	void unlock(void) {
+		locked.store(false);
+	}
+	
+	bool try_lock(void) {
+		if (locked.load())
+			return false;
+		
+		locked.store(true);
+		return true;
+	}
+};
 
 namespace game {
 	/**
@@ -80,8 +105,8 @@ namespace game {
 	/**
 	 * Handles entity data.
 	 */
-    extern entityx::EntityManager entities;
-
+    extern LockableEntityManager entities;
+	
 	/**
 	 * An instance of the main game engine.
 	 */
diff --git a/include/events.hpp b/include/events.hpp
index 2daae56..1f06544 100644
--- a/include/events.hpp
+++ b/include/events.hpp
@@ -16,6 +16,13 @@ class World;
 /// INPUT EVENTS
 //////////////////////////
 
+struct MainSDLEvent {
+	MainSDLEvent(SDL_Event e)
+		: event(e) {}
+	
+	SDL_Event event;
+};
+
 struct MouseScrollEvent {
  	MouseScrollEvent(int sd = 0)
  		: scrollDistance(sd) {}
diff --git a/include/inventory.hpp b/include/inventory.hpp
index fa24de4..44ed148 100644
--- a/include/inventory.hpp
+++ b/include/inventory.hpp
@@ -7,29 +7,57 @@
 #include <events.hpp>
 
 struct Item {
-    GLuint icon;
+	std::string name;
+	std::string type;
+	int value;
+	int stackSize;
+	Texture sprite;
+
+	Item(void)
+		: value(0), stackSize(1) {}
+
+	Item(XMLElement *e) {
+		name = e->StrAttribute("name");
+		type = e->StrAttribute("type");
+		
+		value = 0;
+		e->QueryIntAttribute("value", &value);
+		stackSize = 1;
+		e->QueryIntAttribute("maxStackSize", &stackSize);
+		
+		sprite = Texture(e->StrAttribute("sprite"));
+	}
 };
 
-using InventoryEntry = std::pair<Item, unsigned int>;
+struct InventoryEntry {
+	Item* item;
+	int count;
+	vec2 loc;
+
+	InventoryEntry(void)
+		: item(nullptr), count(0) {}
+};
 
 class InventorySystem : public entityx::System<InventorySystem>, public entityx::Receiver<InventorySystem> {
 private:
-    entityx::Entity currentItemEntity;
-
     std::vector<InventoryEntry> items;
-    unsigned int maxItemCount;
 
 public:
-    InventorySystem(unsigned int mic = 1)
-        : maxItemCount(mic) {}
+    InventorySystem(int size = 4) {
+		items.resize(size);
+		loadItems();
+	}
 
     void configure(entityx::EventManager &ev);
 
-    void loadIcons(void);
+    void loadItems(void);
 
     void update(entityx::EntityManager &en, entityx::EventManager &ev, entityx::TimeDelta dt) override;
 
     void receive(const KeyDownEvent &kde);
+	void render(void);
+
+	void add(const std::string& name, int count);
 };
 
 #endif // INVENTORY_HPP_
diff --git a/include/mingw.condition_variable.h b/include/mingw.condition_variable.h
new file mode 100644
index 0000000..b664758
--- /dev/null
+++ b/include/mingw.condition_variable.h
@@ -0,0 +1,211 @@
+/**
+* @file condition_variable.h
+* @brief std::condition_variable implementation for MinGW
+*
+* (c) 2013-2016 by Mega Limited, Auckland, New Zealand
+* @author Alexander Vassilev
+*
+* @copyright Simplified (2-clause) BSD License.
+* You should have received a copy of the license along with this
+* program.
+*
+* This code is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+* @note
+* This file may become part of the mingw-w64 runtime package. If/when this happens,
+* the appropriate license will be added, i.e. this code will become dual-licensed,
+* and the current BSD 2-clause license will stay.
+*/
+
+#ifndef MINGW_CONDITIONAL_VARIABLE_H
+#define MINGW_CONDITIONAL_VARIABLE_H
+#include <atomic>
+#include <assert.h>
+#include "mingw.mutex.h"
+#include <chrono>
+#include <system_error>
+#include <windows.h>
+#ifdef _GLIBCXX_HAS_GTHREADS
+#error This version of MinGW seems to include a win32 port of pthreads, and probably    \
+    already has C++11 std threading classes implemented, based on pthreads.             \
+    It is likely that you will get errors about redefined classes, and unfortunately    \
+    this implementation can not be used standalone and independent of the system <mutex>\
+    header, since it relies on it for                                                   \
+    std::unique_lock and other utility classes. If you would still like to use this     \
+    implementation (as it is more lightweight), you have to edit the                    \
+    c++-config.h system header of your MinGW to not define _GLIBCXX_HAS_GTHREADS.       \
+    This will prevent system headers from defining actual threading classes while still \
+    defining the necessary utility classes.
+#endif
+
+namespace std
+{
+
+enum class cv_status { no_timeout, timeout };
+class condition_variable_any
+{
+protected:
+    recursive_mutex mMutex;
+    atomic<int> mNumWaiters;
+    HANDLE mSemaphore;
+    HANDLE mWakeEvent;
+public:
+    typedef HANDLE native_handle_type;
+    native_handle_type native_handle() {return mSemaphore;}
+    condition_variable_any(const condition_variable_any&) = delete;
+    condition_variable_any& operator=(const condition_variable_any&) = delete;
+    condition_variable_any()
+        :mNumWaiters(0), mSemaphore(CreateSemaphore(NULL, 0, 0xFFFF, NULL)),
+         mWakeEvent(CreateEvent(NULL, FALSE, FALSE, NULL))
+    {}
+    ~condition_variable_any() {  CloseHandle(mWakeEvent); CloseHandle(mSemaphore);  }
+protected:
+    template <class M>
+    bool wait_impl(M& lock, DWORD timeout)
+    {
+        {
+            lock_guard<recursive_mutex> guard(mMutex);
+            mNumWaiters++;
+        }
+        lock.unlock();
+            DWORD ret = WaitForSingleObject(mSemaphore, timeout);
+
+        mNumWaiters--;
+        SetEvent(mWakeEvent);
+        lock.lock();
+        if (ret == WAIT_OBJECT_0)
+            return true;
+        else if (ret == WAIT_TIMEOUT)
+            return false;
+//2 possible cases:
+//1)The point in notify_all() where we determine the count to
+//increment the semaphore with has not been reached yet:
+//we just need to decrement mNumWaiters, but setting the event does not hurt
+//
+//2)Semaphore has just been released with mNumWaiters just before
+//we decremented it. This means that the semaphore count
+//after all waiters finish won't be 0 - because not all waiters
+//woke up by acquiring the semaphore - we woke up by a timeout.
+//The notify_all() must handle this grafecully
+//
+        else
+            throw system_error(EPROTO, generic_category());
+    }
+public:
+    template <class M>
+    void wait(M& lock)
+    {
+        wait_impl(lock, INFINITE);
+    }
+    template <class M, class Predicate>
+    void wait(M& lock, Predicate pred)
+    {
+        while(!pred())
+        {
+            wait(lock);
+        };
+    }
+
+    void notify_all() noexcept
+    {
+        lock_guard<recursive_mutex> lock(mMutex); //block any further wait requests until all current waiters are unblocked
+        if (mNumWaiters.load() <= 0)
+            return;
+
+        ReleaseSemaphore(mSemaphore, mNumWaiters, NULL);
+        while(mNumWaiters > 0)
+        {
+            auto ret = WaitForSingleObject(mWakeEvent, 1000);
+            if ((ret == WAIT_FAILED) || (ret == WAIT_ABANDONED))
+                throw system_error(EPROTO, generic_category());
+        }
+        assert(mNumWaiters == 0);
+//in case some of the waiters timed out just after we released the
+//semaphore by mNumWaiters, it won't be zero now, because not all waiters
+//woke up by acquiring the semaphore. So we must zero the semaphore before
+//we accept waiters for the next event
+//See _wait_impl for details
+        while(WaitForSingleObject(mSemaphore, 0) == WAIT_OBJECT_0);
+    }
+    void notify_one() noexcept
+    {
+        lock_guard<recursive_mutex> lock(mMutex);
+        if (!mNumWaiters)
+            return;
+        int targetWaiters = mNumWaiters.load() - 1;
+        ReleaseSemaphore(mSemaphore, 1, NULL);
+        while(mNumWaiters > targetWaiters)
+        {
+            auto ret = WaitForSingleObject(mWakeEvent, 1000);
+            if ((ret == WAIT_FAILED) || (ret == WAIT_ABANDONED))
+                throw system_error(EPROTO, generic_category());
+        }
+        assert(mNumWaiters == targetWaiters);
+    }
+    template <class M, class Rep, class Period>
+    std::cv_status wait_for(M& lock,
+      const std::chrono::duration<Rep, Period>& rel_time)
+    {
+        long long timeout = chrono::duration_cast<chrono::milliseconds>(rel_time).count();
+        if (timeout < 0)
+            timeout = 0;
+        bool ret = wait_impl(lock, (DWORD)timeout);
+        return ret?cv_status::no_timeout:cv_status::timeout;
+    }
+
+    template <class M, class Rep, class Period, class Predicate>
+    bool wait_for(M& lock,
+       const std::chrono::duration<Rep, Period>& rel_time, Predicate pred)
+    {
+        wait_for(lock, rel_time);
+        return pred();
+    }
+    template <class M, class Clock, class Duration>
+    cv_status wait_until (M& lock,
+      const chrono::time_point<Clock,Duration>& abs_time)
+    {
+        return wait_for(lock, abs_time - Clock::now());
+    }
+    template <class M, class Clock, class Duration, class Predicate>
+    bool wait_until (M& lock,
+      const std::chrono::time_point<Clock, Duration>& abs_time,
+      Predicate pred)
+    {
+        auto time = abs_time - Clock::now();
+        if (time < 0)
+            return pred();
+        else
+            return wait_for(lock, time, pred);
+    }
+};
+class condition_variable: protected condition_variable_any
+{
+protected:
+    typedef condition_variable_any base;
+public:
+    using base::native_handle_type;
+    using base::native_handle;
+    using base::base;
+    using base::notify_all;
+    using base::notify_one;
+    void wait(unique_lock<mutex> &lock)
+    {       base::wait(lock);                               }
+    template <class Predicate>
+    void wait(unique_lock<mutex>& lock, Predicate pred)
+    {       base::wait(lock, pred);                         }
+    template <class Rep, class Period>
+    std::cv_status wait_for(unique_lock<mutex>& lock, const std::chrono::duration<Rep, Period>& rel_time)
+    {      return base::wait_for(lock, rel_time);           }
+    template <class Rep, class Period, class Predicate>
+    bool wait_for(unique_lock<mutex>& lock, const std::chrono::duration<Rep, Period>& rel_time, Predicate pred)
+    {        return base::wait_for(lock, rel_time, pred);   }
+    template <class Clock, class Duration>
+    cv_status wait_until (unique_lock<mutex>& lock, const chrono::time_point<Clock,Duration>& abs_time)
+    {        return base::wait_for(lock, abs_time);         }
+    template <class Clock, class Duration, class Predicate>
+    bool wait_until (unique_lock<mutex>& lock, const std::chrono::time_point<Clock, Duration>& abs_time, Predicate pred)
+    {        return base::wait_until(lock, abs_time, pred); }
+};
+}
+#endif // MINGW_CONDITIONAL_VARIABLE_H
diff --git a/include/mingw.mutex.h b/include/mingw.mutex.h
new file mode 100644
index 0000000..d453202
--- /dev/null
+++ b/include/mingw.mutex.h
@@ -0,0 +1,275 @@
+/**
+* @file mingw.mutex.h
+* @brief std::mutex et al implementation for MinGW
+** (c) 2013-2016 by Mega Limited, Auckland, New Zealand
+* @author Alexander Vassilev
+*
+* @copyright Simplified (2-clause) BSD License.
+* You should have received a copy of the license along with this
+* program.
+*
+* This code is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+* @note
+* This file may become part of the mingw-w64 runtime package. If/when this happens,
+* the appropriate license will be added, i.e. this code will become dual-licensed,
+* and the current BSD 2-clause license will stay.
+*/
+
+#ifndef WIN32STDMUTEX_H
+#define WIN32STDMUTEX_H
+#ifdef _GLIBCXX_HAS_GTHREADS
+#error This version of MinGW seems to include a win32 port of pthreads, and probably    \
+    already has C++11 std threading classes implemented, based on pthreads.             \
+    You are likely to have class redefinition errors below, and unfirtunately this      \
+    implementation can not be used standalone                                           \
+    and independent of the system <mutex> header, since it relies on it for             \
+    std::unique_lock and other utility classes. If you would still like to use this     \
+    implementation (as it is more lightweight), you have to edit the                    \
+    c++-config.h system header of your MinGW to not define _GLIBCXX_HAS_GTHREADS.       \
+    This will prevent system headers from defining actual threading classes while still \
+    defining the necessary utility classes.
+#endif
+// Recursion checks on non-recursive locks have some performance penalty, so the user
+// may want to disable the checks in release builds. In that case, make sure they
+// are always enabled in debug builds.
+
+#if defined(STDMUTEX_NO_RECURSION_CHECKS) && !defined(NDEBUG)
+    #undef STDMUTEX_NO_RECURSION_CHECKS
+#endif
+
+#include <windows.h>
+#include <chrono>
+#include <system_error>
+
+#ifndef EPROTO
+    #define EPROTO 134
+#endif
+#ifndef EOWNERDEAD
+    #define EOWNERDEAD 133
+#endif
+
+namespace std
+{
+class recursive_mutex
+{
+protected:
+    CRITICAL_SECTION mHandle;
+public:
+    typedef LPCRITICAL_SECTION native_handle_type;
+    native_handle_type native_handle() {return &mHandle;}
+    recursive_mutex() noexcept
+    {
+        InitializeCriticalSection(&mHandle);
+    }
+    recursive_mutex (const recursive_mutex&) = delete;
+    recursive_mutex& operator=(const recursive_mutex&) = delete;
+    ~recursive_mutex() noexcept
+    {
+        DeleteCriticalSection(&mHandle);
+    }
+    void lock()
+    {
+        EnterCriticalSection(&mHandle);
+    }
+    void unlock()
+    {
+        LeaveCriticalSection(&mHandle);
+    }
+    bool try_lock()
+    {
+        return (TryEnterCriticalSection(&mHandle)!=0);
+    }
+};
+template <class B>
+class _NonRecursive: protected B
+{
+protected:
+    typedef B base;
+    DWORD mOwnerThread;
+public:
+    using base::native_handle_type;
+    using base::native_handle;
+    _NonRecursive() noexcept :base(), mOwnerThread(0) {}
+    _NonRecursive (const _NonRecursive<B>&) = delete;
+    _NonRecursive& operator= (const _NonRecursive<B>&) = delete;
+    void lock()
+    {
+        base::lock();
+        checkSetOwnerAfterLock();
+    }
+protected:
+    void checkSetOwnerAfterLock()
+    {
+        DWORD self = GetCurrentThreadId();
+        if (mOwnerThread == self)
+        {
+            fprintf(stderr, "FATAL: Recursive locking or non-recursive mutex detected. Throwing sysetm exception\n");
+            fflush(stderr);
+            throw system_error(EDEADLK, generic_category());
+        }
+        mOwnerThread = self;
+    }
+    void checkSetOwnerBeforeUnlock()
+    {
+        DWORD self = GetCurrentThreadId();
+        if (mOwnerThread != self)
+        {
+            fprintf(stderr, "FATAL: Recursive unlocking of non-recursive mutex detected. Throwing system exception\n");
+            fflush(stderr);
+            throw system_error(EDEADLK, generic_category());
+        }
+        mOwnerThread = 0;
+    }
+public:
+    void unlock()
+    {
+        checkSetOwnerBeforeUnlock();
+        base::unlock();
+    }
+    bool try_lock()
+    {
+        bool ret = base::try_lock();
+        if (ret)
+            checkSetOwnerAfterLock();
+        return ret;
+    }
+};
+
+#ifndef STDMUTEX_NO_RECURSION_CHECKS
+    typedef _NonRecursive<recursive_mutex> mutex;
+#else
+    typedef recursive_mutex mutex;
+#endif
+
+class recursive_timed_mutex
+{
+protected:
+    HANDLE mHandle;
+public:
+    typedef HANDLE native_handle_type;
+    native_handle_type native_handle() const {return mHandle;}
+    recursive_timed_mutex(const recursive_timed_mutex&) = delete;
+    recursive_timed_mutex& operator=(const recursive_timed_mutex&) = delete;
+    recursive_timed_mutex(): mHandle(CreateMutex(NULL, FALSE, NULL)){}
+    ~recursive_timed_mutex()
+    {
+        CloseHandle(mHandle);
+    }
+    void lock()
+    {
+        DWORD ret = WaitForSingleObject(mHandle, INFINITE);
+        if (ret != WAIT_OBJECT_0)
+        {
+            if (ret == WAIT_ABANDONED)
+                throw system_error(EOWNERDEAD, generic_category());
+            else
+                throw system_error(EPROTO, generic_category());
+        }
+    }
+    void unlock()
+    {
+        if (!ReleaseMutex(mHandle))
+            throw system_error(EDEADLK, generic_category());
+    }
+    bool try_lock()
+    {
+        DWORD ret = WaitForSingleObject(mHandle, 0);
+        if (ret == WAIT_TIMEOUT)
+            return false;
+        else if (ret == WAIT_OBJECT_0)
+            return true;
+        else if (ret == WAIT_ABANDONED)
+            throw system_error(EOWNERDEAD, generic_category());
+        else
+            throw system_error(EPROTO, generic_category());
+    }
+    template <class Rep, class Period>
+    bool try_lock_for(const std::chrono::duration<Rep,Period>& dur)
+    {
+        DWORD timeout = (DWORD)chrono::duration_cast<chrono::milliseconds>(dur).count();
+
+        DWORD ret = WaitForSingleObject(mHandle, timeout);
+        if (ret == WAIT_TIMEOUT)
+            return false;
+        else if (ret == WAIT_OBJECT_0)
+            return true;
+        else if (ret == WAIT_ABANDONED)
+            throw system_error(EOWNERDEAD, generic_category());
+        else
+            throw system_error(EPROTO, generic_category());
+    }
+    template <class Clock, class Duration>
+    bool try_lock_until(const std::chrono::time_point<Clock,Duration>& timeout_time)
+    {
+        return try_lock_for(timeout_time - Clock::now());
+    }
+};
+
+class timed_mutex: public _NonRecursive<recursive_timed_mutex>
+{
+protected:
+    typedef _NonRecursive<recursive_timed_mutex> base;
+public:
+    using base::base;
+    timed_mutex(const timed_mutex&) = delete;
+    timed_mutex& operator=(const timed_mutex&) = delete;
+    template <class Rep, class Period>
+    void try_lock_for(const std::chrono::duration<Rep,Period>& dur)
+    {
+        bool ret = base::try_lock_for(dur);
+#ifndef STDMUTEX_NO_RECURSION_CHECKS
+        if (ret)
+            checkSetOwnerAfterLock();
+#endif
+        return ret;
+    }
+public:
+    template <class Clock, class Duration>
+    bool try_lock_until(const std::chrono::time_point<Clock,Duration>& timeout_time)
+    {
+        bool ret = base::try_lock_until(timeout_time);
+#ifndef STDMUTEX_NO_RECURSION_CHECKS
+        if (ret)
+            checkSetOwnerAfterLock();
+#endif
+        return ret;
+    }
+};
+// You can use the scoped locks and other helpers that are still provided by <mutex>
+// In that case, you must include <mutex> before including this file, so that this
+// file will not try to redefine them
+#ifndef _GLIBCXX_MUTEX
+
+/// Do not acquire ownership of the mutex.
+struct defer_lock_t { };
+
+ /// Try to acquire ownership of the mutex without blocking.
+struct try_to_lock_t { };
+
+ /// Assume the calling thread has already obtained mutex ownership
+ /// and manage it.
+struct adopt_lock_t { };
+
+constexpr defer_lock_t	defer_lock { };
+constexpr try_to_lock_t	try_to_lock { };
+constexpr adopt_lock_t	adopt_lock { };
+
+template <class M>
+class lock_guard
+{
+protected:
+    M& mMutex;
+public:
+    typedef M mutex_type;
+    lock_guard(const lock_guard&) = delete;
+    lock_guard& operator=(const lock_guard&) = delete;
+    explicit lock_guard(mutex_type& m): mMutex(m) { mMutex.lock();  }
+    lock_guard(mutex_type& m, std::adopt_lock_t):mMutex(m){}
+    ~lock_guard() {  mMutex.unlock();   }
+};
+
+#endif
+}
+#endif // WIN32STDMUTEX_H
diff --git a/include/mingw.thread.h b/include/mingw.thread.h
new file mode 100644
index 0000000..6c1a997
--- /dev/null
+++ b/include/mingw.thread.h
@@ -0,0 +1,167 @@
+/**
+* @file mingw.thread.h
+* @brief std::thread implementation for MinGW
+* (c) 2013-2016 by Mega Limited, Auckland, New Zealand
+* @author Alexander Vassilev
+*
+* @copyright Simplified (2-clause) BSD License.
+* You should have received a copy of the license along with this
+* program.
+*
+* This code is distributed in the hope that it will be useful,
+* but WITHOUT ANY WARRANTY; without even the implied warranty of
+* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
+* @note
+* This file may become part of the mingw-w64 runtime package. If/when this happens,
+* the appropriate license will be added, i.e. this code will become dual-licensed,
+* and the current BSD 2-clause license will stay.
+*/
+
+#ifndef WIN32STDTHREAD_H
+#define WIN32STDTHREAD_H
+
+#include <windows.h>
+#include <functional>
+#include <memory>
+#include <chrono>
+#include <system_error>
+#include <process.h>
+
+#ifdef _GLIBCXX_HAS_GTHREADS
+#error This version of MinGW seems to include a win32 port of pthreads, and probably    \
+    already has C++11 std threading classes implemented, based on pthreads.             \
+    It is likely that you will get class redefinition errors below, and unfortunately   \
+    this implementation can not be used standalone                                      \
+    and independent of the system <mutex> header, since it relies on it for             \
+    std::unique_lock and other utility classes. If you would still like to use this     \
+    implementation (as it is more lightweight), you have to edit the                    \
+    c++-config.h system header of your MinGW to not define _GLIBCXX_HAS_GTHREADS.       \
+    This will prevent system headers from defining actual threading classes while still \
+    defining the necessary utility classes.
+#endif
+
+//instead of INVALID_HANDLE_VALUE _beginthreadex returns 0
+#define _STD_THREAD_INVALID_HANDLE 0
+namespace std
+{
+
+class thread
+{
+public:
+    class id
+    {
+        DWORD mId;
+        void clear() {mId = 0;}
+        friend class thread;
+    public:
+        id(DWORD aId=0):mId(aId){}
+        bool operator==(const id& other) const {return mId == other.mId;}
+    };
+protected:
+    HANDLE mHandle;
+    id mThreadId;
+public:
+    typedef HANDLE native_handle_type;
+    id get_id() const noexcept {return mThreadId;}
+    native_handle_type native_handle() const {return mHandle;}
+    thread(): mHandle(_STD_THREAD_INVALID_HANDLE){}
+
+    thread(thread&& other)
+    :mHandle(other.mHandle), mThreadId(other.mThreadId)
+    {
+        other.mHandle = _STD_THREAD_INVALID_HANDLE;
+        other.mThreadId.clear();
+    }
+
+    thread(const thread &other)=delete;
+
+    template<class Function, class... Args>
+    explicit thread(Function&& f, Args&&... args)
+    {
+        typedef decltype(std::bind(f, args...)) Call;
+        Call* call = new Call(std::bind(f, args...));
+        mHandle = (HANDLE)_beginthreadex(NULL, 0, threadfunc<Call>,
+            (LPVOID)call, 0, (unsigned*)&(mThreadId.mId));
+    }
+    template <class Call>
+    static unsigned int __stdcall threadfunc(void* arg)
+    {
+        std::unique_ptr<Call> upCall(static_cast<Call*>(arg));
+        (*upCall)();
+        return (unsigned long)0;
+    }
+    bool joinable() const {return mHandle != _STD_THREAD_INVALID_HANDLE;}
+    void join()
+    {
+        if (get_id() == GetCurrentThreadId())
+            throw system_error(EDEADLK, generic_category());
+        if (mHandle == _STD_THREAD_INVALID_HANDLE)
+            throw system_error(ESRCH, generic_category());
+        if (!joinable())
+            throw system_error(EINVAL, generic_category());
+        WaitForSingleObject(mHandle, INFINITE);
+        CloseHandle(mHandle);
+        mHandle = _STD_THREAD_INVALID_HANDLE;
+        mThreadId.clear();
+    }
+
+    ~thread()
+    {
+        if (joinable())
+            std::terminate();
+    }
+    thread& operator=(const thread&) = delete;
+    thread& operator=(thread&& other) noexcept
+    {
+        if (joinable())
+          std::terminate();
+        swap(std::forward<thread>(other));
+        return *this;
+    }
+    void swap(thread&& other) noexcept
+    {
+        std::swap(mHandle, other.mHandle);
+        std::swap(mThreadId.mId, other.mThreadId.mId);
+    }
+    static unsigned int hardware_concurrency() noexcept
+    {
+        static int ncpus = -1;
+        if (ncpus == -1)
+        {
+            SYSTEM_INFO sysinfo;
+            GetSystemInfo(&sysinfo);
+            ncpus = sysinfo.dwNumberOfProcessors;
+        }
+        return ncpus;
+    }
+    void detach()
+    {
+        if (!joinable())
+            throw system_error();
+        if (mHandle != _STD_THREAD_INVALID_HANDLE)
+        {
+            CloseHandle(mHandle);
+            mHandle = _STD_THREAD_INVALID_HANDLE;
+        }
+        mThreadId.clear();
+    }
+};
+
+namespace this_thread
+{
+    inline thread::id get_id() {return thread::id(GetCurrentThreadId());}
+    inline void yield() {Sleep(0);}
+    template< class Rep, class Period >
+    void sleep_for( const std::chrono::duration<Rep,Period>& sleep_duration)
+    {
+        Sleep(chrono::duration_cast<chrono::milliseconds>(sleep_duration).count());
+    }
+    template <class Clock, class Duration>
+    void sleep_until(const std::chrono::time_point<Clock,Duration>& sleep_time)
+    {
+        sleep_for(sleep_time-Clock::now());
+    }
+}
+
+}
+#endif // WIN32STDTHREAD_H
diff --git a/include/particle.hpp b/include/particle.hpp
index 92ab7e4..48a8938 100644
--- a/include/particle.hpp
+++ b/include/particle.hpp
@@ -9,22 +9,22 @@
 #include <entityx/entityx.h>
 
 enum class ParticleType : char {
-	Drop,
-	Confetti,
-	SmallBlast,
-	SmallPoof
+	Drop       = 1,
+	Confetti   = 2,
+	SmallBlast = 4,
+	SmallPoof  = 8
 };
 
 struct Particle {
-	vec2 location;
-	vec2 velocity;
-	ParticleType type;
 	int timeLeft;
+	ParticleType type;
+	vec2 velocity;
+	vec2 location;
 	vec2 color; // assets/colorIndex.png
 
 	Particle(vec2 p, ParticleType t, int tl, vec2 c)
-		: location(p), type(t), timeLeft(tl), color(c) {}
-};// __attribute__ ((packed));
+		: timeLeft(tl), type(t), location(p), color(c) {}
+};
 
 class ParticleSystem : public entityx::System<ParticleSystem> {
 private:
diff --git a/include/render.hpp b/include/render.hpp
index 0a2adcd..997d7d0 100644
--- a/include/render.hpp
+++ b/include/render.hpp
@@ -69,11 +69,12 @@ namespace Render {
     extern Shader worldShader;
     extern Shader textShader;
 
-    void initShaders(void);
-
     void useShader(Shader *s);
 
     void drawRect(vec2 ll, vec2 ur, float z);
+
+	void init(void);
+	void render(const int& fps);
 }
 
 #endif // RENDER_HPP_
diff --git a/include/texture.hpp b/include/texture.hpp
index 3cb8d1f..43db1b6 100644
--- a/include/texture.hpp
+++ b/include/texture.hpp
@@ -93,6 +93,8 @@ namespace Colors {
 	extern ColorTex red;   /**< A solid red texture. */
 	extern ColorTex blue;  /**< A solid blue texture. */
 
+	extern GLfloat texCoord[12];
+
 	/**
 	 * Creates the colors.
 	 */
diff --git a/include/ui.hpp b/include/ui.hpp
index 519d259..67c1010 100644
--- a/include/ui.hpp
+++ b/include/ui.hpp
@@ -44,8 +44,13 @@ SDL_Keycode getControl(int index);
 
 #include <entityx/entityx.h>
 
-class InputSystem : public entityx::System<InputSystem> {
+class InputSystem : public entityx::System<InputSystem>, public entityx::Receiver<InputSystem> {
 public:
+	inline void configure(entityx::EventManager &ev) {
+		ev.subscribe<MainSDLEvent>(*this);
+	}
+
+	void receive(const MainSDLEvent& event);
 	void update(entityx::EntityManager &en, entityx::EventManager &ev, entityx::TimeDelta dt) override;
 };
 
diff --git a/include/vector2.hpp b/include/vector2.hpp
new file mode 100644
index 0000000..debaee9
--- /dev/null
+++ b/include/vector2.hpp
@@ -0,0 +1,80 @@
+#ifndef VECTOR2_HPP_
+#define VECTOR2_HPP_
+
+#include <string>
+#include <type_traits>
+
+template<typename T>
+struct vector2 {
+	static_assert(std::is_arithmetic<T>::value, "vector2 members must be an arithmetic type (i.e. numbers)");
+
+	T x, y;
+
+	vector2(T _x = 0, T _y = 0)
+		: x(_x), y(_y) {}
+
+	// format: "3, 5"
+	vector2(const std::string& s) {
+		*this = s;
+	}
+
+	vector2<T>& operator=(const T& value) {
+		x = y = value;
+		return *this;
+	}
+
+	vector2<T>& operator=(const std::string& s) {
+		auto comma = s.find(',');
+		x = std::stoi(s.substr(0, comma));
+		y = std::stoi(s.substr(comma + 1));
+		return *this;
+	}
+
+	// addition
+	vector2<T> operator+(const vector2<T>& v) const {
+		return vector2<T>(x + v.x, y + v.y);
+	}
+
+	vector2<T> operator+(const T& n) const {
+		return vector2<T>(x + n, y + n);
+	}
+
+	// subtraction
+	vector2<T> operator-(const vector2<T>& v) const {
+		return vector2<T>(x - v.x, y - v.y);
+	}
+
+	vector2<T> operator-(const T& n) const {
+		return vector2<T>(x - n, y - n);
+	}
+
+	// multiplication
+	vector2<T> operator*(const vector2<T>& v) const {
+		return vector2<T>(x * v.x, y * v.y);
+	}
+
+	vector2<T> operator*(const T& n) const {
+		return vector2<T>(x * n, y * n);
+	}
+
+	// division
+	vector2<T> operator/(const vector2<T>& v) const {
+		return vector2<T>(x / v.x, y / v.y);
+	}
+
+	vector2<T> operator/(const T& n) const {
+		return vector2<T>(x / n, y / n);
+	}
+
+	// compare
+	bool operator==(const vector2<T>& v) const {
+		return (x == v.x) && (y == v.y);
+	}
+
+	// other functions
+	std::string toString(void) const {
+		return "(" + std::to_string(x) + ", " + std::to_string(y) + ")";
+	}
+};
+
+#endif // VECTOR2_HPP_
diff --git a/include/weather.hpp b/include/weather.hpp
index f2f5fed..8e148dd 100644
--- a/include/weather.hpp
+++ b/include/weather.hpp
@@ -50,15 +50,15 @@ public:
 					offset.y + game::SCREEN_HEIGHT / 2 + 100),
 					ParticleType::Drop, 3000, 3);
 			}
-			break; // TODO
+			break;
 		case Weather::Snowy:
-			if (newPartDelay++ == 4) {
+			if (newPartDelay++ == 6) {
 				newPartDelay = 0;
-				partSystem.add(vec2(offset.x - game::SCREEN_WIDTH / 2 + randGet() % game::SCREEN_WIDTH,
-					offset.y + game::SCREEN_HEIGHT / 2 + 100),
-					ParticleType::Confetti, 6000, 0);
+				partSystem.add(vec2(offset.x - game::SCREEN_WIDTH + randGet() % game::SCREEN_WIDTH * 2,
+					offset.y + game::SCREEN_HEIGHT / 2 + 50),
+					ParticleType::Confetti, 10000, 0);
 			}
-			break; // TODO
+			break;
 		default:
 			break;
 		}
diff --git a/include/window.hpp b/include/window.hpp
index 5cf05ea..d53a2bf 100644
--- a/include/window.hpp
+++ b/include/window.hpp
@@ -36,7 +36,9 @@ public:
 	void die(void);
 
 	void configure(entityx::EventManager &ev);
-    void update(entityx::EntityManager &en, entityx::EventManager &ev, entityx::TimeDelta dt) override;
+    void update(entityx::EntityManager &en, entityx::EventManager &ev, entityx::TimeDelta dt) override
+	{ (void)en; (void)ev; (void)dt; }
+	void render(void);
 	void receive(const WindowResizeEvent&);	
 	void receive(const ScreenshotEvent&);
 };
diff --git a/include/world.hpp b/include/world.hpp
index 14c64d0..9b68314 100644
--- a/include/world.hpp
+++ b/include/world.hpp
@@ -37,7 +37,7 @@ struct WorldData {
     float         grassHeight[2]; /**< height of the two grass blades */
     float         groundHeight;   /**< height of the 'line' */
     unsigned char groundColor;    /**< a value that affects the ground's color */
-} __attribute__ ((packed));
+};
 
 /**
  * Defines how many game ticks it takes to go from day to night or vice versa.
@@ -171,8 +171,8 @@ public:
 	WorldData2 worldData;
 
 	void generate(int width = 0);
-	void addHole(const unsigned int& start, const unsigned int& end);
-	void addHill(const ivec2& peak, const unsigned int& width);
+	//void addHole(const unsigned int& start, const unsigned int& end);
+	//void addHill(const ivec2& peak, const unsigned int& width);
 
 	bool save(void);
 	void load(const std::string& file);