Crea con scripts de módulo | Documentación del Centro de creación de Roblox

Para aplicar tus conocimientos sobre scripts de módulo, crea un script de módulo que permita a los jugadores recoger llaves y usarlas para abrir cofres del tesoro.

Configuración del proyecto

Este proyecto incluye un mapa de inicio con tabla de clasificación y objetos recogibles programados para las llaves y los cofres del tesoro.

Cargar el proyecto de inicio

Descarga el proyecto de inicio.
En Roblox Studio, abre el archivo descargado: Intro to Module Scripts - Starter Project.rbxl.

Crear un script de módulo

Para que los jugadores puedan obtener tesoros de los cofres, crea un script de módulo llamado TreasureManager. Usar un script de módulo conectará las recogidas y las tablas de clasificación.

En ServerStorage, crea un nuevo ModuleScript y renómbralo TreasureManager.

En TreasureManager, renombra la tabla de módulo predeterminada reemplazando module con TreasureManager en ambos lugares.


local TreasureManager = {}

return TreasureManager

Usar funciones en scripts de módulo

Para probar cómo funcionan las funciones en los scripts de módulo, crea una nueva función llamada getKey(). Cuando se llame a la función getKey() desde otro script, recibirá una parte de llave para destruir y agregar 1 al número de llaves en el inventario del jugador.

Crear una función de módulo para llaves

Este script de módulo utilizará una combinación de funciones de módulo y locales, escribe dos comentarios para ayudarte a mantenerlas separadas.


local TreasureManager = {}

------------------ Funciones Locales

------------------ Funciones de Módulo

return TreasureManager

Bajo el comentario Funciones de Módulo, agrega una nueva función de módulo a TreasureManager llamada getKey().

Usa dos parámetros:

keyPart - la parte a destruir.
whichCharacter - el jugador que tocó la parte de la llave.


local TreasureManager = {}

------------------ Funciones Locales

------------------ Funciones de Módulo
function TreasureManager.getKey(keyPart, whichCharacter)

end

return TreasureManager

En getKey(), destruye keyPart.


function TreasureManager.getKey(keyPart, whichCharacter)
	keyPart:Destroy()
end

Usar la función de módulo

Ahora, la función de módulo getKey() se puede utilizar en otros scripts. Para probar esa función, abrirás un script prehecho y lo llamarás.

Abre el script de llaves en Workspace ⟩ Keys ⟩ KeyScript.

En keyScript, almacena el script de módulo en una variable llamada treasureManager y configúralo como: require(ServerStorage:WaitForChild("TreasureManager"))


local ServerStorage = game:GetService("ServerStorage")
-- Requiere el script de módulo a continuación ⯆
local treasureManager = require(ServerStorage:WaitForChild("TreasureManager"))

local keys = script.Parent
local keysFolder = keys.Parts
local keysArray = keysFolder:GetChildren()

Previene errores usando WaitForChild() en lugar del operador de punto para hacer que el script espere hasta que se haya cargado TreasureManager antes de continuar. Para scripts en ServerScriptService o ServerStorage, es seguro usar el operador de punto, como en ServerStorage.TreasureManager.

Ya hay una función llamada partTouched() para verificar si un jugador tocó la parte. Dentro de partTouched():

Llama a la función de módulo getKey() para destruir la llave.
Pasa keyPart y whichCharacter.


local ServerStorage = game:GetService("ServerStorage")
-- Requiere el script de módulo a continuación ⯆
local treasureManager = require(ServerStorage:WaitForChild("TreasureManager"))

local keys = script.Parent
local keysFolder = keys.Parts
local keysArray = keysFolder:GetChildren()

local function partTouched(otherPart, keyPart)
	local whichCharacter = otherPart.Parent
	local humanoid = whichCharacter:FindFirstChildWhichIsA("Humanoid")
	if humanoid then
		-- Da al jugador una llave y destruye la parte de la llave
		-- =============================================
		treasureManager.getKey(keyPart, whichCharacter)
		-- =============================================
	end
end

Ejecuta el proyecto y verifica que tocar una llave la destruye.

Consejos de solución de problemas

Problema: Obtienes un mensaje de error que incluye: "Se puede producir un retraso infinito".

Verifica la ortografía de tu script de módulo en un script. Si un script de módulo, como TreasureManager, se escribe de manera diferente, habrá un error.

Problema: Obtienes un mensaje de error que incluye: "intento de indexar global".

Verifica la línea que incluye el requerimiento para el script de módulo en keyScript. Si el módulo no incluye requerimiento, no puede usar funciones y variables desde ese script de módulo.

Problema: El script no se ejecuta o no puede recoger llaves.

En el script de módulo, asegúrate de que todo el código esté entre local TreasureManager = {} y return TreasureManager. El return debe ser la última línea de código en un Script de Módulo.
Verifica que haya dos paréntesis al final de la línea con require, como en WaitForChild("TreasureManager")).

Crear una función local

Ahora mismo, una tabla de clasificación rastrea las llaves y tesoros de un jugador. Para cambiar los números de la tabla de clasificación, usa una función local en el script de módulo. Se utiliza una función local porque cambiar los valores de clave o tesoro de un jugador solo será necesario en el script TreasureManager, no en ningún otro lugar.

En ServerStorage, abre el script TreasureManager.

Crea variables locales para hacer lo siguiente:

Obtén el servicio Players para que el script pueda trabajar con las estadísticas de la tabla de clasificación de los jugadores.
Almacena el número de llaves que recibe el jugador después de tocar keyPart.


local TreasureManager = {}
local Players = game:GetService("Players")
local keyDrop = 1

------------------ Funciones Locales

------------------ Funciones de Módulo
function TreasureManager.getKey(keyPart, whichCharacter)
	keyPart:Destroy()
end

return TreasureManager

Copia y pega estas dos funciones locales en la sección Funciones Locales.

getPlayerKeys() devuelve el valor de Lockpicks del leaderstat del jugador.
getPlayerTreasure() devuelve el valor de Treasure del leaderstat del jugador.


------------------ Funciones Locales
local function getPlayerKeys(whichCharacter)
	local player = Players:GetPlayerFromCharacter(whichCharacter)
	local leaderstats = player:FindFirstChild("leaderstats")
	return leaderstats:WaitForChild("Lockpicks")
end
local function getPlayerTreasure(whichCharacter)
	local player = Players:GetPlayerFromCharacter(whichCharacter)
	local leaderstats = player:FindFirstChild("leaderstats")
	return leaderstats:WaitForChild("Treasure")
end
------------------ Funciones de Módulo

Para añadir las llaves del jugador, en la función de módulo getKey():

Crea una variable local para llamar a getPlayerKeys(whichCharacter).
Agrega el valor de keyDrop a playerKeys.


------------------ Funciones de Módulo
function TreasureManager.getKey(keyPart, whichCharacter)
	local playerKeys = getPlayerKeys(whichCharacter)
	playerKeys.Value = playerKeys.Value + keyDrop
	keyPart:Destroy()
end

Ejecuta el proyecto. Verifica que tocar una llave la destruye y agrega 1 a las llaves del jugador en la tabla de clasificación.

Si es necesario, compara tu script con el que hay a continuación para problemas de solución de problemas.

Script TreasureManager Actual
local TreasureManager = {}
local Players = game:GetService("Players")
local keyDrop = 1

------------------ Funciones Locales
local function getPlayerKeys(whichCharacter)
   local player = Players:GetPlayerFromCharacter(whichCharacter)
   local leaderstats = player:FindFirstChild("leaderstats")
   return leaderstats:WaitForChild("Lockpicks")
end

local function getPlayerTreasure(whichCharacter)
   local player = Players:GetPlayerFromCharacter(whichCharacter)
   local leaderstats = player:FindFirstChild("leaderstats")
   return leaderstats:WaitForChild("Treasure")
end

------------------ Funciones de Módulo
function TreasureManager.getKey(keyPart, whichCharacter)
   local playerKeys = getPlayerKeys(whichCharacter)
   playerKeys.Value = playerKeys.Value + keyDrop
   keyPart:Destroy()
end

return TreasureManager

Obtener información de los scripts de módulo

El script de módulo TreasureManager se utilizará cuando los jugadores toquen un cofre del tesoro para comprobar si tienen al menos una llave antes de abrirlo y darles oro.

Verificar si los cofres se pueden abrir

Primero, en el script TreasureManager de ServerStorage, configura variables para cuántas llaves cuesta abrir un cofre y cuánto oro contiene cada cofre.


local TreasureManager = {}

local Players = game:GetService("Players")
local keyDrop = 1
local chestPickCost = 1
local chestReward = 100

------------------ Funciones Locales
local function getPlayerKeys(whichCharacter)
	local player = Players:GetPlayerFromCharacter(whichCharacter)
	local leaderstats = player:FindFirstChild("leaderstats")
	return leaderstats:WaitForChild("Lockpicks")
end

Para crear una función que verifique si un jugador puede abrir un cofre, en la sección Funciones de Módulo, agrega una nueva función a la tabla TreasureManager llamada canOpenChest() con el parámetro whichCharacter.


------------------ Funciones de Módulo
function TreasureManager.canOpenChest(whichCharacter)

end

function TreasureManager.getKey(keyPart, whichCharacter)
	local playerKeys = getPlayerKeys(whichCharacter)
	playerKeys.Value = playerKeys.Value + keyDrop
	keyPart:Destroy()
end

Copia y pega el código a continuación en canOpenChest() para devolver true si el jugador tiene suficientes llaves, y false si no.


function TreasureManager.canOpenChest(whichCharacter)
	local playerKeys = getPlayerKeys(whichCharacter)
	if playerKeys.Value >= chestPickCost then
		return true
	else
		return false
	end
end

Otorgar tesoros a los jugadores

Para que el jugador pueda abrir un cofre, crea una función en TreasureManager que les otorgue tesoros.

Agrega una nueva función de módulo a TreasureManager llamada openChest().

Pasa dos argumentos:

chestPart - la parte del cofre a destruir.
whichCharacter - el jugador al que se le otorga el tesoro.


function TreasureManager.openChest(chestPart, whichCharacter)

end

Para restar las llaves de un jugador y otorgarles tesoros, copia y pega el código a continuación en openChest(). Este código utiliza las variables creadas anteriormente, como chestReward, la cantidad de tesoro otorgada por cofre.


function TreasureManager.openChest(chestPart, whichCharacter)
	local playerKeys = getPlayerKeys(whichCharacter)
	local playerTreasure = getPlayerTreasure(whichCharacter)
	playerKeys.Value = playerKeys.Value - chestPickCost
	playerTreasure.Value = playerTreasure.Value + chestReward
	chestPart.Parent:Destroy()
end

Llamar a las funciones del cofre

Ahora que se han creado las dos funciones de módulo, canOpenChest() y openChest(), pueden ser llamadas por las partes del cofre cada vez que un jugador las toca usando la función prehecha partTouched().

En Workspace ⟩ Chests abre ChestScript.

Crea una nueva variable llamada treasureManager y requieres el script de módulo TreasureManager en ServerStorage.


local ServerStorage = game:GetService("ServerStorage")
-- Requiere el script de módulo a continuación
local treasureManager = require(ServerStorage:WaitForChild("TreasureManager"))

local chests = script.Parent
local chestsFolder = chests.Parts
local chestsArray = chestsFolder:GetChildren()

En partTouched(), bajo la declaración if humanoid, crea una nueva variable llamada canOpen y configúralo como:

treasureManager.canOpenChest(whichCharacter)


local function partTouched(otherPart, chestPart)
	local whichCharacter = otherPart.Parent
	local humanoid = whichCharacter:FindFirstChildWhichIsA("Humanoid")
	if humanoid then
		-- Verifica si el jugador puede abrir un cofre, luego déjale obtener tesoro
		-- =============================================
		local canOpen = treasureManager.canOpenChest(whichCharacter)
		-- =============================================
	end
end

A continuación, crea una declaración if para verificar si canOpen es verdadero.

Si es así, llama a la función openChest() de TreasureManager.
Luego, pasa dos parámetros: chestPart, el cofre a destruir, y whichCharacter, el jugador al que dar el tesoro.


local function partTouched(otherPart, chestPart)
	local whichCharacter = otherPart.Parent
	local humanoid = whichCharacter:FindFirstChildWhichIsA("Humanoid")
	if humanoid then
		-- Verifica si el jugador puede abrir un cofre, luego déjale obtener tesoro
		-- =============================================
		local canOpen = treasureManager.canOpenChest(whichCharacter)
		if canOpen == true then
			treasureManager.openChest(chestPart, whichCharacter)
		end
		-- =============================================
	end
end

Ejecuta el proyecto. Verifica que:
- Si tienes al menos 1 llave, tocar un cofre lo destruirá y otorgará tesoro.
- Si tienes 0 llaves, no puedes abrir un cofre del tesoro.

Consejos de solución de problemas

En ChestScript, asegúrate de que las funciones llamadas desde el script de módulo, como canOpenChest(), están escritas exactamente como se encuentran en el script TreasureManager. Cualquier diferencia causará un error.
Verifica que las funciones copiadas y pegadas, como treasureManager.openChest(), estén exactamente como se muestran en la lección. Cualquier diferencia puede causar errores sutiles en el script.

Scripts finalizados

Script TreasureManager Finalizado
local TreasureManager = {}
local Players = game:GetService("Players")
local keyDrop = 1
local chestPickCost = 1
local chestReward = 100

------------------ Funciones Locales
local function getPlayerKeys(whichCharacter)
   local player = Players:GetPlayerFromCharacter(whichCharacter)
   local leaderstats = player:FindFirstChild("leaderstats")
   return leaderstats:WaitForChild("Lockpicks")
end

local function getPlayerTreasure(whichCharacter)
   local player = Players:GetPlayerFromCharacter(whichCharacter)
   local leaderstats = player:FindFirstChild("leaderstats")
   return leaderstats:WaitForChild("Treasure")
end

------------------ Funciones de Módulo
function TreasureManager.openChest(chestPart, whichCharacter)
   local playerKeys = getPlayerKeys(whichCharacter)
   local playerTreasure = getPlayerTreasure(whichCharacter)
   playerKeys.Value = playerKeys.Value - chestPickCost
   playerTreasure.Value = playerTreasure.Value + chestReward
   chestPart.Parent:Destroy()
end

function TreasureManager.canOpenChest(whichCharacter)
   local playerKeys = getPlayerKeys(whichCharacter)
   if playerKeys.Value >= chestPickCost then
   return true
   else
   return false
   end
end

function TreasureManager.getKey(keyPart, whichCharacter)
   local playerKeys = getPlayerKeys(whichCharacter)
   playerKeys.Value = playerKeys.Value + keyDrop
   keyPart:Destroy()
end

return TreasureManager

Script ChestScript Finalizado
local ServerStorage = game:GetService("ServerStorage")
-- Requiere el script de módulo a continuación ⯆
local treasureManager = require(ServerStorage:WaitForChild("TreasureManager"))

local chests = script.Parent
local chestsFolder = chests.Parts
local chestsArray = chestsFolder:GetChildren()

local function partTouched(otherPart, chestPart)
   local whichCharacter = otherPart.Parent
   local humanoid = whichCharacter:FindFirstChildWhichIsA("Humanoid")
   if humanoid then
      -- Verifica si el jugador puede abrir un cofre, luego déjale obtener tesoro
      -- =============================================
      local canOpen = treasureManager.canOpenChest(whichCharacter)
      if canOpen == true then
         treasureManager.openChest(chestPart, whichCharacter)
      end
      -- =============================================
   end
end

-- Vincula cada parte del cofre a la función de toque para que funcione en todas las partes
for chestIndex = 1, #chestsArray do
   local chestPart = chestsArray[chestIndex]:WaitForChild("Collider")
   chestPart.Touched:Connect(function(otherPart)
   partTouched(otherPart, chestPart)
   end)
end

Script keyScript Finalizado
local ServerStorage = game:GetService("ServerStorage")
-- Requiere el script de módulo a continuación ⯆
local treasureManager = require(ServerStorage:WaitForChild("TreasureManager"))

local keys = script.Parent
local keysFolder = keys.Parts
local keysArray = keysFolder:GetChildren()

local function partTouched(otherPart, keyPart)
   local whichCharacter = otherPart.Parent
   local humanoid = whichCharacter:FindFirstChildWhichIsA("Humanoid")
   if humanoid then
      -- Da al jugador una llave y destruye la parte de la llave
      -- =============================================
      treasureManager.getKey(keyPart, whichCharacter)
      -- =============================================
   end
end

-- Vincula cada parte de llave a la función de toque para que funcione en todas las partes
for keyIndex = 1, #keysArray do
   local keyPart = keysArray[keyIndex]
   keyPart.Touched:Connect(function(otherPart)
      partTouched(otherPart, keyPart)
   end)
end

Resumen

Una aplicación común del uso de scripts de módulo en las experiencias de Roblox es manejar tareas comunes usadas por los jugadores, como otorgarles puntos. Para este ejemplo, se creó un script de módulo llamado TreasureManager para manejar la entrega de llaves y tesoros a los jugadores siempre que interactúen con objetos en el juego.