Tworzenie z użyciem skryptów modułowych | Dokumentacja

Aby zastosować swoją wiedzę na temat skryptów modułowych, stwórz skrypt modułowy, który pozwala graczom zbierać klucze i używać ich do otwierania skrzyń skarbów.

Ustawienie projektu

Ten projekt zawiera mapę startową z tablicą wyników i skryptowanymi obiektami do zbierania kluczy i skrzyń skarbów.

Załaduj projekt startowy

Pobierz projekt startowy.
W Roblox Studio otwórz pobrany plik: Intro to Module Scripts - Starter Project.rbxl.

Stwórz skrypt modułowy

Aby gracze mogli zdobywać skarby ze skrzyń, stwórz skrypt modułowy o nazwie TreasureManager. Użycie skryptu modułowego połączy zbieranie i tablice wyników.

W ServerStorage stwórz nowy ModuleScript i zmień jego nazwę na TreasureManager.
W TreasureManager zmień nazwę domyślnej tabeli modułowej, zastępując module na TreasureManager w obu miejscach.
local TreasureManager = {} return TreasureManager

Użyj funkcji w skryptach modułowych

Aby przetestować, jak działają funkcje w skryptach modułowych, stwórz nową funkcję o nazwie getKey(). Gdy funkcja getKey() zostanie wywołana z innego skryptu, otrzyma część klucza do zniszczenia i doda 1 do liczby kluczy w ekwipunku gracza.

Stwórz funkcję modułową dla kluczy

Ten skrypt modułowy będzie używał kombinacji funkcji modułowych i lokalnych, wpisz dwa komentarze, aby pomóc w ich rozdzieleniu.

local TreasureManager = {}

------------------ Funkcje lokalne

------------------ Funkcje modułowe

return TreasureManager

Pod komentarzem Funkcje modułowe dodaj nową funkcję modułową do TreasureManager o nazwie getKey().

Użyj dwóch parametrów:
- keyPart - część do zniszczenia.
- whichCharacter - gracz, który dotknął części klucza.
local TreasureManager = {} ------------------ Funkcje lokalne ------------------ Funkcje modułowe function TreasureManager.getKey(keyPart, whichCharacter) end return TreasureManager

W getKey() zniszcz keyPart.

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

Użyj funkcji modułowej

Teraz funkcja modułowa getKey() może być używana w innych skryptach. Aby przetestować tę funkcję, otwórz gotowy skrypt i wywołaj ją.

Otwórz skrypt klucza w Workspace ⟩ Keys ⟩ KeyScript.
W keyScript przechowaj skrypt modułowy w zmiennej o nazwie treasureManager i ustaw ją na: require(ServerStorage:WaitForChild("TreasureManager"))
local ServerStorage = game:GetService("ServerStorage") -- Wymagaj skryptu modułowego poniżej ⯆ local treasureManager = require(ServerStorage:WaitForChild("TreasureManager")) local keys = script.Parent local keysFolder = keys.Parts local keysArray = keysFolder:GetChildren()
Zapobiegaj błędom, używając WaitForChild() zamiast operatora kropki, aby skrypt czekał, aż TreasureManager zostanie załadowany, zanim przejdzie dalej. Dla skryptów w ServerScriptService lub ServerStorage, bezpiecznie jest używać operatora kropki, jak w ServerStorage.TreasureManager.

Istnieje już funkcja o nazwie partTouched(), aby sprawdzić, czy gracz dotknął części. Wewnątrz partTouched():

Wywołaj funkcję modułową getKey(), aby zniszczyć klucz.
Przekaż keyPart i whichCharacter.

local ServerStorage = game:GetService("ServerStorage")
-- Wymagaj skryptu modułowego poniżej ⯆
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
		-- Daj graczowi klucz i zniszcz część klucza
		-- =============================================
		treasureManager.getKey(keyPart, whichCharacter)
		-- =============================================
	end
end

Uruchom projekt i sprawdź, czy dotknięcie klucza go niszczy.

Wskazówki dotyczące rozwiązywania problemów

Problem: Otrzymujesz komunikat o błędzie zawierający: "Infinite yield possible".

Sprawdź pisownię swojego skryptu modułowego w skrypcie. Jeśli skrypt modułowy, taki jak TreasureManager, jest napisany inaczej, wystąpi błąd.

Problem: Otrzymujesz komunikat o błędzie zawierający: "attempt to index global".

Sprawdź linię, która zawiera wymaganie dla skryptu modułowego w keyScript. Jeśli moduł nie zawiera wymagania, nie może używać funkcji i zmiennych z tego skryptu modułowego.

Problem: Skrypt nie działa lub nie można zbierać kluczy.

W skrypcie modułowym upewnij się, że cały kod znajduje się między local TreasureManager = {} a return TreasureManager. Zwrócenie musi być ostatnią linią kodu w skrypcie modułowym.
Sprawdź, czy na końcu linii z wymaganiem są dwie nawiasy, jak w WaitForChild("TreasureManager")).

Stwórz funkcję lokalną

W tej chwili tablica wyników śledzi klucze i skarby gracza. Aby zmienić liczby na tablicy wyników, użyj funkcji lokalnej w skrypcie modułowym. Funkcja lokalna jest używana, ponieważ zmiana wartości kluczy lub skarbów gracza będzie potrzebna tylko w skrypcie TreasureManager, a nie gdzie indziej.

W ServerStorage otwórz skrypt TreasureManager.

Stwórz lokalne zmienne, aby wykonać następujące czynności:

Uzyskaj usługę Graczy, aby skrypt mógł pracować z danymi tablicy wyników gracza.
Przechowuj liczbę kluczy, które gracz otrzymuje po dotknięciu keyPart.

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

------------------ Funkcje lokalne

------------------ Funkcje modułowe
function TreasureManager.getKey(keyPart, whichCharacter)
	keyPart:Destroy()
end

return TreasureManager

Skopiuj i wklej te dwie lokalne funkcje do sekcji Funkcje lokalne.

getPlayerKeys() zwraca wartość Lockpicks gracza w tablicy wyników.
getPlayerTreasure() zwraca wartość Treasure gracza w tablicy wyników.

------------------ Funkcje lokalne
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
------------------ Funkcje modułowe

Aby dodać klucze gracza, w funkcji modułowej getKey():

Stwórz zmienną local, aby wywołać getPlayerKeys(whichCharacter).
Dodaj wartość keyDrop do playerKeys.

------------------ Funkcje modułowe
function TreasureManager.getKey(keyPart, whichCharacter)
	local playerKeys = getPlayerKeys(whichCharacter)
	playerKeys.Value = playerKeys.Value + keyDrop
	keyPart:Destroy()
end

Uruchom projekt. Sprawdź, czy dotknięcie klucza go niszczy i dodaje 1 do kluczy gracza w tablicy wyników.

Jeśli to konieczne, sprawdź swój skrypt w porównaniu do poniższego, aby znaleźć jakiekolwiek problemy z rozwiązywaniem problemów.

Aktualny skrypt TreasureManager

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

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

------------------ Funkcje modułowe
function TreasureManager.getKey(keyPart, whichCharacter)
   local playerKeys = getPlayerKeys(whichCharacter)
   playerKeys.Value = playerKeys.Value + keyDrop
   keyPart:Destroy()
end

return TreasureManager

Uzyskaj informacje ze skryptów modułowych

Skrypt modułowy TreasureManager będzie używany, gdy gracze dotkną skrzyni skarbów, aby sprawdzić, czy mają przynajmniej jeden klucz przed jej otwarciem i przyznaniem im złota.

Sprawdź, czy skrzynie mogą być otwierane

Najpierw w skrypcie ServerStorage ⟩ TreasureManager ustaw zmienne dotyczące tego, ile kluczy kosztuje otwarcie skrzyni oraz ile złota zawiera każda skrzynia.

local TreasureManager = {}

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

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

Aby stworzyć funkcję, która sprawdza, czy gracz może otworzyć skrzynię, w sekcji Funkcje modułowe dodaj nową funkcję do tabeli TreasureManager o nazwie canOpenChest() z parametrem whichCharacter.

------------------ Funkcje modułowe
function TreasureManager.canOpenChest(whichCharacter)

end

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

Skopiuj i wklej poniższy kod do canOpenChest(), aby zwrócić true, jeśli gracz ma wystarczająco kluczy, i false, jeśli nie ma.

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

Przyznaj graczom skarb

Aby gracz mógł otworzyć skrzynię, stwórz funkcję w TreasureManager, która przyznaje im skarb.

Dodaj nową funkcję modułową do TreasureManager o nazwie openChest().

Przekaż dwa argumenty:
- chestPart - część skrzyni do zniszczenia.
- whichCharacter - gracz, któremu przyznasz skarb.
function TreasureManager.openChest(chestPart, whichCharacter) end

Aby odjąć klucze gracza i przyznać mu skarb, skopiuj i wklej poniższy kod do openChest(). Ten kod używa wcześniej stworzonych zmiennych, takich jak chestReward, ilość skarbu przyznawanego za skrzynię.

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

Wywołaj funkcje skrzyni

Teraz, gdy dwie funkcje modułowe, canOpenChest() i openChest(), zostały stworzone, mogą być wywoływane przez części skrzyni, gdy gracz je dotknie, używając gotowej funkcji partTouched().

W Workspace ⟩ Chests otwórz ChestScript.

Stwórz nową zmienną o nazwie treasureManager i wymagaj skryptu modułowego TreasureManager w ServerStorage.

local ServerStorage = game:GetService("ServerStorage")
-- Wymagaj skryptu modułowego poniżej
local treasureManager = require(ServerStorage:WaitForChild("TreasureManager"))

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

W partTouched(), pod instrukcją if humanoid, stwórz nową zmienną o nazwie canOpen i ustaw ją na:

treasureManager.canOpenChest(whichCharacter)

local function partTouched(otherPart, chestPart)
	local whichCharacter = otherPart.Parent
	local humanoid = whichCharacter:FindFirstChildWhichIsA("Humanoid")
	if humanoid then
		-- Sprawdź, czy gracz może otworzyć skrzynię, a następnie pozwól mu zdobyć skarb
		-- =============================================
		local canOpen = treasureManager.canOpenChest(whichCharacter)
		-- =============================================
	end
end

Następnie stwórz instrukcję if, aby sprawdzić, czy canOpen jest prawdziwe.

Jeśli tak, wywołaj funkcję openChest() skryptu TreasureManager.
Następnie przekaż dwa parametry: chestPart, skrzynia do zniszczenia, oraz whichCharacter, graczowi, któremu przyznasz skarb.

local function partTouched(otherPart, chestPart)
	local whichCharacter = otherPart.Parent
	local humanoid = whichCharacter:FindFirstChildWhichIsA("Humanoid")
	if humanoid then
		-- Sprawdź, czy gracz może otworzyć skrzynię, a następnie pozwól mu zdobyć skarb
		-- =============================================
		local canOpen = treasureManager.canOpenChest(whichCharacter)
		if canOpen == true then
			treasureManager.openChest(chestPart, whichCharacter)
		end
		-- =============================================
	end
end

Uruchom projekt. Sprawdź, czy:
- Jeśli masz przynajmniej 1 klucz, dotknięcie skrzyni ją niszczy i przyznaje skarb.
- Jeśli masz 0 kluczy, nie możesz otworzyć skrzyni skarbów.

Wskazówki dotyczące rozwiązywania problemów

W ChestScript upewnij się, że funkcje wywoływane z skryptu modułowego, takie jak canOpenChest(), są napisane dokładnie tak, jak znajdują się w skrypcie TreasureManager. Jakakolwiek różnica spowoduje błąd.
Sprawdź, czy skopiowane i wklejone funkcje, takie jak treasureManager.openChest(), są dokładnie takie, jak pokazano w lekcji. Jakiekolwiek różnice mogą powodować subtelne błędy w skrypcie.

Zakończone skrypty

Zakończony skrypt TreasureManager

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

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

------------------ Funkcje modułowe
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

Zakończony skrypt ChestScript

local ServerStorage = game:GetService("ServerStorage")
-- Wymagaj skryptu modułowego poniżej ⯆
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
      -- Sprawdź, czy gracz może otworzyć skrzynię, a następnie pozwól mu zdobyć skarb
      -- =============================================
      local canOpen = treasureManager.canOpenChest(whichCharacter)
      if canOpen == true then
         treasureManager.openChest(chestPart, whichCharacter)
      end
      -- =============================================
   end
end

-- Łączy każdą część skrzyni z funkcją dotyku, aby działała na wszystkich częściach
for chestIndex = 1, #chestsArray do
   local chestPart = chestsArray[chestIndex]:WaitForChild("Collider")
   chestPart.Touched:Connect(function(otherPart)
   partTouched(otherPart, chestPart)
   end)
end

Zakończony skrypt keyScript

local ServerStorage = game:GetService("ServerStorage")
-- Wymagaj skryptu modułowego poniżej ⯆
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
      -- Daj graczowi klucz i zniszcz część klucza
      -- =============================================
      treasureManager.getKey(keyPart, whichCharacter)
      -- =============================================
   end
end

-- Łączy każdą część klucza z funkcją dotyku, aby działała na wszystkich częściach
for keyIndex = 1, #keysArray do
   local keyPart = keysArray[keyIndex]
   keyPart.Touched:Connect(function(otherPart)
      partTouched(otherPart, keyPart)
   end)
end

Podsumowanie

Typowym zastosowaniem skryptów modułowych w grach Roblox jest obsługa wspólnych zadań używanych przez graczy, takich jak przyznawanie im punktów. W tym przykładzie stworzono skrypt modułowy o nazwie TreasureManager, aby obsługiwał przyznawanie graczom kluczy i skarbów, gdy wchodzą w interakcję z obiektami w grze.