Plugins de Rust: instalar Oxide y Carbon, lo básico

Respuesta rápida: instala Oxide o Carbon en el servidor y luego suelta el archivo .cs del plugin en oxide/plugins/ o carbon/plugins/. Se carga solo, sin reiniciar, y su archivo de ajustes aparece en la carpeta de config la primera vez que carga.

Un plugin de Rust es un archivo C# (.cs) que un framework de mods compila y ejecuta dentro de tu servidor dedicado. Los plugins corren solo en el servidor, así que los jugadores no instalan nada. Un servidor vanilla no puede ejecutarlos: antes necesitas Oxide o Carbon en el servidor.

Oxide o Carbon

Los dos cargan el mismo tipo de plugin, y solo uno puede estar en un servidor a la vez, porque los dos parchean los mismos archivos del juego.

Oxide (también llamado uMod) es el de toda la vida. Sus archivos viven en la carpeta oxide/ del servidor.
Carbon es más nuevo y también carga plugins hechos para Oxide. Sus archivos viven en la carpeta carbon/.

Crucible Local Server instala cualquiera de los dos por ti cuando creas un servidor con él, y gestiona sus plugins en la pestaña Mods; mira cómo instalar Carbon u Oxide en un servidor de Rust.

Dónde van los archivos de los plugins

Qué	Oxide	Carbon
Plugins (`.cs`)	`oxide/plugins/`	`carbon/plugins/`
Ajustes de cada plugin (`.json`)	`oxide/config/`	`carbon/configs/`
Datos que guarda un plugin	`oxide/data/`	`carbon/data/`
Mensajes de un plugin, por idioma	`oxide/lang/`	`carbon/lang/`
Logs	`oxide/logs/`	`carbon/logs/`

Las carpetas están junto a RustDedicated.exe y aparecen la primera vez que el servidor arranca con el framework instalado. Un plugin escribe su archivo de config la primera vez que carga; edítalo y luego recarga el plugin.

Cargar, recargar y quitar un plugin

Suelta un archivo .cs en la carpeta de plugins y el framework lo compila y lo carga solo, sin reiniciar. Cambia el archivo y se recarga; bórralo y deja de cargarse. La consola del servidor muestra entonces una línea como Loaded plugin Hello World v1.0.0 by YourName, o el error de compilación si el código está mal.

También puedes hacerlo a mano desde la consola del servidor o por RCON:

Oxide: oxide.load Nombre, oxide.reload Nombre, oxide.unload Nombre, oxide.plugins (cada uno también funciona como o.load, o.reload y así).
Carbon: c.load Nombre, c.reload Nombre, c.unload Nombre, c.plugins.

Nombre es el nombre del archivo sin .cs. Un servidor con Oxide se marca a sí mismo como modded. Todos esos comandos están con su nombre completo en los comandos de consola de Rust.

Permisos

La mayoría de los plugins protegen sus comandos con permisos, que llevan el nombre del plugin (hello.use, kits.admin). Oxide empieza con dos grupos: default, en el que está todo jugador, y admin, para los admins del servidor.

oxide.grant user <nombre o SteamID> <permiso> da un permiso a un jugador.
oxide.grant group default <permiso> se lo da a todos.
oxide.revoke lo quita, con la misma forma.
oxide.usergroup add <nombre o SteamID> <grupo> mete a un jugador en un grupo, y oxide.group add <grupo> crea uno nuevo.

Todos los comandos de Oxide, con lo que hacen, están al final de los comandos de consola de Rust.

Tu primer plugin

Guárdalo como HelloWorld.cs en la carpeta de plugins. Escribe una línea en la consola al cargar, otra por cada jugador que entra, y responde a /hello en el chat.

namespace Oxide.Plugins
{
    [Info("Hello World", "YourName", "1.0.0")]
    [Description("Says hello when a player types /hello in chat.")]
    public class HelloWorld : RustPlugin
    {
        private void OnServerInitialized()
        {
            Puts("Hello World is running.");
        }

        private void OnPlayerConnected(BasePlayer player)
        {
            Puts($"{player.displayName} joined.");
        }

        [ChatCommand("hello")]
        private void HelloCommand(BasePlayer player, string command, string[] args)
        {
            SendReply(player, $"Hello, {player.displayName}!");
        }
    }
}

Qué hace cada parte:

El nombre del archivo y el de la clase tienen que coincidir (HelloWorld.cs, class HelloWorld).
[Info] da el título, el autor y la versión del plugin, que la consola muestra al cargar.
Los métodos con el nombre de un hook se ejecutan cuando pasa esa cosa en el juego: OnServerInitialized cuando el servidor termina de arrancar (o al momento si ya está en marcha), OnPlayerConnected cuando entra un jugador. El framework los encuentra por el nombre, así que una errata significa que el método nunca se ejecuta, sin ningún error.
[ChatCommand("hello")] convierte un método en un comando de chat. Puts escribe en la consola del servidor; SendReply manda un mensaje de chat a un jugador.

El mismo archivo corre en Carbon. La lista completa de hooks y lo que recibe cada uno está en la documentación de Oxide, en docs.oxidemod.com.

Nombres e ids que usan los plugins

Los plugins se refieren a las cosas del juego por sus nombres dentro del juego, que esta web lista directamente del juego:

Items por shortname (rifle.ak, wood): lista de items de Rust.
Entidades por ruta de prefab (assets/prefabs/deployable/large wood storage/box.wooden.large.prefab): las páginas de prefabs de la referencia del juego Rust.
Ajustes del servidor por nombre de convar (server.maxplayers): variables del servidor de Rust.

Prueba un plugin antes de ponerlo en vivo

Ejecútalo primero en una copia local de tu servidor, con el mismo framework y el mismo mapa, para que un plugin roto nunca llegue a tus jugadores. Crucible Local Server corre uno en tu propio PC con Oxide o Carbon instalado en un clic.