Creazione con Modulistica | Documentazione

Per applicare la tua conoscenza degli script del modulo, crea uno script del modulo che consente ai giocatori di prendere le chiavi e di usarle per aprire i forzieri del tesoro.

Configurazione del progetto

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

Carica il progetto iniziale

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

Crea uno script del modulo

In modo che i giocatori possano ottenere tesori dai forzieri, crea uno script del modulo chiamato TreasureManager . Utilizzando uno script del modulo connetterai i pickup e le classifiche insieme.

In ServerStorage , crea un nuovo ModuleScript e rinominalo in TreasureManager .

In TreasureManager , rinomina la tabella del modulo predefinito per sostituire module con TreasureManager in entrambi i luoghi.


local TreasureManager = {}

return TreasureManager

Uso delle funzioni nei script del modulo

Per testare il modo in cui le funzioni funzionano negli script del modulo, crea una nuova funzione chiamata getKey() . Quando la funzione getKey() viene chiamata da un altro script, riceverà una parte chiave per distruggere e aggiungere 1 alla quantità di chiavi nell'Inventario, reportoriodel Giocatore.

Crea una funzione del modulo per le chiavi

Questo script del modulo utilizza una combinazione di funzioni del modulo e locali, due commenti per aiutarti a tenerli separati.


local TreasureManager = {}

--Funzioni locali

------------------ Funzioni Modulo

return TreasureManager

Sotto il Commentare Funzioni del modulo , aggiungi una nuova funzione del 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 Modulo
function TreasureManager.getKey(keyPart, whichCharacter)

end

return TreasureManager

In getKey() , distruggi keyPart .


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

Usa la funzione del modulo

Ora, la funzione del modulo getKey() può essere utilizzata in altri script. Per testare questa funzione, apri uno script predefinito e chiamalo.

Apri lo script di chiave in Workspace > Keys > KeyScript.

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


local ServerStorage = game:GetService("ServerStorage")
-- Richiedi lo script del modulo sottostante ⯆
local treasureManager = require(ServerStorage:WaitForChild("TreasureManager"))

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

Prevenire gli errori utilizzando WaitForChild() invece che l'operatore punto per fare in modo che lo script aspetti fino a quando TreasureManager non ha caricato prima di passare avanti. Per gli script in ServerScriptService o ServerStorage, è sicuro utilizzare 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 del modulo getKey() per distruggere la chiave.
Pass in keyPart e whichCharacter .


local ServerStorage = game:GetService("ServerStorage")
-- Richiedi lo script del modulo sottostante ⯆
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 toccando una chiave lo distrugge.

Risolvere i problemi

Problema: Ottieni un messaggio di errore tra cui: "Infinite yield possible" .

Controlla la punteggiatura del tuo script del modulo in uno script. Se uno script del modulo, come TreasureManager , è scritto in modo diverso, ci sarà un errore. Problema: Ottieni un messaggio di errore tra cui: "attempt to index global" .
Controlla la linea che include il requisito per lo script del modulo in keyScript . Se il modulo non include il Richiesto/a, non può utilizzare le funzioni e le variabili di quel script del modulo. Problema: Lo script non viene eseguito o non può prendere le chiavi.
Nello script del modulo, assicurati che tutto il codice sia tra local TreasureManager = {} e return TreasureManager . Il ritorno deve essere l'ultima linea di codice in uno script del modulo.
Assicurati che ci siano due parentesi alla fine della linea con Richiesto/a, come in WaitForChild("TreasureManager")) .

Crea una funzione locale

In questo momento, una classifica tiene traccia delle chiavi e del tesoro di un Giocatore. Per cambiare i numeri della classifica, usa una funzione locale nel script del modulo. Una funzione locale è utilizzata poiché la modifica di una chiave o dei valori del tesoro di un Giocatoresarà necessaria solo nel script del TreasureManager, non in nessun altro luogo.

In ServerStorage , apri lo script TreasureManager.

Crea le variabili locali per eseguire le Seguendooperazioni:

Ottieni il servizio Players in modo che lo script possa lavorare con le statistiche della classifica 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 Modulo
function TreasureManager.getKey(keyPart, whichCharacter)
	keyPart:Destroy()
end

return TreasureManager

Copia e pasta queste due funzioni locali nella sezione Funzioni locali .

getPlayerKeys() restituisce il valore della leaderboard del Giocatore.
getPlayerTreasure() restituisce il valore della leaderstat del GiocatoreTreasure .


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

Per aggiungere alle chiavi del Giocatore, nella funzione del modulo getKey() :

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


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

Esegui il progetto. Controlla che toccando una chiave la distrugge e aggiunga 1 alle chiavi del Giocatorenella Classifica.

Se necessario, controlla il tuo script contro quello sottostante per qualsiasi problema di soluzione dei problemi.

Current TreasureManager Script
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 Modulo
function TreasureManager.getKey(keyPart, whichCharacter)
   local playerKeys = getPlayerKeys(whichCharacter)
   playerKeys.Value = playerKeys.Value + keyDrop
   keyPart:Destroy()
end

return TreasureManager

Ottenere informazioni dai script del modulo

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

Controlla se i forzieri possono essere aperti

Primo in ServerStorage > TreasureManager script, imposta le variabili per il numero di chiavi che costa 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 Modulo , aggiungi una nuova funzione alla tabella TreasureManager chiamata canOpenChest() con il parametro 2> whichCharacter2> .


------------------ Funzioni 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 pasta il codice seguente in canOpenChest() per restituire true se il giocatore ha abbastanza chiavi, e false se non lo hanno.


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

Dai ai giocatori il tesoro

In modo che il giocatore possa aprire una cassa, creare una funzione in TreasureManager che gli assegna il tesoro.

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

Passa in due argomenti:

chestPart - la parte della cassa per distruggere.
whichCharacter - il giocatore che dà il tesoro.


function TreasureManager.openChest(chestPart, whichCharacter)

end

Per sottrarre le chiavi di un Giocatoree assegnargli un tesoro, copia e pasta il codice seguente in openChest() . Questo codice utilizza le variabili create in precedenza, come chestReward , la quantità di tesoro dato per ciascun 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:Destroy()
end

Chiama le funzioni della cassa

Ora che le due funzioni del modulo, canOpenChest() e openChest(), sono state create, possono essere chiamate dalle parti del petto quando un giocatore le tocca usando la funzione premade partTouched() .

In Workspace > Chests open ChestScript .

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


local ServerStorage = game:GetService("ServerStorage")
-- Richiedi lo script del modulo sottostante
local treasureManager = require(ServerStorage:WaitForChild("TreasureManager"))

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

In partTouched() , sotto la dichiarazione if humanoid, crea una nuova variabile chiamata canOpen e imposta 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 castello, quindi lascia che prendano tesori
		-- =====================================
		local canOpen = treasureManager.canOpenChest(whichCharacter)
		-- =====================================
	end
end

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

Se è così, chiama la funzione openChest() del TreasureManager.
Quindi, passa in due parametri: chestPart , la cassa da distruggere, e whichCharacter , il giocatore per ricompensare 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 castello, quindi lascia che prendano 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 ti darà tesori.
- Se hai 0 chiavi, non puoi aprire un tesoro.

Risolvere i problemi

In ChestScript , assicurati che le funzioni chiamate dallo script del modulo come canOpenChest() siano sparse esattamente come sono trovate nello script del Gestore risorse. Qualsiasi differenza causerà un errore.
Assicurati che le funzioni pastate come treasureManager.openChest() siano esattamente come mostrato nella lezione. Tutte le differenze possono causare errori sottili negli script.

Script finiti

Script del Tesoro terminato
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 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: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 del Comune terminato
local ServerStorage = game:GetService("ServerStorage")
-- Richiedi lo script del modulo sottostante ⯆
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 castello, quindi lascia che prendano tesori
      -- =====================================
      local canOpen = treasureManager.canOpenChest(whichCharacter)
      if canOpen == true then
         treasureManager.openChest(chestPart, whichCharacter)
      end
      -- =====================================
   end
end

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

Script della chiave terminato
local ServerStorage = game:GetService("ServerStorage")
-- Richiedi lo script del modulo sottostante ⯆
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

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

Panoramica

Un uso comune di script del modulo in Roblox Games è gestire le attività comuni utilizzate dai giocatori, come concedere loro punti. Per questo esempio, uno script del modulo chiamato TreasureManager è stato creato per gestire la consegna delle chiavi e del tesoro ogni volta che interagiscono con gli oggetti in gioco.