Crea con gli script dei moduli | Documentazione

Per applicare le tue conoscenze sugli script dei moduli, crea uno script di modulo che consenta ai giocatori di raccogliere chiavi e usarle per aprire scrigni del tesoro.

Configurazione del progetto

Questo progetto include una mappa di partenza con leaderboard e oggetti di raccolta scriptati per le chiavi e gli scrigni del tesoro.

Carica il progetto di avvio

Scarica il progetto di avvio.
In Roblox Studio, apri il file scaricato: Intro to Module Scripts - Starter Project.rbxl.

Crea uno script di modulo

Affinché i giocatori possano ottenere tesori dagli scrigni, crea uno script di modulo chiamato TreasureManager. Usare uno script di modulo collegherà le raccolte e le leaderboard insieme.

In ServerStorage, crea un nuovo ModuleScript e rinominalo TreasureManager.

In TreasureManager, rinomina la tabella di modulo predefinita sostituendo module con TreasureManager in entrambi i posti.


local TreasureManager = {}

return TreasureManager

Usa le funzioni negli script dei moduli

Per testare come funzionano le funzioni negli script dei moduli, crea una nuova funzione chiamata getKey(). Quando la funzione getKey() viene chiamata da un altro script, riceverà una parte chiave da distruggere e aggiungerà 1 al numero di chiavi nell'inventario del giocatore.

Crea una funzione di modulo per le chiavi

Questo script di modulo utilizzerà una combinazione di funzioni di modulo e locali, digita due commenti per aiutarti a mantenerli separati.


local TreasureManager = {}

------------------ Funzioni Locali

------------------ Funzioni di Modulo

return TreasureManager

Sotto il commento Funzioni di Modulo, aggiungi una nuova funzione di modulo a TreasureManager chiamata getKey().

Usa due parametri:

keyPart - la parte da distruggere.
whichCharacter - il giocatore che ha toccato la parte chiave.


local TreasureManager = {}

------------------ Funzioni Locali

------------------ Funzioni di Modulo
function TreasureManager.getKey(keyPart, whichCharacter)

end

return TreasureManager

In getKey(), distruggi keyPart.


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

Usa la funzione di modulo

Ora, la funzione di modulo getKey() può essere utilizzata in altri script. Per testare quella funzione, aprirai uno script premade e la chiamerai.

Apri lo script chiave in Workspace ⟩ Keys ⟩ KeyScript.

In keyScript, memorizza lo script di modulo in una variabile chiamata treasureManager e impostala uguale a: require(ServerStorage:WaitForChild("TreasureManager"))


local ServerStorage = game:GetService("ServerStorage")
-- Richiedi lo script di modulo qui sotto ⯆
local treasureManager = require(ServerStorage:WaitForChild("TreasureManager"))

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

Previeni errori usando WaitForChild() invece dell'operatore punto per far attendere lo script fino a quando TreasureManager non è stato caricato prima di procedere. Per gli script in ServerScriptService o ServerStorage, è sicuro usare invece l'operatore punto, come in ServerStorage.TreasureManager.

C'è già una funzione chiamata partTouched() per controllare se un giocatore tocca la parte. All'interno di partTouched():

Chiama la funzione di modulo getKey() per distruggere la chiave.
Passa keyPart e whichCharacter.


local ServerStorage = game:GetService("ServerStorage")
-- Richiedi lo script di modulo qui sotto ⯆
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
		-- Dai al giocatore una chiave e distruggi la parte chiave
		-- =============================================
		treasureManager.getKey(keyPart, whichCharacter)
		-- =============================================
	end
end

Esegui il progetto e verifica che toccare una chiave la distrugga.

Suggerimenti per la risoluzione dei problemi

Problema: Ricevi un messaggio di errore che include: "Infinite yield possible".

Controlla l'ortografia del tuo script di modulo in uno script. Se uno script di modulo, come TreasureManager, è scritto in modo diverso, si verificherà un errore.

Problema: Ricevi un messaggio di errore che include: "attempt to index global".

Controlla la riga che include la richiesta per lo script di modulo in keyScript. Se il modulo non include require, non può utilizzare funzioni e variabili da quello script di modulo.

Problema: Lo script non viene eseguito o non riesce a raccogliere le chiavi.

Nello script di modulo, assicurati che tutto il codice sia tra local TreasureManager = {} e return TreasureManager. Il ritorno deve essere l'ultima riga di codice in uno script di modulo.
Controlla che ci siano due parentesi alla fine della riga con require, come in WaitForChild("TreasureManager")).

Crea una funzione locale

In questo momento, una leaderboard tiene traccia delle chiavi e dei tesori di un giocatore. Per cambiare i numeri della leaderboard, usa una funzione locale nello script di modulo. Una funzione locale è utilizzata perché modificare i valori delle chiavi o del tesoro di un giocatore sarà necessario solo nello script TreasureManager, non altrove.

In ServerStorage, apri lo script TreasureManager.

Crea variabili locali per fare quanto segue:

Ottieni il servizio Players in modo che lo script possa lavorare con le statistiche della leaderboard dei giocatori.
Memorizza il numero di chiavi che il giocatore riceve dopo aver toccato keyPart.


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

------------------ Funzioni Locali

------------------ Funzioni di Modulo
function TreasureManager.getKey(keyPart, whichCharacter)
	keyPart:Destroy()
end

return TreasureManager

Copia e incolla queste due funzioni locali nella sezione Funzioni Locali.

getPlayerKeys() restituisce il valore della Lockpicks leaderstat del giocatore.
getPlayerTreasure() restituisce il valore della Treasure leaderstat del giocatore.


------------------ Funzioni Locali
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
------------------ Funzioni di Modulo

Per aggiungere le chiavi del giocatore, nella funzione di modulo getKey():

Crea una variabile local per chiamare getPlayerKeys(whichCharacter).
Aggiungi il valore di keyDrop a playerKeys.


------------------ Funzioni di Modulo
function TreasureManager.getKey(keyPart, whichCharacter)
	local playerKeys = getPlayerKeys(whichCharacter)
	playerKeys.Value = playerKeys.Value + keyDrop
	keyPart:Destroy()
end

Esegui il progetto. Controlla che toccare una chiave la distrugga e aggiunga 1 alle chiavi del giocatore nella leaderboard.

Se necessario, controlla il tuo script con quello sottostante per eventuali problemi di risoluzione.

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

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

------------------ Funzioni di Modulo
function TreasureManager.getKey(keyPart, whichCharacter)
   local playerKeys = getPlayerKeys(whichCharacter)
   playerKeys.Value = playerKeys.Value + keyDrop
   keyPart:Destroy()
end

return TreasureManager

Ottieni informazioni dagli script di modulo

Lo script di modulo TreasureManager verrà utilizzato quando i giocatori toccano uno scrigno del tesoro per controllare se hanno almeno una chiave prima di aprirlo e dare loro oro.

Controlla se gli scrigni possono essere aperti

Prima in ServerStorage ⟩ TreasureManager, imposta le variabili per quante chiavi costano per aprire uno scrigno e quanto oro contiene ogni scrigno.


local TreasureManager = {}

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

------------------ Funzioni Locali
local function getPlayerKeys(whichCharacter)
	local player = Players:GetPlayerFromCharacter(whichCharacter)
	local leaderstats = player:FindFirstChild("leaderstats")
	return leaderstats:WaitForChild("Lockpicks")
end

Per creare una funzione che controlla se un giocatore può aprire uno scrigno, nella sezione Funzioni di Modulo, aggiungi una nuova funzione alla tabella TreasureManager chiamata canOpenChest() con il parametro whichCharacter.


------------------ Funzioni di Modulo
function TreasureManager.canOpenChest(whichCharacter)

end

function TreasureManager.getKey(keyPart, whichCharacter)
	local playerKeys = getPlayerKeys(whichCharacter)
	playerKeys.Value = playerKeys.Value + keyDrop
	keyPart:Destroy()
end

Copia e incolla il codice qui sotto in canOpenChest() per restituire true se il giocatore ha abbastanza chiavi e false se non le ha.


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

Dai ai giocatori tesori

Affinché il giocatore possa aprire uno scrigno, crea una funzione in TreasureManager che gli assegna tesori.

Aggiungi una nuova funzione di modulo a TreasureManager chiamata openChest().

Passa due argomenti:

chestPart - la parte dello scrigno da distruggere.
whichCharacter - il giocatore a cui dare tesori.


function TreasureManager.openChest(chestPart, whichCharacter)

end

Per sottrarre le chiavi di un giocatore e premiarlo con tesori, copia e incolla il codice qui sotto in openChest(). Questo codice utilizza le variabili create in precedenza, come chestReward, la quantità di tesoro data per scrigno.


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

Chiama le funzioni degli scrigni

Ora che le due funzioni di modulo, canOpenChest() e openChest(), sono state create, possono essere chiamate dai pezzi dello scrigno ogni volta che un giocatore li tocca utilizzando la funzione premade partTouched().

In Workspace ⟩ Chests apri ChestScript.

Crea una nuova variabile chiamata treasureManager e richiedi lo script di modulo TreasureManager in ServerStorage.


local ServerStorage = game:GetService("ServerStorage")
-- Richiedi lo script di modulo qui sotto
local treasureManager = require(ServerStorage:WaitForChild("TreasureManager"))

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

In partTouched(), sotto l'istruzione if humanoid, crea una nuova variabile chiamata canOpen e impostala uguale a:

treasureManager.canOpenChest(whichCharacter)


local function partTouched(otherPart, chestPart)
	local whichCharacter = otherPart.Parent
	local humanoid = whichCharacter:FindFirstChildWhichIsA("Humanoid")
	if humanoid then
		-- Controlla se il giocatore può aprire uno scrigno, poi fallo ottenere tesori
		-- =============================================
		local canOpen = treasureManager.canOpenChest(whichCharacter)
		-- =============================================
	end
end

Successivamente, crea un'istruzione if per controllare se canOpen è vero.

Se sì, chiama la funzione openChest() di TreasureManager.
Poi, passa due parametri: chestPart, lo scrigno da distruggere, e whichCharacter, il giocatore a cui assegnare il tesoro.


local function partTouched(otherPart, chestPart)
	local whichCharacter = otherPart.Parent
	local humanoid = whichCharacter:FindFirstChildWhichIsA("Humanoid")
	if humanoid then
		-- Controlla se il giocatore può aprire uno scrigno, poi fallo ottenere tesori
		-- =============================================
		local canOpen = treasureManager.canOpenChest(whichCharacter)
		if canOpen == true then
			treasureManager.openChest(chestPart, whichCharacter)
		end
		-- =============================================
	end
end

Esegui il progetto. Controlla che:
- Se hai almeno 1 chiave, toccare uno scrigno lo distruggerà e premierà con tesori.
- Se hai 0 chiavi, non puoi aprire uno scrigno del tesoro.

Suggerimenti per la risoluzione dei problemi

In ChestScript, assicurati che le funzioni chiamate dallo script di modulo come canOpenChest() siano scritte esattamente come si trovano nello script TreasureManager. Qualsiasi differenza causerà un errore.
Controlla che le funzioni copiate e incollate, come treasureManager.openChest(), siano esattamente come mostrato nella lezione. Qualsiasi differenza può causare errori sottili nello script.

Script finiti

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

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

------------------ Funzioni di Modulo
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 Finito
local ServerStorage = game:GetService("ServerStorage")
-- Richiedi lo script di modulo qui sotto ⯆
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
      -- Controlla se il giocatore può aprire uno scrigno, poi fallo ottenere tesori
      -- =============================================
      local canOpen = treasureManager.canOpenChest(whichCharacter)
      if canOpen == true then
         treasureManager.openChest(chestPart, whichCharacter)
      end
      -- =============================================
   end
end

-- Collega ogni parte dello scrigno alla funzione di tocco in modo che funzioni su tutte le parti
for chestIndex = 1, #chestsArray do
   local chestPart = chestsArray[chestIndex]:WaitForChild("Collider")
   chestPart.Touched:Connect(function(otherPart)
   partTouched(otherPart, chestPart)
   end)
end

Script keyScript Finito
local ServerStorage = game:GetService("ServerStorage")
-- Richiedi lo script di modulo qui sotto ⯆
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
      -- Dai al giocatore una chiave e distruggi la parte chiave
      -- =============================================
      treasureManager.getKey(keyPart, whichCharacter)
      -- =============================================
   end
end

-- Collega ogni parte chiave alla funzione di tocco in modo che funzioni su tutte le parti
for keyIndex = 1, #keysArray do
   local keyPart = keysArray[keyIndex]
   keyPart.Touched:Connect(function(otherPart)
      partTouched(otherPart, keyPart)
   end)
end

Riepilogo

Un'applicazione comune dell'uso degli script di modulo nelle esperienze di Roblox è gestire compiti comuni usati dai giocatori, come concedere loro punti. Per questo esempio, è stato creato uno script di modulo chiamato TreasureManager per gestire la concessione di chiavi e tesori ai giocatori ogni volta che interagiscono con oggetti di gioco.