> 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/interatividade/deprecated-functions.md).

# Funções Obsoletas

Funções legadas

Todas as funções seguintes são antigas e devem ser evitadas. Continuam a funcionar, mas poderão deixar de ser suportadas no futuro. Todos estes exemplos incluem ligações para formas alternativas de obter as mesmas informações ou alcançar os mesmos resultados.

## O jogador entra ou sai da cena

{% hint style="warning" %}
**📔 Nota**: O `onEnterSceneObservable` e `onLeaveSceneObservable` são eventos obsoletos no SDK 7.x. Em vez disso, utilize `onEnterScene` ; consulte [O jogador entra ou sai da cena](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/interatividade/event-listeners.md#player-enters-or-leaves-scene).
{% endhint %}

Sempre que um avatar entra ou sai dos parcels de terreno que compõem a sua cena, ou se teletransporta para dentro ou para fora dela, é criado um evento ao qual pode associar um listener. Este evento é acionado por todos os avatares, incluindo o do jogador.

```ts
import {
	onEnterSceneObservable,
	onLeaveSceneObservable,
} from '@dcl/sdk/observables'

onEnterSceneObservable.add((player) => {
	console.log('player entered scene: ', player.userId)
})

onLeaveSceneObservable.add((player) => {
	console.log('player left scene: ', player.userId)
})
```

{% hint style="warning" %}
**📔 Nota**: Este evento só responde a jogadores que estão a ser renderizados localmente. Em cenas grandes, cujo tamanho excede o alcance visual, os jogadores que entram pelo canto oposto poderão não ser detetados. Se o número de jogadores na região exceder a capacidade de uma ilha nos servidores de Decentraland, os jogadores que não estiverem na mesma ilha não serão visíveis nem monitorizados por estes eventos.
{% endhint %}

Os observables `onEnterScene` e `onLeaveScene` importados de `'@dcl/sdk/observables'` também estão obsoletos. As funções corretas têm o mesmo nome, mas devem ser importadas de `'@dcl/sdk/src/players'` em vez disso. No exemplo abaixo, pode ver ambas as variantes: primeiro a versão obsoleta e, depois, a versão correta.

```ts
// OBSOLETO - importado de observables
import { onEnterScene, onLeaveScene } from '@dcl/sdk/observables'

onEnterScene.add((player) => {
	console.log('player entered scene: ', player.userId)
})

onLeaveScene.add((player) => {
	console.log('player left scene: ', player.userId)
})

// ATUAL - importado como uma função de jogador
import { onEnterScene, onLeaveScene } from '@dcl/sdk/src/players'

export function main() {
	onEnterScene((player) => {
		if (!player) return
		console.log('ENTERED SCENE', player)
	})

	onLeaveScene((userId) => {
		if (!userId) return
		console.log('LEFT SCENE', userId)
	})
}
```

## O jogador liga-se ou desliga-se

{% hint style="warning" %}
**📔 Nota**: A função `getConnectedPlayers` e os eventos `onPlayerConnectedObservable` e `onPlayerDisconnectedObservable` são obsoletos no SDK 7.x. Em vez disso, utilize `onEnterScene` ; consulte [O jogador entra ou sai da cena](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/interatividade/event-listeners.md#player-enters-or-leaves-scene). Cada cena é agora uma ilha de comunicação distinta, pelo que estar ligado equivale a estar na mesma cena.
{% endhint %}

Obtenha a lista completa dos jogadores atualmente ligados através de `getConnectedPlayers`.

```ts
import { getConnectedPlayers } from '~system/Players'

executeTask(async () => {
	let connectedPlayers = await getConnectedPlayers({})
	connectedPlayers.players.forEach((player) => {
		console.log('player was already here: ', player.userId)
	})
})
```

Sempre que outro jogador começa ou deixa de ser renderizado pelo motor local, é gerado um evento ao qual pode associar-se. Os jogadores podem estar ou não na mesma cena que você, mas têm de estar dentro do alcance visual (não necessariamente no seu campo de visão). O `onPlayerConnectedObservable` deteta tanto quando um jogador se liga nas proximidades como quando se aproxima o suficiente para entrar no alcance visual. Da mesma forma, o `onPlayerDisconnectedObservable` deteta quando um jogador termina a sessão ou se afasta bastante.

```ts
import {
	onPlayerConnectedObservable,
	onPlayerDisconnectedObservable,
} from '@dcl/sdk/observables'

onPlayerConnectedObservable.add((player) => {
	console.log('player entered: ', player.userId)
})

onPlayerDisconnectedObservable.add((player) => {
	console.log('player left: ', player.userId)
})
```

Tenha em atenção que, se outros jogadores já estiverem a ser renderizados nas proximidades antes de o jogador carregar a sua cena, este evento não notificará a cena recém-carregada sobre os jogadores que já estavam presentes. Se precisar de acompanhar todos os jogadores atuais, pode consultar os jogadores existentes quando a cena carregar e, em seguida, ouvir este evento para receber atualizações.

## Consultar todos os jogadores na cena

{% hint style="warning" %}
**📔 Nota**: A função `getPlayersInScene` está obsoleta no SDK 7.x. Em vez disso, percorra todos os jogadores com o componente `PlayerIdentityData` . Consulte [Obter todos os jogadores](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/interatividade/user-data.md#fetch-all-players).
{% endhint %}

Também pode obter a lista completa dos jogadores que estão atualmente na sua cena e a ser renderizados chamando `getPlayersInScene()`.

```ts
import { getPlayersInScene } from '~system/Players'

executeTask(async () => {
	let connectedPlayers = await getPlayersInScene({})
	connectedPlayers.players.forEach((player) => {
		console.log('player was already here: ', player.userId)
	})
})
```

## O jogador reproduz uma animação

{% hint style="warning" %}
**📔 Nota**: O evento `onPlayerExpressionObservable` está obsoleto no SDK 7.x. Use o componente `AvatarEmoteCommand` em vez disso. Consulte [O jogador executa uma animação](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/interatividade/event-listeners.md#player-plays-animation).
{% endhint %}

Sempre que o jogador executa uma emote (dança, aplauso, aceno, etc.), pode detetar este evento.

```ts
import { onPlayerExpressionObservable } from '@dcl/sdk/observables'

onPlayerExpressionObservable.add(({ expressionId }) => {
	console.log('Expression: ', expressionId)
})
```

O evento inclui as seguintes informações:

* expressionId: nome da emote executada (por exemplo: *wave*, *clap*, *kiss*)

{% hint style="warning" %}
**📔 Nota**: Este evento é acionado sempre que o jogador executa uma emote e a cena está carregada. Quando isso acontece, o jogador pode estar numa cena próxima.
{% endhint %}

## O jogador altera o perfil

{% hint style="warning" %}
**📔 Nota**: O evento `onProfileChanged` está obsoleto no SDK 7.x. Use o componente `AvatarEquippedData` em vez disso. Consulte [O jogador altera o perfil](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/interatividade/event-listeners.md#player-changes-profile).
{% endhint %}

Sempre que o jogador faz uma alteração no perfil, o `onProfileChanged` evento é chamado. Essas alterações podem incluir vestir diferentes Wearables, mudar o nome ou a descrição, ativar experiências portáteis, etc.

```ts
import { onProfileChanged } from '@dcl/sdk/observables'

onProfileChanged.add((profileData) => {
	console.log('Own profile data is ', profileData)
})
```

Os dados do evento incluem apenas o ID do jogador e um número de versão para o perfil do Avatar, de acordo com o servidor Catalyst. Sempre que uma alteração é propagada, o número da versão aumenta em 1.

Quando esse evento é acionado, pode usar a função [getUserData()](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/interatividade/user-data.md#get-player-data) para obter a versão mais recente destas informações, incluindo a lista de Wearables que o jogador está a usar. Poderá ter de aguardar um pouco antes de chamar `getUserData()` para garantir que a versão devolvida por esta função está atualizada.

{% hint style="info" %}
**💡 Dica**: Ao testar na pré-visualização com o Explorer Web legado, para evitar usar um Avatar aleatório, execute a cena no browser ligado à sua carteira MetaMask.
{% endhint %}

{% hint style="warning" %}
**📔 Nota**: Este evento só é acionado por alterações feitas pelo jogador atual, não por alterações nos perfis de outros jogadores próximos.
{% endhint %}

## Carregamento da cena concluído

{% hint style="warning" %}
**📔 Nota**: O evento `onSceneReadyObservable` foi preterido no SDK v7.x. Esta função já não é relevante. Pode garantir que algo é executado depois de a cena terminar de carregar, executando-o dentro da função `Main()` . Consulte [Ciclo de vida da cena](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/primeiros-passos/coding-scenes.md#scene-lifecycle)
{% endhint %}

Quando a cena termina de carregar, o `onSceneReadyObservable` é chamado. Isto funciona tanto quando o jogador entra diretamente na cena como quando se desloca até ela a partir de outro local. Quando todo o conteúdo da cena termina o carregamento inicial, incluindo modelos pesados, etc., este evento é chamado.

```ts
import { onSceneReadyObservable } from '@dcl/sdk/observables'

onSceneReadyObservable.add(() => {
	console.log('SCENE LOADED')
})
```

## Métodos de dados do jogador preteridos

{% hint style="warning" %}
**📔 Nota**: As funções `getUserData()` e `getPlayerData()` foram preteridas no SDK v7.4.x. Em alternativa, use `getPlayer()` . Consulte [Dados do utilizador](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/interatividade/user-data.md#get-player-data).
{% endhint %}

Para obter informações sobre o jogador atual que está a executar a cena, use `getUserData()`.

O exemplo abaixo importa o `~system/UserIdentity` namespace e executa `getUserData()`.

```ts
import { getUserData } from '~system/UserIdentity'

executeTask(async () => {
	let userData = await getUserData({})
	console.log(userData.data)
})
```

Pode obter dados de outros jogadores que estejam próximos chamando `getPlayerData()`, passando o ID de uma conta Decentraland.

```ts
import { getPlayerData } from '~system/Players'

executeTask(async () => {
	let userData = await getPlayerData({ userId: '0x….' })
	console.log(userData)
})
```

Ambos `getUserData()` e `getPlayerData()` retornam a mesma estrutura de dados disponível através da API de conteúdo. Consulte [Dados de qualquer jogador](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/interatividade/user-data.md#data-from-any-player)

`getPlayerData()` só pode obter dados de jogadores que estejam atualmente por perto. Não precisam necessariamente de estar na mesma cena, mas têm de estar no alcance visual, pois estas informações são obtidas pelo engine local que renderiza estes avatares. Para testar isto na pré-visualização, abra um segundo separador e inicie sessão com uma conta diferente.

{% hint style="warning" %}
**📔 Nota**: Os IDs de utilizador têm de estar sempre em minúsculas. Se copiar um endereço de carteira, certifique-se de que todos os caracteres estão em minúsculas.
{% endhint %}

As funções `getUserPublicKey()` e `getUserAccount()` também estão obsoletas. Utilize `getPlayer()` em vez delas. Consulte [Dados do utilizador](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/interatividade/user-data.md#get-player-data).

## Obter a hora do skybox

{% hint style="warning" %}
**📔 Nota**: A função `getDecentralandTime()` está obsoleta a partir do SDK v7.x.x. Utilize `getWorldTime()` em vez dela. Consulte [Obter a hora de Decentraland](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/interatividade/runtime-data.md#get-decentraland-time).
{% endhint %}

```ts
import { getDecentralandTime } from '~system/EnvironmentApi'

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

## Obter o realm

{% hint style="warning" %}
**📔 Nota**: A função `getCurrentRealm()` está obsoleta a partir do SDK v7.x.x. Utilize `getRealm()` em vez dela. Consulte [Obter dados do realm](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/interatividade/runtime-data.md#get-realm-data).
{% endhint %}

```ts
import { getCurrentRealm } from '~system/EnvironmentApi'

async function fetchPlayerData() {
	const playerRealm = await getCurrentRealm({})

	console.log(playerRealm.currentRealm?.domain)
}

fetchPlayerData()
```

## Verificar se está no modo de pré-visualização

{% hint style="warning" %}
**📔 Nota**: A `isPreviewMode()` A função está obsoleta desde o SDK v7.x.x. Em vez disso, use `getRealm()` que contém uma propriedade `preview` . Consulte [Obter dados do Realm](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/interatividade/runtime-data.md#get-realm-data).
{% endhint %}

```ts
import { isPreviewMode } from '~system/EnvironmentApi'

executeTask(async () => {
	const { isPreview } = await isPreviewMode({})

	if (isPreview) {
		console.log('Running in preview')
	}
})
```

## O jogador clica noutro jogador

Sempre que o jogador clica noutro jogador, pode detetar um evento.

```ts
import { onPlayerClickedObservable } from '@dcl/sdk/observables'

onPlayerClickedObservable.add((clickEvent) => {
	console.log('Clicked ', clickEvent.userId, ' details: ', clickEvent.ray)
})
```

{% hint style="warning" %}
**📔 Nota**: O evento `onPlayerClickedObservable` está obsoleto desde o SDK v7.x. As versões futuras permitirão uma abordagem mais [orientada a dados](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/arquitetura/data-oriented-programming.md), baseada na consulta regular de dados em vez de eventos.

Em alternativa, pode anexar um Collider invisível ao jogador e detetar cliques nesse Collider.
{% endhint %}

{% hint style="warning" %}
**📔 Nota**: Tanto o jogador que clica como o jogador em quem se clica têm de estar dentro dos parcels da cena. Este listener deteta apenas eventos em que o jogador atual clica noutros jogadores, não cliques efetuados por outros jogadores.
{% endhint %}

O evento inclui os seguintes dados:

* `userId`: O ID do jogador em quem se clicou
* `ray`: Dados sobre o raio traçado pelo clique
  * `direction`: *Vector3* Um Vector3 normalizado que representa a direção entre o ponto de origem do clique e o ponto de impacto do clique.
  * `distance`: *number* A distância, em metros, entre o ponto de origem e o ponto de impacto.
  * `origin`: *Vector3* O ponto de origem do clique: a posição do jogador que clicou, relativa à cena.

{% hint style="info" %}
**💡 Sugestão**: Por predefinição, clicar noutro jogador abre o passaporte do jogador, onde pode ver mais informações sobre essa pessoa, adicioná-la como amiga, etc. Pode desativar a abertura desta UI para que não interfira com a experiência que pretende criar, adicionando uma [Avatar Modifier Area](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/interatividade/avatares/modifier-areas.md).
{% endhint %}

## O jogador bloqueia/desbloqueia o cursor

{% hint style="warning" %}
**📔 Nota**: O evento `onPointerLockedStateChange` foi removido no SDK v7.x e já não está disponível. Consulte [Listeners de eventos](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/interatividade/event-listeners.md#player-locks-or-unlocks-cursor) para ver a alternativa atual.
{% endhint %}

Os jogadores podem alternar entre dois modos de cursor: *cursor bloqueado* para controlar a câmara ou *cursor desbloqueado* para mover o cursor livremente sobre a UI.

Os jogadores desbloqueiam o cursor ao clicar no *botão direito do rato* ou ao premir a tecla *Esc* e voltam a bloqueá-lo ao clicar em qualquer ponto do ecrã.

Para reagir sempre que um jogador alterna entre estes dois modos, use o `onChange` função na `PointerLock` componente, consulte [Ouvintes de eventos](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/interatividade/event-listeners.md#player-locks-or-unlocks-cursor).

## O jogador muda de realm ou ilha

Os jogadores em Decentraland existem em *realms*, e em *ilhas* dentro de cada realm. Os jogadores em realms ou ilhas diferentes não conseguem ver-se, interagir nem conversar entre si, mesmo que estejam nos mesmos parcels.

Sempre que o jogador muda de realm ou ilha, o evento `onRealmChangedObservable` é chamado.

```ts
import { onRealmChangedObservable } from '@dcl/sdk/observables'

onRealmChangedObservable.add((realmChange) => {
	console.log('PLAYER CHANGED ISLAND TO ', realmChange.room)
})
```

{% hint style="warning" %}
**📔 Nota**: O evento `onRealmChangedObservable` foi descontinuado no SDK v7.x. As versões futuras permitirão uma abordagem mais [orientada a dados](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/arquitetura/data-oriented-programming.md), baseada em consultar dados regularmente em vez de usar eventos.
{% endhint %}

Este evento inclui os seguintes campos:

* **serverName**: *string*; O nome do servidor Catalyst.
* **room**: *string*; O nome da ilha.
* **displayName**: *string*; O nome do servidor Catalyst seguido de *-* e do nome da ilha. Por exemplo, `unicorn-x011`.
* **domain**: *string*; O URL do servidor Catalyst que está a ser utilizado.

À medida que os jogadores se deslocam pelo mapa, podem mudar de ilha para serem agrupados com os jogadores que estão mais perto deles. As ilhas também ajustam dinamicamente as suas fronteiras para manter um grupo gerível de pessoas em cada uma. Assim, mesmo que um jogador fique parado, pode mudar de ilha à medida que outros entram e saem das cenas circundantes.

Se a sua cena depender de um [servidor de terceiros](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/rede/third-party-servers.md) para sincronizar alterações entre jogadores em tempo real, talvez queira partilhar dados apenas entre jogadores agrupados no mesmo realm e na mesma ilha. Por isso, é uma boa prática mudar de sala no servidor de terceiros sempre que os jogadores mudarem de ilha.

## Funções de criptografia

{% hint style="warning" %}
**📔 Nota**: As funções `requirePayment()`, `signMessage()`, `convertMessageToObject()` foram descontinuadas. Utilize `sendAsync()` função em vez disso. Consulte [Operações de blockchain da cena](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/blockchain/scene-blockchain-operations.md). Também existem bibliotecas que podem ajudar a simplificar alguns casos de uso comuns com estas funções.
{% endhint %}

## Eventos de vídeo

{% hint style="warning" %}
**📔 Nota**: O evento `onVideoEvent` foi descontinuado no SDK v7.x. Consulte [Ouvintes de eventos](https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/media/video-playing.md#video-events) para encontrar uma alternativa que não tenha sido descontinuada.
{% endhint %}

Quando o estado de reprodução de um vídeo muda, o observável `onVideoEvent` recebe um evento.

```ts
onVideoEvent.add((data) => {
	console.log('New Video Event ', data)
})
```

A entrada de um evento de vídeo contém as seguintes propriedades:

* `videoClipId` ( *string*): o ID da Entity cujo estado mudou.
* `componentId` (*string*): o ID da Entity cujo estado mudou.
* `currentOffset` (*number*): o valor atual da propriedade `seek` do vídeo. Este valor indica os segundos decorridos desde o início original do vídeo. *-1* por padrão.
* `totalVideoLength` (*number* ): a duração total do vídeo, em segundos. *-1* se a duração for desconhecida.
* `videoStatus`: o valor do novo estado de vídeo de `VideoTexture`, expresso como um valor do enum `VideoStatus` . Este enum pode conter os seguintes valores possíveis:
* `VideoStatus.NONE` = 0,
* `VideoStatus.ERROR` = 1,
* `VideoStatus.LOADING` = 2,
* `VideoStatus.READY` = 3,
* `VideoStatus.PLAYING` = 4,
* `VideoStatus.BUFFERING` = 5


---

# 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/interatividade/deprecated-functions.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.
