Revert "Shadows"

Shadows

include/Engine/Network/Packet.h

@@ -24,9 +24,7 @@ public:
     {
         // Check if we are trying to add more than the package can fit.
         if (m_MaxPacketSize < m_Offset + sizeof(T)) {
-            if (m_MaxPacketSize >= 32000) {
-                LOG_WARNING("Package::WritePrimitive(): New size is huge %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));

src/Engine/Collision/CollisionSystem.cpp

@@ -17,107 +17,105 @@ void CollisionSystem::UpdateComponent(EntityWrapper& entity, ComponentWrapper& c
     EntityAABB& boxA = *boundingBox;
     bool everHitTheGround = false;
 
-    if (entity == LocalPlayer) {
-        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) {
+    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;
+                }
+                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 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;
+                    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;
                 }
             }
         }
+    }
 
-        // Collide against octree items
-        m_OctreeResult.clear();
-        m_Octree->ObjectsInSameRegion(*boundingBox, m_OctreeResult);
-        for (auto& boxB : m_OctreeResult) {
-            glm::vec3 resolutionVector;
-            if (boxA.Entity == boxB.Entity) {
+    // Collide against octree items
+    m_OctreeResult.clear();
+    m_Octree->ObjectsInSameRegion(*boundingBox, m_OctreeResult);
+    for (auto& boxB : m_OctreeResult) {
+        glm::vec3 resolutionVector;
+        if (boxA.Entity == boxB.Entity) {
+            continue;
+        }
+
+        if (boxB.Entity.HasComponent("Model") && Collision::AABBVsAABB(boxA, boxB)) {
+            //Here we know boxB is a entity with Collideable, AABB, and Model.
+            RawModel* model;
+            try {
+                model = ResourceManager::Load<RawModel, true>(boxB.Entity["Model"]["Resource"]);
+            } catch (const std::exception&) {
                 continue;
             }
 
-            if (boxB.Entity.HasComponent("Model") && Collision::AABBVsAABB(boxA, boxB)) {
-                //Here we know boxB is a entity with Collideable, AABB, and Model.
-                RawModel* model;
-                try {
-                    model = ResourceManager::Load<RawModel, true>(boxB.Entity["Model"]["Resource"]);
-                } catch (const std::exception&) {
-                    continue;
-                }
+            glm::mat4 modelMatrix = Transform::ModelMatrix(boxB.Entity);
 
-                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)) {
-                    //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;
-                        (bool)cPhysics["IsOnGround"] = true;
-                    }
-                }
-            } else if (Collision::AABBVsAABB(boxA, boxB, resolutionVector)) {
-                //Enter here if boxB has no Model.
-                (glm::vec3&)cTransform["Position"] += resolutionVector;
+            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)) {
+                //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);
-                if (resolutionVector.y > 0) {
+                cPhysics["Velocity"] = inOutVelocity;
+                if (isOnGround) {
                     everHitTheGround = true;
                     (bool)cPhysics["IsOnGround"] = true;
-                    ((glm::vec3&)cPhysics["Velocity"]).y = 0.f;
                 }
             }
+        } 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;
+                ((glm::vec3&)cPhysics["Velocity"]).y = 0.f;
+            }
         }
-
-        //This should apply air friction and such, iff zero models were hit.
-        if (!everHitTheGround) {
-            (bool)cPhysics["IsOnGround"] = false;
-        }
-
-        m_PrevPositions[entity] = boxA.Origin();
     }
+
+    //This should apply air friction and such, iff zero models were hit.
+    if (!everHitTheGround) {
+        (bool)cPhysics["IsOnGround"] = false;
+    }
+
+    m_PrevPositions[entity] = boxA.Origin();
 }

src/Engine/Network/Packet.cpp

@@ -49,24 +49,18 @@ void Packet::WriteString(const std::string& str)
     // Message, add one extra byte for null terminator
     size_t sizeOfString = str.size() + 1;
     if (m_Offset + sizeOfString > m_MaxPacketSize) {
-        if (m_MaxPacketSize >= 32000) {
-            LOG_WARNING("Package::WriteString(): New size is huge %i bytes\n", m_MaxPacketSize*2);
-        }
+        //LOG_WARNING("Package::WriteString(): Data size in packet exceeded maximum package size. New size is %i bytes\n", m_MaxPacketSize*2);
         resizeData();
     }
-    memcpy(m_Data + m_Offset, str.data(), str.size() * sizeof(char));
-    m_Offset += str.size() * sizeof(char);
-    m_Data[m_Offset] = '\0';
-    m_Offset += 1;
+    memcpy(m_Data + m_Offset, str.data(), sizeOfString * sizeof(char));
+    m_Offset += sizeOfString * sizeof(char);
 }
 
 void Packet::WriteData(char * data, int sizeOfData)
 {
 
     if (m_Offset + sizeOfData > m_MaxPacketSize) {
-        if (m_MaxPacketSize >= 32000) {
-            LOG_WARNING("Package::WriteData(): New size is huge %i bytes\n", m_MaxPacketSize*2);
-        }
+        //LOG_WARNING("Packet::WriteData(): Data size in packet exceeded maximum packet size. New size is %i bytes\n", m_MaxPacketSize*2);
         while (m_Offset + sizeOfData > m_MaxPacketSize) {
             resizeData();
         }

src/Engine/Network/TCPClient.cpp

@@ -74,10 +74,7 @@ size_t TCPClient::readBuffer()
         boost::asio::ip::tcp::socket::message_peek, error);
     unsigned int sizeOfPacket = 0;
     memcpy(&sizeOfPacket, m_ReadBuffer, sizeof(int));
-    if (sizeOfPacket > m_Socket->available()) {
-        LOG_WARNING("TCPClient::readBuffer(): We haven't got the whole packet yet.");
-        return 0;
-    }
+
     // if the buffer is to small increase the size of it
     // TODO if message is huge 1 time the buffer will not decrease.
     if (sizeOfPacket > m_BufferSize) {

src/Engine/Network/TCPServer.cpp

@@ -106,10 +106,7 @@ int TCPServer::readBuffer(PlayerDefinition & playerDefinition)
         boost::asio::ip::tcp::socket::message_peek, error);
     unsigned int sizeOfPacket = 0;
     memcpy(&sizeOfPacket, m_ReadBuffer, sizeof(int));
-    if (sizeOfPacket > playerDefinition.TCPSocket->available()) {
-        LOG_WARNING("TCPServer::readBuffer(): We haven't got the whole packet yet.");
-        return 0;
-    }
+
     // if the buffer is to small increase the size of it
     if (sizeOfPacket > m_BufferSize) {
         delete[] m_ReadBuffer;

src/Engine/Network/UDPClient.cpp

@@ -45,10 +45,7 @@ int UDPClient::readBuffer()
          boost::asio::ip::udp::socket::message_peek, error);
     int sizeOfPacket = 0;
     memcpy(&sizeOfPacket, m_ReadBuffer, sizeof(int));
-    if (sizeOfPacket > m_Socket->available()) {
-        LOG_WARNING("UDPClient::readBuffer(): We haven't got the whole packet yet.");
-        //return 0;
-    }
+
     // if the buffer is to small increase the size of it
     if (sizeOfPacket > m_BufferSize) {
         delete[] m_ReadBuffer;

src/Engine/Network/UDPServer.cpp

@@ -92,11 +92,6 @@ int UDPServer::readBuffer()
     unsigned int sizeOfPacket = 0;
     memcpy(&sizeOfPacket, m_ReadBuffer, sizeof(int));
 
-    if (sizeOfPacket > m_Socket->available()) {
-        LOG_WARNING("UDPServer::readBuffer(): We haven't got the whole packet yet.");
-        //return 0;
-    }
-
     // if the buffer is to small increase the size of it
     if (sizeOfPacket > m_BufferSize) {
         delete[] m_ReadBuffer;

src/Game/Systems/PlayerMovementSystem.cpp

@@ -18,9 +18,14 @@ PlayerMovementSystem::~PlayerMovementSystem()
 void PlayerMovementSystem::Update(double dt)
 {
     updateMovementControllers(dt);
-    // Only do physics calculations on client and only for themselves.
-    if (IsClient && LocalPlayer.Valid()) {
-        updateVelocity(LocalPlayer, dt);
+    if (IsServer) {
+        for (auto& kv : m_PlayerInputControllers) {
+            updateVelocity(kv.first, dt);
+        }
+    } else {
+        if (LocalPlayer.Valid()) {
+            updateVelocity(LocalPlayer, dt);
+        }
     }
 }