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

# Conflicts:
#	include/Game/Game.h

src/Game/CMakeLists.txt

@@ -26,7 +26,9 @@ set(SOURCE_FILES
     ${SOURCE_FILES}
     "Game.cpp"
     ${SOURCE_FILES_Systems}
-	${SOURCE_FILES_Events}
+    ${SOURCE_FILES_Events}
+
+    
 )
 
 set(LIBRARIES

src/Game/Game.cpp

@@ -8,6 +8,7 @@
 #include "Systems/SpawnerSystem.h"
 #include "Systems/PlayerSpawnSystem.h"
 #include "Core/EntityFileWriter.h"
+#include "Game/Systems/CapturePointSystem.h"
 
 Game::Game(int argc, char* argv[])
 {
@@ -68,8 +69,8 @@ Game::Game(int argc, char* argv[])
 
 
     // Create Octrees
-    m_OctreeCollision = new Octree(AABB(glm::vec3(-100), glm::vec3(100)), 4);
-    m_OctreeFrustrumCulling = new Octree(AABB(glm::vec3(-100), glm::vec3(100)), 4);
+    m_OctreeCollision = new Octree<AABB>(AABB(glm::vec3(-100), glm::vec3(100)), 4);
+    m_OctreeFrustrumCulling = new Octree<AABB>(AABB(glm::vec3(-100), glm::vec3(100)), 4);
     // Create system pipeline
     m_SystemPipeline = new SystemPipeline(m_EventBroker);
 
@@ -79,6 +80,7 @@ Game::Game(int argc, char* argv[])
     m_SystemPipeline->AddSystem<EditorSystem>(updateOrderLevel, m_Renderer);
     m_SystemPipeline->AddSystem<HealthSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<PlayerMovementSystem>(updateOrderLevel);
+    m_SystemPipeline->AddSystem<InterpolationSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<SpawnerSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<PlayerSpawnSystem>(updateOrderLevel);
     // Populate Octree with collidables
@@ -89,6 +91,7 @@ Game::Game(int argc, char* argv[])
     m_SystemPipeline->AddSystem<CollisionSystem>(updateOrderLevel, m_OctreeCollision);
     m_SystemPipeline->AddSystem<TriggerSystem>(updateOrderLevel, m_OctreeCollision);
     ++updateOrderLevel;
+    m_SystemPipeline->AddSystem<CapturePointSystem>(updateOrderLevel);
     m_SystemPipeline->AddSystem<RenderSystem>(updateOrderLevel, m_Renderer, m_RenderFrame);
 
     // Invoke network
@@ -144,7 +147,6 @@ void Game::Tick()
     m_SystemPipeline->Update(m_World, dt);
     debugTick(dt);
     m_Renderer->Update(dt);
-    m_EventBroker->Process<Client>();
     m_SoundSystem->Update(dt);
     GLERROR("Game::Tick m_RenderQueueFactory->Update");
     m_Renderer->Draw(*m_RenderFrame);

src/Game/Systems/CapturePointSystem.cpp

@@ -0,0 +1,236 @@
+#include "Systems/CapturePointSystem.h"
+#include <algorithm>
+
+CapturePointSystem::CapturePointSystem(EventBroker* eventBroker)
+    : System(eventBroker),
+    PureSystem("CapturePoint")
+{
+    //subscribe/listenTo playerdamage,healthpickup events (using the eventBroker)
+    EVENT_SUBSCRIBE_MEMBER(m_ETriggerTouch, &CapturePointSystem::OnTriggerTouch);
+    EVENT_SUBSCRIBE_MEMBER(m_ETriggerLeave, &CapturePointSystem::OnTriggerLeave);
+    EVENT_SUBSCRIBE_MEMBER(m_ECaptured, &CapturePointSystem::OnCaptured);
+}
+
+//here all capturepoints will update their component
+//NOTE: needs to run each frame, since we're possibly modifying the captureTimer for the capturePoints by dt
+void CapturePointSystem::UpdateComponent(World* world, EntityWrapper& entity, ComponentWrapper& capturePoint, double dt)
+{
+    if (m_WinnerWasFound) {
+        return;
+    }
+    const int capturePointNumber = capturePoint["CapturePointNumber"];
+    const bool hasTeamComponent = world->HasComponent(capturePoint.EntityID, "Team");
+
+    //if point doesnt have a teamComponent yet, add one. since:
+    //what if capture point has no team -> we cant get/use the team enum from it...
+    if (!hasTeamComponent) {
+        world->AttachComponent(capturePoint.EntityID, "Team");
+        ComponentWrapper& teamComponent = world->GetComponent(capturePoint.EntityID, "Team");
+        teamComponent["Team"] = (int)teamComponent["Team"].Enum("Spectator");
+    }
+    ComponentWrapper& teamComponent = world->GetComponent(capturePoint.EntityID, "Team");
+    const int redTeam = (int)teamComponent["Team"].Enum("Red");
+    const int blueTeam = (int)teamComponent["Team"].Enum("Blue");
+    const int spectatorTeam = (int)teamComponent["Team"].Enum("Spectator");
+
+    int homePointForTeam = (int)capturePoint["HomePointForTeam"];
+    if (m_NumberOfCapturePoints == 0 && capturePointNumber != 0 && (homePointForTeam == redTeam || homePointForTeam == blueTeam)) {
+        m_NumberOfCapturePoints = capturePointNumber + 1;//ex 2 -> 0,1,2 = 3
+        if (homePointForTeam == redTeam) {
+            m_RedTeamHomeCapturePoint = capturePointNumber;
+            m_BlueTeamHomeCapturePoint = 0;
+        } else {
+            m_BlueTeamHomeCapturePoint = capturePointNumber;
+            m_RedTeamHomeCapturePoint = 0;
+        }
+    }
+
+    //if we havent received all capturepoints yet, just return
+    if (m_NumberOfCapturePoints == 0 || m_NumberOfCapturePoints != m_CapturePointNumberToEntityIDMap.size()) {
+        m_CapturePointNumberToEntityIDMap.insert(std::make_pair(capturePointNumber, capturePoint.EntityID));
+        return;
+    }
+
+    //we have all capturepoints now - process stuff
+    int ownedBy = teamComponent["Team"];
+    int redTeamPlayersStandingInside = 0;
+    int blueTeamPlayersStandingInside = 0;
+    if (entity.HasComponent("Model")) {
+        //Now sets team color to the capturepoint, or white if it is uncaptured.
+        entity["Model"]["Color"] = ownedBy == blueTeam ? glm::vec4(0, 0.2f, 1, 1) : ownedBy == redTeam ? glm::vec4(1, 0.2f, 0, 1) : glm::vec4(1, 1, 1, 1);
+    }
+
+    //calculate next possible capturePoint for both teams
+    std::map<std::string, int> nextPossibleCapturePoint;
+    nextPossibleCapturePoint["Red"] = -1;
+    nextPossibleCapturePoint["Blue"] = -1;
+    for (size_t i = 0; i < m_NumberOfCapturePoints; i++)
+    {
+        ComponentWrapper& capturePointOwnedBy = world->GetComponent(m_CapturePointNumberToEntityIDMap[i], "Team");
+        if ((int)capturePointOwnedBy["Team"] == redTeam && m_RedTeamHomeCapturePoint == 0) {
+            nextPossibleCapturePoint["Red"] = i + 1;
+        }
+        if ((int)capturePointOwnedBy["Team"] == blueTeam && m_BlueTeamHomeCapturePoint == 0) {
+            nextPossibleCapturePoint["Blue"] = i + 1;
+        }
+    }
+    for (int i = m_NumberOfCapturePoints - 1; i >= 0; i--)
+    {
+        ComponentWrapper& capturePointOwnedBy = world->GetComponent(m_CapturePointNumberToEntityIDMap[i], "Team");
+        if ((int)capturePointOwnedBy["Team"] == redTeam && m_RedTeamHomeCapturePoint != 0) {
+            nextPossibleCapturePoint["Red"] = i - 1;
+        }
+        if ((int)capturePointOwnedBy["Team"] == blueTeam && m_BlueTeamHomeCapturePoint != 0) {
+            nextPossibleCapturePoint["Blue"] = i - 1;
+        }
+    }
+
+    //reset timers and reset the bool that triggers this
+    if (m_ResetTimers) {
+        for (size_t i = 0; i < m_NumberOfCapturePoints; i++)
+        {
+            ComponentWrapper& capturePoint = world->GetComponent(m_CapturePointNumberToEntityIDMap[i], "CapturePoint");
+            if ((int)capturePoint["CapturePointNumber"] != nextPossibleCapturePoint["Red"] &&
+                (int)capturePoint["CapturePointNumber"] != nextPossibleCapturePoint["Blue"]) {
+                capturePoint["CaptureTimer"] = 0.0;
+            }
+        }
+        m_ResetTimers = false;
+    }
+
+    //colorize next possible capturepoint
+    if (nextPossibleCapturePoint["Red"] == capturePointNumber) {
+        entity["Model"]["Color"] = glm::vec4(1, 1, 0, 1);
+    }
+    if (nextPossibleCapturePoint["Blue"] == capturePointNumber) {
+        entity["Model"]["Color"] = glm::vec4(0, 1, 1, 1);
+    }
+
+    //check how many players are standing inside and are healthy
+    for (size_t i = m_ETriggerTouchVector.size(); i > 0; i--)
+    {
+        auto triggerTouched = m_ETriggerTouchVector[i - 1];
+        if (std::get<1>(triggerTouched) == capturePoint.EntityID) {
+            //some player has touched this - lets figure out: what team, health
+            EntityID playerID = std::get<0>(triggerTouched);
+            if (!world->HasComponent(playerID, "Player")) {
+                //if a non-player has entered the capturePoint, just erase that event and continue
+                m_ETriggerTouchVector.erase(m_ETriggerTouchVector.begin() + i - 1);
+                continue;
+            }
+            bool hasHealthComponent = world->HasComponent(playerID, "Health");
+            if (hasHealthComponent) {
+                double currentHealth = world->GetComponent(playerID, "Health")["Health"];
+                //check if player is dead
+                if ((int)currentHealth == 0) {
+                    continue;
+                }
+            }
+            //check team - spectatorNumber = "no team"
+            int teamNumber = world->GetComponent(playerID, "Team")["Team"];
+            if (teamNumber == redTeam) {
+                redTeamPlayersStandingInside++;
+            } else if (teamNumber == blueTeam) {
+                blueTeamPlayersStandingInside++;
+            }
+            continue;
+        }
+    }
+
+    //create data to be used in option B
+    //check so this is the next possible capture point for the take-over team and see if only one team is standing inside it
+    double timerDeltaChange = 0.0;
+    int currentTeam = 0;
+    bool canCapture = false;
+    if (redTeamPlayersStandingInside > 0 && blueTeamPlayersStandingInside == 0) {
+        timerDeltaChange = redTeamPlayersStandingInside*dt;
+        currentTeam = redTeam;
+        canCapture = nextPossibleCapturePoint["Red"] == capturePointNumber;
+    }
+    if (redTeamPlayersStandingInside == 0 && blueTeamPlayersStandingInside > 0) {
+        timerDeltaChange = -blueTeamPlayersStandingInside*dt;
+        currentTeam = blueTeam;
+        canCapture = nextPossibleCapturePoint["Blue"] == capturePointNumber;
+    }
+
+    if (redTeamPlayersStandingInside == 0 && blueTeamPlayersStandingInside == 0) {
+        //A.nobodys standing inside
+        //do nothing (?)
+    } else if (redTeamPlayersStandingInside > 0 && blueTeamPlayersStandingInside > 0) {
+        //C.both teams have players inside
+        //do nothing (?)
+    } else {
+        //B. at most one of the teams have players inside
+        //if capturePoint is not owned by the take-over team, just modify the CaptureTimer accordingly
+        if (ownedBy != currentTeam && canCapture) {
+            if (abs((double)capturePoint["CaptureTimer"]) < 0.001f) {
+                LOG_DEBUG("Point is being captured by team %i", currentTeam);   //Remove when we tested sufficiently.
+            }
+            capturePoint["CaptureTimer"] = (double)capturePoint["CaptureTimer"] + timerDeltaChange;
+        }
+        //if capturePoint is owned by the team, and the other team has been trying to take it, then increase/decrease the timer towards 0.0
+        if ((ownedBy == currentTeam && currentTeam == redTeam && (double)capturePoint["CaptureTimer"] < 0.0) ||
+            (ownedBy == currentTeam && currentTeam == blueTeam && (double)capturePoint["CaptureTimer"] > 0.0)) {
+            capturePoint["CaptureTimer"] = (double)capturePoint["CaptureTimer"] + timerDeltaChange;
+        }
+        //check if captureTimer > m_CaptureTimeToTakeOver and if so change owner and publish the eCaptured event
+        if (abs((double)capturePoint["CaptureTimer"]) > abs(m_CaptureTimeToTakeOver) && canCapture) {
+            teamComponent["Team"] = currentTeam;
+            capturePoint["CaptureTimer"] = 0.0;
+            //publish Captured event
+            LOG_DEBUG("Point is captured by team %i!", currentTeam);    //Remove when we tested sufficiently.
+            Events::Captured e;
+            e.CapturePointID = capturePoint.EntityID;
+            e.TeamNumberThatCapturedCapturePoint = currentTeam;
+            m_EventBroker->Publish(e);
+            //NextPossibleCapturePoint will be calculated in the next update...
+        }
+    }
+
+    //check for possible winCondition = check if the homebase is owned by the other team
+    bool checkForWinner = false;
+    if (capturePointNumber == m_RedTeamHomeCapturePoint && ownedBy != redTeam)
+    {
+        checkForWinner = true;
+    }
+    if (capturePointNumber == m_BlueTeamHomeCapturePoint && ownedBy != blueTeam)
+    {
+        checkForWinner = true;
+    }
+
+    if (checkForWinner && !m_WinnerWasFound)
+    {
+        //publish Win event
+        Events::Win e;
+        e.TeamThatWon = ownedBy;
+        m_EventBroker->Publish(e);
+        m_WinnerWasFound = true;
+    }
+
+}
+
+bool CapturePointSystem::OnTriggerTouch(const Events::TriggerTouch& e)
+{
+    //personEntered = e.Entity, thingEntered = e.Trigger
+    m_ETriggerTouchVector.push_back(std::make_tuple(e.Entity, e.Trigger));
+    return true;
+}
+
+bool CapturePointSystem::OnTriggerLeave(const Events::TriggerLeave& e)
+{
+    for (size_t i = 0; i < m_ETriggerTouchVector.size(); i++)
+    {
+        auto triggerTouched = m_ETriggerTouchVector[i];
+        if (std::get<0>(triggerTouched) == e.Entity && std::get<1>(triggerTouched) == e.Trigger) {
+            m_ETriggerTouchVector.erase(m_ETriggerTouchVector.begin() + i);
+            break;
+        }
+    }
+    return true;
+}
+bool CapturePointSystem::OnCaptured(const Events::Captured& e)
+{
+    //reset the timers in the next update since a capture has changed the "nextCapturePoint" for 1-2 teams
+    m_ResetTimers = true;
+    return true;
+}

src/Game/Systems/HealthSystem.cpp

@@ -12,7 +12,6 @@ HealthSystem::HealthSystem(EventBroker* eventBroker)
 void HealthSystem::UpdateComponent(World* world, EntityWrapper& entity, ComponentWrapper& component, double dt)
 {
     //if entityID of health is 9 then the players ID is also 9 (player,health are connected to the same entity)
-    ComponentWrapper player = world->GetComponent(component.EntityID, "Player");
     double maxHealth = (double)component["MaxHealth"];
 
     //process the DeltaHealthVector and change the entitys health accordingly
@@ -20,21 +19,22 @@ void HealthSystem::UpdateComponent(World* world, EntityWrapper& entity, Componen
     {
         auto deltaHP = m_DeltaHealthVector[i - 1];
         //if we have a healthchange for the current player and health is greater than 0, then apply it
-        if (std::get<0>(deltaHP) == player.EntityID && (double)component["Health"] > 0.0f) {
+        if (std::get<0>(deltaHP) == component.EntityID && (double)component["Health"] > 0.0f) {
             //get the deltaHP value from the tuple and make sure you dont get more than maxHealth
             double newHealth = std::min((double)component["Health"] + (double)std::get<1>(deltaHP), maxHealth);
             component["Health"] = newHealth;
             m_DeltaHealthVector.erase(m_DeltaHealthVector.begin() + i - 1);
             //check if health is <= 0
             if ((double)component["Health"] <= 0.0f) {
+                component["Health"] = 0.0;
                 //publish death event
                 Events::PlayerDeath e;
-                e.PlayerID = player.EntityID;
+                e.PlayerID = component.EntityID;
                 m_EventBroker->Publish(e);
                 //clear the remaining hpDeltas for the dead player
                 for (size_t j = m_DeltaHealthVector.size(); j > 0; j--)
                 {
-                    if (std::get<0>(m_DeltaHealthVector[j - 1]) == player.EntityID)
+                    if (std::get<0>(m_DeltaHealthVector[j - 1]) == component.EntityID)
                         m_DeltaHealthVector.erase(m_DeltaHealthVector.begin() + j - 1);
                 }
                 //break the loop if the player is dead

src/Game/Systems/InterpolationSystem.cpp

@@ -0,0 +1,86 @@
+#include "Systems/InterpolationSystem.h"
+
+//void InterpolationSystem::UpdateComponent(World * world, ComponentWrapper & transform, double dt)
+//{
+//    if (m_InterpolationPoints[transform.EntityID].size() > 0) {
+//        Transform& sTransform = m_InterpolationPoints[transform.EntityID].front();
+//        sTransform.interpolationTime += dt;
+//        if (sTransform.interpolationTime > 0.05) {
+//            double time = std::fmod(sTransform.interpolationTime, 0.05f);
+//            m_InterpolationPoints[transform.EntityID].pop();
+//            if (m_InterpolationPoints[transform.EntityID].size() <= 0) {
+//                return;
+//            }
+//            sTransform = m_InterpolationPoints[transform.EntityID].front();
+//            sTransform.interpolationTime = time;
+//        }
+//        glm::vec3 nextPosition = sTransform.Position;
+//        glm::vec3 currentPosition = static_cast<glm::vec3>(transform["Position"]);
+//        transform["Position"] = vectorInterpolation(currentPosition, nextPosition, sTransform.interpolationTime);
+//    }
+//}
+
+void InterpolationSystem::UpdateComponent(World * world, EntityWrapper& entity, ComponentWrapper & transform, double dt)
+{
+    if (m_NextTransform.find(transform.EntityID) != m_NextTransform.end()) { // Exists in map
+        m_NextTransform[transform.EntityID].interpolationTime += dt;
+        Transform sTransform = m_NextTransform[transform.EntityID];
+        double time = sTransform.interpolationTime;
+        if (time > SNAPSHOTINTERVAL) {
+            if (m_LastReceivedTransform.find(transform.EntityID) != m_LastReceivedTransform.end()) {
+                m_NextTransform[transform.EntityID] = m_LastReceivedTransform[transform.EntityID];
+                m_NextTransform[transform.EntityID].interpolationTime = time - SNAPSHOTINTERVAL;
+                sTransform = m_NextTransform[transform.EntityID];
+                m_LastReceivedTransform.erase(transform.EntityID);
+            } else {
+                m_NextTransform.erase(transform.EntityID);
+            }
+        }
+        if (transform.Info.Name == "Transform") {
+            // Position
+            glm::vec3 nextPosition = sTransform.Position;
+            glm::vec3 currentPosition = static_cast<glm::vec3>(transform["Position"]);
+            (glm::vec3&)transform["Position"] += vectorInterpolation<glm::vec3>(currentPosition, nextPosition, sTransform.interpolationTime);
+            // Orientation
+            glm::quat nextOrientation = sTransform.Orientation;
+            glm::quat currentOrientation = glm::quat(static_cast<glm::vec3>(transform["Orientation"]));
+            (glm::vec3&)transform["Orientation"] = glm::eulerAngles(glm::slerp<float>(currentOrientation, nextOrientation, sTransform.interpolationTime / SNAPSHOTINTERVAL));
+            // Scale
+            glm::vec3 nextScale = sTransform.Scale;
+            glm::vec3 currentScale = static_cast<glm::vec3>(transform["Scale"]);
+            (glm::vec3&)transform["Scale"] += vectorInterpolation<glm::vec3>(currentScale, nextScale, sTransform.interpolationTime);
+        }
+    }
+}
+
+bool InterpolationSystem::OnInterpolate(const Events::Interpolate & e)
+{
+    Transform transform;
+    int offset = 0;
+    // Read the data
+    memcpy(&transform.Position, e.DataArray.get() + offset, sizeof(glm::vec3));
+    offset += sizeof(glm::vec3);
+    glm::vec3 tempOrientation;
+    memcpy(&tempOrientation, e.DataArray.get() + offset, sizeof(glm::vec3));
+    transform.Orientation = glm::quat(tempOrientation);
+    offset += sizeof(glm::vec3);
+    memcpy(&transform.Scale, e.DataArray.get() + offset, sizeof(glm::vec3));
+    transform.interpolationTime = 0.0f;
+
+    if (m_NextTransform.find(e.Entity) != m_NextTransform.end()) { // Did exist
+        m_LastReceivedTransform[e.Entity] = transform;
+    } else { // Did not
+        m_NextTransform[e.Entity] = transform;
+    }
+    // Check if queue already exists
+    //if (m_InterpolationPoints.find(e.Entity) != m_InterpolationPoints.end()) { // Did exist, push to queue
+    //    m_InterpolationPoints[e.Entity].push(transform);
+    //} 
+
+    //else { // Did not exist, create queue
+    //    std::queue<Transform> transformQueue;
+    //    transformQueue.push(transform);
+    //    m_InterpolationPoints[e.Entity] = transformQueue;
+    //}
+    return false;
+}

src/Game/Systems/PlayerMovementSystem.cpp

@@ -9,7 +9,9 @@ void PlayerMovementSystem::UpdateComponent(World* world, EntityWrapper& entity,
     ComponentWrapper& cPhysics = entity["Physics"];
 
     glm::vec3& velocity = cPhysics["Velocity"];
-    velocity.y -= 9.82 * dt;
+    if (cPhysics["Gravity"]) {
+        velocity.y -= 9.82 * dt;
+    }
 
     glm::vec3& position = cTransform["Position"];
     position += velocity * (float)dt;