Разработка плагина для Minecraft

public final class MyCoolPlugin extends JavaPlugin {
    public Logger logger = getLogger();
    
    @Override
    public void onEnable() {
        logger.info("Плагин запущен!");
    }
    
    @Override
    public void onDisable() {
        logger.info("Плагин остановлен!");
    }
}

public class MyListener implements Listener {
    
    @EventHandler
    public void onPlayerJoin(PlayerJoinEvent event) {
        Player player = event.getPlayer();
        player.sendMessage("Привет, " + player.getName() + "!");
    }
}

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

@EventHandler(priority = EventPriority.HIGH)
public void onPlayerInteract(PlayerInteractEvent event) {
    // Код обработки
}

Player player = event.getPlayer();
Location location = new Location(player.getWorld(), 100, 64, 100);
player.teleport(location);

Block block = event.getClickedBlock();
if (block.getType() == Material.STONE) {
    block.setType(Material.DIAMOND_BLOCK);
}

// Сохранение дефолтного конфига
saveDefaultConfig();
// Чтение значения с дефолтом
int cooldown = getConfig().getInt("abilities.fireball.cooldown", 30);
// Запись значения
getConfig().set("players." + player.getUniqueId() + ".money", 1000);
saveConfig();

// Создаем ключ
NamespacedKey key = new NamespacedKey(this, "custom_value");
// Получаем контейнер из предмета
ItemStack item = player.getInventory().getItemInMainHand();
ItemMeta meta = item.getItemMeta();
PersistentDataContainer container = meta.getPersistentDataContainer();
 
// Записываем данные
container.set(key, PersistentDataType.INTEGER, 42);
item.setItemMeta(meta);
 
// Читаем данные
if (container.has(key, PersistentDataType.INTEGER)) {
    int value = container.get(key, PersistentDataType.INTEGER);
}

// Создаем результат крафта
ItemStack superSword = new ItemStack(Material.DIAMOND_SWORD);
ItemMeta meta = superSword.getItemMeta();
meta.setDisplayName("§6Супер-меч");
meta.addEnchant(Enchantment.DAMAGE_ALL, 10, true);
superSword.setItemMeta(meta);
 
// Создаем рецепт
ShapedRecipe recipe = new ShapedRecipe(new NamespacedKey(this, "super_sword"), superSword);
recipe.shape("DDD", " S ", " S ");
recipe.setIngredient('D', Material.DIAMOND);
recipe.setIngredient('S', Material.STICK);
 
// Регистрируем рецепт
getServer().addRecipe(recipe);

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

public class HealCommand implements CommandExecutor {
    @Override
    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
        if (!(sender instanceof Player) && args.length == 0) {
            sender.sendMessage("Эту команду может использовать только игрок!");
            return true;
        }
        
        Player target;
        if (args.length == 0) {
            target = (Player) sender;
        } else {
            target = Bukkit.getPlayer(args[0]);
            if (target == null) {
                sender.sendMessage("Игрок " + args[0] + " не найден!");
                return true;
            }
        }
        
        target.setHealth(target.getMaxHealth());
        sender.sendMessage("Здоровье восстановлено!");
        return true;
    }
}

public class HealTabCompleter implements TabCompleter {
    @Override
    public List<String> onTabComplete(CommandSender sender, Command command, String alias, String[] args) {
        if (args.length == 1) {
            List<String> playerNames = new ArrayList<>();
            for (Player player : Bukkit.getOnlinePlayers()) {
                playerNames.add(player.getName());
            }
            return playerNames;
        }
        return null;
    }
}

getCommand("heal").setTabCompleter(new HealTabCompleter());

if (!sender.hasPermission("myplugin.heal")) {
    sender.sendMessage("У вас нет прав для использования этой команды!");
    return true;
}

ItemStack magicWand = new ItemStack(Material.BLAZE_ROD);
ItemMeta meta = magicWand.getItemMeta();
meta.setDisplayName("§5Волшебная палочка");
List<String> lore = new ArrayList<>();
lore.add("§7Создает шар огня");
lore.add("§cПерезарядка: 10 секунд");
meta.setLore(lore);
meta.addEnchant(Enchantment.FIRE_ASPECT, 1, true);
meta.addItemFlags(ItemFlag.HIDE_ENCHANTS);
 
// Добавляем метаданные для идентификации
NamespacedKey key = new NamespacedKey(this, "magic_wand");
meta.getPersistentDataContainer().set(key, PersistentDataType.BYTE, (byte)1);
 
magicWand.setItemMeta(meta);
 
// Дадим этот предмет игроку
player.getInventory().addItem(magicWand);

@EventHandler
public void onPlayerInteract(PlayerInteractEvent event) {
    if (!event.getAction().isRightClick()) return;
    
    ItemStack item = event.getItem();
    if (item == null) return;
    
    ItemMeta meta = item.getItemMeta();
    if (meta == null) return;
    
    NamespacedKey key = new NamespacedKey(this, "magic_wand");
    if (meta.getPersistentDataContainer().has(key, PersistentDataType.BYTE)) {
        // Это наша волшебная палочка!
        Player player = event.getPlayer();
        player.launchProjectile(Fireball.class);
        
        // Здесь можно добавить кулдаун...
    }
}

private Map<UUID, Long> cooldowns = new HashMap<>();
private final long COOLDOWN_TIME = 10 * 1000; // 10 секунд в миллисекундах
 
// Проверка кулдауна
UUID playerId = player.getUniqueId();
long currentTime = System.currentTimeMillis();
 
if (cooldowns.containsKey(playerId) && 
    currentTime - cooldowns.get(playerId) < COOLDOWN_TIME) {
    long remainingTime = (cooldowns.get(playerId) + COOLDOWN_TIME - currentTime) / 1000;
    player.sendMessage("§cПерезарядка: " + remainingTime + " сек.");
    return;
}
 
// Действие выполняется, устанавливаем кулдаун
cooldowns.put(playerId, currentTime);

// Создаем спиральные частицы вокруг игрока
Location loc = player.getLocation();
World world = loc.getWorld();
 
for (double y = 0; y < 2; y += 0.1) {
    double radius = 1.0 - (y / 2);
    for (double angle = 0; angle < Math.PI * 2; angle += Math.PI / 16) {
        double x = Math.cos(angle) * radius;
        double z = Math.sin(angle) * radius;
        Location particleLoc = loc.clone().add(x, y, z);
        world.spawnParticle(Particle.FLAME, particleLoc, 1, 0, 0, 0, 0);
    }
}
 
// Проигрываем звук для всех игроков в радиусе 30 блоков
world.playSound(loc, Sound.ENTITY_ENDER_DRAGON_GROWL, 1.0f, 1.0f);

// Выполнить задачу через 20 тиков (1 секунда)
Bukkit.getScheduler().runTaskLater(this, () -> {
    player.sendMessage("Прошла 1 секунда!");
}, 20L);
 
// Запустить повторяющуюся задачу
int taskId = Bukkit.getScheduler().scheduleSyncRepeatingTask(this, () -> {
    player.sendMessage("Эта задача выполняется каждые 5 секунд!");
}, 0L, 100L); // 0L - начальная задержка, 100L - период (5 секунд)
 
// Отменить задачу
Bukkit.getScheduler().cancelTask(taskId);

Bukkit.getScheduler().runTaskAsynchronously(this, () -> {
    // Тяжелые вычисления или операции ввода-вывода
    // НЕ взаимодействуйте с API Bukkit здесь!
    
    // Вернуться в основной поток для работы с API
    Bukkit.getScheduler().runTask(this, () -> {
        // Безопасно использовать API Bukkit
    });
});

// В методе onEnable()
HikariConfig config = new HikariConfig();
config.setJdbcUrl("jdbc:mysql://localhost:3306/minecraft");
config.setUsername("user");
config.setPassword("pass");
dataSource = new HikariDataSource(config);
 
// Использование
Bukkit.getScheduler().runTaskAsynchronously(this, () -> {
    try (Connection conn = dataSource.getConnection();
         PreparedStatement stmt = conn.prepareStatement("SELECT * FROM players WHERE uuid = ?")) {
        
        stmt.setString(1, player.getUniqueId().toString());
        ResultSet rs = stmt.executeQuery();
        
        if (rs.next()) {
            int balance = rs.getInt("balance");
            
            // Вернуться в основной поток
            Bukkit.getScheduler().runTask(this, () -> {
                player.sendMessage("Ваш баланс: " + balance);
            });
        }
    } catch (SQLException e) {
        e.printStackTrace();
    }
});

// Создание инвентаря-меню
Inventory menu = Bukkit.createInventory(null, 27, "Магазин предметов");
 
// Добавление элементов
ItemStack swordItem = new ItemStack(Material.DIAMOND_SWORD);
ItemMeta swordMeta = swordItem.getItemMeta();
swordMeta.setDisplayName("§6Купить меч");
swordItem.setItemMeta(swordMeta);
menu.setItem(13, swordItem);
 
// Показать меню игроку
player.openInventory(menu);
 
// Обработка кликов
@EventHandler
public void onInventoryClick(InventoryClickEvent event) {
    if (!event.getView().getTitle().equals("Магазин предметов")) return;
    
    event.setCancelled(true); // Отменяем клик для предотвращения взятия предметов
    
    if (event.getCurrentItem() == null) return;
    
    if (event.getCurrentItem().getType() == Material.DIAMOND_SWORD) {
        Player player = (Player) event.getWhoClicked();
        player.sendMessage("Вы купили меч!");
        player.closeInventory();
    }
}

public interface ICommand {
    boolean execute(CommandSender sender, String[] args);
}
 
public class HealCommand implements ICommand {
    @Override
    public boolean execute(CommandSender sender, String[] args) {
        // Логика восстановления здоровья
        return true;
    }
}
 
public class CommandManager {
    private Map<String, ICommand> commands = new HashMap<>();
    
    public void registerCommand(String name, ICommand command) {
        commands.put(name, command);
    }
    
    public boolean executeCommand(CommandSender sender, String commandName, String[] args) {
        if (!commands.containsKey(commandName)) {
            return false;
        }
        return commands.get(commandName).execute(sender, args);
    }
}

public interface CustomEventListener {
    void onPlayerScoreChange(UUID playerId, int newScore);
}
 
public class ScoreManager {
    private Map<UUID, Integer> playerScores = new HashMap<>();
    private List<CustomEventListener> listeners = new ArrayList<>();
    
    public void addListener(CustomEventListener listener) {
        listeners.add(listener);
    }
    
    public void setPlayerScore(UUID playerId, int score) {
        playerScores.put(playerId, score);
        // Уведомляем всех слушателей
        for (CustomEventListener listener : listeners) {
            listener.onPlayerScoreChange(playerId, score);
        }
    }
}

public interface ItemFactory {
    ItemStack createItem();
}
 
public class MagicWandFactory implements ItemFactory {
    private final Plugin plugin;
    
    public MagicWandFactory(Plugin plugin) {
        this.plugin = plugin;
    }
    
    @Override
    public ItemStack createItem() {
        ItemStack wand = new ItemStack(Material.BLAZE_ROD);
        ItemMeta meta = wand.getItemMeta();
        meta.setDisplayName("§5Волшебная палочка");
        
        // Добавляем метаданные
        NamespacedKey key = new NamespacedKey(plugin, "magic_wand");
        meta.getPersistentDataContainer().set(key, PersistentDataType.BYTE, (byte)1);
        
        wand.setItemMeta(meta);
        return wand;
    }
}

public interface SpellStrategy {
    void cast(Player player, ItemStack wand);
}
 
public class FireballSpell implements SpellStrategy {
    @Override
    public void cast(Player player, ItemStack wand) {
        player.launchProjectile(Fireball.class);
    }
}
 
public class LightningSpell implements SpellStrategy {
    @Override
    public void cast(Player player, ItemStack wand) {
        player.getWorld().strikeLightning(player.getTargetBlock(null, 50).getLocation());
    }
}
 
public class SpellManager {
    private Map<String, SpellStrategy> spells = new HashMap<>();
    
    public void registerSpell(String name, SpellStrategy spell) {
        spells.put(name, spell);
    }
    
    public void castSpell(String name, Player player, ItemStack wand) {
        if (spells.containsKey(name)) {
            spells.get(name).cast(player, wand);
        }
    }
}

public interface Weapon {
    void attack(Player player, Entity target);
}
 
public class BaseWeapon implements Weapon {
    private final ItemStack item;
    
    public BaseWeapon(ItemStack item) {
        this.item = item;
    }
    
    @Override
    public void attack(Player player, Entity target) {
        // Базовая атака
        if (target instanceof LivingEntity) {
            ((LivingEntity) target).damage(5, player);
        }
    }
}
 
public abstract class WeaponDecorator implements Weapon {
    protected Weapon decoratedWeapon;
    
    public WeaponDecorator(Weapon weapon) {
        this.decoratedWeapon = weapon;
    }
}
 
public class FireWeaponDecorator extends WeaponDecorator {
    public FireWeaponDecorator(Weapon weapon) {
        super(weapon);
    }
    
    @Override
    public void attack(Player player, Entity target) {
        decoratedWeapon.attack(player, target);
        
        // Дополнительный эффект огня
        target.setFireTicks(100);
    }
}

public abstract class BuildValidator {
    private BuildValidator next;
    
    public BuildValidator setNext(BuildValidator next) {
        this.next = next;
        return next;
    }
    
    public boolean validate(Player player, Block block) {
        boolean result = doValidate(player, block);
        
        if (result && next != null) {
            return next.validate(player, block);
        }
        
        return result;
    }
    
    protected abstract boolean doValidate(Player player, Block block);
}
 
public class PermissionValidator extends BuildValidator {
    @Override
    protected boolean doValidate(Player player, Block block) {
        return player.hasPermission("build.place");
    }
}
 
public class RegionValidator extends BuildValidator {
    @Override
    protected boolean doValidate(Player player, Block block) {
        // Проверка региона
        return true; // Упрощено для примера
    }
}
 
// Использование
BuildValidator validator = new PermissionValidator();
validator.setNext(new RegionValidator());
 
@EventHandler
public void onBlockPlace(BlockPlaceEvent event) {
    if (!validator.validate(event.getPlayer(), event.getBlock())) {
        event.setCancelled(true);
    }
}

public final class MyPlugin extends JavaPlugin {
    private static MyPlugin instance;
    
    @Override
    public void onEnable() {
        instance = this;
        // Остальной код
    }
    
    public static MyPlugin getInstance() {
        return instance;
    }
}

public class ArenaBuilder {
    private String name;
    private Location corner1;
    private Location corner2;
    private GameMode gameMode;
    private int timeLimit = 300; // 5 минут по умолчанию
    private int minPlayers = 2;
    private int maxPlayers = 8;
    private List<Location> spawnPoints = new ArrayList<>();
    
    public ArenaBuilder setName(String name) {
        this.name = name;
        return this;
    }
    
    public ArenaBuilder setBounds(Location corner1, Location corner2) {
        this.corner1 = corner1;
        this.corner2 = corner2;
        return this;
    }
    
    public ArenaBuilder setGameMode(GameMode gameMode) {
        this.gameMode = gameMode;
        return this;
    }
    
    public ArenaBuilder setTimeLimit(int seconds) {
        this.timeLimit = seconds;
        return this;
    }
    
    public ArenaBuilder setPlayerLimits(int min, int max) {
        this.minPlayers = min;
        this.maxPlayers = max;
        return this;
    }
    
    public ArenaBuilder addSpawnPoint(Location location) {
        this.spawnPoints.add(location);
        return this;
    }
    
    public Arena build() {
        // Проверяем обязательные параметры
        if (name == null || corner1 == null || corner2 == null || gameMode == null) {
            throw new IllegalStateException("Не все обязательные параметры указаны!");
        }
        
        if (spawnPoints.size() < minPlayers) {
            throw new IllegalStateException("Недостаточно точек возрождения!");
        }
        
        return new Arena(name, corner1, corner2, gameMode, timeLimit, minPlayers, maxPlayers, spawnPoints);
    }
}

Arena arena = new ArenaBuilder()
    .setName("Дуэльная арена")
    .setBounds(loc1, loc2)
    .setGameMode(GameMode.PVP)
    .setTimeLimit(180)
    .setPlayerLimits(2, 2)
    .addSpawnPoint(spawn1)
    .addSpawnPoint(spawn2)
    .build();

public interface CommandNode {
    boolean execute(CommandSender sender, String[] args);
    List<String> tabComplete(CommandSender sender, String[] args);
}
 
public class LeafCommand implements CommandNode {
    private final String name;
    private final Executable executor;
    
    public LeafCommand(String name, Executable executor) {
        this.name = name;
        this.executor = executor;
    }
    
    @Override
    public boolean execute(CommandSender sender, String[] args) {
        return executor.execute(sender, args);
    }
    
    @Override
    public List<String> tabComplete(CommandSender sender, String[] args) {
        return new ArrayList<>(); // Или реальное автодополнение
    }
}
 
public class CompositeCommand implements CommandNode {
    private final String name;
    private final Map<String, CommandNode> subcommands = new HashMap<>();
    
    public CompositeCommand(String name) {
        this.name = name;
    }
    
    public void addSubcommand(String name, CommandNode command) {
        subcommands.put(name, command);
    }
    
    @Override
    public boolean execute(CommandSender sender, String[] args) {
        if (args.length == 0) {
            // Показать справку по подкомандам
            return true;
        }
        
        CommandNode subcommand = subcommands.get(args[0]);
        if (subcommand == null) {
            sender.sendMessage("Неизвестная подкоманда: " + args[0]);
            return false;
        }
        
        // Передаем подкоманде оставшиеся аргументы
        return subcommand.execute(sender, Arrays.copyOfRange(args, 1, args.length));
    }
    
    @Override
    public List<String> tabComplete(CommandSender sender, String[] args) {
        if (args.length == 1) {
            // Возвращаем список подкоманд
            return new ArrayList<>(subcommands.keySet());
        } else if (args.length > 1) {
            CommandNode subcommand = subcommands.get(args[0]);
            if (subcommand != null) {
                return subcommand.tabComplete(sender, Arrays.copyOfRange(args, 1, args.length));
            }
        }
        
        return new ArrayList<>();
    }
}

public interface GameState {
    void enter();
    void update();
    void exit();
    boolean onPlayerJoin(Player player);
    boolean onPlayerQuit(Player player);
}
 
public class LobbyState implements GameState {
    private final MiniGame game;
    
    public LobbyState(MiniGame game) {
        this.game = game;
    }
    
    @Override
    public void enter() {
        game.broadcastMessage("Ожидание игроков...");
    }
    
    @Override
    public void update() {
        if (game.getPlayers().size() >= game.getMinPlayers()) {
            game.startCountdown(10); // 10 секунд до начала
        }
    }
    
    @Override
    public void exit() {
        game.broadcastMessage("Игра начинается!");
    }
    
    @Override
    public boolean onPlayerJoin(Player player) {
        game.addPlayer(player);
        player.teleport(game.getLobbySpawn());
        game.broadcastMessage(player.getName() + " присоединился! (" 
            + game.getPlayers().size() + "/" + game.getMaxPlayers() + ")");
        return true;
    }
    
    @Override
    public boolean onPlayerQuit(Player player) {
        game.removePlayer(player);
        game.broadcastMessage(player.getName() + " вышел! (" 
            + game.getPlayers().size() + "/" + game.getMaxPlayers() + ")");
        return true;
    }
}
 
public class PlayingState implements GameState {
    private final MiniGame game;
    
    public PlayingState(MiniGame game) {
        this.game = game;
    }
    
    @Override
    public void enter() {
        for (Player player : game.getPlayers()) {
            player.teleport(game.getRandomSpawn());
            player.getInventory().clear();
            player.setHealth(player.getMaxHealth());
            // Выдать стартовый инвентарь
        }
        game.startTimer(game.getTimeLimit());
    }
    
    @Override
    public void update() {
        // Проверить условия завершения игры
        if (game.getAlivePlayers().size() <= 1 || game.getTimeLeft() <= 0) {
            game.changeState(new EndState(game));
        }
    }
    
    @Override
    public void exit() {
        // Отменить все задачи, связанные с игровым процессом
    }
    
    @Override
    public boolean onPlayerJoin(Player player) {
        // Игра уже идет, сделать зрителем или отказать
        player.sendMessage("Игра уже началась!");
        return false;
    }
    
    @Override
    public boolean onPlayerQuit(Player player) {
        game.eliminatePlayer(player);
        game.broadcastMessage(player.getName() + " выбыл из игры!");
        return true;
    }
}

// Никогда не делайте так в основном потоке!
public void onCommand(...) {
    Connection conn = database.getConnection();
    ResultSet rs = conn.executeQuery("SELECT * FROM huge_table");
    // Сервер зависает, пока выполняется запрос
}
 
// Правильный подход
public void onCommand(...) {
    Bukkit.getScheduler().runTaskAsynchronously(plugin, () -> {
        try (Connection conn = database.getConnection()) {
            ResultSet rs = conn.executeQuery("SELECT * FROM huge_table");
            
            // Обрабатываем результаты в асинхронном потоке
            List<PlayerData> players = new ArrayList<>();
            while (rs.next()) {
                players.add(new PlayerData(rs));
            }
            
            // Возвращаемся в основной поток для работы с API
            Bukkit.getScheduler().runTask(plugin, () -> {
                // Здесь безопасно использовать Bukkit API
                for (PlayerData data : players) {
                    Player player = Bukkit.getPlayer(data.getUuid());
                    if (player != null) {
                        player.sendMessage("Ваш баланс: " + data.getBalance());
                    }
                }
            });
        } catch (SQLException e) {
            e.printStackTrace();
        }
    });
}

public abstract class MenuPage {
    protected final Inventory inventory;
    protected final Player player;
    protected final MenuManager manager;
    
    public MenuPage(Player player, String title, int rows, MenuManager manager) {
        this.player = player;
        this.manager = manager;
        this.inventory = Bukkit.createInventory(null, rows * 9, title);
        initializeItems();
    }
    
    protected abstract void initializeItems();
    
    public void open() {
        player.openInventory(inventory);
        manager.registerActiveMenu(player.getUniqueId(), this);
    }
    
    public abstract void handleClick(InventoryClickEvent event);
}
 
public class ShopPage extends MenuPage {
    private int currentPage = 0;
    private final List<ShopItem> items;
    
    public ShopPage(Player player, MenuManager manager, List<ShopItem> items) {
        super(player, "Магазин - Страница " + (currentPage + 1), 6, manager);
        this.items = items;
    }
    
    @Override
    protected void initializeItems() {
        // Очищаем инвентарь
        inventory.clear();
        
        // Добавляем товары для текущей страницы
        int itemsPerPage = 45; // 5 рядов по 9 ячеек
        int startIndex = currentPage * itemsPerPage;
        
        for (int i = 0; i < itemsPerPage && i + startIndex < items.size(); i++) {
            ShopItem shopItem = items.get(i + startIndex);
            inventory.setItem(i, shopItem.createDisplayItem());
        }
        
        // Добавляем кнопки навигации
        if (currentPage > 0) {
            inventory.setItem(45, createNavigationButton("Предыдущая страница"));
        }
        if ((currentPage + 1) * itemsPerPage < items.size()) {
            inventory.setItem(53, createNavigationButton("Следующая страница"));
        }
        
        // Кнопка возврата
        inventory.setItem(49, createNavigationButton("Вернуться"));
    }
    
    @Override
    public void handleClick(InventoryClickEvent event) {
        event.setCancelled(true);
        
        if (event.getCurrentItem() == null) return;
        
        int slot = event.getSlot();
        
        if (slot == 45 && currentPage > 0) {
            currentPage--;
            initializeItems();
        } else if (slot == 53 && (currentPage + 1) * 45 < items.size()) {
            currentPage++;
            initializeItems();
        } else if (slot == 49) {
            // Вернуться в главное меню
            manager.openMainMenu(player);
        } else if (slot < 45) {
            // Клик по товару
            int itemIndex = currentPage * 45 + slot;
            if (itemIndex < items.size()) {
                ShopItem item = items.get(itemIndex);
                // Логика покупки товара
            }
        }
    }
}

public class ExternalApiClient {
    private final String apiKey;
    private final String baseUrl;
    private final OkHttpClient client;
    
    public ExternalApiClient(String apiKey, String baseUrl) {
        this.apiKey = apiKey;
        this.baseUrl = baseUrl;
        this.client = new OkHttpClient.Builder()
            .connectTimeout(10, TimeUnit.SECONDS)
            .readTimeout(30, TimeUnit.SECONDS)
            .build();
    }
    
    public CompletableFuture<Boolean> registerAchievement(UUID playerId, String achievementId) {
        CompletableFuture<Boolean> future = new CompletableFuture<>();
        
        Bukkit.getScheduler().runTaskAsynchronously(MyPlugin.getInstance(), () -> {
            try {
                JSONObject json = new JSONObject();
                json.put("player_id", playerId.toString());
                json.put("achievement_id", achievementId);
                json.put("timestamp", System.currentTimeMillis());
                
                Request request = new Request.Builder()
                    .url(baseUrl + "/achievements")
                    .addHeader("Authorization", "Bearer " + apiKey)
                    .post(RequestBody.create(
                        MediaType.parse("application/json"), json.toString()))
                    .build();
                
                try (Response response = client.newCall(request).execute()) {
                    future.complete(response.isSuccessful());
                }
            } catch (Exception e) {
                e.printStackTrace();
                future.completeExceptionally(e);
            }
        });
        
        return future;
    }
}

public void sendTitle(Player player, String title, String subtitle, int fadeIn, int stay, int fadeOut) {
    try {
        // Получаем версию сервера
        String version = Bukkit.getServer().getClass().getPackage().getName().split("\\.")[3];
        
        // Получаем класс CraftPlayer
        Class<?> craftPlayerClass = Class.forName("org.bukkit.craftbukkit." + version + ".entity.CraftPlayer");
        
        // Получаем объект EntityPlayer
        Object craftPlayer = craftPlayerClass.cast(player);
        Object entityPlayer = craftPlayerClass.getMethod("getHandle").invoke(craftPlayer);
        
        // Получаем соединение игрока
        Object playerConnection = entityPlayer.getClass().getField("playerConnection").get(entityPlayer);
        
        // Создаем пакеты для заголовка и подзаголовка
        Class<?> packetClass = Class.forName("net.minecraft.server." + version + ".PacketPlayOutTitle");
        Class<?> enumTitleAction = Class.forName("net.minecraft.server." + version + ".PacketPlayOutTitle$EnumTitleAction");
        Class<?> chatComponentClass = Class.forName("net.minecraft.server." + version + ".IChatBaseComponent");
        Class<?> chatSerializerClass = Class.forName("net.minecraft.server." + version + ".IChatBaseComponent$ChatSerializer");
        
        Object titleAction = enumTitleAction.getField("TITLE").get(null);
        Object subtitleAction = enumTitleAction.getField("SUBTITLE").get(null);
        
        Object titleComponent = chatSerializerClass.getMethod("a", String.class)
            .invoke(null, "{\"text\":\"" + title + "\"}");
        Object subtitleComponent = chatSerializerClass.getMethod("a", String.class)
            .invoke(null, "{\"text\":\"" + subtitle + "\"}");
        
        // Создаем и отправляем пакет времени
        Constructor<?> titleConstructor = packetClass.getConstructor(enumTitleAction, chatComponentClass, int.class, int.class, int.class);
        Object titleTimesPacket = packetClass.getConstructor(int.class, int.class, int.class)
            .newInstance(fadeIn, stay, fadeOut);
        
        // Отправляем пакеты
        playerConnection.getClass().getMethod("sendPacket", Class.forName("net.minecraft.server." + version + ".Packet"))
            .invoke(playerConnection, titleTimesPacket);
        
        Object titlePacket = titleConstructor.newInstance(titleAction, titleComponent, fadeIn, stay, fadeOut);
        playerConnection.getClass().getMethod("sendPacket", Class.forName("net.minecraft.server." + version + ".Packet"))
            .invoke(playerConnection, titlePacket);
        
        Object subtitlePacket = titleConstructor.newInstance(subtitleAction, subtitleComponent, fadeIn, stay, fadeOut);
        playerConnection.getClass().getMethod("sendPacket", Class.forName("net.minecraft.server." + version + ".Packet"))
            .invoke(playerConnection, subtitlePacket);
        
    } catch (Exception e) {
        e.printStackTrace();
    }
}

public class NMSHandler {
    private static final String VERSION = Bukkit.getServer().getClass().getPackage().getName().split("\\.")[3];
    
    public static Class<?> getNMSClass(String className) {
        try {
            return Class.forName("net.minecraft.server." + VERSION + "." + className);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            return null;
        }
    }
    
    public static Class<?> getCraftBukkitClass(String className) {
        try {
            return Class.forName("org.bukkit.craftbukkit." + VERSION + "." + className);
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
            return null;
        }
    }
}

public static void spawnHologram(Location location, String text) {
    try {
        // Создаем ArmorStand с невидимыми атрибутами
        Object world = location.getWorld().getClass().getMethod("getHandle").invoke(location.getWorld());
        
        Class<?> entityArmorStandClass = getNMSClass("EntityArmorStand");
        Constructor<?> constructor = entityArmorStandClass.getConstructor(getNMSClass("World"), double.class, double.class, double.class);
        
        Object armorStand = constructor.newInstance(world, location.getX(), location.getY(), location.getZ());
        
        // Настраиваем свойства ArmorStand
        entityArmorStandClass.getMethod("setInvisible", boolean.class).invoke(armorStand, true);
        entityArmorStandClass.getMethod("setCustomNameVisible", boolean.class).invoke(armorStand, true);
        entityArmorStandClass.getMethod("setGravity", boolean.class).invoke(armorStand, false);
        
        // Устанавливаем текст
        Class<?> chatComponentClass = getNMSClass("IChatBaseComponent");
        Class<?> chatSerializerClass = getNMSClass("IChatBaseComponent$ChatSerializer");
        Object chatComponent = chatSerializerClass.getMethod("a", String.class).invoke(null, "{\"text\":\"" + text + "\"}");
        
        entityArmorStandClass.getMethod("setCustomName", chatComponentClass).invoke(armorStand, chatComponent);
        
        // Спавним ArmorStand для всех игроков
        Class<?> worldClass = getNMSClass("World");
        worldClass.getMethod("addEntity", getNMSClass("Entity")).invoke(world, armorStand);
        
    } catch (Exception e) {
        e.printStackTrace();
    }
}

public void sendFakeBlock(Player player, Location location, Material material) {
    try {
        // Получаем соединение игрока
        Object craftPlayer = getCraftBukkitClass("entity.CraftPlayer").cast(player);
        Object entityPlayer = craftPlayer.getClass().getMethod("getHandle").invoke(craftPlayer);
        Object connection = entityPlayer.getClass().getField("playerConnection").get(entityPlayer);
        
        // Создаем информацию о блоке
        Object blockPosition = getNMSClass("BlockPosition")
            .getConstructor(int.class, int.class, int.class)
            .newInstance(location.getBlockX(), location.getBlockY(), location.getBlockZ());
        
        // Получаем материал блока
        Object craftBlock = getCraftBukkitClass("util.CraftMagicNumbers")
            .getMethod("getBlock", Material.class)
            .invoke(null, material);
        
        // Создаем пакет изменения блока
        Object blockChangePacket = getNMSClass("PacketPlayOutBlockChange")
            .getConstructor()
            .newInstance();
        
        blockChangePacket.getClass().getField("a").set(blockChangePacket, blockPosition);
        blockChangePacket.getClass().getField("block").set(blockChangePacket, craftBlock);
        
        // Отправляем пакет
        connection.getClass()
            .getMethod("sendPacket", getNMSClass("Packet"))
            .invoke(connection, blockChangePacket);
            
    } catch (Exception e) {
        e.printStackTrace();
    }
}

public class PluginChannelManager implements PluginMessageListener {
    private final Plugin plugin;
    private final String channel;
    
    public PluginChannelManager(Plugin plugin, String channel) {
        this.plugin = plugin;
        this.channel = channel;
        
        plugin.getServer().getMessenger().registerOutgoingPluginChannel(plugin, channel);
        plugin.getServer().getMessenger().registerIncomingPluginChannel(plugin, channel, this);
    }
    
    public void sendData(Player player, byte[] data) {
        player.sendPluginMessage(plugin, channel, data);
    }
    
    @Override
    public void onPluginMessageReceived(String channel, Player player, byte[] message) {
        if (!channel.equals(this.channel)) return;
        
        // Обработка полученных данных
        ByteArrayInputStream stream = new ByteArrayInputStream(message);
        DataInputStream in = new DataInputStream(stream);
        
        try {
            // Пример чтения строки из сообщения
            String subChannel = in.readUTF();
            
            if (subChannel.equals("SomeAction")) {
                // Выполнить действие на основе полученных данных
                String additionalData = in.readUTF();
                // ...
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

public class SpatialHashGrid {
    private final int cellSize;
    private final Map<Long, List<Entity>> grid = new HashMap<>();
    
    public SpatialHashGrid(int cellSize) {
        this.cellSize = cellSize;
    }
    
    private long hashPosition(Location location) {
        int x = (int) Math.floor(location.getX() / cellSize);
        int y = (int) Math.floor(location.getY() / cellSize);
        int z = (int) Math.floor(location.getZ() / cellSize);
        
        return ((long)x << 42) | ((long)y << 21) | z;
    }
    
    public void insertEntity(Entity entity) {
        long hash = hashPosition(entity.getLocation());
        grid.computeIfAbsent(hash, k -> new ArrayList<>()).add(entity);
    }
    
    public List<Entity> getNearbyEntities(Location location, double radius) {
        Set<Long> cellsToCheck = new HashSet<>();
        List<Entity> result = new ArrayList<>();
        
        // Определяем все ячейки в радиусе поиска
        int radiusCells = (int) Math.ceil(radius / cellSize);
        int baseX = (int) Math.floor(location.getX() / cellSize);
        int baseY = (int) Math.floor(location.getY() / cellSize);
        int baseZ = (int) Math.floor(location.getZ() / cellSize);
        
        for (int x = -radiusCells; x <= radiusCells; x++) {
            for (int y = -radiusCells; y <= radiusCells; y++) {
                for (int z = -radiusCells; z <= radiusCells; z++) {
                    long hash = ((long)(baseX + x) << 42) | ((long)(baseY + y) << 21) | (baseZ + z);
                    cellsToCheck.add(hash);
                }
            }
        }
        
        // Собираем все сущности из выбранных ячеек
        double radiusSquared = radius * radius;
        for (Long hash : cellsToCheck) {
            List<Entity> entitiesInCell = grid.get(hash);
            if (entitiesInCell != null) {
                for (Entity entity : entitiesInCell) {
                    if (entity.getLocation().distanceSquared(location) <= radiusSquared) {
                        result.add(entity);
                    }
                }
            }
        }
        
        return result;
    }
}

public class DebugRenderer {
    public static void drawLine(Location start, Location end, Particle particle, double density) {
        World world = start.getWorld();
        double distance = start.distance(end);
        Vector direction = end.toVector().subtract(start.toVector()).normalize();
        
        for (double d = 0; d < distance; d += 1.0 / density) {
            Location point = start.clone().add(direction.clone().multiply(d));
            world.spawnParticle(particle, point, 1, 0, 0, 0, 0);
        }
    }
    
    public static void drawCube(Location center, double size, Particle particle) {
        double half = size / 2;
        World world = center.getWorld();
        
        Location p1 = center.clone().add(-half, -half, -half);
        Location p2 = center.clone().add(half, -half, -half);
        Location p3 = center.clone().add(half, -half, half);
        Location p4 = center.clone().add(-half, -half, half);
        Location p5 = center.clone().add(-half, half, -half);
        Location p6 = center.clone().add(half, half, -half);
        Location p7 = center.clone().add(half, half, half);
        Location p8 = center.clone().add(-half, half, half);
        
        // Нижняя грань
        drawLine(p1, p2, particle, 10);
        drawLine(p2, p3, particle, 10);
        drawLine(p3, p4, particle, 10);
        drawLine(p4, p1, particle, 10);
        
        // Верхняя грань
        drawLine(p5, p6, particle, 10);
        drawLine(p6, p7, particle, 10);
        drawLine(p7, p8, particle, 10);
        drawLine(p8, p5, particle, 10);
        
        // Стороны
        drawLine(p1, p5, particle, 10);
        drawLine(p2, p6, particle, 10);
        drawLine(p3, p7, particle, 10);
        drawLine(p4, p8, particle, 10);
    }
}

dev/
  ├── server/
  │     ├── plugins/
  │     ├── server.jar
  │     └── ...
  ├── test-scripts/
  │     ├── start-server.bat
  │     ├── compile-and-deploy.bat
  │     └── ...
  └── mock-players/
        ├── player1.js
        └── ...

public class SimpleProfiler {
  private final Map<String, Long> startTimes = new HashMap<>();
  private final Map<String, Long> totalTimes = new HashMap<>();
  private final Map<String, Integer> counts = new HashMap<>();
  
  public void start(String section) {
      startTimes.put(section, System.nanoTime());
  }
  
  public void end(String section) {
      if (!startTimes.containsKey(section)) {
          return;
      }
      
      long time = System.nanoTime() - startTimes.get(section);
      totalTimes.put(section, totalTimes.getOrDefault(section, 0L) + time);
      counts.put(section, counts.getOrDefault(section, 0) + 1);
  }
  
  public void printResults() {
      List<Map.Entry<String, Long>> entries = new ArrayList<>(totalTimes.entrySet());
      entries.sort(Map.Entry.<String, Long>comparingByValue().reversed());
      
      System.out.println("=== Результаты профилирования ===");
      for (Map.Entry<String, Long> entry : entries) {
          String section = entry.getKey();
          long total = entry.getValue();
          int count = counts.getOrDefault(section, 1);
          double avg = (double) total / count / 1_000_000; // в миллисекундах
          
          System.out.printf("%s: выполнено %d раз, среднее время: %.3f мс\n", 
              section, count, avg);
      }
  }
}

public interface VersionAdapter {
  void sendActionBar(Player player, String message);
  void spawnParticle(Location location, String particleType);
  // ... другие методы, зависящие от версии
}
 
public class VersionAdapterFactory {
  public static VersionAdapter getAdapter() {
      String version = Bukkit.getServer().getClass().getPackage().getName().split("\\.")[3];
      
      if (version.startsWith("v1_8")) {
          return new V1_8_Adapter();
      } else if (version.startsWith("v1_12")) {
          return new V1_12_Adapter();
      } else {
          return new ModernAdapter(); // 1.13+
      }
  }
}

try {
  // Потенциально опасный код
} catch (Exception e) {
  plugin.getLogger().severe("Произошла ошибка при выполнении операции!");
  plugin.getLogger().severe("Детали: " + e.getMessage());
  
  StringWriter sw = new StringWriter();
  e.printStackTrace(new PrintWriter(sw));
  plugin.getLogger().severe("Стек вызовов: " + sw.toString());
}

public void handleCriticalError(String feature, Exception e) {
  disabledFeatures.add(feature);
  
  getLogger().severe("====== КРИТИЧЕСКАЯ ОШИБКА ======");
  getLogger().severe("Функция '" + feature + "' отключена из-за ошибки!");
  getLogger().severe("Причина: " + e.getMessage());
  e.printStackTrace();
  
  // Уведомить администраторов онлайн
  for (Player player : Bukkit.getOnlinePlayers()) {
      if (player.hasPermission("myplugin.admin")) {
          player.sendMessage(ChatColor.RED + "[MyPlugin] Критическая ошибка в функции '" 
              + feature + "'. Проверьте консоль!");
      }
  }
}

com.myserver.telecompass/
├── TeleCompass.java           // Основной класс плагина
├── commands/                  // Командные обработчики
│   ├── CommandManager.java
│   ├── GiveCommand.java
│   └── ReloadCommand.java
├── config/                    // Управление конфигурацией
│   ├── ConfigManager.java
│   └── Messages.java
├── items/                     // Фабрики предметов
│   ├── ItemFactory.java
│   └── TelecompassFactory.java
├── listeners/                 // Обработчики событий
│   ├── CraftingListener.java
│   └── TeleportListener.java
└── utils/                     // Вспомогательные классы
    ├── ParticleUtils.java
    └── CooldownManager.java

public final class TeleCompass extends JavaPlugin {
    private static TeleCompass instance;
    private ConfigManager configManager;
    private CommandManager commandManager;
    private CooldownManager cooldownManager;
    
    @Override
    public void onEnable() {
        instance = this;
        
        // Инициализация менеджеров
        configManager = new ConfigManager(this);
        cooldownManager = new CooldownManager(this);
        commandManager = new CommandManager(this);
        
        // Регистрация команд
        commandManager.registerCommand("telecompass", new GiveCommand(this));
        commandManager.registerCommand("telecompassreload", new ReloadCommand(this));
        
        // Регистрация обработчиков событий
        getServer().getPluginManager().registerEvents(new CraftingListener(this), this);
        getServer().getPluginManager().registerEvents(new TeleportListener(this), this);
        
        // Регистрация рецепта
        Bukkit.addRecipe(TelecompassFactory.createRecipe(this));
        
        getLogger().info("TeleCompass активирован!");
    }
    
    @Override
    public void onDisable() {
        getLogger().info("TeleCompass деактивирован!");
    }
    
    public static TeleCompass getInstance() {
        return instance;
    }
    
    public ConfigManager getConfigManager() {
        return configManager;
    }
    
    public CooldownManager getCooldownManager() {
        return cooldownManager;
    }
}

public interface ICommand {
    boolean execute(CommandSender sender, String[] args);
    List<String> tabComplete(CommandSender sender, String[] args);
}
 
public class CommandManager implements CommandExecutor, TabCompleter {
    private final TeleCompass plugin;
    private final Map<String, ICommand> commands = new HashMap<>();
    
    public CommandManager(TeleCompass plugin) {
        this.plugin = plugin;
    }
    
    public void registerCommand(String name, ICommand command) {
        commands.put(name.toLowerCase(), command);
        PluginCommand pluginCommand = plugin.getCommand(name);
        if (pluginCommand != null) {
            pluginCommand.setExecutor(this);
            pluginCommand.setTabCompleter(this);
        }
    }
    
    @Override
    public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
        ICommand command = commands.get(cmd.getName().toLowerCase());
        if (command != null) {
            return command.execute(sender, args);
        }
        return false;
    }
    
    @Override
    public List<String> onTabComplete(CommandSender sender, Command cmd, String alias, String[] args) {
        ICommand command = commands.get(cmd.getName().toLowerCase());
        if (command != null) {
            return command.tabComplete(sender, args);
        }
        return null;
    }
}

public class ConfigManager {
    private final TeleCompass plugin;
    private FileConfiguration config;
    private Messages messages;
    
    public ConfigManager(TeleCompass plugin) {
        this.plugin = plugin;
        reload();
    }
    
    public void reload() {
        plugin.saveDefaultConfig();
        plugin.reloadConfig();
        config = plugin.getConfig();
        messages = new Messages(this);
    }
    
    public int getCooldownTime() {
        return config.getInt("cooldown", 30);
    }
    
    public boolean isPermissionRequired() {
        return config.getBoolean("require_permission", true);
    }
    
    public FileConfiguration getConfig() {
        return config;
    }
    
    public Messages getMessages() {
        return messages;
    }
}

public class TelecompassFactory {
    private static final int CUSTOM_MODEL_DATA = 1;
    
    public static ItemStack create() {
        ItemStack telecompass = new ItemStack(Material.COMPASS);
        ItemMeta meta = telecompass.getItemMeta();
        
        // Устанавливаем имя и описание
        meta.setDisplayName(ChatColor.LIGHT_PURPLE + "Телекомпас");
        List<String> lore = new ArrayList<>();
        lore.add(ChatColor.GRAY + "Привяжите к лодстоуну, затем");
        lore.add(ChatColor.GRAY + "используйте для телепортации.");
        meta.setLore(lore);
        
        // Добавляем метаданные для идентификации
        NamespacedKey key = new NamespacedKey(TeleCompass.getInstance(), "telecompass");
        meta.getPersistentDataContainer().set(key, PersistentDataType.BYTE, (byte)1);
        
        // Устанавливаем Custom Model Data для ресурспака
        meta.setCustomModelData(CUSTOM_MODEL_DATA);
        
        telecompass.setItemMeta(meta);
        return telecompass;
    }
    
    public static ShapedRecipe createRecipe(TeleCompass plugin) {
        ItemStack telecompass = create();
        NamespacedKey key = new NamespacedKey(plugin, "telecompass_recipe");
        
        ShapedRecipe recipe = new ShapedRecipe(key, telecompass);
        recipe.shape("EPE", "ECE", "EEE");
        recipe.setIngredient('E', Material.ENDER_PEARL);
        recipe.setIngredient('P', Material.ENDER_EYE);
        recipe.setIngredient('C', Material.COMPASS);
        
        return recipe;
    }
    
    public static boolean isTelecompass(ItemStack item) {
        if (item == null || item.getType() != Material.COMPASS) {
            return false;
        }
        
        ItemMeta meta = item.getItemMeta();
        if (meta == null) {
            return false;
        }
        
        NamespacedKey key = new NamespacedKey(TeleCompass.getInstance(), "telecompass");
        return meta.getPersistentDataContainer().has(key, PersistentDataType.BYTE);
    }
}

public class TeleportListener implements Listener {
    private final TeleCompass plugin;
    
    public TeleportListener(TeleCompass plugin) {
        this.plugin = plugin;
    }
    
    @EventHandler(priority = EventPriority.HIGH)
    public void onPlayerInteract(PlayerInteractEvent event) {
        // Проверяем, что игрок кликнул правой кнопкой мыши
        if (!event.getAction().isRightClick()) {
            return;
        }
        
        Player player = event.getPlayer();
        ItemStack item = player.getInventory().getItemInMainHand();
        
        // Проверяем, что предмет - телекомпас
        if (!TelecompassFactory.isTelecompass(item)) {
            return;
        }
        
        // Проверяем разрешение на использование
        if (plugin.getConfigManager().isPermissionRequired() && 
            !player.hasPermission("telecompass.use")) {
            player.sendMessage(plugin.getConfigManager().getMessages().getNoPermission());
            event.setCancelled(true);
            return;
        }
        
        // Если игрок кликает на лодстоун, позволяем стандартное взаимодействие
        if (event.getClickedBlock() != null && 
            event.getClickedBlock().getType() == Material.LODESTONE) {
            // Не отменяем событие - компас привяжется к лодстоуну
            return;
        }
        
        // Проверяем кулдаун
        if (!plugin.getCooldownManager().canUse(player)) {
            long remaining = plugin.getCooldownManager().getRemainingTime(player);
            player.sendMessage(plugin.getConfigManager().getMessages().getCooldownMessage(remaining));
            event.setCancelled(true);
            return;
        }
        
        // Телепортируем игрока
        teleportPlayer(player, item);
        event.setCancelled(true);
    }
    
    private void teleportPlayer(Player player, ItemStack compass) {
        ItemMeta meta = compass.getItemMeta();
        if (!(meta instanceof CompassMeta)) {
            player.sendMessage(plugin.getConfigManager().getMessages().getNotLinked());
            return;
        }
        
        CompassMeta compassMeta = (CompassMeta) meta;
        if (!compassMeta.isLodestoneTracked()) {
            player.sendMessage(plugin.getConfigManager().getMessages().getNotLinked());
            return;
        }
        
        Location destination = compassMeta.getLodestone();
        if (destination == null) {
            player.sendMessage(plugin.getConfigManager().getMessages().getNotLinked());
            return;
        }
        
        // Запоминаем начальную позицию для эффектов
        Location startLoc = player.getLocation().clone();
        
        // Эффекты перед телепортацией
        ParticleUtils.spawnTeleportParticles(startLoc);
        startLoc.getWorld().playSound(startLoc, Sound.ENTITY_ENDERMAN_TELEPORT, 1.0f, 1.0f);
        
        // Телепортация
        player.teleport(destination);
        
        // Эффекты после телепортации
        ParticleUtils.spawnTeleportParticles(destination);
        destination.getWorld().playSound(destination, Sound.ENTITY_ENDERMAN_TELEPORT, 1.0f, 1.0f);
        
        // Устанавливаем кулдаун
        plugin.getCooldownManager().setCooldown(player);
        
        player.sendMessage(plugin.getConfigManager().getMessages().getTeleportSuccess());
    }
}

public class CooldownManager {
    private final TeleCompass plugin;
    private final Map<UUID, Long> cooldowns = new HashMap<>();
    
    public CooldownManager(TeleCompass plugin) {
        this.plugin = plugin;
    }
    
    public boolean canUse(Player player) {
        // Игроки с особым разрешением могут игнорировать кулдаун
        if (player.hasPermission("telecompass.nocooldown")) {
            return true;
        }
        
        UUID playerId = player.getUniqueId();
        if (!cooldowns.containsKey(playerId)) {
            return true;
        }
        
        long lastUsed = cooldowns.get(playerId);
        long currentTime = System.currentTimeMillis();
        int cooldownTime = plugin.getConfigManager().getCooldownTime() * 1000; // в миллисекундах
        
        return currentTime - lastUsed >= cooldownTime;
    }
    
    public long getRemainingTime(Player player) {
        UUID playerId = player.getUniqueId();
        if (!cooldowns.containsKey(playerId)) {
            return 0;
        }
        
        long lastUsed = cooldowns.get(playerId);
        long currentTime = System.currentTimeMillis();
        int cooldownTime = plugin.getConfigManager().getCooldownTime() * 1000;
        
        long remaining = (lastUsed + cooldownTime - currentTime) / 1000;
        return Math.max(0, remaining);
    }
    
    public void setCooldown(Player player) {
        cooldowns.put(player.getUniqueId(), System.currentTimeMillis());
    }
}

public class ParticleUtils {
    public static void spawnTeleportParticles(Location location) {
        World world = location.getWorld();
        
        // Создаем спиральные частицы портала
        for (double y = 0; y < 2; y += 0.1) {
            double radius = 1.0 - (y / 2);
            for (double angle = 0; angle < Math.PI * 2; angle += Math.PI / 16) {
                double x = Math.cos(angle) * radius;
                double z = Math.sin(angle) * radius;
                Location particleLoc = location.clone().add(x, y, z);
                world.spawnParticle(Particle.PORTAL, particleLoc, 2, 0, 0, 0, 0.05);
            }
        }
        
        // Добавляем облако частиц в центре
        world.spawnParticle(Particle.REVERSE_PORTAL, location.clone().add(0, 1, 0), 
                            50, 0.5, 0.5, 0.5, 0.1);
    }
}

public class Messages {
    private final ConfigManager configManager;
    private String noPermission;
    private String cooldownMessage;
    private String notLinked;
    private String teleportSuccess;
    
    public Messages(ConfigManager configManager) {
        this.configManager = configManager;
        loadMessages();
    }
    
    private void loadMessages() {
        FileConfiguration config = configManager.getConfig();
        noPermission = ChatColor.translateAlternateColorCodes('&', 
                      config.getString("messages.no_permission", "&cУ вас нет разрешения!"));
        
        cooldownMessage = ChatColor.translateAlternateColorCodes('&', 
                         config.getString("messages.cooldown", "&cПодождите еще {time} сек.!"));
        
        notLinked = ChatColor.translateAlternateColorCodes('&', 
                   config.getString("messages.not_linked", "&cКомпас не привязан к лодстоуну!"));
        
        teleportSuccess = ChatColor.translateAlternateColorCodes('&', 
                         config.getString("messages.teleport_success", "&aТелепортация успешна!"));
    }
    
    public String getNoPermission() {
        return noPermission;
    }
    
    public String getCooldownMessage(long remainingSeconds) {
        return cooldownMessage.replace("{time}", String.valueOf(remainingSeconds));
    }
    
    public String getNotLinked() {
        return notLinked;
    }
    
    public String getTeleportSuccess() {
        return teleportSuccess;
    }
}

public class GiveCommand implements ICommand {
    private final TeleCompass plugin;
    
    public GiveCommand(TeleCompass plugin) {
        this.plugin = plugin;
    }
    
    @Override
    public boolean execute(CommandSender sender, String[] args) {
        // Проверка разрешения
        if (!sender.hasPermission("telecompass.give")) {
            sender.sendMessage(plugin.getConfigManager().getMessages().getNoPermission());
            return true;
        }
        
        Player target;
        
        // Определяем получателя
        if (args.length > 0) {
            target = Bukkit.getPlayer(args[0]);
            if (target == null) {
                sender.sendMessage(ChatColor.RED + "Игрок не найден!");
                return true;
            }
        } else if (sender instanceof Player) {
            target = (Player) sender;
        } else {
            sender.sendMessage(ChatColor.RED + "Укажите игрока!");
            return true;
        }
        
        // Выдаем телекомпас
        ItemStack telecompass = TelecompassFactory.create();
        target.getInventory().addItem(telecompass);
        
        sender.sendMessage(ChatColor.GREEN + "Телекомпас выдан игроку " + target.getName() + "!");
        return true;
    }
    
    @Override
    public List<String> tabComplete(CommandSender sender, String[] args) {
        if (args.length == 1) {
            List<String> players = new ArrayList<>();
            for (Player player : Bukkit.getOnlinePlayers()) {
                players.add(player.getName());
            }
            return players;
        }
        return Collections.emptyList();
    }
}

public class ReloadCommand implements ICommand {
  private final TeleCompass plugin;
  
  public ReloadCommand(TeleCompass plugin) {
      this.plugin = plugin;
  }
  
  @Override
  public boolean execute(CommandSender sender, String[] args) {
      if (!sender.hasPermission("telecompass.reload")) {
          sender.sendMessage(plugin.getConfigManager().getMessages().getNoPermission());
          return true;
      }
      
      plugin.getConfigManager().reload();
      sender.sendMessage(ChatColor.GREEN + "Конфигурация плагина TeleCompass перезагружена!");
      return true;
  }
  
  @Override
  public List<String> tabComplete(CommandSender sender, String[] args) {
      return Collections.emptyList(); // Нет параметров для автодополнения
  }
}

public class CraftingListener implements Listener {
  private final TeleCompass plugin;
  
  public CraftingListener(TeleCompass plugin) {
      this.plugin = plugin;
  }
  
  @EventHandler
  public void onCraft(CraftItemEvent event) {
      ItemStack result = event.getRecipe().getResult();
      
      if (TelecompassFactory.isTelecompass(result)) {
          Player player = (Player) event.getWhoClicked();
          
          if (plugin.getConfigManager().isPermissionRequired() && 
              !player.hasPermission("telecompass.craft")) {
              
              event.setCancelled(true);
              player.sendMessage(plugin.getConfigManager().getMessages().getNoPermission());
              player.closeInventory();
          }
      }
  }
}

resourcepack/
├── pack.mcmeta
├── pack.png
└── assets/
    └── minecraft/
        └── models/
            └── item/
                └── compass.json