Criar com scripts de módulo | Documentação

Para aplicar seu conhecimento sobre scripts de módulo, crie um script de módulo que permita aos jogadores pegar chaves e usá-las para abrir baús de tesouro.

Configuração do projeto

Este projeto inclui um mapa inicial com placar e objetos de coleta com script para as chaves e baús de tesouro.

Carregar o projeto inicial

Baixe o projeto inicial.
No Roblox Studio, abra o arquivo baixado: Intro to Module Scripts - Starter Project.rbxl.

Criar um script de módulo

Para que os jogadores possam obter tesouros de baús, crie um script de módulo chamado TreasureManager. Usar um script de módulo conectará as coletas e placares juntos.

Em ServerStorage, crie um novo ModuleScript e renomeie-o para TreasureManager.

Em TreasureManager, renomeie a tabela de módulo padrão substituindo module por TreasureManager em ambos os locais.


local TreasureManager = {}

return TreasureManager

Usar funções em scripts de módulo

Para testar como as funções funcionam em scripts de módulo, crie uma nova função chamada getKey(). Quando a função getKey() for chamada de outro script, ela receberá uma parte da chave para destruir e adicionar 1 ao número de chaves no inventário do jogador.

Criar uma função de módulo para as chaves

Este script de módulo usará uma combinação de funções de módulo e locais. Digite dois comentários para ajudá-lo a mantê-los separados.


local TreasureManager = {}

------------------ Funções Locais

------------------ Funções de Módulo

return TreasureManager

Sob o comentário Funções de Módulo, adicione uma nova função de módulo ao TreasureManager chamada getKey().

Use dois parâmetros:

keyPart - a parte a ser destruída.
whichCharacter - o jogador que tocou a parte da chave.


local TreasureManager = {}

------------------ Funções Locais

------------------ Funções de Módulo
function TreasureManager.getKey(keyPart, whichCharacter)

end

return TreasureManager

Em getKey(), destrua keyPart.


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

Usar a função de módulo

Agora, a função de módulo getKey() pode ser usada em outros scripts. Para testar essa função, você abrirá um script pré-feito e a chamará.

Abra o script da chave em Workspace ⟩ Keys ⟩ KeyScript.

No keyScript, armazene o script de módulo em uma variável chamada treasureManager e defina-a como: require(ServerStorage:WaitForChild("TreasureManager"))


local ServerStorage = game:GetService("ServerStorage")
-- Requer o script de módulo abaixo ⯆
local treasureManager = require(ServerStorage:WaitForChild("TreasureManager"))

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

Previna erros utilizando WaitForChild() ao invés do operador ponto para fazer o script esperar até que TreasureManager tenha carregado antes de prosseguir. Para scripts em ServerScriptService ou ServerStorage, é seguro usar o operador ponto, como em ServerStorage.TreasureManager.

Já existe uma função chamada partTouched() para verificar se um jogador tocou a parte. Dentro de partTouched():

Chame a função de módulo getKey() para destruir a chave.
Passe keyPart e whichCharacter.


local ServerStorage = game:GetService("ServerStorage")
-- Requer o script de módulo abaixo ⯆
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
		-- Dê ao jogador uma chave e destrua a parte da chave
		-- =============================================
		treasureManager.getKey(keyPart, whichCharacter)
		-- =============================================
	end
end

Execute o projeto e verifique se tocar em uma chave a destrói.

Dicas de resolução de problemas

Problema: Recebo uma mensagem de erro incluindo: "Infinite yield possible".

Verifique a ortografia do seu script de módulo em um script. Se um script de módulo, como TreasureManager, estiver escrito de forma diferente, ocorrerá um erro.

Problema: Recebo uma mensagem de erro incluindo: "attempt to index global".

Verifique a linha que inclui a requisição para o script de módulo no keyScript. Se o módulo não incluir require, não pode usar funções e variáveis daquele script de módulo.

Problema: O script não é executado ou não consegue pegar chaves.

No script de módulo, certifique-se de que todo o código está entre local TreasureManager = {} e return TreasureManager. O retorno deve ser a última linha de código em um script de módulo.
Verifique se há dois parênteses no final da linha com require, como em WaitForChild("TreasureManager")).

Criar uma Função Local

Atualmente, um placar monitora as chaves e tesouros de um jogador. Para alterar os números do placar, utilize uma função local no script de módulo. Uma função local é usada porque mudar os valores de chave ou tesouro de um jogador só será necessário no script TreasureManager, e não em outros lugares.

Em ServerStorage, abra o script TreasureManager.

Crie variáveis locais para fazer o seguinte:

Obter o serviço Players para que o script possa trabalhar com as estatísticas no placar do jogador.
Armazenar o número de chaves que o jogador recebe após tocar keyPart.


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

------------------ Funções Locais

------------------ Funções de Módulo
function TreasureManager.getKey(keyPart, whichCharacter)
	keyPart:Destroy()
end

return TreasureManager

Copie e cole essas duas funções locais na seção Funções Locais.

getPlayerKeys() retorna o valor do Lockpicks leaderstat do jogador.
getPlayerTreasure() retorna o valor do Treasure leaderstat do jogador.


------------------ Funções Locais
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
------------------ Funções de Módulo

Para adicionar as chaves do jogador, na função do módulo getKey():

Crie uma variável local para chamar getPlayerKeys(whichCharacter).
Adicione o valor de keyDrop a playerKeys.


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

Execute o projeto. Verifique se tocar em uma chave a destrói e adiciona 1 às chaves do jogador no placar.

Se necessário, verifique seu script em relação ao abaixo para problemas de resolução.

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

------------------ Funções Locais
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

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

return TreasureManager

Obter informações de scripts de módulo

O script de módulo TreasureManager será usado quando jogadores tocarem um baú de tesouro para verificar se eles têm pelo menos uma chave antes de abri-lo e concedê-los ouro.

Verificar se os baús podem ser abertos

Primeiro, em ServerStorage ⟩ TreasureManager script, configure variáveis para quantas chaves custam para abrir um baú, e quanto ouro cada baú contém.


local TreasureManager = {}

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

------------------ Funções Locais
local function getPlayerKeys(whichCharacter)
	local player = Players:GetPlayerFromCharacter(whichCharacter)
	local leaderstats = player:FindFirstChild("leaderstats")
	return leaderstats:WaitForChild("Lockpicks")
end

Para criar uma função que verifica se um jogador pode abrir um baú, na seção Funções de Módulo, adicione uma nova função à tabela TreasureManager chamada canOpenChest() com o parâmetro whichCharacter.


------------------ Funções 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

Copie e cole o código abaixo em canOpenChest() para retornar true se o jogador tiver chaves suficientes, e false se não tiver.


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

Conceder tesouro aos jogadores

Para que o jogador possa abrir um baú, crie uma função em TreasureManager que conceda a eles tesouro.

Adicione uma nova função de módulo ao TreasureManager chamada openChest().

Passe dois argumentos:

chestPart - a parte do baú a ser destruída.
whichCharacter - o jogador a quem conceder tesouro.


function TreasureManager.openChest(chestPart, whichCharacter)

end

Para subtrair as chaves de um jogador e conceder-lhes tesouro, copie e cole o código abaixo em openChest(). Este código usa as variáveis criadas anteriormente, como chestReward, a quantidade de tesouro dada por baú.


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

Chamar as funções do baú

Agora que as duas funções de módulo, canOpenChest() e openChest(), foram criadas, elas podem ser chamadas pelas partes de Baú sempre que um jogador as tocar, utilizando a função pré-feita partTouched().

Em Workspace ⟩ Chests, abra ChestScript.

Crie uma nova variável chamada treasureManager e requer o script de módulo TreasureManager em ServerStorage.


local ServerStorage = game:GetService("ServerStorage")
-- Requer o script de módulo abaixo
local treasureManager = require(ServerStorage:WaitForChild("TreasureManager"))

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

Em partTouched(), sob a instrução if humanoid, crie uma nova variável chamada canOpen e defina-a como:

treasureManager.canOpenChest(whichCharacter)


local function partTouched(otherPart, chestPart)
	local whichCharacter = otherPart.Parent
	local humanoid = whichCharacter:FindFirstChildWhichIsA("Humanoid")
	if humanoid then
		-- Verifique se o jogador pode abrir um baú, então deixe-o obter tesouro
		-- =============================================
		local canOpen = treasureManager.canOpenChest(whichCharacter)
		-- =============================================
	end
end

Em seguida, crie uma instrução if para verificar se canOpen é verdadeiro.

Se sim, chame a função openChest() do TreasureManager.
Em seguida, passe dois parâmetros: chestPart, o baú a ser destruído, e whichCharacter, o jogador a quem conceder tesouro.


local function partTouched(otherPart, chestPart)
	local whichCharacter = otherPart.Parent
	local humanoid = whichCharacter:FindFirstChildWhichIsA("Humanoid")
	if humanoid then
		-- Verifique se o jogador pode abrir um baú, então deixe-o obter tesouro
		-- =============================================
		local canOpen = treasureManager.canOpenChest(whichCharacter)
		if canOpen == true then
			treasureManager.openChest(chestPart, whichCharacter)
		end
		-- =============================================
	end
end

Execute o projeto. Verifique se:
- Se você tiver pelo menos 1 chave, tocar em um baú irá destruí-lo e conceder tesouro.
- Se você tiver 0 chaves, não poderá abrir um baú de tesouro.

Dicas de resolução de problemas

No ChestScript, certifique-se de que funções chamadas do script de módulo, como canOpenChest(), estão escritas exatamente como estão no script TreasureManager. Qualquer diferença causará um erro.
Verifique se funções copiadas e coladas, como treasureManager.openChest(), estão exatamente como mostrado na lição. Quaisquer diferenças podem causar erros sutis no script.

Scripts finalizados

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

------------------ Funções Locais
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

------------------ Funções 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")
-- Requer o script de módulo abaixo ⯆
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
      -- Verifique se o jogador pode abrir um baú, então deixe-o obter tesouro
      -- =============================================
      local canOpen = treasureManager.canOpenChest(whichCharacter)
      if canOpen == true then
         treasureManager.openChest(chestPart, whichCharacter)
      end
      -- =============================================
   end
end

-- Vincula cada parte do baú à função de toque para que funcione em todas as 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")
-- Requer o script de módulo abaixo ⯆
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
      -- Dê ao jogador uma chave e destrua a parte da chave
      -- =============================================
      treasureManager.getKey(keyPart, whichCharacter)
      -- =============================================
   end
end

-- Vincula cada parte da chave à função de toque para que funcione em todas as partes
for keyIndex = 1, #keysArray do
   local keyPart = keysArray[keyIndex]
   keyPart.Touched:Connect(function(otherPart)
      partTouched(otherPart, keyPart)
   end)
end

Resumo

Uma aplicação comum do uso de scripts de módulo nas experiências do Roblox é lidar com tarefas comuns usadas pelos jogadores, como conceder pontos a eles. Para este exemplo, um script de módulo chamado TreasureManager foi criado para lidar com a concessão de chaves e tesouros aos jogadores sempre que interagem com objetos do jogo.