Comandos de Admin

Um comando de administrador é uma palavra-chave ou frase que um usuário com um determinado nível de controle pode digitar na janela de chat para iniciar uma ação. Essa biblioteca usa módulos de chat, o que permite uma implementação fácil de comandos de administrador no topo do sistema de chat legado. Módulos de chat ouvão mensagens entrantes no servidor e podem executar ações com base em quaisquer critérios desejados.

Configuração

Quando um local do Roblox carrega, ele verifica se o serviço de Chat está vazio. Se ele não encontrar os componentes que precisa, o local irá inserir a versão mais recente desses componentes. Isso significa que sobrescrever ou fazer alterações nesses componentes em uma experiência impedirá que eles sejam atualizados.

O primeiro passo para configurar a biblioteca de comandos de admin é adicionar um novo módulo de chat ao serviço de chat. A biblioteca neste tutorial cuida do trabalho pesado feito por um módulo de chat, então o único objeto que você precisa adicionar ao serviço de chat é um novo ModuleScript . O nome do seu script de módulo pode ser qualquer coisa, mas eu sugiro algo intuitivo como AdminCommands

implementando novos comandos

Ao invés de implementar a maioria da lógica do Chat Module, você simplesmente precisará do módulo de biblioteca que faz um monte de trabalho e adiciona funcionalidades extras. A maneira mais simples de adicionar a biblioteca ao seu módulo é requerê-la pelo seu id de ativo na parte superior do seu script.

local AdminCommands = require(1163352238)

Este Módulo retorna uma tabela de funções, com a função Run como a mais importante. A biblioteca possui uma função Run para o seu módulo de Chat. É importante que AdminCommands retorne esta função Run para o módulo de Chat. A função é indexada por seu nome, 2>Run2>, e você

return AdminCommands.Run

Entre essas duas linhas de código, implemente seus próprios comandos e quaisquer funções de auxílio necessárias.

Para vincular uma função à biblioteca, use a função BindCommand de AdminCommands. Ao vincular um comando, você precisará especificar uma tabela de chaves que

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

Para desvincular você também usaria UnbindCommand e especificaria uma palavra-chave para desvincular.

AdminCommands:UnbindCommand({"keyword1"})

No geral, o conteúdo do seu script AdminCommands deve parecer com o seguindo:

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

function commandFunction(commandData)
	-- Código de comando aqui
	-- Retorna verdadeiro se tiver sucesso e falso caso contrário
end

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

return AdminCommands.Run

Você pode notar que a função de exemplo leva um parâmetro chamado commandData. Este parâmetro é um argumento de tabela passado para todos os comandos de admin vinculados quando executados pela biblioteca. A tabela contém informações úteis sobre o comando que foi dito e o usuário que falou. Ela tem os seguintes campos:

• Orador: ChatSpeaker
• Mensagem: string
• ChannelName: string / cadeia / texto
• Comando: string

É importante sempre esperar commandData como um parâmetro de funções de comando. Por exemplo, se você tiver um comando chamado "explode", que requer um parâmetro de Player para ser especificado, a função pareceria com explode(comandoData, usuário).

| Função | Parâmetros | Retornar | | | | | | Return | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | | |

Utilidades

A biblioteca já tem algumas funções de utilidade incorporadas chamadas Utilities que você pode usar. Armazenar AdminCommand.Utilities em uma variável ou referência direta.

local Utilities = AdminCommands.Utilities

As funções atuais da utilidade são:

| Função | Paramet

Exemplos de Comandos

Um comando útil para ter seria um que imprime uma lista de todos os comandos opcionais que os usuários têm disponíveis. Este comando sai em cada comando vinculado à biblioteca e algumas de suas propriedades.

-- Imprime uma lista de todos os comandos vinculados

function listCommand(commandData)

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

	-- Iterar através de cada comando e imprimir

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

Outro comando útil permite que os usuários se dêem brilhos. Este comando requer um parâmetro quando falado – o nome do usuário alvo. Se o usuário existir, o comando criará um objeto de Sparkles na HumanoidRootPart do usuário.

-- Dá brilhos de personagem de um jogador específico
function sparklesCommand(commandData)
	 -- Erro se nenhum parâmetro for dado/dito
	if #commandData.Parameters == 0 then
		return Utilities:NoPlayerSpecified(commandData)
	end
	-- Loop através dos parâmetros (Execute em cada nome dado a cada jogador)
	for index = 1, #commandData.Parameters do
		local parameter = commandData.Parameters[index]
		if (parameter == "me" or parameter == "") then parameter = commandData.Speaker.Name end -- Se o parâmetro for eu, então o usuário deve estar se referindo a si mesmo

		-- Use uma função de auxiliar para encontrar o personagem do jogador e adicionar os brilhos
		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")

Você também pode incluir um comando de explosão no TutorialCriar um Comando de Administrador. Este comando também leva o nome de um usuário como um parâmetro.

-- Verifica se o modelo dado é um Personagem e adiciona uma explosão à 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

-- Faz o personagem de um jogador específico explodir
function explodeCommand(commandData)
	 -- Erro se nenhum parâmetro for dado/dito
	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 o parâmetro for eu, então o usuário deve estar se referindo a si mesmo

		-- Use uma função de auxiliar para encontrar o personagem do jogador e adicionar a explosão
		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 de Permissões

Se um não-admin tentar falar um comando como este, que tem um nível de permissão maior que 0, ele não será acionado. O sistema de comando usa uma biblioteca de permissão separada, à qual o criador de experiência é automaticamente dado o nível de permissão math.huge. Os administradores podem ser adicionados usando as seguintes funções em seu ObjetoAdminCommands module:

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

| Função | Parâmetros | Retornar | | ---------------- |

Módulo de Intialização Rápida

Para um setup mais fácil, você também pode usar este Início Rápido, que é um módulo que já implementou a biblioteca de Comandos de Admin. O modelo é um módulo com o mesmo formato descrito acima. Além disso, o módulo tem alguns comandos já incluídos para que você não precise re-Implementar.

| Comando/Vinculação | Parâmetro Fal