diff --git a/MAIN/src/main/java/com/trafalcraft/anti_redstone_clock/Main.java b/MAIN/src/main/java/com/trafalcraft/anti_redstone_clock/Main.java new file mode 100644 index 0000000..b7cd789 --- /dev/null +++ b/MAIN/src/main/java/com/trafalcraft/anti_redstone_clock/Main.java @@ -0,0 +1,260 @@ +package com.trafalcraft.anti_redstone_clock; + +import java.util.ArrayList; +import java.util.Collection; +import java.util.HashMap; +import java.util.Map; +import java.util.concurrent.Callable; + +import org.bstats.bukkit.Metrics; +import org.bstats.charts.DrilldownPie; +import org.bstats.charts.SimplePie; +import org.bukkit.Bukkit; +import org.bukkit.Material; +import org.bukkit.command.Command; +import org.bukkit.command.CommandSender; +import org.bukkit.plugin.java.JavaPlugin; +import org.yaml.snakeyaml.error.YAMLException; + +import com.trafalcraft.anti_redstone_clock.commands.AutoRemoveDetectedClock; +import com.trafalcraft.anti_redstone_clock.commands.CheckList; +import com.trafalcraft.anti_redstone_clock.commands.CreateSignWhenClockIsBreak; +import com.trafalcraft.anti_redstone_clock.commands.DisableRedstoneClockCheckAbove; +import com.trafalcraft.anti_redstone_clock.commands.NotifyAdmin; +import com.trafalcraft.anti_redstone_clock.commands.Reload; +import com.trafalcraft.anti_redstone_clock.commands.SetDelay; +import com.trafalcraft.anti_redstone_clock.commands.SetMaxPulses; +import com.trafalcraft.anti_redstone_clock.listener.ComparatorListener; +import com.trafalcraft.anti_redstone_clock.listener.ObserverListener; +import com.trafalcraft.anti_redstone_clock.listener.PistonListener; +import com.trafalcraft.anti_redstone_clock.listener.RedstoneListener; +import com.trafalcraft.anti_redstone_clock.util.CheckTPS; +import com.trafalcraft.anti_redstone_clock.util.Msg; +import com.trafalcraft.anti_redstone_clock.util.plotSquared.VersionPlotSquared; +import com.trafalcraft.anti_redstone_clock.util.worldGuard.VersionWG; + +public class Main extends JavaPlugin { + + private static Main instance; + //Store region and world ignored by the plugin + private static final ArrayList ignoredWorlds = new ArrayList<>(); + private static final ArrayList ignoredRegions = new ArrayList<>(); + + @Override + public void onLoad() { + super.onLoad(); + + instance = this; + + instance.saveDefaultConfig(); + instance.getConfig().options().copyDefaults(true); + instance.saveConfig(); + instance.reloadConfig(); + + if (VersionWG.getInstance().getWG() != null) { + this.getLogger().info(String.format("WorldGuard %s found", VersionWG.getInstance().getWG().getVersion())); + if (VersionWG.getInstance().getWG().registerFlag()) { + this.getLogger().info("Flag antiredstoneclock registered"); + } else { + this.getLogger().severe("An error occurred while registering antiredstoneclock flag"); + } + } + } + + @Override + public void onEnable() { + long startTime = System.currentTimeMillis(); + + if (instance.getConfig().getBoolean("metrics")) { + this.getLogger().info("Enabling Metrics"); + try { + Class.forName("org.bstats.bukkit.Metrics"); + Metrics metrics = new Metrics(this, 26927); + initMetricsChart(metrics); + this.getLogger().info("Metrics loaded"); + } catch (Exception e) { + this.getLogger().info("An error occured while trying to enable metrics. Skipping..."); + } + } + + try { + Msg.load(); + } catch (YAMLException e) { + e.printStackTrace(); + } + + registerPluginEvents(); + + CheckTPS.initCheckTPS(instance.getConfig().getInt("checkTPS.minimumTPS"), instance.getConfig().getInt("checkTPS.maximumTPS"), instance.getConfig().getInt("checkTPS.intervalInSecond")); + + if (VersionPlotSquared.getInstance().getPlotSquared() != null) { + VersionPlotSquared.getInstance().getPlotSquared().init(); + this.getLogger().info(String.format("PlotSquared %s found and flag loaded", VersionPlotSquared.getInstance().getPlotSquared().getVersion())); + } + + long endTime = System.currentTimeMillis(); + + long duration = (endTime - startTime); + this.getLogger().info(String.format("Plugin loaded in %d ms", duration)); //2ms + } + + //Register events depend on user preferences in config.yml file + private void registerPluginEvents() { + Bukkit.getServer().getPluginManager().registerEvents(new PlayerListener(), this); + if (instance.getConfig().getBoolean("checkedClock.comparator")) { + Material comparator = Material.getMaterial("COMPARATOR"); + if (comparator != null) { + Bukkit.getServer().getPluginManager().registerEvents(new ComparatorListener(comparator), this); + } else { + comparator = Material.getMaterial("REDSTONE_COMPARATOR_OFF"); + Bukkit.getServer().getPluginManager().registerEvents(new ComparatorListener(comparator), this); + Material comparator2 = Material.getMaterial("REDSTONE_COMPARATOR_ON"); + Bukkit.getServer().getPluginManager().registerEvents(new ComparatorListener(comparator2), this); + } + } + if (Material.getMaterial("OBSERVER") != null && instance.getConfig().getBoolean("checkedClock.observer")) { + Bukkit.getServer().getPluginManager().registerEvents(new ObserverListener(), this); + } + if (instance.getConfig().getBoolean("checkedClock.piston")) { + Bukkit.getServer().getPluginManager().registerEvents(new PistonListener(), this); + } + if (instance.getConfig().getBoolean("checkedClock.redstoneAndRepeater")) { + Material repeater = Material.getMaterial("REPEATER"); + if (repeater != null) { + Bukkit.getServer().getPluginManager().registerEvents(new RedstoneListener(repeater), this); + } else { + repeater = Material.getMaterial("DIODE_BLOCK_ON"); + Bukkit.getServer().getPluginManager().registerEvents(new RedstoneListener(repeater), this); + Material repeater2 = Material.getMaterial("DIODE_BLOCK_OFF"); + Bukkit.getServer().getPluginManager().registerEvents(new RedstoneListener(repeater2), this); + + } + } + } + + @Override + public void onDisable() { + //Nothing to do + } + + @Override + public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) { + boolean validCMD = true; + if (cmd.getName().equalsIgnoreCase("antiredstoneclock")) { + if (sender.isOp() || sender.hasPermission("antiRedstoneClock.Admin")) { + if (args.length == 0) { + Msg.getHelp(sender); + validCMD = false; + } else { + switch (args[0].toUpperCase()) { + case "RELOAD": + Reload.getInstance().performCMD(sender); + break; + case "CHECKLIST": + CheckList.getInstance().performCMD(sender, args); + break; + case "SETMAXPULSES": + SetMaxPulses.getInstance().performCMD(sender, args); + break; + case "SETDELAY": + SetDelay.getInstance().performCMD(sender, args); + break; + case "DISABLEREDSTONECLOCKCHECKABOVE": + DisableRedstoneClockCheckAbove.getInstance().performCMD(sender, args); + break; + case "NOTIFYADMIN": + NotifyAdmin.getInstance().performCMD(sender, args); + break; + case "AUTOREMOVEDETECTEDCLOCK": + AutoRemoveDetectedClock.getInstance().performCMD(sender, args); + break; + case "CREATESIGNWHENCLOCKISBREAK": + CreateSignWhenClockIsBreak.getInstance().performCMD(sender, args); + break; + default: + Msg.getHelp(sender); + validCMD = false; + } + } + } else { + sender.sendMessage(Msg.UNKNOWN_CMD.toString()); + validCMD = false; + } + } else { + sender.sendMessage(Msg.UNKNOWN_CMD.toString()); + validCMD = false; + } + return validCMD; + } + + + public static Main getInstance() { + return instance; + } + + public static Collection getIgnoredWorlds() { + return ignoredWorlds; + } + + public static Collection getIgnoredRegions() { + return ignoredRegions; + } + + public void initMetricsChart(Metrics metrics) { + metrics.addCustomChart(new SimplePie("worldguard_version", new Callable(){ + + @Override + public String call() throws Exception { + return VersionWG.getInstance().getWG().getVersion(); + } + })); + + metrics.addCustomChart(new SimplePie("plotsquared_version", new Callable(){ + + @Override + public String call() throws Exception { + return VersionPlotSquared.getInstance().getPlotSquared().getVersion(); + } + })); + + metrics.addCustomChart(new DrilldownPie("config_maxpulses", () -> { + Map> map = new HashMap<>(); + Map entry = new HashMap<>(); + int maxPulses = Main.getInstance().getConfig().getInt("MaxPulses"); + if (maxPulses < 100) { + entry.put(Integer.toString(maxPulses), 1); + map.put("<100", entry); + } else if (maxPulses < 500) { + entry.put(Integer.toString(maxPulses), 1); + map.put("<500", entry); + } else if (maxPulses < 1000) { + entry.put(Integer.toString(maxPulses), 1); + map.put("<1000", entry); + } else if (maxPulses < 10000) { + entry.put(Integer.toString(maxPulses), 1); + map.put("<10000", entry); + } + return map; + })); + + metrics.addCustomChart(new DrilldownPie("config_delay", () -> { + Map> map = new HashMap<>(); + Map entry = new HashMap<>(); + int delay = Main.getInstance().getConfig().getInt("Delay"); + if (delay < 100) { + entry.put(Integer.toString(delay), 1); + map.put("<100", entry); + } else if (delay < 500) { + entry.put(Integer.toString(delay), 1); + map.put("<500", entry); + } else if (delay < 1000) { + entry.put(Integer.toString(delay), 1); + map.put("<1000", entry); + } else if (delay < 10000) { + entry.put(Integer.toString(delay), 1); + map.put("<10000", entry); + } + return map; + })); + } +} diff --git a/MAIN/src/main/java/com/trafalcraft/anti_redstone_clock/PlayerListener.java b/MAIN/src/main/java/com/trafalcraft/anti_redstone_clock/PlayerListener.java new file mode 100644 index 0000000..3eb47a6 --- /dev/null +++ b/MAIN/src/main/java/com/trafalcraft/anti_redstone_clock/PlayerListener.java @@ -0,0 +1,104 @@ +package com.trafalcraft.anti_redstone_clock; + +import org.bukkit.Material; +import org.bukkit.block.Block; +import org.bukkit.block.BlockFace; +import org.bukkit.block.BlockState; +import org.bukkit.block.Sign; +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.block.BlockExplodeEvent; +import org.bukkit.event.entity.EntityExplodeEvent; + +import com.trafalcraft.anti_redstone_clock.object.RedstoneClockController; + +public class PlayerListener implements Listener { + + @EventHandler(priority = EventPriority.HIGHEST) + public void onBlockBreak(BlockBreakEvent e) { + Block block = e.getBlock(); + if (checkRedStoneItems_1_13(block.getType()) + || checkRedStoneItemsOlderThan_1_13(block.getType())) { + cleanRedstone(block); + } else if (checkSign(block)) { + block.setType(Material.AIR); + } else { + block = block.getRelative(BlockFace.UP); + if (checkRedStoneItems_1_13(block.getType()) + || checkRedStoneItemsOlderThan_1_13(block.getType())) { + cleanRedstone(block); + } else if (checkSign(block)) { + block.setType(Material.AIR); + } + } + } + + @EventHandler(priority = EventPriority.HIGHEST) + public void onExplosion(BlockExplodeEvent e) { + for(Block block : e.blockList()) { + if (checkSign(block)) { + block.setType(Material.AIR); + } + } + } + + @EventHandler(priority = EventPriority.HIGHEST) + public void onExplosion(EntityExplodeEvent e) { + for(Block block : e.blockList()) { + if (checkSign(block)) { + block.setType(Material.AIR); + } + } + } + + private boolean checkRedStoneItems_1_13(Material type) { + return type == Material.getMaterial("REDSTONE_WIRE") + || type == Material.getMaterial("REPEATER") + || type == Material.getMaterial("PISTON") + || type == Material.getMaterial("STICKY_PISTON") + || type == Material.getMaterial("COMPARATOR") + || type == Material.getMaterial("OBSERVER"); + } + + private boolean checkRedStoneItemsOlderThan_1_13(Material type) { + return type == Material.getMaterial("DIODE_BLOCK_OFF") + || type == Material.getMaterial("DIODE_BLOCK_ON") + || type == Material.getMaterial("PISTON_BASE") + || type == Material.getMaterial("PISTON_EXTENSION") + || type == Material.getMaterial("PISTON_STICKY_BASE") + || type == Material.getMaterial("REDSTONE_COMPARATOR_OFF") + || type == Material.getMaterial("REDSTONE_COMPARATOR_ON"); + } + + private void cleanRedstone(Block block) { + if (RedstoneClockController.contains(block.getLocation())) { + RedstoneClockController.removeRedstoneByLocation(block.getLocation()); + } + } + + private boolean checkSign(Block block) { + if(block.getType() == Material.getMaterial("OAK_SIGN") + || block.getType() == Material.getMaterial("SIGN_POST") + || block.getType() == Material.getMaterial("SIGN")) { + BlockState blockState = block.getState(); + Sign sign = (Sign) blockState; + if (checkSignLines(sign)) { + return true; + } + } + return false; + } + + private boolean checkSignLines(Sign sign) { + return (sign.getLine(0).equalsIgnoreCase(Main.getInstance().getConfig().getString("Sign.Line1") + .replace("&", "§")) + && sign.getLine(1).equalsIgnoreCase(Main.getInstance().getConfig().getString("Sign.Line2") + .replace("&", "§")) + && sign.getLine(2).equalsIgnoreCase(Main.getInstance().getConfig().getString("Sign.Line3") + .replace("&", "§")) + && sign.getLine(3).equalsIgnoreCase(Main.getInstance().getConfig().getString("Sign.Line4") + .replace("&", "§"))); + } +}