From 22bf4bc9bbce0307c93896ea233e292755c25c2b Mon Sep 17 00:00:00 2001 From: ulumulu1510 Date: Sat, 24 Jan 2015 04:43:28 +0100 Subject: [PATCH] Safer piston build protection --- .../factions/engine/EngineMain.java | 37 ++++++---- .../massivecraft/factions/entity/MConf.java | 4 + .../factions/spigot/EngineSpigot.java | 73 +++++++++++++++++++ 3 files changed, 100 insertions(+), 14 deletions(-) diff --git a/src/com/massivecraft/factions/engine/EngineMain.java b/src/com/massivecraft/factions/engine/EngineMain.java index 573520b3..bb37531e 100644 --- a/src/com/massivecraft/factions/engine/EngineMain.java +++ b/src/com/massivecraft/factions/engine/EngineMain.java @@ -84,6 +84,7 @@ import com.massivecraft.factions.event.EventFactionsPvpDisallowed; import com.massivecraft.factions.event.EventFactionsPowerChange; import com.massivecraft.factions.event.EventFactionsPowerChange.PowerChangeReason; import com.massivecraft.factions.integration.Econ; +import com.massivecraft.factions.spigot.SpigotFeatures; import com.massivecraft.factions.util.VisualizeUtil; import com.massivecraft.massivecore.EngineAbstract; import com.massivecraft.massivecore.PriorityLines; @@ -1383,15 +1384,19 @@ public class EngineMain extends EngineAbstract @EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true) public void blockBuild(BlockPistonExtendEvent event) { + // Is using Spigot or is checking deactivated by MConf? + if (SpigotFeatures.isActive() || ! MConf.get().handlePistonProtectionThroughDenyBuild) return; + Block block = event.getBlock(); - - Faction pistonFaction = BoardColl.get().getFactionAt(PS.valueOf(block)); - - // target end-of-the-line empty (air) block which is being pushed into, including if piston itself would extend into air + + // Targets end-of-the-line empty (air) block which is being pushed into, including if piston itself would extend into air Block targetBlock = block.getRelative(event.getDirection(), event.getLength() + 1); - // members of faction might not have build rights in their own territory, but pistons should still work regardless; so, address that corner case + // Factions involved + Faction pistonFaction = BoardColl.get().getFactionAt(PS.valueOf(block)); Faction targetFaction = BoardColl.get().getFactionAt(PS.valueOf(targetBlock)); + + // Members of a faction might not have build rights in their own territory, but pistons should still work regardless if (targetFaction == pistonFaction) return; // if potentially pushing into air/water/lava in another territory, we need to check it out @@ -1405,30 +1410,34 @@ public class EngineMain extends EngineAbstract * up to 12 blocks and the width of any territory is 16 blocks, it should be safe (and much more lightweight) to test * only the final target block as done above */ + } @EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true) public void blockBuild(BlockPistonRetractEvent event) { - // if not a sticky piston, retraction should be fine - if (!event.isSticky()) return; - + // Is using Spigot or is checking deactivated by MConf? + if (SpigotFeatures.isActive() || ! MConf.get().handlePistonProtectionThroughDenyBuild) return; + + // If not a sticky piston, retraction should be fine + if ( ! event.isSticky()) return; + Block retractBlock = event.getRetractLocation().getBlock(); PS retractPs = PS.valueOf(retractBlock); // if potentially retracted block is just air/water/lava, no worries if (retractBlock.isEmpty() || retractBlock.isLiquid()) return; + // Factions involved Faction pistonFaction = BoardColl.get().getFactionAt(PS.valueOf(event.getBlock())); - - // members of faction might not have build rights in their own territory, but pistons should still work regardless; so, address that corner case Faction targetFaction = BoardColl.get().getFactionAt(retractPs); + + // Members of a faction might not have build rights in their own territory, but pistons should still work regardless if (targetFaction == pistonFaction) return; - if (!MPerm.getPermBuild().has(pistonFaction, targetFaction)) - { - event.setCancelled(true); - } + if (MPerm.getPermBuild().has(pistonFaction, targetFaction)) return; + + event.setCancelled(true); } @EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true) diff --git a/src/com/massivecraft/factions/entity/MConf.java b/src/com/massivecraft/factions/entity/MConf.java index 472ac0a7..d1b971d6 100644 --- a/src/com/massivecraft/factions/entity/MConf.java +++ b/src/com/massivecraft/factions/entity/MConf.java @@ -305,6 +305,10 @@ public class MConf extends Entity // 0.1 means that you take 10% less damage at home. public double territoryShieldFactor = 0.1D; + // Protects the faction land from piston extending/retracting + // through the denying of MPerm build + public boolean handlePistonProtectionThroughDenyBuild = true; + // -------------------------------------------- // // DENY COMMANDS // -------------------------------------------- // diff --git a/src/com/massivecraft/factions/spigot/EngineSpigot.java b/src/com/massivecraft/factions/spigot/EngineSpigot.java index 2529df23..0439c31d 100644 --- a/src/com/massivecraft/factions/spigot/EngineSpigot.java +++ b/src/com/massivecraft/factions/spigot/EngineSpigot.java @@ -1,16 +1,26 @@ package com.massivecraft.factions.spigot; +import java.util.List; + +import org.bukkit.block.Block; import org.bukkit.entity.Entity; import org.bukkit.entity.EntityType; import org.bukkit.entity.Player; import org.bukkit.event.EventHandler; import org.bukkit.event.EventPriority; +import org.bukkit.event.block.BlockPistonExtendEvent; +import org.bukkit.event.block.BlockPistonRetractEvent; import org.bukkit.event.player.PlayerInteractAtEntityEvent; import org.bukkit.plugin.Plugin; import com.massivecraft.factions.Factions; import com.massivecraft.factions.engine.EngineMain; +import com.massivecraft.factions.entity.BoardColl; +import com.massivecraft.factions.entity.Faction; +import com.massivecraft.factions.entity.MConf; +import com.massivecraft.factions.entity.MPerm; import com.massivecraft.massivecore.EngineAbstract; +import com.massivecraft.massivecore.ps.PS; public class EngineSpigot extends EngineAbstract @@ -73,4 +83,67 @@ public class EngineSpigot extends EngineAbstract event.setCancelled(true); } + /* + * Note: With 1.8 and the slime blocks, retracting and extending pistons + * became more of a problem. Blocks located on the border of a chunk + * could have easily been stolen. That is the reason why every block + * needs to be checked now, whether he moved into a territory which + * he actually may not move into. + */ + @EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true) + public void blockBuild(BlockPistonExtendEvent event) + { + // Is checking deactivated by MConf? + if ( ! MConf.get().handlePistonProtectionThroughDenyBuild) return; + + Faction pistonFaction = BoardColl.get().getFactionAt(PS.valueOf(event.getBlock())); + + List blocks = event.getBlocks(); + + // Check for all extended blocks + for (Block block : blocks) + { + // Block which is being pushed into + Block targetBlock = block.getRelative(event.getDirection()); + + // Members of a faction might not have build rights in their own territory, but pistons should still work regardless + Faction targetFaction = BoardColl.get().getFactionAt(PS.valueOf(targetBlock)); + if (targetFaction == pistonFaction) continue; + + // Perm check + if (MPerm.getPermBuild().has(pistonFaction, targetFaction)) continue; + + event.setCancelled(true); + return; + } + } + + @EventHandler(priority = EventPriority.NORMAL, ignoreCancelled = true) + public void blockBuild(BlockPistonRetractEvent event) + { + // Is checking deactivated by MConf? + if ( ! MConf.get().handlePistonProtectionThroughDenyBuild) return; + + Faction pistonFaction = BoardColl.get().getFactionAt(PS.valueOf(event.getBlock())); + + List blocks = event.getBlocks(); + + // Check for all retracted blocks + for (Block block : blocks) + { + // Is the retracted block air/water/lava? Don't worry about it + if (block.isEmpty() || block.isLiquid()) return; + + // Members of a faction might not have build rights in their own territory, but pistons should still work regardless + Faction targetFaction = BoardColl.get().getFactionAt(PS.valueOf(block)); + if (targetFaction == pistonFaction) continue; + + // Perm check + if (MPerm.getPermBuild().has(pistonFaction, targetFaction)) continue; + + event.setCancelled(true); + return; + } + } + }