> ## Documentation Index > Fetch the complete documentation index at: https://devdocs.xbox.com/llms.txt > Use this file to discover all available pages before exploring further. # Integrar servidores de juegos con el SDK de servidor de juegos de PlayFab (GSDK) > Integre su servidor de juegos con el SDK de servidor de juegos (GSDK) de PlayFab en C++, C# o Java para indicar que está listo, enviar latidos y administrar las asignaciones multijugador. ## Información general El SDK de servidor de juegos (GSDK) de PlayFab se proporciona en versiones para C++, C# y Java. El GSDK conecta su servidor de juegos con el agente de PlayFab instalado en la máquina virtual. Este agente facilita las interacciones clave del servidor con la plataforma multijugador de PlayFab. ## Integración básica Para que su servidor de juegos pueda comunicarse con la plataforma multijugador de PlayFab, debe integrarlo con el GSDK. Como mínimo, debe implementar los métodos `Start` y `ReadyForPlayers` en su servidor de juegos. ```cpp theme={null} int main() { // Call this while your game is initializing; it will start sending a heartbeat to our agent and put the game server in an Initializing state Microsoft::Azure::Gaming::GSDK::start(); /* Add any other initialization code your game server needs before players can connect */ // Call this when your game is done initializing and players can connect // Note: This is a blocking call, and will return when this game server is either allocated or terminated if (Microsoft::Azure::Gaming::GSDK::readyForPlayers()) { // readyForPlayers returns true when an allocation call has been done, a player is about to connect! } else { // readyForPlayers returns false when the server is being terminated } } ``` ```csharp theme={null} static void Main(string[] args) { // Call this while your game is initializing; it will start sending a heartbeat to our agent and put the game server in an Initializing state GameserverSDK.Start(); /* Add any other initializion code your game server needs before players can connect */ // Call this when your game is done initializing and players can connect // Note: This is a blocking call, and will return when this game server is either allocated or terminated if (GameserverSDK.ReadyForPlayers()) { // readyForPlayers returns true when an allocation call has been done, a player is about to connect! } else { // readyForPlayers returns false when the server is being terminated } } ``` ```java theme={null} public static void main(String[] args) { // Call this while your game is initializing; it will start sending a heartbeat to our agent and put the game server in an Initializing state GameserverSDK.start(); /* Add any other initializion code your game server needs before players can connect */ // Call this when your game is done initializing and players can connect // Note: This is a blocking call, and will return when this game server is either allocated or terminated if (GameserverSDK.readyForPlayers()) { // readyForPlayers returns true when an allocation call has been done, a player is about to connect! } else { // readyForPlayers returns false when the server is being terminated } } ``` ## Registro con el GSDK Cuando el servidor de juegos finaliza, el agente de PlayFab de la máquina virtual comprime los archivos de registro y los pone a su disposición. \ Hay dos formas de agregar archivos de registro desde su juego: 1. Use el método `Log` del GSDK: agregará sus propias líneas de registro al archivo de registro del GSDK. 2. Escriba su propio archivo de registro en el directorio de registros adecuado, que el agente de PlayFab de la máquina virtual comprimirá y cargará. ```cpp theme={null} // This will add your log line to the GSDK log file, alongside other information logged by the GSDK Microsoft::Azure::Gaming::GSDK::logMessage("Here is a sample log"); // Alternatively, you can log your own files to the log directory std::string logFolder = Microsoft::Azure::Gaming::GSDK::getLogsDirectory(); ``` ```csharp theme={null} // This will add your log line to the GSDK log file, alongside other information logged by the GSDK GameserverSDK.LogMessage("Here is a sample log"); // Alternatively, you can log your own files to the log directory string logFolder = GameserverSDK.GetLogsDirectory(); ``` ```java theme={null} // This will add your log line to the GSDK log file, alongside other information logged by the GSDK GameserverSDK.log("Here is a sample log"); // Alternatively, you can log your own files to the log directory String logFolder = GameserverSDK.getLogsDirectory(); ``` ## Apagar correctamente el servidor de juegos Hay tres escenarios en los que el servidor de juegos finalizará: 1. La aplicación del servidor de juegos se cierra. 2. PlayFab finaliza el servidor de juegos porque hay más servidores de juegos disponibles de los necesarios para la carga actual de jugadores. > [!NOTE] > > PlayFab *solo* finalizará los servidores de juegos que no estén activos en ese momento. 3. Azure realizará el mantenimiento necesario en la máquina virtual que hospeda el servidor de juegos. Para el caso **(1)** anterior: usted controla cuándo sucede y puede realizar cualquier limpieza necesaria antes de que se cierre la aplicación. Para los casos **(2)** y **(3)** anteriores: el GSDK le proporciona una forma de saber cuándo se producirán mediante la especificación de un método de devolución de llamada. ```cpp theme={null} // This method will be called in case #2, when PlayFab terminates the game server void onShutdown() { printf("GSDK is shutting me down!!!\n"); /* Perform any necessary cleanup and end the program */ std::exit(0); } // This method will be called in case #3, when Azure will perform maintenance on the virtual machine void onMaintenanceScheduled(tm t) { #ifdef WINDOWS time_t local = _mkgmtime(&t); double delta = difftime(local, time(NULL)); struct tm buf; char str[26]; gmtime_s(&buf, &local); asctime_s(str, sizeof str, &buf); printf("UTC: %s", str); localtime_s(&buf, &local); asctime_s(str, sizeof str, &buf); printf("local: %s", str); printf("delta: %f", delta); #else // Linux time_t local = timegm(&t); double delta = difftime(local, time(NULL)); printf("UTC: %s\n", asctime(gmtime(&local))); printf("local: %s\n", asctime(localtime(&local))); printf("delta: %f\n", delta); #endif /* Perform any necessary cleanup, notify your players, etc. */ } int main() { Microsoft::Azure::Gaming::GSDK::start(); Microsoft::Azure::Gaming::GSDK::registerShutdownCallback(&onShutdown); Microsoft::Azure::Gaming::GSDK::registerMaintenanceCallback(&onMaintenanceScheduled); // Continue initializing your game } ``` ```csharp theme={null} // This method will be called in case #2, when PlayFab terminates the game server static void OnShutdown() { GameserverSDK.LogMessage("Shutting down..."); /* Perform any necessary cleanup and end the program */ } // This method will be called in case #3, when Azure will perform maintenance on the virtual machine static void OnMaintenanceScheduled(DateTimeOffset time) { /* Perform any necessary cleanup, notify your players, etc. */ } static void Main(string[] args) { GameserverSDK.Start(); GameserverSDK.RegisterShutdownCallback(OnShutdown); GameserverSDK.RegisterMaintenanceCallback(OnMaintenanceScheduled); // Continue initializing your game } ``` ```java theme={null} // This method will be called in case #2, when PlayFab terminates the game server private static void onShutdown() { System.out.println("Shutting down..."); /* Perform any necessary cleanup and end the program */ } // This method will be called in case #3, when Azure will perform maintenance on the virtual machine private static void onMaintenanceScheduled(ZonedDateTime time) { /* Perform any necessary cleanup, notify your players, etc. */ } static void Main(string[] args) { GameserverSDK.start(); GameserverSDK.registerShutdownCallback(Main::onShutdown); GameserverSDK.registerMaintenanceCallback(Main::onMaintenanceScheduled); // Continue initializing your game } ``` ## Proporcionar a PlayFab información sobre el servidor de juegos Actualmente, hay dos cosas que puede comunicar a PlayFab mediante el GSDK: 1. El estado de mantenimiento actual del servidor de juegos. 2. Una lista de los jugadores que están conectados actualmente al servidor de juegos. Estos dos datos se transmitirán a PlayFab en el siguiente latido y actualmente se pueden usar para la generación de informes. ```cpp theme={null} static std::vector players; void playerConnected() { // When a new player connects, you can let PlayFab know by adding it to the vector of players and calling updateConnectedPlayers players.push_back(Microsoft::Azure::Gaming::ConnectedPlayer("player_tag")); Microsoft::Azure::Gaming::GSDK::updateConnectedPlayers(players); } // This method will be called on every heartbeat to check if your game is healthy, as such, it should return very quickly bool isHealthy() { // Return whether your game server should be considered healthy return true; } int main() { Microsoft::Azure::Gaming::GSDK::start(); Microsoft::Azure::Gaming::GSDK::registerHealthCallback(&isHealthy); // Continue initializing your game } ``` ```csharp theme={null} static private List players = new List(); static void OnPlayerConnected() { // When a new player connects, you can let PlayFab know by adding it to the vector of players and calling updateConnectedPlayers players.Add(new ConnectedPlayer("player_tag")); GameserverSDK.UpdateConnectedPlayers(players); } // This method will be called on every heartbeat to check if your game is healthy, as such, it should return very quickly static bool IsHealthy() { // Return whether your game server should be considered healthy return true; } static void Main(string[] args) { GameserverSDK.Start(); GameserverSDK.RegisterHealthCallback(IsHealthy); // Continue initializing your game } ``` ```java theme={null} private static ArrayList players = new ArrayList(); private static void onPlayerConnected() { // When a new player connects, you can let PlayFab know by adding it to the vector of players and calling updateConnectedPlayers players.add(new ConnectedPlayer("player_tag")); GameserverSDK.updateConnectedPlayers(players); } // This method will be called on every heartbeat to check if your game is healthy, as such, it should return very quickly private static GameHostHealth getGameHealth() { // Return whether your game server should be considered healthy return GameHostHealth.Healthy; } static void Main(string[] args) { GameserverSDK.start(); GameserverSDK.registerHealthCallback(Main::getGameHealth); // Continue initializing your game } ``` ## Obtener opciones de configuración en el servidor de juegos Hay varias opciones de configuración de PlayFab relacionadas con el servidor de juegos que puede recuperar mediante el GSDK. > [!NOTE] > > Dos de estas opciones de configuración las pasan *en realidad* sus clientes a PlayFab, como parte de la llamada para solicitar un servidor multijugador. Por lo tanto, esas opciones *no* estarán disponibles para el servidor de juegos hasta que se asigne. ```cpp theme={null} // Get all the configuration values std::unordered_map config = Microsoft::Azure::Gaming::GSDK::getConfigSettings(); // Retrieve a particular configuration value auto it = config.find(Microsoft::Azure::Gaming::GSDK::SESSION_COOKIE_KEY); if (it != config.end()) { std::string sessionCookie = config[Microsoft::Azure::Gaming::GSDK::SESSION_COOKIE_KEY]; } // Here some other useful configuration keys (the full list is in gsdk.h) static constexpr const char* SERVER_ID_KEY; // ID given to your game server upon creation static constexpr const char* LOG_FOLDER_KEY; // Path to the folder that should contain all log files static constexpr const char* CERTIFICATE_FOLDER_KEY; // Path to the folder that contains any game certificate files static constexpr const char* TITLE_ID_KEY; // PlayFab Title ID for this game server static constexpr const char* BUILD_ID_KEY; // PlayFab Build ID for this game server static constexpr const char* REGION_KEY; // Azure Region this server is running in // These two keys are only available after allocation (once readyForPlayers returns true) static constexpr const char* SESSION_COOKIE_KEY; // The Session Cookie you passed into the allocation call when you requested a server static constexpr const char* SESSION_ID_KEY; // The Session ID you specified in the allocation call when you requested a server ``` ```csharp theme={null} // Get all the configuration values IDictionary config = GameserverSDK.getConfigSettings(); // Retrieve a particular configuration value if (config.TryGetValue(GameserverSDK.SessionCookieKey, out string sessionCookie)) { // sessionCookie contains the value } // Here are some other useful configuration keys (the full list is in the GameserverSDK class) public static string ServerIdKey; // ID given to your game server upon creation public static string LogFolderKey; // Path to the folder that should contain all log files public static string CertificateFolderKey; // Path to the folder that contains any game certificate files public static string TitleIdKey; // PlayFab Title ID for this game server public static string BuildIdKey; // PlayFab Build ID for this game server public static string RegionKey; // Azure Region this server is running in // These two keys are only available after allocation (once readyForPlayers returns true) public static string SessionCookieKey; // The Session Cookie you passed into the allocation call when you requested a server public static string SessionIdKey; // The Session ID you specified in the allocation call when you requested a server ``` ```java theme={null} // Get all the configuration values Map config = GameserverSDK.getConfigSettings(); // Retrieve a particular configuration value if (config.containsKey(GameserverSDK.SESSION_COOKIE_KEY)) { String sessionCookie = config.get(GameserverSDK.SESSION_COOKIE_KEY); } // Here are some other useful configuration keys (the full list is in the GameserverSDK class) public static final String SERVER_ID_KEY; // ID given to your game server upon creation public static final String LOG_FOLDER_KEY; // Path to the folder that should contain all log files public static final String CERTIFICATE_FOLDER_KEY; // Path to the folder that contains any game certificate files public static final String TITLE_ID_KEY; // PlayFab Title ID for this game server public static final String BUILD_ID_KEY; // PlayFab Build ID for this game server public static final String REGION_KEY; // Azure Region this server is running in // These two keys are only available after allocation (once readyForPlayers returns true) public static final String SESSION_COOKIE_KEY; // The Session Cookie you passed into the allocation call when you requested a server public static final String SESSION_ID_KEY; // The Session ID you specified in the allocation call when you requested a server ``` ## Related topics - [Depuración local de servidores de juego e integración con PlayFab](https://devdocs.xbox.com/es/services/playfab/multiplayer/servers/locally-debugging-game-servers-and-integration-with-playfab.md) - [Creación e implementación de compilaciones de Linux](https://devdocs.xbox.com/es/services/playfab/multiplayer/servers/deploying-linux-based-builds.md) - [Creación de una compilación de servidor de juegos](https://devdocs.xbox.com/es/services/playfab/multiplayer/servers/author-a-game-server-build.md) - [Uso de PlayFab Multiplayer Servers para hospedar juegos multijugador](https://devdocs.xbox.com/es/services/playfab/multiplayer/servers/using-playfab-servers-to-host-games.md) - [Ciclo de vida de un servidor multijugador](https://devdocs.xbox.com/es/services/playfab/multiplayer/servers/multiplayer-game-server-lifecycle.md)