From e39ee21ca835754f83c02d0cf2a624a964dc3355 Mon Sep 17 00:00:00 2001
From: Daniel Evans <dan@rekt.io>
Date: Fri, 9 Sep 2016 21:13:20 +0100
Subject: [PATCH] clang-format files in rwgame

---
 rwgame/DrawUI.cpp     |  383 +++++-----
 rwgame/DrawUI.hpp     |    3 +-
 rwgame/GameConfig.cpp |  128 ++--
 rwgame/GameConfig.hpp |   72 +-
 rwgame/GameWindow.cpp |   89 +--
 rwgame/GameWindow.hpp |   36 +-
 rwgame/MenuSystem.hpp |  283 ++++----
 rwgame/RWGame.cpp     | 1597 ++++++++++++++++++++---------------------
 rwgame/RWGame.hpp     |  197 +++--
 rwgame/State.cpp      |   74 +-
 rwgame/State.hpp      |  188 +++--
 rwgame/game.hpp       |   15 +-
 rwgame/main.cpp       |   49 +-
 13 files changed, 1512 insertions(+), 1602 deletions(-)

diff --git a/rwgame/DrawUI.cpp b/rwgame/DrawUI.cpp
index 87285696..7994bd39 100644
--- a/rwgame/DrawUI.cpp
+++ b/rwgame/DrawUI.cpp
@@ -1,9 +1,9 @@
 #include "DrawUI.hpp"
-#include <render/GameRenderer.hpp>
 #include <ai/PlayerController.hpp>
-#include <objects/CharacterObject.hpp>
 #include <engine/GameState.hpp>
 #include <items/WeaponItem.hpp>
+#include <objects/CharacterObject.hpp>
+#include <render/GameRenderer.hpp>
 
 #include <glm/gtc/constants.hpp>
 #include <iomanip>
@@ -26,121 +26,121 @@ const float ui_mapSize = 150.f;
 const float ui_worldSizeMin = 200.f;
 const float ui_worldSizeMax = 300.f;
 
-void drawMap(ViewCamera& currentView,  PlayerController* player, GameWorld* world, GameRenderer* render)
-{
-	MapRenderer::MapInfo map;
-	
-	glm::quat camRot = currentView.rotation;
-	
-	map.rotation = glm::roll(camRot) - glm::half_pi<float>();
-	map.worldSize = ui_worldSizeMin;
-	map.worldSize = ui_worldSizeMax;
-	if( player )
-	{
-		map.worldCenter = glm::vec2(player->getCharacter()->getPosition());
-	}
+void drawMap(ViewCamera& currentView, PlayerController* player,
+             GameWorld* world, GameRenderer* render) {
+    MapRenderer::MapInfo map;
 
-	const glm::ivec2 &vp = render->getRenderer()->getViewport();
+    glm::quat camRot = currentView.rotation;
 
-	glm::vec2 mapTop = glm::vec2(ui_outerMargin, vp.y - (ui_outerMargin + ui_mapSize));
-	glm::vec2 mapBottom = glm::vec2(ui_outerMargin + ui_mapSize, vp.y - ui_outerMargin);
+    map.rotation = glm::roll(camRot) - glm::half_pi<float>();
+    map.worldSize = ui_worldSizeMin;
+    map.worldSize = ui_worldSizeMax;
+    if (player) {
+        map.worldCenter = glm::vec2(player->getCharacter()->getPosition());
+    }
 
-	map.screenPosition = (mapTop + mapBottom)/2.f;
-	map.screenSize = ui_mapSize * 0.95;
-	
-	render->map.draw(world, map);
+    const glm::ivec2& vp = render->getRenderer()->getViewport();
+
+    glm::vec2 mapTop =
+        glm::vec2(ui_outerMargin, vp.y - (ui_outerMargin + ui_mapSize));
+    glm::vec2 mapBottom =
+        glm::vec2(ui_outerMargin + ui_mapSize, vp.y - ui_outerMargin);
+
+    map.screenPosition = (mapTop + mapBottom) / 2.f;
+    map.screenSize = ui_mapSize * 0.95;
+
+    render->map.draw(world, map);
 }
 
-void drawPlayerInfo(PlayerController* player, GameWorld* world, GameRenderer* render)
-{
-	float infoTextX = render->getRenderer()->getViewport().x -
-			(ui_outerMargin + ui_weaponSize + ui_infoMargin);
-	float infoTextY = 0.f + ui_outerMargin;
-	float iconX = render->getRenderer()->getViewport().x -
-			(ui_outerMargin + ui_weaponSize);
-	float iconY = ui_outerMargin;
-	float wantedX = render->getRenderer()->getViewport().x -
-			(ui_outerMargin);
-	float wantedY = ui_outerMargin + ui_weaponSize + 3.f;
+void drawPlayerInfo(PlayerController* player, GameWorld* world,
+                    GameRenderer* render) {
+    float infoTextX = render->getRenderer()->getViewport().x -
+                      (ui_outerMargin + ui_weaponSize + ui_infoMargin);
+    float infoTextY = 0.f + ui_outerMargin;
+    float iconX = render->getRenderer()->getViewport().x -
+                  (ui_outerMargin + ui_weaponSize);
+    float iconY = ui_outerMargin;
+    float wantedX = render->getRenderer()->getViewport().x - (ui_outerMargin);
+    float wantedY = ui_outerMargin + ui_weaponSize + 3.f;
 
-	TextRenderer::TextInfo ti;
-	ti.font = 1;
-	ti.size = ui_textSize;
-	ti.align = TextRenderer::TextInfo::Right;
+    TextRenderer::TextInfo ti;
+    ti.font = 1;
+    ti.size = ui_textSize;
+    ti.align = TextRenderer::TextInfo::Right;
 
-	{
-		std::stringstream ss;
-		ss << std::setw(2) << std::setfill('0') << world->getHour()
-		   << std::setw(0) << ":"
-		   << std::setw(2) << world->getMinute();
+    {
+        std::stringstream ss;
+        ss << std::setw(2) << std::setfill('0') << world->getHour()
+           << std::setw(0) << ":" << std::setw(2) << world->getMinute();
 
-		ti.text = GameStringUtil::fromString(ss.str());
-	}
-	ti.baseColour = ui_shadowColour;
-	ti.screenPosition = glm::vec2(infoTextX + 1.f, infoTextY+1.f);
-	render->text.renderText(ti);
+        ti.text = GameStringUtil::fromString(ss.str());
+    }
+    ti.baseColour = ui_shadowColour;
+    ti.screenPosition = glm::vec2(infoTextX + 1.f, infoTextY + 1.f);
+    render->text.renderText(ti);
 
-	ti.baseColour = ui_timeColour;
-	ti.screenPosition = glm::vec2(infoTextX, infoTextY);
-	render->text.renderText(ti);
+    ti.baseColour = ui_timeColour;
+    ti.screenPosition = glm::vec2(infoTextX, infoTextY);
+    render->text.renderText(ti);
 
-	infoTextY += ui_textHeight;
+    infoTextY += ui_textHeight;
 
-	{
-		std::stringstream ss;
-		ss << std::setw(8) << std::setfill('0') << world->state->playerInfo.displayedMoney;
+    {
+        std::stringstream ss;
+        ss << std::setw(8) << std::setfill('0')
+           << world->state->playerInfo.displayedMoney;
 
-		ti.text = GameSymbols::Money + GameStringUtil::fromString(ss.str());
-	}
-	ti.baseColour = ui_shadowColour;
-	ti.screenPosition = glm::vec2(infoTextX + 1.f, infoTextY+1.f);
-	render->text.renderText(ti);
+        ti.text = GameSymbols::Money + GameStringUtil::fromString(ss.str());
+    }
+    ti.baseColour = ui_shadowColour;
+    ti.screenPosition = glm::vec2(infoTextX + 1.f, infoTextY + 1.f);
+    render->text.renderText(ti);
 
-	ti.baseColour = ui_moneyColour;
-	ti.screenPosition = glm::vec2(infoTextX, infoTextY);
-	render->text.renderText(ti);
+    ti.baseColour = ui_moneyColour;
+    ti.screenPosition = glm::vec2(infoTextX, infoTextY);
+    render->text.renderText(ti);
 
-	infoTextY += ui_textHeight;
+    infoTextY += ui_textHeight;
 
-	{
-		std::stringstream ss;
-		ss << std::setw(3) << std::setfill('0')
-		   << (int)player->getCharacter()->getCurrentState().health;
-		ti.text = GameSymbols::Heart + GameStringUtil::fromString(ss.str());
-	}
-	ti.baseColour = ui_shadowColour;
-	ti.screenPosition = glm::vec2(infoTextX + 1.f, infoTextY+1.f);
-	render->text.renderText(ti);
+    {
+        std::stringstream ss;
+        ss << std::setw(3) << std::setfill('0')
+           << (int)player->getCharacter()->getCurrentState().health;
+        ti.text = GameSymbols::Heart + GameStringUtil::fromString(ss.str());
+    }
+    ti.baseColour = ui_shadowColour;
+    ti.screenPosition = glm::vec2(infoTextX + 1.f, infoTextY + 1.f);
+    render->text.renderText(ti);
 
-	ti.baseColour = ui_healthColour;
-	ti.screenPosition = glm::vec2(infoTextX, infoTextY);
-	render->text.renderText(ti);
+    ti.baseColour = ui_healthColour;
+    ti.screenPosition = glm::vec2(infoTextX, infoTextY);
+    render->text.renderText(ti);
 
-	if (player->getCharacter()->getCurrentState().armour > 0)
-	{
-		std::stringstream ss;
-		ss << std::setw(3) << std::setfill('0')
-		   << (int)player->getCharacter()->getCurrentState().armour;
-		ti.text = GameSymbols::Armour + GameStringUtil::fromString(ss.str());
-		ti.baseColour = ui_shadowColour;
-		ti.screenPosition = glm::vec2(infoTextX + 1.f - ui_armourOffset, infoTextY+1.f);
-		render->text.renderText(ti);
+    if (player->getCharacter()->getCurrentState().armour > 0) {
+        std::stringstream ss;
+        ss << std::setw(3) << std::setfill('0')
+           << (int)player->getCharacter()->getCurrentState().armour;
+        ti.text = GameSymbols::Armour + GameStringUtil::fromString(ss.str());
+        ti.baseColour = ui_shadowColour;
+        ti.screenPosition =
+            glm::vec2(infoTextX + 1.f - ui_armourOffset, infoTextY + 1.f);
+        render->text.renderText(ti);
 
-		ti.baseColour = ui_armourColour;
-		ti.screenPosition = glm::vec2(infoTextX - ui_armourOffset, infoTextY);
-		render->text.renderText(ti);
-	}
+        ti.baseColour = ui_armourColour;
+        ti.screenPosition = glm::vec2(infoTextX - ui_armourOffset, infoTextY);
+        render->text.renderText(ti);
+    }
 
-	GameString s;
-	for (size_t i = 0; i < ui_maxWantedLevel; ++i) {
-		s += GameSymbols::Star;
-	}
-	ti.text = s;
-	ti.baseColour = ui_shadowColour;
-	ti.screenPosition = glm::vec2(wantedX + 1.f, wantedY + 1.f);
-	render->text.renderText(ti);
+    GameString s;
+    for (size_t i = 0; i < ui_maxWantedLevel; ++i) {
+        s += GameSymbols::Star;
+    }
+    ti.text = s;
+    ti.baseColour = ui_shadowColour;
+    ti.screenPosition = glm::vec2(wantedX + 1.f, wantedY + 1.f);
+    render->text.renderText(ti);
 
-#if 0 // Useful for debugging
+#if 0  // Useful for debugging
 	ti.text = "ABCDEFGHIJKLMANOQRTSWXYZ\nM0123456789";
 	ti.size = 30;
 	ti.align = TextRenderer::TextInfo::Left;
@@ -152,115 +152,110 @@ void drawPlayerInfo(PlayerController* player, GameWorld* world, GameRenderer* re
 	render->text.renderText(ti);
 #endif
 
-	InventoryItem *current = player->getCharacter()->getActiveItem();
-	std::string itemTextureName = "fist";
-	if (current) {
-		uint16_t model = current->getModelID();
-		if (model > 0) {
-			ObjectDataPtr weaponData = world
-					->data
-					->findObjectType<ObjectData>(model);
-			if (weaponData != nullptr) {
-				itemTextureName = weaponData->modelName;
-			}
-		}
-	}
-	// Urgh
-	if (itemTextureName == "colt45") {
-		itemTextureName = "pistol";
-	}
+    InventoryItem* current = player->getCharacter()->getActiveItem();
+    std::string itemTextureName = "fist";
+    if (current) {
+        uint16_t model = current->getModelID();
+        if (model > 0) {
+            ObjectDataPtr weaponData =
+                world->data->findObjectType<ObjectData>(model);
+            if (weaponData != nullptr) {
+                itemTextureName = weaponData->modelName;
+            }
+        }
+    }
+    // Urgh
+    if (itemTextureName == "colt45") {
+        itemTextureName = "pistol";
+    }
 
-	TextureData::Handle itemTexture = render->getData()->findTexture(itemTextureName);
-	RW_CHECK(itemTexture != nullptr, "Item has 0 texture");
-	if (itemTexture != nullptr) {
-		RW_CHECK(itemTexture->getName() != 0, "Item has 0 texture");
-		render->drawTexture(itemTexture.get(),
-							glm::vec4(iconX,
-									  iconY,
-									  ui_weaponSize,
-									  ui_weaponSize));
-	}
+    TextureData::Handle itemTexture =
+        render->getData()->findTexture(itemTextureName);
+    RW_CHECK(itemTexture != nullptr, "Item has 0 texture");
+    if (itemTexture != nullptr) {
+        RW_CHECK(itemTexture->getName() != 0, "Item has 0 texture");
+        render->drawTexture(
+            itemTexture.get(),
+            glm::vec4(iconX, iconY, ui_weaponSize, ui_weaponSize));
+    }
 
-	if (current) {
-		WeaponItem* wep = static_cast<WeaponItem*>(current);
-		if (wep->getWeaponData()->fireType != WeaponData::MELEE) {
-			const CharacterState& cs = player->getCharacter()->getCurrentState();
-			const CharacterWeaponSlot& slotInfo = cs.weapons[cs.currentWeapon];
-			ti.text = GameStringUtil::fromString(
-			            std::to_string(slotInfo.bulletsClip) + "-"
-			          + std::to_string(slotInfo.bulletsTotal));
+    if (current) {
+        WeaponItem* wep = static_cast<WeaponItem*>(current);
+        if (wep->getWeaponData()->fireType != WeaponData::MELEE) {
+            const CharacterState& cs =
+                player->getCharacter()->getCurrentState();
+            const CharacterWeaponSlot& slotInfo = cs.weapons[cs.currentWeapon];
+            ti.text = GameStringUtil::fromString(
+                std::to_string(slotInfo.bulletsClip) + "-" +
+                std::to_string(slotInfo.bulletsTotal));
 
-			ti.baseColour = ui_shadowColour;
-			ti.font = 2;
-			ti.size = ui_ammoSize;
-			ti.align = TextRenderer::TextInfo::Center;
-			ti.screenPosition = glm::vec2(iconX + ui_weaponSize / 2.f,
-										  iconY + ui_weaponSize - ui_ammoHeight);
-			render->text.renderText(ti);
-		}
-	}
+            ti.baseColour = ui_shadowColour;
+            ti.font = 2;
+            ti.size = ui_ammoSize;
+            ti.align = TextRenderer::TextInfo::Center;
+            ti.screenPosition =
+                glm::vec2(iconX + ui_weaponSize / 2.f,
+                          iconY + ui_weaponSize - ui_ammoHeight);
+            render->text.renderText(ti);
+        }
+    }
 }
 
-void drawHUD(ViewCamera& currentView, PlayerController* player, GameWorld* world, GameRenderer* render)
-{
-	if(player && player->getCharacter()) {
-		drawMap(currentView, player, world, render);
-		drawPlayerInfo(player, world, render);
-	}
+void drawHUD(ViewCamera& currentView, PlayerController* player,
+             GameWorld* world, GameRenderer* render) {
+    if (player && player->getCharacter()) {
+        drawMap(currentView, player, world, render);
+        drawPlayerInfo(player, world, render);
+    }
 }
 
-void drawOnScreenText(GameWorld* world, GameRenderer* renderer)
-{
-	const auto vp = glm::vec2(renderer->getRenderer()->getViewport());
-	
-	TextRenderer::TextInfo ti;
-	ti.font = 2;
-	ti.screenPosition = glm::vec2( 10.f, 10.f );
-	ti.size = 20.f;
+void drawOnScreenText(GameWorld* world, GameRenderer* renderer) {
+    const auto vp = glm::vec2(renderer->getRenderer()->getViewport());
 
-	auto& alltext = world->state->text.getAllText();
+    TextRenderer::TextInfo ti;
+    ti.font = 2;
+    ti.screenPosition = glm::vec2(10.f, 10.f);
+    ti.size = 20.f;
 
-	for(auto& l : alltext)
-	{
-		for (auto& t : l)
-		{
-			ti.size = t.size;
-			ti.font = t.font;
-			ti.text = t.text;
-			ti.wrapX = t.wrapX;
-			ti.screenPosition = (t.position/glm::vec2(640.f, 480.f)) * vp;
-			switch(t.alignment) {
-			case 0:
-				ti.align = TextRenderer::TextInfo::Left;
-				break;
-			case 1:
-				ti.align = TextRenderer::TextInfo::Center;
-				break;
-			case 2:
-				ti.align = TextRenderer::TextInfo::Right;
-				break;
-			}
+    auto& alltext = world->state->text.getAllText();
 
-			// Check for the background type
-			if (t.colourBG.a == 0)
-			{
-				glm::vec2 shadowPosition((int8_t)t.colourBG.x, (int8_t)t.colourBG.y);
+    for (auto& l : alltext) {
+        for (auto& t : l) {
+            ti.size = t.size;
+            ti.font = t.font;
+            ti.text = t.text;
+            ti.wrapX = t.wrapX;
+            ti.screenPosition = (t.position / glm::vec2(640.f, 480.f)) * vp;
+            switch (t.alignment) {
+                case 0:
+                    ti.align = TextRenderer::TextInfo::Left;
+                    break;
+                case 1:
+                    ti.align = TextRenderer::TextInfo::Center;
+                    break;
+                case 2:
+                    ti.align = TextRenderer::TextInfo::Right;
+                    break;
+            }
 
-				ti.baseColour = glm::vec3(0.f);
-				ti.screenPosition += shadowPosition;
-				ti.backgroundColour = {0, 0, 0, 0};
+            // Check for the background type
+            if (t.colourBG.a == 0) {
+                glm::vec2 shadowPosition((int8_t)t.colourBG.x,
+                                         (int8_t)t.colourBG.y);
 
-				renderer->text.renderText(ti, true);
+                ti.baseColour = glm::vec3(0.f);
+                ti.screenPosition += shadowPosition;
+                ti.backgroundColour = {0, 0, 0, 0};
 
-				ti.screenPosition -= shadowPosition;
-			}
-			else if(t.colourBG.a > 0)
-			{
-				ti.backgroundColour = t.colourBG;
-			}
+                renderer->text.renderText(ti, true);
 
-			ti.baseColour = t.colourFG;
-			renderer->text.renderText(ti);
-		}
-	}
+                ti.screenPosition -= shadowPosition;
+            } else if (t.colourBG.a > 0) {
+                ti.backgroundColour = t.colourBG;
+            }
+
+            ti.baseColour = t.colourFG;
+            renderer->text.renderText(ti);
+        }
+    }
 }
diff --git a/rwgame/DrawUI.hpp b/rwgame/DrawUI.hpp
index 102509e3..74f38af5 100644
--- a/rwgame/DrawUI.hpp
+++ b/rwgame/DrawUI.hpp
@@ -4,6 +4,7 @@
 
 class PlayerController;
 
-void drawHUD(ViewCamera& currentView, PlayerController* player, GameWorld* world, GameRenderer* render);
+void drawHUD(ViewCamera& currentView, PlayerController* player,
+             GameWorld* world, GameRenderer* render);
 
 void drawOnScreenText(GameWorld* world, GameRenderer* renderer);
diff --git a/rwgame/GameConfig.cpp b/rwgame/GameConfig.cpp
index bfee9e96..09f1f546 100644
--- a/rwgame/GameConfig.cpp
+++ b/rwgame/GameConfig.cpp
@@ -1,100 +1,86 @@
 #include "GameConfig.hpp"
-#include <rw/defines.hpp>
-#include <cstring>
 #include <cstdlib>
+#include <cstring>
+#include <rw/defines.hpp>
 
 #include <ini.h>
 
 const std::string kConfigDirectoryName("OpenRW");
 
-GameConfig::GameConfig(const std::string& configName, const std::string& configPath)
-	: m_configName(configName)
-	, m_configPath(configPath)
-	, m_valid(false)
-	, m_inputInvertY(false)
-{
-	if (m_configPath.empty())
-	{
-		m_configPath = getDefaultConfigPath();
-	}
+GameConfig::GameConfig(const std::string& configName,
+                       const std::string& configPath)
+    : m_configName(configName)
+    , m_configPath(configPath)
+    , m_valid(false)
+    , m_inputInvertY(false) {
+    if (m_configPath.empty()) {
+        m_configPath = getDefaultConfigPath();
+    }
 
-	// Look up the path to use
-	auto configFile = getConfigFile();
+    // Look up the path to use
+    auto configFile = getConfigFile();
 
-	if (ini_parse(configFile.c_str(), handler, this) < 0)
-	{
-		m_valid = false;
-	}
-	else
-	{
-		m_valid = true;
-	}
+    if (ini_parse(configFile.c_str(), handler, this) < 0) {
+        m_valid = false;
+    } else {
+        m_valid = true;
+    }
 }
 
-std::string GameConfig::getConfigFile()
-{
-	return m_configPath + "/" + m_configName;
+std::string GameConfig::getConfigFile() {
+    return m_configPath + "/" + m_configName;
 }
 
-bool GameConfig::isValid()
-{
-	return m_valid;
+bool GameConfig::isValid() {
+    return m_valid;
 }
 
-std::string GameConfig::getDefaultConfigPath()
-{
-#if defined(RW_LINUX) || defined(RW_FREEBSD) || defined(RW_NETBSD) || defined(RW_OPENBSD)
-	char* config_home = getenv("XDG_CONFIG_HOME");
-	if (config_home != nullptr) {
-		return std::string(config_home) + "/" + kConfigDirectoryName;
-	}
-	char* home = getenv("HOME");
-	if (home != nullptr) {
-		return std::string(home) + "/.config/" + kConfigDirectoryName;
-	}
+std::string GameConfig::getDefaultConfigPath() {
+#if defined(RW_LINUX) || defined(RW_FREEBSD) || defined(RW_NETBSD) || \
+    defined(RW_OPENBSD)
+    char* config_home = getenv("XDG_CONFIG_HOME");
+    if (config_home != nullptr) {
+        return std::string(config_home) + "/" + kConfigDirectoryName;
+    }
+    char* home = getenv("HOME");
+    if (home != nullptr) {
+        return std::string(home) + "/.config/" + kConfigDirectoryName;
+    }
 
 #elif defined(RW_OSX)
-	char* home = getenv("HOME");
-	if (home)
-		return std::string(home) + "/Library/Preferences/" + kConfigDirectoryName;
+    char* home = getenv("HOME");
+    if (home)
+        return std::string(home) + "/Library/Preferences/" +
+               kConfigDirectoryName;
 
 #else
-	return ".";
+    return ".";
 #endif
 
-	// Well now we're stuck.
-	RW_ERROR("No default config path found.");
-	return ".";
+    // Well now we're stuck.
+    RW_ERROR("No default config path found.");
+    return ".";
 }
 
-int GameConfig::handler(void* user,
-						 const char* section,
-						 const char* name,
-						 const char* value)
-{
-	auto self = static_cast<GameConfig*>(user);
+int GameConfig::handler(void* user, const char* section, const char* name,
+                        const char* value) {
+    auto self = static_cast<GameConfig*>(user);
 #define MATCH(_s, _n) (strcmp(_s, section) == 0 && strcmp(_n, name) == 0)
 
-	if (MATCH("game", "path"))
-	{
-		self->m_gamePath = value;
-	}
-	else if (MATCH("game", "language"))
-	{
-		// @todo Don't allow path seperators and relative directories
-		self->m_gameLanguage = value;
-	}
-	else if (MATCH("input", "invert_y"))
-	{
-		self->m_inputInvertY = atoi(value) > 0;
-	}
-	else
-	{
-		RW_MESSAGE("Unhandled config entry [" << section << "] " << name << " = " << value);
-		return 0;
-	}
+    if (MATCH("game", "path")) {
+        self->m_gamePath = value;
+    } else if (MATCH("game", "language")) {
+        // @todo Don't allow path seperators and relative directories
+        self->m_gameLanguage = value;
+    } else if (MATCH("input", "invert_y")) {
+        self->m_inputInvertY = atoi(value) > 0;
+    } else {
+        RW_MESSAGE("Unhandled config entry [" << section << "] " << name
+                                              << " = " << value);
+        return 0;
+    }
 
-	return 1;
+    return 1;
 
 #undef MATCH
 }
diff --git a/rwgame/GameConfig.hpp b/rwgame/GameConfig.hpp
index f7624efa..850b73ee 100644
--- a/rwgame/GameConfig.hpp
+++ b/rwgame/GameConfig.hpp
@@ -2,50 +2,56 @@
 #define RWGAME_GAMECONFIG_HPP
 #include <string>
 
-class GameConfig
-{
+class GameConfig {
 public:
-	/**
-	 * @brief GameConfig Loads a game configuration
-	 * @param configName The configuration filename to load
-	 * @param configPath Where to look.
-	 */
-	GameConfig(const std::string& configName, const std::string& configPath = getDefaultConfigPath());
+    /**
+     * @brief GameConfig Loads a game configuration
+     * @param configName The configuration filename to load
+     * @param configPath Where to look.
+     */
+    GameConfig(const std::string& configName,
+               const std::string& configPath = getDefaultConfigPath());
 
-	/**
-	 * @brief getFilePath Returns the system file path for the configuration
-	 */
-	std::string getConfigFile();
+    /**
+     * @brief getFilePath Returns the system file path for the configuration
+     */
+    std::string getConfigFile();
 
-	/**
-	 * @brief isValid
-	 * @return True if the loaded configuration is valid
-	 */
-	bool isValid();
+    /**
+     * @brief isValid
+     * @return True if the loaded configuration is valid
+     */
+    bool isValid();
 
-	const std::string& getGameDataPath() const { return m_gamePath; }
-	const std::string& getGameLanguage() const { return m_gameLanguage; }
-	bool getInputInvertY() const { return m_inputInvertY; }
+    const std::string& getGameDataPath() const {
+        return m_gamePath;
+    }
+    const std::string& getGameLanguage() const {
+        return m_gameLanguage;
+    }
+    bool getInputInvertY() const {
+        return m_inputInvertY;
+    }
 
 private:
-	static std::string getDefaultConfigPath();
-	static int handler(void*, const char*, const char*, const char*);
+    static std::string getDefaultConfigPath();
+    static int handler(void*, const char*, const char*, const char*);
 
-	/* Config State */
-	std::string m_configName;
-	std::string m_configPath;
-	bool m_valid;
+    /* Config State */
+    std::string m_configName;
+    std::string m_configPath;
+    bool m_valid;
 
-	/* Actual Configuration */
+    /* Actual Configuration */
 
-	/// Path to the game data
-	std::string m_gamePath;
+    /// Path to the game data
+    std::string m_gamePath;
 
-	/// Language for game
-	std::string m_gameLanguage = "american";
+    /// Language for game
+    std::string m_gameLanguage = "american";
 
-	/// Invert the y axis for camera control.
-	bool m_inputInvertY;
+    /// Invert the y axis for camera control.
+    bool m_inputInvertY;
 };
 
 #endif
diff --git a/rwgame/GameWindow.cpp b/rwgame/GameWindow.cpp
index 2f40e55f..0140b688 100644
--- a/rwgame/GameWindow.cpp
+++ b/rwgame/GameWindow.cpp
@@ -1,68 +1,57 @@
-#include <core/Logger.hpp>
 #include "GameWindow.hpp"
+#include <core/Logger.hpp>
 
-GameWindow::GameWindow() :
-	window(nullptr), glcontext(nullptr)
-{
-
+GameWindow::GameWindow() : window(nullptr), glcontext(nullptr) {
 }
 
+void GameWindow::create(const std::string& title, size_t w, size_t h,
+                        bool fullscreen) {
+    Uint32 style = SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE | SDL_WINDOW_HIDDEN;
+    if (fullscreen) style |= SDL_WINDOW_FULLSCREEN;
 
-void GameWindow::create(const std::string& title, size_t w, size_t h, bool fullscreen)
-{
-	Uint32 style = SDL_WINDOW_OPENGL | SDL_WINDOW_RESIZABLE | SDL_WINDOW_HIDDEN;
-	if (fullscreen)
-		style |= SDL_WINDOW_FULLSCREEN;
+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK,
+                        SDL_GL_CONTEXT_PROFILE_CORE);
+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
+    SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
+    SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
+    SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
+    SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
 
-	SDL_GL_SetAttribute(SDL_GL_CONTEXT_PROFILE_MASK, SDL_GL_CONTEXT_PROFILE_CORE);
-	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MAJOR_VERSION, 3);
-	SDL_GL_SetAttribute(SDL_GL_CONTEXT_MINOR_VERSION, 3);
-	SDL_GL_SetAttribute(SDL_GL_DOUBLEBUFFER, 1);
-	SDL_GL_SetAttribute(SDL_GL_DEPTH_SIZE, 24);
-	SDL_GL_SetAttribute(SDL_GL_STENCIL_SIZE, 8);
+    window = SDL_CreateWindow(title.c_str(), SDL_WINDOWPOS_CENTERED,
+                              SDL_WINDOWPOS_CENTERED, w, h, style);
+    if (window == nullptr) {
+        // Window creation failure is fatal
+        std::string sdlErrorStr = SDL_GetError();
+        throw std::runtime_error("SDL_CreateWindow failed: " + sdlErrorStr);
+    }
+    glcontext = SDL_GL_CreateContext(window);
+    if (glcontext == nullptr) {
+        // context creation failure is fatal
+        std::string sdlErrorStr = SDL_GetError();
+        throw std::runtime_error("SDL_GL_CreateContext failed: " + sdlErrorStr);
+    }
 
-	window = SDL_CreateWindow(title.c_str(), SDL_WINDOWPOS_CENTERED, SDL_WINDOWPOS_CENTERED, w, h, style);
-	if (window == nullptr) {
-		// Window creation failure is fatal
-		std::string sdlErrorStr = SDL_GetError();
-		throw std::runtime_error("SDL_CreateWindow failed: " + sdlErrorStr);
-	}
-	glcontext = SDL_GL_CreateContext(window);
-	if (glcontext == nullptr) {
-		// context creation failure is fatal
-		std::string sdlErrorStr = SDL_GetError();
-		throw std::runtime_error("SDL_GL_CreateContext failed: " + sdlErrorStr);
-	}
-
-	SDL_ShowWindow(window);
+    SDL_ShowWindow(window);
 }
 
+void GameWindow::close() {
+    SDL_GL_DeleteContext(glcontext);
+    SDL_DestroyWindow(window);
 
-void GameWindow::close()
-{
-	SDL_GL_DeleteContext(glcontext);
-	SDL_DestroyWindow(window);
-
-	window = nullptr;
+    window = nullptr;
 }
 
-
-void GameWindow::showCursor()
-{
-	SDL_SetRelativeMouseMode(SDL_FALSE);
+void GameWindow::showCursor() {
+    SDL_SetRelativeMouseMode(SDL_FALSE);
 }
 
-
-void GameWindow::hideCursor()
-{
-	SDL_SetRelativeMouseMode(SDL_TRUE);
+void GameWindow::hideCursor() {
+    SDL_SetRelativeMouseMode(SDL_TRUE);
 }
 
+glm::ivec2 GameWindow::getSize() const {
+    int x, y;
+    SDL_GL_GetDrawableSize(window, &x, &y);
 
-glm::ivec2 GameWindow::getSize() const
-{
-	int x, y;
-	SDL_GL_GetDrawableSize(window, &x, &y);
-
-	return glm::ivec2(x, y);
+    return glm::ivec2(x, y);
 }
diff --git a/rwgame/GameWindow.hpp b/rwgame/GameWindow.hpp
index 7e11696d..0b34076f 100644
--- a/rwgame/GameWindow.hpp
+++ b/rwgame/GameWindow.hpp
@@ -1,38 +1,34 @@
 #ifndef GAMEWINDOW_HPP
 #define GAMEWINDOW_HPP
 
+#include <glm/vec2.hpp>
 #include <string>
 #include "SDL.h"
-#include <glm/vec2.hpp>
 
 #include <render/GameRenderer.hpp>
 
-
-class GameWindow
-{
-	SDL_Window* window;
-	SDL_GLContext glcontext;
+class GameWindow {
+    SDL_Window* window;
+    SDL_GLContext glcontext;
 
 public:
-	GameWindow();
+    GameWindow();
 
-	void create(const std::string& title, size_t w, size_t h, bool fullscreen);
-	void close();
+    void create(const std::string& title, size_t w, size_t h, bool fullscreen);
+    void close();
 
-	void showCursor();
-	void hideCursor();
+    void showCursor();
+    void hideCursor();
 
-	glm::ivec2 getSize() const;
+    glm::ivec2 getSize() const;
 
-	void swap() const
-	{
-		SDL_GL_SwapWindow(window);
-	}
+    void swap() const {
+        SDL_GL_SwapWindow(window);
+    }
 
-	bool isOpen() const
-	{
-		return !!window;
-	}
+    bool isOpen() const {
+        return !!window;
+    }
 };
 
 #endif
diff --git a/rwgame/MenuSystem.hpp b/rwgame/MenuSystem.hpp
index 30e9bd76..220d73d8 100644
--- a/rwgame/MenuSystem.hpp
+++ b/rwgame/MenuSystem.hpp
@@ -1,17 +1,16 @@
 #ifndef _GAME_MENUSYSTEM_HPP_
 #define _GAME_MENUSYSTEM_HPP_
-#include <string>
-#include <memory>
-#include <glm/glm.hpp>
-#include <render/GameRenderer.hpp>
-#include <functional>
 #include <algorithm>
+#include <functional>
+#include <glm/glm.hpp>
+#include <memory>
+#include <render/GameRenderer.hpp>
+#include <string>
 
 /**
  * Default values for menus that should match the look and feel of the original
  */
-namespace MenuDefaults
-{
+namespace MenuDefaults {
 constexpr int kFont = 1;
 
 constexpr const char* kStartGameId = "FET_SAN";
@@ -22,161 +21,133 @@ constexpr const char* kOptionsId = "FET_OPT";
 constexpr const char* kQuitGameId = "FET_QG";
 }
 
-class Menu
-{
-	int font;
+class Menu {
+    int font;
+
 public:
-	
-	Menu(int font = MenuDefaults::kFont)
-	 : font(font), activeEntry(-1) {}
-	
-	struct MenuEntry
-	{
-		GameString text;
-		float _size;
-		
-		MenuEntry(const GameString& n, float size = 30.f)
-		    : text(n)
-		    , _size(size)
-		{
-		}
-		
-		float getHeight() { return _size; }
-		
-		virtual void draw(int font, bool active, GameRenderer* r, glm::vec2& basis)
-		{
-			TextRenderer::TextInfo ti;
-			ti.font = font;
-			ti.screenPosition = basis;
-			ti.text = text;
-			ti.size = getHeight();
-			if( ! active )
-			{
-				ti.baseColour = glm::u8vec3(255);
-			}
-			else
-			{
-				ti.baseColour = glm::u8vec3(255, 255, 0);
-			}
-			r->text.renderText(ti);
-			basis.y += getHeight();
-		}
-		
-		virtual void activate(float clickX, float clickY) = 0;
-	};
+    Menu(int font = MenuDefaults::kFont) : font(font), activeEntry(-1) {
+    }
 
-	struct Entry : public MenuEntry
-	{
-		std::function<void(void)> callback;
+    struct MenuEntry {
+        GameString text;
+        float _size;
 
-		Entry(const GameString& title,
-		      std::function<void(void)> cb,
-		      float size)
-		    : MenuEntry(title, size)
-		    , callback(cb)
-		{
-		}
+        MenuEntry(const GameString& n, float size = 30.f)
+            : text(n), _size(size) {
+        }
 
-		void activate(float clickX, float clickY)
-		{
-			RW_UNUSED(clickX);
-			RW_UNUSED(clickY);
-			callback();
-		}
-	};
+        float getHeight() {
+            return _size;
+        }
 
-	static std::shared_ptr<MenuEntry> lambda(const GameString& n, std::function<void (void)>  callback, float size = 30.f)
-	{
-		return std::shared_ptr<MenuEntry>(new Entry(n, callback, size));
-	}
+        virtual void draw(int font, bool active, GameRenderer* r,
+                          glm::vec2& basis) {
+            TextRenderer::TextInfo ti;
+            ti.font = font;
+            ti.screenPosition = basis;
+            ti.text = text;
+            ti.size = getHeight();
+            if (!active) {
+                ti.baseColour = glm::u8vec3(255);
+            } else {
+                ti.baseColour = glm::u8vec3(255, 255, 0);
+            }
+            r->text.renderText(ti);
+            basis.y += getHeight();
+        }
 
-	static std::shared_ptr<MenuEntry> lambda(const std::string& n, std::function<void (void)>  callback, float size = 30.f)
-	{
-		return lambda(GameStringUtil::fromString(n), callback, size);
-	}
-	
-	std::vector<std::shared_ptr<MenuEntry>> entries;
-	
-	/**
-	 * Active Entry index
-	 */
-	int activeEntry;
-	
-	glm::vec2 offset;
-	
-	void addEntry(std::shared_ptr<MenuEntry> entry)
-	{
-		entries.push_back(entry);
-	}
-	
-	void draw(GameRenderer* r)
-	{
-		glm::vec2 basis(offset);
-		for(size_t i = 0;
-			i < entries.size();
-			++i)
-		{
-			bool active = false;
-			if(activeEntry >= 0 && i == (unsigned) activeEntry)
-			{
-				active = true;
-			}
-			entries[i]->draw(font, active, r, basis);
-		}
-	}
-	
-	void hover(const float x, const float y)
-	{
-		glm::vec2 c(x - offset.x, y - offset.y);
-		for(size_t i = 0;
-			i < entries.size();
-			++i)
-		{
-			if( c.y > 0.f && c.y < entries[i]->getHeight() ) {
-				activeEntry = i;
-				return;
-			}
-			else {
-				c.y -= entries[i]->getHeight();
-			}
-		}
-	}
-	
-	void click(const float x, const float y)
-	{
-		glm::vec2 c(x - offset.x, y - offset.y);
-		for(auto it = entries.begin();
-			it != entries.end();
-			++it)
-		{
-			if( c.y > 0.f && c.y < (*it)->getHeight() ) {
-				(*it)->activate(c.x, c.y);
-				return;
-			}
-			else {
-				c.y -= (*it)->getHeight();
-			}
-		}
-	}
-	
-	// Activates the menu entry at the current active index.
-	void activate()
-	{
-		if(activeEntry >= 0 && (unsigned) activeEntry < entries.size()) {
-			entries[activeEntry]->activate(0.f, 0.f);
-		}
-	}
-	
-	void move(int movement)
-	{
-		activeEntry += movement;
-		if (activeEntry >= int(entries.size())) {
-			activeEntry = 0;
-		}
-		else if (activeEntry < 0) {
-			activeEntry = entries.size() - 1;
-		}
-	}
+        virtual void activate(float clickX, float clickY) = 0;
+    };
+
+    struct Entry : public MenuEntry {
+        std::function<void(void)> callback;
+
+        Entry(const GameString& title, std::function<void(void)> cb, float size)
+            : MenuEntry(title, size), callback(cb) {
+        }
+
+        void activate(float clickX, float clickY) {
+            RW_UNUSED(clickX);
+            RW_UNUSED(clickY);
+            callback();
+        }
+    };
+
+    static std::shared_ptr<MenuEntry> lambda(const GameString& n,
+                                             std::function<void(void)> callback,
+                                             float size = 30.f) {
+        return std::shared_ptr<MenuEntry>(new Entry(n, callback, size));
+    }
+
+    static std::shared_ptr<MenuEntry> lambda(const std::string& n,
+                                             std::function<void(void)> callback,
+                                             float size = 30.f) {
+        return lambda(GameStringUtil::fromString(n), callback, size);
+    }
+
+    std::vector<std::shared_ptr<MenuEntry>> entries;
+
+    /**
+     * Active Entry index
+     */
+    int activeEntry;
+
+    glm::vec2 offset;
+
+    void addEntry(std::shared_ptr<MenuEntry> entry) {
+        entries.push_back(entry);
+    }
+
+    void draw(GameRenderer* r) {
+        glm::vec2 basis(offset);
+        for (size_t i = 0; i < entries.size(); ++i) {
+            bool active = false;
+            if (activeEntry >= 0 && i == (unsigned)activeEntry) {
+                active = true;
+            }
+            entries[i]->draw(font, active, r, basis);
+        }
+    }
+
+    void hover(const float x, const float y) {
+        glm::vec2 c(x - offset.x, y - offset.y);
+        for (size_t i = 0; i < entries.size(); ++i) {
+            if (c.y > 0.f && c.y < entries[i]->getHeight()) {
+                activeEntry = i;
+                return;
+            } else {
+                c.y -= entries[i]->getHeight();
+            }
+        }
+    }
+
+    void click(const float x, const float y) {
+        glm::vec2 c(x - offset.x, y - offset.y);
+        for (auto it = entries.begin(); it != entries.end(); ++it) {
+            if (c.y > 0.f && c.y < (*it)->getHeight()) {
+                (*it)->activate(c.x, c.y);
+                return;
+            } else {
+                c.y -= (*it)->getHeight();
+            }
+        }
+    }
+
+    // Activates the menu entry at the current active index.
+    void activate() {
+        if (activeEntry >= 0 && (unsigned)activeEntry < entries.size()) {
+            entries[activeEntry]->activate(0.f, 0.f);
+        }
+    }
+
+    void move(int movement) {
+        activeEntry += movement;
+        if (activeEntry >= int(entries.size())) {
+            activeEntry = 0;
+        } else if (activeEntry < 0) {
+            activeEntry = entries.size() - 1;
+        }
+    }
 };
 
 #endif
diff --git a/rwgame/RWGame.cpp b/rwgame/RWGame.cpp
index 0946817c..9e1ac54d 100644
--- a/rwgame/RWGame.cpp
+++ b/rwgame/RWGame.cpp
@@ -1,25 +1,25 @@
 #include "RWGame.hpp"
-#include "State.hpp"
-#include "states/LoadingState.hpp"
-#include "states/IngameState.hpp"
-#include "states/MenuState.hpp"
-#include "states/BenchmarkState.hpp"
 #include "DrawUI.hpp"
+#include "State.hpp"
+#include "states/BenchmarkState.hpp"
+#include "states/IngameState.hpp"
+#include "states/LoadingState.hpp"
+#include "states/MenuState.hpp"
 
 #include <core/Profiler.hpp>
 
-#include <objects/GameObject.hpp>
 #include <engine/GameState.hpp>
-#include <engine/SaveGame.hpp>
 #include <engine/GameWorld.hpp>
-#include <render/GameRenderer.hpp>
+#include <engine/SaveGame.hpp>
+#include <objects/GameObject.hpp>
 #include <render/DebugDraw.hpp>
+#include <render/GameRenderer.hpp>
 
 #include <script/ScriptMachine.hpp>
 #include <script/modules/GTA3Module.hpp>
 
-#include <data/CutsceneData.hpp>
 #include <ai/PlayerController.hpp>
+#include <data/CutsceneData.hpp>
 #include <objects/CharacterObject.hpp>
 #include <objects/VehicleObject.hpp>
 
@@ -39,259 +39,227 @@ DebugDraw* debug = nullptr;
 
 StdOutReciever logPrinter;
 
-RWGame::RWGame(int argc, char* argv[])
-{
-	if (!config.isValid())
-	{
-		throw std::runtime_error("Invalid configuration file at: " + config.getConfigFile());
-	}
+RWGame::RWGame(int argc, char* argv[]) {
+    if (!config.isValid()) {
+        throw std::runtime_error("Invalid configuration file at: " +
+                                 config.getConfigFile());
+    }
 
-	size_t w = GAME_WINDOW_WIDTH, h = GAME_WINDOW_HEIGHT;
-	bool fullscreen = false;
-	bool newgame = false;
-	bool test = false;
-	bool help = false;
-	std::string startSave;
-	std::string benchFile;
+    size_t w = GAME_WINDOW_WIDTH, h = GAME_WINDOW_HEIGHT;
+    bool fullscreen = false;
+    bool newgame = false;
+    bool test = false;
+    bool help = false;
+    std::string startSave;
+    std::string benchFile;
 
-	// Define and parse command line options
-	namespace po = boost::program_options;
-	po::options_description desc("Available options");
-	desc.add_options()
-		("help",                                   "Show this help message")
-		("width,w",      po::value<size_t>(),      "Game resolution width in pixel")
-		("height,h",     po::value<size_t>(),      "Game resolution height in pixel")
-		("fullscreen,f",                           "Enable fullscreen mode")
-		("newgame,n",                              "Directly start a new game")
-		("test,t",                                 "Starts a new game in a test location")
-		("load,l",       po::value<std::string>(), "Load save file")
-		("benchmark,b",  po::value<std::string>(), "Run benchmark from file")
-	;
+    // Define and parse command line options
+    namespace po = boost::program_options;
+    po::options_description desc("Available options");
+    desc.add_options()("help", "Show this help message")(
+        "width,w", po::value<size_t>(), "Game resolution width in pixel")(
+        "height,h", po::value<size_t>(), "Game resolution height in pixel")(
+        "fullscreen,f", "Enable fullscreen mode")("newgame,n",
+                                                  "Directly start a new game")(
+        "test,t", "Starts a new game in a test location")(
+        "load,l", po::value<std::string>(), "Load save file")(
+        "benchmark,b", po::value<std::string>(), "Run benchmark from file");
 
-	po::variables_map vm;
-	try
-	{
-		po::store(po::parse_command_line(argc, argv, desc), vm);
-		po::notify(vm);
-	}
-	catch (po::error& ex)
-	{
-		help = true;
-		std::cout << "Error parsing arguments: " << ex.what() << std::endl;
-	}
+    po::variables_map vm;
+    try {
+        po::store(po::parse_command_line(argc, argv, desc), vm);
+        po::notify(vm);
+    } catch (po::error& ex) {
+        help = true;
+        std::cout << "Error parsing arguments: " << ex.what() << std::endl;
+    }
 
-	if( help || vm.count("help") )
-	{
-		std::cout << desc;
-		throw std::invalid_argument("");
-	}
-	if( vm.count("width") )
-	{
-		w = vm["width"].as<size_t>();
-	}
-	if( vm.count("height") )
-	{
-		h = vm["height"].as<size_t>();
-	}
-	if( vm.count("fullscreen") )
-	{
-		fullscreen = true;
-	}
-	if( vm.count("newgame") )
-	{
-		newgame = true;
-	}
-	if( vm.count("test") )
-	{
-		test = true;
-	}
-	if( vm.count("load") )
-	{
-		startSave = vm["load"].as<std::string>();
-	}
-	if( vm.count("benchmark") )
-	{
-		benchFile = vm["benchmark"].as<std::string>();
-	}
+    if (help || vm.count("help")) {
+        std::cout << desc;
+        throw std::invalid_argument("");
+    }
+    if (vm.count("width")) {
+        w = vm["width"].as<size_t>();
+    }
+    if (vm.count("height")) {
+        h = vm["height"].as<size_t>();
+    }
+    if (vm.count("fullscreen")) {
+        fullscreen = true;
+    }
+    if (vm.count("newgame")) {
+        newgame = true;
+    }
+    if (vm.count("test")) {
+        test = true;
+    }
+    if (vm.count("load")) {
+        startSave = vm["load"].as<std::string>();
+    }
+    if (vm.count("benchmark")) {
+        benchFile = vm["benchmark"].as<std::string>();
+    }
 
-	if (SDL_Init(SDL_INIT_VIDEO) < 0)
-		throw std::runtime_error("Failed to initialize SDL2!");
+    if (SDL_Init(SDL_INIT_VIDEO) < 0)
+        throw std::runtime_error("Failed to initialize SDL2!");
 
-	window = new GameWindow();
-	window->create(kWindowTitle + " [" + kBuildStr + "]", w, h, fullscreen);
+    window = new GameWindow();
+    window->create(kWindowTitle + " [" + kBuildStr + "]", w, h, fullscreen);
 
-	work = new WorkContext();
+    work = new WorkContext();
 
-	log.addReciever(&logPrinter);
-	log.info("Game", "Game directory: " + config.getGameDataPath());
-	log.info("Game", "Build: " + kBuildStr);
-	
-	if(! GameData::isValidGameDirectory(config.getGameDataPath()) )
-	{
-		throw std::runtime_error("Invalid game directory path: " + config.getGameDataPath());
-	}
+    log.addReciever(&logPrinter);
+    log.info("Game", "Game directory: " + config.getGameDataPath());
+    log.info("Game", "Build: " + kBuildStr);
 
-	data = new GameData(&log, work, config.getGameDataPath());
+    if (!GameData::isValidGameDirectory(config.getGameDataPath())) {
+        throw std::runtime_error("Invalid game directory path: " +
+                                 config.getGameDataPath());
+    }
 
-	data->load();
-	
-	// Initialize renderer
-	renderer = new GameRenderer(&log, data);
-	
-	// Set up text renderer
-	renderer->text.setFontTexture(0, "pager");
-	renderer->text.setFontTexture(1, "font1");
-	renderer->text.setFontTexture(2, "font2");
+    data = new GameData(&log, work, config.getGameDataPath());
 
-	debug = new DebugDraw;
-	debug->setDebugMode(btIDebugDraw::DBG_DrawWireframe | btIDebugDraw::DBG_DrawConstraints | btIDebugDraw::DBG_DrawConstraintLimits);
-	debug->setShaderProgram(renderer->worldProg);
+    data->load();
 
-	data->loadDynamicObjects(config.getGameDataPath() + "/data/object.dat");
+    // Initialize renderer
+    renderer = new GameRenderer(&log, data);
 
-	data->loadGXT("text/" + config.getGameLanguage() + ".gxt");
-	
-	getRenderer()->water.setWaterTable(data->waterHeights, 48, data->realWater, 128*128);
-	
-	for(int m = 0; m < MAP_BLOCK_SIZE; ++m)
-	{
-		std::string num = (m < 10 ? "0" : "");
-		std::string name = "radar" + num +  std::to_string(m);
-		data->loadTXD(name + ".txd");
-	}
+    // Set up text renderer
+    renderer->text.setFontTexture(0, "pager");
+    renderer->text.setFontTexture(1, "font1");
+    renderer->text.setFontTexture(2, "font2");
 
-	auto loading = new LoadingState(this);
-	if (! benchFile.empty())
-	{
-		loading->setNextState(new BenchmarkState(this, benchFile));
-	}
-	else if( test)
-	{
-		loading->setNextState(new IngameState(this, true, "test"));
-	}
-	else if( newgame )
-	{
-		loading->setNextState(new IngameState(this, true));
-	}
-	else if( ! startSave.empty() )
-	{
-		loading->setNextState(new IngameState(this, true, startSave));
-	}
-	else
-	{
-		loading->setNextState(new MenuState(this));
-	}
+    debug = new DebugDraw;
+    debug->setDebugMode(btIDebugDraw::DBG_DrawWireframe |
+                        btIDebugDraw::DBG_DrawConstraints |
+                        btIDebugDraw::DBG_DrawConstraintLimits);
+    debug->setShaderProgram(renderer->worldProg);
 
-	StateManager::get().enter(loading);
+    data->loadDynamicObjects(config.getGameDataPath() + "/data/object.dat");
 
-	log.info("Game", "Started");
+    data->loadGXT("text/" + config.getGameLanguage() + ".gxt");
+
+    getRenderer()->water.setWaterTable(data->waterHeights, 48, data->realWater,
+                                       128 * 128);
+
+    for (int m = 0; m < MAP_BLOCK_SIZE; ++m) {
+        std::string num = (m < 10 ? "0" : "");
+        std::string name = "radar" + num + std::to_string(m);
+        data->loadTXD(name + ".txd");
+    }
+
+    auto loading = new LoadingState(this);
+    if (!benchFile.empty()) {
+        loading->setNextState(new BenchmarkState(this, benchFile));
+    } else if (test) {
+        loading->setNextState(new IngameState(this, true, "test"));
+    } else if (newgame) {
+        loading->setNextState(new IngameState(this, true));
+    } else if (!startSave.empty()) {
+        loading->setNextState(new IngameState(this, true, startSave));
+    } else {
+        loading->setNextState(new MenuState(this));
+    }
+
+    StateManager::get().enter(loading);
+
+    log.info("Game", "Started");
 }
 
-RWGame::~RWGame()
-{
-	log.info("Game", "Beginning cleanup");
+RWGame::~RWGame() {
+    log.info("Game", "Beginning cleanup");
 
-	log.info("Game", "Stopping work queue");
-	work->stop();
+    log.info("Game", "Stopping work queue");
+    work->stop();
 
-	log.info("Game", "Cleaning up scripts");
-	delete script;
+    log.info("Game", "Cleaning up scripts");
+    delete script;
 
-	log.info("Game", "Cleaning up renderer");
-	delete renderer;
+    log.info("Game", "Cleaning up renderer");
+    delete renderer;
 
-	log.info("Game", "Cleaning up world");
-	delete world;
-	
-	log.info("Game", "Cleaning up state");
-	delete state;
+    log.info("Game", "Cleaning up world");
+    delete world;
 
-	log.info("Game", "Cleaning up window");
-	delete window;
+    log.info("Game", "Cleaning up state");
+    delete state;
 
-	log.info("Game", "Cleaning up work queue");
-	delete work;
+    log.info("Game", "Cleaning up window");
+    delete window;
 
-	SDL_Quit();
+    log.info("Game", "Cleaning up work queue");
+    delete work;
 
-	log.info("Game", "Done cleaning up");
+    SDL_Quit();
+
+    log.info("Game", "Done cleaning up");
 }
 
-void RWGame::newGame()
-{
-	if( state != nullptr )
-	{
-		log.error("Game", "Cannot start a new game: game is already running.");
-		return;
-	}
+void RWGame::newGame() {
+    if (state != nullptr) {
+        log.error("Game", "Cannot start a new game: game is already running.");
+        return;
+    }
 
-	state = new GameState();
-	world = new GameWorld(&log, work, data);
-	world->dynamicsWorld->setDebugDrawer(debug);
+    state = new GameState();
+    world = new GameWorld(&log, work, data);
+    world->dynamicsWorld->setDebugDrawer(debug);
 
-	// Associate the new world with the new state and vice versa
-	state->world = world;
-	world->state = state;
+    // Associate the new world with the new state and vice versa
+    state->world = world;
+    world->state = state;
 
-	for(std::map<std::string, std::string>::iterator it = world->data->iplLocations.begin();
-		it != world->data->iplLocations.end();
-		++it) {
-		world->data->loadZone(it->second);
-		world->placeItems(it->second);
-	}
-	
+    for (std::map<std::string, std::string>::iterator it =
+             world->data->iplLocations.begin();
+         it != world->data->iplLocations.end(); ++it) {
+        world->data->loadZone(it->second);
+        world->placeItems(it->second);
+    }
 }
 
-void RWGame::saveGame(const std::string& savename)
-{
-	RW_UNUSED(savename);
+void RWGame::saveGame(const std::string& savename) {
+    RW_UNUSED(savename);
 }
 
-void RWGame::loadGame(const std::string& savename)
-{
-	delete state->world;
-	delete state->script;
-	state = nullptr;
+void RWGame::loadGame(const std::string& savename) {
+    delete state->world;
+    delete state->script;
+    state = nullptr;
 
-	log.info("Game", "Loading game " + savename);
+    log.info("Game", "Loading game " + savename);
 
-	newGame();
+    newGame();
 
-	startScript("data/main.scm");
+    startScript("data/main.scm");
 
-	if(! SaveGame::loadGame(*state, savename) )
-	{
-		log.error("Game", "Failed to load game");
-	}
+    if (!SaveGame::loadGame(*state, savename)) {
+        log.error("Game", "Failed to load game");
+    }
 }
 
-void RWGame::startScript(const std::string& name)
-{
-	SCMFile* f = world->data->loadSCM(name);
-	if( f ) {
-		if( script ) delete script;
+void RWGame::startScript(const std::string& name) {
+    SCMFile* f = world->data->loadSCM(name);
+    if (f) {
+        if (script) delete script;
 
-		SCMOpcodes* opcodes = new SCMOpcodes;
-		opcodes->modules.push_back(new GTA3Module);
+        SCMOpcodes* opcodes = new SCMOpcodes;
+        opcodes->modules.push_back(new GTA3Module);
 
-		script = new ScriptMachine(state, f, opcodes);
-		
-		state->script = script;
-	}
-	else {
-		log.error("Game", "Failed to load SCM: " + name);
-	}
+        script = new ScriptMachine(state, f, opcodes);
+
+        state->script = script;
+    } else {
+        log.error("Game", "Failed to load SCM: " + name);
+    }
 }
 
-PlayerController *RWGame::getPlayer()
-{
-	auto object = world->pedestrianPool.find(state->playerObject);
-	if( object )
-	{
-		auto controller = static_cast<CharacterObject*>(object)->controller;
-		return static_cast<PlayerController*>(controller);
-	}
-	return nullptr;
+PlayerController* RWGame::getPlayer() {
+    auto object = world->pedestrianPool.find(state->playerObject);
+    if (object) {
+        auto controller = static_cast<CharacterObject*>(object)->controller;
+        return static_cast<PlayerController*>(controller);
+    }
+    return nullptr;
 }
 
 // Modifiers for GTA3 we try to recreate
@@ -300,700 +268,717 @@ PlayerController *RWGame::getPlayer()
 #define RW_GAME_GTA3_ANNIVERSARY 0
 
 void RWGame::handleCheatInput(char symbol) {
-	cheatInputWindow = cheatInputWindow.substr(1) + symbol;
+    cheatInputWindow = cheatInputWindow.substr(1) + symbol;
 
-	// Helper to check for cheats
-	auto checkForCheat = [this](std::string cheat, std::function<void()> action) {
-		RW_CHECK(cheatInputWindow.length() >= cheat.length(), "Cheat too long");
-		size_t offset = cheatInputWindow.length() - cheat.length();
-		if (cheat == cheatInputWindow.substr(offset)) {
-			log.info("Game", "Cheat triggered: '" + cheat + "'");
-			if (action) {
-				action();
-			}
-		}
-	};
+    // Helper to check for cheats
+    auto checkForCheat = [this](std::string cheat,
+                                std::function<void()> action) {
+        RW_CHECK(cheatInputWindow.length() >= cheat.length(), "Cheat too long");
+        size_t offset = cheatInputWindow.length() - cheat.length();
+        if (cheat == cheatInputWindow.substr(offset)) {
+            log.info("Game", "Cheat triggered: '" + cheat + "'");
+            if (action) {
+                action();
+            }
+        }
+    };
 
-	// Player related cheats
-	{
-		auto player = static_cast<CharacterObject*>(world->pedestrianPool.find(state->playerObject));
+    // Player related cheats
+    {
+        auto player = static_cast<CharacterObject*>(
+            world->pedestrianPool.find(state->playerObject));
 
-#ifdef RW_GAME_GTA3_GERMAN // Germans got their own cheat
-		std::string health_cheat = "GESUNDHEIT";
+#ifdef RW_GAME_GTA3_GERMAN  // Germans got their own cheat
+        std::string health_cheat = "GESUNDHEIT";
 #else
-		std::string health_cheat = "HEALTH";
+        std::string health_cheat = "HEALTH";
 #endif
-		checkForCheat(health_cheat, [&]{
-			player->getCurrentState().health = 100.f;
-			// @todo ShowHelpMessage("CHEAT3"); // III / VC: Inputting health cheat.
-		});
+        checkForCheat(health_cheat, [&] {
+            player->getCurrentState().health = 100.f;
+            // @todo ShowHelpMessage("CHEAT3"); // III / VC: Inputting health
+            // cheat.
+        });
 
-#if RW_GAME_VERSION >= 1100 // Changed cheat name in version 1.1
-		std::string armor_cheat = "TORTOISE";
+#if RW_GAME_VERSION >= 1100  // Changed cheat name in version 1.1
+        std::string armor_cheat = "TORTOISE";
 #else
-		std::string armor_cheat = "TURTOISE";
+        std::string armor_cheat = "TURTOISE";
 #endif
-		checkForCheat(armor_cheat, [&]{
-			player->getCurrentState().armour = 100.f;
-			// @todo ShowHelpMessage("CHEAT4"); // III / VC: Inputting armor cheat.
-		});
+        checkForCheat(armor_cheat, [&] {
+            player->getCurrentState().armour = 100.f;
+            // @todo ShowHelpMessage("CHEAT4"); // III / VC: Inputting armor
+            // cheat.
+        });
 
-		checkForCheat("GUNSGUNSGUNS", [&]{
-			// @todo give player weapons
-			// @todo ShowHelpMessage("CHEAT2"); // III / VC: Inputting weapon cheats.
-		});
+        checkForCheat("GUNSGUNSGUNS", [&] {
+            // @todo give player weapons
+            // @todo ShowHelpMessage("CHEAT2"); // III / VC: Inputting weapon
+            // cheats.
+        });
 
-		checkForCheat("IFIWEREARICHMAN", [&]{
-			world->state->playerInfo.money += 250000;
-			// @todo ShowHelpMessage("CHEAT6"); // III: Inputting money cheat.
-		});
+        checkForCheat("IFIWEREARICHMAN", [&] {
+            world->state->playerInfo.money += 250000;
+            // @todo ShowHelpMessage("CHEAT6"); // III: Inputting money cheat.
+        });
 
-		checkForCheat("MOREPOLICEPLEASE", [&]{
-			// @todo raise to next wanted level
-			// @todo ShowHelpMessage("CHEAT5"); // III / VC: Inputting wanted level cheats.
-		});
+        checkForCheat("MOREPOLICEPLEASE", [&] {
+            // @todo raise to next wanted level
+            // @todo ShowHelpMessage("CHEAT5"); // III / VC: Inputting wanted
+            // level cheats.
+        });
 
-		checkForCheat("NOPOLICEPLEASE", [&]{
-			// @todo lower to next lower wanted level
-			// @todo ShowHelpMessage("CHEAT5"); // III / VC: Inputting wanted level cheats.
-		});
-	}
+        checkForCheat("NOPOLICEPLEASE", [&] {
+            // @todo lower to next lower wanted level
+            // @todo ShowHelpMessage("CHEAT5"); // III / VC: Inputting wanted
+            // level cheats.
+        });
+    }
 
-	// Misc cheats.
-	{
-		checkForCheat("BANGBANGBANG", [&]{
-			// @todo Explode nearby vehicles
-			// @todo What radius?
-			// @todo ShowHelpMessage("CHEAT1"); // III / VC: Inputting most cheats.
-		});
+    // Misc cheats.
+    {
+        checkForCheat("BANGBANGBANG", [&] {
+            // @todo Explode nearby vehicles
+            // @todo What radius?
+            // @todo ShowHelpMessage("CHEAT1"); // III / VC: Inputting most
+            // cheats.
+        });
 
-		checkForCheat("GIVEUSATANK", [&]{
-			// The iPod / Android version of the game (10th year anniversary) spawns random (?) vehicles instead of always rhino
+        checkForCheat("GIVEUSATANK", [&] {
+// The iPod / Android version of the game (10th year anniversary) spawns random
+// (?) vehicles instead of always rhino
 #ifdef RW_GAME_GTA3_ANNIVERSARY
-			uint16_t vehicleModel = 110; // @todo Which cars are spawned?!
+            uint16_t vehicleModel = 110;  // @todo Which cars are spawned?!
 #else
 			uint16_t vehicleModel = 122;
 #endif
-			// @todo Spawn rhino
-			// @todo ShowHelpMessage("CHEAT1"); // III / VC: Inputting most cheats.
-		});
+            // @todo Spawn rhino
+            // @todo ShowHelpMessage("CHEAT1"); // III / VC: Inputting most
+            // cheats.
+        });
 
-		checkForCheat("CORNERSLIKEMAD", [&]{
-			// @todo Weird car handling
-			// @todo ShowHelpMessage("CHEAT1"); // III / VC: Inputting most cheats.
-		});
+        checkForCheat("CORNERSLIKEMAD", [&] {
+            // @todo Weird car handling
+            // @todo ShowHelpMessage("CHEAT1"); // III / VC: Inputting most
+            // cheats.
+        });
 
-		checkForCheat("ANICESETOFWHEELS", [&]{
-			// @todo Hide car bodies
-			// @todo ShowHelpMessage("CHEAT1"); // III / VC: Inputting most cheats.
-		});
+        checkForCheat("ANICESETOFWHEELS", [&] {
+            // @todo Hide car bodies
+            // @todo ShowHelpMessage("CHEAT1"); // III / VC: Inputting most
+            // cheats.
+        });
 
-		checkForCheat("CHITTYCHITTYBB", [&]{
-			// @todo Cars can fly
-			// @todo ShowHelpMessage("CHEAT1"); // III / VC: Inputting most cheats.
-		});
+        checkForCheat("CHITTYCHITTYBB", [&] {
+            // @todo Cars can fly
+            // @todo ShowHelpMessage("CHEAT1"); // III / VC: Inputting most
+            // cheats.
+        });
 
-		checkForCheat("NASTYLIMBCHEAT", [&]{
-			// @todo Makes it possible to shoot limbs off, iirc?
-			// @todo ShowHelpMessage("CHEAT1"); // III / VC: Inputting most cheats.
-		});
+        checkForCheat("NASTYLIMBCHEAT", [&] {
+            // @todo Makes it possible to shoot limbs off, iirc?
+            // @todo ShowHelpMessage("CHEAT1"); // III / VC: Inputting most
+            // cheats.
+        });
 
-		checkForCheat("ILIKEDRESSINGUP", [&]{
-			// @todo Which skins will be chosen?
-			// @todo ShowHelpMessage("CHEAT1"); // III / VC: Inputting most cheats.
-		});
-	}
+        checkForCheat("ILIKEDRESSINGUP", [&] {
+            // @todo Which skins will be chosen?
+            // @todo ShowHelpMessage("CHEAT1"); // III / VC: Inputting most
+            // cheats.
+        });
+    }
 
-	// Pedestrian cheats
-	{
-		checkForCheat("WEAPONSFORALL", [&]{
-			// @todo Give all pedestrians weapons.. this is also saved in the savegame?!
-			// @todo Which weapons do they get?
-			// @todo ShowHelpMessage("CHEAT1"); // III / VC: Inputting most cheats.
-		});
+    // Pedestrian cheats
+    {
+        checkForCheat("WEAPONSFORALL", [&] {
+            // @todo Give all pedestrians weapons.. this is also saved in the
+            // savegame?!
+            // @todo Which weapons do they get?
+            // @todo ShowHelpMessage("CHEAT1"); // III / VC: Inputting most
+            // cheats.
+        });
 
-		checkForCheat("NOBODYLIKESME", [&]{
-			// @todo Set all pedestrians hostile towards player.. this is also saved in the savegame?!
-			// @todo ShowHelpMessage("CHEAT1"); // III / VC: Inputting most cheats.
-		});
+        checkForCheat("NOBODYLIKESME", [&] {
+            // @todo Set all pedestrians hostile towards player.. this is also
+            // saved in the savegame?!
+            // @todo ShowHelpMessage("CHEAT1"); // III / VC: Inputting most
+            // cheats.
+        });
 
-		checkForCheat("ITSALLGOINGMAAAD", [&]{
-			// @todo Set all pedestrians to fighting each other.. this is also saved in the savegame?!
-			// @todo ShowHelpMessage("CHEAT1"); // III / VC: Inputting most cheats.
-		});
+        checkForCheat("ITSALLGOINGMAAAD", [&] {
+            // @todo Set all pedestrians to fighting each other.. this is also
+            // saved in the savegame?!
+            // @todo ShowHelpMessage("CHEAT1"); // III / VC: Inputting most
+            // cheats.
+        });
 
-		// Game speed cheats
+        // Game speed cheats
 
-		checkForCheat("TIMEFLIESWHENYOU", [&]{
-			// @todo Set fast gamespeed
-			// @todo ShowHelpMessage("CHEAT1"); // III / VC: Inputting most cheats.
-		});
+        checkForCheat("TIMEFLIESWHENYOU", [&] {
+            // @todo Set fast gamespeed
+            // @todo ShowHelpMessage("CHEAT1"); // III / VC: Inputting most
+            // cheats.
+        });
 
-		checkForCheat("BOOOOORING", [&]{
-			// @todo Set slow gamespeed
-			// @todo ShowHelpMessage("CHEAT1"); // III / VC: Inputting most cheats.
-		});
-	}
+        checkForCheat("BOOOOORING", [&] {
+            // @todo Set slow gamespeed
+            // @todo ShowHelpMessage("CHEAT1"); // III / VC: Inputting most
+            // cheats.
+        });
+    }
 
-	// Weather cheats
-	{
-		checkForCheat("ILIKESCOTLAND", [&]{
-			// @todo Set weather to cloudy
-			// @todo ShowHelpMessage("CHEAT7"); // III / VC: Inputting weather cheats.
-		});
+    // Weather cheats
+    {
+        checkForCheat("ILIKESCOTLAND", [&] {
+            // @todo Set weather to cloudy
+            // @todo ShowHelpMessage("CHEAT7"); // III / VC: Inputting weather
+            // cheats.
+        });
 
-		checkForCheat("SKINCANCERFORME", [&]{
-			// @todo Set sunny / normal weather
-			// @todo ShowHelpMessage("CHEAT7"); // III / VC: Inputting weather cheats.
-		});
+        checkForCheat("SKINCANCERFORME", [&] {
+            // @todo Set sunny / normal weather
+            // @todo ShowHelpMessage("CHEAT7"); // III / VC: Inputting weather
+            // cheats.
+        });
 
-		checkForCheat("MADWEATHER", [&]{
-			// @todo Set bad weather
-			// @todo ShowHelpMessage("CHEAT7"); // III / VC: Inputting weather cheats.
-		});
+        checkForCheat("MADWEATHER", [&] {
+            // @todo Set bad weather
+            // @todo ShowHelpMessage("CHEAT7"); // III / VC: Inputting weather
+            // cheats.
+        });
 
-		checkForCheat("ILOVESCOTLAND", [&]{
-			// @todo Set weather to rainy
-			// @todo ShowHelpMessage("CHEAT7"); // III / VC: Inputting weather cheats.
-		});
+        checkForCheat("ILOVESCOTLAND", [&] {
+            // @todo Set weather to rainy
+            // @todo ShowHelpMessage("CHEAT7"); // III / VC: Inputting weather
+            // cheats.
+        });
 
-		checkForCheat("PEASOUP", [&]{
-			// @todo Set weather to foggy
-			// @todo ShowHelpMessage("CHEAT7"); // III / VC: Inputting weather cheats.
-		});
-	}
+        checkForCheat("PEASOUP", [&] {
+            // @todo Set weather to foggy
+            // @todo ShowHelpMessage("CHEAT7"); // III / VC: Inputting weather
+            // cheats.
+        });
+    }
 }
 
-int RWGame::run()
-{
-	last_clock_time = clock.now();
+int RWGame::run() {
+    last_clock_time = clock.now();
 
-	// Loop until we run out of states.
-	while (StateManager::get().states.size()) {
-		State* state = StateManager::get().states.back();
+    // Loop until we run out of states.
+    while (StateManager::get().states.size()) {
+        State* state = StateManager::get().states.back();
 
-		RW_PROFILE_FRAME_BOUNDARY();
-		
-		RW_PROFILE_BEGIN("Input");
-		SDL_Event event;
-		while (SDL_PollEvent(&event)) {
-			switch (event.type) {
-			case SDL_QUIT:
-				StateManager::get().clear();
-				break;
+        RW_PROFILE_FRAME_BOUNDARY();
 
-			case SDL_WINDOWEVENT:
-				switch (event.window.event) {
-				case SDL_WINDOWEVENT_FOCUS_GAINED:
-					inFocus = true;
-					break;
+        RW_PROFILE_BEGIN("Input");
+        SDL_Event event;
+        while (SDL_PollEvent(&event)) {
+            switch (event.type) {
+                case SDL_QUIT:
+                    StateManager::get().clear();
+                    break;
 
-				case SDL_WINDOWEVENT_FOCUS_LOST:
-					inFocus = false;
-					break;
-				}
-				break;
+                case SDL_WINDOWEVENT:
+                    switch (event.window.event) {
+                        case SDL_WINDOWEVENT_FOCUS_GAINED:
+                            inFocus = true;
+                            break;
 
-			case SDL_KEYDOWN:
-				globalKeyEvent(event);
-				break;
+                        case SDL_WINDOWEVENT_FOCUS_LOST:
+                            inFocus = false;
+                            break;
+                    }
+                    break;
 
-			case SDL_MOUSEMOTION:
-				event.motion.xrel *= MOUSE_SENSITIVITY_SCALE;
-				event.motion.yrel *= MOUSE_SENSITIVITY_SCALE;
-				break;
-			}
+                case SDL_KEYDOWN:
+                    globalKeyEvent(event);
+                    break;
 
-			RW_PROFILE_BEGIN("State");
-			state->handleEvent(event);
-			RW_PROFILE_END()
-		}
-		RW_PROFILE_END();
+                case SDL_MOUSEMOTION:
+                    event.motion.xrel *= MOUSE_SENSITIVITY_SCALE;
+                    event.motion.yrel *= MOUSE_SENSITIVITY_SCALE;
+                    break;
+            }
 
-		auto now = clock.now();
-		float timer = std::chrono::duration<float>(now - last_clock_time).count();
-		last_clock_time = now;
-		accum += timer * timescale;
+            RW_PROFILE_BEGIN("State");
+            state->handleEvent(event);
+            RW_PROFILE_END()
+        }
+        RW_PROFILE_END();
 
-		RW_PROFILE_BEGIN("Update");
-		if ( accum >= GAME_TIMESTEP ) {
-			if (StateManager::get().states.size() == 0) {
-				break;
-			}
+        auto now = clock.now();
+        float timer =
+            std::chrono::duration<float>(now - last_clock_time).count();
+        last_clock_time = now;
+        accum += timer * timescale;
 
-			RW_PROFILE_BEGIN("state");
-			StateManager::get().tick(GAME_TIMESTEP);
-			RW_PROFILE_END();
+        RW_PROFILE_BEGIN("Update");
+        if (accum >= GAME_TIMESTEP) {
+            if (StateManager::get().states.size() == 0) {
+                break;
+            }
 
-			RW_PROFILE_BEGIN("engine");
-			tick(GAME_TIMESTEP);
-			RW_PROFILE_END();
-			
-			accum -= GAME_TIMESTEP;
-			
-			// Throw away time if the accumulator reaches too high.
-			if ( accum > GAME_TIMESTEP * 5.f )
-			{
-				accum = 0.f;
-			}
-		}
-		RW_PROFILE_END();
+            RW_PROFILE_BEGIN("state");
+            StateManager::get().tick(GAME_TIMESTEP);
+            RW_PROFILE_END();
 
-		float alpha = fmod(accum, GAME_TIMESTEP) / GAME_TIMESTEP;
-		if( ! state->shouldWorldUpdate() )
-		{
-			alpha = 1.f;
-		}
+            RW_PROFILE_BEGIN("engine");
+            tick(GAME_TIMESTEP);
+            RW_PROFILE_END();
 
-		RW_PROFILE_BEGIN("Render");
-		RW_PROFILE_BEGIN("engine");
-		render(alpha, timer);
-		RW_PROFILE_END();
+            accum -= GAME_TIMESTEP;
 
-		RW_PROFILE_BEGIN("state");
-		if (StateManager::get().states.size() > 0) {
-			StateManager::get().draw(renderer);
-		}
-		RW_PROFILE_END();
-		RW_PROFILE_END();
+            // Throw away time if the accumulator reaches too high.
+            if (accum > GAME_TIMESTEP * 5.f) {
+                accum = 0.f;
+            }
+        }
+        RW_PROFILE_END();
 
-		renderProfile();
+        float alpha = fmod(accum, GAME_TIMESTEP) / GAME_TIMESTEP;
+        if (!state->shouldWorldUpdate()) {
+            alpha = 1.f;
+        }
 
-		window->swap();
-	}
+        RW_PROFILE_BEGIN("Render");
+        RW_PROFILE_BEGIN("engine");
+        render(alpha, timer);
+        RW_PROFILE_END();
 
-	return 0;
+        RW_PROFILE_BEGIN("state");
+        if (StateManager::get().states.size() > 0) {
+            StateManager::get().draw(renderer);
+        }
+        RW_PROFILE_END();
+        RW_PROFILE_END();
+
+        renderProfile();
+
+        window->swap();
+    }
+
+    return 0;
 }
 
-void RWGame::tick(float dt)
-{
-	// Process the Engine's background work.
-	world->_work->update();
-	
-	State* currState = StateManager::get().states.back();
+void RWGame::tick(float dt) {
+    // Process the Engine's background work.
+    world->_work->update();
 
-	world->chase.update(dt);
-	
-	static float clockAccumulator = 0.f;
-	if ( currState->shouldWorldUpdate() ) {
-		// Clear out any per-tick state.
-		world->clearTickData();
+    State* currState = StateManager::get().states.back();
 
-		state->gameTime += dt;
+    world->chase.update(dt);
 
-		clockAccumulator += dt;
-		while( clockAccumulator >= 1.f ) {
-			world->state->basic.gameMinute ++;
-			while( state->basic.gameMinute >= 60 ) {
-				state->basic.gameMinute = 0;
-				state->basic.gameHour ++;
-				while( state->basic.gameHour >= 24 ) {
-					state->basic.gameHour = 0;
-				}
-			}
-			clockAccumulator -= 1.f;
-		}
-		
-		// Clean up old VisualFX
-		for( int i = 0; i < static_cast<int>(world->effects.size()); ++i )
-		{
-			VisualFX* effect = world->effects[i];
-			if( effect->getType() == VisualFX::Particle )
-			{
-				auto& part = effect->particle;
-				if( part.lifetime < 0.f ) continue;
-				if( world->getGameTime() >= part.starttime + part.lifetime )
-				{
-					world->destroyEffect( effect );
-					--i;
-				}
-			}
-		}
+    static float clockAccumulator = 0.f;
+    if (currState->shouldWorldUpdate()) {
+        // Clear out any per-tick state.
+        world->clearTickData();
 
-		for( auto& object : world->allObjects ) {
-			object->_updateLastTransform();
-			object->tick(dt);
-		}
-		
-		world->destroyQueuedObjects();
+        state->gameTime += dt;
 
-		state->text.tick(dt);
+        clockAccumulator += dt;
+        while (clockAccumulator >= 1.f) {
+            world->state->basic.gameMinute++;
+            while (state->basic.gameMinute >= 60) {
+                state->basic.gameMinute = 0;
+                state->basic.gameHour++;
+                while (state->basic.gameHour >= 24) {
+                    state->basic.gameHour = 0;
+                }
+            }
+            clockAccumulator -= 1.f;
+        }
 
-		world->dynamicsWorld->stepSimulation(dt, 2, dt);
-		
-		if( script ) {
-			try {
-				script->execute(dt);
-			}
-			catch( SCMException& ex ) {
-				std::cerr << ex.what() << std::endl;
-				log.error( "Script", ex.what() );
-				throw;
-			}
-		}
+        // Clean up old VisualFX
+        for (int i = 0; i < static_cast<int>(world->effects.size()); ++i) {
+            VisualFX* effect = world->effects[i];
+            if (effect->getType() == VisualFX::Particle) {
+                auto& part = effect->particle;
+                if (part.lifetime < 0.f) continue;
+                if (world->getGameTime() >= part.starttime + part.lifetime) {
+                    world->destroyEffect(effect);
+                    --i;
+                }
+            }
+        }
 
-		/// @todo this doesn't make sense as the condition
-		if ( state->playerObject ) {
-			nextCam.frustum.update(nextCam.frustum.projection() * nextCam.getView());
-			// Use the current camera position to spawn pedestrians.
-			world->cleanupTraffic(nextCam);
-			world->createTraffic(nextCam);
-		}
-	}
-	
-	// render() needs two cameras to smoothly interpolate between ticks.
-	lastCam = nextCam;
-	nextCam = currState->getCamera();
+        for (auto& object : world->allObjects) {
+            object->_updateLastTransform();
+            object->tick(dt);
+        }
+
+        world->destroyQueuedObjects();
+
+        state->text.tick(dt);
+
+        world->dynamicsWorld->stepSimulation(dt, 2, dt);
+
+        if (script) {
+            try {
+                script->execute(dt);
+            } catch (SCMException& ex) {
+                std::cerr << ex.what() << std::endl;
+                log.error("Script", ex.what());
+                throw;
+            }
+        }
+
+        /// @todo this doesn't make sense as the condition
+        if (state->playerObject) {
+            nextCam.frustum.update(nextCam.frustum.projection() *
+                                   nextCam.getView());
+            // Use the current camera position to spawn pedestrians.
+            world->cleanupTraffic(nextCam);
+            world->createTraffic(nextCam);
+        }
+    }
+
+    // render() needs two cameras to smoothly interpolate between ticks.
+    lastCam = nextCam;
+    nextCam = currState->getCamera();
 }
 
-void RWGame::render(float alpha, float time)
-{
-	lastDraws = getRenderer()->getRenderer()->getDrawCount();
-	
-	getRenderer()->getRenderer()->swap();
+void RWGame::render(float alpha, float time) {
+    lastDraws = getRenderer()->getRenderer()->getDrawCount();
 
-	glm::ivec2 windowSize = window->getSize();
-	renderer->setViewport(windowSize.x, windowSize.y);
+    getRenderer()->getRenderer()->swap();
 
-	ViewCamera viewCam;
-	viewCam.frustum.fov = glm::radians(90.f);
-	if( state->currentCutscene != nullptr && state->cutsceneStartTime >= 0.f )
-	{
-		auto cutscene = state->currentCutscene;
-		float cutsceneTime = std::min(world->getGameTime() - state->cutsceneStartTime,
-									  cutscene->tracks.duration);
-		cutsceneTime += GAME_TIMESTEP * alpha;
-		glm::vec3 cameraPos = cutscene->tracks.getPositionAt(cutsceneTime),
-		targetPos = cutscene->tracks.getTargetAt(cutsceneTime);
-		float zoom = cutscene->tracks.getZoomAt(cutsceneTime);
-		viewCam.frustum.fov = glm::radians(zoom);
-		float tilt = cutscene->tracks.getRotationAt(cutsceneTime);
+    glm::ivec2 windowSize = window->getSize();
+    renderer->setViewport(windowSize.x, windowSize.y);
 
-		auto direction = glm::normalize(targetPos - cameraPos);
-		auto right = glm::normalize(glm::cross(glm::vec3(0.f, 0.f, 1.f), direction));
-		auto up = glm::normalize(glm::cross(direction, right));
+    ViewCamera viewCam;
+    viewCam.frustum.fov = glm::radians(90.f);
+    if (state->currentCutscene != nullptr && state->cutsceneStartTime >= 0.f) {
+        auto cutscene = state->currentCutscene;
+        float cutsceneTime =
+            std::min(world->getGameTime() - state->cutsceneStartTime,
+                     cutscene->tracks.duration);
+        cutsceneTime += GAME_TIMESTEP * alpha;
+        glm::vec3 cameraPos = cutscene->tracks.getPositionAt(cutsceneTime),
+                  targetPos = cutscene->tracks.getTargetAt(cutsceneTime);
+        float zoom = cutscene->tracks.getZoomAt(cutsceneTime);
+        viewCam.frustum.fov = glm::radians(zoom);
+        float tilt = cutscene->tracks.getRotationAt(cutsceneTime);
 
-		glm::mat3 m;
-		m[0][0] = direction.x;
-		m[0][1] = right.x;
-		m[0][2] = up.x;
+        auto direction = glm::normalize(targetPos - cameraPos);
+        auto right =
+            glm::normalize(glm::cross(glm::vec3(0.f, 0.f, 1.f), direction));
+        auto up = glm::normalize(glm::cross(direction, right));
 
-		m[1][0] = direction.y;
-		m[1][1] = right.y;
-		m[1][2] = up.y;
+        glm::mat3 m;
+        m[0][0] = direction.x;
+        m[0][1] = right.x;
+        m[0][2] = up.x;
 
-		m[2][0] = direction.z;
-		m[2][1] = right.z;
-		m[2][2] = up.z;
+        m[1][0] = direction.y;
+        m[1][1] = right.y;
+        m[1][2] = up.y;
 
-		auto qtilt = glm::angleAxis(glm::radians(tilt), direction);
+        m[2][0] = direction.z;
+        m[2][1] = right.z;
+        m[2][2] = up.z;
 
-		cameraPos += cutscene->meta.sceneOffset;
-		targetPos += cutscene->meta.sceneOffset;
+        auto qtilt = glm::angleAxis(glm::radians(tilt), direction);
 
-		viewCam.position = cameraPos;
-		viewCam.rotation = glm::inverse(glm::quat_cast(m)) * qtilt;
-	}
-	else if( state->cameraFixed )
-	{
-		viewCam.position = state->cameraPosition;
-		viewCam.rotation = state->cameraRotation;
-	}
-	else
-	{
-		// There's no cutscene playing - use the camera returned by the State.
-		viewCam.position = glm::mix(lastCam.position, nextCam.position, alpha);
-		viewCam.rotation = glm::slerp(lastCam.rotation, nextCam.rotation, alpha);
-	}
+        cameraPos += cutscene->meta.sceneOffset;
+        targetPos += cutscene->meta.sceneOffset;
 
-	viewCam.frustum.aspectRatio = windowSize.x / static_cast<float>(windowSize.y);
+        viewCam.position = cameraPos;
+        viewCam.rotation = glm::inverse(glm::quat_cast(m)) * qtilt;
+    } else if (state->cameraFixed) {
+        viewCam.position = state->cameraPosition;
+        viewCam.rotation = state->cameraRotation;
+    } else {
+        // There's no cutscene playing - use the camera returned by the State.
+        viewCam.position = glm::mix(lastCam.position, nextCam.position, alpha);
+        viewCam.rotation =
+            glm::slerp(lastCam.rotation, nextCam.rotation, alpha);
+    }
 
-	if ( state->isCinematic )
-	{
-		viewCam.frustum.fov *= viewCam.frustum.aspectRatio;
-	}
+    viewCam.frustum.aspectRatio =
+        windowSize.x / static_cast<float>(windowSize.y);
 
-	glEnable(GL_DEPTH_TEST);
-	glClear(GL_DEPTH_BUFFER_BIT|GL_COLOR_BUFFER_BIT);
+    if (state->isCinematic) {
+        viewCam.frustum.fov *= viewCam.frustum.aspectRatio;
+    }
 
-	renderer->getRenderer()->pushDebugGroup("World");
+    glEnable(GL_DEPTH_TEST);
+    glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);
 
-	RW_PROFILE_BEGIN("world");
-	renderer->renderWorld(world, viewCam, alpha);
-	RW_PROFILE_END();
+    renderer->getRenderer()->pushDebugGroup("World");
 
+    RW_PROFILE_BEGIN("world");
+    renderer->renderWorld(world, viewCam, alpha);
+    RW_PROFILE_END();
 
-	auto rendertime = renderer->getRenderer()->popDebugGroup();
+    auto rendertime = renderer->getRenderer()->popDebugGroup();
 
-	RW_PROFILE_BEGIN("debug");
-	if( showDebugPaths )
-	{
-		renderDebugPaths(time);
-	}
+    RW_PROFILE_BEGIN("debug");
+    if (showDebugPaths) {
+        renderDebugPaths(time);
+    }
 
-	if ( showDebugStats )
-	{
-		renderDebugStats(time, rendertime);
-	}
+    if (showDebugStats) {
+        renderDebugStats(time, rendertime);
+    }
 
-	if( showDebugPhysics )
-	{
-		if( world )
-		{
-			world->dynamicsWorld->debugDrawWorld();
-			debug->flush(renderer);
-		}
-	}
-	RW_PROFILE_END();
-	
-	drawOnScreenText(world, renderer);
+    if (showDebugPhysics) {
+        if (world) {
+            world->dynamicsWorld->debugDrawWorld();
+            debug->flush(renderer);
+        }
+    }
+    RW_PROFILE_END();
+
+    drawOnScreenText(world, renderer);
 }
 
-void RWGame::renderDebugStats(float time, Renderer::ProfileInfo& worldRenderTime)
-{
-	// Turn time into milliseconds
-	float time_ms = time * 1000.f;
-	constexpr size_t average_every_frame = 15;
-	static float times[average_every_frame];
-	static size_t times_index = 0;
-	static float time_average = 0;
-	times[times_index++] = time_ms;
-	if (times_index >= average_every_frame) {
-		times_index = 0;
-		time_average = 0;
+void RWGame::renderDebugStats(float time,
+                              Renderer::ProfileInfo& worldRenderTime) {
+    // Turn time into milliseconds
+    float time_ms = time * 1000.f;
+    constexpr size_t average_every_frame = 15;
+    static float times[average_every_frame];
+    static size_t times_index = 0;
+    static float time_average = 0;
+    times[times_index++] = time_ms;
+    if (times_index >= average_every_frame) {
+        times_index = 0;
+        time_average = 0;
 
-		for (size_t i = 0; i < average_every_frame; ++i) {
-			time_average += times[i];
-		}
-		time_average /= average_every_frame;
-	}
+        for (size_t i = 0; i < average_every_frame; ++i) {
+            time_average += times[i];
+        }
+        time_average /= average_every_frame;
+    }
 
-	std::map<std::string, Renderer::ProfileInfo*> profGroups {
-		{"Objects", &renderer->profObjects},
-		{"Effects", &renderer->profEffects},
-		{"Sky", &renderer->profSky},
-		{"Water", &renderer->profWater},
-	};
+    std::map<std::string, Renderer::ProfileInfo*> profGroups{
+        {"Objects", &renderer->profObjects},
+        {"Effects", &renderer->profEffects},
+        {"Sky", &renderer->profSky},
+        {"Water", &renderer->profWater},
+    };
 
-	std::stringstream ss;
-	ss << "Frametime: " << time_ms << " (FPS " << (1.f/time) << ")\n";
-	ss << "Average (per " << average_every_frame << " frames); Frametime: " << time_average << " (FPS " << (1000.f/time_average) << ")\n";
-	ss << "Draws: " << lastDraws << " (" << renderer->culled << " Culls)\n";
-	ss << " Texture binds: " << renderer->getRenderer()->getTextureCount() << "\n";
-	ss << " Buffer binds: " << renderer->getRenderer()->getBufferCount() << "\n";
-	ss << " World time: " << (worldRenderTime.duration/1000000) << "ms\n";
-	for(auto& perf : profGroups)
-	{
-		ss << "  " << perf.first << ": "
-		<< perf.second->draws << " draws " << perf.second->primitives << " prims "
-		<< (perf.second->duration/1000000) << "ms\n";
-	}
-	
-	// Count the number of interesting objects.
-	int peds = 0, cars = 0;
-	for( auto& object : world->allObjects )
-	{
-		switch ( object->type() )
-		{
-			case GameObject::Character: peds++; break;
-			case GameObject::Vehicle: cars++; break;
-			default: break;
-		}
-	}
-	
-	ss << "P " << peds << " V " << cars << "\n";
-	
-	if( state->playerObject ) {
-		ss << "Player (" << state->playerObject << ")\n";
-		auto object = world->pedestrianPool.find(state->playerObject);
-		auto player = static_cast<CharacterObject*>(object)->controller;
-		ss << "Player Activity: ";
-		if( player->getCurrentActivity() ) {
-			ss << player->getCurrentActivity()->name();
-		}
-		else {
-			ss << "Idle";
-		}
-		ss << std::endl;
-	}
-	
-	TextRenderer::TextInfo ti;
-	ti.text = GameStringUtil::fromString(ss.str());
-	ti.font = 2;
-	ti.screenPosition = glm::vec2( 10.f, 10.f );
-	ti.size = 15.f;
-	ti.baseColour = glm::u8vec3(255);
-	renderer->text.renderText(ti);
+    std::stringstream ss;
+    ss << "Frametime: " << time_ms << " (FPS " << (1.f / time) << ")\n";
+    ss << "Average (per " << average_every_frame
+       << " frames); Frametime: " << time_average << " (FPS "
+       << (1000.f / time_average) << ")\n";
+    ss << "Draws: " << lastDraws << " (" << renderer->culled << " Culls)\n";
+    ss << " Texture binds: " << renderer->getRenderer()->getTextureCount()
+       << "\n";
+    ss << " Buffer binds: " << renderer->getRenderer()->getBufferCount()
+       << "\n";
+    ss << " World time: " << (worldRenderTime.duration / 1000000) << "ms\n";
+    for (auto& perf : profGroups) {
+        ss << "  " << perf.first << ": " << perf.second->draws << " draws "
+           << perf.second->primitives << " prims "
+           << (perf.second->duration / 1000000) << "ms\n";
+    }
 
-	/*while( engine->log.size() > 0 && engine->log.front().time + 10.f < engine->gameTime ) {
-		engine->log.pop_front();
-	}
+    // Count the number of interesting objects.
+    int peds = 0, cars = 0;
+    for (auto& object : world->allObjects) {
+        switch (object->type()) {
+            case GameObject::Character:
+                peds++;
+                break;
+            case GameObject::Vehicle:
+                cars++;
+                break;
+            default:
+                break;
+        }
+    }
 
-	ti.screenPosition = glm::vec2( 10.f, 500.f );
-	ti.size = 15.f;
-	for(auto it = engine->log.begin(); it != engine->log.end(); ++it) {
-		ti.text = it->message;
-		switch(it->type) {
-		case GameWorld::LogEntry::Error:
-			ti.baseColour = glm::vec3(1.f, 0.f, 0.f);
-			break;
-		case GameWorld::LogEntry::Warning:
-			ti.baseColour = glm::vec3(1.f, 1.f, 0.f);
-			break;
-		default:
-			ti.baseColour = glm::vec3(1.f, 1.f, 1.f);
-			break;
-		}
+    ss << "P " << peds << " V " << cars << "\n";
 
-		// Interpolate the color
-		// c.a = (engine->gameTime - it->time > 5.f) ? 255 - (((engine->gameTime - it->time) - 5.f)/5.f) * 255 : 255;
-		// text.setColor(c);
+    if (state->playerObject) {
+        ss << "Player (" << state->playerObject << ")\n";
+        auto object = world->pedestrianPool.find(state->playerObject);
+        auto player = static_cast<CharacterObject*>(object)->controller;
+        ss << "Player Activity: ";
+        if (player->getCurrentActivity()) {
+            ss << player->getCurrentActivity()->name();
+        } else {
+            ss << "Idle";
+        }
+        ss << std::endl;
+    }
 
-		engine->renderer.text.renderText(ti);
-		ti.screenPosition.y -= ti.size;
-	}*/
+    TextRenderer::TextInfo ti;
+    ti.text = GameStringUtil::fromString(ss.str());
+    ti.font = 2;
+    ti.screenPosition = glm::vec2(10.f, 10.f);
+    ti.size = 15.f;
+    ti.baseColour = glm::u8vec3(255);
+    renderer->text.renderText(ti);
+
+    /*while( engine->log.size() > 0 && engine->log.front().time + 10.f <
+    engine->gameTime ) {
+        engine->log.pop_front();
+    }
+
+    ti.screenPosition = glm::vec2( 10.f, 500.f );
+    ti.size = 15.f;
+    for(auto it = engine->log.begin(); it != engine->log.end(); ++it) {
+        ti.text = it->message;
+        switch(it->type) {
+        case GameWorld::LogEntry::Error:
+            ti.baseColour = glm::vec3(1.f, 0.f, 0.f);
+            break;
+        case GameWorld::LogEntry::Warning:
+            ti.baseColour = glm::vec3(1.f, 1.f, 0.f);
+            break;
+        default:
+            ti.baseColour = glm::vec3(1.f, 1.f, 1.f);
+            break;
+        }
+
+        // Interpolate the color
+        // c.a = (engine->gameTime - it->time > 5.f) ? 255 - (((engine->gameTime
+    - it->time) - 5.f)/5.f) * 255 : 255;
+        // text.setColor(c);
+
+        engine->renderer.text.renderText(ti);
+        ti.screenPosition.y -= ti.size;
+    }*/
 }
 
-void RWGame::renderDebugPaths(float time)
-{
-	RW_UNUSED(time);
+void RWGame::renderDebugPaths(float time) {
+    RW_UNUSED(time);
 
-	btVector3 roadColour(1.f, 0.f, 0.f);
-	btVector3 pedColour(0.f, 0.f, 1.f);
-	
-	for( AIGraphNode* n : world->aigraph.nodes )
-	{
-		btVector3 p( n->position.x, n->position.y, n->position.z );
-		auto& col = n->type == AIGraphNode::Pedestrian ? pedColour : roadColour;
-		debug->drawLine( p - btVector3(0.f, 0.f, 1.f), p + btVector3(0.f, 0.f, 1.f), col);
-		debug->drawLine( p - btVector3(1.f, 0.f, 0.f), p + btVector3(1.f, 0.f, 0.f), col);
-		debug->drawLine( p - btVector3(0.f, 1.f, 0.f), p + btVector3(0.f, 1.f, 0.f), col);
+    btVector3 roadColour(1.f, 0.f, 0.f);
+    btVector3 pedColour(0.f, 0.f, 1.f);
 
-		for( AIGraphNode* c : n->connections )
-		{
-			btVector3 f( c->position.x, c->position.y, c->position.z );
-			debug->drawLine( p, f, col);
-		}
-	}
+    for (AIGraphNode* n : world->aigraph.nodes) {
+        btVector3 p(n->position.x, n->position.y, n->position.z);
+        auto& col = n->type == AIGraphNode::Pedestrian ? pedColour : roadColour;
+        debug->drawLine(p - btVector3(0.f, 0.f, 1.f),
+                        p + btVector3(0.f, 0.f, 1.f), col);
+        debug->drawLine(p - btVector3(1.f, 0.f, 0.f),
+                        p + btVector3(1.f, 0.f, 0.f), col);
+        debug->drawLine(p - btVector3(0.f, 1.f, 0.f),
+                        p + btVector3(0.f, 1.f, 0.f), col);
 
-	// Draw Garage bounds
-	for(size_t g = 0; g < state->garages.size(); ++g) {
-		auto& garage = state->garages[g];
-		btVector3 minColor(1.f, 0.f, 0.f);
-		btVector3 maxColor(0.f, 1.f, 0.f);
-		btVector3 min(garage.min.x,garage.min.y,garage.min.z);
-		btVector3 max(garage.max.x,garage.max.y,garage.max.z);
-		debug->drawLine(min, min + btVector3(0.5f, 0.f, 0.f), minColor);
-		debug->drawLine(min, min + btVector3(0.f, 0.5f, 0.f), minColor);
-		debug->drawLine(min, min + btVector3(0.f, 0.f, 0.5f), minColor);
-		
-		debug->drawLine(max, max - btVector3(0.5f, 0.f, 0.f), maxColor);
-		debug->drawLine(max, max - btVector3(0.f, 0.5f, 0.f), maxColor);
-		debug->drawLine(max, max - btVector3(0.f, 0.f, 0.5f), maxColor);
-	}
+        for (AIGraphNode* c : n->connections) {
+            btVector3 f(c->position.x, c->position.y, c->position.z);
+            debug->drawLine(p, f, col);
+        }
+    }
 
-	// Draw vehicle generators
-	for(size_t v = 0; v < state->vehicleGenerators.size(); ++v) {
-		auto& generator = state->vehicleGenerators[v];
-		btVector3 color(1.f, 0.f, 0.f);
-		btVector3 position(generator.position.x,generator.position.y,generator.position.z);
-		float heading = glm::radians(generator.heading);
-		auto back  = btVector3(0.f,-1.f, 0.f).rotate(btVector3(0.f, 0.f, 1.f), heading);
-		auto right = btVector3(0.15f, -0.15f, 0.f).rotate(btVector3(0.f, 0.f, 1.f), heading);
-		auto left  = btVector3(-0.15f,-0.15f, 0.f).rotate(btVector3(0.f, 0.f, 1.f), heading);
-		debug->drawLine(position, position+back, color);
-		debug->drawLine(position, position+right, color);
-		debug->drawLine(position, position+left, color);
-	}
+    // Draw Garage bounds
+    for (size_t g = 0; g < state->garages.size(); ++g) {
+        auto& garage = state->garages[g];
+        btVector3 minColor(1.f, 0.f, 0.f);
+        btVector3 maxColor(0.f, 1.f, 0.f);
+        btVector3 min(garage.min.x, garage.min.y, garage.min.z);
+        btVector3 max(garage.max.x, garage.max.y, garage.max.z);
+        debug->drawLine(min, min + btVector3(0.5f, 0.f, 0.f), minColor);
+        debug->drawLine(min, min + btVector3(0.f, 0.5f, 0.f), minColor);
+        debug->drawLine(min, min + btVector3(0.f, 0.f, 0.5f), minColor);
 
-	debug->flush(renderer);
+        debug->drawLine(max, max - btVector3(0.5f, 0.f, 0.f), maxColor);
+        debug->drawLine(max, max - btVector3(0.f, 0.5f, 0.f), maxColor);
+        debug->drawLine(max, max - btVector3(0.f, 0.f, 0.5f), maxColor);
+    }
+
+    // Draw vehicle generators
+    for (size_t v = 0; v < state->vehicleGenerators.size(); ++v) {
+        auto& generator = state->vehicleGenerators[v];
+        btVector3 color(1.f, 0.f, 0.f);
+        btVector3 position(generator.position.x, generator.position.y,
+                           generator.position.z);
+        float heading = glm::radians(generator.heading);
+        auto back =
+            btVector3(0.f, -1.f, 0.f).rotate(btVector3(0.f, 0.f, 1.f), heading);
+        auto right = btVector3(0.15f, -0.15f, 0.f)
+                         .rotate(btVector3(0.f, 0.f, 1.f), heading);
+        auto left = btVector3(-0.15f, -0.15f, 0.f)
+                        .rotate(btVector3(0.f, 0.f, 1.f), heading);
+        debug->drawLine(position, position + back, color);
+        debug->drawLine(position, position + right, color);
+        debug->drawLine(position, position + left, color);
+    }
+
+    debug->flush(renderer);
 }
 
-void RWGame::renderProfile()
-{
+void RWGame::renderProfile() {
 #if RW_PROFILER
-	auto& frame = perf::Profiler::get().getFrame();
-	constexpr float upperlimit = 30000.f;
-	constexpr float lineHeight = 15.f;
-	static std::vector<glm::vec4> perf_colours;
-	if (perf_colours.size() == 0) {
-		float c = 8.f;
-		for (int r = 0; r < c; ++r) {
-			for (int g = 0; g < c; ++g) {
-				for (int b = 0; b < c; ++b) {
-					perf_colours.push_back({
-											   r / c, g / c, b / c, 1.f
-										   });
-				}
-			}
-		}
-	}
+    auto& frame = perf::Profiler::get().getFrame();
+    constexpr float upperlimit = 30000.f;
+    constexpr float lineHeight = 15.f;
+    static std::vector<glm::vec4> perf_colours;
+    if (perf_colours.size() == 0) {
+        float c = 8.f;
+        for (int r = 0; r < c; ++r) {
+            for (int g = 0; g < c; ++g) {
+                for (int b = 0; b < c; ++b) {
+                    perf_colours.push_back({r / c, g / c, b / c, 1.f});
+                }
+            }
+        }
+    }
 
-
-	float xscale = renderer->getRenderer()->getViewport().x / upperlimit;
-	TextRenderer::TextInfo ti;
-	ti.align = TextRenderer::TextInfo::Left;
-	ti.font = 2;
-	ti.size = lineHeight - 2.f;
-	ti.baseColour = glm::u8vec3(255);
-	std::function<void(const perf::ProfileEntry&,int)> renderEntry = [&](const perf::ProfileEntry& entry, int depth)
-	{
-		int g = 0;
-		for(auto& event : entry.childProfiles)
-		{
-			auto duration = event.end - event.start;
-			float y = 60.f + (depth * (lineHeight + 5.f));
-			renderer->drawColour(perf_colours[(std::hash<std::string>()(entry.label) * (g++))%perf_colours.size()],
-			{
-				xscale * event.start,
-				y,
-				xscale * duration,
-				lineHeight
-			});
-			ti.screenPosition.x = xscale * (event.start);
-			ti.screenPosition.y = y + 2.f;
-			ti.text = event.label + " " + std::to_string(duration) + " us ";
-			renderer->text.renderText(ti);
-			renderEntry(event, depth+1);
-		}
-	};
-	renderEntry(frame, 0);
-	ti.screenPosition = glm::vec2( xscale * (16000), 40.f);
-	ti.text = ".16 ms";
-	renderer->text.renderText(ti);
+    float xscale = renderer->getRenderer()->getViewport().x / upperlimit;
+    TextRenderer::TextInfo ti;
+    ti.align = TextRenderer::TextInfo::Left;
+    ti.font = 2;
+    ti.size = lineHeight - 2.f;
+    ti.baseColour = glm::u8vec3(255);
+    std::function<void(const perf::ProfileEntry&, int)> renderEntry = [&](
+        const perf::ProfileEntry& entry, int depth) {
+        int g = 0;
+        for (auto& event : entry.childProfiles) {
+            auto duration = event.end - event.start;
+            float y = 60.f + (depth * (lineHeight + 5.f));
+            renderer->drawColour(
+                perf_colours[(std::hash<std::string>()(entry.label) * (g++)) %
+                             perf_colours.size()],
+                {xscale * event.start, y, xscale * duration, lineHeight});
+            ti.screenPosition.x = xscale * (event.start);
+            ti.screenPosition.y = y + 2.f;
+            ti.text = event.label + " " + std::to_string(duration) + " us ";
+            renderer->text.renderText(ti);
+            renderEntry(event, depth + 1);
+        }
+    };
+    renderEntry(frame, 0);
+    ti.screenPosition = glm::vec2(xscale * (16000), 40.f);
+    ti.text = ".16 ms";
+    renderer->text.renderText(ti);
 #endif
 }
 
-void RWGame::globalKeyEvent(const SDL_Event& event)
-{
-	switch (event.key.keysym.sym) {
-	case SDLK_LEFTBRACKET:
-		world->offsetGameTime(-30);
-		break;
-	case SDLK_RIGHTBRACKET:
-		world->offsetGameTime(30);
-		break;
-	case SDLK_9:
-		timescale *= 0.5f;
-		break;
-	case SDLK_0:
-		timescale *= 2.0f;
-		break;
-	case SDLK_F1:
-		showDebugStats = ! showDebugStats;
-		break;
-	case SDLK_F2:
-		showDebugPaths = ! showDebugPaths;
-		break;
-	case SDLK_F3:
-		showDebugPhysics = ! showDebugPhysics;
-		break;
-	default: break;
-	}
+void RWGame::globalKeyEvent(const SDL_Event& event) {
+    switch (event.key.keysym.sym) {
+        case SDLK_LEFTBRACKET:
+            world->offsetGameTime(-30);
+            break;
+        case SDLK_RIGHTBRACKET:
+            world->offsetGameTime(30);
+            break;
+        case SDLK_9:
+            timescale *= 0.5f;
+            break;
+        case SDLK_0:
+            timescale *= 2.0f;
+            break;
+        case SDLK_F1:
+            showDebugStats = !showDebugStats;
+            break;
+        case SDLK_F2:
+            showDebugPaths = !showDebugPaths;
+            break;
+        case SDLK_F3:
+            showDebugPhysics = !showDebugPhysics;
+            break;
+        default:
+            break;
+    }
 
-	std::string keyName = SDL_GetKeyName(event.key.keysym.sym);
-	if (keyName.length() == 1) {
-		char symbol = keyName[0];
-		handleCheatInput(symbol);
-	}
+    std::string keyName = SDL_GetKeyName(event.key.keysym.sym);
+    if (keyName.length() == 1) {
+        char symbol = keyName[0];
+        handleCheatInput(symbol);
+    }
 }
diff --git a/rwgame/RWGame.hpp b/rwgame/RWGame.hpp
index 2ac6ac09..34bf8e4f 100644
--- a/rwgame/RWGame.hpp
+++ b/rwgame/RWGame.hpp
@@ -1,12 +1,12 @@
 #ifndef _RWGAME_HPP_
 #define _RWGAME_HPP_
 
+#include <chrono>
 #include <core/Logger.hpp>
 #include <engine/GameData.hpp>
 #include <engine/GameWorld.hpp>
 #include <render/GameRenderer.hpp>
 #include <script/ScriptMachine.hpp>
-#include <chrono>
 #include "game.hpp"
 
 #include "GameConfig.hpp"
@@ -16,131 +16,128 @@
 
 class PlayerController;
 
-class RWGame
-{
-	Logger log;
-	GameConfig config {"openrw.ini"};
-	GameState* state = nullptr;
-	GameData* data = nullptr;
-	GameWorld* world = nullptr;
-	// must be allocated after Logger setup.
-	GameRenderer* renderer = nullptr;
+class RWGame {
+    Logger log;
+    GameConfig config{"openrw.ini"};
+    GameState* state = nullptr;
+    GameData* data = nullptr;
+    GameWorld* world = nullptr;
+    // must be allocated after Logger setup.
+    GameRenderer* renderer = nullptr;
     ScriptMachine* script = nullptr;
-	GameWindow *window = nullptr;
-	// Background worker
-	WorkContext *work = nullptr;
-	std::chrono::steady_clock clock;
-	std::chrono::steady_clock::time_point last_clock_time;
+    GameWindow* window = nullptr;
+    // Background worker
+    WorkContext* work = nullptr;
+    std::chrono::steady_clock clock;
+    std::chrono::steady_clock::time_point last_clock_time;
 
-	bool inFocus = true;
-	ViewCamera lastCam, nextCam;
-	bool showDebugStats = false;
-	bool showDebugPaths = false;
-	bool showDebugPhysics = false;
-	int lastDraws; /// Number of draws issued for the last frame.
+    bool inFocus = true;
+    ViewCamera lastCam, nextCam;
+    bool showDebugStats = false;
+    bool showDebugPaths = false;
+    bool showDebugPhysics = false;
+    int lastDraws;  /// Number of draws issued for the last frame.
 
-	std::string cheatInputWindow = std::string(32, ' ');
+    std::string cheatInputWindow = std::string(32, ' ');
+
+    float accum = 0.f;
+    float timescale = 1.f;
 
-	float accum = 0.f;
-	float timescale = 1.f;
 public:
+    RWGame(int argc, char* argv[]);
+    ~RWGame();
 
-	RWGame(int argc, char* argv[]);
-	~RWGame();
+    int run();
 
-	int run();
+    /**
+     * Initalizes a new game
+     */
+    void newGame();
 
-	/**
-	 * Initalizes a new game
-	 */
-	void newGame();
+    GameState* getState() const {
+        return state;
+    }
 
-	GameState* getState() const
-	{
-		return state;
-	}
+    GameWorld* getWorld() const {
+        return world;
+    }
 
-	GameWorld* getWorld() const
-	{
-		return world;
-	}
+    GameData* getGameData() const {
+        return data;
+    }
 
-	GameData* getGameData() const
-	{
-		return data;
-	}
+    GameRenderer* getRenderer() const {
+        return renderer;
+    }
 
-	GameRenderer* getRenderer() const
-	{
-		return renderer;
-	}
+    GameWindow& getWindow() {
+        return *window;
+    }
 
-	GameWindow& getWindow()
-	{
-		return *window;
-	}
+    ScriptMachine* getScript() const {
+        return script;
+    }
 
-	ScriptMachine* getScript() const
-	{
-		return script;
-	}
+    const GameConfig& getConfig() const {
+        return config;
+    }
 
-	const GameConfig& getConfig() const
-	{
-		return config;
-	}
+    bool hitWorldRay(glm::vec3& hit, glm::vec3& normal,
+                     GameObject** object = nullptr) {
+        auto vc = nextCam;
+        glm::vec3 from(vc.position.x, vc.position.y, vc.position.z);
+        glm::vec3 tmp = vc.rotation * glm::vec3(1000.f, 0.f, 0.f);
 
-	bool hitWorldRay(glm::vec3 &hit, glm::vec3 &normal, GameObject** object = nullptr)
-	{
-		auto vc = nextCam;
-		glm::vec3 from(vc.position.x, vc.position.y, vc.position.z);
-		glm::vec3 tmp = vc.rotation * glm::vec3(1000.f, 0.f, 0.f);
+        return hitWorldRay(from, tmp, hit, normal, object);
+    }
 
-		return hitWorldRay(from, tmp, hit, normal, object);
-	}
+    bool hitWorldRay(const glm::vec3& start, const glm::vec3& direction,
+                     glm::vec3& hit, glm::vec3& normal,
+                     GameObject** object = nullptr) {
+        auto from = btVector3(start.x, start.y, start.z);
+        auto to = btVector3(start.x + direction.x, start.y + direction.y,
+                            start.z + direction.z);
+        btCollisionWorld::ClosestRayResultCallback ray(from, to);
 
-	bool hitWorldRay(const glm::vec3 &start, const glm::vec3 &direction, glm::vec3 &hit, glm::vec3 &normal, GameObject **object = nullptr)
-	{
-		auto from = btVector3(start.x, start.y, start.z);
-		auto to = btVector3(start.x+direction.x, start.y+direction.y, start.z+direction.z);
-		btCollisionWorld::ClosestRayResultCallback ray(from, to);
+        world->dynamicsWorld->rayTest(from, to, ray);
+        if (ray.hasHit()) {
+            hit = glm::vec3(ray.m_hitPointWorld.x(), ray.m_hitPointWorld.y(),
+                            ray.m_hitPointWorld.z());
+            normal =
+                glm::vec3(ray.m_hitNormalWorld.x(), ray.m_hitNormalWorld.y(),
+                          ray.m_hitNormalWorld.z());
+            if (object) {
+                *object = static_cast<GameObject*>(
+                    ray.m_collisionObject->getUserPointer());
+            }
+            return true;
+        }
+        return false;
+    }
 
-		world->dynamicsWorld->rayTest(from, to, ray);
-		if( ray.hasHit() )
-		{
-			hit = glm::vec3(ray.m_hitPointWorld.x(), ray.m_hitPointWorld.y(),
-							ray.m_hitPointWorld.z());
-			normal = glm::vec3(ray.m_hitNormalWorld.x(), ray.m_hitNormalWorld.y(),
-							   ray.m_hitNormalWorld.z());
-			if(object) {
-				*object = static_cast<GameObject*>(ray.m_collisionObject->getUserPointer());
-			}
-			return true;
-		}
-		return false;
-	}
-	
-	void startScript(const std::string& name);
+    void startScript(const std::string& name);
 
-	bool hasFocus() const { return inFocus; }
+    bool hasFocus() const {
+        return inFocus;
+    }
 
-	void saveGame(const std::string& savename);
-	void loadGame(const std::string& savename);
+    void saveGame(const std::string& savename);
+    void loadGame(const std::string& savename);
 
-	/** shortcut for getWorld()->state.player->getCharacter() */
-	PlayerController* getPlayer();
+    /** shortcut for getWorld()->state.player->getCharacter() */
+    PlayerController* getPlayer();
 
 private:
-	void tick(float dt);
-	void render(float alpha, float dt);
-	
-	void renderDebugStats(float time, Renderer::ProfileInfo& worldRenderTime);
-	void renderDebugPaths(float time);
-	void renderProfile();
+    void tick(float dt);
+    void render(float alpha, float dt);
 
-	void handleCheatInput(char symbol);
+    void renderDebugStats(float time, Renderer::ProfileInfo& worldRenderTime);
+    void renderDebugPaths(float time);
+    void renderProfile();
 
-	void globalKeyEvent(const SDL_Event& event);
+    void handleCheatInput(char symbol);
+
+    void globalKeyEvent(const SDL_Event& event);
 };
 
 #endif
diff --git a/rwgame/State.cpp b/rwgame/State.cpp
index cd2fcc70..6be49c95 100644
--- a/rwgame/State.cpp
+++ b/rwgame/State.cpp
@@ -2,57 +2,53 @@
 #include "RWGame.hpp"
 
 // This serves as the "initial" camera position.
-ViewCamera defaultView({-250.f, -550.f, 75.f}, glm::angleAxis(glm::radians(5.f), glm::vec3(0.f, 1.f, 0.f)));
+ViewCamera defaultView({-250.f, -550.f, 75.f},
+                       glm::angleAxis(glm::radians(5.f),
+                                      glm::vec3(0.f, 1.f, 0.f)));
 
+void State::handleEvent(const SDL_Event& e) {
+    auto m = getCurrentMenu();
+    if (!m) return;
 
-void State::handleEvent(const SDL_Event& e)
-{
-	auto m = getCurrentMenu();
-	if(!m) return;
+    switch (e.type) {
+        case SDL_MOUSEBUTTONUP:
+            if (e.button.button == SDL_BUTTON_LEFT)
+                m->click(e.button.x, e.button.y);
+            break;
 
-	switch(e.type) {
-	case SDL_MOUSEBUTTONUP:
-		if (e.button.button == SDL_BUTTON_LEFT)
-			m->click(e.button.x, e.button.y);
-		break;
+        case SDL_MOUSEMOTION:
+            m->hover(e.motion.x, e.motion.y);
+            break;
 
-	case SDL_MOUSEMOTION:
-		m->hover(e.motion.x, e.motion.y);
-		break;
+        case SDL_KEYDOWN:
+            switch (e.key.keysym.sym) {
+                case SDLK_UP:
+                    m->move(-1);
+                    break;
 
-	case SDL_KEYDOWN:
-		switch (e.key.keysym.sym) {
-		case SDLK_UP:
-			m->move(-1);
-			break;
+                case SDLK_DOWN:
+                    m->move(1);
+                    break;
 
-		case SDLK_DOWN:
-			m->move(1);
-			break;
-
-		case SDLK_RETURN:
-			m->activate();
-			break;
-		}
-	}
+                case SDLK_RETURN:
+                    m->activate();
+                    break;
+            }
+    }
 }
 
-const ViewCamera& State::getCamera()
-{
-	return defaultView;
+const ViewCamera& State::getCamera() {
+    return defaultView;
 }
 
-bool State::shouldWorldUpdate()
-{
-	return false;
+bool State::shouldWorldUpdate() {
+    return false;
 }
 
-GameWorld* State::getWorld()
-{
-	return game->getWorld();
+GameWorld* State::getWorld() {
+    return game->getWorld();
 }
 
-GameWindow& State::getWindow()
-{
-	return game->getWindow();
+GameWindow& State::getWindow() {
+    return game->getWindow();
 }
diff --git a/rwgame/State.hpp b/rwgame/State.hpp
index ac1d0ba6..193cf000 100644
--- a/rwgame/State.hpp
+++ b/rwgame/State.hpp
@@ -1,123 +1,111 @@
 #ifndef _GAME_STATE_HPP_
 #define _GAME_STATE_HPP_
 #include <functional>
+#include <glm/gtc/quaternion.hpp>
 #include <queue>
 #include <render/ViewCamera.hpp>
+#include "GameWindow.hpp"
 #include "MenuSystem.hpp"
-#include <glm/gtc/quaternion.hpp>
 #include "SDL.h"
 #include "SDL_events.h"
-#include "GameWindow.hpp"
 
 class RWGame;
 class GameWorld;
 
-struct State
-{
-	// Helper for global menu behaviour
-	Menu* currentMenu;
-	Menu* nextMenu;
+struct State {
+    // Helper for global menu behaviour
+    Menu* currentMenu;
+    Menu* nextMenu;
 
-	RWGame* game;
-	
-	State(RWGame* game)
-	 : currentMenu(nullptr), nextMenu(nullptr), game(game) {}
-	
-	virtual void enter() = 0;
-	virtual void exit() = 0;
-	
-	virtual void tick(float dt) = 0;
-	
-	virtual void draw(GameRenderer* r)
-	{
-		if(getCurrentMenu()) {
-			getCurrentMenu()->draw(r);
-		}
-	}
-	
-	virtual ~State() {
-		if(getCurrentMenu()) {
-			delete getCurrentMenu();
-		}
-	}
-	
-	void enterMenu(Menu* menu)
-	{
-		nextMenu = menu;
-	}
-	
-	Menu* getCurrentMenu()
-	{
-		if(nextMenu) {
-			if(currentMenu) {
-				delete currentMenu;
-			}
-			currentMenu = nextMenu;
-			nextMenu = nullptr;
-		}
-		return currentMenu;
-	}
+    RWGame* game;
 
-	virtual void handleEvent(const SDL_Event& e);
+    State(RWGame* game) : currentMenu(nullptr), nextMenu(nullptr), game(game) {
+    }
 
-	virtual const ViewCamera& getCamera();
-	
-	/**
-	 * Returns false if the game world should not should
-	 * not update while this state is active
-	 */
-	virtual bool shouldWorldUpdate();
+    virtual void enter() = 0;
+    virtual void exit() = 0;
 
-	GameWorld* getWorld();
-	GameWindow& getWindow();
+    virtual void tick(float dt) = 0;
+
+    virtual void draw(GameRenderer* r) {
+        if (getCurrentMenu()) {
+            getCurrentMenu()->draw(r);
+        }
+    }
+
+    virtual ~State() {
+        if (getCurrentMenu()) {
+            delete getCurrentMenu();
+        }
+    }
+
+    void enterMenu(Menu* menu) {
+        nextMenu = menu;
+    }
+
+    Menu* getCurrentMenu() {
+        if (nextMenu) {
+            if (currentMenu) {
+                delete currentMenu;
+            }
+            currentMenu = nextMenu;
+            nextMenu = nullptr;
+        }
+        return currentMenu;
+    }
+
+    virtual void handleEvent(const SDL_Event& e);
+
+    virtual const ViewCamera& getCamera();
+
+    /**
+     * Returns false if the game world should not should
+     * not update while this state is active
+     */
+    virtual bool shouldWorldUpdate();
+
+    GameWorld* getWorld();
+    GameWindow& getWindow();
 };
 
-struct StateManager
-{
-	static StateManager& get()
-	{
-		static StateManager m;
-		return m;
-	}
-	
-	std::deque<State*> states;
+struct StateManager {
+    static StateManager& get() {
+        static StateManager m;
+        return m;
+    }
 
-	void clear()
-	{
-		states.clear();
-	}
-	
-	void enter(State* state)
-	{
-		states.push_back(state);
-		state->enter();
-	}
+    std::deque<State*> states;
 
-	void exec(State* state)
-	{
-		exit();
-		enter(state);
-	}
-	
-	void tick(float dt)
-	{
-		states.back()->tick(dt);
-	}
-	
-	void draw(GameRenderer* r)
-	{
-		states.back()->draw(r);
-	}
-	
-	void exit()
-	{
-		// TODO: Resole states being leaked.
-		states.back()->exit();
-		states.pop_back();
-		if(states.size() > 0) {
-			states.back()->enter();
-		}
-	}
+    void clear() {
+        states.clear();
+    }
+
+    void enter(State* state) {
+        states.push_back(state);
+        state->enter();
+    }
+
+    void exec(State* state) {
+        exit();
+        enter(state);
+    }
+
+    void tick(float dt) {
+        states.back()->tick(dt);
+    }
+
+    void draw(GameRenderer* r) {
+        states.back()->draw(r);
+    }
+
+    void exit() {
+        // TODO: Resole states being leaked.
+        states.back()->exit();
+        states.pop_back();
+        if (states.size() > 0) {
+            states.back()->enter();
+        }
+    }
 };
 
 #endif
diff --git a/rwgame/game.hpp b/rwgame/game.hpp
index 5cb6cc5d..fbc84506 100644
--- a/rwgame/game.hpp
+++ b/rwgame/game.hpp
@@ -1,20 +1,21 @@
 #ifndef GAME_HPP
 #define GAME_HPP
 
-#include <objects/GameObject.hpp>
 #include <engine/GameWorld.hpp>
+#include <objects/GameObject.hpp>
 
-constexpr double PiOver180 = 3.1415926535897932384626433832795028/180;
+constexpr double PiOver180 = 3.1415926535897932384626433832795028 / 180;
 
 // TODO: Move all of this stuff so it's not just lying around.
 
-bool hitWorldRay(glm::vec3& hit, glm::vec3& normal, GameObject** object = nullptr);
+bool hitWorldRay(glm::vec3& hit, glm::vec3& normal,
+                 GameObject** object = nullptr);
 bool hitWorldRay(const glm::vec3& start, const glm::vec3& direction,
-				 glm::vec3& hit, glm::vec3& normal, GameObject** object = nullptr);
+                 glm::vec3& hit, glm::vec3& normal,
+                 GameObject** object = nullptr);
 
-#define GAME_TIMESTEP (1.f/30.f)
+#define GAME_TIMESTEP (1.f / 30.f)
 #define GAME_WINDOW_WIDTH 800
 #define GAME_WINDOW_HEIGHT 600
 
-#endif // GAME_HPP
-
+#endif  // GAME_HPP
diff --git a/rwgame/main.cpp b/rwgame/main.cpp
index 88cdce1a..5501f742 100644
--- a/rwgame/main.cpp
+++ b/rwgame/main.cpp
@@ -1,35 +1,34 @@
+#include <iostream>
 #include "RWGame.hpp"
 #include "SDL.h"
-#include <iostream>
 
-int main(int argc, char* argv[])
-{
-	try {
-		RWGame game(argc, argv);
+int main(int argc, char* argv[]) {
+    try {
+        RWGame game(argc, argv);
 
-		return game.run();
-	} catch (std::invalid_argument& ex) {
-		// This exception is thrown when either an invalid command line option
-		// or a --help is found. The RWGame constructor prints a usage message
-		// in this case and then throws this exception.
-		return -2;
-	} catch (std::runtime_error& ex) {
-		// Catch runtime_error as these are fatal issues the user may want to
-		// know about like corrupted files or GL initialisation failure.
-		// Catching other types (out_of_range, bad_alloc) would just make
-		// debugging them more difficult.
+        return game.run();
+    } catch (std::invalid_argument& ex) {
+        // This exception is thrown when either an invalid command line option
+        // or a --help is found. The RWGame constructor prints a usage message
+        // in this case and then throws this exception.
+        return -2;
+    } catch (std::runtime_error& ex) {
+        // Catch runtime_error as these are fatal issues the user may want to
+        // know about like corrupted files or GL initialisation failure.
+        // Catching other types (out_of_range, bad_alloc) would just make
+        // debugging them more difficult.
 
-		const char* kErrorTitle = "Fatal Error";
+        const char* kErrorTitle = "Fatal Error";
 
-		std::cerr << kErrorTitle << "\n" << ex.what() << std::endl;
+        std::cerr << kErrorTitle << "\n" << ex.what() << std::endl;
 
-		if (SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, kErrorTitle,
-		                             ex.what(), NULL) < 0) {
-			SDL_Log("Failed to show message box\n");
-		}
+        if (SDL_ShowSimpleMessageBox(SDL_MESSAGEBOX_ERROR, kErrorTitle,
+                                     ex.what(), NULL) < 0) {
+            SDL_Log("Failed to show message box\n");
+        }
 
-		SDL_Quit();
+        SDL_Quit();
 
-		return -1;
-	}
+        return -1;
+    }
 }