Propiedades y atributos

Hacer que las experiencias sean interactivas a menudo significa manipular las propiedades e atributos del objeto:

• Las propiedades son parte de la clase de objeto.Por ejemplo, la propiedad BasePart.Anchored controla la física para la parte.En una experiencia de pista y campo, es posible que desees anclar un disco o jabalina en el momento en que aterriza para que los jugadores tengan una indicación visual de la distancia que recorrió.

• Los atributos son esencialmente propiedades personalizadas que defines.Por ejemplo, el proyecto de referencia Planta utiliza atributos para establecer el precio de compra de las semillas y el tamaño máximo de la planta que un maceta puede contener.

Orden de replicación

Antes de comenzar a recuperar y manipular objetos, debe tener una comprensión de la orden de replicación.

El motor de Roblox no garantiza el orden en el que se replican los objetos desde el servidor al cliente, lo que hace que el método Instance:WaitForChild() sea esencial para acceder a los objetos en los scripts del cliente, particularmente objetos en el Workspace.Aún así, algunos aspectos del proceso son predecibles:

1. El cliente carga el contenido de ReplicatedFirst , como una pantalla de carga, recursos y scripts.

2. LocalScripts (y Scripts con un RunContext de Client ) en ReplicatedFirst ejecutar.Estos scripts pueden obtener objetos de forma segura de ReplicatedFirst sin usar WaitForChild() :

   -- Seguro
   local ReplicatedFirst = game:GetService("ReplicatedFirst")
   local LoadingScreen = require(ReplicatedFirst.LoadingScreen)

   Estos scripts no pueden obtener de forma segura objetos de otros servicios, porque es posible que aún no hayan cargado:

   -- No es seguro
   local ReplicatedStorage = game:GetService("ReplicatedStorage")
   local PickupManager = require(ReplicatedStorage.PickupManager)

   Puedes usar en estos scripts para obtener objetos de otros servicios, pero hacerlo anula los beneficios de usar .

3. El cliente continúa cargando el resto de la experiencia.

4. Cuando termine, se activa el evento game.Loaded y game:IsLoaded() devuelve verdadero.

5. LocalScripts en Players.Player.PlayerScripts (copiado de StarterPlayerScripts ) ejecutar, así como el cliente Scripts en ReplicatedStorage .Estos scripts pueden obtener objetos de forma segura de ReplicatedStorage sin usar WaitForChild().

6. El modelo del jugador Character aparece en la experiencia.

7. LocalScripts en Workspace.Character (copiado de StarterCharacterScripts ) ejecutar.

Si tu experiencia usa transmisión de instancias ( Workspace.StreamingEnabled ), algunos o la mayoría de los objetos pueden no haberse cargado en el espacio de trabajo, por lo que usar WaitForChild() se convierte en una medida de seguridad aún más importante.En particular, vea Stream en y controles de transmisión por modelo adicionales para obtener información adicional sobre la carga y la optimización del comportamiento de transmisión.

Obtener objetos

El primer paso para modificar las propiedades y atributos del objeto es obtener una referencia al objeto.La solución más sencilla es hacer del script un hijo del objeto en el Explorador y usar script.Parent para referenciar el objeto.

local sign = script.Parent

La solución más universal es obtener el objeto de un servicio usando métodos como Instance:FindFirstChild() o Instance:WaitForChild().

local ReplicatedStorage = game:GetService("ReplicatedStorage")

local signsFolder = ReplicatedStorage:WaitForChild("Signs")
local sign = signsFolder:WaitForChild("InteractiveSign")

Modificar propiedades

Las propiedades son fáciles de acceder; solo usa un . después de la referencia del objeto —aunque si estás trabajando con un aplicación de modelado, es posible que necesites elegir una parte individual en lugar del propio modelo.

local ReplicatedStorage = game:GetService("ReplicatedStorage")
local chair = ReplicatedStorage:WaitForChild("Chair")

chair.LeftArmRest.Size = Vector3.new(10, 1, 10)

Crear atributos

Aunque puedes crear atributos de forma programática, la solución más común es crearlos con valores predeterminados en la interfaz de usuario de Studio.Entonces puedes usar scripts para modificar sus valores en respuesta a las acciones del jugador.

Para obtener información sobre la creación de atributos en Studio, consulte atributos de instancia.

Establecer atributos

Para modificar el valor de un atributo, llama Instance:SetAttribute() con un nombre y un valor.

Crear o modificar el atributo
local cabbage = script.Parent

cabbage:SetAttribute("Harvestable", true)

Si el atributo no existe, este método lo crea.

Obtener valores de atributo

Para obtener el valor de un atributo existente, llame a Instance:GetAttribute() en la instancia.

Obtener el valor del atributo
local cabbage = script.Parent

cabbage:SetAttribute("Harvestable", true)

local isHarvestable = cabbage:GetAttribute("Harvestable")
print(isHarvestable) --> true

Del mismo modo, puedes obtener todos los atributos llamando Instance:GetAttributes(). Este método devuelve un diccionario de pares clave-valor.

Obtener todos los atributos
local cabbage = script.Parent

local cabbageAttributes = cabbage:GetAttributes()

print(cabbageAttributes.GrowthRate) --> 2

for k, v in cabbageAttributes do
	print(k, v)
end

Atributos de eliminación

Para eliminar un atributo, establece su valor en nil .

Atributo de eliminación
local cabbage = script.Parent

cabbage:SetAttribute("GrowthRate", nil)

Detectar cambios

Hay varias maneras de escuchar cambios en propiedades y atributos:

• La lista de eventos Instance.AttributeChanged escucha cambios en cualquier atributo y pasa el nombre del atributo cambiado como parámetro.
• El método Instance:GetPropertyChangedSignal() te permite escuchar cambios en una propiedad y no pasa parámetros.
• El método Instance:GetAttributeChangedSignal() te permite escuchar cambios a un atributo y no pasa parámetros.

Debido a la información mínima que pasan estos eventos y métodos como parámetros, todos son una buena opción para funciones anónimas, particularmente Instance:GetPropertyChangedSignal() y Instance:GetAttributeChangedSignal().Para aprender más sobre funciones anónimas y trabajar con eventos, vea Eventos.

Escuchar cambios
local cabbage = script.Parent

-- Funciones locales
local function onAnyPropertyChange(property)
	-- Ignorar cambios en los atributos
	if property ~= "Attributes" then
		print(property) --> Nombre
		print(cabbage[property]) --> Col1
	end
end

local function onAnyAttributeChange(attribute)
	print(attribute) --> Crecer, Tasa de crecimiento
	print(cabbage:GetAttribute(attribute)) --> falsa, 3
end

-- Escuchar cambios y conectarse a funciones locales
cabbage.Changed:Connect(onAnyPropertyChange)
cabbage.AttributeChanged:Connect(onAnyAttributeChange)

-- Escuchar cambios y conectarse a funciones anónimas
cabbage:GetPropertyChangedSignal("Name"):Connect(function()
	print(cabbage.Name) --> Col1
end)
cabbage:GetAttributeChangedSignal("GrowthRate"):Connect(function()
	print(cabbage:GetAttribute("GrowthRate")) --> 3
end)

-- Incendios cambiados y GetPropertyChangedSignal()
cabbage.Name = "Cabbage1"

-- Incendios cambiados y atributos cambiados
cabbage:SetAttribute("Grow", false)

-- Fuegos cambiados, AttributeChanged y GetAttributeChangedSignal()
cabbage:SetAttribute("GrowthRate", 3)