# Functions descontinuadas

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" %}
**📔 Nota**: A `onEnterSceneObservable` e `onLeaveSceneObservable` eventos estão obsoletos 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 dos parcels de terra que compõem a sua scene, ou faz teleport para dentro ou para fora, isso cria um event que você pode ouvir. Este event é disparado por todos os avatares, incluindo o do player.

```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 event responde apenas aos players que estão sendo renderizados localmente no momento. Em scenes grandes, onde o tamanho da scene excede o alcance visual, players que entram no canto oposto podem não ser registrados. Se o número de players na região exceder as capacidades de uma island nos servidores da Decentraland, os players que não estiverem compartilhando a mesma island não ficam visíveis e também não são rastreados por estes events.
{% 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 são importadas de `'@dcl/sdk/src/players'` em vez disso. No exemplo abaixo você pode ver ambas as variações, primeiro a versão obsoleta e depois a 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 player
import { onEnterScene, onLeaveScene } from '@dcl/sdk/src/players'

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

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

## O player conecta ou desconecta

{% hint style="warning" %}
**📔 Nota**: A `getConnectedPlayers` função e a `onPlayerConnectedObservable` e `onPlayerDisconnectedObservable` eventos estão obsoletos 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). Cada scene agora é uma island de comunicação distinta, tornando a conexão igual a estar na mesma scene.
{% endhint %}

Obtenha a lista completa de players atualmente conectados 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 player começa ou para de ser renderizado pelo engine local, isso cria um event que você pode ouvir. Os players podem ou não estar na mesma scene que você, mas precisam estar dentro do alcance visual (não necessariamente à vista). A `onPlayerConnectedObservable` detecta tanto quando um player se conecta nas proximidades ou chega perto o suficiente para estar no alcance visual, assim como a `onPlayerDisconnectedObservable` detecta quando um player encerra a sessão ou se afasta demais.

```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 mente que, se outros players já estiverem sendo renderizados nos arredores antes de o player carregar a sua scene, este event não notificará a scene recém-carregada sobre os players já existentes. Se você precisar acompanhar todos os players atuais, pode consultar os players existentes ao carregar a scene e depois ouvir este event para atualizações.

## Consultar todos os players na scene

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

Você também pode obter a lista completa de players que estão atualmente na sua scene 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" %}
**📔 Nota**: A `onPlayerExpressionObservable` event está obsoleto no SDK 7.x. Use o `AvatarEmoteCommand` component 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 player executar um emote (dance, clap, wave, etc), você pode detectar este event.

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

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

O evento inclui as seguintes informações:

* expressionId: Nome do emote executado (por ex.: *wave*, *clap*, *kiss*)

{% hint style="warning" %}
**📔 Nota**: Este event é disparado sempre que o player faz um emote e a scene está carregada. O player pode estar em uma scene próxima quando isso acontece.
{% endhint %}

## Player muda o perfil

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

Sempre que o player faz uma alteração no seu profile, o `onProfileChanged` event é chamado. Essas alterações podem incluir vestir diferentes wearables, mudar nome, 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 event incluem apenas o ID do player e um número de versão do profile desse avatar, de acordo com o catalyst server. Cada vez que uma alteração é propagada, o número de versão aumenta em 1.

Quando este event for disparado, você pode então usar a [getUserData()](/creator/content-creator-pt/scenes-sdk7/interatividade/user-data.md#get-player-data) função para buscar a versão mais recente dessas informações, incluindo a lista de wearables que o player está usando. Talvez seja necessário adicionar um pequeno delay antes de 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 legacy web explorer, para evitar usar um avatar aleatório, execute a scene no browser conectado com a sua carteira Metamask.
{% endhint %}

{% hint style="warning" %}
**📔 Nota**: Este event é disparado apenas por alterações no player atual, e não por alterações nos profiles de outros players próximos.
{% endhint %}

## Scene concluída ao carregar

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

Quando a scene termina de carregar, o `onSceneReadyObservable` é chamado. Isso funciona tanto se o player entrar diretamente na scene quanto se o player caminhar até a scene a partir de outro lugar. Quando todo o conteúdo da scene concluir o carregamento inicial, incluindo modelos pesados, etc., este event é chamado.

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

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

## Métodos legados de dados do player

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

Para obter informações do player atual que está executando a scene, 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 players 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)
})
```

Ambas `getUserData()` e `getPlayerData()` retorna a mesma estrutura de dados disponível via a content API. Veja [Dados de qualquer player](/creator/content-creator-pt/scenes-sdk7/interatividade/user-data.md#data-from-any-player)

`getPlayerData()` só pode buscar dados de players que estejam atualmente por perto. Eles não precisam necessariamente estar na mesma scene, mas dentro do alcance visual; isso acontece porque essas informações estão sendo obtidas do engine local que está renderizando estes avatares. Para testar isso em preview, abra uma segunda aba e faça login com uma conta diferente.

{% hint style="warning" %}
**📔 Nota**: Os IDs de usuário devem sempre estar em minúsculas. Se copiar um endereço de wallet, certifique-se de que todos os caracteres estejam em minúsculas.
{% endhint %}

O `getUserPublicKey()` e `getUserAccount()` funções também estão obsoletas. Por favor, use `getPlayer()` em vez disso. Veja [Dados do usuário](/creator/content-creator-pt/scenes-sdk7/interatividade/user-data.md#get-user-data).

## Obter horário do skybox

{% hint style="warning" %}
**📔 Nota**: A `getDecentralandTime()` função está obsoleta desde o SDK v7.x.x. Use `getWorldTime()` em vez disso. Veja [Obter horário 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" %}
**📔 Nota**: A `getCurrentRealm()` função está obsoleta desde o 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 '@decentraland/EnvironmentAPI'

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

	console.log(playerRealm.domain)
}

fetchPlayerData()
```

## Está em modo preview

{% hint style="warning" %}
**📔 Nota**: A `isPreviewMode()` função está obsoleta desde o 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 preview: boolean = await isPreviewMode({})

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

## Player clica em outro player

Sempre que o player clica em outro player, você pode detectar um event.

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

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

{% hint style="warning" %}
**📔 Nota**: A `onPlayerClickedObservable` event está obsoleto desde o SDK v7.x. Futuras versões permitirão uma abordagem mais [orientada a dados](/creator/content-creator-pt/scenes-sdk7/arquitetura/data-oriented-programming.md), baseada em consultar dados regularmente em vez de events.

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

{% hint style="warning" %}
**📔 Nota**: Tanto o player que executa o clique quanto o player clicado devem estar dentro dos parcels da scene. Este listener detecta apenas events do player atual clicando em outros players, não aqueles de cliques realizados por outros players.
{% endhint %}

O event inclui os seguintes dados:

* `userId`: O id do player clicado
* `ray`: Dados sobre o ray traçado pelo clique
  * `direction`: *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 player que fez o clique, relativa à scene.

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

## Player trava/destrava o cursor

{% hint style="warning" %}
**📔 Nota**: A `onPointerLockedStateChange` event está obsoleto desde o SDK v7.x. Veja [Event listeners](/creator/content-creator-pt/scenes-sdk7/interatividade/event-listeners.md#player-locks-or-unlocks-cursor) para uma alternativa não obsoleta.
{% endhint %}

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

Os players desbloqueiam o cursor clicando no *botão direito do mouse* ou pressionando a tecla *Esc* , e bloqueiam o cursor novamente clicando em qualquer lugar da tela.

Este `onPointerLockedStateChange` event é ativado cada vez que um player alterna entre estes dois modos, enquanto estiver perto da scene.

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

onPointerLockedStateChange.add(({ locked }) => {
	if (locked) {
		console.log('Pointer has been locked')
	} else {
		console.log('Pointer has been unlocked')
	}
})
```

{% hint style="warning" %}
**📔 Nota**: Este event é disparado mesmo que o player não esteja diretamente dentro da scene.
{% endhint %}

## Player muda de realm ou island

Players na Decentraland existem em *realms*separados, e em *islands* separadas dentro de cada realm. Players em realms ou islands diferentes não conseguem se ver, interagir ou conversar entre si, mesmo que estejam nos mesmos parcels.

Cada vez que o player muda de realm ou island, o `onRealmChangedObservable` event é chamado.

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

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

{% hint style="warning" %}
**📔 Nota**: A `onRealmChangedObservable` event está obsoleto desde o SDK v7.x. Futuras versões permitirão uma abordagem mais [orientada a dados](/creator/content-creator-pt/scenes-sdk7/arquitetura/data-oriented-programming.md), baseada em consultar dados regularmente em vez de events.
{% endhint %}

Este event inclui os seguintes campos:

* **serverName**: *string*; O nome do catalyst server.
* **room**: *string*; O nome da island.
* **displayName**: *string*; O nome do catalyst server seguido de um *-* e o nome da island. Por exemplo `unicorn-x011`.
* **domain**: *string*; A url para o catalyst server utilizado.

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

Se a sua scene depende de um [servidor de 3ª parte](/creator/content-creator-pt/scenes-sdk7/networking/authoritative-servers.md) para sincronizar mudanças entre players em tempo real, então talvez seja melhor compartilhar dados apenas entre players agrupados no mesmo realm+island, então é uma boa prática mudar de room no servidor de 3ª parte sempre que os players mudarem de island.

## Funções de crypto

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

## Video Events

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

Quando um video altera seu status de reprodução, o `onVideoEvent` observable recebe um event.

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

A entrada de um video event contém as seguintes propriedades:

* `videoClipId` ( *string*): O ID da entidade que mudou de status.
* `componentId` (*string*): O ID da entidade que mudou de status.
* `currentOffset` (*number*): O valor atual da propriedade `seek` no video. Este valor mostra os segundos após o início original do video. *-1* por padrão.
* `totalVideoLength` (*number* ): A duração em segundos de todo o video. *-1* se a duração for desconhecida.
* `videoStatus`: O valor para o novo status de video do `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: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://docs.decentraland.org/creator/content-creator-pt/scenes-sdk7/interatividade/deprecated-functions.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
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.