> 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/escenas-sdk7/interactividad/runtime-data.md).

# Datos de runtime

## Obtener la hora de Decentraland

Decentraland sigue un ciclo de día y 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 del día fija específica, 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**: La `getWorldTime()` función es asíncrona. Consulta [Funciones asíncronas](/creator/content-creator-es/escenas-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 transcurrido (en tiempo de Decentraland) desde el comienzo del día, suponiendo que el ciclo completo dura 24 horas. Divide el valor de seconds entre 60 para obtener los minutos, y entre 60 otra vez para obtener las horas desde el comienzo del día. Por ejemplo, si el `seconds` valor es *36000*, corresponde a *10 a. m.*.

En el tiempo 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 scene en consecuencia, por ejemplo para reproducir sonidos de pájaros cuando haya luz del día y grillos cuando esté oscuro, o para activar los materiales emisivos en 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) {
    // hora nocturna
    console.log('reproduciendo sonidos de grillos')
  } else {
    // hora diurna
    console.log('reproduciendo sonidos de pájaros')
  }
})
```

## Obtener datos del realm

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

Si tu scene envía datos a un [servidor de terceros](/creator/content-creator-es/escenas-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 forma inquietante, 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**: La `getRealm()` función es asíncrona. Consulta [Funciones asíncronas](/creator/content-creator-es/escenas-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 los smart items) a través de una red descentralizada de servidores de comunicación; cada uno de estos servidores se llama un **Realm**. Cada uno de estos servidores puede soportar múltiples **rooms** separados (también llamados **islands**), cada uno agrupando un conjunto diferente de jugadores que están cerca entre sí en el mapa de Decentraland.

La `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 de Ethereum
* `commsAdapter`: *(string)* Adaptador de comunicaciones, eliminando todos los parámetros de consulta (credenciales)
* `isPreview`: *(boolean)* Verdadero si la scene 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 scene.

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

A medida que los jugadores se mueven por el mapa, pueden cambiar de rooms para agruparse con aquellos jugadores que ahora están más cerca de ellos. Las rooms también ajustan sus límites de forma dinámica 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 world, el jugador podría encontrarse en otro room. Los jugadores en una misma `room` se comunican y compartirán mensajes a través de MessageBus incluso si están demasiado lejos para verse entre sí. Los jugadores en un mismo server pero en rooms diferentes no se están comunicando actualmente, pero podrían empezar a comunicarse a medida que se muevan por el mapa y cambien de rooms.

Para reaccionar a cambios respecto al realm o al room del jugador, usa la `onChange` función en el `RealmInfo` componente, que el engine añade a `engine.RootEntity`. Este componente contiene los mismos campos devueltos por `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 scene se carga por primera vez, puede que todavía no haya un room asignado para el jugador. El Explorer acabará asignando un room al jugador, pero esto a veces puede ocurrir un par de segundos después de que la scene 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 oficial de escritorio, 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 oficial de escritorio de Decentraland, esta función debería devolver los siguientes datos:

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

Es probable que los jugadores que usan la aplicación oficial de escritorio de Decentraland tengan 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 del navegador. También echarán en falta muchas funciones como el control de la cámara, las luces dinámicas, congelar el movimiento del jugador, mejoras de UI, etc.

## El componente EngineInfo

La `EngineInfo`lleva un seguimiento de los datos sobre el ciclo de vida de la Scene, lo que a veces puede ser útil para saber cuándo ocurre un evento, con respecto a la inicialización de la Scene.

Este componente se añade a `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 +
      '\n--------------'
  )
})
```

La `EngineInfo`El componente contiene los siguientes datos:

* `frame_number`: Contador de frames del engine
* `total_runtime`: Tiempo total de ejecución de esta Scene en segundos
* `tick_number`: Contador de ticks de la scene según [ADR-148](https://adr.decentraland.org/adr/ADR-148)

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

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

Consulta [Imports](/creator/content-creator-es/escenas-sdk7/primeros-pasos/coding-scenes.md#imports) para ver cómo gestionarlos fácilmente.
{% 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 dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter, and the optional `goal` query parameter:

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.