Mit Modul-Skripts erstellen | Dokumentation

Um dein Wissen über Modul-Skripte anzuwenden, erstelle ein Modul-Skript, das den Spielern die Schlüssel abholen und sie verwenden, um Schatztruhen zu öffnen.

Projekt-Einstellungen

Dieses Projekt enthält eine Starter-Karte mit Bestenlisten und Skript-Pickup-Objekten für Schlüssel und Schatztruhen.

Laden Sie das Starter-Projekt

Laden Sie das Starter-Projekt herunter.
Öffnen Sie in Roblox Studio die heruntergeladene Datei: Intro to Module Scripts - Starter Project.rbxl.

erstellen ein Modul-Skript

So können Spieler Schätze aus Truhen erhalten, ein Modul-Skript namens TreasureManager erstellen. Wenn Sie ein Modul-Skript verwenden, verbinden Sie die Pickups und Leaderboards miteinander.

In ServerStorage erstellen Sie ein neues ModuleScript und benennen Sie es TreasureManager um.

In TreasureManager , ändern Sie die Standard-Modul-Tabelle durch das Ersetzen von module durch TreasureManager in beiden Orten.


local TreasureManager = {}

return TreasureManager

Verwendung von Funktionen in Modul-Skripts

Um zu testen, wie Funktionen in Modul-Skripts arbeiten, erstellen Sie eine neue Funktion mit dem Namen getKey(). Wenn die Funktion getKey() aus einem anderen Skript, das. PL: die Skriptsaufgerufen wird, erhält sie einen Schlüsselteil, um die Zahl der Schlüssel im Inventar des Spieler:inzu zerstören und 1 hinzuzufügen.

Erstellen Sie eine Modul-Funktion für Schlüssel

Dieses Modul-Skript verwendet eine Kombination von Modul- und lokalen Funktionen, geben Sie einige Kommentare aus, um Ihnen zu helfen, sie separat zu halten.


local TreasureManager = {}

------------------ Lokale Funktionen

------------------ Modul-Funktionen

return TreasureManager

Unter dem Kommentar postenfügen Sie einer neuen Modul-Funktion zu TreasureManager mit dem Namen getKey() hinzu.

Verwende zwei Argumente:

keyPart - der Teil, den du zerstören willst.
whichCharacter - der Spieler, der die Tastenpartie berührt hat.


local TreasureManager = {}

------------------ Lokale Funktionen

------------------ Modul-Funktionen
function TreasureManager.getKey(keyPart, whichCharacter)

end

return TreasureManager

In getKey() , zerstöre keyPart .


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

Modul-Funktion verwenden

Jetzt kann die Modulfunktion getKey() in anderen Skripts verwendet werden. Um diese Funktion zu testen, öffnen Sie ein vordefiniertes Skript und rufen Sie es auf.

Öffnen Sie das Schlüsselskript in Workspace > Keys > KeyScript.

In keyScript speichern Sie das Modul-Skript in einer Variable namens treasureManager und setzen Sie es auf: require(ServerStorage:WaitForChild("TreasureManager"))


local ServerStorage = game:GetService("ServerStorage")
-- Benötigen Sie das Modul-Skript unten ⯆
local treasureManager = require(ServerStorage:WaitForChild("TreasureManager"))

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

Vermeiden Sie Fehler, indem Sie WaitForChild() anstelle des Dot-Betreibers verwenden, um das Skript zu warten, bis TreasureManager geladen ist, bevor es weitergeht. Für Skripte in ServerScriptService oder ServerStorage ist es sicher, den Dot-Betreiber anzustelle, wie in ServerStorage.TreasureManager.

Es gibt bereits eine Funktion namens partTouched() , um nach einem Spieler zu prüfen, der das Teil berührt. In partTouched() :

Rufe die getKey() Modul-Funktion auf, um den Schlüssel zu zerstören.
Pass in keyPart und whichCharacter .


local ServerStorage = game:GetService("ServerStorage")
-- Benötigen Sie das Modul-Skript unten ⯆
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
		-- Geben Sie dem Spieler einen Schlüssel und zerstören Sie den Schlüsselpart
		-- =============================================
		treasureManager.getKey(keyPart, whichCharacter)
		-- =============================================
	end
end

Führen Sie das Projekt aus und überprüfen Sie, dass das Berühren eines Schlüssels es zerstört.

Troubleshooting-Tipps

Problem:: Erhalte eine Fehler-Nachricht, einschließlich: "Infinite yield possible".

Überprüfen Sie die Rechtschreibung Ihres Modul-Skripts in einem Skript, das. PL: die Skripts. Wenn ein Skript, das. PL: die Skripts, wie TreasureManager , anders geschrieben ist, wird ein Fehler auftreten. Problem:: Erhalte eine Fehler-Nachricht, einschließlich: "attempt to index global" .
Überprüfen Sie die Zeile, die das Require für das Modul-Skript in keyScript enthält. Wenn das Modul keinen erfordernenthält, kann es keine Funktionen und Variablen aus diesem Skript, das. PL: die Skriptsverwenden. Problem:: Das Skript läuft nicht oder kann keine Schlüssel aufheben.
Im Skript, das. PL: die Skriptsstellen Sie sicher, dass der gesamte Code zwischen local TreasureManager = {} und return TreasureManager liegt. Die Rückgabe muss die letzte Zeile des Codes in einem Modul-Skript sein.
Stellen Sie sicher, dass es zwei Elternteile am Ende der Zeile mit erfordern, wie in WaitForChild("TreasureManager")) .

Erstellen Sie eine lokale Funktion

Derzeit wird in einem Bestenlisten-Cookie ein Spieler:insämtliche Schlüssel und Schätze verfolgt. Um die Bestenlisten-Nummern zu ändern, verwenden Sie eine lokale Funktion in der Skript, das. PL: die Skripts. Eine lokale Funktion wird verwendet, da das Ändern der Schlüssel eines Spieler:inoder Schatzwerte nur in der Skript, das. PL: die Skriptserforderlich ist, nicht an irgendeinem anderen Ort.

In ServerStorage öffnen Sie das Skript TreasureManager.

Erstellen Sie lokale Variablen, um gefolgte Profilezu tun:

Bereiten Sie den Players-Dienst vor, damit das Skript mit den Statistiken der Spieler:inarbeiten kann.
Lagere die Anzahl der Tasten, die der Spieler erhält, nach dem Berühren von keyPart.


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

------------------ Lokale Funktionen

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

return TreasureManager

Kopiere und füge diese beiden lokalen Funktionen in den Lokale Funktionen Abschnitt ein.

getPlayerKeys() gibt die Werte des Spieler:inLockpicks Führers zurück.
getPlayerTreasure() gibt die Werte des Spieler:inTreasure-Leaderstat zurück.


------------------ Lokale Funktionen
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

Um den Schlüssel des Spielers zu den Schlüssel des Spielers hinzuzufügen, in der getKey() Modul-Funktion:

Erstellen Sie eine local Variable, um getPlayerKeys(whichCharacter) aufzurufen.
Fügen Sie den Wert von keyDrop zu playerKeys hinzu.


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

Führen Sie das Projekt aus. Überprüfen Sie, dass das Berühren eines Schlüssels es zerstört und 1 zu den Schlüssen des Spieler:inin der Bestenlistehinzufügt.

Wenn nötig, überprüfen Sie Ihr Skript gegen das untenstehende für mögliche Fehler.

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

------------------ Lokale Funktionen
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

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

return TreasureManager

Informationen von Modul-Skripts erhalten

Das TreasureManager Modul-Skript wird verwendet, wenn Spieler eine Schatztruhe berühren, um zu überprüfen, ob sie mindestens einen Schlüssel haben, bevor sie sie öffnen und ihnen Gold geben.

Überprüfen, ob Truhen geöffnet werden können

Erst in ServerStorage > TreasureManager Skript, das. PL: die Skripts, setzen Sie Variablen für die Anzahl der Schlüssel, die zum Öffnen einer Truhe kosten, und wie viel Gold in jeder Truhe enthalten ist.


local TreasureManager = {}

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

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

Um eine Funktion zu erstellen, die prüft, ob ein Spieler eine Truhe öffnen kann, in der Modul-Funktionen -Sektion, füge eine neue Funktion zu der TreasureManager -Tabelle namens canOpenChest() mit dem Parameter 1> whichCharacter1> hinzu.


------------------ Modul-Funktionen
function TreasureManager.canOpenChest(whichCharacter)

end

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

Kopiere und füge den Code unten in canOpenChest() ein, um 5 true zurückzugeben, wenn der Spieler genug Schlüssel hat, und false wenn sie nicht haben.


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

Spielern Schätze geben

So kann der Spieler eine Truhe öffnen, erstellen eine Funktion in TreasureManager, die ihnen Schatz verleiht.

Füge eine neue Modulfunktion zu TreasureManager mit dem Namen openChest() hinzu.

Passen Sie in zwei Argumenten:
- chestPart - die Brustpartie, die zerstört werden muss.
- whichCharacter - der Spieler, der Schätze geben wird.
```
function TreasureManager.openChest(chestPart, whichCharacter)

end
```

Um die Schlüssel eines Spieler:inabzuziehen und ihm Schätze zu gewähren, kopiere und füge den Code unten in openChest() ein. Dieser Code verwendet die Variablen, die vorher erstellt wurden, wie chestReward , die Menge des Schatzes pro Truhe.


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

Rufe die Brustfunktionen auf

Nun, da die beiden Modul-Funktionen, canOpenChest() und openChest(), erstellt wurden, können sie von den Brust-Teilen ausgerufen werden, wann immer ein Spieler sie mit der vordefinierten Funktion partTouched() berührt.

In Arbeitsbereich > Truhen öffnen ChestScript.

Erstellen Sie eine neue Variable namens treasureManager und benötigen Sie das TreasureManager-Modul in ServerStorage .


local ServerStorage = game:GetService("ServerStorage")
-- Benötigen Sie das Modul-Skript unten
local treasureManager = require(ServerStorage:WaitForChild("TreasureManager"))

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

In partTouched() , unter der if humanoid Anweisung, erstellen Sie eine neue Variable namens canOpen und setzen Sie sie auf:

treasureManager.canOpenChest(whichCharacter)


local function partTouched(otherPart, chestPart)
	local whichCharacter = otherPart.Parent
	local humanoid = whichCharacter:FindFirstChildWhichIsA("Humanoid")
	if humanoid then
		-- Überprüfen Sie, ob der Spieler eine Truhe öffnen kann, dann lassen Sie ihn den Schatz bekommen
		-- =============================================
		local canOpen = treasureManager.canOpenChest(whichCharacter)
		-- =============================================
	end
end

Nächste, erstellen Sie ein if- Statement, um zu überprüfen, ob canOpen wahr ist.

Wenn so, rufen Sie die Funktion openChest() des TreasureManager auf.
Dann geben Sie zwei Argumente ein: chestPart , die Truhe zu zerstören, und whichCharacter , der Spieler den Schatz zu verleihen.


local function partTouched(otherPart, chestPart)
	local whichCharacter = otherPart.Parent
	local humanoid = whichCharacter:FindFirstChildWhichIsA("Humanoid")
	if humanoid then
		-- Überprüfen Sie, ob der Spieler eine Truhe öffnen kann, dann lassen Sie ihn den Schatz bekommen
		-- =============================================
		local canOpen = treasureManager.canOpenChest(whichCharacter)
		if canOpen == true then
			treasureManager.openChest(chestPart, whichCharacter)
		end
		-- =============================================
	end
end

Führen Sie das Projekt aus. Überprüfen Sie, dass:
- Wenn du mindestens einen Schlüssel hast, zerstört das Aus触ieren einer Truhe den Inhalt und verleiht Schätze.
- Wenn du keine 0 Schlüssel hast, kannst du keine Schatztruhe öffnen.

Troubleshooting-Tipps

In ChestScript stellen Sie sicher, dass Funktionen, die vom Modul-Skript wie canOpenChest() aufgerufen werden, genau so geschrieben sind, wie sie im TreasureManagerSkript, das. PL: die Skriptsgefunden werden. Jeder Unterschied verursacht einen Fehler.
Überprüfen Sie, dass kopierte und eingefügte Funktionen, wie treasureManager.openChest() , genau wie in der Lektion gezeigt, sind. Alle Unterschiede können subtile Fehler im Skript, das. PL: die Skriptsverursachen.

Abgeschlossene Skripte

SchatzManager-Skript fertig
local TreasureManager = {}
local Players = game:GetService("Players")
local keyDrop = 1
local chestPickCost = 1
local chestReward = 100

------------------ Lokale Funktionen
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

------------------ Modul-Funktionen
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

Abgeschlossenes ChestScript
local ServerStorage = game:GetService("ServerStorage")
-- Benötigen Sie das Modul-Skript unten ⯆
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
      -- Überprüfen Sie, ob der Spieler eine Truhe öffnen kann, dann lassen Sie ihn den Schatz bekommen
      -- =============================================
      local canOpen = treasureManager.canOpenChest(whichCharacter)
      if canOpen == true then
         treasureManager.openChest(chestPart, whichCharacter)
      end
      -- =============================================
   end
end

-- Bindet jeden Brust Teil an die Touch Funktion, damit er auf allen Teilen funktioniert
for chestIndex = 1, #chestsArray do
   local chestPart = chestsArray[chestIndex]
   chestPart.Touched:Connect(function(otherPart)
   partTouched(otherPart, chestPart)
   end)
end

Beendetes keyScript
local ServerStorage = game:GetService("ServerStorage")
-- Benötigen Sie das Modul-Skript unten ⯆
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
      -- Geben Sie dem Spieler einen Schlüssel und zerstören Sie den Schlüsselpart
      -- =============================================
      treasureManager.getKey(keyPart, whichCharacter)
      -- =============================================
   end
end

-- Bindet jeden Tastenpart zu der Touch-Funktion, damit er auf allen Teilen funktioniert
for keyIndex = 1, #keysArray do
   local keyPart = keysArray[keyIndex]
   keyPart.Touched:Connect(function(otherPart)
      partTouched(otherPart, keyPart)
   end)
end

Zusammenfassung

Eine häufige Anwendung von Modul-Skripts in Roblox-Spielen ist die Verarbeitung häufiger Aufgaben, die von Spielern verwendet werden, z. B. die Gewährung von Punkten. Für dieses Beispiel wurde ein Modul-Skript namens TreasureManager erstellt, um den Spielern die Schlüssel und den Schatz zu geben, wenn sie mit In-Game-Objekten interagieren.