Ce guide couvre les commandes d'administration du système de chat hérité, qui est obsolète et n'accueille plus de nouveaux utilisateurs en faveur de TextChatService avec des paramètres de chat plus simples et plus modernes.Si vous utilisez le système de chat par défaut alimenté par TextChatService, voir chat textuel en expérience pour créer des commandes de chat personnalisées.
Un commande admin est un mot-clé ou une phrase que l'utilisateur avec un certain niveau de contrôle peut saisir dans la fenêtre de chat pour déclencher une action.Cette bibliothèque utilise des modules de chat, ce qui permet une mise en œuvre facile des commandes d'administration en plus du système de chat hérité.Les modules de chat écoutent les messages entrants sur le serveur et peuvent exécuter des actions en fonction des critères souhaités.
Lancement
Chaque fois qu'un lieu Roblox se charge, il vérifie si le service de chat est vide.S'il ne trouve pas les composants dont il a besoin, l'endroit insérera la dernière version de ces composants.Cela signifie que l'écriture surécrasante ou la modification de ces composants dans une expérience les empêchera de être mis à jour.
La première étape pour configurer la bibliothèque des commandes d'administration est d'ajouter un nouveau module de chat au service de chat.La bibliothèque dans ce tutoriel s'occupe du levage lourd effectué par un module de chat, de sorte que le seul objet que vous devez ajouter au service de chat est un nouveau ModuleScript.Le nom de votre script de module peut être n'importe quoi, mais je suggère quelque chose d'intuitif comme AdminCommands .
Implémenter de nouvelles commandes
Plutôt que d'implémenter la plupart de la logique du module de chat, vous aurez simplement besoin du module de bibliothèque qui fait une grande partie du travail et ajoute une fonctionnalité supplémentaire.La façon la plus simple d'ajouter la bibliothèque à votre module est de la requérir par son ID de ressource en haut de votre script.
Ce module renvoie une table de fonctions, avec la fonction Run comme la plus importante.La bibliothèque a une fonction Run pour son module de chat.Il est important que les commandes d'administration renvoient cette fonction Run au service de chat.La fonction est indexée par son nom, Run , et vous pouvez retourner ce qui suit comme si Run était une propriété de notre représentation de table des commandes d'administration :
Entre ces deux lignes de code, implémentez vos propres commandes et toutes les fonctions d'aide nécessaires.
Pour lier une fonction à la bibliothèque, utilisez la fonction BindCommand de AdminCommands.Lorsque vous liez une commande, vous devrez spécifier une table de mots-clés qui, lorsqu'ils sont prononcés, déclencheront la commande, la fonction qui sera déclenchée, un niveau de priorité et, facultativement, une description de la commande.Si vous ne spécifiez pas un niveau de privilège, il sera par défaut de 0.Les niveaux de priorité sont des valeurs numériques utilisées par la bibliothèque AdminCommands pour attribuer une hiérarchie de permissions parmi les utilisateurs avec les niveaux de privilège correspondants.Lors de l'exécution d'une commande, le locuteur doit avoir un niveau de privilège supérieur ou égal à celui de la commande bibliothèque des permissions.
Pour vous désolidariser, vous utiliseriez également UnbindCommand et spécifieriez un mot-clé pour vous désolidariser.
En tout, le contenu de votre script de commandes d'administration devrait ressembler à ce qui suivre:
local AdminCommands = require(1163352238)
local Utilities = AdminCommands.Utilities
function commandFunction(commandData)
-- Code de commande ici
-- Renvoie vrai si réussi et faux sinon
end
AdminCommands:BindCommand({"keyword1", "keyword2"}, commandFunction, 1, "Optional description")
return AdminCommands.Run
Vous pouvez remarquer que la fonction d'exemple prend un paramètre nommé commandData.Ce paramètre est un argument de table transmis à toutes les fonctions de commande d'administrateur liées lorsqu'elles sont exécutées par la bibliothèque.La table contient des informations utiles sur la commande qui a été prononcée et l'utilisateur qui l'a prononcée.Il a les champs suivants :
- Orateur : ChatSpeaker
- Message : string
- Nom du canal : string
- Commande : string
Il est important d'attendre toujours commandData comme paramètre des fonctions de commande.Par exemple, si vous avez une commande nommée "explode", qui nécessite un paramètre Player pour être spécifié, la fonction ressemblerait à explode(commandData, utilisateur).
Chaque fonction de commande est passée commandData en tant que paramètre.Si vous utilisez un autre nombre de paramètres, il est toujours important de passer commandData en premier, même si vous n'utilisez que les autres paramètres.
| Fonction | Paramètres | Retour | | --------------- | ------------------------------------------------------------------------------------------------ | ------ | | Commandes : | | | | BindCommand() | table functionIDs, fonction functionToExecute, nombre minimumPermissionLevel, chaîne description | bool | | UnbindCommand() | table functionIDs | bool | | Obtenir des commandes() | | table |
Utilités
La bibliothèque a déjà quelques fonctions d'aide intégrées appelées utilités que vous pouvez utiliser.Stocker la commande AdminCommand.Utilities dans une variable ou la référencer directement.
Les fonctions d'utilité actuelles sont :
| Fonction | Paramètres | Retour | | -------------------------- | -------------------------------------------------- | ------ | | Messages de la fenêtre de chat : | | | | SendSystemMessage() | table commandData, string content, table extraData | bool | | SendSystemSuccessMessage() | table commandData, string content | bool | | SendSystemWarningMessage() | table commandData, string content | bool | | IncorrectValueType() | table commandData, string given, string expected | | | Gestionnaires d'erreurs : | | | | NotEnoughSpecified() | table commandData | bool | | IncorrectValueType() | table commandData, string given, string expected | | | Conversion de données : | | | | ToTupple(paramètre) | string paramètre | array | | ToBoolean() | string paramètre | bool | | ValidateData() | string expectedType, ...| bool |
Exemples de commandes
Un commande utile à avoir serait celle qui imprime une liste de toutes les commandes optionnelles dont les utilisateurs disposent.Cette commande produit chaque commande liée à la bibliothèque et quelques-unes de ses propriétés.
-- Imprime une liste de toutes les commandes liées
function listCommand(commandData)
Utilities:SendSystemMessage(commandData, "The following commands are available:")
-- Iterer à travers chaque commande et l'imprimer
for id, command in PublicAPI:GetCommands() do
Utilities:SendSystemMessage(commandData, string.format("%* requires permission %*.", id, command.Permission))
end
return true
end
AdminCommands:BindCommand({"list"}, listCommand, 0, "Prints a list of commands.")
Une autre commande utile permet aux utilisateurs de se donner des étincelles.Cette commande nécessite un paramètre lorsqu'elle est prononcée - le nom de l'utilisateur ciblé.Si l'utilisateur existe, la commande créera un objet Sparkles dans la partie HumanoidRoot de cet utilisateur.
-- Donne des étincelles au personnage d'un joueur spécifié
function sparklesCommand(commandData)
-- Erreur si aucun paramètre n'est donné/parlé
if #commandData.Parameters == 0 then
return Utilities:NoPlayerSpecified(commandData)
end
-- Boucle à travers les paramètres (exécution sur le nom de chaque joueur donné)
for index = 1, #commandData.Parameters do
local parameter = commandData.Parameters[index]
if (parameter == "me" or parameter == "") then parameter = commandData.Speaker.Name end -- Si le paramètre est moi, l'utilisateur doit se référer à lui-même
-- Utilisez une fonction d'aide pour trouver le personnage du joueur et ajouter les étincelles
local character = Utilities:GetCharacter(parameter)
if character then
local sparkles = Instance.new("Sparkles")
sparkles.Parent = character:FindFirstChild("HumanoidRootPart")
Utilities:SendSystemSuccessMessage(commandData, string.format(commandData.Speaker.Name .. "added sparkles to " .. parameter))
else
Utilities:SendSystemErrorMessage(commandData, string.format("%* is not a valid player.", parameter))
return false
end
end
return true
end
AdminCommands:BindCommand({"sparkles"}, sparklesCommand, 1, "Gives the specified player sparkles")
Vous pouvez également inclure une commande d'explosion du tutoriel Créer une commande d'administrateur. Cette commande prend également le nom d'un utilisateur comme paramètre.
-- Vérifie que le modèle donné est un personnage et ajoute une explosion à sa partie racine humanoïde
local function makeExplosion(character)
if character and character:FindFirstChild("HumanoidRootPart") then
local explosion = Instance.new("Explosion")
explosion.Position = character.HumanoidRootPart.Position
explosion.Parent = character.HumanoidRootPart
return true
end
return false
end
-- Fait exploser le personnage d'un joueur spécifié
function explodeCommand(commandData)
-- Erreur si aucun paramètre n'est donné/parlé
if #commandData.Parameters == 0 then
return Utilities:NoPlayerSpecified(commandData)
end
for index = 1, #commandData.Parameters do
local parameter = tostring(commandData.Parameters[index])
if (parameter == "me" or parameter == "") then parameter = commandData.Speaker.Name end -- Si le paramètre est moi, l'utilisateur doit se référer à lui-même
-- Utilisez une fonction d'aide pour trouver le personnage du joueur et ajouter l'explosion
local character = Utilities:GetCharacter(parameter)
local success = makeExplosion(character)
if success then
Utilities:sendSystemSuccessMessage(commandData, string.format(commandData.Speaker.Name .. " made" .. parameter .. " explode."))
else
Utilities:SendSystemErrorMessage(commandData, string.format("%* is not a valid player.", parameter))
return false
end
end
return true
end
AdminCommands:BindCommand({"explode"}, explodeCommand, 1, "Makes the specified player explode.")
Bibliothèque d'autorisation
Si un non-administrateur essaie de parler une commande comme celle-ci, qui a un niveau de permission plus élevé que 0, elle ne sera pas déclenchée.Le système de commande utilise une bibliothèque de permissions séparée, à laquelle le créateur d'expérience est automatiquement attribué le niveau de permission math.huge.Les administrateurs peuvent être ajoutés en utilisant les fonctions suivantes sur l'objet de module AdminCommands :
| Fonction | Paramètres | Retour | | ---------------------------- | ---------------------------------------------------------------------------------- | ------ | | Permission | | | | GetAdmins() | | table | | SetUserPermission() | number requesterUserId, number targetGroupNameId, permissionLevel | bool | | GetUserPermission() | number userId | number | | GetGroups() | | table | | SetGroupRankPermission() | number requesterUserId, number targetGroupId, number targetRankId, permissionLevel | bool | | GetGroupRankPermission() | targetGroupId, targetRankId | int |
Module de démarrage rapide
Pour une configuration plus simple, vous pouvez également utiliser ce démarrage rapide, qui est un module qui a déjà implémenté la bibliothèque des commandes d'administration.Le modèle est un module avec le même format décrit ci-dessus.De plus, le module a quelques commandes déjà incluses afin que vous n'ayez pas à les réimplémenter.
| Command/bindage | Paramètre parlé | | -------------------------------- | -------------------------------- | | "list", "commands" | nom d'utilisateur | | "sparkles" | nom d'utilisateur | | "sparkles" | nom d'utilisateur | | "unforcefield", "unff" | nom d'utilisateur | | "explode" | nom d'utilisateur | | "part" | Chemin (c'est-à-direexpérience.Workspace) | | "freeze" | nom d'utilisateur | | "unfreeze" | nom d'utilisateur | | "ajouter" | nom d'utilisateur | | "retirer" | nom d'utilisateur | | "exclure" | nom d'utilisateur | | "setuserpermission", "sup" | identifiant de groupe, permission | | "setgrouprankpermission", "sgrp" | groupe, rangId, permission |