> ## 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.

# Conflictos de Game Saves

> Resuelva conflictos de PlayFab Game Saves cuando los datos de guardado locales y en la nube divergen, con estrategias de sincronización para proteger el progreso del jugador entre dispositivos.

# Conflictos de guardados de juego y unidades atómicas

## Información general

Los conflictos de guardado se producen cuando modifica los mismos datos del juego en varios dispositivos. El sistema necesita decidir qué versión conservar. Para diseñar la estructura de sus datos de guardado, debe comprender cómo el sistema detecta y resuelve los conflictos.

## Cuándo se producen los conflictos

Los conflictos se producen durante la operación de sincronización (`PFGameSaveFilesAddUserWithUiAsync`) solo cuando todas las condiciones siguientes son verdaderas:

1. **Existen cambios locales**: Modificó archivos localmente desde la última sincronización.
2. **Existen cambios en la nube**: Otro dispositivo cargó datos más recientes desde la última sincronización.
3. **Misma unidad atómica**: Ambos cambios están en la misma carpeta de nivel raíz.

### Matriz de detección de conflictos

| Cambios en el dispositivo local | La nube tiene cambios en la misma unidad atómica | Resultado               |
| ------------------------------- | ------------------------------------------------ | ----------------------- |
| Archivos modificados            | Sí                                               | **CONFLICTO**           |
| Archivos eliminados             | Sí                                               | **CONFLICTO**           |
| Sin cambios                     | Sí                                               | La descarga continúa    |
| Archivos modificados            | No                                               | La carga continúa       |
| Archivos eliminados             | No                                               | La eliminación continúa |

## ¿Qué es una unidad atómica?

Algunos sistemas de sincronización de archivos tratan los conflictos archivo por archivo. Si el mismo archivo necesita cargarse y descargarse, hay un conflicto. En Game Saves, cada subcarpeta de nivel raíz se trata como una *unidad atómica*.

<Note>
  **Cada subcarpeta de nivel raíz es una unidad atómica.**
</Note>

Si algún archivo o subcarpeta dentro de una subcarpeta de nivel raíz necesita descargarse y algún archivo o carpeta de esa misma subcarpeta raíz necesita cargarse, entonces toda la unidad atómica está en conflicto.

Este enfoque le permite:

* **Mantener la integridad de los datos**: Los archivos interdependientes se mantienen coherentes juntos
* **Proporcionar aislamiento**: Los datos independientes en carpetas separadas se sincronizan sin conflictos
* **Minimizar los conflictos**: Los cambios en unidades atómicas diferentes en dispositivos diferentes se combinan automáticamente

### Ejemplo de estructura de guardado

```
SaveRoot/
├── save.dat              ← Atomic unit: root
├── player.dat            ← Atomic unit: root
├── Save1/
│   ├── stats.json        ← Atomic unit: Save1
│   └── inventory.json    ← Atomic unit: Save1
├── Save2/
│   ├── stats.json        ← Atomic unit: Save2
│   └── inventory.json    ← Atomic unit: Save2
└── WorldState/
    ├── map.dat           ← Atomic unit: WorldState
    └── npcs/
        └── positions.dat ← Atomic unit: WorldState
```

### Escenarios de conflicto

| Cambios en el dispositivo A | Cambios en el dispositivo B     | ¿Conflicto? | Por qué                                   |
| --------------------------- | ------------------------------- | ----------- | ----------------------------------------- |
| `Save1/stats.json`          | `Save1/inventory.json`          | **SÍ**      | Misma unidad atómica: Save1               |
| `Save1/stats.json`          | `Save2/stats.json`              | No          | Unidades diferentes: Save1 frente a Save2 |
| `WorldState/map.dat`        | `WorldState/npcs/positions.dat` | **SÍ**      | Misma unidad atómica: WorldState          |
| `save.dat`                  | `Save1/stats.json`              | No          | Unidades diferentes: raíz frente a Save1  |
| `player.dat`                | `save.dat`                      | **SÍ**      | Misma unidad atómica: raíz                |

## Archivos de nivel raíz: caso especial

**Todos los archivos en la raíz del guardado comparten una unidad atómica.**

El sistema agrupa todos los archivos que coloca directamente en la raíz del guardado (no en ninguna subcarpeta) como una sola unidad atómica. Si modifica un archivo de nivel raíz localmente y otro dispositivo modifica un archivo de nivel raíz diferente, esta diferencia desencadena un conflicto.

| Dispositivo A (local)    | Dispositivo B (nube)        | ¿Misma unidad atómica? | Resultado                           |
| ------------------------ | --------------------------- | ---------------------- | ----------------------------------- |
| Modifica `rootfile1.txt` | Modifica `rootfile2.txt`    | ✅ SÍ                   | **CONFLICTO**                       |
| Modifica `rootfile1.txt` | Modifica `save1/config.ini` | ❌ NO                   | Sin conflicto, ambos se sincronizan |
| Elimina `save.dat`       | Modifica `progress.dat`     | ✅ SÍ                   | **CONFLICTO**                       |

## Opciones de elección del usuario

Cuando se producen conflictos, los jugadores eligen entre:

* **Usar datos locales (conservar los locales)**: Conservar los datos de guardado actuales del dispositivo.
* **Usar datos de la nube (conservar los de la nube)**: Descargar y usar los datos de guardado de la nube.

### Fundamental: la resolución es todo o nada

<Note>
  ⚠️ **Importante**: Aunque las unidades atómicas determinan *cuándo* se detecta un conflicto, la elección de resolución de conflictos del usuario se aplica al **guardado completo**, no a cada unidad atómica.
</Note>

### Ejemplo: escenario de conflicto mixto

```
SaveRoot/
├── SlotA/ ← Local: modified, Cloud: modified  → CONFLICT
├── SlotB/ ← Local: modified, Cloud: unchanged → Local-only change
├── SlotC/ ← Local: unchanged, Cloud: modified → Cloud-only change
└── SlotD/ ← Local: modified, Cloud: unchanged → Local-only change
```

**El usuario ve el aviso de conflicto** (debido a SlotA).

| Elección del usuario | SlotA                       | SlotB                                | SlotC                                | SlotD                                |
| -------------------- | --------------------------- | ------------------------------------ | ------------------------------------ | ------------------------------------ |
| **Conservar local**  | ✅ Se conserva lo local      | ✅ Se carga lo local                  | ❌ El cambio de la nube se **PIERDE** | ✅ Se carga lo local                  |
| **Conservar nube**   | ✅ Se descarga lo de la nube | ❌ El cambio local se **sobrescribe** | ✅ Se descarga lo de la nube          | ❌ El cambio local se **sobrescribe** |

### Por qué es importante

1. **Conservar local pierde los cambios solo en la nube**: Si elige "Conservar local" debido a un conflicto en SlotA, no recibe la actualización de la nube en SlotC que hizo otro dispositivo.

2. **Conservar nube pierde los cambios solo locales**: Si elige "Conservar nube", el estado de la nube sobrescribe sus cambios locales en SlotB y SlotD.

3. **Reversión disponible**: Ambas elecciones conservan la rama descartada para una futura capacidad de reversión.

### Resumen de diseño

| Aspecto                      | Granularidad                         |
| ---------------------------- | ------------------------------------ |
| **Detección** de conflictos  | Por unidad atómica (subcarpeta raíz) |
| **Resolución** de conflictos | Guardado completo (todo o nada)      |

Este enfoque de todo o nada simplifica la experiencia del jugador. Aunque la resolución por unidad atómica mantiene técnicamente la coherencia de los datos (dado que las unidades atómicas definen los límites de coherencia), crea desafíos de experiencia de usuario:

* Los jugadores necesitan entender el concepto de unidades atómicas y los límites de carpetas.
* Los resultados mixtos (algunas carpetas locales, otras de la nube) pueden dejar a los jugadores confundidos sobre el estado final.
* Preguntar por cada unidad atómica en conflicto por separado hace que la resolución de conflictos sea abrumadora.

Al presentar una única elección entre **Conservar local** y **Conservar nube**, los jugadores toman una decisión clara sin necesidad de entender la estructura de guardado subyacente.

## Cuándo no se producen conflictos

### Eliminación en ambos lados

Si ambos dispositivos eliminan el mismo archivo (o archivos de la misma unidad atómica), **no se produce ningún conflicto**. El sistema reconoce que ambos dispositivos están de acuerdo en que el archivo debe quitarse.

### Cambios en unidades atómicas diferentes

Si el dispositivo A modifica archivos en `SlotA/` y el dispositivo B modifica archivos en `SlotB/`, no se produce ningún conflicto. La sincronización combina automáticamente ambos cambios.

## Procedimientos recomendados

### 1. Diseñe cuidadosamente la estructura de carpetas

Use subcarpetas para unidades de guardado independientes:

```
SaveRoot/
├── Slot1/           ← Each slot is independent
│   └── save.dat
├── Slot2/
│   └── save.dat
```

Un sistema de guardado de juego basado en ranuras donde cada ranura es una subcarpeta de nivel raíz es un ejemplo sencillo de cómo puede usar las unidades atómicas de forma eficaz.

Otros ejemplos incluyen:

* **Datos de referencia compartidos**: Almacene los datos que cualquier ranura de guardado pueda usar, como contenido desbloqueado o logros, en su propia subcarpeta para que se sincronicen de forma independiente de las ranuras de guardado individuales.
* **Colecciones grandes de recursos**: Si su juego almacena conjuntos grandes de archivos que se actualizan de forma independiente, como paquetes de contenido descargado o niveles creados por los usuarios, considere dividirlos en varias subcarpetas raíz para que las actualizaciones de una colección no entren en conflicto con las actualizaciones de otra.

### 2. Evite archivos de nivel raíz para datos modificados con frecuencia

Todos los archivos de nivel raíz comparten una unidad atómica. Evite colocar archivos modificados con frecuencia en la raíz si desea sincronizarlos de forma independiente.

**En lugar de:**

```
SaveRoot/
├── autosave.dat     ← All root files = 1 atomic unit
└── save1.dat
└── save2.dat
```

**Considere:**

```
SaveRoot/
├── AutoSave/
│   └── autosave.dat     ← Independent unit
└── Save1/
    └── gamesave.dat ← Independent unit
```

### 3. Agrupe los datos relacionados

Use la misma carpeta para los archivos que deben mantenerse coherentes juntos.

```
SaveRoot/
├── Save1/
│   ├── stats.json       ← These files are interdependent
│   ├── inventory.json   ← and should conflict together
│   └── quests.json
```

### 4. Minimice los conflictos

Cargue con frecuencia para reducir la posibilidad de conflictos. Cuanto más a menudo sincronice, menos probable es que dos dispositivos tengan cambios divergentes.

### 5. Supervise las tasas de conflicto

Use los [eventos de PlayStream](/services/playfab/player-progression/game-saves/playstream-events) para realizar el seguimiento de la frecuencia con la que se producen conflictos y de cómo los resuelven los jugadores. Una tasa de conflictos en aumento o una fuerte inclinación hacia "conservar local" frente a "conservar remoto" puede indicar problemas de experiencia de usuario o de cadencia de guardado que vale la pena investigar.


## Related topics

- [Inicio rápido de Game Saves](/es/services/playfab/player-progression/game-saves/quickstart.md)
- [Reversión de Game Saves](/es/services/playfab/player-progression/game-saves/rollback.md)
- [Devoluciones de llamada de la interfaz de usuario de Game Saves](/es/services/playfab/player-progression/game-saves/ui-callbacks.md)
- [Cuadros de diálogo del sistema de Game Saves](/es/build/core-features/common/game-save/game-saves-dialogues.md)
- [Estrategias de vinculación de cuentas para PlayFab Game Saves](/es/services/playfab/player-progression/game-saves/linking.md)