Esta página aún no está traducida: se muestra la versión en inglés.

Data

Cambias un campo y la sincronización viene sola. Data es la mecánica debajo de cada campo sincronizado: deltas respecto del último estado confirmado, el aspecto como unidad de política, prioridad y frecuencia de envío, suscripciones que se pueden reanudar, la ventana de retención y hooks antes y después de cada cambio.

Te diriges a entidades, no a tablas: la interfaz para leer y cambiar (buscar, filtrar, ordenar, paginar, suscribirse a una selección) está en Entity; esta página describe la mecánica que hay debajo. Quien consume no tiene ningún camino hacia una tabla, y no hay una segunda forma de escribir: un cambio es una operación de Entity, y el delta es lo que resulta de ella.

Cuándo usarlo

• Necesitas replicar el estado a los clientes sin escribir código de snapshots: cambiar un campo es toda la sincronización.
• Los campos difieren en urgencia o en audiencia: prioridad y un tope de frecuencia de envío por aspecto, y un predicado de visibilidad para la niebla de guerra.
• Un cliente que se reconecta no debe desincronizarse en silencio: el hueco se detecta y se nombra, y a un hueco más largo que la ventana de retención (retained window) se responde con el estado completo.
• Necesitas el pasado reciente: la ventana de retención de deltas, indexada por sim_time, es lo que leen la predicción y la compensación de lag (lag compensation).
• Una regla de validación debe vivir en un solo lugar: un hook previo al cambio acota el valor o veta el cambio antes de que se aplique.
• No toques los ajustes si solo necesitas leer o consultar. La interfaz de Entity se apoya en esta mecánica sin modificarla.

Quién hace qué

En resumen

public class Motion
{
    public Vector3 Position;
    [Sync(Hz = 4)] public float Fuel;                    // one field overrides the aspect
}

public class Loadout { public int Ammo; }

[Entity("tank")]
public class Tank
{
    [Aspect("motion", Priority = 10, Hz = 30)]           // policy lives on the aspect
    public Motion Motion = new();

    [Aspect("loadout", Visible = "owner == caller.player")]
    public Loadout Loadout = new();

    public float InternalHeat;                           // in no aspect — never leaves the server
}

tank.Motion.Position = next;   // ← the change; the delta is its consequence

export class Motion {
  position!: Vector3;
  @Sync({ hz: 4 }) fuel = 0;                             // one field overrides the aspect
}

export class Loadout { ammo = 0; }

@Entity('tank')
export class Tank {
  @Aspect('motion', { priority: 10, hz: 30 })            // policy lives on the aspect
  motion = new Motion();

  @Aspect('loadout', { visible: 'owner == caller.player' })
  loadout = new Loadout();

  internalHeat = 0;                                      // in no aspect — never leaves the server
}

tank.motion.position = next;   // ← the change; the delta is its consequence

class Motion:
    position: Vector3
    fuel: float = sync(hz=4)                             # one field overrides the aspect

class Loadout:
    ammo: int = 0

@entity("tank")
class Tank:
    motion: Motion = aspect("motion", priority=10, hz=30)          # policy lives on the aspect
    loadout: Loadout = aspect("loadout", visible="owner == caller.player")
    internal_heat: float = 0.0                           # in no aspect — never leaves the server

tank.motion.position = next_pos   # ← the change; the delta is its consequence

// declarations compile into the same pushed model — playserv push from the UE project or CI
USTRUCT()
struct FMotion
{
    GENERATED_BODY()

    UPROPERTY() FVector3f Position;
    UPROPERTY(PSSync = (Hz = 4)) float Fuel;             // one field overrides the aspect
};

USTRUCT()
struct FLoadout
{
    GENERATED_BODY()

    UPROPERTY() int32 Ammo;
};

UCLASS(PSEntity = "tank")
class UTank : public UObject
{
    GENERATED_BODY()

    UPROPERTY(PSAspect = (Name = "motion", Priority = 10, Hz = 30))   // policy lives on the aspect
    FMotion Motion;

    UPROPERTY(PSAspect = (Name = "loadout", Visible = "owner == caller.player"))
    FLoadout Loadout;

    float InternalHeat = 0.f;                            // no UPROPERTY, in no aspect — never leaves the server
};

Tank->Motion.Position = Next;   // ← the change; the delta is its consequence

public class Motion
{
    public Vector3 Position;
    [Sync(Hz = 4)] public float Fuel;                    // one field overrides the aspect
}

public class Loadout { public int Ammo; }

[Entity("tank")]
public class Tank
{
    [Aspect("motion", Priority = 10, Hz = 30)]           // policy lives on the aspect
    public Motion Motion = new();

    [Aspect("loadout", Visible = "owner == caller.player")]
    public Loadout Loadout = new();

    public float InternalHeat;                           // in no aspect — never leaves the server
}

tank.Motion.Position = next;   // ← the change; the delta is its consequence

El modelo

Qué lleva un delta.

Qué declara un aspecto.

Todo se declara con atributos, en el aspecto o en un campo concreto, nunca con una llamada en runtime. El aspecto fija el valor por defecto y un campo puede sobrescribirlo; el aspecto sigue siendo la unidad de política, porque si no, no habría nada con qué armar los presets.

Qué contiene una suscripción.

Lo que vale para cualquier flujo.

Qué puede hacer un hook, y cuándo.

[Before(Data.Change, aspect: "tank.motion")]
public static Verdict ClampFuel(Change<Motion> change) =>
    change.Next.Fuel < 0 ? Hook.Reject("negative fuel") : Hook.Continue(change);

export const clampFuel = before(Data.change, { aspect: 'tank.motion' }, (change: Change<Motion>) =>
  change.next.fuel < 0 ? Hook.reject('negative fuel') : Hook.continue(change));

@before(data.change, aspect="tank.motion")
def clamp_fuel(change: Change[Motion]) -> Verdict:
    return hook.reject("negative fuel") if change.next.fuel < 0 else hook.proceed(change)

El borrado tiene su hook en Entity, donde vive la eliminación; esta primitiva engancha el cambio.

Errores

• Un destino de suscripción no declarado es un rechazo de validación.
• Sin permiso para suscribirse se responde forbidden o not found, según si la existencia del destino es en sí un secreto: el rechazo no debe convertirse en un oráculo.
• Una posición de reanudación que no se puede interpretar es una solicitud incorrecta, nunca un reinicio silencioso desde ahora.
• Una suscripción cerrada del lado de la plataforma es un conflicto, y es observable: el closed de la máquina de estados es final, y el cliente no tiene que deducir que llegó ahí.
• Agotar el número de suscripciones es un conflicto: el permiso está, pero no queda capacidad.

Límites

Los números llegarán con el capítulo sobre los límites de la plataforma; lo que pasa en cada tope ya está definido.

• La ventana de retención de deltas: reanudar desde un punto más antiguo que la ventana entrega el estado completo en lugar de un rechazo.
• Suscripciones por actor: se rechaza la nueva y las existentes continúan.
• Tamaño del delta: el delta se divide en lugar de truncarse, y la división es observable.
• La frecuencia de envío: un límite superior, no una garantía.
• El costo de un paquete por actor: al agotarse, degradación declarada al paquete compartido.