# Execução

O runtime trata [cenas](https://github.com/decentraland/docs/blob/main/contributor/contributor/content/entity-types/scenes.md) como módulos Node típicos. Uma vez que a sandbox é configurada (isto é, todos os [globals](https://github.com/decentraland/docs/blob/main/contributor/globals.md) são injetados e [módulos](https://github.com/decentraland/docs/blob/main/contributor/modules.md) estão prontos para serem carregados), o código da cena será avaliado para que possa preencher o [objeto](https://github.com/decentraland/docs/blob/main/contributor/globals.md#module) .

Dois métodos serão selecionados pelo host a partir de `objeto`: [`onStart`](#onStart) (opcional) e [`onUpdate`](#onUpdate) (obrigatório).

```ts
type Exports = {
  onStart?: () => Promise<void>;
  onUpdate: (deltaSeconds: number) => Promise<void>;
};
```

Durante o ciclo de vida de uma cena, o runtime garantirá que chamadas a esses métodos nunca sejam feitas concorrentemente. A `Promise` retornada será sempre aguardada antes que a cena receba uma nova chamada.

{% @mermaid/diagram content="flowchart LR
A\[onStart] -->|await| B\[onUpdate]
B -->|await| B" %}

{% hint style="info" %}
Sincronização eficaz e com bom desempenho entre cenas individuais e o motor de renderização do jogo é uma questão complicada. Você pode encontrar lições da implementação da Foundation em [ADR-148](https://adr.decentraland.org/adr/ADR-148).
{% endhint %}

**`onStart`**

O ciclo de vida de uma cena começa com o método assíncrono `onStart` . É o lugar para fazer inicializações de uma só vez que devem ser concluídas antes da primeira chamada a [`onUpdate`](#onUpdate) ser feita.

```ts
onStart(): Promise<void>
```

As cenas devem usar esta chamada para solicitar qualquer estado pré-existente ao runtime (como as [entidades básicas](https://github.com/decentraland/docs/blob/main/contributor/entities.md)) e realizar sua própria configuração inicial.

Exportar `onStart` é recomendado para todas as cenas (e feito automaticamente ao usar o SDK), mas não é exigido pelo protocolo. O método pode estar ausente, ou retornar uma `Promise`.

**`onUpdate`**

Enquanto uma cena está ativamente em execução, o método assíncrono `onUpdate` será periodicamente invocado pelo runtime para reportar a passagem do tempo. Este é o coração da cena: em cada chamada sucessiva, entidades podem ser atualizadas, entrada processada, animações reproduzidas, mensagens enviadas, UI exibida, etc.

```ts
onUpdate(deltaSeconds: number): Promise<void>
```

O `deltaSeconds` parâmetro é o número fracionário de segundos decorrido desde a última chamada a `onUpdate` foi iniciada pelo runtime (independentemente de quando a `Promise` retornada foi resolvida). Isto é específico de cada cena em execução.

Como as `onUpdate` chamadas nunca irão se sobrepor, a sequência de `deltaSeconds` produz uma linha do tempo coerente.

Em circunstâncias ideais, as cenas têm a chance de executar `onUpdate` antes de cada frame ser renderizado. No entanto, dependendo dos recursos disponíveis, cenas executando uma carga de trabalho pesada podem não resolver suas `Promise` a tempo para o próximo frame. Cada cena é independente nesse aspecto: implementações leves de `onUpdate` podem ser invocadas múltiplas vezes no mesmo período que uma única chamada demorada em outra cena.

Veja [ADR-148](https://adr.decentraland.org/adr/ADR-148) para detalhes.

### Executando Múltiplas Cenas

O World Explorer deve não apenas suportar a execução de várias cenas em sandbox, ele deve fazê-lo o tempo todo. Há duas razões para isso:

Primeiro, quando jogadores exploram o mundo, sua visão alcança além dos limites geográficos da cena em que estão. Cenas próximas (até uma distância arbitrária ou configurável) devem estar em execução para gerar o conteúdo que os jogadores devem ser capazes de ver.

Segundo, as cenas não apenas rodam dentro de seus próprios limites não sobrepostos. Elas também podem ser sobrepostas umas às outras, afetando a área ao redor do jogador mas fornecendo funcionalidades diferentes.

Este é o caso de dois tipos de cenas em particular: a cena de avatar, e experiências portáteis.

#### A Cena de Avatar <a href="#avatarscene" id="avatarscene"></a>

Desde o momento em que o jogador entra no mundo, uma cena global encarregada de renderizar os avatares de outros jogadores começa a rodar.

Esta cena não é limitada por fronteiras geográficas, e pode exibir suas entidades (assim como widgets de UI para comunicação) independentemente da localização do jogador.

#### Experiências Portáteis

Decentraland permite que wearables tenham seu próprio comportamento, que roda em seu próprio contexto de cena. Essas cenas são centradas no jogador, e podem enriquecer a experiência adicionando entidades ou exibindo widgets de UI.

Elas começam a rodar quando o wearable é equipado, e param quando é removido.