From 43bbc9e21d5f0e4454d39a1dd4c1162935bdbf4a Mon Sep 17 00:00:00 2001
From: ethan <ethan.adams36@gmail.com>
Date: Tue, 22 Apr 2025 13:37:50 -0400
Subject: [PATCH] Preload scripts on boot and grab by ID for less file io
 operations + general cleanup

---
 Resources/monsters/shooty_peeps.xml           |    3 +
 Resources/scenes/debugScene.xml               |   11 +-
 Resources/scripts/ai_scripts.xml              |    4 +
 Resources/scripts/weapon_scripts.xml          |    3 +
 .../weapons/{bubblegun.xml => weapon_def.xml} |    2 +-
 .../include/utility/resourcemanager.h         |  115 +-
 YuppleMayham/include/utility/script.h         |   42 +-
 YuppleMayham/include/utility/xmlloader.h      |  348 ++---
 YuppleMayham/src/gameplay/scene.cpp           |    6 +-
 YuppleMayham/src/graphics/texture.cpp         |  242 ++--
 YuppleMayham/src/utility/resourcemanager.cpp  |  234 ++--
 YuppleMayham/src/utility/xmlloader.cpp        | 1187 ++++++++++-------
 12 files changed, 1195 insertions(+), 1002 deletions(-)
 create mode 100644 Resources/monsters/shooty_peeps.xml
 create mode 100644 Resources/scripts/ai_scripts.xml
 create mode 100644 Resources/scripts/weapon_scripts.xml
 rename Resources/weapons/{bubblegun.xml => weapon_def.xml} (96%)

diff --git a/Resources/monsters/shooty_peeps.xml b/Resources/monsters/shooty_peeps.xml
new file mode 100644
index 0000000..bad62c2
--- /dev/null
+++ b/Resources/monsters/shooty_peeps.xml
@@ -0,0 +1,3 @@
+
+<monster id="monster/shooty/bighead" anim="character/tmp" weapon="gun/pistol" aggressive="true" behaviour="script/behaviour/grunt" hp="10.0"/>
+<monster id="monster/shooty/clone" anim="character/player" weapon="gun/shotgun" aggressive="true" behaviour="script/behaviour/grunt" hp="15.0"/>
diff --git a/Resources/scenes/debugScene.xml b/Resources/scenes/debugScene.xml
index 39c9326..6b4ac64 100644
--- a/Resources/scenes/debugScene.xml
+++ b/Resources/scenes/debugScene.xml
@@ -3,20 +3,17 @@
 <scene type="shooter" id="000" bg="backgrounds/blue_sky.png">
   <map name="newmap"/>
   <entities>
-		<player x="7" y="5" weapon="gun/machine">
+		<player x="7" y="5" weapon="gun/shotgun">
 			<animation id="character/player"/>
     </player>
 		<entity x="10" y="3" weapon="gun/pistol">
 			<animation id="character/player"/>
-      <script file="scripts/ai/grunt_behaviour.lua"/>
+      <script id="script/behaviour/grunt"/>
     </entity>
 		<entity x="6" y="3" weapon="gun/pistol">
 			<animation id="character/tmp"/>
-      <script file="scripts/ai/grunt_behaviour.lua"/>
-    </entity>
-		<entity x="5" y="3" weapon="gun/pistol">
-			<animation id="character/tmp"/>
-      <script file="scripts/ai/grunt_behaviour.lua"/>
+      <script id="script/behaviour/grunt"/>
     </entity>
+    <entity x="5" y="3" weapon="gun/pistol" monster_id="monster/shooty/bighead"/>
   </entities>
 </scene>
diff --git a/Resources/scripts/ai_scripts.xml b/Resources/scripts/ai_scripts.xml
new file mode 100644
index 0000000..5640721
--- /dev/null
+++ b/Resources/scripts/ai_scripts.xml
@@ -0,0 +1,4 @@
+
+<!-- Shooter Scripts -->
+<script id="script/behaviour/grunt" file="scripts/ai/grunt_behaviour.lua"/>
+<script id="script/behaviour/scared" file="scripts/ai/scared_behaviour.lua"/>
diff --git a/Resources/scripts/weapon_scripts.xml b/Resources/scripts/weapon_scripts.xml
new file mode 100644
index 0000000..c090563
--- /dev/null
+++ b/Resources/scripts/weapon_scripts.xml
@@ -0,0 +1,3 @@
+
+<!-- Ranged weapon scripts -->
+<script id="script/weapon/shotgun" file="scripts/weapons/shotgun_script.lua"/>
diff --git a/Resources/weapons/bubblegun.xml b/Resources/weapons/weapon_def.xml
similarity index 96%
rename from Resources/weapons/bubblegun.xml
rename to Resources/weapons/weapon_def.xml
index e8a8492..b89c0de 100644
--- a/Resources/weapons/bubblegun.xml
+++ b/Resources/weapons/weapon_def.xml
@@ -12,7 +12,7 @@
   </weapon>
 
   <weapon id="gun/shotgun" fireSpeed="1750.0" maxAmmo="64" clipSize="4">
-    <script file="scripts/weapons/shotgun_script.lua"/>
+    <script id="script/weapon/shotgun"/>
 		<animation>
       <size x="55.0" y="55.0"/>
       <offset x="-30.0" y="0.0"/>
diff --git a/YuppleMayham/include/utility/resourcemanager.h b/YuppleMayham/include/utility/resourcemanager.h
index a5af8ac..6f38edc 100644
--- a/YuppleMayham/include/utility/resourcemanager.h
+++ b/YuppleMayham/include/utility/resourcemanager.h
@@ -1,77 +1,90 @@
 #ifndef _H_RESOURCEMANAGER_H
 #define _H_RESOURCEMANAGER_H
 
-#include <unordered_map>
 #include <memory>
 #include <string>
+#include <unordered_map>
 
-#include "sound/soundeffect.h"
-#include "utility/xmlloader.h"
+#include "graphics/background.h"
 #include "graphics/shader.h"
 #include "graphics/sprite.h"
-#include "graphics/background.h"
+#include "sound/soundeffect.h"
+#include "utility/script.h"
+#include "utility/xmlloader.h"
 #include <cassert>
 
 class Weapon;
-class Script;
 class AnimationSet;
-class AIScript;
-class WeaponScript;
 class SpriteComponent;
 
-class ResourceManager
-{
+class ResourceManager {
 public:
-	ResourceManager() : 
-		xmlLoader(std::make_shared<XMLLoader>()) 
-	{ 
-		xmlLoader->loadWeapons("weapons"); 
-		xmlLoader->loadAnimations("animations");
-		xmlLoader->loadTileSets("maps/tilesets");
-		xmlLoader->loadMaps("maps");
-		xmlLoader->loadScenes("scenes"); 
-		xmlLoader->loadSoundEffects("sounds");
-		shaders["__fallback__"] = std::make_unique<GenericShader>();
-	};
+  ResourceManager() : xmlLoader(std::make_shared<XMLLoader>()) {
+    xmlLoader->loadWeapons("weapons");
+    xmlLoader->loadAnimations("animations");
+    xmlLoader->loadMonsters("monsters");
+    xmlLoader->loadTileSets("maps/tilesets");
+    xmlLoader->loadMaps("maps");
+    xmlLoader->loadScripts("scripts", loadLuaString);
+    xmlLoader->loadScenes("scenes");
+    xmlLoader->loadSoundEffects("sounds");
+    shaders["__fallback__"] = std::make_unique<GenericShader>();
+  };
 
-	// Returns a NON-OWNING pointer to a sprite atlas
-	SpriteAtlas*									loadSpriteAtlas 		(const std::string& path, float frameSize, bool isDirectional = false);
-	// Returns a NON-OWNING pointer to a static sprite
-	Sprite*												loadSpriteStatic		(const std::string& path);
-	// Returns a NON-OWNING pointer to a background
-	Background*										loadBackground			(const std::string& path);
-	const unsigned								loadSoundEffect			(const std::string& id);
-	std::unique_ptr<AIScript>			loadAIScript				(const std::string& path);
-	std::unique_ptr<WeaponScript>	loadWeaponScript		(const std::string& path);
-	std::unique_ptr<Weapon>				loadWeapon					(const std::string& name, const unsigned weaponShaderID, const unsigned bulletShaderID);
-	std::shared_ptr<AnimationSet>	loadAnimationSet		(const std::string& name, int entityid = 0);
+  // Returns a NON-OWNING pointer to a sprite atlas
+  SpriteAtlas *loadSpriteAtlas(const std::string &path, float frameSize,
+                               bool isDirectional = false);
+  // Returns a NON-OWNING pointer to a static sprite
+  Sprite *loadSpriteStatic(const std::string &path);
+  // Returns a NON-OWNING pointer to a background
+  Background *loadBackground(const std::string &path);
+  const unsigned loadSoundEffect(const std::string &id);
+  template <typename T = Script>
+  std::unique_ptr<T> loadScript(const std::string &id);
+  std::unique_ptr<Weapon> loadWeapon(const std::string &name,
+                                     const unsigned weaponShaderID,
+                                     const unsigned bulletShaderID);
+  std::shared_ptr<AnimationSet> loadAnimationSet(const std::string &name,
+                                                 int entityid = 0);
 
-	const unsigned								loadShader					(const std::string& name, const std::string& vertexPath, const std::string& fragPath);
-	const SceneData*							loadScene						(const std::string& id);
-	const TileSetData*						loadTileSet					(const std::string& name);
+  const unsigned loadShader(const std::string &name,
+                            const std::string &vertexPath,
+                            const std::string &fragPath);
+  const SceneData *loadScene(const std::string &id);
+  const TileSetData *loadTileSet(const std::string &name);
 
-	// Returns a NON-OWNING pointer to a shader by ID
-	Shader*					 		getShaderByID(unsigned int ID);
+  // Returns a NON-OWNING pointer to a shader by ID
+  Shader *getShaderByID(unsigned int ID);
 
-	void clearResources();
+  void clearResources();
 
-	~ResourceManager();
+  ~ResourceManager();
 
 private:
-	std::unordered_map<std::string, std::unique_ptr<Shader>>			shaders;
-	std::unordered_map<unsigned, Shader*>													shaderIDs;
-	std::unordered_map<std::string, std::unique_ptr<SoundEffect>> sounds;
-	std::unordered_map<std::string, std::unique_ptr<Sprite>>			sprites;
-	//std::unordered_map<std::string, std::unique_ptr<Weapon>>			weapons;
-	//std::unordered_map<std::string, std::string>									scripts;
-	std::unordered_map<std::string, std::unique_ptr<Background>>	backgrounds;
-	std::unordered_map<std::string, std::shared_ptr<TileSetData>>	tileSets;
-	//std::unordered_map<std::string, std::shared_ptr<EntityData>> entityData;
-	//std::unordered_map<std::string, std::shared_ptr<SceneData>>	 scenes;
-	//std::unordered_map<std::string, std::shared_ptr<MapData>>	 maps;
-	//std::unordered_map<std::string, std::shared_ptr<TileType>>	 tiles;
+  std::unordered_map<std::string, std::unique_ptr<Shader>> shaders;
+  std::unordered_map<unsigned, Shader *> shaderIDs;
+  std::unordered_map<std::string, std::unique_ptr<SoundEffect>> sounds;
+  std::unordered_map<std::string, std::unique_ptr<Sprite>> sprites;
+  std::unordered_map<std::string, std::unique_ptr<Background>> backgrounds;
+  std::unordered_map<std::string, std::shared_ptr<TileSetData>> tileSets;
 
-	std::shared_ptr<XMLLoader> xmlLoader;
+  std::shared_ptr<XMLLoader> xmlLoader;
+
+  static bool loadLuaString(ScriptData *script);
 };
 
+template <typename T>
+std::unique_ptr<T> ResourceManager::loadScript(const std::string &id) {
+  const ScriptData *data = xmlLoader->getScriptData(id);
+  if (data == nullptr)
+    return nullptr;
+  try {
+    std::unique_ptr<T> script = std::make_unique<T>(data->script);
+    return std::move(script);
+  } catch (std::exception &e) {
+    LOG(ERROR, "Failed to load script '{}'", data->fileName);
+    return nullptr;
+  }
+}
+
 #endif // _H_RESOURCEMANAGER_H
diff --git a/YuppleMayham/include/utility/script.h b/YuppleMayham/include/utility/script.h
index 31c25fa..1121332 100644
--- a/YuppleMayham/include/utility/script.h
+++ b/YuppleMayham/include/utility/script.h
@@ -3,45 +3,45 @@
 
 #define SOL_ALL_SAFETIES_ON 1
 
-#include <sol/sol.hpp>
 #include <chrono>
 #include <memory>
+#include <sol/sol.hpp>
 
 class Script {
 public:
-	sol::state lua;
-	Script(const std::string& path);
-	~Script();
+  sol::state lua;
+  Script(const std::string &str);
+  ~Script();
+
 private:
-	bool loadScript(const std::string& path) {
-		auto result = lua.script_file(path);
-		if (!result.valid())
-		{
-			sol::error err = result;
-			std::cerr << "Failed to load script ( " << path << " ) Error: " << err.what() << std::endl;
-		}
-		return result.valid();
-	}
-	void registerGlobalUserTypes();
+  bool loadScript(const std::string &str) {
+    auto result = lua.script(str);
+    if (!result.valid()) {
+      sol::error err = result;
+      std::cerr << "Failed to load script. Error: " << err.what() << std::endl;
+    }
+    return result.valid();
+  }
+  void registerGlobalUserTypes();
 };
 
 class AIScript : public Script {
 public:
-	AIScript(const std::string& path) : Script(path) { registerUserTypes(); }
+  AIScript(const std::string &str) : Script(str) { registerUserTypes(); }
 
-	~AIScript();
+  ~AIScript();
 
 private:
-
-	void registerUserTypes() ;
+  void registerUserTypes();
 };
 
 class WeaponScript : public Script {
 public:
-	WeaponScript(const std::string& path) : Script(path) { registerUserTypes(); }
-	~WeaponScript();
+  WeaponScript(const std::string &str) : Script(str) { registerUserTypes(); }
+  ~WeaponScript();
+
 private:
-	void registerUserTypes() ;
+  void registerUserTypes();
 };
 
 #endif // _H_SCRIPT_H
diff --git a/YuppleMayham/include/utility/xmlloader.h b/YuppleMayham/include/utility/xmlloader.h
index 65882bc..f18bd5e 100644
--- a/YuppleMayham/include/utility/xmlloader.h
+++ b/YuppleMayham/include/utility/xmlloader.h
@@ -1,91 +1,103 @@
 #ifndef _H_XMLLOADER_H
 #define _H_XMLLOADER_H
 
-#include <vector>
-#include <string>
-#include <memory>
-#include <unordered_map>
+#include <functional>
 #include <glm/glm.hpp>
+#include <memory>
+#include <string>
+#include <unordered_map>
+#include <vector>
 
-#include <sstream>
-#include <fstream>
 #include <filesystem>
+#include <fstream>
+#include <sstream>
 #include <tinyxml2.h>
 
 struct Tile;
 
+// Except for the player, these definitions are mostly overrides of the monster
+// data
 struct EntityData {
-	bool isPlayer;
-	bool animated;
-	int x = 0, y = 0;
-	std::string graphic;
-	std::string weapon = "pistol";
-	std::string script;
+  bool isPlayer;
+  bool animated;
+  int x = 0, y = 0;
+  float hp;
+  std::string monsterDef;
+  std::string graphic;
+  std::string weapon = "gun/pistol";
+  std::string script;
 };
 
 struct MapData {
-	std::string name;
-	struct TileSet {
-		int startID = 1;
-		std::string path;
-	};
-	std::vector<TileSet> tileSets;
-	int width = 0, height = 0;
-	float tileSize = 32.f;
-	// 3D array, 0: layer, 1: y, 2: x
-	// Holding tile startID + ids, 0 is an empty tile
-	std::vector<std::vector<std::vector<int>>> tiles;
+  std::string name;
+  struct TileSet {
+    int startID = 1;
+    std::string path;
+  };
+  std::vector<TileSet> tileSets;
+  int width = 0, height = 0;
+  float tileSize = 32.f;
+  // 3D array, 0: layer, 1: y, 2: x
+  // Holding tile startID + ids, 0 is an empty tile
+  std::vector<std::vector<std::vector<int>>> tiles;
 };
 
 struct TileSetData {
-	std::string name;
-	std::string type;
-	std::string file;
-	int width = 0, height = 0;
-	int columns = 0;
-	int tileCount = 0;
-	float tileSize = 64.f;
-	struct TileData {
-		int id = 0;
-		std::string type;
-		bool walkable = true;
-		struct ObjectData {
-			int id = 0;
-			std::string name;
-			glm::vec2 pos;
-			glm::vec2 size;
-			bool collidable = false;
-			bool pickup = false;
-		};
-		std::vector<std::shared_ptr<ObjectData>> objects;
-	};
-	std::vector<std::shared_ptr<TileData>> tiles;
+  std::string name;
+  std::string type;
+  std::string file;
+  int width = 0, height = 0;
+  int columns = 0;
+  int tileCount = 0;
+  float tileSize = 64.f;
+  struct TileData {
+    int id = 0;
+    std::string type;
+    bool walkable = true;
+    struct ObjectData {
+      int id = 0;
+      std::string name;
+      glm::vec2 pos;
+      glm::vec2 size;
+      bool collidable = false;
+      bool pickup = false;
+    };
+    std::vector<std::shared_ptr<ObjectData>> objects;
+  };
+  std::vector<std::shared_ptr<TileData>> tiles;
 };
 
 struct SceneData {
-	std::string id;
-	std::string type;
-	std::string bgFile;
+  std::string id;
+  std::string type;
+  std::string bgFile;
 
-	const MapData* map;
-	std::vector<EntityData> entities;
+  const MapData *map;
+  std::vector<EntityData> entities;
+};
+
+// Store our script as a string so we only need to read the file at boot
+struct ScriptData {
+  std::string id;
+  std::string fileName;
+  std::string script;
 };
 
 struct WeaponData {
-	std::string id;
-	float fireSpeed = 250.0f;
-	int clipSize = 21;
-	int maxAmmo = 512;
-	std::string script = "";
-	std::string graphic;
-	bool animated = false;
-	float sizeX = 50.f, sizeY = 50.f;
-	float offsetX = 0.f, offsetY = 0.f;
-	float bulletSizeX = 50.f, bulletSizeY = 50.f;
-	std::string bulletGraphic;
-	bool bulletAnimated = false;
-	float bulletSpread = 1.0f, bulletSpeed = 3.0f, bulletDrop = 500.f;
-	float modMin = 0.5f, modMax = 1.0f;
+  std::string id;
+  float fireSpeed = 250.0f;
+  int clipSize = 21;
+  int maxAmmo = 512;
+  std::string script = "";
+  std::string graphic;
+  bool animated = false;
+  float sizeX = 50.f, sizeY = 50.f;
+  float offsetX = 0.f, offsetY = 0.f;
+  float bulletSizeX = 50.f, bulletSizeY = 50.f;
+  std::string bulletGraphic;
+  bool bulletAnimated = false;
+  float bulletSpread = 1.0f, bulletSpeed = 3.0f, bulletDrop = 500.f;
+  float modMin = 0.5f, modMax = 1.0f;
 };
 
 // ID is the new tactic I've decided on.
@@ -94,111 +106,141 @@ struct WeaponData {
 // This prefix will be used to look up the animation on
 // the animation map
 struct AnimationData {
-	std::string id;
-	std::string spriteAtlas;
-	bool directional = false;
-	bool oneShot;
-	float FPS = 1.f;
-	float frameSize;
+  std::string id;
+  std::string spriteAtlas;
+  bool directional = false;
+  bool oneShot;
+  float FPS = 1.f;
+  float frameSize;
+};
+
+// This holds a lot of defaults, but the scene can
+// override a large portion of the definitions here
+struct MonsterData {
+  std::string id;
+  std::string anim;
+  std::string weapon;
+  bool aggressive = false;
+  std::string behaviour;
+  float hp;
 };
 
 struct SoundData {
-	std::string id; // <type>/<object>/<state>
-	std::string path;
-	bool spatial;
+  std::string id; // <type>/<object>/<state>
+  std::string path;
+  bool spatial;
 };
 
-class XMLLoader
-{
+class XMLLoader {
 public:
-	XMLLoader() {}
-	bool loadScenes(const char* sceneFolder);
-	bool loadWeapons(const char* weaponFolder);
-	bool loadAnimations(const char* animationFolder);
-	bool loadTileSets(const char* tileSetFolder);
-	bool loadMaps(const char* mapFolder);
-	bool loadSoundEffects(const char* soundFolder);
+  XMLLoader() {}
+  bool loadScenes(const char *sceneFolder);
+  bool loadWeapons(const char *weaponFolder);
+  bool loadAnimations(const char *animationFolder);
+  bool loadTileSets(const char *tileSetFolder);
+  bool loadMaps(const char *mapFolder);
+  bool loadMonsters(const char *monsterFolder);
+  // luaLoader is the function we use to load the lua file.
+  // This will be defined in our resource manager
+  bool loadScripts(const char *scriptFolder,
+                   std::function<bool(ScriptData *)> luaLoader);
+  bool loadSoundEffects(const char *soundFolder);
 
-	const SceneData* getSceneData(const std::string& id) const { 
-		try {
-			return scenes.at(id).get();
-		}
-		catch (std::exception&) {
-			return nullptr;
-		}
-	}
+  const SceneData *getSceneData(const std::string &id) const {
+    try {
+      return scenes.at(id).get();
+    } catch (std::exception &) {
+      return nullptr;
+    }
+  }
 
-	const MapData* getMapData(const std::string& name) const {
-		try {
-			return maps.at(name).get();
-		}
-		catch (std::exception&) {
-			return nullptr;
-		}
-	}
+  const ScriptData *getScriptData(const std::string &id) const {
+    try {
+      return scripts.at(id).get();
+    } catch (std::exception &) {
+      return nullptr;
+    }
+  }
 
-	const WeaponData* getWeaponData(const std::string& id) const {
-		try {
-			return weapons.at(id).get();
-		}
-		catch (std::exception&) {
-			return nullptr;
-		}
-	}
+  const MapData *getMapData(const std::string &name) const {
+    try {
+      return maps.at(name).get();
+    } catch (std::exception &) {
+      return nullptr;
+    }
+  }
 
-	const AnimationData* getAnimationData(const std::string& id) const {
-		try {
-			return animations.at(id).get();
-		}
-		catch (std::exception&) {
-			return nullptr;
-		}
-	}
+  const WeaponData *getWeaponData(const std::string &id) const {
+    try {
+      return weapons.at(id).get();
+    } catch (std::exception &) {
+      return nullptr;
+    }
+  }
 
-	const TileSetData* getTileSetData(const std::string& name) const {
-		try {
-			return tileSets.at(name).get();
-		}
-		catch (std::exception&) {
-			return nullptr;
-		}
-	}
+  const AnimationData *getAnimationData(const std::string &id) const {
+    try {
+      return animations.at(id).get();
+    } catch (std::exception &) {
+      return nullptr;
+    }
+  }
 
-	const SoundData* getSoundData(const std::string& id) const {
-		try {
-			return sounds.at(id).get();
-		}
-		catch (std::exception&) {
-			return nullptr;
-		}
-	}
+  const TileSetData *getTileSetData(const std::string &name) const {
+    try {
+      return tileSets.at(name).get();
+    } catch (std::exception &) {
+      return nullptr;
+    }
+  }
 
-	// return a full set of animations, may need further optimization.
-	// one idea is when loading animations we create a seperate map that holds each set by their reference, so we can just do a simple,
-	// hash table lookup.
-	std::vector<AnimationData*> getAnimationSet(const std::string& prefix) const {
-		std::vector<AnimationData*> animSet;
-		animSet.reserve(animations.size());
-		for (const auto& [id, anim] : animations) {
-			if (id.starts_with(prefix)) animSet.push_back(anim.get());
-		}
-		animSet.shrink_to_fit();
-		return animSet;
-	}
+  const SoundData *getSoundData(const std::string &id) const {
+    try {
+      return sounds.at(id).get();
+    } catch (std::exception &) {
+      return nullptr;
+    }
+  }
+
+  // return a full set of animations, may need further optimization.
+  // one idea is when loading animations we create a seperate map that holds
+  // each set by their reference, so we can just do a simple, hash table lookup.
+  std::vector<AnimationData *>
+  getAnimationSet(const std::string &prefix) const {
+    std::vector<AnimationData *> animSet;
+    animSet.reserve(animations.size());
+    for (const auto &[id, anim] : animations) {
+      if (id.starts_with(prefix))
+        animSet.push_back(anim.get());
+    }
+    animSet.shrink_to_fit();
+    return animSet;
+  }
+
+  void clearData() {
+    scenes.clear();
+    weapons.clear();
+    animations.clear();
+    maps.clear();
+    tileSets.clear();
+  }
 
-	void clearData() { scenes.clear(); weapons.clear(); animations.clear(); maps.clear(); tileSets.clear(); }
 protected:
-	bool loadXmlScene(const char* xmlFile, SceneData* out);
-	bool loadEntityData(const char* xmlFile, SceneData* out);
-	bool loadTile(tinyxml2::XMLElement* tileElement, TileSetData::TileData* out);
-	bool loadObject(tinyxml2::XMLElement* objectElement, TileSetData::TileData::ObjectData* out);
+  bool loadXmlScene(const char *xmlFile, SceneData *out);
+  bool loadEntityData(const char *xmlFile, SceneData *out);
+  bool loadTile(tinyxml2::XMLElement *tileElement, TileSetData::TileData *out);
+  bool loadObject(tinyxml2::XMLElement *objectElement,
+                  TileSetData::TileData::ObjectData *out);
+
 private:
-	std::unordered_map<std::string, std::unique_ptr<SceneData>> scenes;
-	std::unordered_map<std::string, std::unique_ptr<WeaponData>> weapons;
-	std::unordered_map<std::string, std::unique_ptr<AnimationData>> animations;
-	std::unordered_map<std::string, std::unique_ptr<MapData>> maps;
-	std::unordered_map<std::string, std::unique_ptr<TileSetData>> tileSets;
-	std::unordered_map<std::string, std::unique_ptr<SoundData>> sounds;
+  std::unordered_map<std::string, std::unique_ptr<SceneData>> scenes;
+  std::unordered_map<std::string, std::unique_ptr<ScriptData>> scripts;
+  std::unordered_map<std::string, std::unique_ptr<WeaponData>> weapons;
+  std::unordered_map<std::string, std::unique_ptr<AnimationData>> animations;
+  std::unordered_map<std::string, std::unique_ptr<MonsterData>> monsters;
+  std::unordered_map<std::string, std::unique_ptr<MapData>> maps;
+  std::unordered_map<std::string, std::unique_ptr<TileSetData>> tileSets;
+  std::unordered_map<std::string, std::unique_ptr<SoundData>> sounds;
 };
 
 #endif // _H_XMLLOADER_H
diff --git a/YuppleMayham/src/gameplay/scene.cpp b/YuppleMayham/src/gameplay/scene.cpp
index 1b6484f..5332d69 100644
--- a/YuppleMayham/src/gameplay/scene.cpp
+++ b/YuppleMayham/src/gameplay/scene.cpp
@@ -101,12 +101,14 @@ void Scene::loadDebugShooterScene() {
     } else {
       // attach ai
       if (!entityData.script.empty()) {
-        auto behaviour = resourceManager->loadAIScript(entityData.script);
+        auto behaviour =
+            resourceManager->loadScript<AIScript>(entityData.script);
         auto rayCaster = std::make_unique<Raycaster>(
             40.f, 300.f, map->getCollisionMap(), mapData->tileSize);
         auto ai = std::make_shared<AI>(entity.get(), std::move(rayCaster));
         ai->setTarget(player.get());
-        ai->attachBehaviourScript(std::move(behaviour));
+        if (behaviour != nullptr)
+          ai->attachBehaviourScript(std::move(behaviour));
         entity->addComponent(std::make_unique<AIComponent>(ai));
       }
     }
diff --git a/YuppleMayham/src/graphics/texture.cpp b/YuppleMayham/src/graphics/texture.cpp
index b682b8f..a76b542 100644
--- a/YuppleMayham/src/graphics/texture.cpp
+++ b/YuppleMayham/src/graphics/texture.cpp
@@ -1,155 +1,129 @@
 #include "graphics/texture.h"
-#include "utility/logger.h"
 #include "util.h"
+#include "utility/logger.h"
 
-bool Texture::loadTexture(const char* imagePath)
-{
-	SDL_Surface* buffer = IMG_Load(imagePath);
-	if (!buffer)
-		ERROR_LOG("Failed to load image file: {}", imagePath);
-	//UTIL::flip_surface(buffer);
+bool Texture::loadTexture(const char *imagePath) {
+  SDL_Surface *buffer = IMG_Load(imagePath);
+  if (!buffer)
+    ERROR_LOG("Failed to load image file: {}", imagePath);
+  // UTIL::flip_surface(buffer);
 
-	glGenTextures(1, &ID);
-	/*
-	GLenum error = glGetError();
-	if(error != GL_NO_ERROR) {
-		std::cout << "OpenGL error: " << error << std::endl;
-	}
-	*/
+  glGenTextures(1, &ID);
+  /*
+  GLenum error = glGetError();
+  if(error != GL_NO_ERROR) {
+          std::cout << "OpenGL error: " << error << std::endl;
+  }
+  */
 
-	glBindTexture(GL_TEXTURE_2D, ID);
+  glBindTexture(GL_TEXTURE_2D, ID);
 
-	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, buffer->w, buffer->h, 0, GL_RGBA, GL_UNSIGNED_BYTE, buffer->pixels);
+  glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, buffer->w, buffer->h, 0, GL_RGBA,
+               GL_UNSIGNED_BYTE, buffer->pixels);
 
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-	glGenerateMipmap(ID);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_REPEAT);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_REPEAT);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+  glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+  glGenerateMipmap(ID);
 
-	textureWidth = buffer->w;
-	textureHeight = buffer->h;
+  textureWidth = buffer->w;
+  textureHeight = buffer->h;
 
-	SDL_FreeSurface(buffer);
+  SDL_FreeSurface(buffer);
 
-	return true;
+  return true;
 }
 
-void Texture::bind()
-{
-	glActiveTexture(GL_TEXTURE0);
-	glBindTexture(GL_TEXTURE_2D, ID);
+void Texture::bind() {
+  glActiveTexture(GL_TEXTURE0);
+  glBindTexture(GL_TEXTURE_2D, ID);
 }
 
+Texture::~Texture() { glDeleteTextures(1, &ID); }
 
-Texture::~Texture()
-{
-	glDeleteTextures(1, &ID);
+bool TextureArray::loadTextures(std::vector<const char *> imagePaths) {
+  std::vector<SDL_Surface *> surfaces;
+  surfaces.resize(imagePaths.size());
+  // Fill surfaces vector
+  for (int i = 0; i < imagePaths.size(); ++i) {
+    surfaces[i] = IMG_Load(imagePaths[i]);
+    if (!surfaces[i])
+      ERROR_LOG("Failed to load image file: {}", imagePaths[i]);
+  }
+  if (!adjustCanvasSizes(surfaces))
+    ERROR_LOG(
+        "Failed to adjust canvas size of images! \n Make sure to check that "
+        "every tileset has square dimensions! (512x512, 756x756 ... etc)",
+        NULL);
+  if (surfaces.empty())
+    ERROR_LOG("No surfaces created!", NULL);
+  numOfLayers = imagePaths.size();
+
+  glGenTextures(1, &ID);
+  glBindTexture(GL_TEXTURE_2D_ARRAY, ID);
+
+  // Creating the texture array all of our textures will live in.
+  // adjustCanvasSizes makes every image the same size, so we can just use the
+  // first surface in the list of surfaces
+  glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_RGBA, surfaces[0]->w, surfaces[0]->h,
+               (GLsizei)numOfLayers, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
+
+  for (int layer = 0; layer < numOfLayers; ++layer) {
+    glTexSubImage3D(GL_TEXTURE_2D_ARRAY, 0, 0, 0, layer, surfaces[layer]->w,
+                    surfaces[layer]->h, 1, GL_RGBA, GL_UNSIGNED_BYTE,
+                    surfaces[layer]->pixels);
+  }
+  glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_S, GL_REPEAT);
+  glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_T, GL_REPEAT);
+  glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+  glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+
+  glGenerateMipmap(GL_TEXTURE_2D_ARRAY);
+
+  for (auto &surface : surfaces)
+    SDL_FreeSurface(surface);
+  surfaces.clear();
+
+  return true;
 }
 
-bool TextureArray::loadTextures(std::vector<const char*> imagePaths)
-{
-	std::vector<SDL_Surface*> surfaces;
-	surfaces.resize(imagePaths.size());
-	// Fill surfaces vector
-	for (int i = 0; i < imagePaths.size(); ++i)
-	{
-		surfaces[i] = IMG_Load(imagePaths[i]);
-		if (!surfaces[i])
-			ERROR_LOG("Failed to load image file: {}", imagePaths[i]);
-	}
-	if (!adjustCanvasSizes(surfaces))
-		ERROR_LOG("Failed to adjust canvas size of images! \n Make sure to check that every tileset has square dimensions! (512x512, 756x756 ... etc)", NULL);
-	if (surfaces.empty())
-		ERROR_LOG("No surfaces created!", NULL);
-	numOfLayers = imagePaths.size();
-
-	glGenTextures(1, &ID);
-	glBindTexture(GL_TEXTURE_2D_ARRAY, ID);
-
-	// Creating the texture array all of our textures will live in.
-	// adjustCanvasSizes makes every image the same size, so we can just use the first 
-	// surface in the list of surfaces
-	glTexImage3D(GL_TEXTURE_2D_ARRAY,
-		0,
-		GL_RGBA,
-		surfaces[0]->w,
-		surfaces[0]->h,
-		(GLsizei)numOfLayers,
-		0,
-		GL_RGBA,
-		GL_UNSIGNED_BYTE,
-		nullptr);
-
-	for (int layer = 0; layer < numOfLayers; ++layer)
-	{
-		glTexSubImage3D(GL_TEXTURE_2D_ARRAY,
-			0,
-			0, 0, layer,
-			surfaces[layer]->w,
-			surfaces[layer]->h,
-			1,
-			GL_RGBA,
-			GL_UNSIGNED_BYTE,
-			surfaces[layer]->pixels);
-	}
-	glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_S, GL_REPEAT);
-	glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_T, GL_REPEAT);
-	glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-	glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-
-	glGenerateMipmap(GL_TEXTURE_2D_ARRAY);
-
-	for (auto& surface : surfaces)
-		SDL_FreeSurface(surface);
-	surfaces.clear();
-
-	return true;
+void TextureArray::bind() {
+  glActiveTexture(GL_TEXTURE0);
+  glBindTexture(GL_TEXTURE_2D_ARRAY, ID);
 }
 
-void TextureArray::bind()
-{
-	glActiveTexture(GL_TEXTURE0);
-	glBindTexture(GL_TEXTURE_2D_ARRAY, ID);
+bool TextureArray::adjustCanvasSizes(std::vector<SDL_Surface *> &surfaces) {
+  int maxWidth = 0;
+  int maxHeight = 0;
+  for (auto &surface : surfaces) {
+    if (surface->w != surface->h)
+      ERROR_LOG("Image must be a square!", NULL);
+
+    if (surface->w > maxWidth)
+      maxWidth = surface->w;
+    if (surface->h > maxHeight)
+      maxHeight = surface->h;
+    textures.push_back(TextureData({surface->w, surface->h}));
+  }
+  for (int i = 0; i < surfaces.size(); ++i) {
+    SDL_Surface *canvas = SDL_CreateRGBSurface(
+        0, maxWidth, maxHeight, surfaces[i]->format->BitsPerPixel,
+        surfaces[i]->format->Rmask, surfaces[i]->format->Gmask,
+        surfaces[i]->format->Bmask, surfaces[i]->format->Amask);
+
+    SDL_FillRect(canvas, NULL, SDL_MapRGBA(canvas->format, 0, 0, 0, 0));
+
+    SDL_BlitSurface(surfaces[i], NULL, canvas, NULL);
+
+    SDL_FreeSurface(surfaces[i]);
+    surfaces[i] = canvas;
+  }
+
+  canvasWidth = maxWidth;
+  canvasHeight = maxHeight;
+
+  return true;
 }
 
-bool TextureArray::adjustCanvasSizes(std::vector<SDL_Surface*>& surfaces)
-{
-	int maxWidth = 0;
-	int maxHeight = 0;
-	for (auto& surface : surfaces)
-	{
-		if (surface->w != surface->h)
-			ERROR_LOG("Image must be a square!", NULL);
-
-		if (surface->w > maxWidth) maxWidth = surface->w;
-		if (surface->h > maxHeight) maxHeight = surface->h;
-		textures.push_back(TextureData({ surface->w, surface->h }));
-	}
-	for (int i = 0; i < surfaces.size(); ++i)
-	{
-		SDL_Surface* canvas = SDL_CreateRGBSurface(0, maxWidth, maxHeight, 
-			surfaces[i]->format->BitsPerPixel,
-			surfaces[i]->format->Rmask,
-			surfaces[i]->format->Gmask,
-			surfaces[i]->format->Bmask,
-			surfaces[i]->format->Amask);
-
-		SDL_FillRect(canvas, NULL, SDL_MapRGBA(canvas->format, 0, 0, 0, 0));
-
-		SDL_BlitSurface(surfaces[i], NULL, canvas, NULL);
-
-		SDL_FreeSurface(surfaces[i]);
-		surfaces[i] = canvas;
-	}
-
-	canvasWidth = maxWidth;
-	canvasHeight = maxHeight;
-
-	return true;
-}
-
-TextureArray::~TextureArray()
-{
-	glDeleteTextures(1, &ID);
-}
+TextureArray::~TextureArray() { glDeleteTextures(1, &ID); }
diff --git a/YuppleMayham/src/utility/resourcemanager.cpp b/YuppleMayham/src/utility/resourcemanager.cpp
index 8f19ff9..1fa9851 100644
--- a/YuppleMayham/src/utility/resourcemanager.cpp
+++ b/YuppleMayham/src/utility/resourcemanager.cpp
@@ -1,149 +1,145 @@
 #include "utility/resourcemanager.h"
+#include "gameplay/weapons/weapons.h"
+#include "graphics/animation.h"
+#include "graphics/background.h"
+#include "graphics/shader.h"
 #include "graphics/sprite.h"
 #include "util.h"
 #include "utility/script.h"
-#include "graphics/shader.h"
-#include "graphics/animation.h"
-#include "graphics/background.h"
-#include "gameplay/weapons/weapons.h"
 
-SpriteAtlas* ResourceManager::loadSpriteAtlas(const std::string& path, float frameSize, bool isDirectional)
-{
-	auto iterator = sprites.find(path);
-	if (iterator != sprites.end())
-		return static_cast<SpriteAtlas*>(iterator->second.get());
-	auto sprite = std::make_unique<SpriteAtlas>(path.c_str(), frameSize, isDirectional);
-	sprites[path] = std::move(sprite);
-	SpriteAtlas& l = static_cast<SpriteAtlas&>(*sprites[path].get());
-	return static_cast<SpriteAtlas*>(sprites[path].get());
+SpriteAtlas *ResourceManager::loadSpriteAtlas(const std::string &path,
+                                              float frameSize,
+                                              bool isDirectional) {
+  auto iterator = sprites.find(path);
+  if (iterator != sprites.end())
+    return static_cast<SpriteAtlas *>(iterator->second.get());
+  auto sprite =
+      std::make_unique<SpriteAtlas>(path.c_str(), frameSize, isDirectional);
+  sprites[path] = std::move(sprite);
+  SpriteAtlas &l = static_cast<SpriteAtlas &>(*sprites[path].get());
+  return static_cast<SpriteAtlas *>(sprites[path].get());
 }
 
-Sprite* ResourceManager::loadSpriteStatic(const std::string& path)
-{
-	auto iterator = sprites.find(path);
-	if (iterator != sprites.end())
-		return iterator->second.get();
-	auto sprite = std::make_unique<SpriteStatic>(path.c_str());
-	if (!sprite->loaded())
-		return nullptr;
-	sprites[path] = std::move(sprite);
-	return sprites[path].get();
+Sprite *ResourceManager::loadSpriteStatic(const std::string &path) {
+  auto iterator = sprites.find(path);
+  if (iterator != sprites.end())
+    return iterator->second.get();
+  auto sprite = std::make_unique<SpriteStatic>(path.c_str());
+  if (!sprite->loaded())
+    return nullptr;
+  sprites[path] = std::move(sprite);
+  return sprites[path].get();
 }
 
-std::unique_ptr<AIScript> ResourceManager::loadAIScript(const std::string& path)
-{
-	return std::make_unique<AIScript>(path.c_str());
+const TileSetData *ResourceManager::loadTileSet(const std::string &name) {
+  return xmlLoader->getTileSetData(name);
 }
 
-std::unique_ptr<WeaponScript> ResourceManager::loadWeaponScript(const std::string& path)
-{
-	return std::make_unique<WeaponScript>(path.c_str());
+const unsigned ResourceManager::loadShader(const std::string &name,
+                                           const std::string &vertexPath,
+                                           const std::string &fragPath) {
+  auto iterator = shaders.find(name);
+  if (iterator != shaders.end())
+    return iterator->second->ID;
+  auto shader = std::make_unique<Shader>(vertexPath.c_str(), fragPath.c_str());
+  if (!shader->isValid()) {
+    return shaders["__fallback__"]->ID;
+  }
+  unsigned id = shader->ID;
+  shaderIDs[shader->ID] = shader.get();
+  shaders[name] = std::move(shader);
+  return id;
 }
 
-const TileSetData* ResourceManager::loadTileSet(const std::string& name)
-{
-	return xmlLoader->getTileSetData(name);
+Shader *ResourceManager::getShaderByID(unsigned int ID) {
+  auto iterator = shaderIDs.find(ID);
+  return (iterator != shaderIDs.end() ? iterator->second
+                                      : shaders["__fallback__"].get());
 }
 
-const unsigned ResourceManager::loadShader(const std::string& name, const std::string& vertexPath, const std::string& fragPath)
-{
-	auto iterator = shaders.find(name);
-	if (iterator != shaders.end())
-		return iterator->second->ID;
-	auto shader = std::make_unique<Shader>(vertexPath.c_str(), fragPath.c_str());
-	if (!shader->isValid()) {
-		return shaders["__fallback__"]->ID;
-	}
-	unsigned id = shader->ID;
-	shaderIDs[shader->ID] = shader.get();
-	shaders[name] = std::move(shader);
-	return id;
+Background *ResourceManager::loadBackground(const std::string &path) {
+  auto iterator = backgrounds.find(path);
+  if (iterator != backgrounds.end())
+    return iterator->second.get();
+  auto background = std::make_unique<Background>(path);
+  backgrounds[path] = std::move(background);
+  return backgrounds[path].get();
 }
 
-Shader* ResourceManager::getShaderByID(unsigned int ID)
-{
-	auto iterator = shaderIDs.find(ID);
-	return (iterator != shaderIDs.end() ? iterator->second : shaders["__fallback__"].get());
-}
-
-Background*	ResourceManager::loadBackground(const std::string& path)
-{
-	auto iterator = backgrounds.find(path);
-	if (iterator != backgrounds.end())
-		return iterator->second.get();
-	auto background = std::make_unique<Background>(path);
-	backgrounds[path] = std::move(background);
-	return backgrounds[path].get();
-}
-
-// We attach our script after we create our weapon because we are passing a reference to the weapon into the script and we don't want to pass an
+// We attach our script after we create our weapon because we are passing a
+// reference to the weapon into the script and we don't want to pass an
 // incomplete reference to our script.
-std::unique_ptr<Weapon> ResourceManager::loadWeapon(const std::string& id, const unsigned weaponShaderID, const unsigned bulletShaderID)
-{
-	const WeaponData* data = xmlLoader->getWeaponData(id);
-	if (!data) {
-		LOG(ERROR, "Could not load weapon id '{}', falling back to pistol", id);
-		data = xmlLoader->getWeaponData("gun/pistol");// using this as a fallback for now
-	}
-	auto weapon = std::make_unique<Weapon>(data, weaponShaderID, bulletShaderID, this);
-	if (!data->script.empty())
-		weapon->attachScript(loadWeaponScript(data->script));
-	return std::move(weapon);
+std::unique_ptr<Weapon>
+ResourceManager::loadWeapon(const std::string &id,
+                            const unsigned weaponShaderID,
+                            const unsigned bulletShaderID) {
+  const WeaponData *data = xmlLoader->getWeaponData(id);
+  if (!data) {
+    LOG(ERROR, "Could not load weapon id '{}', falling back to pistol", id);
+    data = xmlLoader->getWeaponData(
+        "gun/pistol"); // using this as a fallback for now
+  }
+  auto weapon =
+      std::make_unique<Weapon>(data, weaponShaderID, bulletShaderID, this);
+  if (!data->script.empty())
+    weapon->attachScript(loadScript<WeaponScript>(data->script));
+  return std::move(weapon);
 }
 
-const unsigned ResourceManager::loadSoundEffect(const std::string& id)
-{
-	auto iterator = sounds.find(id);
-	if (iterator != sounds.end())
-		return iterator->second->getBuffer();
-	auto soundData = xmlLoader->getSoundData(id) ;
-	if (!soundData) {
-		soundData = xmlLoader->getSoundData(UTIL::get_generic(id));
-		LOG(WARN, "Could not load sound id: '{}' trying generic", id);
-		if (!soundData)
-			return 0;
-	}
-	auto sound = std::make_unique<SoundEffect>(soundData->path);
-	sounds[id] = std::move(sound);
-	return sounds[id]->getBuffer();
+const unsigned ResourceManager::loadSoundEffect(const std::string &id) {
+  auto iterator = sounds.find(id);
+  if (iterator != sounds.end())
+    return iterator->second->getBuffer();
+  auto soundData = xmlLoader->getSoundData(id);
+  if (!soundData) {
+    soundData = xmlLoader->getSoundData(UTIL::get_generic(id));
+    LOG(WARN, "Could not load sound id: '{}' trying generic", id);
+    if (!soundData)
+      return 0;
+  }
+  auto sound = std::make_unique<SoundEffect>(soundData->path);
+  sounds[id] = std::move(sound);
+  return sounds[id]->getBuffer();
 }
 
-const SceneData* ResourceManager::loadScene(const std::string& id)
-{
-	return xmlLoader->getSceneData(id);
+const SceneData *ResourceManager::loadScene(const std::string &id) {
+  return xmlLoader->getSceneData(id);
 }
 
-std::shared_ptr<AnimationSet> ResourceManager::loadAnimationSet(const std::string& prefix, int entityid)
-{
-	auto animSetData = xmlLoader->getAnimationSet(prefix);
+std::shared_ptr<AnimationSet>
+ResourceManager::loadAnimationSet(const std::string &prefix, int entityid) {
+  auto animSetData = xmlLoader->getAnimationSet(prefix);
 
-	return std::make_shared<AnimationSet>(entityid, this, animSetData);
+  return std::make_shared<AnimationSet>(entityid, this, animSetData);
 }
 
-// this will need some work, but for now where there is only one weapon type we can work with it
-// TODO: Allow different weapon types!
-/*
-template <typename T>
-std::shared_ptr<T> ResourceManager::loadWeapon(const std::string& name, std::shared_ptr<Shader> shader, std::shared_ptr<SpriteComponent> spriteComponent)
-{
-	auto iterator = weapons.find(name);
-	if (iterator != weapons.end())
-		return iterator->second;
-	auto weapon = std::make_shared<T>(T(shader, spriteComponent));
-	weapons[name] = weapon;
-	return weapon;
-}
-*/
-void ResourceManager::clearResources()
-{
-	sprites.clear();
-	shaders.clear();
-	shaderIDs.clear();
-	tileSets.clear();
+void ResourceManager::clearResources() {
+  sprites.clear();
+  shaders.clear();
+  shaderIDs.clear();
+  tileSets.clear();
 }
 
-ResourceManager::~ResourceManager()
-{
-	clearResources();
-	xmlLoader.reset();
+ResourceManager::~ResourceManager() {
+  clearResources();
+  xmlLoader.reset();
+}
+
+bool ResourceManager::loadLuaString(ScriptData *scriptData) {
+  std::filesystem::path file(scriptData->fileName);
+  if (file.empty() || !file.has_extension())
+    return false;
+  try {
+
+    std::ifstream fileStream(file);
+    std::ostringstream sstr;
+    sstr << fileStream.rdbuf();
+    scriptData->script = sstr.str().c_str();
+    fileStream.close();
+
+  } catch (std::exception &e) {
+    ERROR_LOG("Failed to read script file: '{}' - '{}'", scriptData->fileName,
+              e.what());
+  }
+  return true;
 }
diff --git a/YuppleMayham/src/utility/xmlloader.cpp b/YuppleMayham/src/utility/xmlloader.cpp
index a5004b3..8091683 100644
--- a/YuppleMayham/src/utility/xmlloader.cpp
+++ b/YuppleMayham/src/utility/xmlloader.cpp
@@ -5,611 +5,770 @@
 #include <tinyxml2.h>
 
 /*
-	Loading every scene in the scene folder and storing in hashmap scenes
-	hashkey is the id of the scene
+        Loading every scene in the scene folder and storing in hashmap scenes
+        hashkey is the id of the scene
 */
-bool XMLLoader::loadScenes(const char* sceneFolder)
-{
-	std::filesystem::path folder(sceneFolder);
-	if (!std::filesystem::exists(folder) || !std::filesystem::is_directory(folder))
-		ERROR_LOG("'{}' folder not found!", sceneFolder);
-	for (auto& file : std::filesystem::directory_iterator(folder))
-	{
-		if (!file.path().has_extension() || !file.path().has_filename() || !file.exists() || file.is_directory())
-			continue;
-		SceneData scene;
-		if (!loadXmlScene((const char*)file.path().string().c_str(), &scene))
-			continue;
-		scenes.try_emplace(scene.id, std::make_unique<SceneData>(scene));
-	}
-	return true;
+bool XMLLoader::loadScenes(const char *sceneFolder) {
+  std::filesystem::path folder(sceneFolder);
+  if (!std::filesystem::exists(folder) ||
+      !std::filesystem::is_directory(folder))
+    ERROR_LOG("'{}' folder not found!", sceneFolder);
+  for (auto &file : std::filesystem::directory_iterator(folder)) {
+    if (!file.path().has_extension() || !file.path().has_filename() ||
+        !file.exists() || file.is_directory())
+      continue;
+    SceneData scene;
+    if (!loadXmlScene((const char *)file.path().string().c_str(), &scene))
+      continue;
+    scenes.try_emplace(scene.id, std::make_unique<SceneData>(scene));
+  }
+  return true;
 }
 
 /*
-	Loading scene data
+        Loading scene data
 */
-bool XMLLoader::loadXmlScene(const char* xmlFile, SceneData* out)
-{
-	tinyxml2::XMLDocument doc;
-	if (doc.LoadFile(xmlFile) != tinyxml2::XML_SUCCESS)
-		ERROR_LOG("Failed to load file: {}", xmlFile);
-	tinyxml2::XMLElement* scene = doc.FirstChildElement("scene");
+bool XMLLoader::loadXmlScene(const char *xmlFile, SceneData *out) {
+  tinyxml2::XMLDocument doc;
+  if (doc.LoadFile(xmlFile) != tinyxml2::XML_SUCCESS)
+    ERROR_LOG("Failed to load file: {}", xmlFile);
+  tinyxml2::XMLElement *scene = doc.FirstChildElement("scene");
 
-	const char* type, * id, * mapName, * bgFile;
-	if (scene->QueryStringAttribute("type", &type) != tinyxml2::XML_SUCCESS ||
-		scene->QueryStringAttribute("id", &id) != tinyxml2::XML_SUCCESS)
-		ERROR_LOG("Could not read type or id tag in file: {}", xmlFile);
-	out->type = type;
-	out->id = id;
+  const char *type, *id, *mapName, *bgFile;
+  if (scene->QueryStringAttribute("type", &type) != tinyxml2::XML_SUCCESS ||
+      scene->QueryStringAttribute("id", &id) != tinyxml2::XML_SUCCESS)
+    ERROR_LOG("Could not read type or id tag in file: {}", xmlFile);
+  out->type = type;
+  out->id = id;
 
-	if (scene->QueryStringAttribute("bg", &bgFile) != tinyxml2::XML_SUCCESS)
-		LOG(WARN, "No background set! attribute 'bg' is empty", NULL);
-	else
-		out->bgFile = bgFile;
+  if (scene->QueryStringAttribute("bg", &bgFile) != tinyxml2::XML_SUCCESS)
+    LOG(WARN, "No background set! attribute 'bg' is empty", NULL);
+  else
+    out->bgFile = bgFile;
 
-	tinyxml2::XMLElement* map = scene->FirstChildElement("map");
-	if (map == NULL)
-		ERROR_LOG("Could not find 'map' tag in file: {}", xmlFile);
-	if (map->QueryStringAttribute("name", &mapName) != tinyxml2::XML_SUCCESS)
-		ERROR_LOG("Could not find attribute 'name' in map tag. file: {}", xmlFile)
+  tinyxml2::XMLElement *map = scene->FirstChildElement("map");
+  if (map == NULL)
+    ERROR_LOG("Could not find 'map' tag in file: {}", xmlFile);
+  if (map->QueryStringAttribute("name", &mapName) != tinyxml2::XML_SUCCESS)
+    ERROR_LOG("Could not find attribute 'name' in map tag. file: {}", xmlFile)
 
-	if (!(out->map = getMapData(mapName)))
-		return false;
-	if (!loadEntityData(xmlFile, out))
-		return false;
-	LOG(DEBUG, "Loading scene: {}", xmlFile);
-	return true;
+  if (!(out->map = getMapData(mapName)))
+    return false;
+  if (!loadEntityData(xmlFile, out))
+    return false;
+  LOG(DEBUG, "Loading scene: {}", xmlFile);
+  return true;
 }
 
 /*
-	Load entity data held in the scene file, store inside of the SceneData out parameter
+ * Load monster definitions
+ */
+bool XMLLoader::loadMonsters(const char *monsterFolder) {
+  std::filesystem::path folder(monsterFolder);
+  if (!std::filesystem::exists(folder) ||
+      !std::filesystem::is_directory(folder))
+    ERROR_LOG("''{}' folder does not exist!", monsterFolder);
+
+  for (auto &file : std::filesystem::directory_iterator(folder)) {
+    if (!file.path().has_extension() || !file.path().has_filename() ||
+        !file.exists() || file.is_directory())
+      continue;
+    tinyxml2::XMLDocument doc;
+    if (doc.LoadFile(file.path().generic_string().c_str()) !=
+        tinyxml2::XML_SUCCESS)
+      continue;
+
+    for (tinyxml2::XMLElement *e = doc.FirstChildElement("monster");
+         e != nullptr; e = e->NextSiblingElement("monster")) {
+      const char *id, *anim, *weapon, *behaviour;
+
+      MonsterData data;
+      data.aggressive = false;
+
+      // The rules for creating a monster is pretty strict, since we can always
+      // just create entities without creating a definition for them as well.
+      if (e->QueryStringAttribute("id", &id) != tinyxml2::XML_SUCCESS ||
+          e->QueryStringAttribute("anim", &anim) != tinyxml2::XML_SUCCESS ||
+          e->QueryStringAttribute("weapon", &weapon) != tinyxml2::XML_SUCCESS ||
+          e->QueryStringAttribute("behaviour", &behaviour) !=
+              tinyxml2::XML_SUCCESS ||
+          e->QueryFloatAttribute("hp", &data.hp) != tinyxml2::XML_SUCCESS)
+        continue;
+
+      e->QueryBoolAttribute("aggressive", &data.aggressive);
+
+      data.id = id;
+      data.anim = anim;
+      data.weapon = weapon;
+      data.behaviour = behaviour;
+
+      monsters.try_emplace(data.id, std::make_unique<MonsterData>(data));
+    }
+  }
+  return true;
+}
+/*
+ * Loading scripts from the xml file then storing the information inside of the
+ * ScriptData definition struct. This includes storing our script contents. This
+ * is mostly a test, but I feel like it would be faster to hold the scripts as
+ * raw string we store at boot then load based on their ID. It certainly makes
+ * creating definitions easier and cleaner to look at.
+ *
+ * It is the responsibilty of the resource manager to open read read the lua
+ * file via the luaLoader function!
+ *
+ */
+bool XMLLoader::loadScripts(const char *scriptFolder,
+                            std::function<bool(ScriptData *)> luaLoader) {
+  std::filesystem::path folder(scriptFolder);
+  if (!std::filesystem::exists(folder) ||
+      !std::filesystem::is_directory(folder))
+    ERROR_LOG("'{}' folder does not exist!", scriptFolder);
+
+  for (auto &file : std::filesystem::directory_iterator(folder)) {
+    if (!file.path().has_extension() || !file.path().has_filename() ||
+        !file.exists() || file.is_directory())
+      continue;
+
+    tinyxml2::XMLDocument doc;
+    if (doc.LoadFile(file.path().generic_string().c_str()) !=
+        tinyxml2::XML_SUCCESS)
+      continue;
+
+    for (tinyxml2::XMLElement *e = doc.FirstChildElement("script");
+         e != nullptr; e = e->NextSiblingElement("script")) {
+      ScriptData scriptData;
+      const char *id, *fileName;
+      if (e->QueryStringAttribute("id", &id) != tinyxml2::XML_SUCCESS ||
+          e->QueryStringAttribute("file", &fileName) != tinyxml2::XML_SUCCESS)
+        continue;
+
+      scriptData.id = id;
+      scriptData.fileName = fileName;
+
+      if (!luaLoader(&scriptData)) {
+        LOG(ERROR, "Failed to load script '{}'", fileName);
+        continue;
+      }
+
+      scripts.try_emplace(scriptData.id,
+                          std::make_unique<ScriptData>(scriptData));
+    }
+  }
+  return true;
+}
+/*
+        Load entity data held in the scene file, store inside of the SceneData
+   out parameter
 */
-bool XMLLoader::loadEntityData(const char* xmlFile, SceneData* out)
-{
-	tinyxml2::XMLDocument doc;
-	if (doc.LoadFile(xmlFile) != tinyxml2::XML_SUCCESS)
-		ERROR_LOG("Failed to load file: {}", xmlFile);
+bool XMLLoader::loadEntityData(const char *xmlFile, SceneData *out) {
+  tinyxml2::XMLDocument doc;
+  if (doc.LoadFile(xmlFile) != tinyxml2::XML_SUCCESS)
+    ERROR_LOG("Failed to load file: {}", xmlFile);
 
-	tinyxml2::XMLElement* entities = doc.FirstChildElement()->FirstChildElement("entities");
+  tinyxml2::XMLElement *entities =
+      doc.FirstChildElement()->FirstChildElement("entities");
 
-	// Adding the player. Player must be in the scene or the scene will not load!
-	tinyxml2::XMLElement* playerElement = entities->FirstChildElement("player");
-	if (playerElement == NULL)
-		ERROR_LOG("Player element not found in scene! File: {}", xmlFile);
+  // Adding the player. Player must be in the scene or the scene will not load!
+  tinyxml2::XMLElement *playerElement = entities->FirstChildElement("player");
+  if (playerElement == NULL)
+    ERROR_LOG("Player element not found in scene! File: {}", xmlFile);
 
-	EntityData playData;
-	const char *graphic, *weaponName = "pistol";
+  EntityData playData;
+  const char *graphic, *weaponName = "pistol";
 
-	if (playerElement->QueryIntAttribute("x", &playData.x) != tinyxml2::XML_SUCCESS ||
-		playerElement->QueryIntAttribute("y", &playData.y) != tinyxml2::XML_SUCCESS)
-		ERROR_LOG("Failed to find x or y attribute in 'player' tag. File: {}", xmlFile);
-	playerElement->QueryStringAttribute("weapon", &weaponName);
-	tinyxml2::XMLElement* anim = playerElement->FirstChildElement("animation");
-	if (anim == NULL)
-	{
-		playData.animated = false;
-		tinyxml2::XMLElement* sprite = playerElement->FirstChildElement("sprite");
-		if (sprite == NULL)
-			ERROR_LOG("Could not find tag 'sprite' in 'player' tag. File: {}", xmlFile);
-		if (sprite->QueryStringAttribute("file", &graphic) != tinyxml2::XML_SUCCESS)
-			ERROR_LOG("Could not find attribute 'file' in 'player' -> 'sprite' tag. File: {}", xmlFile);
-	}
-	else
-	{
-		playData.animated = true;
-		if (anim->QueryStringAttribute("id", &graphic) != tinyxml2::XML_SUCCESS)
-			ERROR_LOG("Could not find 'name' attribute in 'animation' tag. File: {}", xmlFile);
-	}
-	playData.isPlayer = true;
-	playData.graphic = graphic;
-	playData.weapon = weaponName;
+  if (playerElement->QueryIntAttribute("x", &playData.x) !=
+          tinyxml2::XML_SUCCESS ||
+      playerElement->QueryIntAttribute("y", &playData.y) !=
+          tinyxml2::XML_SUCCESS)
+    ERROR_LOG("Failed to find x or y attribute in 'player' tag. File: {}",
+              xmlFile);
+  playerElement->QueryStringAttribute("weapon", &weaponName);
+  tinyxml2::XMLElement *anim = playerElement->FirstChildElement("animation");
+  if (anim == NULL) {
+    playData.animated = false;
+    tinyxml2::XMLElement *sprite = playerElement->FirstChildElement("sprite");
+    if (sprite == NULL)
+      ERROR_LOG("Could not find tag 'sprite' in 'player' tag. File: {}",
+                xmlFile);
+    if (sprite->QueryStringAttribute("file", &graphic) != tinyxml2::XML_SUCCESS)
+      ERROR_LOG("Could not find attribute 'file' in 'player' -> 'sprite' tag. "
+                "File: {}",
+                xmlFile);
+  } else {
+    playData.animated = true;
+    if (anim->QueryStringAttribute("id", &graphic) != tinyxml2::XML_SUCCESS)
+      ERROR_LOG("Could not find 'name' attribute in 'animation' tag. File: {}",
+                xmlFile);
+  }
+  playData.isPlayer = true;
+  playData.graphic = graphic;
+  playData.weapon = weaponName;
 
-	out->entities.push_back(playData);
-	LOG(DEBUG, "Loaded player with sprite: {} in file: {}", graphic, xmlFile);
+  out->entities.push_back(playData);
+  LOG(DEBUG, "Loaded player with sprite: {} in file: {}", graphic, xmlFile);
 
-	// Adding every other entity...
-	// TODO: Add npcs to game and enable their use with XMLLoader
+  // Adding every other entity...
+  // TODO: Add npcs to game and enable their use with XMLLoader
 
-	for (tinyxml2::XMLElement* e = entities->FirstChildElement("entity"); e != NULL; e = e->NextSiblingElement("entity"))
-	{
-		EntityData data;
-		const char *graphic, *weaponName = "pistol", *scriptPath;
-		if (e->QueryIntAttribute("x", &data.x) != tinyxml2::XML_SUCCESS ||
-			e->QueryIntAttribute("y", &data.y) != tinyxml2::XML_SUCCESS)
-			ERROR_LOG("Could not load position coordinates for entity. File: {}", xmlFile);
-		e->QueryStringAttribute("weapon", &weaponName);
-		tinyxml2::XMLElement* anim = e->FirstChildElement("animation");
-		if (anim == NULL)
-		{
-			data.animated = false;
-			tinyxml2::XMLElement* sprite = e->FirstChildElement("sprite");
-			if (sprite == NULL)
-				continue;
-			if (sprite->QueryStringAttribute("file", &graphic) != tinyxml2::XML_SUCCESS)
-				continue;
-		}
-		else
-		{
-			data.animated = true;
-			if (anim->QueryStringAttribute("id", &graphic) != tinyxml2::XML_SUCCESS)
-				continue;
-		}
-		tinyxml2::XMLElement* script = e->FirstChildElement("script");
-		script->QueryStringAttribute("file", &scriptPath);
-		data.isPlayer = false;
-		data.graphic = graphic;
-		data.script = scriptPath;
-		data.weapon = weaponName;
+  for (tinyxml2::XMLElement *e = entities->FirstChildElement("entity");
+       e != NULL; e = e->NextSiblingElement("entity")) {
+    EntityData data;
+    const char *monsterDef, *graphic, *weaponID, *scriptID;
+    if (e->QueryIntAttribute("x", &data.x) != tinyxml2::XML_SUCCESS ||
+        e->QueryIntAttribute("y", &data.y) != tinyxml2::XML_SUCCESS)
+      ERROR_LOG("Could not load position coordinates for entity. File: {}",
+                xmlFile);
+    e->QueryStringAttribute("weapon", &weaponName);
+    e->QueryStringAttribute("monster_id", &monsterDef);
+    // If we find that the entity has a monster definition we will fill in the
+    // defaults Having a monster definition means we must be animated by default
+    // and we will prefer the animated default for now.
+    if (monsterDef != NULL && monsters[monsterDef] != NULL) {
+      // Setting up the defaults
+      data.animated = true;
+      data.monsterDef = monsterDef;
+      weaponID = monsters[monsterDef]->weapon.c_str();
+      graphic = monsters[monsterDef]->anim.c_str();
+      scriptID = monsters[monsterDef]->behaviour.c_str();
+    }
+    try {
+      // So if we look for the animation tag and there is no monster definition
+      // only then will we take in a sprite as the graphic
+      tinyxml2::XMLElement *anim = e->FirstChildElement("animation");
+      if (anim == NULL && data.monsterDef.empty()) {
+        data.animated = false;
+        tinyxml2::XMLElement *sprite = e->FirstChildElement("sprite");
+        if (sprite == NULL)
+          continue;
+        if (sprite->QueryStringAttribute("file", &graphic) !=
+            tinyxml2::XML_SUCCESS)
+          continue;
+      } else if (data.monsterDef.empty()) {
+        data.animated = true;
+        if (anim->QueryStringAttribute("id", &graphic) != tinyxml2::XML_SUCCESS)
+          continue;
+      } else if (anim != NULL) {
+        // We will take alternative animation ids if specified
+        data.animated = true;
+        anim->QueryStringAttribute("id", &graphic);
+      }
+    } catch (std::exception &e) {
+      LOG(ERROR, "Failed to load entity! ''{}'", e.what());
+      continue;
+    }
+    // We just overload the script id if there is an overload given
+    tinyxml2::XMLElement *script = e->FirstChildElement("script");
+    if (script != NULL)
+      script->QueryStringAttribute("id", &scriptID);
+    data.isPlayer = false;
+    data.graphic = graphic;
+    data.script = scriptID;
+    data.weapon = weaponName;
 
-		out->entities.push_back(data);
-	}
+    out->entities.push_back(data);
+  }
 
-	return true;
+  return true;
 }
 
-float getFloatIfExists(tinyxml2::XMLElement* e)
-{
-	float buf = 0.f;
-	if (e)
-	{
-		e->QueryFloatText(&buf);
-	}
-	return buf;
+float getFloatIfExists(tinyxml2::XMLElement *e) {
+  float buf = 0.f;
+  if (e) {
+    e->QueryFloatText(&buf);
+  }
+  return buf;
 }
 
 /*
-	Load every weapon file, weapon nodes can be fit together in one file or placed in seperate files.
-	hash key is the weapon name
+   Load every weapon file, weapon nodes can be fit together in one file or
+   placed in seperate files. hash key is the weapon id
 */
-bool XMLLoader::loadWeapons(const char* weaponFolder)
-{
-	// We are gonna check every xml file within the weaponFolder, then check every weapon node within each file.
-	std::filesystem::path folder(weaponFolder);
-	if (!std::filesystem::exists(folder) || !std::filesystem::is_directory(folder))
-		ERROR_LOG("'{}' folder does not exist!", weaponFolder);
-	for (auto& file : std::filesystem::directory_iterator(folder))
-	{
-		if (!file.path().has_extension() || !file.path().has_filename() || !file.exists() || file.is_directory())
-			continue;
-		tinyxml2::XMLDocument doc;
-		if (doc.LoadFile(file.path().generic_string().c_str()) != tinyxml2::XML_SUCCESS)
-			continue;
-		tinyxml2::XMLElement* guns = doc.FirstChildElement("weapons");
-		if (guns == NULL)
-			continue;
+bool XMLLoader::loadWeapons(const char *weaponFolder) {
+  // We are gonna check every xml file within the weaponFolder, then check every
+  // weapon node within each file.
+  std::filesystem::path folder(weaponFolder);
+  if (!std::filesystem::exists(folder) ||
+      !std::filesystem::is_directory(folder))
+    ERROR_LOG("'{}' folder does not exist!", weaponFolder);
+  for (auto &file : std::filesystem::directory_iterator(folder)) {
+    if (!file.path().has_extension() || !file.path().has_filename() ||
+        !file.exists() || file.is_directory())
+      continue;
+    tinyxml2::XMLDocument doc;
+    if (doc.LoadFile(file.path().generic_string().c_str()) !=
+        tinyxml2::XML_SUCCESS)
+      continue;
+    tinyxml2::XMLElement *guns = doc.FirstChildElement("weapons");
+    if (guns == NULL)
+      continue;
 
-		for (tinyxml2::XMLElement* weapon = guns->FirstChildElement("weapon"); weapon != NULL; weapon = weapon->NextSiblingElement("weapon"))
-		{
-			// populate weapon data into this temp buffer, then push it into our list of weapons
-			WeaponData data;
-			const char *id, *graphic, *bulletGraphic, *script;
-			// Getting top level weapon data, attribs in the weapon Node
-			if (weapon->QueryStringAttribute("id", &id) != tinyxml2::XML_SUCCESS)
-				continue;
-			weapon->QueryFloatAttribute("fireSpeed", &data.fireSpeed);
-			weapon->QueryIntAttribute("maxAmmo", &data.maxAmmo);
-			weapon->QueryIntAttribute("clipSize", &data.clipSize);
-			// Getting script file if Node exists
-			tinyxml2::XMLElement* wepScript = weapon->FirstChildElement("script");
-			if (wepScript)
-				wepScript->QueryStringAttribute("file", &script);
-			else
-				script = "";
-			// Getting weapon sprite information, held in the sprite node
-			tinyxml2::XMLElement* anim = weapon->FirstChildElement("animation");
-			if (anim)
-			{
-				data.animated = true;
-				if (anim->ChildElementCount() != 0)
-				{
-					tinyxml2::XMLElement* size = anim->FirstChildElement("size");
-					size->QueryFloatAttribute("x", &data.sizeX);
-					size->QueryFloatAttribute("y", &data.sizeY);
-					tinyxml2::XMLElement* offset = anim->FirstChildElement("offset");
-					offset->QueryFloatAttribute("x", &data.offsetX);
-					offset->QueryFloatAttribute("y", &data.offsetY);
-				}
-			}
-			else 
-			{
-				tinyxml2::XMLElement* wepSprite = weapon->FirstChildElement("sprite");
-				if (wepSprite == NULL)
-					continue;
+    for (tinyxml2::XMLElement *weapon = guns->FirstChildElement("weapon");
+         weapon != NULL; weapon = weapon->NextSiblingElement("weapon")) {
+      // populate weapon data into this temp buffer, then push it into our list
+      // of weapons
+      WeaponData data;
+      const char *id, *graphic, *bulletGraphic, *script;
+      // Getting top level weapon data, attribs in the weapon Node
+      if (weapon->QueryStringAttribute("id", &id) != tinyxml2::XML_SUCCESS)
+        continue;
+      weapon->QueryFloatAttribute("fireSpeed", &data.fireSpeed);
+      weapon->QueryIntAttribute("maxAmmo", &data.maxAmmo);
+      weapon->QueryIntAttribute("clipSize", &data.clipSize);
+      // Getting script file if Node exists
+      tinyxml2::XMLElement *wepScript = weapon->FirstChildElement("script");
+      if (wepScript)
+        wepScript->QueryStringAttribute("id", &script);
+      else
+        script = "";
+      // Getting weapon sprite information, held in the sprite node
+      tinyxml2::XMLElement *anim = weapon->FirstChildElement("animation");
+      if (anim) {
+        data.animated = true;
+        if (anim->ChildElementCount() != 0) {
+          tinyxml2::XMLElement *size = anim->FirstChildElement("size");
+          size->QueryFloatAttribute("x", &data.sizeX);
+          size->QueryFloatAttribute("y", &data.sizeY);
+          tinyxml2::XMLElement *offset = anim->FirstChildElement("offset");
+          offset->QueryFloatAttribute("x", &data.offsetX);
+          offset->QueryFloatAttribute("y", &data.offsetY);
+        }
+      } else {
+        tinyxml2::XMLElement *wepSprite = weapon->FirstChildElement("sprite");
+        if (wepSprite == NULL)
+          continue;
 
-				wepSprite->QueryStringAttribute("file", &graphic);
-				data.animated = false;
-				if (wepSprite->ChildElementCount() != 0)
-				{
-					tinyxml2::XMLElement* size = wepSprite->FirstChildElement("size");
-					size->QueryFloatAttribute("x", &data.sizeX);
-					size->QueryFloatAttribute("y", &data.sizeY);
-					tinyxml2::XMLElement* offset = wepSprite->FirstChildElement("offset");
-					offset->QueryFloatAttribute("x", &data.offsetX);
-					offset->QueryFloatAttribute("y", &data.offsetY);
-				}
-			}
-			// getting bullet information held in the bullet node and each child node held therein
-			tinyxml2::XMLElement* bullet = weapon->FirstChildElement("bullet");
+        wepSprite->QueryStringAttribute("file", &graphic);
+        data.animated = false;
+        if (wepSprite->ChildElementCount() != 0) {
+          tinyxml2::XMLElement *size = wepSprite->FirstChildElement("size");
+          size->QueryFloatAttribute("x", &data.sizeX);
+          size->QueryFloatAttribute("y", &data.sizeY);
+          tinyxml2::XMLElement *offset = wepSprite->FirstChildElement("offset");
+          offset->QueryFloatAttribute("x", &data.offsetX);
+          offset->QueryFloatAttribute("y", &data.offsetY);
+        }
+      }
+      // getting bullet information held in the bullet node and each child node
+      // held therein
+      tinyxml2::XMLElement *bullet = weapon->FirstChildElement("bullet");
 
-			if (bullet->FindAttribute("anim"))
-			{
-				data.bulletAnimated = true;
-				if (bullet->QueryStringAttribute("anim", &bulletGraphic) != tinyxml2::XML_SUCCESS)
-					continue;
-			}
-			else
-			{
-				data.bulletAnimated = false;
-				if (bullet->QueryStringAttribute("sprite", &bulletGraphic) != tinyxml2::XML_SUCCESS)
-					continue;
-			}
-			
+      if (bullet->FindAttribute("anim")) {
+        data.bulletAnimated = true;
+        if (bullet->QueryStringAttribute("anim", &bulletGraphic) !=
+            tinyxml2::XML_SUCCESS)
+          continue;
+      } else {
+        data.bulletAnimated = false;
+        if (bullet->QueryStringAttribute("sprite", &bulletGraphic) !=
+            tinyxml2::XML_SUCCESS)
+          continue;
+      }
 
-			if (bullet->FirstChildElement("size")->QueryFloatAttribute("x", &data.bulletSizeX)		!= tinyxml2::XML_SUCCESS ||
-				bullet->FirstChildElement("size")->QueryFloatAttribute("y", &data.bulletSizeY)		!= tinyxml2::XML_SUCCESS)
-				continue;
+      if (bullet->FirstChildElement("size")->QueryFloatAttribute(
+              "x", &data.bulletSizeX) != tinyxml2::XML_SUCCESS ||
+          bullet->FirstChildElement("size")->QueryFloatAttribute(
+              "y", &data.bulletSizeY) != tinyxml2::XML_SUCCESS)
+        continue;
 
-			data.id = id;
-			data.script = script;
-			data.bulletGraphic = bulletGraphic;
+      data.id = id;
+      data.script = script;
+      data.bulletGraphic = bulletGraphic;
 
-			tinyxml2::XMLElement* spread	= bullet->FirstChildElement("spread");
-			tinyxml2::XMLElement* speed		= bullet->FirstChildElement("speed");
-			tinyxml2::XMLElement* drop		= bullet->FirstChildElement("drop");
-			tinyxml2::XMLElement* modifier	= bullet->FirstChildElement("modifier");
-			if (spread)
-				spread->QueryFloatText(&data.bulletSpread);
-			if (speed)
-				speed->QueryFloatText(&data.bulletSpeed);
-			if (drop)
-				drop->QueryFloatText(&data.bulletDrop);
-			if (modifier)
-			{
-				modifier->QueryFloatAttribute("min", &data.modMin);
-				modifier->QueryFloatAttribute("max", &data.modMax);
-			}
+      tinyxml2::XMLElement *spread = bullet->FirstChildElement("spread");
+      tinyxml2::XMLElement *speed = bullet->FirstChildElement("speed");
+      tinyxml2::XMLElement *drop = bullet->FirstChildElement("drop");
+      tinyxml2::XMLElement *modifier = bullet->FirstChildElement("modifier");
+      if (spread)
+        spread->QueryFloatText(&data.bulletSpread);
+      if (speed)
+        speed->QueryFloatText(&data.bulletSpeed);
+      if (drop)
+        drop->QueryFloatText(&data.bulletDrop);
+      if (modifier) {
+        modifier->QueryFloatAttribute("min", &data.modMin);
+        modifier->QueryFloatAttribute("max", &data.modMax);
+      }
 
-			LOG(DEBUG, "Loaded {} from {}", data.id, file.path().filename().generic_string());
-			weapons.try_emplace(data.id, std::make_unique<WeaponData>(data));
-		}
-	}
-	return (!weapons.empty());
+      LOG(DEBUG, "Loaded {} from {}", data.id,
+          file.path().filename().generic_string());
+      weapons.try_emplace(data.id, std::make_unique<WeaponData>(data));
+    }
+  }
+  return (!weapons.empty());
 }
 
 /*
-* Load each animation node and store inside a hashmap by their id. Each object that needs an animation will be given a prefix <type>/<object>. 
-* Which will be used to look up the corresponding animation
-*/
-bool XMLLoader::loadAnimations(const char* animationFolder)
-{
-	std::filesystem::path folder(animationFolder);
-	if (!std::filesystem::exists(folder) || !std::filesystem::is_directory(folder))
-		ERROR_LOG("'{}' folder does not exist!", animationFolder);
-	for (auto& file : std::filesystem::directory_iterator(folder))
-	{
-		if (!file.path().has_extension() || !file.path().has_filename() || !file.exists() || file.is_directory())
-			continue;
+ * Load each animation node and store inside a hashmap by their id. Each object
+ * that needs an animation will be given a prefix <type>/<object>. Which will be
+ * used to look up the corresponding animation
+ */
+bool XMLLoader::loadAnimations(const char *animationFolder) {
+  std::filesystem::path folder(animationFolder);
+  if (!std::filesystem::exists(folder) ||
+      !std::filesystem::is_directory(folder))
+    ERROR_LOG("'{}' folder does not exist!", animationFolder);
+  for (auto &file : std::filesystem::directory_iterator(folder)) {
+    if (!file.path().has_extension() || !file.path().has_filename() ||
+        !file.exists() || file.is_directory())
+      continue;
 
-		tinyxml2::XMLDocument doc;
-		if (doc.LoadFile(file.path().generic_string().c_str()) != tinyxml2::XML_SUCCESS)
-			continue;
+    tinyxml2::XMLDocument doc;
+    if (doc.LoadFile(file.path().generic_string().c_str()) !=
+        tinyxml2::XML_SUCCESS)
+      continue;
 
-		for (tinyxml2::XMLElement* e = doc.FirstChildElement("animation"); e != NULL; e = e->NextSiblingElement("animation"))
-		{
-			AnimationData animData;
-			const char *id, *spriteAtlas;
+    for (tinyxml2::XMLElement *e = doc.FirstChildElement("animation");
+         e != NULL; e = e->NextSiblingElement("animation")) {
+      AnimationData animData;
+      const char *id, *spriteAtlas;
 
-			if (e->QueryStringAttribute("id", &id) != tinyxml2::XML_SUCCESS)
-				continue;
+      if (e->QueryStringAttribute("id", &id) != tinyxml2::XML_SUCCESS)
+        continue;
 
-			if (e->QueryStringAttribute("atlas", &spriteAtlas) != tinyxml2::XML_SUCCESS ||
-					e->QueryFloatAttribute("frameSize", &animData.frameSize) != tinyxml2::XML_SUCCESS)
-				continue;
+      if (e->QueryStringAttribute("atlas", &spriteAtlas) !=
+              tinyxml2::XML_SUCCESS ||
+          e->QueryFloatAttribute("frameSize", &animData.frameSize) !=
+              tinyxml2::XML_SUCCESS)
+        continue;
 
-			e->QueryFloatAttribute("FPS", &animData.FPS);
-			e->QueryBoolAttribute("directional", &animData.directional);
+      e->QueryFloatAttribute("FPS", &animData.FPS);
+      e->QueryBoolAttribute("directional", &animData.directional);
 
-			animData.id = id;
-			animData.spriteAtlas = spriteAtlas;
-			animations.try_emplace(animData.id, std::make_unique<AnimationData>(animData));
-		}
-	}
-	return true;
+      animData.id = id;
+      animData.spriteAtlas = spriteAtlas;
+      animations.try_emplace(animData.id,
+                             std::make_unique<AnimationData>(animData));
+    }
+  }
+  return true;
 }
 
 /*
-	Start of (LoadTileSets)
+        Start of (LoadTileSets)
 
-	Load every tileset and store them in hashmap tileSets
-	hashkey is the <parent directory>/<filename>, this is due to the expected
-	file structure, being 
-	Resources
-	|
-	  - maps
-	    |
-	     - tilesets 
-	Thats is, the tilesets folder is within the maps folder. 
-	This makes it easier to import maps from the Tiled program. 
-	Refer to the Tiled project file for the file structure
+        Load every tileset and store them in hashmap tileSets
+        hashkey is the <parent directory>/<filename>, this is due to the
+   expected file structure, being Resources
+        |
+          - maps
+            |
+             - tilesets
+        Thats is, the tilesets folder is within the maps folder.
+        This makes it easier to import maps from the Tiled program.
+        Refer to the Tiled project file for the file structure
 */
-bool XMLLoader::loadTileSets(const char* tileSetFolder)
-{
-	std::filesystem::path folder(tileSetFolder);
-	if (!std::filesystem::exists(folder) || !std::filesystem::is_directory(folder))
-		ERROR_LOG("'{}' folder failed to load!", tileSetFolder);
+bool XMLLoader::loadTileSets(const char *tileSetFolder) {
+  std::filesystem::path folder(tileSetFolder);
+  if (!std::filesystem::exists(folder) ||
+      !std::filesystem::is_directory(folder))
+    ERROR_LOG("'{}' folder failed to load!", tileSetFolder);
 
-	for (auto& file : std::filesystem::directory_iterator(folder))
-	{
-		if (!file.path().has_extension() || !file.path().has_filename() || !file.exists() || file.is_directory())
-			continue;
-		tinyxml2::XMLDocument doc;
-		if (doc.LoadFile(file.path().generic_string().c_str()) != tinyxml2::XML_SUCCESS)
-			continue;
+  for (auto &file : std::filesystem::directory_iterator(folder)) {
+    if (!file.path().has_extension() || !file.path().has_filename() ||
+        !file.exists() || file.is_directory())
+      continue;
+    tinyxml2::XMLDocument doc;
+    if (doc.LoadFile(file.path().generic_string().c_str()) !=
+        tinyxml2::XML_SUCCESS)
+      continue;
 
-		tinyxml2::XMLElement* tileSet = doc.FirstChildElement("tileset");
-		if (tileSet == NULL)
-			continue;
-		TileSetData tileSetData;
-		const char* setName, * setType = "shooter", * setFile;
+    tinyxml2::XMLElement *tileSet = doc.FirstChildElement("tileset");
+    if (tileSet == NULL)
+      continue;
+    TileSetData tileSetData;
+    const char *setName, *setType = "shooter", *setFile;
 
-		tileSet->QueryStringAttribute("class", &setType);
+    tileSet->QueryStringAttribute("class", &setType);
 
-		// Read attributes of tileset element
-		if (tileSet->QueryStringAttribute("name", &setName) != tinyxml2::XML_SUCCESS ||
-			tileSet->QueryFloatAttribute("tilewidth", &tileSetData.tileSize) != tinyxml2::XML_SUCCESS ||
-			tileSet->QueryIntAttribute("tilecount", &tileSetData.tileCount) != tinyxml2::XML_SUCCESS ||
-			tileSet->QueryIntAttribute("columns", &tileSetData.columns) != tinyxml2::XML_SUCCESS)
-			continue;
+    // Read attributes of tileset element
+    if (tileSet->QueryStringAttribute("name", &setName) !=
+            tinyxml2::XML_SUCCESS ||
+        tileSet->QueryFloatAttribute("tilewidth", &tileSetData.tileSize) !=
+            tinyxml2::XML_SUCCESS ||
+        tileSet->QueryIntAttribute("tilecount", &tileSetData.tileCount) !=
+            tinyxml2::XML_SUCCESS ||
+        tileSet->QueryIntAttribute("columns", &tileSetData.columns) !=
+            tinyxml2::XML_SUCCESS)
+      continue;
 
-		tinyxml2::XMLElement* image = tileSet->FirstChildElement("image");
-		if (image == NULL)
-			continue;
+    tinyxml2::XMLElement *image = tileSet->FirstChildElement("image");
+    if (image == NULL)
+      continue;
 
-		// Reading image element attribs
-		if (image->QueryStringAttribute("source", &setFile) != tinyxml2::XML_SUCCESS ||
-			image->QueryIntAttribute("width", &tileSetData.width) != tinyxml2::XML_SUCCESS ||
-			image->QueryIntAttribute("height", &tileSetData.height) != tinyxml2::XML_SUCCESS)
-			continue;
+    // Reading image element attribs
+    if (image->QueryStringAttribute("source", &setFile) !=
+            tinyxml2::XML_SUCCESS ||
+        image->QueryIntAttribute("width", &tileSetData.width) !=
+            tinyxml2::XML_SUCCESS ||
+        image->QueryIntAttribute("height", &tileSetData.height) !=
+            tinyxml2::XML_SUCCESS)
+      continue;
 
-		for (tinyxml2::XMLElement* tileElement = tileSet->FirstChildElement("tile"); tileElement != NULL; tileElement = tileElement->NextSiblingElement("tile"))
-		{
-			TileSetData::TileData tileData;
-			if (!loadTile(tileElement, &tileData))
-				continue;
-			tileSetData.tiles.push_back(std::make_shared<TileSetData::TileData>(tileData));
-		}
-		tileSetData.name = setName;
-		tileSetData.type = setType;
-		tileSetData.file = file.path().parent_path().string() + "/" + std::string(setFile);
-		std::string key = folder.filename().string() + "/" + file.path().filename().string();
+    for (tinyxml2::XMLElement *tileElement = tileSet->FirstChildElement("tile");
+         tileElement != NULL;
+         tileElement = tileElement->NextSiblingElement("tile")) {
+      TileSetData::TileData tileData;
+      if (!loadTile(tileElement, &tileData))
+        continue;
+      tileSetData.tiles.push_back(
+          std::make_shared<TileSetData::TileData>(tileData));
+    }
+    tileSetData.name = setName;
+    tileSetData.type = setType;
+    tileSetData.file =
+        file.path().parent_path().string() + "/" + std::string(setFile);
+    std::string key =
+        folder.filename().string() + "/" + file.path().filename().string();
 
-		tileSets.try_emplace(key, std::make_unique<TileSetData>(tileSetData));
-	}
-	return true;
+    tileSets.try_emplace(key, std::make_unique<TileSetData>(tileSetData));
+  }
+  return true;
 }
 
-bool XMLLoader::loadTile(tinyxml2::XMLElement* tileElement, TileSetData::TileData* out)
-{
-	TileSetData::TileData tileData;
-	const char* tileType;
+bool XMLLoader::loadTile(tinyxml2::XMLElement *tileElement,
+                         TileSetData::TileData *out) {
+  TileSetData::TileData tileData;
+  const char *tileType;
 
-	if (tileElement == NULL)
-		ERROR_LOG("Failed to find 'tile' tag.", NULL);
-	if (tileElement->QueryIntAttribute("id", &tileData.id) != tinyxml2::XML_SUCCESS ||
-		tileElement->QueryStringAttribute("type", &tileType) != tinyxml2::XML_SUCCESS)
-		ERROR_LOG("Failed to load tile id or type. {}", tileElement->Value());
+  if (tileElement == NULL)
+    ERROR_LOG("Failed to find 'tile' tag.", NULL);
+  if (tileElement->QueryIntAttribute("id", &tileData.id) !=
+          tinyxml2::XML_SUCCESS ||
+      tileElement->QueryStringAttribute("type", &tileType) !=
+          tinyxml2::XML_SUCCESS)
+    ERROR_LOG("Failed to load tile id or type. {}", tileElement->Value());
 
-	if (std::string(tileType).compare("object") == 0)
-	{
-		/*
-			Refer to .tsx file of tile set for specific details regarding the layout of the tile element.
-			You will notice each tile has the potential to be a container for objects, so that is how we are 
-			handling it here. If the tileType was specified as an object, but it contains no objects, then we don't
-			load the tile. Objects are defined in the Tiled program using the collision editor.
-		*/
-		tinyxml2::XMLElement* objectGroup = tileElement->FirstChildElement("objectgroup");
-		if (objectGroup == NULL)
-			ERROR_LOG("Failed to find tag 'objectgroup' in tile id: {}", tileData.id);
-		for (tinyxml2::XMLElement* obj = objectGroup->FirstChildElement("object"); obj != NULL; obj = obj->NextSiblingElement("object"))
-		{
-			TileSetData::TileData::ObjectData objData;
-			if (!loadObject(obj, &objData))
-				continue;
-			tileData.objects.push_back(std::make_shared<TileSetData::TileData::ObjectData>(objData));
-		}
-		if (tileData.objects.empty())
-			ERROR_LOG("No objects found", NULL);
-	}
-	else
-	{
-		/*
-			May support multiple properties in the future with a future property struct to hold any value type
-			But this may not be needed, so we'll just capture the walkable property for now.
-			Assume default of there is no properties tag or walkable property, just use nested if's
-		*/
-		tinyxml2::XMLElement* properties = tileElement->FirstChildElement("properties");
-		if (properties == NULL) {
-			LOG(WARN, "No properties found on tile id: {} assuming defaults", tileData.id);
-		} else {
-			tinyxml2::XMLElement* propWalk = properties->FirstChildElement("property");
-			if (propWalk == NULL) {
-				LOG(WARN, "No walkable propery found on tile id: {} assuming walkable", tileData.id);
-			} else {
-				for (auto& prop = propWalk; prop != NULL; prop = prop->NextSiblingElement()) {
-					if (prop->Attribute("name", "walkable")) {
-						prop->QueryBoolAttribute("value", &tileData.walkable);
-						break;
-					}
-				}
-			}
-		}
-	}
+  if (std::string(tileType).compare("object") == 0) {
+    /*
+            Refer to .tsx file of tile set for specific details regarding the
+       layout of the tile element. You will notice each tile has the potential
+       to be a container for objects, so that is how we are handling it here. If
+       the tileType was specified as an object, but it contains no objects, then
+       we don't load the tile. Objects are defined in the Tiled program using
+       the collision editor.
+    */
+    tinyxml2::XMLElement *objectGroup =
+        tileElement->FirstChildElement("objectgroup");
+    if (objectGroup == NULL)
+      ERROR_LOG("Failed to find tag 'objectgroup' in tile id: {}", tileData.id);
+    for (tinyxml2::XMLElement *obj = objectGroup->FirstChildElement("object");
+         obj != NULL; obj = obj->NextSiblingElement("object")) {
+      TileSetData::TileData::ObjectData objData;
+      if (!loadObject(obj, &objData))
+        continue;
+      tileData.objects.push_back(
+          std::make_shared<TileSetData::TileData::ObjectData>(objData));
+    }
+    if (tileData.objects.empty())
+      ERROR_LOG("No objects found", NULL);
+  } else {
+    /*
+            May support multiple properties in the future with a future property
+       struct to hold any value type But this may not be needed, so we'll just
+       capture the walkable property for now. Assume default of there is no
+       properties tag or walkable property, just use nested if's
+    */
+    tinyxml2::XMLElement *properties =
+        tileElement->FirstChildElement("properties");
+    if (properties == NULL) {
+      LOG(WARN, "No properties found on tile id: {} assuming defaults",
+          tileData.id);
+    } else {
+      tinyxml2::XMLElement *propWalk =
+          properties->FirstChildElement("property");
+      if (propWalk == NULL) {
+        LOG(WARN, "No walkable propery found on tile id: {} assuming walkable",
+            tileData.id);
+      } else {
+        for (auto &prop = propWalk; prop != NULL;
+             prop = prop->NextSiblingElement()) {
+          if (prop->Attribute("name", "walkable")) {
+            prop->QueryBoolAttribute("value", &tileData.walkable);
+            break;
+          }
+        }
+      }
+    }
+  }
 
-	tileData.type = tileType;
+  tileData.type = tileType;
 
-	*out = tileData;
-	return true;
+  *out = tileData;
+  return true;
 }
 
-bool XMLLoader::loadObject(tinyxml2::XMLElement* objElement, TileSetData::TileData::ObjectData* out)
-{
-	TileSetData::TileData::ObjectData objData;
-	const char* objName;
+bool XMLLoader::loadObject(tinyxml2::XMLElement *objElement,
+                           TileSetData::TileData::ObjectData *out) {
+  TileSetData::TileData::ObjectData objData;
+  const char *objName;
 
-	// avoid null pointer exception
-	if (objElement == NULL)
-		ERROR_LOG("Failed to find 'object' tag", NULL);
-	// load id and name
-	if (objElement->QueryIntAttribute("id", &objData.id) != tinyxml2::XML_SUCCESS ||
-		objElement->QueryStringAttribute("name", &objName) != tinyxml2::XML_SUCCESS)
-		ERROR_LOG("No id or name found for object. {}", objElement->Value());
-	// load position into vec2
-	if (objElement->QueryFloatAttribute("x", &objData.pos.x) != tinyxml2::XML_SUCCESS ||
-		objElement->QueryFloatAttribute("y", &objData.pos.y) != tinyxml2::XML_SUCCESS)
-		ERROR_LOG("Failed to load position coordinates for object: {}", objData.name);
-	// load size into seperate vec2
-	if (objElement->QueryFloatAttribute("width", &objData.size.x) != tinyxml2::XML_SUCCESS ||
-		objElement->QueryFloatAttribute("height", &objData.size.y) != tinyxml2::XML_SUCCESS)
-		ERROR_LOG("Failed to load size of object: {}", objData.name);
+  // avoid null pointer exception
+  if (objElement == NULL)
+    ERROR_LOG("Failed to find 'object' tag", NULL);
+  // load id and name
+  if (objElement->QueryIntAttribute("id", &objData.id) !=
+          tinyxml2::XML_SUCCESS ||
+      objElement->QueryStringAttribute("name", &objName) !=
+          tinyxml2::XML_SUCCESS)
+    ERROR_LOG("No id or name found for object. {}", objElement->Value());
+  // load position into vec2
+  if (objElement->QueryFloatAttribute("x", &objData.pos.x) !=
+          tinyxml2::XML_SUCCESS ||
+      objElement->QueryFloatAttribute("y", &objData.pos.y) !=
+          tinyxml2::XML_SUCCESS)
+    ERROR_LOG("Failed to load position coordinates for object: {}",
+              objData.name);
+  // load size into seperate vec2
+  if (objElement->QueryFloatAttribute("width", &objData.size.x) !=
+          tinyxml2::XML_SUCCESS ||
+      objElement->QueryFloatAttribute("height", &objData.size.y) !=
+          tinyxml2::XML_SUCCESS)
+    ERROR_LOG("Failed to load size of object: {}", objData.name);
 
-	// refer to comment in XMLLoader::loadTile regarding the properties portion as to why we return true here
-	tinyxml2::XMLElement* properties = objElement->FirstChildElement("properties");
-	if (properties != NULL)
-	{
-		tinyxml2::XMLElement* propCollide = properties->FirstChildElement("property");
-		if (propCollide != NULL && propCollide->Attribute("name", "collidable"))
-			propCollide->QueryBoolAttribute("value", &objData.collidable);
-	}
+  // refer to comment in XMLLoader::loadTile regarding the properties portion as
+  // to why we return true here
+  tinyxml2::XMLElement *properties =
+      objElement->FirstChildElement("properties");
+  if (properties != NULL) {
+    tinyxml2::XMLElement *propCollide =
+        properties->FirstChildElement("property");
+    if (propCollide != NULL && propCollide->Attribute("name", "collidable"))
+      propCollide->QueryBoolAttribute("value", &objData.collidable);
+  }
 
-	objData.name = objName;
+  objData.name = objName;
 
-	*out = objData;
-	return true;
+  *out = objData;
+  return true;
 }
 /* End of (LoadTileSets) */
 
-bool XMLLoader::loadMaps(const char* mapFolder)
-{
-	std::filesystem::path folder(mapFolder);
-	if (!std::filesystem::exists(folder) || !std::filesystem::is_directory(folder))
-		ERROR_LOG("'{}' folder not found!", mapFolder);
+bool XMLLoader::loadMaps(const char *mapFolder) {
+  std::filesystem::path folder(mapFolder);
+  if (!std::filesystem::exists(folder) ||
+      !std::filesystem::is_directory(folder))
+    ERROR_LOG("'{}' folder not found!", mapFolder);
 
-	for (auto& file : std::filesystem::directory_iterator(folder))
-	{
-		if (!file.path().has_extension() || !file.path().has_filename() || !file.exists() || file.is_directory())
-			continue;
-		tinyxml2::XMLDocument doc;
-		if (doc.LoadFile(file.path().generic_string().c_str()) != tinyxml2::XML_SUCCESS)
-			continue;
+  for (auto &file : std::filesystem::directory_iterator(folder)) {
+    if (!file.path().has_extension() || !file.path().has_filename() ||
+        !file.exists() || file.is_directory())
+      continue;
+    tinyxml2::XMLDocument doc;
+    if (doc.LoadFile(file.path().generic_string().c_str()) !=
+        tinyxml2::XML_SUCCESS)
+      continue;
 
-		tinyxml2::XMLElement* map = doc.FirstChildElement("map");
-		if (map == NULL)
-			continue;
-		MapData mapData;
+    tinyxml2::XMLElement *map = doc.FirstChildElement("map");
+    if (map == NULL)
+      continue;
+    MapData mapData;
 
-		if (map->QueryIntAttribute("width", &mapData.width) != tinyxml2::XML_SUCCESS ||
-			map->QueryIntAttribute("height", &mapData.height) != tinyxml2::XML_SUCCESS ||
-			map->QueryFloatAttribute("tilewidth", &mapData.tileSize) != tinyxml2::XML_SUCCESS)
-			continue;
+    if (map->QueryIntAttribute("width", &mapData.width) !=
+            tinyxml2::XML_SUCCESS ||
+        map->QueryIntAttribute("height", &mapData.height) !=
+            tinyxml2::XML_SUCCESS ||
+        map->QueryFloatAttribute("tilewidth", &mapData.tileSize) !=
+            tinyxml2::XML_SUCCESS)
+      continue;
 
-		for (tinyxml2::XMLElement* tileSet = map->FirstChildElement("tileset"); tileSet != NULL; tileSet = tileSet->NextSiblingElement("tileset"))
-		{
-			int firstGID = 0;
-			const char* tileSetPath;
-			if (tileSet->QueryStringAttribute("source", &tileSetPath) != tinyxml2::XML_SUCCESS ||
-				tileSet->QueryIntAttribute("firstgid", &firstGID) != tinyxml2::XML_SUCCESS)
-				continue;
-			mapData.tileSets.push_back({ firstGID, tileSetPath });
-		}
+    for (tinyxml2::XMLElement *tileSet = map->FirstChildElement("tileset");
+         tileSet != NULL; tileSet = tileSet->NextSiblingElement("tileset")) {
+      int firstGID = 0;
+      const char *tileSetPath;
+      if (tileSet->QueryStringAttribute("source", &tileSetPath) !=
+              tinyxml2::XML_SUCCESS ||
+          tileSet->QueryIntAttribute("firstgid", &firstGID) !=
+              tinyxml2::XML_SUCCESS)
+        continue;
+      mapData.tileSets.push_back({firstGID, tileSetPath});
+    }
 
-		if (mapData.tileSets.empty())
-			continue;
+    if (mapData.tileSets.empty())
+      continue;
 
-		mapData.tiles.reserve(10);
-		mapData.tiles.resize(10);
+    mapData.tiles.reserve(10);
+    mapData.tiles.resize(10);
 
-		for (int layer = 0; layer < 10; ++layer)
-		{
-			mapData.tiles[layer].reserve(mapData.height);
-			mapData.tiles[layer].resize(mapData.height);
-			for (int y = 0; y < mapData.height; ++y)
-			{
-				mapData.tiles[layer][y].reserve(mapData.width);
-				mapData.tiles[layer][y].resize(mapData.width);
-			}
-		}
+    for (int layer = 0; layer < 10; ++layer) {
+      mapData.tiles[layer].reserve(mapData.height);
+      mapData.tiles[layer].resize(mapData.height);
+      for (int y = 0; y < mapData.height; ++y) {
+        mapData.tiles[layer][y].reserve(mapData.width);
+        mapData.tiles[layer][y].resize(mapData.width);
+      }
+    }
 
-		int layerNumber = 0;
-		for (tinyxml2::XMLElement* layer = map->FirstChildElement("layer"); layer != NULL; layer = layer->NextSiblingElement("layer"))
-		{
-			tinyxml2::XMLElement* data = layer->FirstChildElement("data");
-			if (data == NULL)
-				continue;
-			if (layerNumber >= 10)
-				continue;
+    int layerNumber = 0;
+    for (tinyxml2::XMLElement *layer = map->FirstChildElement("layer");
+         layer != NULL; layer = layer->NextSiblingElement("layer")) {
+      tinyxml2::XMLElement *data = layer->FirstChildElement("data");
+      if (data == NULL)
+        continue;
+      if (layerNumber >= 10)
+        continue;
 
-			std::string idSet = data->GetText();
-			std::string tileRow;
-			std::string tileString;
+      std::string idSet = data->GetText();
+      std::string tileRow;
+      std::string tileString;
 
-			std::stringstream ssidSet(idSet);
-			int x = 0, y = -1;
+      std::stringstream ssidSet(idSet);
+      int x = 0, y = -1;
 
-			while (std::getline(ssidSet, tileRow) && y < mapData.height)
-			{
-				std::stringstream ssid(tileRow);
-				x = 0;
-				while (std::getline(ssid, tileString, ',') && x < mapData.width)
-				{
-					int id = std::stoi(tileString);
-					mapData.tiles[layerNumber][y][x] = id;
-					x++;
-				}
-				y++;
-			}
+      while (std::getline(ssidSet, tileRow) && y < mapData.height) {
+        std::stringstream ssid(tileRow);
+        x = 0;
+        while (std::getline(ssid, tileString, ',') && x < mapData.width) {
+          int id = std::stoi(tileString);
+          mapData.tiles[layerNumber][y][x] = id;
+          x++;
+        }
+        y++;
+      }
 
-			layerNumber += 1;
-		}
+      layerNumber += 1;
+    }
 
-		mapData.tiles.resize(layerNumber);
-		mapData.tiles.shrink_to_fit();
-		/* TODO: Add object layer */
+    mapData.tiles.resize(layerNumber);
+    mapData.tiles.shrink_to_fit();
+    /* TODO: Add object layer */
 
-		mapData.name = file.path().stem().string();
+    mapData.name = file.path().stem().string();
 
-		maps.try_emplace(mapData.name, std::make_unique<MapData>(mapData));
-	}
-	return true;
+    maps.try_emplace(mapData.name, std::make_unique<MapData>(mapData));
+  }
+  return true;
 }
 
-bool XMLLoader::loadSoundEffects(const char *soundFolder)
-{
-	std::filesystem::path folder(soundFolder);
-	if (!std::filesystem::exists(folder) || !std::filesystem::is_directory(folder))
-		ERROR_LOG("Directory '{}' does not exist!", soundFolder);
+bool XMLLoader::loadSoundEffects(const char *soundFolder) {
+  std::filesystem::path folder(soundFolder);
+  if (!std::filesystem::exists(folder) ||
+      !std::filesystem::is_directory(folder))
+    ERROR_LOG("Directory '{}' does not exist!", soundFolder);
 
-	for (auto& file : std::filesystem::directory_iterator(folder))
-	{
-		if (!file.path().has_extension() || !file.path().has_filename() || !file.exists() || file.is_directory())
-			continue;
+  for (auto &file : std::filesystem::directory_iterator(folder)) {
+    if (!file.path().has_extension() || !file.path().has_filename() ||
+        !file.exists() || file.is_directory())
+      continue;
 
-		tinyxml2::XMLDocument doc;
-		if (doc.LoadFile(file.path().string().c_str()) != tinyxml2::XML_SUCCESS)
-			continue;
+    tinyxml2::XMLDocument doc;
+    if (doc.LoadFile(file.path().string().c_str()) != tinyxml2::XML_SUCCESS)
+      continue;
 
-		for (tinyxml2::XMLElement *e = doc.FirstChildElement("sound"); e != NULL; e = e->NextSiblingElement("sound")) {
-			SoundData sound;
-			const char *id, *path;
-			if (e->QueryStringAttribute("id", &id) != tinyxml2::XML_SUCCESS ||
-					e->QueryStringAttribute("path", &path) != tinyxml2::XML_SUCCESS)
-				continue;
-			e->QueryBoolAttribute("spatial", &sound.spatial);
+    for (tinyxml2::XMLElement *e = doc.FirstChildElement("sound"); e != NULL;
+         e = e->NextSiblingElement("sound")) {
+      SoundData sound;
+      const char *id, *path;
+      if (e->QueryStringAttribute("id", &id) != tinyxml2::XML_SUCCESS ||
+          e->QueryStringAttribute("path", &path) != tinyxml2::XML_SUCCESS)
+        continue;
+      e->QueryBoolAttribute("spatial", &sound.spatial);
 
-			sound.id = id;
-			sound.path = path;
-			
-			sounds.try_emplace(sound.id, std::make_unique<SoundData>(sound));
-		}
-	}
-	return true;
+      sound.id = id;
+      sound.path = path;
+
+      sounds.try_emplace(sound.id, std::make_unique<SoundData>(sound));
+    }
+  }
+  return true;
 }