Erstellen mit Modulscripten | Dokumentation

Um Ihr Wissen über Modulscripte anzuwenden, erstellen Sie ein Modulskript, das es Spielern ermöglicht, Schlüssel aufzuheben und diese zu verwenden, um Schatzkisten zu öffnen.

Projekt einrichten

Dieses Projekt enthält eine Starter-Karte mit einem Leaderboard und geskripteten Pickup-Objekten für die Schlüssel und Schatzkisten.

Laden Sie das Startprojekt

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

Damit Spieler Schätze aus Kisten erhalten können, erstellen Sie ein Modulskript mit dem Namen TreasureManager. Die Verwendung eines Modulscripts verbindet die Pickup-Objekte und die Leaderboards miteinander.

Erstellen Sie in ServerStorage ein neues ModuleScript und benennen Sie es in TreasureManager um.

Benennen Sie in TreasureManager die Standard-Modultabelle um, indem Sie module an beiden Stellen durch TreasureManager ersetzen.


local TreasureManager = {}

return TreasureManager

Verwenden Sie Funktionen in Modulscripten

Um zu testen, wie Funktionen in Modulscripten funktionieren, erstellen Sie eine neue Funktion namens getKey(). Wenn die Funktion getKey() aus einem anderen Skript aufgerufen wird, erhält sie einen Schlüssel-Teil, um ihn zu zerstören und 1 zur Anzahl der Schlüssel im Inventar des Spielers hinzuzufügen.

Erstellen Sie eine Modulfunktion für Schlüssel

Dieses Modulscript verwendet eine Kombination aus Modul- und lokalen Funktionen. Schreiben Sie zwei Kommentare, um sie voneinander zu trennen.


local TreasureManager = {}

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

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

return TreasureManager

Fügen Sie unter dem Kommentar Modul Funktionen eine neue Modul-Funktion zu TreasureManager mit dem Namen getKey() hinzu.

Verwenden Sie zwei Parameter:

keyPart - der Teil, der zerstört werden soll.
whichCharacter - der Spieler, der den Schlüsselteil berührt hat.


local TreasureManager = {}

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

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

end

return TreasureManager

Zerstören Sie in getKey() keyPart.


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

Verwenden Sie die Modul-Funktion

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

Öffnen Sie das Schlüssel-Skript in Workspace ⟩ Keys ⟩ KeyScript.

Speichern Sie im keyScript das Modulskript in einer Variablen namens treasureManager und setzen Sie es gleich: require(ServerStorage:WaitForChild("TreasureManager"))


local ServerStorage = game:GetService("ServerStorage")
-- Das Modulscript hier unten anfordern ⯆
local treasureManager = require(ServerStorage:WaitForChild("TreasureManager"))

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

Verhindern Sie Fehler, indem Sie WaitForChild() anstelle des Punktoperators verwenden, um das Skript warten zu lassen, bis TreasureManager geladen wurde, bevor es weitergeht. Für Skripte in ServerScriptService oder ServerStorage ist es sicher, stattdessen den Punktoperator zu verwenden, wie in ServerStorage.TreasureManager.

Es gibt bereits eine Funktion namens partTouched(), um zu überprüfen, ob ein Spieler den Teil berührt. Innerhalb von partTouched():

Rufen Sie die Funktion getKey() des Moduls auf, um den Schlüssel zu zerstören.
Übergeben Sie keyPart und whichCharacter.


local ServerStorage = game:GetService("ServerStorage")
-- Das Modulscript hier unten anfordern ⯆
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üsselteil
		-- =============================================
		treasureManager.getKey(keyPart, whichCharacter)
		-- =============================================
	end
end

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

Fehlersuche

Problem: Erhalten Sie eine Fehlermeldung, die Folgendes enthält: "Infinite yield possible".

Überprüfen Sie die Schreibweise Ihres Modulscripts in einem Skript. Wenn ein Modulscript, wie TreasureManager, anders geschrieben wird, gibt es einen Fehler.

Problem: Erhalten Sie eine Fehlermeldung, die Folgendes enthält: "attempt to index global".

Überprüfen Sie die Zeile, die das Require für das Modulscript im keyScript enthält. Wenn das Modul kein Require enthält, kann es keine Funktionen und Variablen aus diesem Modulscript verwenden.

Problem: Das Skript wird nicht ausgeführt oder kann keine Schlüssel aufheben.

Stellen Sie im Modulscript sicher, dass der gesamte Code zwischen local TreasureManager = {} und return TreasureManager steht. Das Return muss die letzte Zeile im Modulscript sein.
Überprüfen Sie, dass am Ende der Zeile mit dem Require zwei Klammern stehen, wie in WaitForChild("TreasureManager")).

Erstellen Sie eine lokale Funktion

Im Moment verfolgt ein Leaderboard die Schlüssel und Schätze eines Spielers. Um die Leaderboard-Zahlen zu ändern, verwenden Sie eine lokale Funktion im Modulscript. Eine lokale Funktion wird verwendet, da die Änderung der Schlüssel- oder Schatzwerte eines Spielers nur im TreasureManager-Skript erforderlich ist, nicht anderswo.

Öffnen Sie in ServerStorage das TreasureManager-Skript.

Erstellen Sie lokale Variablen, um Folgendes zu tun:

Holen Sie sich den Players-Service, damit das Skript mit den Leaderboard-Statistiken der Spieler arbeiten kann.
Speichern Sie die Anzahl der Schlüssel, die der Spieler erhält, nachdem er keyPart berührt hat.


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

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

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

return TreasureManager

Kopieren Sie diese beiden lokalen Funktionen in den Abschnitt Lokale Funktionen.

getPlayerKeys() gibt den Wert des Lockpicks-Leaderstats des Spielers zurück.
getPlayerTreasure() gibt den Wert des Treasure-Leaderstats des Spielers 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
------------------ Modul Funktionen

Um die Schlüssel des Spielers hinzuzufügen, erstellen Sie eine local-Variable in der Modul-Funktion getKey():

Rufen Sie getPlayerKeys(whichCharacter) auf.
Addieren Sie den Wert von keyDrop zu playerKeys.


------------------ 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, ob das Berühren eines Schlüssels ihn zerstört und 1 zu den Schlüsseln des Spielers im Leaderboard hinzufügt.

Wenn nötig, überprüfen Sie Ihr Skript mit dem untenstehenden, um Fehler zu beheben.

Aktuelles TreasureManager-Skript
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 aus Modulscripten abrufen

Das TreasureManager-Modulskript wird verwendet, wenn Spieler eine Schatzkiste berühren, um zu überprüfen, ob sie mindestens einen Schlüssel haben, bevor sie sie öffnen und Gold erhalten.

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

Zuerst im ServerStorage ⟩ TreasureManager-Skript richten Sie Variablen dafür ein, wie viele Schlüssel es kostet, eine Kiste zu öffnen, und wie viel Gold jede Kiste enthält.


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 überprüft, ob ein Spieler eine Kiste öffnen kann, fügen Sie im Abschnitt Modul Funktionen eine neue Funktion zur TreasureManager-Tabelle mit dem Namen canOpenChest() und dem Parameter whichCharacter 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

Kopieren Sie den folgenden Code in canOpenChest(), um true zurückzugeben, wenn der Spieler genug Schlüssel hat, und false, wenn nicht.


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

Geben Sie den Spielern Schätze

Damit der Spieler eine Kiste öffnen kann, erstellen Sie eine Funktion in TreasureManager, die ihm Schätze gewährt.

Fügen Sie eine neue Modul-Funktion zu TreasureManager mit dem Namen openChest() hinzu.

Übergeben Sie zwei Argumente:
- chestPart - den Kisten-Teil, der zerstört werden soll.
- whichCharacter - der Spieler, dem der Schatz gegeben wird.
```
function TreasureManager.openChest(chestPart, whichCharacter)

end
```

Um die Schlüssel eines Spielers abzuziehen und ihm Schätze zu gewähren, kopieren Sie den folgenden Code in openChest(). Dieser Code verwendet die zuvor erstellten Variablen, wie chestReward, die Menge an Schätzen, die pro Kiste gegeben wird.


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

Rufen Sie die Kistenfunktionen auf

Jetzt, da die beiden Modulfunktionen, canOpenChest() und openChest(), erstellt wurden, können sie von den Kisten-Teilen aufgerufen werden, wenn ein Spieler sie berührt, indem sie die vorgefertigte Funktion partTouched() verwenden.

Öffnen Sie in Workspace ⟩ Chests das ChestScript.

Erstellen Sie eine neue Variable mit dem Namen treasureManager und fordern Sie das TreasureManager-Modulskript in ServerStorage an.


local ServerStorage = game:GetService("ServerStorage")
-- Das Modulscript hier anfordern
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 gleich:

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 Kiste öffnen kann, und lassen Sie ihn dann Schätze erhalten
		-- =============================================
		local canOpen = treasureManager.canOpenChest(whichCharacter)
		-- =============================================
	end
end

Erstellen Sie dann eine if-Anweisung, um zu überprüfen, ob canOpen wahr ist.

Wenn ja, rufen Sie die Funktion openChest() von TreasureManager auf.
Übergeben Sie dann zwei Parameter: chestPart, die Kiste, die zerstört werden soll, und whichCharacter, den Spieler, dem der Schatz verliehen werden soll.


local function partTouched(otherPart, chestPart)
	local whichCharacter = otherPart.Parent
	local humanoid = whichCharacter:FindFirstChildWhichIsA("Humanoid")
	if humanoid then
		-- Überprüfen Sie, ob der Spieler eine Kiste öffnen kann, und lassen Sie ihn dann Schätze erhalten
		-- =============================================
		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, ob:
- Wenn Sie mindestens 1 Schlüssel haben, das Berühren einer Kiste sie zerstört und Schätze verleiht.
- Wenn Sie 0 Schlüssel haben, können Sie eine Schatzkiste nicht öffnen.

Fehlersuche

Stellen Sie im ChestScript sicher, dass Funktionen, die aus dem Modulscript aufgerufen werden, wie canOpenChest(), genau so geschrieben sind, wie sie im TreasureManager-Skript zu finden sind. Jede Abweichung verursacht einen Fehler.
Überprüfen Sie, dass kopierte und eingefügte Funktionen wie treasureManager.openChest() genau wie im Unterricht gezeigt sind. Jede Abweichung kann subtile Fehler im Skript verursachen.

Fertige Skripte

Fertiges TreasureManager-Skript
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.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

Fertiges ChestScript
local ServerStorage = game:GetService("ServerStorage")
-- Das Modulscript hier anfordern ⯆
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 Kiste öffnen kann, und lassen Sie ihn dann Schätze erhalten
      -- =============================================
      local canOpen = treasureManager.canOpenChest(whichCharacter)
      if canOpen == true then
         treasureManager.openChest(chestPart, whichCharacter)
      end
      -- =============================================
   end
end

-- Bindet jedes Kisten-Teil an die Berührfunktion, damit sie auf allen Teilen funktioniert
for chestIndex = 1, #chestsArray do
   local chestPart = chestsArray[chestIndex]:WaitForChild("Collider")
   chestPart.Touched:Connect(function(otherPart)
   partTouched(otherPart, chestPart)
   end)
end

Fertiges keyScript
local ServerStorage = game:GetService("ServerStorage")
-- Das Modulscript hier anfordern ⯆
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üsselteil
      -- =============================================
      treasureManager.getKey(keyPart, whichCharacter)
      -- =============================================
   end
end

-- Bindet jedes Schlüssel-Teil an die Berührfunktion, damit sie 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 Modulscripten in Roblox-Erlebnissen besteht darin, gängige Aufgaben zu verwalten, die von Spielern verwendet werden, wie das Gewähren von Punkten. In diesem Beispiel wurde ein Modulskript mit dem Namen TreasureManager erstellt, um Spielern Schlüssel und Schätze zu geben, wann immer sie mit Spielobjekten interagieren.