Zum Inhalt

Command API

Alles, worauf ein Befehl sicher zugreifen kann, steckt in CommandAPI:

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

Laden

loadCommands Server

CommandAPI.loadCommands(details): Commands

Damit laden, taggen und ändern die Paketmodule unter Config > Commands ihre Befehlssätze. Öffne eines der Pakete dort, um es in Aktion zu sehen.


Eingabeaufforderungen

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

Zeigt einen Hinweis, eine Nachricht oder eine Karte. Für Aktions-Eingabeaufforderungen mit Schaltflächen siehe bindPrompt.

Prompt-Typ Was angezeigt wird
"info" "success" "warn" "error" Ein Hinweis in der Seitenleiste mit Soundeffekt
"message" Eine Nachricht in der Bildschirmmitte, zum Beispiel in ;message verwendet
"hint" Eine kleine Leiste am oberen Bildschirmrand, zum Beispiel in ;hint verwendet
"privateMessage" Ein haftender Hinweis in der Seitenleiste, der beim Anklicken die vollständige Nachricht öffnet
"alert" Ein haftender Hinweis in der Seitenleiste, der einen Sound in Dauerschleife abspielt, bis er stummgeschaltet wird, und beim Anklicken die vollständige Nachricht öffnet
"action" Ein Hinweis in der Seitenleiste mit Schaltflächen und Steuerelementen. Erstelle sie mit task:bindPrompt
CommandAPI.prompt("success", task.caller, "Quest complete!", {duration = 5})

Sie gibt eine Verbindung zurück, die du mit connection:Disconnect() trennen kannst, um die Eingabeaufforderung zu beenden. Du kannst sie zum Beispiel dem Janitor einer Aufgabe hinzufügen, damit sie endet, sobald der Befehl endet:

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

Optionen

Alle sind optional und funktionieren bei jedem Prompt-Typ, sofern die Zeile nichts anderes sagt:

Option Typ Was sie macht
title string Die Überschrift über dem Text. privateMessage und alert setzen ihre eigene
duration number Sekunden, bis sich die Eingabeaufforderung selbst schließt. Lässt du sie weg, wird sie aus der Textlänge berechnet. 0 lässt sie auf dem Bildschirm, bis sie geschlossen oder getrennt wird
subtext string Eine kleinere Zeile unter dem Text
icon string Ein rbxassetid://-Bild, das das Symbol des Hinweises ersetzt
color Color3 Färbt den Text eines hint
dismissable boolean false blendet die Schließen-Schaltfläche aus, sodass nur duration oder das Handle sie entfernen kann
openPage string Ein Klick auf den Hinweis öffnet das Panel auf dieser Seite, zum Beispiel "Commands", "Roles", "Settings" oder "About"
openProfile boolean Ein Klick auf den Hinweis öffnet das eigene Profil des Spielers
openImage table {image = "rbxassetid://...", title = "Map", ratio = 16/9}. Ein Klick auf den Hinweis öffnet das Bild in der Bildschirmmitte
linkButtons table Kleine Schaltflächen am unteren Rand des Hinweises. {label = "Roles", page = "Roles"} öffnet eine Seite und {label = "Profile", profile = true} öffnet das Profil. Mit style = "Neutral" wird die Schaltfläche gedämpft dargestellt, und mit hideAfterPress = true schließt sich der Hinweis nach dem Drücken. Aus einem LocalScript über die Client-API führt {label = "Shop", onActivate = function() ... end, icon = "rbxassetid://..."} stattdessen deine eigene Funktion aus
roleBadges table Rollenabzeichen unter dem Titel, {{name = "Admin", color = Color3.fromRGB(255, 170, 0)}}
countdown number Zählt ab dieser Anzahl Sekunden live herunter, überall dort, wo %TIME% im Text steht
fromUserId number Zeigt Avatar, Name und höchste Rolle dieses Nutzers als Absender einer message, privateMessage oder alert
userText boolean Zeigt den Text genau so, wie er geschrieben wurde, ohne Rich-Text-Tags usw.
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)}},
})

Für Aktions-Eingabeaufforderungen mit Schaltflächen siehe bindPrompt.


Charakter

getHumanoid Shared

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

Der Humanoid des Spielers, oder nil, wenn sein Charakter nicht vorhanden ist.


getHRP Shared

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

Der HumanoidRootPart des Spielers, oder nil.


getHead Shared

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

Der Kopf des Spielers und sein Charakter, oder nil.


getNeck Shared

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

Das Nackengelenk des Spielers, oder nil. Funktioniert sowohl mit R6- als auch mit R15-Rigs.


getTorso Shared

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

Der Oberkörper des Spielers, oder nil. Funktioniert sowohl mit R6- als auch mit R15-Rigs.


loadCharacter Server

CommandAPI.loadCharacter(player: Player?)

Lässt den Charakter des Spielers neu spawnen. Nutze immer diese Funktion statt player:LoadCharacter(), damit die Aufgaben von HD Admin wissen, dass der Respawn gewollt war.


Spieler

getUserInfoAsync Shared

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

Gibt true und die UserInfo für jeden Nutzer zurück, auch für Offline-Nutzer, oder false und einen Grund. Ergebnisse werden zwischengespeichert, wiederholte Aufrufe kosten also nichts.


getNameFromUserIdAsync Shared

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

Gibt true und den Namen des Nutzers zurück, oder false und einen Grund. Funktioniert auch für Offline-Nutzer.


teleportAsync Server

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

Setzt den Charakter des Spielers auf das angegebene CFrame und lässt ihn vorher aufstehen, damit er seinen Sitz nicht mitzieht.


getAllowedTargets Server

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

Die Spieler, auf die ein Befehl wirken darf. Standardmäßig sind das alle im Server abzüglich derer, die in ihren You Settings Block commands aktiviert haben.


unequipTools Server

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

Legt das ausgerüstete Werkzeug des Spielers zurück in sein Inventar.


Aufgaben

getTasks Shared

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

Gibt die laufenden Aufgaben zurück, optional nach Befehl und Ziel gefiltert. Das sind dieselben Aufgabenobjekte, die die Task API beschreibt.


getTasksByCallerId Shared

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

Jede laufende Aufgabe, die vom angegebenen Aufrufer gestartet wurde.


Chat

systemMessage Shared

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

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

Sendet eine Systemnachricht in den Chat des Spielers.


checkTextLimit Server

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

HD Admin begrenzt das Senden nachrichtenbezogener Funktionen wegen der Altersschutzrichtlinien von Roblox. Damit kannst du diese Abklingzeit abfragen.

Sie gibt true zurück, wenn Text angezeigt werden darf, sonst false mit der verbleibenden Abklingzeit.

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,
Art Gemeinsam genutzt von
"Message" Nachrichten, Hints, Hinweise, Alerts, private Nachrichten und Umfragen
"SurfaceText" Namen, Titel, Teamnamen und Statistiken
"ChatText" Chat-Tags und Chat-Namen
"Reason" Kick- und Bann-Gründe

forceBubbleChat Shared

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

Zeigt eine Sprechblase über dem Charakter des Spielers oder über jedem Modell oder Teil, das du stattdessen übergibst.


Outfits

getDescription Server

CommandAPI.getDescription(humanoid: Humanoid): HumanoidDescription

Die aktuelle HumanoidDescription des Humanoids.


applyDescription Server

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

Wendet die HumanoidDescription sicher an und versucht es erneut, wenn Roblox den ersten Versuch ablehnt. Übergib properties, um Felder auf der Basisbeschreibung anzupassen.


outfitBuff Server

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

Wendet HumanoidDescription-Eigenschaften als Buff an, der sich selbst zurücknimmt, wenn die Aufgabe endet. So räumen Befehle wie ;wormify von allein auf.


setFakeBodyParts Server

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

Tauscht Körperteile gegen vom Befehl erzeugte Platzhalter aus und gibt eine Funktion zurück, die die Originale wiederherstellt.


clearFakeBodyParts Server

CommandAPI.clearFakeBodyParts(character: Model)

Entfernt diese Platzhalter wieder.


runBundleId Server

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

Zieht dem Ziel der Aufgabe ein Katalog-Bundle an und stellt sein eigenes Outfit wieder her, wenn die Aufgabe endet.


Assets

registerSound Shared

CommandAPI.registerSound(sound: Sound)

Nötig für jeden Sound, den dein Befehl erstellt, damit die Lautstärke- und Tonhöhen-Einstellungen des Spiels darauf wirken.


setAnchored Shared

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

Verankert oder löst jedes Teil unter der Instanz.


setTransparency Shared

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

Blendet jedes Teil unter der Instanz aus.


promptPurchaseAsync Server

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

Fordert den Spieler zum Kauf des Assets auf und wählt dafür den passenden Kaufablauf für seinen Typ.


ownsAssetAsync Server

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

Ob der Spieler das Asset besitzt.


isTypeAsync Server

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

Prüft, ob das Asset den angegebenen Typ hat. Gibt true zurück, oder false und den Grund.


loadAssetCommand Server

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

Prüft, ob das Asset den angegebenen Typ hat und erlaubt ist, fügt es ein und übergibt es dann an deinen Callback, der es platziert. Das steckt hinter ;gear.


getToolsInfoAsync Server

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

Gibt true und die ToolInfo jedes Werkzeugs zurück, das für ;give verfügbar ist, oder false und einen Grund.


Hilfsfunktionen

getTargets Server

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

Löst einen Qualifizierer in die Spieler auf, die er gerade abdeckt. "Nearby" und "OthersNearby" messen vom Ursprungsspieler aus mit radius Studs (standardmäßig 50).


setCameraSubject Client

CommandAPI.setCameraSubject(newSubject: Instance)

Richtet die Kamera des lokalen Spielers auf ein neues Subjekt, etwa den Humanoid eines anderen Spielers für ;view.


runPromptCommand Server

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

Die Grundlage hinter ;message, ;hint und ähnlichen Eingabeaufforderungen. Sie filtert den Text, zeigt die Eingabeaufforderung jedem Ziel und hält die Aufgabe am Leben, bis die Eingabeaufforderung abläuft.


runEmoteId Server

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

Spielt die Emote-Animation beim Ziel der Aufgabe ab und beendet sie, wenn die Aufgabe endet.


createEmoteCommand Server

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

Gibt einen fertigen Emote-Befehl zurück, den du direkt in dein Befehls-Array einfügen kannst. Mit properties überschreibst du jedes Feld des erzeugten Befehls.


createBundleCommand Server

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

Dasselbe Verhalten für Bundle-Befehle wie ;ratdance.


bindEmotePrompt Server

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

Bindet die Emote-Aktionskarte an die Aufgabe, damit das Ziel das Emote favorisieren oder im Katalog ansehen kann.


openProfile Server

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

Öffnet für den Spieler das Profil-Popup des angegebenen Nutzers.


openPage Server

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

Öffnet das Panel des Spielers direkt auf der angegebenen Seite, optional auf einem ihrer Tabs.


openEmotes Server

CommandAPI.openEmotes(player: Player?)

Öffnet das Emote-Popup für den Spieler.


colourRoleName Shared

CommandAPI.colourRoleName(role): string

Der Name der Rolle, in ihre Farbe gehüllt, für Rich Text.


isTableEmpty Shared

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

Ob die Tabelle überhaupt keine Einträge hat, auch keine mit Schlüssel, die #tbl übersieht.


round Shared

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

Rundet eine Zahl auf die angegebenen Dezimalstellen, standardmäßig auf eine ganze Zahl.


Typen

Commands

type Commands = {Command}

Das Array, das ein Befehlsmodul zurückgibt.


Command

Eine Befehlstabelle innerhalb von Commands (name, args, run und so weiter). Custom Commands behandelt jedes Feld.


Task

Das Aufgabenobjekt, das an jede run-Funktion übergeben wird. Die Task API behandelt es vollständig.


ClientCommands

Das Gegenstück zu Commands für die Client-Seite, zurückgegeben vom Client-Modul.


ClientCommand

Eine Befehlstabelle der Client-Seite innerhalb von ClientCommands.


UserInfo

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

userTopRole ist nur für Spieler in diesem Server vorhanden.


ToolInfo

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

PromptType

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

Die Prompt-Typ-Strings. Was jeder anzeigt, steht unter prompt.


PromptOptions

Die Optionstabelle, die prompt akzeptiert, vollständig aufgelistet unter prompt.


PromptHandle

Das Handle, das prompt zurückgibt. Mit handle:Disconnect() schließt es die Eingabeaufforderung vorzeitig.