Merge remote-tracking branch 'origin/master' into HEAD

Conflicts:
	src/Engine/Rendering/CubeMapPass.cpp
	src/Engine/Rendering/DrawFinalPass.cpp

src/Engine/Collision/CollisionSystem.cpp

@@ -12,55 +12,56 @@ void CollisionSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& c
     if (!boundingBox) {
         return;
     }
+
     ComponentWrapper& cTransform = entity["Transform"];
     EntityAABB& boxA = *boundingBox;
     bool everHitTheGround = false;
 
-    glm::vec3 size = boxA.Size();
-    float diameter = std::min(size.x, size.z);
-    glm::vec3 prevOrigin = (glm::vec3)cPhysics["PrevOrigin"];
-    glm::vec3 toCurrentPos = boxA.Origin() - prevOrigin;
-    float rayLength = glm::length(toCurrentPos) + 0.5f*diameter;
-    //If the entity has moved farther than the size of its box, we need to handle it specially.
-    bool traceCollision = rayLength > diameter;
-    //hack solution: If prevOrigin is less than -9000 in all dimensions, 
-    //then it means it is not set, i.e. this is the first collision check for the entity.
-    if (traceCollision && glm::any(glm::greaterThan((glm::vec3)cPhysics["PrevOrigin"], glm::vec3(-9000.f)))) {
-        Ray ray(prevOrigin, toCurrentPos);
-        m_OctreeResult.clear();
-        m_Octree->ObjectsPossiblyHitByRay(ray, m_OctreeResult);
-        for (auto& boxB : m_OctreeResult) {
-            if (boxA.Entity == boxB.Entity) {
-                continue;
-            }
-            bool hit;
-            float dist;
-            if (boxB.Entity.HasComponent("Model")) {
-                RawModel* model;
-                std::string res = (std::string)boxB.Entity["Model"]["Resource"];
-                try {
-                    model = ResourceManager::Load<RawModel, true>(res);
-                } catch (const std::exception&) {
+    auto prevPosIt = m_PrevPositions.find(entity);
+    if (prevPosIt != m_PrevPositions.end()) {
+        glm::vec3 size = boxA.Size();
+        float diameter = std::min(size.x, size.z);
+        glm::vec3 prevOrigin = prevPosIt->second;
+        glm::vec3 toCurrentPos = boxA.Origin() - prevOrigin;
+        float rayLength = glm::length(toCurrentPos) + 0.5f*diameter;
+        //If the entity has moved farther than the size of its box, we need to handle it specially.
+        if (rayLength > diameter) {
+            Ray ray(prevOrigin, toCurrentPos);
+            m_OctreeResult.clear();
+            m_Octree->ObjectsPossiblyHitByRay(ray, m_OctreeResult);
+            for (auto& boxB : m_OctreeResult) {
+                if (boxA.Entity == boxB.Entity) {
                     continue;
                 }
-                float u, v;
-                hit = Collision::RayVsModel(ray, model->Vertices(), model->m_Indices, Transform::ModelMatrix(boxB.Entity), dist, u, v);
-            } else {
-                hit = Collision::RayVsAABB(ray, boxB, dist);
-            }
-            if (hit && dist < rayLength) {
-                //Set the entity to where it was colliding, minus the maximum box size. 
-                //TODO: Perhaps this should be done slightly more properly.
-                glm::vec3 newOriginPos = ray.Origin() + (dist - 0.707107f*diameter) * ray.Direction();
-                glm::vec3 resolve = newOriginPos - boxA.Origin();
-                (glm::vec3&)cTransform["Position"] += resolve;
-                boxA = *Collision::EntityAbsoluteAABB(entity);
-                if (resolve.y > 0) {
-                    everHitTheGround = true;
-                    (bool)cPhysics["IsOnGround"] = true;
-                    ((glm::vec3&)cPhysics["Velocity"]).y = 0.f;
+                bool hit;
+                float dist;
+                if (boxB.Entity.HasComponent("Model")) {
+                    RawModel* model;
+                    std::string res = (std::string)boxB.Entity["Model"]["Resource"];
+                    try {
+                        model = ResourceManager::Load<RawModel, true>(res);
+                    } catch (const std::exception&) {
+                        continue;
+                    }
+                    float u, v;
+                    hit = Collision::RayVsModel(ray, model->Vertices(), model->m_Indices, Transform::ModelMatrix(boxB.Entity), dist, u, v);
+                } else {
+                    hit = Collision::RayVsAABB(ray, boxB, dist);
+                }
+                if (hit && dist < rayLength) {
+                    //Set the entity to where it was colliding, minus the maximum box size. 
+                    //TODO: Perhaps this should be done slightly more properly.
+                    glm::vec3 newOriginPos = ray.Origin() + (dist - 0.707107f*diameter) * ray.Direction();
+                    glm::vec3 resolve = newOriginPos - boxA.Origin();
+                    (glm::vec3&)cTransform["Position"] += resolve;
+                    boxA = *Collision::EntityAbsoluteAABB(entity);
+                    if (resolve.y > 0) {
+                        everHitTheGround = true;
+                        (bool)cPhysics["IsOnGround"] = true;
+                        ((glm::vec3&)cPhysics["Velocity"]).y = 0.f;
+                    }
+                    break;
                 }
-                break;
             }
         }
     }
@@ -86,10 +87,13 @@ void CollisionSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& c
             glm::mat4 modelMatrix = Transform::ModelMatrix(boxB.Entity);
 
             glm::vec3 inOutVelocity = (glm::vec3)cPhysics["Velocity"];
+            bool notMovingxz = glm::all(glm::lessThan(glm::abs(glm::vec2(inOutVelocity.x, inOutVelocity.z)), glm::vec2(0.01f))) && prevPosIt != m_PrevPositions.end();
             bool isOnGround = (bool)cPhysics["IsOnGround"];
             float verticalStepHeight = (float)(double)cPhysics["VerticalStepHeight"];
             if (Collision::AABBvsTriangles(boxA, model->Vertices(), model->m_Indices, modelMatrix, inOutVelocity, verticalStepHeight, isOnGround, resolutionVector)) {
-                (glm::vec3&)cTransform["Position"] += resolutionVector;
+                //Move the position to previous position if it is not moving in the xz-plane, else resolve with the resolution vector.
+                (glm::vec3&)cTransform["Position"] += notMovingxz ? prevPosIt->second - boxA.Origin() : resolutionVector;
+                boxA = *Collision::EntityAbsoluteAABB(entity);
                 cPhysics["Velocity"] = inOutVelocity;
                 if (isOnGround) {
                     everHitTheGround = true;
@@ -99,6 +103,7 @@ void CollisionSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& c
         } else if (Collision::AABBVsAABB(boxA, boxB, resolutionVector)) {
             //Enter here if boxB has no Model.
             (glm::vec3&)cTransform["Position"] += resolutionVector;
+            boxA = *Collision::EntityAbsoluteAABB(entity);
             if (resolutionVector.y > 0) {
                 everHitTheGround = true;
                 (bool)cPhysics["IsOnGround"] = true;
@@ -112,5 +117,5 @@ void CollisionSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& c
         (bool)cPhysics["IsOnGround"] = false;
     }
 
-    (glm::vec3&)cPhysics["PrevOrigin"] = boxA.Origin();
+    m_PrevPositions[entity] = boxA.Origin();
 }

src/Engine/Core/EntityWrapper.cpp

@@ -51,6 +51,40 @@ EntityWrapper EntityWrapper::FirstParentWithComponent(const std::string& compone
     return EntityWrapper::Invalid;
 }
 
+EntityWrapper EntityWrapper::Clone(EntityWrapper parent /*= Invalid*/)
+{
+    if (!Valid()) {
+        return EntityWrapper::Invalid;
+    }
+
+    EntityWrapper clone = cloneRecursive(*this, EntityWrapper::Invalid);
+    this->World->SetParent(clone.ID, parent.ID);
+    return clone;
+}
+
+std::vector<EntityWrapper> EntityWrapper::ChildrenWithComponent(const std::string& componentType)
+{
+    std::vector<EntityWrapper> childrenWithComponent;
+    childrenWithComponentRecursive(componentType, *this, childrenWithComponent);
+    return childrenWithComponent;
+}
+
+void EntityWrapper::DeleteChildren()
+{
+    auto itPair = this->World->GetDirectChildren(this->ID);
+    if (itPair.first == itPair.second) {
+        return;
+    }
+
+    std::vector<EntityID> entitiesToDelete;
+    for (auto it = itPair.first; it != itPair.second; it++) {
+        entitiesToDelete.push_back(it->second);
+    }
+    for (auto& e : entitiesToDelete) {
+        this->World->DeleteEntity(e);
+    }
+}
+
 bool EntityWrapper::IsChildOf(EntityWrapper potentialParent)
 {
     EntityWrapper entity = *this;
@@ -90,6 +124,11 @@ ComponentWrapper EntityWrapper::operator[](const char* componentName)
     }
 }
 
+ComponentWrapper EntityWrapper::operator[](const std::string& componentName)
+{
+    return this->operator[](componentName.c_str());
+}
+
 bool EntityWrapper::operator==(const EntityWrapper& e) const
 {
     return (this->ID == e.ID) && (this->World == e.World);
@@ -111,7 +150,7 @@ EntityWrapper EntityWrapper::firstChildByNameRecursive(const std::string& name,
         return EntityWrapper::Invalid;
     }
 
-    auto itPair = this->World->GetChildren(parent);
+    auto itPair = this->World->GetDirectChildren(parent);
     if (itPair.first == itPair.second) {
         return EntityWrapper::Invalid;
     }
@@ -131,3 +170,42 @@ EntityWrapper EntityWrapper::firstChildByNameRecursive(const std::string& name,
     return EntityWrapper::Invalid;
 }
 
+EntityWrapper EntityWrapper::cloneRecursive(EntityWrapper entity, EntityWrapper parent)
+{
+    EntityWrapper clone = EntityWrapper(entity.World, entity.World->CreateEntity(parent.ID));
+    entity.World->SetName(clone.ID, entity.Name());
+
+    // Clone components
+    for (auto& kv : entity.World->GetComponentPools()) {
+        if (kv.second->KnowsEntity(entity.ID)) {
+            ComponentWrapper c1 = kv.second->GetByEntity(entity.ID);
+            ComponentWrapper c2 = entity.World->AttachComponent(clone.ID, kv.first);
+            c1.Copy(c2);
+        }
+    }
+
+    // Clone children
+    auto children = entity.World->GetDirectChildren(entity.ID);
+    for (auto it = children.first; it != children.second; ++it) {
+        EntityWrapper child(entity.World, it->second);
+        cloneRecursive(child, clone);
+    }
+      
+    return clone;
+}
+
+void EntityWrapper::childrenWithComponentRecursive(const std::string& componentType, EntityWrapper& entity, std::vector<EntityWrapper>& childrenWithComponent)
+{
+    auto itPair = this->World->GetDirectChildren(entity.ID);
+    if (itPair.first == itPair.second) {
+        return;
+    }
+
+    for (auto it = itPair.first; it != itPair.second; ++it) {
+        EntityWrapper child = EntityWrapper(entity.World, it->second);
+        if (child.HasComponent(componentType)) {
+            childrenWithComponent.push_back(child);
+        }
+        childrenWithComponentRecursive(componentType, child, childrenWithComponent);
+    }
+}

src/Engine/Core/Util/Logging.cpp

@@ -33,8 +33,8 @@ void _LOG(_LOG_LEVEL logLevel, const char* file, const char* func, unsigned int
 	va_end(args);
 
 	if (logLevel == LOG_LEVEL_ERROR) {
-		std::cerr << file << ":" << line << " " << func << std::endl;
-		std::cerr << _LOG_LEVEL_PREFIX[logLevel] << message << std::endl;
+		//std::cerr << file << ":" << line << " " << func << std::endl;
+		//std::cerr << _LOG_LEVEL_PREFIX[logLevel] << message << std::endl;
 	} else {
 		std::cout << _LOG_LEVEL_PREFIX[logLevel] << message << std::endl;
 	}

src/Engine/Core/World.cpp

@@ -127,7 +127,7 @@ void World::SetParent(EntityID entity, EntityID parent)
     m_EntityChildren.insert(std::make_pair(parent, entity));
 }
 
-const std::pair<std::unordered_multimap<EntityID, EntityID>::const_iterator, std::unordered_multimap<EntityID, EntityID>::const_iterator> World::GetChildren(EntityID entity)
+const std::pair<std::unordered_multimap<EntityID, EntityID>::const_iterator, std::unordered_multimap<EntityID, EntityID>::const_iterator> World::GetDirectChildren(EntityID entity)
 {
     return m_EntityChildren.equal_range(entity);
 }

src/Engine/Editor/EditorGUI.cpp

@@ -598,6 +598,19 @@ bool EditorGUI::OnKeyDown(const Events::KeyDown& e)
         entityImport(m_World);
     }
 
+    if (e.ModCtrl && e.KeyCode == GLFW_KEY_C) {
+        m_CopyTarget = m_CurrentSelection;
+    }
+
+    if (e.ModCtrl && e.KeyCode == GLFW_KEY_V) {
+        if (m_OnEntityPaste != nullptr) {
+            EntityWrapper copy = m_OnEntityPaste(m_CopyTarget, m_CurrentSelection);
+            if (copy != EntityWrapper::Invalid) {
+                SelectEntity(copy);
+            }
+        }
+    }
+
     if (e.KeyCode == GLFW_KEY_DELETE) {
         if (m_CurrentSelection.Valid()) {
             entityDelete(m_CurrentSelection);

src/Engine/Editor/EditorSystem.cpp

@@ -28,6 +28,7 @@ EditorSystem::EditorSystem(SystemParams params, IRenderer* renderer, RenderFrame
     m_EditorGUI->SetEntityDeleteCallback(std::bind(&EditorSystem::OnEntityDelete, this, std::placeholders::_1));
     m_EditorGUI->SetEntityChangeParentCallback(std::bind(&EditorSystem::OnEntityChangeParent, this, std::placeholders::_1, std::placeholders::_2));
     m_EditorGUI->SetEntityChangeNameCallback(std::bind(&EditorSystem::OnEntityChangeName, this, std::placeholders::_1, std::placeholders::_2));
+    m_EditorGUI->SetEntityPasteCallback(std::bind(&EditorSystem::OnEntityPaste, this, std::placeholders::_1, std::placeholders::_2));
     m_EditorGUI->SetComponentAttachCallback(std::bind(&EditorSystem::OnComponentAttach, this, std::placeholders::_1, std::placeholders::_2));
     m_EditorGUI->SetComponentDeleteCallback(std::bind(&EditorSystem::OnComponentDelete, this, std::placeholders::_1, std::placeholders::_2));
     m_EditorGUI->SetWidgetModeCallback(std::bind(&EditorSystem::setWidgetMode, this, std::placeholders::_1));
@@ -160,6 +161,11 @@ void EditorSystem::OnEntityChangeName(EntityWrapper entity, const std::string& n
     }
 }
 
+EntityWrapper EditorSystem::OnEntityPaste(EntityWrapper entityToCopy, EntityWrapper parent)
+{
+    return entityToCopy.Clone(parent);
+}
+
 void EditorSystem::OnComponentAttach(EntityWrapper entity, const std::string& componentType)
 {
     if (entity.Valid()) {

src/Engine/Network/Client.cpp

@@ -261,8 +261,14 @@ void Client::parseEntityDeletion(Packet & packet)
     if (m_ServerIDToClientID.find(entityToDelete) != m_ServerIDToClientID.end()) {
         EntityID localEntity = m_ServerIDToClientID.at(entityToDelete);
         if (m_World->ValidEntity(localEntity)) {
-            m_World->DeleteEntity(localEntity);
-            deleteFromServerClientMaps(entityToDelete, localEntity);
+            if (m_World->HasComponent(localEntity,"Player")) {
+                Events::PlayerDeath e;
+                e.Player = EntityWrapper(m_World, localEntity);
+                m_EventBroker->Publish(e);
+            } else {
+                m_World->DeleteEntity(localEntity);
+                deleteFromServerClientMaps(entityToDelete, localEntity);
+            }
         }
     }
 }

src/Engine/Network/Server.cpp

@@ -186,7 +186,7 @@ void Server::addInputCommandsToPacket(Packet& packet)
 
 void Server::addPlayersToPacket(Packet & packet, EntityID entityID)
 {
-    auto itPair = m_World->GetChildren(entityID);
+    auto itPair = m_World->GetDirectChildren(entityID);
     std::unordered_map<std::string, ComponentPool*> worldComponentPools = m_World->GetComponentPools();
     // Loop through every child
     for (auto it = itPair.first; it != itPair.second; it++) {
@@ -234,7 +234,7 @@ void Server::addPlayersToPacket(Packet & packet, EntityID entityID)
 
 void Server::addChildrenToPacket(Packet & packet, EntityID entityID)
 {
-    auto itPair = m_World->GetChildren(entityID);
+    auto itPair = m_World->GetDirectChildren(entityID);
     std::unordered_map<std::string, ComponentPool*> worldComponentPools = m_World->GetComponentPools();
     // Loop through every child
     for (auto it = itPair.first; it != itPair.second; it++) {
@@ -601,7 +601,7 @@ void Server::parsePlayerTransform(Packet& packet)
 
 bool Server::shouldSendToClient(EntityWrapper childEntity)
 {
-    auto children = m_World->GetChildren(childEntity.ID);
+    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")) {

src/Engine/Rendering/CubeMapPass.cpp

@@ -17,7 +17,7 @@ void CubeMapPass::LoadTextures(std::string input)
             m_CubeMapTextures.push_back(img);
         }
         GenerateCubeMapTexture();
-		m_PreviusCubeMapTexture = input;
+        m_PreviusCubeMapTexture = input;
     }
 }
 

src/Engine/Rendering/DrawFinalPass.cpp

@@ -187,10 +187,11 @@ void DrawFinalPass::Draw(RenderScene& scene)
     state->StencilMask(0x00);
     DrawModelRenderQueues(scene.Jobs.OpaqueObjects, scene);
     GLERROR("OpaqueObjects");
-    state->BlendFunc(GL_ONE, GL_ONE);
-    DrawModelRenderQueues(scene.Jobs.TransparentObjects, scene);
-    GLERROR("TransparentObjects");
+    //state->BlendFunc(GL_ONE, GL_ONE);
     state->BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+
+    GLERROR("TransparentObjects");
+    //state->BlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
     DrawSprites(scene.Jobs.SpriteJob, scene);
     GLERROR("SpriteJobs");
 

src/Game/Game.cpp

@@ -16,7 +16,7 @@
 #include "Game/Systems/PickupSpawnSystem.h"
 #include "Game/Systems/AmmoPickupSystem.h"
 #include "Game/Systems/DamageIndicatorSystem.h"
-#include "Game/Systems/Weapon/WeaponSystem.h"
+#include "Game/Systems/Weapon/DefenderWeaponBehaviour.h"
 #include "Rendering/AnimationSystem.h"
 #include "Game/Systems/HealthHUDSystem.h"
 #include "Rendering/BoneAttachmentSystem.h"
@@ -48,7 +48,6 @@ Game::Game(int argc, char* argv[])
     ResourceManager::UseThreading = m_Config->Get<bool>("Multithreading.ResourceLoading", true);
     DisableMemoryPool::Value = m_Config->Get<bool>("Debug.DisableMemoryPool", false);
     LOG_LEVEL = static_cast<_LOG_LEVEL>(m_Config->Get<int>("Debug.LogLevel", 1));
-    PlayerSpawnSystem::SetRespawnTime(m_Config->Get<float>("Debug.RespawnTime", 15.0f));
 
     // Create the core event broker
     m_EventBroker = new EventBroker();
@@ -98,6 +97,10 @@ Game::Game(int argc, char* argv[])
             m_NetworkClient->Connect(m_NetworkAddress, m_NetworkPort);
             m_Renderer->SetWindowTitle(m_Renderer->WindowTitle() + " CLIENT");
         }
+    } else {
+        // If network is disabled, pretend we're a server
+        m_IsClient = true;
+        m_IsServer = true;
     }
 
     // Create Octrees
@@ -120,7 +123,7 @@ Game::Game(int argc, char* argv[])
     m_SystemPipeline->AddSystem<PlayerMovementSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<SpawnerSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<PlayerSpawnSystem>(updateOrderLevel);
-    m_SystemPipeline->AddSystem<WeaponSystem>(updateOrderLevel, m_Renderer, m_OctreeCollision);
+    m_SystemPipeline->AddSystem<DefenderWeaponBehaviour>(updateOrderLevel, m_Renderer, m_OctreeCollision);
     m_SystemPipeline->AddSystem<LifetimeSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<CapturePointSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<CapturePointHUDSystem>(updateOrderLevel);
@@ -135,7 +138,6 @@ Game::Game(int argc, char* argv[])
     ++updateOrderLevel;
     m_SystemPipeline->AddSystem<FillOctreeSystem>(updateOrderLevel, m_OctreeCollision, "Collidable");
     m_SystemPipeline->AddSystem<FillOctreeSystem>(updateOrderLevel, m_OctreeTrigger, "Player");
-    m_SystemPipeline->AddSystem<FillFrustumOctreeSystem>(updateOrderLevel, m_OctreeFrustrumCulling);
     m_SystemPipeline->AddSystem<AnimationSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<UniformScaleSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<HealthHUDSystem>(updateOrderLevel);
@@ -145,6 +147,9 @@ Game::Game(int argc, char* argv[])
     m_SystemPipeline->AddSystem<BoneAttachmentSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<CollisionSystem>(updateOrderLevel, m_OctreeCollision);
     m_SystemPipeline->AddSystem<TriggerSystem>(updateOrderLevel, m_OctreeTrigger);
+    // Octree for frustum culling must be updated after collisions, otherwise players frustum may be moved after tree is filled, and wrong things are culled.
+    ++updateOrderLevel;
+    m_SystemPipeline->AddSystem<FillFrustumOctreeSystem>(updateOrderLevel, m_OctreeFrustrumCulling);
     ++updateOrderLevel;
     m_SystemPipeline->AddSystem<RenderSystem>(updateOrderLevel, m_Renderer, m_RenderFrame, m_OctreeFrustrumCulling);
     ++updateOrderLevel;

src/Game/Network/MultiplayerSnapshotFilter.cpp

@@ -13,6 +13,7 @@ bool MultiplayerSnapshotFilter::FilterComponent(EntityWrapper entity, SharedComp
             component.Info.Name == "Transform"
             || component.Info.Name == "Physics"
             || component.Info.Name == "AssaultWeapon"
+            || component.Info.Name == "DefenderWeapon"
             || component.Info.Name == "Animation"
             || component.Info.Name == "AnimationOffset"
             || entity.Name() == "PlayerName"

src/Game/Systems/DamageIndicatorSystem.cpp

@@ -13,7 +13,7 @@ DamageIndicatorSystem::DamageIndicatorSystem(SystemParams params)
 }
 
 void DamageIndicatorSystem::Update(double dt) {
-    if (!IsServer) {
+    if (!IsServer && LocalPlayer.Valid()) {
         for (auto& iter = updateDamageIndicatorVector.begin(); iter != updateDamageIndicatorVector.end(); iter++) {
             if (!iter->spriteEntity.Valid()) {
                 updateDamageIndicatorVector.erase(iter);

src/Game/Systems/PlayerMovementSystem.cpp

@@ -116,12 +116,18 @@ void PlayerMovementSystem::updateMovementControllers(double dt)
                 ImGui::Text("velocity: (%f, %f, %f) |%f|", velocity.x, velocity.y, velocity.z, glm::length(velocity));
             }
 
-            //you cant jump and dash at the same time - since there is no friction in the air and we would thus dash much further in the air
-            if (!controller->PlayerIsDashing() && controller->Jumping() && !controller->Crouching() && (isOnGround || !controller->DoubleJumping())) {
-                (bool)cPhysics["IsOnGround"] = false;
+            if (isOnGround) {
+                controller->SetDoubleJumping(false);
+            }
+            //If player presses Jump and is not crouching.
+            if (controller->Jumping() && !controller->Crouching()) {
                 if (isOnGround) {
-                    controller->SetDoubleJumping(false);
-                } else {
+                    (bool)cPhysics["IsOnGround"] = false;
+                    velocity.y = player["Player"]["JumpSpeed"];
+                } else if (player.HasComponent("DoubleJump") && !controller->DoubleJumping()) {
+                    //Enter here if player can double jump and is doing so.
+                    (bool)cPhysics["IsOnGround"] = false;
+                    velocity.y = player["DoubleJump"]["DoubleJumpSpeed"];
                     // If IsServer and network is off this will not work
                     if (IsClient) {
                         //put a hexagon at the players feet
@@ -133,7 +139,6 @@ void PlayerMovementSystem::updateMovementControllers(double dt)
                         m_EventBroker->Publish(e);
                     }
                 }
-                velocity.y = 4.f;
             }
 
             if (player.HasComponent("AABB")) {

src/Game/Systems/PlayerSpawnSystem.cpp

@@ -1,29 +1,40 @@
 #include "Systems/PlayerSpawnSystem.h"
 
-//This should be set by the config anyway.
-float PlayerSpawnSystem::m_RespawnTime = 15.0f;
-
 PlayerSpawnSystem::PlayerSpawnSystem(SystemParams params)
     : System(params)
-    , m_Timer(0.f)
+    , m_DbgConfigForceRespawn(false)
 {
     EVENT_SUBSCRIBE_MEMBER(m_OnInputCommand, &PlayerSpawnSystem::OnInputCommand);
     EVENT_SUBSCRIBE_MEMBER(m_OnPlayerSpawnerd, &PlayerSpawnSystem::OnPlayerSpawned);
     EVENT_SUBSCRIBE_MEMBER(m_OnPlayerDeath, &PlayerSpawnSystem::OnPlayerDeath);
-    m_NetworkEnabled = ResourceManager::Load<ConfigFile>("Config.ini")->Get("Networking.StartNetwork", false);
+    ConfigFile* config = ResourceManager::Load<ConfigFile>("Config.ini");
+    m_NetworkEnabled = config->Get("Networking.StartNetwork", false);
+    m_ForcedRespawnTime = config->Get("Debug.RespawnTime", -1.0f);
+    m_DbgConfigForceRespawn = m_ForcedRespawnTime > 0;
 }
 
 void PlayerSpawnSystem::Update(double dt)
 {
-    //Increase timer.
-    m_Timer += dt;
-    if (m_Timer < m_RespawnTime) {
-        return;
+    // If there are no CapturePointGameMode components we will just spawn immediately.
+    // Should be able to support older maps with this.
+    // TODO: In the future we might want to return instead, to avoid spawning in the menu for instance.
+    auto pool = m_World->GetComponents("CapturePointGameMode");
+    if (pool != nullptr && pool->size() > 0)
+    {
+        // Take the first CapturePointGameMode component found.
+        ComponentWrapper& modeComponent = *pool->begin();
+        // Increase timer.
+        double& timer = (double&)modeComponent["RespawnTime"];
+        timer += dt;
+        double maxRespawnTime = m_DbgConfigForceRespawn ? m_ForcedRespawnTime : (double)modeComponent["MaxRespawnTime"];
+        if (timer < maxRespawnTime) {
+            return;
+        }
+        // If respawn time has passed, we spawn all players that have requested to be spawned.
+        timer = 0;
     }
-    //If respawn time has passed, we spawn all players that have requested to be spawned.
-    m_Timer = 0.f;
 
-    //If there are no spawn requests, return immediately, if we are client the SpawnRequests should always be empty.
+    // If there are no spawn requests, return immediately, if we are client the SpawnRequests should always be empty.
     if (m_SpawnRequests.size() == 0) {
         return;
     }

src/Game/Systems/SpawnerSystem.cpp

@@ -36,7 +36,7 @@ EntityWrapper SpawnerSystem::Spawn(EntityWrapper spawner, EntityWrapper parent /
     }
 
     // Find any SpawnPoints existing as children of spawner
-    auto children = spawner.World->GetChildren(spawner.ID);
+    auto children = spawner.World->GetDirectChildren(spawner.ID);
     std::vector<EntityWrapper> spawnPoints;
     for (auto kv = children.first; kv != children.second; ++kv) {
         const EntityID& child = kv->second;

src/Game/Systems/Weapon/AssaultWeaponBehaviour.cpp_

@@ -1,13 +1,5 @@
 #include "Systems/Weapon/AssaultWeaponBehaviour.h"
 
-AssaultWeaponBehaviour::AssaultWeaponBehaviour(SystemParams systemParams, IRenderer* renderer, Octree<EntityAABB>* collisionOctree, EntityWrapper player) 
-    : WeaponBehaviour(systemParams, renderer, collisionOctree, player)
-{
-    m_FirstPersonModel = m_Player.FirstChildByName("Hands");
-    m_ThirdPersonModel = m_Player.FirstChildByName("PlayerModel");
-    EVENT_SUBSCRIBE_MEMBER(m_EAnimationComplete, &AssaultWeaponBehaviour::OnAnimationComplete);
-}
-
 void AssaultWeaponBehaviour::Fire()
 {
     m_TimeSinceLastFire = 0.0;
@@ -36,7 +28,7 @@ void AssaultWeaponBehaviour::Reload()
         return;
     }
 
-    // Don't reload if we're completly out of ammo
+    // Don't reload if we're completely out of ammo
     if (ammo == 0) {
         playEmptySound();
         m_TimeSinceLastFire = -0.0f; // HACK: To make empty sound play with interval
@@ -56,14 +48,14 @@ void AssaultWeaponBehaviour::Update(double dt)
 {
     if (m_Reloading) {
         m_ReloadTimer -= dt;
-        // Re-enable glow on reload impersonator half-way through the animation
+        // Re-enable glow on reload impostor half-way through the animation
         if (IsClient) {
             if (m_ReloadTimer <= (double)m_Player["AssaultWeapon"]["ReloadTime"] / 2.0) {
-                if (m_FirstPersonReloadImpersonator.Valid()) {
-                    m_FirstPersonReloadImpersonator["Model"]["GlowMap"] = true;
+                if (m_FirstPersonReloadImpostor.Valid()) {
+                    m_FirstPersonReloadImpostor["Model"]["GlowMap"] = true;
                 }
-                if (m_ThirdPersonReloadImpersonator.Valid()) {
-                    m_ThirdPersonReloadImpersonator["Model"]["GlowMap"] = true;
+                if (m_ThirdPersonReloadImpostor.Valid()) {
+                    m_ThirdPersonReloadImpostor["Model"]["GlowMap"] = true;
                 }
             }
         }
@@ -96,21 +88,6 @@ void AssaultWeaponBehaviour::Update(double dt)
     }
 }
 
-bool AssaultWeaponBehaviour::OnAnimationComplete(Events::AnimationComplete& e)
-{
-    if (e.Entity != m_FirstPersonModel) {
-        return false;
-    }
-
-    //if (e.Name == "ShootRifle") {
-    //    if (!m_Firing) {
-    //        playIdleAnimation();
-    //    }
-    //}
-
-    return true;
-}
-
 bool AssaultWeaponBehaviour::hasAmmo()
 {
     ComponentWrapper& cAssaultWeapon = m_Player["AssaultWeapon"];
@@ -177,7 +154,6 @@ void AssaultWeaponBehaviour::spawnTracer()
 
 float AssaultWeaponBehaviour::traceRayDistance(glm::vec3 origin, glm::vec3 direction)
 {
-    // TODO: Cast a ray and size tracer appropriately
     float distance;
     glm::vec3 pos;
     auto entity = Collision::EntityFirstHitByRay(Ray(origin, direction), m_CollisionOctree, distance, pos);
@@ -215,6 +191,12 @@ void AssaultWeaponBehaviour::playEmptySound()
 
 void AssaultWeaponBehaviour::viewPunch()
 {
+    // Since we send absolute client orientations to server, running this server side would
+    // cause aim desync.
+    if (!IsClient) {
+        return;
+    }
+
     EntityWrapper playerCamera = m_Player.FirstChildByName("Camera");
     if (!playerCamera.Valid()) {
         return;
@@ -323,8 +305,8 @@ void AssaultWeaponBehaviour::playReloadAnimation()
         EntityWrapper firstPersonWeaponModel = m_Player.FirstChildByName("WeaponModel");
         EntityWrapper reloadSpawner = m_Player.FirstChildByName("FirstPersonReloadSpawner");
         if (IsClient) {
-            m_FirstPersonReloadImpersonator = SpawnerSystem::Spawn(reloadSpawner, reloadSpawner);
-            firstPersonWeaponModel["Model"].Copy(m_FirstPersonReloadImpersonator["Model"]);
+            m_FirstPersonReloadImpostor = SpawnerSystem::Spawn(reloadSpawner, reloadSpawner);
+            firstPersonWeaponModel["Model"].Copy(m_FirstPersonReloadImpostor["Model"]);
         }
         firstPersonWeaponModel["Model"]["Visible"] = false;
     }
@@ -332,8 +314,8 @@ void AssaultWeaponBehaviour::playReloadAnimation()
         EntityWrapper thirdPersonWeaponModel = m_Player.FirstChildByName("ThirdPersonWeaponModel");
         EntityWrapper reloadSpawner = m_Player.FirstChildByName("ThirdPersonReloadSpawner");
         if (IsClient) {
-            m_ThirdPersonReloadImpersonator = SpawnerSystem::Spawn(reloadSpawner, reloadSpawner);
-            thirdPersonWeaponModel["Model"].Copy(m_ThirdPersonReloadImpersonator["Model"]);
+            m_ThirdPersonReloadImpostor = SpawnerSystem::Spawn(reloadSpawner, reloadSpawner);
+            thirdPersonWeaponModel["Model"].Copy(m_ThirdPersonReloadImpostor["Model"]);
         }
         thirdPersonWeaponModel["Model"]["Visible"] = false;
     }
@@ -371,7 +353,7 @@ bool AssaultWeaponBehaviour::shoot(double damage)
         return false;
     }
 
-    // Don't let us shoot ourselves in the foot
+    // Don't let us shoot ourselves in the foot somehow
     if (victim == LocalPlayer) {
         return false;
     }

src/Game/Systems/Weapon/DefenderWeaponBehaviour.cpp

@@ -0,0 +1,188 @@
+#include "Systems/Weapon/DefenderWeaponBehaviour.h"
+
+void DefenderWeaponBehaviour::UpdateComponent(EntityWrapper& entity, ComponentWrapper& cWeapon, double dt)
+{
+    (double&)cWeapon["TimeSinceLastFire"] += dt;
+    WeaponBehaviour::UpdateComponent(entity, cWeapon, dt);
+}
+
+void DefenderWeaponBehaviour::UpdateWeapon(WeaponInfo& wi, double dt)
+{
+    ComponentWrapper cWeapon = wi.GetComponent();
+
+    bool isFiring = cWeapon["IsFiring"];
+    bool cooldownPassed = (double)cWeapon["TimeSinceLastFire"] >= (60.0 / (double)cWeapon["RPM"]);
+    bool isNotShielding = wi.Player.ChildrenWithComponent("Shield").size() == 0;
+    if (isFiring && cooldownPassed && isNotShielding) {
+        fireShell(wi);
+    }
+}
+
+void DefenderWeaponBehaviour::OnPrimaryFire(WeaponInfo& wi)
+{
+    ComponentWrapper cWeapon = wi.GetComponent();
+    cWeapon["IsFiring"] = true;
+    bool cooldownPassed = (double)cWeapon["TimeSinceLastFire"] >= (60.0 / (double)cWeapon["RPM"]);
+    bool isNotShielding = wi.Player.ChildrenWithComponent("Shield").size() == 0;
+    if (cooldownPassed && isNotShielding) {
+        fireShell(wi);
+    }
+}
+
+void DefenderWeaponBehaviour::OnCeasePrimaryFire(WeaponInfo& wi)
+{
+    ComponentWrapper cWeapon = wi.GetComponent();
+    cWeapon["IsFiring"] = false;
+}
+
+bool DefenderWeaponBehaviour::OnInputCommand(WeaponInfo& wi, const Events::InputCommand& e)
+{
+    if (e.Command == "SpecialAbility" && IsServer) {
+        EntityWrapper attachment = wi.Player.FirstChildByName("ShieldAttachment");
+        if (attachment.Valid()) {
+            if (e.Value > 0) {
+                SpawnerSystem::Spawn(attachment, attachment);
+            } else {
+                attachment.DeleteChildren();
+            }
+        }
+    }
+
+    return false;
+}
+
+bool DefenderWeaponBehaviour::OnSetCamera(const Events::SetCamera& e)
+{
+    m_CurrentCamera = e.CameraEntity;
+    return true;
+}
+
+void DefenderWeaponBehaviour::fireShell(WeaponInfo& wi)
+{
+    ComponentWrapper cWeapon = wi.GetComponent();
+
+    cWeapon["TimeSinceLastFire"] = 0.0;
+    int numPellets = cWeapon["NumPellets"];
+    float spreadAngle = cWeapon["SpreadAngle"];
+    std::uniform_real_distribution<float> randomSpreadAngle(-spreadAngle, spreadAngle);
+
+    // Calculate pellet angles
+    // HACK: Random for now?
+    // TODO: Make distribution even for each quadrant
+    std::vector<glm::vec2> pelletAngles;
+    for (int i = 0; i < numPellets; i++) {
+        pelletAngles.push_back(glm::vec2(randomSpreadAngle(m_RandomEngine), randomSpreadAngle(m_RandomEngine)));
+        LOG_DEBUG("%f %f", pelletAngles[i].x, pelletAngles[i].y);
+    }
+
+    double pelletDamage = (double)cWeapon["BaseDamage"] / numPellets;
+
+    // Tracers
+    EntityWrapper weaponModelEntity;
+    if (wi.Player == LocalPlayer) {
+        weaponModelEntity = wi.FirstPersonEntity;
+    } else {
+        weaponModelEntity = wi.ThirdPersonEntity;
+    }
+    if (weaponModelEntity.Valid()) {
+        EntityWrapper spawner = weaponModelEntity.FirstChildByName("WeaponMuzzle");
+        for (auto& angles : pelletAngles) {
+            glm::vec3 direction = Transform::AbsoluteOrientation(spawner) * glm::quat(glm::vec3(angles, 0.f)) * glm::vec3(0, 0, -1);
+            float distance = traceRayDistance(Transform::AbsolutePosition(spawner), direction);
+            EntityWrapper ray = SpawnerSystem::Spawn(spawner);
+            ((glm::vec3&)ray["Transform"]["Scale"]).z = (distance / 100.f);
+            glm::vec3& orientation = ray["Transform"]["Orientation"];
+            orientation.x += angles.x;
+            orientation.y += angles.y;
+            glm::vec3 trajectory = direction * distance;
+            dealDamage(wi, direction, pelletDamage);
+        }
+    }
+
+}
+
+void DefenderWeaponBehaviour::dealDamage(WeaponInfo& wi, glm::vec3 direction, double damage)
+{
+    // Only deal damage client side
+    if (!IsClient) {
+        return;
+    }
+
+    // Only handle shooting for the local player
+    if (wi.Player != LocalPlayer) {
+        return;
+    }
+
+    // Make sure the player isn't shooting from the grave
+    if (!wi.Player.Valid()) {
+        return;
+    }
+    
+    glm::vec3 maxRange = direction * 2.f;
+    EntityWrapper camera = wi.Player.FirstChildByName("Camera");
+    glm::vec3 cameraPosition = Transform::AbsolutePosition(camera);
+    if (!camera.Valid()) {
+        return;
+    }
+    Rectangle screenResolution = m_Renderer->GetViewportSize();
+    glm::vec2 centerScreen = glm::vec2(screenResolution.Width / 2, screenResolution.Height / 2);
+    glm::vec2 screenCoords = cameraFromEntity(m_CurrentCamera).WorldToScreen(cameraPosition + maxRange, m_Renderer->GetViewportSize());
+    PickData pickData = m_Renderer->Pick(centerScreen + screenCoords);
+    EntityWrapper victim(m_World, pickData.Entity);
+    if (!victim.Valid()) {
+        return;
+    }
+
+    // Don't let us shoot ourselves in the foot somehow
+    if (victim == LocalPlayer) {
+        return;
+    }
+
+    // Only care about players being hit
+    if (!victim.HasComponent("Player")) {
+        victim = victim.FirstParentWithComponent("Player");
+    }
+    if (!victim.Valid()) {
+        return;
+    }
+
+    // Check for friendly fire
+    if ((ComponentInfo::EnumType)victim["Team"]["Team"] == (ComponentInfo::EnumType)wi.Player["Team"]["Team"]) {
+        return;
+    }
+
+    // Deal damage! 
+    Events::PlayerDamage ePlayerDamage;
+    ePlayerDamage.Inflictor = wi.Player;
+    ePlayerDamage.Victim = victim;
+    ePlayerDamage.Damage = damage;
+    m_EventBroker->Publish(ePlayerDamage);
+    LOG_DEBUG("Damage: %f", damage);
+}
+
+float DefenderWeaponBehaviour::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;
+    }
+}
+
+Camera DefenderWeaponBehaviour::cameraFromEntity(EntityWrapper camera)
+{
+    ComponentWrapper cTransform = camera["Transform"];
+    ComponentWrapper cCamera = camera["Camera"];
+    Camera cam(
+        (float)m_Renderer->Resolution().Width / m_Renderer->Resolution().Height, 
+        (double)cCamera["FOV"], 
+        (double)cCamera["NearClip"], 
+        (double)cCamera["FarClip"]
+    );
+    cam.SetPosition(cTransform["Position"]);
+    cam.SetOrientation(glm::quat((const glm::vec3&)cTransform["Orientation"]));
+    return cam;
+}

src/Game/Systems/Weapon/WeaponSystem.cpp_

@@ -13,7 +13,7 @@ WeaponSystem::WeaponSystem(SystemParams params, IRenderer* renderer, Octree<Enti
 
 void WeaponSystem::Update(double dt)
 {
-
+    // TODO: Clear inactive weapons
 }
 
 void WeaponSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& cPlayer, double dt)
@@ -72,20 +72,64 @@ bool WeaponSystem::OnInputCommand(Events::InputCommand& e)
 
 void WeaponSystem::selectWeapon(EntityWrapper player, ComponentInfo::EnumType slot)
 {
+    std::vector<EntityWrapper> weaponAttachments = player.ChildrenWithComponent("WeaponAttachment");
+
+    // Find the weapon attachments matching the slot selected
+    EntityWrapper firstPersonAttachment;
+    EntityWrapper thirdPersonAttachment;
+    for (auto& attachment : weaponAttachments) {
+        ComponentWrapper cWeaponAttachment = attachment["WeaponAttachment"];
+        if ((ComponentInfo::EnumType)cWeaponAttachment["Slot"] == slot) {
+            ComponentWrapper::SubscriptProxy person = cWeaponAttachment["Person"];
+            if (person == person.Enum("FirstPerson")) {
+                firstPersonAttachment = attachment;
+            } else if (person == person.Enum("ThirdPerson")) {
+                thirdPersonAttachment = attachment;
+            }
+        }
+    }
+
+    if (firstPersonAttachment.Valid() && thirdPersonAttachment.Valid()) {
+        LOG_WARNING("No weapon attachment found for slot %i of player #%i", slot, player.ID);
+        return;
+    }
+
+    // TODO: Delete old weapons
+
+    // Spawn the weapon(s)
+    EntityWrapper firstPersonWeapon;
+    EntityWrapper thirdPersonWeapon;
+    if (firstPersonAttachment.Valid()) {
+        firstPersonWeapon = SpawnerSystem::Spawn(firstPersonAttachment, firstPersonAttachment);
+    }
+    if (thirdPersonAttachment.Valid()) {
+        firstPersonWeapon = SpawnerSystem::Spawn(thirdPersonAttachment, thirdPersonAttachment);
+    }
+
+    // Create the correct behaviour
+    if (firstPersonWeapon.Valid()) {
+        if (firstPersonWeapon.HasComponent("AssaultWeapon") { 
+
+        }
+    }
+
     // Primary
     if (slot == 1) {
         // TODO: if class...
-        if (m_ActiveWeapons.count(player) == 0) {
-            m_ActiveWeapons.insert(std::make_pair(player, std::make_shared<AssaultWeaponBehaviour>(m_SystemParams, m_Renderer, m_CollisionOctree, player)));
-        } else {
-            //m_ActiveWeapons.erase(player);
-        }
+        nextBehaviour = std::make_shared<AssaultWeaponBehaviour>(m_SystemParams, m_Renderer, m_CollisionOctree, player);
     }
 
     // Secondary
     if (slot == 2) {
         //m_ActiveWeapons[player] = std::make_shared<PistolWeaponBehaviour>();
     }
+
+    if (nextBehaviour != nullptr) {
+        // TODO: Destroy previous behaviour and make new
+        if (m_ActiveWeapons.count(player) == 0) {
+            m_ActiveWeapons[player] = nextBehaviour;
+        }
+    }
 }
 
 bool WeaponSystem::OnPlayerSpawned(Events::PlayerSpawned& e)