Merge remote-tracking branch 'origin/master' into HUD-Timers

# Conflicts:
#	resources/Schema/Entities/Player.xml

include/Engine/Core/ECaptured.h

@@ -12,7 +12,9 @@ namespace Events
 struct Captured : Event
 {
     int TeamNumberThatCapturedCapturePoint;
-    EntityID CapturePointID;
+    EntityID CapturePointTakenID;
+    EntityWrapper BlueTeamNextCapturePoint;
+    EntityWrapper RedTeamNextCapturePoint;
 };
 
 }

include/Engine/Core/EntityFile.h

@@ -1,164 +1,21 @@
 #ifndef EntityFile_h__
 #define EntityFile_h__
 
-#include <stack>
-#include <boost/lexical_cast.hpp>
-#include <xercesc/util/XercesDefs.hpp>
-#include <xercesc/util/PlatformUtils.hpp>
-#include <xercesc/sax2/SAX2XMLReader.hpp>
-#include <xercesc/sax2/XMLReaderFactory.hpp>
-#include <xercesc/sax2/DefaultHandler.hpp>
-#include <xercesc/sax2/Attributes.hpp>
-#include <xercesc/util/XMLString.hpp>
-#include <xercesc/util/XMLChar.hpp>
-#include <xercesc/sax2/DefaultHandler.hpp>
-#include <xercesc/framework/XMLDocumentHandler.hpp>
-#include <xercesc/framework/psvi/XSElementDeclaration.hpp>
-#include <xercesc/framework/psvi/XSComplexTypeDefinition.hpp>
-#include <xercesc/framework/psvi/XSParticle.hpp>
-#include <xercesc/framework/psvi/XSModelGroup.hpp>
-#include <xercesc/framework/psvi/XSAnnotation.hpp>
-#include <xercesc/framework/psvi/XSValue.hpp>
-#include <xercesc/framework/XMLGrammarPoolImpl.hpp>
-#include <xercesc/dom/DOM.hpp>
-#include <xercesc/dom/DOMLSInput.hpp>
-#include <xercesc/dom/DOMElement.hpp>
+#include "World.h"
+#include "EntityXMLFile.h"
+#include "EntityXMLFilePreprocessor.h"
+#include "EntityXMLFileParser.h"
+#include "EntityWrapper.h"
 
-#include "../GLM.h"
-#include "Util/XercesString.h"
-#include "ResourceManager.h"
-#include "Entity.h"
-#include "ComponentInfo.h"
-
-class EntityFileHandler
-{
-    friend class EntityFileSAXHandler;
-public:
-    // @param EntityID The entity found
-    // @param EntityID The parent of the entity
-    typedef std::function<void(EntityID, EntityID, const std::string&)> OnStartEntityCallback;
-    void SetStartEntityCallback(OnStartEntityCallback c) { m_OnStartEntityCallback = c; }
-    // @param EntityID The entity the component corresponds to
-    // @param std::string Type name of the component
-    typedef std::function<void(EntityID, const std::string&)> OnStartComponentCallback;
-    void SetStartComponentCallback(OnStartComponentCallback c) { m_OnStartComponentCallback = c; }
-    // @param EntityID Entity 
-    // @param std::string Component name 
-    // @param std::string Field name
-    // @param std::map<std::string, std::string> Field attribute names and values
-    typedef std::function<void(EntityID, const std::string&, const std::string&, const std::map<std::string, std::string>&)> OnStartFieldCallback;
-    void SetStartFieldCallback(OnStartFieldCallback c) { m_OnStartFieldCallback = c; }
-    // @param EntityID Entity 
-    // @param std::string Component name 
-    // @param std::string Field name
-    // @param char* Field data
-    typedef std::function<void(EntityID, const std::string&, const std::string&, const char*)> OnStartFieldDataCallback;
-    void SetStartFieldDataCallback(OnStartFieldDataCallback c) { m_OnStartFieldDataCallback = c; }
-
-private:
-    OnStartEntityCallback m_OnStartEntityCallback = nullptr;
-    OnStartComponentCallback m_OnStartComponentCallback = nullptr;
-    OnStartFieldCallback m_OnStartFieldCallback = nullptr;
-    OnStartFieldDataCallback m_OnStartFieldDataCallback = nullptr;
-};
-
-class EntityFileSAXHandler : public xercesc::DefaultHandler
+class EntityFile : private World, public Resource
 {
 public:
-    enum class State
-    {
-        Unknown,
-        Entity,
-        Component,
-        ComponentField
-    };
+    EntityFile(std::string path);
 
-    EntityFileSAXHandler(const EntityFileHandler* handler, xercesc::SAX2XMLReader* reader);
-
-    void startElement(const XMLCh* const _uri, const XMLCh* const _localName, const XMLCh* const _qname, const xercesc::Attributes& attrs) override;
-    void characters(const XMLCh* const chars, const XMLSize_t length) override;
-    void endElement(const XMLCh* const _uri, const XMLCh* const _localName, const XMLCh* const _qname) override;
-
-    void warning(const xercesc::SAXParseException& e);
-    void error(const xercesc::SAXParseException& e);
-    void fatalError(const xercesc::SAXParseException& e);
+    EntityWrapper MergeInto(World* other);
 
 private:
-    const EntityFileHandler* m_Handler;
-    xercesc::XMLGrammarPool* m_GrammarPool;
-    xercesc::SAX2XMLReader* m_Reader;
-    //State m_CurrentScope = State::Unknown;
-    std::stack<State> m_StateStack;
-    unsigned int m_NextEntityID = 0;
-    std::stack<EntityID> m_EntityStack;
-    std::string m_CurrentComponent;
-    std::string m_CurrentField;
-    std::map<std::string, std::string> m_CurrentAttributes;
-
-    void onStartEntity(const xercesc::Attributes& attrs); 
-    void onEndEntity();
-    void onStartEntityRef(const xercesc::Attributes& attrs);
-    void onStartComponent(const std::string& name);
-    void onEndComponent(const std::string& name);
-    void onStartComponentField(const std::string& field, const xercesc::Attributes& attrs);
-    void onEndComponentField(const std::string& field);
-    void onFieldData(char* data);
-};
-
-class EntityFileXMLErrorHandler : public xercesc::ErrorHandler
-{
-public:
-	void warning(const xercesc::SAXParseException& e) override
-	{
-		reportParseException("Warning", e);
-	}
-	void error(const xercesc::SAXParseException& e) override
-	{
-		reportParseException("Error", e);
-	}
-	void fatalError(const xercesc::SAXParseException& e) override
-	{
-		reportParseException("FATAL ERROR", e);
-	}
-	void resetErrors() override { }
-
-private:
-	void reportParseException(std::string type, const xercesc::SAXParseException& e)
-	{
-		char* message = xercesc::XMLString::transcode(e.getMessage());
-		char* systemID = xercesc::XMLString::transcode(e.getSystemId());
-		std::cerr << systemID << ":" << e.getLineNumber() << ":" << e.getColumnNumber() << std::endl;
-		std::cerr << type << ": " << message << std::endl;
-		xercesc::XMLString::release(&systemID);
-		xercesc::XMLString::release(&message);
-	}
-};
-
-class EntityFile : public Resource
-{
-    friend class ResourceManager;
-    friend class EntityFileSAXHandler;
-private:
-    EntityFile(boost::filesystem::path path);
-    ~EntityFile();
-
-public:
-    static unsigned int GetTypeStride(std::string typeName);
-    static void WriteAttributeData(char* outData, const ComponentInfo::Field_t& field, const std::map<std::string, std::string>& attributes);
-    static void WriteValueData(char* outData, const ComponentInfo::Field_t& field, const char* valueData);
-
-    xercesc::XMLGrammarPool* GrammarPool() const { return m_GrammarPool; }
-
-    void Parse(const EntityFileHandler* handler) const;
-
-private:
-    boost::filesystem::path m_FilePath;
-    xercesc::XMLGrammarPool* m_GrammarPool;
-    xercesc::SAX2XMLReader* m_SAX2XMLReader;
-	//std::map<std::string, ::ComponentInfo> m_ComponentInfo;
-    //std::vector<std::string> m_EntityReferences;
-
-    static void setReaderFeatures(xercesc::SAX2XMLReader* reader);
+    EntityID m_RootEntity = EntityID_Invalid;
 };
 
 #endif

include/Engine/Core/EntityXMLFile.h

@@ -0,0 +1,164 @@
+#ifndef EntityXMLFile_h__
+#define EntityXMLFile_h__
+
+#include <stack>
+#include <boost/lexical_cast.hpp>
+#include <xercesc/util/XercesDefs.hpp>
+#include <xercesc/util/PlatformUtils.hpp>
+#include <xercesc/sax2/SAX2XMLReader.hpp>
+#include <xercesc/sax2/XMLReaderFactory.hpp>
+#include <xercesc/sax2/DefaultHandler.hpp>
+#include <xercesc/sax2/Attributes.hpp>
+#include <xercesc/util/XMLString.hpp>
+#include <xercesc/util/XMLChar.hpp>
+#include <xercesc/sax2/DefaultHandler.hpp>
+#include <xercesc/framework/XMLDocumentHandler.hpp>
+#include <xercesc/framework/psvi/XSElementDeclaration.hpp>
+#include <xercesc/framework/psvi/XSComplexTypeDefinition.hpp>
+#include <xercesc/framework/psvi/XSParticle.hpp>
+#include <xercesc/framework/psvi/XSModelGroup.hpp>
+#include <xercesc/framework/psvi/XSAnnotation.hpp>
+#include <xercesc/framework/psvi/XSValue.hpp>
+#include <xercesc/framework/XMLGrammarPoolImpl.hpp>
+#include <xercesc/dom/DOM.hpp>
+#include <xercesc/dom/DOMLSInput.hpp>
+#include <xercesc/dom/DOMElement.hpp>
+
+#include "../GLM.h"
+#include "Util/XercesString.h"
+#include "ResourceManager.h"
+#include "Entity.h"
+#include "ComponentInfo.h"
+
+class EntityFileHandler
+{
+    friend class EntityFileSAXHandler;
+public:
+    // @param EntityID The entity found
+    // @param EntityID The parent of the entity
+    typedef std::function<void(EntityID, EntityID, const std::string&)> OnStartEntityCallback;
+    void SetStartEntityCallback(OnStartEntityCallback c) { m_OnStartEntityCallback = c; }
+    // @param EntityID The entity the component corresponds to
+    // @param std::string Type name of the component
+    typedef std::function<void(EntityID, const std::string&)> OnStartComponentCallback;
+    void SetStartComponentCallback(OnStartComponentCallback c) { m_OnStartComponentCallback = c; }
+    // @param EntityID Entity 
+    // @param std::string Component name 
+    // @param std::string Field name
+    // @param std::map<std::string, std::string> Field attribute names and values
+    typedef std::function<void(EntityID, const std::string&, const std::string&, const std::map<std::string, std::string>&)> OnStartFieldCallback;
+    void SetStartFieldCallback(OnStartFieldCallback c) { m_OnStartFieldCallback = c; }
+    // @param EntityID Entity 
+    // @param std::string Component name 
+    // @param std::string Field name
+    // @param char* Field data
+    typedef std::function<void(EntityID, const std::string&, const std::string&, const char*)> OnStartFieldDataCallback;
+    void SetStartFieldDataCallback(OnStartFieldDataCallback c) { m_OnStartFieldDataCallback = c; }
+
+private:
+    OnStartEntityCallback m_OnStartEntityCallback = nullptr;
+    OnStartComponentCallback m_OnStartComponentCallback = nullptr;
+    OnStartFieldCallback m_OnStartFieldCallback = nullptr;
+    OnStartFieldDataCallback m_OnStartFieldDataCallback = nullptr;
+};
+
+class EntityFileSAXHandler : public xercesc::DefaultHandler
+{
+public:
+    enum class State
+    {
+        Unknown,
+        Entity,
+        Component,
+        ComponentField
+    };
+
+    EntityFileSAXHandler(const EntityFileHandler* handler, xercesc::SAX2XMLReader* reader);
+
+    void startElement(const XMLCh* const _uri, const XMLCh* const _localName, const XMLCh* const _qname, const xercesc::Attributes& attrs) override;
+    void characters(const XMLCh* const chars, const XMLSize_t length) override;
+    void endElement(const XMLCh* const _uri, const XMLCh* const _localName, const XMLCh* const _qname) override;
+
+    void warning(const xercesc::SAXParseException& e);
+    void error(const xercesc::SAXParseException& e);
+    void fatalError(const xercesc::SAXParseException& e);
+
+private:
+    const EntityFileHandler* m_Handler;
+    xercesc::XMLGrammarPool* m_GrammarPool;
+    xercesc::SAX2XMLReader* m_Reader;
+    //State m_CurrentScope = State::Unknown;
+    std::stack<State> m_StateStack;
+    unsigned int m_NextEntityID = 0;
+    std::stack<EntityID> m_EntityStack;
+    std::string m_CurrentComponent;
+    std::string m_CurrentField;
+    std::map<std::string, std::string> m_CurrentAttributes;
+
+    void onStartEntity(const xercesc::Attributes& attrs); 
+    void onEndEntity();
+    void onStartEntityRef(const xercesc::Attributes& attrs);
+    void onStartComponent(const std::string& name);
+    void onEndComponent(const std::string& name);
+    void onStartComponentField(const std::string& field, const xercesc::Attributes& attrs);
+    void onEndComponentField(const std::string& field);
+    void onFieldData(char* data);
+};
+
+class EntityFileXMLErrorHandler : public xercesc::ErrorHandler
+{
+public:
+	void warning(const xercesc::SAXParseException& e) override
+	{
+		reportParseException("Warning", e);
+	}
+	void error(const xercesc::SAXParseException& e) override
+	{
+		reportParseException("Error", e);
+	}
+	void fatalError(const xercesc::SAXParseException& e) override
+	{
+		reportParseException("FATAL ERROR", e);
+	}
+	void resetErrors() override { }
+
+private:
+	void reportParseException(std::string type, const xercesc::SAXParseException& e)
+	{
+		char* message = xercesc::XMLString::transcode(e.getMessage());
+		char* systemID = xercesc::XMLString::transcode(e.getSystemId());
+		std::cerr << systemID << ":" << e.getLineNumber() << ":" << e.getColumnNumber() << std::endl;
+		std::cerr << type << ": " << message << std::endl;
+		xercesc::XMLString::release(&systemID);
+		xercesc::XMLString::release(&message);
+	}
+};
+
+class EntityXMLFile : public Resource
+{
+    friend class ResourceManager;
+    friend class EntityFileSAXHandler;
+private:
+    EntityXMLFile(boost::filesystem::path path);
+    ~EntityXMLFile();
+
+public:
+    static unsigned int GetTypeStride(std::string typeName);
+    static void WriteAttributeData(char* outData, const ComponentInfo::Field_t& field, const std::map<std::string, std::string>& attributes);
+    static void WriteValueData(char* outData, const ComponentInfo::Field_t& field, const char* valueData);
+
+    xercesc::XMLGrammarPool* GrammarPool() const { return m_GrammarPool; }
+
+    void Parse(const EntityFileHandler* handler) const;
+
+private:
+    boost::filesystem::path m_FilePath;
+    xercesc::XMLGrammarPool* m_GrammarPool;
+    xercesc::SAX2XMLReader* m_SAX2XMLReader;
+	//std::map<std::string, ::ComponentInfo> m_ComponentInfo;
+    //std::vector<std::string> m_EntityReferences;
+
+    static void setReaderFeatures(xercesc::SAX2XMLReader* reader);
+};
+
+#endif

include/Engine/Core/EntityXMLFileParser.h

@@ -1,18 +1,19 @@
-#ifndef EntityFileParser_h__
-#define EntityFileParser_h__
+#ifndef EntityXMLFileParser_h__
+#define EntityXMLFileParser_h__
 
-#include "EntityFile.h"
+#include "EntityXMLFile.h"
 #include "World.h"
 
-class EntityFileParser
+class EntityXMLFileParser
 {
+    friend class EntityFile;
 public:
-    EntityFileParser(const EntityFile* entityFile);
-
-    EntityID MergeEntities(World* world, EntityID baseParent = EntityID_Invalid);
+    EntityXMLFileParser(const EntityXMLFile* entityFile);
 
 private:
-    const EntityFile* m_EntityFile;
+    EntityID MergeEntities(World* world, EntityID baseParent = EntityID_Invalid);
+
+    const EntityXMLFile* m_EntityFile;
     EntityFileHandler m_Handler;
     World* m_World = nullptr;
     EntityID m_FirstEntity = EntityID_Invalid;

include/Engine/Core/EntityXMLFilePreprocessor.h

@@ -1,5 +1,5 @@
-#ifndef EntityFilePreprocessor_h__
-#define EntityFilePreprocessor_h__
+#ifndef EntityXMLFilePreprocessor_h__
+#define EntityXMLFilePreprocessor_h__
 
 #include <xercesc/framework/psvi/XSElementDeclaration.hpp>
 #include <xercesc/framework/psvi/XSComplexTypeDefinition.hpp>
@@ -17,17 +17,18 @@
 #include "Util/XercesString.h"
 #include "ResourceManager.h"
 #include "World.h"
-#include "EntityFile.h"
+#include "EntityXMLFile.h"
 
-class EntityFilePreprocessor
+class EntityXMLFilePreprocessor
 {
+    friend class EntityFile;
 public:
-    EntityFilePreprocessor(const EntityFile* entityFile);
-
-    void RegisterComponents(World* world);
+    EntityXMLFilePreprocessor(const EntityXMLFile* entityFile);
 
 private:
-    const EntityFile* m_EntityFile;
+    void RegisterComponents(World* world);
+
+    const EntityXMLFile* m_EntityFile;
     std::map<std::string, unsigned int> m_ComponentCounts;
 	std::map<std::string, ComponentInfo> m_ComponentInfo;
 

include/Engine/Core/EntityXMLFileWriter.h

@@ -1,5 +1,5 @@
-#ifndef EntityFileWriter_h__
-#define EntityFileWriter_h__
+#ifndef EntityXMLFileWriter_h__
+#define EntityXMLFileWriter_h__
 
 #include <boost/filesystem.hpp>
 #include <xercesc/dom/DOM.hpp>
@@ -8,13 +8,13 @@
 #include <xercesc/framework/LocalFileFormatTarget.hpp>
 
 #include "Util/XercesString.h"
-#include "EntityFile.h"
+#include "EntityXMLFile.h"
 #include "World.h"
 
-class EntityFileWriter
+class EntityXMLFileWriter
 {
 public:
-    EntityFileWriter(boost::filesystem::path file)
+    EntityXMLFileWriter(boost::filesystem::path file)
         : m_FilePath(file)
     {
         using namespace xercesc;

include/Engine/Core/MemoryPool.h

@@ -118,9 +118,6 @@ public:
 		else {
 			m_ExtraMemory.push_back((char*)malloc(m_Stride));
 			//We should preferably not enter here to avoid performance issues. Set more numMaxElements in constructor instead.
-            if (!DisableMemoryPool::Value) {
-			    LOG_DEBUG("Allocated slots exceed Pool size, extra memory allocated dynamically. Pool size: %u, dynamic size: %u.", m_NumSlots, m_ExtraMemory.size());
-            }
 			return m_ExtraMemory.back();
 		}
 	}

include/Engine/Core/World.h

@@ -6,6 +6,7 @@
 #include "ObjectPool.h"
 #include "ComponentPool.h"
 #include "EventBroker.h"
+struct EntityWrapper;
 
 class World
 {
@@ -18,13 +19,13 @@ public:
     World(const World& other);
 
     // Create empty entity
-    EntityID CreateEntity(EntityID parent = 0);
+    EntityID CreateEntity(EntityID parent = EntityID_Invalid);
     // Delete entity and all components within
     void DeleteEntity(EntityID entity);
     // Check if an entity exists
     bool ValidEntity(EntityID entity) const;
     // Register a component type and allocate space for it
-    void RegisterComponent(ComponentInfo& ci);
+    void RegisterComponent(const ComponentInfo& ci);
     // Attach a component to an entity and fill it with default values
     ComponentWrapper AttachComponent(EntityID entity, const std::string& componentType);
     // Check if an entity has a component
@@ -49,6 +50,12 @@ public:
     void SetName(EntityID entity, const std::string& name);
     // Get the textual name of an entity
     std::string GetName(EntityID entity) const;
+    // Get the first entity in the world with the name.
+    EntityWrapper GetFirstEntityByName(const std::string& name);
+
+    // Merge another world into this one
+    // Returns a map that maps entities from the other world to their copies in this one
+    std::unordered_map<EntityID, EntityID> Merge(const World* other);
 
 private:
     EventBroker* m_EventBroker = nullptr;

include/Engine/Editor/EditorGUI.h

@@ -22,7 +22,6 @@
 #include "../Core/ELockMouse.h"
 #include "../Core/EFileDropped.h"
 #include "../Rendering/Texture.h"
-#include "Game/Events/ESpawnerSpawn.h"
 
 class EditorGUI
 {

include/Engine/Editor/EditorSystem.h

@@ -5,9 +5,8 @@
 #include "../Core/World.h"
 #include "../Core/SystemPipeline.h"
 #include "../Core/ResourceManager.h"
-#include "../Core/EntityFilePreprocessor.h"
-#include "../Core/EntityFileParser.h"
-#include "../Core/EntityFileWriter.h"
+#include "../Core/EntityFile.h"
+#include "../Core/EntityXMLFileWriter.h"
 #include "../Core/EMousePress.h"
 #include "../Input/EInputCommand.h"
 #include "EditorGUI.h"

include/Engine/Input/FirstPersonInputController.h

@@ -27,7 +27,7 @@ public:
     virtual bool OnCommand(const Events::InputCommand& e) override;
     virtual void Reset();
 
-    void AssaultDashCheck(double dt, bool isJumping, double assaultDashCoolDownMaxTimer);
+    void AssaultDashCheck(double dt, bool isJumping, double assaultDashCoolDownMaxTimer, double& assaultDashCoolDownTimer, EntityID playerID);
     virtual bool AssaultDashDoubleTapped() const { return m_AssaultDashDoubleTapped; }
     virtual bool PlayerIsDashing() const { return m_PlayerIsDashing; }
 
@@ -41,7 +41,7 @@ protected:
     bool m_Crouching = false;
     //assault dash membervariables - needed to calculate the doubletap- and dashlogic
     double m_AssaultDashDoubleTapDeltaTime = 0.0;
-    double m_AssaultDashCoolDownTimer = 0.0;
+    double m_DashEffectResetTimer = 0.0;
     //i will let m_AssaultDashDoubleTapSensitivityTimer stay hardcoded, its not really a gamevariable (more an inputvariable), 
     //and its very unlikely that someone wants to change that value
     const float m_AssaultDashDoubleTapSensitivityTimer = 0.25f;
@@ -52,7 +52,7 @@ protected:
     bool m_ShiftDashing = false;
     bool m_ValidDoubleTap = false;
 
-    //specialabilitys
+    //specialabilities
     bool m_MovementKeyDown = false;
     bool m_SpecialAbilityKeyDown = false;
     int m_NumberOfMovementKeysDown = 0;
@@ -191,23 +191,33 @@ bool FirstPersonInputController<EventContext>::OnLockMouse(const Events::LockMou
 }
 
 template <typename EventContext>
-void FirstPersonInputController<EventContext>::AssaultDashCheck(double dt, bool isJumping, double assaultDashCoolDownMaxTimer) {
+void FirstPersonInputController<EventContext>::AssaultDashCheck(double dt, bool isJumping, double assaultDashCoolDownMaxTimer, double& assaultDashCoolDownTimer, EntityID playerID) {
     m_AssaultDashDoubleTapDeltaTime += dt;
-    m_AssaultDashCoolDownTimer -= dt;
+    m_DashEffectResetTimer += dt;
+    assaultDashCoolDownTimer -= dt;
     //cooldown = assaultDashCoolDownMaxTimer sec, pretend the dash lasts 0.25 sec (for friction to do its work)
-    if (m_AssaultDashCoolDownTimer > (assaultDashCoolDownMaxTimer - 0.25f)) {
+    if (assaultDashCoolDownTimer > (assaultDashCoolDownMaxTimer - 0.25f)) {
         m_PlayerIsDashing = true;
+        if (m_DashEffectResetTimer > 0.05) {
+            Events::DashAbility e;
+            e.Player = playerID;
+            m_EventBroker->Publish(e);
+            m_DashEffectResetTimer = 0.0;
+        }
     } else {
         m_PlayerIsDashing = false;
     }
 
     //dashing with shift
-    if (m_ShiftDashing && m_AssaultDashCoolDownTimer <= 0.0f) {
+    if (m_ShiftDashing && assaultDashCoolDownTimer <= 0.0f) {
         //player is dashing with shift
         //the wanted-direction is set in playermovement already so we dont need to check what direction we want to dash in!
-        m_AssaultDashCoolDownTimer = assaultDashCoolDownMaxTimer;
+        assaultDashCoolDownTimer = assaultDashCoolDownMaxTimer;
         m_AssaultDashDoubleTapped = true;
         m_AssaultDashDoubleTapDeltaTime = 0.f;
+        Events::DashAbility e;
+        e.Player = playerID;
+        m_EventBroker->Publish(e);
         return;
     }
 
@@ -227,7 +237,7 @@ void FirstPersonInputController<EventContext>::AssaultDashCheck(double dt, bool
     }
     m_ValidDoubleTap = false;
 
-    if (!(m_AssaultDashCoolDownTimer <= 0.0f)) {
+    if (!(assaultDashCoolDownTimer <= 0.0f)) {
         //if we cant dash at the moment, then just reset the tap-sensitivity-timer
         m_AssaultDashDoubleTapDeltaTime = 0.f;
         return;
@@ -235,9 +245,10 @@ void FirstPersonInputController<EventContext>::AssaultDashCheck(double dt, bool
     //ok, we have a valid tap, lets do it
     m_AssaultDashDoubleTapped = true;
     m_AssaultDashDoubleTapDeltaTime = 0.f;
-    m_AssaultDashCoolDownTimer = assaultDashCoolDownMaxTimer;
+    assaultDashCoolDownTimer = assaultDashCoolDownMaxTimer;
 
     Events::DashAbility e;
+    e.Player = playerID;
     m_EventBroker->Publish(e);
 }
 

include/Engine/Network/Client.h

@@ -26,7 +26,9 @@
 #include "Network/EInterpolate.h"
 #include "Network/SnapshotFilter.h"
 #include "Core/EPlayerSpawned.h"
+#include "Core/EAmmoPickup.h"
 #include "Network/ESearchForServers.h"
+#include "../Game/Events/EDashAbility.h"
 
 struct ServerInfo
 {
@@ -106,7 +108,9 @@ private:
     void parsePlayerDamage(Packet& packet);
     void parseComponentDeletion(Packet& packet);
     void parseDoubleJump(Packet& packet);
-    void InterpolateFields(Packet & packet, const ComponentInfo & componentInfo, const EntityID & entityID, const std::string & componentType);
+    void parseDashEffect(Packet& packet);
+    void parseAmmoPickup(Packet& packet);
+    void InterpolateFields(Packet& packet, const ComponentInfo & componentInfo, const EntityID & entityID, const std::string & componentType);
     void parseSnapshot(Packet& packet);
     void identifyPacketLoss();
     void hasServerTimedOut();
@@ -133,6 +137,9 @@ private:
     EventRelay< Client, Events::SearchForServers> m_ESearchForServers;
     EventRelay<Client, Events::DoubleJump> m_EDoubleJump;
     bool OnDoubleJump(Events::DoubleJump & e);
+    EventRelay<Client, Events::DashAbility> m_EDashAbility;
+    bool OnDashAbility(const Events::DashAbility& e);
+
     bool OnSearchForServers(const Events::SearchForServers& e);
     UDPClient m_ServerlistRequest;
     std::vector<ServerInfo> m_Serverlist;

include/Engine/Network/MessageType.h

@@ -20,7 +20,9 @@ enum class MessageType
     ComponentDeleted,
     PlayerTransform,
     OnDoubleJump,
+    OnDashEffect,
     ServerlistRequest,
+    AmmoPickup,
     Invalid
 };
 

include/Engine/Network/Server.h

@@ -20,6 +20,7 @@
 #include "../Game/Events/EDoubleJump.h"
 #include "Core/EEntityDeleted.h"
 #include "Core/EComponentDeleted.h"
+#include "Core/EAmmoPickup.h"
 
 class Server : public Network
 {
@@ -82,13 +83,14 @@ private:
     void parseClientPing();
     void parsePing();
     bool parseDoubleJump(Packet& packet);
+    void parseDashEffect(Packet& packet);
     void parseUDPConnect(Packet& packet);
     void parseTCPConnect(Packet& packet);
     void parseDisconnect();
     void parseServerlistRequest(boost::asio::ip::udp::endpoint endpoint);
     bool shouldSendToClient(EntityWrapper childEntity);
 
-    // Debug event
+    // Events
     EventRelay<Server, Events::InputCommand> m_EInputCommand;
     bool OnInputCommand(const Events::InputCommand& e);
     EventRelay<Server, Events::PlayerSpawned> m_EPlayerSpawned;
@@ -99,6 +101,8 @@ private:
     bool OnComponentDeleted(const Events::ComponentDeleted& e);
     EventRelay<Server, Events::PlayerDamage> m_EPlayerDamage;
     bool OnPlayerDamage(const Events::PlayerDamage& e);
+    EventRelay<Server, Events::AmmoPickup> m_EAmmoPickup;
+    bool OnAmmoPickup(const Events::AmmoPickup& e);
 };
 
 #endif

include/Engine/Rendering/DrawColorCorrectionPass.h

@@ -17,7 +17,7 @@ public:
     void InitializeFrameBuffers();
     void InitializeShaderPrograms();
 
-    void Draw(GLuint sceneTexture, GLuint bloomTexture, GLuint sceneTextureLowRes, GLuint bloomTextureLowRes, GLfloat gamma, GLfloat exposure);
+    void Draw(GLuint sceneTexture, GLuint bloomTexture, GLfloat gamma, GLfloat exposure);
 private:
     const IRenderer* m_Renderer;
 

include/Engine/Rendering/DrawFinalPass.h

@@ -15,7 +15,7 @@
 class DrawFinalPass
 {
 public:
-    DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCullingPass, CubeMapPass* cubeMapPass, SSAOPass* ssaoPass, GLuint* depthBuffer);
+    DrawFinalPass(IRenderer* renderer, LightCullingPass* lightCullingPass, CubeMapPass* cubeMapPass, SSAOPass* ssaoPass);
     ~DrawFinalPass() { }
     void InitializeTextures();
     void InitializeFrameBuffers();
@@ -26,20 +26,17 @@ public:
 
     //Return the texture that is used in later stages to apply the bloom effect
     GLuint BloomTexture() const { return m_BloomTexture; }
-    GLuint BloomTextureLowRes() const { return m_BloomTextureLowRes; }
     //Return the texture with diffuse and lighting of the scene.
     GLuint SceneTexture() const { return m_SceneTexture; }
-    GLuint SceneTextureLowRes() const { return m_SceneTextureLowRes; }
     //Return the framebuffer used in the scene rendering stage.
     FrameBuffer* FinalPassFrameBuffer() { return &m_FinalPassFrameBuffer; }
-    FrameBuffer* FinalPassFrameBufferLowRes() { return &m_FinalPassFrameBufferLowRes; }
 
 private:
     void DrawSprites(std::list<std::shared_ptr<RenderJob>>&jobs, RenderScene& scene);
     void DrawModelRenderQueues(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene);
-    void DrawShieldToStencilBuffer(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene);
+	void DrawModelRenderQueuesWithShieldCheck(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene);
     void DrawShieldedModelRenderQueue(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene);
-    void DrawToDepthBuffer(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene);
+    void DrawToDepthStencilBuffer(std::list<std::shared_ptr<RenderJob>>& jobs, RenderScene& scene);
 
     void BindExplosionUniforms(GLuint shaderHandle, std::shared_ptr<ExplosionEffectJob>& job, RenderScene& scene);
     void BindModelUniforms(GLuint shaderHandle, std::shared_ptr<ModelJob>& job, RenderScene& scene);
@@ -54,13 +51,11 @@ private:
     Texture* m_ErrorTexture;
 
     FrameBuffer m_FinalPassFrameBuffer;
-    FrameBuffer m_FinalPassFrameBufferLowRes;
+	FrameBuffer m_ShieldDepthFrameBuffer;
     GLuint m_BloomTexture;
     GLuint m_SceneTexture;
-    GLuint m_BloomTextureLowRes;
-    GLuint m_SceneTextureLowRes;
-    GLuint* m_DepthBuffer;
-    GLuint m_DepthBufferLowRes;
+    GLuint m_DepthBuffer;
+	GLuint m_ShieldBuffer;
     GLuint m_CubeMapTexture;
 
     //maqke this component based i guess?
@@ -76,16 +71,27 @@ private:
 	ShaderProgram* m_ExplosionEffectSplatMapProgram;
     ShaderProgram* m_SpriteProgram;
 	ShaderProgram* m_ForwardPlusSplatMapProgram;
-    ShaderProgram* m_ShieldToStencilProgram;
-    ShaderProgram* m_FillDepthBufferProgram;
+    ShaderProgram* m_FillDepthStencilBufferProgram;
+
+	ShaderProgram* m_ForwardPlusShieldCheckProgram;
+	ShaderProgram* m_ExplosionEffectShieldCheckProgram;
+	ShaderProgram* m_ExplosionEffectSplatMapShieldCheckProgram;
+	ShaderProgram* m_SpriteShieldCheckProgram;
+	ShaderProgram* m_ForwardPlusSplatMapShieldCheckProgram;
+
 
 
 	ShaderProgram* m_ForwardPlusSkinnedProgram;
 	ShaderProgram* m_ExplosionEffectSkinnedProgram;
 	ShaderProgram* m_ExplosionEffectSplatMapSkinnedProgram;
 	ShaderProgram* m_ForwardPlusSplatMapSkinnedProgram;
-    ShaderProgram* m_ShieldToStencilSkinnedProgram;
-    ShaderProgram* m_FillDepthBufferSkinnedProgram;
+    ShaderProgram* m_FillDepthStencilBufferSkinnedProgram;
+
+	ShaderProgram* m_ForwardPlusSkinnedShieldCheckProgram;
+	ShaderProgram* m_ExplosionEffectSkinnedShieldCheckProgram;
+	ShaderProgram* m_ExplosionEffectSplatMapSkinnedShieldCheckProgram;
+	ShaderProgram* m_ForwardPlusSplatMapSkinnedShieldCheckProgram;
+	ShaderProgram* m_FillDepthBufferSkinnedShieldCheckProgram;
 };
 
 #endif 

include/Engine/Rendering/ExplosionEffectJob.h

@@ -15,8 +15,8 @@
 
 struct ExplosionEffectJob : ModelJob
 {
-    ExplosionEffectJob(ComponentWrapper explosionEffectComponent, ::Model* model, Camera* camera, glm::mat4 matrix, ::RawModel::MaterialProperties matGroup, ComponentWrapper modelComponent, ::World* world, glm::vec4 fillColor, float fillPercentage)
-        : ModelJob(model, camera, matrix, matGroup, modelComponent, world, fillColor, fillPercentage)
+    ExplosionEffectJob(ComponentWrapper explosionEffectComponent, ::Model* model, Camera* camera, glm::mat4 matrix, ::RawModel::MaterialProperties matGroup, ComponentWrapper modelComponent, ::World* world, glm::vec4 fillColor, float fillPercentage, bool isShielded)
+        : ModelJob(model, camera, matrix, matGroup, modelComponent, world, fillColor, fillPercentage, isShielded)
     {
         ExplosionOrigin = (glm::vec3)explosionEffectComponent["ExplosionOrigin"];
         TimeSinceDeath = (double)explosionEffectComponent["TimeSinceDeath"];

include/Engine/Rendering/ModelJob.h

@@ -18,7 +18,7 @@
 
 struct ModelJob : RenderJob
 {
-    ModelJob(Model* model, Camera* camera, glm::mat4 matrix, ::RawModel::MaterialProperties matProp, ComponentWrapper modelComponent, World* world, glm::vec4 fillColor, float fillPercentage)
+    ModelJob(Model* model, Camera* camera, glm::mat4 matrix, ::RawModel::MaterialProperties matProp, ComponentWrapper modelComponent, World* world, glm::vec4 fillColor, float fillPercentage, bool isShielded)
         : RenderJob()
     {
         Model = model;
@@ -117,7 +117,7 @@ struct ModelJob : RenderJob
 
         FillColor = fillColor;
         FillPercentage = fillPercentage;
-
+		IsShielded = isShielded;
 
         if (model->IsSkinned()) {
             Skeleton = Model->m_RawModel->m_Skeleton;
@@ -181,7 +181,7 @@ struct ModelJob : RenderJob
 
     glm::vec4 FillColor = glm::vec4(0);
     float FillPercentage = 0.0;
-
+	bool IsShielded;
     void CalculateHash() override
     {
         Hash = ShaderID << 20 + ModelID << 10 + TextureID;

include/Engine/Rendering/RenderQueue.h

@@ -24,7 +24,6 @@ struct RenderScene
         std::list<std::shared_ptr<RenderJob>> OpaqueObjects;
         std::list<std::shared_ptr<RenderJob>> TransparentObjects;
         std::list<std::shared_ptr<RenderJob>> OpaqueShieldedObjects;
-        std::list<std::shared_ptr<RenderJob>> TransparentShieldedObjects;
         std::list<std::shared_ptr<RenderJob>> ShieldObjects;
         std::list<std::shared_ptr<RenderJob>> SpriteJob;
         std::list<std::shared_ptr<RenderJob>> PointLight;
@@ -41,7 +40,6 @@ struct RenderScene
         Jobs.OpaqueObjects.clear();
         Jobs.TransparentObjects.clear();
         Jobs.OpaqueShieldedObjects.clear();
-        Jobs.TransparentShieldedObjects.clear();
         Jobs.ShieldObjects.clear();
         Jobs.SpriteJob.clear();
         Jobs.DirectionalLight.clear();

include/Game/Events/EDashAbility.h

@@ -2,11 +2,15 @@
 #define Events_DashAbility_h__
 
 #include "Core/Event.h"
+#include "Core/EntityWrapper.h"
 
 namespace Events
 {
 
-struct DashAbility : public Event { };
+struct DashAbility : public Event 
+{
+    EntityID Player;
+};
 
 }
 

include/Game/Game.h

@@ -13,13 +13,13 @@
 #include "Input/KeyboardInputHandler.h"
 #include "Input/MouseInputHandler.h"
 #include "Core/EKeyDown.h"
-#include "Core/EntityFilePreprocessor.h"
+#include "Core/EntityXMLFilePreprocessor.h"
 #include "Core/SystemPipeline.h"
 #include "Systems/ExplosionEffectSystem.h"
 #include "Editor/EditorSystem.h"
-#include "Core/EntityFile.h"
+#include "Core/EntityXMLFile.h"
 #include "Rendering/RenderSystem.h"
-#include "Core/EntityFileParser.h"
+#include "Core/EntityXMLFileParser.h"
 #include "Core/Octree.h"
 #include "Rendering/Font.h"
 #include "Systems/InterpolationSystem.h"

include/Game/Systems/AbilityCooldownHUDSystem.h

@@ -0,0 +1,17 @@
+#ifndef AbilityCooldownHUDSystem_h__
+#define AbilityCooldownHUDSystem_h__
+
+#include "../../Engine/Core/System.h"
+#include "../../Engine/GLM.h"
+
+class AbilityCooldownHUDSystem : public ImpureSystem
+{
+public:
+    AbilityCooldownHUDSystem(SystemParams params)
+        : System(params)
+    { }
+
+    virtual void Update(double dt) override;
+};
+
+#endif

include/Game/Systems/AmmoPickupSystem.h

@@ -4,7 +4,7 @@
 #include "Core/System.h"
 #include "Core/Transform.h"
 #include "Core/ResourceManager.h"
-#include "Core/EntityFileParser.h"
+#include "Core/EntityFile.h"
 #include "Core/EPickupSpawned.h"
 #include "Core/EAmmoPickup.h"
 #include "Engine/Collision/ETrigger.h"
@@ -20,6 +20,11 @@ public:
 private:
     EventRelay<AmmoPickupSystem, Events::TriggerTouch> m_ETriggerTouch;
     bool OnTriggerTouch(Events::TriggerTouch& e);
+    EventRelay<AmmoPickupSystem, Events::TriggerLeave> m_ETriggerLeave;
+    bool OnTriggerLeave(Events::TriggerLeave& e);
+
+    EventRelay<AmmoPickupSystem, Events::AmmoPickup> m_EAmmoPickup;
+    bool OnAmmoPickup(Events::AmmoPickup& e);
 
     struct NewAmmoPickup {
         glm::vec3 Pos;
@@ -29,5 +34,11 @@ private:
         EntityID parentID;
     };
     std::vector<NewAmmoPickup> m_ETriggerTouchVector;
+    struct EntityAtMaxValuePickupStruct {
+        EntityWrapper player;
+        EntityWrapper trigger;
+    };
+    std::vector<EntityAtMaxValuePickupStruct> m_PickupAtMaximum;
+    void DoPickup(EntityWrapper &player, EntityWrapper &trigger);
 };
 #endif

include/Game/Systems/BoostIconsHUDSystem.h

@@ -0,0 +1,19 @@
+#ifndef BoostIconsHUDSystem_h__
+#define BoostIconsHUDSystem_h__
+
+#include "../../Engine/Core/System.h"
+#include "../../Engine/GLM.h"
+
+class BoostIconsHUDSystem : public PureSystem
+{
+public:
+    BoostIconsHUDSystem(SystemParams params)
+        : System(params)
+        , PureSystem("BoostIconsHUD")
+    { }
+
+    virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& capturePoint, double dt) override;
+
+};
+
+#endif

include/Game/Systems/BoostSystem.h

@@ -0,0 +1,21 @@
+#ifndef BoostSystem_h__
+#define BoostSystem_h__
+
+#include "Core/System.h"
+#include "Core/ResourceManager.h"
+#include "Core/EntityFile.h"
+#include "Core/EPlayerDamage.h"
+#include "Common.h"
+
+class BoostSystem : public System
+{
+public:
+    BoostSystem(SystemParams params);
+
+private:
+    EventRelay<BoostSystem, Events::PlayerDamage> m_EPlayerDamage;
+    bool OnPlayerDamage(Events::PlayerDamage& e);
+
+    std::string DetermineClass(EntityWrapper player);
+};
+#endif

include/Game/Systems/CapturePointArrowHUDSystem.h

@@ -0,0 +1,30 @@
+#ifndef CapturePointArrowHUDSystem_h__
+#define CapturePointArrowHUDSystem_h__
+
+#include <GLFW/glfw3.h>
+#include <glm/common.hpp>
+#include <glm/gtx/vector_angle.hpp>
+
+#include "Common.h"
+#include "Core/System.h"
+#include "Core/Transform.h"
+#include "Core/ECaptured.h"
+
+
+class CapturePointArrowHUDSystem : public ImpureSystem
+{
+public:
+    CapturePointArrowHUDSystem(SystemParams params);
+
+    virtual void Update(double dt) override;
+
+private:
+    EventRelay<CapturePointArrowHUDSystem, Events::Captured> m_ECapturedEvent;
+    bool OnCapturePointCaptured(Events::Captured& e);
+
+    bool m_InitialtargetsSet = false;
+    glm::vec3 m_RedTeamCurrentTarget;
+    glm::vec3 m_BlueTeamCurrentTarget;
+};
+
+#endif

include/Game/Systems/CapturePointHUDSystem.h

@@ -7,7 +7,7 @@
 
 #include "Common.h"
 #include "Core/System.h"
-#include "Engine/Collision/ETrigger.h"
+#include "Collision/ETrigger.h"
 
 class CapturePointHUDSystem : public ImpureSystem
 {

include/Game/Systems/CapturePointSystem.h

@@ -42,9 +42,9 @@ private:
     int m_NumberOfCapturePoints = 0;
     std::map<int, EntityWrapper> m_CapturePointNumberToEntityMap;
 
-    //std::vector<ComponentWrapper>
-
     bool m_ResetTimers = false;
+    bool m_RecentlyCapturedNeedNextCapturePointNow = false;
+    Events::Captured m_CapturedEvent;
 
     //vectors which will keep track of enter/leave changes
     std::vector<std::tuple<EntityWrapper, EntityWrapper>> m_ETriggerTouchVector;

include/Game/Systems/DamageIndicatorSystem.h

@@ -4,7 +4,7 @@
 #include "Core/System.h"
 #include "Core/Transform.h"
 #include "Core/ResourceManager.h"
-#include "Core/EntityFileParser.h"
+#include "Core/EntityFile.h"
 #include "Core/EPlayerDamage.h"
 #include "Common.h"
 #include <tuple>

include/Game/Systems/FloatingEffectSystem.h

@@ -0,0 +1,19 @@
+#include "Common.h"
+#include "Core/System.h"
+
+class FloatingEffectSystem : public PureSystem
+{
+public:
+    FloatingEffectSystem(SystemParams params)
+        : System(params)
+        , PureSystem("FloatingEffect")
+    { }
+
+    virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt) override
+    {
+        ComponentWrapper& transform = m_World->GetComponent(component.EntityID, "Transform");
+        (double&)component["Time"] += dt;
+        (glm::vec3&)transform["Position"] = (float)(double)component["Amplitude"] * glm::sin((glm::two_pi<float>() / (float)(double)component["Period"]) *  (float)(double)component["Time"]) * (glm::vec3)component["Axis"];
+
+    }
+};

include/Game/Systems/PickupSpawnSystem.h

@@ -4,12 +4,11 @@
 #include "Core/System.h"
 #include "Core/Transform.h"
 #include "Core/ResourceManager.h"
-#include "Core/EntityFileParser.h"
+#include "Core/EntityFile.h"
 #include "Core/EPickupSpawned.h"
 #include "Core/EPlayerHealthPickup.h"
 #include "Engine/Collision/ETrigger.h"
 #include "Common.h"
-#include <tuple>
 
 class PickupSpawnSystem : public ImpureSystem
 {
@@ -21,6 +20,8 @@ public:
 private:
     EventRelay<PickupSpawnSystem, Events::TriggerTouch> m_ETriggerTouch;
     bool OnTriggerTouch(Events::TriggerTouch& e);
+    EventRelay<PickupSpawnSystem, Events::TriggerLeave> m_ETriggerLeave;
+    bool OnTriggerLeave(Events::TriggerLeave& e);
 
     struct NewHealthPickup {
         glm::vec3 Pos;
@@ -30,5 +31,11 @@ private:
         EntityID parentID;
     };
     std::vector<NewHealthPickup> m_ETriggerTouchVector;
+    struct EntityAtMaxValuePickupStruct {
+        EntityWrapper player;
+        EntityWrapper trigger;
+    };
+    std::vector<EntityAtMaxValuePickupStruct> m_PickupAtMaximum;
+    void DoPickup(EntityWrapper &player, EntityWrapper &trigger);
 };
 #endif

include/Game/Systems/PlayerDeathSystem.h

@@ -6,11 +6,9 @@
 #include "GLM.h"
 #include "Rendering/ESetCamera.h"
 #include "Core/ConfigFile.h"
-
 #include "Core/EntityFile.h"
-#include "Core/EntityFileParser.h"
-
 #include "Core/EPlayerDeath.h"
+#include "Core/EEntityDeleted.h"
 
 class PlayerDeathSystem : public ImpureSystem
 {
@@ -20,8 +18,12 @@ public:
     virtual void Update(double dt) override;
 
 private:
+    EntityWrapper m_LocalPlayerDeathEffect;
+
     EventRelay<PlayerDeathSystem, Events::PlayerDeath> m_OnPlayerDeath;
     bool OnPlayerDeath(Events::PlayerDeath& e);
+    EventRelay<PlayerDeathSystem, Events::EntityDeleted> m_EEntityDeleted;
+    bool OnEntityDeleted(Events::EntityDeleted& e);
 
     void createDeathEffect(EntityWrapper player);
 

include/Game/Systems/PlayerMovementSystem.h

@@ -6,9 +6,7 @@
 #include <imgui/imgui.h>
 #include "Events/EDoubleJump.h"
 #include "../Engine/Sound/EPlaySoundOnEntity.h"
-
 #include "Core/EntityFile.h"
-#include "Core/EntityFileParser.h"
 
 class PlayerMovementSystem : public ImpureSystem
 {
@@ -41,6 +39,8 @@ private:
     bool OnPlayerSpawned(Events::PlayerSpawned& e);
     EventRelay<PlayerMovementSystem, Events::DoubleJump> m_EDoubleJump;
     bool PlayerMovementSystem::OnDoubleJump(Events::DoubleJump & e);
+    EventRelay<PlayerMovementSystem, Events::DashAbility> m_EDashAbility;
+    bool PlayerMovementSystem::OnDashAbility(Events::DashAbility & e);
 
     void updateMovementControllers(double dt);
     void updateVelocity(EntityWrapper player, double dt);

include/Game/Systems/SpawnerSystem.h

@@ -7,8 +7,7 @@
 #include "Core/System.h"
 #include "Events/ESpawnerSpawn.h"
 #include "Core/Transform.h"
-#include "Core/ResourceManager.h"
-#include "Core/EntityFileParser.h"
+#include "Core/EntityFile.h"
 
 class SpawnerSystem : public System
 {

include/Game/Systems/Weapon/DefenderWeaponBehaviour.h

@@ -1,6 +1,7 @@
 #include "WeaponBehaviour.h"
 #include "Collision/Collision.h"
 #include "Core/EPlayerDamage.h"
+#include "Rendering/ESetCamera.h"
 
 class DefenderWeaponBehaviour : public WeaponBehaviour<DefenderWeaponBehaviour>
 {
@@ -9,22 +10,29 @@ public:
         : System(systemParams)
         , WeaponBehaviour(systemParams, "DefenderWeapon", renderer, collisionOctree)
         , m_RandomEngine(m_RandomDevice())
-    { }
+    {
+        EVENT_SUBSCRIBE_MEMBER(m_ESetCamera, &DefenderWeaponBehaviour::OnSetCamera);
+    }
 
     void UpdateComponent(EntityWrapper& entity, ComponentWrapper& cWeapon, double dt) override;
-    void UpdateWeapon(ComponentWrapper cWeapon, WeaponInfo& wi, double dt) override;
-    void OnPrimaryFire(ComponentWrapper cWeapon, WeaponInfo& wi) override;
-    void OnCeasePrimaryFire(ComponentWrapper cWeapon, WeaponInfo& wi) override;
-    bool OnInputCommand(ComponentWrapper cWeapon, WeaponInfo& wi, const Events::InputCommand& e) override;
+    void UpdateWeapon(WeaponInfo& wi, double dt) override;
+    void OnPrimaryFire(WeaponInfo& wi) override;
+    void OnCeasePrimaryFire(WeaponInfo& wi) override;
+    bool OnInputCommand(WeaponInfo& wi, const Events::InputCommand& e) override;
 
 private:
     std::random_device m_RandomDevice;
     std::mt19937 m_RandomEngine;
+    EntityWrapper m_CurrentCamera;
+
+    EventRelay<DefenderWeaponBehaviour, Events::SetCamera> m_ESetCamera;
+    bool OnSetCamera(const Events::SetCamera& e);
 
     // Weapon functions
-    void fireShell(ComponentWrapper cWeapon, WeaponInfo& wi);
-    void dealDamage(ComponentWrapper cWeapon, WeaponInfo& wi, glm::vec3 direction, double damage);
+    void fireShell(WeaponInfo& wi);
+    void dealDamage(WeaponInfo& wi, glm::vec3 direction, double damage);
 
     // Utility
+    float traceRayDistance(glm::vec3 origin, glm::vec3 direction);
     Camera cameraFromEntity(EntityWrapper camera);
 };

include/Game/Systems/Weapon/SidearmWeaponBehaviour.h

@@ -1,33 +0,0 @@
-#include "WeaponBehaviour.h"
-#include "Collision/Collision.h"
-#include "Core/EPlayerDamage.h"
-
-class SidearmWeaponBehaviour : public WeaponBehaviour<SidearmWeaponBehaviour>
-{
-public:
-    SidearmWeaponBehaviour(SystemParams systemParams, IRenderer* renderer, Octree<EntityAABB>* collisionOctree)
-        : System(systemParams)
-        , WeaponBehaviour(systemParams, "SidearmWeapon", renderer, collisionOctree)
-        , m_RandomEngine(m_RandomDevice())
-    { }
-
-    void UpdateComponent(EntityWrapper& entity, ComponentWrapper& cWeapon, double dt) override;
-    void UpdateWeapon(ComponentWrapper cWeapon, WeaponInfo& wi, double dt) override;
-    void OnPrimaryFire(ComponentWrapper cWeapon, WeaponInfo& wi) override;
-    void OnCeasePrimaryFire(ComponentWrapper cWeapon, WeaponInfo& wi) override;
-    void OnEquip(ComponentWrapper cWeapon, WeaponInfo& wi) override;
-    void OnHolster(ComponentWrapper cWeapon, WeaponInfo& wi) override;
-
-private:
-    std::random_device m_RandomDevice;
-    std::mt19937 m_RandomEngine;
-
-    // Weapon functions
-    void fireBullet(ComponentWrapper cWeapon, WeaponInfo& wi);
-    //void dealDamage(WeaponInfo& wi, glm::vec3 direction, double damage);
-
-    // Utility
-    bool canFire(ComponentWrapper cWeapon);
-    bool playerInFirstPerson(EntityWrapper player);
-    //float traceRayDistance(glm::vec3 origin, glm::vec3 direction);
-};

include/Game/Systems/Weapon/WeaponBehaviour.h

@@ -7,7 +7,6 @@
 #include "Collision/EntityAABB.h"
 #include "Input/EInputCommand.h"
 #include "Systems/SpawnerSystem.h"
-#include "Rendering/ESetCamera.h"
 
 template <typename ETYPE>
 class WeaponBehaviour : public PureSystem
@@ -22,81 +21,41 @@ public:
         , m_CollisionOctree(collisionOctree)
     {
         EVENT_SUBSCRIBE_MEMBER(m_EInputCommand, &WeaponBehaviour::_OnInputCommand)
-        EVENT_SUBSCRIBE_MEMBER(m_ESetCamera, &WeaponBehaviour::_OnSetCamera)
     }
     virtual ~WeaponBehaviour() = default;
 
-    virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& cWeapon, double dt) override
+    virtual void UpdateComponent(EntityWrapper& entity, ComponentWrapper& component, double dt) override
     {
         auto weapon = getActiveWeapon(entity);
         if (!weapon) {
             return;
         } else {
-            UpdateWeapon(cWeapon, *weapon, dt);
+            UpdateWeapon(*weapon, dt);
         }
     }
 
 protected:
     struct WeaponInfo
     {
+        std::string WeaponComponent;
         EntityWrapper Player;
         EntityWrapper WeaponEntity;
         EntityWrapper FirstPersonEntity;
         EntityWrapper ThirdPersonEntity;
+        ComponentWrapper GetComponent() { return WeaponEntity[WeaponComponent]; }
     };
 
     IRenderer* m_Renderer;
-    EntityWrapper m_CurrentCamera;
     Octree<EntityAABB>* m_CollisionOctree;
     std::unordered_map<EntityWrapper, WeaponInfo> m_ActiveWeapons;
 
-    virtual void UpdateWeapon(ComponentWrapper cWeapon, WeaponInfo& wi, double dt) { }
-    virtual void OnPrimaryFire(ComponentWrapper cWeapon, WeaponInfo& wi) { }
-    virtual void OnCeasePrimaryFire(ComponentWrapper cWeapon, WeaponInfo& wi) { }
-    virtual void OnReload(ComponentWrapper cWeapon, WeaponInfo& wi) { }
-    virtual void OnEquip(ComponentWrapper cWeapon, WeaponInfo& wi) { }
-    virtual void OnHolster(ComponentWrapper cWeapon, WeaponInfo& wi) { }
-    virtual bool OnInputCommand(ComponentWrapper cWeapon, WeaponInfo& wi, const Events::InputCommand& e) { return false; }
-
-    bool isPlayerInFirstPerson(EntityWrapper player)
-    {
-        if (!m_CurrentCamera.Valid()) {
-            return false;
-        } else {
-            return m_CurrentCamera == player || m_CurrentCamera.IsChildOf(player);
-        }
-    }
-
-    // Returns wi.FirstPersonEntity or wi.ThirdPersonEntity depending on
-    // if the player is in first person mode or not.
-    EntityWrapper getRelevantWeaponModelEntity(WeaponInfo& wi)
-    {
-        if (isPlayerInFirstPerson(wi.Player)) {
-            return wi.FirstPersonEntity;
-        } else {
-            return wi.ThirdPersonEntity;
-        }
-    }
-
-    float traceRayDistance(glm::vec3 origin, glm::vec3 direction)
-    {
-        float distance;
-        glm::vec3 pos;
-        auto entity = Collision::EntityFirstHitByRay(Ray(origin, direction), m_CollisionOctree, distance, pos);
-        if (entity) {
-            return distance;
-        } else {
-            return 100.f;
-        }
-    }
+    virtual void UpdateWeapon(WeaponInfo& wi, double dt) { }
+    virtual void OnPrimaryFire(WeaponInfo& wi) { }
+    virtual void OnCeasePrimaryFire(WeaponInfo& wi) { }
+    virtual void OnReload(WeaponInfo& wi) { }
+    virtual bool OnInputCommand(WeaponInfo& wi, const Events::InputCommand& e) { return false; }
 
 private:
-    EventRelay<ETYPE, Events::SetCamera> m_ESetCamera;
-    bool _OnSetCamera(const Events::SetCamera& e)
-    {
-        m_CurrentCamera = e.CameraEntity;
-        return true;
-    }
     EventRelay<ETYPE, Events::InputCommand> m_EInputCommand;
     bool _OnInputCommand(const Events::InputCommand& e)
     {
@@ -111,19 +70,15 @@ private:
         }
 
         // Make sure the player has this weapon
-        auto cWeapon = getWeaponComponent(player);
-        if (!cWeapon) {
+        auto weapon = getWeaponComponent(player);
+        if (!weapon) {
             return false;
         }
 
         // Weapon selection
         if (e.Command == "SelectWeapon") {
-            if (e.Value > 0) {
-                if (static_cast<ComponentInfo::EnumType>(e.Value) == static_cast<ComponentInfo::EnumType>((*cWeapon)["Slot"])) {
-                    selectWeapon(*cWeapon, player);
-                } else {
-                    holsterWeapon(*cWeapon, player);
-                }
+            if (static_cast<ComponentInfo::EnumType>(e.Value) == static_cast<ComponentInfo::EnumType>((*weapon)["Slot"])) {
+                selectWeapon(player);
             }
         }
 
@@ -136,18 +91,18 @@ private:
         // Fire
         if (e.Command == "PrimaryFire") {
             if (e.Value > 0) {
-                OnPrimaryFire(*cWeapon, *activeWeapon);
+                OnPrimaryFire(*activeWeapon);
             } else {
-                OnCeasePrimaryFire(*cWeapon, *activeWeapon);
+                OnCeasePrimaryFire(*activeWeapon);
             }
         }
 
         // Reload
         if (e.Command == "Reload" && e.Value != 0) {
-            OnReload(*cWeapon, *activeWeapon);
+            OnReload(*activeWeapon);
         }
 
-        return OnInputCommand(*cWeapon, *activeWeapon, e);
+        return OnInputCommand(*activeWeapon, e);
     }
 
     boost::optional<ComponentWrapper> getWeaponComponent(EntityWrapper player)
@@ -174,13 +129,8 @@ private:
         return activeWeapon;
     }
 
-    void selectWeapon(ComponentWrapper cWeapon, EntityWrapper player)
+    void selectWeapon(EntityWrapper player)
     {
-        // Don't reselect weapon if it's already active
-        if (getActiveWeapon(player)) {
-            return;
-        }
-
         // Find the weapon attachments matching the weapon type
         std::vector<EntityWrapper> weaponAttachments = player.ChildrenWithComponent("WeaponAttachment");
         EntityWrapper firstPersonAttachment;
@@ -202,6 +152,14 @@ private:
             return;
         }
 
+        // Purge other weapon entities
+        for (auto& attachment : weaponAttachments) {
+            //if (attachment == firstPersonAttachment || attachment == thirdPersonAttachment) {
+            //    continue;
+            //}
+            attachment.DeleteChildren();
+        }
+
         // Spawn the weapon(s)
         EntityWrapper firstPersonWeapon;
         EntityWrapper thirdPersonWeapon;
@@ -212,36 +170,11 @@ private:
             thirdPersonWeapon = SpawnerSystem::Spawn(thirdPersonAttachment, thirdPersonAttachment);
         }
 
-        WeaponInfo& wi = m_ActiveWeapons[player];
-        wi.Player = player;
-        wi.WeaponEntity = player;
-        wi.FirstPersonEntity = firstPersonWeapon;
-        wi.ThirdPersonEntity = thirdPersonWeapon;
-        
-        OnEquip(cWeapon, wi);
-    }
-
-    void holsterWeapon(ComponentWrapper cWeapon, EntityWrapper player)
-    {
-        auto activeWeapon = getActiveWeapon(player);
-        if (!activeWeapon) {
-            return;
-        }
-        WeaponInfo& wi = *activeWeapon;
-
-        // Send holster event
-        OnHolster(cWeapon, wi);
-
-        // Delete weapon entities
-        if (wi.FirstPersonEntity.Valid()) {
-            m_World->DeleteEntity(wi.FirstPersonEntity.ID);
-        }
-        if (wi.ThirdPersonEntity.Valid()) {
-            m_World->DeleteEntity(wi.ThirdPersonEntity.ID);
-        }
-
-        // Make weapon inactive
-        m_ActiveWeapons.erase(player);
+        m_ActiveWeapons[player].WeaponComponent = m_ComponentType;
+        m_ActiveWeapons[player].Player = player;
+        m_ActiveWeapons[player].WeaponEntity = player;
+        m_ActiveWeapons[player].FirstPersonEntity = firstPersonWeapon;
+        m_ActiveWeapons[player].ThirdPersonEntity = thirdPersonWeapon;
     }
 };
 

include/Game/Systems/Weapon/WeaponSystem.h

@@ -9,8 +9,8 @@
 #include "Core/EShoot.h"
 #include "Core/EPlayerSpawned.h"
 #include "Input/EInputCommand.h"
-#include "Core/EntityFile.h"
-#include "Core/EntityFileParser.h"
+#include "Core/EntityXMLFile.h"
+#include "Core/EntityXMLFileParser.h"
 #include "Core/Octree.h"
 #include "Collision/EntityAABB.h"
 #include "Systems/SpawnerSystem.h"

resources/DefaultConfig.ini

@@ -4,7 +4,7 @@ LoadMap=
 ; if true -> Pool allocation is not used when calling Allocate/Free, just use regular dynamic allocation. 
 ; if false -> Use pool allocation.
 DisableMemoryPool=false
-RespawnTime = 8.0
+RespawnTime = -1.0
 EditorEnabled=false
 OutOfBodyExperience=false
 
@@ -68,5 +68,17 @@ Contrast=1.5
 Intensity=1.0
 NumSamples=24
 NumTurns=17
-NumIterations=13
-TextureQuality=0
+NumIterations=9
+TextureQuality=0
+
+[GLOW]
+Quality=3;
+
+[GLOW1]
+NumIterations=5
+
+[GLOW2]
+NumIterations=9
+
+[GLOW3]
+NumIterations=13

resources/Schema/Components.xsd

@@ -35,7 +35,12 @@
 	<xs:include schemaLocation="Components/AmmoPickup.xsd"/>
 	<xs:include schemaLocation="Components/AnimationOffset.xsd"/>
 	<xs:include schemaLocation="Components/DashAbility.xsd"/>
+	<xs:include schemaLocation="Components/ShieldAbility.xsd"/>
+	<xs:include schemaLocation="Components/SprintAbility.xsd"/>
 	<xs:include schemaLocation="Components/AssaultWeapon.xsd"/>
+	<xs:include schemaLocation="Components/BoostAssault.xsd"/>
+	<xs:include schemaLocation="Components/BoostDefender.xsd"/>
+	<xs:include schemaLocation="Components/BoostSniper.xsd"/>
 	<xs:include schemaLocation="Components/Shield.xsd"/>
 	<xs:include schemaLocation="Components/Sprite.xsd"/>
 	<xs:include schemaLocation="Components/Shielded.xsd"/>
@@ -46,9 +51,12 @@
 	<xs:include schemaLocation="Components/Page.xsd"/>
 	<xs:include schemaLocation="Components/SpriteIndicator.xsd"/>
 	<xs:include schemaLocation="Components/Button.xsd"/>
+	<xs:include schemaLocation="Components/AbilityCooldownHUD.xsd"/>
 	<xs:include schemaLocation="Components/DoubleJump.xsd"/>
 	<xs:include schemaLocation="Components/WeaponAttachment.xsd"/>
 	<xs:include schemaLocation="Components/DefenderWeapon.xsd"/>
-	<xs:include schemaLocation="Components/SidearmWeapon.xsd"/>
 	<xs:include schemaLocation="Components/CapturePointGameMode.xsd"/>
+	<xs:include schemaLocation="Components/CapturePointArrowHUD.xsd"/>
+	<xs:include schemaLocation="Components/FloatingEffect.xsd"/>
+	<xs:include schemaLocation="Components/BoostIconsHUD.xsd"/>
 </xs:schema>

resources/Schema/Components/AbilityCooldownHUD.xml

@@ -0,0 +1,3 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<AbilityCooldownHUD xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="AbilityCooldownHUD.xsd">
+</AbilityCooldownHUD>

resources/Schema/Components/AbilityCooldownHUD.xsd

@@ -0,0 +1,9 @@
+<?xml version="1.0"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:t="types">
+	<xs:import schemaLocation="../Types.xsd" namespace="types"/>
+	<xs:element name="AbilityCooldownHUD">
+		<xs:annotation>
+			<xs:documentation>HUD element for tracking ability cooldown. If it has a sprite and fill component it will fill the sprite with chosen color depending on the cooldown.\n A child with text component named "Cooldown"</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+</xs:schema>

resources/Schema/Components/BoostAssault.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<BoostAssault xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="BoostAssault.xsd">
+  <StrengthOfEffect>2</StrengthOfEffect>
+</BoostAssault>

resources/Schema/Components/BoostAssault.xsd

@@ -0,0 +1,18 @@
+<?xml version="1.0"?>
+
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:t="types">
+	<xs:import schemaLocation="../Types.xsd" namespace="types"/>
+	
+	<xs:element name="BoostAssault">
+		<xs:annotation>
+			<xs:documentation>This is the assault's class boost component</xs:documentation>
+		</xs:annotation>
+		<xs:complexType>
+			<xs:all>
+				<xs:element name="StrengthOfEffect" type="t:double" minOccurs="0">
+					<xs:annotation><xs:documentation>This is the strength of the boost effect</xs:documentation></xs:annotation>
+				</xs:element>
+			</xs:all>
+		</xs:complexType>
+	</xs:element>
+</xs:schema>

resources/Schema/Components/BoostDefender.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<BoostDefender xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="BoostDefender.xsd">
+  <StrengthOfEffect>10</StrengthOfEffect>
+</BoostDefender>

resources/Schema/Components/BoostDefender.xsd

@@ -0,0 +1,18 @@
+<?xml version="1.0"?>
+
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:t="types">
+	<xs:import schemaLocation="../Types.xsd" namespace="types"/>
+	
+	<xs:element name="BoostDefender">
+		<xs:annotation>
+			<xs:documentation>This is the defender's class boost component</xs:documentation>
+		</xs:annotation>
+		<xs:complexType>
+			<xs:all>
+				<xs:element name="StrengthOfEffect" type="t:double" minOccurs="0">
+					<xs:annotation><xs:documentation>This is the strength of the boost effect</xs:documentation></xs:annotation>
+				</xs:element>
+			</xs:all>
+		</xs:complexType>
+	</xs:element>
+</xs:schema>

resources/Schema/Components/BoostIconsHUD.xml

@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<BoostIconsHUD xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="BoostIconsHUD.xsd"/>

resources/Schema/Components/BoostIconsHUD.xsd

@@ -0,0 +1,10 @@
+<?xml version="1.0"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:t="types">
+	<xs:import schemaLocation="../Types.xsd" namespace="types"/>
+
+	<xs:element name="BoostIconsHUD">
+		<xs:annotation>
+			<xs:documentation>Origin for the 3 boost states. Create 3 children with Sprite and Fill components, name them "Sprint", "Defender", "Assault"</xs:documentation>
+		</xs:annotation>
+	</xs:element>
+</xs:schema>

resources/Schema/Components/BoostSniper.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<BoostSniper xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="BoostSniper.xsd">
+  <StrengthOfEffect>10</StrengthOfEffect>
+</BoostSniper>

resources/Schema/Components/BoostSniper.xsd

@@ -0,0 +1,18 @@
+<?xml version="1.0"?>
+
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:t="types">
+	<xs:import schemaLocation="../Types.xsd" namespace="types"/>
+	
+	<xs:element name="BoostSniper">
+		<xs:annotation>
+			<xs:documentation>This is the sniper's class boost component</xs:documentation>
+		</xs:annotation>
+		<xs:complexType>
+			<xs:all>
+				<xs:element name="StrengthOfEffect" type="t:double" minOccurs="0">
+					<xs:annotation><xs:documentation>This is the strength of the boost effect</xs:documentation></xs:annotation>
+				</xs:element>
+			</xs:all>
+		</xs:complexType>
+	</xs:element>
+</xs:schema>

resources/Schema/Components/CapturePointArrowHUD.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<CapturePointArrowHUD xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="CapturePointArrowHUD.xsd">
+	<CurrentTarget>0</CurrentTarget>
+</CapturePointArrowHUD>

resources/Schema/Components/CapturePointArrowHUD.xsd

@@ -0,0 +1,18 @@
+<?xml version="1.0"?>
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:t="types">
+	<xs:import schemaLocation="../Types.xsd" namespace="types"/>
+	<xs:element name="CapturePointArrowHUD">
+		<xs:annotation>
+			<xs:documentation>HUD element for tracking next capturable Capture Point.</xs:documentation>
+		</xs:annotation>
+		<xs:complexType>
+			<xs:all>
+				<xs:element name="CurrentTarget" type="t:int" minOccurs="0">
+					<xs:annotation>
+						<xs:documentation>Corresponds to the current capturepoint the arrow points Towards</xs:documentation>
+					</xs:annotation>
+				</xs:element>
+			</xs:all>
+		</xs:complexType>
+	</xs:element>
+</xs:schema>

resources/Schema/Components/DashAbility.xml

@@ -1,4 +1,5 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no" ?>
 <DashAbility xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="DashAbility.xsd">
 	<CoolDownMaxTimer>2.0</CoolDownMaxTimer>
+	<CoolDownTimer>0.0</CoolDownTimer>
 </DashAbility>

resources/Schema/Components/DashAbility.xsd

@@ -10,7 +10,10 @@
 		<xs:complexType>
 			<xs:all>
 				<xs:element name="CoolDownMaxTimer" type="t:double" minOccurs="0">
-					<xs:annotation><xs:documentation>This is the cooldown on dash</xs:documentation></xs:annotation>
+					<xs:annotation><xs:documentation>This is the max cooldown on dash</xs:documentation></xs:annotation>
+				</xs:element>
+				<xs:element name="CoolDownTimer" type="t:double" minOccurs="0">
+					<xs:annotation><xs:documentation>This is the current cooldown on dash</xs:documentation></xs:annotation>
 				</xs:element>
 			</xs:all>
 		</xs:complexType>

resources/Schema/Components/DefenderWeapon.xsd

@@ -4,18 +4,6 @@
 	<xs:import schemaLocation="../Types.xsd" namespace="types"/>
 	<xs:include schemaLocation="../Types/WeaponSlotEnum.xsd"/>
 
-	<xs:complexType name="WeaponStateEnum" mixed="true">
-		<xs:complexContent>
-			<xs:extension base="t:enum">
-				<xs:choice>
-					<xs:element name="Idle" type="t:int" fixed="0" minOccurs="0"/>
-					<xs:element name="Firing" type="t:int" fixed="1" minOccurs="0"/>
-					<xs:element name="Reloading" type="t:int" fixed="2" minOccurs="0"/>
-				</xs:choice>
-			</xs:extension>
-		</xs:complexContent>
-	</xs:complexType>
-
 	<xs:element name="DefenderWeapon">
 		<xs:complexType>
 			<xs:all>

resources/Schema/Components/FloatingEffect.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<FloatingEffect xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="FloatingEffect.xsd">
+	<Period>1</Period>
+	<Amplitude>1</Amplitude>
+	<Time>0</Time>
+	<Axis X="0" Y="0" Z="0"/>
+	<Position X="0" Y="0" Z="0"/>
+</FloatingEffect>

resources/Schema/Components/FloatingEffect.xsd

@@ -0,0 +1,17 @@
+<?xml version="1.0"?>
+
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:t="types">
+	<xs:import schemaLocation="../Types.xsd" namespace="types"/>
+
+	<xs:element name="FloatingEffect">
+		<xs:complexType>
+			<xs:all>
+				<xs:element name="Period" type="t:double" minOccurs="0"/>
+				<xs:element name="Amplitude" type="t:double" minOccurs="0"/>
+				<xs:element name="Time" type="t:double" minOccurs="0"/>
+				<xs:element name="Axis" type="t:Vector" minOccurs="0"/>
+				<xs:element name="Position" type="t:Vector" minOccurs="0"/>
+			</xs:all>
+		</xs:complexType>
+	</xs:element>
+</xs:schema>

resources/Schema/Components/ShieldAbility.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<ShieldAbility xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="ShieldAbility.xsd">
+	<CoolDownMaxTimer>2.0</CoolDownMaxTimer>
+</ShieldAbility>

resources/Schema/Components/ShieldAbility.xsd

@@ -0,0 +1,18 @@
+<?xml version="1.0"?>
+
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:t="types">
+	<xs:import schemaLocation="../Types.xsd" namespace="types"/>
+
+	<xs:element name="ShieldAbility">
+		<xs:annotation>
+			<xs:documentation>A shield component for one of the classes</xs:documentation>
+		</xs:annotation>
+		<xs:complexType>
+			<xs:all>
+				<xs:element name="CoolDownMaxTimer" type="t:double" minOccurs="0">
+					<xs:annotation><xs:documentation>This is the cooldown on shield</xs:documentation></xs:annotation>
+				</xs:element>
+			</xs:all>
+		</xs:complexType>
+	</xs:element>
+</xs:schema>

resources/Schema/Components/SidearmWeapon.xml

@@ -1,16 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
-<SidearmWeapon xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="SidearmWeapon.xsd">
-	<MagazineAmmo>16</MagazineAmmo>
-	<MagazineSize>16</MagazineSize>
-	<BaseDamage>20</BaseDamage>
-	<RPM>500</RPM>
-	<Automatic>false</Automatic>
-	<ViewPunch>0.01</ViewPunch>
-	<ReloadTime>0.5</ReloadTime>
-	<EquipTime>0.5</EquipTime>
-	<Slot><Secondary/></Slot>
-	<TriggerHeld>false</TriggerHeld>
-	<FireCooldown>0</FireCooldown>
-	<IsReloading>false</IsReloading>
-	<ReloadTimer>0</ReloadTimer>
-</SidearmWeapon>

resources/Schema/Components/SidearmWeapon.xsd

@@ -1,52 +0,0 @@
-<?xml version="1.0"?>
-
-<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:t="types">
-	<xs:import schemaLocation="../Types.xsd" namespace="types"/>
-	<xs:include schemaLocation="../Types/WeaponSlotEnum.xsd"/>
-
-	<xs:complexType name="WeaponStateEnum" mixed="true">
-		<xs:complexContent>
-			<xs:extension base="t:enum">
-				<xs:choice>
-					<xs:element name="Idle" type="t:int" fixed="0" minOccurs="0"/>
-					<xs:element name="Firing" type="t:int" fixed="1" minOccurs="0"/>
-					<xs:element name="Reloading" type="t:int" fixed="2" minOccurs="0"/>
-				</xs:choice>
-			</xs:extension>
-		</xs:complexContent>
-	</xs:complexType>
-
-	<xs:element name="SidearmWeapon">
-		<xs:complexType>
-			<xs:all>
-				<xs:element name="MagazineAmmo" type="t:int" minOccurs="0">
-					<xs:annotation><xs:documentation>Ammo currently loaded into the magazine</xs:documentation></xs:annotation>
-				</xs:element>
-				<xs:element name="MagazineSize" type="t:int" minOccurs="0">
-						<xs:annotation><xs:documentation>Max number of rounds in a magazine</xs:documentation></xs:annotation>
-				</xs:element>
-				<xs:element name="BaseDamage" type="t:double" minOccurs="0">
-					<xs:annotation><xs:documentation>Damage dealt if all shotgun pellets hit</xs:documentation></xs:annotation>
-				</xs:element>
-				<xs:element name="RPM" type="t:double" minOccurs="0">
-					<xs:annotation><xs:documentation>Rate of fire in rounds per minute</xs:documentation></xs:annotation>
-				</xs:element>
-				<xs:element name="Automatic" type="t:bool" minOccurs="0"/>
-				<xs:element name="ViewPunch" type="t:float" minOccurs="0">
-					<xs:annotation><xs:documentation>View punch in radians for each shell fired</xs:documentation></xs:annotation>
-				</xs:element>
-				<xs:element name="ReloadTime" type="t:double" minOccurs="0">
-					<xs:annotation><xs:documentation>Time it takes to load ONE SHELL into the weapon in seconds</xs:documentation></xs:annotation>
-				</xs:element>
-				<xs:element name="EquipTime" type="t:double" minOccurs="0">
-					<xs:annotation><xs:documentation>Time it takes from selecting the weapon until it's ready to fire</xs:documentation></xs:annotation>
-				</xs:element>
-				<xs:element name="Slot" type="WeaponSlotEnum" minOccurs="0"/>
-				<xs:element name="TriggerHeld" type="t:bool" minOccurs="0"/>
-				<xs:element name="FireCooldown" type="t:double" minOccurs="0"/>
-				<xs:element name="IsReloading" type="t:bool" minOccurs="0"/>
-				<xs:element name="ReloadTimer" type="t:double" minOccurs="0"/>
-			</xs:all>
-		</xs:complexType>
-	</xs:element>
-</xs:schema>

resources/Schema/Components/SprintAbility.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<SprintAbility xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="SprintAbility.xsd">
+	<CoolDownMaxTimer>2.0</CoolDownMaxTimer>
+</SprintAbility>

resources/Schema/Components/SprintAbility.xsd

@@ -0,0 +1,18 @@
+<?xml version="1.0"?>
+
+<xs:schema xmlns:xs="http://www.w3.org/2001/XMLSchema" xmlns:t="types">
+	<xs:import schemaLocation="../Types.xsd" namespace="types"/>
+
+	<xs:element name="SprintAbility">
+		<xs:annotation>
+			<xs:documentation>A sprint component for one of the classes</xs:documentation>
+		</xs:annotation>
+		<xs:complexType>
+			<xs:all>
+				<xs:element name="CoolDownMaxTimer" type="t:double" minOccurs="0">
+					<xs:annotation><xs:documentation>This is the cooldown on sprint</xs:documentation></xs:annotation>
+				</xs:element>
+			</xs:all>
+		</xs:complexType>
+	</xs:element>
+</xs:schema>

resources/Schema/Components/Text.xml

@@ -1,7 +1,7 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no" ?>
 <Text xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="Text.xsd">
 	<Content></Content>
-	<Resource></Resource>
+	<Resource>Fonts/DroidSans.ttf,64</Resource>
 	<Color R="1" G="1" B="1" A="1"/>
 	<Visible>true</Visible>
 	<Alignment><Center/></Alignment>

resources/Schema/Entities/BoostAssault.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<Entity xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../Types/Entity.xsd">
+
+  <Components>
+    <c:BoostAssault/>
+    <c:Lifetime>
+      <Lifetime>10</Lifetime>
+    </c:Lifetime>
+    <c:Transform/>
+  </Components>
+
+  <Children/>
+
+</Entity>

resources/Schema/Entities/BoostDefender.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<Entity xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../Types/Entity.xsd">
+
+  <Components>
+    <c:BoostDefender/>
+    <c:Lifetime>
+      <Lifetime>10</Lifetime>
+    </c:Lifetime>
+    <c:Transform/>
+  </Components>
+
+  <Children/>
+
+</Entity>

resources/Schema/Entities/BoostSniper.xml

@@ -0,0 +1,14 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<Entity xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../Types/Entity.xsd">
+
+  <Components>
+    <c:BoostSniper/>
+    <c:Lifetime>
+      <Lifetime>10</Lifetime>
+    </c:Lifetime>
+    <c:Transform/>
+  </Components>
+
+  <Children/>
+
+</Entity>

resources/Schema/Entities/DashEffect.xml

@@ -0,0 +1,18 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<Entity name="DashEffect" xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../Types/Entity.xsd">
+
+  <Components>
+    <c:Animation/>
+    <c:Lifetime>
+      <Lifetime>0.5</Lifetime>
+    </c:Lifetime>
+    <c:ExplosionEffect>
+      <Velocity X="0" Y="0" Z="0"/>
+      <TimeSinceDeath>0</TimeSinceDeath>
+      <ExplosionDuration>0.5</ExplosionDuration>
+      <EndColor A="0" B="0" G="0" R="0"/>
+    </c:ExplosionEffect>
+    <c:Model/>
+    <c:Transform/>
+  </Components>
+</Entity>

resources/Schema/Entities/DefenderWeaponView.xml

@@ -1,12 +1,16 @@
 <?xml version="1.0" encoding="UTF-8" standalone="no" ?>
-<Entity name="DefenderWeapon" xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../Types/Entity.xsd">
+<Entity name="WeaponModel" xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../Types/Entity.xsd">
 
   <Components>
+    <c:BoneAttachment>
+      <BoneName>R_Arm_Weapon_Joint</BoneName>
+      <PositionOffset X="0" Y="0.0480000004" Z="-0.183000013"/>
+    </c:BoneAttachment>
     <c:Model>
       <Resource>Models/Weapons/Blue/DefenderGunBlue.mesh</Resource>
     </c:Model>
     <c:Transform>
-      <Position X="0" Y="0.0350000001" Z="-0.295000017"/>
+      <Position X="0.120430306" Y="0.775375426" Z="1.36542225"/>
     </c:Transform>
   </Components>
 

resources/Schema/Entities/NewMap.xml

@@ -5019,7 +5019,7 @@
           </Team>
         </c:Team>
         <c:Transform>
-          <Position X="-60.3695679" Y="5.64500046" Z="-79.3789597"/>
+          <Position X="-60.3695679" Y="5.14500046" Z="-79.3789597"/>
         </c:Transform>
       </Components>
       <Children>
@@ -5089,7 +5089,7 @@
           </Team>
         </c:Team>
         <c:Transform>
-          <Position X="60.0169258" Y="5.78000021" Z="76.2893906"/>
+          <Position X="60.0169258" Y="6.0800004" Z="76.2893906"/>
         </c:Transform>
       </Components>
       <Children>
@@ -5165,7 +5165,7 @@
             <c:Transform>
               <Position X="48.9189453" Y="7.06223536" Z="-78.9347992"/>
               <Scale X="0.300000012" Y="0.300000012" Z="0.300000012"/>
-              <Orientation X="0" Y="75.6124268" Z="0"/>
+              <Orientation X="0" Y="74.6042328" Z="0"/>
             </c:Transform>
             <c:Trigger/>
           </Components>
@@ -5184,7 +5184,7 @@
             <c:Transform>
               <Position X="-59.3499641" Y="7.46932745" Z="-20.6276321"/>
               <Scale X="0.300000012" Y="0.300000012" Z="0.300000012"/>
-              <Orientation X="0" Y="72.2667694" Z="0"/>
+              <Orientation X="0" Y="71.2585754" Z="0"/>
             </c:Transform>
             <c:Trigger/>
           </Components>
@@ -5203,7 +5203,7 @@
             <c:Transform>
               <Position X="-1.13644195" Y="1.38919806" Z="38.9768829"/>
               <Scale X="0.300000012" Y="0.300000012" Z="0.300000012"/>
-              <Orientation X="0" Y="69.8748016" Z="0"/>
+              <Orientation X="0" Y="68.8666077" Z="0"/>
             </c:Transform>
             <c:Trigger/>
           </Components>
@@ -5222,7 +5222,7 @@
             <c:Transform>
               <Position X="54.7225227" Y="6.51863909" Z="29.0052128"/>
               <Scale X="0.300000012" Y="0.300000012" Z="0.300000012"/>
-              <Orientation X="0" Y="70.1887283" Z="0"/>
+              <Orientation X="0" Y="69.180542" Z="0"/>
             </c:Transform>
             <c:Trigger/>
           </Components>
@@ -5241,7 +5241,7 @@
             <c:Transform>
               <Position X="-51.6792374" Y="8.44526482" Z="32.5153465"/>
               <Scale X="0.300000012" Y="0.300000012" Z="0.300000012"/>
-              <Orientation X="0" Y="69.6374512" Z="0"/>
+              <Orientation X="0" Y="68.6292572" Z="0"/>
             </c:Transform>
             <c:Trigger/>
           </Components>
@@ -5260,7 +5260,7 @@
             <c:Transform>
               <Position X="-42.3974304" Y="7.28327894" Z="81.9305344"/>
               <Scale X="0.300000012" Y="0.300000012" Z="0.300000012"/>
-              <Orientation X="0" Y="67.7666702" Z="0"/>
+              <Orientation X="0" Y="66.7584839" Z="0"/>
             </c:Transform>
             <c:Trigger/>
           </Components>
@@ -5279,7 +5279,7 @@
             <c:Transform>
               <Position X="-9.85184956" Y="8.25567532" Z="39.6119232"/>
               <Scale X="0.300000012" Y="0.300000012" Z="0.300000012"/>
-              <Orientation X="0" Y="66.8154602" Z="0"/>
+              <Orientation X="0" Y="65.8073425" Z="0"/>
             </c:Transform>
             <c:Trigger/>
           </Components>
@@ -5298,7 +5298,7 @@
             <c:Transform>
               <Position X="49.2257118" Y="7.39368248" Z="-31.1810112"/>
               <Scale X="0.300000012" Y="0.300000012" Z="0.300000012"/>
-              <Orientation X="0" Y="64.0265808" Z="0"/>
+              <Orientation X="0" Y="63.0184822" Z="0"/>
             </c:Transform>
             <c:Trigger/>
           </Components>

resources/Schema/Entities/Player.xml

@@ -6,12 +6,16 @@
       <Origin X="0" Y="0.772000015" Z="0"/>
       <Size X="1" Y="1.60000002" Z="1"/>
     </c:AABB>
+    <c:AssaultWeapon>
+      <Slot>
+        <Secondary/>
+      </Slot>
+    </c:AssaultWeapon>
     <c:Collidable/>
     <c:DefenderWeapon>
-      <TimeSinceLastFire>102.85760837900634</TimeSinceLastFire>
+      <TimeSinceLastFire>52.867678870419283</TimeSinceLastFire>
     </c:DefenderWeapon>
     <c:DoubleJump/>
-    <c:SidearmWeapon/>
     <c:Health/>
     <c:Physics>
       <Velocity X="2.30999646e-23" Y="0" Z="1.05272533e-23"/>
@@ -33,7 +37,10 @@
   <Children>
     <Entity name="Camera">
       <Components>
-        <c:Camera/>
+        <c:Camera>
+          <NearClip>0.10000000149011612</NearClip>
+          <FarClip>300</FarClip>
+        </c:Camera>
         <c:Transform>
           <Position X="0" Y="1.27700007" Z="0"/>
         </c:Transform>
@@ -93,12 +100,12 @@
                       <Percentage>1</Percentage>
                       <Color A="1" B="1" G="0" R="0"/>
                     </c:Fill>
-                    <c:HealthHUD/>
                     <c:Text>
                       <Content>100/100</Content>
                       <Resource>Fonts/DroidSans.ttf,64</Resource>
                       <Color A="0.505882382" B="3.92156863" G="1.17647064" R="0"/>
                     </c:Text>
+                    <c:HealthHUD/>
                     <c:Transform>
                       <Position X="-0.355000019" Y="-0.203000009" Z="0.0410000011"/>
                       <Scale X="0.0350000001" Y="0.0350000001" Z="0.0350000001"/>
@@ -125,7 +132,70 @@
                       <Orientation X="5.87300014" Y="0" Z="4.71200037"/>
                     </c:Transform>
                   </Components>
-                  <Children/>
+                  <Children>
+                    <Entity name="BoostIcons">
+                      <Components>
+                        <c:BoostIconsHUD/>
+                        <c:Transform/>
+                      </Components>
+                      <Children>
+                        <Entity name="Assault">
+                          <Components>
+                            <c:Fill>
+                              <Color A="1" B="0.533333361" G="1" R="0.329411775"/>
+                            </c:Fill>
+                            <c:Sprite>
+                              <DiffuseTexture>Textures/Core/White.png</DiffuseTexture>
+                              <DepthSort>false</DepthSort>
+                              <GlowMap></GlowMap>
+                              <Color A="0.588235319" B="0.0392156877" G="0.184313729" R="0"/>
+                            </c:Sprite>
+                            <c:Transform>
+                              <Position X="0.225000009" Y="0.168000013" Z="0"/>
+                              <Scale X="0.27700001" Y="0.100000001" Z="0.200000003"/>
+                            </c:Transform>
+                          </Components>
+                          <Children/>
+                        </Entity>
+                        <Entity name="Defender">
+                          <Components>
+                            <c:Fill>
+                              <Color A="1" B="1" G="0.58431375" R="0.105882354"/>
+                            </c:Fill>
+                            <c:Sprite>
+                              <DiffuseTexture>Textures/Core/White.png</DiffuseTexture>
+                              <DepthSort>false</DepthSort>
+                              <GlowMap></GlowMap>
+                              <Color A="0.588235319" B="0.34117648" G="0.192156866" R="0"/>
+                            </c:Sprite>
+                            <c:Transform>
+                              <Position X="0.224999994" Y="0.27700001" Z="0"/>
+                              <Scale X="0.27700001" Y="0.100000001" Z="0.200000003"/>
+                            </c:Transform>
+                          </Components>
+                          <Children/>
+                        </Entity>
+                        <Entity name="Sniper">
+                          <Components>
+                            <c:Fill>
+                              <Color A="1" B="0.345098048" G="0" R="1"/>
+                            </c:Fill>
+                            <c:Sprite>
+                              <DiffuseTexture>Textures/Core/White.png</DiffuseTexture>
+                              <DepthSort>false</DepthSort>
+                              <GlowMap></GlowMap>
+                              <Color A="0.588235319" B="0.121568628" G="0" R="0.443137258"/>
+                            </c:Sprite>
+                            <c:Transform>
+                              <Position X="0.225000009" Y="0.38500002" Z="0"/>
+                              <Scale X="0.27700001" Y="0.100000001" Z="0.200000003"/>
+                            </c:Transform>
+                          </Components>
+                          <Children/>
+                        </Entity>
+                      </Children>
+                    </Entity>
+                  </Children>
                 </Entity>
               </Children>
             </Entity>
@@ -189,7 +259,6 @@
                           <CapturePointNumber>3</CapturePointNumber>
                         </c:CapturePointHUD>
                         <c:Fill>
-                          <Percentage>0.80222018197612788</Percentage>
                           <Color A="0.699999988" B="1" G="0.200000003" R="0"/>
                         </c:Fill>
                         <c:Sprite>
@@ -224,6 +293,7 @@
                           <CapturePointNumber>4</CapturePointNumber>
                         </c:CapturePointHUD>
                         <c:Fill>
+                          <Percentage>1</Percentage>
                           <Color A="0.699999988" B="1" G="0.200000003" R="0"/>
                         </c:Fill>
                         <c:Sprite>
@@ -279,7 +349,7 @@
                     <c:Sprite>
                       <DiffuseTexture>Textures/Core/UnitHexagon.png</DiffuseTexture>
                       <GlowMap></GlowMap>
-                      <Color A="0.699999988" B="0" G="0.200000003" R="1"/>
+                      <Color A="0.699999988" B="0" G="0" R="1"/>
                     </c:Sprite>
                     <c:Transform>
                       <Position X="-1.58304751" Y="0.919596612" Z="0"/>
@@ -290,7 +360,8 @@
                       <Components>
                         <c:CapturePointHUD/>
                         <c:Fill>
-                          <Color A="0.699999988" B="1" G="0.200000003" R="0"/>
+                          <Percentage>1</Percentage>
+                          <Color A="0.699999988" B="0" G="0" R="1"/>
                         </c:Fill>
                         <c:Sprite>
                           <DiffuseTexture>Textures/Core/UnitHexagon_Rotated.png</DiffuseTexture>
@@ -299,7 +370,7 @@
                         <c:Transform>
                           <Position X="0" Y="0" Z="0.00999999978"/>
                           <Scale X="0.800000012" Y="0.800000012" Z="0.800000012"/>
-                          <Orientation X="0" Y="0" Z="1.57079637"/>
+                          <Orientation X="0" Y="0" Z="4.71238899"/>
                         </c:Transform>
                       </Components>
                       <Children/>
@@ -362,13 +433,32 @@
                 </Entity>
               </Children>
             </Entity>
+            <Entity name="CapturePointArrow">
+              <Components>
+                <c:CapturePointArrowHUD/>
+                <c:Model>
+                  <Resource>Models/Widgets/Arrows/Arrow5.mesh</Resource>
+                </c:Model>
+                <c:Team>
+                  <Team>
+                    <Blue/>
+                  </Team>
+                </c:Team>
+                <c:Transform>
+                  <Position X="0" Y="0.714000046" Z="-1.30000007"/>
+                  <Scale X="0.200000003" Y="0.200000003" Z="0.200000003"/>
+                  <Orientation X="0.405680239" Y="0.369605929" Z="0"/>
+                </c:Transform>
+              </Components>
+              <Children/>
+            </Entity>
           </Children>
         </Entity>
         <Entity name="Hands">
           <Components>
             <c:Animation>
               <AnimationName1>Idle</AnimationName1>
-              <Time1>1.8348644854054612</Time1>
+              <Time1>1.9408570429715581</Time1>
               <Speed1>1</Speed1>
               <AnimationName2></AnimationName2>
               <AnimationName3></AnimationName3>
@@ -382,37 +472,25 @@
           <Children>
             <Entity name="PrimaryAttachment">
               <Components>
-                <c:BoneAttachment>
-                  <BoneName>R_Arm_Weapon_Joint</BoneName>
-                </c:BoneAttachment>
                 <c:WeaponAttachment>
                   <Weapon>DefenderWeapon</Weapon>
                 </c:WeaponAttachment>
                 <c:Spawner>
                   <EntityFile>Schema/Entities/DefenderWeaponView.xml</EntityFile>
                 </c:Spawner>
-                <c:Transform>
-                  <Position X="0.120430619" Y="-0.229639441" Z="-0.181454554"/>
-                  <Orientation X="0.0104045719" Y="-0.00268170005" Z="0.0428441055"/>
-                </c:Transform>
+                <c:Transform/>
               </Components>
               <Children/>
             </Entity>
             <Entity name="SecondaryAttachment">
               <Components>
-                <c:BoneAttachment>
-                  <BoneName>R_Arm_Weapon_Joint</BoneName>
-                </c:BoneAttachment>
                 <c:WeaponAttachment>
-                  <Weapon>SidearmWeapon</Weapon>
+                  <Weapon>AssaultWeapon</Weapon>
                 </c:WeaponAttachment>
                 <c:Spawner>
-                  <EntityFile>Schema/Entities/SidearmWeaponView.xml</EntityFile>
+                  <EntityFile>Schema/Entities/AssaultWeaponView.xml</EntityFile>
                 </c:Spawner>
-                <c:Transform>
-                  <Position X="0.120430619" Y="-0.229639441" Z="-0.181454554"/>
-                  <Orientation X="0.0104045719" Y="-0.00268170005" Z="0.0428441055"/>
-                </c:Transform>
+                <c:Transform/>
               </Components>
               <Children/>
             </Entity>
@@ -422,7 +500,10 @@
     </Entity>
     <Entity name="ThirdPersonCamera">
       <Components>
-        <c:Camera/>
+        <c:Camera>
+          <NearClip>0.10000000149011612</NearClip>
+          <FarClip>300</FarClip>
+        </c:Camera>
         <c:Model>
           <Resource>Models/Widgets/Camera.mesh</Resource>
           <Visible>false</Visible>
@@ -438,7 +519,7 @@
       <Components>
         <c:Animation>
           <AnimationName1>Idle</AnimationName1>
-          <Time1>0.013134522267137072</Time1>
+          <Time1>1.5631122524686134</Time1>
           <Speed1>1</Speed1>
           <AnimationName2></AnimationName2>
           <AnimationName3></AnimationName3>
@@ -473,22 +554,16 @@
         </Entity>
         <Entity name="SecondaryAttachment">
           <Components>
-            <c:BoneAttachment>
-              <BoneName>R_Arm_Weapon_Joint</BoneName>
-            </c:BoneAttachment>
             <c:WeaponAttachment>
-              <Weapon>SidearmWeapon</Weapon>
+              <Weapon>AssaultWeapon</Weapon>
               <Person>
                 <ThirdPerson/>
               </Person>
             </c:WeaponAttachment>
             <c:Spawner>
-              <EntityFile>Schema/Entities/SidearmWeaponWorld.xml</EntityFile>
+              <EntityFile>Schema/Entities/AssaultWeaponWorld.xml</EntityFile>
             </c:Spawner>
-            <c:Transform>
-              <Position X="0.156846598" Y="1.03287792" Z="-0.216207206"/>
-              <Orientation X="-0.0626498386" Y="-0.0301200207" Z="0.12067578"/>
-            </c:Transform>
+            <c:Transform/>
           </Components>
           <Children/>
         </Entity>

resources/Schema/Entities/PlayerRed.xml

@@ -13,7 +13,7 @@
     </c:AssaultWeapon>
     <c:Collidable/>
     <c:DefenderWeapon>
-      <TimeSinceLastFire>1.6944730461160304</TimeSinceLastFire>
+      <TimeSinceLastFire>22.22055262342397</TimeSinceLastFire>
     </c:DefenderWeapon>
     <c:DoubleJump/>
     <c:Health/>
@@ -37,7 +37,10 @@
   <Children>
     <Entity name="Camera">
       <Components>
-        <c:Camera/>
+        <c:Camera>
+          <NearClip>0.10000000149011612</NearClip>
+          <FarClip>300</FarClip>
+        </c:Camera>
         <c:Transform>
           <Position X="0" Y="1.27700007" Z="0"/>
         </c:Transform>
@@ -372,7 +375,7 @@
           <Components>
             <c:Animation>
               <AnimationName1>Idle</AnimationName1>
-              <Time1>0.67172915251515519</Time1>
+              <Time1>1.1978087298230946</Time1>
               <Speed1>1</Speed1>
               <AnimationName2></AnimationName2>
               <AnimationName3></AnimationName3>
@@ -386,25 +389,25 @@
           <Children>
             <Entity name="PrimaryAttachment">
               <Components>
+                <c:WeaponAttachment>
+                  <Weapon>DefenderWeapon</Weapon>
+                </c:WeaponAttachment>
                 <c:Spawner>
                   <EntityFile>Schema/Entities/DefenderWeaponViewRed.xml</EntityFile>
                 </c:Spawner>
                 <c:Transform/>
-                <c:WeaponAttachment>
-                  <Weapon>DefenderWeapon</Weapon>
-                </c:WeaponAttachment>
               </Components>
               <Children/>
             </Entity>
             <Entity name="SecondaryAttachment">
               <Components>
+                <c:WeaponAttachment>
+                  <Weapon>AssaultWeapon</Weapon>
+                </c:WeaponAttachment>
                 <c:Spawner>
                   <EntityFile>Schema/Entities/AssaultWeaponView.xml</EntityFile>
                 </c:Spawner>
                 <c:Transform/>
-                <c:WeaponAttachment>
-                  <Weapon>AssaultWeapon</Weapon>
-                </c:WeaponAttachment>
               </Components>
               <Children/>
             </Entity>
@@ -414,7 +417,10 @@
     </Entity>
     <Entity name="ThirdPersonCamera">
       <Components>
-        <c:Camera/>
+        <c:Camera>
+          <NearClip>0.10000000149011612</NearClip>
+          <FarClip>300</FarClip>
+        </c:Camera>
         <c:Model>
           <Resource>Models/Widgets/Camera.mesh</Resource>
           <Visible>false</Visible>
@@ -430,6 +436,7 @@
       <Components>
         <c:Animation>
           <AnimationName1>Idle</AnimationName1>
+          <Time1>0.69274608502888668</Time1>
           <Speed1>1</Speed1>
           <AnimationName2></AnimationName2>
           <AnimationName3></AnimationName3>
@@ -449,31 +456,31 @@
       <Children>
         <Entity name="PrimaryAttachment">
           <Components>
-            <c:Spawner>
-              <EntityFile>Schema/Entities/DefenderWeaponWorldRed.xml</EntityFile>
-            </c:Spawner>
-            <c:Transform/>
             <c:WeaponAttachment>
               <Weapon>DefenderWeapon</Weapon>
               <Person>
                 <ThirdPerson/>
               </Person>
             </c:WeaponAttachment>
+            <c:Spawner>
+              <EntityFile>Schema/Entities/DefenderWeaponWorldRed.xml</EntityFile>
+            </c:Spawner>
+            <c:Transform/>
           </Components>
           <Children/>
         </Entity>
         <Entity name="SecondaryAttachment">
           <Components>
-            <c:Spawner>
-              <EntityFile>Schema/Entities/AssaultWeaponWorld.xml</EntityFile>
-            </c:Spawner>
-            <c:Transform/>
             <c:WeaponAttachment>
               <Weapon>AssaultWeapon</Weapon>
               <Person>
                 <ThirdPerson/>
               </Person>
             </c:WeaponAttachment>
+            <c:Spawner>
+              <EntityFile>Schema/Entities/AssaultWeaponWorld.xml</EntityFile>
+            </c:Spawner>
+            <c:Transform/>
           </Components>
           <Children/>
         </Entity>

resources/Schema/Entities/QualityAssurance.xml

@@ -2,6 +2,9 @@
 <Entity xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../Types/Entity.xsd">
 
   <Components>
+    <c:CapturePointGameMode>
+      <RespawnTime>4.7473226580121377</RespawnTime>
+    </c:CapturePointGameMode>
     <c:Transform>
       <Position X="0" Y="-1" Z="0"/>
     </c:Transform>
@@ -40,7 +43,7 @@
               <Axis X="0" Y="1" Z="0"/>
             </c:RaptorCopter>
             <c:Transform>
-              <Orientation X="0" Y="8433.37305" Z="0"/>
+              <Orientation X="0" Y="9038.11328" Z="0"/>
             </c:Transform>
           </Components>
           <Children>
@@ -81,19 +84,19 @@
     </Entity>
     <Entity name="DirectionalLight">
       <Components>
+        <c:RaptorCopter>
+          <Speed>1</Speed>
+          <Axis X="0" Y="1" Z="0"/>
+        </c:RaptorCopter>
         <c:DirectionalLight>
           <Intensity>0.80000001192092896</Intensity>
         </c:DirectionalLight>
         <c:Model>
           <Resource>Models/Widgets/Lights/DirectionalLightWidget.mesh</Resource>
         </c:Model>
-        <c:RaptorCopter>
-          <Speed>1</Speed>
-          <Axis X="0" Y="1" Z="0"/>
-        </c:RaptorCopter>
         <c:Transform>
           <Position X="2.1529963" Y="6.59221172" Z="0.169116676"/>
-          <Orientation X="4.16300011" Y="18271.9141" Z="0"/>
+          <Orientation X="4.16300011" Y="18876.6172" Z="0"/>
         </c:Transform>
       </Components>
       <Children/>
@@ -108,7 +111,11 @@
       <Children>
         <Entity name="RunAnim">
           <Components>
-            <c:Animation/>
+            <c:Animation>
+              <AnimationName1></AnimationName1>
+              <AnimationName2></AnimationName2>
+              <AnimationName3></AnimationName3>
+            </c:Animation>
             <c:Model>
               <Resource>Models/Characters/Assault/AssaultAnimated.mesh</Resource>
             </c:Model>
@@ -120,7 +127,11 @@
         </Entity>
         <Entity name="Walkanim">
           <Components>
-            <c:Animation/>
+            <c:Animation>
+              <AnimationName1></AnimationName1>
+              <AnimationName2></AnimationName2>
+              <AnimationName3></AnimationName3>
+            </c:Animation>
             <c:Model>
               <Resource>Models/Characters/Assault/AssaultAnimated.mesh</Resource>
             </c:Model>
@@ -168,13 +179,17 @@
                   <Axis X="0" Y="1" Z="0"/>
                 </c:RaptorCopter>
                 <c:Transform>
-                  <Orientation X="0" Y="2553.63574" Z="0"/>
+                  <Orientation X="0" Y="2856.05518" Z="0"/>
                 </c:Transform>
               </Components>
               <Children>
                 <Entity name="Asset">
                   <Components>
-                    <c:Animation/>
+                    <c:Animation>
+                      <AnimationName1></AnimationName1>
+                      <AnimationName2></AnimationName2>
+                      <AnimationName3></AnimationName3>
+                    </c:Animation>
                     <c:Model>
                       <Resource>Models/Characters/Assault/AssaultAnimated.mesh</Resource>
                     </c:Model>
@@ -213,7 +228,7 @@
               <Axis X="1" Y="1" Z="1"/>
             </c:RaptorCopter>
             <c:Transform>
-              <Orientation X="16862.3945" Y="16862.3945" Z="16862.3945"/>
+              <Orientation X="17467.0977" Y="17467.0977" Z="17467.0977"/>
             </c:Transform>
           </Components>
           <Children>
@@ -277,7 +292,7 @@
               <Axis X="0" Y="1" Z="0"/>
             </c:RaptorCopter>
             <c:Transform>
-              <Orientation X="0" Y="16658.3906" Z="0"/>
+              <Orientation X="0" Y="17263.0938" Z="0"/>
             </c:Transform>
           </Components>
           <Children>
@@ -309,7 +324,7 @@
                       <Axis X="0.699999988" Y="1" Z="0.300000012"/>
                     </c:RaptorCopter>
                     <c:Transform>
-                      <Orientation X="12206.665" Y="17385.8008" Z="5202.3335"/>
+                      <Orientation X="12630.0664" Y="17990.5039" Z="5383.80176"/>
                     </c:Transform>
                   </Components>
                   <Children>
@@ -659,7 +674,7 @@
                   <Axis X="0" Y="1" Z="0"/>
                 </c:RaptorCopter>
                 <c:Transform>
-                  <Orientation X="0" Y="851.386902" Z="0"/>
+                  <Orientation X="0" Y="1153.80225" Z="0"/>
                 </c:Transform>
               </Components>
               <Children>
@@ -706,7 +721,7 @@
                   <Axis X="0" Y="1" Z="0"/>
                 </c:RaptorCopter>
                 <c:Transform>
-                  <Orientation X="0" Y="851.386902" Z="0"/>
+                  <Orientation X="0" Y="1153.80225" Z="0"/>
                 </c:Transform>
               </Components>
               <Children>
@@ -766,7 +781,7 @@
                   <Axis X="0" Y="1" Z="0"/>
                 </c:RaptorCopter>
                 <c:Transform>
-                  <Orientation X="0" Y="851.386902" Z="0"/>
+                  <Orientation X="0" Y="1153.80225" Z="0"/>
                 </c:Transform>
               </Components>
               <Children>
@@ -813,7 +828,7 @@
                   <Axis X="0" Y="1" Z="0"/>
                 </c:RaptorCopter>
                 <c:Transform>
-                  <Orientation X="0" Y="851.386902" Z="0"/>
+                  <Orientation X="0" Y="1153.80225" Z="0"/>
                 </c:Transform>
               </Components>
               <Children>
@@ -859,7 +874,7 @@
                   <Axis X="0" Y="1" Z="0"/>
                 </c:RaptorCopter>
                 <c:Transform>
-                  <Orientation X="0" Y="851.386902" Z="0"/>
+                  <Orientation X="0" Y="1153.80225" Z="0"/>
                 </c:Transform>
               </Components>
               <Children>
@@ -906,7 +921,7 @@
                   <Axis X="0" Y="1" Z="0"/>
                 </c:RaptorCopter>
                 <c:Transform>
-                  <Orientation X="0" Y="851.386902" Z="0"/>
+                  <Orientation X="0" Y="1153.80225" Z="0"/>
                 </c:Transform>
               </Components>
               <Children>
@@ -953,7 +968,7 @@
                   <Axis X="0" Y="1" Z="0"/>
                 </c:RaptorCopter>
                 <c:Transform>
-                  <Orientation X="0" Y="851.386902" Z="0"/>
+                  <Orientation X="0" Y="1153.80225" Z="0"/>
                 </c:Transform>
               </Components>
               <Children>
@@ -1013,6 +1028,7 @@
                   </HomePointForTeam>
                   <CaptureTimer>15</CaptureTimer>
                 </c:CapturePoint>
+                <c:Trigger/>
                 <c:Model>
                   <Resource>Models/Core/UnitCube.mesh</Resource>
                   <Color A="0.300000012" B="0" G="0" R="1"/>
@@ -1027,7 +1043,6 @@
                   <Position X="0" Y="2" Z="0"/>
                   <Scale X="8" Y="4" Z="8"/>
                 </c:Transform>
-                <c:Trigger/>
               </Components>
               <Children/>
             </Entity>
@@ -1063,6 +1078,7 @@
                 <c:CapturePoint>
                   <CapturePointNumber>1</CapturePointNumber>
                 </c:CapturePoint>
+                <c:Trigger/>
                 <c:Model>
                   <Resource>Models/Core/UnitCube.mesh</Resource>
                   <Color A="0.300000012" B="1" G="1" R="1"/>
@@ -1073,7 +1089,6 @@
                   <Position X="0" Y="2" Z="0"/>
                   <Scale X="8" Y="4" Z="8"/>
                 </c:Transform>
-                <c:Trigger/>
               </Components>
               <Children/>
             </Entity>
@@ -1107,6 +1122,7 @@
                 <c:CapturePoint>
                   <CapturePointNumber>2</CapturePointNumber>
                 </c:CapturePoint>
+                <c:Trigger/>
                 <c:Model>
                   <Resource>Models/Core/UnitCube.mesh</Resource>
                   <Color A="0.300000012" B="1" G="1" R="1"/>
@@ -1117,7 +1133,6 @@
                   <Position X="0" Y="2" Z="0"/>
                   <Scale X="8" Y="4" Z="8"/>
                 </c:Transform>
-                <c:Trigger/>
               </Components>
               <Children/>
             </Entity>
@@ -1153,6 +1168,7 @@
                 <c:CapturePoint>
                   <CapturePointNumber>3</CapturePointNumber>
                 </c:CapturePoint>
+                <c:Trigger/>
                 <c:Model>
                   <Resource>Models/Core/UnitCube.mesh</Resource>
                   <Color A="0.300000012" B="1" G="1" R="1"/>
@@ -1163,7 +1179,6 @@
                   <Position X="0" Y="2" Z="0"/>
                   <Scale X="8" Y="4" Z="8"/>
                 </c:Transform>
-                <c:Trigger/>
               </Components>
               <Children/>
             </Entity>
@@ -1203,6 +1218,7 @@
                   <CaptureTimer>-15</CaptureTimer>
                   <CapturePointNumber>4</CapturePointNumber>
                 </c:CapturePoint>
+                <c:Trigger/>
                 <c:Model>
                   <Resource>Models/Core/UnitCube.mesh</Resource>
                   <Color A="0.300000012" B="1" G="0" R="0"/>
@@ -1217,7 +1233,6 @@
                   <Position X="0" Y="2" Z="0"/>
                   <Scale X="8" Y="4" Z="8"/>
                 </c:Transform>
-                <c:Trigger/>
               </Components>
               <Children/>
             </Entity>
@@ -1367,7 +1382,7 @@
                   <Axis X="0" Y="1" Z="0"/>
                 </c:RaptorCopter>
                 <c:Transform>
-                  <Orientation X="0" Y="1385.11243" Z="0"/>
+                  <Orientation X="0" Y="1687.52917" Z="0"/>
                 </c:Transform>
               </Components>
               <Children>
@@ -1376,7 +1391,7 @@
                     <c:ExplosionEffect>
                       <ColorByDistance>true</ColorByDistance>
                       <Velocity X="0.800000012" Y="0.0379999988" Z="0"/>
-                      <TimeSinceDeath>0.8256214817261025</TimeSinceDeath>
+                      <TimeSinceDeath>2.5396116058983438</TimeSinceDeath>
                       <ExplosionDuration>3.7999999523162842</ExplosionDuration>
                       <EndColor A="0" B="23.5294113" G="11.7647057" R="0"/>
                       <Randomness>true</Randomness>
@@ -1423,7 +1438,7 @@
                   <Axis X="0" Y="1" Z="0"/>
                 </c:RaptorCopter>
                 <c:Transform>
-                  <Orientation X="0" Y="1385.11243" Z="0"/>
+                  <Orientation X="0" Y="1687.52917" Z="0"/>
                 </c:Transform>
               </Components>
               <Children>
@@ -1432,7 +1447,7 @@
                     <c:ExplosionEffect>
                       <Velocity X="0.5" Y="1" Z="0"/>
                       <ExplosionOrigin X="0" Y="0.900000036" Z="0"/>
-                      <TimeSinceDeath>1.8641349174045843</TimeSinceDeath>
+                      <TimeSinceDeath>1.5396208215609732</TimeSinceDeath>
                     </c:ExplosionEffect>
                     <c:Model>
                       <Resource>Models/Characters/Assault/AssaultTPose.mesh</Resource>
@@ -1475,18 +1490,22 @@
                   <Axis X="0" Y="1" Z="0"/>
                 </c:RaptorCopter>
                 <c:Transform>
-                  <Orientation X="0" Y="1385.11243" Z="0"/>
+                  <Orientation X="0" Y="1687.52917" Z="0"/>
                 </c:Transform>
               </Components>
               <Children>
                 <Entity name="Asset">
                   <Components>
-                    <c:Animation/>
+                    <c:Animation>
+                      <AnimationName1></AnimationName1>
+                      <AnimationName2></AnimationName2>
+                      <AnimationName3></AnimationName3>
+                    </c:Animation>
                     <c:ExplosionEffect>
                       <ColorByDistance>true</ColorByDistance>
                       <Velocity X="0.300000012" Y="2" Z="0"/>
                       <ExplosionOrigin X="0" Y="1.30000007" Z="-0.200000003"/>
-                      <TimeSinceDeath>1.8641349174045843</TimeSinceDeath>
+                      <TimeSinceDeath>1.5396208215609732</TimeSinceDeath>
                       <EndColor A="0" B="0.333333343" G="0.933333337" R="3.92156863"/>
                       <Randomness>true</Randomness>
                     </c:ExplosionEffect>
@@ -1531,7 +1550,7 @@
                   <Axis X="0" Y="1" Z="0"/>
                 </c:RaptorCopter>
                 <c:Transform>
-                  <Orientation X="0" Y="1392.89258" Z="0"/>
+                  <Orientation X="0" Y="1695.30933" Z="0"/>
                 </c:Transform>
               </Components>
               <Children>
@@ -1541,7 +1560,7 @@
                       <ColorByDistance>true</ColorByDistance>
                       <Velocity X="0" Y="0.699999988" Z="0"/>
                       <ExplosionOrigin X="0" Y="-1.10000002" Z="0"/>
-                      <TimeSinceDeath>1.2301962937648341</TimeSinceDeath>
+                      <TimeSinceDeath>4.4522528839264339</TimeSinceDeath>
                       <ExplosionDuration>10</ExplosionDuration>
                       <EndColor A="1" B="0" G="0" R="1"/>
                       <RandomnessScalar>3</RandomnessScalar>
@@ -1589,7 +1608,7 @@
                   <Axis X="0" Y="1" Z="0"/>
                 </c:RaptorCopter>
                 <c:Transform>
-                  <Orientation X="0" Y="991.007263" Z="0"/>
+                  <Orientation X="0" Y="1293.42383" Z="0"/>
                 </c:Transform>
               </Components>
               <Children>
@@ -1599,7 +1618,7 @@
                       <ColorByDistance>true</ColorByDistance>
                       <Velocity X="6" Y="0.100000001" Z="0"/>
                       <ExplosionOrigin X="0" Y="-10" Z="0"/>
-                      <TimeSinceDeath>3.4214855659573402</TimeSinceDeath>
+                      <TimeSinceDeath>3.2362842141074992</TimeSinceDeath>
                       <ExponentialAccelaration>true</ExponentialAccelaration>
                       <ExplosionDuration>5</ExplosionDuration>
                       <Randomness>true</Randomness>
@@ -1690,6 +1709,7 @@
             </c:Physics>
             <c:Player>
               <MovementSpeed>5</MovementSpeed>
+              <CurrentWeapon></CurrentWeapon>
             </c:Player>
             <c:Team>
               <Team>
@@ -1712,6 +1732,7 @@
                 <Entity name="PlayerName">
                   <Components>
                     <c:Text>
+                      <Content></Content>
                       <Resource>Fonts/DroidSans.ttf,100</Resource>
                       <Color A="1" B="0" G="1" R="0"/>
                     </c:Text>
@@ -1780,7 +1801,7 @@
                         <c:ExplosionEffect>
                           <ColorByDistance>true</ColorByDistance>
                           <Velocity X="0.800000012" Y="0.0379999988" Z="0"/>
-                          <TimeSinceDeath>0.8256214817261025</TimeSinceDeath>
+                          <TimeSinceDeath>2.5396116058983438</TimeSinceDeath>
                           <ExplosionDuration>3.7999999523162842</ExplosionDuration>
                           <EndColor A="0" B="23.5294113" G="11.7647057" R="0"/>
                           <Randomness>true</Randomness>
@@ -1823,7 +1844,11 @@
             </Entity>
             <Entity name="PlayerModel">
               <Components>
-                <c:Animation/>
+                <c:Animation>
+                  <AnimationName1></AnimationName1>
+                  <AnimationName2></AnimationName2>
+                  <AnimationName3></AnimationName3>
+                </c:Animation>
                 <c:Shielded/>
                 <c:HiddenForLocalPlayer/>
                 <c:Model>
@@ -1925,6 +1950,7 @@
           <Components>
             <c:Sprite>
               <DiffuseTexture>Textures/Props/FoliageDiff.png</DiffuseTexture>
+              <GlowMap></GlowMap>
             </c:Sprite>
             <c:Transform/>
           </Components>
@@ -1934,6 +1960,7 @@
           <Components>
             <c:Sprite>
               <DiffuseTexture>Textures/Props/FoliageDiff.png</DiffuseTexture>
+              <GlowMap></GlowMap>
             </c:Sprite>
             <c:Transform>
               <Position X="-0.177861199" Y="0" Z="-1.04673338"/>
@@ -1954,6 +1981,7 @@
           <Components>
             <c:Sprite>
               <DiffuseTexture>Textures/Core/UnitHexagon.png</DiffuseTexture>
+              <GlowMap></GlowMap>
               <Color A="0.300000012" B="1" G="1" R="1"/>
             </c:Sprite>
             <c:Transform>
@@ -1971,6 +1999,7 @@
                 </c:Fill>
                 <c:Sprite>
                   <DiffuseTexture>Textures/Core/UnitHexagon_Rotated.png</DiffuseTexture>
+                  <GlowMap></GlowMap>
                 </c:Sprite>
                 <c:Transform>
                   <Position X="0" Y="0" Z="0.00999999978"/>
@@ -1986,6 +2015,7 @@
           <Components>
             <c:Sprite>
               <DiffuseTexture>Textures/Core/UnitHexagon.png</DiffuseTexture>
+              <GlowMap></GlowMap>
               <Color A="0.300000012" B="1" G="1" R="1"/>
             </c:Sprite>
             <c:Transform>
@@ -2003,6 +2033,7 @@
                 </c:Fill>
                 <c:Sprite>
                   <DiffuseTexture>Textures/Core/UnitHexagon_Rotated.png</DiffuseTexture>
+                  <GlowMap></GlowMap>
                 </c:Sprite>
                 <c:Transform>
                   <Position X="0" Y="0" Z="0.00999999978"/>
@@ -2018,6 +2049,7 @@
           <Components>
             <c:Sprite>
               <DiffuseTexture>Textures/Core/UnitHexagon.png</DiffuseTexture>
+              <GlowMap></GlowMap>
               <Color A="0.699999988" B="1" G="0.200000003" R="0"/>
             </c:Sprite>
             <c:Transform>
@@ -2036,6 +2068,7 @@
                 </c:Fill>
                 <c:Sprite>
                   <DiffuseTexture>Textures/Core/UnitHexagon_Rotated.png</DiffuseTexture>
+                  <GlowMap></GlowMap>
                 </c:Sprite>
                 <c:Transform>
                   <Position X="0" Y="0" Z="0.00999999978"/>
@@ -2051,6 +2084,7 @@
           <Components>
             <c:Sprite>
               <DiffuseTexture>Textures/Core/UnitHexagon.png</DiffuseTexture>
+              <GlowMap></GlowMap>
               <Color A="0.300000012" B="1" G="1" R="1"/>
             </c:Sprite>
             <c:Transform>
@@ -2068,6 +2102,7 @@
                 </c:Fill>
                 <c:Sprite>
                   <DiffuseTexture>Textures/Core/UnitHexagon_Rotated.png</DiffuseTexture>
+                  <GlowMap></GlowMap>
                 </c:Sprite>
                 <c:Transform>
                   <Position X="0" Y="0" Z="0.00999999978"/>
@@ -2083,6 +2118,7 @@
           <Components>
             <c:Sprite>
               <DiffuseTexture>Textures/Core/UnitHexagon.png</DiffuseTexture>
+              <GlowMap></GlowMap>
               <Color A="0.699999988" B="0" G="0" R="1"/>
             </c:Sprite>
             <c:Transform>
@@ -2099,6 +2135,7 @@
                 </c:Fill>
                 <c:Sprite>
                   <DiffuseTexture>Textures/Core/UnitHexagon_Rotated.png</DiffuseTexture>
+                  <GlowMap></GlowMap>
                 </c:Sprite>
                 <c:Transform>
                   <Position X="0" Y="0" Z="0.00999999978"/>
@@ -2167,6 +2204,7 @@
                   <Components>
                     <c:Sprite>
                       <DiffuseTexture>Textures/Core/ErrorTexture.png</DiffuseTexture>
+                      <GlowMap></GlowMap>
                     </c:Sprite>
                     <c:Transform>
                       <Position X="0" Y="0" Z="-1"/>
@@ -2178,6 +2216,7 @@
                         <c:Button/>
                         <c:Sprite>
                           <DiffuseTexture>Textures/Core/White.png</DiffuseTexture>
+                          <GlowMap></GlowMap>
                         </c:Sprite>
                         <c:Transform>
                           <Position X="0" Y="0.388422519" Z="0.0627754927"/>
@@ -2206,6 +2245,7 @@
                         <c:Button/>
                         <c:Sprite>
                           <DiffuseTexture>Textures/Core/White.png</DiffuseTexture>
+                          <GlowMap></GlowMap>
                         </c:Sprite>
                         <c:Transform>
                           <Position X="0" Y="0.214031488" Z="0.0627754927"/>
@@ -2234,6 +2274,7 @@
                         <c:Button/>
                         <c:Sprite>
                           <DiffuseTexture>Textures/Core/White.png</DiffuseTexture>
+                          <GlowMap></GlowMap>
                         </c:Sprite>
                         <c:Transform>
                           <Position X="0" Y="0.0367300175" Z="0.0627754927"/>
@@ -2262,6 +2303,7 @@
                         <c:Button/>
                         <c:Sprite>
                           <DiffuseTexture>Textures/Core/White.png</DiffuseTexture>
+                          <GlowMap></GlowMap>
                         </c:Sprite>
                         <c:Transform>
                           <Position X="0" Y="-0.148274168" Z="0.0627754927"/>
@@ -2290,6 +2332,7 @@
                         <c:Button/>
                         <c:Sprite>
                           <DiffuseTexture>Textures/Core/White.png</DiffuseTexture>
+                          <GlowMap></GlowMap>
                         </c:Sprite>
                         <c:Transform>
                           <Position X="0" Y="-0.335298717" Z="0.0627754927"/>
@@ -2331,6 +2374,7 @@
                   <Components>
                     <c:Sprite>
                       <DiffuseTexture>Textures/Core/ErrorTexture.png</DiffuseTexture>
+                      <GlowMap></GlowMap>
                     </c:Sprite>
                     <c:Transform>
                       <Position X="0" Y="0" Z="-1"/>
@@ -2342,6 +2386,7 @@
                         <c:Button/>
                         <c:Sprite>
                           <DiffuseTexture>Textures/Core/White.png</DiffuseTexture>
+                          <GlowMap></GlowMap>
                         </c:Sprite>
                         <c:Transform>
                           <Position X="0" Y="0.375197947" Z="0.0627754927"/>
@@ -2370,6 +2415,7 @@
                         <c:Button/>
                         <c:Sprite>
                           <DiffuseTexture>Textures/Core/White.png</DiffuseTexture>
+                          <GlowMap></GlowMap>
                         </c:Sprite>
                         <c:Transform>
                           <Position X="0" Y="0.199327558" Z="0.0627754927"/>
@@ -2398,6 +2444,7 @@
                         <c:Button/>
                         <c:Sprite>
                           <DiffuseTexture>Textures/Core/White.png</DiffuseTexture>
+                          <GlowMap></GlowMap>
                         </c:Sprite>
                         <c:Transform>
                           <Position X="0" Y="0.0159880854" Z="0.0627754927"/>
@@ -2426,6 +2473,7 @@
                         <c:Button/>
                         <c:Sprite>
                           <DiffuseTexture>Textures/Core/White.png</DiffuseTexture>
+                          <GlowMap></GlowMap>
                         </c:Sprite>
                         <c:Transform>
                           <Position X="0" Y="-0.164955258" Z="0.0627754927"/>
@@ -2482,6 +2530,36 @@
       </Components>
       <Children/>
     </Entity>
+    <Entity>
+      <Components>
+        <c:Team/>
+        <c:Transform>
+          <Position X="9.42733288" Y="8.22214794" Z="0"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity name="CapturePointArrow">
+          <Components>
+            <c:CapturePointArrowHUD>
+              <CurrentTarget>2</CurrentTarget>
+            </c:CapturePointArrowHUD>
+            <c:Model>
+              <Resource>Models/Weapons/Blue/AssaultWeaponBlue.mesh</Resource>
+            </c:Model>
+            <c:Team>
+              <Team>
+                <Red/>
+              </Team>
+            </c:Team>
+            <c:Transform>
+              <Scale X="10.7000008" Y="1.4000001" Z="5.30000019"/>
+              <Orientation X="-0.648448348" Y="-0.417814791" Z="0"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+      </Children>
+    </Entity>
   </Children>
 
 </Entity>

resources/Schema/Entities/Ray2Red

@@ -1,18 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
-<Entity xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../Types/Entity.xsd">
-
-  <Components>
-    <c:Sprite>
-      <DiffuseTexture>Textures/Effects/Ray.png</DiffuseTexture>
-      <GlowMap></GlowMap>
-      <Color A="1" B="0" G="0" R="1"/>
-    </c:Sprite>
-    <c:Transform>
-      <Position X="0" Y="0.690654039" Z="2.69841838"/>
-      <Scale X="2" Y="0.0260000005" Z="1"/>
-    </c:Transform>
-  </Components>
-
-  <Children/>
-
-</Entity>

resources/Schema/Entities/Ray2Red.xml

@@ -1,43 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
-<Entity xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../Types/Entity.xsd">
-
-  <Components>
-    <c:Transform>
-      <Scale X="0" Y="1" Z="1"/>
-    </c:Transform>
-  </Components>
-
-  <Children>
-    <Entity>
-      <Components>
-        <c:Sprite>
-          <DiffuseTexture>Textures/Effects/Ray.png</DiffuseTexture>
-          <GlowMap></GlowMap>
-          <Color A="1" B="0" G="0" R="1"/>
-        </c:Sprite>
-        <c:Transform>
-          <Position X="0" Y="0" Z="-50"/>
-          <Scale X="100" Y="0.0260000005" Z="0"/>
-          <Orientation X="0" Y="-1.57099998" Z="0"/>
-        </c:Transform>
-      </Components>
-      <Children/>
-    </Entity>
-    <Entity>
-      <Components>
-        <c:Sprite>
-          <DiffuseTexture>Textures/Effects/Ray.png</DiffuseTexture>
-          <GlowMap></GlowMap>
-          <Color A="1" B="0" G="0" R="1"/>
-        </c:Sprite>
-        <c:Transform>
-          <Position X="0" Y="0" Z="-50"/>
-          <Scale X="100" Y="0.0260000005" Z="0"/>
-          <Orientation X="0" Y="-1.57099998" Z="3.1400001"/>
-        </c:Transform>
-      </Components>
-      <Children/>
-    </Entity>
-  </Children>
-
-</Entity>

resources/Schema/Entities/SidearmWeaponView.xml

@@ -1,88 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
-<Entity name="SidearmWeapon" xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../Types/Entity.xsd">
-
-  <Components>
-    <c:Model>
-      <Resource>Models/Weapons/SecondaryWeapon.mesh</Resource>
-    </c:Model>
-    <c:Transform>
-      <Position X="-0.00200000009" Y="0.0600000024" Z="-0.297000021"/>
-    </c:Transform>
-  </Components>
-
-  <Children>
-    <Entity name="WeaponMuzzle">
-      <Components>
-        <c:Spawner>
-          <EntityFile>Schema/Entities/Ray2Red.xml</EntityFile>
-        </c:Spawner>
-        <c:Transform>
-          <Position X="0" Y="0.105000004" Z="-0.256000012"/>
-        </c:Transform>
-      </Components>
-      <Children/>
-    </Entity>
-    <Entity name="AmmunitionHUD">
-      <Components>
-        <c:AmmunitionHUD/>
-        <c:Transform>
-          <Position X="-0.0300000012" Y="0.077000007" Z="-0.063000001"/>
-          <Scale X="0.400000006" Y="0.400000006" Z="0.400000006"/>
-        </c:Transform>
-      </Components>
-      <Children>
-        <Entity name="AmmunitionHUDBackground">
-          <Components>
-            <c:Sprite>
-              <DiffuseTexture>Textures/Core/UnitHexagon.png</DiffuseTexture>
-              <GlowMap></GlowMap>
-              <Color A="0.588235319" B="0" G="0" R="0"/>
-            </c:Sprite>
-            <c:Transform>
-              <Position X="0" Y="0" Z="-0.00300000003"/>
-              <Scale X="0.119999997" Y="0.119999997" Z="0.119999997"/>
-            </c:Transform>
-          </Components>
-          <Children/>
-        </Entity>
-        <Entity name="AmmunitionText">
-          <Components>
-            <c:Transform/>
-          </Components>
-          <Children>
-            <Entity name="MagazineAmmo">
-              <Components>
-                <c:Text>
-                  <Content>16</Content>
-                  <Resource>Fonts/DroidSans.ttf,64</Resource>
-                  <Color A="1" B="3.92156863" G="1.17647064" R="0"/>
-                </c:Text>
-                <c:Transform>
-                  <Position X="0" Y="-0.00600000005" Z="0"/>
-                  <Scale X="0.0599999987" Y="0.0599999987" Z="0.0599999987"/>
-                </c:Transform>
-              </Components>
-              <Children/>
-            </Entity>
-            <Entity name="Infinity!">
-              <Components>
-                <c:Text>
-                  <Content>8</Content>
-                  <Resource>Fonts/DroidSans.ttf,64</Resource>
-                  <Color A="1" B="3.92156863" G="1.17647064" R="0"/>
-                </c:Text>
-                <c:Transform>
-                  <Position X="0.0150000006" Y="-0.029000001" Z="0"/>
-                  <Scale X="0.0399999991" Y="0.0399999991" Z="0.0399999991"/>
-                  <Orientation X="0" Y="0" Z="1.5710001"/>
-                </c:Transform>
-              </Components>
-              <Children/>
-            </Entity>
-          </Children>
-        </Entity>
-      </Children>
-    </Entity>
-  </Children>
-
-</Entity>

resources/Schema/Entities/SidearmWeaponWorld.xml

@@ -1,27 +0,0 @@
-<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
-<Entity name="SidearmWeapon" xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../Types/Entity.xsd">
-
-  <Components>
-    <c:Model>
-      <Resource>Models/Weapons/SecondaryWeapon.mesh</Resource>
-    </c:Model>
-    <c:Transform>
-      <Position X="-0.0160000008" Y="0.0800000057" Z="-0.275000006"/>
-    </c:Transform>
-  </Components>
-
-  <Children>
-    <Entity name="WeaponMuzzle">
-      <Components>
-        <c:Spawner>
-          <EntityFile>Schema/Entities/RayBlue.xml</EntityFile>
-        </c:Spawner>
-        <c:Transform>
-          <Position X="0.0123999491" Y="0.102453232" Z="-0.273824364"/>
-        </c:Transform>
-      </Components>
-      <Children/>
-    </Entity>
-  </Children>
-
-</Entity>

resources/Schema/Entities/SpectatorCamera.xml

@@ -0,0 +1,219 @@
+<?xml version="1.0" encoding="UTF-8" standalone="no" ?>
+<Entity name="SpectatorCamera" xmlns:c="components" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="../Types/Entity.xsd">
+
+  <Components>
+    <c:Camera/>
+    <c:Transform>
+      <Position X="0" Y="0" Z="0"/>
+    </c:Transform>
+  </Components>
+
+  <Children>
+    <Entity name="SpectatorHUD">
+      <Components>
+        <c:Transform>
+          <Position X="0" Y="0" Z="-0.5"/>
+        </c:Transform>
+      </Components>
+      <Children>
+        <Entity name="RespawnTimer">
+          <Components>
+            <c:Text>
+              <Content>Time to respawn: 0</Content>
+              <Resource>Fonts/DroidSans.ttf,64</Resource>
+              <Color A="1" B="0" G="1" R="0.784313738"/>
+              <Alignment>
+                <Left/>
+              </Alignment>
+            </c:Text>
+            <c:Transform>
+              <Position X="-0.115000000" Y="0.15304254" Z="0"/>
+              <Scale X="0.0250000004" Y="0.0250000004" Z="1"/>
+            </c:Transform>
+          </Components>
+          <Children/>
+        </Entity>
+        <Entity name="CapturePointHUD">
+          <Components>
+            <c:Transform>
+              <Position X="0" Y="0.190541431" Z="0"/>
+              <Scale X="0.0599999987" Y="0.0599999987" Z="0.0599999987"/>
+            </c:Transform>
+          </Components>
+          <Children>
+            <Entity name="BackgroundHexagon">
+              <Components>
+                <c:Sprite>
+                  <DiffuseTexture>Textures/Core/UnitHexagon.png</DiffuseTexture>
+                  <GlowMap></GlowMap>
+                  <Color A="0.300000012" B="1" G="1" R="1"/>
+                </c:Sprite>
+                <c:Transform>
+                  <Position X="0" Y="0.919596612" Z="0"/>
+                </c:Transform>
+              </Components>
+              <Children>
+                <Entity name="ProgressionHexagon">
+                  <Components>
+                    <c:CapturePointHUD>
+                      <CapturePointNumber>2</CapturePointNumber>
+                    </c:CapturePointHUD>
+                    <c:Fill>
+                      <Color A="0.699999988" B="1" G="0.200000003" R="0"/>
+                    </c:Fill>
+                    <c:Sprite>
+                      <DiffuseTexture>Textures/Core/UnitHexagon_Rotated.png</DiffuseTexture>
+                      <GlowMap></GlowMap>
+                    </c:Sprite>
+                    <c:Transform>
+                      <Position X="0" Y="0" Z="0.00999999978"/>
+                      <Scale X="0.800000012" Y="0.800000012" Z="0.800000012"/>
+                      <Orientation X="0" Y="0" Z="1.57079637"/>
+                    </c:Transform>
+                  </Components>
+                  <Children/>
+                </Entity>
+              </Children>
+            </Entity>
+            <Entity name="BackgroundHexagon">
+              <Components>
+                <c:Sprite>
+                  <DiffuseTexture>Textures/Core/UnitHexagon.png</DiffuseTexture>
+                  <GlowMap></GlowMap>
+                  <Color A="0.300000012" B="1" G="1" R="1"/>
+                </c:Sprite>
+                <c:Transform>
+                  <Position X="0.811270177" Y="0.440691769" Z="-0.100000001"/>
+                </c:Transform>
+              </Components>
+              <Children>
+                <Entity name="ProgressionHexagon">
+                  <Components>
+                    <c:CapturePointHUD>
+                      <CapturePointNumber>3</CapturePointNumber>
+                    </c:CapturePointHUD>
+                    <c:Fill>
+                      <Color A="0.699999988" B="1" G="0.200000003" R="0"/>
+                    </c:Fill>
+                    <c:Sprite>
+                      <DiffuseTexture>Textures/Core/UnitHexagon_Rotated.png</DiffuseTexture>
+                      <GlowMap></GlowMap>
+                    </c:Sprite>
+                    <c:Transform>
+                      <Position X="0" Y="0" Z="0.00999999978"/>
+                      <Scale X="0.800000012" Y="0.800000012" Z="0.800000012"/>
+                      <Orientation X="0" Y="0" Z="1.57079637"/>
+                    </c:Transform>
+                  </Components>
+                  <Children/>
+                </Entity>
+              </Children>
+            </Entity>
+            <Entity name="BackgroundHexagon">
+              <Components>
+                <c:Sprite>
+                  <DiffuseTexture>Textures/Core/UnitHexagon.png</DiffuseTexture>
+                  <GlowMap></GlowMap>
+                  <Color A="0.699999988" B="1" G="0.200000003" R="0"/>
+                </c:Sprite>
+                <c:Transform>
+                  <Position X="1.62788737" Y="0.919596612" Z="0"/>
+                </c:Transform>
+              </Components>
+              <Children>
+                <Entity name="ProgressionHexagon">
+                  <Components>
+                    <c:CapturePointHUD>
+                      <CapturePointNumber>4</CapturePointNumber>
+                    </c:CapturePointHUD>
+                    <c:Fill>
+                      <Color A="0.699999988" B="1" G="0.200000003" R="0"/>
+                    </c:Fill>
+                    <c:Sprite>
+                      <DiffuseTexture>Textures/Core/UnitHexagon_Rotated.png</DiffuseTexture>
+                      <GlowMap></GlowMap>
+                    </c:Sprite>
+                    <c:Transform>
+                      <Position X="0" Y="0" Z="0.00999999978"/>
+                      <Scale X="0.800000012" Y="0.800000012" Z="0.800000012"/>
+                      <Orientation X="0" Y="0" Z="1.57079637"/>
+                    </c:Transform>
+                  </Components>
+                  <Children/>
+                </Entity>
+              </Children>
+            </Entity>
+            <Entity name="BackgroundHexagon">
+              <Components>
+                <c:Sprite>
+                  <DiffuseTexture>Textures/Core/UnitHexagon.png</DiffuseTexture>
+                  <GlowMap></GlowMap>
+                  <Color A="0.300000012" B="1" G="1" R="1"/>
+                </c:Sprite>
+                <c:Transform>
+                  <Position X="-0.820431828" Y="0.441878349" Z="-0.100000001"/>
+                </c:Transform>
+              </Components>
+              <Children>
+                <Entity name="ProgressionHexagon">
+                  <Components>
+                    <c:CapturePointHUD>
+                      <CapturePointNumber>1</CapturePointNumber>
+                    </c:CapturePointHUD>
+                    <c:Fill>
+                      <Percentage>0.59265931447347009</Percentage>
+                      <Color A="0.699999988" B="0" G="0" R="1"/>
+                    </c:Fill>
+                    <c:Sprite>
+                      <DiffuseTexture>Textures/Core/UnitHexagon_Rotated.png</DiffuseTexture>
+                      <GlowMap></GlowMap>
+                    </c:Sprite>
+                    <c:Transform>
+                      <Position X="0" Y="0" Z="0.00999999978"/>
+                      <Scale X="0.800000012" Y="0.800000012" Z="0.800000012"/>
+                      <Orientation X="0" Y="0" Z="4.71238899"/>
+                    </c:Transform>
+                  </Components>
+                  <Children/>
+                </Entity>
+              </Children>
+            </Entity>
+            <Entity name="BackgroundHexagon">
+              <Components>
+                <c:Sprite>
+                  <DiffuseTexture>Textures/Core/UnitHexagon.png</DiffuseTexture>
+                  <GlowMap></GlowMap>
+                  <Color A="0.699999988" B="0" G="0" R="1"/>
+                </c:Sprite>
+                <c:Transform>
+                  <Position X="-1.58304751" Y="0.919596612" Z="0"/>
+                </c:Transform>
+              </Components>
+              <Children>
+                <Entity name="ProgressionHexagon">
+                  <Components>
+                    <c:CapturePointHUD/>
+                    <c:Fill>
+                      <Color A="0.699999988" B="1" G="0.200000003" R="0"/>
+                    </c:Fill>
+                    <c:Sprite>
+                      <DiffuseTexture>Textures/Core/UnitHexagon_Rotated.png</DiffuseTexture>
+                      <GlowMap></GlowMap>
+                    </c:Sprite>
+                    <c:Transform>
+                      <Position X="0" Y="0" Z="0.00999999978"/>
+                      <Scale X="0.800000012" Y="0.800000012" Z="0.800000012"/>
+                      <Orientation X="0" Y="0" Z="1.57079637"/>
+                    </c:Transform>
+                  </Components>
+                  <Children/>
+                </Entity>
+              </Children>
+            </Entity>
+          </Children>
+        </Entity>
+      </Children>
+    </Entity>
+  </Children>
+
+</Entity>

resources/Schema/Types/Entity.xsd

@@ -51,8 +51,17 @@
 							<xs:element ref="c:Page" minOccurs="0"/>
 							<xs:element ref="c:Button" minOccurs="0"/>
 							<xs:element ref="c:WeaponAttachment" minOccurs="0"/>
+							<xs:element ref="c:AbilityCooldownHUD" minOccurs="0"/>
 							<xs:element ref="c:DefenderWeapon" minOccurs="0"/>
-							<xs:element ref="c:SidearmWeapon" minOccurs="0"/>
+							<xs:element ref="c:CapturePointArrowHUD" minOccurs="0"/>
+							<xs:element ref="c:BoostIconsHUD" minOccurs="0"/>
+							<xs:element ref="c:FloatingEffect" minOccurs="0"/>
+							<xs:element ref="c:AmmoPickup" minOccurs="0"/>
+							<xs:element ref="c:HealthPickup" minOccurs="0"/>
+							<xs:element ref="c:CapturePointGameMode" minOccurs="0"/>
+							<xs:element ref="c:DoubleJump" minOccurs="0"/>
+							<xs:element ref="c:HealthHUD" minOccurs="0"/>
+							<xs:element ref="c:SpriteIndicator" minOccurs="0"/>
 						</xs:all>
 					</xs:complexType>
 				</xs:element>

resources/Shaders/DrawColorCorrection.frag.glsl

@@ -2,8 +2,6 @@
 
 layout (binding = 0) uniform sampler2D SceneTexture;
 layout (binding = 1) uniform sampler2D BloomTexture;
-layout (binding = 2) uniform sampler2D SceneTextureLowRes;
-layout (binding = 3) uniform sampler2D BloomTextureLowRes;
 uniform float Exposure;
 uniform float Gamma;
 
@@ -17,21 +15,12 @@ void main()
 {
 	vec4 hdrColor = texture(SceneTexture, Input.TextureCoordinate);
 	vec4 bloomColor = texture(BloomTexture, Input.TextureCoordinate);
-	vec4 hdrColorLowRes = texture(SceneTextureLowRes, Input.TextureCoordinate);
-	vec4 bloomColorLowRes = texture(BloomTextureLowRes, Input.TextureCoordinate);
 
 	//hdrColor = hdrColor * SSAO;
 	hdrColor += bloomColor;
-	hdrColorLowRes;
 
-	float hdrColorsum = hdrColorLowRes.r + hdrColorLowRes.g + hdrColorLowRes.b;
 	//Toon mapping thingy
-	vec3 result;
-	if(hdrColorsum > 0.0) {
-		result = vec3(1.0) - exp(-hdrColorLowRes.rgb * Exposure);
-	} else {
-		result = vec3(1.0) - exp(-hdrColor.rgb * Exposure);
-	}
+	vec3 result = vec3(1.0) - exp(-hdrColor.rgb * Exposure);
 
 	//gamme correction
 	result = pow(result, vec3(1.0 / Gamma));

resources/Shaders/ForwardPlusShieldCheck.frag.glsl

@@ -0,0 +1,207 @@
+#version 430
+
+#define MIN_AMBIENT_LIGHT 0.3
+
+uniform mat4 M;
+uniform mat4 V;
+uniform mat4 P;
+uniform vec4 Color;
+uniform vec4 DiffuseColor;
+uniform vec2 ScreenDimensions;
+uniform vec4 FillColor;
+uniform vec4 AmbientColor;
+uniform float FillPercentage;
+uniform float GlowIntensity = 10;
+uniform vec3 CameraPosition;
+uniform int SSAOQuality;
+
+uniform vec2 DiffuseUVRepeat;
+uniform vec2 NormalUVRepeat;
+uniform vec2 SpecularUVRepeat;
+uniform vec2 GlowUVRepeat;
+layout (binding = 0) uniform sampler2D AOTexture;
+layout (binding = 1) uniform sampler2D DiffuseTexture;
+layout (binding = 2) uniform sampler2D NormalMapTexture;
+layout (binding = 3) uniform sampler2D SpecularMapTexture;
+layout (binding = 4) uniform sampler2D GlowMapTexture;
+layout (binding = 5) uniform samplerCube CubeMap;
+layout (binding = 31) uniform sampler2D ShieldBuffer;
+
+#define TILE_SIZE 16
+
+struct LightSource {
+	vec4 Position;
+	vec4 Direction;
+	vec4 Color;
+	float Radius;
+	float Intensity;
+	float Falloff;
+	int Type;
+};
+
+layout (std430, binding = 1) buffer LightBuffer
+{
+	LightSource List[];
+} LightSources;
+
+struct LightGrid {
+	float Start;
+	float Amount;
+	vec2 Padding;
+};
+
+layout (std430, binding = 2) buffer LightGridBuffer
+{
+	LightGrid Data[];
+} LightGrids;
+
+layout (std430, binding = 4) buffer LightIndexBuffer
+{
+	float LightIndex[];
+};
+
+
+in VertexData{
+	vec3 Position;
+	vec3 Normal;
+	vec3 Tangent;
+	vec3 BiTangent;
+	vec2 TextureCoordinate;
+	vec4 ExplosionColor;
+	float ExplosionPercentageElapsed;
+}Input;
+
+out vec4 sceneColor;
+out vec4 bloomColor;
+
+struct LightResult {
+	vec4 Diffuse;
+	vec4 Specular;
+};
+
+float CalcAttenuation(float radius, float dist, float falloff) {
+	return 1.0 - smoothstep(radius * falloff, radius, dist);
+}
+
+vec4 CalcSpecular(vec4 lightColor, vec4 viewVec,  vec4 lightVec, vec4 normal) {
+	vec4 R = normalize( reflect(-lightVec, normal));
+	float RdotV = max( dot(R, viewVec), 0.0);
+	return lightColor * pow(RdotV, 90.0);
+}
+
+vec4 CalcDiffuse(vec4 lightColor, vec4 lightVec, vec4 normal) {
+	float power = max( dot(normal, lightVec), 0.0);
+	return lightColor * power;
+}
+
+LightResult CalcPointLightSource(vec4 lightPos, float lightRadius, vec4 lightColor, float intensity, vec4 viewVec, vec4 position, vec4 normal, float falloff)
+{
+	vec4 L = lightPos - position;
+	float dist = length(L);
+	L = normalize(L);
+
+	float attenuation = CalcAttenuation(lightRadius, dist, falloff);
+
+	LightResult result;
+	result.Diffuse = CalcDiffuse(lightColor, L, normal) * attenuation * intensity;
+	result.Specular = CalcSpecular(lightColor, viewVec, L, normal) * attenuation *  intensity;
+	return result;
+}
+
+LightResult CalcDirectionalLightSource(vec4 direction, vec4 color, float intensity, vec4 viewVec, vec4 vertNormal)
+{
+	vec4 L = normalize( -vec4(direction.xyz, 0) );
+
+	LightResult result;
+	result.Diffuse = CalcDiffuse(color, L, vertNormal) * intensity;
+	result.Specular = CalcSpecular(color, viewVec, L, vertNormal) * intensity;
+	return result;
+}
+
+vec4 CalcNormalMappedValue(vec3 normal, vec3 tangent, vec3 bitangent, vec2 textureCoordinate, sampler2D normalMap)
+{
+	mat3 TBN = mat3(tangent, bitangent, normal);
+	vec3 NormalMap = texture(normalMap, textureCoordinate).xyz * 2.0 - vec3(1.0);
+	return vec4(TBN * normalize(NormalMap), 0.0);
+}
+
+void main()
+{
+	float shieldDepthValue = texelFetch(ShieldBuffer, ivec2(gl_FragCoord.xy), 0).r;
+	
+	if(shieldDepthValue < gl_FragCoord.z){
+		discard;
+	}
+
+	float ao = texelFetch(AOTexture, ivec2(gl_FragCoord.xy) >> int(SSAOQuality), 0).r;
+	ao = (clamp(1.0 - (1.0 - ao), 0.0, 1.0) + MIN_AMBIENT_LIGHT) /  (1.0 + MIN_AMBIENT_LIGHT);
+	vec4 diffuseTexel = texture2D(DiffuseTexture, Input.TextureCoordinate * DiffuseUVRepeat);
+	vec4 glowTexel = texture2D(GlowMapTexture, Input.TextureCoordinate * GlowUVRepeat);
+	vec4 specularTexel = texture2D(SpecularMapTexture, Input.TextureCoordinate * SpecularUVRepeat);
+	vec4 position = V * M * vec4(Input.Position, 1.0); 
+	vec4 normal = V * CalcNormalMappedValue(Input.Normal, Input.Tangent, Input.BiTangent, Input.TextureCoordinate * NormalUVRepeat, NormalMapTexture);
+	normal = normalize(normal);
+	//vec4 normal = normalize(V  * vec4(Input.Normal, 0.0));
+	vec4 viewVec = normalize(-position);
+	vec3 I = normalize(vec3(M * vec4(Input.Position, 1.0)) - CameraPosition);
+	vec3 R = reflect(-I, Input.Normal);
+	//R = vec3(P * vec4(R, 1.0));
+	vec4 reflectionColor = texture(CubeMap, R);
+
+	vec2 tilePos;
+	tilePos.x = int(gl_FragCoord.x/TILE_SIZE);
+	tilePos.y = int(gl_FragCoord.y/TILE_SIZE);
+
+	LightResult totalLighting;
+	totalLighting.Diffuse = vec4(AmbientColor.rgb * ao, 1.0);
+	int currentTile = int(floor(gl_FragCoord.x/TILE_SIZE) + (floor(gl_FragCoord.y/TILE_SIZE) * int(ScreenDimensions.x/TILE_SIZE)));
+
+	int start = int(LightGrids.Data[currentTile].Start);
+	int amount = int(LightGrids.Data[currentTile].Amount);
+
+	for(int i = start; i < start + amount; i++) {
+
+		int l = int(LightIndex[i]);
+		LightSource light = LightSources.List[l];
+
+		LightResult light_result;
+		//These if statements should be removed.
+		if(light.Type == 1) { // point
+			light_result = CalcPointLightSource(V * light.Position, light.Radius, light.Color, light.Intensity, viewVec, position, normal, light.Falloff);
+		} else if (light.Type == 2) { //Directional
+			light_result = CalcDirectionalLightSource(V * light.Direction, light.Color, light.Intensity, viewVec, normal);
+		}
+		totalLighting.Diffuse += vec4(light_result.Diffuse.rgb * ao, light_result.Diffuse.a);
+		totalLighting.Specular += vec4(light_result.Specular.rgb * ao, light_result.Specular.a);
+	}
+
+	vec4 color_result = mix((Color * diffuseTexel * DiffuseColor), Input.ExplosionColor, Input.ExplosionPercentageElapsed);
+	color_result = color_result * (totalLighting.Diffuse + (totalLighting.Specular * specularTexel));
+	float specularResult = (specularTexel.r + specularTexel.g + specularTexel.b)/3.0;
+	vec4 reflectionTotal = reflectionColor * (1-specularTexel.a) * color_result.a;
+	color_result = color_result * clamp(1/specularTexel.a, 0, 1) + reflectionTotal;
+	//vec4 color_result = (DiffuseColor + Input.ExplosionColor) * (totalLighting.Diffuse + (totalLighting.Specular * specularTexel)) * diffuseTexel * Color;
+	
+
+	float pos = ((P * vec4(Input.Position, 1)).y + 1.0)/2.0;
+
+	if(pos <= FillPercentage) {
+		color_result += FillColor;
+	}
+	sceneColor = vec4(color_result.xyz, clamp(color_result.a, 0, 1));
+	//sceneColor = vec4(reflectionColor.xyz, 1);
+	color_result.xyz += glowTexel.xyz*GlowIntensity;
+
+	bloomColor = vec4(max(color_result.xyz - 1.0, 0.0), clamp(color_result.a, 0, 1));
+
+	//Tiled Debug Code
+	/*
+	if(int(gl_FragCoord.x)%16 == 0 || int(gl_FragCoord.y)%16 == 0 ) {
+		sceneColor += vec4(0.5, 0, 0, 0);
+	} else {
+		sceneColor += vec4(LightGrids.Data[int(tilePos.x + tilePos.y*80)].Amount/LightSources.List.length(), 0, 0, 1);
+	}
+	*/
+}
+
+

resources/Shaders/ForwardPlusSplatMapRGBShieldCheck.frag.glsl

@@ -0,0 +1,253 @@
+#version 430
+
+#define MIN_AMBIENT_LIGHT 0.3
+
+uniform mat4 M;
+uniform mat4 V;
+uniform mat4 P;
+uniform vec2 ScreenDimensions;
+uniform float FillPercentage;
+uniform vec4 DiffuseColor;
+uniform vec4 FillColor;
+uniform vec4 Color;
+uniform vec4 AmbientColor;
+uniform int SSAOQuality;
+
+//Get bineded at the same time as the textures
+uniform vec2 DiffuseUVRepeat1;
+uniform vec2 DiffuseUVRepeat2;
+uniform vec2 DiffuseUVRepeat3;
+uniform vec2 NormalUVRepeat1;
+uniform vec2 NormalUVRepeat2;
+uniform vec2 NormalUVRepeat3;
+uniform vec2 SpecularUVRepeat1;
+uniform vec2 SpecularUVRepeat2;
+uniform vec2 SpecularUVRepeat3;
+uniform vec2 GlowUVRepeat1;
+uniform vec2 GlowUVRepeat2;
+uniform vec2 GlowUVRepeat3;
+layout (binding = 0) uniform sampler2D AOTexture;
+layout (binding = 1) uniform sampler2D SplatMapTexture;
+layout (binding = 2) uniform sampler2D DiffuseTexture1;
+layout (binding = 3) uniform sampler2D DiffuseTexture2;
+layout (binding = 4) uniform sampler2D DiffuseTexture3;
+layout (binding = 5) uniform sampler2D NormalMapTexture1;
+layout (binding = 6) uniform sampler2D NormalMapTexture2;
+layout (binding = 7) uniform sampler2D NormalMapTexture3;
+layout (binding = 8) uniform sampler2D SpecularMapTexture1;
+layout (binding = 9) uniform sampler2D SpecularMapTexture2;
+layout (binding = 10) uniform sampler2D SpecularMapTexture3;
+layout (binding = 11) uniform sampler2D GlowMapTexture1;
+layout (binding = 12) uniform sampler2D GlowMapTexture2;
+layout (binding = 13) uniform sampler2D GlowMapTexture3;
+layout (binding = 31) uniform samplerCube ShieldBuffer;
+
+#define TILE_SIZE 16
+
+struct LightSource {
+	vec4 Position;
+	vec4 Direction;
+	vec4 Color;
+	float Radius;
+	float Intensity;
+	float Falloff;
+	int Type;
+};
+
+layout (std430, binding = 1) buffer LightBuffer
+{
+	LightSource List[];
+} LightSources;
+
+struct LightGrid {
+	float Start;
+	float Amount;
+	vec2 Padding;
+};
+
+layout (std430, binding = 2) buffer LightGridBuffer
+{
+	LightGrid Data[];
+} LightGrids;
+
+layout (std430, binding = 4) buffer LightIndexBuffer
+{
+	float LightIndex[];
+};
+
+
+in VertexData{
+	vec3 Position;
+	vec3 Normal;
+	vec3 Tangent;
+	vec3 BiTangent;
+	vec2 TextureCoordinate;
+	vec4 ExplosionColor;
+	float ExplosionPercentageElapsed;
+}Input;
+
+out vec4 sceneColor;
+out vec4 bloomColor;
+
+struct LightResult {
+	vec4 Diffuse;
+	vec4 Specular;
+};
+
+float CalcAttenuation(float radius, float dist, float falloff) {
+	return 1.0 - smoothstep(radius * 0.3, radius, dist);
+}
+
+vec4 CalcSpecular(vec4 lightColor, vec4 viewVec,  vec4 lightVec, vec4 normal) {
+	vec4 R = normalize( reflect(-lightVec, normal));
+	float RdotV = max( dot(R, viewVec), 0.0);
+	return lightColor * pow(RdotV, 90.0);
+}
+
+vec4 CalcDiffuse(vec4 lightColor, vec4 lightVec, vec4 normal) {
+	float power = max( dot(normal, lightVec), 0.0);
+	return lightColor * power;
+}
+
+LightResult CalcPointLightSource(vec4 lightPos, float lightRadius, vec4 lightColor, float intensity, vec4 viewVec, vec4 position, vec4 normal, float falloff)
+{
+	vec4 L = lightPos - position;
+	float dist = length(L);
+	L = normalize(L);
+
+	float attenuation = CalcAttenuation(lightRadius, dist, falloff);
+
+	LightResult result;
+	result.Diffuse = CalcDiffuse(lightColor, L, normal) * attenuation * intensity;
+	result.Specular = CalcSpecular(lightColor, viewVec, L, normal) * attenuation *  intensity;
+	return result;
+}
+
+LightResult CalcDirectionalLightSource(vec4 direction, vec4 color, float intensity, vec4 viewVec, vec4 vertNormal)
+{
+	vec4 L = normalize( -vec4(direction.xyz, 0) );
+
+	LightResult result;
+	result.Diffuse = CalcDiffuse(color, L, vertNormal) * intensity;
+	result.Specular = CalcSpecular(color, viewVec, L, vertNormal) * intensity;
+	return result;
+}
+
+vec4 CalcNormalMappedValue(vec3 normal, vec3 tangent, vec3 bitangent, vec2 textureCoordinate, sampler2D normalMap)
+{
+	mat3 TBN = mat3(tangent, bitangent, normal);
+	vec3 NormalMap = texture(normalMap, textureCoordinate).xyz * 2.0 - vec3(1.0);
+	return vec4(TBN * normalize(NormalMap), 0.0);
+}
+
+vec4 CalcBlendedTexel(vec4 blendValue, sampler2D R, sampler2D G, sampler2D B,
+	 				  vec2 R_TileValues,  vec2 G_TileValues,  vec2 B_TileValues){
+	vec4 R_Channel = texture2D(R, Input.TextureCoordinate * R_TileValues);
+	vec4 G_Channel = texture2D(G, Input.TextureCoordinate * G_TileValues);
+	vec4 B_Channel = texture2D(B, Input.TextureCoordinate * B_TileValues);
+
+	float total = blendValue.r + blendValue.g + blendValue.b;
+	float totalDiv = 1.0f / total;
+	blendValue.r = blendValue.r * totalDiv;
+	blendValue.g = blendValue.g * totalDiv;
+	blendValue.b = blendValue.b * totalDiv;
+
+	return blendValue.r * R_Channel
+		 + blendValue.g * G_Channel
+		 + blendValue.b * B_Channel;
+}
+
+vec4 CalcBlendedNormal(vec4 blendValue, sampler2D R, sampler2D G, sampler2D B,
+					   vec2 R_TileValues,  vec2 G_TileValues,  vec2 B_TileValues){
+	mat3 TBN = mat3(Input.Tangent, Input.BiTangent, Input.Normal);
+	vec3 R_Channel = texture(R, Input.TextureCoordinate * R_TileValues).xyz * 2.0 - vec3(1.0);
+	vec3 G_Channel = texture(G, Input.TextureCoordinate * G_TileValues).xyz * 2.0 - vec3(1.0);
+	vec3 B_Channel = texture(B, Input.TextureCoordinate * B_TileValues).xyz * 2.0 - vec3(1.0);
+
+	float total = blendValue.r + blendValue.g + blendValue.b + blendValue.a;
+	float totalDiv = 1 / total;
+	blendValue.r = blendValue.r * totalDiv;
+	blendValue.g = blendValue.g * totalDiv;
+	blendValue.b = blendValue.b * totalDiv;
+
+	vec3 Normal_result = blendValue.r * R_Channel
+					   + blendValue.g * G_Channel 
+		 			   + blendValue.b * B_Channel;
+
+	return vec4(TBN * normalize(Normal_result), 0.0);
+}
+
+void main()
+{
+	float ao = texelFetch(AOTexture, ivec2(gl_FragCoord.xy) >> int(SSAOQuality), 0).r;
+	ao = (clamp(1.0 - (1.0 - ao), 0.0, 1.0) + MIN_AMBIENT_LIGHT) /  (1.0 + MIN_AMBIENT_LIGHT);
+
+	vec4 splatTexel = texture2D(SplatMapTexture, Input.TextureCoordinate);
+
+	vec4 diffuseTexel = CalcBlendedTexel(splatTexel, DiffuseTexture1, DiffuseTexture2, DiffuseTexture3,
+	 									 DiffuseUVRepeat1, DiffuseUVRepeat2, DiffuseUVRepeat3);
+	vec4 glowTexel = CalcBlendedTexel(splatTexel, GlowMapTexture1, GlowMapTexture2, GlowMapTexture3,
+	 									 GlowUVRepeat1, GlowUVRepeat2, GlowUVRepeat3);
+	vec4 specularTexel = CalcBlendedTexel(splatTexel, SpecularMapTexture1, SpecularMapTexture2, SpecularMapTexture3,
+										 SpecularUVRepeat1, SpecularUVRepeat2, SpecularUVRepeat3);
+	vec4 position = V * M * vec4(Input.Position, 1.0); 
+	//vec4 normal = V * CalcNormalMappedValue(Input.Normal, Input.Tangent, Input.BiTangent, Input.TextureCoordinate, SplatMapTexture);
+	vec4 normal = V * CalcBlendedNormal(splatTexel, NormalMapTexture1, NormalMapTexture2, NormalMapTexture3,
+		   								NormalUVRepeat1, NormalUVRepeat2, NormalUVRepeat3);
+	normal = normalize(normal);
+	//vec4 normal = normalize(V  * vec4(Input.Normal, 0.0));
+	vec4 viewVec = normalize(-position); 
+
+	vec2 tilePos;
+	tilePos.x = int(gl_FragCoord.x/TILE_SIZE);
+	tilePos.y = int(gl_FragCoord.y/TILE_SIZE);
+
+	LightResult totalLighting;
+	totalLighting.Diffuse = vec4(AmbientColor.rgb * ao, 1.0);
+	int currentTile = int(floor(gl_FragCoord.x/TILE_SIZE) + (floor(gl_FragCoord.y/TILE_SIZE) * int(ScreenDimensions.x/TILE_SIZE)));
+
+	int start = int(LightGrids.Data[currentTile].Start);
+	int amount = int(LightGrids.Data[currentTile].Amount);
+
+	for(int i = start; i < start + amount; i++) {
+
+		int l = int(LightIndex[i]);
+		LightSource light = LightSources.List[l];
+
+		LightResult light_result;
+		//These if statements should be removed.
+		if(light.Type == 1) { // point
+			light_result = CalcPointLightSource(V * light.Position, light.Radius, light.Color, light.Intensity, viewVec, position, normal, light.Falloff);
+		} else if (light.Type == 2) { //Directional
+			light_result = CalcDirectionalLightSource(V * light.Direction, light.Color, light.Intensity, viewVec, normal);
+		}
+		totalLighting.Diffuse += vec4(light_result.Diffuse.rgb * ao, light_result.Diffuse.a);
+		totalLighting.Specular += vec4(light_result.Specular.rgb * ao, light_result.Specular.a);
+	}
+
+	vec4 color_result = mix((Color * diffuseTexel * DiffuseColor), Input.ExplosionColor, Input.ExplosionPercentageElapsed);
+	color_result = color_result * (totalLighting.Diffuse + (totalLighting.Specular * specularTexel));
+	//vec4 color_result = (DiffuseColor + Input.ExplosionColor) * (totalLighting.Diffuse + (totalLighting.Specular * specularTexel)) * diffuseTexel * Color;
+	
+
+	float pos = ((P * vec4(Input.Position, 1)).y + 1.0)/2.0;
+
+	if(pos <= FillPercentage) {
+		color_result += FillColor;
+	}
+	sceneColor = vec4(color_result.xyz, clamp(color_result.a, 0, 1));
+	color_result += glowTexel*3;
+
+	bloomColor = vec4(clamp(color_result.xyz - 1.0, 0, 100), 1.0);
+
+	//Tiled Debug Code
+	/*
+	if(int(gl_FragCoord.x)%16 == 0 || int(gl_FragCoord.y)%16 == 0 ) {
+		sceneColor += vec4(0.5, 0, 0, 0);
+	} else {
+		sceneColor += vec4(LightGrids.Data[int(tilePos.x + tilePos.y*80)].Amount/LightSources.List.length(), 0, 0, 1);
+	}
+	*/
+}
+
+

resources/Shaders/SpriteShieldCheck.frag.glsl

@@ -0,0 +1,41 @@
+#version 430
+
+uniform vec4 Color;
+uniform vec4 FillColor;
+uniform float FillPercentage;
+uniform mat4 M;
+uniform mat4 V;
+uniform mat4 P;
+
+layout (binding = 1) uniform sampler2D DiffuseTexture;
+layout (binding = 2) uniform sampler2D GlowMapTexture;
+
+
+in VertexData{
+	vec3 Position;
+	vec3 Normal;
+	vec2 TextureCoordinate;
+}Input;
+
+
+out vec4 sceneColor;
+out vec4 bloomColor;
+
+void main()
+{
+	vec4 diffuseTexel = texture2D(DiffuseTexture, Input.TextureCoordinate);
+	vec4 glowTexel = texture2D(GlowMapTexture, Input.TextureCoordinate);
+
+	vec4 color_result = Color * diffuseTexel;
+
+	float pos = ((P * vec4(Input.Position, 1)).y + 1.0)/2.0;
+	if(pos <= FillPercentage) {
+		color_result = FillColor*diffuseTexel.a;
+	}
+	sceneColor = vec4(color_result.xyz, clamp(color_result.a, 0, 1));
+
+	//bloomColor = vec4(clamp((glowTexel.xyz*3) - 1.0, 0, 100), 1.0);
+	bloomColor = vec4(1.0, 1.0, 1.0, 0.0);
+}
+
+

src/Engine/Core/EntityFile.cpp

@@ -1,291 +1,25 @@
 #include "Core/EntityFile.h"
 
-EntityFile::EntityFile(boost::filesystem::path path)
-    : m_FilePath(path)
+EntityFile::EntityFile(std::string path)
 {
-    using namespace xercesc;
-    XMLPlatformUtils::Initialize();
-    m_GrammarPool = new XMLGrammarPoolImpl();
-    m_SAX2XMLReader = XMLReaderFactory::createXMLReader(XMLPlatformUtils::fgMemoryManager, m_GrammarPool);
-}
+    EntityXMLFile* xml = ResourceManager::Load<EntityXMLFile>(path);
 
-EntityFile::~EntityFile()
-{
-    delete m_SAX2XMLReader;
-    delete m_GrammarPool;
-    xercesc::XMLPlatformUtils::Terminate();
-}
+    EntityXMLFilePreprocessor preprocessor(xml);
+    preprocessor.RegisterComponents(this);
 
-void EntityFile::Parse(const EntityFileHandler* handler) const
-{
-    using namespace xercesc;
+    EntityXMLFileParser parser(xml);
+    m_RootEntity = parser.MergeEntities(this);
 
-    EntityFileSAXHandler saxHandler(handler, m_SAX2XMLReader);
-    setReaderFeatures(m_SAX2XMLReader);
-    m_SAX2XMLReader->setContentHandler(&saxHandler);
-    m_SAX2XMLReader->setErrorHandler(&saxHandler);
-    m_SAX2XMLReader->setDeclarationHandler(&saxHandler);
-    m_SAX2XMLReader->parse(m_FilePath.string().c_str());
-}
-
-void EntityFile::setReaderFeatures(xercesc::SAX2XMLReader* reader)
-{
-    using namespace xercesc;
-    reader->setFeature(XMLUni::fgXercesCacheGrammarFromParse, true);
-    reader->setFeature(XMLUni::fgXercesUseCachedGrammarInParse, true);
-    reader->setFeature(XMLUni::fgSAX2CoreValidation, true);
-    reader->setFeature(XMLUni::fgSAX2CoreNameSpaces, true);
-    reader->setFeature(XMLUni::fgXercesSchema, true);
-    reader->setFeature(XMLUni::fgXercesSchemaFullChecking, true);
-    reader->setFeature(XMLUni::fgXercesCalculateSrcOfs, true);
-    reader->setFeature(XMLUni::fgXercesIdentityConstraintChecking, true);
-}
-
-unsigned int EntityFile::GetTypeStride(std::string typeName)
-{
-    std::map<std::string, unsigned int> typeStrides{
-        { "bool", sizeof(bool) },
-        { "int", sizeof(int) },
-        { "float", sizeof(float) },
-        { "double", sizeof(double) },
-        { "string", sizeof(std::string) },
-        { "enum", sizeof(ComponentInfo::EnumType) },
-        { "Vector", sizeof(glm::vec3) },
-        { "Quaternion", sizeof(glm::quat) },
-        { "Color", sizeof(glm::vec4) }
-    };
-
-    auto it = typeStrides.find(typeName);
-    return (it != typeStrides.end()) ? it->second : 0;
-}
-
-void EntityFile::WriteAttributeData(char* outData, const ComponentInfo::Field_t& field, const std::map<std::string, std::string>& attributes)
-{
-    if (field.Type == "Vector") {
-        glm::vec3 vec;
-        vec.x = boost::lexical_cast<float>(attributes.at("X"));
-        vec.y = boost::lexical_cast<float>(attributes.at("Y"));
-        vec.z = boost::lexical_cast<float>(attributes.at("Z"));
-        memcpy(outData, reinterpret_cast<char*>(&vec), field.Stride);
-    } else if (field.Type == "Color") {
-        glm::vec4 vec;
-        vec.r = boost::lexical_cast<float>(attributes.at("R"));
-        vec.g = boost::lexical_cast<float>(attributes.at("G"));
-        vec.b = boost::lexical_cast<float>(attributes.at("B"));
-        vec.a = boost::lexical_cast<float>(attributes.at("A"));
-        memcpy(outData, reinterpret_cast<char*>(&vec), field.Stride);
-    } else if (field.Type == "Quaternion") {
-        glm::quat q;
-        q.x = boost::lexical_cast<float>(attributes.at("X"));
-        q.y = boost::lexical_cast<float>(attributes.at("Y"));
-        q.z = boost::lexical_cast<float>(attributes.at("Z"));
-        q.w = boost::lexical_cast<float>(attributes.at("W"));
-        memcpy(outData, reinterpret_cast<char*>(&q), field.Stride);
-    } else if (!attributes.empty()) {
-        LOG_WARNING("%i attributes not handled by any type conversion!", attributes.size());
-    }
-}
-
-void EntityFile::WriteValueData(char* outData, const ComponentInfo::Field_t& field, const char* valueData)
-{
-    // Catch and ignore casting errors so whitespace around string enums won't mess anything up
-    try {
-        if (field.Type == "int") {
-            int value = boost::lexical_cast<int>(valueData);
-            memcpy(outData, reinterpret_cast<char*>(&value), field.Stride);
-        } else if (field.Type == "enum") {
-            ComponentInfo::EnumType value = boost::lexical_cast<ComponentInfo::EnumType>(valueData);
-            memcpy(outData, reinterpret_cast<char*>(&value), field.Stride);
-        } else if (field.Type == "float") {
-            float value = boost::lexical_cast<float>(valueData);
-            memcpy(outData, reinterpret_cast<char*>(&value), field.Stride);
-        } else if (field.Type == "double") {
-            double value = boost::lexical_cast<double>(valueData);
-            memcpy(outData, reinterpret_cast<char*>(&value), field.Stride);
-        } else if (field.Type == "bool") {
-            bool value = (valueData[0] == 't'); // Lazy bool evaluation
-            memcpy(outData, reinterpret_cast<char*>(&value), field.Stride);
-        } else if (field.Type == "string") {
-            new (outData) std::string(valueData);
-        } else {
-            LOG_WARNING("Unknown value data type: %s", field.Type.c_str());
-        }
-    } catch (const boost::bad_lexical_cast&) { }
-}
-
-EntityFileSAXHandler::EntityFileSAXHandler(const EntityFileHandler* handler, xercesc::SAX2XMLReader* reader) 
-    : m_Handler(handler)
-    , m_Reader(reader)
-{
-    // 0 is imaginary base parent
-    m_EntityStack.push(0);
-    m_StateStack.push(State::Unknown);
-}
-
-void EntityFileSAXHandler::startElement(const XMLCh* const _uri, const XMLCh* const _localName, const XMLCh* const _qname, const xercesc::Attributes& attrs)
-{
-    std::string name = XS::ToString(_localName);
-
-    if (m_StateStack.top() == State::Unknown || m_StateStack.top() == State::Entity) {
-        if (name == "Entity") {
-            m_StateStack.push(State::Entity);
-            onStartEntity(attrs);
-            return;
-        }
-        if (name == "EntityRef") {
-            onStartEntityRef(attrs);
-            return;
-        }
+    if (m_RootEntity == EntityID_Invalid) {
+        ResourceManager::Release("EntityXMLFile", path);
+        throw Resource::FailedLoadingException("Failed to merge entities; root entity is invalid");
     }
 
-    std::string uri = XS::ToString(_uri);
-    if (m_StateStack.top() == State::Entity) {
-        if (uri == "components") {
-            m_StateStack.push(State::Component);
-            onStartComponent(name);
-            return;
-        }
-    }
-
-    if (m_StateStack.top() == State::Component) {
-        m_StateStack.push(State::ComponentField);
-        onStartComponentField(name, attrs);
-        return;
-    }
+    ResourceManager::Release("EntityXMLFile", path);
 }
 
-void EntityFileSAXHandler::endElement(const XMLCh* const _uri, const XMLCh* const _localName, const XMLCh* const _qname)
+EntityWrapper EntityFile::MergeInto(World* other)
 {
-    std::string name = XS::ToString(_localName);
-    if (m_StateStack.top() == State::Entity) {
-        if (name == "Entity") {
-            m_StateStack.pop();
-            onEndEntity();
-            return;
-        }
-    }
-
-    std::string uri = XS::ToString(_uri);
-    if (m_StateStack.top() == State::Component) {
-        //if (uri == "components") {
-        m_StateStack.pop();
-        onEndComponent(name);
-        return;
-        //}
-    }
-
-    if (m_StateStack.top() == State::ComponentField && name == m_CurrentField) {
-        m_StateStack.pop();
-        onEndComponentField(name);
-        return;
-    }
-}
-
-void EntityFileSAXHandler::characters(const XMLCh* const chars, const XMLSize_t length)
-{
-    if (m_StateStack.top() == State::ComponentField) {
-        char* transcoded = xercesc::XMLString::transcode(chars);
-        onFieldData(transcoded);
-    }
-}
-
-void EntityFileSAXHandler::fatalError(const xercesc::SAXParseException& e)
-{
-    std::string message = XS::ToString(e.getMessage());
-    std::string systemId = XS::ToString(e.getSystemId());
-    XMLFileLoc line = e.getLineNumber();
-    XMLFileLoc column = e.getColumnNumber();
-    LOG_ERROR("SAXParseException\n\tLocation: %s:%i:%i\n\tFatal Error: %s", systemId.c_str(), line, column, message.c_str());
-}
-
-void EntityFileSAXHandler::error(const xercesc::SAXParseException& e)
-{
-    std::string message = XS::ToString(e.getMessage());
-    std::string systemId = XS::ToString(e.getSystemId());
-    XMLFileLoc line = e.getLineNumber();
-    XMLFileLoc column = e.getColumnNumber();
-    LOG_ERROR("SAXParseException\n\tLocation: %s:%i:%i\n\tError: %s", systemId.c_str(), line, column, message.c_str());
-}
-
-void EntityFileSAXHandler::warning(const xercesc::SAXParseException& e)
-{
-    std::string message = XS::ToString(e.getMessage());
-    std::string systemId = XS::ToString(e.getSystemId());
-    XMLFileLoc line = e.getLineNumber();
-    XMLFileLoc column = e.getColumnNumber();
-    LOG_ERROR("SAXParseException\n\tLocation: %s:%i:%i\n\tWarning: %s", systemId.c_str(), line, column, message.c_str());
-}
-
-void EntityFileSAXHandler::onStartEntity(const xercesc::Attributes& attrs)
-{
-    EntityID parent = m_EntityStack.top();
-
-    if (m_Handler->m_OnStartEntityCallback) {
-        std::string name;
-        auto xName = attrs.getValue(XS::ToXMLCh("name"));
-        if (xName != nullptr) {
-            name = XS::ToString(xName);
-        }
-        m_Handler->m_OnStartEntityCallback(m_NextEntityID, parent, name);
-    }
-
-    m_EntityStack.push(m_NextEntityID);
-    m_NextEntityID++;
-}
-
-void EntityFileSAXHandler::onEndEntity()
-{
-    m_EntityStack.pop();
-}
-
-void EntityFileSAXHandler::onStartEntityRef(const xercesc::Attributes& attrs)
-{
-    std::string path = XS::ToString(attrs.getValue(XS::ToXMLCh("file")));
-
-    xercesc::SAX2XMLReader* reader = xercesc::XMLReaderFactory::createXMLReader();
-    EntityFile::setReaderFeatures(reader);
-    reader->setContentHandler(this);
-    reader->setErrorHandler(this);
-    reader->parse(path.c_str());
-    delete reader;
-}
-
-void EntityFileSAXHandler::onStartComponentField(const std::string& field, const xercesc::Attributes& attrs)
-{
-    //LOG_DEBUG("        Field: %s", field.c_str());
-    m_CurrentField = field;
-    m_CurrentAttributes.clear();
-    for (int i = 0; i < attrs.getLength(); i++) {
-        auto name = attrs.getQName(i);
-        auto value = attrs.getValue(name);
-        //LOG_DEBUG("            %s = %s", (char*)XS::ToString(name), (char*)XS::ToString(value));
-        m_CurrentAttributes[XS::ToString(name).operator std::string()] = XS::ToString(value).operator std::string();
-    }
-
-    if (m_Handler->m_OnStartFieldCallback) {
-        m_Handler->m_OnStartFieldCallback(m_EntityStack.top(), m_CurrentComponent, field, m_CurrentAttributes);
-    }
-}
-
-void EntityFileSAXHandler::onEndComponent(const std::string& name) { }
-
-void EntityFileSAXHandler::onStartComponent(const std::string& name)
-{
-    //LOG_DEBUG("    Component: %s", name.c_str());
-    m_CurrentComponent = name;
-    if (m_Handler->m_OnStartComponentCallback) {
-        m_Handler->m_OnStartComponentCallback(m_EntityStack.top(), name);
-    }
-}
-
-void EntityFileSAXHandler::onEndComponentField(const std::string& field) { }
-
-void EntityFileSAXHandler::onFieldData(char* data)
-{
-    //LOG_DEBUG("            Data: %s", data);
-    if (m_Handler->m_OnStartFieldDataCallback) {
-        m_Handler->m_OnStartFieldDataCallback(m_EntityStack.top(), m_CurrentComponent, m_CurrentField, data);
-    }
-
-    xercesc::XMLString::release(&data);
-}
+    auto mapping = other->Merge(this);
+    return EntityWrapper(other, mapping.at(m_RootEntity));
+}

src/Engine/Core/EntityFileParser.cpp

@@ -1,74 +0,0 @@
-#include "Core/EntityFileParser.h"
-
-EntityFileParser::EntityFileParser(const EntityFile* entityFile) 
-    : m_EntityFile(entityFile)
-{
-    m_Handler.SetStartEntityCallback(std::bind(&EntityFileParser::onStartEntity, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
-    m_Handler.SetStartComponentCallback(std::bind(&EntityFileParser::onStartComponent, this, std::placeholders::_1, std::placeholders::_2));
-    m_Handler.SetStartFieldCallback(std::bind(&EntityFileParser::onStartComponentField, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
-    m_Handler.SetStartFieldDataCallback(std::bind(&EntityFileParser::onFieldData, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
-}
-
-EntityID EntityFileParser::MergeEntities(World* world, EntityID baseParent /*= EntityID_Invalid */)
-{
-    m_World = world;
-    m_EntityIDMapper[0] = baseParent;
-    m_EntityFile->Parse(&m_Handler);
-    return m_FirstEntity;
-}
-
-void EntityFileParser::onStartEntity(EntityID entity, EntityID parent, const std::string& name)
-{
-    EntityID realParent = m_EntityIDMapper.at(parent);
-    EntityID realEntity = m_World->CreateEntity(realParent);
-    if (m_FirstEntity == EntityID_Invalid) {
-        m_FirstEntity = realEntity;
-    }
-    if (!name.empty()) {
-        m_World->SetName(realEntity, name);
-    }
-    m_EntityIDMapper[entity] = realEntity;
-    //LOG_DEBUG("Created entity #%i (%i) with parent %i (%i)", entity, realEntity, parent, realParent);
-}
-
-void EntityFileParser::onStartComponent(EntityID entity, const std::string& component)
-{
-    EntityID realEntity = m_EntityIDMapper.at(entity);
-    m_World->AttachComponent(realEntity, component);
-    //LOG_DEBUG("Attached component of type \"%s\" to entity #%i (%i)", component.c_str(), entity, realEntity);
-}
-
-void EntityFileParser::onStartComponentField(EntityID entity, const std::string& componentType, const std::string& fieldName, const std::map<std::string, std::string>& attributes)
-{
-    EntityID realEntity = m_EntityIDMapper.at(entity);
-    ComponentWrapper component = m_World->GetComponent(realEntity, componentType);
-    auto fieldIt = component.Info.Fields.find(fieldName);
-    if (fieldIt == component.Info.Fields.end()) {
-        LOG_ERROR("Tried to set unknown field \"%s\" of component type \"%s\"! Ignoring.", fieldName.c_str(), componentType.c_str());
-        return;
-    }
-    auto& field = fieldIt->second;
-
-    //LOG_DEBUG("Field \"%s\" type \"%s\"", fieldName.c_str(), field.Type.c_str());
-    //LOG_DEBUG("Attributes:");
-    //for (auto& kv : attributes) {
-    //    LOG_DEBUG("\t%s = %s", kv.first.c_str(), kv.second.c_str());
-    //}
-
-    char* data = component.Data + field.Offset;
-    EntityFile::WriteAttributeData(data, field, attributes);
-}
-
-void EntityFileParser::onFieldData(EntityID entity, const std::string& componentType, const std::string& fieldName, const char* fieldData)
-{
-    EntityID realEntity = m_EntityIDMapper.at(entity);
-    ComponentWrapper component = m_World->GetComponent(realEntity, componentType);
-    auto fieldIt = component.Info.Fields.find(fieldName);
-    if (fieldIt == component.Info.Fields.end()) {
-        return;
-    }
-    auto& field = fieldIt->second;
-
-    char* data = component.Data + field.Offset;
-    EntityFile::WriteValueData(data, field, fieldData);
-}

src/Engine/Core/EntityXMLFile.cpp

@@ -0,0 +1,291 @@
+#include "Core/EntityXMLFile.h"
+
+EntityXMLFile::EntityXMLFile(boost::filesystem::path path)
+    : m_FilePath(path)
+{
+    using namespace xercesc;
+    XMLPlatformUtils::Initialize();
+    m_GrammarPool = new XMLGrammarPoolImpl();
+    m_SAX2XMLReader = XMLReaderFactory::createXMLReader(XMLPlatformUtils::fgMemoryManager, m_GrammarPool);
+}
+
+EntityXMLFile::~EntityXMLFile()
+{
+    delete m_SAX2XMLReader;
+    delete m_GrammarPool;
+    xercesc::XMLPlatformUtils::Terminate();
+}
+
+void EntityXMLFile::Parse(const EntityFileHandler* handler) const
+{
+    using namespace xercesc;
+
+    EntityFileSAXHandler saxHandler(handler, m_SAX2XMLReader);
+    setReaderFeatures(m_SAX2XMLReader);
+    m_SAX2XMLReader->setContentHandler(&saxHandler);
+    m_SAX2XMLReader->setErrorHandler(&saxHandler);
+    m_SAX2XMLReader->setDeclarationHandler(&saxHandler);
+    m_SAX2XMLReader->parse(m_FilePath.string().c_str());
+}
+
+void EntityXMLFile::setReaderFeatures(xercesc::SAX2XMLReader* reader)
+{
+    using namespace xercesc;
+    reader->setFeature(XMLUni::fgXercesCacheGrammarFromParse, true);
+    reader->setFeature(XMLUni::fgXercesUseCachedGrammarInParse, true);
+    reader->setFeature(XMLUni::fgSAX2CoreValidation, true);
+    reader->setFeature(XMLUni::fgSAX2CoreNameSpaces, true);
+    reader->setFeature(XMLUni::fgXercesSchema, true);
+    reader->setFeature(XMLUni::fgXercesSchemaFullChecking, true);
+    reader->setFeature(XMLUni::fgXercesCalculateSrcOfs, true);
+    reader->setFeature(XMLUni::fgXercesIdentityConstraintChecking, true);
+}
+
+unsigned int EntityXMLFile::GetTypeStride(std::string typeName)
+{
+    std::map<std::string, unsigned int> typeStrides{
+        { "bool", sizeof(bool) },
+        { "int", sizeof(int) },
+        { "float", sizeof(float) },
+        { "double", sizeof(double) },
+        { "string", sizeof(std::string) },
+        { "enum", sizeof(ComponentInfo::EnumType) },
+        { "Vector", sizeof(glm::vec3) },
+        { "Quaternion", sizeof(glm::quat) },
+        { "Color", sizeof(glm::vec4) }
+    };
+
+    auto it = typeStrides.find(typeName);
+    return (it != typeStrides.end()) ? it->second : 0;
+}
+
+void EntityXMLFile::WriteAttributeData(char* outData, const ComponentInfo::Field_t& field, const std::map<std::string, std::string>& attributes)
+{
+    if (field.Type == "Vector") {
+        glm::vec3 vec;
+        vec.x = boost::lexical_cast<float>(attributes.at("X"));
+        vec.y = boost::lexical_cast<float>(attributes.at("Y"));
+        vec.z = boost::lexical_cast<float>(attributes.at("Z"));
+        memcpy(outData, reinterpret_cast<char*>(&vec), field.Stride);
+    } else if (field.Type == "Color") {
+        glm::vec4 vec;
+        vec.r = boost::lexical_cast<float>(attributes.at("R"));
+        vec.g = boost::lexical_cast<float>(attributes.at("G"));
+        vec.b = boost::lexical_cast<float>(attributes.at("B"));
+        vec.a = boost::lexical_cast<float>(attributes.at("A"));
+        memcpy(outData, reinterpret_cast<char*>(&vec), field.Stride);
+    } else if (field.Type == "Quaternion") {
+        glm::quat q;
+        q.x = boost::lexical_cast<float>(attributes.at("X"));
+        q.y = boost::lexical_cast<float>(attributes.at("Y"));
+        q.z = boost::lexical_cast<float>(attributes.at("Z"));
+        q.w = boost::lexical_cast<float>(attributes.at("W"));
+        memcpy(outData, reinterpret_cast<char*>(&q), field.Stride);
+    } else if (!attributes.empty()) {
+        LOG_WARNING("%i attributes not handled by any type conversion!", attributes.size());
+    }
+}
+
+void EntityXMLFile::WriteValueData(char* outData, const ComponentInfo::Field_t& field, const char* valueData)
+{
+    // Catch and ignore casting errors so whitespace around string enums won't mess anything up
+    try {
+        if (field.Type == "int") {
+            int value = boost::lexical_cast<int>(valueData);
+            memcpy(outData, reinterpret_cast<char*>(&value), field.Stride);
+        } else if (field.Type == "enum") {
+            ComponentInfo::EnumType value = boost::lexical_cast<ComponentInfo::EnumType>(valueData);
+            memcpy(outData, reinterpret_cast<char*>(&value), field.Stride);
+        } else if (field.Type == "float") {
+            float value = boost::lexical_cast<float>(valueData);
+            memcpy(outData, reinterpret_cast<char*>(&value), field.Stride);
+        } else if (field.Type == "double") {
+            double value = boost::lexical_cast<double>(valueData);
+            memcpy(outData, reinterpret_cast<char*>(&value), field.Stride);
+        } else if (field.Type == "bool") {
+            bool value = (valueData[0] == 't'); // Lazy bool evaluation
+            memcpy(outData, reinterpret_cast<char*>(&value), field.Stride);
+        } else if (field.Type == "string") {
+            new (outData) std::string(valueData);
+        } else {
+            LOG_WARNING("Unknown value data type: %s", field.Type.c_str());
+        }
+    } catch (const boost::bad_lexical_cast&) { }
+}
+
+EntityFileSAXHandler::EntityFileSAXHandler(const EntityFileHandler* handler, xercesc::SAX2XMLReader* reader) 
+    : m_Handler(handler)
+    , m_Reader(reader)
+{
+    // 0 is imaginary base parent
+    m_EntityStack.push(0);
+    m_StateStack.push(State::Unknown);
+}
+
+void EntityFileSAXHandler::startElement(const XMLCh* const _uri, const XMLCh* const _localName, const XMLCh* const _qname, const xercesc::Attributes& attrs)
+{
+    std::string name = XS::ToString(_localName);
+
+    if (m_StateStack.top() == State::Unknown || m_StateStack.top() == State::Entity) {
+        if (name == "Entity") {
+            m_StateStack.push(State::Entity);
+            onStartEntity(attrs);
+            return;
+        }
+        if (name == "EntityRef") {
+            onStartEntityRef(attrs);
+            return;
+        }
+    }
+
+    std::string uri = XS::ToString(_uri);
+    if (m_StateStack.top() == State::Entity) {
+        if (uri == "components") {
+            m_StateStack.push(State::Component);
+            onStartComponent(name);
+            return;
+        }
+    }
+
+    if (m_StateStack.top() == State::Component) {
+        m_StateStack.push(State::ComponentField);
+        onStartComponentField(name, attrs);
+        return;
+    }
+}
+
+void EntityFileSAXHandler::endElement(const XMLCh* const _uri, const XMLCh* const _localName, const XMLCh* const _qname)
+{
+    std::string name = XS::ToString(_localName);
+    if (m_StateStack.top() == State::Entity) {
+        if (name == "Entity") {
+            m_StateStack.pop();
+            onEndEntity();
+            return;
+        }
+    }
+
+    std::string uri = XS::ToString(_uri);
+    if (m_StateStack.top() == State::Component) {
+        //if (uri == "components") {
+        m_StateStack.pop();
+        onEndComponent(name);
+        return;
+        //}
+    }
+
+    if (m_StateStack.top() == State::ComponentField && name == m_CurrentField) {
+        m_StateStack.pop();
+        onEndComponentField(name);
+        return;
+    }
+}
+
+void EntityFileSAXHandler::characters(const XMLCh* const chars, const XMLSize_t length)
+{
+    if (m_StateStack.top() == State::ComponentField) {
+        char* transcoded = xercesc::XMLString::transcode(chars);
+        onFieldData(transcoded);
+    }
+}
+
+void EntityFileSAXHandler::fatalError(const xercesc::SAXParseException& e)
+{
+    std::string message = XS::ToString(e.getMessage());
+    std::string systemId = XS::ToString(e.getSystemId());
+    XMLFileLoc line = e.getLineNumber();
+    XMLFileLoc column = e.getColumnNumber();
+    LOG_ERROR("SAXParseException\n\tLocation: %s:%i:%i\n\tFatal Error: %s", systemId.c_str(), line, column, message.c_str());
+}
+
+void EntityFileSAXHandler::error(const xercesc::SAXParseException& e)
+{
+    std::string message = XS::ToString(e.getMessage());
+    std::string systemId = XS::ToString(e.getSystemId());
+    XMLFileLoc line = e.getLineNumber();
+    XMLFileLoc column = e.getColumnNumber();
+    LOG_ERROR("SAXParseException\n\tLocation: %s:%i:%i\n\tError: %s", systemId.c_str(), line, column, message.c_str());
+}
+
+void EntityFileSAXHandler::warning(const xercesc::SAXParseException& e)
+{
+    std::string message = XS::ToString(e.getMessage());
+    std::string systemId = XS::ToString(e.getSystemId());
+    XMLFileLoc line = e.getLineNumber();
+    XMLFileLoc column = e.getColumnNumber();
+    LOG_ERROR("SAXParseException\n\tLocation: %s:%i:%i\n\tWarning: %s", systemId.c_str(), line, column, message.c_str());
+}
+
+void EntityFileSAXHandler::onStartEntity(const xercesc::Attributes& attrs)
+{
+    EntityID parent = m_EntityStack.top();
+
+    if (m_Handler->m_OnStartEntityCallback) {
+        std::string name;
+        auto xName = attrs.getValue(XS::ToXMLCh("name"));
+        if (xName != nullptr) {
+            name = XS::ToString(xName);
+        }
+        m_Handler->m_OnStartEntityCallback(m_NextEntityID, parent, name);
+    }
+
+    m_EntityStack.push(m_NextEntityID);
+    m_NextEntityID++;
+}
+
+void EntityFileSAXHandler::onEndEntity()
+{
+    m_EntityStack.pop();
+}
+
+void EntityFileSAXHandler::onStartEntityRef(const xercesc::Attributes& attrs)
+{
+    std::string path = XS::ToString(attrs.getValue(XS::ToXMLCh("file")));
+
+    xercesc::SAX2XMLReader* reader = xercesc::XMLReaderFactory::createXMLReader();
+    EntityXMLFile::setReaderFeatures(reader);
+    reader->setContentHandler(this);
+    reader->setErrorHandler(this);
+    reader->parse(path.c_str());
+    delete reader;
+}
+
+void EntityFileSAXHandler::onStartComponentField(const std::string& field, const xercesc::Attributes& attrs)
+{
+    //LOG_DEBUG("        Field: %s", field.c_str());
+    m_CurrentField = field;
+    m_CurrentAttributes.clear();
+    for (int i = 0; i < attrs.getLength(); i++) {
+        auto name = attrs.getQName(i);
+        auto value = attrs.getValue(name);
+        //LOG_DEBUG("            %s = %s", (char*)XS::ToString(name), (char*)XS::ToString(value));
+        m_CurrentAttributes[XS::ToString(name).operator std::string()] = XS::ToString(value).operator std::string();
+    }
+
+    if (m_Handler->m_OnStartFieldCallback) {
+        m_Handler->m_OnStartFieldCallback(m_EntityStack.top(), m_CurrentComponent, field, m_CurrentAttributes);
+    }
+}
+
+void EntityFileSAXHandler::onEndComponent(const std::string& name) { }
+
+void EntityFileSAXHandler::onStartComponent(const std::string& name)
+{
+    //LOG_DEBUG("    Component: %s", name.c_str());
+    m_CurrentComponent = name;
+    if (m_Handler->m_OnStartComponentCallback) {
+        m_Handler->m_OnStartComponentCallback(m_EntityStack.top(), name);
+    }
+}
+
+void EntityFileSAXHandler::onEndComponentField(const std::string& field) { }
+
+void EntityFileSAXHandler::onFieldData(char* data)
+{
+    //LOG_DEBUG("            Data: %s", data);
+    if (m_Handler->m_OnStartFieldDataCallback) {
+        m_Handler->m_OnStartFieldDataCallback(m_EntityStack.top(), m_CurrentComponent, m_CurrentField, data);
+    }
+
+    xercesc::XMLString::release(&data);
+}

src/Engine/Core/EntityXMLFileParser.cpp

@@ -0,0 +1,84 @@
+#include "Core/EntityXMLFileParser.h"
+
+EntityXMLFileParser::EntityXMLFileParser(const EntityXMLFile* entityFile)
+    : m_EntityFile(entityFile)
+{
+    m_Handler.SetStartEntityCallback(std::bind(&EntityXMLFileParser::onStartEntity, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3));
+    m_Handler.SetStartComponentCallback(std::bind(&EntityXMLFileParser::onStartComponent, this, std::placeholders::_1, std::placeholders::_2));
+    m_Handler.SetStartFieldCallback(std::bind(&EntityXMLFileParser::onStartComponentField, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
+    m_Handler.SetStartFieldDataCallback(std::bind(&EntityXMLFileParser::onFieldData, this, std::placeholders::_1, std::placeholders::_2, std::placeholders::_3, std::placeholders::_4));
+}
+
+EntityID EntityXMLFileParser::MergeEntities(World* world, EntityID baseParent /*= EntityID_Invalid */)
+{
+    m_World = world;
+    m_EntityIDMapper[0] = baseParent;
+    m_EntityFile->Parse(&m_Handler);
+    return m_FirstEntity;
+}
+
+void EntityXMLFileParser::onStartEntity(EntityID entity, EntityID parent, const std::string& name)
+{
+    EntityID realParent = m_EntityIDMapper.at(parent);
+    EntityID realEntity = m_World->CreateEntity(realParent);
+    if (m_FirstEntity == EntityID_Invalid) {
+        m_FirstEntity = realEntity;
+    }
+    if (!name.empty()) {
+        m_World->SetName(realEntity, name);
+    }
+    m_EntityIDMapper[entity] = realEntity;
+    //LOG_DEBUG("Created entity #%i (%i) with parent %i (%i)", entity, realEntity, parent, realParent);
+}
+
+void EntityXMLFileParser::onStartComponent(EntityID entity, const std::string& component)
+{
+    if (m_World->GetComponentPools().count(component) != 0) {
+        EntityID realEntity = m_EntityIDMapper.at(entity);
+        m_World->AttachComponent(realEntity, component);
+    } else {
+        LOG_ERROR("Tried to attach unregistered component \"%s\"! to entity #%i. Ignoring.", component.c_str(), entity);
+    }
+    //LOG_DEBUG("Attached component of type \"%s\" to entity #%i (%i)", component.c_str(), entity, realEntity);
+}
+
+void EntityXMLFileParser::onStartComponentField(EntityID entity, const std::string& componentType, const std::string& fieldName, const std::map<std::string, std::string>& attributes)
+{
+    if (m_World->GetComponentPools().count(componentType) == 0) {
+        return;
+    }
+    EntityID realEntity = m_EntityIDMapper.at(entity);
+    ComponentWrapper component = m_World->GetComponent(realEntity, componentType);
+    auto fieldIt = component.Info.Fields.find(fieldName);
+    if (fieldIt == component.Info.Fields.end()) {
+        LOG_ERROR("Tried to set unknown field \"%s\" of component type \"%s\"! Ignoring.", fieldName.c_str(), componentType.c_str());
+        return;
+    }
+    auto& field = fieldIt->second;
+
+    //LOG_DEBUG("Field \"%s\" type \"%s\"", fieldName.c_str(), field.Type.c_str());
+    //LOG_DEBUG("Attributes:");
+    //for (auto& kv : attributes) {
+    //    LOG_DEBUG("\t%s = %s", kv.first.c_str(), kv.second.c_str());
+    //}
+
+    char* data = component.Data + field.Offset;
+    EntityXMLFile::WriteAttributeData(data, field, attributes);
+}
+
+void EntityXMLFileParser::onFieldData(EntityID entity, const std::string& componentType, const std::string& fieldName, const char* fieldData)
+{
+    if (m_World->GetComponentPools().count(componentType) == 0) {
+        return;
+    }
+    EntityID realEntity = m_EntityIDMapper.at(entity);
+    ComponentWrapper component = m_World->GetComponent(realEntity, componentType);
+    auto fieldIt = component.Info.Fields.find(fieldName);
+    if (fieldIt == component.Info.Fields.end()) {
+        return;
+    }
+    auto& field = fieldIt->second;
+
+    char* data = component.Data + field.Offset;
+    EntityXMLFile::WriteValueData(data, field, fieldData);
+}

src/Engine/Core/EntityXMLFilePreprocessor.cpp

@@ -1,10 +1,10 @@
-#include "Core/EntityFilePreprocessor.h"
+#include "Core/EntityXMLFilePreprocessor.h"
 
-EntityFilePreprocessor::EntityFilePreprocessor(const EntityFile* entityFile) 
+EntityXMLFilePreprocessor::EntityXMLFilePreprocessor(const EntityXMLFile* entityFile) 
     : m_EntityFile(entityFile)
 {
     EntityFileHandler handler;
-    handler.SetStartComponentCallback(std::bind(&EntityFilePreprocessor::onStartComponent, this, std::placeholders::_1, std::placeholders::_2));
+    handler.SetStartComponentCallback(std::bind(&EntityXMLFilePreprocessor::onStartComponent, this, std::placeholders::_1, std::placeholders::_2));
     m_EntityFile->Parse(&handler);
 
     //LOG_DEBUG("___ COMPONENT DEFINITIONS ___");
@@ -28,20 +28,20 @@ EntityFilePreprocessor::EntityFilePreprocessor(const EntityFile* entityFile)
     parseDefaults();
 }
 
-void EntityFilePreprocessor::RegisterComponents(World* world)
+void EntityXMLFilePreprocessor::RegisterComponents(World* world)
 {
     for (auto& kv : m_ComponentInfo) {
         world->RegisterComponent(kv.second);
     }
 }
 
-void EntityFilePreprocessor::onStartComponent(EntityID entity, std::string type)
+void EntityXMLFilePreprocessor::onStartComponent(EntityID entity, std::string type)
 {
     //LOG_DEBUG("Component: %s", type.c_str());
     m_ComponentCounts[type]++;
 }
 
-void EntityFilePreprocessor::parseComponentInfo()
+void EntityXMLFilePreprocessor::parseComponentInfo()
 {
     using namespace xercesc;
     EntityFileXMLErrorHandler errorHandler;
@@ -141,9 +141,9 @@ void EntityFilePreprocessor::parseComponentInfo()
             std::string baseType = XS::ToString(elementDeclaration->getTypeDefinition()->getBaseType()->getName());
 
             std::string effectiveType = type;
-            unsigned int stride = EntityFile::GetTypeStride(type);
+            unsigned int stride = EntityXMLFile::GetTypeStride(type);
             if (stride == 0) {
-                stride = EntityFile::GetTypeStride(baseType);
+                stride = EntityXMLFile::GetTypeStride(baseType);
                 if (stride == 0) {
                     LOG_WARNING("Field \"%s\" in component \"%s\" uses unexpected field type \"%s\" with base type \"%s\". Skipping.", name.c_str(), compInfo.Name.c_str(), type.c_str(), baseType.c_str());
                     continue;
@@ -196,7 +196,7 @@ void EntityFilePreprocessor::parseComponentInfo()
     }
 }
 
-void EntityFilePreprocessor::parseDefaults()
+void EntityXMLFilePreprocessor::parseDefaults()
 {
     using namespace xercesc;
 
@@ -261,7 +261,7 @@ void EntityFilePreprocessor::parseDefaults()
                     auto attribItem = attributeMap->item(i);
                     attributes[XS::ToString(attribItem->getNodeName())] = XS::ToString(attribItem->getNodeValue());
                 }
-                EntityFile::WriteAttributeData(data, field, attributes);
+                EntityXMLFile::WriteAttributeData(data, field, attributes);
             }
 
             auto childNode = fieldElement->getFirstChild();
@@ -278,14 +278,14 @@ void EntityFilePreprocessor::parseDefaults()
             // Handle potential field values
             if (childNode->getNodeType() == DOMNode::TEXT_NODE) {
                 char* cstrValue = XMLString::transcode(childNode->getNodeValue());
-                EntityFile::WriteValueData(data, field, cstrValue);
+                EntityXMLFile::WriteValueData(data, field, cstrValue);
                 XMLString::release(&cstrValue);
             }
         }
     }
 }
 
-std::string EntityFilePreprocessor::parseAnnotationXML(const XMLCh* xml)
+std::string EntityXMLFilePreprocessor::parseAnnotationXML(const XMLCh* xml)
 {
     using namespace xercesc;
 

src/Engine/Core/EntityXMLFileWriter.cpp

@@ -1,13 +1,13 @@
-#include "Core/EntityFileWriter.h"
+#include "Core/EntityXMLFileWriter.h"
 
 #define X(str) XS::ToXMLCh(str)
 
-void EntityFileWriter::WriteWorld(World* world)
+void EntityXMLFileWriter::WriteWorld(World* world)
 {
     WriteEntity(world, 0);
 }
 
-void EntityFileWriter::WriteEntity(World* world, EntityID entity)
+void EntityXMLFileWriter::WriteEntity(World* world, EntityID entity)
 {
     using namespace xercesc;
     DOMDocument* doc = m_DOMImplementation->createDocument(nullptr, X("Entity"), nullptr);
@@ -41,7 +41,7 @@ void EntityFileWriter::WriteEntity(World* world, EntityID entity)
     doc->release();
 }
 
-void EntityFileWriter::appendEntityChildren(xercesc::DOMElement* parentElement, const World* world, EntityID entity)
+void EntityXMLFileWriter::appendEntityChildren(xercesc::DOMElement* parentElement, const World* world, EntityID entity)
 {
     using namespace xercesc;
     DOMDocument* doc = parentElement->getOwnerDocument();
@@ -67,7 +67,7 @@ void EntityFileWriter::appendEntityChildren(xercesc::DOMElement* parentElement,
     }
 }
 
-void EntityFileWriter::appentEntityComponents(xercesc::DOMElement* parentElement, const World* world, EntityID entity)
+void EntityXMLFileWriter::appentEntityComponents(xercesc::DOMElement* parentElement, const World* world, EntityID entity)
 {
     using namespace xercesc;
     DOMDocument* doc = parentElement->getOwnerDocument();

src/Engine/Core/World.cpp

@@ -1,6 +1,7 @@
 #include "Core/World.h"
 #include "Core/EEntityDeleted.h"
 #include "Core/EComponentDeleted.h"
+#include "Core/EntityWrapper.h"
 
 World::~World()
 {
@@ -44,7 +45,7 @@ bool World::ValidEntity(EntityID entity) const
     return m_EntityParents.find(entity) != m_EntityParents.end();
 }
 
-void World::RegisterComponent(ComponentInfo& ci)
+void World::RegisterComponent(const ComponentInfo& ci)
 {
     if (m_ComponentPools.find(ci.Name) == m_ComponentPools.end()) {
         m_ComponentPools[ci.Name] = new ComponentPool(ci);
@@ -151,6 +152,62 @@ std::string World::GetName(EntityID entity) const
     }
 }
 
+EntityWrapper World::GetFirstEntityByName(const std::string& name)
+{
+    auto itPair = GetDirectChildren(EntityID_Invalid);
+    for (auto it = itPair.first; it != itPair.second; it++) {
+        EntityID childEntityID = it->second;
+        EntityWrapper childEntity(this, childEntityID);
+        if (!childEntity.Valid()) {
+            continue;
+        }
+        EntityWrapper entityWithName = childEntity.Name() == name ? childEntity : childEntity.FirstChildByName(name);
+        if (entityWithName.Valid()) {
+            return entityWithName;
+        }
+    }
+    return EntityWrapper::Invalid;
+}
+
+std::unordered_map<EntityID, EntityID> World::Merge(const World* other)
+{
+    std::unordered_map<EntityID, EntityID> oldToNew;
+
+    // Create new entities
+    for (auto& kv : other->m_EntityParents) {
+        EntityID entity = kv.first;
+
+        EntityID newEntity = CreateEntity();
+        SetName(newEntity, other->GetName(entity));
+        oldToNew[entity] = newEntity;
+    }
+    // Fix relationships
+    for (auto& kv : other->m_EntityParents) {
+        EntityID entity = kv.first;
+        EntityID parent = kv.second;
+        if (parent != EntityID_Invalid) {
+            SetParent(oldToNew.at(entity), oldToNew.at(parent));
+        }
+    }
+
+    // Transfer components
+    for (auto& kv : other->m_ComponentPools) {
+        auto& componentType = kv.first;
+        ComponentPool* pool = kv.second;
+        // Register pool if it's not present in world
+        if (m_ComponentPools.count(componentType) == 0) {
+            RegisterComponent(pool->ComponentInfo());
+        }
+        // Copy components
+        for (auto component : *pool) {
+            ComponentWrapper newComponent = AttachComponent(oldToNew.at(component.EntityID), componentType);
+            component.Copy(newComponent);
+        }
+    }
+
+    return oldToNew;
+}
+
 EntityID World::generateEntityID()
 {
     // TODO: Make EntityID generation smarter

src/Engine/Editor/EditorGUI.cpp

@@ -338,15 +338,6 @@ bool EditorGUI::drawComponentNode(EntityWrapper entity, const ComponentInfo& ci)
         }
     }
 
-    if (ci.Name == "Spawner") {
-        if (ImGui::Button("Activate")) {
-            Events::SpawnerSpawn e;
-            e.Spawner = entity;
-            e.Parent = entity;
-            m_EventBroker->Publish(e);
-        }
-    }
-
     return true;
 }
 
@@ -390,52 +381,14 @@ bool EditorGUI::drawComponentField_Vector(ComponentWrapper &c, const ComponentIn
         // Limit scale values to a minimum of 0
         return ImGui::DragFloat3("", glm::value_ptr(val), 0.1f, 0.f, std::numeric_limits<float>::max());
     } else if (field.Name == "Orientation") {
-        //glm::vec3 tempVal = val;
-        glm::vec3 originalVal = val;
-
-        ImVec2 cursorPos = ImGui::GetCursorScreenPos();
-        glm::tvec3<bool> isSnapping(false, false, false);
-        bool changed = ImGui::DragFloat3("", glm::value_ptr(val), 0.066666f);
-        if (changed) {
-            // Make orentations have a period of 2*Pi
-            val = glm::fmod(val, glm::vec3(glm::two_pi<float>()));
-            for (int i = 0; i < 3; i++) {
-                if (val[i] < 0) {
-                    val[i] += glm::two_pi<float>();
-                }
-            }
+        // Make orentations have a period of 2*Pi
+        glm::vec3 tempVal = glm::fmod(val, glm::vec3(glm::two_pi<float>()));
+        if (ImGui::SliderFloat3("", glm::value_ptr(tempVal), 0.f, glm::two_pi<float>())) {
+            val = tempVal;
+            return true;
+        } else {
+            return false;
         }
-
-        // Snap to angle
-        //float snapRange = glm::pi<float>() / 15.f;
-        //float snapAngle = glm::quarter_pi<float>();
-        //glm::vec3 snap = glm::fmod(val, glm::vec3(snapAngle));
-        //for (int i = 0; i < 3; i++) {
-        //    isSnapping[i] = glm::abs(snap[i] - (snapRange / 2.f)) < snapRange;
-        //}
-        //if (changed && ImGui::IsMouseDown(0)) {
-        //    glm::vec3 change = val - originalVal;
-        //    for (int i = 0; i < 3; i++) {
-        //        if (isSnapping[i] && glm::abs(change[i]) < snapRange) {
-        //            val[i] -= snap[i] - snapRange;
-        //        }
-        //    }
-        //}
-
-        // Draw snapping outline
-        float width = ImGui::CalcItemWidth() / 3.f;;
-        float spacing = GImGui->Style.ItemInnerSpacing.x;
-        for (int i = 0; i < 3; i++) {
-            if (isSnapping[i]) {
-                ImVec2 pos = cursorPos + ImVec2(i * (width + spacing), 0.f);
-                ImRect bb(pos - ImVec2(1, 1), pos + ImVec2(width, 17));
-                auto window = ImGui::GetCurrentWindow();
-                const ImU32 col = window->Color(ImGuiCol_HeaderActive);
-                window->DrawList->AddRect(bb.Min, bb.Max, col, 3.f);
-            }
-        }
-
-        return changed;
     } else {
         return ImGui::DragFloat3("", glm::value_ptr(val), 0.1f, std::numeric_limits<float>::lowest(), std::numeric_limits<float>::max());
     }

src/Engine/Editor/EditorRenderSystem.cpp

@@ -54,7 +54,7 @@ void EditorRenderSystem::Update(double dt)
             EntityWrapper entity(m_World, cModel.EntityID);
             glm::mat4 modelMatrix = Transform::ModelMatrix(entity.ID, entity.World);
             for (auto matGroup : model->MaterialGroups()) {
-                std::shared_ptr<ModelJob> modelJob = std::make_shared<ModelJob>(model, scene.Camera, modelMatrix, matGroup, cModel, entity.World, glm::vec4(0), 0.f);
+                std::shared_ptr<ModelJob> modelJob = std::make_shared<ModelJob>(model, scene.Camera, modelMatrix, matGroup, cModel, entity.World, glm::vec4(0), 0.f, false);
                 if (cModel["Transparent"]) {
                     scene.Jobs.TransparentObjects.push_back(modelJob);
                 } else {

src/Engine/Editor/EditorSystem.cpp

@@ -2,6 +2,7 @@
 #include "Core/UniformScaleSystem.h"
 #include "Editor/EditorRenderSystem.h"
 #include "Editor/EditorWidgetSystem.h"
+#include "Core/EntityFile.h"
 
 EditorSystem::EditorSystem(SystemParams params, IRenderer* renderer, RenderFrame* renderFrame) 
     : System(params)
@@ -129,7 +130,7 @@ void EditorSystem::OnEntitySelected(EntityWrapper entity)
 
 void EditorSystem::OnEntitySave(EntityWrapper entity, boost::filesystem::path filePath)
 {
-    EntityFileWriter writer(filePath);
+    EntityXMLFileWriter writer(filePath);
     writer.WriteEntity(entity.World, entity.ID);
 }
 
@@ -260,12 +261,11 @@ EntityWrapper EditorSystem::importEntity(EntityWrapper parent, boost::filesystem
 
     try {
         auto entityFile = ResourceManager::Load<EntityFile>(filePath.string());
-        EntityFilePreprocessor fpp(entityFile);
-        fpp.RegisterComponents(parent.World);
-        EntityFileParser fp(entityFile);
-        EntityID newEntity = fp.MergeEntities(parent.World, parent.ID);
-        return EntityWrapper(parent.World, newEntity);
-    } catch (const std::exception&) {
+        EntityWrapper newEntity = entityFile->MergeInto(parent.World);
+        parent.World->SetParent(newEntity.ID, parent.ID);
+        return newEntity;
+    } catch (const std::exception& e) {
+        LOG_ERROR("Failed to import entity \"%s\": \"%s\"", filePath.string().c_str(), e.what());
         return EntityWrapper::Invalid;
     }
 }

src/Engine/Network/Client.cpp

@@ -33,6 +33,7 @@ void Client::Connect(std::string address, int port)
     EVENT_SUBSCRIBE_MEMBER(m_EPlayerDamage, &Client::OnPlayerDamage);
     EVENT_SUBSCRIBE_MEMBER(m_EPlayerSpawned, &Client::OnPlayerSpawned);
     EVENT_SUBSCRIBE_MEMBER(m_EDoubleJump, &Client::OnDoubleJump);
+    EVENT_SUBSCRIBE_MEMBER(m_EDashAbility, &Client::OnDashAbility);
     EVENT_SUBSCRIBE_MEMBER(m_ESearchForServers, &Client::OnSearchForServers);
     auto config = ResourceManager::Load<ConfigFile>("Config.ini");
     m_Address = address;
@@ -101,8 +102,7 @@ void Client::Update()
 
 void Client::parseMessageType(Packet& packet)
 {
-    // Pop packetSize which is used by TCP Client to
-    // create a packet of the correct size
+    // Pop packetSize
     packet.ReadPrimitive<int>();
     int messageType = packet.ReadPrimitive<int>();
     if (messageType == -1)
@@ -144,6 +144,12 @@ void Client::parseMessageType(Packet& packet)
     case MessageType::OnDoubleJump:
         parseDoubleJump(packet);
         break;
+    case MessageType::OnDashEffect:
+        parseDashEffect(packet);
+        break;
+    case MessageType::AmmoPickup:
+        parseAmmoPickup(packet);
+        break;
     default:
         break;
     }
@@ -233,7 +239,6 @@ void Client::parseSpawnEvents()
         m_EventBroker->Publish(e);
     }
     m_PlayerSpawnEvents = tempSpawn;
-    // m_PlayerSpawnEvents.clear();
 }
 
 void Client::parsePlayersSpawned(Packet& packet)
@@ -261,7 +266,7 @@ void Client::parseEntityDeletion(Packet & packet)
     if (m_ServerIDToClientID.find(entityToDelete) != m_ServerIDToClientID.end()) {
         EntityID localEntity = m_ServerIDToClientID.at(entityToDelete);
         if (m_World->ValidEntity(localEntity)) {
-            if (m_World->HasComponent(localEntity,"Player")) {
+            if (m_World->HasComponent(localEntity, "Player")) {
                 Events::PlayerDeath e;
                 e.Player = EntityWrapper(m_World, localEntity);
                 m_EventBroker->Publish(e);
@@ -296,6 +301,28 @@ void Client::parseDoubleJump(Packet & packet)
     }
 }
 
+
+void Client::parseDashEffect(Packet& packet)
+{
+    EntityID serverID = packet.ReadPrimitive<EntityID>();
+    if (!serverClientMapsHasEntity(serverID)) {
+        return;
+    }
+    Events::DashAbility e;
+    e.Player = m_ServerIDToClientID.at(serverID);
+    if (e.Player != m_LocalPlayer.ID) {
+        m_EventBroker->Publish(e);
+    }
+}
+
+void Client::parseAmmoPickup(Packet & packet)
+{
+    Events::AmmoPickup e;
+    e.AmmoGain = packet.ReadPrimitive<int>();
+    e.Player = m_LocalPlayer;
+    m_EventBroker->Publish(e);
+}
+
 void Client::updateFields(Packet& packet, const ComponentInfo& componentInfo, const EntityID& entityID)
 {
     for (auto field : componentInfo.FieldsInOrder) {
@@ -379,7 +406,7 @@ void Client::parseSnapshot(Packet& packet)
                     if (m_SnapshotFilter != nullptr) {
                         shouldApply = m_SnapshotFilter->FilterComponent(localEntity, newComponent);
                     }
-                    if (shouldApply) {                        
+                    if (shouldApply) {
                         ComponentWrapper currentComponent = m_World->GetComponent(localEntityID, componentType);
                         memcpy(currentComponent.Data, newComponent.Data, componentInfo.Stride);
                     }
@@ -509,6 +536,18 @@ bool Client::OnPlayerSpawned(const Events::PlayerSpawned& e)
     return true;
 }
 
+
+bool Client::OnDashAbility(const Events::DashAbility& e)
+{
+    if (!clientServerMapsHasEntity(e.Player) || e.Player != m_LocalPlayer.ID) {
+        return false;
+    }
+    Packet packet(MessageType::OnDashEffect);
+    packet.WritePrimitive(m_ClientIDToServerID.at(e.Player));
+    m_Reliable.Send(packet);
+    return true;
+}
+
 bool Client::OnSearchForServers(const Events::SearchForServers& e)
 {
     m_SearchingForServers = true;

src/Engine/Network/Server.cpp

@@ -13,7 +13,7 @@ Server::Server(World* world, EventBroker* eventBroker, int port)
     EVENT_SUBSCRIBE_MEMBER(m_EEntityDeleted, &Server::OnEntityDeleted);
     EVENT_SUBSCRIBE_MEMBER(m_EComponentDeleted, &Server::OnComponentDeleted);
     EVENT_SUBSCRIBE_MEMBER(m_EPlayerDamage, &Server::OnPlayerDamage);
-
+    EVENT_SUBSCRIBE_MEMBER(m_EAmmoPickup, &Server::OnAmmoPickup);
     // BindWW
     if (port == 0) {
         port = config->Get<float>("Networking.Port", 27666);
@@ -141,6 +141,9 @@ void Server::parseMessageType(Packet& packet)
     case MessageType::OnDoubleJump:
         parseDoubleJump(packet);
         break;
+    case MessageType::OnDashEffect:
+        parseDashEffect(packet);
+        break;
     default:
         break;
     }
@@ -510,6 +513,19 @@ bool Server::OnPlayerDamage(const Events::PlayerDamage& e)
     return true;
 }
 
+bool Server::OnAmmoPickup(const Events::AmmoPickup & e)
+{
+    for (auto& kv : m_ConnectedPlayers) {
+        if (e.Player.ID == kv.second.EntityID) {
+            Packet packet(MessageType::AmmoPickup);
+            // We dont send playerID as it will be set at client to local 
+            packet.WritePrimitive(e.AmmoGain);
+            m_Reliable.Send(packet, kv.second);
+        }
+    }
+    return true;
+}
+
 void Server::parseClientPing()
 {
     LOG_INFO("%i: Parsing ping", m_PacketID);
@@ -542,6 +558,11 @@ bool Server::parseDoubleJump(Packet & packet)
     return true;
 }
 
+void Server::parseDashEffect(Packet& packet)
+{
+    reliableBroadcast(packet);
+}
+
 void Server::parseOnInputCommand(Packet& packet)
 {
     PlayerID player = -1;
@@ -604,12 +625,14 @@ bool Server::shouldSendToClient(EntityWrapper childEntity)
     auto children = m_World->GetDirectChildren(childEntity.ID);
     for (auto it = children.first; it != children.second; it++) {
         EntityWrapper child(m_World, it->second);
-        if(child.HasComponent("CapturePoint")) {
+        if (child.HasComponent("CapturePoint") || child.HasComponent("HealthPickup")
+            || child.HasComponent("AmmoPickup")) {
             return true;
         }
     }
     return childEntity.HasComponent("Player") || childEntity.FirstParentWithComponent("Player").Valid()
-        || childEntity.HasComponent("CapturePoint");
+        || childEntity.HasComponent("CapturePoint") || childEntity.HasComponent("HealthPickup")
+        || childEntity.HasComponent("AmmoPickup");
 }
 
 PlayerID Server::GetPlayerIDFromEndpoint()