Java через Minecraft: От новичка до разработчика модов и плагинов

Фундамент Java: Настройка среды, переменные и управляющие конструкции

Добро пожаловать в курс «Java через Minecraft: От новичка до разработчика модов и плагинов». Если вы когда-либо хотели создать свой собственный меч, добавить нового моба или написать плагин для телепортации на сервере, вы попали по адресу. Но прежде чем мы начнем ковать алмазную броню, нам нужно добыть дерево и сделать верстак.

В мире программирования нашим «верстаком» является среда разработки, а «деревом» — базовый синтаксис языка Java. Minecraft написан на Java, поэтому, изучая этот язык, вы буквально изучаете ДНК игры.

1. Подготовка инструментов: JDK и IDE

Любой крафт начинается с инструментов. В программировании нам нужны две главные вещи:

1. JDK (Java Development Kit) — это набор инструментов разработчика. Представьте, что это ресурсы игры (текстуры, звуки, логика), без которых ничего не запустится.
2. IDE (Integrated Development Environment) — интегрированная среда разработки. Это ваш продвинутый верстак. Мы будем использовать IntelliJ IDEA, так как она является стандартом индустрии и идеально подходит для моддинга.

Установка

1. Скачайте и установите JDK (рекомендуется версия 17 или 21 для современных версий Minecraft).
2. Скачайте IntelliJ IDEA Community Edition (она бесплатна).

Программирование — это не магия, это ремесло. И как в любом ремесле, качество инструментов имеет значение.

Ваша первая программа

Традиционно первая программа выводит фразу «Hello, World!». В контексте Minecraft это похоже на установку первого блока земли. Создайте новый проект в IDEA, создайте класс Main и напишите следующий код:

public class Main {
    public static void main(String[] args) {
        System.out.println("Hello, Minecraft World!");
    }
}

Если в консоли появилась надпись Hello, Minecraft World!, поздравляю — вы только что скрафтили свою первую программу.

2. Переменные: Инвентарь для данных

В Minecraft у вас есть инвентарь, где вы храните предметы. В Java у нас есть переменные. Переменная — это ячейка памяти, у которой есть имя и тип содержимого.

Основные типы данных (Примитивы)

В Java строгая типизация. Это значит, что вы не можете положить ведро лавы в слот для брони. Вы должны четко сказать программе, что именно вы храните.

• int (целые числа): Используется для подсчета предметов, уровня опыта, ID блоков.

  int diamondStack = 64;
  int playerLevel = 30;
  

• double (дробные числа): Используется для здоровья, координат, урона.

  double playerHealth = 20.0; // 10 сердец
  double xCoordinate = 150.5;
  

• boolean (логический тип): Только true (правда) или false (ложь). Идеально для состояний.

  boolean isRaining = false;
  boolean canFly = true;
  

• char (символ): Один символ.

  char direction = 'N'; // North
  

Ссылочный тип: String

Строки — это не примитив, а объект (об этом позже), но используются они повсеместно для текста.

String welcomeMessage = "Добро пожаловать на сервер!";

Для углубленного изучения типов данных обратитесь к Официальной документации Java.

3. Математика и операции

Код — это постоянные вычисления. Расчет урона, траектории стрелы или количества ресурсов для крафта.

Арифметика

Java поддерживает стандартные операции: +, -, *, / и % (остаток от деления).

Представим, что мы рассчитываем итоговый урон меча с учетом силы игрока. Формула может выглядеть так:

$$D_{total} = D_{base} + (S_{level} \times 1.5)$$

Где $D_{total}$ — итоговый урон, $D_{base}$ — базовый урон оружия, а $S_{level}$ — уровень эффекта силы, умноженный на коэффициент $1.5$.

В коде это выглядит так:

double baseDamage = 7.0; // Алмазный меч
int strengthLevel = 2;
double totalDamage = baseDamage + (strengthLevel * 1.5);
System.out.println("Урон: " + totalDamage);

4. Управляющие конструкции: Редстоун-логика

Если переменные — это блоки, то управляющие конструкции — это редстоун. Они решают, что и когда должно произойти.

Условный оператор if-else

Это аналог компаратора. «Если сундук полон, зажечь лампу, иначе — выключить».

Синтаксис:

if (условие) {
    // Действие, если правда
} else {
    // Действие, если ложь
}

Пример из Minecraft: Проверка, жив ли игрок.

double health = 0.0;

if (health <= 0) {
    System.out.println("Игрок погиб! Нажмите 'Respawn'.");
} else {
    System.out.println("Игрок жив. Здоровье: " + health);
}

Логические операторы

Часто нужно проверить несколько условий сразу.

• && (И) — оба условия должны быть верны (как два рычага для одной двери).
• || (ИЛИ) — хотя бы одно условие верно.
• ! (НЕ) — инверсия (как красный факел).

boolean isNight = true;
boolean hasBed = false;

if (isNight && hasBed) {
    System.out.println("Можно спать.");
} else {
    System.out.println("Вы не можете спать сейчас.");
}

Больше примеров кода можно найти в репозитории Java Basics на GitHub.

5. Циклы: Командные блоки и повторители

Иногда нужно повторить действие много раз. Например, построить стену 10x10 или выдать всем игрокам предмет. Вручную писать код 100 раз — плохая идея. Для этого есть циклы.

Цикл for

Используется, когда мы знаем точное количество повторений. Представьте, что вы строите столб из 5 блоков.

// int i = 0 — начало (высота 0)
// i < 5 — условие (пока высота меньше 5)
// i++ — шаг (увеличиваем высоту на 1)

for (int i = 0; i < 5; i++) {
    System.out.println("Установлен блок на высоте " + i);
}

Цикл while

Используется, когда мы не знаем число повторений, но знаем условие. Например, «копать вниз, пока не найдем бедрок».

boolean foundBedrock = false;
int depth = 60;

while (!foundBedrock) {
    depth--; // Копаем вниз
    System.out.println("Копаем... Высота: " + depth);

    if (depth <= -60) {
        foundBedrock = true;
        System.out.println("Бедрок найден!");
    }
}

Практическое задание: Генератор опыта

Давайте объединим знания. Напишем программу, которая рассчитывает, сколько опыта нужно для достижения определенного уровня. В Minecraft формула опыта меняется в зависимости от уровня.

Упрощенная формула для уровней 1-16:

$$XP_{req} = 2 \times L + 7$$

Где $XP_{req}$ — требуемый опыт для следующего уровня, а $L$ — текущий уровень.

Попробуйте реализовать цикл, который считает суммарный опыт с 1 по 10 уровень, используя эту формулу.

Что дальше?

Сегодня мы заложили фундамент. Мы настроили среду (верстак), изучили переменные (инвентарь) и научились управлять потоком программы (редстоун). Эти знания универсальны: они пригодятся и при создании модов через Forge, и при написании плагинов на Spigot.

В следующей статье мы перейдем к Объектно-Ориентированному Программированию (ООП). Мы узнаем, как создавать свои собственные классы, что такое объекты и как описать зомби так, чтобы Java его поняла.

Объектно-ориентированное программирование: Классы и объекты в контексте игровых сущностей

В предыдущей статье мы научились пользоваться инструментами: переменными, условиями и циклами. Это наш «каменный век» программирования. Мы могли написать скрипт, который считает опыт или проверяет здоровье. Но что, если мы хотим создать целый мир, населенный сотнями зомби, скелетов и жителей, каждый из которых имеет свои уникальные характеристики?

Если писать это в одном файле с кучей переменных вроде zombie1Health, zombie2Health, zombie1Speed, мы сойдем с ума быстрее, чем найдем Эндер-дракона. Здесь на сцену выходит Объектно-Ориентированное Программирование (ООП).

Minecraft — это идеальный пример ООП. Вся игра построена на взаимодействии объектов. Сегодня мы узнаем, как описать сущность так, чтобы Java вдохнула в неё жизнь.

1. Философия ООП: Чертеж и Здание

В основе ООП лежат два главных понятия: Класс и Объект.

Представьте, что вы архитектор. У вас есть чертеж дома. Чертеж — это просто бумага (или файл), на которой написано: «Здесь стена, здесь окно, высота 5 блоков». В этом доме нельзя жить, это просто инструкция.

• Класс (Class) — это чертеж, шаблон или описание того, каким должен быть предмет.
• Объект (Object) — это конкретный дом, построенный по этому чертежу в мире. Вы можете построить по одному чертежу целую деревню. Все дома будут иметь одинаковую структуру, но могут отличаться цветом шерсти на полу или содержимым сундуков.

Пример из Minecraft

В коде игры есть файл Zombie.java. Это класс. Он описывает, что зомби умеет рычать и имеет 20 единиц здоровья. Когда вы заходите в игру ночью и видите толпу монстров — каждый отдельный зомби является объектом (или экземпляром) этого класса.

2. Анатомия Класса

Давайте создадим свой собственный класс. Допустим, мы делаем мод и хотим добавить нового моба — DarkKnight (Темный Рыцарь).

Класс в Java состоит из двух основных частей:

1. Поля (Fields) — характеристики (что объект имеет).
2. Методы (Methods) — поведение (что объект делает).

Создайте новый файл DarkKnight.java:

public class DarkKnight {
    // Поля (Характеристики)
    String name;
    int health;
    double damage;
    boolean isAggressive;

    // Методы (Поведение)
    void attack() {
        System.out.println(name + " наносит удар мечом! Урон: " + damage);
    }

    void takeDamage(int amount) {
        health = health - amount;
        System.out.println(name + " получил урон. Осталось здоровья: " + health);
    }
}

Теперь у нас есть чертеж. Но самого рыцаря в мире еще нет.

3. Создание Объектов: Заклинание new

Чтобы «заспавнить» объект в памяти компьютера, мы используем ключевое слово new. Вернемся в наш главный метод main (в файле Main.java из прошлого урока) и создадим рыцаря.

public class Main {
    public static void main(String[] args) {
        // Тип переменной (DarkKnight) -> Имя (knight1) = new Класс();
        DarkKnight knight1 = new DarkKnight();

        // Настраиваем характеристики конкретного рыцаря
        knight1.name = "Сэр Артур";
        knight1.health = 100;
        knight1.damage = 15.5;
        knight1.isAggressive = true;

        // Заставляем его действовать
        knight1.attack();
        knight1.takeDamage(20);
    }
}

Мы можем создать второго рыцаря по тому же чертежу, и он будет полностью независим от первого:

DarkKnight knight2 = new DarkKnight();
knight2.name = "Черный Барон";
knight2.health = 150;
// Если мы изменим здоровье Барона, здоровье Артура НЕ изменится!

4. Конструкторы: Рождение сущности

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

В Minecraft мобы спавнятся уже с характеристиками. Для этого используются Конструкторы. Это специальный метод, который вызывается только один раз — в момент рождения объекта.

Добавим конструктор в наш класс DarkKnight:

public class DarkKnight {
    String name;
    int health;

    // Конструктор называется так же, как и класс, и не имеет типа возврата
    public DarkKnight(String inputName, int inputHealth) {
        name = inputName;
        health = inputHealth;
        System.out.println("В мир призван новый рыцарь: " + name);
    }

    // ... остальные методы
}

Теперь создание объекта выглядит так:

// Мы ОБЯЗАНЫ передать параметры, иначе Java не даст создать объект
DarkKnight boss = new DarkKnight("Король Скелетов", 500);

5. Математика в методах: Расчет дистанции

Игровые сущности постоянно что-то вычисляют. Например, видит ли моб игрока? Для этого нужно рассчитать расстояние между ними.

В двумерном пространстве (если не учитывать высоту $y$) расстояние $d$ между мобом и игроком вычисляется по теореме Пифагора:

$$d = \sqrt{(x_2 - x_1)^2 + (z_2 - z_1)^2}$$

Где $d$ — итоговое расстояние, $x_1, z_1$ — координаты моба, а $x_2, z_2$ — координаты игрока. $\sqrt{...}$ обозначает квадратный корень.

Давайте реализуем метод проверки дистанции в нашем классе. Предположим, у рыцаря есть координаты x и z.

// Внутри класса DarkKnight
double x;
double z;

boolean canSeePlayer(double playerX, double playerZ) {
    // Math.pow(a, 2) возводит число 'a' в квадрат
    // Math.sqrt(a) извлекает корень
    double distance = Math.sqrt(Math.pow(playerX - x, 2) + Math.pow(playerZ - z, 2));

    if (distance < 16.0) { // 16 блоков - стандартная дальность агро
        return true;
    } else {
        return false;
    }
}

Программирование игр — это геометрия, которая ожила.

6. Инкапсуляция: Защита данных

Представьте, что любой плагин на сервере может залезть в код вашего игрока и написать player.health = -1000. Это хаос.

В Java есть принцип Инкапсуляции. Мы прячем внутренние данные и даем доступ к ним только через специальные методы (рычаги).

Для этого используются модификаторы доступа:

• public — доступно всем (как сундук посреди спавна).
• private — доступно только внутри этого класса (как Эндер-сундук).

Правильный подход к созданию класса:

public class Player {
    private int health; // Никто извне не может изменить это напрямую

    public void heal(int amount) {
        if (amount < 0) {
            System.out.println("Нельзя лечить отрицательным числом!");
            return;
        }
        health = health + amount;
    }

    public int getHealth() {
        return health;
    }
}

Теперь, чтобы изменить здоровье, нужно использовать метод heal(), который содержит проверку (защиту от дурака).

Практическое применение: Подготовка к моддингу

Когда вы начнете работать с Minecraft Forge или Spigot API, вы увидите, что там всё состоит из классов и объектов.

Например, в Spigot, чтобы выдать игроку предмет, вы работаете с объектами:

// Пример псевдокода Spigot
Player player = event.getPlayer(); // Получаем объект игрока
Inventory inv = player.getInventory(); // Получаем объект инвентаря
ItemStack diamond = new ItemStack(Material.DIAMOND, 64); // Создаем объект предмета
inv.addItem(diamond); // Вызываем метод добавления

Понимая, что ItemStack — это просто класс, а diamond — это объект, созданный через new, вы перестанете копировать код вслепую и начнете понимать его структуру.

Дополнительные материалы

Для глубокого погружения в тему классов рекомендую:

1. Официальная документация Oracle: Classes and Objects — первоисточник знаний.
2. Репозиторий Java Basics — примеры кода из этой статьи.

Что дальше?

Мы создали рыцаря, но что если мы хотим создать Лучника, который тоже имеет здоровье, но атакует иначе? Копировать весь код? Нет.

В следующей статье мы изучим Наследование и Полиморфизм. Мы узнаем, как создать общий класс Monster и заставить Зомби и Скелетов наследовать его свойства, экономя тысячи строк кода. Готовьтесь, мы переходим к настоящей архитектуре!

Архитектура Minecraft: Создание модов на базе Forge и работа с ресурсами

Поздравляю! Вы прошли путь от «Hello World» до понимания классов, объектов и наследования. Теперь у вас есть ключи от королевства. Знание Java — это суперсила, которая позволяет менять правила игры. Но чтобы применить эту силу в Minecraft, нам нужен проводник.

В этой статье мы разберем архитектуру модинга. Мы не просто напишем код, мы поймем, как устроен «двигатель» игры, как Java-код превращается в блок на экране и почему папка resources так же важна, как и папка java.

1. Что такое Minecraft Forge?

Minecraft, написанный Mojang, изначально не был предназначен для легкого изменения. Код игры обфусцирован (запутан). Если вы попытаетесь читать исходный код игры напрямую, вы увидите классы с именами вроде a.class, b.class и методы func_1234.

Minecraft Forge — это API (Application Programming Interface). Представьте, что это огромный переходник или мост.

• С одной стороны — запутанный код Minecraft.
• С другой стороны — ваш чистый и понятный Java-код.

Forge загружает ваш мод, дает ему доступ к игре и предотвращает конфликты, если вы установите 100 модов одновременно.

Для начала работы вам понадобится MDK (Mod Development Kit). Вы можете скачать его на официальном сайте Forge. Это готовый шаблон проекта, который уже настроен для работы с IntelliJ IDEA.

2. Анатомия проекта: Java и Ресурсы

Когда вы откроете проект мода, вы увидите две главные директории. Это разделение критически важно для понимания архитектуры.

1. src/main/java — Мозги. Здесь живет логика. Классы предметов, искусственный интеллект мобов, расчет урона.
2. src/main/resources — Внешность. Здесь живут текстуры, модели, звуки и переводы.

В чистой Java мы привыкли, что программа просто выводит текст. В играх логика отделена от представления. Если вы создадите класс SuperSword.java, но не добавите текстуру в ресурсы, меч будет работать (бить врагов), но выглядеть как черно-фиолетовый куб (текстура ошибки).

3. Главный класс и точка входа

В обычной Java-программе все начинается с метода public static void main. В моде Minecraft точки входа main нет (её запускает сама игра). Вместо этого мы используем Аннотации.

Аннотация — это метаданные для кода, начинающиеся с символа @. Они говорят Forge: «Эй, посмотри сюда, это важно!».

Ваш главный класс будет выглядеть примерно так:

@Mod("examplemod") // ID вашего мода
public class ExampleMod {
    // Конструктор вызывается, когда Forge загружает мод
    public ExampleMod() {
        // Регистрация событий и блоков
    }
}

Аннотация @Mod сообщает загрузчику, что этот класс является основой мода. ID мода (examplemod) должен быть уникальным, состоять только из строчных букв и не содержать пробелов.

4. Реестры (Registries): Бюрократия Minecraft

Minecraft — это огромная база данных. В игре есть списки (реестры) для всего: блоков, предметов, биомов, звуков, эффектов.

Чтобы ваш предмет появился в игре, недостаточно просто создать объект new Item(). Вы должны официально зарегистрировать его в реестре предметов. Если предмета нет в реестре, для игры он не существует.

В современном Forge используется механизм DeferredRegister (Отложенная регистрация). Это безопасный способ сказать игре: «Когда будешь готова, добавь в свой список вот эти вещи».

Пример создания предмета

Допустим, мы хотим добавить «Рубин».

public class ItemInit {
    // Создаем реестр для ПРЕДМЕТОВ (ITEMS)
    public static final DeferredRegister<Item> ITEMS =
        DeferredRegister.create(ForgeRegistries.ITEMS, "examplemod");

    // Регистрируем сам предмет
    public static final RegistryObject<Item> RUBY = ITEMS.register("ruby",
        () -> new Item(new Item.Properties()));
}

Здесь мы используем лямбда-выражение () -> new Item(...). Это продвинутая тема Java, но пока воспринимайте это как «инструкцию по созданию», которую мы передаем Forge.

5. Клиент и Сервер: Две стороны одной медали

Даже если вы играете в одиночную игру (Singleplayer), Minecraft запускает внутренний сервер. Важно понимать разницу:

• Серверная сторона (Logical Server): Отвечает за логику. Здоровье, движение, крафты, генерация мира, ИИ мобов. Здесь происходят вычисления.
• Клиентская сторона (Logical Client): Отвечает за то, что видит и слышит игрок. Текстуры, модели, звуки, интерфейс (GUI), нажатия клавиш.

Золотое правило: Никогда не пытайтесь загружать текстуры или рисовать интерфейс на стороне сервера. Это приведет к краху (Crash), так как у сервера нет «глаз» (видеокарты).

Для разделения кода используются аннотации @OnlyIn(Dist.CLIENT) или проверки world.isRemote (в старых версиях) или level.isClientSide (в новых).

6. Система Событий (Event Bus)

Как заставить мод реагировать на действия? Например, мы хотим, чтобы при ломании алмазной руды игрока било молнией. Мы не можем залезть в код класса Block и дописать туда эту логику.

Для этого существует Шина Событий (Event Bus). Это как радиостанция. Minecraft постоянно транслирует сообщения:

• «Игрок зашел на сервер!»
• «Блок сломан!»
• «Зомби получил урон!»

Ваш мод может «подписаться» на эти сообщения.

@SubscribeEvent
public void onBlockBreak(BlockEvent.BreakEvent event) {
    // Проверяем, что сломанный блок - алмазная руда
    if (event.getState().getBlock() == Blocks.DIAMOND_ORE) {
        // Логика удара молнией
        Player player = event.getPlayer();
        player.sendMessage(new TextComponent("Не трогай алмазы!"), Util.NIL_UUID);
    }
}

7. Ресурсы: JSON-магия

Вернемся к папке src/main/resources. Чтобы наш Рубин выглядел как рубин, нам нужно создать несколько файлов. Minecraft использует формат JSON для описания моделей.

Для одного простого предмета нужно:

1. Текстура (ruby.png) — картинка 16x16 пикселей.
2. Модель предмета (ruby.json) — файл, который говорит игре: «Используй эту текстуру и отображай её как плоский предмет в руке».
3. Локализация (en_us.json, ru_ru.json) — файл, где написано, что item.examplemod.ruby в игре называется "Рубин".

Пример ruby.json:

{
  "parent": "item/generated",
  "textures": {
    "layer0": "examplemod:item/ruby"
  }
}

«Код дает предмету душу, а ресурсы — тело.»

8. Математика в мире блоков: Координаты

При создании модов вы часто будете работать с координатами. В Minecraft используется трехмерная система координат $(x, y, z)$.

Предположим, вы хотите заспавнить сундук ровно в 5 блоках перед игроком, куда бы он ни смотрел. Для этого нужно использовать векторы.

Формула расчета новой позиции:

$$P_{target} = P_{player} + (V_{look} \times D)$$

Где:

• $P_{target}$ — итоговые координаты ($x, y, z$) места, где появится сундук.
• $P_{player}$ — текущие координаты глаз игрока.
• $V_{look}$ — вектор взгляда игрока (направление, куда он смотрит, нормализованный вектор длиной 1).
• $D$ — дистанция (в нашем случае 5 блоков).

В коде Java это реализуется через методы класса Vec3 (Vector 3D).

Что дальше?

Мы разобрали фундамент архитектуры. Теперь вы знаете, что мод — это сочетание Java-классов, регистрации объектов и JSON-ресурсов, скрепленных вместе через Forge API.

В следующих уроках мы перейдем к практике:

1. Создадим свой первый блок и предмет.
2. Научимся делать крафты.
3. Разберем создание сущностей (мобов).

Для углубленного изучения структуры Forge рекомендую изучать Официальную документацию Forge. Она сложная, но это первоисточник истины.

А пока — проверьте, правильно ли настроена ваша IDE, и попробуйте запустить пустой мод из MDK. Если в главном меню игры появилась кнопка "Mods" и там есть ваш мод — вы готовы к свершениям!

Серверная магия: Разработка плагинов с использованием Spigot API

Добро пожаловать обратно, архитектор кода! В прошлых модулях мы научились ковать моды с помощью Forge, изменяя саму ткань реальности Minecraft. Мы добавляли новые блоки, руды и мобов. Но у модов есть один существенный недостаток: чтобы поиграть с вашим модом, каждый игрок должен установить его себе на компьютер.

А что, если вы хотите изменить правила игры для тысяч игроков сразу, не заставляя их ничего скачивать? Здесь на сцену выходят Плагины.

Сегодня мы погрузимся в мир Spigot API (и его современного форка Paper). Мы узнаем, как писать серверный код, управлять командами, слушать события и использовать Java для администрирования миров.

1. Моды против Плагинов: В чем разница?

Прежде чем писать код, важно понять архитектурное различие.

• Моды (Forge/Fabric): Изменяют код игры (клиента и сервера). Могут добавлять новые блоки, текстуры, модели. Требуют установки у всех игроков.
• Плагины (Spigot/Paper): Работают только на сервере. Они используют уже существующие в игре механики, но меняют их поведение. Вы не можете добавить новый блок с новой текстурой, но вы можете заставить блок земли взрываться при касании.

Плагины — это идеальный способ тренировать чистую логику Java и работу с API без возни с текстурами и моделями.

2. Анатомия Spigot-плагина

Основой разработки плагинов является Spigot API. Это библиотека, предоставляющая удобные Java-классы для управления сервером. Вместо того чтобы копаться в запутанном коде Minecraft (как в Forge), мы используем понятные методы вроде player.sendMessage("Привет!").

Подготовка верстака

Для создания плагина нам понадобятся:

1. JDK (тот же, что и раньше).
2. IntelliJ IDEA.
3. Система сборки (Maven или Gradle). Это инструменты, которые автоматически скачивают нужные библиотеки (в нашем случае Spigot API).

Сердце плагина: JavaPlugin

Любой плагин начинается с главного класса. В отличие от обычной Java-программы, здесь нет метода main. Вместо этого мы наследуемся от класса JavaPlugin.

Вспомним ООП: наследование означает, что наш класс является плагином и получает все его возможности.

package com.example.magicplugin;

import org.bukkit.plugin.java.JavaPlugin;

public class MagicPlugin extends JavaPlugin {

    @Override
    public void onEnable() {
        // Код, который выполняется при запуске сервера
        getLogger().info("Магический плагин успешно загружен!");
    }

    @Override
    public void onDisable() {
        // Код, который выполняется при выключении сервера
        getLogger().info("Магия рассеялась...");
    }
}

Методы onEnable() и onDisable() — это жизненный цикл вашего плагина. Сервер сам вызовет их в нужный момент.

Паспорт плагина: plugin.yml

Spigot не умеет читать мысли. Ему нужно объяснить, где лежит главный класс и как называется плагин. Для этого в папке src/main/resources создается файл plugin.yml.

name: MagicPlugin
version: 1.0
main: com.example.magicplugin.MagicPlugin
api-version: 1.20
commands:
  heal:
    description: Полностью исцеляет игрока
    usage: /heal

Без этого файла сервер просто проигнорирует ваш .jar файл.

3. Команды: Интерфейсы в действии

Самое частое применение плагинов — создание команд. Давайте напишем команду /heal, которая восстанавливает здоровье и голод.

Чтобы класс мог реагировать на команды, он должен реализовать интерфейс CommandExecutor. Интерфейс в Java — это контракт. Если мы подписываем этот контракт (пишем implements), мы обязаны реализовать метод onCommand.

import org.bukkit.command.Command;
import org.bukkit.command.CommandExecutor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;

public class HealCommand implements CommandExecutor {

    @Override
    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
        // 1. Проверяем, кто отправил команду. Это может быть консоль сервера или игрок.
        if (!(sender instanceof Player)) {
            sender.sendMessage("Эту команду может использовать только игрок!");
            return true;
        }

        // 2. Превращаем (кастим) отправителя в Игрока
        Player player = (Player) sender;

        // 3. Применяем логику
        player.setHealth(20.0); // 20 полусердец = 10 сердец
        player.setFoodLevel(20);
        player.sendMessage("§aВы были исцелены магией кода!");

        return true; // Возвращаем true, если команда выполнена успешно
    }
}

Теперь нужно зарегистрировать эту команду в главном классе onEnable():

@Override
public void onEnable() {
    this.getCommand("heal").setExecutor(new HealCommand());
}

4. События: Реакция на мир

В Forge мы использовали шину событий. В Spigot принцип тот же, но синтаксис немного отличается. Мы используем интерфейс Listener и аннотацию @EventHandler.

Допустим, мы хотим сделать «Ботинки Гермеса»: если игрок падает с высоты, он не получает урон.

import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.entity.EntityDamageEvent;
import org.bukkit.entity.Player;

public class FallDamageHandler implements Listener {

    @EventHandler
    public void onDamage(EntityDamageEvent event) {
        // Проверяем, что урон получает именно Игрок, а не зомби
        if (event.getEntity() instanceof Player) {
            // Проверяем причину урона
            if (event.getCause() == EntityDamageEvent.DamageCause.FALL) {
                event.setCancelled(true); // Отменяем событие (урон не проходит)

                Player player = (Player) event.getEntity();
                player.sendMessage("§bВаши крылья спасли вас!");
            }
        }
    }
}

Не забудьте зарегистрировать слушатель в onEnable(): getServer().getPluginManager().registerEvents(new FallDamageHandler(), this);

5. Математика векторов: Запуск игрока

Плагины часто работают с физикой. В Minecraft движение описывается векторами. Вектор — это направление и сила движения.

Представим, мы хотим сделать батут. Когда игрок наступает на золотой блок, его подбрасывает вверх.

Формула изменения скорости игрока:

$$\vec{V}_{new} = \vec{V}_{current} + \vec{V}_{up} \times k$$

Где $\vec{V}_{new}$ — итоговый вектор скорости игрока, $\vec{V}_{current}$ — текущая скорость, $\vec{V}_{up}$ — вектор, направленный строго вверх (0, 1, 0), а $k$ — коэффициент силы подбрасывания (например, 2.0).

В коде Spigot это выглядит элегантно:

@EventHandler
public void onPlayerMove(PlayerMoveEvent event) {
    Player player = event.getPlayer();
    // Получаем блок под ногами
    if (player.getLocation().subtract(0, 1, 0).getBlock().getType() == Material.GOLD_BLOCK) {
        // Создаем вектор вверх (x=0, y=1, z=0) и умножаем его силу на 2
        Vector launch = new Vector(0, 1, 0).multiply(2.0);
        player.setVelocity(launch);
    }
}

«Векторная алгебра — это лучший друг разработчика мини-игр.»

6. Конфигурации: Гибкость кода

Хороший разработчик никогда не пишет магические числа (как 2.0 в примере выше) прямо в коде. А вдруг владелец сервера захочет силу прыжка 5.0? Перекомпилировать плагин каждый раз неудобно.

Spigot имеет встроенную систему config.yml.

1. Создаем config.yml в ресурсах:

   jump-strength: 2.0
   message: "Полетели!"
   

2. В коде onEnable() сохраняем дефолтный конфиг: saveDefaultConfig();
3. Используем значения:

   double strength = plugin.getConfig().getDouble("jump-strength");
   player.setVelocity(new Vector(0, 1, 0).multiply(strength));
   

7. Планировщик задач (Scheduler)

Новички часто совершают фатальную ошибку: используют Thread.sleep(), чтобы сделать задержку. Никогда так не делайте! Minecraft работает в одном главном потоке. Если вы «усыпите» поток, весь сервер замрет: игроки зависнут, мобы остановятся.

Вместо этого используйте BukkitRunnable. Это таймер, который работает синхронно с тиками сервера (20 тиков = 1 секунда).

Пример: Взрыв через 3 секунды.

new BukkitRunnable() {
    @Override
    public void run() {
        player.getWorld().createExplosion(player.getLocation(), 4.0f);
        player.sendMessage("БУМ!");
    }
}.runTaskLater(plugin, 60L); // 60 тиков = 3 секунды

Практическое задание: Бог Грома

Попробуйте создать простой плагин «ThorHammer».

1. Создайте предмет (например, золотой топор).
2. Отследите событие PlayerInteractEvent (клик мышкой).
3. Если игрок кликнул золотым топором, получите блок, на который он смотрит (player.getTargetBlock(...)).
4. Ударьте в это место молнией: world.strikeLightning(location).

Что дальше?

Мы разобрали основы Spigot API. Теперь вы можете создавать команды, менять правила физики и защищать игроков от урона. Это база для создания серверов с мини-играми, экономикой и RPG-системами.

Для углубленного изучения рекомендую Spigot Wiki и Javadocs.

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

Продвинутая Java, основы шейдеров GLSL и реализация итогового проекта

Добро пожаловать в финал курса! Мы прошли долгий путь: от установки JDK и написания «Hello World» до создания собственных модов на Forge и плагинов на Spigot. Вы научились управлять миром Minecraft, но чтобы стать настоящим мастером, нужно заглянуть еще глубже.

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

1. Продвинутая Java: Коллекции и Stream API

До сих пор мы часто использовали массивы (String[] args). Массивы в Java похожи на сундуки в Minecraft: у них фиксированный размер. Если сундук полон, вы не можете положить туда еще один предмет, не создав новый сундук.

В реальной разработке мы не знаем заранее, сколько игроков зайдет на сервер или сколько мобов заспавнится. Нам нужны «резиновые» хранилища. В Java это называется Java Collections Framework.

Основные коллекции

1. ArrayList (Список) Это динамический массив. Он расширяется автоматически, как если бы ваш инвентарь добавлял новые слоты по мере заполнения.

   import java.util.ArrayList;
   import java.util.List;
   
   List<String> players = new ArrayList<>();
   players.add("Steve");
   players.add("Alex");
   // Размер списка теперь 2. Можно добавлять бесконечно.
   

2. HashMap (Словарь/Карта) Хранит пары «Ключ — Значение». Это идеально подходит для хранения статистики игроков. Ключ — это имя игрока (уникальное), а значение — его уровень маны.

   import java.util.HashMap;
   import java.util.Map;
   
   Map<String, Integer> manaStats = new HashMap<>();
   manaStats.put("Steve", 100);
   manaStats.put("Alex", 150);
   
   // Получаем ману Стива мгновенно, не перебирая весь список
   int steveMana = manaStats.get("Steve");
   

Stream API: Конвейер обработки данных

Представьте, что у вас есть список из 1000 игроков, и вам нужно найти всех, у кого здоровье меньше 5, и выдать им эффект регенерации. С помощью обычного цикла for это займет много строк кода.

Stream API позволяет обрабатывать данные декларативно (говорить что сделать, а не как).

List<Player> players = server.getOnlinePlayers();

players.stream()
    .filter(p -> p.getHealth() < 5.0) // 1. Отбираем раненых
    .forEach(p -> p.heal(2.0));       // 2. Лечим каждого

Это мощнейший инструмент для работы с большими объемами данных, который часто используется в плагинах для сортировки топов игроков или фильтрации предметов.

Для углубленного изучения коллекций рекомендую Официальную документацию Java.

2. Основы шейдеров: GLSL

Java выполняется на процессоре (CPU). Она отвечает за логику: кто кого ударил, сколько урона нанесено. Но за красоту картинки — тени, отражения в воде, колыхание травы — отвечает видеокарта (GPU).

Чтобы управлять видеокартой, мы используем язык GLSL (OpenGL Shading Language). Шейдеры — это небольшие программы, которые запускаются миллионы раз в секунду для каждого пикселя или вершины объекта.

Вершинные и Фрагментные шейдеры

В Minecraft (и в большинстве 3D игр) процесс отрисовки делится на два этапа:

1. Vertex Shader (Вершинный шейдер): Отвечает за геометрию. Он берет углы блока (вершины) и решает, где они будут на экране. Именно здесь делается эффект «волнующегося мира» при тошноте или колыхание листвы.
2. Fragment Shader (Фрагментный шейдер): Отвечает за цвет. Он решает, какого цвета будет конкретный пиксель на экране. Здесь рассчитывается освещение, туман и накладываются текстуры.

Пример простого фрагментного шейдера

Синтаксис GLSL похож на C. Давайте напишем шейдер, который делает всё красным (эффект ярости).

#version 120

void main() {
    // gl_FragColor — это итоговый цвет пикселя (R, G, B, Alpha)
    // vec4(1.0, 0.0, 0.0, 1.0) — Красный: 100%, Зеленый: 0%, Синий: 0%, Непрозрачность: 100%
    gl_FragColor = vec4(1.0, 0.0, 0.0, 1.0);
}

Более подробные уроки можно найти в книге The Book of Shaders.

3. Математика света: Векторы

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

Используется Скалярное произведение векторов (Dot Product). Представьте два вектора:

1. $N$ — нормаль поверхности (стрелка, торчащая перпендикулярно из стены).
2. $L$ — направление на источник света (солнце).

Формула освещенности Ламберта:

$$I = \max(0.0, N \cdot L)$$

Где:

• $I$ — интенсивность света (от 0.0 до 1.0).
• $N$ — вектор нормали поверхности.
• $L$ — вектор направления света.
• $\cdot$ — операция скалярного произведения.
• $\max(0.0, ...)$ — функция, которая убирает отрицательные значения (свет не может быть «отрицательным», если он светит сзади).

Если солнце светит прямо в стену, угол между векторами 0, а их произведение максимально ($1.0$). Стена яркая. Если солнце светит сбоку (90 градусов), произведение равно $0.0$. Стена черная.

4. Итоговый проект: «Проклятый Артефакт»

Теперь мы объединим все модули курса в один большой проект. Мы создадим систему, которая требует и клиентского мода, и серверного плагина.

Задача: Создать меч «Пожиратель Душ», который:

1. Имеет уникальную модель и анимацию (Forge Mod).
2. Светится пульсирующим светом (GLSL Shader).
3. Сохраняет количество убитых мобов в базу данных и усиливается с каждым убийством (Spigot Plugin + SQL).

Шаг 1: Мод (Forge) — Визуал

В моде мы создаем предмет SoulEaterItem. Мы регистрируем его в игре. Для рендеринга мы используем кастомный TileEntityRenderer или современные возможности рендеринга предметов в Forge, подключая наш шейдер.

В шейдере мы можем использовать функцию синуса для пульсации цвета:

// time передается из Java-кода
float glow = sin(time * 2.0) * 0.5 + 0.5;
gl_FragColor = vec4(0.5, 0.0, 1.0, 1.0) * glow;

Шаг 2: Плагин (Spigot) — Логика и База Данных

Плагин будет отслеживать убийства. Чтобы данные не пропадали после перезагрузки, мы используем базу данных SQLite. Java умеет работать с базами данных через JDBC.

Пример подключения к базе данных:

import java.sql.Connection;
import java.sql.DriverManager;
import java.sql.PreparedStatement;

// Создаем подключение к файлу базы данных
Connection connection = DriverManager.getConnection("jdbc:sqlite:plugins/SoulEater/data.db");

// SQL-запрос для обновления статистики
String sql = "UPDATE sword_stats SET kills = kills + 1 WHERE player_uuid = ?";
PreparedStatement stmt = connection.prepareStatement(sql);
stmt.setString(1, player.getUniqueId().toString());
stmt.executeUpdate();

Шаг 3: Связь

Когда игрок бьет моба:

1. Spigot-плагин ловит EntityDeathEvent.
2. Обновляет базу данных.
3. Вычисляет новый урон: $D_{new} = D_{base} + (K \times 0.1)$, где $K$ — количество убийств.
4. Отправляет сообщение игроку: «Ваш меч поглотил душу! Урон вырос».

Заключение курса

Поздравляю! Вы прошли путь от новичка до разработчика, способного создавать сложные игровые системы. Вы изучили:

• Синтаксис Java: переменные, циклы, ООП.
• Архитектуру Minecraft: как работают моды и плагины.
• Математику игр: векторы и логику координат.
• Основы графики: как работают шейдеры.

Minecraft — это бесконечный конструктор, а Java — инструкция к нему, которую вы теперь можете переписывать. Не останавливайтесь на достигнутом. Изучайте исходные коды других модов, читайте документацию и создавайте миры, о которых другие только мечтают.

Удачи в коде, и пусть ваши криперы всегда деспавнятся вовремя!