Emita eventos.
Receba o caso pronto.

// dedicated server, one client per process
GameLink::GLClient client;
client.Startup( iMaxPlayers, nullptr );
client.LoadCertificateFromFile( sCert, sKey );
client.ConnectUsingEndpoint(
    sEndpoint, sLicenseKey, sVersion, 5000 );

// in the server's main loop
client.Tick();

// game events
GameLink::Player::SendJoin(
    &client, iPlayer, sName, ePlatform );
GameLink::Social::SendChatMessage(
    &client, iSender, eChannel, sText );

client.Shutdown();

/* extern "C" over the same library */
gl_client_t * c = gl_client_create();
gl_client_startup( c, max_players, NULL );
gl_client_connect_endpoint(
    c, endpoint, license_key, version, 5000 );

/* server loop */
gl_client_tick( c );

gl_client_shutdown( c );
gl_client_destroy( c );

// P/Invoke over the C ABI
[DllImport("gamelink")]
static extern IntPtr gl_client_create();
[DllImport("gamelink")]
static extern int gl_client_tick(IntPtr c);
[DllImport("gamelink")]
static extern int gl_client_startup(IntPtr c, uint maxPlayers, IntPtr cfg);

var c = gl_client_create();
gl_client_startup(c, maxPlayers, IntPtr.Zero);

// same pattern in the Unity and Unreal wrappers
gl_client_tick(c);

// FFI over the C ABI
use std::ffi::{c_int, c_void};

#[link(name = "gamelink")]
unsafe extern "C" {
    fn gl_client_create() -> *mut c_void;
    fn gl_client_tick(c: *mut c_void) -> c_int;
}

let c = unsafe { gl_client_create() };
// in the server's main loop
unsafe { gl_client_tick(c) };

// cgo over the C ABI
/*
#cgo LDFLAGS: -lgamelink
#include "gamelink.h"
*/
import "C"

c := C.gl_client_create()
C.gl_client_startup(c,
    C.uint32_t(maxPlayers), nil)

// in the server's main loop
C.gl_client_tick(c)

// FFI over the C ABI (java.lang.foreign)
// link() wraps Linker.nativeLinker().downcallHandle(...)
try (var arena = Arena.ofConfined()) {
    var lib = SymbolLookup
        .libraryLookup("gamelink", arena);
    var create = link(lib, "gl_client_create",
        ADDRESS);
    var tick = link(lib, "gl_client_tick",
        JAVA_INT, ADDRESS);

    MemorySegment c = (MemorySegment) create
        .invoke();
    tick.invoke(c);
}

# GameLink Web API: events over HTTPS with an API key
curl https://api.praetor.example/v1/events \
  -H "Authorization: Bearer $PRAETOR_KEY" \
  -H "Content-Type: application/json" \
  -d '{
    "server_id": "eu-west-03",
    "events": [
      { "type": "player.join",
        "player": "76561198000000042" },
      { "type": "combat.hit",
        "attacker": "76561198000000042",
        "victim": "76561198000000043" }
    ]
  }'

# open cases waiting for review
curl https://api.praetor.example/v1/cases \
  -G -d status=review \
  -H "Authorization: Bearer $PRAETOR_KEY"

# any HTTP client works
import os, requests

API = "https://api.praetor.example/v1"
KEY = os.environ["PRAETOR_KEY"]
H = { "Authorization": "Bearer " + KEY }

requests.post(API + "/events", headers=H,
    json={ "server_id": "eu-west-03",
           "events": [ { "type": "chat.message",
                         "player": pid,
                         "text": msg } ] })

cases = requests.get(API + "/cases", headers=H,
    params={ "status": "review" }).json()

// Node 18+, built-in fetch
const API = "https://api.praetor.example/v1";
const headers = {
  Authorization: `Bearer ${process.env.PRAETOR_KEY}`,
  "Content-Type": "application/json",
};

await fetch(`${API}/events`, {
  method: "POST", headers,
  body: JSON.stringify({
    server_id: "eu-west-03",
    events: [ { type: "match.end",
                match: matchId } ],
  }),
});

Os exemplos HTTP usam um endereço fictício. O endpoint e a chave reais vêm com a sua conta.