experimental changes

# Conflicts:
#	include/Game/Systems/DamageIndicatorSystem.h
#	src/Game/Systems/DamageIndicatorSystem.cpp
#	src/Game/Systems/SoundSystem.cpp

include/Engine/Collision/CollisionSystem.h

@@ -24,7 +24,6 @@ public:
 private:
     Octree<EntityAABB>* m_Octree;
     std::vector<EntityAABB> m_OctreeResult;
-    std::unordered_map<EntityWrapper, glm::vec3> m_PrevPositions;
 };
 
 #endif

include/Engine/Core/MemoryPool.h

@@ -119,7 +119,7 @@ public:
 			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());
+			    //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/Input/FirstPersonInputController.h

@@ -192,6 +192,8 @@ bool FirstPersonInputController<EventContext>::OnLockMouse(const Events::LockMou
 
 template <typename EventContext>
 void FirstPersonInputController<EventContext>::AssaultDashCheck(double dt, bool isJumping, double assaultDashCoolDownMaxTimer) {
+    ImGui::Text(std::to_string(m_AssaultDashCoolDownTimer).c_str());
+
     m_AssaultDashDoubleTapDeltaTime += dt;
     m_AssaultDashCoolDownTimer -= dt;
     //cooldown = assaultDashCoolDownMaxTimer sec, pretend the dash lasts 0.25 sec (for friction to do its work)

include/Engine/Network/Client.h

@@ -21,7 +21,6 @@
 #include "Core/ConfigFile.h"
 #include "Input/EInputCommand.h"
 #include "Core/EPlayerDamage.h"
-#include "../Game/Events/EDoubleJump.h"
 #include "Network/EInterpolate.h"
 #include "Network/SnapshotFilter.h"
 #include "Core/EPlayerSpawned.h"
@@ -48,9 +47,7 @@ public:
 
     void Connect(std::string address, int port);
     void Update() override;
-private:
+
-    UDPClient m_Unreliable;
-    TCPClient m_Reliable;
     std::vector<Events::PlayerSpawned> m_PlayerSpawnEvents;
     void parseSpawnEvents();
     // Save for children
@@ -104,9 +101,9 @@ private:
     void parseEntityDeletion(Packet& packet);
     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 parseSnapshot(Packet& packet);
+    void UpdateLocalCapturePointHUD(EntityWrapper capturePointHUD);
     void identifyPacketLoss();
     void hasServerTimedOut();
     EntityID createPlayer();
@@ -130,10 +127,11 @@ private:
     EventRelay<Client, Events::PlayerSpawned> m_EPlayerSpawned;
     bool OnPlayerSpawned(const Events::PlayerSpawned& e);
     EventRelay< Client, Events::SearchForServers> m_ESearchForServers;
-    EventRelay<Client, Events::DoubleJump> m_EDoubleJump;
-    bool OnDoubleJump(Events::DoubleJump & e);
     bool OnSearchForServers(const Events::SearchForServers& e);
+private:
+    UDPClient m_Unreliable;
     UDPClient m_ServerlistRequest;
+    TCPClient m_Reliable;
     std::vector<ServerInfo> m_Serverlist;
     bool m_SearchingForServers = false;
     std::clock_t m_StartSearchTime;

include/Engine/Network/MessageType.h

@@ -19,7 +19,6 @@ enum class MessageType
     EntityDeleted,
     ComponentDeleted,
     PlayerTransform,
-    OnDoubleJump,
     ServerlistRequest,
     Invalid
 };

include/Engine/Network/Packet.h

@@ -24,7 +24,7 @@ public:
     {
         // Check if we are trying to add more than the package can fit.
         if (m_MaxPacketSize < m_Offset + sizeof(T)) {
-            LOG_WARNING("Packet AddPrimitive(): You are trying to add more than we have allocated for! New size is %i bytes\n", m_MaxPacketSize*2);
+            //LOG_WARNING("Packet AddPrimitive(): You are trying to add more than we have allocated for! New size is %i bytes\n", m_MaxPacketSize*2);
             resizeData();
         }
         memcpy(m_Data + m_Offset, &val, sizeof(T));
@@ -35,7 +35,7 @@ public:
     T ReadPrimitive()
     {
         if (m_Offset < m_ReturnDataOffset + sizeof(T)) {
-            LOG_WARNING("Packet PopFrontPrimitive(): You are trying to remove more than what exists in this packet!");
+            //LOG_WARNING("Packet PopFrontPrimitive(): You are trying to remove more than what exists in this packet!");
             return -1;
         }
         T returnValue;

include/Engine/Network/Server.h

@@ -8,6 +8,7 @@
 
 #include "Network/TCPServer.h"
 #include "Network/UDPServer.h"
+#include "Network/UDPClient.h" //LOL
 #include "Network/MessageType.h"
 #include "Network/PlayerDefinition.h"
 #include "Core/World.h"
@@ -17,7 +18,6 @@
 #include "Core/EPlayerDamage.h"
 #include "Network/EPlayerDisconnected.h"
 #include "Core/EPlayerSpawned.h"
-#include "../Game/Events/EDoubleJump.h"
 #include "Core/EEntityDeleted.h"
 #include "Core/EComponentDeleted.h"
 
@@ -81,9 +81,8 @@ private:
     void parseOnInputCommand(Packet& packet);
     void parseClientPing();
     void parsePing();
-    bool parseDoubleJump(Packet& packet);
+    void parseUDPConnect(Packet & packet);
-    void parseUDPConnect(Packet& packet);
+    void parseTCPConnect(Packet & packet);
-    void parseTCPConnect(Packet& packet);
     void parseDisconnect();
     void parseServerlistRequest(boost::asio::ip::udp::endpoint endpoint);
     bool shouldSendToClient(EntityWrapper childEntity);

include/Engine/Network/TCPServer.h

@@ -25,9 +25,10 @@ private:
     std::unique_ptr<boost::asio::ip::tcp::acceptor> acceptor;
     boost::shared_ptr<boost::asio::ip::tcp::socket> lastReceivedSocket;
 
+    void handle_accept(boost::shared_ptr<boost::asio::ip::tcp::socket> socket,
+        int& nextPlayerID, std::map<PlayerID, PlayerDefinition>& connectedPlayers,
+        const boost::system::error_code& error);
     int readBuffer(PlayerDefinition& playerDefinition);
-    PlayerID getPlayerIDFromEndpoint(const std::map<PlayerID, PlayerDefinition>& connectedPlayers,
-        boost::asio::ip::address address, unsigned short port);
     int GetPort();
     std::string GetAddress();
     int m_Port = 0;

include/Engine/Rendering/ShaderProgram.h

@@ -21,8 +21,6 @@ public:
 	std::string GetFileName() const;
 	GLuint GetHandle() const;
 	bool IsCompiled() const;
-    static std::string ReadFile(std::string fileName);
-private:
 protected:
 	GLenum m_ShaderType;
 	std::string m_FileName;

include/Game/Events/EDoubleJump.h

@@ -8,7 +8,7 @@ namespace Events
 
 struct DoubleJump : public Event
 {
-    EntityID entityID;
+
 };
 
 }

include/Game/Systems/AmmoPickupSystem.h

@@ -20,14 +20,24 @@ public:
 private:
     EventRelay<AmmoPickupSystem, Events::TriggerTouch> m_ETriggerTouch;
     bool OnTriggerTouch(Events::TriggerTouch& e);
+    EventRelay<AmmoPickupSystem, Events::TriggerLeave> m_ETriggerLeave;
+    bool OnTriggerLeave(Events::TriggerLeave& e);
 
-    struct NewAmmoPickup {
+    struct NewPickup {
         glm::vec3 Pos;
         double AmmoGain;
         double RespawnTimer;
         double DecreaseThisRespawnTimer;
         EntityID parentID;
+        bool isAmmoPickup;
     };
-    std::vector<NewAmmoPickup> m_ETriggerTouchVector;
+    struct EntityAtMaxValuePickupStruct {
+        EntityWrapper player;
+        EntityWrapper pickup;
+    };
+    std::vector<NewPickup> m_ETriggerTouchVector;
+    std::vector<EntityAtMaxValuePickupStruct> m_PickupAtMaximum;
+    
+    void DoPickup(EntityWrapper &player, EntityWrapper &trigger);
 };
 #endif

include/Game/Systems/HealthSystem.h

@@ -27,7 +27,7 @@ public:
 private:
     bool m_NetworkEnabled;
 
-   // methods which will take care of specific events
+    // methods which will take care of specific events
     EventRelay<HealthSystem, Events::PlayerDamage> m_EPlayerDamage;
     bool HealthSystem::OnPlayerDamaged(Events::PlayerDamage& e);
     EventRelay<HealthSystem, Events::PlayerHealthPickup> m_EPlayerHealthPickup;
@@ -37,6 +37,16 @@ private:
 
     //vector which will keep track of health changes
     std::vector<std::tuple<EntityID, double>> m_DeltaHealthVector;
+    struct DeadPlayers {
+        EntityWrapper playerEntity;
+        double timeSinceDeath;
+        DeadPlayers(EntityWrapper entity) : playerEntity(entity) {
+            timeSinceDeath = 0.0;
+        }
+    };
+    std::vector<DeadPlayers> m_DeadPlayers;
+
+
 };
 
 #endif

include/Game/Systems/PlayerMovementSystem.h

@@ -34,13 +34,9 @@ private:
     glm::vec3 m_LastPosition = glm::vec3();
     // The logic for making the sound play when player is moving
     void playerStep(double dt);
-    // Spawn a hexagon at origin of an Entity
-    void spawnHexagon(EntityWrapper target);
 
     EventRelay<PlayerMovementSystem, Events::PlayerSpawned> m_EPlayerSpawned;
     bool OnPlayerSpawned(Events::PlayerSpawned& e);
-    EventRelay<PlayerMovementSystem, Events::DoubleJump> m_EDoubleJump;
-    bool PlayerMovementSystem::OnDoubleJump(Events::DoubleJump & e);
 
     void updateMovementControllers(double dt);
     void updateVelocity(EntityWrapper player, double dt);

include/Game/Systems/PlayerSpawnSystem.h

@@ -21,6 +21,7 @@ private:
     {
         int PlayerID;
         ComponentInfo::EnumType Team;
+        double timeSinceDeath;
     };
 
     bool m_NetworkEnabled = false;
@@ -40,4 +41,7 @@ private:
     bool OnPlayerSpawned(Events::PlayerSpawned& e);
     EventRelay<PlayerSpawnSystem, Events::PlayerDeath> m_OnPlayerDeath;
     bool OnPlayerDeath(Events::PlayerDeath& e);
+
+    std::vector<SpawnRequest> m_LatePlayersVector;
+    void CheckForLatePlayers(double dt);
 };

resources/Schema/Components/Physics.xml

@@ -2,6 +2,7 @@
 <Physics xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xsi:noNamespaceSchemaLocation="Physics.xsd">
 	<Velocity X="0" Y="0" Z="0"/>
 	<Gravity>true</Gravity>
+	<PrevOrigin X="-9876.5" Y="-9876.5" Z="-9876.5"/>
 	<IsOnGround>false</IsOnGround>
 	<VerticalStepHeight>0.33</VerticalStepHeight>
 </Physics>

resources/Schema/Components/Physics.xsd

@@ -13,6 +13,7 @@
 					<xs:annotation><xs:documentation>m/s^2</xs:documentation></xs:annotation>
 				</xs:element>
 				<xs:element name="Gravity" type="t:bool" minOccurs="0"/>
+				<xs:element name="PrevOrigin" type="t:Vector" minOccurs="0"/>
 				<xs:element name="IsOnGround" type="t:bool" minOccurs="0"/>
 				<xs:element name="VerticalStepHeight" type="t:double" minOccurs="0">
 					<xs:annotation><xs:documentation>The largest height of a "stair-step" that can be walked over</xs:documentation></xs:annotation>

resources/Schema/Entities/Player.xml

@@ -13,6 +13,7 @@
     <c:DashAbility/>
     <c:Health/>
     <c:Physics>
+      <PrevOrigin X="0" Y="0.772000015" Z="0"/>
       <Velocity X="2.30999646e-23" Y="0" Z="1.05272533e-23"/>
     </c:Physics>
     <c:Player>

resources/Schema/Entities/PlayerRed.xml

@@ -13,6 +13,7 @@
     <c:DashAbility/>
     <c:Health/>
     <c:Physics>
+      <PrevOrigin X="0" Y="0.772000015" Z="0"/>
       <Velocity X="2.30999646e-23" Y="0" Z="1.05272533e-23"/>
     </c:Physics>
     <c:Player>

resources/Schema/Entities/aim_rays.xml

@@ -215,7 +215,8 @@
         </c:CapturePoint>
         <c:Model>
           <Resource>Models\Core\UnitCube.mesh</Resource>
-          <Color A="1" B="1" G="0.200000003" R="0"/>
+          <Color A="0.300000012" B="1" G="0" R="0"/>
+          <Transparent>true</Transparent>
         </c:Model>
         <c:Team>
           <Team>
@@ -241,7 +242,8 @@
         </c:CapturePoint>
         <c:Model>
           <Resource>Models\Core\UnitCube.mesh</Resource>
-          <Color A="1" B="1" G="1" R="0"/>
+          <Color A="0.300000012" B="0" G="0" R="1"/>
+          <Transparent>true</Transparent>
         </c:Model>
         <c:Team>
           <Team>
@@ -256,6 +258,25 @@
       </Components>
       <Children/>
     </Entity>
+    <Entity>
+      <Components>
+        <c:AmmoPickup/>
+        <c:Model>
+          <Resource>Models/Props/PickUps/AmmoPickUp.mesh</Resource>
+        </c:Model>
+        <c:RaptorCopter>
+          <Speed>8</Speed>
+          <Axis X="0" Y="0.100000001" Z="0"/>
+        </c:RaptorCopter>
+        <c:Transform>
+          <Position X="0" Y="1.86800003" Z="0"/>
+          <Scale X="0.600000024" Y="0.600000024" Z="0.600000024"/>
+          <Orientation X="0" Y="18741" Z="0"/>
+        </c:Transform>
+        <c:Trigger/>
+      </Components>
+      <Children/>
+    </Entity>
   </Children>
 
 </Entity>

resources/Shaders/ForwardPlus.frag.glsl

@@ -116,7 +116,12 @@ LightResult CalcDirectionalLightSource(vec4 direction, vec4 color, float intensi
 	return result;
 }
 
-#include "Shaders/Util/CommonUniforms.glsl"
+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()
 {
@@ -175,7 +180,6 @@ void main()
 		color_result += FillColor;
 	}
 	sceneColor = vec4(color_result.xyz, clamp(color_result.a, 0, 1));
-	//sceneColor = CommonUniforms.testColour;
 	//sceneColor = vec4(reflectionColor.xyz, 1);
 	color_result += glowTexel*GlowIntensity;
 

resources/Shaders/Util/CommonUniforms.glsl

@@ -1,6 +0,0 @@
-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);
-}

src/Engine/Collision/CollisionSystem.cpp

@@ -16,51 +16,51 @@ void CollisionSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& c
     EntityAABB& boxA = *boundingBox;
     bool everHitTheGround = false;
 
-    auto prevPosIt = m_PrevPositions.find(entity);
+    glm::vec3 size = boxA.Size();
-    if (prevPosIt != m_PrevPositions.end()) {
+    float diameter = std::min(size.x, size.z);
-        glm::vec3 size = boxA.Size();
+    glm::vec3 prevOrigin = (glm::vec3)cPhysics["PrevOrigin"];
-        float diameter = std::min(size.x, size.z);
+    glm::vec3 toCurrentPos = boxA.Origin() - prevOrigin;
-        glm::vec3 prevOrigin = prevPosIt->second;
+    float rayLength = glm::length(toCurrentPos) + 0.5f*diameter;
-        glm::vec3 toCurrentPos = boxA.Origin() - prevOrigin;
+    //If the entity has moved farther than the size of its box, we need to handle it specially.
-        float rayLength = glm::length(toCurrentPos) + 0.5f*diameter;
+    bool traceCollision = rayLength > diameter;
-        //If the entity has moved farther than the size of its box, we need to handle it specially.
+    //hack solution: If prevOrigin is less than -9000 in all dimensions, 
-        if (rayLength > diameter) {
+    //then it means it is not set, i.e. this is the first collision check for the entity.
-            Ray ray(prevOrigin, toCurrentPos);
+    if (traceCollision && glm::any(glm::greaterThan((glm::vec3)cPhysics["PrevOrigin"], glm::vec3(-9000.f)))) {
-            m_OctreeResult.clear();
+        Ray ray(prevOrigin, toCurrentPos);
-            m_Octree->ObjectsPossiblyHitByRay(ray, m_OctreeResult);
+        m_OctreeResult.clear();
-            for (auto& boxB : m_OctreeResult) {
+        m_Octree->ObjectsPossiblyHitByRay(ray, m_OctreeResult);
-                if (boxA.Entity == boxB.Entity) {
+        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&) {
                     continue;
                 }
-                bool hit;
+                float u, v;
-                float dist;
+                hit = Collision::RayVsModel(ray, model->Vertices(), model->m_Indices, Transform::ModelMatrix(boxB.Entity), dist, u, v);
-                if (boxB.Entity.HasComponent("Model")) {
+            } else {
-                    RawModel* model;
+                hit = Collision::RayVsAABB(ray, boxB, dist);
-                    std::string res = (std::string)boxB.Entity["Model"]["Resource"];
+            }
-                    try {
+            if (hit && dist < rayLength) {
-                        model = ResourceManager::Load<RawModel, true>(res);
+                //Set the entity to where it was colliding, minus the maximum box size. 
-                    } catch (const std::exception&) {
+                //TODO: Perhaps this should be done slightly more properly.
-                        continue;
+                glm::vec3 newOriginPos = ray.Origin() + (dist - 0.707107f*diameter) * ray.Direction();
-                    }
+                glm::vec3 resolve = newOriginPos - boxA.Origin();
-                    float u, v;
+                (glm::vec3&)cTransform["Position"] += resolve;
-                    hit = Collision::RayVsModel(ray, model->Vertices(), model->m_Indices, Transform::ModelMatrix(boxB.Entity), dist, u, v);
+                boxA = *Collision::EntityAbsoluteAABB(entity);
-                } else {
+                if (resolve.y > 0) {
-                    hit = Collision::RayVsAABB(ray, boxB, dist);
+                    everHitTheGround = true;
-                }
+                    (bool)cPhysics["IsOnGround"] = true;
-                if (hit && dist < rayLength) {
+                    ((glm::vec3&)cPhysics["Velocity"]).y = 0.f;
-                    //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;
             }
         }
     }
@@ -90,7 +90,6 @@ void CollisionSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& c
             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;
-                boxA = *Collision::EntityAbsoluteAABB(entity);
                 cPhysics["Velocity"] = inOutVelocity;
                 if (isOnGround) {
                     everHitTheGround = true;
@@ -100,7 +99,6 @@ 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;
@@ -114,5 +112,5 @@ void CollisionSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& c
         (bool)cPhysics["IsOnGround"] = false;
     }
 
-    m_PrevPositions[entity] = boxA.Origin();
+    (glm::vec3&)cPhysics["PrevOrigin"] = boxA.Origin();
 }

src/Engine/Network/Client.cpp

@@ -32,7 +32,6 @@ void Client::Connect(std::string address, int port)
     EVENT_SUBSCRIBE_MEMBER(m_EInputCommand, &Client::OnInputCommand);
     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_ESearchForServers, &Client::OnSearchForServers);
     auto config = ResourceManager::Load<ConfigFile>("Config.ini");
     m_Address = address;
@@ -141,9 +140,6 @@ void Client::parseMessageType(Packet& packet)
     case MessageType::OnPlayerDamage:
         parsePlayerDamage(packet);
         break;
-    case MessageType::OnDoubleJump:
-        parseDoubleJump(packet);
-        break;
     default:
         break;
     }
@@ -187,7 +183,7 @@ void Client::parsePing()
     m_IsConnected = true;
     // Time since last ping was received
     m_DurationOfPingTime = 1000 * (std::clock() - m_StartPingTime) / static_cast<double>(CLOCKS_PER_SEC);
-    LOG_INFO("%i: response time with ctime(ms): %f", m_PacketID, m_DurationOfPingTime);
+    //LOG_INFO("%i: response time with ctime(ms): %f", m_PacketID, m_DurationOfPingTime);
     m_StartPingTime = std::clock();
 
     Packet packet(MessageType::Ping, m_SendPacketID);
@@ -276,20 +272,6 @@ void Client::parseComponentDeletion(Packet & packet)
     }
 }
 
-void Client::parseDoubleJump(Packet & packet)
-{
-    EntityID serverID = packet.ReadPrimitive<EntityID>();
-    if (!serverClientMapsHasEntity(serverID)) {
-        return;
-    }
-    Events::DoubleJump e;
-    e.entityID = m_ServerIDToClientID.at(serverID);
-    // If player is local player do not publish to prevent infinite feedback loop
-    if (e.entityID != m_LocalPlayer.ID) {
-        m_EventBroker->Publish(e);
-    }
-}
-
 void Client::updateFields(Packet& packet, const ComponentInfo& componentInfo, const EntityID& entityID)
 {
     for (auto field : componentInfo.FieldsInOrder) {
@@ -366,7 +348,9 @@ void Client::parseSnapshot(Packet& packet)
                 EntityWrapper localEntity(m_World, localEntityID);
                 // Update entity
                 if (m_World->HasComponent(localEntityID, componentType)) {
-                    // TODO Fix memory leak here
+                    if (localEntity.Name() == "CapturePointHUD") {
+                        UpdateLocalCapturePointHUD(localEntity);
+                    }
                     SharedComponentWrapper newComponent = createSharedComponent(packet, localEntityID, componentInfo);
                     bool shouldApply = true;
                     // Apply potential filter function
@@ -377,7 +361,6 @@ void Client::parseSnapshot(Packet& packet)
                         ComponentWrapper currentComponent = m_World->GetComponent(localEntityID, componentType);
                         memcpy(currentComponent.Data, newComponent.Data, componentInfo.Stride);
                     }
-
                     //if (localEntity != m_LocalPlayer && !localEntity.IsChildOf(m_LocalPlayer)) {
                     //    updateFields(packet, componentInfo, localEntityID);
                     //} else {
@@ -394,11 +377,7 @@ void Client::parseSnapshot(Packet& packet)
                 if (serverParentID == EntityID_Invalid) {
                     newLocalEntityID = m_World->CreateEntity(EntityID_Invalid);
                 } else {
-                    if (serverClientMapsHasEntity(serverParentID)) {
+                    newLocalEntityID = m_World->CreateEntity(m_ServerIDToClientID.at(serverParentID));
-                        newLocalEntityID = m_World->CreateEntity(m_ServerIDToClientID.at(serverParentID));
-                    } else {
-                        newLocalEntityID = m_World->CreateEntity(EntityID_Invalid);
-                    }
                 }
                 m_World->SetName(newLocalEntityID, serverEntityName);
                 insertIntoServerClientMaps(serverEntityID, newLocalEntityID);
@@ -408,16 +387,26 @@ void Client::parseSnapshot(Packet& packet)
         }
         // Parent logic
         // This should be enough beacause we know that the entities arives in pre-order (there will always be a parent)
-        if (serverParentID != EntityID_Invalid && serverClientMapsHasEntity(serverParentID)) {
+        if (serverParentID != EntityID_Invalid) {
             EntityID localEntityID = m_ServerIDToClientID.at(serverEntityID);
-            if (m_World->GetParent(localEntityID) != m_ServerIDToClientID.at(serverParentID)) {
+            m_World->SetParent(localEntityID, m_ServerIDToClientID.at(serverParentID));
-                m_World->SetParent(localEntityID, m_ServerIDToClientID.at(serverParentID));
-            }
         }
     }
     parseSpawnEvents();
 }
 
+
+void Client::UpdateLocalCapturePointHUD(EntityWrapper capturePointHUD)
+{
+    //auto children = m_World->GetChildren(capturePointHUD.ID);
+    //for (auto it = children.first; it != children.second; it++) {
+    //    it->first
+    //}
+    //
+    //EntityWrapper& localHUD = m_LocalPlayer.FirstChildByName("HUD").FirstChildByName("CapturePointHUD");
+    //m_World->GetComponentPools()
+}
+
 void Client::disconnect()
 {
     m_IsConnected = false;
@@ -480,11 +469,6 @@ bool Client::OnPlayerDamage(const Events::PlayerDamage & e)
     if (e.Inflictor != m_LocalPlayer) {
         return false;
     }
-    // Could this happen?
-    //if (!clientServerMapsHasEntity(e.Inflictor.ID) 
-    //    || !clientServerMapsHasEntity(e.Victim.ID)) {
-    //    return;
-    //}
 
     Packet packet(MessageType::OnPlayerDamage, m_SendPacketID);
     packet.WritePrimitive(m_ClientIDToServerID.at(e.Inflictor.ID));
@@ -519,7 +503,7 @@ void Client::parsePlayerDamage(Packet& packet)
     Events::PlayerDamage e;
     PlayerID victimID = packet.ReadPrimitive<EntityID>();
     PlayerID inflictorID = packet.ReadPrimitive<EntityID>();
-    if (!serverClientMapsHasEntity(victimID) || !serverClientMapsHasEntity(inflictorID)) {
+    if(!serverClientMapsHasEntity(victimID) || !serverClientMapsHasEntity(inflictorID)){
         return;
     }
     e.Inflictor = EntityWrapper(m_World, m_ServerIDToClientID.at(victimID));
@@ -531,17 +515,6 @@ void Client::parsePlayerDamage(Packet& packet)
     }
 }
 
-bool Client::OnDoubleJump(Events::DoubleJump & e)
-{
-    if (!clientServerMapsHasEntity(e.entityID) || e.entityID != m_LocalPlayer.ID) {
-        return false;
-    }
-    Packet packet(MessageType::OnDoubleJump);
-    packet.WritePrimitive(m_ClientIDToServerID.at(e.entityID));
-    m_Reliable.Send(packet);
-    return true;
-}
-
 void Client::sendLocalPlayerTransform()
 {
     if (!m_LocalPlayer.Valid()) {

src/Engine/Network/Server.cpp

@@ -29,8 +29,9 @@ Server::~Server()
 
 void Server::Update()
 {
-    m_Reliable.AcceptNewConnections(m_NextPlayerID, m_ConnectedPlayers);
+    PlayerDefinition pd;
 
+    m_Reliable.AcceptNewConnections(m_NextPlayerID, m_ConnectedPlayers);
     for (auto& kv : m_ConnectedPlayers) {
         while (kv.second.TCPSocket->available()) {
             // Packet will get real data in receive
@@ -46,7 +47,6 @@ void Server::Update()
         }
     }
 
-    PlayerDefinition pd;
     while (m_Unreliable.IsSocketAvailable()) {
         // Packet will get real data in receive
         Packet packet(MessageType::Invalid);
@@ -65,7 +65,7 @@ void Server::Update()
         PlayerDefinition localArea;
         localArea.Endpoint = boost::asio::ip::udp::endpoint();
         m_ServerlistRequest.Receive(packet, localArea);
-        if (packet.GetMessageType() == MessageType::ServerlistRequest) {
+        if(packet.GetMessageType() == MessageType::ServerlistRequest) {
             packet.ReadPrimitive<int>(); // Pop size
             packet.ReadPrimitive<int>(); // Pop MsgType
             packet.ReadPrimitive<int>(); // Pop packet ID
@@ -76,7 +76,7 @@ void Server::Update()
     }
 
     // Check if players have disconnected
-    for (int i = 0; i < m_PlayersToDisconnect.size(); i++) {
+     for (int i = 0; i < m_PlayersToDisconnect.size(); i++) {
         disconnect(m_PlayersToDisconnect.at(i));
     }
     m_PlayersToDisconnect.clear();
@@ -136,10 +136,7 @@ void Server::parseMessageType(Packet& packet)
         parseOnPlayerDamage(packet);
         break;
     case MessageType::PlayerTransform:
-        parsePlayerTransform(packet);
+       parsePlayerTransform(packet);
-        break;
-    case MessageType::OnDoubleJump:
-        parseDoubleJump(packet);
         break;
     default:
         break;
@@ -194,41 +191,43 @@ void Server::addPlayersToPacket(Packet & packet, EntityID entityID)
         // HACK: Only sync players for now, since the map turned out to be TOO LARGE to send in one snapshot and Simon's computer shits itself
         // HACK: Also checked CapturePointHUD for now. (this would get out of sync);
         EntityWrapper childEntity(m_World, childEntityID);
-        if (shouldSendToClient(childEntity)) {
+        if (!shouldSendToClient(childEntity)) {
-            // Write EntityID and parentsID and Entity name
+            continue;
-            packet.WritePrimitive(childEntityID);
+        }
-            packet.WritePrimitive(entityID);
+
-            packet.WriteString(m_World->GetName(childEntityID));
+        // Write EntityID and parentsID and Entity name
-            // Write components to child
+        packet.WritePrimitive(childEntityID);
-            int numberOfComponents = 0;
+        packet.WritePrimitive(entityID);
-            for (auto& i : worldComponentPools) {
+        packet.WriteString(m_World->GetName(childEntityID));
-                if (i.second->KnowsEntity(childEntityID)) {
+        // Write components to child
-                    numberOfComponents++;
+        int numberOfComponents = 0;
-                }
+        for (auto& i : worldComponentPools) {
+            if (i.second->KnowsEntity(childEntityID)) {
+                numberOfComponents++;
             }
-            // Write how many components should be read
+        }
-            packet.WritePrimitive(numberOfComponents);
+        // Write how many components should be read
-            for (auto& i : worldComponentPools) {
+        packet.WritePrimitive(numberOfComponents);
-                // If the entity exist in the pool
+        for (auto& i : worldComponentPools) {
-                if (i.second->KnowsEntity(childEntityID)) {
+            // If the entity exist in the pool
-                    ComponentWrapper componentWrapper = i.second->GetByEntity(childEntityID);
+            if (i.second->KnowsEntity(childEntityID)) {
-                    // ComponentType
+                ComponentWrapper componentWrapper = i.second->GetByEntity(childEntityID);
-                    packet.WriteString(componentWrapper.Info.Name);
+                // ComponentType
-                    // Loop through fields
+                packet.WriteString(componentWrapper.Info.Name);
-                    for (auto& componentField : componentWrapper.Info.FieldsInOrder) {
+                // Loop through fields
-                        ComponentInfo::Field_t fieldInfo = componentWrapper.Info.Fields.at(componentField);
+                for (auto& componentField : componentWrapper.Info.FieldsInOrder) {
-                        if (fieldInfo.Type == "string") {
+                    ComponentInfo::Field_t fieldInfo = componentWrapper.Info.Fields.at(componentField);
-                            std::string& value = componentWrapper[componentField];
+                    if (fieldInfo.Type == "string") {
-                            packet.WriteString(value);
+                        std::string& value = componentWrapper[componentField];
-                        } else {
+                        packet.WriteString(value);
-                            packet.WriteData(componentWrapper.Data + fieldInfo.Offset, fieldInfo.Stride);
+                    } else {
-                        }
+                        packet.WriteData(componentWrapper.Data + fieldInfo.Offset, fieldInfo.Stride);
                     }
                 }
             }
         }
         // Go to to your children
-        addPlayersToPacket(packet, childEntityID);
+        addChildrenToPacket(packet, childEntityID);
     }
 }
 
@@ -344,7 +343,7 @@ void Server::parseTCPConnect(Packet & packet)
     // Read packet ID 
     m_PreviousPacketID = m_PacketID;    // Set previous packet id
     m_PacketID = packet.ReadPrimitive<int>(); //Read new packet id
-
+    
     LOG_INFO("Parsing connections");
     // Check if player is already connected
     // Ska vara till lagd i TCPServer receive
@@ -456,7 +455,8 @@ bool Server::OnInputCommand(const Events::InputCommand & e)
         }
         isReadingData = !isReadingData;
         m_SaveDataTimer = std::clock();
-    } else if (e.Command == "KickPlayer" && e.Value > 0) {
+    }
+    else if (e.Command == "KickPlayer" && e.Value > 0) {
         kick(0);
     }
 
@@ -507,7 +507,7 @@ bool Server::OnPlayerDamage(const Events::PlayerDamage& e)
     packet.WritePrimitive(e.Damage);
     reliableBroadcast(packet);
 
-    return true;
+    return false;
 }
 
 void Server::parseClientPing()
@@ -536,12 +536,6 @@ void Server::parsePing()
     }
 }
 
-bool Server::parseDoubleJump(Packet & packet)
-{
-    reliableBroadcast(packet);
-    return true;
-}
-
 void Server::parseOnInputCommand(Packet& packet)
 {
     PlayerID player = -1;
@@ -601,15 +595,8 @@ void Server::parsePlayerTransform(Packet& packet)
 
 bool Server::shouldSendToClient(EntityWrapper childEntity)
 {
-    auto children = m_World->GetChildren(childEntity.ID);
-    for (auto it = children.first; it != children.second; it++) {
-        EntityWrapper child(m_World, it->second);
-        if(child.HasComponent("CapturePoint")) {
-            return true;
-        }
-    }
     return childEntity.HasComponent("Player") || childEntity.FirstParentWithComponent("Player").Valid()
-        || childEntity.HasComponent("CapturePoint");
+        || childEntity.HasComponent("CapturePoint") || childEntity.FirstParentWithComponent("CapturePoint").Valid();
 }
 
 PlayerID Server::GetPlayerIDFromEndpoint()

src/Engine/Network/TCPServer.cpp

@@ -4,8 +4,6 @@ using namespace boost::asio::ip;
 TCPServer::TCPServer() 
 {
     acceptor = std::unique_ptr<tcp::acceptor>(new tcp::acceptor(m_IOService, tcp::endpoint(tcp::v4(), 27666)));
-    // Make the acceptor non-blocking so we wont get stuck in AcceptNewConnections().
-    acceptor->non_blocking(true);
     m_Port = GetPort();
     m_Address = GetAddress();
 }
@@ -15,24 +13,14 @@ TCPServer::~TCPServer()
 
 void TCPServer::AcceptNewConnections(int& nextPlayerID, std::map<PlayerID, PlayerDefinition>& connectedPlayers)
 {
-    boost::system::error_code error;
     boost::shared_ptr<tcp::socket> newSocket = boost::shared_ptr<tcp::socket>(new tcp::socket(m_IOService));
-    acceptor->accept(*newSocket, error);
+    m_IOService.poll();
-    // If no error occured add new tcp connection
+    acceptor->async_accept(*newSocket,
-    if (!error) {
+        boost::bind(&TCPServer::handle_accept, this, newSocket, boost::ref(nextPlayerID), boost::ref(connectedPlayers),
-        // Add tcp socket to connections
+            boost::asio::placeholders::error));
-        boost::asio::ip::tcp::no_delay option(true);
-        newSocket->set_option(option);
-        PlayerDefinition pd;
-        pd.StopTime = std::clock();
-        pd.TCPSocket = newSocket;
-        pd.TCPAddress = newSocket.get()->remote_endpoint().address();
-        pd.TCPPort = newSocket.get()->remote_endpoint().port();
-        connectedPlayers[nextPlayerID++] = pd;
-    }
 }
 
-PlayerID TCPServer::getPlayerIDFromEndpoint(const std::map<PlayerID, PlayerDefinition>& connectedPlayers,
+PlayerID GetPlayerIDFromEndpoint(const std::map<PlayerID, PlayerDefinition>& connectedPlayers,
     boost::asio::ip::address address, unsigned short port)
 {
     for (auto& kv : connectedPlayers) {
@@ -44,6 +32,24 @@ PlayerID TCPServer::getPlayerIDFromEndpoint(const std::map<PlayerID, PlayerDefin
     return -1;
 }
 
+void TCPServer::handle_accept(boost::shared_ptr<tcp::socket> socket,
+    int& nextPlayerID, std::map<PlayerID, PlayerDefinition>& connectedPlayers,
+    const boost::system::error_code& error)
+{
+    if (!error && GetPlayerIDFromEndpoint(connectedPlayers, socket->remote_endpoint().address(),
+        socket->remote_endpoint().port()) == -1) {
+        // Add tcp socket to connections
+        boost::asio::ip::tcp::no_delay option(true);
+        socket->set_option(option);
+        PlayerDefinition pd;
+        pd.StopTime = std::clock();
+        pd.TCPSocket = socket;
+        pd.TCPAddress = socket.get()->remote_endpoint().address();
+        pd.TCPPort = socket.get()->remote_endpoint().port();
+        connectedPlayers[nextPlayerID++] = pd;
+    }
+}
+
 void TCPServer::Send(Packet & packet, PlayerDefinition & playerDefinition)
 {
     packet.UpdateSize();

src/Engine/Rendering/ShaderProgram.cpp

@@ -4,32 +4,22 @@ GLuint Shader::CompileShader(GLenum shaderType, std::string fileName)
 {
 	LOG_INFO("Compiling shader \"%s\"", fileName.c_str());
 
-    std::string shaderFile = ReadFile(fileName);
+	std::string shaderFile;
+	std::ifstream in(fileName, std::ios::in);
+	if (!in) {
+		LOG_ERROR("Error: Failed to open shader file \"%s\"", fileName.c_str());
+		return 0;
+	}
+	in.seekg(0, std::ios::end);
+	shaderFile.resize((int)in.tellg());
+	in.seekg(0, std::ios::beg);
+	in.read(&shaderFile[0], shaderFile.size());
+	in.close();
 
 	GLuint shader = glCreateShader(shaderType);
 	if (GLERROR("glCreateShader"))
 		return 0;
 
-    std::size_t startPos = 0;
-    std::size_t SEofNewFile[2];
-    std::string key = "#include";
-    while((startPos = shaderFile.find(key, startPos)) != std::string::npos)
-    {
-        SEofNewFile[0] = shaderFile.find('"', startPos+key.length())+1;
-        SEofNewFile[1] = shaderFile.find('"', SEofNewFile[0]);
-        if (SEofNewFile[0] == std::string::npos || SEofNewFile[1] == std::string::npos)
-            return 0;
-
-        std::string replacementFileName = shaderFile.substr(SEofNewFile[0], SEofNewFile[1] - SEofNewFile[0]);
-        std::string replacementString = ReadFile(replacementFileName);
-        size_t firstof = replacementString.find_first_of((char)0);
-        replacementString.erase(firstof, replacementString.size() - firstof);
-        if (replacementString.length() <= 0)
-            return 0;
-        shaderFile.replace(startPos, SEofNewFile[1]+2 - startPos, replacementString + "\n");
-        startPos += replacementString.length(); //This might not be wanted.
-    }
-
 	const GLchar* shaderFiles = shaderFile.c_str();
 	const GLint length = static_cast<GLint>(shaderFile.length());
 	glShaderSource(shader, 1, &shaderFiles, &length);
@@ -56,24 +46,6 @@ GLuint Shader::CompileShader(GLenum shaderType, std::string fileName)
 	return shader;
 }
 
-std::string Shader::ReadFile(std::string fileName)
-{
-    std::string shaderFile;
-    std::ifstream in(fileName, std::ios::in);
-    if (!in) {
-        LOG_ERROR("Error: Failed to open shader file \"%s\"", fileName.c_str());
-        return "";
-    }
-
-    in.seekg(0, std::ios::end);
-    shaderFile.resize((int)in.tellg());
-    in.seekg(0, std::ios::beg);
-    in.read(&shaderFile[0], shaderFile.size());
-    in.close();
-    return shaderFile;
-}
-
-
 Shader::Shader(GLenum shaderType, std::string fileName) : m_ShaderType(shaderType), m_FileName(fileName)
 {
 	m_ShaderHandle = 0;

src/Game/Systems/AmmoPickupSystem.cpp

@@ -4,18 +4,20 @@ AmmoPickupSystem::AmmoPickupSystem(SystemParams params)
     : System(params)
 {
     EVENT_SUBSCRIBE_MEMBER(m_ETriggerTouch, &AmmoPickupSystem::OnTriggerTouch);
+    EVENT_SUBSCRIBE_MEMBER(m_ETriggerLeave, &AmmoPickupSystem::OnTriggerLeave);
 }
 
 void AmmoPickupSystem::Update(double dt)
 {
     for (auto it = m_ETriggerTouchVector.begin(); it != m_ETriggerTouchVector.end(); ++it)
     {
-        auto& ammoPickupPosition = *it;
+        auto& somePickup = *it;
+
         //set the double timer value (value 3)
-        ammoPickupPosition.DecreaseThisRespawnTimer -= dt;
+        somePickup.DecreaseThisRespawnTimer -= dt;
-        if (ammoPickupPosition.DecreaseThisRespawnTimer < 0.0) {
+        if (somePickup.DecreaseThisRespawnTimer < 0.0) {
             //spawn and delete the vector item
-            auto entityFile = ResourceManager::Load<EntityFile>("Schema/Entities/AmmoPickup.xml");
+            auto entityFile = ResourceManager::Load<EntityFile>("Schema/Entities/" + somePickup.isAmmoPickup ? "AmmoPickup.xml" : "HealthPickup.xml");
             EntityFileParser parser(entityFile);
             EntityID ammoPickupID = parser.MergeEntities(m_World);
 
@@ -25,17 +27,34 @@ void AmmoPickupSystem::Update(double dt)
             m_EventBroker->Publish(ePickupSpawned);
 
             //set values from the old entity to the new entity
-            auto& newAmmoPickupEntity = EntityWrapper(m_World, ammoPickupID);
+            auto& newPickupEntity = EntityWrapper(m_World, ammoPickupID);
-            newAmmoPickupEntity["Transform"]["Position"] = ammoPickupPosition.Pos;
+            newPickupEntity["Transform"]["Position"] = somePickup.Pos;
-            newAmmoPickupEntity["AmmoPickup"]["AmmoGain"] = ammoPickupPosition.AmmoGain;
+            if (somePickup.isAmmoPickup) {
-            newAmmoPickupEntity["AmmoPickup"]["RespawnTimer"] = ammoPickupPosition.RespawnTimer;
+                newPickupEntity["AmmoPickup"]["AmmoGain"] = somePickup.AmmoGain;
-            m_World->SetParent(newAmmoPickupEntity.ID, ammoPickupPosition.parentID);
+                newPickupEntity["AmmoPickup"]["RespawnTimer"] = somePickup.RespawnTimer;
+            } else {
+                newPickupEntity["HealthPickup"]["HealthGain"] = somePickup.AmmoGain;
+                newPickupEntity["HealthPickup"]["RespawnTimer"] = somePickup.RespawnTimer;
+            }
+            m_World->SetParent(newPickupEntity.ID, somePickup.parentID);
 
-            //erase the current element (AmmoPickupPosition)
+            //erase the current element (somePickup)
             m_ETriggerTouchVector.erase(it);
             break;
         }
     }
+    //still touching AmmoPickupAtMaxHealthAmmo?
+    for (auto& it = m_PickupAtMaximum.begin(); it != m_PickupAtMaximum.end(); ++it) {
+        if (!it->player.Valid() || !it->pickup.Valid()) {
+            m_PickupAtMaximum.erase(it);
+            break;
+        }
+        if ((int)it->player["AssaultWeapon"]["Ammo"] < (int)it->player["AssaultWeapon"]["MaxAmmo"]) {
+            DoPickup(it->player, it->pickup);
+            m_PickupAtMaximum.erase(it);
+            break;
+        }
+    }
 }
 
 
@@ -44,36 +63,59 @@ bool AmmoPickupSystem::OnTriggerTouch(Events::TriggerTouch& e)
     if (e.Entity != LocalPlayer) {
         return false;
     }
+    if (!e.Trigger.HasComponent("AmmoPickup") && !e.Trigger.HasComponent("HealthPickup")) {
+        return false;
+    }
     //TODO: add other weapontypes
     if (!e.Entity.HasComponent("AssaultWeapon")) {
         return false;
     }
-    if (!e.Trigger.HasComponent("AmmoPickup")) {
-        return false;
-    }
     int maxWeaponAmmo = (int)e.Entity["AssaultWeapon"]["MaxAmmo"];
     int& currentAmmo = (int)e.Entity["AssaultWeapon"]["Ammo"];
-
-    int ammoGiven = 0.01*(double)e.Trigger["AmmoPickup"]["AmmoGain"] * maxWeaponAmmo;
     //cant pick up ammopacks if you are already at MaxAmmo
     if (currentAmmo >= maxWeaponAmmo) {
+        m_PickupAtMaximum.push_back({ e.Entity, e.Trigger });
         return false;
     }
+    DoPickup(e.Entity, e.Trigger);
+    return true;
+}
 
-    //personEntered = e.Entity, thingEntered = e.Trigger
+bool AmmoPickupSystem::OnTriggerLeave(Events::TriggerLeave& e) {
+    //triggerleave erases possible AmmoPickupAtMaxHealthAmmo
+    for (auto& it = m_PickupAtMaximum.begin(); it != m_PickupAtMaximum.end(); ++it) {
+        if (it->pickup.ID == e.Trigger.ID && it->player.ID == e.Entity.ID) {
+            m_PickupAtMaximum.erase(it);
+            break;
+        }
+    }
+    return true;
+}
+void AmmoPickupSystem::DoPickup(EntityWrapper &player, EntityWrapper &trigger) {
+    auto& weaponEntity = player["AssaultWeapon"];
+    auto& pickup = trigger["AmmoPickup"];
+    auto& gain = pickup["AmmoGain"];
+    int maxValue = (int)weaponEntity["MaxAmmo"];
+    int& currentValue = (int)weaponEntity["Ammo"];
+
+    //cant pick up if you are already at max
+    if (currentValue >= maxValue) {
+        return;
+    }
+
+    int increaseGiven = 0.01*(double)gain * maxValue;
     Events::AmmoPickup ePlayerAmmoPickup;
-    ePlayerAmmoPickup.AmmoGain = ammoGiven;
+    ePlayerAmmoPickup.AmmoGain = increaseGiven;
-    ePlayerAmmoPickup.Player = e.Entity;
+    ePlayerAmmoPickup.Player = player;
     m_EventBroker->Publish(ePlayerAmmoPickup);
     //immediately give the player the ammo
-    currentAmmo = std::min(currentAmmo + ammoGiven, maxWeaponAmmo);
+    currentValue = std::min(currentValue + increaseGiven, maxValue);
 
     //copy position, ammogain, respawntimer (twice since one of the values will be counted down to 0, the other will be set in the new object)
     //we need to copy all values since each value can be different for each ammoPickup
-    m_ETriggerTouchVector.push_back({ e.Trigger["Transform"]["Position"], e.Trigger["AmmoPickup"]["AmmoGain"],
+    m_ETriggerTouchVector.push_back({ trigger["Transform"]["Position"], gain,
-        e.Trigger["AmmoPickup"]["RespawnTimer"], e.Trigger["AmmoPickup"]["RespawnTimer"], m_World->GetParent(e.Trigger.ID) });
+        pickup["RespawnTimer"], pickup["RespawnTimer"], m_World->GetParent(trigger.ID) , true });
 
     //delete the ammopickup
-    m_World->DeleteEntity(e.Trigger.ID);
+    m_World->DeleteEntity(trigger.ID);
-    return true;
 }

src/Game/Systems/CapturePointSystem.cpp

@@ -6,11 +6,9 @@ CapturePointSystem::CapturePointSystem(SystemParams params)
     , PureSystem("CapturePoint")
 {
     //subscribe/listenTo playerdamage,healthpickup events (using the eventBroker)
-    if (!IsClient) {
+    EVENT_SUBSCRIBE_MEMBER(m_ETriggerTouch, &CapturePointSystem::OnTriggerTouch);
-        EVENT_SUBSCRIBE_MEMBER(m_ETriggerTouch, &CapturePointSystem::OnTriggerTouch);
+    EVENT_SUBSCRIBE_MEMBER(m_ETriggerLeave, &CapturePointSystem::OnTriggerLeave);
-        EVENT_SUBSCRIBE_MEMBER(m_ETriggerLeave, &CapturePointSystem::OnTriggerLeave);
+    EVENT_SUBSCRIBE_MEMBER(m_ECaptured, &CapturePointSystem::OnCaptured);
-        EVENT_SUBSCRIBE_MEMBER(m_ECaptured, &CapturePointSystem::OnCaptured);
-    }
 
 }
 
@@ -18,9 +16,6 @@ CapturePointSystem::CapturePointSystem(SystemParams params)
 //NOTE: needs to run each frame, since we're possibly modifying the captureTimer for the capturePoints by dt
 void CapturePointSystem::UpdateComponent(EntityWrapper& capturePointEntity, ComponentWrapper& cCapturePoint, double dt)
 {
-    if (IsClient) {
-        return;
-    }
     if (m_WinnerWasFound) {
         return;
     }
@@ -156,12 +151,12 @@ void CapturePointSystem::UpdateComponent(EntityWrapper& capturePointEntity, Comp
     int currentTeam = 0;
     bool canCapture = false;
     if (redTeamPlayersStandingInside > 0 && blueTeamPlayersStandingInside == 0) {
-        timerDeltaChange = redTeamPlayersStandingInside*dt;
+        timerDeltaChange = 3*redTeamPlayersStandingInside*dt;
         currentTeam = redTeam;
         canCapture = nextPossibleCapturePoint["Red"] == capturePointNumber;
     }
     if (redTeamPlayersStandingInside == 0 && blueTeamPlayersStandingInside > 0) {
-        timerDeltaChange = -blueTeamPlayersStandingInside*dt;
+        timerDeltaChange = -3*blueTeamPlayersStandingInside*dt;
         currentTeam = blueTeam;
         canCapture = nextPossibleCapturePoint["Blue"] == capturePointNumber;
     }

src/Game/Systems/HealthSystem.cpp

@@ -14,16 +14,35 @@ HealthSystem::HealthSystem(SystemParams params)
 void HealthSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& cHealth, double dt)
 {
     double& health = cHealth["Health"];
-    if (health <= 0.0) {
+    int healthInt = (int)health;
+    //update struct
+    for (auto& iter = m_DeadPlayers.begin(); iter < m_DeadPlayers.end(); iter++)
+    {
+        iter->timeSinceDeath += dt;
+        if (iter->timeSinceDeath > 2.0f || !iter->playerEntity.Valid()) {
+            m_DeadPlayers.erase(iter);
+            break;
+        }
+    }
+    if (healthInt <= 0) {
+        for (auto deadPlayer : m_DeadPlayers)
+        {
+            if (deadPlayer.playerEntity.ID == entity.ID) {
+                return;
+            }
+        }
+        LOG_INFO("-> health <= 0");
         Events::PlayerDeath ePlayerDeath;
         ePlayerDeath.Player = entity;
         m_EventBroker->Publish(ePlayerDeath);
+        m_DeadPlayers.emplace_back(entity);
         //Note: we will delete the entity in PlayerDeathSystem
     }
 }
 
 bool HealthSystem::OnPlayerDamaged(Events::PlayerDamage& e)
 {
+    LOG_INFO("<- on player damage");
     if (!IsServer && m_NetworkEnabled || !e.Victim.Valid()) {
         return false;
     }
@@ -31,6 +50,7 @@ bool HealthSystem::OnPlayerDamaged(Events::PlayerDamage& e)
     ComponentWrapper cHealth = e.Victim["Health"];
     double& health = cHealth["Health"];
     health -= e.Damage;
+    LOG_INFO("-> health onplayerdam");
 
     return true;
 }

src/Game/Systems/KillFeedSystem.cpp

@@ -54,9 +54,13 @@ void KillFeedSystem::Update(double dt)
 
 bool KillFeedSystem::OnPlayerDeath(Events::PlayerDeath& e)
 {
+    LOG_INFO("<- killfeed death");
+
     KillFeedInfo kfInfo;
 
     if (e.Player.HasComponent("Team")) {
+        LOG_INFO("- killfeed death");
+
         int red = e.Player["Team"].Enum("Team", "Red");
         int blue = e.Player["Team"].Enum("Team", "Blue");
 
@@ -70,6 +74,7 @@ bool KillFeedSystem::OnPlayerDeath(Events::PlayerDeath& e)
             m_DeathQueue.push_back(kfInfo);
         }
     }
+    LOG_INFO("-> killfeed death");
 
 
     if(m_DeathQueue.size() > 3) {

src/Game/Systems/PlayerDeathSystem.cpp

@@ -8,18 +8,27 @@ PlayerDeathSystem::PlayerDeathSystem(SystemParams params)
 
 void PlayerDeathSystem::Update(double dt)
 {
+
 }
 
 bool PlayerDeathSystem::OnPlayerDeath(Events::PlayerDeath& e)
 {
+    LOG_INFO("<- deathsystem: valid player");
+
     if (!e.Player.Valid()) {
         return false;
     }
+    LOG_INFO("-> deathsystem: valid player");
+
+    LOG_INFO("<- create effect");
 
     createDeathEffect(e.Player);
 
-    // Delete player
+    LOG_INFO("-> create effect");
-    m_World->DeleteEntity(e.Player.ID);
+
+    if (!IsClient || !ResourceManager::Load<ConfigFile>("Config.ini")->Get("Networking.StartNetwork", false)) {
+        m_World->DeleteEntity(e.Player.ID);
+    }
 
     return true;
 }
@@ -32,6 +41,8 @@ void PlayerDeathSystem::createDeathEffect(EntityWrapper player)
     EntityID deathEffectID = parser.MergeEntities(m_World);
     EntityWrapper deathEffectEW = EntityWrapper(m_World, deathEffectID);
 
+    LOG_INFO("<- effect camera");
+
     //components that we need from player
     auto playerModel = player.FirstChildByName("PlayerModel");
     if (!playerModel.Valid()) {
@@ -42,6 +53,7 @@ void PlayerDeathSystem::createDeathEffect(EntityWrapper player)
     }
     auto playerEntityModel = playerModel["Model"];
     auto playerEntityAnimation = playerModel["Animation"];
+    LOG_INFO("-> effect camera");
 
     //copy the data from player to explosioneffectmodel
     playerEntityModel.Copy(deathEffectEW["Model"]);
@@ -57,11 +69,15 @@ void PlayerDeathSystem::createDeathEffect(EntityWrapper player)
     //effect,camera is relative to playersPosition
     //deathEffectEW["ExplosionEffect"]["ExplosionOrigin"] = glm::vec3(0, 0, 0);
 
+    LOG_INFO("<- localplayer");
     //camera (with lifetime) behind the player
     if (player == LocalPlayer) {
         auto cam = deathEffectEW.FirstChildByName("Camera");
         Events::SetCamera eSetCamera;
         eSetCamera.CameraEntity = cam;
         m_EventBroker->Publish(eSetCamera);
+        LOG_INFO("in localplayer");
     }
+    LOG_INFO("-> localplayer");
+
 }

src/Game/Systems/PlayerMovementSystem.cpp

@@ -4,7 +4,6 @@ PlayerMovementSystem::PlayerMovementSystem(SystemParams params)
     : System(params)
 {
     EVENT_SUBSCRIBE_MEMBER(m_EPlayerSpawned, &PlayerMovementSystem::OnPlayerSpawned);
-    EVENT_SUBSCRIBE_MEMBER(m_EDoubleJump, &PlayerMovementSystem::OnDoubleJump);
 }
 
 PlayerMovementSystem::~PlayerMovementSystem()
@@ -37,6 +36,7 @@ void PlayerMovementSystem::updateMovementControllers(double dt)
         if (!player.Valid()) {
             continue;
         }
+
         // Aim pitch
         EntityWrapper cameraEntity = player.FirstChildByName("Camera");
         if (cameraEntity.Valid()) {
@@ -122,14 +122,15 @@ void PlayerMovementSystem::updateMovementControllers(double dt)
                 if (isOnGround) {
                     controller->SetDoubleJumping(false);
                 } else {
-                    // If IsServer and network is off this will not work
                     if (IsClient) {
                         //put a hexagon at the players feet
-                        spawnHexagon(player);
+                        auto hexagonEffect = ResourceManager::Load<EntityFile>("Schema/Entities/DoubleJumpHexagon.xml");
+                        EntityFileParser parser(hexagonEffect);
+                        EntityID hexagonEffectID = parser.MergeEntities(m_World);
+                        EntityWrapper hexagonEW = EntityWrapper(m_World, hexagonEffectID);
+                        hexagonEW["Transform"]["Position"] = (glm::vec3)player["Transform"]["Position"];
                         controller->SetDoubleJumping(true);
-                        // Publish event for client to listen to
                         Events::DoubleJump e;
-                        e.entityID = player.ID;
                         m_EventBroker->Publish(e);
                     }
                 }
@@ -294,26 +295,3 @@ bool PlayerMovementSystem::OnPlayerSpawned(Events::PlayerSpawned& e)
     }
     return true;
 }
-
-bool PlayerMovementSystem::OnDoubleJump(Events::DoubleJump & e)
-{
-    // If entity does not exist, exit
-    if (!EntityWrapper(m_World, e.entityID).Valid()) { 
-        return false;
-    }
-    // If entity IsLocalPlayer, exit
-    if (e.entityID == m_LocalPlayer.ID) { 
-        return false;
-    }
-    spawnHexagon(EntityWrapper(m_World, e.entityID));
-}
-
-void PlayerMovementSystem::spawnHexagon(EntityWrapper target)
-{ 
-    //put a hexagon at the entitys... feet?
-    auto hexagonEffect = ResourceManager::Load<EntityFile>("Schema/Entities/DoubleJumpHexagon.xml");
-    EntityFileParser parser(hexagonEffect);
-    EntityID hexagonEffectID = parser.MergeEntities(m_World);
-    EntityWrapper hexagonEW = EntityWrapper(m_World, hexagonEffectID);
-    hexagonEW["Transform"]["Position"] = (glm::vec3)target["Transform"]["Position"];
-}

src/Game/Systems/PlayerSpawnSystem.cpp

@@ -15,6 +15,11 @@ PlayerSpawnSystem::PlayerSpawnSystem(SystemParams params)
 
 void PlayerSpawnSystem::Update(double dt)
 {
+    CheckForLatePlayers(dt);
+    for (auto& spawnReqs : m_SpawnRequests)
+    {
+        spawnReqs.timeSinceDeath += dt;
+    }
     //Increase timer.
     m_Timer += dt;
     if (m_Timer < m_RespawnTime) {
@@ -35,6 +40,10 @@ void PlayerSpawnSystem::Update(double dt)
 
     int numSpawnedPlayers = 0;
     for (auto& req : m_SpawnRequests) {
+        if (req.timeSinceDeath < 2.5f) {
+            m_LatePlayersVector.push_back(req);
+            continue;
+        }
         for (auto& cPlayerSpawn : *playerSpawns) {
             EntityWrapper spawner(m_World, cPlayerSpawn.EntityID);
             if (!spawner.HasComponent("Spawner")) {
@@ -111,6 +120,8 @@ bool PlayerSpawnSystem::OnInputCommand(Events::InputCommand& e)
         SpawnRequest req;
         req.PlayerID = e.PlayerID;
         req.Team = (ComponentInfo::EnumType)e.Value;
+        //set timeSinceDeath > 2.5f since we are force-spawning
+        req.timeSinceDeath = 3.0f;
         m_SpawnRequests.push_back(req);
     } else {
         return false;
@@ -134,7 +145,7 @@ bool PlayerSpawnSystem::OnPlayerSpawned(Events::PlayerSpawned& e)
         playerName["Text"]["Content"] = e.PlayerName;
     }
 
-    if (!IsClient) {
+    if (m_NetworkEnabled && !IsClient) {
         return false;
     }
 
@@ -164,6 +175,8 @@ bool PlayerSpawnSystem::OnPlayerSpawned(Events::PlayerSpawned& e)
 
 bool PlayerSpawnSystem::OnPlayerDeath(Events::PlayerDeath& e)
 {
+    LOG_INFO("<- spawnsystem death");
+
     //Only spawn request if network is disabled or we are server.
     if (!IsServer && m_NetworkEnabled) {
         return false;
@@ -177,6 +190,8 @@ bool PlayerSpawnSystem::OnPlayerDeath(Events::PlayerDeath& e)
         return false;
     }
 
+    LOG_INFO("- spawnsystem death");
+
     if (m_PlayerIDs.count(e.Player.ID) == 0) {
         return false;
     }
@@ -184,7 +199,52 @@ bool PlayerSpawnSystem::OnPlayerDeath(Events::PlayerDeath& e)
     SpawnRequest req;
     req.PlayerID = m_PlayerIDs.at(e.Player.ID);
     req.Team = cTeam["Team"];
+    req.timeSinceDeath = 0.0f;
     m_SpawnRequests.push_back(req);
+    LOG_INFO("-> spawnsystem death");
 
     return true;
 }
+void PlayerSpawnSystem::CheckForLatePlayers(double dt) {
+    for (size_t i = 0; i < m_LatePlayersVector.size(); i++)
+    {
+        auto& req = m_LatePlayersVector[i];
+        req.timeSinceDeath += dt;
+        if (req.timeSinceDeath > 2.5f) {
+            //good but, this will only spawn them in the next cycle - i.e. not immediately
+            //m_SpawnRequests.push_back(spawnReq);
+
+            //insta spawn
+            auto playerSpawns = m_World->GetComponents("PlayerSpawn");
+            for (auto& cPlayerSpawn : *playerSpawns) {
+                EntityWrapper spawner(m_World, cPlayerSpawn.EntityID);
+                if (!spawner.HasComponent("Spawner")) {
+                    continue;
+                }
+
+                // If the spawner has a team affiliation, check it
+                if (spawner.HasComponent("Team")) {
+                    if ((int)spawner["Team"]["Team"] != req.Team) {
+                        continue;
+                    }
+                }
+
+                // Spawn the player!
+                EntityWrapper player = SpawnerSystem::Spawn(spawner, EntityWrapper::Invalid, "Player");
+                // Set the player team affiliation
+                player["Team"]["Team"] = req.Team;
+
+                // Publish a PlayerSpawned event
+                Events::PlayerSpawned e;
+                e.PlayerID = req.PlayerID;
+                e.Player = player;
+                e.Spawner = spawner;
+                m_EventBroker->Publish(e);
+                break;
+            }
+            //end insta spawn
+            m_LatePlayersVector.erase(m_LatePlayersVector.begin() + i);
+            break;
+        }
+    }
+}

src/Game/Systems/Weapon/AssaultWeaponBehaviour.cpp

@@ -386,7 +386,7 @@ bool AssaultWeaponBehaviour::shoot(double damage)
 
     // Check for friendly fire
     if ((ComponentInfo::EnumType)victim["Team"]["Team"] == (ComponentInfo::EnumType)m_Player["Team"]["Team"]) {
-        return false;
+        damage = 1;
     }
 
     // Deal damage!