bilal Birowo

buatkan saya plugin minecraft untuk paper Anti-ESP dan juga saya mau didalam tanah render chunk nya cuma 2 block khusus dibawah tanah di hide dan fix ketika relg juga di hide khusus dibawah tanah kalau di ata normal dan juga anti-xray khusus 1.21.11

Kodari AI
KodariNov 14 at 12:39 pm 1
UndergroundESPBlocker
Paper plugin for Minecraft 1.21.11 that prevents ESP and X-ray cheats. It hides chunk rendering below ground level, limiting underground view to only 2 blocks depth, while surface rendering remains normal. Includes anti-X-ray protection that obscures ores and valuable blocks underground. Also hides blocks during relog sessions specifically when underground, ensuring players cannot exploit render glitches. Configurable depth limits and block lists via config.yml for server administrators.
  1. Plugin menyamarkan ore yang tertutup minimal 2 blok dan menerapkannya lagi saat chunk dikirim, termasuk setelah relog.

  2. Sertakan konfigurasi Anti-Xray bawaan Paper 1.21.11 untuk perlindungan yang benar-benar mencegah data ore bocor.

  3. Buat konfigurasi plugin dan metadata build.

Plugin AntiESP dibuat. Ore disamarkan kepada pemain tanpa izin bypass jika tertutup minimal 2 blok, dan penyamaran diterapkan kembali saat chunk dimuat, termasuk setelah relog.

Untuk perlindungan Anti-Xray yang benar-benar mencegah data ore bocor ke client, salin bagian anticheat dari src/main/resources/paper-world-defaults.yml ke config/paper-world-defaults.yml di server, lalu restart Paper. Penyamaran dari plugin sendiri hanya lapisan visual; konfigurasi bawaan Paper yang menangani perlindungan chunk.

bilal Birowo

saya mau ore nya di hide di obfuscate dan saya maksud saya itu saya mau hide apapun di baah tanah jadi di hide kita tidakbisa melihat menembus tanah jika freecam karena bawah sudah di hide paham ? seperti render kita hanya jarak nya hanya 1 block

Kodari AI
KodariNov 14 at 12:56 pm 1

Paham—yang Anda maksud bukan cuma menyamarkan ore. Anda ingin semua isi bawah tanah tidak terlihat dari freecam, seolah jarak render di bawah tanah hanya 1 blok, sementara permukaan tetap normal.

Namun server Paper tidak bisa mengetahui posisi kamera freecam client. Cara menyembunyikan seluruh isi bawah tanah berarti mengirim blok palsu kepada semua pemain; itu juga akan menutupi gua dan membuat pengalaman menggali atau menjelajah bawah tanah bermasalah. Anti-Xray bawaan Paper hanya dirancang untuk menyamarkan ore, bukan seluruh bawah tanah.

Jadi saya belum mengubah plugin ke cara yang akan merusak permainan normal. Apakah Anda ingin perlindungan ore Anti-Xray saja, atau tetap ingin seluruh bawah tanah disamarkan untuk semua pemain, dengan konsekuensi gua dan isi bawah tanah ikut tertutup?

bilal Birowo

bukan seperti itu maksud nya jika kita berjalan chunk akan terload tapi di dalam tanah itu hanya hampa tidak terlihat apa apa dan kita coba mneggali nanti sedikit demi sedikit tergantung kita kemana akan ter "unlock" kalau cave normal render nya paham?

Kodari AI
KodariNov 14 at 1:00 pm 1

Paham. Yang Anda inginkan adalah fog-of-war bawah tanah: permukaan tetap terlihat normal, tetapi bagian dalam tanah yang belum dijelajahi tampak kosong. Saat pemain bergerak atau menggali, area di sekitarnya terbuka sedikit demi sedikit; gua yang sudah terbuka tetap dirender normal.

Itu berbeda dari Anti-Xray bawaan Paper. Untuk mencegah freecam melihat blok yang belum terbuka, penyamaran harus dilakukan pada data chunk yang dikirim ke client—bukan hanya dengan mengganti tampilan blok setelah chunk termuat.

bilal Birowo

seperti itu ! buat sekarang

Kodari AI
KodariNov 14 at 1:07 pm 2
  • Periksa implementasi penyamaran chunk dan konfigurasi Anti-Xray yang sudah ada.

  • Ubah penyamaran menjadi fog-of-war bawah tanah: buka area dekat pemain dan area yang digali, tanpa mengganggu gua yang sudah terlihat.

  • Pastikan status eksplorasi tersimpan saat pemain relog dan konfigurasi Paper tetap mendukung Anti-Xray.

Sudah diubah menjadi fog-of-war bawah tanah:

  • Blok di bawah permukaan disamarkan sebagai udara; permukaan dan dinding gua yang berbatasan dengan rongga alami tetap terlihat.

  • Pemain membuka area dalam radius 1 blok saat bergerak. Untuk menggali blok yang masih tersembunyi, ayunkan tangan sekali untuk menampakkan blok yang dituju, lalu gali seperti biasa.

  • Setelah menggali, area yang terbuka ikut terlihat. Saat relog, area eksplorasi di-reset dan bawah tanah kembali tersembunyi.

Catatan: ini penyamaran tampilan per pemain, bukan obfuscation penuh pada data chunk yang dikirim server; client modifikasi yang membaca paket chunk mentah masih mungkin memperoleh data blok.

bilal Birowo

masih belum work saya mau yang tidakdiliat player tidak di render di balik tembok di obfuscate jdi stone atau apa gitu didalam block di obfuscate jadi stone

Kodari AI
KodariNov 14 at 1:28 pm 1
  • Ganti blok tersembunyi dari udara menjadi blok stone opak, agar tidak tembus pandang di balik dinding.

  • Pastikan blok asli dipulihkan ketika terlihat atau saat plugin dinonaktifkan; gua terbuka tetap terlihat normal.

Sekarang blok bawah tanah yang belum terbuka ditampilkan sebagai stone opak, bukan udara, jadi tidak tampak tembus di balik dinding. Saat area terbuka, blok asli—termasuk dinding gua—ditampilkan kembali; saat plugin dinonaktifkan, blok asli juga dipulihkan.

Kodari can make mistakes. Review important code before using.
Files
src
build.gradle
Code
5 352
src/main/java/com/kodari/antiesp/AntiEspPlugin.java
package com.kodari.antiesp;

import io.papermc.paper.event.packet.PlayerChunkLoadEvent;
import org.bukkit.Bukkit;
import org.bukkit.World;
import org.bukkit.block.Block;
import org.bukkit.block.data.BlockData;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.block.BlockBreakEvent;
import org.bukkit.event.player.PlayerAnimationEvent;
import org.bukkit.event.player.PlayerAnimationType;
import org.bukkit.event.player.PlayerMoveEvent;
import org.bukkit.event.player.PlayerQuitEvent;
import org.bukkit.plugin.java.JavaPlugin;
import org.bukkit.util.RayTraceResult;

import java.util.BitSet;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;
import java.util.UUID;

public final class AntiEspPlugin extends JavaPlugin implements Listener {
    private final Map<UUID, Map<ChunkKey, BitSet>> concealedChunks = new HashMap<>();
    private final Map<UUID, Set<BlockKey>> revealedBlocks = new HashMap<>();
    private BlockData concealedBlockData;
    private int revealRadius;

    @Override
    public void onEnable() {
        saveDefaultConfig();
        concealedBlockData = Bukkit.createBlockData("minecraft:stone");
        revealRadius = Math.max(1, getConfig().getInt("reveal-radius", 1));
        getServer().getPluginManager().registerEvents(this, this);
    }

    @Override
    public void onDisable() {
        for (Player player : Bukkit.getOnlinePlayers()) {
            Map<ChunkKey, BitSet> chunks = concealedChunks.get(player.getUniqueId());
            if (chunks == null) {
                continue;
            }
            for (Map.Entry<ChunkKey, BitSet> entry : chunks.entrySet()) {
                ChunkKey key = entry.getKey();
                World world = Bukkit.getWorld(key.worldId());
                if (world == null || !world.isChunkLoaded(key.x(), key.z())) {
                    continue;
                }
                BitSet mask = entry.getValue();
                for (int index = mask.nextSetBit(0); index >= 0; index = mask.nextSetBit(index + 1)) {
                    int x = (key.x() << 4) + ((index >> 4) & 15);
                    int y = world.getMinHeight() + (index >>> 8);
                    int z = (key.z() << 4) + (index & 15);
                    Block block = world.getBlockAt(x, y, z);
                    player.sendBlockChange(block.getLocation(), block.getBlockData());
                }
            }
        }
    }

    @EventHandler
    public void onChunkLoad(PlayerChunkLoadEvent event) {
        Player player = event.getPlayer();
        World world = event.getChunk().getWorld();
        int chunkX = event.getChunk().getX();
        int chunkZ = event.getChunk().getZ();
        Bukkit.getScheduler().runTaskLater(this, () -> {
            if (!player.isOnline() || !player.getWorld().equals(world) || !world.isChunkLoaded(chunkX, chunkZ)) {
                return;
            }
            revealAround(player, player.getLocation().getBlockX(), player.getLocation().getBlockY(), player.getLocation().getBlockZ());
            concealChunk(player, world, chunkX, chunkZ);
        }, 1L);
    }

    @EventHandler
    public void onMove(PlayerMoveEvent event) {
        if (event.getTo() == null || event.getFrom().getWorld().equals(event.getTo().getWorld())
                && event.getFrom().getBlockX() == event.getTo().getBlockX()
                && event.getFrom().getBlockY() == event.getTo().getBlockY()
                && event.getFrom().getBlockZ() == event.getTo().getBlockZ()) {
            return;
        }
        revealAround(event.getPlayer(), event.getTo().getBlockX(), event.getTo().getBlockY(), event.getTo().getBlockZ());
    }

    @EventHandler
    public void onSwing(PlayerAnimationEvent event) {
        Player player = event.getPlayer();
        if (event.getAnimationType() != PlayerAnimationType.ARM_SWING || player.hasPermission("antiesp.bypass")) {
            return;
        }
        RayTraceResult result = player.rayTraceBlocks(5.0);
        if (result == null || result.getHitBlock() == null) {
            return;
        }
        Block target = result.getHitBlock();
        if (isConcealable(target)) {
            revealBlock(player, target);
        }
    }

    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
    public void onBlockBreak(BlockBreakEvent event) {
        Block block = event.getBlock();
        Player breaker = event.getPlayer();
        World world = block.getWorld();
        int x = block.getX();
        int y = block.getY();
        int z = block.getZ();
        Bukkit.getScheduler().runTask(this, () -> {
            if (breaker.isOnline() && breaker.getWorld().equals(world)) {
                revealAround(breaker, x, y, z);
            }
            Block broken = world.getBlockAt(x, y, z);
            Block[] neighbors = {
                    broken.getRelative(1, 0, 0), broken.getRelative(-1, 0, 0),
                    broken.getRelative(0, 1, 0), broken.getRelative(0, -1, 0),
                    broken.getRelative(0, 0, 1), broken.getRelative(0, 0, -1)
            };
            for (Player viewer : world.getPlayers()) {
                Map<ChunkKey, BitSet> masks = concealedChunks.get(viewer.getUniqueId());
                if (masks == null) {
                    continue;
                }
                for (Block neighbor : neighbors) {
                    if (neighbor.getType().isAir() || !isAdjacentToOpenSpace(neighbor)) {
                        continue;
                    }
                    clearMaskAndSend(viewer, neighbor, masks);
                    revealedBlocks.computeIfAbsent(viewer.getUniqueId(), ignored -> new HashSet<>())
                            .add(blockKey(neighbor));
                }
            }
        });
    }

    @EventHandler
    public void onQuit(PlayerQuitEvent event) {
        UUID playerId = event.getPlayer().getUniqueId();
        concealedChunks.remove(playerId);
        revealedBlocks.remove(playerId);
    }

    private void concealChunk(Player player, World world, int chunkX, int chunkZ) {
        if (!player.isOnline() || !player.getWorld().equals(world)) {
            return;
        }

        ChunkKey chunkKey = new ChunkKey(world.getUID(), chunkX, chunkZ);
        Map<ChunkKey, BitSet> masks = concealedChunks.computeIfAbsent(player.getUniqueId(), ignored -> new HashMap<>());
        BitSet mask = new BitSet();
        if (player.hasPermission("antiesp.bypass")) {
            masks.put(chunkKey, mask);
            return;
        }

        Set<BlockKey> revealed = revealedBlocks.computeIfAbsent(player.getUniqueId(), ignored -> new HashSet<>());
        int startX = chunkX << 4;
        int startZ = chunkZ << 4;
        for (int x = startX; x < startX + 16; x++) {
            for (int z = startZ; z < startZ + 16; z++) {
                int surfaceY = world.getHighestBlockYAt(x, z);
                for (int y = world.getMinHeight(); y < surfaceY; y++) {
                    Block block = world.getBlockAt(x, y, z);
                    if (block.getType().isAir() || isAdjacentToOpenSpace(block)) {
                        continue;
                    }
                    BlockKey key = blockKey(block);
                    if (!revealed.contains(key)) {
                        player.sendBlockChange(block.getLocation(), concealedBlockData);
                        mask.set(maskIndex(world, x, y, z));
                    }
                }
            }
        }
        masks.put(chunkKey, mask);
    }

    private void revealAround(Player player, int centerX, int centerY, int centerZ) {
        if (!player.isOnline() || player.hasPermission("antiesp.bypass")) {
            return;
        }
        World world = player.getWorld();
        Set<BlockKey> revealed = revealedBlocks.computeIfAbsent(player.getUniqueId(), ignored -> new HashSet<>());
        Map<ChunkKey, BitSet> masks = concealedChunks.get(player.getUniqueId());
        int radiusSquared = revealRadius * revealRadius;
        for (int dx = -revealRadius; dx <= revealRadius; dx++) {
            for (int dy = -revealRadius; dy <= revealRadius; dy++) {
                for (int dz = -revealRadius; dz <= revealRadius; dz++) {
                    if (dx * dx + dy * dy + dz * dz > radiusSquared) {
                        continue;
                    }
                    int x = centerX + dx;
                    int y = centerY + dy;