Crie com scripts de módulo

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 programados para as chaves e baús de tesouro.

Carregar o projeto inicial

1. Baixe o projeto inicial.

   Baixar

2. 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 dos baús, crie um script de módulo chamado TreasureManager. Usar um script de módulo conectará as coletas e os placares.

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

   

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

   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 chaves

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

2. Sob o comentário Funções de Módulo, adicione uma nova função de módulo a 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

3. 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é-fabricado e a chamará.

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

2. 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 usando WaitForChild() em vez do operador de ponto para fazer o script esperar até que TreasureManager tenha carregado antes de prosseguir. Para scripts em ServerScriptService ou ServerStorage, é seguro usar o operador de ponto, como em ServerStorage.TreasureManager.

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

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

Dicas de solução de problemas

Problema: Receber 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, haverá um erro.

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

• Verifique a linha que inclui a requisição para o script de módulo em keyScript. Se o módulo não incluir a requisição, não poderá usar funções e variáveis desse 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 esteja 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 a requisição, como em WaitForChild("TreasureManager")).

Criar uma Função Local

Neste momento, um placar mantém o controle das chaves e tesouros de um jogador. Para alterar os números do placar, use 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, não em nenhum outro lugar.

1. Em ServerStorage, abra o script TreasureManager.

2. Crie variáveis locais para fazer o seguinte:

   • Obter o serviço Players para que o script possa trabalhar com as estatísticas do placar do jogador.

   • Armazenar o número de chaves que o jogador recebe após tocar em 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

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

4. Para adicionar as chaves do jogador, na função de 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

5. 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 quaisquer problemas de solução.

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 os jogadores tocarem em um baú de tesouro para verificar se eles têm pelo menos uma chave antes de abri-lo e dar-lhes ouro.

Verificar se os baús podem ser abertos

1. Primeiro, em ServerStorage ⟩ TreasureManager, configure variáveis para quantas chaves custa 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

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

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

Dar tesouros aos jogadores

Para que o jogador possa abrir um baú, crie uma função em TreasureManager que os recompense com tesouro.

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

   Passe dois argumentos:

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

   function TreasureManager.openChest(chestPart, whichCharacter)
   
   end

2. Para subtrair as chaves de um jogador e recompensá-lo com 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 do baú sempre que um jogador as tocar usando a função pré-fabricada partTouched().

1. Em Workspace ⟩ Chests, abra ChestScript.

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

3. Em partTouched(), sob a declaraçã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

4. Em seguida, crie uma declaraçã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 dar 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

5. Execute o projeto. Verifique se:

   • Se você tiver pelo menos 1 chave, tocar em um baú o destruirá e concederá tesouro.
   • Se você tiver 0 chaves, não poderá abrir um baú de tesouro.

Dicas de solução de problemas

• Em ChestScript, certifique-se de que as 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 as funções copiadas e coladas, como treasureManager.openChest(), estão exatamente como mostrado na lição. Qualquer diferença pode causar erros sutis no script.

Scripts finalizados

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

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

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 em jogos 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 eles interagem com objetos do jogo.