> For the complete documentation index, see [llms.txt](https://docs.decentraland.org/llms.txt). Markdown versions of documentation pages are available by appending `.md` to page URLs; this page is available as [Markdown](https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/interactividad/runtime-data.md).

# Datos en tiempo de ejecución

Obtén datos del contexto en el que se ejecuta tu escena y de la propia escena.

## Obtener la hora de Decentraland

Decentraland sigue un ciclo de día/noche que tarda 2 horas en completarse, por lo que hay 12 ciclos completos cada día. Los jugadores también pueden cambiar la configuración para experimentar una hora fija específica del día; por ejemplo, para ver siempre Decentraland con un cielo nocturno de las 10 p. m. Por esta razón, la hora de Decentraland puede variar de un jugador a otro.

Usa `getWorldTime()` para obtener la hora del día que el jugador está experimentando dentro de Decentraland.

```ts
import { getWorldTime } from '~system/Runtime'

executeTask(async () => {
  let time = await getWorldTime({})
  console.log(time.seconds)
})
```

{% hint style="info" %}
**💡 Consejo**: El `getWorldTime()` la función es asíncrona. Consulta [Funciones asíncronas](/creator/content-creator-es/scenes-sdk7/patrones-de-programacion/async-functions.md) si no estás familiarizado con ellas.
{% endhint %}

`getWorldTime()` devuelve un objeto con una `seconds` propiedad. Esta propiedad indica cuántos segundos han pasado (en la hora de Decentraland) desde el inicio del día, asumiendo que el ciclo completo dura 24 horas. Divide el valor de seconds entre 60 para obtener los minutos, y otra vez entre 60 para obtener las horas desde el inicio del día. Por ejemplo, si el `seconds` valor es *36000*, corresponde a *10 a. m.*.

En la hora de Decentraland, el sol siempre sale a las 6:15 y se pone a las 19:50.

Podrías usar esta información para cambiar la escena en consecuencia; por ejemplo, para reproducir sonidos de pájaros cuando hay luz del día y grillos cuando está oscuro, o para activar los materiales emisivos de las farolas cuando está oscuro.

```ts
import { getWorldTime } from '~system/Runtime'

executeTask(async () => {
  let time = await getWorldTime({})
  console.log(time.seconds)
  if (time.seconds < 6.25 * 60 * 60 || time.seconds > 19.85 * 60 * 60) {
    // noche
    console.log('reproduciendo sonidos de grillos')
  } else {
    // día
    console.log('reproduciendo sonidos de pájaros')
  }
})
```

## Obtener datos del Realm

Los jugadores en Decentraland existen en varios *realms*. Los jugadores en distintos realms no pueden verse, interactuar ni chatear entre sí, incluso si están parados en los mismos parcels. Dividir a los jugadores de esta manera permite a Decentraland manejar una cantidad ilimitada de jugadores sin encontrarse con ninguna limitación. También empareja a los jugadores que están en regiones cercanas, para garantizar que los tiempos de ping entre jugadores que interactúan sean aceptables.

Si tu escena envía datos a un [servidor de terceros](/creator/content-creator-es/scenes-sdk7/networking/third-party-servers.md) para sincronizar cambios entre jugadores en tiempo real, entonces a menudo es importante que los cambios solo se sincronicen entre jugadores que están en el mismo realm. Debes tratar todos los cambios que pertenecen a un realm como algo separado de los de un realm diferente. De lo contrario, los jugadores verán que las cosas cambian de una manera extraña, sin que nadie haga el cambio.

```ts
import { getRealm } from '~system/Runtime'

executeTask(async () => {
  const { realmInfo } = await getRealm({})
  if (!realmInfo) return
  console.log(`Estás en el realm: `, realmInfo.realmName)
})
```

{% hint style="info" %}
**💡 Consejo**: El `getRealm()` la función es asíncrona. Consulta [Funciones asíncronas](/creator/content-creator-es/scenes-sdk7/patrones-de-programacion/async-functions.md) si no estás familiarizado con ellas.
{% endhint %}

Decentraland gestiona sus comunicaciones entre jugadores (incluidas las posiciones de los jugadores, el chat, los mensajes de messageBus y los cambios de estado de smart item) a través de una red descentralizada de servidores de comunicación; a cada uno de estos servidores se le llama **Realm**. Cada uno de estos servidores puede soportar múltiples **salas** (también llamadas **islas**), cada una agrupando a un conjunto diferente de jugadores que están cerca entre sí en el mapa de Decentraland.

El `getRealm()` la función devuelve la siguiente información:

* `baseUrl`: *(string)* El dominio del servidor del realm
* `realmName`: *(string)* El nombre del servidor del realm
* `networkId`: *(number)* La red Ethereum
* `commsAdapter`: *(string)* Adaptador de comms, eliminando todos los parámetros de consulta (credenciales)
* `isPreview`: *(boolean)* Verdadero si la escena se está ejecutando como una vista previa local, en lugar de estar publicada en Decentraland.
* `isConnectedSceneRoom`: *(boolean)* Verdadero si el usuario está conectado a la sala de la escena.

{% hint style="warning" %}
**📔 Nota**: El `layer` la propiedad está obsoleta y debe evitarse.
{% endhint %}

A medida que los jugadores se mueven por el mapa, pueden cambiar de sala para agruparse con los jugadores que ahora están más cerca de ellos. Las salas también desplazan sus bordes dinámicamente para ajustarse a un grupo manejable de personas, así que incluso si un jugador se queda quieto, a medida que los jugadores entran y salen del mundo, el jugador podría encontrarse en otra sala. Los jugadores en la misma `sala` se comunican, y compartirán mensajes a través de MessageBus incluso si están demasiado lejos para verse entre sí. Actualmente, los jugadores en el mismo servidor pero en diferentes salas no se comunican, pero podrían empezar a comunicarse a medida que se mueven por el mapa y cambian de sala.

Para reaccionar a cambios relacionados con el realm o la sala del jugador, usa el `onChange` función en el `RealmInfo` componente, que el engine añade a la `engine.RootEntity`. Este componente contiene los mismos campos que devuelve `getRealm()`.

```ts
import { engine, RealmInfo } from '@dcl/sdk/ecs'

export function main() {
	RealmInfo.onChange(engine.RootEntity, (realmInfo) => {
		if (!realmInfo) return
		console.log('Realm cambiado: ', realmInfo.realmName)
	})
}
```

{% hint style="warning" %}
**📔 Nota**: Cuando la escena se carga por primera vez, puede que todavía no haya una sala asignada al jugador. El Explorer terminará asignando una sala al jugador, pero a veces esto puede ocurrir un par de segundos después de que la escena se haya cargado.
{% endhint %}

## Obtener la plataforma del jugador

Los jugadores pueden acceder a Decentraland a través de varias plataformas, incluida la aplicación de escritorio oficial y las versiones web y de escritorio obsoletas, así como [clientes experimentales alternativos](https://github.com/decentraland/protocol-squad) creados para otros motores.

Usa `getExplorerInformation()` para saber en qué plataforma está ejecutando Decentraland el jugador actual.

```ts
import { getExplorerInformation } from '~system/Runtime';

executeTask(async () => {
  let data = await getExplorerInformation({})
  console.log("PLATAFORMA: ", data.platform, " AGENTE: ", data.agent)
})
```

Cuando se usa la aplicación de escritorio oficial de Decentraland, esta función debería devolver los siguientes datos:

```
{
    agent: unity-explorer,
    platform: desktop
}
```

Los jugadores que usan la aplicación de escritorio oficial de Decentraland probablemente tendrán una experiencia mucho más fluida que los que usan el navegador, ya que el navegador impone limitaciones de rendimiento sobre cuánta potencia de procesamiento de la máquina puede usar la pestaña. También echarán de menos muchas funciones como el control de la cámara, las luces dinámicas, congelar el movimiento del jugador, mejoras de la UI, etc.

## Obtener idioma del jugador

Usa `getPlayerLanguage()` para saber en qué idioma está configurado el cliente del jugador. Devuelve una [BCP 47](https://en.wikipedia.org/wiki/IETF_language_tag) etiqueta, como `'en'`, `'es'` ni `'pt-BR'`. Úsalo para elegir qué traducción de los textos de tu escena mostrar.

```ts
import { getPlayerLanguage, onPlayerLanguageChanged } from '@dcl/sdk/platform'

console.log('IDIOMA: ', getPlayerLanguage())

// Reaccionar a que el jugador cambie de idioma a mitad de sesión
onPlayerLanguageChanged.add(({ language }) => {
  console.log('IDIOMA CAMBIADO A: ', language)
})
```

`onPlayerLanguageChanged` se activa cada vez que el jugador cambia el idioma del cliente mientras está en tu escena. Los clientes más antiguos nunca lo emiten.

{% hint style="warning" %}
**📔 Nota**: `getPlayerLanguage()` devuelve `'en'` hasta que el Explorer haya informado su idioma a la escena, lo que ocurre poco después de que la escena se inicia. También devuelve `'en'` en clientes que no informan un idioma. Ambas funciones requieren `@dcl/sdk` la versión 7.30.0 o posterior.
{% endhint %}

## El componente EngineInfo

El `EngineInfo`el componente hace un seguimiento de datos sobre el ciclo de vida de la escena, lo que a veces puede ser útil para saber cuándo ocurre un evento en relación con la inicialización de la escena.

Este componente se añade al `engine.RootEntity`.

```ts
engine.addSystem((deltaTime) => {
  const engineInfo = EngineInfo.getOrNull(engine.RootEntity)
  if (!engineInfo) return

  console.log(
    '--------------' +
      '\nframeNumber: ' +
      engineInfo.frameNumber +
      '\ntickNumber: ' +
      engineInfo.tickNumber +
      '\ntotalRuntime: ' +
      engineInfo.totalRuntime +
      '\nsceneHidden: ' +
      engineInfo.sceneHidden +
      '\n--------------'
  )
})
```

Puedes usar `sceneHidden` para pausar el trabajo que consume muchos recursos mientras la escena no es visible:

```ts
engine.addSystem((deltaTime) => {
  const engineInfo = EngineInfo.getOrNull(engine.RootEntity)
  if (engineInfo?.sceneHidden) return

  // La lógica normal del gameplay solo se ejecuta cuando la escena es visible
})
```

El `EngineInfo` el componente contiene los siguientes datos:

* `frameNumber`: contador de fotogramas del engine.
* `totalRuntime`: tiempo total de ejecución de esta escena, en segundos.
* `tickNumber`: contador de ticks de la escena según [ADR-148](https://adr.decentraland.org/adr/ADR-148).
* `sceneHidden`: `true` cuando la escena está oculta detrás de la UI de pantalla completa del Explorer. Eso incluye la pantalla de carga, y también el mapa, la mochila y el menú de configuración. Úsalo para silenciar el audio y pausar el trabajo pesado mientras el jugador no puede ver la escena.

{% hint style="warning" %}
**📔 Nota**: El `EngineInfo` componente debe importarse mediante

> `import { EngineInfo } from "@dcl/sdk/ecs"`

Ver [Imports](/creator/content-creator-es/scenes-sdk7/primeros-pasos/coding-scenes.md#imports) para ver cómo manejarlos fácilmente.
{% endhint %}

### Reaccionar a que la pantalla de carga se desvanece

El `scene_hidden` el campo te indica si el jugador realmente puede ver tu escena o si está cubierta por la UI de pantalla completa del Explorer. Mientras la pantalla de carga está visible, `sceneHidden` es `true`. En el momento en que la pantalla de carga se desvanece y el jugador obtiene su primera vista del mundo, cambia a `false`.

Cambia a `true` de nuevo más tarde cada vez que una UI de pantalla completa del Explorer cubre la escena, como el mapa, la mochila o el menú de configuración. Eso lo convierte en una buena señal para silenciar [el audio](/creator/content-creator-es/scenes-sdk7/fundamentos-del-contenido-3d/sounds.md) y pausar los sistemas costosos, y luego reanudar cuando vuelva a `false`.

Esta es la única manera de que una escena sepa cuándo ocurre esa primera revelación. Úsalo para retener cualquier cosa que, de otro modo, se reproduciría detrás de la pantalla de carga y el jugador se la perdería: cinemáticas de introducción, sonidos de bienvenida, un tween que solo se aprecia bien si se ve, una UI de apertura o un evento de analytics que solo debería contar una vez que el jugador realmente está allí.

```ts
import { engine, EngineInfo } from '@dcl/sdk/ecs'

function onSceneRevealed() {
  // El jugador ahora está viendo la escena, inicia aquí la introducción
  console.log('La pantalla de carga acaba de desvanecerse')
}

engine.addSystem(function waitForSceneRevealed() {
  const engineInfo = EngineInfo.getOrNull(engine.RootEntity)
  if (!engineInfo || engineInfo.sceneHidden) return

  // Solo ejecutar una vez
  engine.removeSystem(waitForSceneRevealed)
  onSceneRevealed()
})
```

{% hint style="warning" %}
**📔 Nota**: Tu escena sigue ejecutándose con normalidad mientras `sceneHidden` es `true`, solo que no se está mostrando. No uses este campo para pausar la lógica de tu escena; úsalo para sincronizar aquello que se supone que el jugador debe presenciar.

`scene_hidden` requiere una versión actualizada de `@dcl/sdk` y una versión reciente del Decentraland Explorer. En los clientes más antiguos, el campo se mantiene en su valor predeterminado de `false`, así que una escena que espera por él sigue ejecutándose; solo que no estará sincronizada con el desvanecimiento de la pantalla de carga.
{% endhint %}


---

# Agent Instructions
This documentation is published with GitBook. GitBook is the documentation platform designed so that both humans and AI agents can read, navigate, and reason over technical content effectively. Learn more at gitbook.com.

## Querying This Documentation
If you need additional information that is not directly available in this page, you can query the documentation by asking a question.

Perform an HTTP GET request on the following URL with the `ask` and `goal` query parameters:

```
GET https://docs.decentraland.org/creator/content-creator-es/scenes-sdk7/interactividad/runtime-data.md?ask=<question>&goal=<user_goal>
```

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is what the user is ultimately trying to achieve, the reason they need the answer. Sharing it helps GitBook give you a better, more relevant answer. A goal is most helpful when it describes the outcome the user wants rather than restating the question. For example, with `ask=how do I create an API token`, a goal like `automate deployments from our CI pipeline` lets GitBook tailor the answer to that use case.

The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.