Skip to content
Open
Show file tree
Hide file tree
Changes from all commits
Commits
File filter

Filter by extension

Filter by extension

Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
2 changes: 2 additions & 0 deletions game-server/libsidecar-cpp/CMakeLists.txt
Original file line number Diff line number Diff line change
Expand Up @@ -364,6 +364,7 @@ set(LIBSIDECAR_SOURCES
src/metrics/prometheus.cpp
src/guids/guid_manager.cpp
src/events/event_hooks.cpp
src/events/updates-barrier.cpp
src/compat_api.cpp
src/api.cpp
)
Expand Down Expand Up @@ -470,6 +471,7 @@ if(BUILD_TESTS)
tests/config_test.cpp
tests/error_test.cpp
tests/guid_manager_test.cpp
tests/updates_barrier_test.cpp
tests/request_processing_benchmark.cpp
tests/request_processing_realistic_benchmark.cpp
)
Expand Down
17 changes: 17 additions & 0 deletions game-server/libsidecar-cpp/include/libsidecar.h
Original file line number Diff line number Diff line change
Expand Up @@ -57,6 +57,23 @@ TC9_API uint64_t TC9GetNextAvailableInstanceGuid(int realmID);
/* Map loading notification */
TC9_API void TC9ReadyToAcceptPlayersFromMaps(uint32_t* maps, int mapsLen);

/* Online status notifications for in-process sessions (e.g. server-side
* bots). Sessions that log in through a gateway already get these events
* published by the gateway itself — only call these for sessions WITHOUT
* a gateway connection, otherwise events are duplicated. The sidecar
* fills RealmID and uses its servers-registry ID as GatewayID so that
* charserver purges these entries when this game server dies. */
TC9_API void TC9CharacterLoggedIn(uint64_t charGUID, const char* charName, uint8_t charRace, uint8_t charClass, uint8_t charGender, uint8_t charLevel, uint32_t charZone, uint32_t charMap, float charPosX, float charPosY, float charPosZ, uint32_t charGuildID, uint32_t accountID);
TC9_API void TC9CharacterLoggedOut(uint64_t charGUID, const char* charName, uint32_t charGuildID, uint32_t accountID);

/* Post-login field updates for in-process sessions. Batched and merged
* per character (same barrier semantics as the gateway) and published as
* gw.char.chars-updates so charserver (/who), guildserver and groupserver
* caches stay fresh. Same rule as above: only call for sessions WITHOUT
* a gateway connection. */
TC9_API void TC9CharacterZoneChanged(uint64_t charGUID, uint32_t mapID, uint32_t areaID, uint32_t zoneID);
TC9_API void TC9CharacterLevelChanged(uint64_t charGUID, uint8_t level);

/* Generic NATS pub/sub. Payloads are opaque bytes, subjects are arbitrary.
* Subscription callbacks run on the thread draining TC9ProcessEventsHooks
* (the world update thread), not on the NATS delivery thread. Both return
Expand Down
142 changes: 142 additions & 0 deletions game-server/libsidecar-cpp/src/api.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -23,8 +23,10 @@
#include "metrics/prometheus.h"
#include "guids/guid_manager.h"
#include "events/event_hooks.h"
#include "events/updates-barrier.h"

#include <spdlog/spdlog.h>
#include <nlohmann/json.hpp>
#include <memory>
#include <cstring>

Expand All @@ -40,6 +42,7 @@ struct TC9State {
std::unique_ptr<tc9::GrpcClients> grpc_clients;
std::unique_ptr<tc9::NatsConsumer> nats_consumer;
std::unique_ptr<tc9::NatsPublisher> nats_publisher;
std::unique_ptr<tc9::CharacterUpdatesBarrier> updates_barrier;
std::unique_ptr<tc9::HealthServer> health_server;

// Registered callbacks
Expand All @@ -52,6 +55,37 @@ struct TC9State {

TC9State g_state;

// Mirrors shared/events/events-gateway.go GatewayEvent values and the
// EventToSendGenericPayload envelope so Go consumers decode transparently.
constexpr int kEventCharacterLoggedIn = 1;
constexpr int kEventCharacterLoggedOut = 2;
constexpr int kEventCharactersUpdates = 3;
constexpr char kSubjectCharLoggedIn[] = "gw.char.logged-in";
constexpr char kSubjectCharLoggedOut[] = "gw.char.logged-out";
constexpr char kSubjectCharsUpdates[] = "gw.char.chars-updates";
constexpr char kEventsVersion[] = "libsidecar-cpp";

// Same order of magnitude as the gateway barrier window; zone/level
// changes are infrequent so a wider window just merges more.
constexpr std::chrono::milliseconds kUpdatesBarrierInterval{5000};

void PublishCharacterEvent(int eventType, const char* subject, nlohmann::json payload) {
if (!g_state.nats_publisher) {
return;
}

payload["RealmID"] = g_state.realm_id;
payload["GatewayID"] = g_state.assigned_server_id;

Comment on lines +76 to +79
nlohmann::json envelope = {
{"v", kEventsVersion},
{"t", eventType},
{"p", std::move(payload)},
};

g_state.nats_publisher->Publish(subject, envelope.dump());
}

} // anonymous namespace

extern "C" {
Expand Down Expand Up @@ -180,6 +214,17 @@ TC9_API void TC9InitLib(
g_state.assigned_server_id = server_id;
g_state.nats_consumer->SetServerID(server_id);

// Start the character updates barrier now that the identity used
// by PublishCharacterEvent (realm + server id) is known.
g_state.updates_barrier = std::make_unique<tc9::CharacterUpdatesBarrier>(
[](nlohmann::json updates) {
PublishCharacterEvent(kEventCharactersUpdates, kSubjectCharsUpdates, {
{"Updates", std::move(updates)},
});
},
kUpdatesBarrierInterval);
g_state.updates_barrier->Start();

// Initialize GUID manager
auto& guid_mgr = tc9::GuidManager::Instance();
guid_mgr.Initialize(g_state.grpc_clients.get(), realmID);
Expand Down Expand Up @@ -233,6 +278,12 @@ TC9_API void TC9GracefulShutdown() {
g_state.nats_consumer->Stop();
}

// Stop the barrier before the publisher so its final flush
// still goes out.
if (g_state.updates_barrier) {
g_state.updates_barrier->Stop();
}

if (g_state.nats_publisher) {
g_state.nats_publisher->Stop();
}
Expand Down Expand Up @@ -338,6 +389,97 @@ TC9_API void TC9ReadyToAcceptPlayersFromMaps(uint32_t* maps, int mapsLen) {
}
}

TC9_API void TC9CharacterLoggedIn(
uint64_t charGUID,
const char* charName,
uint8_t charRace,
uint8_t charClass,
uint8_t charGender,
uint8_t charLevel,
uint32_t charZone,
uint32_t charMap,
float charPosX,
float charPosY,
float charPosZ,
uint32_t charGuildID,
uint32_t accountID) {

if (!g_state.initialized) {
return;
}

try {
PublishCharacterEvent(kEventCharacterLoggedIn, kSubjectCharLoggedIn, {
{"CharGUID", charGUID},
{"CharName", charName ? charName : ""},
{"CharRace", charRace},
{"CharClass", charClass},
{"CharGender", charGender},
{"CharLevel", charLevel},
{"CharZone", charZone},
{"CharMap", charMap},
{"CharPosX", charPosX},
{"CharPosY", charPosY},
{"CharPosZ", charPosZ},
{"CharGuildID", charGuildID},
{"AccountID", accountID},
});
} catch (const std::exception& e) {
spdlog::error("Error publishing character logged in: {}", e.what());
}
}

TC9_API void TC9CharacterLoggedOut(
uint64_t charGUID,
const char* charName,
uint32_t charGuildID,
uint32_t accountID) {

if (!g_state.initialized) {
return;
}

try {
PublishCharacterEvent(kEventCharacterLoggedOut, kSubjectCharLoggedOut, {
{"CharGUID", charGUID},
{"CharName", charName ? charName : ""},
{"CharGuildID", charGuildID},
{"AccountID", accountID},
});
} catch (const std::exception& e) {
spdlog::error("Error publishing character logged out: {}", e.what());
}
}

TC9_API void TC9CharacterZoneChanged(
uint64_t charGUID,
uint32_t mapID,
uint32_t areaID,
uint32_t zoneID) {

if (!g_state.initialized || !g_state.updates_barrier) {
return;
}

try {
g_state.updates_barrier->UpdateZone(charGUID, mapID, areaID, zoneID);
} catch (const std::exception& e) {
spdlog::error("Error queueing character zone update: {}", e.what());
}
}

TC9_API void TC9CharacterLevelChanged(uint64_t charGUID, uint8_t level) {
if (!g_state.initialized || !g_state.updates_barrier) {
return;
}

try {
g_state.updates_barrier->UpdateLevel(charGUID, level);
} catch (const std::exception& e) {
spdlog::error("Error queueing character level update: {}", e.what());
}
}

TC9_API int TC9NatsPublish(const char* subject, const char* payload, int payloadLen) {
if (!subject || payloadLen < 0 || (payloadLen > 0 && !payload)) {
return -1;
Expand Down
115 changes: 115 additions & 0 deletions game-server/libsidecar-cpp/src/events/updates-barrier.cpp
Original file line number Diff line number Diff line change
@@ -0,0 +1,115 @@
#include "updates-barrier.h"

#include <spdlog/spdlog.h>

#include <utility>

namespace tc9 {

namespace {
// Same cap as the gateway barrier send loop.
constexpr size_t kMaxUpdatesPerEvent = 1000;
} // anonymous namespace

CharacterUpdatesBarrier::CharacterUpdatesBarrier(FlushFn flushFn, std::chrono::milliseconds interval)
: flush_fn_(std::move(flushFn)), interval_(interval) {}

CharacterUpdatesBarrier::~CharacterUpdatesBarrier() {
Stop();
}

void CharacterUpdatesBarrier::Start() {
std::lock_guard<std::mutex> lock(mutex_);
if (running_) {
return;
}
running_ = true;
thread_ = std::thread(&CharacterUpdatesBarrier::run, this);
}

void CharacterUpdatesBarrier::Stop() {
bool was_running = false;
{
std::lock_guard<std::mutex> lock(mutex_);
was_running = running_;
running_ = false;
}
if (was_running) {
cv_.notify_all();
if (thread_.joinable()) {
thread_.join();
}
}
// Flush leftovers unconditionally: updates can be queued while the
// barrier is stopped (or before Start) and must not be lost.
flush();
}

void CharacterUpdatesBarrier::UpdateZone(uint64_t charGUID, uint32_t mapID, uint32_t areaID, uint32_t zoneID) {
std::lock_guard<std::mutex> lock(mutex_);
auto& upd = pending_[charGUID];
upd.map = mapID;
upd.area = areaID;
upd.zone = zoneID;
}

void CharacterUpdatesBarrier::UpdateLevel(uint64_t charGUID, uint8_t level) {
std::lock_guard<std::mutex> lock(mutex_);
pending_[charGUID].level = level;
}

void CharacterUpdatesBarrier::run() {
for (;;) {
{
std::unique_lock<std::mutex> lock(mutex_);
cv_.wait_for(lock, interval_, [this] { return !running_; });
if (!running_) {
return;
}
}
flush();
}
}
Comment on lines +61 to +72

void CharacterUpdatesBarrier::flush() {
std::unordered_map<uint64_t, PendingUpdate> updates;
{
std::lock_guard<std::mutex> lock(mutex_);
updates.swap(pending_);
}
if (updates.empty()) {
return;
}

try {
nlohmann::json batch = nlohmann::json::array();
for (const auto& [guid, upd] : updates) {
nlohmann::json item = {{"i", guid}};
if (upd.level) {
item["l"] = *upd.level;
}
if (upd.map) {
item["m"] = *upd.map;
}
if (upd.area) {
item["a"] = *upd.area;
}
if (upd.zone) {
item["z"] = *upd.zone;
}
batch.push_back(std::move(item));

if (batch.size() >= kMaxUpdatesPerEvent) {
flush_fn_(std::move(batch));
batch = nlohmann::json::array();
}
}
if (!batch.empty()) {
flush_fn_(std::move(batch));
}
} catch (const std::exception& e) {
spdlog::error("Error flushing character updates: {}", e.what());
}
}

} // namespace tc9
Loading
Loading