Crea con scripts de módulo

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 inicial con un marcador y objetos de recogida programados para las llaves y los cofres del tesoro.

Cargar el proyecto inicial

1. Descarga el proyecto inicial.

   Descargar

2. 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 los marcadores juntos.

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

   

2. 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 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 sumará 1 al número de llaves en el inventario del jugador.

Crear una función de módulo para llaves

1. 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

2. 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

3. 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() puede ser utilizada en otros scripts. Para probar esa función, abrirás un script prehecho y la llamarás.

1. Abre el script de la llave en Workspace ⟩ Keys ⟩ KeyScript.

2. En keyScript, almacena el script de módulo en una variable llamada treasureManager y asígnale: 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 TreasureManager se haya cargado antes de continuar. Para scripts en ServerScriptService o ServerStorage, es seguro usar el operador de punto en su lugar, como en ServerStorage.TreasureManager.

3. Ya hay una función llamada partTouched() para verificar si un jugador toca 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

4. 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: "Infinite yield possible".

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

Problema: Obtienes un mensaje de error que incluye: "attempt to index global".

• Verifica la línea que incluye el requerimiento para el script de módulo en keyScript. Si el módulo no incluye require, no puede usar funciones y variables de 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

En este momento, un marcador lleva un registro de las llaves y tesoros de un jugador. Para cambiar los números del marcador, usa una función local en el script de módulo. Se utiliza una función local porque cambiar los valores de llaves o tesoros de un jugador solo será necesario en el script de TreasureManager, no en ningún otro lugar.

1. En ServerStorage, abre el script TreasureManager.

2. Crea variables locales para hacer lo siguiente:

   • Obtener el servicio de Players para que el script pueda trabajar con las estadísticas del marcador del jugador.

   • Almacenar el número de llaves que el jugador recibe 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

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

   • getPlayerKeys() devuelve el valor de la Lockpicks del jugador en el marcador.

   • getPlayerTreasure() devuelve el valor del Treasure del jugador en el marcador.

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

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

   • Crea una variable local para llamar a getPlayerKeys(whichCharacter).

   • Suma 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

5. Ejecuta el proyecto. Verifica que tocar una llave la destruye y añade 1 a las llaves del jugador en el marcador.

   

Si es necesario, verifica tu script contra el que se muestra a continuación para cualquier problema de solución de problemas.

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 scripts de módulo

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

Verificar si los cofres se pueden abrir

1. Primero en ServerStorage ⟩ TreasureManager script, 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

2. 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

3. 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

Dar tesoros a los jugadores

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

1. 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 dará el tesoro.

   function TreasureManager.openChest(chestPart, whichCharacter)
   
   end

2. Para restar las llaves de un jugador y otorgarle tesoro, 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 dada 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().

1. En Workspace ⟩ Chests abre ChestScript.

2. Crea una nueva variable llamada treasureManager y requiere 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()

3. En partTouched(), bajo la declaración if humanoid, crea una nueva variable llamada canOpen y asígnale:

   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éjalos obtener tesoro
   		-- =============================================
   		local canOpen = treasureManager.canOpenChest(whichCharacter)
   		-- =============================================
   	end
   end

4. 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 se le otorgará 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éjalos obtener tesoro
   		-- =============================================
   		local canOpen = treasureManager.canOpenChest(whichCharacter)
   		if canOpen == true then
   			treasureManager.openChest(chestPart, whichCharacter)
   		end
   		-- =============================================
   	end
   end

5. 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(), sean exactamente como se muestran en la lección. Cualquier diferencia puede causar errores sutiles en el script.

Scripts terminados

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

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éjalos 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

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 la 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 de usar scripts de módulo en juegos de Roblox es manejar tareas comunes utilizadas 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 cada vez que interactúan con objetos en el juego.