test

package org.alvindimas05.lagassist.chunks;

import java.util.*;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import org.alvindimas05.lagassist.Main;
import org.alvindimas05.lagassist.utils.ServerType;
import org.bukkit.*;
import org.bukkit.block.BlockState;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Entity;
import org.bukkit.entity.Player;

public class ChkAnalyse {

    protected static final int ammoshow = Main.config.getInt("chunkanalyse.ammount");
    protected static final Map<String, Integer> values = new HashMap<>();
    private static final List<ChkStats> scores = new ArrayList<>();

    public static void Enabler() {
        Bukkit.getLogger().info("    §e[§a✔§e] §fChunk Analyser.");

        Set<String> slist = Objects.requireNonNull(Main.config.getConfigurationSection("chunkanalyse.values")).getKeys(false);
        for (String s : slist) {
            values.put(s.toLowerCase(), Main.config.getInt("chunkanalyse.values." + s));
        }
    }

    public static void analyseChunks(Player p) {
        scores.clear();
        List<Chunk> loadedChunks = new ArrayList<>();

        for (World w : Bukkit.getWorlds()) {
            loadedChunks.addAll(Arrays.asList(w.getLoadedChunks()));
        }

        if (ServerType.isFolia()) {
            for (Chunk ch : loadedChunks) {
                World w = ch.getWorld();
                Bukkit.getRegionScheduler().execute(Main.p, w, ch.getX(), ch.getZ(), () -> {
                    scores.add(new ChkStats(ch, false));
                    if (scores.size() == loadedChunks.size()) {
                        sendResultsToPlayer(p);
                    }
                });
            }
        } else {
            for (Chunk ch : loadedChunks) {
                scores.add(new ChkStats(ch, false));
            }
            sendResultsToPlayer(p);
        }
    }

    private static void sendResultsToPlayer(Player p) {
        scores.sort(Collections.reverseOrder());

        p.sendMessage("");
        p.sendMessage("§2§l⬛⬛⬛⬛⬛⬛ §f§lCHUNKANALYSER §2§l⬛⬛⬛⬛⬛⬛");
        p.sendMessage("");

        for (int i = 0; i < ammoshow && i < scores.size(); i++) {
            ChkStats cs = scores.get(i);
            p.spigot().sendMessage(cs.genText());
        }

        p.sendMessage("");
        p.sendMessage("§2§l⬛⬛⬛⬛⬛⬛⬛⬛⬛⬛⬛⬛⬛⬛⬛⬛⬛⬛⬛⬛⬛⬛⬛⬛");
    }

    public static void analyseChunks(CommandSender p) {
        Map<Chunk, Integer> chunkscore = new HashMap<>();
        List<Chunk> loadedChunks = new ArrayList<>();

        for (World w : Bukkit.getWorlds()) {
            loadedChunks.addAll(Arrays.asList(w.getLoadedChunks()));
        }

        if (ServerType.isFolia()) {
            for (Chunk ch : loadedChunks) {
                World w = ch.getWorld();
                Bukkit.getRegionScheduler().execute(Main.p, w, ch.getX(), ch.getZ(), () -> {
                    processChunk(ch, chunkscore);
                    if (chunkscore.size() == loadedChunks.size()) {
                        sendResultsToSender(p, chunkscore);
                    }
                });
            }
        } else {
            for (Chunk ch : loadedChunks) {
                processChunk(ch, chunkscore);
            }
            sendResultsToSender(p, chunkscore);
        }
    }

    private static void processChunk(Chunk ch, Map<Chunk, Integer> chunkscore) {
        chunkscore.putIfAbsent(ch, 0);

        for (BlockState blkst : ch.getTileEntities()) {
            String m = blkst.getType().toString().toLowerCase();
            if (values.containsKey(m)) {
                chunkscore.put(ch, chunkscore.get(ch) + values.get(m));
            }
        }

        for (Entity e : ch.getEntities()) {
            String et = e.getType().toString().toLowerCase();
            if (values.containsKey(et)) {
                chunkscore.put(ch, chunkscore.get(ch) + values.get(et));
            }
        }
    }

    private static void sendResultsToSender(CommandSender p, Map<Chunk, Integer> chunkscore) {
        p.sendMessage("");
        p.sendMessage("⬛⬛⬛⬛⬛⬛ §f§lCHUNKANALYSER ⬛⬛⬛⬛⬛⬛");
        p.sendMessage("");

        Stream<Map.Entry<Chunk, Integer>> sorted = chunkscore.entrySet().stream()
                .sorted(Collections.reverseOrder(Map.Entry.comparingByValue()));

        Map<Chunk, Integer> topChunks = sorted.limit(ammoshow)
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));

        for (Chunk ch : topChunks.keySet()) {
            p.sendMessage("  ✸ Chunk (" + ch.getX() + " " + ch.getZ() + ") - Score " + chunkscore.get(ch));
        }

        p.sendMessage("");
        p.sendMessage("⬛⬛⬛⬛⬛⬛⬛⬛⬛⬛⬛⬛⬛⬛⬛⬛⬛⬛⬛⬛⬛⬛⬛⬛");
    }

    public static void analyseCurrentChunk(CommandSender s) {
        if (!(s instanceof Player p)) {
            s.sendMessage(Main.PREFIX + "You cannot analyse the current chunk from console.");
            return;
        }

        Location l = p.getLocation();
        Chunk chunk = l.getChunk();

        if (ServerType.isFolia()) {
            Bukkit.getRegionScheduler().execute(Main.p, l.getWorld(), chunk.getX(), chunk.getZ(), () -> {
                sendChunkStats(p, chunk);
            });
        } else {
            sendChunkStats(p, chunk);
        }
    }

    private static void sendChunkStats(Player p, Chunk chunk) {
        ChkStats stats = new ChkStats(chunk, true);

        String crds = stats.getCoords()[0] + " " + stats.getCoords()[1];
        String cmd = "lagassist tpchunk " + p.getWorld().getName() + " " + crds;

        p.sendMessage("§2§l⬛⬛⬛⬛⬛⬛ §f§lCHUNK STATS §2§l⬛⬛⬛⬛⬛⬛");
        p.sendMessage("");
        p.sendMessage("  §2✸ §fChunk coordinates: §7" + crds);
        p.sendMessage("");
        p.sendMessage("  §2✸ §fEntity Amount: §7" + stats.getEnts().length);
        p.sendMessage("  §2✸ §fTiles Amount: §7" + stats.getTiles().length);
        p.sendMessage("");
        p.spigot().sendMessage(stats.genMobCount("  §2✸ §fDetailed Info §7(HOVER)", cmd));
        p.sendMessage("");
        p.sendMessage("§2§l⬛⬛⬛⬛⬛⬛⬛⬛⬛⬛⬛⬛⬛⬛⬛⬛⬛⬛⬛⬛⬛⬛");
    }
}
package org.alvindimas05.lagassist.chunks;

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

import org.alvindimas05.lagassist.Main;
import org.alvindimas05.lagassist.utils.Cache;
import org.alvindimas05.lagassist.utils.ServerType;
import org.bukkit.Bukkit;
import org.bukkit.Chunk;
import org.bukkit.World;
import org.bukkit.block.Block;
import org.bukkit.block.BlockState;
import org.bukkit.entity.Entity;
import org.bukkit.entity.EntityType;
import org.bukkit.entity.Vehicle;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.event.entity.EntitySpawnEvent;
import org.bukkit.event.vehicle.VehicleCreateEvent;
import org.bukkit.scheduler.BukkitRunnable;

public class ChkLimiter implements Listener {

    private static final Cache<Chunk, Entity[]> entcache = new Cache<>(30);
    private static final Cache<Chunk, BlockState[]> tilecache = new Cache<>(100);
    private static int moblimit = -1;
    private static int tilelimit = -1;

    public static void Enabler(boolean reload) {
        if (!reload) {
            Main.p.getServer().getPluginManager().registerEvents(new ChkLimiter(), Main.p);
            runTask();
        }
        Bukkit.getLogger().info("    §e[§a✔§e] §fChunk Limiter.");

        moblimit = Main.config.getInt("limiter.mobs.total-limit");
        tilelimit = Main.config.getInt("limiter.tiles.total-limit");
    }

    private static void runTask() {
        long delay = 1L;
        long period = 1L;

        if (ServerType.isFolia()) {
            Bukkit.getGlobalRegionScheduler().runAtFixedRate(Main.p, task -> executeTask(), delay, period);
        } else {
            new BukkitRunnable() {
                @Override
                public void run() {
                    executeTask();
                }
            }.runTaskTimer(Main.p, delay, period);
        }
    }

    private static void executeTask() {
        for (World w : Bukkit.getWorlds()) {
            for (Chunk chk : w.getLoadedChunks()) {
                Map<EntityType, Integer> counts = new HashMap<>();

                for (Entity ent : chk.getEntities()) {
                    if (Main.config.getBoolean("limiter.ignore-named-mobs") && ent.getCustomName() != null) {
                        continue;
                    }

                    EntityType type = ent.getType();
                    int allowed = getMobMaxHard(type);

                    if (allowed == -1) {
                        continue;
                    }

                    int count = counts.getOrDefault(type, 0);

                    if (count < allowed) {
                        counts.put(type, count + 1);
                        continue;
                    }

                    ent.remove();
                }
            }
        }

        tilecache.tick();
        entcache.tick();
    }

    private static int getMobMaxHard(EntityType entype) {
        String location = "limiter.mobs.hard-limit." + entype.toString().toLowerCase();
        return Main.config.contains(location) ? Main.config.getInt(location) : -1;
    }

    private static int getTileMax(Class<?> cls) {
        String location = "limiter.tiles.per-limit." + cls.getSimpleName().toLowerCase();
        return Main.config.contains(location) ? Main.config.getInt(location) : -1;
    }

    private static int getTileMax(Block b) {
        return getTileMax(b.getState().getClass());
    }

    private static int getMobCount(Chunk chk, EntityType entype) {
        int ents = 0;

        if (!entcache.isCached(chk)) {
            entcache.putCached(chk, chk.getEntities());
        }

        for (Entity ent : entcache.getCached(chk)) {
            if (ent != null && ent.getType() == entype) {
                ents++;
            }
        }
        return ents;
    }

    private static int getTileCount(Chunk chk, Class<?> type) {
        int tls = 0;

        if (!tilecache.isCached(chk)) {
            tilecache.putCached(chk, chk.getTileEntities());
        }

        for (BlockState tle : tilecache.getCached(chk)) {
            if (tle != null && tle.getClass().equals(type)) {
                tls++;
            }
        }
        return tls;
    }

    private static boolean isDeniedMob(Entity ent) {
        if (Main.config.getBoolean("limiter.ignore-named-mobs") && ent.getCustomName() != null) {
            return false;
        }

        if (ent.getType() == EntityType.PLAYER) {
            return false;
        }

        Chunk chk = ent.getLocation().getChunk();
        int current = getMobCount(chk, ent.getType());
        int maximum = getMobMaxHard(ent.getType());

        if (maximum < 0) {
            return false;
        }

        return current >= maximum;
    }

    private static boolean isDeniedTile(Block b) {
        Chunk chk = b.getLocation().getChunk();
        int current = getTileCount(chk, b.getState().getClass());
        int maximum = getTileMax(b);

        if (maximum < 0) {
            return false;
        }

        return current >= maximum;
    }

    @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
    public void onVehicleSpawn(VehicleCreateEvent e) {
        if (isDeniedMob(e.getVehicle())) {
            e.getVehicle().remove();
        }
    }

    @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
    public void onSpawn(EntitySpawnEvent e) {
        if (isDeniedMob(e.getEntity())) {
            e.setCancelled(true);
        }
    }

    @EventHandler(priority = EventPriority.LOWEST, ignoreCancelled = true)
    public void onPlace(BlockPlaceEvent e) {
        if (isDeniedTile(e.getBlock())) {
            e.setCancelled(true);
        }
    }
}
package org.alvindimas05.lagassist.chunks;

import java.util.Collections;
import java.util.HashMap;
import java.util.LinkedHashMap;
import java.util.Map;
import java.util.stream.Collectors;
import java.util.stream.Stream;

import org.alvindimas05.lagassist.Main;
import org.alvindimas05.lagassist.utils.Chat;
import org.alvindimas05.lagassist.utils.ServerType;
import org.bukkit.Bukkit;
import org.bukkit.Chunk;
import org.bukkit.block.BlockState;
import org.bukkit.entity.Entity;

import net.md_5.bungee.api.chat.TextComponent;

public class ChkStats implements Comparable<ChkStats> {

    private int score = 0;
    private final int[] coords = new int[2];

    private BlockState[] tiles;
    private Entity[] ents;
    private final String world;

    private final Map<String, Integer> amount = new HashMap<>();

    public ChkStats(Chunk ch, boolean genscores) {
        world = ch.getWorld().getName();
        coords[0] = ch.getX();
        coords[1] = ch.getZ();

        if (ServerType.isFolia()) {
            Bukkit.getRegionScheduler().execute(Main.p, ch.getWorld(), ch.getX(), ch.getZ(), () -> {
                tiles = ch.getTileEntities();
                ents = ch.getEntities();
                if (genscores) {
                    genScores();
                }
            });
        } else {
            tiles = ch.getTileEntities();
            ents = ch.getEntities();
            if (genscores) {
                genScores();
            }
        }
    }

    public void genScores() {
        Bukkit.getLogger().info("🔍 Calculating score for chunk [" + coords[0] + ", " + coords[1] + "] in world " + world);

        for (BlockState blkst : tiles) {
            String m = blkst.getType().toString().toLowerCase();
            if (ChkAnalyse.values.containsKey(m)) {
                score += ChkAnalyse.values.get(m);
                amount.put(m, amount.getOrDefault(m, 0) + 1);
            }
        }

        for (Entity ent : ents) {
            String m = ent.getType().toString().toLowerCase();
            if (ChkAnalyse.values.containsKey(m)) {
                score += ChkAnalyse.values.get(m);
                amount.put(m, amount.getOrDefault(m, 0) + 1);
            }
        }

        Bukkit.getLogger().info("✅ Score for chunk [" + coords[0] + ", " + coords[1] + "] = " + score);
    }

    public int getScore() {
        return score;
    }

    public int getX() {
        return coords[0];
    }

    public int getZ() {
        return coords[1];
    }

    public int[] getCoords() {
        return coords;
    }

    public Entity[] getEnts() {
        return ents;
    }

    public BlockState[] getTiles() {
        return tiles;
    }

    public TextComponent genMobCount(String s, String click) {
        Stream<Map.Entry<String, Integer>> sorted = amount.entrySet().stream()
                .sorted(Collections.reverseOrder(Map.Entry.comparingByValue()));

        Map<String, Integer> tops = sorted.limit(ChkAnalyse.ammoshow)
                .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (e1, e2) -> e1, LinkedHashMap::new));

        String regionfile = "r." + (coords[0] >> 5) + "." + (coords[1] >> 5) + ".mca";

        String empt = "\n§2✸ §fClick to teleport!\n\n§fChunk Information:\n  §2✸ §fWorld:§e "
                + Chat.capitalize(world.toLowerCase()) + "\n  §2✸ §fRegion File:§e " + regionfile
                + "\n\n§fMost often appearances:";
        for (String stg : tops.keySet()) {
            empt = empt + "\n" + "  §2✸ §f" + Chat.capitalize(stg.replace('_', ' ')) + ": §e" + tops.get(stg);
        }
        empt = empt + "\n";

        return Chat.genHoverAndRunCommandTextComponent(s, empt, click);
    }

    public TextComponent genText() {
        String name = "  §2✸ §fChunk §2(" + coords[0] + " " + coords[1] + ")§f Score: §e" + score;
        String cmd = "lagassist tpchunk " + world + " " + coords[0] + " " + coords[1];
        return genMobCount(name, cmd);
    }

    @Override
    public int compareTo(ChkStats from) {
        return from.getScore() - score;
    }
}
package org.alvindimas05.lagassist.chunks;

import java.util.ArrayList;
import java.util.List;

import org.alvindimas05.lagassist.Main;
import org.alvindimas05.lagassist.Reflection;
import org.alvindimas05.lagassist.utils.Chat;
import org.alvindimas05.lagassist.utils.MathUtils;
import org.bukkit.Bukkit;
import org.bukkit.Chunk;
import org.bukkit.Location;
import org.bukkit.World;
import org.bukkit.WorldBorder;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.scheduler.BukkitTask;

import org.alvindimas05.lagassist.utils.VersionMgr;

public class ChunkGenerator {

    private static Object chunkProvider;
    private static World world;
    private static BukkitTask gentask;

    // WORLDBORDER VALUES
    private static int maxx;
    private static int maxz;

    private static int minx;
    private static int minz;

    // WORLDBORDER VALUES END

    private static int currenti;

    public static void pregenWorld(CommandSender s, String[] args) {
        if (!(s instanceof Player p)) {
            s.sendMessage(Main.PREFIX + "You need to execute this command as a player");
            return;
        }

        if (args.length != 2) {
            s.sendMessage(Main.PREFIX + "Correct usage: §2/lagassist pregench [Max-Millis-Per-Tick]");
            return;
        }

        if (!MathUtils.isInt(args[1])) {
            s.sendMessage(Main.PREFIX + "Please input a correct ammount of milliseconds.");
            return;
        }

        if (gentask != null) {
            s.sendMessage(
                    Main.PREFIX + "The world is already pregenerating. Please wait for it to finish or cancel it.");
            return;
        }

        int millis = Integer.parseInt(args[1]);

        World w = p.getWorld();

        if (w.getWorldBorder().getSize() > 50000) {
            s.sendMessage(Main.PREFIX + "The max worldborder size is 50k.");
            return;
        }

        pregenWorld(w, millis);
    }

    public static void stopGen(CommandSender s) {
        if (gentask == null) {
            s.sendMessage(Main.PREFIX + "There is no active world pregeneration.");
            return;
        }
        gentask.cancel();
        gentask = null;
        s.sendMessage(Main.PREFIX + "Pregeneration task cancelled.");

    }

    private static void pregenWorld(World w, int millis) {

        // PREPARING ENVIRONMENT
        if (!VersionMgr.isNewMaterials()) {
            chunkProvider = Reflection.getChunkProvider(Reflection.getWorldServer(Reflection.getCraftWorld(w)));
        }
        world = w;

        // PREPARING WORLDBORDER CHECK
        WorldBorder wb = w.getWorldBorder();
        Location center = wb.getCenter();
        double radius = wb.getSize() / 2;

        maxx = (int) ((center.getX() + radius) / 16);
        maxz = (int) ((center.getZ() + radius) / 16);

        minx = (int) ((center.getX() - radius) / 16);
        minz = (int) ((center.getZ() - radius) / 16);

        Chunk spawn = world.getSpawnLocation().getChunk();
        int xfin = spawn.getX();
        int zfin = spawn.getZ();

        // Prepare list of chunks to pregenerate. It will further be used to pregenerate
        // the world.

        Bukkit.getScheduler().runTaskAsynchronously(Main.p, new Runnable() {
            @Override
            public void run() {
                List<int[]> chunks = new ArrayList<int[]>();

                int x = xfin;
                int z = zfin;
                int i = 1;

                while (isInside(x, z)) {
                    for (int temp = x + 1; temp <= x + i; temp++) {
                        chunks.add(new int[]{x, z});
                    }
                    x += i;
                    for (int temp = z - 1; temp >= z - i; temp--) {
                        chunks.add(new int[]{x, temp});
                    }
                    z -= i;
                    i++;
                    for (int temp = x - 1; temp >= x - i; temp--) {
                        chunks.add(new int[]{temp, z});
                    }
                    x -= i;
                    for (int temp = z + 1; temp <= z + i; temp++) {
                        chunks.add(new int[]{x, temp});
                    }
                    z += i;
                    i++;
                }
                startGen(chunks, millis);
            }
        });
    }

    private static void startGen(List<int[]> chunks, int millis) {
        currenti = 0;
        gentask = Bukkit.getScheduler().runTaskTimer(Main.p, new Runnable() {
            @Override
            public void run() {
                long time = System.currentTimeMillis();
                for (int i = currenti; i < chunks.size(); i++) {
                    pregenChunk(chunks.get(i));
                    if (i % 300 == 0 && i != 0) {
                        int percent = (int) ((double) i / chunks.size() * 100);
                        Bukkit.getLogger()
                                .info("§e[§a✪§e] §fThe pregeneration of the §2"
                                        + Chat.capitalize(world.getName()) + " §fworld is at §a" + percent
                                        + "% completion.");
                    }
                    if (i % 20 == 0 && i != 0) {
                        long curr = System.currentTimeMillis();
                        if (time + millis < curr) {
                            currenti = i;
                            return;
                        }
                    }
                }
                gentask.cancel();
                gentask = null;
                Bukkit.getLogger()
                        .info("§e[§a✪§e] §fThe pregeneration of the §2" + Chat.capitalize(world.getName())
                                + " §fworld is finished. Thank you for your patience.");

            }
        }, 1L, 1L);
    }

    private static void pregenChunk(int[] cords) {

        pregenChunk(cords[0], cords[1]);

    }

    private static void pregenChunk(int x, int z) {
        if (VersionMgr.isChunkGenerated(world, chunkProvider, x, z)) {
            return;
        }

        VersionMgr.loadChunk(world, x, z);
    }

    private static boolean isInside(int x, int z) {

        if (x < minx || x > maxx) {
            return false;
        }
        return z >= minz && z <= maxz;
    }

}
package org.alvindimas05.lagassist.chunks;

import org.alvindimas05.lagassist.Main;
import org.alvindimas05.lagassist.utils.PaperOnly;
import org.alvindimas05.lagassist.utils.WorldMgr;
import org.bukkit.Bukkit;
import org.bukkit.World;
import org.bukkit.entity.Player;
import org.bukkit.event.EventHandler;
import org.bukkit.event.EventPriority;
import org.bukkit.event.Listener;
import org.bukkit.event.player.PlayerJoinEvent;

import org.alvindimas05.lagassist.utils.VersionMgr;

public class DynViewer implements Listener {

    private static int maxChunks;
    private static int maxView;

    private static int currChunks = 0;

    public static void Enabler(boolean reload) {

        boolean enabled = Main.config.getBoolean("chunk-manager.enabled");

        if (!enabled) {
            return;
        }

        if (!Main.paper) {
            Bukkit.getLogger().info("    §e[§a✖§e] §fChunkManager - No PaperSpigot found");
            return;
        }

        maxChunks = Main.config.getInt("chunk-manager.max-chunks");
        maxView = Main.config.getInt("chunk-manager.max-view");

        if (!reload) {
            Main.p.getServer().getPluginManager().registerEvents(new DynViewer(), Main.p);

            runTask();
        }

        Bukkit.getLogger().info("    §e[§a✔§e] §fChunkManager.");

    }

    private static void runTask() {
        Bukkit.getScheduler().runTaskTimer(Main.p, DynViewer::setViews, 0, 600);
    }

    public static void setViews() {

        Main.sendDebug("Attempting to set dynamic view distance...", 1);

        // Get a value that is at least the minimum view distance and at max the spigot
        // view distance.

        int pl = Bukkit.getOnlinePlayers().size();

        if (pl == 0) {
            return;
        }

        int vd = (int) Math.sqrt((double) maxChunks / pl / 4);

        int newchunks = Math.max(Math.min(maxView, vd), Bukkit.getViewDistance());

        if (currChunks == newchunks) {
            return;
        }

        currChunks = newchunks;

        for (World w : Bukkit.getWorlds()) {
            if (WorldMgr.blacklist.contains(w.getName())) {
                continue;
            }

            PaperOnly.setViewDistance(w, currChunks);
        }
    }

    @EventHandler(priority = EventPriority.LOWEST)
    private void onJoin(PlayerJoinEvent e) {
        Player p = e.getPlayer();

        Main.sendDebug("Join detected for " + p.getName(), 1);

        if (VersionMgr.isNewMaterials()) {
            Main.sendDebug("Is new materials in dynviewer for " + p.getName() + ". Returning... ", 1);
            return;
        }

        // TODO: FIX Dynamic view
        Bukkit.getScheduler().runTaskLater(Main.p, () -> PaperOnly.setViewDistance(p, currChunks), 25);

    }

}