> 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-pt/scenes-sdk7/primeiros-passos/coding-scenes.md).

# Essenciais de codificação

Este conjunto vai ajudar você a entender como as coisas funcionam no client e no SDK do Decentraland.

## As ferramentas de desenvolvimento

A um nível muito geral, o Decentraland **Software Development Kit** (SDK) permite-lhe fazer o seguinte:

* Gerar um *projeto* predefinido que contém uma cena do Decentraland, incluindo todos os recursos necessários para renderizar e executar o seu conteúdo.
* Criar, testar e pré-visualizar o conteúdo da sua cena localmente no navegador — completamente offline e sem ter de fazer transações Ethereum ou possuir LAND.
* Escrever código TypeScript usando a API do Decentraland para adicionar comportamentos interativos e dinâmicos à cena.
* Carregar o conteúdo da sua cena para o servidor de conteúdo.
* Associar os seus tokens LAND ao URL do conteúdo que carregou.

O nosso SDK inclui o seguinte:

* **O Creator Hub**: Uma aplicação autónoma que, entre outras coisas, permite criar cenas através de uma interface simples de arrastar e largar. Pode executar pré-visualizações, depurar, editar código e publicar. [Saber mais](https://docs.decentraland.org/creator/content-creator-pt/scene-editor/primeiros-passos/about-editor.md)
* **O ECS do Decentraland**: Um pacote TypeScript que contém a estrutura de métodos auxiliares que permite criar experiências interativas. Utilize-o para criar e manipular objetos na cena e também para facilitar transações no mundo entre jogadores ou outras aplicações. ( [referência mais recente do ECS](https://github.com/decentraland/ecs-reference/blob/master/docs-latest/decentraland-ecs.md))
* **Exemplos de cenas**: Inspire-se e conheça as práticas recomendadas de programação através dos [exemplos de cenas](https://docs.decentraland.org/creator/content-creator-pt/tutoriais-e-exemplos/examples.md).

Outras ferramentas antigas:

* **O Web Editor**: Uma ferramenta baseada na Web para criar cenas simples e publicá-las.

## Requisitos

Para desenvolver uma cena localmente, não precisa de possuir tokens LAND. Pode desenvolver e testar uma cena completamente offline, sem ter de a implementar na rede Ethereum (o sistema que o Decentraland utiliza para estabelecer a propriedade de LAND ou de um nome do Decentraland) nem no servidor de conteúdo.

Tem de ter:

* **O Creator Hub**: Uma aplicação autónoma que, entre outras coisas, permite criar cenas através de uma interface simples de arrastar e largar. Pode executar pré-visualizações, depurar, editar código e publicar. [Saber mais](https://docs.decentraland.org/creator/content-creator-pt/scene-editor/primeiros-passos/about-editor.md).

Se tenciona editar o código da cena, também terá de instalar um dos seguintes programas:

* <img src="https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-38ec445a6fa4d8c8b4e5f5c7b80ea1e58b35b6df%2Fvscode.webp?alt=media" alt="VS Code" data-size="line"> **Visual Studio Code**: Transfira-o [aqui](https://code.visualstudio.com/). Ajuda a escrever código muito mais rapidamente e com menos erros. Um editor de código-fonte assinala erros de sintaxe, completa automaticamente o código enquanto escreve e até apresenta sugestões inteligentes com base no contexto. Também pode clicar num objeto no código para ver a definição completa da respetiva classe e os atributos que suporta.
* <img src="https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-96c78b13a696e8a70912e19e76551a23ec486a5b%2Fcursor-icon.webp?alt=media" alt="Cursor" data-size="line"> **Cursor AI**: Transfira-o [aqui](https://www.cursor.com/). Um editor de código avançado integrado com IA. Permite escolher diferentes modelos de IA para ajudar a escrever código, todos gratuitos. O assistente de IA não se limita a completar automaticamente o código enquanto escreve: também pode pedir-lhe para refatorizar uma grande base de código, escrever documentação e muito mais.

{% hint style="info" %}
**💡 Dica**: Pode utilizar assistentes de IA como o Cursor, o OpenDCL ou o Claude Code para criar cenas inteiras a partir de descrições em linguagem simples — sem precisar de experiência em TypeScript. Consulte [Programação intuitiva com IA](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/primeiros-passos/vibe-coding.md) para começar.
{% endhint %}

## Linguagens e sintaxe suportadas

O Decentraland utiliza [TypeScript (.ts)](https://www.typescriptlang.org/docs/handbook/jsx.html) como linguagem predefinida para escrever cenas.

TypeScript é um superconjunto de JavaScript. Por isso, se já conhece JavaScript, vai achar que é quase igual, mas TypeScript inclui declarações de tipos. Graças a estas declarações, é possível ter funcionalidades como a conclusão automática e sugestões de depuração mais úteis, que aceleram o desenvolvimento e permitem criar uma base de código mais sólida. Estas funcionalidades são essenciais para uma experiência de desenvolvimento positiva.

Quando uma cena é compilada, o código TypeScript que escreveu é convertido em JavaScript minificado para ocupar menos espaço. O código-fonte original em TypeScript nunca é carregado para os servidores; apenas a versão compilada em JavaScript é carregada.

### Outras linguagens

Pode usar outra ferramenta ou linguagem em vez de TypeScript e compilá-la para JavaScript, desde que os scripts compilados estejam contidos num único ficheiro JavaScript que corresponda ao caminho definido no `main` campo do ficheiro `scene.json` da sua cena (por predefinição, *bin/index.js*). Todas as declarações de tipos fornecidas são feitas em TypeScript, e outras linguagens e transpiladores não são oficialmente suportados.

## Cenas

O conteúdo que implementa no seu LAND chama-se **cena**. Uma cena é um programa interativo que renderiza conteúdo 3D. Pode ser um jogo, uma experiência interativa, uma galeria de arte, ou qualquer outra coisa que queira!

As cenas são implementadas em LAND virtual na Decentraland. LAND é um ativo escasso e não fungível, mantido num contrato inteligente Ethereum. Implemente numa única **parcela**, um terreno de LAND com 16 por 16 metros, ou em várias parcelas adjacentes.

Quando os jogadores visitam a Decentraland, descarregam e renderizam o conteúdo de cada cena à medida que percorrem o mapa. As cenas são descarregadas quando se afastam delas.

Também pode executar uma cena localmente na sua máquina, iniciando uma pré-visualização através da CLI.

## Entities e Components

As cenas tridimensionais na Decentraland baseiam-se numa arquitetura [Entity-Component-System](https://en.wikipedia.org/wiki/Entity%E2%80%93component%E2%80%93system) , em que tudo numa cena é uma *entity*. As entities têm *components*, e cada component atribui propriedades específicas à entity a que pertence. É provável que uma entity de porta tenha, pelo menos, um component Transform (que define a posição, a rotação e a escala) e outro que lhe atribua uma forma. Os components são apenas locais para armazenar dados; não executam ações por si próprios.

![](https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-a7a82338639fce594aa9a8459ae54b9579f3e0c1%2Fecs-components-new.webp?alt=media)

```ts
export function main() {
	// Create an entity
	const door = engine.addEntity()

	// Give the entity a position via a transform component
	Transform.create(door, {
		position: Vector3.create(5, 1, 5),
	})

	// Give the entity a visible shape via a GltfContainer component
	GltfContainer.create(door, {
		src: 'assets/models/door.glb',
	})
}
```

As entities podem estar aninhadas noutras entities, formando uma estrutura em árvore. Se conhece desenvolvimento Web, pode ser útil pensar nas entities como elementos de uma árvore DOM e nos components como os atributos de cada um desses elementos.

![](https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-05ea75b83fc4f7f0d533368199638177ef38915b%2Fecs-nested-entities-new.webp?alt=media)

Entities são um conceito abstrato. Uma entity é apenas um ID usado como referência para agrupar diferentes components.

Consulte [Entities e components](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/arquitetura/entities-components.md) para uma análise detalhada destes dois conceitos e da forma como são usados pelas cenas da Decentraland.

### Components personalizados

O conjunto predefinido de components (como `Transform`, `GltfContainer`, `Material`, etc.) é interpretado pelo engine e tem consequências diretas no aspeto da entity, na sua posição, na emissão de sons, etc.

Também pode definir *components personalizados* para armazenar dados que possam ser úteis para as mecânicas da sua cena. O engine não saberá interpretar o significado dos valores destes components, pelo que estes não terão consequências diretas na forma como a cena é renderizada. No entanto, pode escrever lógica no código da cena para monitorizar estes valores e reagir a eles. Por exemplo, pode definir um component personalizado "doorState" para acompanhar se a porta está aberta ou fechada. Neste caso, o component não é mais do que um local onde se armazena um valor que acompanha este estado. Para que a porta abra e feche na sua cena, tem de implementar separadamente a lógica que usa estes valores para alterar a rotação da porta — um valor do component `Transform` que o engine sabe interpretar.

Consulte [Componentes personalizados](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/arquitetura/custom-components.md) para obter mais informações.

### Obter entidades pelo nome

As entidades adicionadas ao arrastar e largar no Scene Editor do Creator Hub também podem ser acedidas através de código, para as editar e adicionar comportamentos.

Utilize `engine.getEntityOrNullByName()` para obter uma entidade, indicando o nome atribuído à entidade na UI do Scene Editor. Cada entidade deve ter um nome único.

```ts
function main() {
	const door = engine.getEntityOrNullByName('door3')
}
```

Pode depois fazer o que quiser com essa entidade, como adicionar novos componentes, modificar os componentes existentes, duplicá-la ou eliminá-la.

Consulte [Obter entidade pelo nome](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/arquitetura/entities-components.md#get-an-entity-by-name) para obter mais informações.

Se a entidade for um [Smart item](https://docs.decentraland.org/creator/content-creator-pt/scene-editor/interatividade/smart-items.md), também pode chamar as respetivas **Ações** ou subscrever os respetivos **Triggers** através de código. Consulte [Itens de referência](https://docs.decentraland.org/creator/content-creator-pt/scene-editor/expandir-com-codigo/reference-items.md).

## Sistemas

As entidades e os componentes são locais onde se guardam informações sobre os objetos de uma cena. *Sistemas* contêm funções que alteram, ao longo do tempo, as informações guardadas nos componentes.

Os sistemas são onde implementamos a lógica do jogo. Executam as ações que têm de ser atualizadas ou verificadas periodicamente em cada tick do ciclo do jogo.

Um sistema é uma função simples e sem efeitos secundários que é chamada uma vez em cada tick (uma vez por cada frame renderizado pelo motor), seguindo o [*padrão de atualização*](http://gameprogrammingpatterns.com/update-method.html).

```ts
// Sistema básico
function mySystem() {
	console.log('my system is running')
}

engine.addSystem(mySystem)

// Sistema com dt
function mySystemDT(dt: number) {
	console.log('time since last frame:  ', dt)
}

engine.addSystem(mySystemDT)
```

Uma única cena pode ter zero ou vários sistemas em execução ao mesmo tempo. Os sistemas podem ser ativados ou desativados em diferentes momentos durante a duração da cena. Em geral, é boa prática manter comportamentos independentes em sistemas separados.

Consulte [Sistemas](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/arquitetura/systems.md) para obter mais informações sobre como os sistemas são utilizados numa cena.

### O ciclo do jogo

O [ciclo do jogo](http://gameprogrammingpatterns.com/game-loop.html) é a espinha dorsal do código de uma cena de Decentraland. Percorre uma parte do código a intervalos regulares e faz o seguinte:

* Detetar os controlos do jogador
* Atualizar a cena
* Voltar a renderizar a cena

Na maioria dos programas de software tradicionais, todos os eventos são acionados diretamente pelas ações do jogador. Nada no estado do programa muda até o jogador clicar num botão, abrir um menu, etc.

Mas os ambientes interativos e os jogos são diferentes. Nem todas as alterações à cena são necessariamente causadas pelas ações do jogador. A sua cena pode ter objetos animados que se movem por conta própria ou até personagens não jogáveis com a sua própria IA. Algumas ações do jogador também podem demorar vários ticks a concluir. Por exemplo, se uma porta demorar um segundo inteiro a abrir, a sua rotação tem de ser atualizada gradualmente em cada tick enquanto se move (60 vezes, se a máquina do jogador renderizar a 60 FPS).

Chamamos a cada iteração do ciclo um *tick*. As cenas de Decentraland executam um tick por cada frame renderizado, pelo que o número de ticks por segundo corresponde à frequência de fotogramas do motor. Se a máquina tiver dificuldades em renderizar cada frame, as atualizações serão menos frequentes.

Em cada tick, a cena é atualizada; em seguida, é renderizada novamente com base nos valores atualizados.

Nas cenas de Decentraland, não existe um game loop declarado explicitamente; em vez disso, os [Systems](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/arquitetura/systems.md) da cena formam o game loop.

A compilação e a renderização da cena são realizadas no backend; não precisa de tratar disso enquanto desenvolve a sua cena.

## Consultar Components

Pode [consultar Components](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/arquitetura/querying-components.md) com o método `engine.getEntitiesWith(...components)` para acompanhar todas as Entities da cena que têm determinados Components.

Muitas vezes, faz sentido consultar Components dentro de um [System](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/arquitetura/systems.md), para depois percorrer cada uma das Entities devolvidas e executar o mesmo conjunto de ações em cada uma.

Tentar percorrer todas as Entities da cena em cada tick do game loop pode ter um custo de desempenho significativo. Ao referir-se apenas às Entities devolvidas por uma consulta, garante que só está a lidar com as relevantes.

```ts
// Define um System
function boxHeightSystem(dt: number) {
	// consulta Entities que incluem os Components MeshRenderer e Transform
	for (const [entity] of engine.getEntitiesWith(MeshRenderer, Transform)) {
		const transform = Transform.get(entity)
		console.log('a box is at height:  ', transform.position.y)
	}
}

// Adiciona o System ao engine
engine.addSystem(boxHeightSystem)
```

## Ciclo de vida da cena

Se começar a escrever linhas de código soltas diretamente em `index.ts`, o seu código pode não ter algum contexto importante. Por exemplo, poderá não ter informações sobre a Entity do jogador ou sobre as Entities adicionadas através de arrastar e largar no Creator Hub. Quando as linhas de código forem lidas, esses elementos ainda não estarão carregados.

Para evitar essa situação, recomenda-se sempre escrever o código de carregamento inicial da cena na função `main()` (no ficheiro `index.ts` ), como ponto de entrada. Esta função só é executada depois de todo o contexto inicial da cena estar carregado, incluindo tudo o que foi adicionado através da UI do Scene Editor.

Pode escrever o seu código fora da função `main()` quando:

* O código é chamado indiretamente por `main()`
* O código define um System ou adiciona um System ao engine
* O código está dentro de uma [função async](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/padroes-de-programacao/async-functions.md)

{% hint style="warning" %}
**📔 Nota**: Quando o código dentro de uma função async ou de um System é executado pela primeira vez, tudo na cena já está devidamente inicializado.

[Definições de Custom Component](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/arquitetura/custom-components.md) são uma exceção: têm de ser sempre escritas fora da função `main()` , num ficheiro separado. Têm de ser interpretadas antes de `main()` ser executada.
{% endhint %}

## Mutabilidade

Pode optar por trabalhar com versões mutáveis ou imutáveis (só de leitura) de um Component. O método `.get()` A função em um componente retorna uma versão imutável do componente. Só é possível ler seus valores, mas não alterar nenhuma de suas propriedades.

A `.getMutable()` função retorna uma representação do componente que permite alterar seus valores. Use versões mutáveis apenas quando pretender fazer alterações em um componente. Lidar com versões imutáveis dos componentes proporciona um enorme ganho de desempenho.

```ts
// obtém uma versão imutável (somente leitura)
const immutableTransform = Transform.get(myEntity)

// o seguinte NÃO funciona:
// 	immutableTransform.position.y = 2

const mutableTransform = Transform.getMutable(myEntity)

// o seguinte altera a posição da entidade
mutableTransform.position.y = 2
```

Consulte [dados mutáveis](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/padroes-de-programacao/mutable-data.md) para mais detalhes.

## Juntando tudo

O *Engine* fica entre *Entities*, e *Components* de um lado e *Systems* do outro.

![](https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-47dcd6cd9846e4d62d320e0ba061c9261d2e4f2a%2Fecs-big-picture.webp?alt=media)

Todos os valores armazenados nos componentes da cena representam o estado da cena naquele momento. A cada ciclo do loop do jogo, o Engine executa as funções de cada um dos Systems para atualizar os valores armazenados nos componentes.

Depois que todos os Systems são executados, os componentes de cada Entity terão novos valores. Quando o Engine renderiza a cena, ele usa esses valores atualizados e os jogadores veem as Entities mudarem para refletir seus novos estados.

```ts
export function main() {
	// Create an entity
	const cube = engine.addEntity()

	// Give the entity a position via a transform component
	Transform.create(cube, {
		position: Vector3.create(5, 1, 5),
	})

	// dá à entidade uma forma visível por meio de um componente MeshRenderer
	MeshRenderer.setBox(cube)
}

// Define um System
function rotationSystem(dt: number) {
	// consulta Entities que incluem os Components MeshRenderer e Transform
	for (const [entity] of engine.getEntitiesWith(MeshRenderer, Transform)) {
		const transform = Transform.getMutable(entity)
		transform.rotation = Quaternion.multiply(
			transform.rotation,
			Quaternion.fromAngleAxis(dt * 10, Vector3.Up())
		)
	}
}

// Adiciona o System ao engine
engine.addSystem(rotationSystem)
```

No exemplo acima, uma entidade `cube` e um System `rotationSystem` são adicionados ao Engine. A `cube` entidade tem um componente `Transform`, e um componente `MeshRenderer` . A cada ciclo do loop do jogo, o `rotationSystem` System é chamado e altera os valores de rotação no componente `Transform` da entidade `cube` .

Observe que a maior parte do código acima é executada apenas uma vez, ao carregar a cena. A exceção é o `rotationSystem` sistema, que é chamado a cada tick do loop do jogo.

## Desacoplamento de Scene

As suas Scenes não são executadas no mesmo contexto que o Engine (também conhecido como thread principal). Criámos o SDK de forma totalmente desacoplada do Engine de renderização. Foi concebido assim por motivos de segurança e desempenho.

Devido a esse desacoplamento, o código da sua Scene não tem acesso ao DOM nem ao objeto `window` , pelo que não pode aceder a dados como o navegador ou a localização geográfica do jogador.

O desacoplamento funciona através do protocolo RPC, que atribui uma pequena parte do cliente exclusivamente à renderização da Scene e ao controlo de eventos.

Também abstraímos o protocolo de comunicação. Isto permite-nos executar as Scenes localmente num WebWorker.

Não queremos que os programadores interfiram nos componentes internos do Engine, nem que precisem de saber o que se passa no seu interior. Temos de garantir uma experiência consistente para os jogadores em todo o mapa de Decentraland, e é mais provável que ocorram erros nesse nível «baixo».

Este desacoplamento também é importante para impedir que Scenes vizinhas interfiram na experiência dos jogadores quando estes estão na Scene de outra pessoa. Um jogador pode ter várias Scenes próximas carregadas ao mesmo tempo, cada uma a executar o seu próprio código. Algumas ações (como abrir links externos ou mover o jogador) só são permitidas quando o jogador está na Scene em questão, não quando a Scene está carregada mas o jogador se encontra no exterior.

## Tree Shaking

Ao converter o código-fonte em TypeScript para código compilado em JavaScript minificado, o processo realiza [tree shaking](https://en.wikipedia.org/wiki/Tree_shaking) para garantir que apenas as partes do código efetivamente utilizadas são convertidas. Isto ajuda a manter o código final da Scene o mais leve possível. É especialmente útil ao utilizar bibliotecas externas, pois estas incluem frequentemente muitas funcionalidades que não são utilizadas e que, de outra forma, aumentariam o tamanho da Scene.

Como consequência do tree shaking, qualquer código que queira executar na sua Scene tem de ser referenciado, de uma forma ou de outra, pelos pontos de entrada do código: a função `main()` em `index.ts`. Em alternativa, os Systems também podem ser adicionados ao Engine no `index.ts` ficheiro, sem serem referenciados `main()`. Qualquer código que não seja referenciado explícita ou indiretamente por estes ficheiros não será incluído na Scene.

Por exemplo, suponha que tem um ficheiro chamado `extraContent.ts` com o conteúdo seguinte. A Entity não será renderizada e o System não começará a ser executado:

```ts
// extraContent.ts

const myEntity = engine.addEntity()
Transform.create(myEntity, {
	position: { x: 8, y: 0, z: 8 },
})
MeshRenderer.setBox(myEntity)

function mySystem(dt: number) {
	console.log('system running')
}

engine.addSystem(mySystem)
```

Para que seja executado como parte da sua Scene, pode referenciá-lo a partir de `index.ts` da seguinte forma:

```ts
// on extraContent.ts

export function addEntities() {
	const myEntity = engine.addEntity()
	Transform.create(myEntity, {
		position: { x: 8, y: 0, z: 8 },
	})
	MeshRenderer.setBox(myEntity)
}

export function mySystem(dt: number) {
	console.log('system running')
}

/////////////////////////////

// on index.ts

import { addEntities, mySystem } from './extraContent'

export function main() {
	addEntities()
}

engine.addSystem(mySystem)
```

A exceção a esta regra são as definições de Components personalizados. Estas não devem ser acedidas através do ponto de entrada da função `main()` , pois têm de ser interpretadas antes de tudo o resto.

## Imports

Todas as funções, objetos, Components e outros elementos utilizados pela Scene têm de ser importados para cada ficheiro em que forem usados. Isto é uma consequência do [tree-shaking](#tree-shaking), que evita empacotar o SDK inteiro e inclui apenas as partes utilizadas pela Scene.

Os exemplos de código ao longo da documentação omitem as linhas de importação no início de cada ficheiro para os manter simples, mas, para funcionarem, tem de as adicionar à Scene.

Ao utilizar o VS Studio Code para escrever as suas Scenes, as opções inteligentes de preenchimento automático devem tratar das importações enquanto escreve, sem que tenha de se preocupar com isso.

No entanto, ao colar um exemplo de código na sua Scene, é provável que veja alguns elementos assinalados a vermelho por não terem sido importados para esse ficheiro. Para corrigir isto:

* Clique em cada palavra sublinhada
* Clique no ícone da lâmpada à esquerda da linha
* Selecione **Add Import From**
* É apresentada uma linha de importação no início do ficheiro.

![](https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-cf0b8b035c6f9232ebfe9b531d34dfb51aed8ae3%2Fimports.webp?alt=media)

Se houver muitos elementos diferentes para importar, também pode selecionar **Add all missing imports** no mesmo menu pendente.

Tenha em atenção que é necessário adicionar as importações a todos os ficheiros onde um elemento é utilizado.

O VS Studio Code deverá conseguir resolver automaticamente os caminhos corretos para as suas importações. Se, por algum motivo, tiver dificuldades em fazê-lo, um truque consiste em colar as seguintes instruções de importação vazias no início do ficheiro. O VS Studio deverá conseguir tratar do resto.

```ts
import {} from '@dcl/sdk/ecs'
import {} from '@dcl/sdk/math'
```

## Versões do SDK

Ao desenvolver uma nova cena, utiliza a versão `@latest` estável do SDK por predefinição.

Pode instalar a versão `@next` do SDK se quiser utilizar ou pré-visualizar funcionalidades futuras que ainda não foram incluídas na versão estável mais recente.

Para o fazer, abra o ficheiro `package.json` da sua cena e altere as seguintes linhas:

```json
  "devDependencies": {
    "@dcl/js-runtime": "next",
    "@dcl/sdk": "next"
  },
```

Em seguida, execute o seguinte comando na pasta do projeto da sua cena:

```
npm i
```

Consulte [gerir dependências](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/bibliotecas/manage-dependencies.md) para mais informações.

{% hint style="warning" %}
**📔 Nota**: tenha em conta que a versão @next pode apresentar problemas ocasionalmente. A sintaxe e os nomes das novas funcionalidades podem mudar antes de serem disponibilizadas numa versão estável.
{% 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-pt/scenes-sdk7/primeiros-passos/coding-scenes.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.
