refactor, another way to store & transfer objects

include/Actor.hpp

@@ -23,7 +23,7 @@ namespace Actor
         Actor(const Actor&);
         Actor(const sf::Vector2f& position, const std::unordered_map<Object::ObjectName, size_t>& inventory);
         Actor(sf::Vector2f&& position, std::unordered_map<Object::ObjectName, size_t>&& inventory);
-        sf::Vector2f&& move_dt(const sf::Vector2f& direction, const sf::Uint32& dt, const WorldMap::ObjectMap& ObjectMap = {});
+        sf::Vector2f&& move_dt(const sf::Vector2f& direction, const sf::Uint32& dt, WorldMap::ObjectMap& ObjectMap);
         void check_direction(const sf::Vector2f&);
         const sf::Vector2f& getPosition() const;
         const sf::Sprite& getSprite() const;
@@ -54,7 +54,7 @@ namespace Actor
     {
     public:
         using Actor::Actor;
-        void make_step(const sf::Uint32& dt, const WorldMap::ObjectMap& ObjectMap = {});
+        void make_step(const sf::Uint32& dt, WorldMap::ObjectMap& ObjectMap);
 
     private:
         sf::Vector2f prev_move_direction = linalg::normalize(sf::Vector2f(std::rand() % 10 - 10 / 2, std::rand() % 10 - 10 / 2));
@@ -70,7 +70,7 @@ namespace Actor
     public:
         User(const sf::Vector2f& position, const std::unordered_map<Object::ObjectName, size_t>& inventory = {});
         User(sf::Vector2f&& position, std::unordered_map<Object::ObjectName, size_t>&& inventory = {});
-        sf::Vector2f&& move_dt(const sf::Vector2f& direction, const sf::Uint32& dt, const WorldMap::ObjectMap& ObjectMap = {});
+        sf::Vector2f&& move_dt(const sf::Vector2f& direction, const sf::Uint32& dt, WorldMap::ObjectMap& ObjectMap);
         const sf::View& getView() const;
         const int& getIp() const;
         const int& getLocalIp() const;        

include/LinearAlgebra.hpp

@@ -6,7 +6,14 @@
 
 namespace linalg
 {
-    sf::Vector2f normalize(const sf::Vector2f& v);
+    inline float magnitude(const sf::Vector2f& v) {
+        return std::sqrt(v.x * v.x + v.y * v.y);
+    }
+
+
+    inline sf::Vector2f normalize(const sf::Vector2f& v) {
+        return v == sf::Vector2f(0.f, 0.f) ? v : v / magnitude(v);
+    }
 
     /*Vector2<T>& rotateBy(float degrees, const Vector2<T>& center=Vector2<T>())
     {
@@ -47,6 +54,4 @@ namespace linalg
             else
                 return 180.0+atan(-y/-x) * 180.f/3.14159f;
     }*/
-
-    float magnitude(const sf::Vector2f& v);
 }

include/Multiplayer.hpp

@@ -10,6 +10,7 @@
 #include <string>
 #include <chrono>
 #include <unordered_map>
+#include <vector>
 #include <cmath>
 
 
@@ -88,6 +89,7 @@ namespace Multiplayer
         ObjectData(sf::Vector2f position, sf::Uint32 time, Object::ObjectName object_name, Object::Passability passability);
         const Object::ObjectName& getName() const;
         const Object::Passability& getPassability() const;
+        inline bool operator ==(const ObjectData& object_data) const { return object_name == object_data.getName() && passability == object_data.getPassability(); }
 
     private:
         Object::ObjectName object_name;
@@ -105,9 +107,10 @@ namespace Multiplayer
         sf::Socket::Status receive();
         sf::Socket::Status send(sf::Packet& packet, const sf::IpAddress& dest_ip = sf::IpAddress());
         const std::unordered_map<std::string, PlayerData>& getPlayerDataPool() const;
-        const std::unordered_map<sf::Vector2f, ObjectData>& getObjectDataPool() const;
+        const std::unordered_map<sf::Vector2f, std::vector<ObjectData>>& getObjectDataPool() const;
+        inline void clearObjectDataPool() { object_data_pool.clear();}
         std::unordered_map<std::string, PlayerData>::iterator removePlayerById(const std::string& id);
-        std::unordered_map<sf::Vector2f, ObjectData>::iterator removeObjectByPoint(const sf::Vector2f& point);
+        std::unordered_map<sf::Vector2f, std::vector<ObjectData>>::iterator removeObjectByPoint(const ObjectData& point);
         void addObject(const Object::Object& object);
         void addObject(const Multiplayer::ObjectData& object_data);
         ObjectData getRemovedObjectData();
@@ -123,7 +126,8 @@ namespace Multiplayer
         /*static*/ unsigned short port;
         /*static*/ unsigned short port_send;
         /*static*/ std::unordered_map<std::string, PlayerData> player_data_pool;
-        /*static*/ std::unordered_map<sf::Vector2f, ObjectData> object_data_pool;
+        /*static*/ std::unordered_map<sf::Vector2f, std::vector<ObjectData>> object_data_pool;
+        /*static*/ /* std::unordered_map<sf::Vector2f, ObjectData> terrain_data_pool; */
         /*static*/ std::vector<ObjectData> removed_object_data_list;
         /*static*/ std::vector<ObjectData> objects_to_inventory_list;
         #ifndef CLIENT

include/WorldMap.hpp

@@ -39,10 +39,9 @@ namespace WorldMap
     {
     public:
         ObjectMap();
-        const std::unordered_map<sf::Vector2f, Object::Object>& getObjectMap(const Object::Passability&) const;
+        std::unordered_map<sf::Vector2f, Object::Object>& getObjectMap(const Object::Passability&);
         void addObject(const Multiplayer::ObjectData&);
         void removeObject(const Multiplayer::ObjectData&);
-        void removeObject(const Object::Object&);
 
     private:
         std::unordered_map<sf::Vector2f, Object::Object> background_objects;

src/Actor.cpp

@@ -51,11 +51,12 @@ namespace Actor
     }
 
 
-    sf::Vector2f&& Actor::move_dt(const sf::Vector2f& direction, const sf::Uint32& dt, const WorldMap::ObjectMap& ObjectMap)
+    sf::Vector2f&& Actor::move_dt(const sf::Vector2f& direction, const sf::Uint32& dt, WorldMap::ObjectMap& ObjectMap)
     {
         check_direction(direction); 
         auto v = new sf::Vector2f(linalg::normalize(direction) * static_cast<float>(dt) * Constants::getSTEP_SIZE_MULTIPLIER() * static_cast<float>(Constants::getPIXEL_SIZE()));
-        for (const auto& object : ObjectMap.getObjectMap(Object::Passability::impassible))
+        const auto& im = ObjectMap.getObjectMap(Object::Passability::impassible);
+        for (const auto& object : im)
         {
             object.second.check_collision(*v, this->getSprite().getGlobalBounds());
         }
@@ -109,7 +110,7 @@ namespace Actor
     }
 
 
-    sf::Vector2f&& User::move_dt(const sf::Vector2f& direction, const sf::Uint32& dt, const WorldMap::ObjectMap& ObjectMap)
+    sf::Vector2f&& User::move_dt(const sf::Vector2f& direction, const sf::Uint32& dt, WorldMap::ObjectMap& ObjectMap)
     {
         auto v = new sf::Vector2f(Actor::move_dt(direction, dt, ObjectMap));
         view.move(*v);
@@ -140,7 +141,7 @@ namespace Actor
     }
 
 
-    void Bot::make_step(const sf::Uint32& dt, const WorldMap::ObjectMap& ObjectMap)
+    void Bot::make_step(const sf::Uint32& dt, WorldMap::ObjectMap& ObjectMap)
     {
         prev_move_direction = linalg::normalize(linalg::normalize(sf::Vector2f(std::rand() % 11 - 11 / 2, std::rand() % 11 - 11 / 2)) * .2f + prev_move_direction * .8f);
         move_dt(prev_move_direction, dt, ObjectMap);

src/Controls.cpp

@@ -134,7 +134,7 @@ void Controls::addEvent(const sf::Event& event)
 
 sf::Vector2f Controls::getDirection()
 {
-    return linalg::normalize(sf::Vector2f(right * 1.f - left * 1.f, down * 1.f - up * 1.f));
+    return linalg::normalize(sf::Vector2f((right ? 1.f : 0.f) - (left ? 1.f : 0.f), (down ? 1.f : 0.f) - (up ? 1.f : 0.f)));
 }
 
 
@@ -230,30 +230,32 @@ void Controls::handleFrameStep()
     // handling player_data_pool
     for (auto iter = udp_manager.getPlayerDataPool().begin(); iter != udp_manager.getPlayerDataPool().end();)
     {
-        auto time = (*iter).second.getTime();
+        auto time = iter->second.getTime();
         sf::Uint32 time_now = static_cast<sf::Uint32>(std::chrono::duration_cast<std::chrono::milliseconds>(std::chrono::high_resolution_clock::now().time_since_epoch()).count());
         int ping = static_cast<int>(time_now) - static_cast<int>(time);
-        if (!player_pool.count((*iter).first))
+        if (!player_pool.count(iter->first))
         {
-            player_pool[(*iter).first] = Actor::Player((*iter).second);
+            player_pool[iter->first] = Actor::Player(iter->second);
             ++iter;
             continue;
         }
         else if (ping > Constants::getMAX_PING())
         {
-            player_pool.erase((*iter).first);
-            udp_manager.removePlayerById((*iter++).first);
+            player_pool.erase(iter->first);
+            udp_manager.removePlayerById(iter++->first);
             continue;
         }
         else
         {
-            player_pool[(*iter).first] << (*iter).second;
+            player_pool[iter->first] << iter->second;
             ++iter;
             continue;
         }
     }
-    for (auto iter = udp_manager.getObjectDataPool().begin(); iter != udp_manager.getObjectDataPool().end(); ++iter)
-        Controls::object_map.addObject((*iter).second);
+    for (auto& pair : udp_manager.getObjectDataPool())
+        for (auto& obj : pair.second)
+            object_map.addObject(obj);
+    Controls::udp_manager.clearObjectDataPool();
     for (auto object_data = udp_manager.getRemovedObjectData(); object_data.getTime() != 0; object_data = udp_manager.getRemovedObjectData())
         Controls::object_map.removeObject(object_data);
     for (auto object_data = udp_manager.getObjectToInventoryData(); object_data.getTime() != 0; object_data = udp_manager.getObjectToInventoryData())
@@ -270,15 +272,82 @@ void Controls::handleFrameStep()
     window.clear();
     // Draw the sprite
     //window.draw(WorldMap::WorldMap::map);
-    for (auto iter : object_map.getObjectMap(Object::Passability::background))
-        window.draw(iter.second);
-    for (auto iter : object_map.getObjectMap(Object::Passability::impassible))
-        Controls::window.draw(iter.second);
+    auto& bm = object_map.getObjectMap(Object::Passability::background);
+    for (auto iter = bm.begin(); iter != bm.end();) {
+        const auto& position = iter->second.getPosition();
+        const auto& it_size = iter->second.getSprite().getGlobalBounds().getSize();
+        const auto& center = window.getView().getCenter();
+        const auto& size = window.getView().getSize();
+        if (position.x + it_size.x < center.x - size.x / 2.f ||
+            position.x > center.x + size.x / 2.f ||
+            position.y + it_size.y < center.y - size.y / 2.f ||
+            position.y > center.y + size.y / 2.f) {
+                iter = bm.erase(iter);
+                continue;
+            }
+        /* auto text = sf::Text(std::to_string(static_cast<int>(position.x / Constants::getPIXEL_SIZE())) + " " + std::to_string(static_cast<int>(position.y / Constants::getPIXEL_SIZE())), font);
+        text.setFillColor(sf::Color::White);
+        text.setPosition(position + size / 2.f);
+        window.draw(text); */
+
+        window.draw(iter->second);
+        ++iter;
+    }
+    auto& im = object_map.getObjectMap(Object::Passability::impassible);
+    for (auto iter = im.begin(); iter != im.end();) {
+        const auto& position = iter->second.getPosition();
+        const auto& it_size = iter->second.getSprite().getGlobalBounds().getSize();
+        const auto& center = window.getView().getCenter();
+        const auto& size = window.getView().getSize();
+        if (position.x + it_size.x < center.x - size.x / 2.f ||
+            position.x > center.x + size.x / 2.f ||
+            position.y + it_size.y < center.y - size.y / 2.f ||
+            position.y > center.y + size.y / 2.f) {
+                iter = im.erase(iter);
+                continue;
+            }
+        /* auto text = sf::Text(std::to_string(static_cast<int>(position.x / Constants::getPIXEL_SIZE())) + " " + std::to_string(static_cast<int>(position.y / Constants::getPIXEL_SIZE())), font);
+        text.setFillColor(sf::Color::White);
+        text.setPosition(position + size / 2.f);
+        window.draw(text); */
+
+        window.draw(iter->second);
+        ++iter;
+    }
     for (const auto& player : player_pool)
         Controls::window.draw(player.second.getSprite());
     Controls::window.draw(user.getSprite());
-    for (auto iter : object_map.getObjectMap(Object::Passability::foreground))
-        window.draw(iter.second);
+    auto& fm = object_map.getObjectMap(Object::Passability::foreground);
+    for (auto iter = fm.begin(); iter != fm.end();) {
+        const auto& position = iter->second.getPosition();
+        const auto& it_size = iter->second.getSprite().getGlobalBounds().getSize();
+        const auto& center = window.getView().getCenter();
+        const auto& size = window.getView().getSize();
+        if (position.x + it_size.x < center.x - size.x / 2.f ||
+            position.x > center.x + size.x / 2.f ||
+            position.y + it_size.y < center.y - size.y / 2.f ||
+            position.y > center.y + size.y / 2.f) {
+                iter = fm.erase(iter);
+                continue;
+            }
+        /* auto text = sf::Text(std::to_string(static_cast<int>(position.x / Constants::getPIXEL_SIZE())) + " " + std::to_string(static_cast<int>(position.y / Constants::getPIXEL_SIZE())), font);
+        text.setFillColor(sf::Color::White);
+        text.setPosition(position + size / 2.f);
+        window.draw(text); */
+
+        window.draw(iter->second);
+        ++iter;
+    }
+    {
+        const auto& bm = object_map.getObjectMap(Object::Passability::background);
+        const auto& im = object_map.getObjectMap(Object::Passability::impassible);
+        const auto& fm = object_map.getObjectMap(Object::Passability::foreground);
+        const auto& odp = udp_manager.getObjectDataPool();
+        auto text = sf::Text(std::to_string(bm.size()) + " " + std::to_string(im.size()) + " " + std::to_string(fm.size()) + " " + std::to_string(odp.size()), font);
+        text.setFillColor(sf::Color::White);
+        text.setPosition(window.getView().getCenter() - window.getView().getSize() / 2.f);
+        window.draw(text);
+    }
     // Draw the string
     //window.draw(text);
     window.setView(user.getView());

src/LinearAlgebra.cpp

@@ -1,20 +1,2 @@
 #include "LinearAlgebra.hpp"
 
-
-sf::Vector2f linalg::normalize(const sf::Vector2f& v)
-{
-    float m = magnitude(v);
-    if (m == 0)
-        return v;
-    m = (1.f / m);
-
-    return v * m;
-}
-
-
-float linalg::magnitude(const sf::Vector2f& v)
-{
-    auto x = static_cast<float>(v.x);
-    auto y = static_cast<float>(v.y);
-    return std::sqrt(x * x + y * y);
-}