Un comando de administrador es una palabra clave o frase que un usuario con cierto nivel de control puede escribir en el chat para activar una acción. Esta biblioteca usa módulos de chat, lo que permite la fácil implementación de comandos de administrador en la parte superior del sistema de chat heredado. Los módulos de chat escuchan los mensajes entrantes en el servidor y pueden ejecutar acciones según los criterios que desee.
Configurar
Cuando un lugar de Roblox se carga, comprueba si el servicio de chat está vacío. Si no encuentra los componentes que necesita, el lugar insertará la última versión de esos componentes. Esto significa que sobrescribir o realizar cambios en estos componentes en una experiencia los evitará de ser actualizados.
El primer paso en la configuración de la biblioteca de comandos de administrador es agregar un nuevo módulo de chat al servicio de chat. La biblioteca en este tutorial se encarga del trabajo pesado realizado por un módulo de chat, por lo que el único objeto que necesita agregar al servicio de chat es un nuevo ModuleScript . El nombre de su script de módulo puede ser cualquier cosa, pero sugiero algo intuitivo como AdminCommands .
Implementando nuevos comandos
En lugar de implementar la mayor parte de la lógica del módulo de chat, simplemente necesitará el módulo de biblioteca que haga la mayor parte del trabajo y agregue funcionalidad adicional. La forma más simple de agregar la biblioteca a su módulo es requerirlo por su assetId en la parte superior de su script.
local AdminCommands = require(1163352238)
Este módulo devuelve una tabla de funciones, con la función Run como la más importante. La biblioteca tiene una función Run para su módulo de chat. Es importante que AdminCommands devuelva esta función Run al servicio de chat. La función está indexada por su nombre, Run, y puede devolver lo siguiente como si Run fuera una propiedad de nuestra representación de la tabla AdminCommands:
return AdminCommands.Run
Entre estas dos líneas de código, implemente sus propios comandos y cualquier función de ayudante necesaria.
Para atar una función a la biblioteca, use la función BindCommand de AdminCommands . Al atar un comando, necesitará especificar una tabla de palabras clave que, cuando se habla, activará el comando, la función que se activará, un nivel de prioridad y, opcionalmente, una descripción del comando. Si no especifica un nivel de privilegio, será predeterminado a 0. Los niveles de prioridad son valores numéricos utilizados por la biblioteca AdminCommands para asignar una jerarquía de permisos entre los usuarios con los niveles correspondientes de privilegios otorgados. Al ejecutar un comando, el orador debe tener un nivel de privilegios mayor o igual al del comando Permission Library.
AdminCommands:BindCommand({"keyword1", "keyword2"}, commandName, 1, "Optional description")
Para desbloquear, también usarías UnbindCommand y especificarías una palabra clave para desbloquear.
AdminCommands:UnbindCommand({"keyword1"})
En general, el contenido de tu script de AdminCommands debería ser el siguiendo:
local AdminCommands = require(1163352238)
local Utilities = AdminCommands.Utilities
function commandFunction(commandData)
-- Código de comando aquí
-- Devuelve verdadero si tiene éxito y falso de lo contrario
end
AdminCommands:BindCommand({"keyword1", "keyword2"}, commandFunction, 1, "Optional description")
return AdminCommands.Run
Es posible que note que la función de ejemplo toma un parámetro llamado commandData . Este parámetro es un argumento de tabla que se pasa a todas las funciones de comandos de administrador limitados cuando son ejecutadas por la biblioteca. La tabla contiene información útil sobre el comando que se ha dicho y el usuario que lo ha dicho. Tiene los siguientes campos:
- Ponente: ChatSpeaker
- cadena: string
- Nombre del canal: string
- Comando: string
Es importante esperar siempre commandData como parámetro de las funciones de comando. Por ejemplo, si tiene un comando llamado "explode," que requiere que se especifique un Player parámetro, la función se verá como explode(commandData, usuario).
| Función | Parámetros | Regreso | | --------------- | ---------------------------------- | | Comandos: | | | | BindCommand () | functionIDs de la función, functionToExecute, número mínimoPermissionLevel, descripción de la cadena | bool | | UnbindCommand () | functionIDs de la tabla | bool | | GetCommands () | | tabla |
Utilidades
La biblioteca ya tiene algunas funciones de ayudante integradas llamadas Utilidades que puedes usar. Almacena AdminCommand.Utilities en una variable o haz referencia a ella directamente.
local Utilities = AdminCommands.Utilities
Las funciones de utilidad actuales son:
| Función | Parámetros | Regreso | |---------------- | ------------------ | | Mensajes de la ventana del chat: | | | | SendSystemMessage () | datos del comando de la tabla, contenido de la cadena, tabla extraData | bool | | SendSystemSuccessMessage () | datos del comando de la tabla, contenido de la cadena | bool | | SendSystemWarningMessage () | datos del comando de la tabla, contenido de la cadena | bool | | SendSystemErrorMessage () | datos del comando de la tabla, contenido de la cadena | bool | | | Manipuladores de errores: | | | | NoPlayerSpecified () | datos del comando de la tabla | bool | NotEnoughSpecified () | datos del comando de la tabla | bool | | IncorrectValueType () | datos del comando de la tabla
Comandos de ejemplo
Un comando útil para tener sería uno que imprime una lista de todos los comandos opcionales que los usuarios tienen disponibles. Este comando emite cada comando vinculado a la biblioteca y algunas de sus propiedades.
-- Imprime una lista de todos los comandos vinculados
function listCommand(commandData)
Utilities:SendSystemMessage(commandData, "The following commands are available:")
-- Iterar a través de cada comando e imprimirlo
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.")
Otro comando útil permite a los usuarios darse destellos. Este comando requiere un parámetro cuando se habla el nombre del usuario objetivo. Si el usuario existe, el comando creará un objeto de destellos en la parte de raíz de humanoide de ese usuario.
-- Da los destellos del personaje de un jugador especificado
function sparklesCommand(commandData)
-- Error si no se dan/hablan los parámetros
if #commandData.Parameters == 0 then
return Utilities:NoPlayerSpecified(commandData)
end
-- Revise los parámetros (ejecútalo en el nombre de cada jugador)
for index = 1, #commandData.Parameters do
local parameter = commandData.Parameters[index]
if (parameter == "me" or parameter == "") then parameter = commandData.Speaker.Name end -- Si el parámetro soy yo, entonces el usuario debe estar refiriéndose a sí mismo
-- Usa una función de ayudante para encontrar el personaje del jugador y añadir los destellos
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")
También puede incluir un comando de explosión del tutorial de comando de administrador creado. Este comando también toma el nombre de un usuario como parámetro.
-- Verifica que el modelo dado sea un Personaje y añade una explosión a su Parte Raíz 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
-- Hace que el personaje de un jugador especificado explote
function explodeCommand(commandData)
-- Error si no se dan/hablan los parámetros
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 -- Si el parámetro soy yo, entonces el usuario debe estar refiriéndose a sí mismo
-- Usa una función de ayudante para encontrar el personaje del jugador y añadir la explosión
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 permisos
Si un no administrador intenta hablar un comando como este, que tiene un nivel de permiso más alto que 0, no se activará. El sistema de comandos utiliza una biblioteca de permisos separada, a la que el creador de la experiencia se le da automáticamente el nivel de permiso math.huge. Los administradores se pueden agregar utilizando las siguientes funciones en el objeto del módulo AdminCommands:
SetUserPermission(number requesterUserId, number targetUserId, permissionLevel) -> boolSetGroupRankPermission(number requesterUserId, number targetGroupId, number targetRankId, permissionLevel) -> bool
| Función | Parámetros | Regresar | | ---------------------------- | -------------------------- | | Permisos <--------------------------------> | | | GetGroupRankPermission () | | number requesterUserId, number targetUserId, permissionLevel | bool | | GetUserPermission () | number userId | number | | GetGroups () | | table | | SetGroupRankPermission () | number requesterUserId, number targetGroupId, number targetRankRankId, permissionLevel | bool | | GetGroupRankPermission () | targetGroupId, targetRankId | int | GetUserGroupRankPermission () | number userId | int
Módulo de inicio rápido
Para una configuración más fácil, también puede usar este Quick Start , que es un módulo que ya ha implementado la biblioteca de comandos de administrador. El modelo es un módulo con el mismo formato que se describió anteriormente. Además, el módulo ya tiene algunos comandos incluidos para que no tenga que volver a implementar.
| Comando/Enlace | Parámetro hablado | | -------------------------------- | -------------------------------- | "comandos" | nombre de usuario | | "sparkles" | nombre de usuario | | "sparkles" | nombre de usuario | | "unforcefield," "unff" | nombre de usuario | | "explode" | nombre de usuario | | "respawn" | nombre de usuario | | "part" | Camino (i.e. experiencia. Workspace) | | "freeze" | nombre de usuario | | "unfreeze" | nombre de usuario | | "añadir" | "eliminar" | nombre de usuario | "explusar" | nombre de usuario | "setuserpermission," "sup" | usuarioId, permiso | "setgrouprankpermission" | groupid, Id, permiso |