Crea con script di modulo | Documentazione

Per applicare la tua conoscenza degli script di modulo, crea uno script di modulo che consenta ai giocatori di raccogliere chiavi e usarle per aprire forzieri.

Impostazione del progetto

Questo progetto include una mappa di avvio con leaderboard e oggetti di raccolta scriptati per le chiavi e i forzieri.

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 dai forzieri, crea uno script di modulo chiamato TreasureManager. Utilizzare uno script di modulo collegherà le raccolte e le leaderboard insieme.

In ServerStorage, crea un nuovo ModuleScript e rinominalo in TreasureManager.
In TreasureManager, rinomina la tabella del modulo predefinita sostituendo module con TreasureManager in entrambi i posti.
local TreasureManager = {} return TreasureManager

Usa funzioni negli script di modulo

Per testare come funzionano le funzioni negli script di modulo, crea una nuova funzione chiamata getKey(). Quando la funzione getKey() viene chiamata da un altro script, riceverà una parte della 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 tenerli 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 della 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 predefinito e la chiamerai.

Apri lo script della 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()
Prevenire errori utilizzando WaitForChild() invece dell'operatore punto per far sì che lo script attenda fino a quando TreasureManager non è stato caricato prima di continuare. Per gli script in ServerScriptService o ServerStorage, è sicuro utilizzare 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 della chiave
		-- =============================================
		treasureManager.getKey(keyPart, whichCharacter)
		-- =============================================
	end
end

Esegui il progetto e controlla 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, ci sarà 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 la richiesta, non può utilizzare funzioni e variabili da quello script di modulo.

Problema: Lo script non viene eseguito o non può raccogliere chiavi.

Nello script di modulo, assicurati che tutto il codice sia tra local TreasureManager = {} e return TreasureManager. Il return 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, utilizza una funzione locale nello script di modulo. Una funzione locale è utilizzata perché cambiare i valori delle chiavi o dei tesori 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 del giocatore.
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 rispetto a quello qui sotto 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 sarà utilizzato quando i giocatori toccano un forziere per controllare se hanno almeno una chiave prima di aprirlo e dare loro oro.

Controlla se i forzieri possono essere aperti

Prima nello script TreasureManager in ServerStorage, imposta variabili per quante chiavi costano per aprire un forziere e quanto oro contiene ogni forziere.

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 un forziere, 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 tesori ai giocatori

Affinché il giocatore possa aprire un forziere, 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 del forziere da distruggere.
- whichCharacter - il giocatore a cui dare il tesoro.
function TreasureManager.openChest(chestPart, whichCharacter) end

Per sottrarre le chiavi di un giocatore e premiarlo con il tesoro, copia e incolla il codice qui sotto in openChest(). Questo codice utilizza le variabili create in precedenza, come chestReward, l'importo di tesoro dato per ogni forziere.

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

Ora che le due funzioni di modulo, canOpenChest() e openChest(), sono state create, possono essere chiamate dalle parti del forziere ogni volta che un giocatore le tocca utilizzando la funzione predefinita 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 un forziere, quindi lascia che ottenga tesoro
		-- =============================================
		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.
Quindi, passa due parametri: chestPart, il forziere 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 un forziere, quindi lascia che ottenga tesoro
		-- =============================================
		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 un forziere lo distruggerà e assegnerà tesoro.
- Se hai 0 chiavi, non puoi aprire un forziere.

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 un forziere, quindi lascia che ottenga tesoro
      -- =============================================
      local canOpen = treasureManager.canOpenChest(whichCharacter)
      if canOpen == true then
         treasureManager.openChest(chestPart, whichCharacter)
      end
      -- =============================================
   end
end

-- Collega ogni parte del forziere 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 della chiave
      -- =============================================
      treasureManager.getKey(keyPart, whichCharacter)
      -- =============================================
   end
end

-- Collega ogni parte della 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 nei giochi Roblox è gestire compiti comuni utilizzati dai giocatori, come concedere loro punti. Per questo esempio, è stato creato uno script di modulo chiamato TreasureManager per gestire l'assegnazione di chiavi e tesori ai giocatori ogni volta che interagiscono con oggetti di gioco.