Files
assets
resource-pack
src
build.gradle
settings.gradle
Code
11 330
src/main/java/com/kodari/grappler/DiamondGrapplingHook.java
package com.kodari.grappler;

import com.cryptomorin.xseries.XMaterial;
import com.cryptomorin.xseries.XSound;
import com.cryptomorin.xseries.particles.XParticle;
import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.Location;
import org.bukkit.Material;
import org.bukkit.NamespacedKey;
import org.bukkit.Particle;
import org.bukkit.Sound;
import org.bukkit.World;
import org.bukkit.block.Block;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.entity.Snowball;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.block.Action;
import org.bukkit.event.entity.ProjectileHitEvent;
import org.bukkit.event.inventory.InventoryClickEvent;
import org.bukkit.event.inventory.InventoryDragEvent;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.event.player.PlayerQuitEvent;
import org.bukkit.inventory.Inventory;
import org.bukkit.inventory.InventoryHolder;
import org.bukkit.inventory.ItemStack;
import org.bukkit.inventory.ShapedRecipe;
import org.bukkit.inventory.meta.ItemMeta;
import org.bukkit.persistence.PersistentDataType;
import org.bukkit.plugin.java.JavaPlugin;
import org.bukkit.scheduler.BukkitRunnable;
import org.bukkit.util.Vector;

import java.util.Arrays;
import java.util.HashMap;
import java.util.Map;
import java.util.UUID;

public final class DiamondGrapplingHook extends JavaPlugin implements Listener {
    private NamespacedKey itemKey;
    private NamespacedKey recipeKey;
    private final Map<UUID, Long> cooldowns = new HashMap<>();
    private final Map<UUID, Grapple> grapples = new HashMap<>();

    @Override
    public void onEnable() {
        saveDefaultConfig();
        itemKey = new NamespacedKey(this, "grappling_hook");
        recipeKey = new NamespacedKey(this, "grappling_hook_recipe");
        ShapedRecipe recipe = new ShapedRecipe(recipeKey, createHook());
        recipe.shape("  D", " DI", "S S");
        recipe.setIngredient('D', material("DIAMOND"));
        recipe.setIngredient('I', material("IRON_INGOT"));
        recipe.setIngredient('S', material("STRING"));
        Bukkit.addRecipe(recipe);
        Bukkit.getPluginManager().registerEvents(this, this);
    }

    @Override
    public void onDisable() {
        for (Grapple grapple : grapples.values().toArray(new Grapple[0])) grapple.stop();
        Bukkit.removeRecipe(recipeKey);
    }

    private Material material(String name) {
        return XMaterial.matchXMaterial(name).map(XMaterial::parseMaterial)
                .orElseThrow(() -> new IllegalStateException("Missing material: " + name));
    }

    private ItemStack createHook() {
        ItemStack item = new ItemStack(material("STICK"));
        ItemMeta meta = item.getItemMeta();
        meta.setDisplayName(ChatColor.AQUA + "" + ChatColor.BOLD + "Diamond Grappling Hook");
        meta.setLore(Arrays.asList(ChatColor.AQUA + "Diamond energy launcher", ChatColor.GRAY + "Right-click to grapple"));
        meta.setItemModel(new NamespacedKey("diamondgrapplinghook", "grappling_hook"));
        meta.getPersistentDataContainer().set(itemKey, PersistentDataType.BYTE, (byte) 1);
        item.setItemMeta(meta);
        return item;
    }

    private boolean isHook(ItemStack item) {
        return item != null && item.hasItemMeta()
                && item.getItemMeta().getPersistentDataContainer().has(itemKey, PersistentDataType.BYTE);
    }

    @EventHandler
    public void onUse(PlayerInteractEvent event) {
        if (event.getHand() != org.bukkit.inventory.EquipmentSlot.HAND || !isHook(event.getItem())) return;
        if (event.getAction() != Action.RIGHT_CLICK_AIR && event.getAction() != Action.RIGHT_CLICK_BLOCK) return;
        event.setCancelled(true);
        Player player = event.getPlayer();
        long now = System.currentTimeMillis();
        if (now < cooldowns.getOrDefault(player.getUniqueId(), 0L)) return;
        cooldowns.put(player.getUniqueId(), now + Math.max(0L, getConfig().getLong("cooldown-ticks", 20)) * 50L);
        Grapple previous = grapples.get(player.getUniqueId());
        if (previous != null) previous.stop();
        Snowball projectile = player.launchProjectile(Snowball.class);
        projectile.setItem(new ItemStack(material("DIAMOND")));
        projectile.setGravity(false);
        projectile.setVelocity(player.getEyeLocation().getDirection().multiply(Math.max(0.1, getConfig().getDouble("projectile-speed", 2.0))));
        Grapple grapple = new Grapple(player, projectile);
        grapples.put(player.getUniqueId(), grapple);
        sound(player.getLocation(), "ENTITY_ENDER_DRAGON_FLAP", 0.6f, 1.8f);
        grapple.runTaskTimer(this, 1L, 1L);
    }

    @EventHandler
    public void onHit(ProjectileHitEvent event) {
        if (!(event.getEntity() instanceof Snowball)) return;
        for (Grapple grapple : grapples.values().toArray(new Grapple[0])) {
            if (!grapple.projectile.getUniqueId().equals(event.getEntity().getUniqueId())) continue;
            Block block = event.getHitBlock();
            if (block == null || !block.getType().isSolid()
                    || grapple.player.getWorld() != grapple.projectile.getWorld()
                    || grapple.player.getLocation().distance(grapple.projectile.getLocation()) > range()) {
                grapple.stop();
                return;
            }
            grapple.target = grapple.projectile.getLocation().clone();
            grapple.projectile.remove();
            sound(grapple.target, "BLOCK_AMETHYST_BLOCK_HIT", 1.0f, 1.4f);
            particles(grapple.target, 15);
            return;
        }
    }

    @EventHandler
    public void onQuit(PlayerQuitEvent event) {
        UUID id = event.getPlayer().getUniqueId();
        Grapple grapple = grapples.get(id);
        if (grapple != null) grapple.stop();
        cooldowns.remove(id);
    }

    @Override
    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
        if (!(sender instanceof Player)) {
            sender.sendMessage("This command is only available to players.");
            return true;
        }
        Player player = (Player) sender;
        if (args.length == 1 && args[0].equalsIgnoreCase("crafting")) {
            RecipeHolder holder = new RecipeHolder();
            Inventory inventory = Bukkit.createInventory(holder, 27, ChatColor.AQUA + "Grappling Hook Recipe");
            holder.inventory = inventory;
            inventory.setItem(2, new ItemStack(material("DIAMOND")));
            inventory.setItem(10, new ItemStack(material("DIAMOND")));
            inventory.setItem(11, new ItemStack(material("IRON_INGOT")));
            inventory.setItem(18, new ItemStack(material("STRING")));
            inventory.setItem(20, new ItemStack(material("STRING")));
            inventory.setItem(15, createHook());
            player.openInventory(inventory);
        } else if (args.length == 1 && args[0].equalsIgnoreCase("give") && player.hasPermission("grappler.give")) {
            Map<Integer, ItemStack> leftovers = player.getInventory().addItem(createHook());
            for (ItemStack item : leftovers.values()) player.getWorld().dropItemNaturally(player.getLocation(), item);
            player.sendMessage(ChatColor.AQUA + "You received a Diamond Grappling Hook.");
        } else {
            player.sendMessage(ChatColor.AQUA + "Use /grappler crafting" + (player.hasPermission("grappler.give") ? " or /grappler give" : ""));
        }
        return true;
    }

    @EventHandler
    public void onInventoryClick(InventoryClickEvent event) {
        if (event.getView().getTopInventory().getHolder() instanceof RecipeHolder) event.setCancelled(true);
    }

    @EventHandler
    public void onInventoryDrag(InventoryDragEvent event) {
        if (event.getView().getTopInventory().getHolder() instanceof RecipeHolder) event.setCancelled(true);
    }

    private double range() {
        return Math.max(1.0, Math.min(40.0, getConfig().getDouble("range", 40.0)));
    }

    private void sound(Location location, String name, float volume, float pitch) {
        XSound.matchXSound(name).ifPresent(sound -> {
            Sound bukkitSound = sound.get();
            if (bukkitSound != null && location.getWorld() != null) location.getWorld().playSound(location, bukkitSound, volume, pitch);
        });
    }

    private void particles(Location location, int count) {
        XParticle.of("ELECTRIC_SPARK").ifPresent(particle -> {
            World world = location.getWorld();
            if (world != null) world.spawnParticle(particle.get(), location, count, 0.1, 0.1, 0.1, 0.01);
        });
    }

    private void cable(Location from, Location to) {
        Vector delta = to.toVector().subtract(from.toVector());
        int points = Math.max(1, (int) Math.ceil(delta.length() * 2));
        XParticle.of("DUST").ifPresent(particle -> {
            Particle.DustOptions dust = new Particle.DustOptions(org.bukkit.Color.fromRGB(55, 225, 255), 0.8f);
            for (int i = 0; i <= points; i++) {
                Location point = from.clone().add(delta.clone().multiply((double) i / points));