Creando con Scripts de Módulo | Documentación del Centro de creación de Roblox

Para aplicar su conocimiento de los scripts de módulo, crea un script de módulo que permite a los jugadores recoger llaves y usarlas para abrir cofres del tesoro.

Configuración del proyecto

Este proyecto incluye un mapa inicial con objetos de recogida con tablas de clasificación y objetos de recogida con scripts para las llaves y cofres del tesoro.

Cargar el proyecto inicial

Descargar el proyecto inicial.
En Roblox Studio, abra el archivo descargado: Intro to Module Scripts - Starter Project.rbxl .

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

En Almacenamiento del Servidor, crea un nuevo Script de Módulo y renombralo TreasureManager .

En TreasureManager, renombre la tabla de módulo por defecto al reemplazar module con TreasureManager en ambos lugares.


local TreasureManager = {}

return TreasureManager

Usando 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 la función getKey() se llama desde otro script, recibirá una parte clave para destruir y agregar 1 a la cantidad de llaves en el inventario del jugador.

Crea una Función de Módulo para las llaves

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


local TreasureManager = {}

------------------ Funciones locales

------------------ Funciones de módulo

return TreasureManager

En el hacer un comentario Funciones del Módulo , añade una nueva función de módulo a TreasureManager nombrado getKey() .

Usa dos parámetros:

keyPart - la parte para destruir.
whichCharacter - el jugador que tocó la parte clave.


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

Usa 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á un script predeterminado y lo llamará.

Abre el script de clave en Espacio de Trabajo > Teclas > Script de Clave .

En keyScript, almacena el script del módulo en una variable llamada treasureManager y establece la igual que: require(ServerStorage:WaitForChild("TreasureManager"))


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

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

Evita los errores al usar el operador de punto en lugar del operador de dot para hacer que el script espere hasta que <a href="/reference/engine/datatypes">TreasureManager</a> se haya cargado antes de seguir adelante. Para los scripts en ServerScriptService o ServerStorage, es seguro usar el operador de dot en lugar, como en <a href="/reference/engine/datatypes">Class.ServerStorage.TreasureManager</a> .

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

Llamar la función del módulo getKey() para destruir la clave.
Pasa en keyPart y whichCharacter .


local ServerStorage = game:GetService("ServerStorage")
-- Requiere el módulo de script 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 a la persona una llave y destruye la parte de la llave
		-- =====================================
		treasureManager.getKey(keyPart, whichCharacter)
		-- =====================================
	end
end

Ejecutar el proyecto y verificar que tocar una tecla lo destruye.

Consejos de solución de problemas

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

Compruebe la ortografía 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 requerimiento 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úrese de que todo el código esté entre local TreasureManager = {} y return TreasureManager . La devolución debe ser la última línea de código en un Script de Módulo.
Asegúrese de que hay dos paréntesis al final de la línea con necesario, obligatorio, como en WaitForChild("TreasureManager")) .

Crear una Función Local

En este momento, un tablero de clasificación registra las llaves y el tesoro de un jugador. Para cambiar los números del tablero de clasificación, usa una función local en el script del módulo. Una función local se usa porque cambiar las llaves o valores del tesoro de un jugador solo se necesitará en el script del TreasureManager, no en ningún otro lugar.

En Almacenamiento del servidor, abra el script TreasureManager.

Cree variables locales para hacer lo siguiendo:

Obtén el servicio de Jugadores para que el script pueda trabajar con las estadísticas de la tabla de clasificación del jugador.
Almacene 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 pegue estas dos funciones locales en la sección Funciones locales .

getPlayerKeys() jugadorLockpicks leaderstat 的值。
getPlayerTreasure() jugadorTreasure leaderstat 的值。


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

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

Crea una variable local para llamar getPlayerKeys(whichCharacter) .
Agregue 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. Comprueba que tocar una tecla la destruye y añade 1 a las teclas del jugador en la tabla de clasificación.

Si es necesario, compruebe su script contra el que se indica a continuación para cualquier problema de diagnóstico.

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

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

Verifique si se pueden abrir cofres

Primero en Almacenamiento del servidor > TreasureManager script, configura variables para la cantidad de llaves que cuesta abrir un cofre y la cantidad de oro que 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 comprueba si un jugador puede abrir un cofre, en la sección Funciones de Módulo , agrega una nueva función a la tabla TreasureManager nombrada canOpenChest() con el parámetro 1> whichCharacter1> .


------------------ 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 pegue el código a continuación en canOpenChest() para devolver true si el jugador tiene suficientes llaves, y false si no lo hacen.


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

Darle a los jugadores un tesoro

Para que el jugador pueda abrir un cofre, crear una función en TreasureManager que les otorga tesoro.

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

Pasa en dos argumentos:

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


function TreasureManager.openChest(chestPart, whichCharacter)

end

Para restar las llaves de un jugador y otorgarles 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 Funciones de Cofre

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

En Espacio de Trabajo > Cofres abierto ChestScript .

Cree una nueva variable llamada treasureManager y requiere el script del módulo TreasureManager en ServStorage .


local ServerStorage = game:GetService("ServerStorage")
-- Requiere el módulo de script de abajo
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 establece la igual que:

treasureManager.canOpenChest(whichCharacter)


local function partTouched(otherPart, chestPart)
	local whichCharacter = otherPart.Parent
	local humanoid = whichCharacter:FindFirstChildWhichIsA("Humanoid")
	if humanoid then
		-- Compruebe si el jugador puede abrir un cofre, luego deje que obtengan tesoro
		-- =====================================
		local canOpen = treasureManager.canOpenChest(whichCharacter)
		-- =====================================
	end
end

Luego, crea una declaración if para verificar si canOpen es cierto.

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


local function partTouched(otherPart, chestPart)
	local whichCharacter = otherPart.Parent
	local humanoid = whichCharacter:FindFirstChildWhichIsA("Humanoid")
	if humanoid then
		-- Compruebe si el jugador puede abrir un cofre, luego deje que obtengan tesoro
		-- =====================================
		local canOpen = treasureManager.canOpenChest(whichCharacter)
		if canOpen == true then
			treasureManager.openChest(chestPart, whichCharacter)
		end
		-- =====================================
	end
end

Ejecutar el proyecto. Compruebe que:
- Si tienes al menos 1 clave, tocar un cofre lo destruirá y te dará un tesoro.
- Si tienes 0 llaves, no puedes abrir un cofre de tesoro.

Consejos de solución de problemas

En ChestScript , asegúrese de que las funciones llamadas desde el script del módulo como canOpenChest() estén escritas exactamente como se encuentran en el script del TreasureManager. Cualquier diferencia causará un error.
Asegúrese de que las funciones copiadas y pegadas, como treasureManager.openChest() , son 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 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: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 módulo de script 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
      -- Compruebe si el jugador puede abrir un cofre, luego deje que obtengan 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]
   chestPart.Touched:Connect(function(otherPart)
   partTouched(otherPart, chestPart)
   end)
end

Script de clave terminado
local ServerStorage = game:GetService("ServerStorage")
-- Requiere el módulo de script 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 a la persona una llave y destruye la parte de la llave
      -- =====================================
      treasureManager.getKey(keyPart, whichCharacter)
      -- =====================================
   end
end

-- Vincula cada parte de la clave 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 los juegos 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 otorgar claves y tesoros cada vez que interactúan con objetos en el juego.