> ## 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. # Eventos de PlayStream de Game Saves > Referencia de los eventos de PlayStream de PlayFab Game Saves, que cubre los campos de telemetría de finalización de versiones, resolución de conflictos y reversión a versiones correctas conocidas. PlayFab Game Saves emite eventos de PlayStream que puede usar para realizar el seguimiento de cómo los jugadores guardan, sincronizan y administran los datos de su juego. Use estos eventos para supervisar la actividad de guardado, detectar conflictos y comprender los patrones de uso entre dispositivos en toda su base de jugadores. Todos los eventos de Game Saves se emiten sobre entidades `title_player_account` en el espacio de nombres `playfab.gamesave`. ## Eventos ### `gamesave_version_finalized` Se emite cada vez que se finaliza una versión de guardado del juego. Todos los archivos están cargados y la versión está completa. Este evento es la señal principal para realizar el seguimiento de la actividad de guardado. | Campo | Tipo | Descripción | | ------------------------ | ---------- | --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `Version` | `long` | El número de versión del guardado de juego finalizado | | `FinalizedAt` | `DateTime` | Marca de tiempo de cuando se finalizó la versión | | `TotalSizeBytes` | `long` | Tamaño total de la versión finalizada, incluidos todos los archivos | | `TotalFileCount` | `int` | Número total de archivos en la versión finalizada | | `NewFileCount` | `int` | Número de archivos nuevos agregados en esta versión | | `NewFilesSizeBytes` | `long` | Tamaño de los archivos nuevos agregados en esta versión | | `PlayerIdentityProvider` | `string` | El proveedor de identidad que usó el jugador (por ejemplo, Steam, XBOX Live) | | `DeviceType` | `string` | El tipo de dispositivo desde el que se cargó el guardado | | `IsGeneratedByRollback` | `bool` | `true` si esta versión se creó al revertir a una versión anterior | | `Conflict` | `Conflict` | Presente cuando esta versión se finalizó como parte de una resolución de conflictos. `null` en caso contrario. Consulte [Resolución de conflictos](#scenario-conflict-resolution) | **Conflict** (objeto anidado, presente solo durante la resolución de conflictos): | Campo | Tipo | Descripción | | -------------------- | ------ | ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- | | `IsWinner` | `bool` | Indica si los cambios locales del jugador ganaron el conflicto. El evento siempre corresponde a un manifiesto nuevo creado a partir de los datos locales del cliente. `true` significa que ese manifiesto se convirtió en la versión canónica; `false` significa que el manifiesto se conservó como punto de reversión mientras la versión existente en la nube siguió siendo la canónica | | `ConflictingVersion` | `long` | El número de versión de la versión existente en la nube que estaba en conflicto | ### `gamesave_version_marked_known_good` Se emite cuando una versión de guardado del juego se marca explícitamente como "correcta conocida". Una versión correcta conocida sirve como punto de restauración de confianza. La versión a la que el sistema revierte si un jugador o el título necesita recuperarse de un estado de guardado incorrecto. | Campo | Tipo | Descripción | | ---------- | ---------- | ---------------------------------------------- | | `Version` | `long` | La versión que se marcó como correcta conocida | | `MarkedAt` | `DateTime` | Marca de tiempo de cuando se marcó la versión | *** ## Escenarios ### Escenario: uso estándar entre dispositivos Un flujo típico entre dispositivos consiste en un jugador que guarda en un dispositivo y reanuda en otro. En PlayStream, este patrón aparece como una secuencia de eventos `gamesave_version_finalized` con números de `Version` que se incrementan. **Lo que ve:** * Un evento `gamesave_version_finalized` cada vez que el jugador guarda, con `DeviceType` y `PlayerIdentityProvider` que indican qué dispositivo y proveedor de identidad se usaron. * `NewFileCount` y `NewFilesSizeBytes` muestran cuántos datos cambiaron en comparación con la versión anterior. Una versión donde `NewFileCount` es 0 significa que el jugador finalizó una versión sin contenido de archivos nuevo (por ejemplo, una actualización solo de metadatos). * `Conflict` es `null` e `IsGeneratedByRollback` es `false` para los guardados normales. **A qué debe prestar atención:** * **Frecuencia de guardado por jugador**: Realice el seguimiento de la tasa de eventos de finalización para comprender la implicación de los jugadores y su comportamiento de guardado. * **Tamaños de guardado a lo largo del tiempo**: Supervise `TotalSizeBytes` y `NewFilesSizeBytes` para detectar un crecimiento inesperado en los datos de guardado que podría afectar a los costos de almacenamiento o a los tiempos de sincronización. * **Distribución de dispositivos**: Agregue `DeviceType` para comprender desde qué plataformas guardan sus jugadores con mayor frecuencia. ### Escenario: resolución de conflictos Los conflictos se producen cuando dos dispositivos finalizan una versión de guardado del juego a partir de la misma versión base. Por ejemplo, un jugador podría jugar sin conexión en su consola y en su PC al mismo tiempo, y ambos dispositivos intentan sincronizar cuando vuelven a estar en línea. **Lo que ve:** * Durante la resolución de conflictos, el cliente siempre carga sus archivos locales en un manifiesto nuevo y finaliza el manifiesto. Este proceso produce un único evento `gamesave_version_finalized` con un objeto `Conflict` no nulo. La versión existente en la nube (ya finalizada en un evento anterior) no produce un evento nuevo. * `Conflict.IsWinner` le indica si los cambios locales del jugador ganaron el conflicto: * `true`: el jugador eligió **conservar local**. El manifiesto nuevo se convierte en la versión canónica y la versión anterior en la nube queda reemplazada. * `false`: el jugador eligió **conservar remoto**. El manifiesto nuevo se conserva como punto de reversión (que contiene los datos locales rechazados), mientras que la versión existente en la nube sigue siendo la canónica. * `Conflict.ConflictingVersion` apunta a la versión existente en la nube que estaba en conflicto. **A qué debe prestar atención:** * **Tasa de conflictos**: Filtre los eventos `gamesave_version_finalized` en los que `Conflict` esté presente. Una tasa de conflictos en aumento podría indicar que los jugadores cambian de dispositivo con frecuencia sin sincronizar, o que la cadencia de guardado de su título causa colisiones de versión innecesarias. * **Preferencia local frente a remota**: Compare la proporción de `IsWinner = true` (se conservó lo local) frente a `IsWinner = false` (se conservó lo remoto) para comprender cómo resuelven los conflictos los jugadores. Una fuerte inclinación hacia un lado podría indicar un problema de experiencia de usuario con el aviso de conflicto. * **Patrones de conflicto entre dispositivos**: Use `DeviceType` y `PlayerIdentityProvider` en los eventos de conflicto para comprender qué combinaciones de plataformas son más propensas a los conflictos. ### Escenario: versión correcta conocida y reversión El mecanismo de "correcta conocida" le permite marcar una versión específica como punto de restauración de confianza. Si el guardado de un jugador se daña o necesita recuperarse, el sistema puede revertir a la versión correcta conocida más reciente y crear una versión nueva a partir de ella. **Lo que ve:** * Un evento `gamesave_version_marked_known_good` cuando designa una versión como punto de restauración, con el número de `Version` y la marca de tiempo `MarkedAt`. * Si se produce una reversión, el sistema emite un evento `gamesave_version_finalized` nuevo con `IsGeneratedByRollback = true`. El contenido de esta versión nueva se basa en la versión correcta conocida, pero recibe un número de versión nuevo e incrementado. * La versión generada por la reversión también puede tener datos de `Conflict` si la reversión se desencadenó como parte de una resolución de conflictos. **A qué debe prestar atención:** * **Frecuencia de reversión**: Realice el seguimiento de los eventos `gamesave_version_finalized` en los que `IsGeneratedByRollback = true`. Las reversiones frecuentes en un título podrían indicar problemas de daños en los guardados o problemas con la lógica de guardado del título. * **Actualización de la versión correcta conocida**: Compare la `Version` en `gamesave_version_marked_known_good` con la última `Version` finalizada para el mismo jugador. Una brecha grande significa que el jugador perdería un progreso significativo si se necesita una reversión. * **Correlación entre reversión y conflicto**: Si las versiones generadas por reversión aparecen con frecuencia junto con datos de conflicto, ese patrón podría sugerir que su estrategia de resolución de conflictos está desencadenando reversiones como efecto secundario. ## Related topics - [Referencia del modelo de eventos de PlayStream para PlayFab](/es/services/playfab/api-references/events/index.md) - [PlayStream con eventos de entidad](/es/services/playfab/data-analytics/ingest-data/playstream-with-entity-events.md) - [Inicio rápido de propiedades personalizadas de jugador](/es/services/playfab/live-service-management/game-configuration/segmentation/player-custom-properties-qs.md) - [Uso de etiquetas personalizadas para personalizar los eventos](/es/services/playfab/data-analytics/ingest-data/playstream-custom-tags.md) - [Uso de acciones de CloudScript con PlayStream](/es/services/playfab/data-analytics/acting-data/action-rules-using-cloudscript-actions-with-playstream.md)