Créer avec des scripts de module | Documentation

Pour appliquer vos connaissances des scripts de module, créez un script de module qui permet aux joueurs de ramasser des clés et d'utiliser-les pour ouvrir des coffres au trésor.

Configuration du projet

Ce projet inclut une carte de démarrage avec des objets de ramassage scriptés pour les clés et les coffres au trésor.

Charger le projet de démarrage

Téléchargez le projet de démarrage.
Dans Roblox Studio, ouvrez le fichier téléchargé : Intro to Module Scripts - Starter Project.rbxl .

Ainsi, les joueurs peuvent obtenir un trésor dans les coffres, créer un script de module nommé TreasureManager . En utilisant un script de module, vous connecterez les pickups et les classements ensemble.

Dans ServerStorage , créez un nouveau ModuleScript et renommez-le en TreasureManager .

Dans TreasureManager, renommez la table de module par défaut en remplaçant module par TreasureManager dans les deux endroits.


local TreasureManager = {}

return TreasureManager

Utiliser les fonctions dans les scripts de module

Pour tester le fonctionnement des fonctions dans les scripts de module, créez une nouvelle fonction nommée getKey(). Lorsque la fonction getKey() est appelée à partir d'un autre script, elle recevra une partie clé pour détruire et ajouter 1 au nombre de clés dans l'inventaire du joueur.

Créer une fonction de module pour les clés

Ce script de module utilisera une combinaison de fonctions de module et locales, type deux commentaires pour vous aider à les séparer.


local TreasureManager = {}

--Local Functions

------------------ Fonctions de module

return TreasureManager

Sous le commenter fonctions de module , ajoutez une nouvelle fonction de module à TreasureManager nommé getKey().

Utilisez deux paramètres :

keyPart - la partie à détruire.
whichCharacter - le joueur qui a touché la partie clé.


local TreasureManager = {}

--Local Functions

------------------ Fonctions de module
function TreasureManager.getKey(keyPart, whichCharacter)

end

return TreasureManager

En getKey() , détruisez keyPart.


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

Utiliser la fonction de module

Maintenant, la fonction module getKey() peut être utilisée dans d'autres scripts. Pour tester cette fonction, vous ouvrirez un script prédéfini et l'appellerez.

Ouvrez le script clé dans Espace de travail > Clés > KeyScript.

Dans keyScript, storez le script de module dans une variable nommée treasureManager et définissez-le comme équivalant à : require(ServerStorage:WaitForChild("TreasureManager"))


local ServerStorage = game:GetService("ServerStorage")
-- Exigez le script de module ci-dessous ⯆
local treasureManager = require(ServerStorage:WaitForChild("TreasureManager"))

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

Empêchez les erreurs en utilisant WaitForChild() au lieu de l'opérateur point pour faire en sorte que le script attend jusqu'à ce que TreasureManager ait chargé avant de continuer. Pour les scripts dans ServerScriptService ou ServerStorage, il est sûr d'utiliser l'opérateur point, comme dans ServerStorage.TreasureManager.

Il y a déjà une fonction nommée partTouched() pour vérifier qu'un joueur touche la partie. À l'intérieur de partTouched() :

Appeler la fonction module getKey() pour détruire la clé.
Passez en keyPart et whichCharacter.


local ServerStorage = game:GetService("ServerStorage")
-- Exigez le script de module ci-dessous ⯆
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
		-- Donnez au joueur une clé et détruisez la partie clé
		-- =====================================
		treasureManager.getKey(keyPart, whichCharacter)
		-- =====================================
	end
end

Exécutez le projet et vérifiez que le toucher d'une clé le détruit.

Conseils de débogage

Problème : Obtenez un message d'erreur comprenant : "Infinite yield possible" .

Vérifiez l'orthographe de votre script de module dans un script. Si un script de module, comme TreasureManager , est écrit différemment, il y aura une erreur. Problème : Obtenez un message d'erreur comprenant : "attempt to index global" .
Vérifiez la ligne qui inclut le requis pour le script de module dans keyScript. Si le module ne inclut pas le exiger, il ne peut pas utiliser les fonctions et les variables de ce script de module. Problème : Le script ne s'exécute pas ou ne peut pas récupérer les clés.
Dans le script de module, assurez-vous que tout le code est entre local TreasureManager = {} et return TreasureManager. Le retour doit être la dernière ligne de code dans un script de module.
Vérifiez qu'il y a deux parenthèses à la fin de la ligne avec exiger, comme dans WaitForChild("TreasureManager")) .

Créer une fonction locale

En ce moment, un classement suit les clés et le trésor d'un joueur. Pour modifier les numéros du classement, utilisez une fonction locale dans le script de module. Une fonction locale est utilisée car le changement d'une clé ou des valeurs du trésor d'un joueur ne sera nécessaire que dans le script de module TreasureManager, pas n'importe où ailleurs.

Dans ServerStorage, ouvrez le script TreasureManager .

Créez des variables locales pour faire les choses suivre:

Obtenez le service Joueurs afin que le script puisse fonctionner avec les statistiques de classement des joueurs.
Stocke le nombre de clés que le joueur reçoit après avoir touché cléPart.


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

--Local Functions

------------------ Fonctions de module
function TreasureManager.getKey(keyPart, whichCharacter)
	keyPart:Destroy()
end

return TreasureManager

Copiez et collez ces deux fonctions locales dans la section fonctions locales .

getPlayerKeys() renvoie la valeur du leader du joueur Lockpicks.
getPlayerTreasure() renvoie la valeur du leader du joueur Treasure .


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

Pour ajouter aux clés du joueur, dans la fonction module getKey() :

Créer une variable local pour appeler getPlayerKeys(whichCharacter) .
Ajoutez la valeur de keyDrop à playerKeys.


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

Exécutez le projet. Vérifiez que le fait de toucher une clé la détruit et ajoute 1 aux clés du joueur dans le classements.

Si nécessaire, vérifiez votre script contre celui ci-dessous pour tout problème de débogage.

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

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

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

return TreasureManager

Obtenir des informations des scripts de module

Le script de module Gestionnaire des trésors sera utilisé lorsque les joueurs toucheront un coffre à trésor pour vérifier s'ils ont au moins une clé avant d'ouvrir et leur donner de l'or.

Vérifier si les coffres peuvent être ouverts

Tout d'abord dans ServerStorage > TreasureManager script, configurer les variables pour le nombre de clés qu'il faut pour ouvrir un coffre, et combien d'or chaque coffre contient.


local TreasureManager = {}

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

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

Pour créer une fonction qui vérifie si un joueur peut ouvrir un coffre, dans la section fonctions de module, ajoutez une nouvelle fonction à la table TreasureManager nommée canOpenChest() avec le paramètre 2> canOpenChest2> .


------------------ Fonctions de module
function TreasureManager.canOpenChest(whichCharacter)

end

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

Copiez et collez le code ci-dessous dans canOpenChest() pour renvoyer true si le joueur a assez de clés, et false s'il n'en a pas.


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

Donner au joueur un trésor

Ainsi, le joueur peut ouvrir un coffre, créer une fonction dans TreasureManager qui leur accorde un trésor.

Ajoutez une nouvelle fonction de module à TreasureManager nommé openChest().

Passez en deux arguments :

chestPart - la partie du coffre pour être détruite.
whichCharacter - le joueur qui donne le trésor.


function TreasureManager.openChest(chestPart, whichCharacter)

end

Pour soustraire les clés d'un joueur et leur attribuer un trésor, copiez et collez le code ci-dessous dans openChest() . Ce code utilise les variables créées précédemment, comme chestReward , le montant de trésor donné par le coffre.


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

Appeler les fonctions de la poitrine

Maintenant que les deux fonctions de module, canOpenChest() et openChest(), ont été créées, elles peuvent être appelées par les parties du coffre à tout moment par un joueur en utilisant la fonction prédéfinie partTouched().

Dans Espace de travail > Coffres > Ouvrir le script du coffre .

Créez une nouvelle variable nommée treasureManager et exigez le script de module TreasureManager dans ServerStorage .


local ServerStorage = game:GetService("ServerStorage")
-- Exigez le script de module ci-dessous
local treasureManager = require(ServerStorage:WaitForChild("TreasureManager"))

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

Dans partTouched() , sous la déclaration if humanoid, créez une nouvelle variable nommée canOpen et définissez-la comme :

treasureManager.canOpenChest(whichCharacter)


local function partTouched(otherPart, chestPart)
	local whichCharacter = otherPart.Parent
	local humanoid = whichCharacter:FindFirstChildWhichIsA("Humanoid")
	if humanoid then
		-- Vérifiez si le joueur peut ouvrir un coffre, puis laissez-leur obtenir un trésor
		-- =====================================
		local canOpen = treasureManager.canOpenChest(whichCharacter)
		-- =====================================
	end
end

Ensuite, créez une if statement pour vérifier si canOpen est vrai.

Si oui, appelez la fonction openChest() du gestionnaire des trésors.
Ensuite, passez deux paramètres : chestPart, la poitrine à détruire, et whichCharacter, le joueur à attribuer le trésor.


local function partTouched(otherPart, chestPart)
	local whichCharacter = otherPart.Parent
	local humanoid = whichCharacter:FindFirstChildWhichIsA("Humanoid")
	if humanoid then
		-- Vérifiez si le joueur peut ouvrir un coffre, puis laissez-leur obtenir un trésor
		-- =====================================
		local canOpen = treasureManager.canOpenChest(whichCharacter)
		if canOpen == true then
			treasureManager.openChest(chestPart, whichCharacter)
		end
		-- =====================================
	end
end

Lancer le projet. Vérifier que :
- Si vous avez au moins 1 clé, toucher un coffre le détruira et vous donnera un trésor.
- Si vous n'avez pas de clés, vous ne pouvez pas ouvrir un coffre au trésor.

Conseils de débogage

Dans ChestScript, assurez-vous que les fonctions appelées à partir du script du module comme canOpenChest() sont correctement orthographiées comme elles sont trouvées dans le script TreasureManager. Toute différence entraînera une erreur.
Vérifiez que les fonctions copiées et collées, comme treasureManager.openChest(), sont exactement comme indiqué dans la leçon. Toutes les différences peuvent causer des erreurs subtiles dans le script.

Scripts terminés

Script de fin de TreasureManager terminé
local TreasureManager = {}
local Players = game:GetService("Players")
local keyDrop = 1
local chestPickCost = 1
local chestReward = 100

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

------------------ Fonctions de module
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

ChestScript terminé
local ServerStorage = game:GetService("ServerStorage")
-- Exigez le script de module ci-dessous ⯆
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
      -- Vérifiez si le joueur peut ouvrir un coffre, puis laissez-leur obtenir un trésor
      -- =====================================
      local canOpen = treasureManager.canOpenChest(whichCharacter)
      if canOpen == true then
         treasureManager.openChest(chestPart, whichCharacter)
      end
      -- =====================================
   end
end

-- Fixe chaque partie du coffre au raccourci de touche afin qu'elle fonctionne sur toutes les parties
for chestIndex = 1, #chestsArray do
   local chestPart = chestsArray[chestIndex]
   chestPart.Touched:Connect(function(otherPart)
   partTouched(otherPart, chestPart)
   end)
end

Script de clé terminé
local ServerStorage = game:GetService("ServerStorage")
-- Exigez le script de module ci-dessous ⯆
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
      -- Donnez au joueur une clé et détruisez la partie clé
      -- =====================================
      treasureManager.getKey(keyPart, whichCharacter)
      -- =====================================
   end
end

-- Lie chaque partie de clé à la fonction de touche pour qu'elle fonctionne sur toutes les parties
for keyIndex = 1, #keysArray do
   local keyPart = keysArray[keyIndex]
   keyPart.Touched:Connect(function(otherPart)
      partTouched(otherPart, keyPart)
   end)
end

Résumé

L'utilisation courante des scripts de module dans les jeux Roblox est de gérer les tâches courantes utilisées par les joueurs, telles que leur accorder des points. Pour cet exemple, un script de module nommé TreasureManager a été créé pour gérer la donation de clés et de trésors chaque fois qu'ils interagissent avec les objets dans le jeu.