> 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/sdk-101.md).

# Início Rápido do SDK

Crie sua primeira scene do Decentraland com o Creator Hub, o SDK e vibe coding assistido por IA usando o SDK Skills oficial.

Este tutorial orienta você na criação da sua primeira cena, combinando as diferentes ferramentas disponíveis: o Scene Editor visual do Creator Hub, código escrito manualmente usando o SDK da Decentraland e programação assistida por IA com **vibe coding**. Você vai usar as três ferramentas em conjunto e aprender quando cada uma se destaca.

## Como criar uma cena da Decentraland?

1. **Instale o** [**Creator Hub**](https://decentraland.org/download/creator-hub), o aplicativo oficial para desktop para criar, visualizar e publicar cenas. É a ferramenta recomendada para criadores de todos os níveis de experiência.
2. **Se você usa um assistente de programação com IA** (como Claude Code, Cursor ou Copilot), instale o pacote oficial [Decentraland SDK Skills](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/primeiros-passos/vibe-coding.md) para que ele conheça os padrões verificados do SDK7: `npx skills add decentraland/sdk-skills`
3. **A** [**CLI**](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/primeiros-passos/using-the-cli.md) é uma alternativa para usuários avançados e fluxos de trabalho automatizados.

O restante deste tutorial explica passo a passo esse caminho recomendado.

## Instale o Creator Hub

O Creator Hub permite criar, visualizar e publicar cenas da Decentraland. Baixe o Creator Hub [aqui](https://decentraland.org/download/creator-hub).

Para editar o código da sua cena, você também precisa de um editor de código. [Visual Studio Code](https://code.visualstudio.com/) e [Cursor](https://www.cursor.com/) são ótimas opções, mas qualquer editor de código serve.

Leia o [guia de instalação](https://docs.decentraland.org/creator/content-creator-pt/scene-editor/primeiros-passos/editor-installation.md) para saber mais.

## Crie sua primeira cena

1. Abra o Creator Hub.
2. Selecione a aba **Scenes** e clique em **New Scene**.

   ![](https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-e5671a1706f73b79a9baffeda0c81d5d9e4cb53d%2Fnew-scene.webp?alt=media)
3. Escolha um template inicial. Para este exercício, escolha **Empty Scene**.

Esta etapa pode levar alguns minutos. Ela preenche sua pasta com o conjunto padrão de arquivos para uma cena básica. Quando terminar, você verá a grade vazia da sua cena.

## Adicione itens dos Asset packs

Explore os **Asset packs** na parte inferior do Scene Editor e arraste alguns itens para a sua cena. Por enquanto, pode escolher quaisquer itens.

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

Você pode clicar nos itens já posicionados e arrastá-los para reposicioná-los. Consulte [noções básicas do Scene Editor](https://docs.decentraland.org/creator/content-creator-pt/scene-editor/primeiros-passos/scene-editor-essentials.md#position-items) para saber mais.

{% hint style="info" %}
**💡 Dica**: Cubra toda a cena com um item de Ground. Itens do tipo **Ground** têm um ícone de balde de tinta. Se você arrastar um desses itens para a cena, todo o chão será coberto com cópias desse item.

<img src="https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-98bc75e11e441e06ff960c54f1f6c5aad7e3a15f%2Fground.webp?alt=media" alt="Ground" data-size="original">
{% endhint %}

## Execute uma visualização

Clique em **Play** botão no menu superior para carregar a sua scene no Decentraland. Agora pode explorar a scene como um avatar do Decentraland.

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

Pode manter a janela de pré-visualização aberta enquanto trabalha: é atualizada sempre que faz uma alteração. Saiba mais em [pré-visualizar uma scene](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/primeiros-passos/preview-scene.md).

## Assets 3D personalizados

Transfira este modelo 3D de um abacate no formato *glb* a partir do seguinte [link](https://github.com/decentraland-scenes/avocado/raw/main/avocado-glb.zip) e extraia os ficheiros.

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

Arraste o ficheiro **avocado.glb** do seu explorador de ficheiros para o painel inferior do Scene Editor (o mesmo painel onde se encontram os separadores **Asset Packs** e **Local Assets** ) e clique em **Importar**.

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

Agora pode encontrar o modelo **avocado.glb** no separador **Local Assets** , dentro da pasta **Scene** . Arraste o ficheiro para a sua scene, tal como faria com qualquer item dos Asset Packs.

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

## Editar o código da scene

Clique no botão **<> Código** no menu superior para abrir o projeto da sua scene no editor de código.

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

{% hint style="warning" %}
**📔 Nota**: Se não abrir nada, certifique-se de que tem instalado um editor de código, como o [Visual Studio Code](https://code.visualstudio.com/) ou o [Cursor](https://www.cursor.com/) .
{% endhint %}

Na margem esquerda do editor de código, pode navegar pelos ficheiros e pela estrutura de pastas do projeto. Abra o ficheiro `index.ts` dentro da pasta `src` . O conteúdo deverá ser semelhante a este:

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

export function main() {}
```

As scenes do Decentraland são escritas em [TypeScript](https://www.typescriptlang.org/), utilizando o SDK do Decentraland: uma biblioteca com tudo o que precisa para posicionar conteúdo 3D, adicionar interatividade e controlar o que acontece na sua scene.

Este ficheiro define uma função chamada `main()`, que é o ponto de entrada da scene: qualquer código que colocar aí é executado quando a scene é carregada pela primeira vez.

Já arrastou visualmente um abacate para a scene. Agora vamos adicionar um segundo, desta vez escrevendo código. Substitua todo o conteúdo do seu ficheiro `index.ts` ficheiro com o seguinte:

```ts
import { Vector3 } from '@dcl/sdk/math'
import { engine, Transform, GltfContainer } from '@dcl/sdk/ecs'

export function main() {
	// create a fresh new Entity
	let avocado2 = engine.addEntity()

	// give it a Transform
	Transform.create(avocado2, {
		position: Vector3.create(8, 0, 8),
	})

	// give it a GLTF
	GltfContainer.create(avocado2, {
		src: 'assets/scene/avocado.glb',
	})
}
```

Estas linhas criam uma nova [entity](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/arquitetura/entities-components.md), atribuem-lhe uma [shape](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/fundamentos-de-conteudo-3d/shape-components.md) baseada no modelo 3D que transferiu e [definem a respetiva posição](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/fundamentos-de-conteudo-3d/entity-positioning.md) através do componente **Transform** .

Como regra geral, todo o código que escrever em `index.ts` deve estar dentro de `main()` (ou noutras funções referenciadas indiretamente por main). Consulte [Ciclo de vida da Scene](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/primeiros-passos/coding-scenes.md#scene-lifecycle) para obter mais detalhes.

Execute a pré-visualização da scene: deverá ver agora dois abacates, um que adicionou no Scene Editor e outro que adicionou através de código.

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

{% hint style="warning" %}
**📔 Nota**: o segundo abacate existe **apenas no seu código**. É apresentado quando executa a scene, mas o Canvas e a árvore de entidades do Scene Editor não conseguem mostrar entidades criadas em `index.ts`. Não se preocupe se não o vir no editor. Este é um aspeto importante a ter em conta quando combina a edição visual com código.
{% endhint %}

Os dois abacates são construídos com as mesmas peças. Selecione o **primeiro** abacate no Scene Editor: o painel de propriedades mostra um **Transform** e um componente **GltfContainer** com os mesmos tipos de campos que acabou de escrever no código. São duas formas de ver a mesma coisa.

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

## Adicione interatividade com um Script

Vamos fazer com que um abacate reaja ao jogador. Poderíamos fazê-lo adicionando código ao `index.ts` que já estávamos a editar, mas, em vez disso, vamos usar o **componente Script**: uma forma de associar código diretamente a um item no Scene Editor. Assim, o comportamento de cada item fica autónomo e até pode reutilizar o mesmo script em vários itens.

1. No Scene Editor, selecione o primeiro abacate (aquele que arrastou; lembre-se de que o abacate criado apenas através de código não está visível aqui).
2. Clique em **+** botão na parte superior do painel de propriedades e selecione **Script** para adicionar um componente Script.
3. Clique em **+ Create New Script** e dê-lhe o nome `AvocadoScript`.

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

4. Clique no botão **<> Code** no componente Script para abrir o novo arquivo no seu editor de código.

O script é uma classe com três partes principais (comentários omitidos para maior brevidade):

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

export class AvocadoScript {
	constructor(
		public src: string, // DO NOT REMOVE
		public entity: Entity, // DO NOT REMOVE
		// Add your custom inputs below
	) {}

	start() {
		// Called once, when the scene loads
	}

	update(dt: number) {
		// Called on every frame
	}
}
```

* O **constructor** define os parâmetros que aparecem como campos editáveis no componente Script do Creator Hub. Não remova `src` nem `entity`.
* **`start()`** é executado **uma vez**, quando a cena é carregada. Use-o para a configuração inicial: criar componentes, registar manipuladores de cliques, etc.
* **`update(dt)`** é executado **a cada frame** do jogo, à mesma frequência com que o engine renderiza (por exemplo, 60 vezes por segundo a 60 FPS). Use-o para comportamentos contínuos, como movimento. `dt` indica quantos segundos passaram desde o último frame.

Dentro da classe, `this.entity` refere-se sempre à entity que contém o componente Script: neste caso, o seu abacate. É isso que torna os scripts reutilizáveis: associe o mesmo script a dez itens e cada um atuará sobre si próprio.

### Crie a sua primeira interação com vibe coding

Pode escrever o código seguinte à mão, mas este é um ótimo momento para experimentar **vibe coding**: descrever o que pretende a um assistente de IA e deixá-lo escrever o código. A maioria dos editores de código tem um assistente integrado, como o chat do Cursor, o GitHub Copilot no VS Code ou o [Claude Code](https://claude.com/product/claude-code). Também pode escrever prompts fora do editor de código, por exemplo, com o Claude Desktop ou o Claude Code na linha de comandos.

Antes do primeiro prompt, instale as skills do SDK da Decentraland, para que a IA conheça os padrões do SDK e cometa muito menos erros:

```bash
npx skills add decentraland/sdk-skills
```

Estas skills são documentos de referência que a IA consulta sempre que não sabe ao certo como fazer algo com o SDK, para escrever código correto em vez de adivinhar. Consulte [Vibe Coding com IA](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/primeiros-passos/vibe-coding.md) para consultar as opções de configuração e sugestões de prompts.

Agora experimente um prompt como este:

> Em AvocadoScript.ts, faça com que o abacate registre uma mensagem no console quando o jogador clicar nele.

O resultado deve ser parecido com este (ou você pode colá-lo):

```ts
import { engine, Entity, pointerEventsSystem, InputAction } from '@dcl/sdk/ecs'
import {} from '@dcl/sdk/math'

export class AvocadoScript {
	constructor(
		public src: string,
		public entity: Entity,
	) {}

	start() {
		pointerEventsSystem.onPointerDown(
			{
				entity: this.entity,
				opts: { button: InputAction.IA_POINTER },
			},
			() => {
				console.log('CLICKED AVOCADO')
			}
		)
	}

	update(dt: number) {}
}
```

Ele adicionou um comportamento de clique dentro da `start()` função. Só precisamos definir o comportamento de clique uma vez, e ele será acionado sempre que o jogador clicar no item. A instrução `pointerEventsSystem.onPointerDown()` define três coisas:

* Em qual `entity` os eventos de clique atuam: neste caso, `this.entity`, o abacate que contém o script.
* Um objeto `opts` : qual botão usar e outros argumentos opcionais que não estamos usando agora.
* Uma função executada sempre que a Entity é clicada.

Para ver a mensagem registrada, execute o Preview e abra o console clicando no ![](https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-a673f6b987216e9e471fdac882879c44fcf94652%2Fconsole-icon.png?alt=media\&token=1965a51b-d4b0-4caa-b9d5-d24d738c1fb8) ícone no canto superior direito. Também é possível ativá-lo ou desativá-lo pressionando a tecla **\`** . Cada vez que você clicar no abacate, verá uma nova linha aparecer:

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

{% hint style="warning" %}
**📔 Observação**: para que uma Entity possa ser clicada, ela precisa ter uma geometria de collider. O modelo usado aqui já inclui uma. Consulte [Colliders](https://docs.decentraland.org/creator/content-creator-pt/modelacao-3d-e-animacoes/colliders.md) para ver soluções alternativas para modelos que não têm.
{% endhint %}

### Faça o abacate desaparecer

Agora vamos fazer o clique ter um efeito mais interessante! Peça ao seu assistente de IA:

> Quando clicarem no abacate, faça-o desaparecer. Quero que ele desapareça com uma animação elástica de encolhimento. Também quero que a dica exibida quando aponto para o abacate diga "Coletar".

O resultado deve ser parecido com este:

```ts
import { engine, Entity, pointerEventsSystem, InputAction, Tween, EasingFunction } from '@dcl/sdk/ecs'
import { Vector3 } from '@dcl/sdk/math'

export class AvocadoScript {
	constructor(
		public src: string,
		public entity: Entity,
	) {}

	start() {
		pointerEventsSystem.onPointerDown(
			{
				entity: this.entity,
				opts: { button: InputAction.IA_POINTER, hoverText: 'Collect' },
			},
			() => {
				this.collect()
			}
		)
	}

	collect() {
		Tween.setScale(
			this.entity,
			Vector3.One(),
			Vector3.Zero(),
			500,
			EasingFunction.EF_EASEINBOUNCE
		)
	}

	update(dt: number) {}
}
```

Vamos analisar o que a IA fez.

* Para criar a animação elástica, ela usou um **Tween**. Um Tween descreve uma transição gradual da posição, rotação ou escala de uma Entity ao longo do tempo. Aqui `Tween.setScale()` reduz o abacate do tamanho normal (`Vector3.One()`) até desaparecer (`Vector3.Zero()`) ao longo de 500 milissegundos, usando uma curva de easing com efeito de ressalto. Saiba mais sobre tweens em [mover Entities](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/fundamentos-de-conteudo-3d/move-entities.md).
* Em vez de escrever o tween diretamente dentro da função de clique, criou um método `collect()` separado. Isto não é obrigatório (se a IA tiver colocado o tween dentro da função de clique, também funciona), mas é uma boa prática: os métodos mantêm o código legível e permitem reutilizar a mesma lógica em diferentes locais.
* Para mostrar a dica «Recolher» no abacate, definiu-a como o valor de `hoverText` .

Execute o Preview e clique no abacate: deverá desaparecer com estilo.

{% hint style="warning" %}
**📔 Nota**: O abacate encolhe até ficar com tamanho 0, mas a Entity continua a existir. O ideal é eliminar a Entity quando o tween terminar, para manter a sua Scene mais leve. Consulte [Quando o tween terminar](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/fundamentos-de-conteudo-3d/move-entities.md#on-tween-finished).
{% endhint %}

### Executar código em cada frame

Até agora, todo o nosso código foi executado em `start()`. Vamos usar `update()` para fazer o abacate rodar continuamente. Substitua o construtor e `update()` por:

```ts
	constructor(
		public src: string,
		public entity: Entity,
		public speed: number = 45,
	) {}

	update(dt: number) {
		const transform = Transform.getMutable(this.entity)
		transform.rotation = Quaternion.multiply(
			transform.rotation,
			Quaternion.fromAngleAxis(this.speed * dt, Vector3.Up())
		)
	}
```

Também terá de adicionar `Transform` e `Quaternion` às importações no início do ficheiro, para que fiquem assim:

```ts
import { engine, Entity, pointerEventsSystem, InputAction, Tween, EasingFunction, Transform } from '@dcl/sdk/ecs'
import { Vector3, Quaternion } from '@dcl/sdk/math'
```

{% hint style="info" %}
**💡 Sugestão**: Em vez de editar as importações manualmente, pode clicar nos erros assinalados pelo editor de código e deixar que os adicione automaticamente.
{% endhint %}

Em cada frame, isto roda o abacate um pouco mais. Multiplicar por `dt` torna o movimento suave e independente da taxa de frames: o abacate roda a 45 graus por segundo, independentemente da velocidade da máquina do jogador.

Como `speed` é um parâmetro do construtor, também aparece como um campo no componente Script do Creator Hub. Clique no ícone de atualização no canto superior direito do componente Script para o ver e, em seguida, ajuste o valor sem tocar no código.

<img src="https://2402076176-files.gitbook.io/~/files/v0/b/gitbook-x-prod.appspot.com/o/spaces%2FoPnXBby9S6MrsW83Y9qZ%2Fuploads%2Fgit-blob-8f1b521e1b68b5d9138dd1b60eeb40e4b13dbb0c%2Fscript-refresh-button.webp?alt=media" alt="Botão Atualizar" width="360">

Cada Entity guarda o seu próprio valor para o campo **Velocidade** ; assim, vários itens podem partilhar o mesmo script e comportar-se de forma diferente. Experimente: copie o abacate com Ctrl + C e Ctrl + V, mova a cópia para que os dois não se sobreponham e defina uma velocidade diferente para cada um. Agora, cada abacate roda à sua própria velocidade.

Os scripts podem fazer muito mais, como disponibilizar ações que outros smart items podem acionar. Consulte [Componente Script](https://docs.decentraland.org/creator/content-creator-pt/scene-editor/expandir-com-codigo/script-component.md) para ter uma visão geral completa.

## Referenciar um item do Scene Editor

O componente Script é a forma mais fácil de adicionar comportamento a um único item, mas existe uma alternativa: o seu código em `index.ts` pode obter qualquer item que tenha adicionado visualmente, pelo nome, usando `engine.getEntityOrNullByName()`. Isto é útil quando uma parte da lógica envolve vários itens ou quando pretende ter tudo num só lugar. Use o nome que aparece na [árvore de Entities](https://docs.decentraland.org/creator/content-creator-pt/scene-editor/primeiros-passos/scene-editor-essentials.md#the-entity-tree).

Neste exemplo, usamos uma Entity chamada **Yellow Crate**. Pode usar qualquer item; basta escrever o nome exatamente como aparece na árvore de Entities.

{% hint style="info" %}
**💡 Dica**: pode mudar o nome das Entities clicando com o botão direito e selecionando **Renomear** na árvore de Entities.
{% endhint %}

```ts
export function main() {
	// avocado2 code from before
	// (...)

	const crate = engine.getEntityOrNullByName('Yellow Crate')

	if (crate) {
		pointerEventsSystem.onPointerDown(
			{
				entity: crate,
				opts: { button: InputAction.IA_POINTER, hoverText: 'Open' },
			},
			function () {
				console.log('CLICKED CRATE')
			}
		)
	}
}
```

Aqui, `engine.getEntityOrNullByName()` obtém uma referência à Entity chamada *Yellow Crate*. A verificação `if (crate)` garante que a Entity existe mesmo na scene; se não houver nenhuma Entity com esse nome, `crate` é `null`. Consulte [Referenciar itens](https://docs.decentraland.org/creator/content-creator-pt/scene-editor/expandir-com-codigo/reference-items.md) para obter mais informações.

{% hint style="info" %}
**💡 Dica**: todas as Entities adicionadas através do Scene Editor já estão carregadas quando `main()` é executada, pelo que é seguro referenciá-las aí ou em funções chamadas indiretamente por `main()`.
{% endhint %}

## Mais tutoriais

Leia [Criar cenas com código](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/primeiros-passos/coding-scenes.md) para compreender em linhas gerais como funcionam as scenes do Decentraland.

Para ver exemplos criados com SDK7, consulte a [página de exemplos](https://docs.decentraland.org/creator/content-creator-pt/tutoriais-e-exemplos/examples.md), que contém scenes reutilizáveis e repositórios.

Consulte a secção **Guia de desenvolvimento** para obter mais instruções sobre como adicionar conteúdo à sua scene.

## Interaja com outros developers

Visite o [Discord da Decentraland](https://dcl.gg/discord) e o [Discord da DAO da Decentraland](https://discord.gg/bxHtcMxUs4) para participar numa conversa animada sobre as possibilidades e como concretizá-las na secção **Criadores** do Discord da Decentraland.

Para depurar quaisquer problemas, consulte as secções [Resolução de problemas](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/depuracao/troubleshooting.md) e [depuração](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/depuracao/debug-in-preview.md) . Um assistente de IA com as [competências de SDK](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/primeiros-passos/vibe-coding.md) instaladas também é um excelente companheiro de depuração: cole a mensagem de erro da consola ou descreva o que não está a funcionar como esperado, e normalmente consegue encontrar o problema no seu código. Se não encontrar uma solução, pode publicar na [categoria de Suporte do SDK](https://forum.decentraland.org/c/support-sdk/11) no Fórum da Decentraland.

## Recursos de arte 3D

Uma boa experiência deve incluir excelentes recursos artísticos em 3D. Se estiver interessado em criar os seus próprios modelos 3D, consulte a secção [Modelação 3D](https://docs.decentraland.org/creator/content-creator-pt/modelacao-3d-e-animacoes/3d-models.md). Mas, se preferir concentrar-se na programação ou na conceção de jogos, não precisa de criar os seus próprios recursos! Consulte [Recursos úteis](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/primeiros-passos/useful-resources.md) para encontrar bibliotecas de recursos e ferramentas de IA que pode usar para obter modelos 3D para a sua Scene.

## Publique a sua Scene

Se for proprietário de um NAME da Decentraland, de um nome ETH ENS ou de LAND, ou tiver permissões concedidas por alguém que seja, pode carregar a sua Scene para a Decentraland. Consulte [publicação](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/publicacao/publishing.md).

## Outras informações úteis

* [Programação intuitiva com IA](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/primeiros-passos/vibe-coding.md)
* [Fluxo de trabalho de desenvolvimento](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/primeiros-passos/dev-workflow.md)
* [Editar Scenes](https://docs.decentraland.org/creator/content-creator-pt/scene-editor/primeiros-passos/about-editor.md)
* [Noções essenciais do Scene Editor](https://docs.decentraland.org/creator/content-creator-pt/scene-editor/primeiros-passos/scene-editor-essentials.md)
* [Restrições de design para jogos](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/conceber-a-experiencia/design-games.md)
* [Modelação 3D](https://docs.decentraland.org/creator/content-creator-pt/modelacao-3d-e-animacoes/3d-models.md)
* [Limitações das Scenes](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/otimizacao/scene-limitations.md)


---

# 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/sdk-101.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.
