제출 버전

Client/CMakeLists.txt

@@ -47,6 +47,14 @@ FetchContent_Declare(
 )
 FetchContent_MakeAvailable(ASSIMP)
 
+FetchContent_Declare(
+    JSONCPP
+    GIT_REPOSITORY "https://github.com/open-source-parsers/jsoncpp.git"
+    GIT_TAG "1.9.6"
+    GIT_SHALLOW ON
+)
+FetchContent_MakeAvailable(JSONCPP)
+
 file(GLOB_RECURSE Sources CONFIGURE_DEPENDS
     "${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp"
 )
@@ -58,6 +66,7 @@ target_link_libraries(${PROJECT_NAME} PRIVATE glfw)
 target_link_libraries(${PROJECT_NAME} PRIVATE Microsoft.GSL::GSL)
 target_link_libraries(${PROJECT_NAME} PRIVATE spdlog)
 target_link_libraries(${PROJECT_NAME} PRIVATE assimp::assimp)
+target_link_libraries(${PROJECT_NAME} PRIVATE jsoncpp_static)
 
 if(WIN32)
     target_link_libraries(${PROJECT_NAME} PRIVATE ws2_32)
@@ -104,3 +113,17 @@ add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
     "$<TARGET_FILE_DIR:${PROJECT_NAME}>"
     COMMENT "Copying spdlog library files and symlinks to output directory"
 )
+
+add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
+    COMMAND ${CMAKE_COMMAND} -E copy_if_different
+    "$<TARGET_FILE:jsoncpp_static>"
+    "$<TARGET_FILE_DIR:${PROJECT_NAME}>"
+    COMMENT "Copying jsoncpp DLL/so to output directory"
+)
+
+add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
+    COMMAND ${CMAKE_COMMAND} -E copy_directory
+    "$<TARGET_FILE_DIR:jsoncpp_static>"
+    "$<TARGET_FILE_DIR:${PROJECT_NAME}>"
+    COMMENT "Copying jsoncpp library files and symlinks to output directory"
+)

Client/include/asteroid/game.h

@@ -1,4 +1,5 @@
 #pragma once
+#include "utils/snowflake.h"
 
 extern std::uint8_t CLIENTID;
 
@@ -6,5 +7,5 @@ namespace veng {
 class Engine;
 }
 
-void BeginPlay(veng::Engine& engine);
+void BeginPlay(veng::Engine& engine, utils::Snowflake playerID);
 void Tick(veng::Engine& engine, std::float_t delta_time);

Client/src/asteroid/begin_play.cpp

@@ -1,78 +1,129 @@
 #include "asteroid/game.h"
-
 #include "vulkan_engine/vulkan/engine.h"
+#include "utils/ConfigManager.h"
 
-
+void BeginPlay(veng::Engine& engine, utils::Snowflake playerID) {
-void BeginPlay(veng::Engine& engine) {
   std::random_device rd;
   std::mt19937 gen = std::mt19937(rd());
-  std::uniform_real_distribution<float> jitterDist = std::uniform_real_distribution<float>(-2, 2);
+  std::uniform_real_distribution<float> jitterDist =
+      std::uniform_real_distribution<float>(-2, 2);
 
-  veng::Model* const player = engine.SpawnLifedModel("player", "player", -1);
+  std::shared_ptr<veng::Model> const player =
-  player->position = glm::vec3(jitterDist(gen), jitterDist(gen), 0.f);
+      engine.SpawnLifedModel("player", "player", -1);
-  player->scale = glm::vec3(.02f);
+  {
-  player->colision = true;
+    std::lock_guard lock(player->modding);
-  player->OnColision = [](veng::Model* self, veng::Model* other) {
+    if (playerID.snowflake != 0)
-    if (other->owner == self) return;
+      player->ID = playerID;
-    spdlog::info("{} and {} is nearby.", (void*)self, (void*)other);
+    player->position = glm::vec3(jitterDist(gen), jitterDist(gen), 0.f);
+    player->scale = glm::vec3(.02f);
+    player->colision = true;
+    player->OnColision = [](utils::ThreadPool* thread_pool,
+                            std::shared_ptr<veng::Model> self,
+                            std::shared_ptr<veng::Model> other) {
+      auto self_owner = self->owner.lock();
+      auto other_owner = other->owner.lock();
+      if (other_owner == nullptr || self_owner == nullptr) return;
+      if (other_owner->ID == self->ID) return;
+      spdlog::info("[{}:{}] and [{}:{}] is nearby.", self->name,
+                   self->ID.snowflake, other->name, other->ID.snowflake);
 
-    spdlog::info("{} 's owner: {}", (void*)self, (void*)self->owner);
+      spdlog::info("[{}:{}] 's owner: [{}:{}]", self->name, self->ID.snowflake,
-    spdlog::info("{} 's owner: {}", (void*)other, (void*)other->owner);
+                   self_owner->name, self_owner->ID.snowflake);
+      spdlog::info("[{}:{}] 's owner: [{}:{}]", other->name,
+                   other->ID.snowflake, other_owner->name,
+                   other_owner->ID.snowflake);
 
-    other->colision = false;
+      other->colision = false;
-    other->visible = false;
+      other->visible = false;
-    other->shouldBeDestroyed = true;
+      other->shouldBeDestroyed = true;
-  };
+    };
-  veng::Model* const player_flame =
+  }
+
+  std::shared_ptr<veng::Model> const player_flame =
       engine.SpawnLifedModel("player_flame", "player_flame", -1);
-  player_flame->scale = player->scale;
+  {
-  player_flame->colision = false;
+    std::lock_guard lock(player_flame->modding);
-  player_flame->networkReplicated = false;
+    player_flame->scale = player->scale;
+    player_flame->colision = false;
+    player_flame->networkReplicated = true;
+    player_flame->needsUpdate = true;
+  }
 
-  spdlog::info("player addr: {}", (void*)player);
+  /*std::shared_ptr<veng::Model> const other_player =
+      engine.SpawnLifedModel("player", "other_player", -1);
+  {
+    std::lock_guard lock(other_player->modding);
+    other_player->position = glm::vec3(1.f, 0.f, 0.f);
+    other_player->scale = glm::vec3(.02f);
+    player->colision = true;
+    player->OnColision = [](utils::ThreadPool* thread_pool,
+                            std::shared_ptr<veng::Model> self,
+                            std::shared_ptr<veng::Model> other) {
+      auto self_owner = self->owner.lock();
+      auto other_owner = other->owner.lock();
+      if (other_owner == nullptr || self_owner == nullptr) return;
+      if (other_owner->ID == self->ID) return;
+      spdlog::info("[{}:{}] and [{}:{}] is nearby.", self->name,
+                   self->ID.snowflake, other->name, other->ID.snowflake);
 
-  veng::Model* const other_player = engine.SpawnLifedModel("player", "other_player", -1);
+      spdlog::info("[{}:{}] 's owner: [{}:{}]", self->name, self->ID.snowflake,
-  other_player->position = glm::vec3(1.f, 0.f, 0.f);
+                   self_owner->name, self_owner->ID.snowflake);
-  other_player->scale = glm::vec3(.02f);
+      spdlog::info("[{}:{}] 's owner: [{}:{}]", other->name,
-  other_player->colision = true;
+                   other->ID.snowflake, other_owner->name,
-  other_player->OnColision = [](veng::Model* self, veng::Model* other) {
+                   other_owner->ID.snowflake);
-    if (other->owner == self) return;
-    spdlog::info("{} and {} is nearby.", (void*)self, (void*)other);
 
-    spdlog::info("{} 's owner: {}", (void*)self, (void*)self->owner);
+      other->colision = false;
-    spdlog::info("{} 's owner: {}", (void*)other, (void*)other->owner);
+      other->visible = false;
+      other->shouldBeDestroyed = true;
+    };
+    other_player->colision = true;
+  }*/
 
-    other->colision = false;
+  std::shared_ptr<veng::Model> const camera_lag =
-    other->visible = false;
+      engine.SpawnLifedModel("", "camera_lag", -1);
-    other->shouldBeDestroyed = true;
+  {
-  };
+    std::lock_guard lock(camera_lag->modding);
+    camera_lag->colision = false;
+    camera_lag->position = player->position;
+  }
 
-  spdlog::info("other player addr: {}", (void*)other_player);
+  std::shared_ptr<veng::Model> const background =
+      engine.SpawnLifedModel("", "background", -1);
+  {
+    std::lock_guard lock(background->modding);
+    background->colision = false;
+    background->position = {background->position.x, background->position.y,
+                            30.f};
+    background->scale *= 100;
+    background->networkReplicated = false;
+  }
 
-  veng::Model* const camera_lag = engine.SpawnLifedModel("", "camera_lag", -1);
+  std::shared_ptr<veng::Model> const background0 =
-  camera_lag->colision = false;
-  camera_lag->position = player->position;
-
-  veng::Model* const background = engine.SpawnLifedModel("", "background", -1);
-  background->colision = false;
-  background->position = {background->position.x, background->position.y, 30.f};
-  background->scale *= 100;
-  background->networkReplicated = false;
-
-  veng::Model* const background0 =
       engine.SpawnLifedModel("background", "background0", -1);
-  background0->scale = background->scale;
+  {
-  background0->networkReplicated = false;
+    std::lock_guard lock(background0->modding);
-  veng::Model* const background1 =
+    background0->scale = background->scale;
+    background0->networkReplicated = false;
+  }
+  std::shared_ptr<veng::Model> const background1 =
       engine.SpawnLifedModel("background", "background1", -1);
-  background1->scale = background->scale;
+  {
-  background1->networkReplicated = false;
+    std::lock_guard lock(background1->modding);
-  veng::Model* const background2 =
+    background1->scale = background->scale;
+    background1->networkReplicated = false;
+  }
+  std::shared_ptr<veng::Model> const background2 =
       engine.SpawnLifedModel("background", "background2", -1);
-  background2->scale = background->scale;
+  {
-  background2->networkReplicated = false;
+    std::lock_guard lock(background2->modding);
-  veng::Model* const background3 =
+    background2->scale = background->scale;
+    background2->networkReplicated = false;
+  }
+  std::shared_ptr<veng::Model> const background3 =
       engine.SpawnLifedModel("background", "background3", -1);
-  background3->scale = background->scale;
+  {
-  background3->networkReplicated = false;
+    std::lock_guard lock(background3->modding);
+    background3->scale = background->scale;
+    background3->networkReplicated = false;
+  }
 }

Client/src/asteroid/main.cpp

@@ -7,8 +7,10 @@
 #include "socket/tcp_socket.h"
 #include "socket/udp_socket.h"
 #include "socket/wsa_manager.h"
+#include "utils/ConfigManager.h"
 #include "utils/log.h"
 #include "utils/snowflake.h"
+#include "utils/utils.h"
 #include "vulkan_engine/vulkan/engine.h"
 #include "vulkan_engine/vulkan/graphics.h"
 
@@ -16,40 +18,36 @@ std::uint8_t CLIENTID = 0;
 
 std::int32_t main(std::int32_t argc, gsl::zstring* argv) {
   Network::WSAManager wsamanager;
-#if !defined(NDEBUG)
+
-  utils::setDefaultLogger(spdlog::level::level_enum::debug, "log.log", 1024, 2);
+  auto config = utils::ConfigManager::load();
-#endif
+  utils::setDefaultLogger(config.logLevel, config.logFileName,
+                          config.logfileSize, config.logfileCount);
+
   utils::ThreadPool tp(0);
   Network::IOCP iocp;
   iocp.init(&tp, SessionProtocol::TCP);
 
   Network::Address addr;
-  in6_addr in6addr;
 
-  addr.set(AF_INET6, "::1", 9010);
+  addr.set(config.ipVersion, config.IP, config.Port);
 
-  Network::TCPSocket TCPSock;
+  std::shared_ptr<Network::TCPSocket> TCPSock =
-  TCPSock.init(AF_INET6);
+      std::make_shared<Network::TCPSocket>(config.ipVersion);
-  if (TCPSock.connect(addr) == INVALID_SOCKET) {
+  if (TCPSock->connect(addr) == INVALID_SOCKET) {
     spdlog::error("connect()");
     std::exit(EXIT_FAILURE);
   }
-  iocp.registerTCPSocket(TCPSock, 16 * 1024);
+  iocp.registerSocket(TCPSock);
+
+  auto result = iocp.recv(TCPSock, 14);
+  auto header_serialized = utils::CvtListToVector(result.get());
 
-  while (iocp.GetRecvedBytes(TCPSock.sock) < 6);
-  std::vector<char> header_serialized(6);
-  iocp.recv(TCPSock, header_serialized);
   Packet::Header header;
   header.Deserialize(header_serialized);
-  while (iocp.GetRecvedBytes(TCPSock.sock) < header.body_length);
-  std::vector<char> data(header.body_length);
-  iocp.recv(TCPSock, data);
-  ::memcpy(&CLIENTID, data.data(), 1); //id 받기
 
-  header.opcode = Packet::Opcode::CLIENTID;
+  result = iocp.recv(TCPSock, header.body_length);
-  header.body_length = 0;
+  std::vector<char> data = utils::CvtListToVector(result.get());
-  header_serialized = header.Serialize();
+  ::memcpy(&CLIENTID, data.data(), 1);  // id 받기
-  iocp.send(TCPSock, header_serialized);
 
   const veng::GlfwInitialization _glfw;
 
@@ -64,16 +62,30 @@ std::int32_t main(std::int32_t argc, gsl::zstring* argv) {
   engine.LoadModelAsset("assets/bullet.fbx", "bullet");
   engine.LoadModelAsset("assets/background.fbx", "background");
 
-  engine.BeginPlay = BeginPlay;
+  engine.BeginPlay = [ID64 = config.playerid](veng::Engine& engine) {
+    utils::Snowflake ID;
+    ID.snowflake = ID64;
+    BeginPlay(engine, ID);
+  };
   engine.Tick = Tick;
 
   engine.init();
 
+  std::shared_ptr<veng::Model> const player = engine.GetSpawnedObject("player");
+  config.playerid = player->ID.snowflake;
+  utils::ConfigManager::save(config);
+
+  tp.enqueueJob(
+      [engine = &engine, TCPSock](utils::ThreadPool* tp, std::uint32_t __) {
+        engine->ResponseToServerAndRefresh(TCPSock);
+      },
+      0);
+
   while (!window.ShouldClose()) {
     glfwPollEvents();
 
     engine.Update();
-    engine.NetUpdate(std::make_shared<Network::Socket>(TCPSock));
+    engine.NetUpdate(TCPSock);
   }
 
   return EXIT_SUCCESS;

Client/src/asteroid/tick.cpp

@@ -5,15 +5,26 @@
 void Tick(veng::Engine& engine, std::float_t delta_time) {
   static std::float_t bullet_cooldown = 0.f;
 
-  veng::Model* const player = engine.GetSpawnedObject("player");
+  std::shared_ptr<veng::Model> const player = engine.GetSpawnedObject("player");
-  veng::Model* const player_flame = engine.GetSpawnedObject("player_flame");
+  std::shared_ptr<veng::Model> const player_flame = engine.GetSpawnedObject("player_flame");
-  veng::Model* const camera_lag = engine.GetSpawnedObject("camera_lag");
+  std::shared_ptr<veng::Model> const camera_lag = engine.GetSpawnedObject("camera_lag");
 
-  veng::Model* const background = engine.GetSpawnedObject("background");
+  std::shared_ptr<veng::Model> const background = engine.GetSpawnedObject("background");
-  veng::Model* const background0 = engine.GetSpawnedObject("background0");
+  std::shared_ptr<veng::Model> const background0 = engine.GetSpawnedObject("background0");
-  veng::Model* const background1 = engine.GetSpawnedObject("background1");
+  std::shared_ptr<veng::Model> const background1 = engine.GetSpawnedObject("background1");
-  veng::Model* const background2 = engine.GetSpawnedObject("background2");
+  std::shared_ptr<veng::Model> const background2 = engine.GetSpawnedObject("background2");
-  veng::Model* const background3 = engine.GetSpawnedObject("background3");
+  std::shared_ptr<veng::Model> const background3 = engine.GetSpawnedObject("background3");
+
+  std::lock_guard<std::mutex> lock[] = {
+      std::lock_guard<std::mutex>(player->modding),
+      std::lock_guard<std::mutex>(player_flame->modding),
+      std::lock_guard<std::mutex>(camera_lag->modding),
+      std::lock_guard<std::mutex>(background->modding),
+      std::lock_guard<std::mutex>(background0->modding),
+      std::lock_guard<std::mutex>(background1->modding),
+      std::lock_guard<std::mutex>(background2->modding),
+      std::lock_guard<std::mutex>(background3->modding)
+  };
 
   glm::vec3 forward = player->rotation * glm::vec3(0, 1, 0);
   glm::vec3 right = player->rotation * glm::vec3(1, 0, 0);
@@ -42,14 +53,25 @@ void Tick(veng::Engine& engine, std::float_t delta_time) {
   if (glfwGetKey(engine.vulkan_graphics->window->GetHandle(), GLFW_KEY_W) ==
       GLFW_PRESS) {
     player->linear_acceleration = glm::normalize(forward) * 10.f;
+    player_flame->linear_velocity = player->linear_velocity;
+    player_flame->position = player->position;
+    player_flame->angular_velocity = player->angular_velocity;
+    player_flame->rotation = player->rotation;
     player_flame->visible = true;
-    player->needsUpdate = true;
+
-    w_laststate = true;
+    if (!w_laststate) {
+      player->needsUpdate = true;
+      player_flame->needsUpdate = true;
+      player->updateRedundantCount = 0;
+      w_laststate = true;
+    }
   } else {
     player->linear_acceleration = forward * .0f;
     player_flame->visible = false;
     if (w_laststate) {
       player->needsUpdate = true;
+      player_flame->needsUpdate = true;
+      player->updateRedundantCount = 0;
       w_laststate = false;
     }
   }
@@ -63,38 +85,70 @@ void Tick(veng::Engine& engine, std::float_t delta_time) {
       bullet_cooldown -= delta_time;
     } else {
       bullet_cooldown = .2f;
-      veng::Model* const bullet =
+      std::shared_ptr<veng::Model> const bullet =
           engine.SpawnLifedModel("bullet", "bullet", 10.f);
       bullet->linear_velocity = player->linear_velocity + forward * 10.f;
       bullet->position = player->position + forward * player->scale.x * 10.f;
       bullet->owner = player;
+      bullet->OwnerID = player->ID;
       bullet->scale = player->scale;
       bullet->colision = true;
+      bullet->OnColision = [](utils::ThreadPool* thread_pool,
+                              std::shared_ptr<veng::Model> self,
+                              std::shared_ptr<veng::Model> other) {
+        auto self_owner = self->owner.lock();
+        auto other_owner = other->owner.lock();
+        if (other_owner == nullptr || self_owner == nullptr) return;
+        if (other_owner->ID == self->ID) return;
+        spdlog::info("[{}:{}] and [{}:{}] is nearby.", self->name,
+                     self->ID.snowflake, other->name, other->ID.snowflake);
+
+        spdlog::info("[{}:{}] 's owner: [{}:{}]", self->name,
+                     self->ID.snowflake, self_owner->name,
+                     self_owner->ID.snowflake);
+        spdlog::info("[{}:{}] 's owner: [{}:{}]", other->name,
+                     other->ID.snowflake, other_owner->name,
+                     other_owner->ID.snowflake);
+
+        other->colision = false;
+        other->visible = false;
+        other->shouldBeDestroyed = true;
+      };
       bullet->networkReplicated = true;
       bullet->needsUpdate = true;
-
-      spdlog::info("bullet address: {}", (void*)bullet);
     }
   }
 
   static bool ad_laststate = false;
+  right = player->rotation * glm::vec3(0, 0, 1);
   if (glfwGetKey(engine.vulkan_graphics->window->GetHandle(), GLFW_KEY_A) ==
       GLFW_PRESS) {
-    right = player->rotation * glm::vec3(0, 0, 1);
     player->angular_velocity = right * 6.f;
-    player->needsUpdate = true;
+    if (!ad_laststate) {
-    ad_laststate = true;
+      player->needsUpdate = true;
-  } else if (glfwGetKey(engine.vulkan_graphics->window->GetHandle(),
+      player->updateRedundantCount = 1;
+      ad_laststate = true;
+    }
+  }
+
+  if (glfwGetKey(engine.vulkan_graphics->window->GetHandle(),
                         GLFW_KEY_D) == GLFW_PRESS) {
-    right = player->rotation * glm::vec3(0, 0, 1);
     player->angular_velocity = right * -6.f;
-    player->needsUpdate = true;
+    if (!ad_laststate) {
-    ad_laststate = true;
+      player->needsUpdate = true;
-  } else {
+      player->updateRedundantCount = 1;
-    right = player->rotation * glm::vec3(0, 0, 1);
+      ad_laststate = true;
+    }
+  }
+
+  if (glfwGetKey(engine.vulkan_graphics->window->GetHandle(), GLFW_KEY_A) ==
+          GLFW_RELEASE &&
+      glfwGetKey(engine.vulkan_graphics->window->GetHandle(), GLFW_KEY_D) ==
+          GLFW_RELEASE) {
     player->angular_velocity = right * 0.f;
     if (ad_laststate) {
       player->needsUpdate = true;
+      player->updateRedundantCount = 2;
       ad_laststate = false;
     }
   }

Client/src/utils/ConfigManager.cpp

@@ -0,0 +1,60 @@
+#include "Utils/ConfigManager.h"
+
+#include <json/json.h>
+
+#include <fstream>
+#include <iostream>
+#include <string>
+
+namespace utils {
+Config ConfigManager::load() {
+  Config config;
+
+  std::ifstream configfile("config.json", std::ifstream::binary);
+  if (!configfile.is_open()) {
+    std::ofstream defaultConfig("config.json", std::ios::out);
+    config.configJsonRoot["IP Version"] = AF_INET6;
+    config.configJsonRoot["IP"] = "::1";
+    config.configJsonRoot["Port"] = 9010;
+    config.configJsonRoot["LogLevel"] = 1;
+    config.configJsonRoot["LogfileName"] = "log.log";
+    config.configJsonRoot["LogfileSize"] = UINT32_MAX;
+    config.configJsonRoot["LogfileCount"] = 5;
+    config.configJsonRoot["PlayerID"] = 0;
+    defaultConfig << config.configJsonRoot;
+    defaultConfig.close();
+    spdlog::critical(
+        "\"config.json\" is missing. Default configuration has been written.");
+  }
+  try {
+    if (configfile.is_open()) configfile >> config.configJsonRoot;
+
+    config.ipVersion = config.configJsonRoot["IP Version"].asInt();
+    if (config.ipVersion != AF_INET && config.ipVersion != AF_INET6)
+      throw std::runtime_error("Invalid IP Version.");
+
+    config.IP = config.configJsonRoot["IP"].asCString();
+
+    config.Port = config.configJsonRoot["Port"].asInt();
+    if (config.Port < 0 || config.Port > 65535)
+      throw std::runtime_error("Invalid listen port.");
+
+    int ll_ = config.configJsonRoot["LogLevel"].asInt();
+    if (ll_ >= 0 && ll_ < spdlog::level::n_levels)
+      config.logLevel = (spdlog::level::level_enum)ll_;
+    else
+      throw std::runtime_error("Invalid log level.");
+
+    config.logFileName = config.configJsonRoot["LogfileName"].asCString();
+    config.logfileSize = config.configJsonRoot["LogfileSize"].asUInt();
+    config.logfileCount = config.configJsonRoot["LogfileCount"].asUInt();
+
+    config.playerid = config.configJsonRoot["PlayerID"].asUInt64();
+  } catch (Json::RuntimeError e) {
+    spdlog::critical(
+        std::string(std::string("[Json Error: ]") + e.what()).c_str());
+    std::exit(EXIT_FAILURE);
+  }
+  return config;
+}
+}  // namespace Chattr

Server/CMakeLists.txt

@@ -48,6 +48,14 @@ FetchContent_Declare(
 )
 FetchContent_MakeAvailable(ASSIMP)
 
+FetchContent_Declare(
+    JSONCPP
+    GIT_REPOSITORY "https://github.com/open-source-parsers/jsoncpp.git"
+    GIT_TAG "1.9.6"
+    GIT_SHALLOW ON
+)
+FetchContent_MakeAvailable(JSONCPP)
+
 file(GLOB_RECURSE Sources CONFIGURE_DEPENDS
     "${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp"
 )
@@ -59,6 +67,7 @@ target_link_libraries(${PROJECT_NAME} PRIVATE glfw)
 target_link_libraries(${PROJECT_NAME} PRIVATE Microsoft.GSL::GSL)
 target_link_libraries(${PROJECT_NAME} PRIVATE spdlog)
 target_link_libraries(${PROJECT_NAME} PRIVATE assimp::assimp)
+target_link_libraries(${PROJECT_NAME} PRIVATE jsoncpp_static)
 
 if(WIN32)
     target_link_libraries(${PROJECT_NAME} PRIVATE ws2_32)
@@ -90,3 +99,17 @@ add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
     "$<TARGET_FILE_DIR:${PROJECT_NAME}>"
     COMMENT "Copying spdlog library files and symlinks to output directory"
 )
+
+add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
+    COMMAND ${CMAKE_COMMAND} -E copy_if_different
+    "$<TARGET_FILE:jsoncpp_static>"
+    "$<TARGET_FILE_DIR:${PROJECT_NAME}>"
+    COMMENT "Copying jsoncpp DLL/so to output directory"
+)
+
+add_custom_command(TARGET ${PROJECT_NAME} POST_BUILD
+    COMMAND ${CMAKE_COMMAND} -E copy_directory
+    "$<TARGET_FILE_DIR:jsoncpp_static>"
+    "$<TARGET_FILE_DIR:${PROJECT_NAME}>"
+    COMMENT "Copying jsoncpp library files and symlinks to output directory"
+)

Server/src/server.cpp

@@ -6,47 +6,38 @@
 #include "socket/tcp_socket.h"
 #include "socket/udp_socket.h"
 #include "socket/wsa_manager.h"
+#include "utils/ConfigManager.h"
 #include "utils/log.h"
 #include "utils/snowflake.h"
+#include "utils/utils.h"
 #include "vulkan_engine/asset/object/model.h"
+#include "vulkan_engine/vulkan/physics.h"
+
+#define TICKRATE 30
+constexpr double TICKDELAY = (1 / TICKRATE);
 
-#define LISTENIP "::"
-#define LISTENPORT 9010
 std::uint8_t CLIENTID = 0;
 
-std::unordered_map<utils::Snowflake, veng::Model> MODELS;
+std::unordered_map<utils::Snowflake, std::shared_ptr<veng::Model>> MODELS;
 std::mutex MODELS_MUTEX;
-std::vector<std::pair<Network::TCPSocket, double>> CLIENTS;
+std::list<std::shared_ptr<Network::Socket>> CLIENTS;
 std::mutex CLIENTS_MUTEX;
 
-void recv_fully(Network::IOCP* iocp, Network::TCPSocket& sock,
-                std::vector<char>& buffer) {
-  size_t total_received = 0;
-  size_t expected = buffer.size();
-
-  while (total_received < expected) {
-    if (total_received != 0)
-      Sleep(100);  // 너무 빨리 재시도해서 큐가 채워질 틈이 없는 듯?
-    if (sock.sock == 0) return;
-    std::vector<char> temp(expected - total_received);
-
-    size_t received = iocp->recv(sock, temp);
-
-    std::copy(temp.begin(), temp.begin() + received,
-              buffer.begin() + total_received);
-    total_received += received;
-  }
-}
-
 void EchoClient(utils::ThreadPool* tp, Network::IOCP* iocp,
-                Network::TCPSocket* NewSock, Network::Address NewAddr) {
+                std::shared_ptr<Network::Socket> NewSock,
+                Network::Address NewAddr) {
   if (NewSock->sock == 0) return;
-  std::vector<char> recv_data(6);
+  std::future<std::list<char>> result;
-  recv_fully(iocp, *NewSock, recv_data);
   Packet::Header header;
+  std::vector<char> recv_data;
+
+  result = iocp->recv(NewSock, 14);
+  recv_data = utils::CvtListToVector(result.get());
+
   header.Deserialize(recv_data);
-  recv_data.resize(header.body_length);
+
-  recv_fully(iocp, *NewSock, recv_data);
+  result = iocp->recv(NewSock, header.body_length);
+  recv_data = utils::CvtListToVector(result.get());
 
   switch (header.opcode) {
     case Packet::Opcode::UPDATEMODEL: {
@@ -55,10 +46,28 @@ void EchoClient(utils::ThreadPool* tp, Network::IOCP* iocp,
 
       std::lock_guard lock(MODELS_MUTEX);
       auto ID = model.ID;
-      if (MODELS.find(ID) == MODELS.end())
+      if (MODELS.find(ID) == MODELS.end()) {
         spdlog::info("model received: {}:{}", model.name, ID.snowflake);
-      MODELS[ID] = std::move(model);
+        MODELS[ID] = std::make_shared<veng::Model>();
-      MODELS[ID].needsUpdate = true;
+        MODELS[ID]->Deserialize(recv_data);
+        MODELS[ID]->OnColision = [](utils::ThreadPool* thread_pool,
+                                   std::shared_ptr<veng::Model> self,
+                                   std::shared_ptr<veng::Model> other) {
+          if (self->shouldBeDestroyed || other->shouldBeDestroyed) return;
+          spdlog::info("[{}:{}] and [{}:{}] is nearby.", self->name,
+                       self->ID.snowflake, other->name, other->ID.snowflake);
+
+          other->colision = false;
+          other->visible = false;
+          other->shouldBeDestroyed = true;
+          self->colision = false;
+          self->visible = false;
+          self->shouldBeDestroyed = true;
+        };
+      } else {
+        MODELS[ID]->Deserialize(recv_data);
+      }
+      MODELS[ID]->needsUpdate = true;
     } break;
     default:
       spdlog::error("unknown data type");
@@ -68,71 +77,91 @@ void EchoClient(utils::ThreadPool* tp, Network::IOCP* iocp,
 }
 
 void ClientRefresher(utils::ThreadPool* tp, Network::IOCP* iocp) {
-  static auto last_all_updated = glfwGetTime();
+  static double last_all_updated;
-  static auto last_frame_time_ = glfwGetTime();
+  static double last_frame_time_;
   auto current_time = glfwGetTime();
   bool needs_all_update = false;
-  if (current_time - last_all_updated >= 100) {
+  if (current_time - last_all_updated >= TICKDELAY) {
     needs_all_update = true;
     last_all_updated = glfwGetTime();
   }
   auto delta_time = current_time - last_frame_time_;
   last_frame_time_ = current_time;
 
+  std::lock_guard client_lock(CLIENTS_MUTEX);
   for (auto it = CLIENTS.begin(); it != CLIENTS.end();) {
-    if (it->first.sock == 0) {
+    if (*it == nullptr || it->get()->sock == 0)
       it = CLIENTS.erase(it);
-    } else {
+    else
       ++it;
+  }
+
+  std::lock_guard model_lock(MODELS_MUTEX);
+  for (auto it = MODELS.begin(); it != MODELS.end();) {
+    auto& model = it->second;
+
+    if (model->shouldBeDestroyed) {
+      it = MODELS.erase(it);
+      continue;
     }
+    ++it;
   }
 
   for (auto it = MODELS.begin(); it != MODELS.end();) {
     auto& model = it->second;
 
-    if (std::abs(model.lifespan + 1.f) <
+    if (std::abs(model->lifespan + 1.f) <
         std::numeric_limits<float>::epsilon()) {
       ++it;
       continue;
     }
 
-    if (model.lifespan <= 0.f) {
+    if (model->lifespan <= 0.f) {
-      it = MODELS.erase(it);
+      it->second->shouldBeDestroyed = true;
+      ++it;
       continue;
     }
 
-    if (model.shouldBeDestroyed) {
+    model->lifespan -= delta_time;
-      it = MODELS.erase(it);
-      continue;
-    }
-
-    model.lifespan -= delta_time;
     ++it;
   }
 
-  for (auto& client : CLIENTS) {
+  for (auto& model : MODELS) {
-    if (client.first.sock == 0) continue;
+    if (model.second->name == "camera_lag") continue;
-    for (auto& model : MODELS) {
+    model.second->Update(delta_time);
-      if (model.second.name == "camera_lag") continue;
+    veng::Physics::invokeOnColisionEvent(tp, MODELS);
+    for (auto& client : CLIENTS) {
+      if (client->sock == 0) continue;
       std::vector<char> send_data;
-      model.second.Update(delta_time + (client.second / 2));
+      auto model_serialized = model.second->Serialize();
-      auto model_serialized = model.second.Serialize();
       Packet::Header header;
-      header.opcode = Packet::Opcode::UPDATEMODEL;
+
+      if (model.second->shouldBeDestroyed) {
+        header.opcode = Packet::Opcode::DESPAWNMODEL;
+      } else {
+        header.opcode = Packet::Opcode::UPDATEMODEL;
+      }
+
+      header.timestamp = glfwGetTime();
       header.body_length = model_serialized.size();
       auto header_serialized = header.Serialize();
       send_data.insert(send_data.end(), header_serialized.begin(),
                        header_serialized.end());
       send_data.insert(send_data.end(), model_serialized.begin(),
                        model_serialized.end());
-      if (!model.second.needsUpdate && !needs_all_update) {
+      /*if (!model.second->needsUpdate && !needs_all_update &&
+          !model.second->shouldBeDestroyed) {
+        continue;
+      }*/
+      if (!needs_all_update) {
         continue;
       }
-      model.second.needsUpdate = false;
+      model.second->needsUpdate = false;
-      if (client.first.send(send_data.data(), send_data.size(), 0) == -1) {
+      if (iocp->send(client, send_data) == -1) {
-        client.first.sock = 0;
+        client->sock = 0;
       }
-      spdlog::info("updated: {}", model.second.name);
+      // spdlog::debug("server-side updated : [{}:{}]", model.second.name,
+      // model.second.ID.snowflake);
     }
   }
 
@@ -142,27 +171,25 @@ void ClientRefresher(utils::ThreadPool* tp, Network::IOCP* iocp) {
 int main(int argc, char* argv[]) {
   Network::WSAManager wsamanager;
   const veng::GlfwInitialization _glfw;
-#if !defined(NDEBUG)
+  utils::Config config = utils::ConfigManager::load();
-  utils::setDefaultLogger(spdlog::level::level_enum::debug, "log.log",
+  utils::setDefaultLogger(config.logLevel, config.logFileName,
-                          1024 * 1024, 2);
+                          config.logfileSize, config.logfileCount);
-#endif
+
   utils::ThreadPool tp(0);
   Network::IOCP iocp;
   iocp.init(&tp, SessionProtocol::TCP);
 
   Network::Address addr;
 
-  addr.set(AF_INET6, "::", 9010);
+  addr.set(config.ipVersion, config.IP, config.Port);
 
-  Network::Socket* sock;
+  std::shared_ptr<Network::TCPSocket> TCPSock =
-  Network::TCPSocket TCPSock;
+      std::make_shared<Network::TCPSocket>(config.ipVersion);
-  TCPSock.init(AF_INET6);
+  if (TCPSock->bind(addr) == INVALID_SOCKET) {
-  sock = &TCPSock;
-  if (TCPSock.bind(addr) == INVALID_SOCKET) {
     spdlog::error("bind()");
     std::exit(EXIT_FAILURE);
   }
-  if (TCPSock.listen(SOMAXCONN) == INVALID_SOCKET) {
+  if (TCPSock->listen(SOMAXCONN) == INVALID_SOCKET) {
     spdlog::error("listen()");
     std::exit(EXIT_FAILURE);
   }
@@ -170,32 +197,31 @@ int main(int argc, char* argv[]) {
   tp.enqueueJob(ClientRefresher, &iocp);
 
   while (true) {
-    Network::TCPSocket NewSock;
+    std::shared_ptr<Network::TCPSocket> NewSock;
-    Network::Address NewAddr;
+    Network::Address NewAddr = addr;
-    NewAddr.length = addr.length;
     spdlog::info("Waiting for connection");
-    TCPSock.accept(NewSock, NewAddr);
+    TCPSock->accept(NewSock, NewAddr);
 
-    iocp.registerTCPSocket(NewSock, 16 * 1024);
+    iocp.registerSocket(NewSock);
 
     Packet::Header header;
+    std::vector<char> packet;
+
     header.opcode = Packet::Opcode::CLIENTID;
-    header.body_length = 9;
+    header.timestamp = glfwGetTime();
-    auto packet = header.Serialize();
+    header.body_length = 1;
-    packet.resize(packet.size() + 9);
+    packet = header.Serialize();
+    packet.resize(packet.size() + 1);
+
     std::lock_guard lock(CLIENTS_MUTEX);
-    std::uint8_t client_id = CLIENTS.size() - 1;
+    std::uint8_t client_id = (std::uint8_t)(CLIENTS.size() - 1);
-    ::memcpy(packet.data() + 6, &client_id, 1);
+    ::memcpy(packet.data() + 14, &client_id, 1);
 
-    std::double_t timestamp = glfwGetTime();
-
-    ::memcpy(packet.data() + 7, &timestamp, 8);
     iocp.send(NewSock, packet);
-    std::vector<char> header_buf(6);
-    recv_fully(&iocp, NewSock, header_buf);
-    auto ping = glfwGetTime() - timestamp;
-    CLIENTS.emplace_back(std::move(NewSock), ping);
 
-    tp.enqueueJob(EchoClient, &iocp, &CLIENTS.back().first, NewAddr);
+    auto ping = glfwGetTime() - header.timestamp;
+    CLIENTS.push_back(NewSock);
+
+    tp.enqueueJob(EchoClient, &iocp, NewSock, NewAddr);
   }
 }

Server/src/utils/ConfigManager.cpp

@@ -0,0 +1,57 @@
+#include "utils/ConfigManager.h"
+
+#include <json/json.h>
+
+#include <fstream>
+#include <iostream>
+#include <string>
+
+namespace utils {
+Config ConfigManager::load() {
+  Config config;
+
+  std::ifstream configfile("config.json", std::ifstream::binary);
+  if (!configfile.is_open()) {
+    std::ofstream defaultConfig("config.json", std::ios::out);
+    config.configJsonRoot["IP Version"] = AF_INET6;
+    config.configJsonRoot["IP"] = "::1";
+    config.configJsonRoot["Port"] = 9010;
+    config.configJsonRoot["LogLevel"] = 1;
+    config.configJsonRoot["LogfileName"] = "log.log";
+    config.configJsonRoot["LogfileSize"] = UINT32_MAX;
+    config.configJsonRoot["LogfileCount"] = 5;
+    defaultConfig << config.configJsonRoot;
+    defaultConfig.close();
+    spdlog::critical(
+        "\"config.json\" is missing. Default configuration has been written.");
+  }
+  try {
+    if (configfile.is_open()) configfile >> config.configJsonRoot;
+
+    config.ipVersion = config.configJsonRoot["IP Version"].asInt();
+    if (config.ipVersion != AF_INET && config.ipVersion != AF_INET6)
+      throw std::runtime_error("Invalid IP Version.");
+
+    config.IP = config.configJsonRoot["IP"].asCString();
+
+    config.Port = config.configJsonRoot["Port"].asInt();
+    if (config.Port < 0 || config.Port > 65535)
+      throw std::runtime_error("Invalid listen port.");
+
+    int ll_ = config.configJsonRoot["LogLevel"].asInt();
+    if (ll_ >= 0 && ll_ < spdlog::level::n_levels)
+      config.logLevel = (spdlog::level::level_enum)ll_;
+    else
+      throw std::runtime_error("Invalid log level.");
+
+    config.logFileName = config.configJsonRoot["LogfileName"].asCString();
+    config.logfileSize = config.configJsonRoot["LogfileSize"].asUInt();
+    config.logfileCount = config.configJsonRoot["LogfileCount"].asUInt();
+  } catch (Json::RuntimeError e) {
+    spdlog::critical(
+        std::string(std::string("[Json Error: ]") + e.what()).c_str());
+    std::exit(EXIT_FAILURE);
+  }
+  return config;
+}
+}  // namespace Chattr

impl/session/session.cpp

@@ -14,9 +14,8 @@ Session::Session(gsl::not_null<Network::IOCP*> iocp, utils::ThreadPool* tp,
     case SessionProtocol::QUIC: 
     case SessionProtocol::TCP:
     case SessionProtocol::TLS: {
-      Network::TCPSocket* sock = new Network::TCPSocket();
+      Network::TCPSocket* sock = new Network::TCPSocket(addr.family);
       sock_ = sock;
-      sock->init(addr.family);
       switch (type) {
         case SessionType::CONNECT:
           sock->connect(addr);

impl/socket/address.cpp

@@ -4,50 +4,6 @@
 
 namespace Network {
 
-//void Address::set(int type, gsl::czstring presentationAddr,
-//                  std::uint16_t port) {
-//  zeroFill();
-//  setType(type);
-//
-//  if (type == AF_INET) {
-//    ::inet_pton(AF_INET, presentationAddr, &addr_in.sin_addr);
-//    addr_in.sin_port = htons(port);
-//  } else if (type == AF_INET6) {
-//    ::inet_pton(AF_INET6, presentationAddr, &addr_in6.sin6_addr);
-//    addr_in6.sin6_port = htons(port);
-//  }
-//
-//  BIO_ADDRINFO* res;
-//  if (!BIO_lookup_ex(presentationAddr, std::to_string(port).c_str(),
-//                     BIO_LOOKUP_CLIENT, type, SOCK_DGRAM, 0, &res)) {
-//    ::BIO_ADDRINFO_free(res);
-//    throw std::runtime_error("can't resolve address");
-//  }
-//
-//  int sock = -1;
-//  for (const BIO_ADDRINFO* ai = res; ai != nullptr;
-//       ai = ::BIO_ADDRINFO_next(ai)) {
-//    sock = ::BIO_socket(BIO_ADDRINFO_family(ai), type, 0, 0);
-//    if (sock == -1)
-//      continue;
-//    else {
-//      auto bio_addr = ::BIO_ADDRINFO_address(ai);
-//      BIO_ADDR_rawaddress(bio_addr, &addr, (unsigned long long*)&length);
-//      bio_addr_info = ::BIO_ADDR_dup(bio_addr);
-//
-//      break;
-//    }
-//  }
-//
-//  if (sock != -1)
-//    ::close(sock);
-//
-//  ::BIO_ADDRINFO_free(res);
-//
-//  addr_in.sin_family = type;
-//  addr_in.sin_port = htons(port);
-//}
-
 Address::Address() { zeroFill(); }
 
 Address::Address(int type, gsl::czstring presentationAddr, std::uint16_t port) {
@@ -58,19 +14,18 @@ void Address::zeroFill() { memset(&addr_in6, 0, sizeof(addr_in6)); }
 
 void Address::set(int type, gsl::czstring presentationAddr,
                   std::uint16_t port) {
-  zeroFill();
+  setType(type);
 
   if (type == AF_INET) {
     addr_in.sin_family = AF_INET;
     ::inet_pton(AF_INET, presentationAddr, &addr_in.sin_addr);
     addr_in.sin_port = htons(port);
-    length = sizeof(sockaddr_in);
   } else if (type == AF_INET6) {
     addr_in6.sin6_family = AF_INET6;
     ::inet_pton(AF_INET6, presentationAddr, &addr_in6.sin6_addr);
     addr_in6.sin6_port = htons(port);
-    length = sizeof(sockaddr_in6);
   }
+  family = type;
 }
 
 void Address::setType(int type) {
@@ -87,12 +42,12 @@ Address::operator std::string() {
 
   if (!port) return std::string();
 
-  if (length == sizeof(addr_in)) {
+  if (family == AF_INET) {
     char addrStr[INET_ADDRSTRLEN];
     ::inet_ntop(AF_INET, &addr_in.sin_addr, addrStr, sizeof(addrStr));
 
     return std::format("{}:{}", addrStr, port.value());
-  } else if (length == sizeof(addr_in6)) {
+  } else if (family == AF_INET6) {
     char addrStr[INET6_ADDRSTRLEN];
     ::inet_ntop(AF_INET6, &addr_in6.sin6_addr, addrStr, sizeof(addrStr));
 

impl/socket/iocp.cpp

@@ -4,7 +4,7 @@
 
 namespace Network {
 
-IOCP::IOCP() {
+IOCP::IOCP() : IOCPThread_(nullptr), proto_(SessionProtocol::TCP) {
   gen_ = std::mt19937(rd_());
   jitterDist_ = std::uniform_int_distribution<int>(-10, 10);
 }
@@ -40,22 +40,86 @@ void IOCP::destruct() {
 #endif
 }
 
-void IOCP::registerTCPSocket(Socket& sock, std::uint32_t bufsize) {
+void IOCP::registerSocket(std::shared_ptr<Socket> sock) {
 #ifdef _WIN32
-  HANDLE returnData = ::CreateIoCompletionPort((HANDLE)sock.sock,
+  HANDLE returnData = ::CreateIoCompletionPort((HANDLE)sock->sock,
-                                               completionPort_, sock.sock, 0);
+                                               completionPort_, sock->sock, 0);
   if (returnData == 0) completionPort_ = returnData;
+#endif
+}
 
-  IOCPPASSINDATA* recv_data = new IOCPPASSINDATA(bufsize);
+std::future<std::vector<char>> IOCP::recvFull(std::shared_ptr<Socket> sock,
-  recv_data->event = IOCPEVENT::READ;
+                                              std::uint32_t bufsize) {
-  recv_data->socket = std::make_shared<Socket>(sock);
+  auto promise = std::make_shared<std::promise<std::vector<char>>>();
-  recv_data->IOCPInstance = this;
+  auto future = promise->get_future();
-  DWORD recvbytes = 0, flags = 0;
+
+  auto buffer = std::make_shared<std::vector<char>>();
+  buffer->reserve(bufsize);
+
+  std::function<void(std::uint32_t)> recvChunk;
+  recvChunk = [=](std::uint32_t remaining) mutable {
+    this->recv(sock, remaining,
+               [=](utils::ThreadPool* th, IOCPPASSINDATA* data) {
+                 buffer->insert(buffer->end(), data->wsabuf.buf,
+                                data->wsabuf.buf + data->transferredbytes);
+
+                 std::uint32_t still_left =
+                     bufsize - static_cast<std::uint32_t>(buffer->size());
+                 if (still_left > 0) {
+                   recvChunk(still_left);
+                 } else {
+                   promise->set_value(std::move(*buffer));
+                 }
+
+                 return std::list<char>();
+               });
+  };
+
+  recvChunk(bufsize);
+
+  return future;
+}
+
+std::list<char> DEFAULT_RECVALL_CALLBACK(utils::ThreadPool* th,
+                                         IOCPPASSINDATA* data) {
+  std::list<char> return_value;
+  return_value.insert(return_value.end(), data->wsabuf.buf,
+                      data->wsabuf.buf + data->transferredbytes);
+
+  if (data->transferredbytes < data->wsabuf.len) {
+    auto future = data->IOCPInstance->recv(
+        data->socket, data->wsabuf.len - data->transferredbytes,
+        DEFAULT_RECVALL_CALLBACK);
+    auto result = future.get();
+    return_value.insert(return_value.end(), result.begin(), result.end());
+  }
+
+  return return_value;
+}
+
+std::future<std::list<char>> IOCP::recv(
+    std::shared_ptr<Socket> sock, std::uint32_t bufsize,
+    std::function<std::list<char>(utils::ThreadPool*, IOCPPASSINDATA*)>
+        callback) {
+  std::lock_guard lock(*GetRecvQueueMutex(sock->sock));
+  auto queue = GetRecvQueue(sock->sock);
+
+  Network::IOCPPASSINDATA* data;
+  std::packaged_task<std::list<char>(utils::ThreadPool*, IOCPPASSINDATA*)> task;
+  std::future<std::list<char>> future;
+  if (callback != nullptr) {
+    task = std::packaged_task<std::list<char>(utils::ThreadPool*,
+                                              IOCPPASSINDATA*)>(callback);
+    future = task.get_future();
+    data = new Network::IOCPPASSINDATA(sock, bufsize, this, std::move(task));
+  } else {
+    data = new Network::IOCPPASSINDATA(sock, bufsize, this);
+  }
 
   int result = SOCKET_ERROR;
-
+  DWORD recvbytes = 0, flags = 0;
-  result = ::WSARecv(recv_data->socket->sock, &recv_data->wsabuf, 1, &recvbytes,
+  result = ::WSARecv(sock->sock, &data->wsabuf, 1, &recvbytes, &flags,
-                     &flags, &recv_data->overlapped, NULL);
+                     &data->overlapped, NULL);
   if (result == SOCKET_ERROR) {
     int err = ::WSAGetLastError();
     if (err != WSA_IO_PENDING) {
@@ -64,82 +128,22 @@ void IOCP::registerTCPSocket(Socket& sock, std::uint32_t bufsize) {
     }
   }
 
-#endif
+  return future;
 }
 
-void IOCP::registerUDPSocket(IOCPPASSINDATA* data, Address recv_addr) {
+int IOCP::send(std::shared_ptr<Socket> sock, std::vector<char>& data) {
-#ifdef _WIN32
+  auto lk = GetSendQueueMutex(sock->sock);
-  HANDLE returnData = ::CreateIoCompletionPort(
+  auto queue = GetSendQueue(sock->sock);
-      (HANDLE)data->socket->sock, completionPort_, data->socket->sock, 0);
-  if (returnData == 0) completionPort_ = returnData;
-
-  IOCPPASSINDATA* recv_data = new IOCPPASSINDATA(data->bufsize);
-  recv_data->event = IOCPEVENT::READ;
-  recv_data->socket = data->socket;
-  DWORD recvbytes = 0, flags = 0;
-
-  int result = SOCKET_ERROR;
-
-  ::WSARecvFrom(recv_data->socket->sock, &recv_data->wsabuf, 1, &recvbytes,
-                &flags, &recv_addr.addr, &recv_addr.length,
-                &recv_data->overlapped, NULL);
-
-  if (result == SOCKET_ERROR) {
-    int err = ::WSAGetLastError();
-    if (err != WSA_IO_PENDING) {
-      auto err_msg = std::format("WSARecv failed: {}", err);
-      throw std::runtime_error(err_msg);
-    }
-  }
-
-#endif
-}
-
-int IOCP::recv(Socket& sock, std::vector<char>& data) {
-  std::lock_guard lock(*GetRecvQueueMutex_(sock.sock));
-  auto queue = GetRecvQueue_(sock.sock);
-
-  std::uint32_t left_data = data.size();
-  std::uint32_t copied = 0;
-
-  while (!queue->empty() && left_data != 0) {
-    auto front = queue->front();
-    queue->pop_front();
-
-    std::uint32_t offset = front.second;
-    std::uint32_t available = front.first.size() - offset;
-    std::uint32_t to_copy = (left_data < available) ? left_data : available;
-
-    ::memcpy(data.data() + copied, front.first.data() + offset, to_copy);
-    copied += to_copy;
-    left_data -= to_copy;
-    offset += to_copy;
-
-    if (offset < front.first.size()) {
-      front.second = offset;
-      queue->push_front(front);
-      break;
-    }
-  }
-
-  return copied;
-}
-
-int IOCP::send(Socket& sock, std::vector<char>& data) {
-  auto lk = GetSendQueueMutex_(sock.sock);
-  auto queue = GetSendQueue_(sock.sock);
   std::lock_guard lock(*lk);
 
-  Network::IOCPPASSINDATA* packet = new Network::IOCPPASSINDATA(data.size());
+  Network::IOCPPASSINDATA* packet = new Network::IOCPPASSINDATA(sock, data.size(), this);
   packet->event = IOCPEVENT::WRITE;
-  packet->socket = std::make_shared<Network::Socket>(sock);
-  packet->IOCPInstance = this;
   ::memcpy(packet->wsabuf.buf, data.data(), data.size());
   packet->wsabuf.len = data.size();
   queue->push_back(packet);
 
   IOCPThread_->enqueueJob(
-      [this, sock = sock.sock](utils::ThreadPool* th, std::uint8_t __) {
+      [this, sock = sock->sock](utils::ThreadPool* th, std::uint8_t __) {
         packet_sender_(sock);
       },
       0);
@@ -147,7 +151,7 @@ int IOCP::send(Socket& sock, std::vector<char>& data) {
 }
 
 int IOCP::GetRecvedBytes(SOCKET sock) {
-  auto queue = GetRecvQueue_(sock);
+  auto queue = GetRecvQueue(sock);
   std::lock_guard lock(socket_mod_mutex_);
 
   int bytes = 0;
@@ -178,7 +182,15 @@ void IOCP::iocpWatcher_(utils::ThreadPool* IOCPThread) {
     data->event = IOCPEVENT::QUIT;
     spdlog::debug("Disconnected. [{}]",
                   (std::string)(data->socket->remoteAddr));
-    delete data;
+    auto task = [this, IOCPThread, data = std::move(data)](
+                    utils::ThreadPool* th, std::uint8_t __) {
+      if (data->callback.valid()) {
+        data->callback(th, data);
+      }
+      data->socket->destruct();
+      delete data;
+    };
+    IOCPThread->enqueueJob(task, 0);
     IOCPThread->enqueueJob(
         [this](utils::ThreadPool* th, std::uint8_t __) { iocpWatcher_(th); },
         0);
@@ -187,34 +199,17 @@ void IOCP::iocpWatcher_(utils::ThreadPool* IOCPThread) {
     data->transferredbytes = cbTransfrred;
   }
 
-  std::vector<char> buf(16384);  // SSL_read최대 반환 크기
+  auto task = [this, IOCPThread, data = std::move(data)](utils::ThreadPool* th,
-  int red_data = 0;
+                                                         std::uint8_t __) {
-  std::lock_guard lock(*GetRecvQueueMutex_(sock));
+    if (data->callback.valid()) data->callback(th, data);
-  auto queue_list = GetRecvQueue_(sock);
-  if (data->event == IOCPEVENT::READ) {
-    ::memcpy(buf.data(), data->wsabuf.buf, data->transferredbytes);
-    queue_list->emplace_back(std::make_pair(
-        std::vector<char>(buf.begin(), buf.begin() + data->transferredbytes),
-        0));
-    DWORD recvbytes = 0, flags = 0;
-
-    IOCPPASSINDATA* recv_data = new IOCPPASSINDATA(data->bufsize);
-    recv_data->event = IOCPEVENT::READ;
-    recv_data->socket = data->socket;
-
     delete data;
-    ::WSARecv(recv_data->socket->sock, &recv_data->wsabuf, 1, &recvbytes,
+  };
-              &flags, &recv_data->overlapped, NULL);
+  IOCPThread->enqueueJob(task, 0);
-  } else {  // WRITE 시, 무시한다.
-    spdlog::debug("writed {} bytes to {}", cbTransfrred,
-                  (std::string)(data->socket->remoteAddr));
-    delete data;
-  }
   IOCPThread->enqueueJob(
       [this](utils::ThreadPool* th, std::uint8_t __) { iocpWatcher_(th); }, 0);
 }
 
-std::shared_ptr<std::list<IOCPPASSINDATA*>> IOCP::GetSendQueue_(SOCKET sock) {
+std::shared_ptr<std::list<IOCPPASSINDATA*>> IOCP::GetSendQueue(SOCKET sock) {
   std::lock_guard lock(socket_mod_mutex_);
   if (send_queue_.find(sock) == send_queue_.end()) {
     send_queue_[sock] = std::make_shared<std::list<IOCPPASSINDATA*>>(
@@ -224,7 +219,7 @@ std::shared_ptr<std::list<IOCPPASSINDATA*>> IOCP::GetSendQueue_(SOCKET sock) {
 }
 
 std::shared_ptr<std::list<std::pair<std::vector<char>, std::uint32_t>>>
-IOCP::GetRecvQueue_(SOCKET sock) {
+IOCP::GetRecvQueue(SOCKET sock) {
   std::lock_guard lock(socket_mod_mutex_);
   if (recv_queue_.find(sock) == recv_queue_.end()) {
     recv_queue_[sock] = std::make_shared<
@@ -234,7 +229,7 @@ IOCP::GetRecvQueue_(SOCKET sock) {
   return recv_queue_[sock];
 }
 
-std::shared_ptr<std::mutex> IOCP::GetSendQueueMutex_(SOCKET sock) {
+std::shared_ptr<std::mutex> IOCP::GetSendQueueMutex(SOCKET sock) {
   std::lock_guard lock(socket_mod_mutex_);
   if (send_queue_mutex_.find(sock) == send_queue_mutex_.end()) {
     send_queue_mutex_[sock] = std::make_shared<std::mutex>();
@@ -242,7 +237,7 @@ std::shared_ptr<std::mutex> IOCP::GetSendQueueMutex_(SOCKET sock) {
   return send_queue_mutex_[sock];
 }
 
-std::shared_ptr<std::mutex> IOCP::GetRecvQueueMutex_(SOCKET sock) {
+std::shared_ptr<std::mutex> IOCP::GetRecvQueueMutex(SOCKET sock) {
   std::lock_guard lock(socket_mod_mutex_);
   if (recv_queue_mutex_.find(sock) == recv_queue_mutex_.end()) {
     recv_queue_mutex_[sock] = std::make_shared<std::mutex>();
@@ -251,8 +246,8 @@ std::shared_ptr<std::mutex> IOCP::GetRecvQueueMutex_(SOCKET sock) {
 }
 
 void IOCP::packet_sender_(SOCKET sock) {
-  auto queue = GetSendQueue_(sock);
+  auto queue = GetSendQueue(sock);
-  std::unique_lock lock(*GetSendQueueMutex_(sock));
+  std::unique_lock lock(*GetSendQueueMutex(sock));
 
   std::vector<char> buf(16384);
   WSABUF wsabuf;

impl/socket/socket.cpp

@@ -2,6 +2,10 @@
 
 namespace Network {
 
+Socket::Socket() {
+  init(AF_INET, SOCK_STREAM, 0);
+}
+
 Socket::Socket(int domain, int type, int protocol) {
   init(domain, type, protocol);
 }
@@ -61,6 +65,8 @@ int Socket::bind(Address __addr) {
   bindAddr = __addr;
   int retVal = ::bind(sock, &__addr.addr, __addr.length);
   if (retVal == INVALID_SOCKET) {
+    int err = WSAGetLastError();
+    spdlog::error("bind() failed: WSA error {} (0x{:X})", err, err);
     spdlog::critical("bind()");
     std::exit(EXIT_FAILURE);
   }
@@ -70,12 +76,13 @@ int Socket::bind(Address __addr) {
 int Socket::connect(Address& serveraddr) {
   std::string addr_string = serveraddr;
   int retVal = -1;
-  if (serveraddr.family == AF_INET)
+  if (serveraddr.family == AF_INET) {
     retVal = ::connect(sock, (const sockaddr*)&serveraddr.addr_in,
                        serveraddr.length);
-  else
+  } else if (serveraddr.family == AF_INET6) {
     retVal = ::connect(sock, (const sockaddr*)&serveraddr.addr_in6,
                        serveraddr.length);
+  }
   memcpy(&remoteAddr, &serveraddr, sizeof(Address));
   if (retVal == INVALID_SOCKET) {
 #ifdef _WIN32
@@ -110,12 +117,6 @@ Socket::Socket(const Socket& other_) {
   valid_ = false;
 }
 
-Socket::Socket(Socket&& other_) noexcept {
-  other_.valid_ = false;
-  memcpy(this, &other_, sizeof(Socket));
-  valid_ = true;
-}
-
 Socket& Socket::operator=(const Socket& other_) {
   memcpy(this, &other_, sizeof(Socket));
   valid_ = false;
@@ -123,6 +124,12 @@ Socket& Socket::operator=(const Socket& other_) {
   return *this;
 }
 
+Socket::Socket(Socket&& other_) noexcept {
+  other_.valid_ = false;
+  memcpy(this, &other_, sizeof(Socket));
+  valid_ = true;
+}
+
 Socket& Socket::operator=(Socket&& other_) noexcept {
   other_.valid_ = false;
   memcpy(this, &other_, sizeof(Socket));

impl/socket/tcp_socket.cpp

@@ -2,6 +2,8 @@
 
 namespace Network {
 
+TCPSocket::TCPSocket(int domain) { init(domain); }
+
 int TCPSocket::init(int domain) { return init(domain, SOCK_STREAM, 0); }
 
 int TCPSocket::listen(int __n) {
@@ -10,35 +12,17 @@ int TCPSocket::listen(int __n) {
   return retVal;
 }
 
-void TCPSocket::accept(TCPSocket &newSock, Address &__addr) {
+void TCPSocket::accept(std::shared_ptr<TCPSocket> &newSock,
+                                Address &__addr) {
   SOCKET newsock = INVALID_SOCKET;
   newsock = ::accept(sock, &__addr.addr, &__addr.length);
   if (newsock == INVALID_SOCKET) {
     spdlog::error("accept() errno:{} {}", errno, strerror(errno));
     std::exit(EXIT_FAILURE);
   }
-  newSock.set(newsock, domain);
+  newSock = std::make_shared<TCPSocket>();
-  memcpy(&newSock.remoteAddr, &__addr, sizeof(Address));
+  newSock->set(newsock, domain);
-}
+  newSock->remoteAddr = __addr;
-
-int TCPSocket::connect(Address &serveraddr) {
-  std::string addr_string = serveraddr;
-  int retVal = -1;
-  if (serveraddr.family == AF_INET)
-    retVal = ::connect(sock, (const sockaddr *)&serveraddr.addr_in,
-                       serveraddr.length);
-  else
-    retVal = ::connect(sock, (const sockaddr *)&serveraddr.addr_in6,
-                       serveraddr.length);
-  memcpy(&remoteAddr, &serveraddr, sizeof(Address));
-  if (retVal == INVALID_SOCKET) {
-#ifdef _WIN32
-    int err = WSAGetLastError();
-    spdlog::error("connect() failed: WSA error {} (0x{:X})", err, err);
-#endif
-    spdlog::error("connect()");
-  }
-  return retVal;
 }
 
 int TCPSocket::recv(void *__restrict __buf, size_t __n, int __flags) {

impl/utils/ConfigManager.cpp

@@ -0,0 +1,16 @@
+#include "Utils/ConfigManager.h"
+
+#include <json/json.h>
+
+#include <fstream>
+
+namespace utils {
+void ConfigManager::save(Config& config) {
+
+  std::ofstream configfile("config.json", std::ios::out);
+
+  configfile << config.configJsonRoot;
+
+  configfile.close();
+}
+}  // namespace utils

impl/utils/generate_id.cpp

@@ -9,7 +9,7 @@ static struct EpochInitializer {
   std::chrono::system_clock::time_point EPOCH;
 } epochInitializer;
 
-Snowflake GenerateID(std::uint16_t instance) {
+Snowflake GenerateID(std::uint8_t instance) {
   static std::mutex snowflakeGenerateMutex_;
 
   std::lock_guard<std::mutex> lock(snowflakeGenerateMutex_);

impl/utils/utils.cpp

@@ -0,0 +1,11 @@
+#include "utils/utils.h"
+
+namespace utils {
+
+std::vector<char> CvtListToVector(std::list<char> data) {
+  std::vector<char> returnValue;
+  returnValue.insert(returnValue.end(), data.begin(), data.end());
+  return returnValue;
+}
+
+}

impl/vulkan_engine/asset/object/model.cpp

@@ -53,15 +53,19 @@ std::vector<char> Model::Serialize() {
   Append(buffer, angular_acceleration);
 
   Append(buffer, scale);
-  Append(buffer, transform);
 
   Append(buffer, original_offset);
+
+  Append(buffer, OwnerID);
+
   Append(buffer, radius);
   Append(buffer, lifespan);
 
   Append(buffer, visible);
   Append(buffer, colision);
 
+  Append(buffer, lastUpdatedTime);
+
   return buffer;
 }
 
@@ -81,14 +85,18 @@ void Model::Deserialize(std::vector<char> data) {
   Read(data, offset, angular_acceleration);
 
   Read(data, offset, scale);
-  Read(data, offset, transform);
 
   Read(data, offset, original_offset);
+
+  Read(data, offset, OwnerID);
+
   Read(data, offset, radius);
   Read(data, offset, lifespan);
 
   Read(data, offset, visible);
   Read(data, offset, colision);
+
+  Read(data, offset, lastUpdatedTime);
 }
 
 void veng::Model::Update(float dt) {

impl/vulkan_engine/vulkan/buffers.cpp

@@ -170,7 +170,7 @@ void Graphics::RenderIndexedBuffer(BufferHandle vertex_buffer,
   vkCmdDrawIndexed(frames_[current_frame_].command_buffer, count, 1, 0, 0, 0);
   SetModelMatrix(glm::mat4(1.f));
 }
-void Graphics::RenderModel(Model* model) {
+void Graphics::RenderModel(std::shared_ptr<Model> model) {
   if (!model->visible) return;
   SetTexture(model->material.texture_handle);
   SetModelMatrix(model->transform);

impl/vulkan_engine/vulkan/engine.cpp

@@ -2,6 +2,10 @@
 
 #include "precomp.h"
 #include "socket/packet.h"
+#include "utils/utils.h"
+
+#define TICKRATE 10
+constexpr double TICKDELAY = (1 / TICKRATE);
 
 namespace veng {
 
@@ -19,15 +23,16 @@ void Engine::init() {
 }
 
 void Engine::LoadModelAsset(std::string path, std::string name) {
-  veng::Model model(vulkan_graphics);
+  model_assets_[name] = veng::Model(vulkan_graphics);
   asset_loader_.setPath(path);
-  asset_loader_.loadModel(model);
+  asset_loader_.loadModel(model_assets_[name]);
 
-  model.vertex_buffer = vulkan_graphics->CreateVertexBuffer(model.vertices);
+  model_assets_[name].vertex_buffer =
-  model.index_buffer = vulkan_graphics->CreateIndexBuffer(model.indices);
+      vulkan_graphics->CreateVertexBuffer(model_assets_[name].vertices);
-  model.material.texture_handle =
+  model_assets_[name].index_buffer =
+      vulkan_graphics->CreateIndexBuffer(model_assets_[name].indices);
+  model_assets_[name].material.texture_handle =
       vulkan_graphics->CreateTexture(asset_loader_.readTexture());
-  model_assets_[name] = std::move(model);
 }
 
 const Model* Engine::GetStaticModel(std::string name) {
@@ -36,16 +41,18 @@ const Model* Engine::GetStaticModel(std::string name) {
   return nullptr;
 }
 
-Model* Engine::SpawnLifedModel(std::string asset_name, std::string name,
+std::shared_ptr<Model> Engine::SpawnLifedModel(std::string asset_name,
-                               std::float_t lifespan) {
+                                               std::string name,
+                                               std::float_t lifespan) {
   if (asset_name == "") {
     Model model_to_spawn(nullptr);
     model_to_spawn.asset_name = "";
     model_to_spawn.name = name;
     model_to_spawn.visible = false;
     model_to_spawn.lifespan = lifespan;
-    models_[name] = std::move(model_to_spawn);
+    models_[name] = std::make_shared<Model>(model_to_spawn);
-    return &models_[name];
+    model_to_spawn.owner = models_[name];
+    return models_[name];
   }
 
   if (models_.find(name) == models_.end()) {
@@ -53,8 +60,9 @@ Model* Engine::SpawnLifedModel(std::string asset_name, std::string name,
     model_to_spawn.asset_name = asset_name;
     model_to_spawn.name = name;
     model_to_spawn.lifespan = lifespan;
-    models_[name] = std::move(model_to_spawn);
+    models_[name] = std::make_shared<Model>(model_to_spawn);
-    return &models_[name];
+    model_to_spawn.owner = models_[name];
+    return models_[name];
   }
 
   std::uint32_t i = 0;
@@ -64,7 +72,10 @@ Model* Engine::SpawnLifedModel(std::string asset_name, std::string name,
       model_to_spawn.asset_name = asset_name;
       model_to_spawn.name = name + std::to_string(i);
       model_to_spawn.lifespan = lifespan;
-      models_[name + std::to_string(i)] = std::move(model_to_spawn);
+
+      models_[name + std::to_string(i)] =
+          std::make_shared<Model>(model_to_spawn);
+      model_to_spawn.owner = models_[name + std::to_string(i)];
       break;
     }
     i++;
@@ -73,12 +84,12 @@ Model* Engine::SpawnLifedModel(std::string asset_name, std::string name,
   if (i == std::numeric_limits<std::uint32_t>::max() - 1)
     return nullptr;
   else
-    return &models_[name + std::to_string(i)];
+    return models_[name + std::to_string(i)];
 }
 
-Model* Engine::GetSpawnedObject(std::string name) {
+std::shared_ptr<Model> Engine::GetSpawnedObject(std::string name) {
   for (auto it = models_.begin(); it != models_.end();) {
-    if (it->first == name) return &it->second;
+    if (it->first == name) return it->second;
     ++it;
   }
 
@@ -110,149 +121,189 @@ void Engine::Update() {
 
     if (Tick != nullptr) Tick(*this, delta_time);
 
-    std::vector<Model*> models;
-    models.reserve(models_.size());
-
     for (auto it = models_.begin(); it != models_.end();) {
       auto& model = it->second;
 
-      if (std::abs(model.lifespan + 1.f) <
+      if (std::abs(model->lifespan + 1.f) <
           std::numeric_limits<float>::epsilon()) {
-        models.push_back(&model);
         ++it;
         continue;
       }
 
-      if (model.lifespan <= 0.f) {
+      if (model->lifespan <= 0.f) {
         it = models_.erase(it);
         continue;
       }
 
-      if (model.shouldBeDestroyed) {
+      if (model->shouldBeDestroyed) {
         it = models_.erase(it);
         continue;
       }
 
-      model.lifespan -= delta_time;
+      model->lifespan -= delta_time;
-
-      models.push_back(&model);
       ++it;
     }
 
     for (auto& it : models_) {
-      it.second.Update(delta_time);
+      it.second->Update(it.second->lastUpdatedTime + delta_time);
-      vulkan_graphics->RenderModel(&it.second);
+      vulkan_graphics->RenderModel(it.second);
     }
 
-    physics_controller_.invokeOnColisionEvent(thread_pool_,
+    // Physics::invokeOnColisionEvent(thread_pool_, models_);
-                                              {models.data(), models.size()});
 
     vulkan_graphics->EndFrame();
   }
 }
 void Engine::NetUpdate(std::shared_ptr<Network::Socket> sock) {
   NetworkUpload(sock);
-  ResponseToServerAndRefresh(sock);
 }
 
 void Engine::NetworkUpload(std::shared_ptr<Network::Socket> sock) {
+  static double last_all_updated;
+  auto current_time = glfwGetTime();
+  bool needs_all_update = false;
+  if (current_time - last_all_updated >= TICKDELAY) {
+    needs_all_update = true;
+    last_all_updated = glfwGetTime();
+  }
+
   std::vector<char> data;
   for (auto& it : models_) {
-    if (!it.second.networkReplicated) continue;
+    std::lock_guard lock(it.second->modding);
-    if (!it.second.needsUpdate) continue;
+    if (!it.second->networkReplicated && !needs_all_update) continue;
+    if (!it.second->needsUpdate && !needs_all_update) continue;
 
     Packet::Header header;
     header.opcode = Packet::Opcode::UPDATEMODEL;
-    std::vector<char> model = it.second.Serialize();
+    header.timestamp = glfwGetTime();
+    std::vector<char> model = it.second->Serialize();
     header.body_length = model.size();
     std::vector<char> header_serialized = header.Serialize();
 
     data.insert(data.end(), header_serialized.begin(), header_serialized.end());
     data.insert(data.end(), model.begin(), model.end());
-    it.second.needsUpdate = false;
+    if (it.second->updateRedundantCount <= 1) {
+      it.second->needsUpdate = false;
+    } else {
+      it.second->updateRedundantCount--;
+    }
+    spdlog::debug("{} uploaded", it.second->name);
   }
-  iocp_->send(*sock, data);
+  iocp_->send(sock, data);
 }
 
-int recv_partial(Network::IOCP* iocp, Network::Socket& sock,
+float GetAlpha(double old_time, double new_time) {
-                 std::vector<char>& buffer) {
+  return (glfwGetTime() - old_time) / (new_time - old_time) * 0.5;
-  size_t total_received = 0;
-  size_t expected = buffer.size();
-
-  while (total_received < expected) {
-    if (total_received != 0)
-      Sleep(100);  // 너무 빨리 재시도해서 큐가 채워질 틈이 없는 듯?
-    if (sock.sock == 0) return 0;
-    std::vector<char> temp(expected - total_received);
-
-    size_t received = iocp->recv(sock, temp);
-    if (received == 0) return 0;
-
-    std::copy(temp.begin(), temp.begin() + received,
-              buffer.begin() + total_received);
-    total_received += received;
-  }
-
-  return total_received;
 }
 
-void recv_fully(Network::IOCP* iocp, Network::Socket& sock,
+void Interpolation(Packet::Header header, std::shared_ptr<veng::Model> local,
-                std::vector<char>& buffer) {
+                   std::shared_ptr<veng::Model> remote) {
-  size_t total_received = 0;
+  constexpr float position_threshold = 5.0f;  // 위치 차이 임계값
-  size_t expected = buffer.size();
+  constexpr float rotation_threshold = 0.5f;  // 회전 차이 임계값 (라디안 기준)
 
-  while (total_received < expected) {
+  std::lock_guard lock(local->modding);
-    if (total_received != 0)
+  float alpha = GetAlpha(local->lastUpdatedTime, header.timestamp);
-      Sleep(100);  // 너무 빨리 재시도해서 큐가 채워질 틈이 없는 듯?
-    if (sock.sock == 0) return;
-    std::vector<char> temp(expected - total_received);
 
-    size_t received = iocp->recv(sock, temp);
+  // 위치 보간 또는 강제 이동
-
+  if (glm::distance(local->position, remote->position) > position_threshold) {
-    std::copy(temp.begin(), temp.begin() + received,
+    local->position = remote->position;
-              buffer.begin() + total_received);
+  } else {
-    total_received += received;
+    local->position = glm::mix(local->position, remote->position, alpha);
   }
+
+  // 선속도
+  if (glm::length(remote->linear_velocity - local->linear_velocity) >
+      position_threshold) {
+    local->linear_velocity = remote->linear_velocity;
+  } else {
+    local->linear_velocity =
+        glm::mix(local->linear_velocity, remote->linear_velocity, alpha);
+  }
+
+  local->linear_acceleration =
+      glm::mix(local->linear_acceleration, remote->linear_acceleration, alpha);
+
+  // 회전 보간 또는 강제 이동
+  if (glm::length(remote->rotation - local->rotation) > rotation_threshold) {
+    local->rotation = remote->rotation;
+  } else {
+    local->rotation = glm::mix(local->rotation, remote->rotation, alpha);
+  }
+
+  local->angular_velocity =
+      glm::mix(local->angular_velocity, remote->angular_velocity, alpha);
+
+  local->angular_acceleration = glm::mix(local->angular_acceleration,
+                                         remote->angular_acceleration, alpha);
+
+  // 스케일은 보간만 적용
+  local->scale = glm::mix(local->scale, remote->scale, alpha);
+
+  // 동기화 항목은 그대로 적용
+  local->original_offset = remote->original_offset;
+  local->radius = remote->radius;
+  local->lifespan = remote->lifespan;
+  local->visible = remote->visible;
+  local->colision = remote->colision;
 }
 
+
+//void Interpolation(Packet::Header header, std::shared_ptr<veng::Model> local,
+//                   std::shared_ptr<veng::Model> remote) {
+//  std::lock_guard lock(local->modding);
+//  local->position =
+//      glm::mix(local->position, remote->position,
+//               GetAlpha(local->lastUpdatedTime, header.timestamp));
+//  local->linear_velocity =
+//      glm::mix(local->linear_velocity, remote->linear_velocity,
+//               GetAlpha(local->lastUpdatedTime, header.timestamp));
+//  local->linear_acceleration =
+//      glm::mix(local->linear_acceleration, remote->linear_acceleration,
+//               GetAlpha(local->lastUpdatedTime, header.timestamp));
+//
+//  local->rotation =
+//      glm::mix(local->rotation, remote->rotation,
+//               GetAlpha(local->lastUpdatedTime, header.timestamp));
+//  local->angular_velocity =
+//      glm::mix(local->angular_velocity, remote->angular_velocity,
+//               GetAlpha(local->lastUpdatedTime, header.timestamp));
+//  local->angular_acceleration =
+//      glm::mix(local->angular_acceleration, remote->angular_acceleration,
+//               GetAlpha(local->lastUpdatedTime, header.timestamp));
+//
+//  local->scale = glm::mix(local->scale, remote->scale,
+//                          GetAlpha(local->lastUpdatedTime, header.timestamp));
+//
+//  local->original_offset = remote->original_offset;
+//  local->radius = remote->radius;
+//  local->lifespan = remote->lifespan;
+//
+//  local->visible = remote->visible;
+//  local->colision = remote->colision;
+//}
+
 void Engine::ResponseToServerAndRefresh(std::shared_ptr<Network::Socket> sock) {
   if (sock->sock == 0) return;
-  std::vector<char> recv_data(6);
+
-  if (recv_partial(iocp_, *sock, recv_data) == 0) return;
+  auto result = iocp_->recv(sock, 14);
+  auto recv_data = utils::CvtListToVector(result.get()); // 여기서 막혀서 프로그램이 리턴을 못하는 문제가 있음..
+
   Packet::Header header;
   header.Deserialize(recv_data);
-  recv_data.resize(header.body_length);
+
-  recv_fully(iocp_, *sock, recv_data);
+  result = iocp_->recv(sock, header.body_length);
+  recv_data = utils::CvtListToVector(result.get());
 
   switch (header.opcode) {
     case Packet::Opcode::UPDATEMODEL: {
-      veng::Model model;
+      std::shared_ptr<veng::Model> model = std::make_shared<veng::Model>();
-      model.Deserialize(recv_data);
+      model->Deserialize(recv_data);
 
       bool found = false;
       for (auto& it : models_) {
-        if (it.second.ID == model.ID) {
+        if (it.second->ID == model->ID) {
-          it.second.position = model.position;
+          Interpolation(header, it.second, model);
-          it.second.linear_velocity = model.linear_velocity;
+          // spdlog::debug("model updated: [{}:{}]", model->name, model->ID.snowflake);
-          it.second.linear_acceleration = model.linear_acceleration;
-
-          it.second.rotation = model.rotation;
-          it.second.angular_velocity = model.angular_velocity;
-          it.second.angular_acceleration = model.angular_acceleration;
-
-          it.second.scale = model.scale;
-          it.second.transform = model.transform;
-
-          it.second.original_offset = model.original_offset;
-          it.second.radius = model.radius;
-          it.second.lifespan = model.lifespan;
-
-          it.second.visible = model.visible;
-          it.second.colision = model.colision;
-
-          spdlog::info("model updated: {}", model.name);
-          spdlog::info("model pos: ({},{},{})", model.position.x,
-                       model.position.y, model.position.z);
           found = true;
           break;
         }
@@ -260,32 +311,50 @@ void Engine::ResponseToServerAndRefresh(std::shared_ptr<Network::Socket> sock) {
 
       if (!found) {
         auto spawnedModel =
-            SpawnLifedModel(model.asset_name, model.name, model.lifespan);
+            SpawnLifedModel(model->asset_name, model->name, model->lifespan);
-        spawnedModel->ID = model.ID;
+        std::lock_guard lock(spawnedModel->modding);
-        spawnedModel->position = model.position;
+        spawnedModel->ID = model->ID;
-        spawnedModel->linear_velocity = model.linear_velocity;
+        spawnedModel->position = model->position;
-        spawnedModel->linear_acceleration = model.linear_acceleration;
+        spawnedModel->linear_velocity = model->linear_velocity;
+        spawnedModel->linear_acceleration = model->linear_acceleration;
 
-        spawnedModel->rotation = model.rotation;
+        spawnedModel->rotation = model->rotation;
-        spawnedModel->angular_velocity = model.angular_velocity;
+        spawnedModel->angular_velocity = model->angular_velocity;
-        spawnedModel->angular_acceleration = model.angular_acceleration;
+        spawnedModel->angular_acceleration = model->angular_acceleration;
 
-        spawnedModel->scale = model.scale;
+        spawnedModel->scale = model->scale;
-        spawnedModel->transform = model.transform;
+        spawnedModel->transform = model->transform;
 
-        spawnedModel->original_offset = model.original_offset;
+        spawnedModel->original_offset = model->original_offset;
-        spawnedModel->radius = model.radius;
+        spawnedModel->radius = model->radius;
-        spawnedModel->lifespan = model.lifespan;
+        spawnedModel->lifespan = model->lifespan;
 
-        spawnedModel->visible = model.visible;
+        spawnedModel->visible = model->visible;
-        spawnedModel->colision = model.colision;
+        spawnedModel->colision = model->colision;
         spawnedModel->networkReplicated = false;
-        spdlog::info("model spawned: {}", model.ID.snowflake);
+        spdlog::info("model spawned: {}", model->ID.snowflake);
+      }
+    } break;
+    case Packet::Opcode::DESPAWNMODEL: {
+      std::shared_ptr<veng::Model> model = std::make_shared<veng::Model>();
+      model->Deserialize(recv_data);
+
+      for (auto it = models_.begin(); it != models_.end();) {
+        if (it->second->ID == model->ID) {
+          models_.erase(it);
+          break;
+        }
+        ++it;
       }
     } break;
     default:
       spdlog::error("unknown data type");
   }
+  thread_pool_->enqueueJob(
+      [this, sock](utils::ThreadPool* tp, std::uint32_t __) {
+        ResponseToServerAndRefresh(sock);
+      },
+      0);
 }
 
 }  // namespace veng

impl/vulkan_engine/vulkan/physics.cpp

@@ -5,35 +5,64 @@
 
 namespace veng {
 void Physics::invokeOnColisionEvent(
-    gsl::not_null<utils::ThreadPool*> thread_pool, gsl::span<Model*> models) {
+    gsl::not_null<utils::ThreadPool*> thread_pool,
+    std::unordered_map<std::string, std::shared_ptr<Model>>& models) {
   constexpr std::float_t EPSILON = std::numeric_limits<std::float_t>::epsilon();
 
-  for (int first = 0; first < models.size(); first++) {
+  for (std::unordered_map<std::string, std::shared_ptr<Model>>::iterator
-    if (!models[first]->colision) continue;
+           iter_A = models.begin();
-    for (int second = first + 1; second < models.size(); second++) {
+       iter_A != models.end(); iter_A++) {
-      if (!models[second]->colision) continue;
+    for (auto iter_B = std::next(iter_A); iter_B != models.end(); iter_B++) {
+      auto model_A = iter_A->second;
+      std::lock_guard<std::mutex> Alock(model_A->modding);
+      auto model_B = iter_B->second;
+      std::lock_guard<std::mutex> Block(model_B->modding);
+      if (!model_A->colision || !model_B->colision) continue;
       std::float_t distance =
-          glm::distance(models[first]->position, models[second]->position);
+          glm::distance(model_A->position, model_B->position);
-      std::float_t model1_radius =
+      std::float_t modelA_radius = model_A->radius * model_A->scale.x;
-          models[first]->radius * models[first]->scale.x;
+      std::float_t modelB_radius = model_B->radius * model_B->scale.x;
-      std::float_t model2_radius =
+      if (distance <= modelA_radius + modelB_radius) {
-          models[second]->radius * models[second]->scale.x;
+        model_A = iter_A->second;
-      if (distance <= model1_radius + model2_radius) {
+        model_B = iter_B->second;
-        if (models[first]->OnColision != nullptr)
+        if (model_A->OnColision)
-          thread_pool->enqueueJob(
+          thread_pool->enqueueJob(model_A->OnColision, model_A, model_B);
-              [OnColision = models[first]->OnColision](
+        model_A = iter_A->second;
-                  utils::ThreadPool* thread_pool, Model* self, Model* other) {
+        model_B = iter_B->second;
-                OnColision(self, other);
+        if (model_B->OnColision)
-              },
+          thread_pool->enqueueJob(model_B->OnColision, model_A, model_B);
-              models[first], models[second]);
+      }
-        if (models[second]->OnColision != nullptr)
+    }
-          thread_pool->enqueueJob(
+  }
-              [OnColision = models[second]->OnColision](
+}
-                  utils::ThreadPool* thread_pool, Model* self, Model* other) {
+
-                OnColision(self, other);
+void Physics::invokeOnColisionEvent(
-              },
+    gsl::not_null<utils::ThreadPool*> thread_pool,
-              models[second], models[first]);
+    std::unordered_map<utils::Snowflake, std::shared_ptr<Model>>& models) {
-        break;
+  constexpr std::float_t EPSILON = std::numeric_limits<std::float_t>::epsilon();
+
+  for (std::unordered_map<utils::Snowflake, std::shared_ptr<Model>>::iterator
+           iter_A = models.begin();
+       iter_A != models.end(); iter_A++) {
+    for (auto iter_B = std::next(iter_A); iter_B != models.end(); iter_B++) {
+      auto model_A = iter_A->second;
+      std::lock_guard<std::mutex> Alock(model_A->modding);
+      auto model_B = iter_B->second;
+      std::lock_guard<std::mutex> Block(model_B->modding);
+      if (!model_A->colision || !model_B->colision) continue;
+      std::float_t distance =
+          glm::distance(model_A->position, model_B->position);
+      std::float_t modelA_radius = model_A->radius * model_A->scale.x;
+      std::float_t modelB_radius = model_B->radius * model_B->scale.x;
+      if (distance <= modelA_radius + modelB_radius) {
+        model_A = iter_A->second;
+        model_B = iter_B->second;
+        if (model_A->OnColision)
+          thread_pool->enqueueJob(model_A->OnColision, model_A, model_B);
+        model_A = iter_A->second;
+        model_B = iter_B->second;
+        if (model_B->OnColision)
+          thread_pool->enqueueJob(model_B->OnColision, model_A, model_B);
       }
     }
   }
@@ -42,7 +71,7 @@ void Physics::invokeOnColisionEvent(
 bool Physics::RayTrace(const glm::vec3& rayOrigin, const glm::vec3& rayDir,
                        const glm::vec3& v0, const glm::vec3& v1,
                        const glm::vec3& v2, std::float_t& outDistance) {
-  const std::float_t EPSILON = std::numeric_limits<std::float_t>::epsilon();
+  constexpr std::float_t EPSILON = std::numeric_limits<std::float_t>::epsilon();
 
   // 삼각형 엣지와 노멀 계산
   glm::vec3 edge1 = v1 - v0;

include/socket/address.h

@@ -10,6 +10,9 @@ struct Address {
   void set(int type, gsl::czstring presentationAddr, std::uint16_t port);
   void setType(int type);
 
+  Address(const Address&) = default;
+  Address& operator=(const Address&) = default;
+
   operator std::string();
   std::uint16_t getPort() const;
 

include/socket/iocp.h

@@ -24,80 +24,10 @@ typedef struct __WSABUF {
 
 namespace Network {
 
-class IOCP;
+struct IOCPPASSINDATA;
 
-enum class IOCPEVENT { QUIT, READ, WRITE };
+std::list<char> DEFAULT_RECVALL_CALLBACK(utils::ThreadPool* th,
-
+                                         IOCPPASSINDATA* data);
-struct IOCPPASSINDATA {
-  OVERLAPPED overlapped;
-  IOCPEVENT event;
-  std::shared_ptr<Socket> socket;
-  std::uint32_t transferredbytes;
-  WSABUF wsabuf;
-  std::uint32_t bufsize;
-  IOCP* IOCPInstance;
-#ifdef __linux__
-  std::shared_ptr<std::queue<IOCPPASSINDATA*>> sendQueue;
-#endif
-
-  IOCPPASSINDATA(std::uint32_t bufsize) {
-    std::memset(&overlapped, 0, sizeof(overlapped));
-    event = IOCPEVENT::QUIT;
-    socket = nullptr;
-    transferredbytes = 0;
-    this->bufsize = bufsize;
-    IOCPInstance = nullptr;
-
-    wsabuf.buf = new char[bufsize];
-    wsabuf.len = bufsize;
-  }
-
-  /*IOCPPASSINDATA(const IOCPPASSINDATA& other) {
-    if (this != &other) {
-      std::memset(&overlapped, 0, sizeof(overlapped));
-      event = other.event;
-      socket = other.socket;
-      ssl = other.ssl;
-      transferredbytes = other.transferredbytes;
-      bufsize = other.bufsize;
-      IOCPInstance = other.IOCPInstance;
-#ifdef __linux__
-      sendQueue = other.sendQueue;
-#endif
-      wsabuf.buf = new char[other.bufsize];
-      wsabuf.len = other.bufsize;
-      std::memcpy(wsabuf.buf, other.wsabuf.buf, other.wsabuf.len);
-    }
-  }*/
-
-  ~IOCPPASSINDATA() {
-    if (wsabuf.buf != nullptr) delete[] wsabuf.buf;
-    wsabuf.buf = nullptr;
-  }
-
-  /*IOCPPASSINDATA& operator=(const IOCPPASSINDATA& other) {
-    if (this != &other) {
-      std::memset(&overlapped, 0, sizeof(overlapped));
-      event = other.event;
-      socket = other.socket;
-      ssl = other.ssl;
-      transferredbytes = other.transferredbytes;
-      bufsize = other.bufsize;
-      IOCPInstance = other.IOCPInstance;
-#ifdef __linux__
-      sendQueue = other.sendQueue;
-#endif
-      if (wsabuf.buf != nullptr) delete[] wsabuf.buf;
-      wsabuf.buf = new char[other.bufsize];
-      wsabuf.len = other.bufsize;
-      std::memcpy(wsabuf.buf, other.wsabuf.buf, other.wsabuf.len);
-    }
-    return *this;
-  }*/
-
-  IOCPPASSINDATA(const IOCPPASSINDATA& other) = delete;
-  IOCPPASSINDATA& operator=(const IOCPPASSINDATA&) = delete;
-};
 
 class IOCP {
  public:
@@ -108,15 +38,26 @@ class IOCP {
 
   void destruct();
 
-  void registerTCPSocket(Socket& sock, std::uint32_t bufsize);
+  void registerSocket(std::shared_ptr<Socket> sock);
-  void registerUDPSocket(IOCPPASSINDATA* data, Address recv_addr);
 
-  int recv(Socket& sock, std::vector<char>& data);
+  std::future<std::vector<char>> recvFull(
+      std::shared_ptr<Socket> sock, std::uint32_t bufsize);
+
+  std::future<std::list<char>> recv(
+      std::shared_ptr<Socket> sock, std::uint32_t bufsize,
+      std::function<std::list<char>(utils::ThreadPool*, IOCPPASSINDATA*)>
+          callback = DEFAULT_RECVALL_CALLBACK);
   // data는 한 가지 소켓에 보내는 패킷만 담아야 합니다
-  int send(Socket& sock, std::vector<char>& data);
+  int send(std::shared_ptr<Socket> sock, std::vector<char>& data);
 
   int GetRecvedBytes(SOCKET sock);
 
+  std::shared_ptr<std::list<IOCPPASSINDATA*>> GetSendQueue(SOCKET sock);
+  std::shared_ptr<std::list<std::pair<std::vector<char>, std::uint32_t>>>
+  GetRecvQueue(SOCKET sock);
+  std::shared_ptr<std::mutex> GetSendQueueMutex(SOCKET sock);
+  std::shared_ptr<std::mutex> GetRecvQueueMutex(SOCKET sock);
+
  private:
 #ifdef _WIN32
   void iocpWatcher_(utils::ThreadPool* IOCPThread);
@@ -124,12 +65,6 @@ class IOCP {
 
 #endif
 
-  std::shared_ptr<std::list<IOCPPASSINDATA*>> GetSendQueue_(SOCKET sock);
-  std::shared_ptr<std::list<std::pair<std::vector<char>, std::uint32_t>>>
-  GetRecvQueue_(SOCKET sock);
-  std::shared_ptr<std::mutex> GetSendQueueMutex_(SOCKET sock);
-  std::shared_ptr<std::mutex> GetRecvQueueMutex_(SOCKET sock);
-
   void packet_sender_(SOCKET sock);
   utils::ThreadPool* IOCPThread_;
 
@@ -182,4 +117,56 @@ class IOCP {
 #endif
 };
 
+enum class IOCPEVENT { QUIT, READ, WRITE };
+
+struct IOCPPASSINDATA {
+  OVERLAPPED overlapped;
+  IOCPEVENT event;
+  std::shared_ptr<Socket> socket;
+  std::uint32_t transferredbytes;
+  WSABUF wsabuf;
+  IOCP* IOCPInstance;
+  std::packaged_task<std::list<char>(utils::ThreadPool*, IOCPPASSINDATA*)>
+      callback;
+#ifdef __linux__
+  std::shared_ptr<std::queue<IOCPPASSINDATA*>> sendQueue;
+#endif
+  IOCPPASSINDATA(std::shared_ptr<Socket> socket, std::uint32_t bufsize,
+                 IOCP* IOCPInstance)
+      : event(IOCPEVENT::QUIT),
+        socket(socket),
+        transferredbytes(0),
+        IOCPInstance(IOCPInstance) {
+    std::memset(&overlapped, 0, sizeof(overlapped));
+
+    wsabuf.buf = new char[bufsize];
+    wsabuf.len = bufsize;
+  }
+
+  IOCPPASSINDATA(
+      std::shared_ptr<Socket> socket, std::uint32_t bufsize, IOCP* IOCPInstance,
+      std::packaged_task<std::list<char>(utils::ThreadPool*, IOCPPASSINDATA*)>
+          callback_)
+      : event(IOCPEVENT::QUIT),
+        socket(socket),
+        transferredbytes(0),
+        IOCPInstance(IOCPInstance),
+        callback(std::move(callback_)) {
+    std::memset(&overlapped, 0, sizeof(overlapped));
+
+    wsabuf.buf = new char[bufsize];
+    wsabuf.len = bufsize;
+  }
+
+  ~IOCPPASSINDATA() {
+    if (wsabuf.buf != nullptr) delete[] wsabuf.buf;
+    wsabuf.buf = nullptr;
+  }
+
+  IOCPPASSINDATA(const IOCPPASSINDATA& other) = delete;
+  IOCPPASSINDATA& operator=(const IOCPPASSINDATA&) = delete;
+  IOCPPASSINDATA(IOCPPASSINDATA&&) = default;
+  IOCPPASSINDATA& operator=(IOCPPASSINDATA&&) = default;
+};
+
 }  // namespace Network

include/socket/packet.h

@@ -16,18 +16,21 @@ enum class Opcode : std::uint16_t {
 
 struct Header {
   Opcode opcode;
+  double timestamp;
   std::uint32_t body_length;
 
   std::vector<char> Serialize() {
-    std::vector<char> serialize(6);
+    std::vector<char> serialize(14);
     ::memcpy(serialize.data(), &opcode, 2);
-    ::memcpy(serialize.data() + 2, &body_length, 4);
+    ::memcpy(serialize.data() + 2, &timestamp, 8);
+    ::memcpy(serialize.data() + 10, &body_length, 4);
     return serialize;
   }
 
   void Deserialize(std::vector<char>& data) {
     ::memcpy(&opcode, data.data(), 2);
-    ::memcpy(&body_length, data.data() + 2, 4);
+    ::memcpy(&timestamp, data.data() + 2, 8);
+    ::memcpy(&body_length, data.data() + 10, 4);
   }
 };
 

include/socket/socket.h

@@ -7,7 +7,7 @@ struct Address;
 
 class Socket {
  public:
-  Socket() = default;
+  Socket();
   Socket(int domain, int type, int protocol);
   ~Socket();
 
@@ -26,8 +26,9 @@ class Socket {
   int sendto(const void* __buf, size_t __n, int __flags, struct Address __addr);
 
   Socket(const Socket&);
-  Socket(Socket&&) noexcept;
   Socket& operator=(const Socket&);
+
+  Socket(Socket&&) noexcept;
   Socket& operator=(Socket&&) noexcept;
 
   struct Address bindAddr = {};

include/socket/tcp_socket.h

@@ -7,10 +7,11 @@ class TCPSocket : public Socket {
  public:
   using Socket::init;
   using Socket::Socket;
+  TCPSocket(int domain);
+
   int init(int domain);
   int listen(int __n);
-  void accept(TCPSocket& newSock, Address& addr);
+  void accept(std::shared_ptr<TCPSocket>& newSock, Address& addr);
-  int connect(Network::Address& serveraddr);
   int recv(void* __restrict __buf, size_t __n, int __flags);
   int send(const void* __buf, size_t __n, int __flags);
 };

include/utils/ConfigManager.h

@@ -0,0 +1,29 @@
+#pragma once
+#include <json/json.h>
+
+#include <fstream>
+
+namespace utils {
+
+struct Config;
+
+class ConfigManager {
+ public:
+  static Config load();
+  static void save(Config&);
+};
+
+struct Config {
+  ~Config() { ConfigManager::save(*this); }
+  Json::Value configJsonRoot;
+  std::uint32_t ipVersion = 0;
+  gsl::czstring IP = "";
+  std::uint32_t Port = 0;
+  spdlog::level::level_enum logLevel = spdlog::level::off;
+  gsl::czstring logFileName = "";
+  std::uint32_t logfileSize = 0;
+  std::uint32_t logfileCount = 0;
+  std::uint64_t playerid = 0;
+};
+
+}  // namespace utils

include/utils/snowflake.h

@@ -18,14 +18,13 @@ struct Snowflake {
   }
 
   std::vector<char> Serialize() {
-    std::vector<char> serialized;
+    std::vector<char> serialized(8);
-    serialized.insert(serialized.end(), &snowflake,
+    ::memcpy(serialized.data(), &snowflake, 8);
-                      &snowflake + sizeof(snowflake));
     return serialized;
   }
 };
 
-Snowflake GenerateID(std::uint16_t instance);
+Snowflake GenerateID(std::uint8_t instance);
 
 }  // namespace Chattr
 

include/utils/utils.h

@@ -0,0 +1,9 @@
+#pragma once
+#include <list>
+#include <vector>
+
+namespace utils {
+
+std::vector<char> CvtListToVector(std::list<char> data);
+
+}  // namespace std

include/vulkan_engine/asset/object/model.h

@@ -5,20 +5,26 @@
 #include <vector>
 
 #include "material.h"
+#include "utils/snowflake.h"
 #include "vulkan_engine/vulkan/buffer_handle.h"
 #include "vulkan_engine/vulkan/vertex.h"
-#include "utils/snowflake.h"
+#include "utils/thread_pool.h"
 
 extern std::uint8_t CLIENTID;
 
 namespace veng {
 struct Model {
-  Model() : graphics_(nullptr) {}
+  Model() : ID(utils::GenerateID(CLIENTID)), graphics_(nullptr) {
-  Model(class Graphics* graphics) : graphics_(graphics) {}
+  }
+  Model(class Graphics* graphics)
+      : ID(utils::GenerateID(CLIENTID)), graphics_(graphics) {
+  }
   ~Model();
 
   Model(const Model& other)
-      : asset_name(other.asset_name),
+      : ID(utils::GenerateID(CLIENTID)),
+        name(/*"_" + */other.name),
+        asset_name(other.asset_name),
         vertices(other.vertices),
         vertex_buffer(other.vertex_buffer),
         indices(other.indices),
@@ -39,14 +45,14 @@ struct Model {
         OnColision(other.OnColision),
         visible(other.visible),
         colision(other.colision),
-        networkReplicated(other.networkReplicated) {
+        networkReplicated(other.networkReplicated),
-    name = "_" + other.name;
+        lastUpdatedTime(other.lastUpdatedTime) {
-    ID = utils::GenerateID(CLIENTID);
     graphics_ = nullptr;
   }
 
   Model(Model&& other)
-      : name(other.name),
+      : ID(other.ID),
+        name(other.name),
         asset_name(other.asset_name),
         vertices(std::move(other.vertices)),
         vertex_buffer(std::move(other.vertex_buffer)),
@@ -68,9 +74,8 @@ struct Model {
         OnColision(other.OnColision),
         visible(other.visible),
         colision(other.colision),
-        networkReplicated(other.networkReplicated)
+        networkReplicated(other.networkReplicated),
-  {
+        lastUpdatedTime(other.lastUpdatedTime) {
-    ID = other.ID;
     ::memset(&other.ID, 0, 8);
 
     graphics_ = other.graphics_;
@@ -98,12 +103,14 @@ struct Model {
       material = std::move(other.material);
       original_offset = other.original_offset;
       owner = other.owner;
+      OwnerID = ID;
       radius = other.radius;
       lifespan = other.lifespan;
       OnColision = other.OnColision;
       visible = other.visible;
       colision = other.colision;
       networkReplicated = other.networkReplicated;
+      lastUpdatedTime = other.lastUpdatedTime;
 
       graphics_ = other.graphics_;
       other.graphics_ = nullptr;
@@ -141,13 +148,16 @@ struct Model {
 
   glm::vec3 original_offset = glm::vec3(0.f);
 
-  Model* owner = this;
+  std::weak_ptr<Model> owner;
+  utils::Snowflake OwnerID;
 
   std::float_t radius = 0.f;
 
   std::float_t lifespan = -1.f;
 
-  std::function<void(Model* self, Model* other)> OnColision = nullptr;
+  std::function<void(utils::ThreadPool* thread_pool, std::shared_ptr<Model> self,
+                     std::shared_ptr<Model> other)>
+      OnColision = nullptr;
 
   bool visible = true;
   bool colision = false;
@@ -156,6 +166,12 @@ struct Model {
 
   bool needsUpdate = true;
 
+  double lastUpdatedTime = 0.f;  // 서버 기준 업데이트된 시간임
+
+  std::uint8_t updateRedundantCount = 0;
+
+  std::mutex modding;
+
  private:
   class Graphics* graphics_;
 };

include/vulkan_engine/vulkan/engine.h

@@ -20,9 +20,9 @@ class Engine {
   const Model* GetStaticModel(std::string name);
 
   // 수명을 무제한으로 놓고 싶으면 lifespan을 -1으로 설정하면 됨
-  Model* SpawnLifedModel(std::string asset_name, std::string name,
+  std::shared_ptr<Model> SpawnLifedModel(std::string asset_name, std::string name,
                          std::float_t lifespan);
-  Model* GetSpawnedObject(std::string name);
+  std::shared_ptr<Model> GetSpawnedObject(std::string name);
 
   void Update();
   void NetUpdate(std::shared_ptr<Network::Socket> sock);
@@ -44,7 +44,6 @@ class Engine {
 
  private:
   Loader asset_loader_;
-  Physics physics_controller_;
   utils::ThreadPool* thread_pool_;
   Network::IOCP* iocp_;
 
@@ -53,7 +52,7 @@ class Engine {
 
   std::unordered_map<std::string, veng::Model> model_assets_;
 
-  std::unordered_map<std::string, veng::Model> models_;
+  std::unordered_map<std::string, std::shared_ptr<Model>> models_;
 };
 
 }  // namespace veng

include/vulkan_engine/vulkan/graphics.h

@@ -33,7 +33,7 @@ class Graphics final {
   void RenderBuffer(BufferHandle handle, std::uint32_t vertex_count);
   void RenderIndexedBuffer(BufferHandle vertex_buffer,
                            BufferHandle index_buffer, std::uint32_t count);
-  void RenderModel(struct Model* model);
+  void RenderModel(std::shared_ptr<struct Model> model);
   void EndFrame();
 
   BufferHandle CreateVertexBuffer(gsl::span<Vertex> vertices);

include/vulkan_engine/vulkan/physics.h

@@ -1,13 +1,18 @@
 #pragma once
 
+#include "utils/thread_pool.h"
 #include "vulkan_engine/asset/object/model.h"
 #include "vulkan_engine/vulkan/vertex.h"
-#include "utils/thread_pool.h"
 
 namespace veng {
 class Physics {
  public:
-  void invokeOnColisionEvent(gsl::not_null<utils::ThreadPool *> thread_pool, gsl::span<Model*> models);
+  static void invokeOnColisionEvent(
+      gsl::not_null<utils::ThreadPool*> thread_pool,
+      std::unordered_map<std::string, std::shared_ptr<Model>>& models);
+  static void invokeOnColisionEvent(
+      gsl::not_null<utils::ThreadPool*> thread_pool,
+      std::unordered_map<utils::Snowflake, std::shared_ptr<Model>>& models);
 
   bool RayTrace(const glm::vec3& rayOrigin, const glm::vec3& rayDir,
                 const glm::vec3& v0, const glm::vec3& v1, const glm::vec3& v2,