fixed global shutdown

Author: usermicrodevices

include/game/GameLogic.hpp

@@ -100,22 +100,29 @@ class GameLogic : public LogicCore
     void OnPlayerDisconnected(uint64_t sessionId);
 
     // Broadcasting
+    void BroadcastPlayerUpdates();
     void BroadcastToNearbyPlayers(const glm::vec3& position, uint16_t messageType,
                                              const std::vector<uint8_t>& data, float radius = 50.0f);
     void BroadcastToNearbyOnlinePlayers(const glm::vec3& position, uint16_t messageType,
                                         const std::vector<uint8_t>& data, float radius = 50.0f);
     void SyncNearbyEntitiesToPlayer(uint64_t sessionId, const glm::vec3& position);
 
     // Helper broadcast methods
+    void BroadcastToNearbyPlayersJson(const glm::vec3& position, const nlohmann::json& message, float radius);
     void BroadcastToAllPlayers(const nlohmann::json& message);
     void BroadcastToAllPlayersBinary(uint16_t messageType, const std::vector<uint8_t>& data);
     void BroadcastToPlayers(const std::vector<uint64_t>& sessionIds, const nlohmann::json& message);
+    void BroadcastPlayerState(uint64_t playerId, const ServerState& state);
+    void BroadcastPlayerSpawn(uint64_t playerId);
+    void BroadcastPlayerDespawn(uint64_t playerId, const glm::vec3& lastPosition);
+    void BroadcastPlayerSpawnJson(uint64_t playerId);
+    void BroadcastPlayerDespawnJson(uint64_t playerId, const glm::vec3& lastPosition);
+    void BroadcastPlayerUpdatesJson();
 
     // Broadcast entity spawn to nearby players
     void BroadcastEntitySpawn(uint64_t entityId, EntityType type, const glm::vec3& position,
                               float yaw, const std::string& name);
     void SendPositionCorrection(uint64_t sessionId, const glm::vec3& position, const glm::vec3& velocity);
-    void BroadcastPlayerState(uint64_t playerId, const ServerState& state);
     void BroadcastEntityDespawn(uint64_t entityId, const glm::vec3& position);
 
     void HandleAuthentication(uint64_t sessionId, const std::vector<uint8_t>& data);

include/network/BinaryProtocol.hpp

@@ -42,7 +42,10 @@ namespace BinaryProtocol {
         MESSAGE_TYPE_PLAYER_ROTATION = 302,
         MESSAGE_TYPE_PLAYER_STATE = 303,
         MESSAGE_TYPE_PLAYER_POSITION_CORRECTION = 304,
-        
+        MESSAGE_TYPE_PLAYER_UPDATE = 305,
+        MESSAGE_TYPE_PLAYER_SPAWN   = 306,
+        MESSAGE_TYPE_PLAYER_DESPAWN = 307,
+
         // NPC messages
         MESSAGE_TYPE_NPC_SPAWN = 400,
         MESSAGE_TYPE_NPC_UPDATE = 401,

include/network/GameServer.hpp

@@ -28,22 +28,20 @@ class GameServer {
     void Run();
     void Shutdown();
 
-    // For binary protocol
+    asio::io_context& GetIoContext() { return ioContext_; }
+
     using SessionFactory = std::function<std::shared_ptr<GameSession>(asio::ip::tcp::socket, std::shared_ptr<asio::ssl::context>)>;
     void SetSessionFactory(SessionFactory factory);
 
-    // For WebSocket protocol
     using WebSocketFactory = std::function<WebSocketProtocol::WebSocketConnection::Pointer(asio::ip::tcp::socket, std::shared_ptr<asio::ssl::context>)>;
     void SetWebSocketConnectionFactory(WebSocketFactory factory);
 
 private:
     void DoAccept();
     void StartWorkerThreads();
-    void SetupSignalHandlers();
 
     asio::io_context ioContext_;
     asio::ip::tcp::acceptor acceptor_;
-    asio::signal_set signals_;
 
     WorkerGroupConfig groupConfig_;
     const ConfigManager& globalConfig_;
@@ -56,7 +54,7 @@ class GameServer {
     std::vector<std::thread> workerThreads_;
     std::atomic<bool> running_{false};
 
-    std::shared_ptr<asio::ssl::context> sslContext_;   // optional, set if SSL is configured
+    std::shared_ptr<asio::ssl::context> sslContext_;
 
     SessionFactory sessionFactory_;
     WebSocketFactory webSocketFactory_;

src/database/SQLiteClient.cpp

@@ -2,15 +2,13 @@
 
 #include "database/SQLiteClient.hpp"
 
-// =============== Constructor and Destructor ===============
 SQLiteClient::SQLiteClient(const nlohmann::json& config, const SQLProvider& sqlProvider)
     : db_(nullptr),
       sqlProvider_(sqlProvider),
       config_(config),
       lastInsertId_(0),
       affectedRows_(0)
 {
-    // Determine database file path
     if (config.contains("file") && config["file"].is_string()) {
         dbPath_ = config["file"].get<std::string>();
     } else if (config.contains("name") && config["name"].is_string()) {
@@ -29,7 +27,6 @@ SQLiteClient::~SQLiteClient() {
     Logger::Debug("SQLiteClient destroyed");
 }
 
-// =============== Connection Management ===============
 bool SQLiteClient::Connect() {
     std::lock_guard<std::mutex> lock(dbMutex_);
     if (db_) return true;
@@ -48,10 +45,16 @@ bool SQLiteClient::Connect() {
         return false;
     }
 
-    // --- New: Set busy timeout to 5 seconds ---
     sqlite3_busy_timeout(db_, 5000);
 
     char* errMsg = nullptr;
+
+    rc = sqlite3_exec(db_, "PRAGMA synchronous = NORMAL;", nullptr, nullptr, &errMsg);
+    if (rc != SQLITE_OK) {
+        Logger::Warn("Failed to enable synchronous NORMAL: {}", errMsg ? errMsg : "unknown error");
+        sqlite3_free(errMsg);
+    }
+
     rc = sqlite3_exec(db_, "PRAGMA journal_mode=WAL;", nullptr, nullptr, &errMsg);
     if (rc != SQLITE_OK) {
         Logger::Warn("Failed to enable WAL mode: {}", errMsg ? errMsg : "unknown error");
@@ -115,7 +118,6 @@ void SQLiteClient::ReconnectAll() {
     Reconnect();
 }
 
-// =============== Connection Pool Management (dummy) ===============
 bool SQLiteClient::InitializeConnectionPool(size_t /*minConnections*/, size_t /*maxConnections*/) {
     Logger::Debug("SQLiteClient: connection pool not implemented");
     return true;
@@ -131,7 +133,6 @@ size_t SQLiteClient::GetIdleConnections() const {
     return 0;
 }
 
-// =============== Helper Methods ===============
 bool SQLiteClient::ExecuteSql(const std::string& sql, std::vector<std::vector<std::string>>* results) {
     std::lock_guard<std::mutex> lock(dbMutex_);
     if (!db_) {
@@ -226,7 +227,6 @@ bool SQLiteClient::TableExists(const std::string& tableName) {
     return ExecuteSql(sql, &results) && !results.empty();
 }
 
-// =============== Query Operations ===============
 nlohmann::json SQLiteClient::Query(const std::string& sql) {
     std::lock_guard<std::mutex> lock(dbMutex_);
     if (!db_) {
@@ -312,7 +312,6 @@ bool SQLiteClient::ExecuteWithParams(const std::string& sql, const std::vector<s
     return Execute(processedSql);
 }
 
-// =============== Shard Operations ===============
 nlohmann::json SQLiteClient::QueryShard(int /*shardId*/, const std::string& sql) {
     return Query(sql);
 }
@@ -328,7 +327,6 @@ bool SQLiteClient::ExecuteShardWithParams(int /*shardId*/, const std::string& sq
     return ExecuteWithParams(sql, params);
 }
 
-// =============== Utility Methods ===============
 int SQLiteClient::GetShardId(uint64_t entityId) const {
     return static_cast<int>(entityId % totalShards_);
 }
@@ -345,7 +343,6 @@ int SQLiteClient::GetAffectedRows() {
     return affectedRows_;
 }
 
-// =============== Statistics ===============
 nlohmann::json SQLiteClient::GetDatabaseStats() {
     nlohmann::json stats;
     auto now = std::chrono::steady_clock::now();
@@ -377,7 +374,6 @@ void SQLiteClient::ResetStats() {
     Logger::Info("SQLite statistics reset");
 }
 
-// =============== Transaction Operations ===============
 bool SQLiteClient::BeginTransaction() {
     std::string sql = sqlProvider_.GetQuery("begin_transaction");
     if (sql.empty()) sql = "BEGIN TRANSACTION;";
@@ -419,7 +415,6 @@ bool SQLiteClient::ExecuteTransaction(const std::function<bool()>& operation) {
     return success;
 }
 
-// =============== Player Data Operations ===============
 bool SQLiteClient::SavePlayerData(uint64_t playerId, const nlohmann::json& data) {
     std::string sql = sqlProvider_.GetQuery("save_player_data");
     if (sql.empty()) {
@@ -506,7 +501,6 @@ nlohmann::json SQLiteClient::GetPlayer(uint64_t playerId) {
     return nlohmann::json();
 }
 
-// =============== Game State Operations ===============
 bool SQLiteClient::SaveGameState(const std::string& key, const nlohmann::json& state) {
     std::string sql = sqlProvider_.GetQuery("save_game_state");
     if (sql.empty()) {
@@ -548,7 +542,6 @@ std::vector<std::string> SQLiteClient::ListGameStates() {
     return keys;
 }
 
-// =============== World Data Operations ===============
 bool SQLiteClient::SaveChunkData(int chunkX, int chunkZ, const nlohmann::json& chunkData) {
     std::lock_guard<std::mutex> lock(dbMutex_);
     if (!db_) {
@@ -561,7 +554,6 @@ bool SQLiteClient::SaveChunkData(int chunkX, int chunkZ, const nlohmann::json& c
         sql = "INSERT OR REPLACE INTO world_chunks (chunk_x, chunk_z, biome, data, last_updated) VALUES (?, ?, ?, ?, datetime('now'));";
     }
 
-    // Begin immediate transaction
     char* errMsg = nullptr;
     int rc = sqlite3_exec(db_, "BEGIN IMMEDIATE;", nullptr, nullptr, &errMsg);
     if (rc != SQLITE_OK) {
@@ -570,7 +562,6 @@ bool SQLiteClient::SaveChunkData(int chunkX, int chunkZ, const nlohmann::json& c
         return false;
     }
 
-    // Prepare and execute the INSERT statement
     sqlite3_stmt* stmt = nullptr;
     rc = sqlite3_prepare_v2(db_, sql.c_str(), -1, &stmt, nullptr);
     if (rc != SQLITE_OK) {
@@ -596,7 +587,6 @@ bool SQLiteClient::SaveChunkData(int chunkX, int chunkZ, const nlohmann::json& c
 
     sqlite3_finalize(stmt);
 
-    // Commit or rollback
     if (success) {
         rc = sqlite3_exec(db_, "COMMIT;", nullptr, nullptr, &errMsg);
         if (rc != SQLITE_OK) {
@@ -667,7 +657,6 @@ std::vector<std::pair<int, int>> SQLiteClient::ListChunksInRange(int centerX, in
     return chunks;
 }
 
-// =============== Inventory Operations ===============
 bool SQLiteClient::SaveInventory(uint64_t playerId, const nlohmann::json& inventory) {
     std::string sql = sqlProvider_.GetQuery("save_inventory");
     if (sql.empty()) {
@@ -688,7 +677,6 @@ nlohmann::json SQLiteClient::LoadInventory(uint64_t playerId) {
     return nlohmann::json();
 }
 
-// =============== Quest Operations ===============
 bool SQLiteClient::SaveQuestProgress(uint64_t playerId, const std::string& questId, const nlohmann::json& progress) {
     std::string sql = sqlProvider_.GetQuery("save_quest_progress");
     if (sql.empty()) {