refactor(gameplay): rename remote player types and add interpolation

include/Cubed/gameplay/client_world.hpp

@@ -11,14 +11,15 @@
 #include <tbb/concurrent_unordered_map.h>
 namespace Cubed {
 
-struct OtherPlayerInfo {
+struct RemotePlayerInfo {
     std::string name;
-    glm::vec3 pos;
+    glm::vec3 render_pos;
+    glm::vec3 target_pos;
 };
 
-struct RenderPlayerData {
+struct RemotePlayerRenderData {
     std::string name;
-    glm::vec3 pos;
+    glm::vec3 render_pos;
 };
 
 class ClientWorld {
@@ -45,7 +46,7 @@ public:
     void receive_block_change(const BlockChangeRsp& rsp);
     void receive_time(const UpdateTime& rsp);
 
-    void receive_other_player(const PlayerInfoRsp& rsp);
+    void receive_remote_player(const PlayerInfoRsp& rsp);
     void receive_player_logout(const LogoutRsp& rsp);
     int rendering_distance() const;
     void rendering_distance(int rendering_distance);
@@ -59,7 +60,7 @@ public:
     void request_chunk();
     std::vector<glm::vec4>& planes();
     const std::vector<ChunkRenderSnapshot>& render_snapshots() const;
-    const std::vector<RenderPlayerData>& render_player_data() const;
+    const std::vector<RemotePlayerRenderData>& render_player_data() const;
     glm::vec3 sunlight_dir() const;
     void receive_chunk(ChunkDataRsp data);
     void exit();
@@ -76,7 +77,8 @@ private:
         tbb::concurrent_unordered_map<ChunkPos, ClientChunk, ChunkPos::Hash>;
     using ChunkPosSet = std::unordered_set<ChunkPos, ChunkPos::Hash>;
     using ChunkPosVector = std::vector<ChunkPos>;
-    using OtherPlayerHashMap = std::unordered_map<std::string, OtherPlayerInfo>;
+    using OtherPlayerHashMap =
+        std::unordered_map<std::string, RemotePlayerInfo>;
     ClientPlayer m_player;
     OtherPlayerHashMap m_other_players;
     ChunkHashMap m_chunks;
@@ -96,7 +98,7 @@ private:
 
     std::deque<ChunkPos> m_dirty_queue;
     std::vector<ChunkRenderSnapshot> m_render_snapshots;
-    std::vector<RenderPlayerData> m_render_player_data;
+    std::vector<RemotePlayerRenderData> m_render_player_data;
     tbb::concurrent_unordered_map<std::string, Timer> m_timers;
     std::atomic<bool> m_game_running{false};
     std::atomic<int> m_rendering_distance{24};

src/gameplay/client_world.cpp

@@ -192,12 +192,18 @@ void ClientWorld::receive_time(const UpdateTime& rsp) {
     m_day_tick = rsp.day_tick();
 }
 
-void ClientWorld::receive_other_player(const PlayerInfoRsp& rsp) {
+void ClientWorld::receive_remote_player(const PlayerInfoRsp& rsp) {
     {
         std::lock_guard lock(m_other_players_mutex);
-        m_other_players[rsp.uuid()].name = rsp.name();
+        glm::vec3 pos{rsp.pos().x(), rsp.pos().y(), rsp.pos().z()};
-        m_other_players[rsp.uuid()].pos =
+        auto it = m_other_players.find(rsp.uuid());
-            glm::vec3{rsp.pos().x(), rsp.pos().y(), rsp.pos().z()};
+        if (it == m_other_players.end()) {
+            m_other_players.emplace(
+                std::piecewise_construct, std::forward_as_tuple(rsp.uuid()),
+                std::forward_as_tuple(rsp.name(), pos, pos));
+        } else {
+            it->second.target_pos = pos;
+        }
         // Logger::info("Player {} pos Update", rsp.name());
     }
 }
@@ -509,7 +515,9 @@ void ClientWorld::update(float delta_time) {
     {
         std::lock_guard lock(m_other_players_mutex);
         for (auto& [uuid, player] : m_other_players) {
-            m_render_player_data.emplace_back(player.name, player.pos);
+            player.render_pos =
+                glm::mix(player.render_pos, player.target_pos, 0.15f);
+            m_render_player_data.emplace_back(player.name, player.render_pos);
         }
     }
 }
@@ -541,7 +549,8 @@ void ClientWorld::rendering_distance(int rendering_distance) {
 const std::vector<ChunkRenderSnapshot>& ClientWorld::render_snapshots() const {
     return m_render_snapshots;
 };
-const std::vector<RenderPlayerData>& ClientWorld::render_player_data() const {
+const std::vector<RemotePlayerRenderData>&
+ClientWorld::render_player_data() const {
     return m_render_player_data;
 }
 std::vector<glm::vec4>& ClientWorld::planes() { return m_planes; }

src/gameplay/network_client.cpp

@@ -100,7 +100,7 @@ asio::awaitable<void> NetworkClient::read_loop() {
             case to_num(PacketEnum::PLAYER_INFO_RSP): {
                 auto* rsp = Arena::Create<PlayerInfoRsp>(&arena);
                 if (decode_packet(*rsp, body_data, header)) {
-                    m_world.receive_other_player(*rsp);
+                    m_world.receive_remote_player(*rsp);
                 }
             } break;
             case to_num(PacketEnum::LOGOUT_RSP): {

src/renderer.cpp

@@ -949,8 +949,8 @@ void Renderer::render_player() {
     auto& players = m_world.render_player_data();
 
     for (auto& player : players) {
-        m_m_mat = glm::translate(glm::mat4(1.0f),
+        m_m_mat = glm::translate(
-                                 player.pos + glm::vec3(-0.5f, 0.0f, -0.5f));
+            glm::mat4(1.0f), player.render_pos + glm::vec3(-0.5f, 0.0f, -0.5f));
         m_mv_mat = m_v_mat * m_m_mat;
         shader.set_loc("mv_matrix", m_mv_mat);
         shader.set_loc("proj_matrix", m_p_mat);