Comandi di amministratore

Un comando admin è 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 utilizza moduli di chat, che consente una facile implementazione di comandi di amministratore sul sistema di chat legacy.I moduli di chat ascoltano i messaggi in arrivo sul server e possono eseguire azioni in base a qualsiasi criterio desiderato.

Configurazione

Ogni volta che un luogo Roblox si carica controlla se il servizio Chat è vuoto.Se non trova i componenti di cui ha bisogno, il luogo inserirà l'ultima versione di tali componenti.Questo significa che la sovrascrizione o l'apporto di modifiche a questi componenti in un'esperienza li impedirà di essere aggiornati.

Il primo passo per configurare la libreria dei comandi di amministrazione è aggiungere un nuovo modulo di chat al servizio di chat.La libreria in questo tutorial si occupa del sollevamento pesante eseguito da un modulo di chat quindi l'unico oggetto che devi aggiungere al servizio di chat è un nuovo ModuleScript .Il nome dello script del tuo modulo può essere qualsiasi cosa, ma suggerisco qualcosa di intuitivo come AdminCommands .

Implementa nuovi comandi

Piuttosto che implementare la maggior parte della logica del modulo di chat, richiederai semplicemente il modulo della libreria che esegue la maggior parte del lavoro e aggiunge funzionalità extra.Il modo più semplice per aggiungere la libreria nel tuo modulo è richiederla per il suo assetId in cima alla tua script.

local AdminCommands = require(1163352238)

Questo modulo restituisce una tabella di funzioni, con la funzione Run come la più importante.La biblioteca ha una funzione Run per il suo modulo Chat.È importante che AdminCommands restituisca questa funzione Run al servizio di chat.La funzione è indicizzata dal suo nome, Run , e puoi restituire quanto segue come se Run fosse una proprietà della rappresentazione della tabella dei comandi di amministrazione:

return AdminCommands.Run

Tra queste due linee di codice, implementa i tuoi comandi e qualsiasi funzione ausiliaria necessaria.

Per legare una funzione alla libreria, usa la funzione BindCommand di AdminCommands.Quando leghi un comando dovrai specificare un elenco di parole chiave che, quando pronunciate, attiveranno il comando, la funzione che verrà attivata, un livello di priorità e, opzionalmente, una descrizione del comando.Se non specifici un livello di privilegio, prenderà per impostazione predefinita 0.I livelli di priorità sono valori numerici utilizzati dalla libreria AdminCommands per assegnare una gerarchia di permessi tra gli utenti con livelli di privilegio corrispondenti.Durante l'esecuzione di un comando, il relatore deve avere un livello di privilegio maggiore o uguale a quello del comando Permission Library.

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

Per dislegare ti verrebbe utilizzare inoltre UnbindCommand e specificare una parola chiave da dislegare.

AdminCommands:UnbindCommand({"keyword1"})

In generale, il contenuto dello script dei comandi dell'amministratore dovrebbe assomigliare al Seguendo:

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

function commandFunction(commandData)
	-- Codice di comando qui
	-- Restituisce vero se riuscito 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 tutte le funzioni di comando dell'amministratore legate quando eseguite dalla libreria.La tabella contiene informazioni utili sul comando che è stato pronunciato e sull'utente che lo ha pronunciato.Ha i seguenti campi:

• Altoparlante: ChatSpeaker
• Messaggio: string
• Nome del canale: string
• Comando: string

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

| Funzione | Parametri | Ritorno | | --------------- | ------------------------------------------------------------------------------------------------ | ------ | | Comandi: | | | | BindCommand() | table functionIDs, function functionToExecute, number minimumPermissionLevel, string description | bool | | UnbindCommand() | table functionIDs | bool | | Get)((() | GetCommands() | | table |

Utilità

La libreria ha già alcune funzioni ausiliarie integrate chiamate Utilities che puoi utilizzare.Memorizza AdminCommand.Utilities in una variabile o fai riferimento direttamente.

local Utilities = AdminCommands.Utilities

Le funzioni di utilità attuali sono:

| Funzione | Parametri | Ritorno | | -------------------------- | -------------------------------------------------- | ------ | | Messaggi della finestra di chat: | | | | SendSystemMessage() | table commandData, string content, table extraData | bool | | SendSystemSuccessMessage() | table commandData, string content | bool | | SendSystemWarningMessage() | table commandData, string content | bool | | Gestori di errori: | | | | NoPlayerSpecified() | table commandData | bool | | IncorrectValueType() | table commandData, string given, string expected | | | Conversione dei dati: | | | | ToTupple(parameter) | string parameter | array | | ToBoolean() | string parameter | bool | | ValidateData() | string expectedType, ...| bool |

Comandi di esempio

Un comando utile da avere sarebbe quello che stampa una lista di tutti i comandi opzionali a disposizione degli utenti.Questo comando esegue ogni comando legato alla libreria e alcune delle sue proprietà.

-- Stampa una lista di tutti i comandi legati

function listCommand(commandData)

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

	-- Itera attraverso ogni comando e stampalo

	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 dare loro scintille.Questo comando richiede un parametro quando viene pronunciato - il nome dell'utente target.Se l'utente esiste, il comando creerà un oggetto Sparkles nel HumanoidRootPart di quell'utente.

-- Dà scintille al personaggio di un Giocatorespecificato
function sparklesCommand(commandData)
	 -- Errore se non vengono forniti/spiegati parametri
	if #commandData.Parameters == 0 then
		return Utilities:NoPlayerSpecified(commandData)
	end
	-- Loop attraverso i parametri (eseguire sul nome di ogni Giocatoredato)
	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 riferirsi a se stesso

		-- Usa una funzione ausiliaria per trovare il personaggio del Giocatoree aggiungere gli scintillii
		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 Tutorialedi Creazione di 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/spiegati 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 riferirsi a se stesso

		-- Usa una funzione ausiliaria 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 dei permessi

Se un non amministratore tenta di parlare un comando come questo, che ha un livello di autorizzazione superiore a 0, non verrà attivato.Il sistema di comando utilizza una libreria di autorizzazione separata, a cui viene automaticamente assegnato al creatore dell'esperienza il livello di autorizzazione math.huge.Gli amministratori possono essere aggiunti utilizzando le seguenti funzioni sul oggetto modulo AdminCommands:

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

| Funzione | Parametri | Ritorno | | ---------------------------- | ---------------------------------------------------------------------------------- | ------ | | Permesso | | | | GetAdmins() | | tabella | | SetUserPermission() | numero richiedenteUUID, numero targetUUID, livello di autorizzazione | bool | | GetUserPermission() | numero userId | numero | | GetGroups() | | tabella | | SetGroupRankPermission() | numero richiedenteUUID, numero targetGroupId, numero targetRankId, livello di autorizzazione | bool | | GetGroupRankPermission() | targetGroupId, targetRankId | int |

Modulo di avvio rapido

Per una configurazione più semplice puoi anche utilizzare questo Avvio rapido, che è un modulo che ha già implementato la libreria dei comandi dell'amministratore.Il modello è un modulo con lo stesso formato come descritto sopra.Inoltre, il modulo ha alcuni comandi già inclusi in modo che non devi riimplementarli.

| Comando/legame | Parametro parlato | | -------------------------------- | -------------------------------- | | "list", "commands" | nome utente | | "sparkles" | nome utente | | "sparkles" | nome utente | | "unforcefield", "unff" | nome utente | | "explode" | nome utente | | "part" | Path (cioè)esperienza.Area di lavoro) | | "freeze" | username | | "unfreeze" | username | | "aggiungere or Inserire" | username | | "Rimuovere" | username | | "Cacciato, Espulso" | username | | "setuserpermission", "sup" | userId, permission | | "setgrouprankpermission", "sgrp" | groupid, rankId, permission |