Créer avec des scripts de modules | Documentation

Pour appliquer vos connaissances des scripts de modules, 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 inclut une carte de démarrage avec classement et 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.

Créer un script de module

Pour que les joueurs puissent obtenir du trésor des coffres, créez un script de module nommé TreasureManager. L'utilisation d'un script de module reliera les ramassages et les classements ensemble.

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

Dans TreasureManager, renommez la table du 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 de fonctions 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()

Empêchez les erreurs en utilisant WaitForChild() au lieu de l'opérateur de point pour faire en sorte que le script attende jusqu'à ce que TreasureManager soit chargé avant de passer à l'étape suivante. Pour les scripts dans ServerScriptService ou ServerStorage, il est sûr d'utiliser l'opérateur de 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 une clé au joueur 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 mal orthographié, il y aura une erreur.

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

Vérifiez la ligne qui inclut la require pour le script de module dans keyScript. Si le module ne comprend 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 se trouve 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

Pour l'instant, un classement suit les clés et le trésor d'un joueur. Pour modifier les chiffres du classement, utilisez une fonction locale dans le script du module. Une fonction locale est utilisée car changer les valeurs de clés ou de trésor d'un joueur ne sera nécessaire que dans le script TreasureManager, et non 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 de classement des joueurs.
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() renvoie la valeur des Lockpicks leaderstat du joueur.
getPlayerTreasure() renvoie la valeur du leaderstat de Treasure 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 les clés du joueur, dans la fonction du 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 classement.

Si besoin, vérifiez votre script par rapport à celui ci-dessous pour des problèmes 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 des scripts de module

Le script modulé 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 le script TreasureManager ⟩ ServerStorage, 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 du trésor aux joueurs

Pour que le joueur puisse ouvrir un coffre, créez une fonction dans TreasureManager qui leur attribue du 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 du trésor.


function TreasureManager.openChest(chestPart, whichCharacter)

end

Pour soustraire les clés d'un joueur et leur attribuer du trésor, copiez et collez le code ci-dessous dans openChest(). Ce code utilise les variables créées précédemment, comme chestReward, la quantité de trésor donnée 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 du trésor
		-- =============================================
		local canOpen = treasureManager.canOpenChest(whichCharacter)
		-- =============================================
	end
end

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

Si c'est le cas, appelez la fonction openChest() de TreasureManager.
Ensuite, passez deux paramètres : chestPart, le coffre à détruire, et whichCharacter, le joueur à qui attribuer du 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 du 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 du 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ées dans la leçon. Toute différence peut causer des erreurs subtiles dans le script.

Scripts fins

Script TreasureManager Fini
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 Fini
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 du 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 pour 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 Fini
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 une clé au joueur et détruisez la partie clé
      -- =============================================
      treasureManager.getKey(keyPart, whichCharacter)
      -- =============================================
   end
end

-- Lie chaque partie clé à la fonction de toucher 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é

Une application courante de l'utilisation de scripts de module dans les expériences 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ésor aux joueurs chaque fois qu'ils interagissent avec des objets du jeu.