> 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 Descontinuadas

Funções legadas

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

## O jogador entra ou sai da scene

{% hint style="warning" %}
**📔 Nota**: O `onEnterSceneObservable` e `onLeaveSceneObservable` eventos estão obsoletos no SDK 7.x. Use `onEnterScene` em vez disso, veja [O jogador 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 terreno que compõem a sua scene, ou faz teleport para dentro ou para fora, isso cria um evento que pode escutar. Este evento é acionado por todos os avatars, 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 responde apenas aos jogadores que estão atualmente a ser renderizados localmente. Em scenes grandes em que o tamanho da scene excede o alcance visual, os jogadores que entram no canto oposto podem não ser registados. Se o número de jogadores na região exceder as capacidades de uma island nos servidores da Decentraland, os jogadores que não partilham a mesma island não ficam visíveis e também não são acompanhados por estes eventos.
{% endhint %}

Os observables `onEnterScene` e `onLeaveScene` importado 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 pode ver ambas as variações, primeiro a versão obsoleta, 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 jogador conecta ou desconecta

{% hint style="warning" %}
**📔 Nota**: O `getConnectedPlayers` function e a `onPlayerConnectedObservable` e `onPlayerDisconnectedObservable` eventos estão obsoletos no SDK 7.x. Use `onEnterScene` em vez disso, veja [O jogador entra ou sai da scene](/creator/content-creator-pt/scenes-sdk7/interatividade/event-listeners.md#player-enters-or-leaves-scene)Cada scene é agora uma ilha de comms distinta, tornando indiferente estar conectado ou estar na mesma scene.
{% endhint %}

Obtenha a lista completa dos jogadores atualmente conectados chamando `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 pode escutar. Os jogadores podem ou não estar na mesma scene que você, mas devem estar dentro do alcance visual (não necessariamente à vista). A `onPlayerConnectedObservable` deteta tanto quando um jogador se conecta recentemente nas proximidades ou chega perto o suficiente para estar dentro do alcance visual; do mesmo modo, a `onPlayerDisconnectedObservable` deteta quando um jogador termina a sessão ou se afasta muito.

```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 jogadores já estiverem a ser renderizados nas proximidades antes de o jogador carregar a sua scene, este evento não notificará a scene recém-carregada dos jogadores já existentes. Se precisar de acompanhar todos os jogadores atuais, pode consultar os jogadores existentes ao carregar a scene e, depois, ouvir este evento para atualizações.

## Consultar todos os jogadores na scene

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

Também pode obter a lista completa de jogadores que estão atualmente na sua scene 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 `onPlayerExpressionObservable` evento está obsoleto no SDK 7.x. Use o `AvatarEmoteCommand` component em vez disso, veja [O jogador reproduz uma animação](/creator/content-creator-pt/scenes-sdk7/interatividade/event-listeners.md#player-plays-animation).
{% endhint %}

Sempre que o jogador reproduz um emote (dança, palmas, aceno, etc.), pode detetar 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 é: *aceno*, *palmas*, *beijo*)

{% hint style="warning" %}
**📔 Nota**Este evento é acionado sempre que o jogador faz um emote e a scene está carregada. O jogador pode estar numa scene próxima quando isso acontece.
{% endhint %}

## O jogador altera o perfil

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

Sempre que o jogador faz uma alteração ao seu perfil, o `onProfileChanged` evento é chamado. Estas alterações podem incluir vestir diferentes wearables, mudar o 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 evento incluem apenas o ID do jogador e um número de versão para o perfil desse avatar, de acordo com o servidor catalyst. Sempre que uma alteração é propagada, o número de versão aumenta em 1.

Quando este evento é acionado, 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 desta informação, incluindo a lista de wearables que o jogador tem equipados. Pode ser necessário adicionar um pequeno atraso antes de chamar `getUserData()` para garantir que a versão devolvida por esta função está 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 ligado com a sua carteira Metamask.
{% endhint %}

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

## A scene terminou de carregar

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

Quando a scene termina de carregar, o `onSceneReadyObservable` é chamado. Isto funciona tanto se o jogador entrar diretamente na scene, como se o jogador se aproximar da scene a partir de outro local. Quando todo o conteúdo da scene tiver concluído o carregamento inicial, incluindo modelos pesados, etc., este evento é chamado.

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

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

## Métodos de dados do jogador obsoletos

{% hint style="warning" %}
**📔 Nota**: O `getUserData()` e `getPlayerData()` funções estão obsoletas desde 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á a executar 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)
})
```

Pode obter dados de outros jogadores que estejam por perto, 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()` devolvem a mesma estrutura de dados disponível através 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 de estar na mesma scene, mas dentro do alcance visual; isso porque esta informação é obtida a partir do engine local que está a renderizar estes avatars. Para experimentar no preview, abra um segundo separador e inicie sessão com uma conta diferente.

{% hint style="warning" %}
**📔 Nota**: Os IDs de utilizador devem 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 %}

O `getUserPublicKey()` e `getUserAccount()` funções também estão obsoletas. Por favor, 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" %}
**📔 Nota**: O `getDecentralandTime()` função está obsoleta desde 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" %}
**📔 Nota**: O `getCurrentRealm()` função está obsoleta desde 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á no modo preview

{% hint style="warning" %}
**📔 Nota**: O `isPreviewMode()` função está obsoleta desde 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('A executar em 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 `onPlayerClickedObservable` evento está obsoleto desde SDK v7.x. As versões futuras permitirão uma abordagem mais [orientada para dados](/creator/content-creator-pt/scenes-sdk7/arquitetura/data-oriented-programming.md), com base na consulta regular de dados em vez de eventos.

Como alternativa, pode anexar um collider invisível ao jogador e detetar cliques contra este.
{% endhint %}

{% hint style="warning" %}
**📔 Nota**: Tanto o jogador que faz o clique como o jogador clicado têm de estar dentro dos parcels da scene. Este listener apenas deteta eventos do jogador atual a clicar noutros jogadores, e não cliques realizados 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
  * `direction`: *Vector3* Um Vector3 normalizado que representa a direção do ponto de origem do clique até ao ponto de impacto do clique.
  * `distance`: *number* A distância em metros desde o ponto de origem até ao ponto de impacto.
  * `origin`: *Vector3* O ponto de origem do clique, a posição do jogador que fez o clique, relativa à scene.

{% hint style="info" %}
**💡 Dica**: O comportamento predefinido de clicar noutro jogador é abrir o passaporte do jogador, onde pode ver informação adicional sobre esse jogador, adicioná-lo como amigo, etc. Pode desativar a abertura desta UI para que ela não interfira com a experiência que quer construir, adicionando uma [Avatar Modifier Area](/creator/content-creator-pt/scenes-sdk7/interatividade/avatars/modifier-areas.md).
{% endhint %}

## O jogador bloqueia/desbloqueia o cursor

{% hint style="warning" %}
**📔 Nota**: O `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 jogadores 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 jogadores desbloqueiam o cursor ao clicar no *botão direito do rato* ou premindo a *tecla Esc* e bloqueiam o cursor novamente clicando em qualquer lugar no ecrã.

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

## O jogador altera realm ou island

Os jogadores na Decentraland existem em *realms*, e em *islands* distintas dentro de cada realm. Os jogadores em realms ou islands diferentes não se podem ver, interagir ou conversar entre si, mesmo que estejam nos mesmos parcels.

Cada vez que o jogador muda de realm 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" %}
**📔 Nota**: O `onRealmChangedObservable` evento está obsoleto desde SDK v7.x. As versões futuras permitirão uma abordagem mais [orientada para dados](/creator/content-creator-pt/scenes-sdk7/arquitetura/data-oriented-programming.md), com base 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 island.
* **displayName**: *string*; O nome do servidor catalyst seguido de um *-* e o nome da island. Por exemplo `unicorn-x011`.
* **domain**: *string*; O URL para o servidor catalyst usado.

À medida que os jogadores se movem pelo mapa, podem mudar de island para ficarem agrupados com os jogadores que estão agora mais próximos deles. As islands também deslocam dinamicamente as suas fronteiras para acomodar um grupo gerível de pessoas em cada uma. Por isso, mesmo que um jogador fique parado, ele pode mudar de island à medida que outros entram e saem das scenes circundantes.

Se a sua scene depender de um [servidor de terceiros](/creator/content-creator-pt/scenes-sdk7/networking/third-party-servers.md) para sincronizar alterações entre jogadores em tempo real, então talvez queira partilhar dados apenas entre jogadores agrupados na mesma realm+island, por isso é uma boa prática mudar de room no servidor de terceiros sempre que os jogadores 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 blockchain da scene](/creator/content-creator-pt/scenes-sdk7/blockchain/scene-blockchain-operations.md). Existem também 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 `onVideoEvent` evento está obsoleto desde 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 vídeo altera o seu estado de reprodução, o `onVideoEvent` observable recebe um evento.

```ts
onVideoEvent.add((data) => {
	console.log('Novo evento de vídeo ', data)
})
```

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

* `videoClipId` ( *string*): O ID da entidade que mudou de estado.
* `componentId` (*string*): O ID da entidade que mudou de estado.
* `currentOffset` (*number*): O valor atual da `seek` propriedade no vídeo. Este valor mostra os segundos após o início original do vídeo. *-1* Por predefinição.
* `totalVideoLength` (*number* ): A duração total em segundos de todo o vídeo. *-1* se a duração for desconhecida.
* `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 dynamically by asking a question.

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

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

`ask` is the immediate question: it should be specific, self-contained, and written in natural language.
`goal` is optional and describes the broader end goal you are ultimately trying to accomplish on behalf of the user. GitBook uses it to tailor the answer towards what is most useful for that goal.

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.