Результаты поиска

Команда молодости нашей... (с)

Единственное различие при вводе команд с консоли сервера и через строку общего чата - это использование слеша ("/") в начале строки во втором случае. Что, в общем-то, логично - надо же как-то серверу различать обычный треп в чате между игроками и осмысленные команды, адресуемые именно ему. В дальнейшем для примеров использования команд будет преимущественно использоваться вариант /command, как наиболее наглядный. Однако следует иметь в виду, что при использовании той же команды с консоли сервера ведущий слеш следует опускать. Кстати, ограничений на дальнейшее использование знаков препинания в названии команд не замечено (кроме пробела, который используется для деления строки команды на элементы), чем иногда пользуются разработчики плагинов (см. команды //size, //paste плагина WorldEdit).

Сама команда знаками пробела делится на элементы: первым элементом является имя команды. Далее следуют аргументы команды. Будут это какие-то опции или значения параметров - дело и проблемы исключительно ваши. И возиться с их парсингом и обработкой опять же вам. Как вы будете это делать - каскадами операторов if() либо парсингом строки команды через регулярные выражения - решать снова вам.

Теперь рассмотрим подробнее те ровно два с половиной способа, с помощью которых можно в нашем плагине обработать эти команды. Первый способ, наиболее простой и универсальный, идеально подходит для небольших плагинов с более-менее статичным контентом. Если плагин ваш заточен под решение одной задачи и подразумевает работу всего-лишь с одной-двумя-тремя командами - это как раз ваш случай. Все, что вам необходимо - это наследовать в основном классе вашего плагина метод onCommand (возвращающий false в классе JavaPlugin, от которого и наследуется класс вашего плагина):

/********************************************************************************
 * обработка события выполнения команды
********************************************************************************/
@Override
public boolean onCommand(CommandSender sender, Command command, String label, String[] args)
{
	return super.onCommand(sender, command, label, args);
}

Метод onCommand является типичным обработчиком т.н. псевдособытия, которые были описаны в предыдущей статье, посвященной этим самым событиям. Баккит вызывает его в том случае, если в процессе обработки входящих данных встречает команду, подходящую для данного плагина. Что это значит? Это, прежде всего значит, что с помощью данного способа можно получить доступ только к тем командам, на которые есть "подписка" у вашего плагина. Получить эту самую подписку в простейшем случае через файл plugin.yml (также описанный в одной из предыдущих статей), который содержит основную информацию о вашем плагине. Чтобы закрепить за ним какую-либо команду, необходимо в этом файле создать секцию commands (очень подробно описана на bukkit-wiki), а в ней - подсекцию с названием, совпадающим с именем команды:

commands:
  test:
    description: просто тестовая команда
    aliases: [tst, teeeest]
    permission: test_plugin.test
    permission-message: Все в сад!
    usage: Что я делаю не так?!

Как видно из приведенного куска файла plugin.yml, плагин резервирует за собой команду /test. Тут надо понимать, что никто, в принципе, не накладывает ограничений на пересечение имен команд, описываемых в данной секции. И, в принципе, они могут совпадать с названиями команд, используемыми другими плагинами. Однако при вызове метода onCommand действует вполне логичное правило "Кто первый встал - того и тапки", так что ваш плагин вполне может оказаться с носом, но без тапок, если какой-то другой плагин, "подписанный" на данную команду, в своем методе onCommand при обработке этой же команды уже вернул true. Так что для перехвата "чужих" команд данный метод вряд ли подойдет.

Что касается остальных параметров подсекции описания команды:

• description: содержит произвольную строку описания. Применяется в основном для генерации "хэлпа" командой /help.
• aliases: здесь можно перечислить т.н. псевдонимы вашей команды, которые можно использовать равноценно наряду с основным именем команды. Поскольку перечисление псевдонимов является неименованным списком, его элементы разделяются запятыми и заключаются в прямые скобки (см. статью YML и все-все-все...).
• permission: разрешение, необходимое для использования данной команды. Если разрешение не указано, команда становится доступна всем игрокам сервера. Команды, вводимые с консоли сервера, под действие системы разрешений не попадают - это абсолютный доступ непосредственно от имени сервера.
• permission-message: сообщение, которое будет выдано игроку, не имеющему доступ к данной команду.
• usage: сообщение, которое выдается пользователю, если команда была введена неправильно. Применительно к разработке плагинов это звучит так: если для плагина, который был "подписан" на команду, был вызван метод onCommand для обработки данной команды и он вернул результат false.

Теперь обратимся к параметрам самого метода onCommand:

• CommandSender sender: объект, отправивший данную команду. Странная система иерархии классов баккита вполне позволяет отправлять команды как от имени игроков или сервера, так и (!) от имени, например, хрюнделя или летящего снежка. Однако обычно отслеживаются только первые два случая - отправка от имени игрока (sender instanceof Player) и отправка команды с консоли (sender instanceof ConsoleCommandSender).
• Command command: сам объект команды. Поскольку методу onCommand достаются только команды, на которые у плагина есть "подписка" (читай, имеющие описание в plugin.yml), баккит по описанию команды генерит объект данного типа, для которого можно получить/установить все те параметры, что я перечислил чуть выше.
• String label: название отправленной команды. Обратите внимание, данный параметр содержит название именно введенной команды, а не команды, описанной в конфиге. То есть, если вы воспользуетесь псевдонимом команды, параметр label будет содержать именно этот псевдоним. Добраться же до основного имени команды можно с помощью конструкции command.getName(). Что интересно, вызов метода command.getLabel() также возвращает основное имя команды, даже если был использован ее псевдоним. Чудны дела твои, Господи.
• String[] args: массив строк, содержащих аргументы команды. Как уже говорилось выше, введенная строка тупо разбивается по пробелам и все, что следует за названием, обзывается аргументами и попадает в этот список. Логично, что массив агрументов может быть и нулевой длины.

Что же со всем этим делать? Конечно же, обрабатывать. Для начала необходимо определить, о какой именно команде идет речь, поскольку секция commands файла plugin.yml может описывать любое их количество. Если команд предполагается не очень много, можно обойтись последовательными if():

if (command.getName().equalsIgnoreCase("test1"))
{
    ...
    return true;
}
else if (command.getName().equalsIgnoreCase("test2"))
{
​    ...
    return true;
}
else ...
else return false;

При большем, нежели несколько штук, количестве команд можно перейти к конструкции switch-case. Суть дела от этого сильно не изменится. Следует помнить лишь об одном: в случае удачного парсинга команды ваш метод onCommand должен вернуть true. При этом вы, конечно, можете производить дополнительные проверки на корректность аргументов команды и, в случае ошибки, возвращать отправителю грозные сообщения. Но все же лучше в том случае, если название команды вами распознано, давать понять баккиту, что команда обработана. Также, чтобы вам не приходилось муторно проверять все возможные варианты, лучше всего приводить имя команды к нижнему регистру и использовать именно ее основное имя (getName), а не использовать аргумент label, который может и не совпадать с основным именем.

Что делать с остальными аргументами команды (массив args), если они, конечно, будут? Тут однозначного ответа нет. Ведь в качестве аргументов команды могут использоваться самые различные по структуре выражения: опции: -option, -option:value, -option:"bla bla value", причем желательно, чтобы опции можно было вставлять в любом месте, а также чтобы можно было использовать сокращенные названия опций, в идеале - чтобы можно было устанавливать перекрестные зависимости между используемыми опциями; целочисленные, дробные аргументы (в том числе и значения опций), строковые выражения (как односложные так и разделенные пробелами), а так же текст до конца строки как единый аргумент. Кроме того, в некоторых случаях команды могут в зависимости от контекста использовать разные наборы аргументов, и эти ситуации также необходимо отслеживать и корректно обрабатывать. Ну и на десерт: каждая команда (а иногда и определенный набор ее параметров) могут требовать отдельного разрешения (пермишенса) на использование.

В свое время подобная мешанина привела меня к написанию собственного командного процессора, основанного на регулярных выражениях. А поскольку аппетит приходит во время еды, постоянно возникало желание допилить его в сторону универсальности. В итоге все это вылилось в отдельный пакет почти с 40 классами общим объемом под 5к строк. Жаль, что нечто подобное разработчики баккита не заложили в стандартный набор, не пришлось бы изобретать велосипед.

В целом, если ваша команда предполагает использование простейших аргументов (например, целочисленных x y z), можно, наверное, обойтись простым их парсингом в числа непосредственно из массива аргументов args. А вот если ситуация более запущенная, возможно, лучшим выходом будет объединить все строковые аргументы обратно в строку (через пробел) и далее уже парсить ее своими средствами с учетом контекста.

К слову сказать, основной класс вашего плагина вовсе не обязательно должен быть обработчиком консольных команд посредством метода onCommand. Данное свойство у главного класса реализуется благодаря интерфейсу CommandExecutor, который как раз и определяет требование к реализации данного метода. В принципе, вы можете создать специальный класс-обработчик команд:

class CommandHandler implements CommandExecutor
{
    public boolean onCommand(CommandSender sender, Command command, String label, String[] args)
    {
        ...
    }
}

который будет реализовывать метод onCommand интерфейса CommandExecutor, а затем при старте плагина создать объект этого класса и зарегистрировать его как обработчик ваших команд:

@Override
public void onEnable()
{
    CommandHandler handler= new CommandHandler(...);
    this.getCommand("test").setExecutor(handler);
}

Обратите внимание, команда, объект которой (PluginCommand) вы пытаетесь получить вызовом метода getCommand, должна быть описана в файле plugin.yml, в противном случае метод вернет null, а следующий за ним вызов setExecutor, соответственно, обрушится эксцепшеном NullPointerException.

Теперь разберем вторые полтора варианта перехвата вводимых команд, которые представляют собой не что иное, как обычные баккитовские события - PlayerCommandPreprocessEvent и ServerCommandEvent - числом 2 (два штуки). Такая вот шизофрения, случай типичный, описан в "Ярбух фюр психоаналитик унд психопатологик". Как, наверное, понятно из названий классов событий, одно из них отвечает за команды, употребляемые игроками через общий чат (посредством пресловутого "/"), а вторые поступаю в обработку непосредственно с консоли сервера. А происходят они: первое - от PlayerEvent (что позволяет через event.getPlayer() получить доступ объекту игрока, запустившего команду), а второе - от ServerEvent, который объединяет все общие события самого сервера:

/********************************************************************************
 * обработка события выполнения команды, отправленной игроком
********************************************************************************/
@EventHandler
public void onPlayerCommandPreprocess(PlayerCommandPreprocessEvent event)
{
    String cmd_line= event.getMessage();
    ...
}

/********************************************************************************
 * обработка события выполнения команды, введенной с консоли
********************************************************************************/
@EventHandler
public void onServerCommandPreprocess(ServerCommandEvent event)
{
    String cmd_line= event.getCommand();
    ...
}

Оба типа событий наследуют интерфейс Cancellable, что позволяет в особо запущенных случаях произвести отмену выполнения какой-либо команды. Например, создав обработчик события PlayerCommandPreprocessEvent с приоритетом MONITOR (см. статью Не думай о событиях свысока!) для обработки единственной команды /seed с единственным действием - отменой введенной команды, можно полностью перекрыть к ней доступ даже для операторов сервера. Сид мира - это святое.

Однако главное отличие данного метода (через обработку событий) в другом: в отличие от метода onCommand они НЕ ТРЕБУЮТ описания (или регистрации, см далее) используемых команд в файле plugin.yml плагина. То есть (теоретически), вы можете через обработчик события перехватить ЛЮБУЮ команду любого плагина. "Теоретичность" заключается в том, что ваш плагин для этого должен в очереди на обработку события оказаться впереди плагина, чью команду вы хотите перехватить. Достигается это, как правило, повышением уровня приоритета обработчика события. Конечно, если плагин, чью команду вы перехватили, зарегистрировал обработчик команд с опцией ignoreCancelled= true, это вас не спасет. Хотя и тут можно нарезать левую резьбу: заменить название команды на что-нибудь типа /dummy и отдельным обработчиком с наименьшим приоритетом "погасить" ее в самом конце "очереди".

Из преимущества, которое не требует предварительной регистрации команды, проистекает главный недостаток данного метода: для команды не создается (да и не может) объект типа Command, в котором перечислены все ее основные характеристики. Команда поступает на обработку именно в том виде, в каком она была введена в консоли сервера (ServerCommandEvent) или в чате (PlayerCommandPreprocessEvent). Однако и тут имеются различия: для ServerCommandEvent эта строка получается вызовом event.getCommand(), а для PlayerCommandPreprocessEvent - через вызов event.getMessage() (шизофрения прогрессирует). Причем во втором случае, обратите внимание, полученная строка команды будет начинаться со слеша ("/").

Что со всем этим делать - опять же решать вам. Выше я уже описал типичные трудности и наметил некоторые варианты их преодоления. Разница тут только в том, что в случае с использованием обработчиков "командных" событий вам придется вручную разбираться с алиасами (псевдонимами), но не придется собирать в строку массив аргументов.

Кроме того, отсутствие явной регистрации команды приводит к еще одному серьезному недостатку: при вводе части команды пользователь может нажать клавишу Tab и получить контекстную подсказку о подходящих командах. Если команда не будет явно зарегистрирована в системе, логично, что она не войдет в этот т.н. таб-комплит (TabComplete) список. Что же делать, если команд у вашего плагина набралось уже порядочно, структуру они имеют довольно сложную, и к тому же активно допиливаются, что превращает их синхронизацию с описанием в plugin.yml в сущий кошмар? Тогда, наверное, будет проще организовать их декларацию в коде плагина (к чему я, собственно, и пришел в своих плагинах) - вместе с возможными наборами аргументов, их типами, допустимыми опциями и их перекрестными зависимостями. А регистрацию команд производить программно - при запуске плагина (в методе onEnable).

К сожалению, подобная схема регистрации команд требует особых низкоуровневых методов ведения допроса доступа к закрытым полям объектов сервера, а их мы еще не проходили. Обещаю, что как только мы рассмотрим тему "рефлексных методов", первым делом опишу как раз способ программной регистрации команд в системе. Для знакомых с данными методами даю небольшую подсказку: метод public boolean register(String label, String fallbackPrefix, Command command) объекта private final SimpleCommandMap commandMap менеджера плагинов вашего сервера.

К сожалению, в рамках одной статьи можно провести только базовый ликбез по теме консольных команд. Однако некоторую основу вы, надеюсь, получили, а дальше все познается методом спортивной ходьбы по граблям.

Не думай о событиях свысока!

Тех, кто привык к системе обработке событий Windows, где события кидаются в общую очередь, и далее все, кто заинтересован в их обработке, должны периодически обращаться к менеджеру этой очереди с вопросом "Есть чо?", поначалу, наверное, будут немного напрягаться от методики, принятой в бакките: здесь менеджер событий при поступлении нового объекта бросает все дела, тормозит всех, вытаскивает список подписчиков данного события и начинает тормошить их всех вопросом "Ннада?". Сложно сказать, какой метод лучше или хуже, и у того и у другого есть свои плюсы и минусы. Тем более, что процесс обработки я описал только черновыми штрихами, без конкретики. Например, событие можно объявить асинхронным, что, по идее, вынесет его обработку в отдельный поток.

Самое главное, что должен уметь делать класс, ответственный за обработку события (если, конечно, он не абстрактный), это выдавать по запросу список обработчиков (подписчиков, слушателей, наблюдателей за наблюдающими) данного события. Как понятно из контекста, список этот должен быть статическим, то есть привязанным именно к классу, а не к конкретному объекту события:

public class BlaBlaEvent extends Event
{
    private static final HandlerList handlers = new HandlerList();
 
    public HandlerList getHandlers()
    {
        return BlaBlaEvent.handlers;
    }
}

Обратите внимание: несмотря на то, что сам список обработчиков является статическим, метод getHandlers(), возвращающий его, не является статическим. В этом просто нет особой необходимости, поскольку он используется при обработке конкретного экземпляра события данного бла-бла-типа (при регистрации обработчиков баккит действует через функции пакета java.lang.reflect, которым статичность свойств и методов до одного места). В общем и целом, как раз именно этот список и является тем самым списком обработчиков, по которому проходится менеджер событий баккита с вопросом "Ннада?".

Еще одной немаловажной особенностью многих баккитовских событий является возможность их отмены. Конечно, далеко не все события обладают такой способностью всилу естественных причин: например, какой смысл делать отменяемым событие PlayerQuitEvent, если игрок все равно уже вышел с сервера, хотите вы этого или нет. Однако, например, PlayerMoveEvent вполне логично сделано отменяемым, чтобы можно было в зависимости от текущих условий отказать игроку в перемещении в заданную точку. Некоторые события, как например PlayerLoginEvent, реализуют механизм отмены собственными методами (allow и disallow) - флаг Гондураса им для этого в руки. Однако если событие следует классической схеме отмены, оно должно наледовать интерфейс Cancellable и реализовывать его методы isCancelled и setCancelled:

public class BlaBlaEvent extends Event
{
    private static final HandlerList handlers= new HandlerList();
    private boolean cancel= false;
 
    public HandlerList getHandlers()
    {
	    return BlaBlaEvent.handlers;
    }
 
    public boolean isCancelled()
    {
        return this.cancel;
    }
 
    public void setCancelled(boolean cancel)
    {
        this.cancel= cancel;
    }
}

Смысл механизма отмены разъясню чуть ниже.

В остальном состав методов и полей класса описания события отдан на откуп разработчику, вы можете добавлять нужные вам свойства, аргументы конструктора события (поскольку создавать его экземпляры будете сами).

Всего в окружении баккита генерится несколько десятков видов событий, разбитых на глобальные группы (производные от глобальных классов): события игрока (PlayerEvent), события блоков (BlockEvent), события сущностей (EntityEvent), события мира (WorldEvent), общие события сервера (ServerEvent), события погоды (WeatherEvent) и еще несколько несистематизированных событий. В целом они покрывают 99% потребностей разработчиков плагинов, хотя иногда бывает чертовски обидно, когда не находишь даже примерно подходящего события, за которое можно было бы зацепиться: например, как уже говорилось в предыдущих статьях, полная засада ожидает при попытке отловить проведение сделки с деревенским жителем.

В любом случае, как бы ни был объявлен класс события, какие бы аргументы он ни содержал в конструкторе, рано или поздно все заканчивается созданием экземпляра этого события и запуском его в обработку:

BlaBlaEvent event= new BlaBlaEvent(...);
    Bukkit.getServer().getPluginManager().callEvent(event);

Это как раз та самая точка, где генерится сообщение-индикатор возникшей ситуации. Располагаться она может в любом месте кода вашего плагина. В первой строчке приведенного примера создается экземпляр нужного класса события. Второй строчкой мы отправляем созданный объект события менеджеру событий баккита (который по совместительству является и менеджером плагинов баккита).

Поскольку все пространство классов java-машины едино, вы (или кто-то еще) можете получить доступ к обработке абсолютно любого события (если, конечно, оно объявлено как public). Таким образом, создание кастомных событий интересно больше не вам самому внутри собственного плагина (у вас и так море возможностей для внутриплагинного взаимодействия компонентов), а скорее для того, чтобы предоставить возможность разработчикам сторонних плагинов получить доступ к "достижениям" вашего плагина.

А вот теперь настало время взглянуть на проблему с другой стороны, поскольку нас, как правило, будет интересовать не генерация событий, а их обработка. Давайте присмотримся к этому механизьму поближе. Как уже было сказано выше, менеджер событий опрашивает все слушателей... как же нам попасть в ряды этих самых слушателей? Для этого вы должны выполнить 3 следующих действия:

1. Класс, методы которого будут заниматься обработкой тех или иных событий, должен реализовывать интерфейс Listener. неважно, будет ли это ваш главный ласс плагина или один из второстепенных, но "заточенных" именно под это. Пускай это (для простоты) будет основной класс нашего тестового плагина:

public class TestPlugin extends JavaPlugin implements Listener
{
    ...
}

2. Каждый, метод, промышляющий обработкой событий, должен иметь один единственный параметр, параметр этот должен быть производным от класса Event. Собственно, класс этого параметра как раз и определяет - какой тип событий будет обрабатывать данный метод. Кроме того, метод-обработчик должен предваряться директивой @EventHandler (о директивах как-нибудь постараюсь написать чуть подробнее):

@EventHandler
public void onBlaBla(BlaBlaEvent event)
{
    ...
}

Название метода значения не имеет (можно даже в 1 классе создать несколько методов, обрабатывающих одно и то же событие). Однако хорошим тоном считается начинать название метода с "on" и заканчивать названием класса события без "Event".

3. "Где-нибудь" (обычно при запуске, в методе onEnable класса плагина) необходимо произвести регистрацию объекта класса-обработчика событий (обратите внимание: не метода, а именно объекта класса) в менеджере событий баккита:

@Override
public void onEnable()
{
    getServer().getPluginManager().registerEvents(this, this);
}

Первым аргументом вызова метода registerEvents является класс-обработчик событий. Вторым - плагин, содержащий данный класс. Поскольку в нашем случае и то и другое являются одним и тем же объектом, а вызов производится из внутреннего метода, в качестве обоих аргументов выступает this.

В очень упрощенном виде алгоритм работы регистратора событий баккита (на самом деле - регистратора обработчиков событий) выглядит примерно так: указанный класс просматривается на предмет поиска методов, помеченных директивой @EventHandler и имеющих в качестве единственного аргумента объект класса, производного от Event. При нахождении такого метода менеджер получает список обработчиков handlers такого класса события и добавляет к этому списку найденный метод (на самом деле, там особо извращенным способом создается специальный метод-исполнитель, но это уже никому не интересные детали). Таким образом, каждый метод, помеченный директивой @EventHandler класса, производного от Listener, ставится в очередь (- В очередь, сукины дети, в очередь!! (с)) подписчиков того или иного типа (класса) событий.

И вот тут самое время вернуться к свойству отмены события, а также рассмотреть систему приоритетов. В самом общем виде директива @EventHandler объявляется следующим образом:

@EventHandler(ignoreCancelled= true|false, priority= EventPriority.XXXX)

Параметр ignoreCancelled (по-умолчанию false) сообщает, должен ли обработчик получать т.н. "отмененные" события. Как было описано выше, для сообщений, реализующих интерфейс Cancellable, можно установить (через вызов setCancelled) признак отмены данного события. После этого данное событие будет передаваться только обработчикам, для которых установлен признак ignoreCancelled (true).

Свойство priority может принимать следующие значения: LOWEST, LOW, NORMAL (по-умолчанию), HIGH, HIGHEST, MONITOR. Как понятно из контекста, наименьший приоритет имеют обработчики LOWEST, наибольший - нет, не HIGHEST, - MONITOR. Их в документации настоятельно рекомендуют использовать только для регистрации самого факта наступления события, без попытки его изменения. Например, это может пригодиться для логгера действий игрока (см. Prism, LogBlock, CoreProtect). В целом, если нет веских причин, следует использовать значение NORMAL.

В свете вышесказанного, алгоритм действий менеджера при обработке того или иного события может быть примерно следующим: список обработчиков события просматривается несколько раз, сначала событие передается обработчикам, имеющим статус приоритета MONITOR, затем обработчикам с приоритетам HIGHEST, и так далее до LOWEST. При этом, если событие наследует интерфейс Cancellable и в какой-то момент оно помечено как отмененное, в дальнейшем оно передается только обработчикам, у которых признак ignoreCancelled равен true. Такие вот пирожки с котятами.

Что касается очередности плагинов в пределах одного уровня приоритета, то тут, подозреваю (специально не смотрел но осуждаю), первым в очереди оказывается тот, кто первым встал зарегистрировался как обработчик данного события.

Что же можно сделать при обработке события? Да что угодно. Можно, например, при обработке события перемещения игрока проверять его попадание в определенный регион и по достижении его выдавать соответствующее сообщение. Следует помнить лишь о том, что обработка большинства событий производится в синхронном режиме (в общем потоке сервера, с приостановкой всех остальных действий), что потенциально может привести к лагам, а в исключительных случаях - к падению сервера (как правило, через 15-30 секунд зависания). Так что при выполнении операций, требующих значительных временных ресурсов, выделяйте подобные действия в отдельный поток (постараюсь потом поподробнее остановиться на классе Runnable и всем, что с ним связано).

Что я помимо этого имею сказать за события: кроме описанных выше классических событий, я бы выделил еще т.н. псевдособытия: для некоторых баккитовких классов (в основном это касается класса JavaPlugin) предусмотрен ряд шаблонных методов, название которых, как и рекомендуемое мной для обработчиков событий, начинается с "on". Эти методы также вызываются в конкретных ситуациях и служат индикаторами их наступления, а, соответственно, при наследовании могут быть напрямую использованы как обработчики данных "событий". В частности, для JavaPlugin определены следующие подобные методы:

- onCommand - запускается при получении плагином консольной команды (команда должна быть описана в файле plugin.yml в секции commands (см. предыдущую статью). Особо обращаю внимание: если за плагином не зарезервирована конкретная команда, вызова данного метода не произойдет.
- onTabComplete - вызывается в ситуации, когда пользователь нажимает клавишу Tab после ввода команды. Можно использовать для того, чтобы отфильтровать список команд, которые стоит показывать пользователю в качестве подсказки, а которые нет.
- onLoad - вызывается при загрузке плагина (не путать с onEnable, о различиях между этими моментами рассказано в предыдущей статье).
- onEnable - вызывается в момент запуска плагина (вызовом setEnabled(true|false) можно управлять данным процессом в зависимости от проведенных проверок. Однако будьте внимательны, в зависимости от значения аргумента могут повторно вызываться методы onEnable или onDisable, что потенциально может привести к зацикливанию и крашу сервера).

- onDisable - вызывается в момент остановки плагина (по команде /reload, ныне репрессированной, или в момент остановки сервера).

Данные псевдособытия, хоть и не попадают под каноническое описание, тем не менее позволяют без особых затрат для простейших плагинов реализовать базовые действия. А уж методы onEnable и onDisable по-любому перекрываются всеми плагинами.

Вот, наверное, и все по самым основным сведениям о событиях баккита. К сожалению, в масштабах одной статьи (уже немаленькой) невозможно рассказать о всех ньюансах, проблемах и затыках обработки событий. Но, по крайней мере, базовые навыки по этому вопросу вы получили. В следующий раз обратимся к консольным командам сервера.