Mit Modulscripten erstellen | Dokumentation

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

Projektsetup

Dieses Projekt enthält eine Starterkarte mit einem Leaderboard und skriptierten Aufhebobjekten für die Schlüssel und Schatztruhen.

Laden Sie das Starterprojekt

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

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

Erstellen Sie in ServerStorage ein neues ModuleScript und benennen Sie es in TreasureManager um.
Benennen Sie in TreasureManager die Standardmodultabelle 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 mit dem Namen getKey(). Wenn die Funktion getKey() von einem anderen Skript aufgerufen wird, erhält sie ein Schlüsselteil, um es 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 Modulskript verwendet eine Kombination aus Modul- und lokalen Funktionen. Geben Sie zwei Kommentare ein, um sie getrennt zu halten.
local TreasureManager = {} ------------------ Lokale Funktionen ------------------ Modul Funktionen return TreasureManager
Fügen Sie unter dem Kommentar Modul Funktionen eine neue Modulfunktion zu TreasureManager mit dem Namen getKey() hinzu.

Verwenden Sie zwei Parameter:
- keyPart - das Teil, das zerstört werden soll.
- whichCharacter - der Spieler, der das Schlüsselteil berührt hat.
local TreasureManager = {} ------------------ Lokale Funktionen ------------------ Modul Funktionen function TreasureManager.getKey(keyPart, whichCharacter) end return TreasureManager

Zerstören Sie in getKey() das keyPart.

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

Verwenden Sie die Modulfunktion

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

Öffnen Sie das Schlüsselskript in Workspace ⟩ Keys ⟩ KeyScript.
Speichern Sie im keyScript das Modulskript in einer Variablen mit dem Namen treasureManager und setzen Sie es gleich: require(ServerStorage:WaitForChild("TreasureManager"))
local ServerStorage = game:GetService("ServerStorage") -- Erfordern Sie das Modulskript unten ⯆ 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 ist, bevor es fortfährt. Für Skripte in ServerScriptService oder ServerStorage ist es sicher, stattdessen den Punktoperator zu verwenden, wie in ServerStorage.TreasureManager.

Es gibt bereits eine Funktion mit dem Namen partTouched(), um zu überprüfen, ob ein Spieler das Teil berührt. Fügen Sie innerhalb von partTouched() Folgendes hinzu:

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

local ServerStorage = game:GetService("ServerStorage")
-- Erfordern Sie das Modulskript 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 das 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 es 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 Modulskript, wie TreasureManager, anders geschrieben ist, tritt ein Fehler auf.

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

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

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

Stellen Sie im Modulskript sicher, dass sich der gesamte Code zwischen local TreasureManager = {} und return TreasureManager befindet. Die Rückgabe muss die letzte Zeile im Modulskript sein.
Überprüfen Sie, dass am Ende der Zeile mit 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 Modulskript. 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 Skript TreasureManager.

Erstellen Sie lokale Variablen, um Folgendes zu tun:

Holen Sie sich den Players-Dienst, damit das Skript mit den Leaderboard-Statistiken der Spieler arbeiten kann.
Speichern Sie die Anzahl der Schlüssel, die der Spieler nach dem Berühren von keyPart erhält.

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 und fügen Sie sie in den Abschnitt Lokale Funktionen ein.

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 zu erhöhen, fügen Sie in der Modulfunktion getKey() Folgendes hinzu:
- 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, ob das Berühren eines Schlüssels es 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 Skript auf mögliche Probleme.

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

Zuerst im ServerStorage ⟩ TreasureManager-Skript richten Sie Variablen ein, wie viele Schlüssel es kostet, eine Truhe zu öffnen, und wie viel Gold jede Truhe 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 Truhe ö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 genügend 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

Spielern Schätze geben

Damit der Spieler eine Truhe öffnen kann, erstellen Sie eine Funktion in TreasureManager, die ihm Schätze verleiht.

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

Übergeben Sie zwei Argumente:
- chestPart - das Truhenteil, das zerstört werden soll.
- whichCharacter - der Spieler, dem der Schatz gegeben werden soll.
function TreasureManager.openChest(chestPart, whichCharacter) end

Um die Schlüssel eines Spielers abzuziehen und ihm Schätze zu verleihen, kopieren Sie den folgenden Code in openChest(). Dieser Code verwendet die zuvor erstellten Variablen, wie chestReward, die Menge an Schatz, die pro Truhe 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 Truhenfunktionen auf

Jetzt, da die beiden Modulfunktionen canOpenChest() und openChest() erstellt wurden, können sie von den Truhenteilen aufgerufen werden, wann immer ein Spieler sie berührt, indem die vorgefertigte Funktion partTouched() verwendet wird.

Ö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")
-- Erfordern Sie das Modulskript 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 mit dem Namen 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 Truhe öffnen kann, und lassen Sie ihn dann Schätze erhalten
		-- =============================================
		local canOpen = treasureManager.canOpenChest(whichCharacter)
		-- =============================================
	end
end

Erstellen Sie als Nächstes 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 Truhe, 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 Truhe ö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 Truhe sie zerstört und Schätze verleiht.
- Wenn Sie 0 Schlüssel haben, können Sie eine Schatztruhe nicht öffnen.

Fehlersuche

Stellen Sie in ChestScript sicher, dass Funktionen, die aus dem Modulskript wie canOpenChest() aufgerufen werden, genau so geschrieben sind, wie sie im TreasureManager-Skript gefunden werden. Jede Abweichung führt zu einem Fehler.
Überprüfen Sie, dass kopierte und eingefügte Funktionen, wie treasureManager.openChest(), genau so sind, wie sie in der Lektion gezeigt werden. 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")
-- Erfordern Sie das Modulskript 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, 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 Truhenteil an die Berührfunktion, damit es 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")
-- Erfordern Sie das Modulskript 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 das Schlüsselteil
      -- =============================================
      treasureManager.getKey(keyPart, whichCharacter)
      -- =============================================
   end
end

-- Bindet jedes Schlüsselteil an die Berührfunktion, damit es 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-Spielen besteht darin, häufige Aufgaben zu verwalten, die von Spielern verwendet werden, wie z. B. 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 Objekten im Spiel interagieren.