Creación con Scripts de Módulo

Para aplicar tu conocimiento de los scripts de los módulos, 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 tabla de clasificación y objetos de recogida programados para las llaves y cofres del tesoro.

Carga 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, cree un script de módulo llamado TreasureManager . El uso de un script de módulo conectará las recogidas y las tablas de clasificación.

1. En ServerStorage , crea un nuevo ModuleScript y gánale un nombre TreasureManager.

   

2. En TreasureManager, cambie el nombre de la tabla del módulo predeterminado reemplazando module con TreasureManager en ambos lugares.

   local TreasureManager = {}
   
   return TreasureManager

Usando funciones en scripts de módulos

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

Crear una función de módulo para las teclas

1. Este script de módulo usará una combinación de módulo y funciones locales, escriba dos comentarios para ayudarlo a mantenerlos separados.

   local TreasureManager = {}
   
   ------------------ Funciones Locales
   
   ------------------ Funciones del módulo
   
   return TreasureManager

2. Bajo el hacer un comentariode Module Functions , agregue 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 clave.

   local TreasureManager = {}
   
   ------------------ Funciones Locales
   
   ------------------ Funciones del 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 del módulo

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

1. Abre el script de teclas en Workspace > Keys > KeyScript .

2. En keyScript, almacena el script del módulo en una variable llamada treasureManager y ponlo igual a: require(ServerStorage:WaitForChild("TreasureManager"))

   local ServerStorage = game:GetService("ServerStorage")
   -- Requiere el script del módulo a continuación ⯆
   local treasureManager = require(ServerStorage:WaitForChild("TreasureManager"))
   
   local keys = script.Parent
   local keysFolder = keys.Parts
   local keysArray = keysFolder:GetChildren()

   Evita 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 los 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 del módulo getKey() para destruir la clave.
   • Pasa en keyPart y whichCharacter.

   local ServerStorage = game:GetService("ServerStorage")
   -- Requiere el script del 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
         -- Dale una llave al jugador y destruye la parte clave
         -- =====================================================================
         treasureManager.getKey(keyPart, whichCharacter)
         -- =====================================================================
      end
   end

4. Ejecuta el proyecto y comprueba que tocar una tecla lo destruye.

Consejos para solucionar problemas

Problema: Obtén un mensaje de error que incluye: "Infinite yield possible" .

• Compruebe la escritura de su script de módulo en un script. Si un script de módulo, como TreasureManager, se escribe de manera diferente, habrá un error. Problema: Obtén un mensaje de error que incluye: "attempt to index global" .

• Compruebe la línea que incluye el requisito para el script del módulo en keyScript . Si el módulo no incluye necesario, obligatorio, no puede usar funciones y variables de ese script de módulo. Problema: El script no se ejecuta o no puede recoger las llaves.

• En el script del módulo, asegúrate de que todo el código esté entre local TreasureManager = {} y return TreasureManager. El retorno debe ser la última línea de código en un script de módulo.

• Comprueba que haya dos paréntesis al final de la línea con necesario, obligatorio, como en WaitForChild("TreasureManager")) .

Crear una función local

En este momento, una tabla de clasificación hace un seguimiento de las llaves y el tesoro de un jugador. Para cambiar los números de la tabla de clasificación, use una función local en el script del módulo. Se usa una función local porque cambiar la llave o los valores del tesoro de un jugador solo será necesario en el script TreasureManager, no en ningún otro lugar.

1. En ServerStorage , abra el TreasureManager script.

2. Crea variables locales para hacer lo siguiendo:

   • Obtén el servicio de jugadores para que el guión pueda funcionar con las estadísticas de la tabla de clasificación del jugador.

   • Almacena el número de teclas que el jugador recibe después de tocar keyPart .

   local TreasureManager = {}
   local Players = game:GetService("Players")
   local keyDrop = 1
   
   ------------------ Funciones Locales
   
   ------------------ Funciones del módulo
   function TreasureManager.getKey(keyPart, whichCharacter)
      keyPart:Destroy()
   end
   
   return TreasureManager

3. Copia y pega estas dos funciones locales en la sección Local Functions .

   • getPlayerKeys() devuelve el valor de la clasificación del jugador Lockpicks.

   • getPlayerTreasure() devuelve el valor de la clasificación del jugador Treasure.

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

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

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

   • Añade el valor de keyDrop a playerKeys .

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

5. Ejecutar el proyecto. Comprueba que tocar una tecla lo destruye y añade 1 a las teclas del jugador en la tabla de clasificación.

   

Si es necesario, compruebe su script contra el de abajo para cualquier problema de solución de problemas.

Current TreasureManager Script
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 del módulo
function TreasureManager.getKey(keyPart, whichCharacter)
   local playerKeys = getPlayerKeys(whichCharacter)
   playerKeys.Value = playerKeys.Value + keyDrop
   keyPart:Destroy()
end

return TreasureManager

Obteniendo información de los scripts de los módulos

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

Compruebe 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 compruebe si un jugador puede abrir un cofre, en la sección Funciones del módulo , agregue una nueva función a la tabla TreasureManager llamada canOpenChest() con el parámetro whichCharacter .

   ------------------ Funciones del 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 teclas, y false si no lo tienen.

   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, cree una función en TreasureManager que le otorgue tesoro.

1. Añade una nueva función de módulo a TreasureManager llamada openChest().

   Pasa en dos argumentos:

   • chestPart - la parte del cofre para destruir.
   • whichCharacter - el jugador para dar el tesoro.

   function TreasureManager.openChest(chestPart, whichCharacter)
   
   end

2. Para restar las llaves de un jugador y otorgarle un tesoro, copia y pega el código a continuación en openChest() . Este código usa 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:Destroy()
   end

Llamar a las Funciones del Cofre

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

1. En Workspace > Cofres abre ChestScript .

2. Crea una nueva variable llamada treasureManager y requiere el script del módulo TreasureManager en ServerStorage .

   local ServerStorage = game:GetService("ServerStorage")
   -- Requiere el script del 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 if humanoid sentencia, crea una nueva variable llamada canOpen y ponla igual a:

   treasureManager.canOpenChest(whichCharacter)

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

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

   • Si es así, llama a la función openChest() del TreasureManager.

   • Luego, pasa en dos parámetros: chestPart , el cofre para destruir, y whichCharacter , el jugador para otorgar tesoro.

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

5. Ejecutar el proyecto. Compruebe que:

   • Si tienes al menos 1 clave, tocar un cofre la destruirá y otorgará tesoros.
   • Si tienes 0 llaves, no puedes abrir un cofre del tesoro.

Consejos para solucionar problemas

• En ChestScript, asegúrese de que las funciones llamadas del script del módulo como canOpenChest() estén escritas exactamente como se encuentran en el script TreasureManager. Cualquier diferencia causará un error.

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

Script de TreasureManager terminado
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 del 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: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

ChestScript Terminado
local ServerStorage = game:GetService("ServerStorage")
-- Requiere el script del 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
      -- Comprueba si el jugador puede abrir un cofre, luego déjalo obtener tesoro
      -- =====================================================================
      local canOpen = treasureManager.canOpenChest(whichCharacter)
      if canOpen == true then
         treasureManager.openChest(chestPart, whichCharacter)
      end
      -- =====================================================================
   end
end

-- Vincula cada parte del pecho a la función táctil para que funcione en todas las partes
for chestIndex = 1, #chestsArray do
   local chestPart = chestsArray[chestIndex]
   chestPart.Touched:Connect(function(otherPart)
   partTouched(otherPart, chestPart)
   end)
end

Teclado terminado
local ServerStorage = game:GetService("ServerStorage")
-- Requiere el script del 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
      -- Dale una llave al jugador y destruye la parte clave
      -- =====================================================================
      treasureManager.getKey(keyPart, whichCharacter)
      -- =====================================================================
   end
end

-- Vincula todas las partes clave a la función táctil 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ódulos en los 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 cuando interactúan con objetos del juego.