Skplayz444 Skplayz444

Ability 3 — Rapid Spam Lightning (Right-Click Hold):

  • While holding right-click with the vanilla Stone Sword, continuously spam lightning strikes rapidly and repeatedly, creating a powerful, chaotic lightning storm effect.
  • Lightning must strike approximately every 2–4 ticks, with a configurable interval for fast, continuous spam.
  • Aim using the player's camera crosshair. Lightning must strike exactly where the player aims, including mobs, players, blocks, and empty sky when aiming upward.
  • Use a ray-tracing system that follows the player's exact looking direction and supports targeting the sky. If aiming at empty sky, summon lightning at the targeted point along the ray, within the maximum configured range.
  • The default maximum targeting range should be 64 blocks and must be configurable. Lightning must never strike beyond the allowed range.
  • While right-click remains held, lightning must keep striking repeatedly at the current aimed location. Update the target continuously as the player moves their camera, so lightning follows their aim in real time.
  • Each successful lightning strike must deal exactly 1 heart (2 HP) of damage to the intended target, ignoring armor, Protection IV, Resistance, and all other damage-reduction effects.
  • Lightning must create visible Minecraft lightning effects, and affected entities must display normal damage feedback.
  • Stop the lightning spam immediately when right-click is released, the player switches away from the Stone Sword, dies, disconnects, or changes worlds.
  • Prevent duplicate repeating tasks and unintended extra damage. Ensure rapid strikes remain server-safe and do not cause infinite event loops.
Kodari AI
KodariOct 27 at 10:49 pm 1
StormStrike
A Minecraft plugin that grants players a Stone Sword imbued with three lightning abilities. Left-click unleashes a single targeted lightning strike dealing 2 HP true damage. Right-click hold rapidly spams lightning every 2-4 ticks at the player's crosshair ray-trace target, up to 64 blocks away, ignoring armor and damage reduction. Lightning follows camera aim in real-time, stops on release, weapon switch, death, disconnect, or world change. Includes configurable intervals and range, with server-safe task management preventing duplicate loops.
  • Create the Paper plugin scaffold and configurable strike interval/range.

  • Implement camera ray tracing, visual-only lightning, and direct 2 HP target damage.

  • Stop sessions on player/item lifecycle changes; use an inactivity timeout because Bukkit cannot reliably observe right-button release for a Stone Sword.

Created the RapidSpamLightning Paper plugin with a configurable 3-tick strike interval and 64-block range. It ray-traces the player’s aim, shows visual-only lightning, and removes 2 HP directly from living targets, bypassing damage reduction.

Right-button release detection has a Bukkit limitation: a Stone Sword does not send a reliable release event. The plugin uses a 6-tick input inactivity timeout, so it can only approximate hold behavior; reliably tracking the actual button state requires a client-side input signal.

Kodari can make mistakes. Review important code before using.
Files
src
build.gradle
settings.gradle
Code
5 228
src/main/java/com/kodari/rapidspamlightning/RapidSpamLightningPlugin.java
package com.kodari.rapidspamlightning;

import org.bukkit.Bukkit;
import org.bukkit.Location;
import org.bukkit.World;
import org.bukkit.entity.Entity;
import org.bukkit.entity.LivingEntity;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.entity.PlayerDeathEvent;
import org.bukkit.event.player.PlayerChangedWorldEvent;
import org.bukkit.event.player.PlayerInteractEvent;
import org.bukkit.event.player.PlayerItemHeldEvent;
import org.bukkit.event.player.PlayerQuitEvent;
import org.bukkit.inventory.EquipmentSlot;
import org.bukkit.inventory.ItemStack;
import org.bukkit.plugin.java.JavaPlugin;
import org.bukkit.scheduler.BukkitRunnable;
import org.bukkit.scheduler.BukkitTask;
import org.bukkit.util.RayTraceResult;
import org.bukkit.util.Vector;
import org.bukkit.FluidCollisionMode;
import org.bukkit.EntityEffect;

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

public final class RapidSpamLightningPlugin extends JavaPlugin implements Listener {
    private static final long INPUT_TIMEOUT_NANOS = 6L * 50_000_000L;

    private final Map<UUID, StrikeSession> sessions = new HashMap<>();
    private int intervalTicks;
    private double maximumRange;

    @Override
    public void onEnable() {
        saveDefaultConfig();
        intervalTicks = Math.max(2, getConfig().getInt("interval-ticks", 3));
        maximumRange = getConfig().getDouble("maximum-range", 64.0);
        if (!Double.isFinite(maximumRange) || maximumRange <= 0.0) {
            maximumRange = 64.0;
        }
        getServer().getPluginManager().registerEvents(this, this);
    }

    @Override
    public void onDisable() {
        for (StrikeSession session : sessions.values()) {
            if (session.task != null) {
                session.task.cancel();
            }
        }
        sessions.clear();
    }

    @EventHandler
    public void onPlayerInteract(PlayerInteractEvent event) {
        if (event.getHand() != EquipmentSlot.HAND
                || !(event.getAction().isRightClick())
                || !isStoneSword(event.getPlayer().getInventory().getItemInMainHand())) {
            return;
        }

        Player player = event.getPlayer();
        StrikeSession session = sessions.get(player.getUniqueId());
        if (session != null) {
            session.lastInputNanos = System.nanoTime();
            return;
        }

        session = new StrikeSession(player);
        sessions.put(player.getUniqueId(), session);
        StrikeSession activeSession = session;
        session.task = new BukkitRunnable() {
            @Override
            public void run() {
                if (!isSessionValid(activeSession)) {
                    stopSession(activeSession.player.getUniqueId());
                    return;
                }

                if (System.nanoTime() - activeSession.lastInputNanos > INPUT_TIMEOUT_NANOS) {
                    stopSession(activeSession.player.getUniqueId());
                    return;
                }

                if (activeSession.ticksUntilStrike <= 0) {
                    strikeAtAim(activeSession.player);
                    activeSession.ticksUntilStrike = intervalTicks - 1;
                } else {
                    activeSession.ticksUntilStrike--;
                }
            }
        }.runTaskTimer(this, 0L, 1L);
    }

    @EventHandler
    public void onPlayerItemHeld(PlayerItemHeldEvent event) {
        ItemStack nextItem = event.getPlayer().getInventory().getItem(event.getNewSlot());
        if (!isStoneSword(nextItem)) {
            stopSession(event.getPlayer().getUniqueId());
        }
    }

    @EventHandler
    public void onPlayerDeath(PlayerDeathEvent event) {
        stopSession(event.getEntity().getUniqueId());
    }

    @EventHandler
    public void onPlayerQuit(PlayerQuitEvent event) {
        stopSession(event.getPlayer().getUniqueId());
    }

    @EventHandler
    public void onPlayerChangedWorld(PlayerChangedWorldEvent event) {
        stopSession(event.getPlayer().getUniqueId());
    }

    private boolean isSessionValid(StrikeSession session) {
        Player player = session.player;
        return player.isOnline()
                && player.isValid()
                && !player.isDead()
                && player.getWorld().getUID().equals(session.worldId)
                && isStoneSword(player.getInventory().getItemInMainHand());
    }

    private boolean isStoneSword(ItemStack item) {
        return item != null && !item.getType().isAir() && "STONE_SWORD".equals(item.getType().name());
    }

    private void strikeAtAim(Player player) {
        Location eye = player.getEyeLocation();
        World world = player.getWorld();
        Vector direction = eye.getDirection().normalize();
        Location endpoint = eye.clone().add(direction.clone().multiply(maximumRange));

        RayTraceResult entityResult = world.rayTraceEntities(
                eye,
                direction,
                maximumRange,
                0.1,
                entity -> entity != player && entity instanceof LivingEntity && !entity.isDead()
        );
        RayTraceResult blockResult = world.rayTraceBlocks(
                eye,
                direction,
                maximumRange,
                FluidCollisionMode.NEVER,
                true
        );

        Entity hitEntity = entityResult == null ? null : entityResult.getHitEntity();
        Vector entityPosition = entityResult == null ? null : entityResult.getHitPosition();
        Vector blockPosition = blockResult == null ? null : blockResult.getHitPosition();
        Location strikeLocation = endpoint;

        if (hitEntity != null && entityPosition != null
                && (blockPosition == null || eye.toVector().distanceSquared(entityPosition)
                <= eye.toVector().distanceSquared(blockPosition))) {
            strikeLocation = new Location(world, entityPosition.getX(), entityPosition.getY(), entityPosition.getZ());
            LivingEntity target = (LivingEntity) hitEntity;
            world.strikeLightningEffect(strikeLocation);
            target.setHealth(Math.max(0.0, target.getHealth() - 2.0));
            target.playEffect(EntityEffect.HURT);
            return;
        }

        if (blockPosition != null) {
            strikeLocation = new Location(world, blockPosition.getX(), blockPosition.getY(), blockPosition.getZ());
        }
        world.strikeLightningEffect(strikeLocation);
    }

    private void stopSession(UUID playerId) {
        StrikeSession session = sessions.remove(playerId);
        if (session != null && session.task != null) {
            session.task.cancel();
        }
    }

    private static final class StrikeSession {
        private final Player player;
        private final UUID worldId;
        private long lastInputNanos = System.nanoTime();
        private int ticksUntilStrike;
        private BukkitTask task;

        private StrikeSession(Player player) {
            this.player = player;
            this.worldId = player.getWorld().getUID();
        }
    }
}