> 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

As funções a seguir são todas legadas e devem ser evitadas. Elas ainda funcionam, mas no futuro podem deixar de ser suportadas. Todos estes exemplos incluem links para formas alternativas de obter as mesmas informações ou alcançar os mesmos resultados.

## Player entra ou sai da scene

{% hint style="warning" %}
**📔 Observação**: A `onEnterSceneObservable` e `onLeaveSceneObservable` os eventos estão descontinuados no SDK 7.x. Use `onEnterScene` em vez disso, veja [Player entra ou sai da scene](/creator/content-creator-pt/scenes-sdk7/interatividade/event-listeners.md#player-enters-or-leaves-scene).
{% endhint %}

Sempre que um avatar entra ou sai das parcelas de terra que compõem a sua cena, ou teleporta para dentro ou para fora, isso cria um evento que você pode escutar. Esse evento é acionado por todos os avatares, incluindo o do jogador.

```ts
import {
	onEnterSceneObservable,
	onLeaveSceneObservable,
} de '@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" %}
**📔 Observação**: Este evento responde apenas a jogadores que estão sendo renderizados localmente no momento. Em cenas grandes, em que o tamanho da cena excede o alcance visual, jogadores que entram no canto oposto podem não ser registrados. Se o número de jogadores na região exceder as capacidades de uma island nos servidores da Decentraland, jogadores que não estiverem compartilhando a mesma island também não ficam visíveis e também não são rastreados por estes eventos.
{% endhint %}

As observables `onEnterScene` e `onLeaveScene` importadas de `'@dcl/sdk/observables'` também estão descontinuadas. As funções corretas têm o mesmo nome, mas são importadas de `'@dcl/sdk/src/players'` em vez disso. No exemplo abaixo, você pode ver as duas variações, primeiro a versão descontinuada e depois a correta.

```ts
// DESCONTINUADO - 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 player
import { onEnterScene, onLeaveScene } from '@dcl/sdk/src/players'

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

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

## Player conecta ou desconecta

{% hint style="warning" %}
**📔 Observação**: A `getConnectedPlayers` função e o `onPlayerConnectedObservable` e `onPlayerDisconnectedObservable` os eventos estão descontinuados no SDK 7.x. Use `onEnterScene` em vez disso, veja [Player entra ou sai da scene](/creator/content-creator-pt/scenes-sdk7/interatividade/event-listeners.md#player-enters-or-leaves-scene). Agora, cada cena é uma ilha de comunicações distinta, tornando igual estar conectado ou estar na mesma cena.
{% endhint %}

Obtenha a lista completa dos jogadores conectados no momento a partir 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 engine local, isso cria um evento que você pode escutar. Os jogadores podem ou não estar na mesma cena que você, mas precisam estar dentro do alcance visual (não necessariamente à vista). O `onPlayerConnectedObservable` detecta tanto quando um jogador se conecta perto pela primeira vez ou chega suficientemente perto para estar no alcance visual; da mesma forma, o `onPlayerDisconnectedObservable` detecta quando um jogador termina a sessão ou se afasta muito.

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

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

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

Lembre-se de que, se outros jogadores já estiverem sendo renderizados nos arredores antes de o jogador carregar a sua cena, esse evento não notificará a cena recém-carregada sobre os jogadores que já existiam. Se você precisar acompanhar todos os jogadores atuais, pode consultar os jogadores existentes ao carregar a cena e, depois, escutar este evento para atualizações.

## Consultar todos os players na scene

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

Você também pode obter a lista completa dos jogadores que estão atualmente na sua cena e sendo 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)
	})
})
```

## Player reproduz animação

{% hint style="warning" %}
**📔 Observação**: A `onPlayerExpressionObservable` evento está descontinuado no SDK 7.x. Use o `AvatarEmoteCommand` componente em vez disso, veja [Player reproduz animação](/creator/content-creator-pt/scenes-sdk7/interatividade/event-listeners.md#player-plays-animation).
{% endhint %}

Sempre que o jogador executa um emote (dança, aplauso, aceno etc.), você pode detectar este evento.

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

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

O evento inclui a seguinte informação:

* expressionId: Nome do emote executado (isto é: *wave*, *clap*, *kiss*)

{% hint style="warning" %}
**📔 Observação**: Este evento é acionado sempre que o jogador faz um emote e a cena está carregada. O jogador pode estar em uma cena próxima quando isso acontecer.
{% endhint %}

## Player altera perfil

{% hint style="warning" %}
**📔 Observação**: A `onProfileChanged` evento está descontinuado no SDK 7.x. Use o `AvatarEquippedData` componente em vez disso, veja [Player altera perfil](/creator/content-creator-pt/scenes-sdk7/interatividade/event-listeners.md#player-changes-profile).
{% endhint %}

Sempre que o jogador faz uma alteração no seu perfil, o `onProfileChanged` evento é chamado. Essas alterações podem incluir usar Wearables diferentes, mudar o nome, 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 do perfil desse avatar, de acordo com o servidor catalyst. Toda vez que uma alteração é propagada, o número de versão aumenta em 1.

Quando este evento é acionado, você pode então usar a [getUserData()](/creator/content-creator-pt/scenes-sdk7/interatividade/user-data.md#get-player-data) função para obter a versão mais recente dessas informações, incluindo a lista de Wearables que o jogador está usando. Talvez seja necessário adicionar um pequeno atraso antes de você chamar `getUserData()` para garantir que a versão retornada por esta função esteja atualizada.

{% hint style="info" %}
**💡 Dica**: Ao testar em preview com o Explorer web legado, para evitar usar um avatar aleatório, execute a cena no navegador conectado com a sua carteira Metamask.
{% endhint %}

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

## Cena concluída carregando

{% hint style="warning" %}
**📔 Observação**: A `onSceneReadyObservable` evento está descontinuado desde o SDK v7.x. Esta função não é mais relevante. Você pode garantir que algo seja executado depois que a cena terminar de carregar executando isso dentro da função `Main()` função. Veja [ciclo de vida da cena](/creator/content-creator-pt/scenes-sdk7/primeiros-passos/coding-scenes.md#scene-lifecycle)
{% endhint %}

Quando a cena termina de carregar, o `onSceneReadyObservable` é chamado. Isso funciona tanto se o jogador entrar diretamente na cena quanto se ele caminhar até a cena a partir de outro lugar. Quando todo o conteúdo da cena termina seu 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 de jogador descontinuados

{% hint style="warning" %}
**📔 Observação**: A `getUserData()` e `getPlayerData()` funções estão descontinuadas no SDK v7.4.x. Use `getPlayer()` em vez disso. Veja [Dados do utilizador](/creator/content-creator-pt/scenes-sdk7/interatividade/user-data.md#get-user-data).
{% endhint %}

Para obter informações do jogador atual que está executando 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)
})
```

Você pode obter dados de outros jogadores que estejam por perto chamando `getPlayerData()`, passando o id de uma conta da 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 por meio da content API. Veja [Dados de qualquer jogador](/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. Eles não precisam necessariamente estar na mesma cena, mas dentro do alcance visual; isso ocorre porque essas informações estão sendo obtidas do engine local que está renderizando esses avatares. Para testar isso em preview, abra uma segunda aba e faça login com uma conta diferente.

{% hint style="warning" %}
**📔 Observação**: Os IDs de utilizador devem estar sempre em minúsculas. Se estiver a copiar um endereço de carteira, certifique-se de que todos os caracteres estejam em minúsculas.
{% endhint %}

O `getUserPublicKey()` e `getUserAccount()` funções também estão descontinuadas. Use `getPlayer()` em vez disso. Veja [Dados do utilizador](/creator/content-creator-pt/scenes-sdk7/interatividade/user-data.md#get-user-data).

## Obter hora do skybox

{% hint style="warning" %}
**📔 Observação**: A `getDecentralandTime()` função está descontinuada no SDK v7.x.x. Use `getWorldTime()` em vez disso. Veja [Obter Hora da Decentraland](/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 realm

{% hint style="warning" %}
**📔 Observação**: A `getCurrentRealm()` função está descontinuada no SDK v7.x.x. Use `getRealm()` em vez disso. Veja [Obter dados do Realm](/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()
```

## Está em modo de pré-visualização

{% hint style="warning" %}
**📔 Observação**: A `isPreviewMode()` função está descontinuada no SDK v7.x.x. Use `getRealm()` em vez disso, que contém uma `preview` propriedade. Veja [Obter dados do Realm](/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 em outro jogador

Sempre que o jogador clica em outro jogador, você pode detectar um evento.

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

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

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

Como alternativa, você pode anexar um collider invisível ao jogador e detectar cliques contra ele.
{% endhint %}

{% hint style="warning" %}
**📔 Observação**: Tanto o jogador que executa o clique quanto o jogador clicado precisam estar dentro das parcelas da cena. Este listener detecta apenas eventos do jogador atual clicando em outros jogadores, e não cliques executados por outros jogadores.
{% endhint %}

O evento inclui os seguintes dados:

* `userId`: O id do jogador clicado
* `ray`: Dados sobre o ray traçado pelo clique
  * `direção`: *Vector3* Um Vector3 normalizado que representa a direção do ponto de origem do clique até o ponto de impacto do clique.
  * `distance`: *number* A distância em metros do ponto de origem até o ponto de impacto.
  * `origin`: *Vector3* O ponto de origem do clique, a posição do jogador que fez o clique, relativa à cena.

{% hint style="info" %}
**💡 Dica**: O comportamento padrão de clicar em outro jogador é abrir o passaporte do jogador, onde você pode ver informações adicionais sobre esse jogador, adicioná-lo como amigo etc. Você pode desativar a abertura desta UI para que ela não atrapalhe a experiência que você deseja criar adicionando um [Avatar Modifier Area](/creator/content-creator-pt/scenes-sdk7/interatividade/avatares/modifier-areas.md).
{% endhint %}

## O jogador bloqueia/desbloqueia o cursor

{% hint style="warning" %}
**📔 Observação**: A `onPointerLockedStateChange` evento foi removido no SDK v7.x, já não está disponível. Veja [Event listeners](/creator/content-creator-pt/scenes-sdk7/interatividade/event-listeners.md#player-locks-or-unlocks-cursor) para a alternativa atual.
{% endhint %}

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

Os players desbloqueiam o cursor ao clicar com o *botão direito do rato* ou ao premir a *Esc* tecla, e voltam a bloquear o cursor ao clicar em qualquer ponto do ecrã.

Para reagir cada vez que um jogador alterna entre estes dois modos, use o `onChange` função no `PointerLock` component, vê [Event listeners](/creator/content-creator-pt/scenes-sdk7/interatividade/event-listeners.md#player-locks-or-unlocks-cursor).

## O jogador muda de realm ou island

Os jogadores na Decentraland existem em *realms*separados e em *ilhas* separadas dentro de cada realm. Jogadores em diferentes realms ou ilhas não conseguem ver, interagir ou conversar uns com os outros, mesmo que estejam sobre as mesmas parcelas.

Cada vez que o jogador muda de realms ou island, o `onRealmChangedObservable` evento é chamado.

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

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

{% hint style="warning" %}
**📔 Observação**: A `onRealmChangedObservable` evento está descontinuado no SDK v7.x. As versões futuras permitirão uma abordagem mais [orientada a dados](/creator/content-creator-pt/scenes-sdk7/arquitetura/data-oriented-programming.md), baseada na consulta regular de dados em vez de 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 por um *-* e o nome da ilha. Por exemplo `unicorn-x011`.
* **domain**: *string*; A url do servidor catalyst que está sendo usado.

À medida que os jogadores se movem pelo mapa, eles podem mudar de island para ficarem agrupados com os jogadores que agora estão mais próximos deles. As islands também ajustam dinamicamente suas fronteiras para acomodar um grupo gerenciável de pessoas em cada uma. Assim, mesmo que um jogador fique parado, ele pode ter sua island alterada conforme outros entram e saem das cenas ao redor.

Se a sua cena depende de um [servidor de terceiros](/creator/content-creator-pt/scenes-sdk7/rede/third-party-servers.md) para sincronizar mudanças entre jogadores em tempo real, então talvez você queira compartilhar dados apenas entre jogadores agrupados no mesmo realm+island, portanto é uma boa prática mudar de rooms no servidor de terceiros sempre que os jogadores mudarem de island.

## Funções de crypto

{% hint style="warning" %}
**📔 Observação**: As funções `requirePayment()`, `signMessage()`, `convertMessageToObject()` estão descontinuadas. Use a `sendAsync()` função em vez disso. Veja [Operações blockchain da cena](/creator/content-creator-pt/scenes-sdk7/blockchain/scene-blockchain-operations.md). Há também libraries que podem ajudar a simplificar alguns casos de uso comuns com estas funções.
{% endhint %}

## Eventos de Vídeo

{% hint style="warning" %}
**📔 Observação**: A `onVideoEvent` evento está descontinuado no SDK v7.x. Veja [Event listeners](/creator/content-creator-pt/scenes-sdk7/media/video-playing.md#video-events) para uma alternativa não descontinuada.
{% endhint %}

Quando um vídeo altera o seu estado de reprodução, o `onVideoEvent` observable 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 que alterou o estado.
* `componentId` (*string*): O ID da Entity que alterou o estado.
* `currentOffset` (*number*): O valor atual da propriedade `seek` do vídeo. Este valor mostra os segundos decorridos desde o início original do vídeo. *-1* por padrão.
* `totalVideoLength` (*number* ): O comprimento em segundos de todo o vídeo. *-1* se o comprimento for desconhecido.
* `videoStatus`: O valor para o novo estado de vídeo do `VideoTexture`, expresso como um valor do `VideoStatus` enum. 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.