# Dados de Runtime

## Obter Decentraland Time

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

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

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

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

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

`getWorldTime()` retorna um objeto com um `seconds` propriedade. Esta 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 em segundos 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 é *36000*, corresponde a *10 AM*.

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

Você pode usar essa informação para alterar a cena de acordo, por exemplo para tocar sons de pássaros quando houver luz do dia e grilos quando estiver escuro, ou para ligar materiais emissivos em postes de luz 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

Jogadores em Decentraland existem em vários *realms*. Jogadores em diferentes realms não conseguem se ver, interagir ou conversar entre si, mesmo que estejam em parcelas iguais. Dividir os jogadores dessa forma permite que Decentraland lide com uma quantidade ilimitada de jogadores sem encontrar limitações. Também agrupa jogadores que estão em regiões próximas, para garantir que os tempos de ping entre jogadores que interagem sejam aceitáveis.

Se a sua cena enviar dados para um [servidor de terceiros](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/networking/authoritative-servers) para sincronizar mudanças entre jogadores em tempo real, então muitas vezes é importante que as mudanças sejam sincronizadas apenas entre jogadores que estão no mesmo realm. Você deve tratar todas as mudanças que pertencem a um realm como separadas daquelas em um realm diferente. Caso contrário, os jogadores verão as coisas mudarem de forma estranha, sem que ninguém tenha feito a mudança.

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

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

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

Decentraland gerencia suas comunicações entre jogadores (incluindo posições dos jogadores, chat, mensagens do messageBus e mudanças de estado de smart items) através de uma rede descentralizada de servidores de comunicação; cada um desses servidores é chamado de **Realm**. Cada um desses servidores pode suportar várias **rooms** (também chamadas de **islands**), cada uma agrupando um conjunto diferente de jogadores que estão próximos uns dos outros no mapa de Decentraland.

O `getRealm()` função 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)* Comms adapter, removendo todos os parâmetros de consulta (credentials)
* `isPreview`: *(boolean)* Verdadeiro se a cena estiver rodando como uma pré-visualização local, em vez de publicada em Decentraland.
* `isConnectedSceneRoom`: *(boolean)* Verdadeiro se o usuário estiver conectado à cena room.

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

Conforme os jogadores se movem pelo mapa, eles podem trocar de rooms para serem agrupados com aqueles jogadores que agora estão mais próximos deles. As rooms também deslocam suas fronteiras dinamicamente para caber em um grupo gerenciável de pessoas, então mesmo se um jogador ficar parado, à medida que jogadores entram e saem do mundo, o jogador pode se ver em outra room. Jogadores em um mesmo `room` são comunicados, e compartilharão mensagens pelo MessageBus mesmo que estejam longe demais para se verem. Jogadores num mesmo servidor mas em rooms diferentes atualmente não estão se comunicando, mas podem passar a se comunicar conforme se movem pelo mapa e mudam de rooms.

Veja [onRealmChangedObservable](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/event-listeners#player-changes-realm-or-island) para saber como detectar mudanças relativas ao realm ou ilha do jogador.

{% hint style="warning" %}
**📔 Nota**: Quando a cena é carregada pela primeira vez, pode ainda não haver uma room atribuída ao jogador. O Explorer eventualmente atribuirá uma room ao jogador, mas isso às vezes pode ocorrer alguns segundos após a cena ser carregada.
{% endhint %}

## Obter plataforma do jogador

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

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

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

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

Ao usar o app oficial de desktop do Decentraland, esta função deve retornar os seguintes dados:

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

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

## O componente EngineInfo

O `EngineInfo`componente rastreia dados sobre o ciclo de vida da cena, o que às vezes pode ser útil para saber quando um evento está ocorrendo, em relação à inicialização da cena.

Este componente é adicionado ao `engine.RootEntity`.

```ts
Por favor note que, uma vez que o raycast é executado em um sistema, o resultado só estará disponível no próximo tick, necessitando de duas execuções do sistema. Uma para registrar o raycast para o próximo frame, e o próximo frame para processar seu resultado.
  const engineInfo = EngineInfo.getOrNull(engine.RootEntity)
  if (!engineInfo) return

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

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

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

{% hint style="warning" %}
**📔 Nota**: O `EngineInfo` componente deve ser importado via

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

Veja [Imports](https://docs.decentraland.org/creator/content-creator-pt/primeiros-passos/coding-scenes#imports) para como lidar com estes facilmente.
{% endhint %}