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
27 changes: 27 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,33 @@ 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);

/* Full vitals snapshot (level/health/power/position/death state) for a
* character WITHOUT a gateway connection (in-process bot). The gateway
* builds SMSG_PARTY_MEMBER_STATS for cross-server group members from these
* fields; without them the client renders a skull and an empty bar. Call
* periodically for bots that are in a group. */
TC9_API void TC9CharacterVitalsUpdated(uint64_t charGUID, uint8_t level, uint32_t curHP,
uint32_t maxHP, uint8_t powerType, uint32_t curPower,
uint32_t maxPower, float posX, float posY,
uint8_t isDead, uint8_t isGhost);

/* 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
168 changes: 168 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;

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,123 @@ 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 void TC9CharacterVitalsUpdated(
uint64_t charGUID,
uint8_t level,
uint32_t curHP,
uint32_t maxHP,
uint8_t powerType,
uint32_t curPower,
uint32_t maxPower,
float posX,
float posY,
uint8_t isDead,
uint8_t isGhost) {

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

try {
g_state.updates_barrier->UpdateVitals(charGUID, level, curHP, maxHP, powerType,
curPower, maxPower, posX, posY,
isDead != 0, isGhost != 0);
} catch (const std::exception& e) {
spdlog::error("Error queueing character vitals 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
Loading
Loading