Comandos de administrador

*Este conteúdo é traduzido por IA (Beta) e pode conter erros. Para ver a página em inglês, clique aqui.

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

Configuração

Sempre que um local do Roblox é carregado, verifica se o serviço de Chat está vazio.Se não encontrar os componentes de que precisa, o local inserirá a versão mais recente desses componentes.Isso significa que substituir ou fazer alterações nesses componentes em uma experiência os impedirá de serem atualizados.

O primeiro passo para configurar a biblioteca de comandos de administração é adicionar um novo módulo de Chat ao serviço de Chat.A biblioteca neste tutorial cuida do levantamento 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 sugiro algo intuitivo como AdminCommands .

Implementar novos comandos

Em vez de implementar a maior parte da lógica do Módulo de Chat, você simplesmente precisará do módulo de biblioteca que faz a maior parte do trabalho e adiciona funcionalidades extras.A maneira mais simples de adicionar a biblioteca ao seu módulo é exigir seu assetId 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 tem uma função Run para o módulo de Chat.É importante que os comandos de administrador retornem essa função Run ao Serviço de Chat.A função é indexada pelo seu nome, Run , e você pode retornar o seguinte como se Run fosse uma propriedade da representação da tabela de comandos de administrador:

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 da AdminCommands.Ao vincular um comando, você precisará especificar uma tabela de palavras-chave que, quando falada, disparará o comando, a função que será disparada, um nível de prioridade e, opcionalmente, uma descrição do comando.Se você não especificar um nível de privilégio, ele padronizará para 0.Níveis de prioridade são valores numéricos usados pela biblioteca AdminCommands para atribuir uma hierarquia de permissões entre usuários com níveis correspondentes de privilégios concedidos.Ao executar um comando, o orador deve ter um nível de privilégio maior ou igual ao do comando Biblioteca de Permissões.

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 de comandos de administrador deve parecer o seguindo:

local AdminCommands = require(1163352238)

local Utilities = AdminCommands.Utilities



function commandFunction(commandData)

	-- Código de comando aqui

	-- Retorna verdadeiro se for bem-sucedido 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 toma um parâmetro chamado commandData .Este parâmetro é um argumento de tabela passado para todas as funções de comando de administrador vinculadas quando executadas pela biblioteca.A tabela contém informações úteis sobre o comando que foi falado e o usuário que o falou.Ela tem os seguintes campos:

  • Palestrante: ChatSpeaker
  • Mensagem: string
  • Nome do Canal: string
  • 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 Player para ser especificado, a função pareceria explosão(commandData, usuário).

| Função | Parâmetros | Retorno | | --------------- | ------------------------------------------------------------------------------------------------ | ------ | | Comandos: | | | | BindCommand() | table functionIDs, function functionToExecute, number minimumPermissionLevel, string description | bool | | UnbindCommand() | table functionIDs | bool | | Obter comandos() | | table |

Utilidades

A biblioteca já tem algumas funções de auxílio integradas chamadas Utilidades que você pode usar.Armazenar Comando de Administração de Comando.Utilidades em uma variável ou referenciá-lo diretamente.

local Utilities = AdminCommands.Utilities

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

| Função | Parâmetros | Retorno | | -------------------------- | -------------------------------------------------- | ------ | | Mensagens da janela de bate-papo: | | | | EnviarSystemMessage() | table commandData, string content, table extraData | bool | | EnviarSystemSuccessMessage() | table commandData, string content | bool | | EnviarSystemWarningMessage() | table commandData, string content | bool | | IncorrectValueType() | table commandData, string given, string expected | | | Erros de conversão de dados: | | | | ToTupple(parameter) | string parameter | array | | ToBoolean() | string parameter | bool | | ValidarDados() | string expectedType, ...| bool |

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 exibe cada comando vinculado à biblioteca e algumas de suas propriedades.

-- Imprime uma lista de todos os comandos ligados



function listCommand(commandData)



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



	-- Iterar através de cada comando e imprimi-lo



	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 Sparkles no HumanoidRootPart desse usuário.

-- Dá brilhos de personagem de um jogador especificado

function sparklesCommand(commandData)

	 -- Erro se nenhum parâmetro for dado/falado

	if #commandData.Parameters == 0 then

		return Utilities:NoPlayerSpecified(commandData)

	end

	-- Loop através dos parâmetros (executar no nome de cada jogador dado)

	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 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 do TutorialCriar um Comando de Administração. Este comando também toma o nome de um usuário como um parâmetro.

-- Verifica que o modelo dado é um Personagem e adiciona uma explosão à sua Raiz Humanoide

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 especificado explodir

function explodeCommand(commandData)

	 -- Erro se nenhum parâmetro for dado/falado

	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 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 administrador 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, para a qual o criador da experiência é automaticamente dado o nível de permissão math.huge.Administradores podem ser adicionados usando as seguintes funções no Objetodo módulo AdminCommands:

SetUserPermission(number requesterUserId, number targetUserId, permissionLevel) -> bool

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

| Função | Parâmetros | Retorno | | ---------------------------- | ---------------------------------------------------------------------------------- | ------ | | Permissão | | | | GetAdmins() | | tabela | | SetUserPermission() | número requerente de usuário, número de grupo alvo, nível de permissão | bool | | GetUserPermission() | número de usuário | número | | GetGroups() | | tabela | | SetGroupRankPermission() | número requerente de usuário, número de grupo alvo, nível de permissão | bool | | GetGroupRankPermission() | targetGroupId, targetRankId | int | | GetUserGroupRankPermission() | número userId | int |

Módulo de início rápido

Para configuração 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 Administrador.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 reimplementar.

| Comando/binding | Parâmetro falado | | -------------------------------- | -------------------------------- | | "list", "commands" | usuário | | "sparkles" | usuário | | "sparkles" | usuário | | "unforcefield", "unff" | usuário | | "explode" | usuário | | "part" | Caminho (ou seja,experiência.Workspace) | | "freeze" | nome de usuário | | "unfreeze" | nome de usuário | | "adicionar" | nome de usuário | | "remover" | nome de usuário | | "expulsar" | nome de usuário | | "setuserpermission", "sup" | identidade, permissão | | "setgrouprankpermission", "sgrp" | grupo, rankId, permissão |