Commandi dell'Admin

Un comando amministratore è una parola chiave o una frase che un utente con un certo livello di controllo può digitare nella finestra di chat per attivare un'azione. Questa libreria usa moduli di chat, che consente un'integrazione facile dei comandi amministratore sul top della sistema di chat legacy. I moduli di chat ascoltano i messaggi in arrivo sul server e possono eseguire azioni in base a quali criteri sono desiderati.

Configurazione

Quando un luogo Roblox carica, controlla se il servizio Chat è vuoto. Se non trova i componenti di cui ha bisogno, il luogo inserisce la versione più recente di questi componenti. Ciò significa che l' sovrascrizione o le modifiche apportate a questi componenti in un'esperienza li impedirà di essere aggiornati.

Il primo passo per configurare la libreria dei comandi amministratori è aggiungere un nuovo modulo di chat al servizio chat. La libreria in questo tutorial si prende cura del pesante lavoro svolto da un modulo di chat, quindi l'unico oggetto che devi aggiungere al servizio chat è un nuovo ModuleScript . Il nome del tuo script del modulo può essere qualsiasi cosa, ma consiglio qualcosa di intuitivo come

Realizzazione di nuovi comandi

Invece di implementare la maggior parte della logica del modulo di chat, dovrai semplicemente richiedere il modulo di library che esegue un gran parte del lavoro e aggiunge funzionalità extra.Il modo più semplice per aggiungere la library nel tuo modulo è richiederla per il suo assetId nella parte superiore dello script.

local AdminCommands = require(1163352238)

Questo modulo restituisce una tabella di funzioni, con la funzione Run come la più importante. La libreria ha una funzione Run per il suo modulo di chat. È importante che AdminCommands restituisca questa funzione Run al servizio chat. La funzione è indizzata dal suo nome, 2>Run2>, e puoi restitu

return AdminCommands.Run

Tra queste due righe di codice, implementa i tuoi comandi e le funzioni di aiuto necessarie.

Per associare una funzione alla library, usa la funzione AdminCommands di AdminCommands. Quando si lega una funzione, si dovrà specificare una tabella di chiavi che, quando viene parlata, att

AdminCommands:BindCommand({"keyword1", "keyword2"}, commandName, 1, "Optional description")

Per disbinarti, userebbe inoltre UnbindCommand e specificare una parola chiave per disbinare.

AdminCommands:UnbindCommand({"keyword1"})

In generale, il contenuto del tuo script AdminCommands dovrebbe assomigliare al Seguendo:

local AdminCommands = require(1163352238)
local Utilities = AdminCommands.Utilities

function commandFunction(commandData)
	-- Comando qui
	-- Restituisce vero se di successo e falso altrimenti
end

AdminCommands:BindCommand({"keyword1", "keyword2"}, commandFunction, 1, "Optional description")

return AdminCommands.Run

Potresti notare che la funzione di esempio prende un parametro chiamato commandData . Questo parametro è un argomento di tabella passato a tutti i comandi di amministratore legati quando eseguito dalla libreria. Il tabello contiene informazioni utili sul comando che è stato parlato e l'utente che l'ha parlato. Ha i seguenti campi:

• Speaker: ChatSpeaker
• Messaggio: string
• ChannelName: string
• Comando: string

È importante sempre aspettarsi commandData come parametro delle funzioni di comando. Ad esempio, se hai un comando chiamato "explode", che richiede un Player parametro per essere specificato, la funzione avrebbe l'aspetto di eseguire(comandoData, utente).

| Funzione | Paranti | Ritorno | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |

Utilità

La libreria ha già alcune funzioni di sistema chiamate Utilities che puoi utilizzare. Store AdminCommand.Utilities in a variable o reference it directly.

local Utilities = AdminCommands.Utilities

Le funzioni dell'utilità attuali sono:

| Funzione | Paramet

Esempi di comandi

Un comando utile da avere sarebbe quello di stampare una lista di tutti i comandi opzionali che gli utenti hanno disponibili. Questo comando esegue ognuno dei comandi legati alla libreria e a alcune delle sue proprietà.

-- Stampa un elenco di tutti i comandi legati

function listCommand(commandData)

	Utilities:SendSystemMessage(commandData, "The following commands are available:")

	-- iterate attraverso ogni comando e stampatelo

	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.")

Un altro comando utile consente agli utenti di darsi luci. Questo comando richiede un parametro quando viene eseguito – il nome dell'utente target. Se l'utente esiste, il comando creerà un oggetto Sparkles nell'area di radice umanoide.

-- Dà luci al personaggio di un Giocatorespecificato
function sparklesCommand(commandData)
	 -- Errore se non vengono forniti/detti parametri
	if #commandData.Parameters == 0 then
		return Utilities:NoPlayerSpecified(commandData)
	end
	-- Loop attraverso i parametri (eseguire su ogni nome dato al Giocatore)
	for index = 1, #commandData.Parameters do
		local parameter = commandData.Parameters[index]
		if (parameter == "me" or parameter == "") then parameter = commandData.Speaker.Name end -- Se il parametro è me allora l'utente deve fare riferimento a se stesso

		-- Usa una funzione di aiuto per trovare il personaggio del Giocatoree aggiungere gli sparkles
		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")

Puoi anche includere un comando di esplosione dal TutorialeCreato un comando amministratore . Questo comando prende anche il nome di un utente come parametro.

-- Verifica che il modello fornito sia un Personaggio e aggiunge un'esplosione alla sua HumanoidRootPart
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

-- Fa esplodere il personaggio di un Giocatorespecificato
function explodeCommand(commandData)
	 -- Errore se non vengono forniti/detti parametri
	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 -- Se il parametro è me allora l'utente deve fare riferimento a se stesso

		-- Usa una funzione di aiuto per trovare il personaggio del Giocatoree aggiungere l'esplosione
		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.")

Biblioteca autorizzazioni

Se un non amministratore tenta di eseguire un comando come questo, che ha un livello di autorizzazione più elevato di 0, non verrà attivato. Il sistema di comandi utilizza una libreria di autorizzazione separata, a cui viene automaticamente concesso il livello di matematica.huge. Gli amministratori possono essere aggiunti utilizzando le seguenti funzioni sul tuo oggetto modulo AdminCommands :

SetUserPermission(number requesterUserId, number targetUserId, permissionLevel) -> bool
SetGroupRankPermission(number requesterUserId, number targetGroupId, number targetRankId, permissionLevel) -> bool

| Funzione | Parametri | Ritorno | | ---------------- |

Modulo di avvio rapido

Per un facile setup puoi anche usare questo Quick Start, che è un modulo che ha già implementato la libreria dei comandi amministratore. Il modulo è un modulo con lo stesso formato descritti sopra. Inoltre, il modulo ha alcuni comandi già inclusi in modo che tu non debba reiniziare.

| Comando/Bind | Spoken Parameter | |