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 de les utiliser pour ouvrir des coffres au trésor.

Configuration du projet

Ce projet comprend une carte de démarrage avec un tableau de classement et 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.

Pour que les joueurs puissent obtenir des trésors des coffres, créez un script de module nommé TreasureManager. L'utilisation d'un script de module reliera les ramassages et les tableaux de classement.

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 aux deux endroits.
local TreasureManager = {} return TreasureManager

Utiliser des fonctions dans les scripts de module

Pour tester comment les fonctions fonctionnent dans les scripts de module, créez une nouvelle fonction nommée getKey(). Lorsque la fonction getKey() est appelée depuis un autre script, elle recevra une partie de clé à détruire et ajoutera 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, tapez deux commentaires pour vous aider à les séparer.

local TreasureManager = {}

------------------ Fonctions Locales

------------------ Fonctions de Module

return TreasureManager

Sous le commentaire Fonctions de Module, ajoutez une nouvelle fonction de module à TreasureManager nommée getKey().

Utilisez deux paramètres :
- keyPart - la partie à détruire.
- whichCharacter - le joueur qui a touché la partie clé.
local TreasureManager = {} ------------------ Fonctions Locales ------------------ Fonctions de Module function TreasureManager.getKey(keyPart, whichCharacter) end return TreasureManager

Dans getKey(), détruisez keyPart.

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

Utiliser la fonction de module

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

Ouvrez le script de clé dans Workspace ⟩ Keys ⟩ KeyScript.
Dans keyScript, stockez le script de module dans une variable nommée treasureManager et définissez-la égale à : require(ServerStorage:WaitForChild("TreasureManager"))
local ServerStorage = game:GetService("ServerStorage") -- Require le script de module ci-dessous ⯆ local treasureManager = require(ServerStorage:WaitForChild("TreasureManager")) local keys = script.Parent local keysFolder = keys.Parts local keysArray = keysFolder:GetChildren()
Évitez les erreurs en utilisant WaitForChild() au lieu de l'opérateur point pour faire attendre le script jusqu'à ce que TreasureManager soit chargé avant de continuer. Pour les scripts dans ServerScriptService ou ServerStorage, il est sûr d'utiliser l'opérateur point à la place, comme dans ServerStorage.TreasureManager.

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

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

local ServerStorage = game:GetService("ServerStorage")
-- Require 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 toucher une clé la détruit.

Conseils de dépannage

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

Vérifiez l'orthographe de votre script de module dans un script. Si un script de module, comme TreasureManager, est orthographié différemment, il y aura une erreur.

Problème : Obtenez un message d'erreur incluant : "attempt to index global".

Vérifiez la ligne qui inclut le require pour le script de module dans keyScript. Si le module n'inclut pas require, il ne peut pas utiliser les fonctions et variables de ce script de module.

Problème : Le script ne s'exécute pas ou ne peut pas ramasser 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 require, comme dans WaitForChild("TreasureManager")).

Créer une fonction locale

En ce moment, un tableau de classement suit les clés et trésors d'un joueur. Pour changer les chiffres du tableau de classement, utilisez une fonction locale dans le script de module. Une fonction locale est utilisée car changer les valeurs de clé ou de trésor d'un joueur ne sera nécessaire que dans le script TreasureManager, pas ailleurs.

Dans ServerStorage, ouvrez le script TreasureManager.

Créez des variables locales pour faire ce qui suit :

Obtenez le service Players afin que le script puisse travailler avec les statistiques du tableau de classement du joueur.
Stockez le nombre de clés que le joueur reçoit après avoir touché keyPart.

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

------------------ Fonctions Locales

------------------ 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() retourne la valeur de la Lockpicks leaderstat du joueur.
getPlayerTreasure() retourne la valeur de la Treasure leaderstat du joueur.

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

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

Créez 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 toucher une clé la détruit et ajoute 1 aux clés du joueur dans le tableau de classement.

Si nécessaire, vérifiez votre script par rapport à celui ci-dessous pour tout problème de dépannage.

Script TreasureManager Actuel

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

------------------ Fonctions Locales
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 à partir des scripts de module

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

Vérifier si les coffres peuvent être ouverts

D'abord dans ServerStorage ⟩ TreasureManager, configurez des variables pour combien de clés il en coûte 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

------------------ Fonctions Locales
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 whichCharacter.

------------------ 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 retourner true si le joueur a suffisamment 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 des trésors aux joueurs

Pour que le joueur puisse ouvrir un coffre, créez une fonction dans TreasureManager qui leur attribue un trésor.

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

Passez deux arguments :
- chestPart - la partie du coffre à détruire.
- whichCharacter - le joueur à qui donner 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 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.Parent:Destroy()
end

Appeler les fonctions de coffre

Maintenant que les deux fonctions de module, canOpenChest() et openChest(), ont été créées, elles peuvent être appelées par les parties de coffre chaque fois qu'un joueur les touche en utilisant la fonction préfabriquée partTouched().

Dans Workspace ⟩ Chests, ouvrez ChestScript.

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

local ServerStorage = game:GetService("ServerStorage")
-- Require 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 l'instruction if humanoid, créez une nouvelle variable nommée canOpen et définissez-la égale à :

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-le obtenir un trésor
		-- =============================================
		local canOpen = treasureManager.canOpenChest(whichCharacter)
		-- =============================================
	end
end

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

Si oui, appelez la fonction openChest() de TreasureManager.
Ensuite, passez deux paramètres : chestPart, le coffre à détruire, et whichCharacter, le joueur à qui 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-le obtenir un trésor
		-- =============================================
		local canOpen = treasureManager.canOpenChest(whichCharacter)
		if canOpen == true then
			treasureManager.openChest(chestPart, whichCharacter)
		end
		-- =============================================
	end
end

Exécutez le projet. Vérifiez que :
- Si vous avez au moins 1 clé, toucher un coffre le détruit et attribue un trésor.
- Si vous avez 0 clés, vous ne pouvez pas ouvrir un coffre au trésor.

Conseils de dépannage

Dans ChestScript, assurez-vous que les fonctions appelées depuis le script de module comme canOpenChest() sont orthographiées exactement comme elles se trouvent 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. Toute différence peut causer des erreurs subtiles dans le script.

Scripts terminés

Script TreasureManager Terminé

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

------------------ Fonctions Locales
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.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

Script ChestScript Terminé

local ServerStorage = game:GetService("ServerStorage")
-- Require 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-le obtenir un trésor
      -- =============================================
      local canOpen = treasureManager.canOpenChest(whichCharacter)
      if canOpen == true then
         treasureManager.openChest(chestPart, whichCharacter)
      end
      -- =============================================
   end
end

-- Lie chaque partie de coffre à la fonction de toucher afin qu'elle fonctionne sur toutes les parties
for chestIndex = 1, #chestsArray do
   local chestPart = chestsArray[chestIndex]:WaitForChild("Collider")
   chestPart.Touched:Connect(function(otherPart)
   partTouched(otherPart, chestPart)
   end)
end

Script keyScript Terminé

local ServerStorage = game:GetService("ServerStorage")
-- Require 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 clé à la fonction de toucher afin 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é

Une application courante de l'utilisation des scripts de module dans les jeux Roblox est de gérer des tâches courantes utilisées par les joueurs, comme leur attribuer des points. Pour cet exemple, un script de module nommé TreasureManager a été créé pour gérer l'attribution de clés et de trésors aux joueurs chaque fois qu'ils interagissent avec des objets du jeu.