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 um certo nível de controle pode digitar na janela de bate-papo para desencadear uma ação. Esta biblioteca usa módulos de bate-papo, o que permite a fácil implementação de comandos de administrador em cima do sistema de bate-papo legado. Os módulos de bate-papo ouvem mensagens recebidas no servidor e podem realizar ações com base em qualquer critério desejado.

Configurar

Sempre que um lugar do Roblox carrega, ele verifica se o serviço de bate-papo está vazio. Se não encontrar os componentes necessários, o lugar irá 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 na configuração da biblioteca de comandos de administrador é adicionar um novo módulo de bate-papo ao serviço de bate-papo. A biblioteca neste tutorial lida com o levantamento pesado feito por um módulo de bate-papo, então o único objeto que você precisa adicionar ao serviço de bate-papo é um novo ModuleScript . O nome do script do seu módulo pode ser qualquer coisa, mas eu sugiro algo intuitivo como AdminCommands .

Implementando 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 funcionalidade extra. A maneira mais simples de adicionar a biblioteca ao seu módulo é exigi-la pelo seu assetId na parte superior do seu script.

local AdminCommands = require(1163352238)

Este Módulo retorna uma tabela de funções, sendo a função Run a mais importante. A biblioteca tem uma função Run para seu módulo de Chat. É importante que o AdminCommands devolva esta 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 nossa representação da tabela AdminCommands:

return AdminCommands.Run

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

Para ligar uma função à biblioteca, use a função BindCommand de AdminCommands . Ao ligar um comando, você precisará especificar uma tabela de palavras-chave que, quando falado, acionará o comando, a função que será acionada, um nível de prioridade e, opcionalmente, uma descrição do comando. Se você não especificar um nível de privilégio, será padrão em 0. Os 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égio concedido. Ao realizar um comando, o orador deve ter um nível de privilégio maior ou igual ao do comando Permission Library.

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

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

AdminCommands:UnbindCommand({"keyword1"})

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

local AdminCommands = require(1163352238)

local Utilities = AdminCommands.Utilities



function commandFunction(commandData)

	-- Código de comando aqui

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

  • Palestrante: ChatSpeaker
  • string / cadeia / texto: string
  • Nome do Canal: string
  • Comando: string

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

| Função | Parâmetros | Retorno | | --------------- | ---------------------------------- | | Comandos: | | | | BindCommand () | functionIDs da função, functionToExecute, número mínimoPermissionLevel, descrição da string | bool | | UnbindCommand () | table functionIDs | bool | | GetCommands () | | table |

Utilidades

A biblioteca já tem algumas funções de ajudante built-in chamadas Utilities que você pode usar. Armazene AdminCommand.Utilities em uma variável ou faça referência a ela diretamente.

local Utilities = AdminCommands.Utilities

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

| Função | Parâmetros | Retornar | | ------------------ | ------------------ | | Mensagens da janela de bate-papo: | | | | SendSystemMessage () | dados do comando da tabela, conteúdo da string, tabela extraData | bool | | SendSystemSuccessMessage () | dados do comando da tabela, conteúdo da string | bool | | SendSystemWarningMessage () | dados do comando da tabela, conteúdo da string | bool | | SendSystemErrorMessage () | dados do comando da tabela, conteúdo da string | bool | | | manipuladores de erro: | | | | | NoPlayerSpecified () | dados do comando da tabela | bool | NotEnoughSpecified () | dados do comando da tabela | bool | | IncorrectValueType () | dados do comando da tabela, string dada, string esperado | |

Comandos de exemplo

Um comando útil a 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 ligado à 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 todos os comandos e imprimi-los



	for id, command in PublicAPI:GetCommands() do



		Utilities:SendSystemMessage(commandData, string.format("'/s' requires permission s.", 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 o nome do usuário alvo é falado. Se o usuário existir, o comando criará um objeto Brilhos na parte de Raiz Humanoide desse usuário.

-- Dá brilhos ao 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 (corrida no nome de 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 ajudante 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("'s' 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 TutorialCriado um Comando de Administrador. Este comando também leva o nome de um usuário como parâmetro.

-- Verifica que o modelo dado é um personagem e adiciona uma explosão à sua parte de raiz de 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 com que o personagem de um jogador especificado exploda

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 de ajudante 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("'s' 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 comandos usa uma biblioteca de Permissões separada, à qual o criador da experiência recebe automaticamente 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 | | ---------------------------- | -------------------------- | | Permission ------------------------> | | | GetGroupRankPermission () | | table | | SetUserPermission () | number requesterUserId, number targetUserId, permissionLevel | bool | | GetUserPermission () | number userId | number | | GetGroups () | | table | | SetGroupRankPermission () | number requesterUserId, number targetGroupId, number targetRankId, permission Level | bool | GetGroupRankPermission () | targetGroupId, targetRankId | int | GetUserGroupRankPermission () | number userId | int

Módulo de Início Rápido

Para uma 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 re-implementá-los.

| Command/Binding | Spoken Parameter | | -------------------------------- | -------------------------------- | "commands" | username | | "sparkles" | username | | "sparkles" | username | | "unforcefield," "unff" | username | | "explode" | username | | "respawn" | username | | "part" | Path (i.e. experiência.Workspace) | | "freeze" | username | | "unfreeze" | username | | "adicionar" | "remover" | username | "expulsar" | username | "setuserpermission," "sup" | userId, permission | "setgrouprankpermission" | groupid, Id, permission |