BENTOBOX PVP ENABLED

[sumbuild]

Some people might notice bentobox natively disabled pvp and there isnt a way to change it for sky grid.
Skygrid does not hold any pvp settings and neither did the jar file when I checked the source.

Bentobox was doing this inside the compiled jar. Written below is the PVPListener inside src > main > java > world > bentobox > bentobox > listeners > flags > settings > PVPListener.java

After doing this you will need grief prevention with claims denying pvp.

package net.root.frozen;

import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.configuration.file.FileConfiguration;
import org.bukkit.configuration.file.YamlConfiguration;
import org.bukkit.event.EventHandler;
import org.bukkit.event.Listener;
import org.bukkit.event.block.BlockBreakEvent;
import org.bukkit.event.block.BlockFromToEvent;
import org.bukkit.event.block.BlockPlaceEvent;
import org.bukkit.plugin.java.JavaPlugin;

import java.util.ArrayList;
import java.io.File;
import java.io.IOException;
import java.util.HashSet;
import java.util.Set;
import java.util.logging.Level;

public class FrozenLiquids extends JavaPlugin implements Listener {

    private final Set<String> allowedToFlow = new HashSet<>();
    private File dataFile;
    private FileConfiguration dataConfig;
    private boolean freezeWater;
    private boolean freezeLava;
    private boolean debug;

    @Override
    public void onEnable() {
        // Save default config
        saveDefaultConfig();
        loadConfig();

        // Initialize data file
        dataFile = new File(getDataFolder(), "allowed_flow.yml");
        dataConfig = YamlConfiguration.loadConfiguration(dataFile);
        loadAllowedFlow();

        // Register events
        getServer().getPluginManager().registerEvents(this, this);
        getLogger().info("[FrozenLiquids] Plugin enabled. Water freezing: " + freezeWater + ", Lava freezing: " + freezeLava);
    }

    @Override
    public void onDisable() {
        saveAllowedFlow();
        getLogger().info("[FrozenLiquids] Plugin disabled. Saved allowed flow data.");
    }

    private void loadConfig() {
        FileConfiguration config = getConfig();
        freezeWater = config.getBoolean("freeze-water", true);
        freezeLava = config.getBoolean("freeze-lava", true);
        debug = config.getBoolean("debug", false);
    }

    private void loadAllowedFlow() {
        if (dataFile.exists()) {
            allowedToFlow.addAll(dataConfig.getStringList("allowed-flow"));
        }
    }

    private void saveAllowedFlow() {
        dataConfig.set("allowed-flow", new ArrayList<>(allowedToFlow));
        try {
            dataConfig.save(dataFile);
        } catch (IOException e) {
            getLogger().log(Level.SEVERE, "Failed to save allowed flow data", e);
        }
    }

    private String getBlockKey(Block block) {
        return block.getWorld().getName() + "," + block.getX() + "," + block.getY() + "," + block.getZ();
    }

    @EventHandler
    public void onLiquidFlow(BlockFromToEvent event) {
        Block source = event.getBlock();
        if (!isLiquid(source)) return;

        String sourceKey = getBlockKey(source);
        if (allowedToFlow.contains(sourceKey)) {
            String destKey = getBlockKey(event.getToBlock());
            if (!allowedToFlow.contains(destKey)) {
                allowedToFlow.add(destKey);
                if (debug) {
                    getLogger().info("Propagated to: " + destKey);
                }
            }
        } else {
            event.setCancelled(true);
            if (debug) {
                getLogger().info("Cancelled liquid flow at " + source.getLocation());
            }
        }
    }

    @EventHandler
    public void onBlockPlace(BlockPlaceEvent event) {
        Block placed = event.getBlock();
        if (!placed.getChunk().isLoaded()) return;

        // Allow placed liquid to flow
        if (isLiquid(placed)) {
            allowedToFlow.add(getBlockKey(placed));
            if (debug) {
                getLogger().info("Allowed player-placed liquid at " + placed.getLocation());
            }
        }

        // Unfreeze adjacent liquids
        for (Block neighbor : getAdjacent(placed)) {
            if (isLiquid(neighbor) && neighbor.getChunk().isLoaded()) {
                allowedToFlow.add(getBlockKey(neighbor));
                if (debug) {
                    getLogger().info("Unfroze adjacent liquid at " + neighbor.getLocation());
                }
            }
        }
        saveAllowedFlow();
    }

    @EventHandler
    public void onBlockBreak(BlockBreakEvent event) {
        Block broken = event.getBlock();
        if (!broken.getChunk().isLoaded()) return;

        // Unfreeze adjacent liquids
        for (Block neighbor : getAdjacent(broken)) {
            if (isLiquid(neighbor) && neighbor.getChunk().isLoaded()) {
                allowedToFlow.add(getBlockKey(neighbor));
                if (debug) {
                    getLogger().info("Unfroze adjacent liquid at " + neighbor.getLocation());
                }
            }
        }
        saveAllowedFlow();
    }

    private boolean isLiquid(Block block) {
        if (block == null || !block.getChunk().isLoaded()) return false;
        Material type = block.getType();
        if (freezeWater && type == Material.WATER) return true;
        if (freezeLava && type == Material.LAVA) return true;
        return false;
    }

    private Set<Block> getAdjacent(Block block) {
        Set<Block> nearby = new HashSet<>();
        if (block == null || !block.getChunk().isLoaded()) return nearby;
        int[][] dirs = {
            {1, 0, 0}, {-1, 0, 0},
            {0, 1, 0}, {0, -1, 0},
            {0, 0, 1}, {0, 0, -1}
        };
        for (int[] d : dirs) {
            Block relative = block.getRelative(d[0], d[1], d[2]);
            if (relative != null && relative.getChunk().isLoaded()) {
                nearby.add(relative);
            }
        }
        return nearby;
    }
}