# Dados de runtime

## Obter horário da Decentraland

Decentraland segue um ciclo dia/noite que leva 2 horas para ser concluído, então há 12 ciclos completos todos os dias. Os jogadores também podem alterar as configurações para experimentar um horário fixo específico do dia, por exemplo, para ver sempre Decentraland com um céu noturno às 22h. Por esse motivo, o tempo em Decentraland pode variar de um jogador para outro.

Use `getWorldTime()` para obter o horário do dia que o jogador está experimentando dentro de Decentraland.

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

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

{% hint style="info" %}
**💡 Dica**: A `getWorldTime()` function é assíncrona. Veja [Funções assíncronas](/creator/content-creator-pt/scenes-sdk7/padroes-de-programacao/async-functions.md) se você não estiver familiarizado com elas.
{% endhint %}

`getWorldTime()` retorna um objeto com uma `seconds` propriedade. Essa propriedade indica quantos segundos se passaram (no tempo de Decentraland) desde o início do dia, assumindo que o ciclo completo dura 24 horas. Divida o valor de seconds por 60 para obter minutos, e por 60 novamente para obter as horas desde o início do dia. Por exemplo, se o `seconds` valor for *36000*, ele corresponde a *10 AM*.

No tempo de Decentraland, o sol sempre nasce às 6:15 e se põe às 19:50.

Você pode usar essas informações para alterar a scene de acordo, por exemplo, para tocar sons de pássaros quando houver luz do dia e grilos quando estiver escuro, ou para ativar os materiais emissivos nos postes de rua quando estiver escuro.

```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) {
    // night time
    console.log('playing cricket sounds')
  } else {
    // day time
    console.log('playing bird sounds')
  }
})
```

## Obter dados do realm

Players em decentraland existem em vários *realms*. Players em diferentes realms não podem ver uns aos outros, interagir ou conversar entre si, mesmo que estejam em parcelas (parcels) iguais. Dividir os players dessa forma permite que Decentraland lide com uma quantidade ilimitada de players sem encontrar quaisquer limitações. Também agrupa players que estão em regiões próximas, para garantir que os tempos de ping entre players que interagem sejam aceitáveis.

Se sua scene enviar dados para um [servidor de 3ª parte](/creator/content-creator-pt/scenes-sdk7/networking/authoritative-servers.md) para sincronizar alterações entre players em tempo real, então muitas vezes é importante que as alterações sejam sincronizadas apenas entre players que estejam no mesmo realm. Você deve tratar todas as alterações que pertencem a um realm como separadas das de um realm diferente. Caso contrário, os players verão as coisas mudarem de uma forma assustadora, sem que ninguém faça a alteração.

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

executeTask(async () => {
  const { realmInfo } = await getRealm({})
  console.log(`Você está no realm: `, realmInfo.realmName)
})
```

{% hint style="info" %}
**💡 Dica**: A `getRealm()` function é assíncrona. Veja [Funções assíncronas](/creator/content-creator-pt/scenes-sdk7/padroes-de-programacao/async-functions.md) se você não estiver familiarizado com elas.
{% endhint %}

Decentraland lida com suas comunicações entre players (incluindo posições dos players, chat, mensagens do messageBus e alterações de estado de smart item) por meio de uma rede descentralizada de servidores de comunicação, cada um desses servidores é chamado de **Realm**. Cada um desses servidores pode suportar vários **rooms** (também chamados **islands**), cada um agrupando um conjunto diferente de players que estão próximos uns dos outros no mapa de Decentraland.

O `getRealm()` function retorna as seguintes informações:

* `baseUrl`: *(string)* O domínio do servidor do realm
* `realmName`: *(string)* O nome do servidor do realm
* `networkId`: *(number)* A rede Ethereum
* `commsAdapter`: *(string)* Adaptador de comms, removendo todos os parâmetros de consulta (credentials)
* `isPreview`: *(boolean)* Verdadeiro se a scene estiver sendo executada como uma pré-visualização local, em vez de publicada em Decentraland.
* `isConnectedSceneRoom`: *(boolean)* Verdadeiro se o usuário estiver conectado à sala da scene.

{% hint style="warning" %}
**📔 Nota**: A `layer` a propriedade está obsoleta e deve ser evitada.
{% endhint %}

À medida que os players se movem pelo mapa, eles podem trocar de rooms para serem agrupados com aqueles players que agora estão mais próximos deles. As rooms também deslocam seus limites dinamicamente para se ajustarem a um grupo administrável de pessoas, então mesmo que um player fique parado, à medida que players entram e saem do world, o player pode se encontrar em outra room. Players em um mesmo `room` são comunicados e compartilharão mensagens pelo MessageBus mesmo que estejam longe demais para se verem. Players no mesmo server, mas em rooms diferentes, atualmente não estão se comunicando, mas podem passar a se comunicar à medida que se movem pelo mapa e mudam de rooms.

Consulte [onRealmChangedObservable](/creator/content-creator-pt/scenes-sdk7/interatividade/event-listeners.md#player-changes-realm-or-island) para detectar alterações relacionadas ao realm ou à ilha do player.

{% hint style="warning" %}
**📔 Nota**: Quando a scene carrega pela primeira vez, pode ser que ainda não haja uma room atribuída ao player. O explorer eventualmente atribuirá uma room ao player, mas isso às vezes pode ocorrer alguns segundos depois de a scene ser carregada.
{% endhint %}

## Obter plataforma do player

Players podem acessar Decentraland por várias plataformas, incluindo o aplicativo oficial para desktop, e versões web e desktop obsoletas, bem como [clientes experimentais alternativos](https://github.com/decentraland/protocol-squad) criados para outros engines.

Use `getExplorerInformation()` para saber em qual plataforma o player atual está executando Decentraland.

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

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

Ao usar o aplicativo oficial de desktop de Decentraland, esta function deve retornar os seguintes dados:

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

Players que usam o aplicativo oficial de desktop de Decentraland provavelmente terão uma experiência muito mais fluida do que aqueles no browser, já que o browser impõe limitações de desempenho sobre quanto do poder de processamento da máquina a aba do navegador pode usar. Eles também ficarão sem muitos recursos, como controle de câmera, luzes dinâmicas, congelamento do movimento do player, melhorias de UI, etc.

## O Component EngineInfo

O `EngineInfo`component mantém o controle de dados sobre o ciclo de vida da scene, o que às vezes pode ser útil para saber quando um evento está ocorrendo, em relação à inicialização da scene.

Este component é adicionado ao `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--------------'
  )
})
```

O `EngineInfo`component contém os seguintes dados:

* `frame_number`: Contador de frames do engine
* `total_runtime`: Tempo total de execução desta scene em segundos
* `tick_number`: Contador de ticks da scene conforme [ADR-148](https://adr.decentraland.org/adr/ADR-148)

{% hint style="warning" %}
**📔 Nota**: A `EngineInfo` component tem de ser importado via

> `import { Vector3, Quaternion } from "@dcl/sdk/ecs"`

Consulte [Imports](/creator/content-creator-pt/scenes-sdk7/comecar/coding-scenes.md#imports) para saber como lidar com isso facilmente.
{% endhint %}


---

# Agent Instructions: 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:

```
GET https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/interatividade/runtime-data.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.