Funciones obsoletas

Funciones heredadas

Las siguientes funciones son heredadas y deben evitarse. Aún funcionan, pero en el futuro podrían dejar de ser compatibles. Todos estos ejemplos incluyen enlaces a formas alternativas de obtener la misma información o lograr los mismos resultados.

El jugador entra o sale de la escena

📔 Nota: El onEnterSceneObservable y onLeaveSceneObservable los eventos están obsoletos en SDK 7.x. Usa onEnterScene en su lugar, ver El jugador entra o sale de la escena.

Siempre que un avatar entra o sale de los parcelas de tierra que componen tu escena, o teleporta dentro o fuera, se crea un evento al que puedes suscribirte. Este evento es activado por todos los avatares, incluido el del jugador.

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)
})

📔 Nota: Este evento solo responde a jugadores que se estén renderizando localmente. En escenas grandes donde el tamaño excede el alcance visual, los jugadores que entren por la esquina opuesta pueden no estar registrados. Si el número de jugadores en la región excede las capacidades de una isla en los servidores de Decentraland, los jugadores que no comparten la misma isla no son visibles y tampoco son rastreados por estos eventos.

Los observables onEnterScene y onLeaveScene importado desde '@dcl/sdk/observables' también están obsoletos. Las funciones correctas tienen el mismo nombre, pero se importan desde '@dcl/sdk/src/players' en su lugar. En el ejemplo abajo puedes ver ambas variaciones, primero la versión obsoleta, luego la correcta.

// DEPRECATED - imported from 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)
})

// CURRENT - imported as a player function
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)
	})
}

Jugador se conecta o desconecta

📔 Nota: El getConnectedPlayers función y el onPlayerConnectedObservable y onPlayerDisconnectedObservable los eventos están obsoletos en SDK 7.x. Usa onEnterScene en su lugar, ver El jugador entra o sale de la escena. Cada escena ahora es una isla de comunicaciones distinta, por lo que es lo mismo estar conectado que estar en la misma escena.

Obtén la lista completa de jugadores actualmente conectados desde getConnectedPlayers.

import { getConnectedPlayers } from '~system/Players'

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

Siempre que otro jugador comienza o deja de ser renderizado por el motor local, se crea un evento al que puedes suscribirte. Los jugadores pueden o no estar en la misma escena que tú, pero deben estar dentro del alcance visual (no necesariamente a la vista). El onPlayerConnectedObservable detecta tanto cuando un jugador se conecta recientemente cerca o se acerca lo suficiente para estar en el alcance visual, del mismo modo que el onPlayerDisconnectedObservable detecta cuando un jugador termina su sesión o se aleja mucho.

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)
})

Ten en cuenta que si otros jugadores ya se estaban renderizando en los alrededores antes de que el jugador cargue tu escena, este evento no notificará a la escena recién cargada sobre los jugadores ya existentes. Si necesitas llevar un registro de todos los jugadores actuales, puedes consultar los jugadores existentes al cargar la escena y luego escuchar este evento para actualizaciones.

Consultar todos los jugadores en la escena

📔 Nota: El getPlayersInScene la función está obsoleta en SDK 7.x. En su lugar, itera sobre todos los jugadores con un PlayerIdentityData componente. Ver Obtener todos los jugadores.

También puedes obtener la lista completa de jugadores que actualmente están en tu escena y se están renderizando llamando a getPlayersInScene().

import { getPlayersInScene } from '~system/Players'

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

El jugador reproduce una animación

📔 Nota: El onPlayerExpressionObservable el evento está obsoleto en SDK 7.x. Usa el AvatarEmoteCommand componente en su lugar, ver El jugador reproduce una animación.

Siempre que el jugador reproduce un emote (baila, aplaude, saluda, etc.), puedes detectar este evento.

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

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

El evento incluye la siguiente información:

• expressionId: Nombre del emote realizado (p. ej.: wave, clap, kiss)

📔 Nota: Este evento se activa cada vez que el jugador hace un emote y la escena está cargada. El jugador podría estar en una escena cercana cuando esto ocurra.

Jugador cambia el perfil

📔 Nota: El onProfileChanged el evento está obsoleto en SDK 7.x. Usa el AvatarEquippedData componente en su lugar, ver Jugador cambia el perfil.

Siempre que el jugador realiza un cambio en su perfil, se llama al evento onProfileChanged . Estos cambios pueden incluir ponerse wearables diferentes, cambiar el nombre, la descripción, activar experiencias portátiles, etc.

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

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

Los datos del evento incluyen solo el ID del jugador y un número de versión para el perfil de ese avatar, según el servidor catalyst. Cada vez que se propaga un cambio, el número de versión aumenta en 1.

Cuando se activa este evento, puedes usar entonces la getUserData() función para obtener la versión más reciente de esta información, incluida la lista de wearables que el jugador tiene puestos. Puede que necesites añadir una pequeña demora antes de llamar a getUserData() para asegurar que la versión que esta función devuelve esté actualizada.

💡 Tip: Al probar en preview con el explorador web heredado, para evitar usar un avatar aleatorio, ejecuta la escena en el navegador conectado con tu wallet Metamask.

📔 Nota: Este evento solo es desencadenado por cambios en el jugador actual, no por cambios en los perfiles de otros jugadores cercanos.

Escena terminó de cargar

📔 Nota: El onSceneReadyObservable el evento está obsoleto desde SDK v7.x. Esta función ya no es relevante. Puedes asegurar que algo se ejecute después de que la escena termine de cargar ejecutándolo dentro de la función Main() . Ver Ciclo de vida de la escena

Cuando la escena termina de cargar, se llama a onSceneReadyObservable . Esto funciona tanto si el jugador carga directamente en la escena, como si el jugador se acerca a la escena desde otro lugar. Cuando todo el contenido de la escena ha terminado su carga inicial, incluidos modelos pesados, etc., se llama a este evento.

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

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

Métodos de datos de jugador obsoletos

📔 Nota: El getUserData() y getPlayerData() las funciones están obsoletas desde SDK v7.4.x. Usa getPlayer() en su lugar. Ver Datos del usuario.

Para obtener información del jugador actual que está ejecutando la escena, usa getUserData().

El ejemplo abajo importa el ~system/UserIdentity namespace y ejecuta getUserData().

import { getUserData } from '~system/UserIdentity'

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

Puedes obtener datos de otros jugadores que estén cerca, llamando a getPlayerData(), pasando el id de una cuenta de Decentraland.

import { getPlayerData } from '~system/Players'

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

Ambas getUserData() y getPlayerData() devuelven la misma estructura de datos disponible a través de la API de contenido. Ver Datos de cualquier jugador

getPlayerData() solo se puede obtener datos de jugadores que estén actualmente cerca. No tienen que estar necesariamente en la misma escena, pero sí en alcance visual, eso es porque esta información se obtiene desde el motor local que está renderizando esos avatares. Para probar esto en preview, abre una segunda pestaña e inicia sesión con una cuenta diferente.

📔 Nota: Los IDs de usuario deben estar siempre en minúsculas. Si copias una dirección de wallet, asegúrate de que todos los caracteres estén en minúsculas.

El getUserPublicKey() y getUserAccount() las funciones también están obsoletas. Por favor usa getPlayer() en su lugar. Ver Datos del usuario.

Obtener tiempo del skybox

📔 Nota: El getDecentralandTime() la función está obsoleta desde SDK v7.x.x. Usa getWorldTime() en su lugar. Ver Obtener Decentraland Time.

import { getDecentralandTime } from '~system/EnvironmentApi'

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

Obtener realm

📔 Nota: El getCurrentRealm() la función está obsoleta desde SDK v7.x.x. Usa getRealm() en su lugar. Ver Obtener datos del Realm.

import { getCurrentRealm } from '@decentraland/EnvironmentAPI'

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

	console.log(playerRealm.domain)
}

fetchPlayerData()

Es modo preview

📔 Nota: El isPreviewMode() la función está obsoleta desde SDK v7.x.x. Usa getRealm() en su lugar, que contiene una preview propiedad. Ver Obtener datos del Realm.

import { isPreviewMode } from '~system/EnvironmentAPI'

executeTask(async () => {
	const preview: boolean = await isPreviewMode({})

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

Jugador hace clic en otro jugador

Siempre que el jugador haga clic en otro jugador, puedes detectar un evento.

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

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

📔 Nota: El onPlayerClickedObservable el evento está obsoleto desde SDK v7.x. Versiones futuras permitirán un enfoque más orientado a datos, basado en consultar datos regularmente en lugar de eventos.

Como alternativa, puedes adjuntar un collider invisible al jugador y detectar clics contra este.

📔 Nota: Tanto el jugador que realiza el clic como el jugador clicado deben estar dentro de los parcelas de la escena. Este listener solo detecta eventos del jugador actual haciendo clic en otros jugadores, no los clics realizados por otros jugadores.

El evento incluye los siguientes datos:

• userId: El id del jugador clicado

• ray: Datos sobre el rayo trazado por el clic

  • dirección: Vector3 Un Vector3 normalizado que representa la dirección desde el punto de origen del clic hasta el punto de impacto del clic.

  • distance: número La distancia en metros desde el punto de origen hasta el punto de impacto.

  • origin: Vector3 El punto de origen del clic, la posición del jugador que hizo el clic, relativa a la escena.

💡 Tip: El comportamiento predeterminado de hacer clic en otro jugador es abrir el passport del jugador, donde puedes ver información adicional sobre ese jugador, agregarlo como amigo, etc. Puedes desactivar la apertura de esta UI para que no interfiera con la experiencia que quieres construir añadiendo un Avatar Modifier Area.

El jugador bloquea/desbloquea el cursor

📔 Nota: El onPointerLockedStateChange el evento está obsoleto desde SDK v7.x. Ver Listeners de eventos para una alternativa no obsoleta.

Los jugadores pueden cambiar entre dos modos de cursor: modo de cursor bloqueado para controlar la cámara o modo de cursor desbloqueado para mover el cursor libremente sobre la UI.

Los jugadores desbloquean el cursor haciendo clic el Botón derecho del ratón o presionando la Esc tecla, y bloquean de nuevo el cursor haciendo clic en cualquier parte de la pantalla.

Este onPointerLockedStateChange evento se activa cada vez que un jugador cambia entre estos dos modos, mientras está cerca de la escena.

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

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

📔 Nota: Este evento se dispara incluso si el jugador no está parado directamente dentro de la escena.

Jugador cambia de realm o isla

Los jugadores en Decentraland existen en realms, y en islands separadas dentro de cada realm. Los jugadores en diferentes realms o islands no pueden verse, interactuar o chatear entre sí, incluso si están sobre los mismos parcelas.

Cada vez que el jugador cambia de realm o island, se llama al evento onRealmChangedObservable .

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

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

📔 Nota: El onRealmChangedObservable el evento está obsoleto desde SDK v7.x. Versiones futuras permitirán un enfoque más orientado a datos, basado en consultar datos regularmente en lugar de eventos.

Este evento incluye los siguientes campos:

• serverName: string; El nombre del servidor catalyst.

• room: string; El nombre de la isla.

• displayName: string; El nombre del servidor catalyst seguido de un - y el nombre de la isla. Por ejemplo unicorn-x011.

• domain: string; La URL del servidor catalyst en uso.

A medida que los jugadores se mueven por el mapa, pueden cambiar de isla para agruparse con aquellos jugadores que ahora están más cerca. Las islas también ajustan sus fronteras dinámicamente para acomodar un grupo manejable de personas en cada una. Así que incluso si un jugador permanece inmóvil, podría cambiar de isla a medida que otros entran y salen de las escenas circundantes.

Si tu escena depende de un servidor de terceros para sincronizar cambios entre jugadores en tiempo real, es posible que desees compartir datos solo entre jugadores que estén agrupados en el mismo realm+island, por lo que es buena práctica cambiar de sala en el servidor de terceros cada vez que los jugadores cambien de island.

Funciones cripto

📔 Nota: Las funciones requirePayment(), signMessage(), convertMessageToObject() están obsoletas. Usa la función sendAsync() en su lugar. Ver Operaciones blockchain de la escena. También existen librerías que pueden ayudar a simplificar algunos casos de uso comunes con estas funciones.

Eventos de video

📔 Nota: El onVideoEvent el evento está obsoleto desde SDK v7.x. Ver Listeners de eventos para una alternativa no obsoleta.

Cuando un video cambia su estado de reproducción, el onVideoEvent observable recibe un evento.

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

La entrada de un evento de video contiene las siguientes propiedades:

• videoClipId ( string): El ID de la entidad que cambió de estado.

• componentId (string): El ID de la entidad que cambió de estado.

• currentOffset (número): El valor actual de la propiedad seek en el video. Este valor muestra los segundos desde el inicio original del video. -1 por defecto.

• totalVideoLength (número ): La duración en segundos de todo el video. -1 si la duración es desconocida.

• videoStatus: El valor del nuevo estado del video del VideoTexture, expresado como un valor del enum VideoStatus . Este enum puede contener los siguientes valores posibles:

• VideoStatus.NONE = 0,

• VideoStatus.ERROR = 1,

• VideoStatus.LOADING = 2,

• VideoStatus.READY = 3,

• VideoStatus.PLAYING = 4,

• VideoStatus.BUFFERING = 5