Juke SMP

code me a plugin for economy server called piglin smp make it be an anticheat based from i want it to be like the anticheat above but better with /sus and more make it hide all blocks underneath Y-level 8 that makes it look like just deepslate till you go down closer to it make it detect continuous suspiscous relogs at that or near that y level to

Kodari AI
KodariYesterday at 5:09 pm 4
PiglinSMPAntiCheat
An advanced anti-cheat plugin for Piglin SMP that detects suspicious player behavior. It hides all blocks below Y-level 8, rendering them as deepslate until players descend closer. The plugin tracks continuous suspicious relogs near that Y-level, flagging repeat offenders. Includes a /sus command for staff to inspect player activity, view violation history, and manage alerts. Features real-time monitoring, configurable thresholds, and automated punishment actions.

I’ll add relog alerts and /sus review tools, plus per-player block masking below Y=8. The masking will be visual rather than a substitute for Paper’s packet-level anti-xray.

Created PiglinSMP AntiCheat with /sus, staff alerts for repeated underground relogs, and configurable deepslate masking below Y=8.

Important: The masking is visual and updates gradually; it does not prevent modified clients from seeing chunk data. Enable Paper’s built-in anti-xray for actual ore protection. Relog alerts are indicators for review, not proof of cheating.

Kodari can make mistakes. Review important code before using.
Files
src
build.gradle
settings.gradle
SNITCH-1.0.0.jar
Code
6 298
src/main/java/com/piglinsmp/anticheat/PiglinAntiCheat.java
package com.piglinsmp.anticheat;

import org.bukkit.Bukkit;
import org.bukkit.ChatColor;
import org.bukkit.Location;
import org.bukkit.World;
import org.bukkit.block.data.BlockData;
import org.bukkit.command.Command;
import org.bukkit.command.CommandSender;
import org.bukkit.configuration.ConfigurationSection;
import org.bukkit.configuration.file.YamlConfiguration;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerJoinEvent;
import org.bukkit.event.player.PlayerQuitEvent;
import org.bukkit.plugin.java.JavaPlugin;

import java.io.File;
import java.io.IOException;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.Iterator;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.UUID;

public final class PiglinAntiCheat extends JavaPlugin implements Listener {
    private final Map<UUID, MaskState> masks = new HashMap<>();
    private File dataFile;
    private YamlConfiguration data;
    private BlockData deepslate;

    @Override
    public void onEnable() {
        saveDefaultConfig();
        dataFile = new File(getDataFolder(), "suspects.yml");
        data = YamlConfiguration.loadConfiguration(dataFile);
        deepslate = Bukkit.createBlockData("minecraft:deepslate");
        Bukkit.getPluginManager().registerEvents(this, this);
        Bukkit.getScheduler().runTaskTimer(this, this::updateMasks, 20L, 1L);
    }

    @Override
    public void onDisable() {
        for (Player player : Bukkit.getOnlinePlayers()) {
            MaskState state = masks.get(player.getUniqueId());
            if (state != null) restore(player, state);
        }
        saveData();
    }

    @EventHandler
    public void onQuit(PlayerQuitEvent event) {
        Player player = event.getPlayer();
        masks.remove(player.getUniqueId());
        Location location = player.getLocation();
        String path = player.getUniqueId().toString();
        data.set(path + ".name", player.getName());
        data.set(path + ".logout.time", System.currentTimeMillis());
        data.set(path + ".logout.world", location.getWorld().getUID().toString());
        data.set(path + ".logout.x", location.getX());
        data.set(path + ".logout.y", location.getY());
        data.set(path + ".logout.z", location.getZ());
        saveData();
    }

    @EventHandler
    public void onJoin(PlayerJoinEvent event) {
        Player player = event.getPlayer();
        String path = player.getUniqueId().toString();
        long now = System.currentTimeMillis();
        long logout = data.getLong(path + ".logout.time", 0L);
        Location current = player.getLocation();
        double dx = current.getX() - data.getDouble(path + ".logout.x");
        double dy = current.getY() - data.getDouble(path + ".logout.y");
        double dz = current.getZ() - data.getDouble(path + ".logout.z");
        double maxDistance = Math.max(0, getConfig().getDouble("relog.maximum-distance", 32));
        long maxMillis = Math.max(0, getConfig().getLong("relog.maximum-seconds", 300)) * 1000L;
        if (logout > 0 && now >= logout && now - logout <= maxMillis
                && current.getWorld().getUID().toString().equals(data.getString(path + ".logout.world"))
                && current.getY() <= getConfig().getDouble("relog.maximum-y", 12)
                && data.getDouble(path + ".logout.y") <= getConfig().getDouble("relog.maximum-y", 12)
                && dx * dx + dy * dy + dz * dz <= maxDistance * maxDistance) {
            long window = Math.max(1, getConfig().getLong("relog.window-minutes", 30)) * 60000L;
            List<Long> times = new ArrayList<>(data.getLongList(path + ".relogs"));
            times.removeIf(time -> time > now || now - time > window);
            times.add(now);
            data.set(path + ".relogs", times);
            data.set(path + ".total", data.getInt(path + ".total") + 1);
            data.set(path + ".last", now);
            if (times.size() >= Math.max(1, getConfig().getInt("relog.alert-threshold", 3))) {
                String message = ChatColor.GOLD + "[PiglinSMP] " + ChatColor.YELLOW + player.getName()
                        + " has " + times.size() + " nearby underground relogs in the configured window. Review with /sus " + player.getName();
                Bukkit.getOnlinePlayers().stream().filter(p -> p.hasPermission("piglinsmp.sus")).forEach(p -> p.sendMessage(message));
                getLogger().info(ChatColor.stripColor(message));
            }
        }
        data.set(path + ".name", player.getName());
        data.set(path + ".logout", null);
        saveData();
    }

    @Override
    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
        if (!sender.hasPermission("piglinsmp.sus")) {
            sender.sendMessage(ChatColor.RED + "You do not have permission.");
            return true;
        }
        if (args.length == 0) {
            sender.sendMessage(ChatColor.GOLD + "Suspicious underground relogs:");
            boolean found = false;
            for (String key : data.getKeys(false)) {
                int total = data.getInt(key + ".total");
                if (total > 0) {
                    sender.sendMessage(ChatColor.YELLOW + data.getString(key + ".name", key) + ChatColor.GRAY + ": " + total + " recorded relogs");
                    found = true;
                }
            }
            if (!found) sender.sendMessage(ChatColor.GRAY + "No records yet.");
            return true;
        }
        boolean clear = args[0].equalsIgnoreCase("clear");
        if ((clear && args.length != 2) || (!clear && args.length != 1)) return false;
        if (clear && !sender.hasPermission("piglinsmp.sus.clear")) {
            sender.sendMessage(ChatColor.RED + "You do not have permission to clear records.");
            return true;
        }
        String name = args[clear ? 1 : 0];
        String key = findPlayer(name);
        if (key == null) {
            sender.sendMessage(ChatColor.RED + "No record found for " + name + ".");
            return true;
        }
        if (clear) {
            data.set(key + ".total", null);
            data.set(key + ".relogs", null);
            data.set(key + ".last", null);
            saveData();
            sender.sendMessage(ChatColor.GREEN + "Cleared suspicion for " + name + ".");
        } else {
            long now = System.currentTimeMillis();
            long window = Math.max(1, getConfig().getLong("relog.window-minutes", 30)) * 60000L;
            long recent = data.getLongList(key + ".relogs").stream().filter(t -> t <= now && now - t <= window).count();
            sender.sendMessage(ChatColor.GOLD + data.getString(key + ".name", name) + ChatColor.GRAY
                    + " — total: " + data.getInt(key + ".total") + ", in current window: " + recent);
            sender.sendMessage(ChatColor.GRAY + "These are indicators, not proof of cheating.");
        }
        return true;
    }

    private String findPlayer(String name) {
        for (String key : data.getKeys(false)) {
            if (name.equalsIgnoreCase(data.getString(key + ".name", "")) || name.equalsIgnoreCase(key)) return key;
        }
        return null;
    }

    private void saveData() {
        try {
            data.save(dataFile);
        } catch (IOException e) {
            getLogger().warning("Could not save suspicion records: " + e.getMessage());
        }
    }

    private void updateMasks() {
        for (Player player : Bukkit.getOnlinePlayers()) {
            UUID id = player.getUniqueId();
            if (!getConfig().getBoolean("mask.enabled", true) || player.hasPermission("piglinsmp.mask.bypass")) {
                MaskState old = masks.remove(id);
                if (old != null) restore(player, old);
                continue;
            }
            Location location = player.getLocation();
            World world = player.getWorld();
            int chunkX = location.getBlockX() >> 4;
            int chunkZ = location.getBlockZ() >> 4;
            int radius = Math.max(0, Math.min(2, getConfig().getInt("mask.chunk-radius", 1)));
            MaskState state = masks.get(id);
            if (state == null || !state.world.equals(world.getUID()) || state.chunkX != chunkX || state.chunkZ != chunkZ || state.radius != radius) {
                if (state != null) restore(player, state);
                state = new MaskState(world.getUID(), chunkX, chunkZ, radius);
                masks.put(id, state);
            }
            int columns = Math.max(1, Math.min(64, getConfig().getInt("mask.columns-per-tick", 16)));
            int side = radius * 2 + 1;
            int totalColumns = side * side * 256;
            int top = Math.min(world.getMaxHeight() - 1, getConfig().getInt("mask.below-y", 8) - 1);
            double reveal = Math.max(0, getConfig().getDouble("mask.reveal-distance", 12));
            for (int i = 0; i < columns; i++) {
                int index = state.column++ % totalColumns;
                int chunkIndex = index / 256;
                int cx = chunkX + chunkIndex % side - radius;
                int cz = chunkZ + chunkIndex / side - radius;
                if (!world.isChunkLoaded(cx, cz)) continue;
                int x = (cx << 4) + (index % 256) % 16;
                int z = (cz << 4) + (index % 256) / 16;