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
32 changes: 32 additions & 0 deletions game-server/libsidecar-cpp/include/libsidecar.h
Original file line number Diff line number Diff line change
Expand Up @@ -85,6 +85,38 @@ TC9_API int TC9NatsSubscribe(const char* subject, TC9NatsMessageHandler handler)
TC9_API void TC9PlayerLeftBattleground(uint64_t playerGUID, uint32_t realmID, uint32_t instanceID);
TC9_API void TC9BattlegroundStatusChanged(uint32_t instanceID, uint8_t status);

/* Enqueue a solo in-process player into a battleground queue — the same RPC
* the gateway issues for real players (pvpTeamID: 1 alliance, 2 horde).
* Blocking gRPC call, do not call from map update threads. 0 on success. */
TC9_API int TC9EnqueueLocalPlayerToBattleground(uint64_t playerGUID, uint32_t playerLvl,
uint32_t bgTypeID, uint32_t pvpTeamID);

/* Group enqueue: leader plus party members in ONE queue entry, so a whole
* group fill pops one full battleground instead of the matchmaking creating
* the match mid-batch. memberGUIDs lists the OTHER party members only — the
* leader travels as leaderGUID and must not be repeated, exactly like the
* gateway's PartyMembers field. Blocking gRPC call. 0 on success. */
TC9_API int TC9EnqueueLocalGroupToBattleground(uint64_t leaderGUID, uint32_t leaderLvl,
uint32_t bgTypeID, uint32_t pvpTeamID, const uint64_t* memberGUIDs, int memberCount);

/* Query the queue slot assigned to an invited player (matchmaking owns the BG
* queues cluster-wide; in-process sessions have no gateway to accept invites).
* outIsAssignedToThisServer is 1 when the assigned battleground runs on THIS
* worldserver. Blocking gRPC call, do not call from map update threads.
* 0 on success, -1 on error or when no battleground is assigned yet. */
TC9_API int TC9BattlegroundQueueDataForLocalPlayer(uint64_t playerGUID, uint32_t* outBgTypeID,
uint32_t* outInstanceID, uint32_t* outMapID, int* outIsAssignedToThisServer);

/* Confirm to matchmaking that an in-process player entered the battleground
* (the gateway does this for real players after AddPlayersToBattleground).
* Blocking gRPC call, do not call from map update threads. 0 on success. */
TC9_API int TC9PlayerJoinedBattleground(uint64_t playerGUID, uint32_t instanceID);

/* Remove a player from a battleground queue (leftover in-process enqueues
* that were never invited, or out-of-bracket after a level up). Blocking
* gRPC call, do not call from map update threads. 0 on success. */
TC9_API int TC9RemovePlayerFromBattlegroundQueue(uint64_t playerGUID, uint32_t bgTypeID);

/* Event hooks registration */
TC9_API void TC9SetOnGroupCreatedHook(OnGroupCreatedHook h);
TC9_API void TC9SetOnGroupMemberAddedHook(OnGroupMemberAddedHook h);
Expand Down
101 changes: 101 additions & 0 deletions game-server/libsidecar-cpp/src/api.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -26,6 +26,7 @@

#include <spdlog/spdlog.h>
#include <memory>
#include <mutex>
#include <cstring>

namespace {
Expand Down Expand Up @@ -387,6 +388,106 @@ TC9_API void TC9PlayerLeftBattleground(
}
}

TC9_API int TC9BattlegroundQueueDataForLocalPlayer(
uint64_t playerGUID,
uint32_t* outBgTypeID,
uint32_t* outInstanceID,
uint32_t* outMapID,
int* outIsAssignedToThisServer) {

if (!g_state.initialized || !g_state.grpc_clients ||
!outBgTypeID || !outInstanceID || !outMapID || !outIsAssignedToThisServer) {
return -1;
}

uint32_t bg_type_id = 0;
uint32_t instance_id = 0;
uint32_t map_id = 0;
std::string gameserver_address;
if (!g_state.grpc_clients->BattlegroundQueueDataForPlayer(
g_state.realm_id, playerGUID, bg_type_id, instance_id, map_id, gameserver_address)) {
return -1;
}

// The registry never returns our own ID with a different address, so a
// one-shot resolution is enough for the pod's lifetime.
static std::mutex own_address_mutex;
static std::string own_address;
{
std::lock_guard<std::mutex> lock(own_address_mutex);
if (own_address.empty() &&
!g_state.grpc_clients->FindGameServerAddressByID(g_state.assigned_server_id, own_address)) {
spdlog::warn("Can't resolve own game server address (id {})", g_state.assigned_server_id);
return -1;
}

*outIsAssignedToThisServer = (gameserver_address == own_address) ? 1 : 0;
}

*outBgTypeID = bg_type_id;
*outInstanceID = instance_id;
*outMapID = map_id;
return 0;
}

TC9_API int TC9PlayerJoinedBattleground(uint64_t playerGUID, uint32_t instanceID) {
if (!g_state.initialized || !g_state.grpc_clients) {
return -1;
}

return g_state.grpc_clients->PlayerJoinedBattleground(
g_state.realm_id, playerGUID, instanceID, false) ? 0 : -1;
}

TC9_API int TC9EnqueueLocalPlayerToBattleground(
uint64_t playerGUID,
uint32_t playerLvl,
uint32_t bgTypeID,
uint32_t pvpTeamID) {

if (!g_state.initialized || !g_state.grpc_clients) {
return -1;
}

// 1 = alliance, 2 = horde; anything else would forward an invalid
// enum value to the matchmaking service.
if (pvpTeamID != 1 && pvpTeamID != 2) {
return -1;
}

return g_state.grpc_clients->EnqueueToBattleground(
g_state.realm_id, playerGUID, playerLvl, bgTypeID, pvpTeamID) ? 0 : -1;
}

TC9_API int TC9EnqueueLocalGroupToBattleground(uint64_t leaderGUID, uint32_t leaderLvl,
uint32_t bgTypeID, uint32_t pvpTeamID, const uint64_t* memberGUIDs, int memberCount) {

if (!g_state.initialized || !g_state.grpc_clients) {
return -1;
}

if (pvpTeamID != 1 && pvpTeamID != 2) {
return -1;
}

if (memberCount < 0 || (memberCount > 0 && !memberGUIDs)) {
return -1;
}

return g_state.grpc_clients->EnqueueGroupToBattleground(
g_state.realm_id, leaderGUID, leaderLvl, bgTypeID, pvpTeamID,
memberGUIDs, memberCount) ? 0 : -1;
}

TC9_API int TC9RemovePlayerFromBattlegroundQueue(uint64_t playerGUID, uint32_t bgTypeID) {
if (!g_state.initialized || !g_state.grpc_clients) {
return -1;
}

return g_state.grpc_clients->RemovePlayerFromQueue(
g_state.realm_id, playerGUID, bgTypeID) ? 0 : -1;
}

TC9_API void TC9BattlegroundStatusChanged(uint32_t instanceID, uint8_t status) {
if (!g_state.initialized) {
return;
Expand Down
222 changes: 222 additions & 0 deletions game-server/libsidecar-cpp/src/grpc/clients.cpp
Original file line number Diff line number Diff line change
Expand Up @@ -230,6 +230,228 @@ bool GrpcClients::PlayerLeftBattleground(
return true;
}

bool GrpcClients::BattlegroundQueueDataForPlayer(
uint32_t realm_id,
uint64_t player_guid,
uint32_t& out_bg_type_id,
uint32_t& out_instance_id,
uint32_t& out_map_id,
std::string& out_gameserver_address) {

if (!connected_ || !matchmaking_stub_) {
spdlog::error("Matchmaking client not connected");
return false;
}

v1::BattlegroundQueueDataForPlayerRequest request;
request.set_api(LIB_VERSION);
request.set_realmid(realm_id);
request.set_playerguid(player_guid);

v1::BattlegroundQueueDataForPlayerResponse response;
grpc::ClientContext context;
context.set_deadline(Deadline());

grpc::Status status = matchmaking_stub_->BattlegroundQueueDataForPlayer(&context, request, &response);

if (!status.ok()) {
spdlog::warn("BattlegroundQueueDataForPlayer RPC failed: {} - {}",
status.error_code(), status.error_message());
return false;
}

if (response.slots_size() == 0 || !response.slots(0).has_assignedbattlegrounddata()) {
return false;
}

const auto& slot = response.slots(0);
const auto& bg_data = slot.assignedbattlegrounddata();
out_bg_type_id = slot.bgtypeid();
out_instance_id = bg_data.assignedbattlegroundinstanceid();
out_map_id = bg_data.mapid();
out_gameserver_address = bg_data.gameserveraddress();
return true;
}

bool GrpcClients::EnqueueToBattleground(
uint32_t realm_id,
uint64_t player_guid,
uint32_t player_lvl,
uint32_t bg_type_id,
uint32_t team_id) {

if (!connected_ || !matchmaking_stub_) {
spdlog::error("Matchmaking client not connected");
return false;
}

v1::EnqueueToBattlegroundRequest request;
request.set_api(LIB_VERSION);
request.set_realmid(realm_id);
request.set_leaderguid(player_guid);
request.set_leaderslvl(player_lvl);
request.set_bgtypeid(bg_type_id);
request.set_teamid(static_cast<v1::PVPTeamID>(team_id));

v1::EnqueueToBattlegroundResponse response;
grpc::ClientContext context;
context.set_deadline(Deadline());

grpc::Status status = matchmaking_stub_->EnqueueToBattleground(&context, request, &response);

if (!status.ok()) {
spdlog::warn("EnqueueToBattleground RPC failed: {} - {}",
status.error_code(), status.error_message());
return false;
}

spdlog::debug("Enqueued player {} to BG type {} (team {})",
player_guid, bg_type_id, team_id);
return true;
}

bool GrpcClients::EnqueueGroupToBattleground(
uint32_t realm_id,
uint64_t leader_guid,
uint32_t leader_lvl,
uint32_t bg_type_id,
uint32_t team_id,
const uint64_t* member_guids,
int member_count) {

if (!connected_ || !matchmaking_stub_) {
spdlog::error("Matchmaking client not connected");
return false;
}

v1::EnqueueToBattlegroundRequest request;
request.set_api(LIB_VERSION);
request.set_realmid(realm_id);
request.set_leaderguid(leader_guid);
request.set_leaderslvl(leader_lvl);
request.set_bgtypeid(bg_type_id);
request.set_teamid(static_cast<v1::PVPTeamID>(team_id));
for (int i = 0; i < member_count; ++i)
request.add_partymembers(member_guids[i]);

v1::EnqueueToBattlegroundResponse response;
grpc::ClientContext context;
context.set_deadline(Deadline());

grpc::Status status = matchmaking_stub_->EnqueueToBattleground(&context, request, &response);

if (!status.ok()) {
spdlog::warn("EnqueueGroupToBattleground RPC failed: {} - {}",
status.error_code(), status.error_message());
return false;
}

spdlog::debug("Enqueued group of {} (leader {}) to BG type {} (team {})",
member_count + 1, leader_guid, bg_type_id, team_id);
return true;
}

bool GrpcClients::RemovePlayerFromQueue(
uint32_t realm_id,
uint64_t player_guid,
uint32_t bg_type_id) {

if (!connected_ || !matchmaking_stub_) {
spdlog::error("Matchmaking client not connected");
return false;
}

v1::RemovePlayerFromQueueRequest request;
request.set_api(LIB_VERSION);
request.set_realmid(realm_id);
request.set_playerguid(player_guid);
request.set_battlegroundtype(bg_type_id);

v1::RemovePlayerFromQueueResponse response;
grpc::ClientContext context;
context.set_deadline(Deadline());

grpc::Status status = matchmaking_stub_->RemovePlayerFromQueue(&context, request, &response);

if (!status.ok()) {
spdlog::warn("RemovePlayerFromQueue RPC failed: {} - {}",
status.error_code(), status.error_message());
return false;
}

spdlog::debug("Removed player {} from BG type {} queue", player_guid, bg_type_id);
return true;
}

bool GrpcClients::PlayerJoinedBattleground(
uint32_t realm_id,
uint64_t player_guid,
uint32_t instance_id,
bool is_cross_realm) {

if (!connected_ || !matchmaking_stub_) {
spdlog::error("Matchmaking client not connected");
return false;
}

v1::PlayerJoinedBattlegroundRequest request;
request.set_api(LIB_VERSION);
request.set_realmid(realm_id);
request.set_playerguid(player_guid);
request.set_instanceid(instance_id);
request.set_iscrossrealm(is_cross_realm);

v1::PlayerJoinedBattlegroundResponse response;
grpc::ClientContext context;
context.set_deadline(Deadline());

grpc::Status status = matchmaking_stub_->PlayerJoinedBattleground(&context, request, &response);

if (!status.ok()) {
spdlog::warn("PlayerJoinedBattleground RPC failed: {} - {}",
status.error_code(), status.error_message());
return false;
}

spdlog::debug("Notified matchmaking: player {} joined BG instance {}",
player_guid, instance_id);
return true;
}

bool GrpcClients::FindGameServerAddressByID(
const std::string& server_id,
std::string& out_address) {

if (!connected_ || !registry_stub_) {
spdlog::error("Registry client not connected");
return false;
}

v1::ListAllGameServersRequest request;
request.set_api(LIB_VERSION);

v1::ListGameServersResponse response;
grpc::ClientContext context;
context.set_deadline(Deadline());

grpc::Status status = registry_stub_->ListAllGameServers(&context, request, &response);

if (!status.ok()) {
spdlog::warn("ListAllGameServers RPC failed: {} - {}",
status.error_code(), status.error_message());
return false;
}

for (const auto& server : response.gameservers()) {
if (server.id() == server_id) {
out_address = server.address();
return true;
}
}

return false;
}

bool GrpcClients::BattlegroundStatusChanged(
uint32_t realm_id,
uint32_t instance_id,
Expand Down
Loading
Loading