Aller au contenu

API des commandes

Tout ce qu'une commande peut référencer sans risque se trouve dans CommandAPI :

local CommandAPI = require(script:FindFirstAncestor("HD Admin").Core.CommandAPI)

Chargement

loadCommands Server

CommandAPI.loadCommands(details): Commands

Les modules de pack sous Config > Commands s'en servent pour charger, étiqueter et modifier leurs ensembles de commandes. Ouvre n'importe quel pack là-bas pour le voir en action.


Invites

prompt Shared

-- In a server command module
CommandAPI.prompt(promptType: PromptType, player: Player, text: string, options: PromptOptions?): PromptHandle

-- In a client command module
CommandAPI.prompt(promptType: PromptType, text: string, options: PromptOptions?): PromptHandle

Affiche une notification, un message ou une carte. Pour les invites d'action avec des boutons, vois bindPrompt.

Type d'invite Ce qu'elle affiche
"info" "success" "warn" "error" Une notification latérale avec un effet sonore
"message" Un message au centre de l'écran, utilisé par exemple dans ;message
"hint" Une petite barre en haut de l'écran, utilisée par exemple dans ;hint
"privateMessage" Une notification latérale persistante qui ouvre le message complet au clic
"alert" Une notification latérale persistante qui répète un son jusqu'à ce qu'elle soit mise en sourdine et ouvre le message complet au clic
"action" Une notification latérale avec des boutons et des contrôles. Crée-les avec task:bindPrompt
CommandAPI.prompt("success", task.caller, "Quest complete!", {duration = 5})

Elle renvoie une connexion que tu peux déconnecter avec connection:Disconnect() pour terminer l'invite. Tu peux par exemple les ajouter au janitor d'une tâche pour qu'elles se terminent dès que la commande se termine :

task.janitor:add(CommandAPI.prompt("hint", task.target, "You're frozen until an admin releases you", {duration = 0})) -- 0 means "infinite"

Options

Toutes sont facultatives et fonctionnent avec chaque type d'invite, sauf si la ligne indique le contraire :

Option Type Ce qu'elle fait
title string Le titre au-dessus du texte. privateMessage et alert définissent le leur
duration number Nombre de secondes avant que l'invite se ferme toute seule. Si tu l'omets, une durée est calculée à partir de la longueur du texte. 0 la garde à l'écran jusqu'à ce qu'elle soit fermée ou déconnectée
subtext string Une ligne plus petite sous le texte
icon string Une image rbxassetid:// qui remplace l'icône de la notification
color Color3 Teinte le texte d'un hint
dismissable boolean false masque le bouton de fermeture, donc seuls duration ou le handle peuvent la retirer
openPage string Cliquer sur la notification ouvre le panneau sur cette page, comme "Commands", "Roles", "Settings" ou "About"
openProfile boolean Cliquer sur la notification ouvre le profil du joueur
openImage table {image = "rbxassetid://...", title = "Map", ratio = 16/9}. Cliquer sur la notification ouvre l'image au centre de l'écran
linkButtons table De petits boutons en bas de la notification. {label = "Roles", page = "Roles"} ouvre une page et {label = "Profile", profile = true} ouvre son profil. Ajoute style = "Neutral" pour un bouton discret, et hideAfterPress = true pour fermer la notification une fois le bouton pressé. Depuis un LocalScript via la Client API, {label = "Shop", onActivate = function() ... end, icon = "rbxassetid://..."} exécute ta propre fonction à la place
roleBadges table Des badges de rôle sous le titre, {{name = "Admin", color = Color3.fromRGB(255, 170, 0)}}
countdown number Décompte en direct à partir de ce nombre de secondes partout où %TIME% apparaît dans le texte
fromUserId number Affiche l'avatar, le nom et le rôle principal de cet utilisateur comme expéditeur d'un message, privateMessage ou alert
userText boolean Affiche le texte exactement tel qu'il est écrit, sans balises de texte enrichi, etc.
CommandAPI.prompt("info", task.caller, "You've unlocked the VIP role", {
    title = "New role",
    openPage = "Roles",
    roleBadges = {{name = "VIP", color = Color3.fromRGB(255, 170, 0)}},
})

Pour les invites d'action avec des boutons, vois bindPrompt.


Personnage

getHumanoid Shared

CommandAPI.getHumanoid(player: Player?): Humanoid?

Le Humanoid du joueur, ou nil si son personnage n'est pas présent.


getHRP Shared

CommandAPI.getHRP(player: Player?): BasePart?

Le HumanoidRootPart du joueur, ou nil.


getHead Shared

CommandAPI.getHead(player: Player?): (BasePart?, Model?)

La Head du joueur et son personnage, ou nil.


getNeck Shared

CommandAPI.getNeck(player: Player?): Motor6D?

L'articulation du cou du joueur, ou nil. Fonctionne avec les rigs R6 et R15.


getTorso Shared

CommandAPI.getTorso(player: Player?): Instance?

Le torse du joueur, ou nil. Fonctionne avec les rigs R6 et R15.


loadCharacter Server

CommandAPI.loadCharacter(player: Player?)

Fait réapparaître le personnage du joueur. Utilise toujours cette fonction plutôt que player:LoadCharacter() pour que les tâches de HD Admin sachent que la réapparition est voulue.


Joueurs

getUserInfoAsync Shared

CommandAPI.getUserInfoAsync(userId: number | string): (boolean, UserInfo | string)

Renvoie true et le UserInfo de n'importe quel utilisateur, même hors ligne, ou false et une raison. Les résultats sont mis en cache, donc les appels répétés ne coûtent rien.


getNameFromUserIdAsync Shared

CommandAPI.getNameFromUserIdAsync(userId: number | string): (boolean, string)

Renvoie true et le nom de l'utilisateur, ou false et une raison. Fonctionne pour les utilisateurs hors ligne.


teleportAsync Server

CommandAPI.teleportAsync(player: Player?, cframe: CFrame): (boolean, string)

Déplace le personnage du joueur vers le CFrame donné, en le faisant d'abord se lever de son siège pour qu'il n'emporte pas le siège avec lui.


getAllowedTargets Server

CommandAPI.getAllowedTargets(task: Task, options: {players: {Player}?}?): ({Player}, {Player})

Les joueurs sur lesquels une commande peut agir, c'est-à-dire par défaut tout le monde dans le serveur sauf ceux qui ont activé Block commands dans leurs You Settings.


unequipTools Server

CommandAPI.unequipTools(player: Player?): (boolean, string)

Remet l'outil équipé du joueur dans son sac à dos.


Tâches

getTasks Shared

CommandAPI.getTasks(commandKey: string?, targetUserId: number?): {Task}

Renvoie les tâches en cours, filtrées si tu le veux par commande et par cible. Ce sont les mêmes objets de tâche que ceux décrits dans Task API.


getTasksByCallerId Shared

CommandAPI.getTasksByCallerId(callerUserId: number): {Task}

Toutes les tâches en cours lancées par l'appelant donné.


Chat

systemMessage Shared

-- In a server command module
CommandAPI.systemMessage(player: Player, text: string)

-- In a client command module
CommandAPI.systemMessage(text: string)

Envoie un message de style système dans le chat du joueur.


checkTextLimit Server

CommandAPI.checkTextLimit(task: Task, textKind: "Message" | "SurfaceText" | "ChatText" | "Reason"): (boolean, number?)

HD Admin limite l'envoi des fonctionnalités liées aux messages à cause des politiques de sécurité liées à l'âge de Roblox, donc cette fonction permet de voir ce délai d'attente.

Elle renvoie true quand le texte peut être affiché, sinon false avec le délai d'attente restant.

args = {"Player", "Leaderstat", {arg = "String", textSurface = "None"}},
run = function(task)
    local stat = task:getArg("Leaderstat")
    local text = task:getArg("String")
    if stat:IsA("StringValue") then
        if not CommandAPI.checkTextLimit(task, "SurfaceText") then
            return
        end
    end
    stat.Value = text
end,
Type Partagé par
"Message" Messages, hints, notifications, alertes, messages privés et sondages
"SurfaceText" Noms, titres, noms d'équipe et statistiques
"ChatText" Tags de chat et noms de chat
"Reason" Raisons d'expulsion et de bannissement

forceBubbleChat Shared

CommandAPI.forceBubbleChat(target: Player | Model, text: string)

Affiche une bulle de chat au-dessus du personnage du joueur, ou au-dessus de n'importe quel modèle ou part que tu passes à la place.


Tenues

getDescription Server

CommandAPI.getDescription(humanoid: Humanoid): HumanoidDescription

Le HumanoidDescription actuel du humanoid.


applyDescription Server

CommandAPI.applyDescription(humanoid: Humanoid?, description: HumanoidDescription?, properties: {[string]: any}?): HumanoidDescription?

Applique le HumanoidDescription en toute sécurité, en réessayant quand Roblox rejette la première tentative. Passe properties pour ajuster des champs par-dessus la description de base.


outfitBuff Server

CommandAPI.outfitBuff(target: Player, properties: {[string]: any})

Applique des propriétés de HumanoidDescription comme un buff qui s'annule tout seul à la fin de la tâche, si bien que des commandes comme ;wormify nettoient derrière elles sans rien faire de plus.


setFakeBodyParts Server

CommandAPI.setFakeBodyParts(character: Model, info: {[string]: any}): (() -> ())?

Remplace des parties du corps par des doublures créées par la commande et renvoie une fonction qui restaure les originales.


clearFakeBodyParts Server

CommandAPI.clearFakeBodyParts(character: Model)

Retire à nouveau ces doublures.


runBundleId Server

CommandAPI.runBundleId(task: Task, bundleId: number, properties: {[string]: any}?)

Habille la cible de la tâche avec un bundle du catalogue, et lui rend sa propre tenue à la fin de la tâche.


Assets

registerSound Shared

CommandAPI.registerSound(sound: Sound)

Obligatoire pour tout Sound que ta commande crée, afin que les paramètres de volume et de hauteur du jeu s'y appliquent.


setAnchored Shared

CommandAPI.setAnchored(instance: Instance, anchored: boolean)

Ancre ou désancre chaque part sous l'instance.


setTransparency Shared

CommandAPI.setTransparency(instance: Instance, transparency: number)

Fait varier la transparence de chaque part sous l'instance.


promptPurchaseAsync Server

CommandAPI.promptPurchaseAsync(assetId: number, player: Player?, infoType: Enum.InfoType?)

Propose au joueur d'acheter l'asset, en passant par le bon flux d'achat selon son type.


ownsAssetAsync Server

CommandAPI.ownsAssetAsync(assetId: number, player: Player?): boolean

Indique si le joueur possède l'asset.


isTypeAsync Server

CommandAPI.isTypeAsync(assetId: number, assetType: Enum.AssetType | Enum.BundleType): (boolean, string?)

Vérifie que l'asset est du type donné. Renvoie true, ou false et la raison.


loadAssetCommand Server

CommandAPI.loadAssetCommand(assetType: Enum.AssetType, task: Task, assetId: number, callback: (item: Instance) -> ())

Vérifie que l'asset est du type donné et autorisé, l'insère, puis le passe à ton callback pour qu'il le place. C'est ce qui fait fonctionner ;gear.


getToolsInfoAsync Server

CommandAPI.getToolsInfoAsync(): (boolean, {ToolInfo} | string)

Renvoie true et le ToolInfo de chaque outil disponible pour ;give, ou false et une raison.


Utilitaires

getTargets Server

CommandAPI.getTargets(targetType: "All" | "Others" | "Nearby" | "OthersNearby", originPlayer: Player?, radius: number?): {Player}

Transforme un qualificatif en joueurs concernés à l'instant présent. "Nearby" et "OthersNearby" mesurent à partir du joueur d'origine, avec radius studs (50 par défaut).


setCameraSubject Client

CommandAPI.setCameraSubject(newSubject: Instance)

Dirige la caméra du joueur local vers un nouveau sujet, comme le Humanoid d'un autre joueur pour ;view.


runPromptCommand Server

CommandAPI.runPromptCommand(promptType: PromptType, task: Task, targets: {Player}, text: string, options: PromptOptions?)

Le moteur derrière ;message, ;hint et les invites similaires. Il filtre le texte, affiche l'invite à chaque cible et garde la tâche en vie jusqu'à ce que l'invite expire.


runEmoteId Server

CommandAPI.runEmoteId(task: Task, emoteId: number, speed: number?, looped: boolean?)

Joue l'animation d'emote sur la cible de la tâche, et l'arrête quand la tâche se termine.


createEmoteCommand Server

CommandAPI.createEmoteCommand(emoteName: string, emoteId: number, properties: {[string]: any}?): Command

Renvoie une commande d'emote complète, prête à être ajoutée à ton tableau de commandes. properties remplace n'importe quel champ de la commande générée.


createBundleCommand Server

CommandAPI.createBundleCommand(commandName: string, bundleId: number, properties: {[string]: any}?): Command

Le même comportement pour les commandes de bundle comme ;ratdance.


bindEmotePrompt Server

CommandAPI.bindEmotePrompt(task: Task, target: Player, emoteId: number, emoteName: string?, isLooped: boolean?)

Lie la carte d'action d'emote à la tâche, pour que la cible puisse mettre l'emote en favori ou la voir dans le catalogue.


openProfile Server

CommandAPI.openProfile(player: Player?, userId: number)

Ouvre pour le joueur la fenêtre de profil de l'utilisateur donné.


openPage Server

CommandAPI.openPage(player: Player?, pageId: string, tabLabel: string?)

Ouvre le panneau du joueur directement sur la page donnée, et si tu veux sur l'un de ses onglets.


openEmotes Server

CommandAPI.openEmotes(player: Player?)

Ouvre la fenêtre des emotes pour le joueur.


colourRoleName Shared

CommandAPI.colourRoleName(role): string

Le nom du rôle entouré de sa couleur, pour le texte enrichi.


isTableEmpty Shared

CommandAPI.isTableEmpty(tbl: {[any]: any}): boolean

Indique si la table n'a aucune entrée, y compris les entrées à clé que #tbl ne voit pas.


round Shared

CommandAPI.round(number: number, decimalPlaces: number?): number

Arrondit un nombre au nombre de décimales donné, ou à l'entier par défaut.


Types

Commands

type Commands = {Command}

Le tableau qu'un module de commandes renvoie.


Command

Une table de commande dans Commands (name, args, run, etc.). Custom Commands détaille chaque champ.


Task

L'objet de tâche passé à chaque fonction run, décrit en détail dans Task API.


ClientCommands

L'équivalent côté client de Commands, renvoyé par le module Client.


ClientCommand

Une table de commande côté client dans ClientCommands.


UserInfo

type UserInfo = {
    userId: number | string,
    userName: string,
    userImage: string,
    userDisplayName: string,
    userTopRole: {key: string, name: string, color: Color3}?,
}

userTopRole n'est présent que pour les joueurs de ce serveur.


ToolInfo

type ToolInfo = {
    name: string,
    textureId: string,
    tool: Tool?,
}

PromptType

type PromptType = "info" | "success" | "warn" | "error" | "message" | "hint" | "privateMessage" | "alert" | "vote" | "voteResults" | "action"

Les chaînes de type d'invite. Vois prompt pour ce que chacune affiche.


PromptOptions

La table d'options que prompt accepte, détaillée en entier sous prompt.


PromptHandle

Le handle que prompt renvoie, qui ferme l'invite plus tôt avec handle:Disconnect().